@ainyc/canonry 4.115.0 → 4.115.1

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

@@ -20,6 +20,7 @@ import {
   DiscoveryBuckets,
   DiscoveryCompetitorTypes,
   DiscoverySessionStatuses,
+  GA4AiReferralTrafficClasses,
   RunKinds,
   RunStatuses,
   RunTriggers,
@@ -87,6 +88,7 @@ import {
   citationStateToCited,
   citationVisibilityResponseSchema,
   classifyCitedSurface,
+  classifyGa4AiReferralTrafficClass,
   classifySkillFile,
   classifySurfaceFromCategory,
   classifyTrafficPath,
@@ -273,7 +275,7 @@ import {
   wordpressSchemaDeployResultDtoSchema,
   wordpressSchemaStatusResultDtoSchema,
   wordpressStatusDtoSchema
-} from "./chunk-VEUBAZRG.js";
+} from "./chunk-6LOKMEL3.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 +760,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 +775,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)
 ]);
@@ -3482,6 +3486,41 @@ 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. `classifyGa4AiReferralTrafficClass`
+    // 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);
+    }
   }
 ];
 function rebuildBacklinkTableWithSource(tx, table) {
@@ -3568,6 +3607,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 = classifyGa4AiReferralTrafficClass({
+      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 +8196,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 +8248,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 +8386,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: [],
@@ -11845,6 +11904,9 @@ function safeNum(value) {
   }
   return 0;
 }
+function isPaidAiTrafficClass(value) {
+  return value === GA4AiReferralTrafficClasses.paid;
+}
 function categorizeQuery(query, projectBrandNames, canonicalDomain) {
   return categorizeQueryByIntent(query, buildBrandTokens(canonicalDomain, projectBrandNames));
 }
@@ -11999,14 +12061,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 +12181,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 +12221,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`
@@ -20423,16 +20542,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: classifyGa4AiReferralTrafficClass({ 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 +23526,76 @@ function pickWinningDimension(rows, tupleKey) {
   }
   return [...winners.values()].sort((a, b) => (b.sessions ?? 0) - (a.sessions ?? 0));
 }
+function normalizeAiTrafficClass(value) {
+  return value === GA4AiReferralTrafficClasses.paid ? GA4AiReferralTrafficClasses.paid : GA4AiReferralTrafficClasses.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) === GA4AiReferralTrafficClasses.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 +23872,12 @@ async function ga4Routes(app, opts) {
               date: row.date,
               source: row.source,
               medium: row.medium,
+              trafficClass: row.trafficClass ?? classifyGa4AiReferralTrafficClass({
+                source: row.source,
+                medium: row.medium,
+                channelGroup: row.channelGroup,
+                landingPage: row.landingPage
+              }),
               sourceDimension: row.sourceDimension,
               channelGroup: row.channelGroup,
               landingPage: row.landingPage,
@@ -23825,13 +24027,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 +24043,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 +24087,7 @@ async function ga4Routes(app, opts) {
       organicSessions: totalOrganicSessions,
       socialSessions,
       directSessions: totalDirectSessions,
-      aiSessionsByChannelGroup
+      aiSessionsByChannelGroup: aiSummary.bySessionChannelGroup
     });
     return {
       totalSessions: total,
@@ -23919,6 +24104,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 +24112,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 +24141,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 +24181,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 +24190,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();