@ainyc/canonry 4.115.0 → 4.116.0

package/dist/{chunk-BXNFOGDF.js → chunk-WEAXJ25Y.js}

@@ -2,6 +2,7 @@ import {
   AGENT_PROVIDER_IDS,
   AI_ENGINE_DOMAINS,
   AI_PROVIDER_INFRA_DOMAINS,
+  AiReferralTrafficClasses,
   AppError,
   BacklinkSources,
   CcReleaseSyncStatuses,
@@ -49,6 +50,7 @@ import {
   adsSyncResponseSchema,
   agentProvidersResponseDtoSchema,
   aggregateHarvestedQueries,
+  aiReferralClassCounts,
   apiKeyDtoSchema,
   apiKeyListDtoSchema,
   applyHarvestSemanticNovelty,
@@ -86,6 +88,7 @@ import {
   citationStateSchema,
   citationStateToCited,
   citationVisibilityResponseSchema,
+  classifyAiReferralTrafficClass,
   classifyCitedSurface,
   classifySkillFile,
   classifySurfaceFromCategory,
@@ -130,6 +133,7 @@ import {
   filterBrandedSeedCandidates,
   findDuplicateLocationLabels,
   forbidden,
+  formatAiReferralClassSummary,
   formatAverageDelta,
   formatDate,
   formatDateRange,
@@ -273,7 +277,7 @@ import {
   wordpressSchemaDeployResultDtoSchema,
   wordpressSchemaStatusResultDtoSchema,
   wordpressStatusDtoSchema
-} from "./chunk-VEUBAZRG.js";
+} from "./chunk-IQPMK36Y.js";
 
 // src/intelligence-service.ts
 import { eq as eq38, desc as desc18, asc as asc6, and as and30, ne as ne5, or as or6, inArray as inArray14, gte as gte7, lte as lte4 } from "drizzle-orm";
@@ -758,6 +762,7 @@ var gaAiReferrals = sqliteTable("ga_ai_referrals", {
   date: text("date").notNull(),
   source: text("source").notNull(),
   medium: text("medium").notNull(),
+  trafficClass: text("traffic_class").$type().notNull().default("organic"),
   /** Which GA4 dimension produced this row: 'session' | 'first_user' | 'manual_utm' */
   sourceDimension: text("source_dimension").notNull().default("session"),
   /** GA4 default channel group for the session (e.g. 'Referral', 'Organic Social'). */
@@ -772,6 +777,7 @@ var gaAiReferrals = sqliteTable("ga_ai_referrals", {
   index("idx_ga_ai_ref_project_date").on(table.projectId, table.date),
   index("idx_ga_ai_ref_source").on(table.source),
   index("idx_ga_ai_ref_landing_page").on(table.projectId, table.date, table.landingPageNormalized),
+  index("idx_ga_ai_ref_traffic_class").on(table.projectId, table.date, table.trafficClass),
   uniqueIndex("idx_ga_ai_ref_unique_v4").on(table.projectId, table.date, table.source, table.medium, table.sourceDimension, table.channelGroup, table.landingPage),
   index("idx_ga_ai_ref_run").on(table.syncRunId)
 ]);
@@ -1096,6 +1102,17 @@ var aiReferralEventsHourly = sqliteTable("ai_referral_events_hourly", {
   landingPathNormalized: text("landing_path_normalized").notNull(),
   status: integer("status").notNull(),
   sessionsOrHits: integer("sessions_or_hits").notNull().default(0),
+  /**
+   * Paid/organic splits the MEASURE, not the primary key. The paid marker lives
+   * in the request's UTM tags, which `landing_path_normalized` strips, so one
+   * bucket can legitimately hold both kinds and the class is NOT functionally
+   * determined by the key. Unclassified arrivals are the residual
+   * `sessions_or_hits - paid - organic`, which leaves rows written before the
+   * ingest classifier shipped (both columns 0) visibly unknown rather than
+   * silently organic — the regression migration v95 shipped on the GA4 side.
+   */
+  paidSessionsOrHits: integer("paid_sessions_or_hits").notNull().default(0),
+  organicSessionsOrHits: integer("organic_sessions_or_hits").notNull().default(0),
   usersEstimated: integer("users_estimated"),
   createdAt: text("created_at").notNull(),
   updatedAt: text("updated_at").notNull()
@@ -3482,6 +3499,62 @@ var MIGRATION_VERSIONS = [
       // post-truncation). Additive + nullable (downgrade-safe).
       `ALTER TABLE discovery_sessions ADD COLUMN canonical_count INTEGER`
     ]
+  },
+  {
+    version: 95,
+    name: "ga-ai-referral-traffic-class",
+    statements: [],
+    run: (tx) => {
+      if (!tableExists(tx, "ga_ai_referrals")) return;
+      if (!columnExists(tx, "ga_ai_referrals", "traffic_class")) {
+        tx.run(sql.raw(`ALTER TABLE ga_ai_referrals ADD COLUMN traffic_class TEXT NOT NULL DEFAULT 'organic'`));
+      }
+      tx.run(sql.raw(`CREATE INDEX IF NOT EXISTS idx_ga_ai_ref_traffic_class ON ga_ai_referrals(project_id, date, traffic_class)`));
+    }
+  },
+  {
+    // v95 added `ga_ai_referrals.traffic_class` with `DEFAULT 'organic'` and did
+    // not classify the rows that already existed. Every historical AI referral
+    // was therefore stamped 'organic', including paid ChatGPT-ads traffic
+    // carrying `medium='cpc'` / `channel_group='Paid Other'`. That silently
+    // reports purchased sessions as organic wins.
+    //
+    // The class is a pure function of columns already stored on each row, so
+    // re-derive it here instead of making an operator delete and re-fetch
+    // identical data from GA4.
+    //
+    // Every row is re-classified, not only the "unclassified" ones: v95's
+    // default is indistinguishable from a genuinely-organic classification, so
+    // there is no way to tell the two apart. `classifyAiReferralTrafficClass`
+    // is pure and deterministic, so re-running it over already-correct rows
+    // writes nothing, which is what makes this version safe to replay.
+    version: 96,
+    name: "ga-ai-referral-traffic-class-backfill",
+    statements: [],
+    run: (tx) => {
+      backfillGaAiReferralTrafficClass(tx);
+    }
+  },
+  {
+    // Splits the server-side AI-referral MEASURE by traffic class rather than
+    // adding a class column. Paid-ness lives in the request's UTM tags, which
+    // `landing_path_normalized` strips, so one hourly bucket can legitimately
+    // hold both paid and organic arrivals: a class column outside the 8-column
+    // primary key would silently stamp a mixed bucket with one label, and
+    // SQLite cannot extend a composite key with ADD COLUMN anyway.
+    //
+    // Deliberately NO backfill. The discriminator was never persisted — the
+    // request's query string is dropped before the hourly bucket and before
+    // `raw_event_samples` — so no honest class exists for historical rows.
+    // Leaving both counters at 0 surfaces their whole `sessions_or_hits` as the
+    // unknown residual. An older binary writing rows after a downgrade lands in
+    // that residual too, which is the truth about those rows.
+    version: 97,
+    name: "server-side-ai-referral-traffic-class",
+    statements: [
+      `ALTER TABLE ai_referral_events_hourly ADD COLUMN paid_sessions_or_hits INTEGER NOT NULL DEFAULT 0`,
+      `ALTER TABLE ai_referral_events_hourly ADD COLUMN organic_sessions_or_hits INTEGER NOT NULL DEFAULT 0`
+    ]
   }
 ];
 function rebuildBacklinkTableWithSource(tx, table) {
@@ -3568,6 +3641,26 @@ function tableIsEmpty(db, table) {
   const rows = db.all(sql.raw(`SELECT COUNT(*) as c FROM ${table}`));
   return (rows[0]?.c ?? 0) === 0;
 }
+function backfillGaAiReferralTrafficClass(tx) {
+  if (!tableExists(tx, "ga_ai_referrals")) return 0;
+  if (!columnExists(tx, "ga_ai_referrals", "traffic_class")) return 0;
+  const rows = tx.all(sql.raw(
+    `SELECT id, source, medium, channel_group, landing_page, traffic_class FROM ga_ai_referrals`
+  ));
+  let updated = 0;
+  for (const row of rows) {
+    const next = classifyAiReferralTrafficClass({
+      source: row.source,
+      medium: row.medium,
+      channelGroup: row.channel_group,
+      landingPage: row.landing_page
+    });
+    if (next === row.traffic_class) continue;
+    tx.run(sql`UPDATE ga_ai_referrals SET traffic_class = ${next} WHERE id = ${row.id}`);
+    updated += 1;
+  }
+  return updated;
+}
 function hasLegacyQuerySchema(db) {
   return tableExists(db, "keywords") || columnExists(db, "query_snapshots", "keyword_id") || columnExists(db, "insights", "keyword");
 }
@@ -8137,7 +8230,7 @@ async function analyticsRoutes(app) {
     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(and7(eq10(runs.projectId, project.id), notProbeRun())).orderBy(runs.createdAt).all().filter((r) => r.status === "completed" || r.status === "partial").filter((r) => !cutoff || r.createdAt >= cutoff);
+    const projectRuns = app.db.select().from(runs).where(and7(eq10(runs.projectId, project.id), eq10(runs.kind, RunKinds["answer-visibility"]), notProbeRun())).orderBy(runs.createdAt).all().filter((r) => r.status === "completed" || r.status === "partial").filter((r) => !cutoff || r.createdAt >= cutoff);
     if (projectRuns.length === 0) {
       return reply.send({
         window,
@@ -8189,14 +8282,14 @@ async function analyticsRoutes(app) {
     const project = resolveProject(app.db, request.params.name);
     const window = parseWindow(request.query.window);
     const cutoff = windowCutoff(window);
-    const completedRuns = app.db.select().from(runs).where(and7(eq10(runs.projectId, project.id), notProbeRun())).orderBy(desc3(runs.createdAt), desc3(runs.id)).all().filter((r) => r.status === "completed" || r.status === "partial");
+    const completedRuns = app.db.select().from(runs).where(and7(eq10(runs.projectId, project.id), eq10(runs.kind, RunKinds["answer-visibility"]), notProbeRun())).orderBy(desc3(runs.createdAt), desc3(runs.id)).all().filter((r) => r.status === "completed" || r.status === "partial");
     const latestGroup = groupRunsByCreatedAt(completedRuns)[0] ?? [];
     const latestGroupRunIds = latestGroup.map((r) => r.id);
     const latestRun = pickGroupRepresentative(latestGroup);
     if (!latestRun) {
       return reply.send({ cited: [], gap: [], uncited: [], mentionedQueries: [], mentionGap: [], notMentioned: [], runId: "", window });
     }
-    const windowRuns = app.db.select().from(runs).where(and7(eq10(runs.projectId, project.id), notProbeRun())).orderBy(runs.createdAt).all().filter((r) => r.status === "completed" || r.status === "partial").filter((r) => !cutoff || r.createdAt >= cutoff);
+    const windowRuns = app.db.select().from(runs).where(and7(eq10(runs.projectId, project.id), eq10(runs.kind, RunKinds["answer-visibility"]), notProbeRun())).orderBy(runs.createdAt).all().filter((r) => r.status === "completed" || r.status === "partial").filter((r) => !cutoff || r.createdAt >= cutoff);
     const windowRunIds = windowRuns.map((r) => r.id);
     const runIdToCreatedAt = new Map(windowRuns.map((r) => [r.id, r.createdAt]));
     const consistencyMap = /* @__PURE__ */ new Map();
@@ -8327,7 +8420,7 @@ async function analyticsRoutes(app) {
       const mapped = surfaceClassFromCompetitorType(row.competitorType);
       if (mapped) storedSurfaceClasses.set(normalizeProjectDomain(row.domain), mapped);
     }
-    const windowRuns = app.db.select().from(runs).where(and7(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);
+    const windowRuns = app.db.select().from(runs).where(and7(eq10(runs.projectId, project.id), eq10(runs.kind, RunKinds["answer-visibility"]), 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: [],
@@ -11213,6 +11306,7 @@ function renderServerActivity(report, audience) {
     if (!copy) return "";
     return `<span class="tone-${deltaTone(d.deltaPct)}">${escapeHtml(copy)}</span>`;
   };
+  const referralSubtitle = [formatDelta(sa.referralArrivals, "sessions"), escapeHtml(sa.referralArrivalsClassSummary)].filter(Boolean).join(" \xB7 ");
   if (isClient) {
     const crawlerRequests = {
       current: sa.verifiedCrawlerHits.current + sa.unverifiedCrawlerHits.current,
@@ -11251,7 +11345,7 @@ function renderServerActivity(report, audience) {
         <div class="metric">
           <div class="label">AI referral sessions</div>
           <div class="value">${formatNumber(sa.referralArrivals.current)}</div>
-          <div class="subtitle">${formatDelta(sa.referralArrivals, "sessions")}</div>
+          <div class="subtitle">${referralSubtitle}</div>
         </div>
       </div>
       ${clientOperatorRows ? `<div class="chart-card"><h3>By AI tool</h3>
@@ -11320,7 +11414,7 @@ function renderServerActivity(report, audience) {
       <div class="metric">
         <div class="label">AI-referral sessions (${windowLabel})</div>
         <div class="value">${formatNumber(sa.referralArrivals.current)}</div>
-        <div class="subtitle">${formatDelta(sa.referralArrivals, "sessions")}</div>
+        <div class="subtitle">${referralSubtitle}</div>
       </div>
     </div>
     ${trendChart}
@@ -11845,6 +11939,9 @@ function safeNum(value) {
   }
   return 0;
 }
+function isPaidAiTrafficClass(value) {
+  return value === AiReferralTrafficClasses.paid;
+}
 function categorizeQuery(query, projectBrandNames, canonicalDomain) {
   return categorizeQueryByIntent(query, buildBrandTokens(canonicalDomain, projectBrandNames));
 }
@@ -11999,14 +12096,40 @@ function buildGaSection(db, projectId, windowDays) {
     users: data.users,
     organicSessions: data.organic
   })).sort((a, b) => b.sessions - a.sessions).slice(0, TOP_LANDING_PAGES_LIMIT);
+  const aiConditions = [
+    eq15(gaAiReferrals.projectId, projectId),
+    eq15(gaAiReferrals.sourceDimension, "session")
+  ];
+  if (snapshotStartDate && snapshotMaxDate) {
+    aiConditions.push(gte2(gaAiReferrals.date, snapshotStartDate));
+    aiConditions.push(lte(gaAiReferrals.date, snapshotMaxDate));
+  }
+  const aiSessionRows = db.select({
+    trafficClass: gaAiReferrals.trafficClass,
+    channelGroup: gaAiReferrals.channelGroup,
+    sessions: sql7`COALESCE(SUM(${gaAiReferrals.sessions}), 0)`
+  }).from(gaAiReferrals).where(and12(...aiConditions)).groupBy(gaAiReferrals.trafficClass, gaAiReferrals.channelGroup).all();
+  let paidAiSessions = 0;
+  let organicAiSessions = 0;
+  let aiOrganicOverlap = 0;
+  let aiDirectOverlap = 0;
+  for (const row of aiSessionRows) {
+    const sessions = Number(row.sessions ?? 0);
+    if (isPaidAiTrafficClass(row.trafficClass)) paidAiSessions += sessions;
+    else organicAiSessions += sessions;
+    if (row.channelGroup === "Organic Search") aiOrganicOverlap += sessions;
+    if (row.channelGroup === "Direct") aiDirectOverlap += sessions;
+  }
   const channelBreakdown = [];
   if (totalSessions > 0) {
-    const organic = totalOrganicSessions;
-    const direct = directSessions;
-    const other = Math.max(totalSessions - organic - direct, 0);
+    const organic = Math.max(0, totalOrganicSessions - Math.min(totalOrganicSessions, aiOrganicOverlap));
+    const direct = Math.max(0, directSessions - Math.min(directSessions, aiDirectOverlap));
+    const other = Math.max(totalSessions - organic - direct - paidAiSessions - organicAiSessions, 0);
     const buckets = [
       { channel: "Organic Search", sessions: organic },
       { channel: "Direct", sessions: direct },
+      { channel: "Paid AI", sessions: paidAiSessions },
+      { channel: "Organic AI referrals", sessions: organicAiSessions },
       { channel: "Other", sessions: other }
     ];
     for (const b of buckets) {
@@ -12093,15 +12216,34 @@ function buildAiReferrals(db, projectId) {
   );
   let total = 0;
   let totalUsers = 0;
+  let paidSessions = 0;
+  let paidUsers = 0;
+  let organicSessions = 0;
+  let organicUsers = 0;
   const sourceAgg = /* @__PURE__ */ new Map();
   const trendAgg = /* @__PURE__ */ new Map();
   const pageAgg = /* @__PURE__ */ new Map();
   for (const r of dedupedRows) {
     total += r.sessions;
     totalUsers += r.users;
-    const s = sourceAgg.get(r.source) ?? { sessions: 0, users: 0 };
+    const paid = isPaidAiTrafficClass(r.trafficClass);
+    if (paid) {
+      paidSessions += r.sessions;
+      paidUsers += r.users;
+    } else {
+      organicSessions += r.sessions;
+      organicUsers += r.users;
+    }
+    const s = sourceAgg.get(r.source) ?? {
+      sessions: 0,
+      users: 0,
+      paidSessions: 0,
+      organicSessions: 0
+    };
     s.sessions += r.sessions;
     s.users += r.users;
+    if (paid) s.paidSessions += r.sessions;
+    else s.organicSessions += r.sessions;
     sourceAgg.set(r.source, s);
     trendAgg.set(r.date, (trendAgg.get(r.date) ?? 0) + r.sessions);
     const page = r.landingPageNormalized ?? r.landingPage;
@@ -12114,11 +12256,23 @@ function buildAiReferrals(db, projectId) {
     source,
     sessions: data.sessions,
     users: data.users,
+    paidSessions: data.paidSessions,
+    organicSessions: data.organicSessions,
     sharePct: total > 0 ? Math.round(data.sessions / total * 100) : 0
   })).sort((a, b) => b.sessions - a.sessions);
   const trend = [...trendAgg.entries()].map(([date, sessions]) => ({ date, sessions })).sort((a, b) => a.date.localeCompare(b.date));
   const topLandingPages = [...pageAgg.entries()].map(([page, data]) => ({ page, sessions: data.sessions, users: data.users })).sort((a, b) => b.sessions - a.sessions).slice(0, TOP_AI_REFERRAL_PAGES_LIMIT);
-  return { totalSessions: total, totalUsers, bySource, trend, topLandingPages };
+  return {
+    totalSessions: total,
+    totalUsers,
+    paidSessions,
+    paidUsers,
+    organicSessions,
+    organicUsers,
+    bySource,
+    trend,
+    topLandingPages
+  };
 }
 function nonSubresourceReferralPathCondition() {
   return sql7`
@@ -12179,16 +12333,21 @@ function buildServerActivity(db, projectId, windowDays) {
       )
     ).get()?.total ?? 0
   );
-  const sumReferrals = (windowStartIso, windowEndIso, exclusiveEnd = false) => Number(
-    db.select({ total: sql7`COALESCE(SUM(${aiReferralEventsHourly.sessionsOrHits}), 0)` }).from(aiReferralEventsHourly).where(
+  const sumReferrals = (windowStartIso, windowEndIso, exclusiveEnd = false) => {
+    const row = db.select({
+      total: sql7`COALESCE(SUM(${aiReferralEventsHourly.sessionsOrHits}), 0)`,
+      paid: sql7`COALESCE(SUM(${aiReferralEventsHourly.paidSessionsOrHits}), 0)`,
+      organic: sql7`COALESCE(SUM(${aiReferralEventsHourly.organicSessionsOrHits}), 0)`
+    }).from(aiReferralEventsHourly).where(
       and12(
         eq15(aiReferralEventsHourly.projectId, projectId),
         nonSubresourceReferralPathCondition(),
         gte2(aiReferralEventsHourly.tsHour, windowStartIso),
         exclusiveEnd ? lt(aiReferralEventsHourly.tsHour, windowEndIso) : lte(aiReferralEventsHourly.tsHour, windowEndIso)
       )
-    ).get()?.total ?? 0
-  );
+    ).get();
+    return aiReferralClassCounts(Number(row?.total ?? 0), Number(row?.paid ?? 0), Number(row?.organic ?? 0));
+  };
   const sumUserFetches = (windowStartIso, windowEndIso, exclusiveEnd = false) => Number(
     db.select({ total: sql7`COALESCE(SUM(${aiUserFetchEventsHourly.hits}), 0)` }).from(aiUserFetchEventsHourly).where(
       and12(
@@ -12386,7 +12545,7 @@ function buildServerActivity(db, projectId, windowDays) {
   return {
     windowStart: headlineStart,
     windowEnd: headlineEnd,
-    hasData: verifiedCurrent + unverifiedCurrent + userFetchCurrent + referralCurrent + verifiedPrior + unverifiedPrior + userFetchPrior + referralPrior > 0 || byOperator.length > 0 || topCrawledPaths.length > 0 || referralProducts.length > 0,
+    hasData: verifiedCurrent + unverifiedCurrent + userFetchCurrent + referralCurrent.total + verifiedPrior + unverifiedPrior + userFetchPrior + referralPrior.total > 0 || byOperator.length > 0 || topCrawledPaths.length > 0 || referralProducts.length > 0,
     verifiedCrawlerHits: {
       current: verifiedCurrent,
       prior: verifiedPrior,
@@ -12403,10 +12562,28 @@ function buildServerActivity(db, projectId, windowDays) {
       deltaPct: deltaPercent(userFetchCurrent, userFetchPrior)
     },
     referralArrivals: {
-      current: referralCurrent,
-      prior: referralPrior,
-      deltaPct: deltaPercent(referralCurrent, referralPrior)
+      current: referralCurrent.total,
+      prior: referralPrior.total,
+      deltaPct: deltaPercent(referralCurrent.total, referralPrior.total)
+    },
+    referralArrivalsByClass: {
+      paid: {
+        current: referralCurrent.paid,
+        prior: referralPrior.paid,
+        deltaPct: deltaPercent(referralCurrent.paid, referralPrior.paid)
+      },
+      organic: {
+        current: referralCurrent.organic,
+        prior: referralPrior.organic,
+        deltaPct: deltaPercent(referralCurrent.organic, referralPrior.organic)
+      },
+      unclassified: {
+        current: referralCurrent.unknown,
+        prior: referralPrior.unknown,
+        deltaPct: deltaPercent(referralCurrent.unknown, referralPrior.unknown)
+      }
     },
+    referralArrivalsClassSummary: formatAiReferralClassSummary(referralCurrent),
     byOperator,
     topCrawledPaths,
     referralProducts,
@@ -20423,16 +20600,23 @@ async function fetchAiReferrals(accessToken, propertyId, days) {
       };
       const response = await runReport(accessToken, propertyId, request);
       if (!response) break;
-      const pageRows = (response.rows ?? []).map((row) => ({
-        date: row.dimensionValues[0].value,
-        source: row.dimensionValues[1].value,
-        medium: row.dimensionValues[2].value,
-        channelGroup: row.dimensionValues[3]?.value ?? "(not set)",
-        landingPage: row.dimensionValues[4]?.value ?? "(not set)",
-        sessions: parseInt(row.metricValues[0].value, 10) || 0,
-        users: parseInt(row.metricValues[1].value, 10) || 0,
-        sourceDimension: dimLabel
-      }));
+      const pageRows = (response.rows ?? []).map((row) => {
+        const source = row.dimensionValues[1].value;
+        const medium = row.dimensionValues[2].value;
+        const channelGroup = row.dimensionValues[3]?.value ?? "(not set)";
+        const landingPage = row.dimensionValues[4]?.value ?? "(not set)";
+        return {
+          date: row.dimensionValues[0].value,
+          source,
+          medium,
+          trafficClass: classifyAiReferralTrafficClass({ source, medium, channelGroup, landingPage }),
+          channelGroup,
+          landingPage,
+          sessions: parseInt(row.metricValues[0].value, 10) || 0,
+          users: parseInt(row.metricValues[1].value, 10) || 0,
+          sourceDimension: dimLabel
+        };
+      });
       rows.push(...pageRows);
       const totalRows = response.rowCount ?? 0;
       offset += pageRows.length;
@@ -23400,6 +23584,76 @@ function pickWinningDimension(rows, tupleKey) {
   }
   return [...winners.values()].sort((a, b) => (b.sessions ?? 0) - (a.sessions ?? 0));
 }
+function normalizeAiTrafficClass(value) {
+  return value === AiReferralTrafficClasses.paid ? AiReferralTrafficClasses.paid : AiReferralTrafficClasses.organic;
+}
+function emptyAiCounts() {
+  return { sessions: 0, users: 0 };
+}
+function summarizeAiReferralCounts(rows) {
+  const dedupeGroups = /* @__PURE__ */ new Map();
+  const bySessionChannelGroup = /* @__PURE__ */ new Map();
+  const paidDeduped = emptyAiCounts();
+  const organicDeduped = emptyAiCounts();
+  const paidBySession = emptyAiCounts();
+  const organicBySession = emptyAiCounts();
+  for (const row of rows) {
+    const isPaid = normalizeAiTrafficClass(row.trafficClass) === AiReferralTrafficClasses.paid;
+    const sessions = row.sessions ?? 0;
+    const users = row.users ?? 0;
+    const key = `${row.date}\0${row.source}\0${row.medium}`;
+    let byDimension = dedupeGroups.get(key);
+    if (!byDimension) {
+      byDimension = /* @__PURE__ */ new Map();
+      dedupeGroups.set(key, byDimension);
+    }
+    let dim = byDimension.get(row.sourceDimension);
+    if (!dim) {
+      dim = { paidSessions: 0, organicSessions: 0, paidUsers: 0, organicUsers: 0 };
+      byDimension.set(row.sourceDimension, dim);
+    }
+    if (isPaid) {
+      dim.paidSessions += sessions;
+      dim.paidUsers += users;
+    } else {
+      dim.organicSessions += sessions;
+      dim.organicUsers += users;
+    }
+    if (row.sourceDimension === "session") {
+      bySessionChannelGroup.set(
+        row.channelGroup,
+        (bySessionChannelGroup.get(row.channelGroup) ?? 0) + sessions
+      );
+      const sessionBucket = isPaid ? paidBySession : organicBySession;
+      sessionBucket.sessions += sessions;
+      sessionBucket.users += users;
+    }
+  }
+  for (const byDimension of dedupeGroups.values()) {
+    const dims = [...byDimension.values()];
+    const bestSessions = dims.reduce((best, d) => d.paidSessions + d.organicSessions > best.paidSessions + best.organicSessions ? d : best);
+    const bestUsers = dims.reduce((best, d) => d.paidUsers + d.organicUsers > best.paidUsers + best.organicUsers ? d : best);
+    paidDeduped.sessions += bestSessions.paidSessions;
+    organicDeduped.sessions += bestSessions.organicSessions;
+    paidDeduped.users += bestUsers.paidUsers;
+    organicDeduped.users += bestUsers.organicUsers;
+  }
+  return {
+    paidDeduped,
+    organicDeduped,
+    paidBySession,
+    organicBySession,
+    bySessionChannelGroup,
+    deduped: {
+      sessions: paidDeduped.sessions + organicDeduped.sessions,
+      users: paidDeduped.users + organicDeduped.users
+    },
+    bySession: {
+      sessions: paidBySession.sessions + organicBySession.sessions,
+      users: paidBySession.users + organicBySession.users
+    }
+  };
+}
 async function refreshOAuthTokenIfNeeded(googleStore, authConfig, canonicalDomain, oauthConn) {
   const expiresAt = oauthConn.tokenExpiresAt ? new Date(oauthConn.tokenExpiresAt).getTime() : 0;
   const fiveMinutes = 5 * 60 * 1e3;
@@ -23676,6 +23930,12 @@ async function ga4Routes(app, opts) {
               date: row.date,
               source: row.source,
               medium: row.medium,
+              trafficClass: row.trafficClass ?? classifyAiReferralTrafficClass({
+                source: row.source,
+                medium: row.medium,
+                channelGroup: row.channelGroup,
+                landingPage: row.landingPage
+              }),
               sourceDimension: row.sourceDimension,
               channelGroup: row.channelGroup,
               landingPage: row.landingPage,
@@ -23825,13 +24085,15 @@ async function ga4Routes(app, opts) {
     const aiReferralRows = app.db.select({
       source: gaAiReferrals.source,
       medium: gaAiReferrals.medium,
+      trafficClass: gaAiReferrals.trafficClass,
       sourceDimension: gaAiReferrals.sourceDimension,
       sessions: sql10`SUM(${gaAiReferrals.sessions})`,
       users: sql10`SUM(${gaAiReferrals.users})`
-    }).from(gaAiReferrals).where(and21(...aiConditions)).groupBy(gaAiReferrals.source, gaAiReferrals.medium, gaAiReferrals.sourceDimension).all();
+    }).from(gaAiReferrals).where(and21(...aiConditions)).groupBy(gaAiReferrals.source, gaAiReferrals.medium, gaAiReferrals.trafficClass, gaAiReferrals.sourceDimension).all();
     const aiReferralLandingPageRows = app.db.select({
       source: gaAiReferrals.source,
       medium: gaAiReferrals.medium,
+      trafficClass: gaAiReferrals.trafficClass,
       sourceDimension: gaAiReferrals.sourceDimension,
       landingPage: sql10`COALESCE(${gaAiReferrals.landingPageNormalized}, ${gaAiReferrals.landingPage})`,
       sessions: sql10`SUM(${gaAiReferrals.sessions})`,
@@ -23839,48 +24101,29 @@ async function ga4Routes(app, opts) {
     }).from(gaAiReferrals).where(and21(...aiConditions)).groupBy(
       gaAiReferrals.source,
       gaAiReferrals.medium,
+      gaAiReferrals.trafficClass,
       gaAiReferrals.sourceDimension,
       sql10`COALESCE(${gaAiReferrals.landingPageNormalized}, ${gaAiReferrals.landingPage})`
     ).all();
+    const aiRowsForTotals = app.db.select({
+      date: gaAiReferrals.date,
+      source: gaAiReferrals.source,
+      medium: gaAiReferrals.medium,
+      trafficClass: gaAiReferrals.trafficClass,
+      sourceDimension: gaAiReferrals.sourceDimension,
+      channelGroup: gaAiReferrals.channelGroup,
+      sessions: gaAiReferrals.sessions,
+      users: gaAiReferrals.users
+    }).from(gaAiReferrals).where(and21(...aiConditions)).all();
     const aiReferrals = pickWinningDimension(
       aiReferralRows,
-      (r) => `${r.source}\0${r.medium}`
+      (r) => `${r.source}\0${r.medium}\0${r.trafficClass}`
     );
     const aiReferralLandingPages = pickWinningDimension(
       aiReferralLandingPageRows,
-      (r) => `${r.source}\0${r.medium}\0${r.landingPage}`
+      (r) => `${r.source}\0${r.medium}\0${r.trafficClass}\0${r.landingPage}`
     );
-    const aiDeduped = app.db.select({
-      sessions: sql10`COALESCE(SUM(max_sessions), 0)`,
-      users: sql10`COALESCE(SUM(max_users), 0)`
-    }).from(
-      sql10`(
-          SELECT date, source, medium,
-                 MAX(dimension_sessions) AS max_sessions,
-                 MAX(dimension_users) AS max_users
-          FROM (
-            SELECT date, source, medium, source_dimension,
-                   SUM(sessions) AS dimension_sessions,
-                   SUM(users) AS dimension_users
-            FROM ga_ai_referrals
-            WHERE project_id = ${project.id}${cutoffDate ? sql10` AND date >= ${cutoffDate}` : sql10``}
-            GROUP BY date, source, medium, source_dimension
-          )
-          GROUP BY date, source, medium
-        )`
-    ).get();
-    const aiBySessionRows = app.db.select({
-      channelGroup: gaAiReferrals.channelGroup,
-      sessions: sql10`COALESCE(SUM(${gaAiReferrals.sessions}), 0)`,
-      users: sql10`COALESCE(SUM(${gaAiReferrals.users}), 0)`
-    }).from(gaAiReferrals).where(and21(...aiConditions, eq26(gaAiReferrals.sourceDimension, "session"))).groupBy(gaAiReferrals.channelGroup).all();
-    const aiSessionsByChannelGroup = /* @__PURE__ */ new Map();
-    let aiBySessionUsers = 0;
-    for (const row of aiBySessionRows) {
-      aiSessionsByChannelGroup.set(row.channelGroup, row.sessions ?? 0);
-      aiBySessionUsers += row.users ?? 0;
-    }
-    const aiBySessionSessions = [...aiSessionsByChannelGroup.values()].reduce((sum, sessions) => sum + sessions, 0);
+    const aiSummary = summarizeAiReferralCounts(aiRowsForTotals);
     const socialReferrals = app.db.select({
       source: gaSocialReferrals.source,
       medium: gaSocialReferrals.medium,
@@ -23902,7 +24145,7 @@ async function ga4Routes(app, opts) {
       organicSessions: totalOrganicSessions,
       socialSessions,
       directSessions: totalDirectSessions,
-      aiSessionsByChannelGroup
+      aiSessionsByChannelGroup: aiSummary.bySessionChannelGroup
     });
     return {
       totalSessions: total,
@@ -23919,6 +24162,7 @@ async function ga4Routes(app, opts) {
       aiReferrals: aiReferrals.map((r) => ({
         source: r.source,
         medium: r.medium,
+        trafficClass: normalizeAiTrafficClass(r.trafficClass),
         sourceDimension: r.sourceDimension,
         sessions: r.sessions ?? 0,
         users: r.users ?? 0
@@ -23926,15 +24170,24 @@ async function ga4Routes(app, opts) {
       aiReferralLandingPages: aiReferralLandingPages.map((r) => ({
         source: r.source,
         medium: r.medium,
+        trafficClass: normalizeAiTrafficClass(r.trafficClass),
         sourceDimension: r.sourceDimension,
         landingPage: r.landingPage,
         sessions: r.sessions ?? 0,
         users: r.users ?? 0
       })),
-      aiSessionsDeduped: aiDeduped?.sessions ?? 0,
-      aiUsersDeduped: aiDeduped?.users ?? 0,
-      aiSessionsBySession: aiBySessionSessions,
-      aiUsersBySession: aiBySessionUsers,
+      aiSessionsDeduped: aiSummary.deduped.sessions,
+      aiUsersDeduped: aiSummary.deduped.users,
+      paidAiSessionsDeduped: aiSummary.paidDeduped.sessions,
+      paidAiUsersDeduped: aiSummary.paidDeduped.users,
+      organicAiSessionsDeduped: aiSummary.organicDeduped.sessions,
+      organicAiUsersDeduped: aiSummary.organicDeduped.users,
+      aiSessionsBySession: aiSummary.bySession.sessions,
+      aiUsersBySession: aiSummary.bySession.users,
+      paidAiSessionsBySession: aiSummary.paidBySession.sessions,
+      paidAiUsersBySession: aiSummary.paidBySession.users,
+      organicAiSessionsBySession: aiSummary.organicBySession.sessions,
+      organicAiUsersBySession: aiSummary.organicBySession.users,
       socialReferrals: socialReferrals.map((r) => ({
         source: r.source,
         medium: r.medium,
@@ -23946,16 +24199,24 @@ async function ga4Routes(app, opts) {
       socialUsers: socialTotals?.users ?? 0,
       channelBreakdown,
       organicSharePct: total > 0 ? Math.round(totalOrganicSessions / total * 100) : 0,
-      aiSharePct: total > 0 ? Math.round((aiDeduped?.sessions ?? 0) / total * 100) : 0,
-      aiSharePctBySession: total > 0 ? Math.round(aiBySessionSessions / total * 100) : 0,
+      aiSharePct: total > 0 ? Math.round(aiSummary.deduped.sessions / total * 100) : 0,
+      aiSharePctBySession: total > 0 ? Math.round(aiSummary.bySession.sessions / total * 100) : 0,
+      paidAiSharePct: total > 0 ? Math.round(aiSummary.paidDeduped.sessions / total * 100) : 0,
+      paidAiSharePctBySession: total > 0 ? Math.round(aiSummary.paidBySession.sessions / total * 100) : 0,
+      organicAiSharePct: total > 0 ? Math.round(aiSummary.organicDeduped.sessions / total * 100) : 0,
+      organicAiSharePctBySession: total > 0 ? Math.round(aiSummary.organicBySession.sessions / total * 100) : 0,
       directSharePct: total > 0 ? Math.round(totalDirectSessions / total * 100) : 0,
       socialSharePct: total > 0 ? Math.round(socialSessions / total * 100) : 0,
       otherSessions: channelBreakdown.other.sessions,
       otherSharePct: channelBreakdown.other.sharePct,
       otherSharePctDisplay: channelBreakdown.other.sharePctDisplay,
       organicSharePctDisplay: formatSharePct(totalOrganicSessions, total),
-      aiSharePctDisplay: formatSharePct(aiDeduped?.sessions ?? 0, total),
-      aiSharePctBySessionDisplay: formatSharePct(aiBySessionSessions, total),
+      aiSharePctDisplay: formatSharePct(aiSummary.deduped.sessions, total),
+      aiSharePctBySessionDisplay: formatSharePct(aiSummary.bySession.sessions, total),
+      paidAiSharePctDisplay: formatSharePct(aiSummary.paidDeduped.sessions, total),
+      paidAiSharePctBySessionDisplay: formatSharePct(aiSummary.paidBySession.sessions, total),
+      organicAiSharePctDisplay: formatSharePct(aiSummary.organicDeduped.sessions, total),
+      organicAiSharePctBySessionDisplay: formatSharePct(aiSummary.organicBySession.sessions, total),
       directSharePctDisplay: formatSharePct(totalDirectSessions, total),
       socialSharePctDisplay: formatSharePct(socialSessions, total),
       lastSyncedAt: latestSync?.syncedAt ?? null,
@@ -23978,6 +24239,7 @@ async function ga4Routes(app, opts) {
       date: gaAiReferrals.date,
       source: gaAiReferrals.source,
       medium: gaAiReferrals.medium,
+      trafficClass: gaAiReferrals.trafficClass,
       landingPage: sql10`COALESCE(${gaAiReferrals.landingPageNormalized}, ${gaAiReferrals.landingPage})`,
       sourceDimension: gaAiReferrals.sourceDimension,
       sessions: sql10`SUM(${gaAiReferrals.sessions})`,
@@ -23986,6 +24248,7 @@ async function ga4Routes(app, opts) {
       gaAiReferrals.date,
       gaAiReferrals.source,
       gaAiReferrals.medium,
+      gaAiReferrals.trafficClass,
       gaAiReferrals.sourceDimension,
       sql10`COALESCE(${gaAiReferrals.landingPageNormalized}, ${gaAiReferrals.landingPage})`
     ).orderBy(gaAiReferrals.date).all();
@@ -29445,6 +29708,33 @@ function utmSourceFromUrl(value) {
     return null;
   }
 }
+function paramsFromQuery(queryString) {
+  if (!queryString) return null;
+  const params = new URLSearchParams(queryString);
+  return [...params.keys()].length > 0 ? params : null;
+}
+function paramsFromUrl(value) {
+  if (!value) return null;
+  try {
+    return paramsFromQuery(new URL(value).search.replace(/^\?/, ""));
+  } catch {
+    return null;
+  }
+}
+function classifyAiReferralTrafficClassFromEvent(event) {
+  for (const params of [paramsFromQuery(event.queryString), paramsFromUrl(event.referer)]) {
+    if (!params) continue;
+    const trafficClass = classifyAiReferralTrafficClass({
+      source: params.get("utm_source"),
+      medium: params.get("utm_medium"),
+      channelGroup: null,
+      // Carries utm_campaign / utm_content / utm_term to the shared rules.
+      landingPage: `/?${params.toString()}`
+    });
+    if (trafficClass === AiReferralTrafficClasses.paid) return AiReferralTrafficClasses.paid;
+  }
+  return AiReferralTrafficClasses.organic;
+}
 function isSelfTraffic(event) {
   const userAgent = event.userAgent?.trim();
   if (!userAgent) return false;
@@ -29488,6 +29778,7 @@ function classifyAiUserFetch(event) {
   return null;
 }
 function classifyAiReferral(event) {
+  const trafficClass = classifyAiReferralTrafficClassFromEvent(event);
   const refererHost = hostFromUrl(event.referer);
   if (refererHost) {
     const rule = DEFAULT_AI_REFERRER_RULES.find((candidate) => hostMatches(refererHost, candidate.domain));
@@ -29496,7 +29787,8 @@ function classifyAiReferral(event) {
         operator: rule.operator,
         product: rule.product,
         sourceDomain: refererHost,
-        evidenceType: "referer"
+        evidenceType: "referer",
+        trafficClass
       };
     }
   }
@@ -29508,7 +29800,8 @@ function classifyAiReferral(event) {
         operator: rule.operator,
         product: rule.product,
         sourceDomain: utmSource,
-        evidenceType: "utm"
+        evidenceType: "utm",
+        trafficClass
       };
     }
   }
@@ -29520,7 +29813,8 @@ function classifyAiReferral(event) {
         operator: rule.operator,
         product: rule.product,
         sourceDomain: refererUtmSource,
-        evidenceType: "referer-utm"
+        evidenceType: "referer-utm",
+        trafficClass
       };
     }
   }
@@ -29623,8 +29917,10 @@ function evidenceRank(evidenceType) {
       return 1;
   }
 }
-function strongerReferralEvidence(current, next) {
-  return evidenceRank(next.evidenceType) > evidenceRank(current.evidenceType) ? next : current;
+function mergeReferralSession(current, next) {
+  const winner = evidenceRank(next.evidenceType) > evidenceRank(current.evidenceType) ? next : current;
+  const paid = current.trafficClass === AiReferralTrafficClasses.paid || next.trafficClass === AiReferralTrafficClasses.paid;
+  return { ...winner, trafficClass: paid ? AiReferralTrafficClasses.paid : winner.trafficClass };
 }
 function sortCrawlerBuckets(a, b) {
   return a.tsHour.localeCompare(b.tsHour) || a.botId.localeCompare(b.botId) || a.pathNormalized.localeCompare(b.pathNormalized) || String(a.status).localeCompare(String(b.status));
@@ -29657,6 +29953,8 @@ function buildTrafficProbeReport(events, options = {}) {
   let crawlerHits = 0;
   let aiUserFetchHits = 0;
   let aiReferralHits = 0;
+  let aiReferralPaidSessions = 0;
+  let aiReferralOrganicSessions = 0;
   let unknownHits = 0;
   const samples = [];
   for (const event of includedEvents) {
@@ -29738,11 +30036,12 @@ function buildTrafficProbeReport(events, options = {}) {
           sourceDomain: aiReferral.sourceDomain,
           evidenceType: aiReferral.evidenceType,
           landingPathNormalized,
-          status: event.status
+          status: event.status,
+          trafficClass: aiReferral.trafficClass
         };
         const key = aiReferralSessionKey(event, aiReferral, landingPathNormalized, aiReferralSessionWindowMs);
         const existing = aiReferralSessions.get(key);
-        aiReferralSessions.set(key, existing ? strongerReferralEvidence(existing, session) : session);
+        aiReferralSessions.set(key, existing ? mergeReferralSession(existing, session) : session);
       }
     }
     if (!crawler && !aiUserFetch && !aiReferral) unknownHits += 1;
@@ -29770,13 +30069,21 @@ function buildTrafficProbeReport(events, options = {}) {
       session.landingPathNormalized,
       session.status ?? "null"
     ].join("	");
+    const { trafficClass, ...bucketFields } = session;
+    const paid = trafficClass === AiReferralTrafficClasses.paid;
+    if (paid) aiReferralPaidSessions += 1;
+    else aiReferralOrganicSessions += 1;
     const existing = aiReferralBuckets.get(key);
     if (existing) {
       existing.hits += 1;
+      if (paid) existing.paidHits += 1;
+      else existing.organicHits += 1;
     } else {
       aiReferralBuckets.set(key, {
-        ...session,
-        hits: 1
+        ...bucketFields,
+        hits: 1,
+        paidHits: paid ? 1 : 0,
+        organicHits: paid ? 0 : 1
       });
     }
     incrementBucket(topAiReferrers, session.sourceDomain, {
@@ -29795,6 +30102,8 @@ function buildTrafficProbeReport(events, options = {}) {
       crawlerHits,
       aiUserFetchHits,
       aiReferralSessions: aiReferralSessions.size,
+      aiReferralPaidSessions,
+      aiReferralOrganicSessions,
       aiReferralHits,
       unknownHits
     },
@@ -30556,6 +30865,8 @@ async function runBackfillTask(options) {
           landingPathNormalized: bucket.landingPathNormalized,
           status: bucket.status ?? 0,
           sessionsOrHits: bucket.hits,
+          paidSessionsOrHits: bucket.paidHits,
+          organicSessionsOrHits: bucket.organicHits,
           usersEstimated: null,
           createdAt: finishedAt,
           updatedAt: finishedAt
@@ -31303,6 +31614,8 @@ async function trafficRoutes(app, opts) {
           landingPathNormalized: bucket.landingPathNormalized,
           status,
           sessionsOrHits: bucket.hits,
+          paidSessionsOrHits: bucket.paidHits,
+          organicSessionsOrHits: bucket.organicHits,
           usersEstimated: null,
           createdAt: finishedAt,
           updatedAt: finishedAt
@@ -31317,8 +31630,13 @@ async function trafficRoutes(app, opts) {
             aiReferralEventsHourly.landingPathNormalized,
             aiReferralEventsHourly.status
           ],
+          // All three counters accumulate. The class splits the measure, so a
+          // colliding bucket adds its paid and organic arrivals to the ones
+          // already there rather than overwriting a single label.
           set: {
             sessionsOrHits: sql12`${aiReferralEventsHourly.sessionsOrHits} + ${bucket.hits}`,
+            paidSessionsOrHits: sql12`${aiReferralEventsHourly.paidSessionsOrHits} + ${bucket.paidHits}`,
+            organicSessionsOrHits: sql12`${aiReferralEventsHourly.organicSessionsOrHits} + ${bucket.organicHits}`,
             updatedAt: finishedAt
           }
         }).run();
@@ -31770,7 +32088,7 @@ async function trafficRoutes(app, opts) {
     let crawlerTotal = 0;
     let crawlerSegments = { content: 0, sitemap: 0, robots: 0, asset: 0, other: 0 };
     let aiUserFetchTotal = 0;
-    let aiReferralTotal = 0;
+    let aiReferralCounts = aiReferralClassCounts(0, 0, 0);
     if (kind === "all" || kind === TrafficEventKinds.crawler) {
       const crawlerFilters = [
         eq28(crawlerEventsHourly.projectId, project.id),
@@ -31836,10 +32154,19 @@ async function trafficRoutes(app, opts) {
       ];
       if (sourceIdParam) aiFilters.push(eq28(aiReferralEventsHourly.sourceId, sourceIdParam));
       const aiWhere = and24(...aiFilters);
-      const total = app.db.select({ total: sql12`COALESCE(SUM(${aiReferralEventsHourly.sessionsOrHits}), 0)` }).from(aiReferralEventsHourly).where(aiWhere).get();
-      aiReferralTotal = Number(total?.total ?? 0);
+      const total = app.db.select({
+        total: sql12`COALESCE(SUM(${aiReferralEventsHourly.sessionsOrHits}), 0)`,
+        paid: sql12`COALESCE(SUM(${aiReferralEventsHourly.paidSessionsOrHits}), 0)`,
+        organic: sql12`COALESCE(SUM(${aiReferralEventsHourly.organicSessionsOrHits}), 0)`
+      }).from(aiReferralEventsHourly).where(aiWhere).get();
+      aiReferralCounts = aiReferralClassCounts(
+        Number(total?.total ?? 0),
+        Number(total?.paid ?? 0),
+        Number(total?.organic ?? 0)
+      );
       const rows = app.db.select().from(aiReferralEventsHourly).where(aiWhere).orderBy(desc15(aiReferralEventsHourly.tsHour)).limit(limit).all();
       for (const r of rows) {
+        const counts2 = aiReferralClassCounts(r.sessionsOrHits, r.paidSessionsOrHits, r.organicSessionsOrHits);
         events.push({
           kind: TrafficEventKinds["ai-referral"],
           sourceId: r.sourceId,
@@ -31850,7 +32177,10 @@ async function trafficRoutes(app, opts) {
           evidenceType: r.evidenceType,
           landingPathNormalized: r.landingPathNormalized,
           status: r.status,
-          hits: r.sessionsOrHits
+          hits: counts2.total,
+          paidHits: counts2.paid,
+          organicHits: counts2.organic,
+          unknownHits: counts2.unknown
         });
       }
     }
@@ -31865,7 +32195,10 @@ async function trafficRoutes(app, opts) {
         crawlerInfraHits: sumInfraHits(crawlerSegments),
         crawlerSegments,
         aiUserFetchHits: aiUserFetchTotal,
-        aiReferralHits: aiReferralTotal
+        aiReferralHits: aiReferralCounts.total,
+        aiReferralPaidHits: aiReferralCounts.paid,
+        aiReferralOrganicHits: aiReferralCounts.organic,
+        aiReferralUnknownHits: aiReferralCounts.unknown
       },
       events: trimmed
     };