@canonry/canonry 4.172.0 → 4.172.2

package/dist/{chunk-O226BLC7.js → chunk-PXTSQ67Z.js}

@@ -231,6 +231,7 @@ import {
   compileBrandAliases,
   compileMeasurementPlan,
   compileMeasurementPlanPreview,
+  compileQueryClassifier,
   computeDedupSimilarityStats,
   contentActionLabel,
   contentGapsResponseDtoSchema,
@@ -277,6 +278,7 @@ import {
   escapeLikePattern,
   evaluateModelPointerExposure,
   extractAnswerMentions,
+  extractDomainsFromText,
   factorStatusFromScore,
   filterBrandedSeedCandidates,
   filterCapturedCitedUrls,
@@ -355,6 +357,7 @@ import {
   hostMatchesAnyDomain,
   hostMatchesDomain,
   hostOf,
+  inclusiveDayCount,
   indexingRequestResponseDtoSchema,
   internalError,
   isBrowserProvider,
@@ -371,6 +374,7 @@ import {
   locationContextSchema,
   loginRequestSchema,
   mapWithConcurrency,
+  matchedAliasKeys,
   matcherMatchesText,
   measurementChangesQuerySchema,
   measurementChangesResponseSchema,
@@ -624,7 +628,7 @@ import {
   wordpressSchemaDeployResultDtoSchema,
   wordpressSchemaStatusResultDtoSchema,
   wordpressStatusDtoSchema
-} from "./chunk-HJ7W2LXI.js";
+} from "./chunk-EGGQSFQL.js";
 
 // src/intelligence-service.ts
 import { eq as eq60, desc as desc27, asc as asc11, and as and48, ne as ne8, or as or14, inArray as inArray21, gte as gte14, lte as lte12 } from "drizzle-orm";
@@ -1019,6 +1023,21 @@ var querySnapshots = sqliteTable("query_snapshots", {
   // observation predates the field, NOT that retrieval did not happen.
   retrievalStatus: text("retrieval_status").$type(),
   retrievalContract: text("retrieval_contract").$type(),
+  /**
+   * LEGACY MIXED SIGNAL — never read this for a mention or a citation metric.
+   *
+   * The run writer unions three different things into it: cited domains,
+   * grounding-source hosts, and answer-text brand matches. A count taken from it
+   * is therefore neither the citation signal nor the mention signal, and naming
+   * it either one reports a number for one signal under the other's name (see
+   * AGENTS.md "Vocabulary"). It is also frozen at run time against the competitor
+   * set and the alias threshold that existed then, so it drifts from any
+   * read-time recomputation as soon as either changes.
+   *
+   * For citations read `citedDomains`. For mentions match the project/competitor
+   * brand aliases against `answerText` with `packages/contracts/src/brand-matching.ts`.
+   * The column is retained for the raw results export and historical inspection.
+   */
   competitorOverlap: text("competitor_overlap", { mode: "json" }).$type().notNull().default([]),
   recommendedCompetitors: text("recommended_competitors", { mode: "json" }).$type().notNull().default([]),
   location: text("location"),
@@ -7247,9 +7266,9 @@ function analyzeCause(regression, currentSnapshots) {
   const matchingSnaps = currentSnapshots.filter(
     (s) => s.query === regression.query && s.provider === regression.provider && !s.cited
   );
-  const withCompetitor = matchingSnaps.find((s) => s.competitorDomains?.length);
+  const withCompetitor = matchingSnaps.find((s) => s.citedCompetitorDomains?.length);
   if (withCompetitor) {
-    const competitor = withCompetitor.competitorDomains[0];
+    const competitor = withCompetitor.citedCompetitorDomains[0];
     return {
       cause: "competitor_gain",
       competitorDomain: competitor,
@@ -7487,8 +7506,8 @@ function detectPersistentGaps(runs2, threshold = PERSISTENT_GAP_THRESHOLD) {
 function buildCompetitorQueryMap(run, tracked) {
   const result = /* @__PURE__ */ new Map();
   for (const snap of run.snapshots) {
-    if (!snap.query || !snap.competitorDomains || snap.competitorDomains.length === 0) continue;
-    for (const domain of snap.competitorDomains) {
+    if (!snap.query || !snap.citedCompetitorDomains || snap.citedCompetitorDomains.length === 0) continue;
+    for (const domain of snap.citedCompetitorDomains) {
       if (!tracked.has(domain)) continue;
       const existing = result.get(domain) ?? /* @__PURE__ */ new Set();
       existing.add(snap.query);
@@ -7753,6 +7772,7 @@ function calculateActionConfidence(input) {
 function buildContentTargetRows(input) {
   const rows = [];
   for (const cq of input.candidateQueries) {
+    const competitiveDomains = competitivePresenceDomains(cq);
     const ourPage = resolveOurPage(cq, input.inventory);
     const ourPageInGroundingSources = cq.ourCitedInLatestRun;
     const ourPageHasSchema = ourPage ? input.wpSchemaAudit.get(ourPage.url) ?? null : null;
@@ -7763,7 +7783,7 @@ function buildContentTargetRows(input) {
     });
     if (!action) continue;
     const hasGsc = cq.gscImpressions > 0;
-    const hasCompetitor = cq.competitorDomains.length > 0;
+    const hasCompetitor = competitiveDomains.length > 0;
     if (!hasGsc && !hasCompetitor && !cq.ourCitedInLatestRun) continue;
     const aiReferralFactor = computeAiReferralFactor(
       input.totalAiReferralSessions,
@@ -7772,7 +7792,7 @@ function buildContentTargetRows(input) {
     const scoring = scoreContentTarget({
       gscImpressions: cq.gscImpressions,
       aiReferralFactor,
-      competitorCount: cq.competitorDomains.length,
+      competitorCount: competitiveDomains.length,
       recentMissRate: cq.recentMissRate,
       citationCount: cq.competitorCitationCount,
       ourCitedRate: cq.ourCitedRate,
@@ -7783,7 +7803,7 @@ function buildContentTargetRows(input) {
       hasGsc: cq.gscPage !== null,
       gscImpressions: cq.gscImpressions,
       runsOfHistory: cq.runsOfHistory,
-      hasCompetitorEvidence: cq.competitorDomains.length > 0,
+      hasCompetitorEvidence: competitiveDomains.length > 0,
       hasInventoryMatch: ourPage?.source === "inventory"
     });
     const targetRef = computeTargetRef({
@@ -7854,12 +7874,12 @@ function buildContentSourceRows(input) {
 function buildContentGapRows(input) {
   const gaps = [];
   for (const cq of input.candidateQueries) {
-    if (cq.competitorDomains.length === 0) continue;
+    if (cq.competitorCitedDomains.length === 0) continue;
     if (cq.ourCitedRate >= 1) continue;
     gaps.push({
       query: cq.query,
-      competitorDomains: cq.competitorDomains,
-      competitorCount: cq.competitorDomains.length,
+      competitorDomains: cq.competitorCitedDomains,
+      competitorCount: cq.competitorCitedDomains.length,
       missRate: clamp012(cq.recentMissRate),
       lastSeenInRunId: input.latestRunId
     });
@@ -7869,6 +7889,12 @@ function buildContentGapRows(input) {
     return b.competitorCount - a.competitorCount;
   });
 }
+function competitivePresenceDomains(cq) {
+  return [.../* @__PURE__ */ new Set([
+    ...cq.competitorCitedDomains,
+    ...cq.competitorMentionedDomains
+  ])];
+}
 function resolveOurPage(cq, inventory) {
   if (cq.gscPage && cq.gscPosition !== null) {
     return { url: cq.gscPage, position: cq.gscPosition, source: "gsc" };
@@ -8106,6 +8132,46 @@ function citedDomainBelongsToProject(citedDomain, projectDomains) {
   return hostMatchesAnyDomain(citedDomain, projectDomains);
 }
 
+// ../intelligence/src/competitive-signals.ts
+function compileCompetitiveSignalResolver(competitorDomains) {
+  const identities = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const candidate of competitorDomains) {
+    const domain = hostOf(candidate);
+    if (!domain || seen.has(domain)) continue;
+    seen.add(domain);
+    const domainBrandKey = brandKeyFromText(brandLabelFromDomain(domain));
+    identities.push({
+      domain,
+      domainBrandKey: domainBrandKey.length >= MIN_DOMAIN_BRAND_KEY_LENGTH ? domainBrandKey : null
+    });
+  }
+  const domainBrandMatcher = compileBrandAliases(
+    identities.filter((identity) => identity.domainBrandKey !== null).map((identity) => brandLabelFromDomain(identity.domain))
+  );
+  return {
+    resolve(evidence) {
+      const citationCandidates = [
+        ...evidence.citedDomains ?? [],
+        ...(evidence.groundingSources ?? []).map((source) => source.uri)
+      ];
+      const answerDomains = extractDomainsFromText(evidence.answerText);
+      const mentionedBrandKeys = matchedAliasKeys(domainBrandMatcher, evidence.answerText);
+      const citedCompetitorDomains = [];
+      const mentionedCompetitorDomains = [];
+      for (const identity of identities) {
+        if (citationCandidates.some((candidate) => hostMatchesDomain(candidate, identity.domain))) {
+          citedCompetitorDomains.push(identity.domain);
+        }
+        if (answerDomains.some((candidate) => hostMatchesDomain(candidate, identity.domain)) || identity.domainBrandKey !== null && mentionedBrandKeys.has(identity.domainBrandKey)) {
+          mentionedCompetitorDomains.push(identity.domain);
+        }
+      }
+      return { citedCompetitorDomains, mentionedCompetitorDomains };
+    }
+  };
+}
+
 // ../intelligence/src/competitor-landscape.ts
 function buildCompetitorLandscape(snapshots, competitorDomains, projectDomains, queryLookup) {
   let projectCitationCount = 0;
@@ -8113,14 +8179,22 @@ function buildCompetitorLandscape(snapshots, competitorDomains, projectDomains,
   for (const c of competitorDomains) {
     competitorMap.set(c, { count: 0, queries: /* @__PURE__ */ new Set(), pages: /* @__PURE__ */ new Map() });
   }
+  const competitorResolver = compileCompetitiveSignalResolver(competitorDomains);
+  const projectResolver = compileCompetitiveSignalResolver(projectDomains);
   for (const snap of snapshots) {
     const q = queryLookup.byId.get(snap.queryId);
-    const allDomains = [...snap.citedDomains, ...snap.competitorOverlap];
-    if (allDomains.some((d) => citedDomainBelongsToProject(d, projectDomains))) {
+    const evidence = {
+      citedDomains: snap.citedDomains,
+      groundingSources: snap.groundingSources
+    };
+    if (projectResolver.resolve(evidence).citedCompetitorDomains.length > 0) {
       projectCitationCount++;
     }
+    const citedCompetitors = new Set(
+      competitorResolver.resolve(evidence).citedCompetitorDomains
+    );
     for (const competitor of competitorDomains) {
-      if (allDomains.some((d) => citedDomainBelongsToProject(d, [competitor]))) {
+      if (citedCompetitors.has(competitor)) {
         const entry = competitorMap.get(competitor);
         entry.count++;
         if (q) entry.queries.add(q);
@@ -8162,55 +8236,84 @@ function buildCompetitorLandscape(snapshots, competitorDomains, projectDomains,
 }
 
 // ../intelligence/src/mention-landscape.ts
+function emptySection(competitorDomains) {
+  return {
+    projectMentionCount: 0,
+    totalAnswerSnapshots: 0,
+    competitorMap: new Map(competitorDomains.map((c) => [c, { count: 0, queries: /* @__PURE__ */ new Set() }]))
+  };
+}
+function toSection(tally) {
+  const totalMentionedSlots = tally.projectMentionCount + [...tally.competitorMap.values()].reduce((sum, v) => sum + v.count, 0);
+  const competitorRows = [...tally.competitorMap.entries()].map(([domain, data]) => {
+    const ratio = tally.totalAnswerSnapshots > 0 ? data.count / tally.totalAnswerSnapshots : 0;
+    let pressureLabel = "None";
+    if (data.count > 0) {
+      if (ratio >= 0.5) pressureLabel = "High";
+      else if (ratio >= 0.2) pressureLabel = "Moderate";
+      else pressureLabel = "Low";
+    }
+    const sharePct = totalMentionedSlots > 0 ? Math.round(data.count / totalMentionedSlots * 100) : null;
+    return {
+      domain,
+      mentionCount: data.count,
+      totalCount: tally.totalAnswerSnapshots,
+      pressureLabel,
+      mentionedQueries: [...data.queries].sort(),
+      sharePct
+    };
+  });
+  competitorRows.sort((a, b) => b.mentionCount - a.mentionCount);
+  return {
+    projectMentionCount: tally.projectMentionCount,
+    totalAnswerSnapshots: tally.totalAnswerSnapshots,
+    competitors: competitorRows
+  };
+}
 function buildMentionLandscape(snapshots, competitorDomains, projectBrandNames, projectDomains, queryLookup) {
-  let projectMentionCount = 0;
-  let totalAnswerSnapshots = 0;
-  const competitorMap = /* @__PURE__ */ new Map();
-  for (const c of competitorDomains) {
-    competitorMap.set(c, { count: 0, queries: /* @__PURE__ */ new Set() });
-  }
+  const classifier = compileQueryClassifier(projectBrandNames);
+  const nonBrand = emptySection(competitorDomains);
+  const branded = emptySection(competitorDomains);
+  const unclassified = emptySection(competitorDomains);
+  const competitorAliases = new Map(
+    competitorDomains.map((domain) => {
+      const label = brandLabelFromDomain(domain);
+      return [domain, brandKeyFromText(label).length >= MIN_DOMAIN_BRAND_KEY_LENGTH ? [label] : []];
+    })
+  );
   for (const snap of snapshots) {
     const text2 = snap.answerText;
     if (!text2) continue;
-    totalAnswerSnapshots++;
     const q = queryLookup.byId.get(snap.queryId);
-    const projectMentioned = snap.answerMentioned ?? determineAnswerMentioned(
+    const queryClass = classifier ? classifier.classify(q ?? null) : null;
+    const tally = queryClass === "branded" ? branded : queryClass === "non-brand" ? nonBrand : unclassified;
+    tally.totalAnswerSnapshots++;
+    const projectMentioned = determineAnswerMentioned(
       text2,
       [...projectBrandNames],
       [...projectDomains]
     );
-    if (projectMentioned) projectMentionCount++;
+    if (projectMentioned) tally.projectMentionCount++;
     for (const competitor of competitorDomains) {
-      const brand = brandLabelFromDomain(competitor);
-      const mentioned = determineAnswerMentioned(text2, brand ? [brand] : [], [competitor]);
+      const aliases = competitorAliases.get(competitor) ?? [];
+      const mentioned = determineAnswerMentioned(text2, aliases, [competitor]);
       if (mentioned) {
-        const entry = competitorMap.get(competitor);
+        const entry = tally.competitorMap.get(competitor);
         entry.count++;
         if (q) entry.queries.add(q);
       }
     }
   }
-  const totalMentionedSlots = projectMentionCount + [...competitorMap.values()].reduce((sum, v) => sum + v.count, 0);
-  const competitorRows = [...competitorMap.entries()].map(([domain, data]) => {
-    const ratio = totalAnswerSnapshots > 0 ? data.count / totalAnswerSnapshots : 0;
-    let pressureLabel = "None";
-    if (data.count > 0) {
-      if (ratio >= 0.5) pressureLabel = "High";
-      else if (ratio >= 0.2) pressureLabel = "Moderate";
-      else pressureLabel = "Low";
-    }
-    const sharePct = totalMentionedSlots > 0 ? Math.round(data.count / totalMentionedSlots * 100) : 0;
-    return {
-      domain,
-      mentionCount: data.count,
-      totalCount: totalAnswerSnapshots,
-      pressureLabel,
-      mentionedQueries: [...data.queries].sort(),
-      sharePct
-    };
-  });
-  competitorRows.sort((a, b) => b.mentionCount - a.mentionCount);
-  return { projectMentionCount, totalAnswerSnapshots, competitors: competitorRows };
+  const scope = classifier ? "non-brand" : "pooled";
+  const headline = toSection(scope === "non-brand" ? nonBrand : unclassified);
+  return {
+    // Kept at the top level so every existing reader of `projectMentionCount` /
+    // `competitors` gets the competitive figure rather than the pooled one.
+    ...headline,
+    scope,
+    nonBrand: headline,
+    branded: toSection(branded)
+  };
 }
 
 // ../intelligence/src/ai-source-origin.ts
@@ -8503,14 +8606,14 @@ function buildGapQueryScore(snapshots) {
   const byQuery = /* @__PURE__ */ new Map();
   for (const snap of snapshots) {
     const key = snap.queryId;
-    const current = byQuery.get(key) ?? { cited: false, competitorOverlap: /* @__PURE__ */ new Set() };
+    const current = byQuery.get(key) ?? { cited: false, citedCompetitors: /* @__PURE__ */ new Set() };
     if (snap.citationState === CitationStates.cited) current.cited = true;
-    for (const domain of snap.competitorOverlap) current.competitorOverlap.add(domain);
+    for (const domain of snap.citedCompetitorDomains) current.citedCompetitors.add(domain);
     byQuery.set(key, current);
   }
   const totalCount = byQuery.size;
   const gapCount = [...byQuery.values()].filter(
-    (entry) => !entry.cited && entry.competitorOverlap.size > 0
+    (entry) => !entry.cited && entry.citedCompetitors.size > 0
   ).length;
   const gapQueryLabel = gapCount === 1 ? "query" : "queries";
   return {
@@ -8540,14 +8643,14 @@ function buildMentionGapScore(snapshots) {
   const byQuery = /* @__PURE__ */ new Map();
   for (const snap of snapshots) {
     const key = snap.queryId;
-    const current = byQuery.get(key) ?? { mentioned: false, competitorOverlap: /* @__PURE__ */ new Set() };
+    const current = byQuery.get(key) ?? { mentioned: false, mentionedCompetitors: /* @__PURE__ */ new Set() };
     if (snap.answerMentioned === true) current.mentioned = true;
-    for (const domain of snap.competitorOverlap) current.competitorOverlap.add(domain);
+    for (const domain of snap.mentionedCompetitorDomains) current.mentionedCompetitors.add(domain);
     byQuery.set(key, current);
   }
   const totalCount = byQuery.size;
   const gapCount = [...byQuery.values()].filter(
-    (entry) => !entry.mentioned && entry.competitorOverlap.size > 0
+    (entry) => !entry.mentioned && entry.mentionedCompetitors.size > 0
   ).length;
   const gapQueryLabel = gapCount === 1 ? "query" : "queries";
   return {
@@ -8579,7 +8682,7 @@ function buildCompetitorPressureScore(snapshots, competitorDomains, totalTracked
   }
   let overlapCount = 0;
   for (const snap of snapshots) {
-    if (snap.competitorOverlap.some((domain) => hostMatchesAnyDomain(domain, competitorDomains))) {
+    if (snap.citedDomains.some((domain) => hostMatchesAnyDomain(domain, competitorDomains))) {
       overlapCount++;
     }
   }
@@ -8604,7 +8707,7 @@ function buildOverviewCompetitors(snapshots, competitors2, queryLookup) {
   return competitors2.map((competitor, index2) => {
     const citedQuerySet = /* @__PURE__ */ new Set();
     for (const snap of snapshots) {
-      if (snap.competitorOverlap.some((domain) => hostMatchesDomain(domain, competitor.domain)) || snap.citedDomains.some((domain) => hostMatchesDomain(domain, competitor.domain))) {
+      if (snap.citedDomains.some((domain) => hostMatchesDomain(domain, competitor.domain))) {
         if (snap.queryId) citedQuerySet.add(snap.queryId);
       }
     }
@@ -8715,15 +8818,62 @@ function collectProviderKeys(perRun) {
 }
 
 // ../intelligence/src/mention-share.ts
-function buildMentionShare(snapshots, options) {
-  const tooltip = 'When AI answers your tracked queries and names a brand, the % of brand-name-drops that are you vs your tracked competitors. Cleaner than Citation Coverage for "am I winning the conversation".';
-  const emptyBreakdown = {
+var MIN_BRAND_ALIAS_KEY_LENGTH = 3;
+function usableBrandAliases(aliases) {
+  return aliases.filter((alias2) => brandKeyFromText(alias2).length >= MIN_BRAND_ALIAS_KEY_LENGTH);
+}
+function emptyTally(competitors2) {
+  return {
     projectMentionSnapshots: 0,
-    competitorMentionSnapshots: 0,
-    perCompetitor: [],
     snapshotsWithAnswerText: 0,
-    snapshotsTotal: snapshots.length
+    snapshotsTotal: 0,
+    competitorCounts: new Map(competitors2.map((c) => [c.domain, 0]))
+  };
+}
+function toBreakdown(tally, competitors2) {
+  const competitorMentionSnapshots = [...tally.competitorCounts.values()].reduce((a, b) => a + b, 0);
+  const denom = tally.projectMentionSnapshots + competitorMentionSnapshots;
+  const perCompetitor = competitors2.map((c) => ({
+    domain: c.domain,
+    mentionSnapshots: tally.competitorCounts.get(c.domain) ?? 0,
+    shareOfCompetitiveTotal: competitorMentionSnapshots > 0 ? Math.round((tally.competitorCounts.get(c.domain) ?? 0) / competitorMentionSnapshots * 1e3) / 10 : 0
+  })).filter((row) => row.mentionSnapshots > 0).sort((a, b) => b.mentionSnapshots - a.mentionSnapshots || (a.domain < b.domain ? -1 : 1));
+  return {
+    projectMentionSnapshots: tally.projectMentionSnapshots,
+    competitorMentionSnapshots,
+    perCompetitor,
+    snapshotsWithAnswerText: tally.snapshotsWithAnswerText,
+    snapshotsTotal: tally.snapshotsTotal,
+    score: denom > 0 ? Math.round(tally.projectMentionSnapshots / denom * 100) : null
   };
+}
+function buildMentionShare(snapshots, options) {
+  const competitorMatchers = new Map(
+    options.competitors.map((c) => [c.domain, compileBrandAliases(usableBrandAliases([...c.brandTokens]))])
+  );
+  const nonBrand = emptyTally(options.competitors);
+  const branded = emptyTally(options.competitors);
+  const unclassified = emptyTally(options.competitors);
+  for (const snap of snapshots) {
+    const tally = snap.queryClass === "branded" ? branded : snap.queryClass === "non-brand" ? nonBrand : unclassified;
+    tally.snapshotsTotal++;
+    const text2 = snap.answerText ?? "";
+    if (text2.length === 0) continue;
+    tally.snapshotsWithAnswerText++;
+    if (snap.projectMentioned) tally.projectMentionSnapshots++;
+    for (const competitor of options.competitors) {
+      const matcher = competitorMatchers.get(competitor.domain);
+      if (matcher && matcherMatchesText(matcher, text2)) {
+        tally.competitorCounts.set(competitor.domain, (tally.competitorCounts.get(competitor.domain) ?? 0) + 1);
+      }
+    }
+  }
+  const classified = nonBrand.snapshotsTotal + branded.snapshotsTotal;
+  const classificationAvailable = options.classificationAvailable === true || classified > 0;
+  const scope = classificationAvailable ? "non-brand" : "pooled";
+  let headline = toBreakdown(scope === "non-brand" ? nonBrand : unclassified, options.competitors);
+  let brandedBreakdown = toBreakdown(branded, options.competitors);
+  const tooltip = scope === "non-brand" ? "On queries that do NOT contain your name, the % of brand-name-drops in AI answers that are you vs your tracked competitors. Branded queries are excluded on purpose: you are named on almost all of them and a competitor cannot be, so pooling them would hide how you place in your category." : "The % of brand-name-drops in AI answers that are you vs your tracked competitors across all tracked queries. This project has no usable brand alias, so branded and non-brand queries could not be separated and the result is labelled pooled.";
   if (snapshots.length === 0) {
     return {
       label: "Mention Share",
@@ -8733,10 +8883,14 @@ function buildMentionShare(snapshots, options) {
       description: "No mention share data yet. Trigger a run to start tracking.",
       tooltip,
       trend: [],
-      breakdown: emptyBreakdown
+      scope,
+      breakdown: headline,
+      branded: brandedBreakdown
     };
   }
   if (options.competitors.length === 0) {
+    headline = { ...headline, score: null };
+    brandedBreakdown = { ...brandedBreakdown, score: null };
     return {
       label: "Mention Share",
       value: "Add competitors",
@@ -8745,83 +8899,95 @@ function buildMentionShare(snapshots, options) {
       description: "Mention Share is a head-to-head competitive metric \u2014 add tracked competitors to compare brand mention rates.",
       tooltip,
       trend: [],
-      breakdown: emptyBreakdown
+      scope,
+      breakdown: headline,
+      branded: brandedBreakdown
     };
   }
-  let projectMentionSnapshots = 0;
-  let snapshotsWithAnswerText = 0;
-  const competitorCounts = /* @__PURE__ */ new Map();
-  const competitorAliases = /* @__PURE__ */ new Map();
-  for (const competitor of options.competitors) {
-    competitorCounts.set(competitor.domain, 0);
-    competitorAliases.set(
-      competitor.domain,
-      competitor.brandTokens.filter((alias2) => brandKeyFromText(alias2).length >= 3)
-    );
+  const score = headline.score;
+  const denom = headline.projectMentionSnapshots + headline.competitorMentionSnapshots;
+  if (scope === "non-brand" && nonBrand.snapshotsTotal === 0) {
+    return {
+      label: "Mention Share",
+      value: "No non-brand queries",
+      delta: branded.snapshotsTotal > 0 ? `${branded.snapshotsTotal} branded ${branded.snapshotsTotal === 1 ? "snapshot" : "snapshots"} only` : "No answers to score",
+      tone: "neutral",
+      description: "Every tracked query names your brand. Branded queries measure recognition, not competitive placement \u2014 add category queries to measure where you place.",
+      tooltip,
+      trend: [],
+      scope,
+      breakdown: headline,
+      branded: brandedBreakdown
+    };
   }
-  for (const snap of snapshots) {
-    const text2 = snap.answerText ?? "";
-    if (text2.length === 0) continue;
-    snapshotsWithAnswerText++;
-    if (snap.projectMentioned) projectMentionSnapshots++;
-    for (const competitor of options.competitors) {
-      const aliases = competitorAliases.get(competitor.domain) ?? [];
-      if (textContainsAnyBrandAlias(text2, aliases)) {
-        competitorCounts.set(competitor.domain, (competitorCounts.get(competitor.domain) ?? 0) + 1);
-      }
-    }
+  if (headline.snapshotsTotal > 0 && headline.snapshotsWithAnswerText === 0) {
+    const brandedAnswers = brandedBreakdown.snapshotsWithAnswerText;
+    return {
+      label: "Mention Share",
+      value: scope === "non-brand" ? "No non-brand answers" : "No answers",
+      delta: scope === "non-brand" && brandedAnswers > 0 ? `${brandedAnswers} branded ${brandedAnswers === 1 ? "answer" : "answers"} only` : "No answers to score",
+      tone: "neutral",
+      description: scope === "non-brand" ? "Non-brand queries are tracked, but no answer text was recorded for them in this run." : "Tracked queries exist, but no answer text was recorded in this run.",
+      tooltip,
+      trend: [],
+      scope,
+      breakdown: headline,
+      branded: brandedBreakdown
+    };
+  }
+  if (score === null) {
+    return {
+      label: "Mention Share",
+      value: "No mentions",
+      delta: scopeLabel(scope, "No brand mentions in this run"),
+      tone: "neutral",
+      description: describe({ scope, score, breakdown: headline, branded: brandedBreakdown }),
+      tooltip,
+      trend: [],
+      scope,
+      breakdown: headline,
+      branded: brandedBreakdown
+    };
   }
-  const competitorMentionSnapshots = [...competitorCounts.values()].reduce((a, b) => a + b, 0);
-  const denom = projectMentionSnapshots + competitorMentionSnapshots;
-  const score = denom > 0 ? Math.round(projectMentionSnapshots / denom * 100) : 0;
-  const perCompetitor = options.competitors.map((c) => ({
-    domain: c.domain,
-    mentionSnapshots: competitorCounts.get(c.domain) ?? 0,
-    shareOfCompetitiveTotal: competitorMentionSnapshots > 0 ? Math.round((competitorCounts.get(c.domain) ?? 0) / competitorMentionSnapshots * 1e3) / 10 : 0
-  })).filter((row) => row.mentionSnapshots > 0).sort((a, b) => b.mentionSnapshots - a.mentionSnapshots);
-  const breakdown = {
-    projectMentionSnapshots,
-    competitorMentionSnapshots,
-    perCompetitor,
-    snapshotsWithAnswerText,
-    snapshotsTotal: snapshots.length
-  };
-  const description = describe({
-    score,
-    projectMentionSnapshots,
-    competitorMentionSnapshots,
-    perCompetitor
-  });
   return {
     label: "Mention Share",
-    value: denom > 0 ? `${score}` : "0",
-    delta: denom > 0 ? `${projectMentionSnapshots} of ${denom} brand mentions` : "No brand mentions in this run",
-    tone: denom > 0 ? mentionShareTone(score) : "neutral",
-    description,
+    value: `${score}`,
+    delta: scopeLabel(scope, `${headline.projectMentionSnapshots} of ${denom} brand mentions`),
+    tone: mentionShareTone(score),
+    description: describe({ scope, score, breakdown: headline, branded: brandedBreakdown }),
     tooltip,
     trend: [],
-    progress: denom > 0 ? score : 0,
-    breakdown
+    progress: score,
+    scope,
+    breakdown: headline,
+    branded: brandedBreakdown
   };
 }
+function scopeLabel(scope, body) {
+  return scope === "non-brand" ? `${body} \xB7 non-brand queries` : `${body} \xB7 pooled queries \xB7 classification unavailable`;
+}
 function mentionShareTone(score) {
   if (score >= 50) return "positive";
   if (score >= 25) return "caution";
   return "negative";
 }
 function describe(parts) {
-  const { score, projectMentionSnapshots, competitorMentionSnapshots, perCompetitor } = parts;
+  const { scope, score, breakdown, branded } = parts;
+  const { projectMentionSnapshots, competitorMentionSnapshots, perCompetitor } = breakdown;
+  const where = scope === "non-brand" ? "on non-brand queries" : "across your tracked queries";
+  const brandedNote = branded.snapshotsWithAnswerText > 0 && branded.score !== null ? ` Separately, you are named in ${branded.projectMentionSnapshots} of ${branded.snapshotsWithAnswerText} answers to queries that contain your name.` : "";
   if (projectMentionSnapshots === 0 && competitorMentionSnapshots === 0) {
-    return "No brand mentions detected for you or your tracked competitors in this run.";
+    return `No brand mentions detected for you or your tracked competitors ${where}.${brandedNote}`;
   }
   if (competitorMentionSnapshots === 0) {
-    return `${projectMentionSnapshots} brand mentions of you, zero competitor mentions \u2014 you own the conversation.`;
+    return `${projectMentionSnapshots} brand mentions of you and zero competitor mentions ${where} \u2014 you own the conversation.${brandedNote}`;
   }
   const top = perCompetitor[0];
+  const total = projectMentionSnapshots + competitorMentionSnapshots;
   if (!top) {
-    return `${score}% of brand mentions are you (${projectMentionSnapshots} of ${projectMentionSnapshots + competitorMentionSnapshots}).`;
+    return `${score}% of brand mentions ${where} are you (${projectMentionSnapshots} of ${total}).${brandedNote}`;
   }
-  return `${score}% of brand mentions are you. Top competitor: ${top.domain} (${top.mentionSnapshots} mentions).`;
+  return `${score}% of brand mentions ${where} are you. Top competitor: ${top.domain} (${top.mentionSnapshots} mentions).${brandedNote}`;
 }
 
 // ../intelligence/src/suggested-queries.ts
@@ -13283,6 +13449,8 @@ function loadRunDetail(app, run) {
     ownedDomains: projects.ownedDomains,
     aliases: projects.aliases
   }).from(projects).where(eq11(projects.id, run.projectId)).get();
+  const competitorDomains = app.db.select({ domain: competitors.domain }).from(competitors).where(eq11(competitors.projectId, run.projectId)).all().map((row) => row.domain);
+  const competitiveSignalResolver = compileCompetitiveSignalResolver(competitorDomains);
   const snapshots = app.db.select({
     id: querySnapshots.id,
     runId: querySnapshots.runId,
@@ -13316,6 +13484,14 @@ function loadRunDetail(app, run) {
     ...formatRun(run),
     snapshots: snapshots.map((s) => {
       const rawParsed = parseSnapshotRawResponse(s.rawResponse);
+      const signalGroundingSources = rawParsed.groundingSources.filter(
+        (source) => typeof source === "object" && source !== null && typeof source.uri === "string"
+      );
+      const competitiveSignals = competitiveSignalResolver.resolve({
+        citedDomains: s.citedDomains,
+        groundingSources: signalGroundingSources,
+        answerText: s.answerText
+      });
       const answerMentioned = project ? resolveSnapshotAnswerMentioned(s, project) : s.answerMentioned ?? false;
       return {
         id: s.id,
@@ -13336,6 +13512,8 @@ function loadRunDetail(app, run) {
         sourceCount: s.sourceCount,
         resolvedCount: s.resolvedCount,
         captureVersion: s.captureVersion,
+        ...competitiveSignals,
+        // Legacy mixed signal retained for backwards compatibility.
         competitorOverlap: s.competitorOverlap,
         recommendedCompetitors: s.recommendedCompetitors,
         matchedTerms: project ? resolveSnapshotMatchedTerms(s, project) : [],
@@ -20164,6 +20342,8 @@ async function historyRoutes(app) {
     if (projectRuns.length === 0) {
       return reply.send({ snapshots: [], total: 0 });
     }
+    const competitorDomains = app.db.select({ domain: competitors.domain }).from(competitors).where(eq22(competitors.projectId, project.id)).all().map((row) => row.domain);
+    const competitiveSignalResolver = compileCompetitiveSignalResolver(competitorDomains);
     const allSnapshots = app.db.select({
       id: querySnapshots.id,
       runId: querySnapshots.runId,
@@ -20183,6 +20363,7 @@ async function historyRoutes(app) {
       competitorOverlap: querySnapshots.competitorOverlap,
       recommendedCompetitors: querySnapshots.recommendedCompetitors,
       location: querySnapshots.location,
+      rawResponse: querySnapshots.rawResponse,
       createdAt: querySnapshots.createdAt
     }).from(querySnapshots).leftJoin(queries, eq22(querySnapshots.queryId, queries.id)).where(inArray8(querySnapshots.runId, projectRuns.map((r) => r.id))).orderBy(desc7(querySnapshots.createdAt)).all();
     const locationFilter = request.query.location;
@@ -20190,29 +20371,43 @@ async function historyRoutes(app) {
     const total = filtered.length;
     const paged = filtered.slice(offset, offset + limit);
     return reply.send({
-      snapshots: paged.map((s) => ({
-        id: s.id,
-        runId: s.runId,
-        queryId: s.queryId,
-        query: s.query,
-        provider: s.provider,
-        model: s.model,
-        citationState: s.citationState,
-        answerMentioned: resolveSnapshotAnswerMentioned(s, project),
-        visibilityState: resolveSnapshotVisibilityState(s, project),
-        mentionState: resolveSnapshotMentionState(s, project),
-        answerText: s.answerText,
-        citedDomains: s.citedDomains,
-        citedUrls: s.citedUrls,
-        captureStatus: s.captureStatus,
-        sourceCount: s.sourceCount,
-        resolvedCount: s.resolvedCount,
-        captureVersion: s.captureVersion,
-        competitorOverlap: s.competitorOverlap,
-        recommendedCompetitors: s.recommendedCompetitors,
-        location: s.location,
-        createdAt: s.createdAt
-      })),
+      snapshots: paged.map((s) => {
+        const rawResponse = parseJsonColumn(s.rawResponse, {});
+        const rawGroundingSources = Array.isArray(rawResponse.groundingSources) ? rawResponse.groundingSources : [];
+        const groundingSources = rawGroundingSources.filter(
+          (source) => typeof source === "object" && source !== null && typeof source.uri === "string"
+        );
+        const competitiveSignals = competitiveSignalResolver.resolve({
+          citedDomains: s.citedDomains,
+          groundingSources,
+          answerText: s.answerText
+        });
+        return {
+          id: s.id,
+          runId: s.runId,
+          queryId: s.queryId,
+          query: s.query,
+          provider: s.provider,
+          model: s.model,
+          citationState: s.citationState,
+          answerMentioned: resolveSnapshotAnswerMentioned(s, project),
+          visibilityState: resolveSnapshotVisibilityState(s, project),
+          mentionState: resolveSnapshotMentionState(s, project),
+          answerText: s.answerText,
+          citedDomains: s.citedDomains,
+          citedUrls: s.citedUrls,
+          captureStatus: s.captureStatus,
+          sourceCount: s.sourceCount,
+          resolvedCount: s.resolvedCount,
+          captureVersion: s.captureVersion,
+          ...competitiveSignals,
+          // Legacy mixed signal retained for backwards compatibility.
+          competitorOverlap: s.competitorOverlap,
+          recommendedCompetitors: s.recommendedCompetitors,
+          location: s.location,
+          createdAt: s.createdAt
+        };
+      }),
       total
     });
   });
@@ -20451,6 +20646,61 @@ function parseOptionalPositiveInt(value, max2) {
 // ../api-routes/src/analytics.ts
 import { and as and17, desc as desc8, eq as eq23, gte as gte4, inArray as inArray9, lt as lt4 } from "drizzle-orm";
 
+// ../api-routes/src/mention-share-inputs.ts
+function mentionShareCompetitorsFromDomains(domains) {
+  return domains.map((domain) => {
+    const exactDomain = hostOf(domain);
+    const domainLabel = brandLabelFromDomain(domain);
+    return {
+      domain,
+      // A short registrable label is too noisy by itself (`AI`), but the full
+      // written domain is operator-approved identity (`ai.com`). Feeding both
+      // through the shared matcher keeps every mention-share surface aligned.
+      brandTokens: usableBrandAliases([
+        ...brandKeyFromText(domainLabel).length >= MIN_DOMAIN_BRAND_KEY_LENGTH ? [domainLabel] : [],
+        ...exactDomain?.includes(".") ? [exactDomain] : []
+      ])
+    };
+  });
+}
+function projectQueryClassifier(project) {
+  const classifier = compileQueryClassifier(effectiveBrandNames({
+    displayName: project.displayName ?? null,
+    aliases: project.aliases ?? null,
+    canonicalDomain: project.canonicalDomain ?? null,
+    ownedDomains: project.ownedDomains ?? null
+  }));
+  return classifier ? (queryText) => classifier.classify(queryText) : null;
+}
+function buildMentionShareInputs(opts) {
+  const classify = projectQueryClassifier(opts.project);
+  const projectBrandNames = effectiveBrandNames({
+    displayName: opts.project.displayName ?? null,
+    aliases: opts.project.aliases ?? null,
+    canonicalDomain: opts.project.canonicalDomain ?? null,
+    ownedDomains: opts.project.ownedDomains ?? null
+  });
+  const projectDomains = effectiveDomains({
+    canonicalDomain: opts.project.canonicalDomain ?? "",
+    ownedDomains: opts.project.ownedDomains ?? []
+  });
+  return {
+    classified: classify !== null,
+    competitors: mentionShareCompetitorsFromDomains(opts.competitorDomains),
+    snapshots: opts.snapshots.map((snap) => {
+      const queryText = (snap.queryId ? opts.queryTextById?.get(snap.queryId) : void 0) ?? snap.queryText ?? null;
+      return {
+        // Mention share is a current-identity metric. Recompute stored answer
+        // text after an alias/domain rename; only text-less legacy rows need
+        // the persisted run-time boolean as a fallback.
+        projectMentioned: snap.answerText ? determineAnswerMentioned(snap.answerText, projectBrandNames, projectDomains) : snap.answerMentioned === true,
+        answerText: snap.answerText,
+        queryClass: classify ? classify(queryText) : null
+      };
+    })
+  };
+}
+
 // ../api-routes/src/model-evidence.ts
 function classifyModelEvidence(values) {
   const models = /* @__PURE__ */ new Set();
@@ -20579,6 +20829,8 @@ function measuredWhole(db, run) {
 async function analyticsRoutes(app) {
   app.get("/projects/:name/analytics/metrics", async (request, reply) => {
     const project = resolveProject(app.db, request.params.name);
+    const classifyQuery = projectQueryClassifier(project);
+    const mentionShareScope = classifyQuery ? "non-brand" : "pooled";
     const window = parseWindow(request.query.window);
     const cutoff = windowCutoff(window);
     const projectRuns = app.db.select().from(runs).where(and17(
@@ -20591,6 +20843,7 @@ async function analyticsRoutes(app) {
     if (projectRuns.length === 0) {
       return reply.send({
         window,
+        mentionShareScope,
         buckets: [],
         overall: { citationRate: 0, cited: 0, total: 0, mentionRate: 0, mentionedCount: 0 },
         byProvider: {},
@@ -20637,16 +20890,16 @@ async function analyticsRoutes(app) {
       ...s,
       runCreatedAt: runCreatedAt.get(s.runId),
       resolvedMentioned: resolveSnapshotAnswerMentioned(s, project),
+      queryClass: classifyQuery ? classifyQuery((s.queryId ? queryTextById.get(s.queryId) : void 0) ?? s.queryText ?? null) : null,
       // Falls back to the id if no text resolves, so two distinct queries can
       // never collapse into one member on an empty key. (An orphan only gets
       // this far when its text matched the basket, so its key is never empty.)
       basketKey: normalizeQueryText(s.queryText ?? (s.queryId ? queryTextById.get(s.queryId) ?? "" : "")) || s.queryId || "",
       runBasketRevision: runBasketRevision.get(s.runId) ?? null
     }));
-    const mentionShareCompetitors = app.db.select({ domain: competitors.domain }).from(competitors).where(eq23(competitors.projectId, project.id)).all().map((c) => ({
-      domain: c.domain,
-      brandTokens: [brandLabelFromDomain(c.domain)].filter((t) => t.length >= 3)
-    }));
+    const mentionShareCompetitors = mentionShareCompetitorsFromDomains(
+      app.db.select({ domain: competitors.domain }).from(competitors).where(eq23(competitors.projectId, project.id)).all().map((c) => c.domain)
+    );
     const overall = computeProviderMetric(allSnapshots);
     const byProvider = {};
     const providers = new Set(allSnapshots.map((s) => s.provider));
@@ -20657,7 +20910,15 @@ async function analyticsRoutes(app) {
     const latest = new Date(projectRuns[projectRuns.length - 1].createdAt);
     const spanDays = Math.max(1, Math.ceil((latest.getTime() - earliest.getTime()) / 864e5));
     const bucketSize = bucketSizeForSpan(spanDays);
-    const buckets = computeBuckets(allSnapshots, projectRuns, bucketSize, queryCreatedAt, mentionShareCompetitors, referenceBasket);
+    const buckets = computeBuckets(
+      allSnapshots,
+      projectRuns,
+      bucketSize,
+      queryCreatedAt,
+      mentionShareCompetitors,
+      referenceBasket,
+      classifyQuery !== null
+    );
     const anchors = {};
     const anchorObservedAt = {};
     const anchorUnavailable = /* @__PURE__ */ new Set();
@@ -20821,7 +21082,7 @@ async function analyticsRoutes(app) {
       }
       previousExecutionChecksum = identity.checksum;
     }
-    return reply.send({ window, buckets, overall, byProvider, trend, mentionTrend, queryChanges, basketChanges, executionIdentityChanges, referenceBasketRevision: latestBasket?.revision ?? null, modelAttribution, servedModelAttribution, modelServiceMismatch, modelPointerChanges });
+    return reply.send({ window, mentionShareScope, buckets, overall, byProvider, trend, mentionTrend, queryChanges, basketChanges, executionIdentityChanges, referenceBasketRevision: latestBasket?.revision ?? null, modelAttribution, servedModelAttribution, modelServiceMismatch, modelPointerChanges });
   });
   app.get("/projects/:name/analytics/gaps", async (request, reply) => {
     const project = resolveProject(app.db, request.params.name);
@@ -20836,6 +21097,10 @@ async function analyticsRoutes(app) {
     }
     const windowRuns = app.db.select().from(runs).where(and17(eq23(runs.projectId, project.id), eq23(runs.kind, RunKinds["answer-visibility"]), notProbeRun())).orderBy(runs.createdAt).all().filter((r) => r.status === "completed" || r.status === "partial").filter((r) => measuredWhole(app.db, r)).filter((r) => !cutoff || r.createdAt >= cutoff);
     const windowRunIds = windowRuns.map((r) => r.id);
+    const competitorDomains = app.db.select({ domain: competitors.domain }).from(competitors).where(eq23(competitors.projectId, project.id)).all().map((c) => c.domain);
+    const competitorMatchers = new Map(
+      mentionShareCompetitorsFromDomains(competitorDomains).map((c) => [c.domain, compileBrandAliases([...c.brandTokens])])
+    );
     const runIdToCreatedAt = new Map(windowRuns.map((r) => [r.id, r.createdAt]));
     const consistencyMap = /* @__PURE__ */ new Map();
     if (windowRunIds.length > 0) {
@@ -20865,7 +21130,7 @@ async function analyticsRoutes(app) {
       citationState: querySnapshots.citationState,
       answerMentioned: querySnapshots.answerMentioned,
       answerText: querySnapshots.answerText,
-      competitorOverlap: querySnapshots.competitorOverlap
+      citedDomains: querySnapshots.citedDomains
     }).from(querySnapshots).leftJoin(queries, eq23(querySnapshots.queryId, queries.id)).where(inArray9(querySnapshots.runId, latestGroupRunIds)).all());
     const snapshots = rawSnapshots.map((s) => ({
       ...s,
@@ -20889,9 +21154,17 @@ async function analyticsRoutes(app) {
       const citedProviders = qSnapshots.filter((s) => s.citationState === CitationStates.cited).map((s) => s.provider);
       const mentionedProviders = qSnapshots.filter((s) => s.resolvedMentioned).map((s) => s.provider);
       const competitorsCiting = /* @__PURE__ */ new Set();
+      const competitorsMentioned = /* @__PURE__ */ new Set();
       for (const s of qSnapshots) {
-        const overlap = s.competitorOverlap;
-        for (const c of overlap) competitorsCiting.add(c);
+        for (const domain of s.citedDomains) {
+          const match = competitorDomains.find((c) => hostMatchesDomain(domain, c));
+          if (match) competitorsCiting.add(match);
+        }
+        if (!s.answerText) continue;
+        for (const competitor of competitorDomains) {
+          const matcher = competitorMatchers.get(competitor);
+          if (matcher && matcherMatchesText(matcher, s.answerText)) competitorsMentioned.add(competitor);
+        }
       }
       const cons = consistencyMap.get(queryId);
       const consistency = {
@@ -20913,6 +21186,7 @@ async function analyticsRoutes(app) {
         category,
         providers: citedProviders,
         competitorsCiting: [...competitorsCiting],
+        competitorsMentioned: [...competitorsMentioned],
         consistency
       };
       if (category === "cited") cited.push(citationEntry);
@@ -20921,7 +21195,7 @@ async function analyticsRoutes(app) {
       let mentionCategory;
       if (mentionedProviders.length > 0) {
         mentionCategory = "cited";
-      } else if (competitorsCiting.size > 0) {
+      } else if (competitorsMentioned.size > 0) {
         mentionCategory = "gap";
       } else {
         mentionCategory = "uncited";
@@ -20932,6 +21206,7 @@ async function analyticsRoutes(app) {
         category: mentionCategory,
         providers: mentionedProviders,
         competitorsCiting: [...competitorsCiting],
+        competitorsMentioned: [...competitorsMentioned],
         consistency
       };
       if (mentionCategory === "cited") mentionedQueries.push(mentionEntry);
@@ -20941,7 +21216,7 @@ async function analyticsRoutes(app) {
     gap.sort((a, b) => b.competitorsCiting.length - a.competitorsCiting.length);
     cited.sort((a, b) => a.query.localeCompare(b.query));
     uncited.sort((a, b) => a.query.localeCompare(b.query));
-    mentionGap.sort((a, b) => b.competitorsCiting.length - a.competitorsCiting.length);
+    mentionGap.sort((a, b) => b.competitorsMentioned.length - a.competitorsMentioned.length);
     mentionedQueries.sort((a, b) => a.query.localeCompare(b.query));
     notMentioned.sort((a, b) => a.query.localeCompare(b.query));
     return reply.send({ cited, gap, uncited, mentionedQueries, mentionGap, notMentioned, runId: latestRun.id, window });
@@ -21058,7 +21333,7 @@ function computeProviderMetric(snapshots) {
     mentionedCount
   };
 }
-function computeBuckets(snapshots, projectRuns, bucketDays, queryCreatedAt, mentionShareCompetitors = [], referenceBasket) {
+function computeBuckets(snapshots, projectRuns, bucketDays, queryCreatedAt, mentionShareCompetitors = [], referenceBasket, classificationAvailable = false) {
   if (projectRuns.length === 0) return [];
   const earliest = new Date(projectRuns[0].createdAt);
   const latest = new Date(projectRuns[projectRuns.length - 1].createdAt);
@@ -21107,7 +21382,7 @@ function computeBuckets(snapshots, projectRuns, bucketDays, queryCreatedAt, ment
         queryCount,
         mentionRate: metric2.mentionRate,
         mentionedCount: metric2.mentionedCount,
-        mentionShare: computeMentionShareBucketMetric(usable, mentionShareCompetitors),
+        mentionShare: computeMentionShareBucketMetric(usable, mentionShareCompetitors, classificationAvailable),
         byProvider,
         modelEvidenceByProvider,
         basketRevision
@@ -21126,22 +21401,23 @@ function bucketStartDateFor(observedAt, earliest, bucketDays) {
   const offset = Math.max(0, Math.floor((observationDay.getTime() - firstBucketStart.getTime()) / bucketMilliseconds));
   return new Date(firstBucketStart.getTime() + offset * bucketMilliseconds).toISOString();
 }
-function computeMentionShareBucketMetric(snapshots, mentionShareCompetitors) {
-  if (mentionShareCompetitors.length === 0) {
-    return { rate: null, projectMentionSnapshots: 0, competitorMentionSnapshots: 0 };
-  }
+function computeMentionShareBucketMetric(snapshots, mentionShareCompetitors, classificationAvailable) {
   const result = buildMentionShare(
     snapshots.map((s) => ({
       projectMentioned: s.resolvedMentioned,
-      answerText: s.answerText
+      answerText: s.answerText,
+      queryClass: s.queryClass
     })),
-    { competitors: mentionShareCompetitors }
+    { competitors: mentionShareCompetitors, classificationAvailable }
   );
   const projectMentionSnapshots = result.breakdown.projectMentionSnapshots;
   const competitorMentionSnapshots = result.breakdown.competitorMentionSnapshots;
   const denominator = projectMentionSnapshots + competitorMentionSnapshots;
   return {
-    rate: denominator > 0 ? round4(projectMentionSnapshots / denominator) : null,
+    scope: result.scope,
+    // A project-only denominator is recognition evidence, not competitive
+    // share. Preserve the count but leave the rate undefined without a frame.
+    rate: mentionShareCompetitors.length > 0 && denominator > 0 ? round4(projectMentionSnapshots / denominator) : null,
     projectMentionSnapshots,
     competitorMentionSnapshots
   };
@@ -21725,20 +22001,27 @@ function aggregateCandidate(opts) {
   const ourCitedRate = citedCount / totalSnaps;
   const recentMissRate = 1 - ourCitedRate;
   const competitorTally = /* @__PURE__ */ new Map();
+  const competitorMentionTally = /* @__PURE__ */ new Map();
+  const competitiveSignalResolver = compileCompetitiveSignalResolver([...opts.competitorSet]);
   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;
-    const competitorOverlap = snap.competitorOverlap;
-    for (const domain of competitorOverlap) {
-      const normalized = hostOf(domain) ?? "";
-      const competitor = findMatchingDomain(normalized, opts.competitorSet);
-      if (!competitor) continue;
-      competitorTally.set(competitor, (competitorTally.get(competitor) ?? 0) + 1);
-    }
     const grounding = extractGroundingSources(snap.rawResponse);
+    const competitiveSignals = competitiveSignalResolver.resolve({
+      citedDomains: snap.citedDomains,
+      groundingSources: grounding,
+      answerText: snap.answerText
+    });
+    const citedCompetitorsHere = /* @__PURE__ */ new Set();
+    for (const competitor of competitiveSignals.citedCompetitorDomains) {
+      citedCompetitorsHere.add(competitor);
+    }
+    for (const competitor of competitiveSignals.mentionedCompetitorDomains) {
+      competitorMentionTally.set(competitor, (competitorMentionTally.get(competitor) ?? 0) + 1);
+    }
     for (const g of grounding) {
       const domain = hostOf(g.uri) ?? "";
       if (!domain) continue;
@@ -21748,9 +22031,14 @@ function aggregateCandidate(opts) {
         continue;
       }
       citedSurfaceTally.set(domain, (citedSurfaceTally.get(domain) ?? 0) + 1);
-      if (!findMatchingDomain(domain, opts.competitorSet)) continue;
+      const competitor = findMatchingDomain(domain, opts.competitorSet);
+      if (!competitor) continue;
+      citedCompetitorsHere.add(competitor);
       recordGroundingHit(competitorGroundingTally, g, domain, snap.provider);
     }
+    for (const competitor of citedCompetitorsHere) {
+      competitorTally.set(competitor, (competitorTally.get(competitor) ?? 0) + 1);
+    }
   }
   return {
     query: opts.query,
@@ -21761,8 +22049,10 @@ function aggregateCandidate(opts) {
     gscCtr: opts.gsc?.ctr ?? 0,
     ourCitedRate,
     ourCitedInLatestRun,
-    competitorDomains: Array.from(competitorTally.keys()),
+    competitorCitedDomains: Array.from(competitorTally.keys()),
+    competitorMentionedDomains: Array.from(competitorMentionTally.keys()),
     competitorCitationCount: Array.from(competitorTally.values()).reduce((a, b) => a + b, 0),
+    competitorMentionCount: Array.from(competitorMentionTally.values()).reduce((a, b) => a + b, 0),
     recentMissRate,
     ourGroundingUrls: Array.from(ourGroundingTally.values()),
     competitorGroundingUrls: Array.from(competitorGroundingTally.values()),
@@ -21800,8 +22090,10 @@ function emptyCandidate(query) {
     gscCtr: 0,
     ourCitedRate: 0,
     ourCitedInLatestRun: false,
-    competitorDomains: [],
+    competitorCitedDomains: [],
+    competitorMentionedDomains: [],
     competitorCitationCount: 0,
+    competitorMentionCount: 0,
     recentMissRate: 0,
     ourGroundingUrls: [],
     competitorGroundingUrls: [],
@@ -22773,6 +23065,15 @@ table.report-table td .badge {
   grid-template-columns: repeat(auto-fit, minmax(360px, 1fr));
   gap: 16px;
 }
+.mention-branded-block {
+  margin-top: 20px;
+}
+.chart-note {
+  font-size: 12px;
+  line-height: 1.6;
+  color: #4b5563;
+  margin: 0 0 12px;
+}
 .legend {
   display: flex;
   flex-wrap: wrap;
@@ -23578,18 +23879,24 @@ function renderCompetitorBars(landscape, canonical) {
   ];
   return renderLandscapeBars(data, "Citations per domain", "Citations per domain bar chart");
 }
-function renderMentionBars(landscape, canonical) {
+function renderMentionBars(section2, canonical, title) {
   const data = [
-    { label: canonical, count: landscape.projectMentionCount, isProject: true },
-    ...landscape.competitors.map((c) => ({ label: c.domain, count: c.mentionCount, isProject: false }))
+    { label: canonical, count: section2.projectMentionCount, isProject: true },
+    ...section2.competitors.map((c) => ({ label: c.domain, count: c.mentionCount, isProject: false }))
   ];
-  return renderLandscapeBars(data, "Mentions per domain", "Mentions per domain bar chart");
+  return renderLandscapeBars(data, title, `${title} bar chart`);
 }
+var MENTION_SCOPE_LABEL = {
+  "non-brand": "non-brand queries",
+  pooled: "pooled queries \xB7 classification unavailable"
+};
 function renderCompetitorLandscape(report) {
   const competitors2 = report.competitorLandscape.competitors;
   const mentionLandscape = report.mentionLandscape;
   const noCitationData = competitors2.length === 0 && report.competitorLandscape.projectCitationCount === 0;
-  const noMentionData = mentionLandscape.competitors.length === 0 && mentionLandscape.projectMentionCount === 0;
+  const brandedMentions = mentionLandscape.branded;
+  const hasBrandedMentions = (brandedMentions?.totalAnswerSnapshots ?? 0) > 0;
+  const noMentionData = mentionLandscape.competitors.length === 0 && mentionLandscape.projectMentionCount === 0 && !hasBrandedMentions;
   if (noCitationData && noMentionData) {
     return section(
       { id: "competitor-landscape", eyebrow: "Section 4", title: "Competitor Landscape" },
@@ -23614,13 +23921,26 @@ function renderCompetitorLandscape(report) {
       <td>${escapeHtml(c.citedQueries.slice(0, 5).join(", "))}${c.citedQueries.length > 5 ? "\u2026" : ""}${pagesDisclosure}</td>
     </tr>`;
   }).join("");
+  const scopeLabel2 = MENTION_SCOPE_LABEL[mentionLandscape.scope] ?? MENTION_SCOPE_LABEL.pooled;
+  const mentionScopeTooltip = mentionLandscape.scope === "non-brand" ? `Mentions on ${scopeLabel2}. Branded queries are counted separately \u2014 the client is named on nearly all of them and a competitor cannot be, so pooling the two would rank the client on its own brand recall.` : `Mentions on ${scopeLabel2}. The project has no usable brand identity for a branded/non-brand split, so all tracked queries remain pooled and this is not a competitive category read.`;
   const table = competitors2.length > 0 ? `<table class="report-table">
-        <thead><tr><th>Domain</th><th>Pressure</th><th>Citations</th><th class="numeric">Mentions</th><th class="numeric" title="Citation share \u2014 % of cited-source slots that went to this competitor across tracked queries. Distinct from Mention Share.">Citation share</th><th>Cited queries</th></tr></thead>
+        <thead><tr><th>Domain</th><th>Pressure</th><th>Citations</th><th class="numeric" title="${escapeHtml(mentionScopeTooltip)}">Mentions (${escapeHtml(scopeLabel2)})</th><th class="numeric" title="Citation share \u2014 % of cited-source slots that went to this competitor across tracked queries. Distinct from Mention Share.">Citation share</th><th>Cited queries</th></tr></thead>
         <tbody>${rows}</tbody>
       </table>` : renderEmpty("No competitors configured.");
   const citationBars = renderCompetitorBars(report.competitorLandscape, report.meta.project.canonicalDomain);
-  const mentionBars = renderMentionBars(mentionLandscape, report.meta.project.canonicalDomain);
+  const mentionBars = renderMentionBars(
+    mentionLandscape,
+    report.meta.project.canonicalDomain,
+    `Mentions per domain \xB7 ${scopeLabel2}`
+  );
   const charts = citationBars && mentionBars ? `<div class="chart-grid">${citationBars}${mentionBars}</div>` : `${citationBars}${mentionBars}`;
+  const mentionShareUnavailable = mentionLandscape.projectMentionCount === 0 && mentionLandscape.competitors.length > 0 && mentionLandscape.competitors.every((row) => row.sharePct === null);
+  const mentionShareNote = mentionShareUnavailable ? `<p class="chart-note">Mention share unavailable for ${escapeHtml(scopeLabel2)}: no tracked brand was named, so the denominator is 0.</p>` : "";
+  const brandedBars = hasBrandedMentions && brandedMentions ? renderMentionBars(brandedMentions, report.meta.project.canonicalDomain, "Mentions per domain \xB7 branded queries") : "";
+  const brandedBlock = brandedBars ? `<div class="mention-branded-block">
+        <p class="chart-note">Branded queries contain the client's own name. The client is named on nearly all of them and a competitor structurally cannot be, so these are kept out of the competitive figure above. Read them as brand recall: ${brandedMentions?.projectMentionCount ?? 0} of ${brandedMentions?.totalAnswerSnapshots ?? 0} branded answers named the client.</p>
+        ${brandedBars}
+      </div>` : "";
   return section(
     {
       id: "competitor-landscape",
@@ -23628,7 +23948,7 @@ function renderCompetitorLandscape(report) {
       title: "Competitor Landscape",
       intro: "Who AI engines cite and mention instead of the client."
     },
-    `${charts}${table}`
+    `${mentionShareNote}${charts}${table}${brandedBlock}`
   );
 }
 var SOURCE_CATEGORY_TONE = {
@@ -24752,19 +25072,22 @@ function buildGaSection(db, projectId, windowDays2) {
     )
   ).limit(1).get() : void 0;
   const fallbackSummary = windowSummary ? null : db.select().from(gaTrafficSummaries).where(eq28(gaTrafficSummaries.projectId, projectId)).orderBy(desc12(gaTrafficSummaries.syncedAt)).limit(1).get();
+  const matchingFallbackSummary = fallbackSummary && inclusiveDayCount(fallbackSummary.periodStart, fallbackSummary.periodEnd) === windowDays2 ? fallbackSummary : null;
   const snapshotMaxDate = db.select({ m: sql9`MAX(${gaTrafficSnapshots.date})` }).from(gaTrafficSnapshots).where(eq28(gaTrafficSnapshots.projectId, projectId)).get()?.m ?? "";
-  if (!windowSummary && !fallbackSummary && !snapshotMaxDate) return null;
-  const snapshotStartDate = snapshotMaxDate ? windowStartDate(snapshotMaxDate, windowDays2) : "";
+  if (!windowSummary && !matchingFallbackSummary && !snapshotMaxDate) return null;
+  const summaryPeriod = windowSummary ?? matchingFallbackSummary;
+  const snapshotMaxInWindow = summaryPeriod?.periodEnd || snapshotMaxDate;
+  const snapshotStartDate = summaryPeriod?.periodStart || (snapshotMaxDate ? windowStartDate(snapshotMaxDate, windowDays2) : "");
   const snapshotRows = snapshotStartDate ? db.select().from(gaTrafficSnapshots).where(
     and22(
       eq28(gaTrafficSnapshots.projectId, projectId),
       gte5(gaTrafficSnapshots.date, snapshotStartDate),
-      lte3(gaTrafficSnapshots.date, snapshotMaxDate)
+      lte3(gaTrafficSnapshots.date, snapshotMaxInWindow)
     )
   ).all() : db.select().from(gaTrafficSnapshots).where(eq28(gaTrafficSnapshots.projectId, projectId)).all();
-  const totalSessions = windowSummary?.totalSessions ?? fallbackSummary?.totalSessions ?? snapshotRows.reduce((s, r) => s + r.sessions, 0);
-  const totalUsers = windowSummary?.totalUsers ?? fallbackSummary?.totalUsers ?? snapshotRows.reduce((s, r) => s + r.users, 0);
-  const totalOrganicSessions = windowSummary?.totalOrganicSessions ?? fallbackSummary?.totalOrganicSessions ?? snapshotRows.reduce((s, r) => s + r.organicSessions, 0);
+  const totalSessions = windowSummary?.totalSessions ?? matchingFallbackSummary?.totalSessions ?? snapshotRows.reduce((s, r) => s + r.sessions, 0);
+  const totalUsers = windowSummary?.totalUsers ?? matchingFallbackSummary?.totalUsers ?? snapshotRows.reduce((s, r) => s + r.users, 0);
+  const totalOrganicSessions = windowSummary?.totalOrganicSessions ?? matchingFallbackSummary?.totalOrganicSessions ?? snapshotRows.reduce((s, r) => s + r.organicSessions, 0);
   const pageAgg = /* @__PURE__ */ new Map();
   let directSessions = windowSummary?.totalDirectSessions ?? 0;
   for (const r of snapshotRows) {
@@ -24786,9 +25109,9 @@ function buildGaSection(db, projectId, windowDays2) {
     eq28(gaAiReferrals.projectId, projectId),
     eq28(gaAiReferrals.sourceDimension, "session")
   ];
-  if (snapshotStartDate && snapshotMaxDate) {
+  if (snapshotStartDate && snapshotMaxInWindow) {
     aiConditions.push(gte5(gaAiReferrals.date, snapshotStartDate));
-    aiConditions.push(lte3(gaAiReferrals.date, snapshotMaxDate));
+    aiConditions.push(lte3(gaAiReferrals.date, snapshotMaxInWindow));
   }
   const aiSessionRows = db.select({
     trafficClass: gaAiReferrals.trafficClass,
@@ -24828,8 +25151,8 @@ function buildGaSection(db, projectId, windowDays2) {
       }
     }
   }
-  const periodStart = windowSummary?.periodStart ?? (snapshotStartDate || fallbackSummary?.periodStart || "");
-  const periodEnd = windowSummary?.periodEnd ?? (snapshotMaxDate || fallbackSummary?.periodEnd || "");
+  const periodStart = snapshotStartDate;
+  const periodEnd = snapshotMaxInWindow;
   return {
     totalSessions,
     totalUsers,
@@ -25931,11 +26254,7 @@ function buildProjectReport(db, projectName, periodDays) {
   const competitorDomains = competitorRows.map((c) => c.domain);
   const ownedDomains = project.ownedDomains;
   const projectDomains = [project.canonicalDomain, ...ownedDomains];
-  const projectAliases = project.aliases;
-  const projectBrandNames = effectiveBrandNames({
-    displayName: project.displayName,
-    aliases: projectAliases
-  });
+  const projectBrandNames = effectiveBrandNames(project);
   const citationScorecard = buildCitationScorecard(latestSnapshots, queryLookup);
   const competitorLandscape = buildCompetitorLandscape(
     latestSnapshots,
@@ -27227,10 +27546,8 @@ function computeCitationVisibility(input) {
   for (const snap of latestByPair.values()) {
     if (citationStateToCited(snap.citationState)) continue;
     if (competitorDomains.length === 0) continue;
-    const cited = snap.citedDomains;
-    const overlap = snap.competitorOverlap;
     const candidates = new Set(
-      [...cited, ...overlap].map((d) => hostOf(d) ?? "").filter((d) => d.length > 0)
+      snap.citedDomains.map((d) => hostOf(d) ?? "").filter((d) => d.length > 0)
     );
     const citingCompetitors = competitorDomains.filter(
       (competitor) => [...candidates].some((candidate) => hostMatchesDomain(candidate, competitor))
@@ -27319,6 +27636,7 @@ function observedPairs(snapshots, attribution, queryIds) {
 function period(numerator, denominator) {
   const ci = wilsonInterval(numerator, denominator);
   return {
+    availability: denominator > 0 ? "available" : "no-observations",
     point: denominator > 0 ? Math.round(numerator / denominator * 1e4) / 1e4 : null,
     ciLow: ci ? ci.low : null,
     ciHigh: ci ? ci.high : null,
@@ -27326,17 +27644,27 @@ function period(numerator, denominator) {
     denominator
   };
 }
+function unavailableCompetitivePeriod(numerator) {
+  return {
+    availability: "no-competitive-frame",
+    point: null,
+    ciLow: null,
+    ciHigh: null,
+    numerator,
+    denominator: 0
+  };
+}
 function ciOverlap(a, b) {
   if (a.ciLow === null || a.ciHigh === null || b.ciLow === null || b.ciHigh === null) return true;
   return a.ciLow <= b.ciHigh && b.ciLow <= a.ciHigh;
 }
-function metric(key, label, driftRobust, from, to, continuityBlock) {
+function metric(key, label, queryClass, driftRobust, from, to, continuityBlock) {
   const verdict = continuityBlock ?? (from.denominator === 0 || to.denominator === 0 ? "insufficient-data" : ciOverlap(from, to) ? "within-noise" : "moved");
   const direction = from.point === null || to.point === null ? null : to.point > from.point ? "up" : to.point < from.point ? "down" : "flat";
   const rateRatio = from.point === null || from.point === 0 || to.point === null ? null : Math.round(to.point / from.point * 100) / 100;
-  return { key, label, driftRobust, from, to, rateRatio, direction, verdict };
+  return { key, label, queryClass, driftRobust, from, to, rateRatio, direction, verdict };
 }
-function countPeriod(snaps, competitors2) {
+function countPeriod(snaps, competitors2, queryClassOf, classificationAvailable, projectBrandNames) {
   let checked = 0;
   let mentioned = 0;
   let cited = 0;
@@ -27370,8 +27698,14 @@ function countPeriod(snaps, competitors2) {
     }
   }
   const mentionShare = buildMentionShare(
-    snaps.map((s) => ({ projectMentioned: s.answerMentioned === true, answerText: s.answerText })),
-    { competitors: competitors2 }
+    snaps.map((s) => ({
+      // Share uses current identity; named-rate counts above deliberately keep
+      // their historical persisted-boolean semantics.
+      projectMentioned: s.answerText ? determineAnswerMentioned(s.answerText, [...projectBrandNames], []) : s.answerMentioned === true,
+      answerText: s.answerText,
+      queryClass: queryClassOf(s)
+    })),
+    { competitors: competitors2, classificationAvailable }
   );
   return {
     checked,
@@ -27397,6 +27731,10 @@ function isUnknownModelEvidence(evidence) {
 }
 function computeVisibilityCompare(input) {
   const attribution = buildQueryAttribution(input.queries);
+  const classifier = compileQueryClassifier(input.brandNames ?? []);
+  const classificationAvailable = classifier !== null;
+  const queryTextById = new Map(input.queries.map((q) => [q.id, q.query]));
+  const queryClassOf = (snap) => classifier ? classifier.classify(queryTextById.get(snap.queryId) ?? snap.queryText) : null;
   const fromObs = observed(input.from.snapshots, attribution);
   const toObs = observed(input.to.snapshots, attribution);
   const queriesObservedBoth = new Set([...fromObs.queryIds].filter((q) => toObs.queryIds.has(q)));
@@ -27406,8 +27744,8 @@ function computeVisibilityCompare(input) {
   const candidateProviders = new Set([...pairsBoth.values()].map((pair) => pair.provider));
   const fromCandidateSnaps = restrict(input.from.snapshots, attribution, pairsBoth);
   const toCandidateSnaps = restrict(input.to.snapshots, attribution, pairsBoth);
-  const fromCandidateCounts = countPeriod(fromCandidateSnaps, input.competitors);
-  const toCandidateCounts = countPeriod(toCandidateSnaps, input.competitors);
+  const fromCandidateCounts = countPeriod(fromCandidateSnaps, input.competitors, queryClassOf, classificationAvailable, input.brandNames ?? []);
+  const toCandidateCounts = countPeriod(toCandidateSnaps, input.competitors, queryClassOf, classificationAvailable, input.brandNames ?? []);
   const continuityProviders = [...candidateProviders].sort((a, b) => a.localeCompare(b)).map((provider) => {
     const fromEvidence = classifyModelEvidence(fromCandidateCounts.modelEvidence.get(provider) ?? []);
     const toEvidence = classifyModelEvidence(toCandidateCounts.modelEvidence.get(provider) ?? []);
@@ -27426,8 +27764,8 @@ function computeVisibilityCompare(input) {
   const excludedProviders = [.../* @__PURE__ */ new Set([...fromObs.providers, ...toObs.providers])].filter((p) => !providersBoth.has(p)).sort((a, b) => a.localeCompare(b));
   const fromSnaps = restrict(input.from.snapshots, attribution, comparedPairs);
   const toSnaps = restrict(input.to.snapshots, attribution, comparedPairs);
-  const fromCounts = countPeriod(fromSnaps, input.competitors);
-  const toCounts = countPeriod(toSnaps, input.competitors);
+  const fromCounts = countPeriod(fromSnaps, input.competitors, queryClassOf, classificationAvailable, input.brandNames ?? []);
+  const toCounts = countPeriod(toSnaps, input.competitors, queryClassOf, classificationAvailable, input.brandNames ?? []);
   const shareCounts = (c) => ({
     proj: c.mentionShare.breakdown.projectMentionSnapshots,
     comp: c.mentionShare.breakdown.competitorMentionSnapshots
@@ -27438,9 +27776,10 @@ function computeVisibilityCompare(input) {
     metric(
       "mention-share-of-voice",
       "Named share of voice",
+      classificationAvailable ? "non-brand" : "pooled",
       true,
-      period(fromShare.proj, fromShare.proj + fromShare.comp),
-      period(toShare.proj, toShare.proj + toShare.comp),
+      input.competitors.length > 0 ? period(fromShare.proj, fromShare.proj + fromShare.comp) : unavailableCompetitivePeriod(fromShare.proj),
+      input.competitors.length > 0 ? period(toShare.proj, toShare.proj + toShare.comp) : unavailableCompetitivePeriod(toShare.proj),
       continuityBlock
     ),
     // Share of voice is undefined without a competitive frame: with zero
@@ -27451,14 +27790,16 @@ function computeVisibilityCompare(input) {
     metric(
       "cited-share-of-voice",
       "Cited share of voice",
+      "all",
       true,
-      input.competitors.length > 0 ? period(fromCounts.projectCited, fromCounts.projectCited + fromCounts.competitorCited) : period(0, 0),
-      input.competitors.length > 0 ? period(toCounts.projectCited, toCounts.projectCited + toCounts.competitorCited) : period(0, 0),
+      input.competitors.length > 0 ? period(fromCounts.projectCited, fromCounts.projectCited + fromCounts.competitorCited) : unavailableCompetitivePeriod(fromCounts.projectCited),
+      input.competitors.length > 0 ? period(toCounts.projectCited, toCounts.projectCited + toCounts.competitorCited) : unavailableCompetitivePeriod(toCounts.projectCited),
       continuityBlock
     ),
     metric(
       "mention-rate",
       "Named rate",
+      "all",
       false,
       period(fromCounts.mentioned, fromCounts.checked),
       period(toCounts.mentioned, toCounts.checked),
@@ -27467,6 +27808,7 @@ function computeVisibilityCompare(input) {
     metric(
       "cited-rate",
       "Cited rate",
+      "all",
       false,
       period(fromCounts.cited, fromCounts.total),
       period(toCounts.cited, toCounts.total),
@@ -27624,7 +27966,8 @@ async function visibilityStatsRoutes(app) {
       lastRuns: lastRunsRaw,
       groupBy: groupByRaw,
       month: monthRaw,
-      shareOfVoice: shareOfVoiceRaw
+      shareOfVoice: shareOfVoiceRaw,
+      queryClass: queryClassRaw
     } = request.query;
     let groupBy = null;
     if (groupByRaw !== void 0 && groupByRaw !== "") {
@@ -27636,6 +27979,9 @@ async function visibilityStatsRoutes(app) {
     const hasLastRuns = lastRunsRaw !== void 0 && lastRunsRaw !== "";
     const hasMonth = monthRaw !== void 0 && monthRaw !== "";
     const wantShareOfVoice = shareOfVoiceRaw === "1" || shareOfVoiceRaw === "true";
+    const requestedQueryClass = queryClassRaw === void 0 || queryClassRaw === "" ? "non-brand" : queryClassRaw === "branded" || queryClassRaw === "non-brand" ? queryClassRaw : (() => {
+      throw validationError('"queryClass" must be "branded" or "non-brand"');
+    })();
     if (hasLastRuns && (hasSince || hasUntil)) {
       throw validationError('"lastRuns" cannot be combined with "since"/"until" \u2014 use one or the other');
     }
@@ -27695,10 +28041,6 @@ async function visibilityStatsRoutes(app) {
     let shareOfVoice;
     if (wantShareOfVoice) {
       const competitorRows = app.db.select({ domain: competitors.domain }).from(competitors).where(eq32(competitors.projectId, project.id)).all();
-      const mentionShareCompetitors = competitorRows.map((c) => ({
-        domain: c.domain,
-        brandTokens: [brandLabelFromDomain(c.domain)].filter((t) => t.length >= 3)
-      }));
       const sovSnapshots = runIds.length > 0 ? app.db.select({
         queryId: querySnapshots.queryId,
         queryText: querySnapshots.queryText,
@@ -27706,16 +28048,29 @@ async function visibilityStatsRoutes(app) {
         answerText: querySnapshots.answerText
       }).from(querySnapshots).where(inArray14(querySnapshots.runId, runIds)).all() : [];
       const attributedSovSnapshots = sovSnapshots.filter((s) => resolveCurrentQuery(queryAttribution, s) !== void 0);
-      const result = buildMentionShare(
-        attributedSovSnapshots.map((s) => ({ projectMentioned: s.answerMentioned === true, answerText: s.answerText })),
-        { competitors: mentionShareCompetitors }
-      );
-      const b = result.breakdown;
+      const inputs = buildMentionShareInputs({
+        project,
+        competitorDomains: competitorRows.map((c) => c.domain),
+        snapshots: attributedSovSnapshots,
+        // Attribution prefers the current query row by id; classification must
+        // use that same text or a rename can put the stats row and its SoV row
+        // in different query classes.
+        queryTextById: new Map(projectQueries.map((q) => [q.id, q.query]))
+      });
+      const result = buildMentionShare(inputs.snapshots, {
+        competitors: inputs.competitors,
+        classificationAvailable: inputs.classified
+      });
+      const servedQueryClass = result.scope === "pooled" ? "pooled" : requestedQueryClass;
+      const b = servedQueryClass === "branded" ? result.branded : result.breakdown;
       const denom = b.projectMentionSnapshots + b.competitorMentionSnapshots;
       shareOfVoice = {
-        // `null` (not 0) when there is no competitive frame configured — a 0 here
-        // would read as "losing" when the head-to-head metric is simply undefined.
-        percent: competitorRows.length === 0 ? null : denom > 0 ? Math.round(b.projectMentionSnapshots / denom * 100) : 0,
+        queryClass: servedQueryClass,
+        // `null` (not 0) when there is no competitive frame or nothing in the
+        // requested class was named. Both are undefined 0/0 proportions, not a
+        // competitive loss.
+        percent: competitorRows.length === 0 || denom === 0 ? null : Math.round(b.projectMentionSnapshots / denom * 100),
+        competitorCount: competitorRows.length,
         projectMentions: b.projectMentionSnapshots,
         competitorMentions: b.competitorMentionSnapshots,
         snapshotsWithAnswerText: b.snapshotsWithAnswerText,
@@ -27765,10 +28120,7 @@ async function visibilityStatsRoutes(app) {
     }
     const projectQueries = app.db.select({ id: queries.id, query: queries.query }).from(queries).where(eq32(queries.projectId, project.id)).all();
     const competitorRows = app.db.select({ domain: competitors.domain }).from(competitors).where(eq32(competitors.projectId, project.id)).all();
-    const competitorInputs = competitorRows.map((c) => ({
-      domain: c.domain,
-      brandTokens: [brandLabelFromDomain(c.domain)].filter((t) => t.length >= 3)
-    }));
+    const competitorInputs = mentionShareCompetitorsFromDomains(competitorRows.map((c) => c.domain));
     const loadMonth = (bounds) => {
       const sinceMs = Date.parse(bounds.since);
       const untilMs = Date.parse(bounds.until);
@@ -27794,6 +28146,7 @@ async function visibilityStatsRoutes(app) {
       project: project.name,
       queries: projectQueries,
       competitors: competitorInputs,
+      brandNames: effectiveBrandNames(project),
       from: { month: fromRaw, since: fromBounds.since, until: fromBounds.until, runCount: fromMonth.runCount, snapshots: fromMonth.snapshots },
       to: { month: toRaw, since: toBounds.since, until: toBounds.until, runCount: toMonth.runCount, snapshots: toMonth.snapshots }
     });
@@ -28107,25 +28460,35 @@ async function compositeRoutes(app) {
       }
     }
     const configuredApiProviders = project.providers.filter((p) => !p.startsWith("cdp:"));
-    const mentionShareCompetitors = competitorRows.map((c) => ({
-      domain: c.domain,
-      // Single brand token derived from the registrable domain (e.g.
-      // "offers.roofle.com" → "roofle"). Future PR can layer operator-curated
-      // aliases on top via a `competitor_aliases` column.
-      brandTokens: [brandLabelFromDomain(c.domain)].filter((t) => t.length >= 3)
+    const mentionShareInputs = buildMentionShareInputs({
+      project,
+      competitorDomains: competitorRows.map((c) => c.domain),
+      snapshots: trackedLatest,
+      queryTextById: queryLookup.byId
+    });
+    const competitiveSignalResolver = compileCompetitiveSignalResolver(
+      competitorRows.map((c) => c.domain)
+    );
+    const gapSignalSnapshots = trackedLatest.map((snapshot) => ({
+      ...snapshot,
+      ...competitiveSignalResolver.resolve({
+        citedDomains: snapshot.citedDomains,
+        groundingSources: snapshot.groundingSources,
+        answerText: snapshot.answerText
+      })
     }));
     const scores = {
       mention: buildMentionCoverage(trackedLatest, { configuredApiProviders }),
       visibility: buildVisibilityScore(trackedLatest, { configuredApiProviders }),
       mentionShare: buildMentionShare(
-        trackedLatest.map((s) => ({
-          projectMentioned: s.answerMentioned === true,
-          answerText: s.answerText
-        })),
-        { competitors: mentionShareCompetitors }
+        mentionShareInputs.snapshots,
+        {
+          competitors: mentionShareInputs.competitors,
+          classificationAvailable: mentionShareInputs.classified
+        }
       ),
-      gapQueries: buildGapQueryScore(trackedLatest),
-      mentionGaps: buildMentionGapScore(trackedLatest),
+      gapQueries: buildGapQueryScore(gapSignalSnapshots),
+      mentionGaps: buildMentionGapScore(gapSignalSnapshots),
       indexCoverage: buildIndexCoverageScore(app, project.id),
       competitorPressure: buildCompetitorPressureScore(
         trackedLatest,
@@ -28307,6 +28670,7 @@ function loadSnapshotsByRunIds(app, runIds, queryIdByText) {
     citationState: querySnapshots.citationState,
     answerMentioned: querySnapshots.answerMentioned,
     answerText: querySnapshots.answerText,
+    rawResponse: querySnapshots.rawResponse,
     competitorOverlap: querySnapshots.competitorOverlap,
     citedDomains: querySnapshots.citedDomains
   }).from(querySnapshots).where(inArray15(querySnapshots.runId, [...runIds])).all();
@@ -28338,6 +28702,7 @@ function loadSnapshotsByRunIds(app, runIds, queryIdByText) {
       citationState: row.citationState,
       answerMentioned: row.answerMentioned,
       answerText: row.answerText,
+      groundingSources: parseOverviewGroundingSources(row.rawResponse),
       competitorOverlap: row.competitorOverlap,
       citedDomains: row.citedDomains
     });
@@ -28345,6 +28710,16 @@ function loadSnapshotsByRunIds(app, runIds, queryIdByText) {
   }
   return result;
 }
+function parseOverviewGroundingSources(rawResponse) {
+  const parsed = parseJsonColumn(rawResponse, {});
+  const sources = parsed.groundingSources;
+  if (!Array.isArray(sources)) return [];
+  return sources.flatMap((source) => {
+    if (!source || typeof source !== "object") return [];
+    const uri = source.uri;
+    return typeof uri === "string" ? [{ uri }] : [];
+  });
+}
 function summarizeFromSnapshots(snapshots) {
   const empty = {
     queryCounts: {
@@ -29431,9 +29806,15 @@ var compareToQueryParameter = {
 var shareOfVoiceQueryParameter = {
   name: "shareOfVoice",
   in: "query",
-  description: 'Set to "1" to include pooled share of voice (project vs tracked-competitor brand mentions in answer text) across the window.',
+  description: 'Set to "1" to include share of voice (project vs tracked-competitor brand mentions in answer text) across the window. Scoped by `queryClass`, which defaults to non-brand.',
   schema: { type: "string", enum: ["1"] }
 };
+var shareOfVoiceQueryClassParameter = {
+  name: "queryClass",
+  in: "query",
+  description: "Which query class `shareOfVoice` covers. Defaults to `non-brand`: a branded query names the project, so it is mentioned on nearly all of them and a competitor structurally cannot be, and one shared denominator would report brand recall as category placement. Never pooled across classes.",
+  schema: { type: "string", enum: ["branded", "non-brand"], default: "non-brand" }
+};
 var wordpressEnvQueryParameter = {
   name: "env",
   in: "query",
@@ -31176,7 +31557,7 @@ var routeCatalog = [
     method: "get",
     path: "/api/v1/projects/{name}/visibility-stats",
     summary: "Get aggregated mention/citation stats per query",
-    description: "Per-query mention (answer-text) and citation (source-list) counts with a sample size, pooled across many answer-visibility runs (probe-excluded). Tri-state aware: `checked` counts only snapshots where answerMentioned was recorded (null = not checked is excluded). Lets a consumer compute confidence-aware (e.g. Wilson) proportions without N+1 run fetches. With no since/until/lastRuns, EVERY completed/partial answer-visibility run is pooled \u2014 `window.runCount` reports how many; bound the window with lastRuns, since/until, or month=YYYY-MM for a recent sample. Set groupBy=provider for a per-provider breakdown whose counts sum to the pooled counts, or shareOfVoice=1 to add pooled share of voice vs tracked competitors.",
+    description: "Per-query mention (answer-text) and citation (source-list) counts with a sample size, pooled across many answer-visibility runs (probe-excluded). Tri-state aware: `checked` counts only snapshots where answerMentioned was recorded (null = not checked is excluded). Lets a consumer compute confidence-aware (e.g. Wilson) proportions without N+1 run fetches. With no since/until/lastRuns, EVERY completed/partial answer-visibility run is pooled \u2014 `window.runCount` reports how many; bound the window with lastRuns, since/until, or month=YYYY-MM for a recent sample. Set groupBy=provider for a per-provider breakdown whose counts sum to the pooled counts, or shareOfVoice=1 to add share of voice vs tracked competitors (non-brand queries by default; set queryClass=branded for brand recall).",
     tags: ["analytics"],
     parameters: [
       nameParameter,
@@ -31185,7 +31566,8 @@ var routeCatalog = [
       lastRunsQueryParameter,
       groupByProviderQueryParameter,
       monthQueryParameter,
-      shareOfVoiceQueryParameter
+      shareOfVoiceQueryParameter,
+      shareOfVoiceQueryClassParameter
     ],
     responses: {
       200: jsonResponse("Aggregated visibility stats returned.", "VisibilityStatsDto"),
@@ -48195,11 +48577,9 @@ async function ga4Routes(app, opts) {
     requireGa4Connection(opts, project.name, project.canonicalDomain);
     const limit = Math.max(1, Math.min(parseInt(request.query.limit ?? "50", 10) || 50, 500));
     const range = resolveDateRange(request.query);
-    const dateFiltered = range.startDate !== null || range.endDate !== null;
-    const snapshotConditions = [eq45(gaTrafficSnapshots.projectId, project.id), ...dateRangeConditions(gaTrafficSnapshots.date, range)];
-    const aiConditions = [eq45(gaAiReferrals.projectId, project.id), ...dateRangeConditions(gaAiReferrals.date, range)];
-    const socialConditions = [eq45(gaSocialReferrals.projectId, project.id), ...dateRangeConditions(gaSocialReferrals.date, range)];
     const windowSummaryRow = range.startDate && !range.explicitDates ? app.db.select({
+      periodStart: gaTrafficWindowSummaries.periodStart,
+      periodEnd: gaTrafficWindowSummaries.periodEnd,
       totalSessions: gaTrafficWindowSummaries.totalSessions,
       totalOrganicSessions: gaTrafficWindowSummaries.totalOrganicSessions,
       totalDirectSessions: gaTrafficWindowSummaries.totalDirectSessions,
@@ -48210,7 +48590,29 @@ async function ga4Routes(app, opts) {
         eq45(gaTrafficWindowSummaries.windowKey, range.window)
       )
     ).get() : null;
-    const snapshotTotalsRow = dateFiltered && !windowSummaryRow ? (() => {
+    const projectSummaryRow = app.db.select({
+      periodStart: gaTrafficSummaries.periodStart,
+      periodEnd: gaTrafficSummaries.periodEnd,
+      totalSessions: gaTrafficSummaries.totalSessions,
+      totalOrganicSessions: gaTrafficSummaries.totalOrganicSessions,
+      totalUsers: gaTrafficSummaries.totalUsers
+    }).from(gaTrafficSummaries).where(eq45(gaTrafficSummaries.projectId, project.id)).get();
+    const retainedBounds = [
+      app.db.select({ min: sql17`MIN(${gaTrafficSnapshots.date})`, max: sql17`MAX(${gaTrafficSnapshots.date})` }).from(gaTrafficSnapshots).where(eq45(gaTrafficSnapshots.projectId, project.id)).get(),
+      app.db.select({ min: sql17`MIN(${gaAiReferrals.date})`, max: sql17`MAX(${gaAiReferrals.date})` }).from(gaAiReferrals).where(eq45(gaAiReferrals.projectId, project.id)).get(),
+      app.db.select({ min: sql17`MIN(${gaSocialReferrals.date})`, max: sql17`MAX(${gaSocialReferrals.date})` }).from(gaSocialReferrals).where(eq45(gaSocialReferrals.projectId, project.id)).get()
+    ];
+    const retainedDates = retainedBounds.flatMap((bound) => [bound?.min, bound?.max]).filter((date) => Boolean(date));
+    const projectSummaryCoversAll = Boolean(
+      projectSummaryRow?.periodStart && projectSummaryRow.periodEnd && retainedDates.every((date) => date >= projectSummaryRow.periodStart && date <= projectSummaryRow.periodEnd)
+    );
+    const denominatorRow = windowSummaryRow ?? (range.window === "all" && projectSummaryCoversAll ? projectSummaryRow : null);
+    const denominatorPeriod = denominatorRow?.periodStart && denominatorRow.periodEnd ? { startDate: denominatorRow.periodStart, endDate: denominatorRow.periodEnd } : null;
+    const measuredRange = denominatorPeriod ? { ...range, ...denominatorPeriod } : range;
+    const snapshotConditions = [eq45(gaTrafficSnapshots.projectId, project.id), ...dateRangeConditions(gaTrafficSnapshots.date, measuredRange)];
+    const aiConditions = [eq45(gaAiReferrals.projectId, project.id), ...dateRangeConditions(gaAiReferrals.date, measuredRange)];
+    const socialConditions = [eq45(gaSocialReferrals.projectId, project.id), ...dateRangeConditions(gaSocialReferrals.date, measuredRange)];
+    const snapshotTotalsRow = !denominatorRow ? (() => {
       const summed = app.db.select({
         totalSessions: sql17`COALESCE(SUM(${gaTrafficSnapshots.sessions}), 0)`,
         totalOrganicSessions: sql17`COALESCE(SUM(${gaTrafficSnapshots.organicSessions}), 0)`,
@@ -48219,25 +48621,16 @@ async function ga4Routes(app, opts) {
       return {
         totalSessions: summed?.totalSessions ?? 0,
         totalOrganicSessions: summed?.totalOrganicSessions ?? 0,
-        // Unavailable for an EXPLICIT calendar range. The rolling-window
-        // fallback keeps its historical summed value: it is wrong for the
-        // same reason, but it predates this branch and correcting it is a
-        // separate, visible behaviour change rather than one bundled here.
-        totalUsers: range.explicitDates ? null : summed?.totalUsers ?? 0
+        // Unavailable for an explicit or all-history range. The rolling-
+        // window fallback keeps its historical summed value for projects
+        // that have not yet backfilled window summaries.
+        totalUsers: range.explicitDates || range.window === "all" ? null : summed?.totalUsers ?? 0
       };
     })() : null;
-    const summaryRow = dateFiltered ? windowSummaryRow ?? snapshotTotalsRow : app.db.select({
-      totalSessions: gaTrafficSummaries.totalSessions,
-      totalOrganicSessions: gaTrafficSummaries.totalOrganicSessions,
-      totalUsers: gaTrafficSummaries.totalUsers
-    }).from(gaTrafficSummaries).where(eq45(gaTrafficSummaries.projectId, project.id)).get();
+    const summaryRow = denominatorRow ?? snapshotTotalsRow;
     const directTotalRow = windowSummaryRow ? { totalDirectSessions: windowSummaryRow.totalDirectSessions } : app.db.select({
       totalDirectSessions: sql17`COALESCE(SUM(${gaTrafficSnapshots.directSessions}), 0)`
     }).from(gaTrafficSnapshots).where(and36(...snapshotConditions)).get();
-    const summaryMeta = app.db.select({
-      periodStart: gaTrafficSummaries.periodStart,
-      periodEnd: gaTrafficSummaries.periodEnd
-    }).from(gaTrafficSummaries).where(eq45(gaTrafficSummaries.projectId, project.id)).get();
     const rows = app.db.select({
       landingPage: sql17`COALESCE(${gaTrafficSnapshots.landingPageNormalized}, ${gaTrafficSnapshots.landingPage})`,
       sessions: sql17`SUM(${gaTrafficSnapshots.sessions})`,
@@ -48300,6 +48693,9 @@ async function ga4Routes(app, opts) {
     const totalDirectSessions = directTotalRow?.totalDirectSessions ?? 0;
     const totalOrganicSessions = summaryRow?.totalOrganicSessions ?? 0;
     const socialSessions = socialTotals?.sessions ?? 0;
+    const windowStart = measuredRange.startDate;
+    const windowEnd = measuredRange.endDate;
+    const windowDays2 = windowStart && windowEnd ? inclusiveDayCount(windowStart, windowEnd) : null;
     const channelBreakdown = buildChannelBreakdown({
       totalSessions: total,
       organicSessions: totalOrganicSessions,
@@ -48315,7 +48711,7 @@ async function ga4Routes(app, opts) {
       // it. GA counts users as a COUNT DISTINCT at the grain requested, so the
       // landing-page dimensioned sum is inflated, and a 0 would read as
       // "nobody visited" rather than "not measurable for this range".
-      totalUsers: summaryRow ? summaryRow.totalUsers : 0,
+      totalUsers: summaryRow ? summaryRow.totalUsers : null,
       topPages: rows.map((r) => ({
         landingPage: r.landingPage,
         sessions: r.sessions ?? 0,
@@ -48382,25 +48778,19 @@ async function ga4Routes(app, opts) {
       directSharePctDisplay: formatSharePct(totalDirectSessions, total),
       socialSharePctDisplay: formatSharePct(socialSessions, total),
       lastSyncedAt: latestSync?.syncedAt ?? null,
-      // Report the range that was actually measured, so a caller can tell which
-      // period the totals above belong to.
-      // An EXPLICIT calendar range is reported back verbatim, even when it
-      // covers nothing. Substituting the synced period there labelled an empty
-      // future range with real past dates, so the numbers said "no data" while
-      // the labels named a period that did have data.
-      //
-      // A rolling window still clamps: "last 30 days" is a relative ask, and a
-      // cutoff computed from today can legitimately land after the last synced
-      // date on a stale project. Reporting a start after the end would be its
-      // own nonsense.
-      periodStart: (() => {
-        if (range.explicitDates) return range.startDate ?? summaryMeta?.periodStart ?? null;
-        const start = range.startDate ?? summaryMeta?.periodStart ?? null;
-        const end = range.endDate ?? summaryMeta?.periodEnd ?? null;
-        if (start && end && start > end) return summaryMeta?.periodStart ?? null;
-        return start;
-      })(),
-      periodEnd: range.endDate ?? summaryMeta?.periodEnd ?? null
+      // The window every figure above was measured over — never a different
+      // table's period, and never a fallback that names dates the queries did
+      // not use. A `null` bound is genuinely open (all retained history on that
+      // side), which is why `windowDays` is null too rather than guessing a
+      // span. Read a share against these dates or not at all.
+      windowStart,
+      windowEnd,
+      windowDays: windowDays2,
+      // Retained aliases of `windowStart` / `windowEnd`. They previously mixed
+      // the requested range with the synced range, which is what let a 30-day
+      // total sit under a 90-day channel count with a label that named neither.
+      periodStart: windowStart,
+      periodEnd: windowEnd
     };
   });
   app.get("/projects/:name/ga/ai-referral-history", async (request, _reply) => {
@@ -65364,6 +65754,16 @@ function matchesBrandAlias(candidate, aliases) {
 var RECURRENCE_LOOKBACK_RUNS = 5;
 var HISTORY_WINDOW_RUNS = Math.max(PERSISTENT_GAP_THRESHOLD, 5);
 var log = createLogger("IntelligenceService");
+function readStoredGroundingSources(rawResponse) {
+  const parsed = parseJsonColumn(rawResponse, {});
+  const sources = parsed.groundingSources;
+  if (!Array.isArray(sources)) return [];
+  return sources.flatMap((source) => {
+    if (!source || typeof source !== "object") return [];
+    const uri = source.uri;
+    return typeof uri === "string" ? [{ uri }] : [];
+  });
+}
 function gbpInsightSlot(typeOrSlot) {
   return typeOrSlot === "gbp-lodging-gap" || typeOrSlot === "gbp-listing-discrepancy" ? "lodging" : typeOrSlot;
 }
@@ -65406,11 +65806,13 @@ var IntelligenceService = class {
       log.info("intelligence.skip", { runId, reason: "run not in recent completed list" });
       return null;
     }
+    const trackedCompetitors = this.loadTrackedCompetitors(projectId);
     const currentRun = this.buildRunData(
       runId,
       projectId,
       currentRunRecord.finishedAt ?? currentRunRecord.createdAt,
-      currentRunRecord.location ?? null
+      currentRunRecord.location ?? null,
+      trackedCompetitors
     );
     if (currentRun.snapshots.length === 0) {
       log.info("intelligence.skip", { runId, reason: "no snapshots" });
@@ -65425,10 +65827,16 @@ var IntelligenceService = class {
       previousRunRecord.id,
       projectId,
       previousRunRecord.finishedAt ?? previousRunRecord.createdAt,
-      previousRunRecord.location ?? null
+      previousRunRecord.location ?? null,
+      trackedCompetitors
     ) : null;
-    const trackedCompetitors = this.loadTrackedCompetitors(projectId);
-    const history = sameLocationOrdered.slice(0, currentLocIdx + 1).map((r) => r.id === runId ? currentRun : this.buildRunData(r.id, projectId, r.finishedAt ?? r.createdAt, r.location ?? null));
+    const history = sameLocationOrdered.slice(0, currentLocIdx + 1).map((r) => r.id === runId ? currentRun : this.buildRunData(
+      r.id,
+      projectId,
+      r.finishedAt ?? r.createdAt,
+      r.location ?? null,
+      trackedCompetitors
+    ));
     if (!previousRun) {
       const result2 = analyzeRuns(currentRun, currentRun, { trackedCompetitors, history });
       log.info("intelligence.analyzed", {
@@ -65632,11 +66040,13 @@ var IntelligenceService = class {
    * would have produced.
    */
   analyzeRunWithPrevious(runRecord, previousRunRecord, historyRecords, opts) {
+    const trackedCompetitors = this.loadTrackedCompetitors(runRecord.projectId);
     const currentRun = this.buildRunData(
       runRecord.id,
       runRecord.projectId,
       runRecord.finishedAt ?? runRecord.createdAt,
-      runRecord.location ?? null
+      runRecord.location ?? null,
+      trackedCompetitors
     );
     if (currentRun.snapshots.length === 0) {
       return null;
@@ -65645,10 +66055,16 @@ var IntelligenceService = class {
       previousRunRecord.id,
       previousRunRecord.projectId,
       previousRunRecord.finishedAt ?? previousRunRecord.createdAt,
-      previousRunRecord.location ?? null
+      previousRunRecord.location ?? null,
+      trackedCompetitors
     ) : null;
-    const trackedCompetitors = this.loadTrackedCompetitors(runRecord.projectId);
-    const history = (historyRecords ?? []).map((r) => r.id === runRecord.id ? currentRun : this.buildRunData(r.id, r.projectId, r.finishedAt ?? r.createdAt, r.location ?? null));
+    const history = (historyRecords ?? []).map((r) => r.id === runRecord.id ? currentRun : this.buildRunData(
+      r.id,
+      r.projectId,
+      r.finishedAt ?? r.createdAt,
+      r.location ?? null,
+      trackedCompetitors
+    ));
     if (!previousRun) {
       const result2 = analyzeRuns(currentRun, currentRun, { trackedCompetitors, history });
       const emptyResult = this.emptyAnalysisResult(result2);
@@ -65918,12 +66334,13 @@ var IntelligenceService = class {
       return { ...insight, severity };
     });
   }
-  buildRunData(runId, projectId, completedAt, location = null) {
+  buildRunData(runId, projectId, completedAt, location = null, trackedCompetitors = []) {
     const projectDomainRow = this.db.select({ canonicalDomain: projects.canonicalDomain, ownedDomains: projects.ownedDomains }).from(projects).where(eq60(projects.id, projectId)).get();
     const projectDomains = projectDomainRow ? effectiveDomains({
       canonicalDomain: projectDomainRow.canonicalDomain,
       ownedDomains: projectDomainRow.ownedDomains
     }) : [];
+    const competitiveSignalResolver = compileCompetitiveSignalResolver(trackedCompetitors);
     const rows = this.db.select({
       query: queries.query,
       // Denormalized query text persisted by v58 — the fallback when the
@@ -65934,7 +66351,7 @@ var IntelligenceService = class {
       citationState: querySnapshots.citationState,
       answerMentioned: querySnapshots.answerMentioned,
       citedDomains: querySnapshots.citedDomains,
-      competitorOverlap: querySnapshots.competitorOverlap,
+      rawResponse: querySnapshots.rawResponse,
       snapshotLocation: querySnapshots.location
     }).from(querySnapshots).leftJoin(queries, eq60(querySnapshots.queryId, queries.id)).where(eq60(querySnapshots.runId, runId)).all();
     const snapshots = [];
@@ -65946,7 +66363,10 @@ var IntelligenceService = class {
         continue;
       }
       const domains = r.citedDomains;
-      const competitors2 = r.competitorOverlap;
+      const citedCompetitorDomains = competitiveSignalResolver.resolve({
+        citedDomains: domains,
+        groundingSources: readStoredGroundingSources(r.rawResponse)
+      }).citedCompetitorDomains;
       snapshots.push({
         query: resolvedQuery,
         provider: r.provider,
@@ -65964,7 +66384,7 @@ var IntelligenceService = class {
         // we read it from the snapshot row so a stale runs.location can't
         // mask snapshot truth.
         location: r.snapshotLocation ?? location ?? null,
-        competitorDomains: competitors2,
+        citedCompetitorDomains,
         // citedDomains is the FULL set (tracked competitors + third-party
         // sources). Cause analysis uses it to name the displacing source
         // when no tracked competitor appears in the response.