@ainyc/canonry 1.28.2 → 1.30.0

package/dist/{chunk-GF5TI2U2.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(),
@@ -783,27 +827,112 @@ var auditLogEntrySchema = z8.object({
   createdAt: z8.string()
 });
 
-// ../contracts/src/schedule.ts
+// ../contracts/src/snapshot.ts
 import { z as z9 } from "zod";
-var scheduleDtoSchema = z9.object({
+var snapshotAccuracySchema = z9.enum(["yes", "no", "unknown", "not-mentioned"]);
+var snapshotRequestSchema = z9.object({
+  companyName: z9.string().min(1),
+  domain: z9.string().min(1),
+  phrases: z9.array(z9.string().min(1)).optional().default([]),
+  competitors: z9.array(z9.string().min(1)).optional().default([])
+});
+var snapshotCompetitorEntrySchema = z9.object({
+  name: z9.string(),
+  count: z9.number().int().nonnegative()
+});
+var snapshotAuditFactorSchema = 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()
+  name: z9.string(),
+  weight: z9.number(),
+  score: z9.number(),
+  grade: z9.string(),
+  status: z9.enum(["pass", "partial", "fail"]),
+  findings: z9.array(z9.object({
+    type: z9.string(),
+    message: z9.string()
+  })).default([]),
+  recommendations: z9.array(z9.string()).default([])
+});
+var snapshotAuditSchema = z9.object({
+  url: z9.string(),
+  finalUrl: z9.string(),
+  auditedAt: z9.string(),
+  overallScore: z9.number(),
+  overallGrade: z9.string(),
+  summary: z9.string(),
+  factors: z9.array(snapshotAuditFactorSchema).default([])
+});
+var snapshotProfileSchema = z9.object({
+  industry: z9.string(),
+  summary: z9.string(),
+  services: z9.array(z9.string()).default([]),
+  categoryTerms: z9.array(z9.string()).default([])
+});
+var snapshotProviderResultSchema = z9.object({
+  provider: z9.string(),
+  displayName: z9.string(),
+  model: z9.string().nullable().optional(),
+  mentioned: z9.boolean(),
+  cited: z9.boolean(),
+  describedAccurately: snapshotAccuracySchema,
+  accuracyNotes: z9.string().nullable().optional(),
+  incorrectClaims: z9.array(z9.string()).default([]),
+  recommendedCompetitors: z9.array(z9.string()).default([]),
+  citedDomains: z9.array(z9.string()).default([]),
+  groundingSources: z9.array(groundingSourceSchema).default([]),
+  searchQueries: z9.array(z9.string()).default([]),
+  answerText: z9.string(),
+  error: z9.string().nullable().optional()
+});
+var snapshotQueryResultSchema = z9.object({
+  phrase: z9.string(),
+  providerResults: z9.array(snapshotProviderResultSchema).default([])
+});
+var snapshotSummarySchema = z9.object({
+  totalQueries: z9.number().int().nonnegative(),
+  totalProviders: z9.number().int().nonnegative(),
+  totalComparisons: z9.number().int().nonnegative(),
+  mentionCount: z9.number().int().nonnegative(),
+  citationCount: z9.number().int().nonnegative(),
+  topCompetitors: z9.array(snapshotCompetitorEntrySchema).default([]),
+  visibilityGap: z9.string(),
+  whatThisMeans: z9.array(z9.string()).default([]),
+  recommendedActions: z9.array(z9.string()).default([])
+});
+var snapshotReportSchema = z9.object({
+  companyName: z9.string(),
+  domain: z9.string(),
+  homepageUrl: z9.string(),
+  generatedAt: z9.string(),
+  phrases: z9.array(z9.string()).default([]),
+  competitors: z9.array(z9.string()).default([]),
+  profile: snapshotProfileSchema,
+  audit: snapshotAuditSchema,
+  queryResults: z9.array(snapshotQueryResultSchema).default([]),
+  summary: snapshotSummarySchema
+});
+
+// ../contracts/src/schedule.ts
+import { z as z10 } from "zod";
+var scheduleDtoSchema = z10.object({
+  id: z10.string(),
+  projectId: z10.string(),
+  cronExpr: z10.string(),
+  preset: z10.string().nullable().optional(),
+  timezone: z10.string().default("UTC"),
+  enabled: z10.boolean().default(true),
+  providers: z10.array(providerNameSchema).default([]),
+  lastRunAt: z10.string().nullable().optional(),
+  nextRunAt: z10.string().nullable().optional(),
+  createdAt: z10.string(),
+  updatedAt: z10.string()
 });
-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([])
+var scheduleUpsertRequestSchema = z10.object({
+  preset: z10.string().optional(),
+  cron: z10.string().optional(),
+  timezone: z10.string().optional().default("UTC"),
+  enabled: z10.boolean().optional().default(true),
+  providers: z10.array(providerNameSchema).optional().default([])
 }).refine(
   (data) => data.preset && !data.cron || !data.preset && data.cron,
   { message: 'Exactly one of "preset" or "cron" must be provided' }
@@ -902,34 +1031,41 @@ function categoryLabel(category) {
 }
 
 // ../contracts/src/ga.ts
-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()
+import { z as z11 } from "zod";
+var ga4ConnectionDtoSchema = z11.object({
+  id: z11.string(),
+  projectId: z11.string(),
+  propertyId: z11.string(),
+  clientEmail: z11.string(),
+  connected: z11.boolean(),
+  createdAt: z11.string(),
+  updatedAt: z11.string()
 });
-var ga4TrafficSnapshotDtoSchema = z10.object({
-  date: z10.string(),
-  landingPage: z10.string(),
-  sessions: z10.number(),
-  organicSessions: z10.number(),
-  users: z10.number()
+var ga4TrafficSnapshotDtoSchema = z11.object({
+  date: z11.string(),
+  landingPage: z11.string(),
+  sessions: z11.number(),
+  organicSessions: z11.number(),
+  users: z11.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()
+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(),
+  totalUsers: z11.number(),
+  topPages: z11.array(z11.object({
+    landingPage: z11.string(),
+    sessions: z11.number(),
+    organicSessions: z11.number(),
+    users: z11.number()
   })),
-  lastSyncedAt: z10.string().nullable()
+  aiReferrals: z11.array(ga4AiReferralDtoSchema),
+  lastSyncedAt: z11.string().nullable()
 });
 
 // ../api-routes/src/auth.ts
@@ -951,6 +1087,7 @@ __export(schema_exports, {
   bingKeywordStats: () => bingKeywordStats,
   bingUrlInspections: () => bingUrlInspections,
   competitors: () => competitors,
+  gaAiReferrals: () => gaAiReferrals,
   gaConnections: () => gaConnections,
   gaTrafficSnapshots: () => gaTrafficSnapshots,
   gaTrafficSummaries: () => gaTrafficSummaries,
@@ -1028,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"),
@@ -1221,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" }),
@@ -1550,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);
@@ -2459,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
@@ -2477,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,
@@ -3089,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();
@@ -3108,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
       })),
@@ -4286,6 +4458,34 @@ var routeCatalog = [
       501: { description: "Google settings updates are not supported." }
     }
   },
+  {
+    method: "post",
+    path: "/api/v1/snapshot",
+    summary: "Generate a one-shot AI perception snapshot",
+    tags: ["snapshot"],
+    requestBody: {
+      required: true,
+      content: {
+        "application/json": {
+          schema: {
+            type: "object",
+            required: ["companyName", "domain"],
+            properties: {
+              companyName: stringSchema,
+              domain: stringSchema,
+              phrases: stringArraySchema,
+              competitors: stringArraySchema
+            }
+          }
+        }
+      }
+    },
+    responses: {
+      200: { description: "Snapshot report returned." },
+      400: { description: "Invalid snapshot input." },
+      501: { description: "Snapshot reporting is not supported." }
+    }
+  },
   {
     method: "put",
     path: "/api/v1/settings/bing",
@@ -5225,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",
@@ -5266,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",
@@ -5353,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",
@@ -5406,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: {
@@ -5431,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: {
@@ -5631,6 +5945,38 @@ async function settingsRoutes(app, opts) {
   });
 }
 
+// ../api-routes/src/snapshot.ts
+async function snapshotRoutes(app, opts) {
+  app.post("/snapshot", async (request, reply) => {
+    const parsed = snapshotRequestSchema.safeParse(request.body);
+    if (!parsed.success) {
+      const err = validationError("Invalid snapshot payload", {
+        issues: parsed.error.issues.map((issue) => ({
+          path: issue.path.join("."),
+          message: issue.message
+        }))
+      });
+      return reply.status(err.statusCode).send(err.toJSON());
+    }
+    if (!opts.onSnapshotRequested) {
+      const err = notImplemented("Snapshot reporting is not supported in this deployment");
+      return reply.status(err.statusCode).send(err.toJSON());
+    }
+    try {
+      const report = await opts.onSnapshotRequested(parsed.data);
+      return reply.send(report);
+    } catch (err) {
+      request.log.error({ err }, "Snapshot report generation failed");
+      return reply.status(500).send({
+        error: {
+          code: "INTERNAL_ERROR",
+          message: err instanceof Error ? err.message : "Failed to generate snapshot report"
+        }
+      });
+    }
+  });
+}
+
 // ../api-routes/src/telemetry.ts
 async function telemetryRoutes(app, opts) {
   app.get("/telemetry", async (_request, reply) => {
@@ -7664,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();
@@ -7790,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) {
@@ -7875,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,
@@ -7893,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,
@@ -7924,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);
@@ -7937,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(),
@@ -7961,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(),
@@ -7973,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
     };
@@ -8002,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,
@@ -8013,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
     };
   });
