@ainyc/canonry 1.29.0 → 1.31.0

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

@@ -494,6 +494,9 @@ function unsupportedKind(kind) {
 function notImplemented(message) {
   return new AppError("NOT_IMPLEMENTED", message, 501);
 }
+function deliveryFailed(message) {
+  return new AppError("DELIVERY_FAILED", message, 502);
+}
 
 // ../contracts/src/google.ts
 import { z as z5 } from "zod";
@@ -716,6 +719,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 +812,7 @@ var querySnapshotDtoSchema = z8.object({
   answerText: z8.string().nullable().optional(),
   citedDomains: z8.array(z8.string()).default([]),
   competitorOverlap: z8.array(z8.string()).default([]),
+  recommendedCompetitors: z8.array(z8.string()).default([]),
   groundingSources: z8.array(groundingSourceSchema).default([]),
   searchQueries: z8.array(z8.string()).default([]),
   model: z8.string().nullable().optional(),
@@ -1004,6 +1051,12 @@ var ga4TrafficSnapshotDtoSchema = z11.object({
   organicSessions: z11.number(),
   users: z11.number()
 });
+var ga4AiReferralDtoSchema = z11.object({
+  source: z11.string(),
+  medium: z11.string(),
+  sessions: z11.number(),
+  users: z11.number()
+});
 var ga4TrafficSummaryDtoSchema = z11.object({
   totalSessions: z11.number(),
   totalOrganicSessions: z11.number(),
@@ -1014,6 +1067,7 @@ var ga4TrafficSummaryDtoSchema = z11.object({
     organicSessions: z11.number(),
     users: z11.number()
   })),
+  aiReferrals: z11.array(ga4AiReferralDtoSchema),
   lastSyncedAt: z11.string().nullable()
 });
 
@@ -1036,6 +1090,7 @@ __export(schema_exports, {
   bingKeywordStats: () => bingKeywordStats,
   bingUrlInspections: () => bingUrlInspections,
   competitors: () => competitors,
+  gaAiReferrals: () => gaAiReferrals,
   gaConnections: () => gaConnections,
   gaTrafficSnapshots: () => gaTrafficSnapshots,
   gaTrafficSummaries: () => gaTrafficSummaries,
@@ -1113,6 +1168,7 @@ var querySnapshots = sqliteTable("query_snapshots", {
   answerText: text("answer_text"),
   citedDomains: text("cited_domains").notNull().default("[]"),
   competitorOverlap: text("competitor_overlap").notNull().default("[]"),
+  recommendedCompetitors: text("recommended_competitors").notNull().default("[]"),
   location: text("location"),
   screenshotPath: text("screenshot_path"),
   rawResponse: text("raw_response"),
@@ -1306,6 +1362,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" }),
@@ -1339,6 +1409,16 @@ function createClient(databasePath) {
   return drizzle(sqlite, { schema: schema_exports });
 }
 
+// ../db/src/json.ts
+function parseJsonColumn(value, fallback) {
+  if (value == null || value === "") return fallback;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return fallback;
+  }
+}
+
 // ../db/src/migrate.ts
 import { sql } from "drizzle-orm";
 var MIGRATION_SQL = `
@@ -1635,7 +1715,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);
@@ -1723,7 +1819,7 @@ import { eq as eq3 } from "drizzle-orm";
 
 // ../api-routes/src/helpers.ts
 import crypto3 from "crypto";
-import { eq as eq2, and } from "drizzle-orm";
+import { eq as eq2, sql as sql2 } from "drizzle-orm";
 function resolveProject(db, name) {
   const project = db.select().from(projects).where(eq2(projects.name, name)).get();
   if (!project) {
@@ -1751,43 +1847,39 @@ async function projectRoutes(app, opts) {
     const { name } = request.params;
     const parsedBody = projectUpsertRequestSchema.safeParse(request.body);
     if (!parsedBody.success) {
-      const err = validationError("Invalid project payload", {
+      throw validationError("Invalid project payload", {
         issues: parsedBody.error.issues.map((issue) => ({
           path: issue.path.join("."),
           message: issue.message
         }))
       });
-      return reply.status(err.statusCode).send(err.toJSON());
     }
     const body = parsedBody.data;
     const validNames = opts.validProviderNames ?? [];
     if (validNames.length && body.providers?.length) {
       const invalid = body.providers.filter((p) => !validNames.includes(p));
       if (invalid.length) {
-        const err = validationError(`Invalid provider(s): ${invalid.join(", ")}. Must be one of: ${validNames.join(", ")}`, {
+        throw validationError(`Invalid provider(s): ${invalid.join(", ")}. Must be one of: ${validNames.join(", ")}`, {
           invalidProviders: invalid,
           validProviders: validNames
         });
-        return reply.status(err.statusCode).send(err.toJSON());
       }
     }
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const existing = app.db.select().from(projects).where(eq3(projects.name, name)).get();
-    const existingLocations = existing ? JSON.parse(existing.locations || "[]") : [];
+    const existingLocations = existing ? parseJsonColumn(existing.locations, []) : [];
     const nextLocations = body.locations ?? existingLocations;
     const duplicateLabels = findDuplicateLocationLabels(nextLocations);
     if (duplicateLabels.length > 0) {
-      const err = validationError(`Duplicate location labels are not allowed: ${duplicateLabels.join(", ")}`, {
+      throw validationError(`Duplicate location labels are not allowed: ${duplicateLabels.join(", ")}`, {
         duplicateLabels
       });
-      return reply.status(err.statusCode).send(err.toJSON());
     }
     const nextDefaultLocation = body.defaultLocation !== void 0 ? body.defaultLocation ?? null : existing?.defaultLocation ?? null;
     if (!hasLocationLabel(nextLocations, nextDefaultLocation)) {
-      const err = validationError(`defaultLocation "${nextDefaultLocation}" must match a configured location label`, {
+      throw validationError(`defaultLocation "${nextDefaultLocation}" must match a configured location label`, {
         defaultLocation: nextDefaultLocation
       });
-      return reply.status(err.statusCode).send(err.toJSON());
     }
     if (existing) {
       app.db.update(projects).set({
@@ -1849,28 +1941,11 @@ async function projectRoutes(app, opts) {
     return reply.send(rows.map(formatProject));
   });
   app.get("/projects/:name", async (request, reply) => {
-    try {
-      const project = resolveProject(app.db, request.params.name);
-      return reply.send(formatProject(project));
-    } catch (e) {
-      if (e && typeof e === "object" && "statusCode" in e && "toJSON" in e) {
-        const err = e;
-        return reply.status(err.statusCode).send(err.toJSON());
-      }
-      throw e;
-    }
+    const project = resolveProject(app.db, request.params.name);
+    return reply.send(formatProject(project));
   });
   app.delete("/projects/:name", async (request, reply) => {
-    let project;
-    try {
-      project = resolveProject(app.db, request.params.name);
-    } catch (e) {
-      if (e && typeof e === "object" && "statusCode" in e && "toJSON" in e) {
-        const err = e;
-        return reply.status(err.statusCode).send(err.toJSON());
-      }
-      throw e;
-    }
+    const project = resolveProject(app.db, request.params.name);
     writeAuditLog(app.db, {
       projectId: project.id,
       actor: "api",
@@ -1883,26 +1958,15 @@ async function projectRoutes(app, opts) {
     return reply.status(204).send();
   });
   app.post("/projects/:name/locations", async (request, reply) => {
-    let project;
-    try {
-      project = resolveProject(app.db, request.params.name);
-    } catch (e) {
-      if (e && typeof e === "object" && "statusCode" in e && "toJSON" in e) {
-        const err = e;
-        return reply.status(err.statusCode).send(err.toJSON());
-      }
-      throw e;
-    }
+    const project = resolveProject(app.db, request.params.name);
     const parsed = locationContextSchema.safeParse(request.body);
     if (!parsed.success) {
-      const err = validationError(parsed.error.issues.map((i) => i.message).join(", "));
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw validationError(parsed.error.issues.map((i) => i.message).join(", "));
     }
     const location = parsed.data;
-    const existing = JSON.parse(project.locations || "[]");
+    const existing = parseJsonColumn(project.locations, []);
     if (existing.some((l) => l.label === location.label)) {
-      const err = validationError(`Location "${location.label}" already exists`);
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw validationError(`Location "${location.label}" already exists`);
     }
     existing.push(location);
     const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -1920,39 +1984,20 @@ async function projectRoutes(app, opts) {
     return reply.status(201).send(location);
   });
   app.get("/projects/:name/locations", async (request, reply) => {
-    let project;
-    try {
-      project = resolveProject(app.db, request.params.name);
-    } catch (e) {
-      if (e && typeof e === "object" && "statusCode" in e && "toJSON" in e) {
-        const err = e;
-        return reply.status(err.statusCode).send(err.toJSON());
-      }
-      throw e;
-    }
-    const locations = JSON.parse(project.locations || "[]");
+    const project = resolveProject(app.db, request.params.name);
+    const locations = parseJsonColumn(project.locations, []);
     return reply.send({
       locations,
       defaultLocation: project.defaultLocation
     });
   });
   app.delete("/projects/:name/locations/:label", async (request, reply) => {
-    let project;
-    try {
-      project = resolveProject(app.db, request.params.name);
-    } catch (e) {
-      if (e && typeof e === "object" && "statusCode" in e && "toJSON" in e) {
-        const err = e;
-        return reply.status(err.statusCode).send(err.toJSON());
-      }
-      throw e;
-    }
+    const project = resolveProject(app.db, request.params.name);
     const label = decodeURIComponent(request.params.label);
-    const existing = JSON.parse(project.locations || "[]");
+    const existing = parseJsonColumn(project.locations, []);
     const filtered = existing.filter((l) => l.label !== label);
     if (filtered.length === existing.length) {
-      const err = validationError(`Location "${label}" not found`);
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw validationError(`Location "${label}" not found`);
     }
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const updates = {
@@ -1973,25 +2018,14 @@ async function projectRoutes(app, opts) {
     return reply.status(204).send();
   });
   app.put("/projects/:name/locations/default", async (request, reply) => {
-    let project;
-    try {
-      project = resolveProject(app.db, request.params.name);
-    } catch (e) {
-      if (e && typeof e === "object" && "statusCode" in e && "toJSON" in e) {
-        const err = e;
-        return reply.status(err.statusCode).send(err.toJSON());
-      }
-      throw e;
-    }
+    const project = resolveProject(app.db, request.params.name);
     const label = request.body?.label;
     if (!label) {
-      const err = validationError("label is required");
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw validationError("label is required");
     }
-    const existing = JSON.parse(project.locations || "[]");
+    const existing = parseJsonColumn(project.locations, []);
     if (!existing.some((l) => l.label === label)) {
-      const err = validationError(`Location "${label}" not found. Add it first.`);
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw validationError(`Location "${label}" not found. Add it first.`);
     }
     const now = (/* @__PURE__ */ new Date()).toISOString();
     app.db.update(projects).set({
@@ -2008,16 +2042,7 @@ async function projectRoutes(app, opts) {
     return reply.send({ defaultLocation: label });
   });
   app.get("/projects/:name/export", async (request, reply) => {
-    let project;
-    try {
-      project = resolveProject(app.db, request.params.name);
-    } catch (e) {
-      if (e && typeof e === "object" && "statusCode" in e && "toJSON" in e) {
-        const err = e;
-        return reply.status(err.statusCode).send(err.toJSON());
-      }
-      throw e;
-    }
+    const project = resolveProject(app.db, request.params.name);
     const kws = app.db.select().from(keywords).where(eq3(keywords.projectId, project.id)).all();
     const comps = app.db.select().from(competitors).where(eq3(competitors.projectId, project.id)).all();
     const schedule = app.db.select().from(schedules).where(eq3(schedules.projectId, project.id)).get();
@@ -2027,21 +2052,21 @@ async function projectRoutes(app, opts) {
       kind: "Project",
       metadata: {
         name: project.name,
-        labels: JSON.parse(project.labels)
+        labels: parseJsonColumn(project.labels, {})
       },
       spec: {
         displayName: project.displayName,
         canonicalDomain: project.canonicalDomain,
-        ownedDomains: JSON.parse(project.ownedDomains || "[]"),
+        ownedDomains: parseJsonColumn(project.ownedDomains, []),
         country: project.country,
         language: project.language,
         keywords: kws.map((k) => k.keyword),
         competitors: comps.map((c) => c.domain),
-        providers: JSON.parse(project.providers || "[]"),
-        locations: JSON.parse(project.locations || "[]"),
+        providers: parseJsonColumn(project.providers, []),
+        locations: parseJsonColumn(project.locations, []),
         ...project.defaultLocation ? { defaultLocation: project.defaultLocation } : {},
         notifications: notificationRows.map((row) => {
-          const cfg = JSON.parse(row.config);
+          const cfg = parseJsonColumn(row.config, { url: "", events: [] });
           return {
             channel: row.channel,
             url: cfg.url,
@@ -2052,7 +2077,7 @@ async function projectRoutes(app, opts) {
           schedule: {
             ...schedule.preset ? { preset: schedule.preset } : { cron: schedule.cronExpr },
             timezone: schedule.timezone,
-            providers: JSON.parse(schedule.providers || "[]")
+            providers: parseJsonColumn(schedule.providers, [])
           }
         } : {}
       }
@@ -2066,13 +2091,13 @@ function formatProject(row) {
     name: row.name,
     displayName: row.displayName,
     canonicalDomain: row.canonicalDomain,
-    ownedDomains: JSON.parse(row.ownedDomains || "[]"),
+    ownedDomains: parseJsonColumn(row.ownedDomains, []),
     country: row.country,
     language: row.language,
-    tags: JSON.parse(row.tags),
-    labels: JSON.parse(row.labels),
-    providers: JSON.parse(row.providers || "[]"),
-    locations: JSON.parse(row.locations || "[]"),
+    tags: parseJsonColumn(row.tags, []),
+    labels: parseJsonColumn(row.labels, {}),
+    providers: parseJsonColumn(row.providers, []),
+    locations: parseJsonColumn(row.locations, []),
     defaultLocation: row.defaultLocation,
     configSource: row.configSource,
     configRevision: row.configRevision,
@@ -2086,18 +2111,15 @@ import crypto5 from "crypto";
 import { eq as eq4 } from "drizzle-orm";
 async function keywordRoutes(app, opts) {
   app.get("/projects/:name/keywords", async (request, reply) => {
-    const project = resolveProjectSafe(app, request.params.name, reply);
-    if (!project) return;
+    const project = resolveProject(app.db, request.params.name);
     const rows = app.db.select().from(keywords).where(eq4(keywords.projectId, project.id)).all();
     return reply.send(rows.map((r) => ({ id: r.id, keyword: r.keyword, createdAt: r.createdAt })));
   });
   app.put("/projects/:name/keywords", async (request, reply) => {
-    const project = resolveProjectSafe(app, request.params.name, reply);
-    if (!project) return;
+    const project = resolveProject(app.db, request.params.name);
     const body = request.body;
     if (!body || !Array.isArray(body.keywords)) {
-      const err = validationError('Body must contain a "keywords" array');
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw validationError('Body must contain a "keywords" array');
     }
     const now = (/* @__PURE__ */ new Date()).toISOString();
     app.db.transaction((tx) => {
@@ -2122,12 +2144,10 @@ async function keywordRoutes(app, opts) {
     return reply.send(rows.map((r) => ({ id: r.id, keyword: r.keyword, createdAt: r.createdAt })));
   });
   app.delete("/projects/:name/keywords", async (request, reply) => {
-    const project = resolveProjectSafe(app, request.params.name, reply);
-    if (!project) return;
+    const project = resolveProject(app.db, request.params.name);
     const body = request.body;
     if (!body || !Array.isArray(body.keywords) || body.keywords.length === 0) {
-      const err = validationError('Body must contain a non-empty "keywords" array');
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw validationError('Body must contain a non-empty "keywords" array');
     }
     const existing = app.db.select().from(keywords).where(eq4(keywords.projectId, project.id)).all();
     const toDelete = new Set(body.keywords);
@@ -2150,12 +2170,10 @@ async function keywordRoutes(app, opts) {
     return reply.send(rows.map((r) => ({ id: r.id, keyword: r.keyword, createdAt: r.createdAt })));
   });
   app.post("/projects/:name/keywords", async (request, reply) => {
-    const project = resolveProjectSafe(app, request.params.name, reply);
-    if (!project) return;
+    const project = resolveProject(app.db, request.params.name);
     const body = request.body;
     if (!body || !Array.isArray(body.keywords)) {
-      const err = validationError('Body must contain a "keywords" array');
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw validationError('Body must contain a "keywords" array');
     }
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const existing = app.db.select().from(keywords).where(eq4(keywords.projectId, project.id)).all();
@@ -2186,30 +2204,25 @@ async function keywordRoutes(app, opts) {
     return reply.send(rows.map((r) => ({ id: r.id, keyword: r.keyword, createdAt: r.createdAt })));
   });
   app.post("/projects/:name/keywords/generate", async (request, reply) => {
-    const project = resolveProjectSafe(app, request.params.name, reply);
-    if (!project) return;
+    const project = resolveProject(app.db, request.params.name);
     const body = request.body;
     if (!body?.provider || typeof body.provider !== "string") {
-      const err = validationError('Body must contain a "provider" string');
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw validationError('Body must contain a "provider" string');
     }
     const provider = body.provider.trim().toLowerCase();
     const validNames = opts.validProviderNames ?? [];
     if (validNames.length && !validNames.includes(provider)) {
-      const err = validationError(`Unknown provider "${body.provider}". Valid providers: ${validNames.join(", ")}`, {
+      throw validationError(`Unknown provider "${body.provider}". Valid providers: ${validNames.join(", ")}`, {
         provider: body.provider,
         validProviders: validNames
       });
-      return reply.status(err.statusCode).send(err.toJSON());
     }
     if (body.count !== void 0 && (typeof body.count !== "number" || !Number.isFinite(body.count) || !Number.isInteger(body.count))) {
-      const err = validationError('"count" must be an integer');
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw validationError('"count" must be an integer');
     }
     const count = Math.min(Math.max(body.count ?? 5, 1), 20);
     if (!opts.onGenerateKeywords) {
-      const err = notImplemented("Key phrase generation is not supported in this deployment");
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw notImplemented("Key phrase generation is not supported in this deployment");
     }
     const existingRows = app.db.select().from(keywords).where(eq4(keywords.projectId, project.id)).all();
     const existingKeywords = existingRows.map((r) => r.keyword);
@@ -2233,36 +2246,21 @@ async function keywordRoutes(app, opts) {
     }
   });
 }
-function resolveProjectSafe(app, name, reply) {
-  try {
-    return resolveProject(app.db, name);
-  } catch (e) {
-    if (e && typeof e === "object" && "statusCode" in e && "toJSON" in e) {
-      const err = e;
-      reply.status(err.statusCode).send(err.toJSON());
-      return null;
-    }
-    throw e;
-  }
-}
 
 // ../api-routes/src/competitors.ts
 import crypto6 from "crypto";
 import { eq as eq5 } from "drizzle-orm";
 async function competitorRoutes(app) {
   app.get("/projects/:name/competitors", async (request, reply) => {
-    const project = resolveProjectSafe2(app, request.params.name, reply);
-    if (!project) return;
+    const project = resolveProject(app.db, request.params.name);
     const rows = app.db.select().from(competitors).where(eq5(competitors.projectId, project.id)).all();
     return reply.send(rows.map((r) => ({ id: r.id, domain: r.domain, createdAt: r.createdAt })));
   });
   app.put("/projects/:name/competitors", async (request, reply) => {
-    const project = resolveProjectSafe2(app, request.params.name, reply);
-    if (!project) return;
+    const project = resolveProject(app.db, request.params.name);
     const body = request.body;
     if (!body || !Array.isArray(body.competitors)) {
-      const err = validationError('Body must contain a "competitors" array');
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw validationError('Body must contain a "competitors" array');
     }
     const now = (/* @__PURE__ */ new Date()).toISOString();
     app.db.transaction((tx) => {
@@ -2287,18 +2285,6 @@ async function competitorRoutes(app) {
     return reply.send(rows.map((r) => ({ id: r.id, domain: r.domain, createdAt: r.createdAt })));
   });
 }
-function resolveProjectSafe2(app, name, reply) {
-  try {
-    return resolveProject(app.db, name);
-  } catch (e) {
-    if (e && typeof e === "object" && "statusCode" in e && "toJSON" in e) {
-      const err = e;
-      reply.status(err.statusCode).send(err.toJSON());
-      return null;
-    }
-    throw e;
-  }
-}
 
 // ../api-routes/src/runs.ts
 import crypto8 from "crypto";
@@ -2306,7 +2292,7 @@ import { eq as eq7, asc, desc } from "drizzle-orm";
 
 // ../api-routes/src/run-queue.ts
 import crypto7 from "crypto";
-import { and as and2, eq as eq6, or } from "drizzle-orm";
+import { and, eq as eq6, or } from "drizzle-orm";
 function queueRunIfProjectIdle(db, params) {
   const createdAt = params.createdAt ?? (/* @__PURE__ */ new Date()).toISOString();
   const kind = params.kind ?? "answer-visibility";
@@ -2314,7 +2300,7 @@ function queueRunIfProjectIdle(db, params) {
   const runId = crypto7.randomUUID();
   return db.transaction((tx) => {
     const activeRun = tx.select().from(runs).where(
-      and2(
+      and(
         eq6(runs.projectId, params.projectId),
         or(eq6(runs.status, "queued"), eq6(runs.status, "running"))
       )
@@ -2338,13 +2324,9 @@ function queueRunIfProjectIdle(db, params) {
 // ../api-routes/src/runs.ts
 async function runRoutes(app, opts) {
   app.post("/projects/:name/runs", async (request, reply) => {
-    const project = resolveProjectSafe3(app, request.params.name, reply);
-    if (!project) return;
+    const project = resolveProject(app.db, request.params.name);
     const kind = request.body?.kind ?? "answer-visibility";
-    if (kind !== "answer-visibility") {
-      const err = unsupportedKind(kind);
-      return reply.status(err.statusCode).send(err.toJSON());
-    }
+    if (kind !== "answer-visibility") throw unsupportedKind(kind);
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const trigger = request.body?.trigger ?? "manual";
     const rawProviders = request.body?.providers;
@@ -2354,31 +2336,30 @@ async function runRoutes(app, opts) {
       if (validNames.length) {
         const invalid = normalized.filter((p) => !validNames.includes(p));
         if (invalid.length) {
-          const err = validationError(`Invalid provider(s): ${invalid.join(", ")}. Must be one of: ${validNames.join(", ")}`, {
+          throw validationError(`Invalid provider(s): ${invalid.join(", ")}. Must be one of: ${validNames.join(", ")}`, {
             invalidProviders: invalid,
             validProviders: validNames
           });
-          return reply.status(err.statusCode).send(err.toJSON());
         }
       }
       rawProviders.splice(0, rawProviders.length, ...normalized);
     }
     const providers = rawProviders?.length ? rawProviders : void 0;
     let resolvedLocation;
-    const projectLocations = JSON.parse(project.locations || "[]");
+    const projectLocations = parseJsonColumn(project.locations, []);
     if (request.body?.noLocation) {
       resolvedLocation = null;
     } else if (request.body?.allLocations) {
     } else if (request.body?.location) {
       const loc = projectLocations.find((l) => l.label === request.body.location);
       if (!loc) {
-        return reply.status(400).send({ error: { code: "VALIDATION_ERROR", message: `Location "${request.body.location}" not found. Configure it first.` } });
+        throw validationError(`Location "${request.body.location}" not found. Configure it first.`);
       }
       resolvedLocation = loc;
     }
     if (request.body?.allLocations) {
       if (projectLocations.length === 0) {
-        return reply.status(400).send({ error: { code: "VALIDATION_ERROR", message: "No locations configured for this project" } });
+        throw validationError("No locations configured for this project");
       }
       const newRuns = [];
       for (const loc of projectLocations) {
@@ -2419,10 +2400,7 @@ async function runRoutes(app, opts) {
       trigger,
       location: locationLabel
     });
-    if (queueResult.conflict) {
-      const err = runInProgress(project.name);
-      return reply.status(err.statusCode).send(err.toJSON());
-    }
+    if (queueResult.conflict) throw runInProgress(project.name);
     const runId = queueResult.runId;
     writeAuditLog(app.db, {
       projectId: project.id,
@@ -2438,8 +2416,7 @@ async function runRoutes(app, opts) {
     return reply.status(201).send(formatRun(run));
   });
   app.get("/projects/:name/runs", async (request, reply) => {
-    const project = resolveProjectSafe3(app, request.params.name, reply);
-    if (!project) return;
+    const project = resolveProject(app.db, request.params.name);
     const parsedLimit = parseInt(request.query.limit ?? "", 10);
     const limit = Number.isNaN(parsedLimit) || parsedLimit <= 0 ? void 0 : parsedLimit;
     const rows = limit == null ? app.db.select().from(runs).where(eq7(runs.projectId, project.id)).orderBy(asc(runs.createdAt)).all() : app.db.select().from(runs).where(eq7(runs.projectId, project.id)).orderBy(desc(runs.createdAt)).limit(limit).all().reverse();
@@ -2455,10 +2432,7 @@ async function runRoutes(app, opts) {
       return reply.status(207).send([]);
     }
     const kind = request.body?.kind ?? "answer-visibility";
-    if (kind !== "answer-visibility") {
-      const err = unsupportedKind(kind);
-      return reply.status(err.statusCode).send(err.toJSON());
-    }
+    if (kind !== "answer-visibility") throw unsupportedKind(kind);
     const rawProviders = request.body?.providers;
     if (rawProviders?.length) {
       const normalized = rawProviders.map((p) => p.trim().toLowerCase()).filter(Boolean);
@@ -2466,11 +2440,10 @@ async function runRoutes(app, opts) {
       if (validNames.length) {
         const invalid = normalized.filter((p) => !validNames.includes(p));
         if (invalid.length) {
-          const err = validationError(`Invalid provider(s): ${invalid.join(", ")}. Must be one of: ${validNames.join(", ")}`, {
+          throw validationError(`Invalid provider(s): ${invalid.join(", ")}. Must be one of: ${validNames.join(", ")}`, {
             invalidProviders: invalid,
             validProviders: validNames
           });
-          return reply.status(err.statusCode).send(err.toJSON());
         }
       }
       rawProviders.splice(0, rawProviders.length, ...normalized);
@@ -2507,15 +2480,9 @@ async function runRoutes(app, opts) {
   });
   app.post("/runs/:id/cancel", async (request, reply) => {
     const run = app.db.select().from(runs).where(eq7(runs.id, request.params.id)).get();
-    if (!run) {
-      const err = notFound("Run", request.params.id);
-      return reply.status(err.statusCode).send(err.toJSON());
-    }
+    if (!run) throw notFound("Run", request.params.id);
     const terminalStatuses = /* @__PURE__ */ new Set(["completed", "partial", "failed", "cancelled"]);
-    if (terminalStatuses.has(run.status)) {
-      const err = runNotCancellable(run.id, run.status);
-      return reply.status(err.statusCode).send(err.toJSON());
-    }
+    if (terminalStatuses.has(run.status)) throw runNotCancellable(run.id, run.status);
     const now = (/* @__PURE__ */ new Date()).toISOString();
     app.db.update(runs).set({ status: "cancelled", finishedAt: now, error: "Cancelled by user" }).where(eq7(runs.id, run.id)).run();
     writeAuditLog(app.db, {
@@ -2530,9 +2497,7 @@ async function runRoutes(app, opts) {
   });
   app.get("/runs/:id", async (request, reply) => {
     const run = app.db.select().from(runs).where(eq7(runs.id, request.params.id)).get();
-    if (!run) {
-      return reply.status(404).send({ error: { code: "NOT_FOUND", message: `Run '${request.params.id}' not found` } });
-    }
+    if (!run) throw notFound("Run", request.params.id);
     const snapshots = app.db.select({
       id: querySnapshots.id,
       runId: querySnapshots.runId,
@@ -2544,6 +2509,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
@@ -2560,8 +2526,9 @@ async function runRoutes(app, opts) {
           provider: s.provider,
           citationState: s.citationState,
           answerText: s.answerText,
-          citedDomains: tryParseJson(s.citedDomains, []),
-          competitorOverlap: tryParseJson(s.competitorOverlap, []),
+          citedDomains: parseJsonColumn(s.citedDomains, []),
+          competitorOverlap: parseJsonColumn(s.competitorOverlap, []),
+          recommendedCompetitors: parseJsonColumn(s.recommendedCompetitors, []),
           model: s.model ?? rawParsed.model,
           location: s.location,
           groundingSources: rawParsed.groundingSources,
@@ -2587,32 +2554,13 @@ function formatRun(row) {
   };
 }
 function parseSnapshotRawResponse(raw) {
-  const parsed = tryParseJson(raw ?? "{}", {});
+  const parsed = parseJsonColumn(raw, {});
   return {
     groundingSources: parsed.groundingSources ?? [],
     searchQueries: parsed.searchQueries ?? [],
     model: parsed.model ?? null
   };
 }
-function tryParseJson(value, fallback) {
-  try {
-    return JSON.parse(value);
-  } catch {
-    return fallback;
-  }
-}
-function resolveProjectSafe3(app, name, reply) {
-  try {
-    return resolveProject(app.db, name);
-  } catch (e) {
-    if (e && typeof e === "object" && "statusCode" in e && "toJSON" in e) {
-      const err = e;
-      reply.status(err.statusCode).send(err.toJSON());
-      return null;
-    }
-    throw e;
-  }
-}
 
 // ../api-routes/src/apply.ts
 import crypto10 from "crypto";
@@ -2870,10 +2818,9 @@ async function applyRoutes(app, opts) {
   app.post("/apply", async (request, reply) => {
     const parsed = projectConfigSchema.safeParse(request.body);
     if (!parsed.success) {
-      const err = validationError("Invalid project config", {
+      throw validationError("Invalid project config", {
         issues: parsed.error.issues.map((i) => ({ path: i.path.join("."), message: i.message }))
       });
-      return reply.status(err.statusCode).send(err.toJSON());
     }
     const config = parsed.data;
     const validNames = opts?.validProviderNames ?? [];
@@ -2885,70 +2832,104 @@ async function applyRoutes(app, opts) {
       if (allProviders.length) {
         const invalid = allProviders.filter((p) => !validNames.includes(p));
         if (invalid.length) {
-          const err = validationError(`Invalid provider(s): ${[...new Set(invalid)].join(", ")}. Must be one of: ${validNames.join(", ")}`, {
+          throw validationError(`Invalid provider(s): ${[...new Set(invalid)].join(", ")}. Must be one of: ${validNames.join(", ")}`, {
             invalidProviders: [...new Set(invalid)],
             validProviders: validNames
           });
-          return reply.status(err.statusCode).send(err.toJSON());
         }
       }
     }
+    let resolvedSchedule = null;
+    let deleteSchedule = false;
+    if (config.spec.schedule) {
+      const schedSpec = config.spec.schedule;
+      let cronExpr;
+      let preset = null;
+      if (schedSpec.preset) {
+        preset = schedSpec.preset;
+        try {
+          cronExpr = resolvePreset(schedSpec.preset);
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          throw validationError(msg);
+        }
+      } else if (schedSpec.cron) {
+        cronExpr = schedSpec.cron;
+        if (!validateCron(cronExpr)) throw validationError(`Invalid cron expression in schedule: ${cronExpr}`);
+      } else {
+        throw validationError('Schedule requires either "preset" or "cron"');
+      }
+      const timezone = schedSpec.timezone ?? "UTC";
+      if (!isValidTimezone(timezone)) throw validationError(`Invalid timezone: ${timezone}`);
+      resolvedSchedule = { cronExpr, preset, timezone };
+    } else {
+      deleteSchedule = true;
+    }
+    const rawSpec = request.body?.spec ?? {};
+    const hasNotifications = "notifications" in rawSpec;
+    if (hasNotifications) {
+      for (const notif of config.spec.notifications) {
+        const urlCheck = await resolveWebhookTarget(notif.url ?? "");
+        if (!urlCheck.ok) throw validationError(`Notification URL invalid: ${urlCheck.message}`);
+      }
+    }
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const name = config.metadata.name;
-    const existing = app.db.select().from(projects).where(eq8(projects.name, name)).get();
     let projectId;
-    if (existing) {
-      projectId = existing.id;
-      app.db.update(projects).set({
-        displayName: config.spec.displayName,
-        canonicalDomain: config.spec.canonicalDomain,
-        ownedDomains: JSON.stringify(config.spec.ownedDomains ?? []),
-        country: config.spec.country,
-        language: config.spec.language,
-        labels: JSON.stringify(config.metadata.labels),
-        providers: JSON.stringify(config.spec.providers ?? []),
-        locations: JSON.stringify(config.spec.locations ?? []),
-        defaultLocation: config.spec.defaultLocation ?? null,
-        configSource: "config-file",
-        configRevision: existing.configRevision + 1,
-        updatedAt: now
-      }).where(eq8(projects.id, existing.id)).run();
-      writeAuditLog(app.db, {
-        projectId,
-        actor: "api",
-        action: "project.applied",
-        entityType: "project",
-        entityId: projectId
-      });
-    } else {
-      projectId = crypto10.randomUUID();
-      app.db.insert(projects).values({
-        id: projectId,
-        name,
-        displayName: config.spec.displayName,
-        canonicalDomain: config.spec.canonicalDomain,
-        ownedDomains: JSON.stringify(config.spec.ownedDomains ?? []),
-        country: config.spec.country,
-        language: config.spec.language,
-        tags: "[]",
-        labels: JSON.stringify(config.metadata.labels),
-        providers: JSON.stringify(config.spec.providers ?? []),
-        locations: JSON.stringify(config.spec.locations ?? []),
-        defaultLocation: config.spec.defaultLocation ?? null,
-        configSource: "config-file",
-        configRevision: 1,
-        createdAt: now,
-        updatedAt: now
-      }).run();
-      writeAuditLog(app.db, {
-        projectId,
-        actor: "api",
-        action: "project.created",
-        entityType: "project",
-        entityId: projectId
-      });
-    }
+    let scheduleAction = null;
     app.db.transaction((tx) => {
+      const existing = tx.select().from(projects).where(eq8(projects.name, name)).get();
+      if (existing) {
+        projectId = existing.id;
+        tx.update(projects).set({
+          displayName: config.spec.displayName,
+          canonicalDomain: config.spec.canonicalDomain,
+          ownedDomains: JSON.stringify(config.spec.ownedDomains ?? []),
+          country: config.spec.country,
+          language: config.spec.language,
+          labels: JSON.stringify(config.metadata.labels),
+          providers: JSON.stringify(config.spec.providers ?? []),
+          locations: JSON.stringify(config.spec.locations ?? []),
+          defaultLocation: config.spec.defaultLocation ?? null,
+          configSource: "config-file",
+          configRevision: existing.configRevision + 1,
+          updatedAt: now
+        }).where(eq8(projects.id, existing.id)).run();
+        writeAuditLog(tx, {
+          projectId,
+          actor: "api",
+          action: "project.applied",
+          entityType: "project",
+          entityId: projectId
+        });
+      } else {
+        projectId = crypto10.randomUUID();
+        tx.insert(projects).values({
+          id: projectId,
+          name,
+          displayName: config.spec.displayName,
+          canonicalDomain: config.spec.canonicalDomain,
+          ownedDomains: JSON.stringify(config.spec.ownedDomains ?? []),
+          country: config.spec.country,
+          language: config.spec.language,
+          tags: "[]",
+          labels: JSON.stringify(config.metadata.labels),
+          providers: JSON.stringify(config.spec.providers ?? []),
+          locations: JSON.stringify(config.spec.locations ?? []),
+          defaultLocation: config.spec.defaultLocation ?? null,
+          configSource: "config-file",
+          configRevision: 1,
+          createdAt: now,
+          updatedAt: now
+        }).run();
+        writeAuditLog(tx, {
+          projectId,
+          actor: "api",
+          action: "project.created",
+          entityType: "project",
+          entityId: projectId
+        });
+      }
       tx.delete(keywords).where(eq8(keywords.projectId, projectId)).run();
       for (const kw of config.spec.keywords) {
         tx.insert(keywords).values({
@@ -2981,98 +2962,63 @@ async function applyRoutes(app, opts) {
         entityType: "competitor",
         diff: { competitors: config.spec.competitors }
       });
-    });
-    if (config.spec.schedule) {
-      const schedSpec = config.spec.schedule;
-      let cronExpr;
-      let preset = null;
-      if (schedSpec.preset) {
-        preset = schedSpec.preset;
-        try {
-          cronExpr = resolvePreset(schedSpec.preset);
-        } catch (err) {
-          const msg = err instanceof Error ? err.message : String(err);
-          return reply.status(400).send({ error: { code: "VALIDATION_ERROR", message: msg } });
+      if (resolvedSchedule) {
+        const existingSched = tx.select().from(schedules).where(eq8(schedules.projectId, projectId)).get();
+        if (existingSched) {
+          tx.update(schedules).set({
+            cronExpr: resolvedSchedule.cronExpr,
+            preset: resolvedSchedule.preset,
+            timezone: resolvedSchedule.timezone,
+            providers: JSON.stringify(config.spec.schedule?.providers ?? []),
+            enabled: 1,
+            updatedAt: now
+          }).where(eq8(schedules.id, existingSched.id)).run();
+        } else {
+          tx.insert(schedules).values({
+            id: crypto10.randomUUID(),
+            projectId,
+            cronExpr: resolvedSchedule.cronExpr,
+            preset: resolvedSchedule.preset,
+            timezone: resolvedSchedule.timezone,
+            enabled: 1,
+            providers: JSON.stringify(config.spec.schedule?.providers ?? []),
+            createdAt: now,
+            updatedAt: now
+          }).run();
         }
-      } else if (schedSpec.cron) {
-        cronExpr = schedSpec.cron;
-        if (!validateCron(cronExpr)) {
-          return reply.status(400).send({
-            error: { code: "VALIDATION_ERROR", message: `Invalid cron expression in schedule: ${cronExpr}` }
-          });
+        scheduleAction = "upsert";
+      } else if (deleteSchedule) {
+        const existingSched = tx.select().from(schedules).where(eq8(schedules.projectId, projectId)).get();
+        if (existingSched) {
+          tx.delete(schedules).where(eq8(schedules.projectId, projectId)).run();
+          scheduleAction = "delete";
         }
-      } else {
-        return reply.status(400).send({
-          error: { code: "VALIDATION_ERROR", message: 'Schedule requires either "preset" or "cron"' }
-        });
       }
-      const timezone = schedSpec.timezone ?? "UTC";
-      if (!isValidTimezone(timezone)) {
-        return reply.status(400).send({
-          error: { code: "VALIDATION_ERROR", message: `Invalid timezone: ${timezone}` }
-        });
-      }
-      const existingSched = app.db.select().from(schedules).where(eq8(schedules.projectId, projectId)).get();
-      if (existingSched) {
-        app.db.update(schedules).set({
-          cronExpr,
-          preset,
-          timezone,
-          providers: JSON.stringify(schedSpec.providers ?? []),
-          enabled: 1,
-          updatedAt: now
-        }).where(eq8(schedules.id, existingSched.id)).run();
-      } else {
-        app.db.insert(schedules).values({
-          id: crypto10.randomUUID(),
-          projectId,
-          cronExpr,
-          preset,
-          timezone,
-          enabled: 1,
-          providers: JSON.stringify(schedSpec.providers ?? []),
-          createdAt: now,
-          updatedAt: now
-        }).run();
-      }
-      opts?.onScheduleUpdated?.("upsert", projectId);
-    } else {
-      const existingSched = app.db.select().from(schedules).where(eq8(schedules.projectId, projectId)).get();
-      if (existingSched) {
-        app.db.delete(schedules).where(eq8(schedules.projectId, projectId)).run();
-        opts?.onScheduleUpdated?.("delete", projectId);
-      }
-    }
-    const rawSpec = request.body?.spec ?? {};
-    if ("notifications" in rawSpec) {
-      for (const notif of config.spec.notifications) {
-        const urlCheck = await resolveWebhookTarget(notif.url ?? "");
-        if (!urlCheck.ok) {
-          return reply.status(400).send({
-            error: { code: "VALIDATION_ERROR", message: `Notification URL invalid: ${urlCheck.message}` }
-          });
+      if (hasNotifications) {
+        tx.delete(notifications).where(eq8(notifications.projectId, projectId)).run();
+        for (const notif of config.spec.notifications) {
+          tx.insert(notifications).values({
+            id: crypto10.randomUUID(),
+            projectId,
+            channel: notif.channel,
+            config: JSON.stringify({ url: notif.url, events: notif.events }),
+            webhookSecret: crypto10.randomBytes(32).toString("hex"),
+            enabled: 1,
+            createdAt: now,
+            updatedAt: now
+          }).run();
         }
-      }
-      app.db.delete(notifications).where(eq8(notifications.projectId, projectId)).run();
-      for (const notif of config.spec.notifications) {
-        app.db.insert(notifications).values({
-          id: crypto10.randomUUID(),
+        writeAuditLog(tx, {
           projectId,
-          channel: notif.channel,
-          config: JSON.stringify({ url: notif.url, events: notif.events }),
-          webhookSecret: crypto10.randomBytes(32).toString("hex"),
-          enabled: 1,
-          createdAt: now,
-          updatedAt: now
-        }).run();
+          actor: "api",
+          action: "notifications.replaced",
+          entityType: "notification",
+          diff: { notifications: config.spec.notifications }
+        });
       }
-      writeAuditLog(app.db, {
-        projectId,
-        actor: "api",
-        action: "notifications.replaced",
-        entityType: "notification",
-        diff: { notifications: config.spec.notifications }
-      });
+    });
+    if (scheduleAction) {
+      opts?.onScheduleUpdated?.(scheduleAction, projectId);
     }
     if ("google" in rawSpec && config.spec.google?.gsc?.propertyUrl) {
       opts?.onGoogleConnectionPropertyUpdated?.(config.spec.canonicalDomain, "gsc", config.spec.google.gsc.propertyUrl);
@@ -3083,13 +3029,13 @@ async function applyRoutes(app, opts) {
       name: project.name,
       displayName: project.displayName,
       canonicalDomain: project.canonicalDomain,
-      ownedDomains: JSON.parse(project.ownedDomains || "[]"),
+      ownedDomains: parseJsonColumn(project.ownedDomains, []),
       country: project.country,
       language: project.language,
-      tags: JSON.parse(project.tags),
-      labels: JSON.parse(project.labels),
-      providers: JSON.parse(project.providers || "[]"),
-      locations: JSON.parse(project.locations || "[]"),
+      tags: parseJsonColumn(project.tags, []),
+      labels: parseJsonColumn(project.labels, {}),
+      providers: parseJsonColumn(project.providers, []),
+      locations: parseJsonColumn(project.locations, []),
       defaultLocation: project.defaultLocation,
       configSource: project.configSource,
       configRevision: project.configRevision,
@@ -3145,8 +3091,7 @@ function redactNotificationDiff(value) {
 // ../api-routes/src/history.ts
 async function historyRoutes(app) {
   app.get("/projects/:name/history", async (request, reply) => {
-    const project = resolveProjectSafe4(app, request.params.name, reply);
-    if (!project) return;
+    const project = resolveProject(app.db, request.params.name);
     const rows = app.db.select().from(auditLog).where(eq9(auditLog.projectId, project.id)).orderBy(desc2(auditLog.createdAt)).all();
     return reply.send(rows.map(formatAuditEntry));
   });
@@ -3155,8 +3100,7 @@ async function historyRoutes(app) {
     return reply.send(rows.map(formatAuditEntry));
   });
   app.get("/projects/:name/snapshots", async (request, reply) => {
-    const project = resolveProjectSafe4(app, request.params.name, reply);
-    if (!project) return;
+    const project = resolveProject(app.db, request.params.name);
     const limit = parseInt(request.query.limit ?? "50", 10);
     const offset = parseInt(request.query.offset ?? "0", 10);
     const projectRuns = app.db.select({ id: runs.id }).from(runs).where(eq9(runs.projectId, project.id)).all();
@@ -3174,6 +3118,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();
@@ -3191,8 +3136,9 @@ async function historyRoutes(app) {
         model: s.model,
         citationState: s.citationState,
         answerText: s.answerText,
-        citedDomains: tryParseJson2(s.citedDomains, []),
-        competitorOverlap: tryParseJson2(s.competitorOverlap, []),
+        citedDomains: parseJsonColumn(s.citedDomains, []),
+        competitorOverlap: parseJsonColumn(s.competitorOverlap, []),
+        recommendedCompetitors: parseJsonColumn(s.recommendedCompetitors, []),
         location: s.location,
         createdAt: s.createdAt
       })),
@@ -3200,8 +3146,7 @@ async function historyRoutes(app) {
     });
   });
   app.get("/projects/:name/timeline", async (request, reply) => {
-    const project = resolveProjectSafe4(app, request.params.name, reply);
-    if (!project) return;
+    const project = resolveProject(app.db, request.params.name);
     const projectKeywords = app.db.select().from(keywords).where(eq9(keywords.projectId, project.id)).all();
     const projectRuns = app.db.select().from(runs).where(eq9(runs.projectId, project.id)).orderBy(runs.createdAt).all();
     if (projectRuns.length === 0 || projectKeywords.length === 0) {
@@ -3283,11 +3228,10 @@ async function historyRoutes(app) {
     return reply.send(timeline);
   });
   app.get("/projects/:name/snapshots/diff", async (request, reply) => {
-    const project = resolveProjectSafe4(app, request.params.name, reply);
-    if (!project) return;
+    resolveProject(app.db, request.params.name);
     const { run1, run2 } = request.query;
     if (!run1 || !run2) {
-      return reply.status(400).send({ error: { code: "VALIDATION_ERROR", message: "Both run1 and run2 query params are required" } });
+      throw validationError("Both run1 and run2 query params are required");
     }
     const snaps1 = app.db.select({
       keywordId: querySnapshots.keywordId,
@@ -3332,36 +3276,16 @@ function formatAuditEntry(row) {
     action: row.action,
     entityType: row.entityType,
     entityId: row.entityId,
-    diff: row.diff ? row.entityType === "notification" ? redactNotificationDiff(tryParseJson2(row.diff, null)) : tryParseJson2(row.diff, null) : null,
+    diff: row.diff ? row.entityType === "notification" ? redactNotificationDiff(parseJsonColumn(row.diff, null)) : parseJsonColumn(row.diff, null) : null,
     createdAt: row.createdAt
   };
 }
-function tryParseJson2(value, fallback) {
-  try {
-    return JSON.parse(value);
-  } catch {
-    return fallback;
-  }
-}
-function resolveProjectSafe4(app, name, reply) {
-  try {
-    return resolveProject(app.db, name);
-  } catch (e) {
-    if (e && typeof e === "object" && "statusCode" in e && "toJSON" in e) {
-      const err = e;
-      reply.status(err.statusCode).send(err.toJSON());
-      return null;
-    }
-    throw e;
-  }
-}
 
 // ../api-routes/src/analytics.ts
 import { eq as eq10, desc as desc3, inArray as inArray2 } from "drizzle-orm";
 async function analyticsRoutes(app) {
   app.get("/projects/:name/analytics/metrics", async (request, reply) => {
-    const project = resolveProjectSafe5(app, request.params.name, reply);
-    if (!project) return;
+    const project = resolveProject(app.db, request.params.name);
     const window = parseWindow(request.query.window);
     const cutoff = windowCutoff(window);
     const projectRuns = app.db.select().from(runs).where(eq10(runs.projectId, project.id)).orderBy(runs.createdAt).all().filter((r) => r.status === "completed" || r.status === "partial").filter((r) => !cutoff || r.createdAt >= cutoff);
@@ -3401,8 +3325,7 @@ async function analyticsRoutes(app) {
     return reply.send({ window, buckets, overall, byProvider, trend, keywordChanges });
   });
   app.get("/projects/:name/analytics/gaps", async (request, reply) => {
-    const project = resolveProjectSafe5(app, request.params.name, reply);
-    if (!project) return;
+    const project = resolveProject(app.db, request.params.name);
     const window = parseWindow(request.query.window);
     const cutoff = windowCutoff(window);
     const latestRun = app.db.select().from(runs).where(eq10(runs.projectId, project.id)).orderBy(desc3(runs.createdAt)).all().find((r) => r.status === "completed" || r.status === "partial");
@@ -3450,7 +3373,7 @@ async function analyticsRoutes(app) {
       const citedProviders = kwSnapshots.filter((s) => s.citationState === "cited").map((s) => s.provider);
       const competitorsCiting = /* @__PURE__ */ new Set();
       for (const s of kwSnapshots) {
-        const overlap = tryParseJson3(s.competitorOverlap, []);
+        const overlap = parseJsonColumn(s.competitorOverlap, []);
         for (const c of overlap) competitorsCiting.add(c);
       }
       let category;
@@ -3483,8 +3406,7 @@ async function analyticsRoutes(app) {
     return reply.send({ cited, gap, uncited, runId: latestRun.id, window });
   });
   app.get("/projects/:name/analytics/sources", async (request, reply) => {
-    const project = resolveProjectSafe5(app, request.params.name, reply);
-    if (!project) return;
+    const project = resolveProject(app.db, request.params.name);
     const window = parseWindow(request.query.window);
     const cutoff = windowCutoff(window);
     const windowRuns = app.db.select().from(runs).where(eq10(runs.projectId, project.id)).orderBy(desc3(runs.createdAt)).all().filter((r) => r.status === "completed" || r.status === "partial").filter((r) => !cutoff || r.createdAt >= cutoff);
@@ -3520,26 +3442,6 @@ async function analyticsRoutes(app) {
     return reply.send({ overall, byKeyword, runId: latestRunId, window });
   });
 }
-function resolveProjectSafe5(app, name, reply) {
-  try {
-    return resolveProject(app.db, name);
-  } catch (e) {
-    if (e && typeof e === "object" && "statusCode" in e && "toJSON" in e) {
-      const err = e;
-      reply.status(err.statusCode).send(err.toJSON());
-      return null;
-    }
-    throw e;
-  }
-}
-function tryParseJson3(value, fallback) {
-  if (!value) return fallback;
-  try {
-    return JSON.parse(value);
-  } catch {
-    return fallback;
-  }
-}
 var PROVIDER_INFRA_DOMAINS = /* @__PURE__ */ new Set([
   "vertexaisearch.cloud.google.com",
   "openai.com",
@@ -3557,7 +3459,7 @@ function isProviderInfraDomain(uri) {
   return false;
 }
 function parseGroundingSources(rawResponse) {
-  const parsed = tryParseJson3(rawResponse, {});
+  const parsed = parseJsonColumn(rawResponse, {});
   const sources = parsed.groundingSources;
   if (!Array.isArray(sources)) return [];
   return sources.filter(
@@ -5338,6 +5240,45 @@ var routeCatalog = [
       404: { description: "Project, connection, or page not found." }
     }
   },
+  {
+    method: "post",
+    path: "/api/v1/projects/{name}/wordpress/pages/meta/bulk",
+    summary: "Bulk update SEO meta for multiple pages",
+    tags: ["wordpress"],
+    parameters: [nameParameter],
+    requestBody: {
+      required: true,
+      content: {
+        "application/json": {
+          schema: {
+            type: "object",
+            required: ["entries"],
+            properties: {
+              entries: {
+                type: "array",
+                items: {
+                  type: "object",
+                  required: ["slug"],
+                  properties: {
+                    slug: stringSchema,
+                    title: stringSchema,
+                    description: stringSchema,
+                    noindex: booleanSchema
+                  }
+                }
+              },
+              env: { type: "string", enum: ["live", "staging"] }
+            }
+          }
+        }
+      }
+    },
+    responses: {
+      200: { description: "Bulk SEO meta update results returned." },
+      400: { description: "Invalid entries or environment." },
+      404: { description: "Project or connection not found." }
+    }
+  },
   {
     method: "get",
     path: "/api/v1/projects/{name}/wordpress/schema",
@@ -5379,6 +5320,48 @@ var routeCatalog = [
       404: { description: "Project, connection, or page not found." }
     }
   },
+  {
+    method: "post",
+    path: "/api/v1/projects/{name}/wordpress/schema/deploy",
+    summary: "Deploy JSON-LD schema to WordPress pages",
+    tags: ["wordpress"],
+    parameters: [nameParameter],
+    requestBody: {
+      required: true,
+      content: {
+        "application/json": {
+          schema: {
+            type: "object",
+            required: ["profile"],
+            properties: {
+              profile: {
+                type: "object",
+                description: "Business profile and per-slug schema mapping"
+              },
+              env: { type: "string", enum: ["live", "staging"] }
+            }
+          }
+        }
+      }
+    },
+    responses: {
+      200: { description: "Schema deployment results returned." },
+      400: { description: "Invalid profile or environment." },
+      404: { description: "Project or connection not found." }
+    }
+  },
+  {
+    method: "get",
+    path: "/api/v1/projects/{name}/wordpress/schema/status",
+    summary: "Get JSON-LD schema status for all pages",
+    tags: ["wordpress"],
+    parameters: [nameParameter, wordpressEnvQueryParameter],
+    responses: {
+      200: { description: "Schema status per page returned." },
+      400: { description: "Invalid environment." },
+      404: { description: "Project or connection not found." }
+    }
+  },
   {
     method: "get",
     path: "/api/v1/projects/{name}/wordpress/llms-txt",
@@ -5466,6 +5449,39 @@ var routeCatalog = [
       404: { description: "Project or connection not found." }
     }
   },
+  {
+    method: "post",
+    path: "/api/v1/projects/{name}/wordpress/onboard",
+    summary: "Full WordPress onboarding workflow",
+    tags: ["wordpress"],
+    parameters: [nameParameter],
+    requestBody: {
+      required: true,
+      content: {
+        "application/json": {
+          schema: {
+            type: "object",
+            required: ["url", "username", "appPassword"],
+            properties: {
+              url: stringSchema,
+              stagingUrl: stringSchema,
+              username: stringSchema,
+              appPassword: stringSchema,
+              defaultEnv: { type: "string", enum: ["live", "staging"] },
+              profile: objectSchema,
+              skipSchema: booleanSchema,
+              skipSubmit: booleanSchema
+            }
+          }
+        }
+      }
+    },
+    responses: {
+      200: { description: "Onboarding result with step-by-step status." },
+      400: { description: "Invalid onboarding request." },
+      404: { description: "Project not found." }
+    }
+  },
   // GA4 routes
   {
     method: "post",
@@ -5519,7 +5535,7 @@ var routeCatalog = [
   {
     method: "post",
     path: "/api/v1/projects/{name}/ga/sync",
-    summary: "Sync GA4 traffic data",
+    summary: "Sync GA4 traffic and AI referral data",
     tags: ["ga4"],
     parameters: [nameParameter],
     requestBody: {
@@ -5544,7 +5560,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: {
@@ -5813,34 +5829,29 @@ import crypto11 from "crypto";
 import { eq as eq11 } from "drizzle-orm";
 async function scheduleRoutes(app, opts) {
   app.put("/projects/:name/schedule", async (request, reply) => {
-    const project = resolveProjectSafe6(app, request.params.name, reply);
-    if (!project) return;
+    const project = resolveProject(app.db, request.params.name);
     const parsedBody = scheduleUpsertRequestSchema.safeParse(request.body);
     if (!parsedBody.success) {
-      const err = validationError("Invalid schedule payload", {
+      throw validationError("Invalid schedule payload", {
         issues: parsedBody.error.issues.map((issue) => ({
           path: issue.path.join("."),
           message: issue.message
         }))
       });
-      return reply.status(err.statusCode).send(err.toJSON());
     }
     const { preset, cron: cron2, timezone, providers, enabled } = parsedBody.data;
     const validNames = opts.validProviderNames ?? [];
     if (validNames.length && providers?.length) {
       const invalid = providers.filter((p) => !validNames.includes(p));
       if (invalid.length) {
-        const err = validationError(`Invalid provider(s): ${invalid.join(", ")}. Must be one of: ${validNames.join(", ")}`, {
+        throw validationError(`Invalid provider(s): ${invalid.join(", ")}. Must be one of: ${validNames.join(", ")}`, {
           invalidProviders: invalid,
           validProviders: validNames
         });
-        return reply.status(err.statusCode).send(err.toJSON());
       }
     }
     if (!isValidTimezone(timezone)) {
-      return reply.status(400).send({
-        error: { code: "VALIDATION_ERROR", message: `Invalid timezone: ${timezone}` }
-      });
+      throw validationError(`Invalid timezone: ${timezone}`);
     }
     let cronExpr;
     if (preset) {
@@ -5848,14 +5859,12 @@ async function scheduleRoutes(app, opts) {
         cronExpr = resolvePreset(preset);
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
-        return reply.status(400).send({ error: { code: "VALIDATION_ERROR", message: msg } });
+        throw validationError(msg);
       }
     } else {
       cronExpr = cron2;
       if (!validateCron(cronExpr)) {
-        return reply.status(400).send({
-          error: { code: "VALIDATION_ERROR", message: `Invalid cron expression: ${cronExpr}` }
-        });
+        throw validationError(`Invalid cron expression: ${cronExpr}`);
       }
     }
     const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -5895,20 +5904,18 @@ async function scheduleRoutes(app, opts) {
     return reply.status(existing ? 200 : 201).send(formatSchedule(schedule));
   });
   app.get("/projects/:name/schedule", async (request, reply) => {
-    const project = resolveProjectSafe6(app, request.params.name, reply);
-    if (!project) return;
+    const project = resolveProject(app.db, request.params.name);
     const schedule = app.db.select().from(schedules).where(eq11(schedules.projectId, project.id)).get();
     if (!schedule) {
-      return reply.status(404).send({ error: { code: "NOT_FOUND", message: `No schedule for project '${request.params.name}'` } });
+      throw notFound("Schedule", request.params.name);
     }
     return reply.send(formatSchedule(schedule));
   });
   app.delete("/projects/:name/schedule", async (request, reply) => {
-    const project = resolveProjectSafe6(app, request.params.name, reply);
-    if (!project) return;
+    const project = resolveProject(app.db, request.params.name);
     const schedule = app.db.select().from(schedules).where(eq11(schedules.projectId, project.id)).get();
     if (!schedule) {
-      return reply.status(404).send({ error: { code: "NOT_FOUND", message: `No schedule for project '${request.params.name}'` } });
+      throw notFound("Schedule", request.params.name);
     }
     app.db.delete(schedules).where(eq11(schedules.id, schedule.id)).run();
     writeAuditLog(app.db, {
@@ -5930,25 +5937,13 @@ function formatSchedule(row) {
     preset: row.preset,
     timezone: row.timezone,
     enabled: row.enabled === 1,
-    providers: JSON.parse(row.providers),
+    providers: parseJsonColumn(row.providers, []),
     lastRunAt: row.lastRunAt,
     nextRunAt: row.nextRunAt,
     createdAt: row.createdAt,
     updatedAt: row.updatedAt
   };
 }
-function resolveProjectSafe6(app, name, reply) {
-  try {
-    return resolveProject(app.db, name);
-  } catch (e) {
-    if (e && typeof e === "object" && "statusCode" in e && "toJSON" in e) {
-      const err = e;
-      reply.status(err.statusCode).send(err.toJSON());
-      return null;
-    }
-    throw e;
-  }
-}
 
 // ../api-routes/src/notifications.ts
 import crypto12 from "crypto";
@@ -5959,30 +5954,15 @@ async function notificationRoutes(app) {
     return reply.send(VALID_EVENTS);
   });
   app.post("/projects/:name/notifications", async (request, reply) => {
-    const project = resolveProjectSafe7(app, request.params.name, reply);
-    if (!project) return;
+    const project = resolveProject(app.db, request.params.name);
     const { channel, url, events } = request.body ?? {};
-    if (channel !== "webhook") {
-      return reply.status(400).send({
-        error: { code: "VALIDATION_ERROR", message: 'Only "webhook" channel is supported' }
-      });
-    }
+    if (channel !== "webhook") throw validationError('Only "webhook" channel is supported');
     const urlCheck = await resolveWebhookTarget(url ?? "");
-    if (!urlCheck.ok) {
-      return reply.status(400).send({
-        error: { code: "VALIDATION_ERROR", message: urlCheck.message }
-      });
-    }
-    if (!events?.length) {
-      return reply.status(400).send({
-        error: { code: "VALIDATION_ERROR", message: '"events" must be a non-empty array' }
-      });
-    }
+    if (!urlCheck.ok) throw validationError(urlCheck.message);
+    if (!events?.length) throw validationError('"events" must be a non-empty array');
     const invalid = events.filter((e) => !VALID_EVENTS.includes(e));
     if (invalid.length) {
-      return reply.status(400).send({
-        error: { code: "VALIDATION_ERROR", message: `Invalid event(s): ${invalid.join(", ")}. Must be one of: ${VALID_EVENTS.join(", ")}` }
-      });
+      throw validationError(`Invalid event(s): ${invalid.join(", ")}. Must be one of: ${VALID_EVENTS.join(", ")}`);
     }
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const id = crypto12.randomUUID();
@@ -6011,19 +5991,15 @@ async function notificationRoutes(app) {
     });
   });
   app.get("/projects/:name/notifications", async (request, reply) => {
-    const project = resolveProjectSafe7(app, request.params.name, reply);
-    if (!project) return;
+    const project = resolveProject(app.db, request.params.name);
     const rows = app.db.select().from(notifications).where(eq12(notifications.projectId, project.id)).all();
     return reply.send(rows.map(formatNotification));
   });
   app.delete("/projects/:name/notifications/:id", async (request, reply) => {
-    const project = resolveProjectSafe7(app, request.params.name, reply);
-    if (!project) return;
+    const project = resolveProject(app.db, request.params.name);
     const notification = app.db.select().from(notifications).where(eq12(notifications.id, request.params.id)).get();
     if (!notification || notification.projectId !== project.id) {
-      return reply.status(404).send({
-        error: { code: "NOT_FOUND", message: `Notification '${request.params.id}' not found` }
-      });
+      throw notFound("Notification", request.params.id);
     }
     app.db.delete(notifications).where(eq12(notifications.id, notification.id)).run();
     writeAuditLog(app.db, {
@@ -6036,21 +6012,14 @@ async function notificationRoutes(app) {
     return reply.status(204).send();
   });
   app.post("/projects/:name/notifications/:id/test", async (request, reply) => {
-    const project = resolveProjectSafe7(app, request.params.name, reply);
-    if (!project) return;
+    const project = resolveProject(app.db, request.params.name);
     const notification = app.db.select().from(notifications).where(eq12(notifications.id, request.params.id)).get();
     if (!notification || notification.projectId !== project.id) {
-      return reply.status(404).send({
-        error: { code: "NOT_FOUND", message: `Notification '${request.params.id}' not found` }
-      });
+      throw notFound("Notification", request.params.id);
     }
-    const config = JSON.parse(notification.config);
+    const config = parseJsonColumn(notification.config, { url: "", events: [] });
     const urlCheck = await resolveWebhookTarget(config.url);
-    if (!urlCheck.ok) {
-      return reply.status(400).send({
-        error: { code: "VALIDATION_ERROR", message: `Stored webhook URL is invalid: ${urlCheck.message}` }
-      });
-    }
+    if (!urlCheck.ok) throw validationError(`Stored webhook URL is invalid: ${urlCheck.message}`);
     const payload = {
       source: "canonry",
       event: "run.completed",
@@ -6073,14 +6042,12 @@ async function notificationRoutes(app) {
       entityId: notification.id,
       diff: { status, error }
     });
-    if (error) {
-      return reply.status(502).send({ error: { code: "DELIVERY_FAILED", message: error } });
-    }
+    if (error) throw deliveryFailed(error);
     return reply.send({ status, ok: status >= 200 && status < 300 });
   });
 }
 function formatNotification(row) {
-  const config = JSON.parse(row.config);
+  const config = parseJsonColumn(row.config, { url: "", events: [] });
   const redacted = redactNotificationUrl(config.url);
   return {
     id: row.id,
@@ -6095,22 +6062,10 @@ function formatNotification(row) {
     updatedAt: row.updatedAt
   };
 }
-function resolveProjectSafe7(app, name, reply) {
-  try {
-    return resolveProject(app.db, name);
-  } catch (e) {
-    if (e && typeof e === "object" && "statusCode" in e && "toJSON" in e) {
-      const err = e;
-      reply.status(err.statusCode).send(err.toJSON());
-      return null;
-    }
-    throw e;
-  }
-}
 
 // ../api-routes/src/google.ts
 import crypto13 from "crypto";
-import { eq as eq13, and as and3, desc as desc4, sql as sql2 } from "drizzle-orm";
+import { eq as eq13, and as and2, desc as desc4, sql as sql3 } from "drizzle-orm";
 
 // ../integration-google/src/constants.ts
 var GOOGLE_AUTH_URL = "https://accounts.google.com/o/oauth2/v2/auth";
@@ -6557,11 +6512,11 @@ async function googleRoutes(app, opts) {
     const project = resolveProject(app.db, request.params.name);
     const { startDate, endDate, query, page, limit } = request.query;
     const conditions = [eq13(gscSearchData.projectId, project.id)];
-    if (startDate) conditions.push(sql2`${gscSearchData.date} >= ${startDate}`);
-    if (endDate) conditions.push(sql2`${gscSearchData.date} <= ${endDate}`);
-    if (query) conditions.push(sql2`${gscSearchData.query} LIKE ${"%" + query + "%"}`);
-    if (page) conditions.push(sql2`${gscSearchData.page} LIKE ${"%" + page + "%"}`);
-    const rows = app.db.select().from(gscSearchData).where(and3(...conditions)).orderBy(desc4(gscSearchData.date)).limit(parseInt(limit ?? "500", 10)).all();
+    if (startDate) conditions.push(sql3`${gscSearchData.date} >= ${startDate}`);
+    if (endDate) conditions.push(sql3`${gscSearchData.date} <= ${endDate}`);
+    if (query) conditions.push(sql3`${gscSearchData.query} LIKE ${"%" + query + "%"}`);
+    if (page) conditions.push(sql3`${gscSearchData.page} LIKE ${"%" + page + "%"}`);
+    const rows = app.db.select().from(gscSearchData).where(and2(...conditions)).orderBy(desc4(gscSearchData.date)).limit(parseInt(limit ?? "500", 10)).all();
     return rows.map((r) => ({
       date: r.date,
       query: r.query,
@@ -6639,7 +6594,7 @@ async function googleRoutes(app, opts) {
     const { url, limit } = request.query;
     const conditions = [eq13(gscUrlInspections.projectId, project.id)];
     if (url) conditions.push(eq13(gscUrlInspections.url, url));
-    const rows = app.db.select().from(gscUrlInspections).where(and3(...conditions)).orderBy(desc4(gscUrlInspections.inspectedAt)).limit(parseInt(limit ?? "100", 10)).all();
+    const rows = app.db.select().from(gscUrlInspections).where(and2(...conditions)).orderBy(desc4(gscUrlInspections.inspectedAt)).limit(parseInt(limit ?? "100", 10)).all();
     return rows.map((r) => ({
       id: r.id,
       url: r.url,
@@ -7011,7 +6966,7 @@ async function googleRoutes(app, opts) {
 
 // ../api-routes/src/bing.ts
 import crypto14 from "crypto";
-import { eq as eq14, and as and4, desc as desc5 } from "drizzle-orm";
+import { eq as eq14, and as and3, desc as desc5 } from "drizzle-orm";
 
 // ../integration-bing/src/constants.ts
 var BING_WMT_API_BASE = "https://ssl.bing.com/webmaster/api.svc/json";
@@ -7310,7 +7265,7 @@ async function bingRoutes(app, opts) {
     if (!store) return;
     const project = resolveProject(app.db, request.params.name);
     const { url, limit } = request.query;
-    const whereClause = url ? and4(eq14(bingUrlInspections.projectId, project.id), eq14(bingUrlInspections.url, url)) : eq14(bingUrlInspections.projectId, project.id);
+    const whereClause = url ? and3(eq14(bingUrlInspections.projectId, project.id), eq14(bingUrlInspections.url, url)) : eq14(bingUrlInspections.projectId, project.id);
     const filtered = app.db.select().from(bingUrlInspections).where(whereClause).orderBy(desc5(bingUrlInspections.inspectedAt)).limit(Math.max(1, Math.min(parseInt(limit ?? "100", 10) || 100, 1e3))).all();
     return filtered.map((r) => ({
       id: r.id,
@@ -7500,7 +7455,7 @@ async function bingRoutes(app, opts) {
 import fs2 from "fs";
 import path2 from "path";
 import os2 from "os";
-import { eq as eq15, and as and5 } from "drizzle-orm";
+import { eq as eq15, and as and4 } from "drizzle-orm";
 function getScreenshotDir() {
   return path2.join(os2.homedir(), ".canonry", "screenshots");
 }
@@ -7573,7 +7528,7 @@ async function cdpRoutes(app, opts) {
     async (request, reply) => {
       const project = resolveProject(app.db, request.params.name);
       const { runId } = request.params;
-      const run = app.db.select().from(runs).where(and5(eq15(runs.id, runId), eq15(runs.projectId, project.id))).get();
+      const run = app.db.select().from(runs).where(and4(eq15(runs.id, runId), eq15(runs.projectId, project.id))).get();
       if (!run) {
         const err = notFound("Run", runId);
         return reply.code(err.statusCode).send(err.toJSON());
@@ -7670,7 +7625,7 @@ async function cdpRoutes(app, opts) {
 
 // ../api-routes/src/ga.ts
 import crypto16 from "crypto";
-import { eq as eq16, desc as desc6, and as and6, sql as sql3 } from "drizzle-orm";
+import { eq as eq16, desc as desc6, and as and5, sql as sql4 } from "drizzle-orm";
 
 // ../integration-google-analytics/src/ga4-client.ts
 import crypto15 from "crypto";
@@ -7809,6 +7764,15 @@ async function batchRunReports(accessToken, propertyId, requests) {
 function formatDate(d) {
   return d.toISOString().split("T")[0];
 }
+var AI_REFERRAL_SOURCE_FILTERS = [
+  { matchType: "CONTAINS", value: "perplexity" },
+  { matchType: "CONTAINS", value: "gemini" },
+  { matchType: "CONTAINS", value: "chatgpt" },
+  { matchType: "CONTAINS", value: "openai" },
+  { matchType: "CONTAINS", value: "claude" },
+  { matchType: "CONTAINS", value: "anthropic" },
+  { matchType: "CONTAINS", value: "copilot" }
+];
 async function fetchTrafficByLandingPage(accessToken, propertyId, days) {
   const syncDays = Math.min(Math.max(1, days ?? GA4_DEFAULT_SYNC_DAYS), GA4_MAX_SYNC_DAYS);
   const endDate = /* @__PURE__ */ new Date();
@@ -7935,6 +7899,61 @@ async function fetchAggregateSummary(accessToken, propertyId, days) {
   ga4Log("info", "fetch-aggregate.done", { propertyId, ...summary });
   return summary;
 }
+async function fetchAiReferrals(accessToken, propertyId, days) {
+  const syncDays = Math.min(Math.max(1, days ?? GA4_DEFAULT_SYNC_DAYS), GA4_MAX_SYNC_DAYS);
+  const endDate = /* @__PURE__ */ new Date();
+  const startDate = /* @__PURE__ */ new Date();
+  startDate.setDate(startDate.getDate() - syncDays);
+  ga4Log("info", "fetch-ai-referrals.start", { propertyId, days: syncDays });
+  const PAGE_SIZE = 1e3;
+  const rows = [];
+  let offset = 0;
+  while (true) {
+    const request = {
+      dateRanges: [{ startDate: formatDate(startDate), endDate: formatDate(endDate) }],
+      dimensions: [
+        { name: "date" },
+        { name: "sessionSource" },
+        { name: "sessionMedium" }
+      ],
+      metrics: [
+        { name: "sessions" },
+        { name: "totalUsers" }
+      ],
+      dimensionFilter: {
+        orGroup: {
+          expressions: AI_REFERRAL_SOURCE_FILTERS.map(({ matchType, value }) => ({
+            filter: {
+              fieldName: "sessionSource",
+              stringFilter: { matchType, value }
+            }
+          }))
+        }
+      },
+      limit: PAGE_SIZE,
+      offset
+    };
+    const response = await runReport(accessToken, propertyId, request);
+    const pageRows = (response.rows ?? []).map((row) => ({
+      date: row.dimensionValues[0].value,
+      source: row.dimensionValues[1].value,
+      medium: row.dimensionValues[2].value,
+      sessions: parseInt(row.metricValues[0].value, 10) || 0,
+      users: parseInt(row.metricValues[1].value, 10) || 0
+    }));
+    rows.push(...pageRows);
+    const totalRows = response.rowCount ?? 0;
+    offset += pageRows.length;
+    if (pageRows.length < PAGE_SIZE || offset >= totalRows) break;
+  }
+  for (const row of rows) {
+    if (row.date.length === 8 && !row.date.includes("-")) {
+      row.date = `${row.date.slice(0, 4)}-${row.date.slice(4, 6)}-${row.date.slice(6, 8)}`;
+    }
+  }
+  ga4Log("info", "fetch-ai-referrals.done", { propertyId, rowCount: rows.length });
+  return rows;
+}
 
 // ../api-routes/src/ga.ts
 function gaLog(level, action, ctx) {
@@ -8020,6 +8039,7 @@ async function ga4Routes(app, opts) {
     }
     app.db.delete(gaTrafficSnapshots).where(eq16(gaTrafficSnapshots.projectId, project.id)).run();
     app.db.delete(gaTrafficSummaries).where(eq16(gaTrafficSummaries.projectId, project.id)).run();
+    app.db.delete(gaAiReferrals).where(eq16(gaAiReferrals.projectId, project.id)).run();
     store.deleteConnection(project.name);
     writeAuditLog(app.db, {
       projectId: project.id,
@@ -8038,7 +8058,7 @@ async function ga4Routes(app, opts) {
     if (!conn) {
       return { connected: false, propertyId: null, clientEmail: null, lastSyncedAt: null };
     }
-    const latestSync = app.db.select({ syncedAt: gaTrafficSnapshots.syncedAt }).from(gaTrafficSnapshots).where(eq16(gaTrafficSnapshots.projectId, project.id)).orderBy(desc6(gaTrafficSnapshots.syncedAt)).limit(1).get();
+    const latestSync = app.db.select({ syncedAt: gaTrafficSummaries.syncedAt }).from(gaTrafficSummaries).where(eq16(gaTrafficSummaries.projectId, project.id)).orderBy(desc6(gaTrafficSummaries.syncedAt)).limit(1).get();
     return {
       connected: true,
       propertyId: conn.propertyId,
@@ -8069,11 +8089,13 @@ async function ga4Routes(app, opts) {
     }
     let rows;
     let summary;
+    let aiReferrals;
     try {
       ;
-      [rows, summary] = await Promise.all([
+      [rows, summary, aiReferrals] = await Promise.all([
         fetchTrafficByLandingPage(accessToken, conn.propertyId, days),
-        fetchAggregateSummary(accessToken, conn.propertyId, days)
+        fetchAggregateSummary(accessToken, conn.propertyId, days),
+        fetchAiReferrals(accessToken, conn.propertyId, days)
       ]);
     } catch (e) {
       const msg = e instanceof Error ? e.message : String(e);
@@ -8082,17 +8104,14 @@ async function ga4Routes(app, opts) {
     }
     const now = (/* @__PURE__ */ new Date()).toISOString();
     app.db.transaction((tx) => {
+      tx.delete(gaTrafficSnapshots).where(
+        and5(
+          eq16(gaTrafficSnapshots.projectId, project.id),
+          sql4`${gaTrafficSnapshots.date} >= ${summary.periodStart}`,
+          sql4`${gaTrafficSnapshots.date} <= ${summary.periodEnd}`
+        )
+      ).run();
       if (rows.length > 0) {
-        const dates = rows.map((r) => r.date);
-        const minDate = dates.reduce((a, b) => a < b ? a : b);
-        const maxDate = dates.reduce((a, b) => a > b ? a : b);
-        tx.delete(gaTrafficSnapshots).where(
-          and6(
-            eq16(gaTrafficSnapshots.projectId, project.id),
-            sql3`${gaTrafficSnapshots.date} >= ${minDate}`,
-            sql3`${gaTrafficSnapshots.date} <= ${maxDate}`
-          )
-        ).run();
         for (const row of rows) {
           tx.insert(gaTrafficSnapshots).values({
             id: crypto16.randomUUID(),
@@ -8106,6 +8125,27 @@ async function ga4Routes(app, opts) {
           }).run();
         }
       }
+      tx.delete(gaAiReferrals).where(
+        and5(
+          eq16(gaAiReferrals.projectId, project.id),
+          sql4`${gaAiReferrals.date} >= ${summary.periodStart}`,
+          sql4`${gaAiReferrals.date} <= ${summary.periodEnd}`
+        )
+      ).run();
+      if (aiReferrals.length > 0) {
+        for (const row of aiReferrals) {
+          tx.insert(gaAiReferrals).values({
+            id: crypto16.randomUUID(),
+            projectId: project.id,
+            date: row.date,
+            source: row.source,
+            medium: row.medium,
+            sessions: row.sessions,
+            users: row.users,
+            syncedAt: now
+          }).run();
+        }
+      }
       tx.delete(gaTrafficSummaries).where(eq16(gaTrafficSummaries.projectId, project.id)).run();
       tx.insert(gaTrafficSummaries).values({
         id: crypto16.randomUUID(),
@@ -8118,10 +8158,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
     };
@@ -8143,11 +8190,17 @@ async function ga4Routes(app, opts) {
     }).from(gaTrafficSummaries).where(eq16(gaTrafficSummaries.projectId, project.id)).get();
     const rows = app.db.select({
       landingPage: gaTrafficSnapshots.landingPage,
-      sessions: sql3`SUM(${gaTrafficSnapshots.sessions})`,
-      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();
+      sessions: sql4`SUM(${gaTrafficSnapshots.sessions})`,
+      organicSessions: sql4`SUM(${gaTrafficSnapshots.organicSessions})`,
+      users: sql4`SUM(${gaTrafficSnapshots.users})`
+    }).from(gaTrafficSnapshots).where(eq16(gaTrafficSnapshots.projectId, project.id)).groupBy(gaTrafficSnapshots.landingPage).orderBy(sql4`SUM(${gaTrafficSnapshots.sessions}) DESC`).limit(limit).all();
+    const aiReferrals = app.db.select({
+      source: gaAiReferrals.source,
+      medium: gaAiReferrals.medium,
+      sessions: sql4`SUM(${gaAiReferrals.sessions})`,
+      users: sql4`SUM(${gaAiReferrals.users})`
+    }).from(gaAiReferrals).where(eq16(gaAiReferrals.projectId, project.id)).groupBy(gaAiReferrals.source, gaAiReferrals.medium).orderBy(sql4`SUM(${gaAiReferrals.sessions}) DESC`).all();
+    const latestSync = app.db.select({ syncedAt: gaTrafficSummaries.syncedAt }).from(gaTrafficSummaries).where(eq16(gaTrafficSummaries.projectId, project.id)).orderBy(desc6(gaTrafficSummaries.syncedAt)).limit(1).get();
     return {
       totalSessions: summary?.totalSessions ?? 0,
       totalOrganicSessions: summary?.totalOrganicSessions ?? 0,
@@ -8158,6 +8211,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
     };
   });
@@ -8172,10 +8231,10 @@ async function ga4Routes(app, opts) {
     }
     const trafficPages = app.db.select({
       landingPage: gaTrafficSnapshots.landingPage,
-      sessions: sql3`SUM(${gaTrafficSnapshots.sessions})`,
-      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`).all();
+      sessions: sql4`SUM(${gaTrafficSnapshots.sessions})`,
+      organicSessions: sql4`SUM(${gaTrafficSnapshots.organicSessions})`,
+      users: sql4`SUM(${gaTrafficSnapshots.users})`
+    }).from(gaTrafficSnapshots).where(eq16(gaTrafficSnapshots.projectId, project.id)).groupBy(gaTrafficSnapshots.landingPage).orderBy(sql4`SUM(${gaTrafficSnapshots.sessions}) DESC`).all();
     return {
       pages: trafficPages.map((r) => ({
         landingPage: r.landingPage,
@@ -8199,6 +8258,115 @@ var WordpressApiError = class extends Error {
   }
 };
 
+// ../integration-wordpress/src/schema-templates.ts
+var SUPPORTED_TYPES = /* @__PURE__ */ new Set([
+  "LocalBusiness",
+  "Organization",
+  "FAQPage",
+  "Service",
+  "WebPage"
+]);
+function isSupportedSchemaType(type) {
+  return SUPPORTED_TYPES.has(type);
+}
+function buildAddress(address) {
+  return {
+    "@type": "PostalAddress",
+    ...address.street ? { streetAddress: address.street } : {},
+    ...address.city ? { addressLocality: address.city } : {},
+    ...address.state ? { addressRegion: address.state } : {},
+    ...address.zip ? { postalCode: address.zip } : {},
+    ...address.country ? { addressCountry: address.country } : {}
+  };
+}
+function generateLocalBusiness(profile) {
+  const schema = {
+    "@context": "https://schema.org",
+    "@type": "LocalBusiness",
+    name: profile.name
+  };
+  if (profile.url) schema.url = profile.url;
+  if (profile.description) schema.description = profile.description;
+  if (profile.phone) schema.telephone = profile.phone;
+  if (profile.email) schema.email = profile.email;
+  if (profile.address) schema.address = buildAddress(profile.address);
+  return schema;
+}
+function generateOrganization(profile) {
+  const schema = {
+    "@context": "https://schema.org",
+    "@type": "Organization",
+    name: profile.name
+  };
+  if (profile.url) schema.url = profile.url;
+  if (profile.description) schema.description = profile.description;
+  if (profile.phone) schema.telephone = profile.phone;
+  if (profile.email) schema.email = profile.email;
+  if (profile.address) schema.address = buildAddress(profile.address);
+  return schema;
+}
+function generateFAQPage(profile, faqs) {
+  const schema = {
+    "@context": "https://schema.org",
+    "@type": "FAQPage",
+    name: profile.name
+  };
+  if (faqs && faqs.length > 0) {
+    schema.mainEntity = faqs.map((faq) => ({
+      "@type": "Question",
+      name: faq.q,
+      acceptedAnswer: {
+        "@type": "Answer",
+        text: faq.a
+      }
+    }));
+  }
+  return schema;
+}
+function generateService(profile) {
+  const schema = {
+    "@context": "https://schema.org",
+    "@type": "Service",
+    name: profile.name
+  };
+  if (profile.url) schema.url = profile.url;
+  if (profile.description) schema.description = profile.description;
+  if (profile.address) schema.areaServed = buildAddress(profile.address);
+  return schema;
+}
+function generateWebPage(profile) {
+  const schema = {
+    "@context": "https://schema.org",
+    "@type": "WebPage",
+    name: profile.name
+  };
+  if (profile.url) schema.url = profile.url;
+  if (profile.description) schema.description = profile.description;
+  return schema;
+}
+function generateSchema(type, profile, overrides) {
+  switch (type) {
+    case "LocalBusiness":
+      return generateLocalBusiness(profile);
+    case "Organization":
+      return generateOrganization(profile);
+    case "FAQPage":
+      return generateFAQPage(profile, overrides?.faqs);
+    case "Service":
+      return generateService(profile);
+    case "WebPage":
+      return generateWebPage(profile);
+    default:
+      throw new Error(`Unsupported schema type: ${type}`);
+  }
+}
+function parseSchemaPageEntry(entry) {
+  if (typeof entry === "string") {
+    return { type: entry };
+  }
+  return { type: entry.type, faqs: entry.faqs };
+}
+
 // ../integration-wordpress/src/wordpress-client.ts
 import crypto17 from "crypto";
 var PAGE_FIELDS = "id,slug,status,link,modified,modified_gmt,title,content,meta";
@@ -8635,6 +8803,271 @@ async function setSeoMeta(connection, slug, body, env) {
   );
   return getPageDetail(connection, slug, site.env, plugins);
 }
+async function detectSeoWriteStrategy(connection, env) {
+  const site = resolveEnvironment(connection, env);
+  const plugins = await listActivePlugins(connection, site.env);
+  const pages = await listPages(connection, site.env);
+  if (pages.length === 0) {
+    return { strategy: "manual", plugins };
+  }
+  const samplePage = await getPageBySlug(connection, pages[0].slug, site.env);
+  const writeTargets = resolveSeoWriteTargets(samplePage.meta, plugins);
+  return {
+    strategy: writeTargets.length > 0 ? "plugin" : "manual",
+    plugins
+  };
+}
+function buildManualMetaAssist(siteUrl, slug, link, meta) {
+  const fields = [];
+  if (meta.title != null) fields.push(`Title: ${meta.title}`);
+  if (meta.description != null) fields.push(`Description: ${meta.description}`);
+  if (meta.noindex != null) fields.push(`Noindex: ${meta.noindex}`);
+  return {
+    manualRequired: true,
+    targetUrl: link ?? `${siteUrl}/${slug}`,
+    adminUrl: `${siteUrl}/wp-admin/`,
+    content: fields.join("\n"),
+    nextSteps: [
+      `Open the WordPress editor for page "${slug}".`,
+      "Install an SEO plugin (Yoast SEO, Rank Math, or AIOSEO) to manage meta fields via REST, or set the values manually in the page editor.",
+      "Apply the meta values listed above.",
+      "Publish/update the page."
+    ]
+  };
+}
+async function bulkSetSeoMeta(connection, entries, env) {
+  const site = resolveEnvironment(connection, env);
+  const { strategy, plugins } = await detectSeoWriteStrategy(connection, site.env);
+  const results = await mapWithConcurrency(
+    entries,
+    3,
+    async (entry) => {
+      try {
+        const page = await getPageBySlug(connection, entry.slug, site.env);
+        if (strategy === "manual") {
+          return {
+            slug: entry.slug,
+            status: "manual",
+            manualAssist: buildManualMetaAssist(
+              site.siteUrl,
+              entry.slug,
+              page.link,
+              entry
+            )
+          };
+        }
+        const writeTargets = resolveSeoWriteTargets(page.meta, plugins);
+        if (writeTargets.length === 0 || !page.meta) {
+          return {
+            slug: entry.slug,
+            status: "manual",
+            manualAssist: buildManualMetaAssist(
+              site.siteUrl,
+              entry.slug,
+              page.link,
+              entry
+            )
+          };
+        }
+        const patch = {};
+        for (const target of SEO_TARGETS) {
+          if (entry.title != null && writeTargets.includes(target.titleKey)) patch[target.titleKey] = entry.title;
+          if (entry.description != null && writeTargets.includes(target.descriptionKey)) patch[target.descriptionKey] = entry.description;
+          if (entry.noindex != null && writeTargets.includes(target.noindexKey)) {
+            patch[target.noindexKey] = encodeNoindexValue(target.noindexKey, entry.noindex);
+          }
+        }
+        if (Object.keys(patch).length === 0) {
+          return {
+            slug: entry.slug,
+            status: "manual",
+            manualAssist: buildManualMetaAssist(
+              site.siteUrl,
+              entry.slug,
+              page.link,
+              entry
+            )
+          };
+        }
+        await fetchJson(
+          connection,
+          site.siteUrl,
+          `/wp-json/wp/v2/pages/${page.id}`,
+          {
+            method: "POST",
+            body: JSON.stringify({
+              meta: { ...page.meta ?? {}, ...patch }
+            })
+          }
+        );
+        return { slug: entry.slug, status: "applied" };
+      } catch (error) {
+        if (error instanceof WordpressApiError && error.code === "NOT_FOUND") {
+          return { slug: entry.slug, status: "skipped", error: `Page "${entry.slug}" not found` };
+        }
+        return {
+          slug: entry.slug,
+          status: "skipped",
+          error: error instanceof Error ? error.message : String(error)
+        };
+      }
+    }
+  );
+  return { env: site.env, strategy, results };
+}
+var CANONRY_SCHEMA_START = "<!-- canonry:schema:start -->";
+var CANONRY_SCHEMA_END = "<!-- canonry:schema:end -->";
+function stripCanonrySchema(content) {
+  const regex = new RegExp(
+    `${escapeRegExp(CANONRY_SCHEMA_START)}[\\s\\S]*?${escapeRegExp(CANONRY_SCHEMA_END)}`,
+    "g"
+  );
+  return content.replace(regex, "").replace(/\n{3,}/g, "\n\n").trim();
+}
+function escapeRegExp(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function injectCanonrySchema(content, schemas) {
+  if (schemas.length === 0) return content;
+  const blocks = schemas.map((schema) => `<script type="application/ld+json">${JSON.stringify(schema).replace(/<\//g, "<\\/")}</script>`).join("\n");
+  const injection = `
+
+${CANONRY_SCHEMA_START}
+${blocks}
+${CANONRY_SCHEMA_END}`;
+  const stripped = stripCanonrySchema(content);
+  return stripped + injection;
+}
+async function verifySchemaInjection(connection, slug, env) {
+  const page = await getPageBySlug(connection, slug, env);
+  const raw = page.content?.raw ?? page.content?.rendered ?? "";
+  return raw.includes(CANONRY_SCHEMA_START);
+}
+async function deploySchema(connection, slug, schemas, env) {
+  const site = resolveEnvironment(connection, env);
+  try {
+    const page = await getPageBySlug(connection, slug, site.env);
+    const currentContent = page.content?.raw ?? page.content?.rendered ?? "";
+    const updatedContent = injectCanonrySchema(currentContent, schemas);
+    await fetchJson(
+      connection,
+      site.siteUrl,
+      `/wp-json/wp/v2/pages/${page.id}`,
+      {
+        method: "POST",
+        body: JSON.stringify({ content: updatedContent })
+      }
+    );
+    const persisted = await verifySchemaInjection(connection, slug, site.env);
+    if (!persisted) {
+      return {
+        slug,
+        status: "stripped",
+        schemasInjected: schemas.map((s) => String(s["@type"] ?? "Unknown")),
+        manualAssist: {
+          manualRequired: true,
+          targetUrl: page.link ?? `${site.siteUrl}/${slug}`,
+          adminUrl: `${site.siteUrl}/wp-admin/`,
+          content: schemas.map((s) => JSON.stringify(s, null, 2)).join("\n\n"),
+          nextSteps: [
+            `WordPress stripped the schema <script> tags for page "${slug}". The connected user likely lacks the unfiltered_html capability.`,
+            "Grant the user Administrator or Super Admin role, or add the schema manually in the page editor or via a schema plugin.",
+            "Paste the JSON-LD blocks provided above."
+          ]
+        }
+      };
+    }
+    return {
+      slug,
+      status: "deployed",
+      schemasInjected: schemas.map((s) => String(s["@type"] ?? "Unknown"))
+    };
+  } catch (error) {
+    if (error instanceof WordpressApiError && error.code === "NOT_FOUND") {
+      return { slug, status: "skipped", error: `Page "${slug}" not found` };
+    }
+    return {
+      slug,
+      status: "failed",
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function deploySchemaFromProfile(connection, profile, env) {
+  const site = resolveEnvironment(connection, env);
+  const slugEntries = Object.entries(profile.pages);
+  const results = await mapWithConcurrency(
+    slugEntries,
+    3,
+    async ([slug, entries]) => {
+      const parsed = entries.map(parseSchemaPageEntry);
+      const unsupported = parsed.filter((p) => !isSupportedSchemaType(p.type));
+      if (unsupported.length > 0) {
+        return {
+          slug,
+          status: "failed",
+          error: `Unsupported schema type(s): ${unsupported.map((u) => u.type).join(", ")}`
+        };
+      }
+      const schemas = parsed.map((p) => generateSchema(p.type, profile.business, { faqs: p.faqs }));
+      return deploySchema(connection, slug, schemas, site.env);
+    }
+  );
+  return { env: site.env, results };
+}
+async function getSchemaStatus(connection, env) {
+  const site = resolveEnvironment(connection, env);
+  const pages = await listPages(connection, site.env);
+  const details = await mapWithConcurrency(
+    pages,
+    5,
+    async (page) => getPageDetail(connection, page.slug, site.env)
+  );
+  const statusPages = details.map((page) => {
+    const rawContent = page.content;
+    const hasCanonryMarker = rawContent.includes(CANONRY_SCHEMA_START);
+    const allSchemaTypes = page.schemaBlocks.map((b) => b.type);
+    const canonrySchemas = [];
+    const thirdPartySchemas = [];
+    if (hasCanonryMarker) {
+      const markerRegex = new RegExp(
+        `${escapeRegExp(CANONRY_SCHEMA_START)}([\\s\\S]*?)${escapeRegExp(CANONRY_SCHEMA_END)}`
+      );
+      const match = markerRegex.exec(rawContent);
+      if (match?.[1]) {
+        const jsonLdRegex = /<script[^>]+type=["']application\/ld\+json["'][^>]*>([\s\S]*?)<\/script>/gi;
+        let jsonMatch;
+        while ((jsonMatch = jsonLdRegex.exec(match[1])) !== null) {
+          try {
+            const parsed = JSON.parse(jsonMatch[1].trim());
+            canonrySchemas.push(String(parsed["@type"] ?? "Unknown"));
+          } catch {
+          }
+        }
+      }
+    }
+    const canonryCounts = /* @__PURE__ */ new Map();
+    for (const t of canonrySchemas) {
+      canonryCounts.set(t, (canonryCounts.get(t) ?? 0) + 1);
+    }
+    for (const schemaType of allSchemaTypes) {
+      const remaining = canonryCounts.get(schemaType) ?? 0;
+      if (remaining > 0) {
+        canonryCounts.set(schemaType, remaining - 1);
+      } else {
+        thirdPartySchemas.push(schemaType);
+      }
+    }
+    return {
+      slug: page.slug,
+      title: page.title,
+      canonrySchemas,
+      thirdPartySchemas,
+      hasCanonrySchema: hasCanonryMarker
+    };
+  });
+  return { env: site.env, pages: statusPages };
+}
 async function getLlmsTxt(connection, env) {
   const site = resolveEnvironment(connection, env);
   const url = `${site.siteUrl}/llms.txt`;
@@ -9080,6 +9513,39 @@ async function wordpressRoutes(app, opts) {
       return updated;
     });
   });
+  app.post("/projects/:name/wordpress/pages/meta/bulk", async (request, reply) => {
+    return withWordpressErrorHandling(reply, async () => {
+      const store = requireStore(reply);
+      if (!store) return;
+      const project = resolveProject(app.db, request.params.name);
+      const connection = requireConnection(store, project.name, reply);
+      if (!connection) return;
+      const entries = request.body?.entries;
+      if (!Array.isArray(entries) || entries.length === 0) {
+        const err = validationError("entries array is required and must not be empty");
+        return reply.status(err.statusCode).send(err.toJSON());
+      }
+      for (const entry of entries) {
+        if (!entry.slug?.trim()) {
+          const err = validationError("each entry must have a slug");
+          return reply.status(err.statusCode).send(err.toJSON());
+        }
+      }
+      const env = parseEnvInput(request.body?.env);
+      const result = await bulkSetSeoMeta(connection, entries, env);
+      const applied = result.results.filter((r) => r.status === "applied");
+      if (applied.length > 0) {
+        writeAuditLog(app.db, {
+          projectId: project.id,
+          actor: "api",
+          action: "wordpress.page-meta-updated",
+          entityType: "wordpress_page",
+          entityId: `bulk(${applied.map((r) => r.slug).join(",")})`
+        });
+      }
+      return result;
+    });
+  });
   app.get("/projects/:name/wordpress/schema", async (request, reply) => {
     return withWordpressErrorHandling(reply, async () => {
       const store = requireStore(reply);
@@ -9113,6 +9579,33 @@ async function wordpressRoutes(app, opts) {
       return buildManualSchemaUpdate(connection, slug, { type: request.body?.type, json }, env);
     });
   });
+  app.post("/projects/:name/wordpress/schema/deploy", async (request, reply) => {
+    return withWordpressErrorHandling(reply, async () => {
+      const store = requireStore(reply);
+      if (!store) return;
+      const project = resolveProject(app.db, request.params.name);
+      const connection = requireConnection(store, project.name, reply);
+      if (!connection) return;
+      const profile = request.body?.profile;
+      if (!profile?.business?.name || !profile?.pages || Object.keys(profile.pages).length === 0) {
+        const err = validationError("profile with business.name and non-empty pages is required");
+        return reply.status(err.statusCode).send(err.toJSON());
+      }
+      const env = parseEnvInput(request.body?.env);
+      return deploySchemaFromProfile(connection, profile, env);
+    });
+  });
+  app.get("/projects/:name/wordpress/schema/status", async (request, reply) => {
+    return withWordpressErrorHandling(reply, async () => {
+      const store = requireStore(reply);
+      if (!store) return;
+      const project = resolveProject(app.db, request.params.name);
+      const connection = requireConnection(store, project.name, reply);
+      if (!connection) return;
+      const env = parseEnvInput(request.query?.env);
+      return getSchemaStatus(connection, env);
+    });
+  });
   app.get("/projects/:name/wordpress/llms-txt", async (request, reply) => {
     return withWordpressErrorHandling(reply, async () => {
       const store = requireStore(reply);
@@ -9196,6 +9689,201 @@ async function wordpressRoutes(app, opts) {
       return buildManualStagingPush(connection);
     });
   });
+  app.post("/projects/:name/wordpress/onboard", async (request, reply) => {
+    return withWordpressErrorHandling(reply, async () => {
+      const store = requireStore(reply);
+      if (!store) return;
+      const project = resolveProject(app.db, request.params.name);
+      const { url, username, appPassword, stagingUrl, profile, skipSchema, skipSubmit } = request.body ?? {};
+      if (!url || !username || !appPassword) {
+        const err = validationError("url, username, and appPassword are required");
+        return reply.status(err.statusCode).send(err.toJSON());
+      }
+      const defaultEnv = parseEnvInput(request.body?.defaultEnv, "defaultEnv") ?? (stagingUrl ? "staging" : "live");
+      if (defaultEnv === "staging" && !stagingUrl) {
+        const err = validationError('defaultEnv "staging" requires stagingUrl');
+        return reply.status(err.statusCode).send(err.toJSON());
+      }
+      const steps = [];
+      let connection = null;
+      let pageUrls = [];
+      try {
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const existing = store.getConnection(project.name);
+        const nextConnection = {
+          projectName: project.name,
+          url,
+          stagingUrl,
+          username,
+          appPassword,
+          defaultEnv,
+          createdAt: existing?.createdAt ?? now,
+          updatedAt: now
+        };
+        await verifyWordpressConnection(nextConnection);
+        connection = store.upsertConnection(nextConnection);
+        writeAuditLog(app.db, {
+          projectId: project.id,
+          actor: "api",
+          action: "wordpress.connected",
+          entityType: "wordpress_connection",
+          entityId: project.name
+        });
+        steps.push({ name: "connect", status: "completed", summary: `Connected to ${url}` });
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        steps.push({ name: "connect", status: "failed", error: msg });
+        return { projectName: project.name, steps };
+      }
+      let auditIssues = [];
+      let auditPages = [];
+      try {
+        const audit = await runAudit(connection);
+        const issueCount = audit.issues?.length ?? 0;
+        const pageCount = audit.pages?.length ?? 0;
+        auditIssues = audit.issues;
+        auditPages = audit.pages;
+        const pageSummaries = await listPages(connection);
+        pageUrls = pageSummaries.map((p) => p.link).filter((link) => typeof link === "string" && link.length > 0);
+        steps.push({ name: "audit", status: "completed", summary: `${pageCount} pages audited, ${issueCount} issues` });
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        steps.push({ name: "audit", status: "failed", error: msg });
+        return { projectName: project.name, steps };
+      }
+      try {
+        const metaEntries = [];
+        for (const issue of auditIssues) {
+          if (issue.code === "missing-meta-description" || issue.code === "missing-seo-title") {
+            const existing = metaEntries.find((e) => e.slug === issue.slug);
+            const page = auditPages.find((p) => p.slug === issue.slug);
+            if (!existing) {
+              metaEntries.push({
+                slug: issue.slug,
+                title: issue.code === "missing-seo-title" ? page?.title ?? issue.slug : void 0,
+                description: issue.code === "missing-meta-description" ? page?.title ?? issue.slug : void 0
+              });
+            } else {
+              if (issue.code === "missing-seo-title" && !existing.title) {
+                existing.title = page?.title ?? issue.slug;
+              }
+              if (issue.code === "missing-meta-description" && !existing.description) {
+                existing.description = page?.title ?? issue.slug;
+              }
+            }
+          }
+        }
+        if (metaEntries.length === 0) {
+          steps.push({ name: "set-meta", status: "skipped", summary: "No pages with missing meta found" });
+        } else {
+          const result = await bulkSetSeoMeta(connection, metaEntries);
+          const applied = result.results.filter((r) => r.status === "applied").length;
+          const manual = result.results.filter((r) => r.status === "manual").length;
+          const skipped = result.results.filter((r) => r.status === "skipped").length;
+          steps.push({
+            name: "set-meta",
+            status: "completed",
+            summary: `${applied} applied, ${manual} manual-assist, ${skipped} skipped`
+          });
+        }
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        steps.push({ name: "set-meta", status: "failed", error: msg });
+        return { projectName: project.name, steps };
+      }
+      if (skipSchema || !profile) {
+        steps.push({
+          name: "schema-deploy",
+          status: "skipped",
+          summary: skipSchema ? "Skipped via --skip-schema" : "No --profile provided"
+        });
+      } else {
+        try {
+          if (!profile.business?.name || !profile.pages || Object.keys(profile.pages).length === 0) {
+            steps.push({ name: "schema-deploy", status: "skipped", summary: "Profile missing business.name or pages" });
+          } else {
+            const result = await deploySchemaFromProfile(connection, profile);
+            const deployed = result.results.filter((r) => r.status === "deployed").length;
+            const stripped = result.results.filter((r) => r.status === "stripped").length;
+            const skipped = result.results.filter((r) => r.status === "skipped").length;
+            steps.push({
+              name: "schema-deploy",
+              status: "completed",
+              summary: `${deployed} deployed, ${stripped} stripped (manual-assist), ${skipped} skipped`
+            });
+          }
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          steps.push({ name: "schema-deploy", status: "failed", error: msg });
+          return { projectName: project.name, steps };
+        }
+      }
+      if (skipSubmit || pageUrls.length === 0) {
+        const reason = skipSubmit ? "Skipped via --skip-submit" : "No page URLs to submit";
+        steps.push({ name: "google-submit", status: "skipped", summary: reason });
+        steps.push({ name: "bing-submit", status: "skipped", summary: reason });
+      } else {
+        try {
+          const authHeader = request.headers.authorization;
+          const googleRes = await app.inject({
+            method: "POST",
+            url: `${opts.routePrefix ?? "/api/v1"}/projects/${encodeURIComponent(project.name)}/google/indexing/request`,
+            payload: { urls: pageUrls },
+            headers: authHeader ? { authorization: authHeader } : {}
+          });
+          if (googleRes.statusCode === 200) {
+            const body = JSON.parse(googleRes.body);
+            const succeeded = body.results?.filter((r) => r.status === "success").length ?? 0;
+            steps.push({ name: "google-submit", status: "completed", summary: `${succeeded}/${pageUrls.length} URLs submitted` });
+          } else {
+            const body = JSON.parse(googleRes.body);
+            const msg = body.message || body.error || `HTTP ${googleRes.statusCode}`;
+            if (googleRes.statusCode === 400 || googleRes.statusCode === 404) {
+              steps.push({ name: "google-submit", status: "skipped", summary: msg });
+            } else {
+              steps.push({ name: "google-submit", status: "failed", error: msg });
+            }
+          }
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          steps.push({ name: "google-submit", status: "skipped", summary: `Google not available: ${msg}` });
+        }
+        try {
+          const authHeader = request.headers.authorization;
+          const bingRes = await app.inject({
+            method: "POST",
+            url: `${opts.routePrefix ?? "/api/v1"}/projects/${encodeURIComponent(project.name)}/bing/request-indexing`,
+            payload: { urls: pageUrls },
+            headers: authHeader ? { authorization: authHeader } : {}
+          });
+          if (bingRes.statusCode === 200) {
+            const body = JSON.parse(bingRes.body);
+            const succeeded = body.results?.filter((r) => r.status === "success").length ?? 0;
+            steps.push({ name: "bing-submit", status: "completed", summary: `${succeeded}/${pageUrls.length} URLs submitted` });
+          } else {
+            const body = JSON.parse(bingRes.body);
+            const msg = body.message || body.error || `HTTP ${bingRes.statusCode}`;
+            if (bingRes.statusCode === 400 || bingRes.statusCode === 404) {
+              steps.push({ name: "bing-submit", status: "skipped", summary: msg });
+            } else {
+              steps.push({ name: "bing-submit", status: "failed", error: msg });
+            }
+          }
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          steps.push({ name: "bing-submit", status: "skipped", summary: `Bing not available: ${msg}` });
+        }
+      }
+      writeAuditLog(app.db, {
+        projectId: project.id,
+        actor: "api",
+        action: "wordpress.onboarded",
+        entityType: "wordpress_connection",
+        entityId: project.name
+      });
+      return { projectName: project.name, steps };
+    });
+  });
 }
 
 // ../api-routes/src/index.ts
@@ -9288,7 +9976,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,
@@ -11251,7 +11940,7 @@ import crypto18 from "crypto";
 import fs4 from "fs";
 import path5 from "path";
 import os4 from "os";
-import { and as and7, eq as eq17, inArray as inArray3 } from "drizzle-orm";
+import { and as and6, eq as eq17, inArray as inArray3 } from "drizzle-orm";
 
 // src/logger.ts
 var IS_TTY = process.stdout.isTTY === true;
@@ -11401,7 +12090,7 @@ var JobRunner = class {
         throw new Error(`Run ${runId} is not executable from status '${existingRun.status}'`);
       }
       if (existingRun.status === "queued") {
-        this.db.update(runs).set({ status: "running", startedAt: now }).where(and7(eq17(runs.id, runId), eq17(runs.status, "queued"))).run();
+        this.db.update(runs).set({ status: "running", startedAt: now }).where(and6(eq17(runs.id, runId), eq17(runs.status, "queued"))).run();
       }
       this.throwIfRunCancelled(runId);
       const project = this.db.select().from(projects).where(eq17(projects.id, projectId)).get();
@@ -11488,6 +12177,12 @@ var JobRunner = class {
             log.info("query.result", { runId, provider: providerName, keyword: kw.keyword, citedDomains: normalized.citedDomains, groundingSources: normalized.groundingSources.map((s) => s.uri), matchDomains: allDomains });
             const citationState = determineCitationState(normalized, allDomains);
             const overlap = computeCompetitorOverlap(normalized, competitorDomains);
+            const extractedCompetitors = extractRecommendedCompetitors(
+              normalized.answerText,
+              allDomains,
+              normalized.citedDomains,
+              overlap
+            );
             let screenshotRelPath = null;
             if (raw.screenshotPath && fs4.existsSync(raw.screenshotPath)) {
               const snapshotId = crypto18.randomUUID();
@@ -11506,6 +12201,7 @@ var JobRunner = class {
                 answerText: normalized.answerText,
                 citedDomains: JSON.stringify(normalized.citedDomains),
                 competitorOverlap: JSON.stringify(overlap),
+                recommendedCompetitors: JSON.stringify(extractedCompetitors),
                 location: runLocation?.label ?? null,
                 screenshotPath: screenshotRelPath,
                 rawResponse: JSON.stringify({
@@ -11527,6 +12223,7 @@ var JobRunner = class {
                 answerText: normalized.answerText,
                 citedDomains: JSON.stringify(normalized.citedDomains),
                 competitorOverlap: JSON.stringify(overlap),
+                recommendedCompetitors: JSON.stringify(extractedCompetitors),
                 location: runLocation?.label ?? null,
                 rawResponse: JSON.stringify({
                   model: raw.model,
@@ -11750,10 +12447,101 @@ 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";
-import { eq as eq18, and as and8, sql as sql4 } from "drizzle-orm";
+import { eq as eq18, and as and7, sql as sql5 } from "drizzle-orm";
 var log2 = createLogger("GscSync");
 function formatDate2(d) {
   return d.toISOString().split("T")[0];
@@ -11805,10 +12593,10 @@ async function executeGscSync(db, runId, projectId, opts) {
     });
     log2.info("fetch.complete", { runId, projectId, rowCount: rows.length });
     db.delete(gscSearchData).where(
-      and8(
+      and7(
         eq18(gscSearchData.projectId, projectId),
-        sql4`${gscSearchData.date} >= ${startDate}`,
-        sql4`${gscSearchData.date} <= ${endDate}`
+        sql5`${gscSearchData.date} >= ${startDate}`,
+        sql5`${gscSearchData.date} <= ${endDate}`
       )
     ).run();
     const batchSize = 500;
@@ -11894,7 +12682,7 @@ async function executeGscSync(db, runId, projectId, opts) {
       }
     }
     const snapshotDate = formatDate2(/* @__PURE__ */ new Date());
-    db.delete(gscCoverageSnapshots).where(and8(eq18(gscCoverageSnapshots.projectId, projectId), eq18(gscCoverageSnapshots.date, snapshotDate))).run();
+    db.delete(gscCoverageSnapshots).where(and7(eq18(gscCoverageSnapshots.projectId, projectId), eq18(gscCoverageSnapshots.date, snapshotDate))).run();
     db.insert(gscCoverageSnapshots).values({
       id: crypto19.randomUUID(),
       projectId,
@@ -11917,7 +12705,7 @@ async function executeGscSync(db, runId, projectId, opts) {
 
 // src/gsc-inspect-sitemap.ts
 import crypto20 from "crypto";
-import { eq as eq19, and as and9 } from "drizzle-orm";
+import { eq as eq19, and as and8 } from "drizzle-orm";
 
 // src/sitemap-parser.ts
 var LOC_REGEX = /<loc>\s*([^<]+?)\s*<\/loc>/gi;
@@ -12081,7 +12869,7 @@ async function executeInspectSitemap(db, runId, projectId, opts) {
       }
     }
     const snapshotDate = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-    db.delete(gscCoverageSnapshots).where(and9(eq19(gscCoverageSnapshots.projectId, projectId), eq19(gscCoverageSnapshots.date, snapshotDate))).run();
+    db.delete(gscCoverageSnapshots).where(and8(eq19(gscCoverageSnapshots.projectId, projectId), eq19(gscCoverageSnapshots.date, snapshotDate))).run();
     db.insert(gscCoverageSnapshots).values({
       id: crypto20.randomUUID(),
       projectId,
@@ -12274,7 +13062,7 @@ var Scheduler = class {
 };
 
 // src/notifier.ts
-import { eq as eq21, desc as desc7, and as and10, or as or2 } from "drizzle-orm";
+import { eq as eq21, desc as desc7, and as and9, or as or2 } from "drizzle-orm";
 import crypto21 from "crypto";
 var log5 = createLogger("Notifier");
 var Notifier = class {
@@ -12338,7 +13126,7 @@ var Notifier = class {
   }
   computeTransitions(runId, projectId) {
     const recentRuns = this.db.select().from(runs).where(
-      and10(
+      and9(
         eq21(runs.projectId, projectId),
         or2(eq21(runs.status, "completed"), eq21(runs.status, "partial"))
       )
@@ -12825,7 +13613,7 @@ var SnapshotService = class {
         heuristicCompetitors: result.recommendedCompetitors,
         citedDomains: result.citedDomains,
         groundingSources: result.groundingSources.map((source) => source.uri),
-        answerText: clipText(result.answerText, 420)
+        answerText: clipText(result.answerText, 2e3)
       }))
     );
     if (responses.length === 0) {
@@ -12853,7 +13641,7 @@ var SnapshotService = class {
             accuracyNotes: assessment.accuracyNotes ?? null,
             incorrectClaims: uniqueStrings(assessment.incorrectClaims ?? []).slice(0, 5),
             ...hasReviewedCompetitors ? {
-              recommendedCompetitors: uniqueStrings(assessment.recommendedCompetitors ?? []).slice(0, 6)
+              recommendedCompetitors: uniqueStrings(assessment.recommendedCompetitors ?? []).slice(0, 10)
             } : {}
           };
         }),
@@ -12906,7 +13694,13 @@ function buildBatchAnalysisPrompt(ctx) {
     "Return strict JSON with keys: assessments, whatThisMeans, recommendedActions.",
     "Each assessment must include: phrase, provider, mentioned, describedAccurately, accuracyNotes, incorrectClaims, recommendedCompetitors.",
     "describedAccurately must be one of: yes, no, unknown, not-mentioned.",
-    "recommendedCompetitors should list actual competitor brands or domains named in the answer, not generic directories unless that is the only thing recommended.",
+    "",
+    "CRITICAL \u2014 recommendedCompetitors extraction:",
+    "For each response, extract EVERY specific company/brand/product name that the AI recommended or listed as an alternative.",
+    'Include the company name exactly as it appears in the response (e.g. "Accenture", "Deloitte", "C3.ai").',
+    'Do NOT include generic terms like "consulting firms" or directories like "G2" or "Clutch".',
+    "Do NOT include the target company itself.",
+    "This is the most important field \u2014 it shows the prospect who AI recommends INSTEAD of them.",
     "",
     `Target company: ${ctx.companyName}`,
     `Target domain: ${ctx.domain}`,
@@ -13042,7 +13836,7 @@ function mentionsTargetCompany(answerText, companyName, domain) {
   if (targetTokens.length === 0) return false;
   let matches = 0;
   for (const token of targetTokens) {
-    if (new RegExp(`\\b${escapeRegExp(token)}\\b`, "i").test(answerText)) {
+    if (new RegExp(`\\b${escapeRegExp2(token)}\\b`, "i").test(answerText)) {
       matches++;
     }
   }
@@ -13128,7 +13922,10 @@ function normalizeStringList(values) {
   );
 }
 function uniqueStrings(values) {
-  return [...new Set(values.map((value) => value.trim()).filter(Boolean))];
+  if (!Array.isArray(values)) return [];
+  return [...new Set(
+    values.filter((value) => typeof value === "string").map((value) => value.trim()).filter(Boolean)
+  )];
 }
 function normalizeDomain(value) {
   const trimmed = value.trim();
@@ -13159,7 +13956,7 @@ function clipText(value, length) {
   if (value.length <= length) return value;
   return `${value.slice(0, length - 3)}...`;
 }
-function escapeRegExp(value) {
+function escapeRegExp2(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }