@ainyc/canonry 4.71.0 → 4.72.0

package/dist/{chunk-XYBBC5CH.js → chunk-XYX447L2.js}

@@ -28,6 +28,7 @@ import {
   TrafficSourceStatuses,
   TrafficSourceTypes,
   VerificationStatuses,
+  WinnabilityClasses,
   __export,
   absolutizeProjectUrl,
   actionConfidenceLabel,
@@ -65,6 +66,7 @@ import {
   citationStateToCited,
   citationVisibilityResponseSchema,
   classifySkillFile,
+  classifySurfaceFromCategory,
   clusterByCosine,
   coerceSkillManifest,
   competitorBatchRequestSchema,
@@ -83,6 +85,7 @@ import {
   deliveryFailed,
   deltaPercent,
   deltaTone,
+  deriveWinnabilityClass,
   determineAnswerMentioned,
   discoveryBucketSchema,
   discoveryPromotePreviewSchema,
@@ -92,6 +95,7 @@ import {
   discoverySessionDetailDtoSchema,
   discoverySessionDtoSchema,
   doctorReportSchema,
+  domainClassificationsResponseDtoSchema,
   effectiveBrandNames,
   effectiveDomains,
   emptyCitationVisibility,
@@ -158,6 +162,7 @@ import {
   queryDtoSchema,
   queryGenerateRequestSchema,
   quotaExceeded,
+  recommendationBriefDtoSchema,
   recommendationExplainRequestSchema,
   recommendationExplanationDtoSchema,
   registrableDomain,
@@ -184,7 +189,10 @@ import {
   snapshotListResponseSchema,
   snapshotReportSchema,
   snapshotRequestSchema,
+  sourceBreakdownDtoSchema,
   summarizeCheckResults,
+  surfaceClassFromCompetitorType,
+  surfaceClassLabel,
   trafficBackfillResponseSchema,
   trafficConnectVercelRequestSchema,
   trafficConnectWordpressRequestSchema,
@@ -199,6 +207,8 @@ import {
   validationError,
   visibilityStateFromAnswerMentioned,
   windowCutoff,
+  winnabilityClassLabel,
+  winnabilityClassSchema,
   withRetry,
   wordpressAuditPageDtoSchema,
   wordpressBulkMetaResultDtoSchema,
@@ -212,10 +222,10 @@ import {
   wordpressSchemaDeployResultDtoSchema,
   wordpressSchemaStatusResultDtoSchema,
   wordpressStatusDtoSchema
-} from "./chunk-5FM7QRYD.js";
+} from "./chunk-SJI6JGPN.js";
 
 // src/intelligence-service.ts
-import { eq as eq31, desc as desc16, asc as asc3, and as and23, ne as ne5, or as or5, inArray as inArray11, gte as gte6, lte as lte3 } from "drizzle-orm";
+import { eq as eq32, desc as desc16, asc as asc3, and as and23, ne as ne5, or as or5, inArray as inArray11, gte as gte6, lte as lte3 } from "drizzle-orm";
 
 // ../db/src/client.ts
 import { mkdirSync } from "fs";
@@ -244,6 +254,7 @@ __export(schema_exports, {
   crawlerEventsHourly: () => crawlerEventsHourly,
   discoveryProbes: () => discoveryProbes,
   discoverySessions: () => discoverySessions,
+  domainClassifications: () => domainClassifications,
   gaAiReferrals: () => gaAiReferrals,
   gaConnections: () => gaConnections,
   gaSocialReferrals: () => gaSocialReferrals,
@@ -269,6 +280,7 @@ __export(schema_exports, {
   queries: () => queries,
   querySnapshots: () => querySnapshots,
   rawEventSamples: () => rawEventSamples,
+  recommendationBriefs: () => recommendationBriefs,
   recommendationExplanations: () => recommendationExplanations,
   runs: () => runs,
   schedules: () => schedules,
@@ -981,6 +993,20 @@ var discoveryProbes = sqliteTable("discovery_probes", {
   index("idx_discovery_probes_session").on(table.sessionId),
   index("idx_discovery_probes_project").on(table.projectId)
 ]);
+var domainClassifications = sqliteTable("domain_classifications", {
+  id: text("id").primaryKey(),
+  projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
+  domain: text("domain").notNull(),
+  competitorType: text("competitor_type").$type().notNull(),
+  /** Recurrence count from the latest classifying session; informational. */
+  hits: integer("hits").notNull().default(0),
+  /** Discovery session that produced the latest classification. */
+  sessionId: text("session_id"),
+  updatedAt: text("updated_at").notNull()
+}, (table) => [
+  uniqueIndex("idx_domain_classifications_project_domain").on(table.projectId, table.domain),
+  index("idx_domain_classifications_project").on(table.projectId)
+]);
 var contentTargetDismissals = sqliteTable("content_target_dismissals", {
   id: text("id").primaryKey(),
   projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
@@ -1011,6 +1037,26 @@ var recommendationExplanations = sqliteTable("recommendation_explanations", {
   ),
   index("idx_recommendation_explanations_project").on(table.projectId)
 ]);
+var recommendationBriefs = sqliteTable("recommendation_briefs", {
+  id: text("id").primaryKey(),
+  projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
+  targetRef: text("target_ref").notNull(),
+  promptVersion: text("prompt_version").notNull(),
+  provider: text("provider").notNull(),
+  model: text("model").notNull(),
+  /** The structured brief payload (angle, why-winnable, schema hookup, etc.). */
+  brief: text("brief", { mode: "json" }).$type().notNull(),
+  /** Estimated cost in millicents (1/100 of a cent) for audit; 0 if unknown. */
+  costMillicents: integer("cost_millicents").notNull().default(0),
+  generatedAt: text("generated_at").notNull()
+}, (table) => [
+  uniqueIndex("idx_recommendation_briefs_unique").on(
+    table.projectId,
+    table.targetRef,
+    table.promptVersion
+  ),
+  index("idx_recommendation_briefs_project").on(table.projectId)
+]);
 var migrationsTable = sqliteTable("_migrations", {
   version: integer("version").primaryKey(),
   name: text("name").notNull(),
@@ -2690,6 +2736,49 @@ var MIGRATION_VERSIONS = [
       )`,
       `CREATE INDEX IF NOT EXISTS idx_gbp_place_details_loc ON gbp_place_details(project_id, location_name, synced_at)`
     ]
+  },
+  {
+    // Durable per-domain classification of cited surfaces, upserted on each
+    // discovery completion. Powers the content-targets winnabilityClass winnability
+    // gate without re-running a discovery probe. Keyed (project_id, domain).
+    version: 73,
+    name: "domain-classifications",
+    statements: [
+      `CREATE TABLE IF NOT EXISTS domain_classifications (
+        id              TEXT PRIMARY KEY,
+        project_id      TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+        domain          TEXT NOT NULL,
+        competitor_type TEXT NOT NULL,
+        hits            INTEGER NOT NULL DEFAULT 0,
+        session_id      TEXT,
+        updated_at      TEXT NOT NULL
+      )`,
+      `CREATE UNIQUE INDEX IF NOT EXISTS idx_domain_classifications_project_domain ON domain_classifications(project_id, domain)`,
+      `CREATE INDEX IF NOT EXISTS idx_domain_classifications_project ON domain_classifications(project_id)`
+    ]
+  },
+  {
+    // Structured LLM content briefs, cached per (project, target_ref,
+    // prompt_version). Separate from recommendation_explanations so the
+    // structured brief payload and its version-keyed cache never collide with
+    // the prompt-version-blind explanation lookup.
+    version: 74,
+    name: "recommendation-briefs",
+    statements: [
+      `CREATE TABLE IF NOT EXISTS recommendation_briefs (
+        id              TEXT PRIMARY KEY,
+        project_id      TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+        target_ref      TEXT NOT NULL,
+        prompt_version  TEXT NOT NULL,
+        provider        TEXT NOT NULL,
+        model           TEXT NOT NULL,
+        brief           TEXT NOT NULL,
+        cost_millicents INTEGER NOT NULL DEFAULT 0,
+        generated_at    TEXT NOT NULL
+      )`,
+      `CREATE UNIQUE INDEX IF NOT EXISTS idx_recommendation_briefs_unique ON recommendation_briefs(project_id, target_ref, prompt_version)`,
+      `CREATE INDEX IF NOT EXISTS idx_recommendation_briefs_project ON recommendation_briefs(project_id)`
+    ]
   }
 ];
 function isDuplicateColumnError(err) {
@@ -3547,6 +3636,7 @@ function buildContentTargetRows(input) {
       gscAvgPosition: cq.gscPosition,
       organicSessions: input.gaTrafficByPage.get(ourPage.url) ?? 0
     } : null;
+    const { winnabilityClass, winnability } = deriveWinnabilityClass(cq.citedSurfaceDomains, input.domainClasses);
     rows.push({
       targetRef,
       query: cq.query,
@@ -3558,7 +3648,9 @@ function buildContentTargetRows(input) {
       drivers: scoring.drivers,
       demandSource: scoring.demandSource,
       actionConfidence,
-      existingAction: input.inProgressActions.get(targetRef) ?? null
+      existingAction: input.inProgressActions.get(targetRef) ?? null,
+      winnabilityClass,
+      winnability
     });
   }
   return dedupeByIntent(
@@ -7173,9 +7265,32 @@ async function analyticsRoutes(app) {
     const project = resolveProject(app.db, request.params.name);
     const window = parseWindow(request.query.window);
     const cutoff = windowCutoff(window);
+    let limit = null;
+    if (request.query.limit !== void 0) {
+      const n = Number(request.query.limit);
+      if (!Number.isInteger(n) || n <= 0) throw validationError('"limit" must be a positive integer');
+      limit = n;
+    }
+    const classifyCtx = {
+      projectDomains: effectiveDomains(project),
+      competitorDomains: app.db.select({ domain: competitors.domain }).from(competitors).where(eq10(competitors.projectId, project.id)).all().map((r) => r.domain)
+    };
+    const storedSurfaceClasses = /* @__PURE__ */ new Map();
+    for (const row of app.db.select({ domain: domainClassifications.domain, competitorType: domainClassifications.competitorType }).from(domainClassifications).where(eq10(domainClassifications.projectId, project.id)).all()) {
+      const mapped = surfaceClassFromCompetitorType(row.competitorType);
+      if (mapped) storedSurfaceClasses.set(normalizeProjectDomain(row.domain), mapped);
+    }
     const windowRuns = app.db.select().from(runs).where(and5(eq10(runs.projectId, project.id), notProbeRun())).orderBy(desc3(runs.createdAt), desc3(runs.id)).all().filter((r) => r.status === "completed" || r.status === "partial").filter((r) => !cutoff || r.createdAt >= cutoff);
     if (windowRuns.length === 0) {
-      return reply.send({ overall: [], byQuery: {}, runId: "", window });
+      return reply.send({
+        overall: [],
+        byQuery: {},
+        ranked: buildRankedList(/* @__PURE__ */ new Map(), limit),
+        byProvider: {},
+        runId: "",
+        window,
+        limit
+      });
     }
     const latestGroup = groupRunsByCreatedAt(windowRuns)[0] ?? [];
     const latestRunId = pickGroupRepresentative(latestGroup)?.id ?? windowRuns[0].id;
@@ -7183,28 +7298,49 @@ async function analyticsRoutes(app) {
     const snapshots = app.db.select({
       queryId: querySnapshots.queryId,
       query: queries.query,
+      provider: querySnapshots.provider,
       rawResponse: querySnapshots.rawResponse
     }).from(querySnapshots).leftJoin(queries, eq10(querySnapshots.queryId, queries.id)).where(inArray3(querySnapshots.runId, windowRunIds)).all();
     const overallCounts = /* @__PURE__ */ new Map();
     const byQuery = {};
+    const overallDomains = /* @__PURE__ */ new Map();
+    const providerDomains = /* @__PURE__ */ new Map();
     for (const snap of snapshots) {
       const sources = parseGroundingSources(snap.rawResponse);
       const qCounts = /* @__PURE__ */ new Map();
       for (const source of sources) {
-        const { category, domain } = categorizeSource(source.uri);
+        const { category, label, domain } = categorizeSource(source.uri);
+        const surfaceClass = classifySurfaceFromCategory(
+          domain,
+          category,
+          classifyCtx,
+          storedSurfaceClasses.get(normalizeProjectDomain(domain))
+        );
         if (!overallCounts.has(category)) overallCounts.set(category, /* @__PURE__ */ new Map());
         const oDomains = overallCounts.get(category);
         oDomains.set(domain, (oDomains.get(domain) ?? 0) + 1);
         if (!qCounts.has(category)) qCounts.set(category, /* @__PURE__ */ new Map());
         const qDomains = qCounts.get(category);
         qDomains.set(domain, (qDomains.get(domain) ?? 0) + 1);
+        bumpDomain(overallDomains, domain, category, label, surfaceClass);
+        let pm = providerDomains.get(snap.provider);
+        if (!pm) {
+          pm = /* @__PURE__ */ new Map();
+          providerDomains.set(snap.provider, pm);
+        }
+        bumpDomain(pm, domain, category, label, surfaceClass);
       }
       if (sources.length > 0 && snap.query) {
         byQuery[snap.query] = buildCategoryCounts(qCounts);
       }
     }
     const overall = buildCategoryCounts(overallCounts);
-    return reply.send({ overall, byQuery, runId: latestRunId, window });
+    const ranked = buildRankedList(overallDomains, limit);
+    const byProvider = {};
+    for (const [provider, domains] of providerDomains) {
+      byProvider[provider] = buildRankedList(domains, limit);
+    }
+    return reply.send({ overall, byQuery, ranked, byProvider, runId: latestRunId, window, limit });
   });
 }
 function isProviderInfraDomain(uri) {
@@ -7315,6 +7451,52 @@ function computeTrend(buckets, rateKey) {
   if (diff < -0.05) return "declining";
   return "stable";
 }
+function round4(ratio) {
+  return Math.round(ratio * 1e4) / 1e4;
+}
+function bumpDomain(map, domain, category, label, surfaceClass) {
+  const existing = map.get(domain);
+  if (existing) existing.count += 1;
+  else map.set(domain, { domain, count: 1, category, label, surfaceClass });
+}
+function buildRankedList(domains, limit) {
+  const all = [...domains.values()];
+  const totalCitedSlots = all.reduce((sum, d) => sum + d.count, 0);
+  const domainTotal = all.length;
+  all.sort((a, b) => b.count - a.count || a.domain.localeCompare(b.domain));
+  const shownEntries = limit != null && limit < all.length ? all.slice(0, limit) : all;
+  const entries = shownEntries.map((d) => ({
+    domain: d.domain,
+    count: d.count,
+    percentage: totalCitedSlots > 0 ? round4(d.count / totalCitedSlots) : 0,
+    category: d.category,
+    label: d.label,
+    surfaceClass: d.surfaceClass
+  }));
+  const shownSlots = shownEntries.reduce((sum, d) => sum + d.count, 0);
+  const classAgg = /* @__PURE__ */ new Map();
+  for (const d of all) {
+    const entry = classAgg.get(d.surfaceClass) ?? { count: 0, domainCount: 0 };
+    entry.count += d.count;
+    entry.domainCount += 1;
+    classAgg.set(d.surfaceClass, entry);
+  }
+  const bySurfaceClass = [...classAgg.entries()].map(([surfaceClass, v]) => ({
+    surfaceClass,
+    label: surfaceClassLabel(surfaceClass),
+    count: v.count,
+    percentage: totalCitedSlots > 0 ? round4(v.count / totalCitedSlots) : 0,
+    domainCount: v.domainCount
+  })).sort((a, b) => b.count - a.count || a.surfaceClass.localeCompare(b.surfaceClass));
+  return {
+    totalCitedSlots,
+    domainTotal,
+    entries,
+    truncatedDomainCount: domainTotal - shownEntries.length,
+    truncatedCitedSlots: totalCitedSlots - shownSlots,
+    bySurfaceClass
+  };
+}
 function buildCategoryCounts(counts) {
   let grandTotal = 0;
   for (const domains of counts.values()) {
@@ -7528,6 +7710,7 @@ function loadOrchestratorInput(db, project, locationFilter = void 0) {
   });
   const gaTrafficByPage = buildGaTrafficByPage(db, projectId);
   const totalAiReferralSessions = sumAiReferralSessions(db, projectId);
+  const domainClasses = loadDomainClasses(db, projectId);
   return {
     projectId,
     ownDomain,
@@ -7540,9 +7723,14 @@ function loadOrchestratorInput(db, project, locationFilter = void 0) {
     totalAiReferralSessions,
     latestRunId,
     latestRunTimestamp,
-    inProgressActions: /* @__PURE__ */ new Map()
+    inProgressActions: /* @__PURE__ */ new Map(),
+    domainClasses
   };
 }
+function loadDomainClasses(db, projectId) {
+  const rows = db.select({ domain: domainClassifications.domain, competitorType: domainClassifications.competitorType }).from(domainClassifications).where(eq12(domainClassifications.projectId, projectId)).all();
+  return new Map(rows.map((r) => [normalizeDomain(r.domain), r.competitorType]));
+}
 function buildQueryIntentModifiers(project, locationFilter) {
   if (locationFilter === void 0 || locationFilter === null) return [];
   const locations = project.locations ?? [];
@@ -7749,6 +7937,7 @@ function aggregateCandidate(opts) {
   const competitorTally = /* @__PURE__ */ new Map();
   const competitorGroundingTally = /* @__PURE__ */ new Map();
   const ourGroundingTally = /* @__PURE__ */ new Map();
+  const citedSurfaceTally = /* @__PURE__ */ new Map();
   let ourCitedInLatestRun = false;
   for (const snap of opts.snapshots) {
     const isLatestRun = snap.runId === opts.latestRunId;
@@ -7767,6 +7956,7 @@ function aggregateCandidate(opts) {
         recordGroundingHit(ourGroundingTally, g, domain, snap.provider);
         continue;
       }
+      citedSurfaceTally.set(domain, (citedSurfaceTally.get(domain) ?? 0) + 1);
       if (!opts.competitorSet.has(domain)) continue;
       recordGroundingHit(competitorGroundingTally, g, domain, snap.provider);
     }
@@ -7785,6 +7975,7 @@ function aggregateCandidate(opts) {
     recentMissRate,
     ourGroundingUrls: Array.from(ourGroundingTally.values()),
     competitorGroundingUrls: Array.from(competitorGroundingTally.values()),
+    citedSurfaceDomains: Array.from(citedSurfaceTally.entries()).map(([domain, citationCount]) => ({ domain, citationCount })),
     runsOfHistory: new Set(opts.snapshots.map((s) => s.runId)).size
   };
 }
@@ -7820,6 +8011,7 @@ function emptyCandidate(query) {
     recentMissRate: 0,
     ourGroundingUrls: [],
     competitorGroundingUrls: [],
+    citedSurfaceDomains: [],
     runsOfHistory: 0
   };
 }
@@ -7886,6 +8078,17 @@ function formatExplanationRow(row) {
     generatedAt: row.generatedAt
   };
 }
+function formatBriefRow(row) {
+  return {
+    targetRef: row.targetRef,
+    promptVersion: row.promptVersion,
+    provider: row.provider,
+    model: row.model,
+    brief: row.brief,
+    costMillicents: row.costMillicents,
+    generatedAt: row.generatedAt
+  };
+}
 function findRecommendationByRef(db, project, targetRef) {
   const input = loadOrchestratorInput(db, project);
   const rows = buildContentTargetRows(input);
@@ -7896,6 +8099,10 @@ async function contentRoutes(app, opts = {}) {
     const project = resolveProject(app.db, request.params.name);
     const includeInProgress = request.query["include-in-progress"] === "true";
     const limit = parseLimitParam(request.query.limit);
+    if (request.query["surface-class"] !== void 0) {
+      throw validationError('"surface-class" was renamed to "winnability-class"');
+    }
+    const winnabilityClassFilter = parseWinnabilityClassFilter(request.query["winnability-class"], request.query.ownable);
     const input = loadOrchestratorInput(app.db, project);
     let rows = buildContentTargetRows(input);
     if (!includeInProgress) {
@@ -7905,6 +8112,10 @@ async function contentRoutes(app, opts = {}) {
     if (dismissed.size > 0) {
       rows = rows.filter((r) => !dismissed.has(r.targetRef));
     }
+    if (winnabilityClassFilter) {
+      rows = rows.filter((r) => r.winnabilityClass === winnabilityClassFilter);
+    }
+    rows = [...rows].sort((a, b) => winnabilityClassRank(a.winnabilityClass) - winnabilityClassRank(b.winnabilityClass));
     if (limit !== void 0) {
       rows = rows.slice(0, limit);
     }
@@ -8065,6 +8276,113 @@ async function contentRoutes(app, opts = {}) {
     if (!row) throw notFound("recommendationExplanation", targetRef);
     return reply.send(formatExplanationRow(row));
   });
+  app.get("/projects/:name/content/recommendations/:targetRef/brief", async (request, reply) => {
+    const project = resolveProject(app.db, request.params.name);
+    const { targetRef } = request.params;
+    const recommendation = findRecommendationByRef(app.db, project, targetRef);
+    if (!recommendation) {
+      throw notFound("contentRecommendation", targetRef);
+    }
+    if (recommendation.winnabilityClass === WinnabilityClasses.ceded) {
+      throw validationError(
+        `Cannot return a brief for "${recommendation.query}": its cited surface is now ceded (dominated by aggregators/editorial).`
+      );
+    }
+    const row = lookupCachedBrief(app.db, project.id, targetRef, opts.briefPromptVersion);
+    if (!row) throw notFound("recommendationBrief", request.params.targetRef);
+    return reply.send(formatBriefRow(row));
+  });
+  app.post("/projects/:name/content/recommendations/:targetRef/brief", async (request, reply) => {
+    const project = resolveProject(app.db, request.params.name);
+    const synthesizer = opts.briefContentRecommendation;
+    if (!synthesizer) {
+      throw providerError(
+        "No AI provider configured for content briefs. Configure a provider via `canonry settings` or set an API key env var (ANTHROPIC_API_KEY, OPENAI_API_KEY, GEMINI_API_KEY, ZAI_API_KEY)."
+      );
+    }
+    const parsed = recommendationExplainRequestSchema.safeParse(request.body ?? {});
+    if (!parsed.success) {
+      throw validationError(parsed.error.issues[0]?.message ?? "Invalid request body.");
+    }
+    const body = parsed.data;
+    const { targetRef } = request.params;
+    const recommendation = findRecommendationByRef(app.db, project, targetRef);
+    if (!recommendation) {
+      throw notFound("contentRecommendation", targetRef);
+    }
+    if (recommendation.winnabilityClass === WinnabilityClasses.ceded) {
+      throw validationError(
+        `Cannot synthesize a brief for "${recommendation.query}": its cited surface is ceded (dominated by aggregators/editorial). This is not a query first-party content can realistically win.`
+      );
+    }
+    if (!body.forceRefresh) {
+      const cached = lookupCachedBrief(app.db, project.id, targetRef, opts.briefPromptVersion);
+      if (cached) return reply.send(formatBriefRow(cached));
+    }
+    const result = await synthesizer({
+      projectId: project.id,
+      projectName: project.name,
+      canonicalDomain: project.canonicalDomain,
+      recommendation,
+      providerOverride: body.provider,
+      modelOverride: body.model
+    });
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    app.db.insert(recommendationBriefs).values({
+      id: crypto11.randomUUID(),
+      projectId: project.id,
+      targetRef,
+      promptVersion: result.promptVersion,
+      provider: result.provider,
+      model: result.model,
+      brief: result.brief,
+      costMillicents: result.costMillicents,
+      generatedAt: now
+    }).onConflictDoUpdate({
+      target: [
+        recommendationBriefs.projectId,
+        recommendationBriefs.targetRef,
+        recommendationBriefs.promptVersion
+      ],
+      set: {
+        provider: result.provider,
+        model: result.model,
+        brief: result.brief,
+        costMillicents: result.costMillicents,
+        generatedAt: now
+      }
+    }).run();
+    const row = app.db.select().from(recommendationBriefs).where(and8(
+      eq13(recommendationBriefs.projectId, project.id),
+      eq13(recommendationBriefs.targetRef, targetRef),
+      eq13(recommendationBriefs.promptVersion, result.promptVersion)
+    )).get();
+    if (!row) throw notFound("recommendationBrief", targetRef);
+    return reply.send(formatBriefRow(row));
+  });
+  app.get("/projects/:name/content/domain-classifications", async (request) => {
+    const project = resolveProject(app.db, request.params.name);
+    const rows = app.db.select().from(domainClassifications).where(eq13(domainClassifications.projectId, project.id)).orderBy(desc6(domainClassifications.hits)).all();
+    const response = {
+      classifications: rows.map((r) => ({
+        domain: r.domain,
+        competitorType: r.competitorType,
+        hits: r.hits,
+        updatedAt: r.updatedAt
+      }))
+    };
+    return response;
+  });
+}
+function lookupCachedBrief(db, projectId, targetRef, promptVersion) {
+  const conditions = [
+    eq13(recommendationBriefs.projectId, projectId),
+    eq13(recommendationBriefs.targetRef, targetRef)
+  ];
+  if (promptVersion !== void 0) {
+    conditions.push(eq13(recommendationBriefs.promptVersion, promptVersion));
+  }
+  return db.select().from(recommendationBriefs).where(and8(...conditions)).orderBy(desc6(recommendationBriefs.generatedAt)).limit(1).get();
 }
 function parseLimitParam(raw) {
   if (raw === void 0) return void 0;
@@ -8074,6 +8392,20 @@ function parseLimitParam(raw) {
   }
   return parsed;
 }
+function parseWinnabilityClassFilter(raw, ownable) {
+  if (raw !== void 0) {
+    const parsed = winnabilityClassSchema.safeParse(raw);
+    if (!parsed.success) {
+      throw validationError('"winnability-class" must be "ownable" or "ceded"');
+    }
+    return parsed.data;
+  }
+  if (ownable === "true") return WinnabilityClasses.ownable;
+  return void 0;
+}
+function winnabilityClassRank(winnabilityClass) {
+  return winnabilityClass === WinnabilityClasses.ownable ? 0 : 1;
+}
 
 // ../api-routes/src/report-renderer.ts
 var COLORS = {
@@ -9995,9 +10327,11 @@ function renderOpportunities(report) {
     const ourPage = o.ourBestPage ? `<a href="${safeHref(absolutizeProjectUrl(o.ourBestPage.url, canonical))}" target="_blank" rel="noopener noreferrer">${escapeHtml(o.ourBestPage.url)}</a>` : '<span class="cell-not-cited">No page yet</span>';
     const winning = o.winningCompetitor ? `<a href="${safeHref(o.winningCompetitor.url)}" target="_blank" rel="noopener noreferrer">${escapeHtml(o.winningCompetitor.domain)}</a>` : '<span class="cell-not-cited">\u2014</span>';
     const drivers = o.drivers.length > 0 ? `<ul class="driver-list">${o.drivers.map((d) => `<li>${escapeHtml(d)}</li>`).join("")}</ul>` : '<span class="cell-not-cited">No driver signal yet</span>';
+    const surfaceTone = o.winnabilityClass === "ceded" ? "tone-caution" : "tone-neutral";
     return `<tr>
       <td>${escapeHtml(o.query)}</td>
       <td><span class="badge tone-neutral">${escapeHtml(contentActionLabel(o.action))}</span></td>
+      <td><span class="badge ${surfaceTone}">${escapeHtml(winnabilityClassLabel(o.winnabilityClass))}</span></td>
       <td class="numeric" title="Opportunity score (0\u2013100)">${Math.round(o.score)}</td>
       <td>${drivers}</td>
       <td>${ourPage}</td>
@@ -10010,10 +10344,10 @@ function renderOpportunities(report) {
       id: "content-opportunities",
       eyebrow: "Section 14",
       title: "Content Opportunities",
-      intro: "Queries where content work has the clearest path to more AI citations. Opportunity score is 0\u2013100, higher = stronger."
+      intro: "Queries where content work has the clearest path to more AI citations. Opportunity score is 0\u2013100, higher = stronger. Winnability flags whether the cited surface is ownable or ceded to aggregators/editorial."
     },
     `${highlights}<table class="report-table">
-      <thead><tr><th>Query</th><th>Action</th><th class="numeric" title="Opportunity score (0\u2013100)">Score</th><th>Why</th><th>Our page</th><th>Winning competitor</th><th>Confidence</th></tr></thead>
+      <thead><tr><th>Query</th><th>Action</th><th>Winnability</th><th class="numeric" title="Opportunity score (0\u2013100)">Score</th><th>Why</th><th>Our page</th><th>Winning competitor</th><th>Confidence</th></tr></thead>
       <tbody>${rows}</tbody>
     </table>`
   );
@@ -10241,7 +10575,7 @@ function renderClientEvidenceSummary(report) {
       <ul class="client-opportunity-list">
         ${opportunities.map((o) => `<li>
           <div class="op-query">${escapeHtml(o.query)}</div>
-          <div class="op-action">${escapeHtml(contentActionLabel(o.action))}</div>
+          <div class="op-action">${escapeHtml(contentActionLabel(o.action))}${o.winnabilityClass === "ceded" ? ' <span class="badge tone-caution">Ceded surface</span>' : ""}</div>
         </li>`).join("")}
       </ul>
     </div>`);
@@ -12618,6 +12952,8 @@ var SCHEMA_TABLE = {
   ContentTargetsResponseDto: contentTargetsResponseDtoSchema,
   CreateApiKeyRequest: createApiKeyRequestSchema,
   CreatedApiKeyDto: createdApiKeyDtoSchema,
+  DomainClassificationsResponseDto: domainClassificationsResponseDtoSchema,
+  RecommendationBriefDto: recommendationBriefDtoSchema,
   RecommendationExplanationDto: recommendationExplanationDtoSchema,
   DiscoveryPromotePreview: discoveryPromotePreviewSchema,
   DiscoveryPromoteResult: discoveryPromoteResultSchema,
@@ -12664,6 +13000,7 @@ var SCHEMA_TABLE = {
   SnapshotDiffResponse: snapshotDiffResponseSchema,
   SnapshotListResponse: snapshotListResponseSchema,
   SnapshotReportDto: snapshotReportSchema,
+  SourceBreakdownDto: sourceBreakdownDtoSchema,
   TrafficBackfillResponse: trafficBackfillResponseSchema,
   TrafficEventsResponse: trafficEventsResponseSchema,
   TrafficSourceDetailDto: trafficSourceDetailDtoSchema,
@@ -13616,10 +13953,9 @@ var routeCatalog = [
     path: "/api/v1/projects/{name}/analytics/sources",
     summary: "Get source origin analytics",
     tags: ["analytics"],
-    parameters: [nameParameter, analyticsWindowParameter],
+    parameters: [nameParameter, analyticsWindowParameter, limitQueryParameter],
     responses: {
-      // TODO: Add `SourceBreakdownDto` Zod schema in contracts.
-      200: rawJsonResponse("Source breakdown returned.", looseObjectSchema),
+      200: jsonResponse("Source breakdown returned.", "SourceBreakdownDto"),
       404: errorResponse("Project not found.")
     }
   },
@@ -15529,16 +15865,18 @@ var routeCatalog = [
     method: "get",
     path: "/api/v1/projects/{name}/content/targets",
     summary: "Ranked, action-typed content opportunities",
-    description: "Returns the canonical opportunity list. Each row is `{query, action, ourBestPage?, winningCompetitor?, score, scoreBreakdown, drivers[], demandSource, actionConfidence, existingAction?}`. Hides rows with in-progress actions by default; pass `?include-in-progress=true` to include them annotated.",
+    description: "Returns the canonical opportunity list. Each row is `{query, action, ourBestPage?, winningCompetitor?, score, scoreBreakdown, drivers[], demandSource, actionConfidence, existingAction?, winnabilityClass, winnability?}`. `winnabilityClass` is the deterministic winnability gate (`ownable` worth a brief, `ceded` an aggregator/editorial head term to skip). Ownable rows sort first. Hides rows with in-progress actions by default; pass `?include-in-progress=true` to include them annotated.",
     tags: ["content"],
     parameters: [
       nameParameter,
       { name: "limit", in: "query", description: "Max rows returned.", schema: stringSchema },
-      { name: "include-in-progress", in: "query", description: "Include rows with in-flight tracked actions.", schema: stringSchema }
+      { name: "include-in-progress", in: "query", description: "Include rows with in-flight tracked actions.", schema: stringSchema },
+      { name: "winnability-class", in: "query", description: 'Filter by winnability: "ownable" or "ceded".', schema: stringSchema },
+      { name: "ownable", in: "query", description: 'Convenience alias for winnability-class=ownable when "true".', schema: stringSchema }
     ],
     responses: {
       200: jsonResponse("Targets returned.", "ContentTargetsResponseDto"),
-      400: errorResponse("Invalid limit."),
+      400: errorResponse("Invalid limit or winnability-class."),
       404: errorResponse("Project not found.")
     }
   },
@@ -15645,6 +15983,65 @@ var routeCatalog = [
       503: errorResponse("No AI provider configured for this project.")
     }
   },
+  {
+    method: "get",
+    path: "/api/v1/projects/{name}/content/recommendations/{targetRef}/brief",
+    summary: "Get cached structured content brief for a recommendation",
+    description: "Returns the cached structured brief (`{targetQuery, winnabilityClass, angle, whyWinnable, schemaHookup, controllableSurfaceRationale}`) for one content recommendation at the current prompt version, or 404 if none exists. Cache-only read from the dedicated recommendation_briefs table \u2014 never collides with the prose explanation. Use `POST /brief` to synthesize one.",
+    tags: ["content"],
+    parameters: [
+      nameParameter,
+      { name: "targetRef", in: "path", required: true, description: "Stable hash from ContentTargetRowDto.targetRef.", schema: stringSchema }
+    ],
+    responses: {
+      200: jsonResponse("Cached brief.", "RecommendationBriefDto"),
+      404: errorResponse("No cached brief for this targetRef yet.")
+    }
+  },
+  {
+    method: "post",
+    path: "/api/v1/projects/{name}/content/recommendations/{targetRef}/brief",
+    summary: "Synthesize (or fetch cached) a structured content brief",
+    description: "Synthesizes a STRUCTURED content brief for one recommendation, reusing the `analyze` capability tier. GATED to `ownable` targets \u2014 a `ceded` head term (cited surface dominated by aggregators/editorial) is rejected with 400 before any LLM call. Cached per (project, targetRef, promptVersion) in a dedicated table; repeat calls without `forceRefresh` return the cached row free. Pass `provider`/`model` to override.",
+    tags: ["content"],
+    parameters: [
+      nameParameter,
+      { name: "targetRef", in: "path", required: true, description: "Stable hash from ContentTargetRowDto.targetRef.", schema: stringSchema }
+    ],
+    requestBody: {
+      required: false,
+      content: {
+        "application/json": {
+          schema: {
+            type: "object",
+            properties: {
+              provider: stringSchema,
+              model: stringSchema,
+              forceRefresh: { type: "boolean" }
+            }
+          }
+        }
+      }
+    },
+    responses: {
+      200: jsonResponse("Brief synthesized or returned from cache.", "RecommendationBriefDto"),
+      400: errorResponse("Invalid request body, unknown provider, or target is ceded (not winnable)."),
+      404: errorResponse("Project not found or targetRef does not match any current recommendation."),
+      503: errorResponse("No AI provider configured for this project.")
+    }
+  },
+  {
+    method: "get",
+    path: "/api/v1/projects/{name}/content/domain-classifications",
+    summary: "List per-domain cited-surface classifications",
+    description: "Returns every cited-surface domain classification discovery has produced for the project (`{domain, competitorType, hits, updatedAt}`), ranked by recurrence. This is the read surface behind the winnabilityClass winnability gate; running discovery improves coverage.",
+    tags: ["content"],
+    parameters: [nameParameter],
+    responses: {
+      200: jsonResponse("Classifications returned.", "DomainClassificationsResponseDto"),
+      404: errorResponse("Project not found.")
+    }
+  },
   {
     method: "get",
     path: "/api/v1/projects/{name}/content/sources",
@@ -27326,10 +27723,11 @@ async function resolveRetainedStart(options, unservableStartMs, endMs) {
 async function drainVercelTrafficEvents(options) {
   const startMs = toMs(options.startDate);
   const endMs = toMs(options.endDate);
+  const now = options.now ?? (() => Date.now());
   const events = [];
   const seenEventIds = /* @__PURE__ */ new Set();
   if (endMs <= startMs) {
-    return { events, subWindowCount: 0, effectiveStartMs: startMs, retentionClamped: false, truncatedSliceCount: 0, truncatedSliceStartsMs: [] };
+    return { events, subWindowCount: 0, effectiveStartMs: startMs, retentionClamped: false, truncatedSliceCount: 0, truncatedSliceStartsMs: [], drainedThroughMs: startMs, deadlineReached: false };
   }
   let cursorMs = startMs;
   let spanMs = endMs - startMs;
@@ -27340,8 +27738,13 @@ async function drainVercelTrafficEvents(options) {
   let floorSpanProbeCountdown = 0;
   let floorPageBudgetCountdown = 0;
   let truncatedSliceCount = 0;
+  let deadlineReached = false;
   const truncatedSliceStartsMs = [];
   while (cursorMs < endMs) {
+    if (options.deadlineMs !== void 0 && now() >= options.deadlineMs) {
+      deadlineReached = true;
+      break;
+    }
     if (subWindowCount >= options.maxSubWindows) {
       throw new Error(
         `Vercel window not drained within ${options.maxSubWindows} sub-windows \u2014 narrow the time range`
@@ -27428,7 +27831,7 @@ async function drainVercelTrafficEvents(options) {
       }
     }
   }
-  return { events, subWindowCount, effectiveStartMs, retentionClamped, truncatedSliceCount, truncatedSliceStartsMs };
+  return { events, subWindowCount, effectiveStartMs, retentionClamped, truncatedSliceCount, truncatedSliceStartsMs, drainedThroughMs: cursorMs, deadlineReached };
 }
 
 // ../api-routes/src/traffic.ts
@@ -27440,6 +27843,8 @@ var DEFAULT_WP_PAGE_SIZE = 500;
 var DEFAULT_WP_MAX_PAGES = 20;
 var DEFAULT_VERCEL_MAX_PAGES = 50;
 var VERCEL_MAX_SUB_WINDOWS = 5e3;
+var VERCEL_MAX_SYNC_WINDOW_MS = 24 * 60 * 6e4;
+var DEFAULT_VERCEL_SYNC_DEADLINE_MS = 4 * 6e4;
 var VERCEL_BACKFILL_CHUNK_MS = 60 * 6e4;
 var MAX_TRACKED_EVENT_IDS = 1e3;
 var DEFAULT_BACKFILL_DAYS = 30;
@@ -27687,6 +28092,7 @@ async function trafficRoutes(app, opts) {
     }
   }
   const vercelMaxPages = opts.defaultVercelMaxPages ?? DEFAULT_VERCEL_MAX_PAGES;
+  const vercelSyncDeadlineMs = opts.vercelSyncDeadlineMs ?? DEFAULT_VERCEL_SYNC_DEADLINE_MS;
   const syncWindowMinutes = opts.defaultSyncWindowMinutes ?? DEFAULT_SYNC_WINDOW_MINUTES;
   const pageSize = opts.defaultPageSize ?? DEFAULT_PAGE_SIZE3;
   const maxPages = opts.defaultMaxPages ?? DEFAULT_MAX_PAGES4;
@@ -28038,6 +28444,7 @@ async function trafficRoutes(app, opts) {
     let allEvents;
     let nextCursor;
     let auditAction;
+    let effectiveWindowEnd = windowEnd;
     if (sourceRow.sourceType === TrafficSourceTypes["cloud-run"]) {
       auditAction = "traffic.cloud-run.synced";
       const credentialStore = opts.cloudRunCredentialStore;
@@ -28163,9 +28570,19 @@ async function trafficRoutes(app, opts) {
       const windowMinutes = Number.isFinite(requestedMinutes) && requestedMinutes && requestedMinutes > 0 ? Math.floor(requestedMinutes) : syncWindowMinutes;
       const requestedStartMs = windowEnd.getTime() - windowMinutes * 6e4;
       const lastSyncedMs = sourceRow.lastSyncedAt ? new Date(sourceRow.lastSyncedAt).getTime() : Number.NEGATIVE_INFINITY;
-      windowStart = new Date(
-        Math.min(windowEnd.getTime(), Math.max(requestedStartMs, lastSyncedMs))
-      );
+      const clampedStartMs = Math.min(windowEnd.getTime(), Math.max(requestedStartMs, lastSyncedMs));
+      const cappedStartMs = Math.max(clampedStartMs, windowEnd.getTime() - VERCEL_MAX_SYNC_WINDOW_MS);
+      if (cappedStartMs > clampedStartMs) {
+        request.log.warn(
+          {
+            sourceId: sourceRow.id,
+            requestedStart: new Date(clampedStartMs).toISOString(),
+            cappedStart: new Date(cappedStartMs).toISOString()
+          },
+          "Vercel sync window exceeded the max single-sync span; clamped the start forward (older traffic skipped \u2014 run a backfill to recover it)"
+        );
+      }
+      windowStart = new Date(cappedStartMs);
       try {
         const drained = await drainVercelTrafficEvents({
           pull: pullVercelEvents,
@@ -28176,11 +28593,31 @@ async function trafficRoutes(app, opts) {
           startDate: windowStart.getTime(),
           endDate: windowEnd.getTime(),
           pagesPerSubWindow: vercelMaxPages,
-          maxSubWindows: VERCEL_MAX_SUB_WINDOWS
+          maxSubWindows: VERCEL_MAX_SUB_WINDOWS,
+          // Bound the drain's wall-clock so a dense/slow window can't run for
+          // many minutes. On hit the drain stops and reports how far it got.
+          deadlineMs: syncStartedAtMs + vercelSyncDeadlineMs
         });
         if (drained.retentionClamped) {
           throw vercelRetentionClampError(windowStart.getTime(), drained.effectiveStartMs);
         }
+        if (drained.deadlineReached) {
+          if (drained.drainedThroughMs <= windowStart.getTime()) {
+            throw new Error(
+              `sync exceeded its ${vercelSyncDeadlineMs}ms drain budget without completing any sub-window (request-logs slow or unavailable)`
+            );
+          }
+          effectiveWindowEnd = new Date(drained.drainedThroughMs);
+          request.log.warn(
+            {
+              sourceId: sourceRow.id,
+              drainedThrough: effectiveWindowEnd.toISOString(),
+              requestedEnd: windowEnd.toISOString(),
+              subWindows: drained.subWindowCount
+            },
+            "Vercel drain hit its time budget; committing the partial window and advancing to it \u2014 next sync resumes from here"
+          );
+        }
         if (drained.truncatedSliceCount > 0) {
           request.log.warn(
             {
@@ -28364,11 +28801,13 @@ async function trafficRoutes(app, opts) {
       }
       const sourceUpdate = {
         status: TrafficSourceStatuses.connected,
-        // Advance to windowEnd, not finishedAt — events arriving at the
-        // source between windowEnd and finishedAt aren't in this pull's
-        // range. If we stored finishedAt, the next sync's clamp would skip
-        // past them and they'd be lost.
-        lastSyncedAt: windowEnd.toISOString(),
+        // Advance to effectiveWindowEnd, not finishedAt — events arriving at the
+        // source between the window end and finishedAt aren't in this pull's
+        // range. If we stored finishedAt, the next sync's clamp would skip past
+        // them and they'd be lost. effectiveWindowEnd equals windowEnd on a full
+        // sync; for a Vercel drain that stopped at its deadline it is the partial
+        // boundary, so the next sync resumes exactly where this one left off.
+        lastSyncedAt: effectiveWindowEnd.toISOString(),
         lastError: null,
         lastEventIds: nextEventIds,
         updatedAt: finishedAt
@@ -28421,7 +28860,9 @@ async function trafficRoutes(app, opts) {
       aiReferralBucketRows,
       sampleRows,
       windowStart: windowStart.toISOString(),
-      windowEnd: windowEnd.toISOString()
+      // The window actually synced: equals windowEnd on a full sync, or the
+      // partial boundary when a Vercel drain stopped at its deadline.
+      windowEnd: effectiveWindowEnd.toISOString()
     };
     return response;
   });
@@ -29170,6 +29611,104 @@ var BING_AUTH_CHECKS = [
   }
 ];
 
+// ../api-routes/src/doctor/checks/content.ts
+import { eq as eq26 } from "drizzle-orm";
+var WINNABILITY_COVERAGE_WARN_THRESHOLD = 0.8;
+var UNCLASSIFIED_DOMAIN_SAMPLE_LIMIT = 10;
+function skippedNoProject() {
+  return {
+    status: CheckStatuses.skipped,
+    code: "content.winnability.no-project",
+    summary: "Project context required for content winnability checks.",
+    remediation: "Run `canonry doctor --project <name>` to scope this check to a project."
+  };
+}
+function loadProject(ctx) {
+  if (!ctx.project) return null;
+  return ctx.db.select().from(projects).where(eq26(projects.id, ctx.project.id)).get() ?? null;
+}
+function percent(value) {
+  return Math.round(value * 100);
+}
+var winnabilityCoverageCheck = {
+  id: "content.winnability.coverage",
+  category: CheckCategories.integrations,
+  scope: CheckScopes.project,
+  title: "Content winnability classification coverage",
+  run: (ctx) => {
+    if (!ctx.project) return skippedNoProject();
+    const project = loadProject(ctx);
+    if (!project) {
+      return {
+        status: CheckStatuses.fail,
+        code: "content.winnability.project-missing",
+        summary: "Project row disappeared before the content winnability check could run.",
+        remediation: "Re-run `canonry doctor --project <name>`; if this persists, inspect the local database."
+      };
+    }
+    const input = loadOrchestratorInput(ctx.db, project);
+    const citationCounts = /* @__PURE__ */ new Map();
+    for (const candidate of input.candidateQueries) {
+      for (const cited of candidate.citedSurfaceDomains) {
+        citationCounts.set(cited.domain, (citationCounts.get(cited.domain) ?? 0) + cited.citationCount);
+      }
+    }
+    const citedDomains = [...citationCounts.keys()].sort();
+    if (citedDomains.length === 0) {
+      return {
+        status: CheckStatuses.skipped,
+        code: "content.winnability.no-cited-surface",
+        summary: "No non-owned cited-surface domains in recent content evidence, so the winnability gate has nothing to classify yet.",
+        remediation: `Run \`canonry run ${ctx.project.name}\` to capture fresh answer-engine citations before checking discovery coverage.`,
+        details: {
+          citedSurfaceDomainCount: 0,
+          classifiedDomainCount: input.domainClasses.size
+        }
+      };
+    }
+    const coveredDomains = citedDomains.filter((domain) => input.domainClasses.has(domain));
+    const unclassifiedDomains = citedDomains.filter((domain) => !input.domainClasses.has(domain));
+    const coverage = coveredDomains.length / citedDomains.length;
+    const details = {
+      citedSurfaceDomainCount: citedDomains.length,
+      classifiedDomainCount: input.domainClasses.size,
+      coveredDomainCount: coveredDomains.length,
+      coverage,
+      threshold: WINNABILITY_COVERAGE_WARN_THRESHOLD,
+      unclassifiedDomains: unclassifiedDomains.slice(0, UNCLASSIFIED_DOMAIN_SAMPLE_LIMIT)
+    };
+    if (coveredDomains.length === 0) {
+      return {
+        status: CheckStatuses.warn,
+        code: "content.winnability.no-classifications",
+        summary: `0 of ${citedDomains.length} cited-surface domain(s) have discovery classifications; the winnability gate is failing open.`,
+        remediation: `Run \`canonry discover run ${ctx.project.name} --wait\` to classify cited domains before trusting ownable/ceded content targets.`,
+        details
+      };
+    }
+    if (coverage < WINNABILITY_COVERAGE_WARN_THRESHOLD) {
+      return {
+        status: CheckStatuses.warn,
+        code: "content.winnability.low-coverage",
+        summary: `${coveredDomains.length} of ${citedDomains.length} cited-surface domain(s) classified (${percent(coverage)}%); the winnability gate may miss ceded surfaces.`,
+        remediation: `Run \`canonry discover run ${ctx.project.name} --wait\` to raise classification coverage before relying on ownable/ceded content targets.`,
+        details
+      };
+    }
+    return {
+      status: CheckStatuses.ok,
+      code: "content.winnability.covered",
+      summary: `${coveredDomains.length} of ${citedDomains.length} cited-surface domain(s) classified (${percent(coverage)}%); the winnability gate is active.`,
+      remediation: null,
+      details
+    };
+  }
+};
+var CONTENT_CHECKS = [winnabilityCoverageCheck];
+var CONTENT_CHECK_BY_ID = Object.fromEntries(
+  CONTENT_CHECKS.map((check) => [check.id, check])
+);
+
 // ../api-routes/src/doctor/checks/ga-auth.ts
 async function checkServiceAccount(conn) {
   if (!conn.propertyId) {
@@ -29312,10 +29851,10 @@ var ga4ConnectionCheck = {
 var GA_AUTH_CHECKS = [ga4ConnectionCheck];
 
 // ../api-routes/src/doctor/checks/gbp-auth.ts
-import { and as and20, eq as eq26 } from "drizzle-orm";
+import { and as and20, eq as eq27 } from "drizzle-orm";
 var RECENT_SYNC_WARN_DAYS = 7;
 var RECENT_SYNC_FAIL_DAYS = 30;
-function skippedNoProject() {
+function skippedNoProject2() {
   return {
     status: CheckStatuses.skipped,
     code: "gbp.auth.no-project",
@@ -29332,7 +29871,7 @@ function storeUnavailable() {
   };
 }
 async function resolveGbpToken(ctx) {
-  if (!ctx.project) return { ok: false, output: skippedNoProject() };
+  if (!ctx.project) return { ok: false, output: skippedNoProject2() };
   const store = ctx.googleConnectionStore;
   if (!store) return { ok: false, output: storeUnavailable() };
   const auth = ctx.getGoogleAuthConfig?.() ?? {};
@@ -29410,7 +29949,7 @@ var scopesCheck = {
   scope: CheckScopes.project,
   title: "GBP granted scopes",
   run: async (ctx) => {
-    if (!ctx.project) return skippedNoProject();
+    if (!ctx.project) return skippedNoProject2();
     const store = ctx.googleConnectionStore;
     if (!store) return storeUnavailable();
     const conn = store.getConnection(ctx.project.canonicalDomain, "gbp");
@@ -29447,7 +29986,7 @@ var accountAccessCheck = {
   scope: CheckScopes.project,
   title: "GBP account access",
   run: async (ctx) => {
-    if (!ctx.project) return skippedNoProject();
+    if (!ctx.project) return skippedNoProject2();
     const store = ctx.googleConnectionStore;
     if (!store) return storeUnavailable();
     const conn = store.getConnection(ctx.project.canonicalDomain, "gbp");
@@ -29544,8 +30083,8 @@ var recentSyncCheck = {
   scope: CheckScopes.project,
   title: "GBP recent sync",
   run: (ctx) => {
-    if (!ctx.project) return skippedNoProject();
-    const selected = ctx.db.select({ locationName: gbpLocations.locationName, syncedAt: gbpLocations.syncedAt }).from(gbpLocations).where(and20(eq26(gbpLocations.projectId, ctx.project.id), eq26(gbpLocations.selected, true))).all();
+    if (!ctx.project) return skippedNoProject2();
+    const selected = ctx.db.select({ locationName: gbpLocations.locationName, syncedAt: gbpLocations.syncedAt }).from(gbpLocations).where(and20(eq27(gbpLocations.projectId, ctx.project.id), eq27(gbpLocations.selected, true))).all();
     if (selected.length === 0) {
       return {
         status: CheckStatuses.skipped,
@@ -29605,7 +30144,7 @@ var GBP_AUTH_CHECK_BY_ID = Object.fromEntries(
 );
 
 // ../api-routes/src/doctor/checks/places.ts
-import { eq as eq27 } from "drizzle-orm";
+import { eq as eq28 } from "drizzle-orm";
 var apiKeyCheck = {
   id: "gbp.places.api-key",
   category: CheckCategories.auth,
@@ -29650,7 +30189,7 @@ var apiKeyCheck = {
         details: { tier: cfg.tier }
       };
     }
-    const rows = ctx.db.select({ placeId: gbpLocations.placeId, selected: gbpLocations.selected }).from(gbpLocations).where(eq27(gbpLocations.projectId, ctx.project.id)).all();
+    const rows = ctx.db.select({ placeId: gbpLocations.placeId, selected: gbpLocations.selected }).from(gbpLocations).where(eq28(gbpLocations.projectId, ctx.project.id)).all();
     const selected = rows.filter((r) => r.selected);
     const locationsWithPlaceId = selected.filter((r) => Boolean(r.placeId)).length;
     const details = {
@@ -29686,7 +30225,7 @@ var PLACES_CHECK_BY_ID = Object.fromEntries(
 var REQUIRED_GSC_SCOPES = [GSC_SCOPE, INDEXING_SCOPE];
 async function resolveAccessToken(ctx) {
   if (!ctx.project) {
-    return { ok: false, output: skippedNoProject2() };
+    return { ok: false, output: skippedNoProject3() };
   }
   const store = ctx.googleConnectionStore;
   if (!store) {
@@ -29753,7 +30292,7 @@ async function resolveAccessToken(ctx) {
     };
   }
 }
-function skippedNoProject2() {
+function skippedNoProject3() {
   return {
     status: CheckStatuses.skipped,
     code: "google.auth.no-project",
@@ -29783,7 +30322,7 @@ var propertyAccessCheck = {
   scope: CheckScopes.project,
   title: "GSC property access",
   run: async (ctx) => {
-    if (!ctx.project) return skippedNoProject2();
+    if (!ctx.project) return skippedNoProject3();
     const store = ctx.googleConnectionStore;
     if (!store) {
       return {
@@ -29884,7 +30423,7 @@ var redirectUriCheck = {
   scope: CheckScopes.project,
   title: "OAuth redirect URI",
   run: async (ctx) => {
-    if (!ctx.project) return skippedNoProject2();
+    if (!ctx.project) return skippedNoProject3();
     const auth = ctx.getGoogleAuthConfig?.() ?? {};
     if (!auth.clientId || !auth.clientSecret) {
       return {
@@ -29938,7 +30477,7 @@ var scopesCheck2 = {
   scope: CheckScopes.project,
   title: "GSC granted scopes",
   run: async (ctx) => {
-    if (!ctx.project) return skippedNoProject2();
+    if (!ctx.project) return skippedNoProject3();
     const store = ctx.googleConnectionStore;
     if (!store) {
       return {
@@ -30101,10 +30640,10 @@ var RUNTIME_STATE_CHECKS = [
 ];
 
 // ../api-routes/src/doctor/checks/traffic-source.ts
-import { and as and21, eq as eq28, gte as gte4, ne as ne4, sql as sql12 } from "drizzle-orm";
+import { and as and21, eq as eq29, gte as gte4, ne as ne4, sql as sql12 } from "drizzle-orm";
 var RECENT_DATA_WARN_DAYS = 7;
 var RECENT_DATA_FAIL_DAYS = 30;
-function skippedNoProject3() {
+function skippedNoProject4() {
   return {
     status: CheckStatuses.skipped,
     code: "traffic.no-project",
@@ -30116,7 +30655,7 @@ function loadProbes(ctx) {
   if (!ctx.project) return [];
   const rows = ctx.db.select().from(trafficSources).where(
     and21(
-      eq28(trafficSources.projectId, ctx.project.id),
+      eq29(trafficSources.projectId, ctx.project.id),
       ne4(trafficSources.status, TrafficSourceStatuses.archived)
     )
   ).all();
@@ -30138,7 +30677,7 @@ var sourceConnectedCheck = {
   scope: CheckScopes.project,
   title: "Traffic source connected",
   run: (ctx) => {
-    if (!ctx.project) return skippedNoProject3();
+    if (!ctx.project) return skippedNoProject4();
     const sources = loadProbes(ctx);
     if (sources.length === 0) {
       return {
@@ -30182,7 +30721,7 @@ var recentDataCheck = {
   scope: CheckScopes.project,
   title: "Traffic source recent data",
   run: (ctx) => {
-    if (!ctx.project) return skippedNoProject3();
+    if (!ctx.project) return skippedNoProject4();
     const sources = loadProbes(ctx);
     if (sources.length === 0) {
       return {
@@ -30197,7 +30736,7 @@ var recentDataCheck = {
     const recentCrawlers = Number(
       ctx.db.select({ total: sql12`COALESCE(SUM(${crawlerEventsHourly.hits}), 0)` }).from(crawlerEventsHourly).where(
         and21(
-          eq28(crawlerEventsHourly.projectId, ctx.project.id),
+          eq29(crawlerEventsHourly.projectId, ctx.project.id),
           gte4(crawlerEventsHourly.tsHour, warnCutoff)
         )
       ).get()?.total ?? 0
@@ -30205,7 +30744,7 @@ var recentDataCheck = {
     const recentReferrals = Number(
       ctx.db.select({ total: sql12`COALESCE(SUM(${aiReferralEventsHourly.sessionsOrHits}), 0)` }).from(aiReferralEventsHourly).where(
         and21(
-          eq28(aiReferralEventsHourly.projectId, ctx.project.id),
+          eq29(aiReferralEventsHourly.projectId, ctx.project.id),
           gte4(aiReferralEventsHourly.tsHour, warnCutoff)
         )
       ).get()?.total ?? 0
@@ -30221,7 +30760,7 @@ var recentDataCheck = {
     const olderCrawlers = Number(
       ctx.db.select({ total: sql12`COALESCE(SUM(${crawlerEventsHourly.hits}), 0)` }).from(crawlerEventsHourly).where(
         and21(
-          eq28(crawlerEventsHourly.projectId, ctx.project.id),
+          eq29(crawlerEventsHourly.projectId, ctx.project.id),
           gte4(crawlerEventsHourly.tsHour, failCutoff)
         )
       ).get()?.total ?? 0
@@ -30229,7 +30768,7 @@ var recentDataCheck = {
     const olderReferrals = Number(
       ctx.db.select({ total: sql12`COALESCE(SUM(${aiReferralEventsHourly.sessionsOrHits}), 0)` }).from(aiReferralEventsHourly).where(
         and21(
-          eq28(aiReferralEventsHourly.projectId, ctx.project.id),
+          eq29(aiReferralEventsHourly.projectId, ctx.project.id),
           gte4(aiReferralEventsHourly.tsHour, failCutoff)
         )
       ).get()?.total ?? 0
@@ -30344,7 +30883,7 @@ var credentialsCheck = {
   scope: CheckScopes.project,
   title: "Traffic source credentials",
   run: async (ctx) => {
-    if (!ctx.project) return skippedNoProject3();
+    if (!ctx.project) return skippedNoProject4();
     const sources = loadProbes(ctx);
     if (sources.length === 0) {
       return {
@@ -30373,7 +30912,7 @@ var scopesCheck3 = {
   scope: CheckScopes.project,
   title: "Traffic source scopes",
   run: async (ctx) => {
-    if (!ctx.project) return skippedNoProject3();
+    if (!ctx.project) return skippedNoProject4();
     const sources = loadProbes(ctx);
     if (sources.length === 0) {
       return {
@@ -30486,6 +31025,7 @@ var ALL_CHECKS = [
   ...GA_AUTH_CHECKS,
   ...PROVIDERS_CHECKS,
   ...TRAFFIC_SOURCE_CHECKS,
+  ...CONTENT_CHECKS,
   ...AGENT_CHECKS
 ];
 
@@ -30608,7 +31148,7 @@ async function doctorRoutes(app, opts) {
 
 // ../api-routes/src/discovery/routes.ts
 import crypto25 from "crypto";
-import { and as and22, desc as desc15, eq as eq29, gte as gte5, inArray as inArray10 } from "drizzle-orm";
+import { and as and22, desc as desc15, eq as eq30, gte as gte5, inArray as inArray10 } from "drizzle-orm";
 var MAX_INFLIGHT_DISCOVERY_AGE_MS = 2 * 60 * 60 * 1e3;
 async function discoveryRoutes(app, opts) {
   app.post("/projects/:name/discover/run", async (request, reply) => {
@@ -30641,8 +31181,8 @@ async function discoveryRoutes(app, opts) {
     const ageFloorIso = new Date(Date.now() - MAX_INFLIGHT_DISCOVERY_AGE_MS).toISOString();
     const decision = app.db.transaction((tx) => {
       const existing = tx.select({ id: discoverySessions.id, runId: discoverySessions.runId }).from(discoverySessions).where(and22(
-        eq29(discoverySessions.projectId, project.id),
-        eq29(discoverySessions.icpDescription, icpDescription),
+        eq30(discoverySessions.projectId, project.id),
+        eq30(discoverySessions.icpDescription, icpDescription),
         inArray10(discoverySessions.status, [
           DiscoverySessionStatuses.queued,
           DiscoverySessionStatuses.seeding,
@@ -30712,7 +31252,7 @@ async function discoveryRoutes(app, opts) {
       const project = resolveProject(app.db, request.params.name);
       const parsedLimit = parseInt(request.query.limit ?? "", 10);
       const limit = Number.isNaN(parsedLimit) || parsedLimit <= 0 ? 50 : parsedLimit;
-      const rows = app.db.select().from(discoverySessions).where(eq29(discoverySessions.projectId, project.id)).orderBy(desc15(discoverySessions.createdAt)).limit(limit).all();
+      const rows = app.db.select().from(discoverySessions).where(eq30(discoverySessions.projectId, project.id)).orderBy(desc15(discoverySessions.createdAt)).limit(limit).all();
       return reply.send(rows.map(serializeSession));
     }
   );
@@ -30720,11 +31260,11 @@ async function discoveryRoutes(app, opts) {
     "/projects/:name/discover/sessions/:id",
     async (request, reply) => {
       const project = resolveProject(app.db, request.params.name);
-      const session = app.db.select().from(discoverySessions).where(eq29(discoverySessions.id, request.params.id)).get();
+      const session = app.db.select().from(discoverySessions).where(eq30(discoverySessions.id, request.params.id)).get();
       if (!session || session.projectId !== project.id) {
         throw notFound("Discovery session", request.params.id);
       }
-      const probeRows = app.db.select().from(discoveryProbes).where(eq29(discoveryProbes.sessionId, session.id)).all();
+      const probeRows = app.db.select().from(discoveryProbes).where(eq30(discoveryProbes.sessionId, session.id)).all();
       const detail = {
         ...serializeSession(session),
         probes: probeRows.map(serializeProbe)
@@ -30736,12 +31276,12 @@ async function discoveryRoutes(app, opts) {
     "/projects/:name/discover/sessions/:id/promote",
     async (request, reply) => {
       const project = resolveProject(app.db, request.params.name);
-      const session = app.db.select().from(discoverySessions).where(eq29(discoverySessions.id, request.params.id)).get();
+      const session = app.db.select().from(discoverySessions).where(eq30(discoverySessions.id, request.params.id)).get();
       if (!session || session.projectId !== project.id) {
         throw notFound("Discovery session", request.params.id);
       }
-      const probeRows = app.db.select().from(discoveryProbes).where(eq29(discoveryProbes.sessionId, session.id)).all();
-      const existingCompetitors = app.db.select({ domain: competitors.domain }).from(competitors).where(eq29(competitors.projectId, project.id)).all().map((r) => r.domain.toLowerCase());
+      const probeRows = app.db.select().from(discoveryProbes).where(eq30(discoveryProbes.sessionId, session.id)).all();
+      const existingCompetitors = app.db.select({ domain: competitors.domain }).from(competitors).where(eq30(competitors.projectId, project.id)).all().map((r) => r.domain.toLowerCase());
       const seenCompetitors = new Set(existingCompetitors);
       const cited = /* @__PURE__ */ new Set();
       const aspirational = /* @__PURE__ */ new Set();
@@ -30770,7 +31310,7 @@ async function discoveryRoutes(app, opts) {
   );
   app.post("/projects/:name/discover/sessions/:id/promote", async (request, reply) => {
     const project = resolveProject(app.db, request.params.name);
-    const session = app.db.select().from(discoverySessions).where(eq29(discoverySessions.id, request.params.id)).get();
+    const session = app.db.select().from(discoverySessions).where(eq30(discoverySessions.id, request.params.id)).get();
     if (!session || session.projectId !== project.id) {
       throw notFound("Discovery session", request.params.id);
     }
@@ -30793,7 +31333,7 @@ async function discoveryRoutes(app, opts) {
     const bucketSet = new Set(buckets);
     const includeCompetitors = parsed.data.includeCompetitors ?? true;
     const competitorTypes = parsed.data.competitorTypes ?? DEFAULT_DISCOVERY_PROMOTE_COMPETITOR_TYPES;
-    const probeRows = app.db.select().from(discoveryProbes).where(eq29(discoveryProbes.sessionId, session.id)).all();
+    const probeRows = app.db.select().from(discoveryProbes).where(eq30(discoveryProbes.sessionId, session.id)).all();
     const candidateQueries = /* @__PURE__ */ new Set();
     for (const probe of probeRows) {
       if (!probe.bucket) continue;
@@ -30801,7 +31341,7 @@ async function discoveryRoutes(app, opts) {
       if (bucket.success && bucketSet.has(bucket.data)) candidateQueries.add(probe.query);
     }
     const existingQueries = new Set(
-      app.db.select({ query: queries.query }).from(queries).where(eq29(queries.projectId, project.id)).all().map((r) => r.query.toLowerCase())
+      app.db.select({ query: queries.query }).from(queries).where(eq30(queries.projectId, project.id)).all().map((r) => r.query.toLowerCase())
     );
     const promotedQueries = [];
     const skippedQueries = [];
@@ -30817,7 +31357,7 @@ async function discoveryRoutes(app, opts) {
     const skippedCompetitors = [];
     if (includeCompetitors) {
       const existingCompetitors = new Set(
-        app.db.select({ domain: competitors.domain }).from(competitors).where(eq29(competitors.projectId, project.id)).all().map((r) => r.domain.toLowerCase())
+        app.db.select({ domain: competitors.domain }).from(competitors).where(eq30(competitors.projectId, project.id)).all().map((r) => r.domain.toLowerCase())
       );
       const competitorMap = parseCompetitorMap(session.competitorMap);
       for (const entry of selectEligibleCompetitors(competitorMap, competitorTypes)) {
@@ -30920,7 +31460,7 @@ function selectEligibleCompetitors(competitorMap, competitorTypes) {
 
 // ../api-routes/src/discovery/orchestrate.ts
 import crypto26 from "crypto";
-import { eq as eq30 } from "drizzle-orm";
+import { eq as eq31 } from "drizzle-orm";
 var DEFAULT_DEDUP_THRESHOLD = 0.85;
 var DEFAULT_MAX_PROBES = 100;
 var ABSOLUTE_MAX_PROBES = 500;
@@ -30975,7 +31515,7 @@ async function executeDiscovery(opts) {
     status: DiscoverySessionStatuses.seeding,
     dedupThreshold,
     startedAt
-  }).where(eq30(discoverySessions.id, opts.sessionId)).run();
+  }).where(eq31(discoverySessions.id, opts.sessionId)).run();
   const seedResult = await opts.deps.seed({
     project: opts.project,
     icpDescription: opts.icpDescription,
@@ -30995,7 +31535,7 @@ async function executeDiscovery(opts) {
     seedProvider: seedResult.provider,
     seedCountRaw,
     seedCount
-  }).where(eq30(discoverySessions.id, opts.sessionId)).run();
+  }).where(eq31(discoverySessions.id, opts.sessionId)).run();
   const probeRows = [];
   const buckets = { cited: 0, aspirational: 0, "wasted-surface": 0 };
   for (const query of probedCanonicals) {
@@ -31035,7 +31575,8 @@ async function executeDiscovery(opts) {
     wastedCount: buckets["wasted-surface"],
     competitorMap,
     finishedAt: (/* @__PURE__ */ new Date()).toISOString()
-  }).where(eq30(discoverySessions.id, opts.sessionId)).run();
+  }).where(eq31(discoverySessions.id, opts.sessionId)).run();
+  upsertDomainClassifications(opts.db, opts.project.id, opts.sessionId, competitorMap);
   return {
     buckets,
     competitorMap,
@@ -31044,12 +31585,37 @@ async function executeDiscovery(opts) {
     seedProvider: seedResult.provider
   };
 }
+function upsertDomainClassifications(db, projectId, sessionId, competitorMap) {
+  if (competitorMap.length === 0) return;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  for (const entry of competitorMap) {
+    const domain = normalizeDomain(entry.domain);
+    if (!domain) continue;
+    db.insert(domainClassifications).values({
+      id: crypto26.randomUUID(),
+      projectId,
+      domain,
+      competitorType: entry.competitorType,
+      hits: entry.hits,
+      sessionId,
+      updatedAt: now
+    }).onConflictDoUpdate({
+      target: [domainClassifications.projectId, domainClassifications.domain],
+      set: {
+        competitorType: entry.competitorType,
+        hits: entry.hits,
+        sessionId,
+        updatedAt: now
+      }
+    }).run();
+  }
+}
 function markSessionFailed(db, sessionId, error) {
   db.update(discoverySessions).set({
     status: DiscoverySessionStatuses.failed,
     error,
     finishedAt: (/* @__PURE__ */ new Date()).toISOString()
-  }).where(eq30(discoverySessions.id, sessionId)).run();
+  }).where(eq31(discoverySessions.id, sessionId)).run();
 }
 function dedupeStrings(input) {
   const seen = /* @__PURE__ */ new Set();
@@ -31146,7 +31712,11 @@ async function apiRoutes(app, opts) {
     await api.register(reportRoutes);
     await api.register(citationRoutes);
     await api.register(compositeRoutes);
-    await api.register(contentRoutes, { explainContentRecommendation: opts.explainContentRecommendation });
+    await api.register(contentRoutes, {
+      explainContentRecommendation: opts.explainContentRecommendation,
+      briefContentRecommendation: opts.briefContentRecommendation,
+      briefPromptVersion: opts.briefPromptVersion
+    });
     await api.register(settingsRoutes, {
       providerSummary: opts.providerSummary,
       providerAdapters: opts.providerAdapters,
@@ -31208,6 +31778,7 @@ async function apiRoutes(app, opts) {
       pullWordpressTrafficEvents: opts.pullWordpressTrafficEvents,
       vercelTrafficCredentialStore: opts.vercelTrafficCredentialStore,
       pullVercelTrafficEvents: opts.pullVercelTrafficEvents,
+      vercelSyncDeadlineMs: opts.vercelSyncDeadlineMs,
       onTrafficSynced: opts.onTrafficSynced,
       onScheduleUpdated: opts.onScheduleUpdated,
       allowLoopbackWebhooks: opts.allowLoopbackWebhooks
@@ -31611,8 +32182,8 @@ var IntelligenceService = class {
   analyzeAndPersist(runId, projectId) {
     const recentRuns = this.db.select().from(runs).where(
       and23(
-        eq31(runs.projectId, projectId),
-        or5(eq31(runs.status, "completed"), eq31(runs.status, "partial")),
+        eq32(runs.projectId, projectId),
+        or5(eq32(runs.status, "completed"), eq32(runs.status, "partial")),
         // Defensive: RunCoordinator already skips probes before this is
         // called, but if a future call site invokes analyzeAndPersist
         // directly for a probe, probes still must not pollute the
@@ -31694,7 +32265,7 @@ var IntelligenceService = class {
    * Returns the persisted insights so the coordinator can count critical/high.
    */
   analyzeAndPersistGbp(runId, projectId) {
-    const runRow = this.db.select({ createdAt: runs.createdAt, startedAt: runs.startedAt, finishedAt: runs.finishedAt }).from(runs).where(eq31(runs.id, runId)).get();
+    const runRow = this.db.select({ createdAt: runs.createdAt, startedAt: runs.startedAt, finishedAt: runs.finishedAt }).from(runs).where(eq32(runs.id, runId)).get();
     if (!runRow) {
       log.info("gbp-intelligence.skip", { runId, reason: "run not found" });
       this.persistGbpInsights(runId, projectId, [], []);
@@ -31703,8 +32274,8 @@ var IntelligenceService = class {
     const windowStart = runRow.startedAt ?? runRow.createdAt;
     const windowEnd = runRow.finishedAt ?? (/* @__PURE__ */ new Date()).toISOString();
     const selected = this.db.select().from(gbpLocations).where(and23(
-      eq31(gbpLocations.projectId, projectId),
-      eq31(gbpLocations.selected, true),
+      eq32(gbpLocations.projectId, projectId),
+      eq32(gbpLocations.selected, true),
       gte6(gbpLocations.syncedAt, windowStart),
       lte3(gbpLocations.syncedAt, windowEnd)
     )).all();
@@ -31739,10 +32310,10 @@ var IntelligenceService = class {
   }
   /** Build the per-location signal bundle the GBP analyzer consumes. */
   buildGbpLocationSignals(projectId, locationName, displayName, fallbackDate) {
-    const metricRows = this.db.select({ metric: gbpDailyMetrics.metric, date: gbpDailyMetrics.date, value: gbpDailyMetrics.value }).from(gbpDailyMetrics).where(and23(eq31(gbpDailyMetrics.projectId, projectId), eq31(gbpDailyMetrics.locationName, locationName))).all();
-    const placeActionRows = this.db.select({ placeActionType: gbpPlaceActions.placeActionType, providerType: gbpPlaceActions.providerType }).from(gbpPlaceActions).where(and23(eq31(gbpPlaceActions.projectId, projectId), eq31(gbpPlaceActions.locationName, locationName))).all();
-    const lodgingRow = this.db.select({ populatedGroupCount: gbpLodgingSnapshots.populatedGroupCount }).from(gbpLodgingSnapshots).where(and23(eq31(gbpLodgingSnapshots.projectId, projectId), eq31(gbpLodgingSnapshots.locationName, locationName))).orderBy(desc16(gbpLodgingSnapshots.syncedAt)).limit(1).get();
-    const placeRow = this.db.select({ attributes: gbpPlaceDetails.attributes }).from(gbpPlaceDetails).where(and23(eq31(gbpPlaceDetails.projectId, projectId), eq31(gbpPlaceDetails.locationName, locationName))).orderBy(desc16(gbpPlaceDetails.syncedAt)).limit(1).get();
+    const metricRows = this.db.select({ metric: gbpDailyMetrics.metric, date: gbpDailyMetrics.date, value: gbpDailyMetrics.value }).from(gbpDailyMetrics).where(and23(eq32(gbpDailyMetrics.projectId, projectId), eq32(gbpDailyMetrics.locationName, locationName))).all();
+    const placeActionRows = this.db.select({ placeActionType: gbpPlaceActions.placeActionType, providerType: gbpPlaceActions.providerType }).from(gbpPlaceActions).where(and23(eq32(gbpPlaceActions.projectId, projectId), eq32(gbpPlaceActions.locationName, locationName))).all();
+    const lodgingRow = this.db.select({ populatedGroupCount: gbpLodgingSnapshots.populatedGroupCount }).from(gbpLodgingSnapshots).where(and23(eq32(gbpLodgingSnapshots.projectId, projectId), eq32(gbpLodgingSnapshots.locationName, locationName))).orderBy(desc16(gbpLodgingSnapshots.syncedAt)).limit(1).get();
+    const placeRow = this.db.select({ attributes: gbpPlaceDetails.attributes }).from(gbpPlaceDetails).where(and23(eq32(gbpPlaceDetails.projectId, projectId), eq32(gbpPlaceDetails.locationName, locationName))).orderBy(desc16(gbpPlaceDetails.syncedAt)).limit(1).get();
     const placesAmenities = placeRow ? extractPlaceAmenities(placeRow.attributes) : [];
     const summary = buildGbpSummary({
       locationName,
@@ -31774,7 +32345,7 @@ var IntelligenceService = class {
   /** Build the month-over-month keyword series for a location from the
    *  accumulating gbp_keyword_monthly table (latest complete month vs prior). */
   buildGbpKeywordTrend(projectId, locationName) {
-    const rows = this.db.select({ month: gbpKeywordMonthly.month, keyword: gbpKeywordMonthly.keyword, valueCount: gbpKeywordMonthly.valueCount }).from(gbpKeywordMonthly).where(and23(eq31(gbpKeywordMonthly.projectId, projectId), eq31(gbpKeywordMonthly.locationName, locationName))).all();
+    const rows = this.db.select({ month: gbpKeywordMonthly.month, keyword: gbpKeywordMonthly.keyword, valueCount: gbpKeywordMonthly.valueCount }).from(gbpKeywordMonthly).where(and23(eq32(gbpKeywordMonthly.projectId, projectId), eq32(gbpKeywordMonthly.locationName, locationName))).all();
     if (rows.length === 0) return { recentMonth: null, priorMonth: null, points: [] };
     const months = [...new Set(rows.map((r) => r.month))].sort().reverse();
     const recentMonth = months[0] ?? null;
@@ -31805,7 +32376,7 @@ var IntelligenceService = class {
    */
   persistGbpInsights(runId, projectId, gbpInsights, coveredLocationNames) {
     const covered = new Set(coveredLocationNames);
-    const existing = this.db.select({ id: insights.id, dismissed: insights.dismissed }).from(insights).where(and23(eq31(insights.projectId, projectId), eq31(insights.provider, GBP_INSIGHT_PROVIDER))).all();
+    const existing = this.db.select({ id: insights.id, dismissed: insights.dismissed }).from(insights).where(and23(eq32(insights.projectId, projectId), eq32(insights.provider, GBP_INSIGHT_PROVIDER))).all();
     const staleIds = [];
     const dismissedSlots = /* @__PURE__ */ new Set();
     for (const row of existing) {
@@ -31816,7 +32387,7 @@ var IntelligenceService = class {
     }
     this.db.transaction((tx) => {
       for (const id of staleIds) {
-        tx.delete(insights).where(eq31(insights.id, id)).run();
+        tx.delete(insights).where(eq32(insights.id, id)).run();
       }
       for (const insight of gbpInsights) {
         const parsed = parseGbpInsightId(insight.id);
@@ -31894,7 +32465,7 @@ var IntelligenceService = class {
    *     create per run + aggregate). DB is left untouched.
    */
   backfill(projectName, opts, onProgress) {
-    const project = this.db.select().from(projects).where(eq31(projects.name, projectName)).get();
+    const project = this.db.select().from(projects).where(eq32(projects.name, projectName)).get();
     if (!project) {
       throw new Error(`Project "${projectName}" not found`);
     }
@@ -31908,8 +32479,8 @@ var IntelligenceService = class {
     }
     const allRuns = this.db.select().from(runs).where(
       and23(
-        eq31(runs.projectId, project.id),
-        or5(eq31(runs.status, "completed"), eq31(runs.status, "partial")),
+        eq32(runs.projectId, project.id),
+        or5(eq32(runs.status, "completed"), eq32(runs.status, "partial")),
         // Backfill must not replay probe runs as if they were real sweeps.
         ne5(runs.trigger, RunTriggers.probe)
       )
@@ -31988,7 +32559,7 @@ var IntelligenceService = class {
     return { processed, skipped, totalInsights };
   }
   loadTrackedCompetitors(projectId) {
-    return this.db.select({ domain: competitors.domain }).from(competitors).where(eq31(competitors.projectId, projectId)).all().map((r) => r.domain);
+    return this.db.select({ domain: competitors.domain }).from(competitors).where(eq32(competitors.projectId, projectId)).all().map((r) => r.domain);
   }
   /**
    * Wipe transition signals from an analysis result while keeping health.
@@ -32009,15 +32580,15 @@ var IntelligenceService = class {
   }
   persistResult(result, runId, projectId) {
     const previouslyDismissed = /* @__PURE__ */ new Set();
-    const existingInsights = this.db.select({ query: insights.query, provider: insights.provider, type: insights.type, dismissed: insights.dismissed }).from(insights).where(eq31(insights.runId, runId)).all();
+    const existingInsights = this.db.select({ query: insights.query, provider: insights.provider, type: insights.type, dismissed: insights.dismissed }).from(insights).where(eq32(insights.runId, runId)).all();
     for (const row of existingInsights) {
       if (row.dismissed) {
         previouslyDismissed.add(`${row.query}:${row.provider}:${row.type}`);
       }
     }
     this.db.transaction((tx) => {
-      tx.delete(insights).where(eq31(insights.runId, runId)).run();
-      tx.delete(healthSnapshots).where(eq31(healthSnapshots.runId, runId)).run();
+      tx.delete(insights).where(eq32(insights.runId, runId)).run();
+      tx.delete(healthSnapshots).where(eq32(healthSnapshots.runId, runId)).run();
       const now = (/* @__PURE__ */ new Date()).toISOString();
       for (const insight of result.insights) {
         const wasDismissed = previouslyDismissed.has(`${insight.query}:${insight.provider}:${insight.type}`);
@@ -32068,14 +32639,14 @@ var IntelligenceService = class {
   applySeverityTiering(rawInsights, excludeRunId, projectId) {
     const regressions = rawInsights.filter((i) => i.type === "regression");
     if (regressions.length === 0) return rawInsights;
-    const gscRows = this.db.select({ query: gscSearchData.query, impressions: gscSearchData.impressions }).from(gscSearchData).where(eq31(gscSearchData.projectId, projectId)).all();
+    const gscRows = this.db.select({ query: gscSearchData.query, impressions: gscSearchData.impressions }).from(gscSearchData).where(eq32(gscSearchData.projectId, projectId)).all();
     const gscConnected = gscRows.length > 0;
     const gscImpressionsByQuery = /* @__PURE__ */ new Map();
     for (const row of gscRows) {
       const key = row.query.toLowerCase();
       gscImpressionsByQuery.set(key, (gscImpressionsByQuery.get(key) ?? 0) + row.impressions);
     }
-    const projectRow = this.db.select({ locations: projects.locations }).from(projects).where(eq31(projects.id, projectId)).get();
+    const projectRow = this.db.select({ locations: projects.locations }).from(projects).where(eq32(projects.id, projectId)).get();
     const locationCount = Math.max(
       1,
       (projectRow?.locations ?? []).length
@@ -32083,9 +32654,9 @@ var IntelligenceService = class {
     const ROWS_PER_GROUP_BUDGET = Math.max(2, locationCount);
     const recentRunRows = this.db.select({ id: runs.id, createdAt: runs.createdAt }).from(runs).where(
       and23(
-        eq31(runs.projectId, projectId),
-        eq31(runs.kind, RunKinds["answer-visibility"]),
-        or5(eq31(runs.status, "completed"), eq31(runs.status, "partial")),
+        eq32(runs.projectId, projectId),
+        eq32(runs.kind, RunKinds["answer-visibility"]),
+        or5(eq32(runs.status, "completed"), eq32(runs.status, "partial")),
         // Defensive — see top of file.
         ne5(runs.trigger, RunTriggers.probe)
       )
@@ -32105,7 +32676,7 @@ var IntelligenceService = class {
     const haveHistory = recentRunIds.length > 0;
     const priorRegressionsByPair = /* @__PURE__ */ new Map();
     if (haveHistory) {
-      const priorRows = this.db.select({ query: insights.query, provider: insights.provider, runId: insights.runId }).from(insights).where(and23(eq31(insights.type, "regression"), inArray11(insights.runId, recentRunIds))).all();
+      const priorRows = this.db.select({ query: insights.query, provider: insights.provider, runId: insights.runId }).from(insights).where(and23(eq32(insights.type, "regression"), inArray11(insights.runId, recentRunIds))).all();
       const regressionGroups = /* @__PURE__ */ new Map();
       for (const row of priorRows) {
         if (!row.runId) continue;
@@ -32134,7 +32705,7 @@ var IntelligenceService = class {
     });
   }
   buildRunData(runId, projectId, completedAt, location = null) {
-    const projectDomainRow = this.db.select({ canonicalDomain: projects.canonicalDomain, ownedDomains: projects.ownedDomains }).from(projects).where(eq31(projects.id, projectId)).get();
+    const projectDomainRow = this.db.select({ canonicalDomain: projects.canonicalDomain, ownedDomains: projects.ownedDomains }).from(projects).where(eq32(projects.id, projectId)).get();
     const projectDomains = projectDomainRow ? effectiveDomains({
       canonicalDomain: projectDomainRow.canonicalDomain,
       ownedDomains: projectDomainRow.ownedDomains
@@ -32150,7 +32721,7 @@ var IntelligenceService = class {
       citedDomains: querySnapshots.citedDomains,
       competitorOverlap: querySnapshots.competitorOverlap,
       snapshotLocation: querySnapshots.location
-    }).from(querySnapshots).leftJoin(queries, eq31(querySnapshots.queryId, queries.id)).where(eq31(querySnapshots.runId, runId)).all();
+    }).from(querySnapshots).leftJoin(queries, eq32(querySnapshots.queryId, queries.id)).where(eq32(querySnapshots.runId, runId)).all();
     const snapshots = [];
     let orphanCount = 0;
     for (const r of rows) {