@@ -8054,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";
@@ -8490,22 +9049,287 @@ async function setSeoMeta(connection, slug, body, env) {
   );
   return getPageDetail(connection, slug, site.env, plugins);
 }
-async function getLlmsTxt(connection, env) {
+async function detectSeoWriteStrategy(connection, env) {
   const site = resolveEnvironment(connection, env);
-  const url = `${site.siteUrl}/llms.txt`;
+  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 {
-    env: site.env,
-    url,
-    content: await fetchText(url)
+    strategy: writeTargets.length > 0 ? "plugin" : "manual",
+    plugins
   };
 }
-async function buildManualLlmsTxtUpdate(connection, content, env) {
-  const site = resolveEnvironment(connection, env);
+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: `${site.siteUrl}/llms.txt`,
-    adminUrl: `${site.siteUrl}/wp-admin/`,
-    content,
+    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`;
+  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.",
@@ -8935,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);
@@ -8968,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);
@@ -9051,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
@@ -9119,6 +10198,9 @@ async function apiRoutes(app, opts) {
       bing: opts.bingSettingsSummary,
       onBingUpdate: opts.onBingSettingsUpdate
     });
+    await api.register(snapshotRoutes, {
+      onSnapshotRequested: opts.onSnapshotRequested
+    });
     await api.register(scheduleRoutes, {
       onScheduleUpdated: opts.onScheduleUpdated,
       validProviderNames: opts.providerAdapters?.map((a) => a.name)
@@ -9140,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,
@@ -11125,7 +12208,7 @@ function emit(entry) {
   }
 }
 function createLogger(module) {
-  function log7(level, action, ctx) {
+  function log8(level, action, ctx) {
     const entry = {
       ts: (/* @__PURE__ */ new Date()).toISOString(),
       level,
@@ -11136,9 +12219,9 @@ function createLogger(module) {
     emit(entry);
   }
   return {
-    info: (action, ctx) => log7("info", action, ctx),
-    warn: (action, ctx) => log7("warn", action, ctx),
-    error: (action, ctx) => log7("error", action, ctx)
+    info: (action, ctx) => log8("info", action, ctx),
+    warn: (action, ctx) => log8("warn", action, ctx),
+    error: (action, ctx) => log8("error", action, ctx)
   };
 }
 
@@ -11340,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();
@@ -11358,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({
@@ -11379,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,
@@ -11602,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";
@@ -12279,6 +13461,9 @@ var Notifier = class {
   }
 };
 
+// src/snapshot-service.ts
+import { runAeoAudit } from "@ainyc/aeo-audit";
+
 // src/site-fetch.ts
 import https2 from "https";
 var FETCH_TIMEOUT_MS = 1e4;
@@ -12390,10 +13575,641 @@ function stripHtml2(html) {
   return text2;
 }
 
+// src/snapshot-format.ts
+function formatAuditFactorScore(factor) {
+  return `${factor.score}/100 (${factor.weight}% weight)`;
+}
+
+// src/snapshot-service.ts
+var log6 = createLogger("Snapshot");
+var ANALYSIS_PROVIDER_PRIORITY = ["openai", "claude", "gemini", "perplexity", "local"];
+var SNAPSHOT_QUERY_COUNT = 6;
+var ProviderExecutionGate2 = class {
+  constructor(maxConcurrency, maxPerMinute) {
+    this.maxConcurrency = maxConcurrency;
+    this.maxPerMinute = maxPerMinute;
+  }
+  window = [];
+  waiters = [];
+  rateLimitChain = Promise.resolve();
+  inFlight = 0;
+  async run(task) {
+    await this.acquire();
+    try {
+      await this.waitForRateLimit();
+      return await task();
+    } finally {
+      this.release();
+    }
+  }
+  async acquire() {
+    if (this.inFlight < Math.max(1, this.maxConcurrency)) {
+      this.inFlight++;
+      return;
+    }
+    await new Promise((resolve) => {
+      this.waiters.push(resolve);
+    });
+    this.inFlight++;
+  }
+  release() {
+    this.inFlight = Math.max(0, this.inFlight - 1);
+    const next = this.waiters.shift();
+    next?.();
+  }
+  async waitForRateLimit() {
+    let releaseChain;
+    const previousChain = this.rateLimitChain;
+    this.rateLimitChain = new Promise((resolve) => {
+      releaseChain = resolve;
+    });
+    await previousChain;
+    try {
+      const now = Date.now();
+      const windowStart = now - 6e4;
+      while (this.window.length > 0 && this.window[0] < windowStart) {
+        this.window.shift();
+      }
+      if (this.window.length >= this.maxPerMinute) {
+        const oldestInWindow = this.window[0];
+        const waitMs = oldestInWindow + 6e4 - now + 50;
+        await new Promise((resolve) => setTimeout(resolve, waitMs));
+        const nowAfterWait = Date.now();
+        const newWindowStart = nowAfterWait - 6e4;
+        while (this.window.length > 0 && this.window[0] < newWindowStart) {
+          this.window.shift();
+        }
+      }
+      this.window.push(Date.now());
+    } finally {
+      releaseChain?.();
+    }
+  }
+};
+var SnapshotService = class {
+  constructor(registry) {
+    this.registry = registry;
+  }
+  async createReport(input) {
+    const companyName = input.companyName.trim();
+    const domain = normalizeDomain(input.domain);
+    const manualPhrases = normalizeStringList(input.phrases ?? []);
+    const manualCompetitors = normalizeStringList(input.competitors ?? []);
+    const providers = this.registry.getAll();
+    if (providers.length === 0) {
+      throw new Error("No providers configured. Add at least one provider API key before running canonry snapshot.");
+    }
+    const analysisProvider = pickAnalysisProvider(this.registry.getApiProviders());
+    const homepageUrl = `https://${extractHostname2(domain)}`;
+    const [siteText, audit] = await Promise.all([
+      fetchSiteText(domain),
+      this.runAudit(homepageUrl)
+    ]);
+    if (manualPhrases.length === 0 && !siteText) {
+      throw new Error(
+        `Could not analyze https://${extractHostname2(domain)}. Try again with a reachable homepage or pass manual category queries via --phrases.`
+      );
+    }
+    const profile = await this.buildProfile({
+      companyName,
+      domain,
+      siteText,
+      audit,
+      manualPhrases,
+      analysisProvider
+    });
+    const queryResults = await this.runSnapshotQueries({
+      companyName,
+      domain,
+      phrases: profile.phrases,
+      providers,
+      manualCompetitors
+    });
+    const batchAssessment = await this.analyzeResponses({
+      companyName,
+      domain,
+      profile,
+      audit,
+      queryResults,
+      manualCompetitors,
+      analysisProvider
+    });
+    const enrichedResults = applyBatchAssessment(queryResults, batchAssessment);
+    const summary = buildSnapshotSummary(companyName, profile.phrases, providers, enrichedResults, audit, batchAssessment);
+    const reportCompetitors = uniqueStrings([
+      ...manualCompetitors,
+      ...summary.topCompetitors.map((entry) => entry.name)
+    ]);
+    return {
+      companyName,
+      domain,
+      homepageUrl,
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      phrases: profile.phrases,
+      competitors: reportCompetitors,
+      profile: {
+        industry: profile.industry,
+        summary: profile.summary,
+        services: profile.services,
+        categoryTerms: profile.categoryTerms
+      },
+      audit,
+      queryResults: enrichedResults,
+      summary
+    };
+  }
+  async runAudit(homepageUrl) {
+    try {
+      const report = await runAeoAudit(homepageUrl);
+      return mapAuditReport(report);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      log6.warn("audit.failed", { homepageUrl, error: message });
+      return {
+        url: homepageUrl,
+        finalUrl: homepageUrl,
+        auditedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        overallScore: 0,
+        overallGrade: "N/A",
+        summary: `Technical audit unavailable: ${message}`,
+        factors: []
+      };
+    }
+  }
+  async buildProfile(ctx) {
+    if (ctx.analysisProvider && ctx.siteText) {
+      const prompt = buildProfilePrompt(ctx);
+      try {
+        const raw = await ctx.analysisProvider.adapter.generateText(prompt, ctx.analysisProvider.config);
+        const parsed = parseJsonObject(raw);
+        const parsedPhrases = ctx.manualPhrases.length > 0 ? ctx.manualPhrases : normalizeStringList(parsed.phrases ?? []).slice(0, SNAPSHOT_QUERY_COUNT);
+        if (ctx.manualPhrases.length === 0 && parsedPhrases.length === 0) {
+          throw new Error("no phrases returned");
+        }
+        return {
+          industry: parsed.industry?.trim() || "Unknown",
+          summary: parsed.summary?.trim() || ctx.audit.summary,
+          services: uniqueStrings(parsed.services ?? []).slice(0, 6),
+          categoryTerms: uniqueStrings(parsed.categoryTerms ?? []).slice(0, 8),
+          phrases: parsedPhrases
+        };
+      } catch (err) {
+        log6.warn("profile.generation-failed", {
+          domain: ctx.domain,
+          provider: ctx.analysisProvider.adapter.name,
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+    }
+    if (ctx.manualPhrases.length === 0) {
+      throw new Error(
+        "Automatic category-query generation requires a configured API provider. Add OpenAI, Claude, Gemini, Perplexity, or Local, or pass --phrases manually."
+      );
+    }
+    return {
+      industry: "Unknown",
+      summary: ctx.audit.summary,
+      services: [],
+      categoryTerms: [],
+      phrases: ctx.manualPhrases
+    };
+  }
+  async runSnapshotQueries(ctx) {
+    const gates = /* @__PURE__ */ new Map();
+    for (const provider of ctx.providers) {
+      gates.set(
+        provider.adapter.name,
+        new ProviderExecutionGate2(
+          provider.config.quotaPolicy.maxConcurrency,
+          provider.config.quotaPolicy.maxRequestsPerMinute
+        )
+      );
+    }
+    const competitorDomains = ctx.manualCompetitors.filter(isDomainLike);
+    return Promise.all(ctx.phrases.map(async (phrase) => ({
+      phrase,
+      providerResults: await Promise.all(ctx.providers.map(async (provider) => {
+        const gate = gates.get(provider.adapter.name);
+        return gate.run(async () => {
+          try {
+            const raw = await provider.adapter.executeTrackedQuery(
+              {
+                keyword: phrase,
+                canonicalDomains: [ctx.domain],
+                competitorDomains
+              },
+              provider.config
+            );
+            const normalized = provider.adapter.normalizeResult(raw);
+            const preliminaryCompetitors = extractCompetitorsFromResponse({
+              answerText: normalized.answerText,
+              citedDomains: normalized.citedDomains,
+              manualCompetitors: ctx.manualCompetitors,
+              targetDomain: ctx.domain
+            });
+            return {
+              provider: provider.adapter.name,
+              displayName: provider.adapter.displayName,
+              model: raw.model,
+              mentioned: mentionsTargetCompany(normalized.answerText, ctx.companyName, ctx.domain),
+              cited: citesTargetDomain(normalized.citedDomains, normalized.groundingSources, ctx.domain),
+              describedAccurately: "unknown",
+              accuracyNotes: null,
+              incorrectClaims: [],
+              recommendedCompetitors: preliminaryCompetitors,
+              citedDomains: uniqueStrings(normalized.citedDomains),
+              groundingSources: normalized.groundingSources,
+              searchQueries: uniqueStrings(normalized.searchQueries),
+              answerText: normalized.answerText,
+              error: null
+            };
+          } catch (err) {
+            return {
+              provider: provider.adapter.name,
+              displayName: provider.adapter.displayName,
+              model: provider.config.model ?? provider.adapter.modelRegistry.defaultModel,
+              mentioned: false,
+              cited: false,
+              describedAccurately: "unknown",
+              accuracyNotes: null,
+              incorrectClaims: [],
+              recommendedCompetitors: [],
+              citedDomains: [],
+              groundingSources: [],
+              searchQueries: [],
+              answerText: "",
+              error: err instanceof Error ? err.message : String(err)
+            };
+          }
+        });
+      }))
+    })));
+  }
+  async analyzeResponses(ctx) {
+    if (!ctx.analysisProvider) {
+      return buildFallbackBatchAssessment(ctx.companyName, ctx.audit);
+    }
+    const responses = ctx.queryResults.flatMap(
+      (query) => query.providerResults.filter((result) => !result.error).map((result) => ({
+        phrase: query.phrase,
+        provider: result.provider,
+        displayName: result.displayName,
+        heuristicMentioned: result.mentioned,
+        heuristicCited: result.cited,
+        heuristicCompetitors: result.recommendedCompetitors,
+        citedDomains: result.citedDomains,
+        groundingSources: result.groundingSources.map((source) => source.uri),
+        answerText: clipText(result.answerText, 2e3)
+      }))
+    );
+    if (responses.length === 0) {
+      return buildFallbackBatchAssessment(ctx.companyName, ctx.audit);
+    }
+    try {
+      const prompt = buildBatchAnalysisPrompt({
+        companyName: ctx.companyName,
+        domain: ctx.domain,
+        profile: ctx.profile,
+        audit: ctx.audit,
+        responses,
+        manualCompetitors: ctx.manualCompetitors
+      });
+      const raw = await ctx.analysisProvider.adapter.generateText(prompt, ctx.analysisProvider.config);
+      const parsed = parseJsonObject(raw);
+      return {
+        assessments: (parsed.assessments ?? []).filter((assessment) => assessment.phrase && assessment.provider).map((assessment) => {
+          const hasReviewedCompetitors = assessment.recommendedCompetitors !== void 0;
+          return {
+            phrase: assessment.phrase,
+            provider: assessment.provider,
+            mentioned: assessment.mentioned,
+            describedAccurately: assessment.describedAccurately,
+            accuracyNotes: assessment.accuracyNotes ?? null,
+            incorrectClaims: uniqueStrings(assessment.incorrectClaims ?? []).slice(0, 5),
+            ...hasReviewedCompetitors ? {
+              recommendedCompetitors: uniqueStrings(assessment.recommendedCompetitors ?? []).slice(0, 10)
+            } : {}
+          };
+        }),
+        whatThisMeans: uniqueStrings(parsed.whatThisMeans ?? []).slice(0, 4),
+        recommendedActions: uniqueStrings(parsed.recommendedActions ?? []).slice(0, 4)
+      };
+    } catch (err) {
+      log6.warn("response.analysis-failed", {
+        provider: ctx.analysisProvider.adapter.name,
+        error: err instanceof Error ? err.message : String(err)
+      });
+      return buildFallbackBatchAssessment(ctx.companyName, ctx.audit);
+    }
+  }
+};
+function pickAnalysisProvider(providers) {
+  return [...providers].sort((a, b) => {
+    const aIndex = ANALYSIS_PROVIDER_PRIORITY.indexOf(a.adapter.name);
+    const bIndex = ANALYSIS_PROVIDER_PRIORITY.indexOf(b.adapter.name);
+    return (aIndex === -1 ? Number.MAX_SAFE_INTEGER : aIndex) - (bIndex === -1 ? Number.MAX_SAFE_INTEGER : bIndex);
+  })[0];
+}
+function buildProfilePrompt(ctx) {
+  const instructions = [
+    "You are an AEO and SEO expert building a sales snapshot for an uninformed corporate prospect.",
+    "Use ONLY the homepage text below. Do not browse or invent facts.",
+    "Infer the company category, summarize what it sells, and generate non-branded category queries buyers would ask an AI assistant.",
+    'Never produce brand queries like "what does Acme do?"',
+    `Return strict JSON with keys: industry, summary, services, categoryTerms, phrases.`,
+    `phrases must contain exactly ${SNAPSHOT_QUERY_COUNT} buyer-style category/recommendation queries unless manual phrases are provided.`
+  ];
+  if (ctx.manualPhrases.length > 0) {
+    instructions.push('Manual phrases were already supplied. Echo them back unchanged in the "phrases" array.');
+  }
+  return [
+    ...instructions,
+    "",
+    `Company: ${ctx.companyName}`,
+    `Domain: ${ctx.domain}`,
+    `Existing audit summary: ${ctx.audit.summary}`,
+    "",
+    "Homepage text:",
+    ctx.siteText
+  ].join("\n");
+}
+function buildBatchAnalysisPrompt(ctx) {
+  return [
+    "You are reviewing AI answer-engine responses for a sales-facing AEO snapshot report.",
+    "Use ONLY the provided facts and responses. Do not invent companies or claims.",
+    "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.",
+    "",
+    "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}`,
+    `Industry: ${ctx.profile.industry}`,
+    `Summary: ${ctx.profile.summary}`,
+    `Services: ${ctx.profile.services.join(", ") || "unknown"}`,
+    `Category terms: ${ctx.profile.categoryTerms.join(", ") || "unknown"}`,
+    `Manual competitor hints: ${ctx.manualCompetitors.join(", ") || "none"}`,
+    `Technical audit: ${ctx.audit.overallScore}/100 (${ctx.audit.overallGrade}) \u2014 ${ctx.audit.summary}`,
+    "",
+    "Responses JSON:",
+    JSON.stringify(ctx.responses, null, 2)
+  ].join("\n");
+}
+function buildFallbackBatchAssessment(companyName, audit) {
+  return {
+    assessments: [],
+    whatThisMeans: [
+      `${companyName} needs category-level visibility, not just branded comprehension.`,
+      `The technical baseline is ${audit.overallScore}/100 (${audit.overallGrade}), so weak site signals may be making AI systems prefer better-structured alternatives.`
+    ],
+    recommendedActions: buildFallbackRecommendedActions(audit)
+  };
+}
+function applyBatchAssessment(queryResults, batchAssessment) {
+  const assessmentMap = /* @__PURE__ */ new Map();
+  for (const assessment of batchAssessment.assessments) {
+    assessmentMap.set(`${assessment.phrase}::${assessment.provider}`, assessment);
+  }
+  return queryResults.map((query) => ({
+    phrase: query.phrase,
+    providerResults: query.providerResults.map((result) => {
+      const assessment = assessmentMap.get(`${query.phrase}::${result.provider}`);
+      if (!assessment) {
+        return {
+          ...result,
+          describedAccurately: result.mentioned ? "unknown" : "not-mentioned"
+        };
+      }
+      const reviewedCompetitors = assessment.recommendedCompetitors;
+      const recommendedCompetitors = reviewedCompetitors !== void 0 ? uniqueStrings(reviewedCompetitors) : result.recommendedCompetitors;
+      return {
+        ...result,
+        mentioned: result.mentioned || assessment.mentioned === true,
+        describedAccurately: assessment.describedAccurately ?? (result.mentioned ? "unknown" : "not-mentioned"),
+        accuracyNotes: assessment.accuracyNotes ?? result.accuracyNotes ?? null,
+        incorrectClaims: uniqueStrings([
+          ...result.incorrectClaims,
+          ...assessment.incorrectClaims ?? []
+        ]),
+        recommendedCompetitors
+      };
+    })
+  }));
+}
+function buildSnapshotSummary(companyName, phrases, providers, queryResults, audit, batchAssessment) {
+  const allResults = queryResults.flatMap((query) => query.providerResults);
+  const successfulResults = allResults.filter((result) => !result.error);
+  const failedComparisons = allResults.length - successfulResults.length;
+  const mentionCount = successfulResults.filter((result) => result.mentioned).length;
+  const citationCount = successfulResults.filter((result) => result.cited).length;
+  const totalComparisons = successfulResults.length;
+  const competitorCounts = /* @__PURE__ */ new Map();
+  for (const result of successfulResults) {
+    for (const competitor of result.recommendedCompetitors) {
+      competitorCounts.set(competitor, (competitorCounts.get(competitor) ?? 0) + 1);
+    }
+  }
+  const topCompetitors = [...competitorCounts.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).slice(0, 10).map(([name, count]) => ({ name, count }));
+  const defaultMeaning = totalComparisons > 0 ? `${companyName} was mentioned in ${mentionCount}/${totalComparisons} successful provider-query response${totalComparisons === 1 ? "" : "s"} across ${phrases.length} category queries.` : `No successful provider responses were returned across ${phrases.length} category queries.`;
+  const failureNote = failedComparisons > 0 ? [
+    `${failedComparisons} provider response${failedComparisons === 1 ? "" : "s"} failed and ${failedComparisons === 1 ? "was" : "were"} excluded from visibility totals.`
+  ] : [];
+  const whatThisMeans = batchAssessment.whatThisMeans.length > 0 ? batchAssessment.whatThisMeans : [
+    defaultMeaning
+  ];
+  const combinedWhatThisMeans = uniqueStrings([...whatThisMeans, ...failureNote]).slice(0, 5);
+  const recommendedActions = batchAssessment.recommendedActions.length > 0 ? batchAssessment.recommendedActions : buildFallbackRecommendedActions(audit);
+  return {
+    totalQueries: phrases.length,
+    totalProviders: providers.length,
+    totalComparisons,
+    mentionCount,
+    citationCount,
+    topCompetitors,
+    visibilityGap: buildVisibilityGap(
+      companyName,
+      phrases.length,
+      providers.length,
+      totalComparisons,
+      mentionCount,
+      citationCount,
+      failedComparisons
+    ),
+    whatThisMeans: combinedWhatThisMeans,
+    recommendedActions
+  };
+}
+function buildVisibilityGap(companyName, queryCount, providerCount, totalComparisons, mentionCount, citationCount, failedComparisons) {
+  const successfulLabel = `${totalComparisons} successful provider response${totalComparisons === 1 ? "" : "s"}`;
+  const failureSuffix = failedComparisons > 0 ? ` ${failedComparisons} provider response${failedComparisons === 1 ? "" : "s"} failed.` : "";
+  if (totalComparisons === 0) {
+    return `No providers returned successful answers across ${queryCount} category queries and ${providerCount} providers.${failureSuffix}`.trim();
+  }
+  if (mentionCount === 0) {
+    return `${companyName} was not mentioned in any of the ${successfulLabel} across ${queryCount} category queries and ${providerCount} providers.${failureSuffix}`.trim();
+  }
+  if (citationCount === 0) {
+    return `${companyName} was mentioned in ${mentionCount}/${totalComparisons} successful provider response${totalComparisons === 1 ? "" : "s"}, but never linked or cited directly.${failureSuffix}`.trim();
+  }
+  return `${companyName} was mentioned in ${mentionCount}/${totalComparisons} successful provider response${totalComparisons === 1 ? "" : "s"} and cited in ${citationCount}/${totalComparisons}.${failureSuffix}`.trim();
+}
+function buildFallbackRecommendedActions(audit) {
+  const weakestFactors = [...audit.factors].sort((a, b) => a.score - b.score || a.name.localeCompare(b.name)).slice(0, 3).map((factor) => `Improve ${factor.name.toLowerCase()}: ${formatAuditFactorScore(factor)}`);
+  const defaults = [
+    "Publish category pages that explicitly describe the services AI should recommend you for.",
+    "Add machine-readable trust signals such as schema, FAQs, and llms.txt support.",
+    "Build comparison and proof content that makes the category fit unmistakable."
+  ];
+  return uniqueStrings([...weakestFactors, ...defaults]).slice(0, 4);
+}
+function mentionsTargetCompany(answerText, companyName, domain) {
+  const haystack = normalizeText(answerText);
+  if (!haystack) return false;
+  const fullName = normalizeText(companyName);
+  if (fullName && haystack.includes(fullName)) {
+    return true;
+  }
+  const targetTokens = uniqueStrings([
+    ...extractDistinctiveTokens(companyName),
+    ...extractDistinctiveTokens(extractHostname2(domain).split(".")[0] ?? "")
+  ]);
+  if (targetTokens.length === 0) return false;
+  let matches = 0;
+  for (const token of targetTokens) {
+    if (new RegExp(`\\b${escapeRegExp2(token)}\\b`, "i").test(answerText)) {
+      matches++;
+    }
+  }
+  return matches >= Math.min(2, targetTokens.length) || matches >= 1 && targetTokens.length === 1;
+}
+function citesTargetDomain(citedDomains, groundingSources, targetDomain) {
+  const normalizedTarget = extractHostname2(targetDomain);
+  for (const domain of citedDomains) {
+    if (domainMatches2(domain, normalizedTarget)) {
+      return true;
+    }
+  }
+  for (const source of groundingSources) {
+    if (source.uri && source.uri.toLowerCase().includes(normalizedTarget.toLowerCase())) {
+      return true;
+    }
+    if (source.title && source.title.toLowerCase().includes(normalizedTarget.toLowerCase())) {
+      return true;
+    }
+  }
+  return false;
+}
+function extractCompetitorsFromResponse(ctx) {
+  const competitors2 = /* @__PURE__ */ new Set();
+  const lowerAnswer = ctx.answerText.toLowerCase();
+  const targetDomain = extractHostname2(ctx.targetDomain);
+  for (const hint of ctx.manualCompetitors) {
+    if (isDomainLike(hint)) {
+      const normalizedHint = normalizeDomain(hint);
+      if (domainMatches2(normalizedHint, targetDomain)) continue;
+      if (ctx.citedDomains.some((domain) => domainMatches2(domain, normalizedHint)) || lowerAnswer.includes(normalizedHint.toLowerCase())) {
+        competitors2.add(normalizedHint);
+      }
+      continue;
+    }
+    if (hint.length >= 3 && lowerAnswer.includes(hint.toLowerCase())) {
+      competitors2.add(hint);
+    }
+  }
+  return [...competitors2].slice(0, 6);
+}
+function mapAuditReport(report) {
+  return {
+    url: report.url,
+    finalUrl: report.finalUrl,
+    auditedAt: report.auditedAt,
+    overallScore: report.overallScore,
+    overallGrade: report.overallGrade,
+    summary: report.summary,
+    factors: report.factors.map(mapAuditFactor)
+  };
+}
+function mapAuditFactor(factor) {
+  return {
+    id: factor.id,
+    name: factor.name,
+    weight: factor.weight,
+    score: factor.score,
+    grade: factor.grade,
+    status: factor.status,
+    findings: factor.findings.map((finding) => ({
+      type: finding.type,
+      message: finding.message
+    })),
+    recommendations: factor.recommendations
+  };
+}
+function parseJsonObject(input) {
+  const fenced = input.match(/```(?:json)?\s*([\s\S]*?)```/i);
+  const candidate = fenced?.[1] ?? input;
+  const start = candidate.indexOf("{");
+  const end = candidate.lastIndexOf("}");
+  const json = start >= 0 && end >= start ? candidate.slice(start, end + 1) : candidate;
+  return JSON.parse(json);
+}
+function normalizeText(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim();
+}
+function normalizeStringList(values) {
+  const items = values.flatMap((value) => value.split(","));
+  return uniqueStrings(
+    items.map((value) => value.trim()).filter(Boolean)
+  );
+}
+function uniqueStrings(values) {
+  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();
+  if (!trimmed) return trimmed;
+  try {
+    const url = trimmed.includes("://") ? new URL(trimmed) : new URL(`https://${trimmed}`);
+    return url.hostname.replace(/^www\./, "").toLowerCase();
+  } catch {
+    return trimmed.replace(/^https?:\/\//, "").replace(/\/.*$/, "").replace(/^www\./, "").toLowerCase();
+  }
+}
+function extractHostname2(value) {
+  return normalizeDomain(value);
+}
+function domainMatches2(candidate, target) {
+  const normalizedCandidate = normalizeDomain(candidate);
+  const normalizedTarget = normalizeDomain(target);
+  return normalizedCandidate === normalizedTarget || normalizedCandidate.endsWith(`.${normalizedTarget}`);
+}
+function extractDistinctiveTokens(value) {
+  return normalizeText(value).split(" ").filter((token) => token.length >= 4).filter((token) => !["llc", "inc", "corp", "company", "group", "services", "solutions", "agency"].includes(token));
+}
+function isDomainLike(value) {
+  const normalized = normalizeDomain(value);
+  return normalized.includes(".") && !normalized.includes(" ");
+}
+function clipText(value, length) {
+  if (value.length <= length) return value;
+  return `${value.slice(0, length - 3)}...`;
+}
+function escapeRegExp2(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
 // src/server.ts
 var _require2 = createRequire2(import.meta.url);
 var { version: PKG_VERSION } = _require2("../package.json");
-var log6 = createLogger("Server");
+var log7 = createLogger("Server");
 var DEFAULT_QUOTA = {
   maxConcurrency: 2,
   maxRequestsPerMinute: 10,
@@ -12483,7 +14299,7 @@ async function createServer(opts) {
       quota: opts.config.geminiQuota
     };
   }
-  log6.info("providers.configured", { providers: Object.keys(providers).filter((k) => {
+  log7.info("providers.configured", { providers: Object.keys(providers).filter((k) => {
     const p = providers[k];
     return p?.apiKey || p?.baseUrl || p?.vertexProject;
   }) });
@@ -12520,6 +14336,7 @@ async function createServer(opts) {
   jobRunner.recoverStaleRuns();
   const notifier = new Notifier(opts.db, serverUrl);
   jobRunner.onRunCompleted = (runId, projectId) => notifier.onRunCompleted(runId, projectId);
+  const snapshotService = new SnapshotService(registry);
   const scheduler = new Scheduler(opts.db, {
     onRunCreated: (runId, projectId, providers2) => {
       jobRunner.executeRun(runId, projectId, providers2).catch((err) => {
@@ -13026,6 +14843,9 @@ async function createServer(opts) {
       });
       const raw = await provider.adapter.generateText(prompt, provider.config);
       return parseKeywordResponse(raw, count);
+    },
+    onSnapshotRequested: async (input) => {
+      return snapshotService.createReport(input);
     }
   });
   const dirname2 = path6.dirname(fileURLToPath(import.meta.url));
@@ -13156,6 +14976,7 @@ export {
   notificationEventSchema,
   effectiveDomains,
   setGoogleAuthConfig,
+  formatAuditFactorScore,
   apiKeys,
   createClient,
   migrate,