@ainyc/canonry 4.1.3 → 4.7.2

package/dist/{chunk-AXMSAMKN.js → chunk-OOADR2Q5.js}

@@ -2,8 +2,13 @@ import {
   CitationStates,
   ContentActions,
   RunKinds,
-  __export
-} from "./chunk-O5JZQUPX.js";
+  __export,
+  brandLabelFromDomain,
+  categorizeSourceWithCompetitors,
+  categoryLabel,
+  determineAnswerMentioned,
+  normalizeProjectDomain
+} from "./chunk-XAW66QUX.js";
 
 // src/intelligence-service.ts
 import { eq, desc, asc, and, or, inArray } from "drizzle-orm";
@@ -1651,13 +1656,14 @@ function computeHealthTrend(runs2) {
 // ../intelligence/src/causes.ts
 function analyzeCause(regression, currentSnapshots) {
   const currentSnap = currentSnapshots.find(
-    (s) => s.query === regression.query && s.provider === regression.provider && !s.cited && s.competitorDomain
+    (s) => s.query === regression.query && s.provider === regression.provider && !s.cited && s.competitorDomains && s.competitorDomains.length > 0
   );
   if (currentSnap) {
+    const competitor = currentSnap.competitorDomains[0];
     return {
       cause: "competitor_gain",
-      competitorDomain: currentSnap.competitorDomain,
-      details: `Competitor ${currentSnap.competitorDomain} now cited for "${regression.query}" on ${regression.provider}`
+      competitorDomain: competitor,
+      details: `Competitor ${competitor} now cited for "${regression.query}" on ${regression.provider}`
     };
   }
   return {
@@ -1668,14 +1674,15 @@ function analyzeCause(regression, currentSnapshots) {
 
 // ../intelligence/src/insights.ts
 import { randomUUID } from "crypto";
-function generateInsights(regressions, gains, health, causes) {
+var QUERY_LEVEL_PROVIDER = "all";
+function generateInsights(input) {
   const insights2 = [];
   const now = (/* @__PURE__ */ new Date()).toISOString();
-  for (const reg of regressions) {
-    const key = `${reg.query}:${reg.provider}`;
-    const cause = causes.get(key);
+  const id = () => `ins_${randomUUID().slice(0, 8)}`;
+  for (const reg of input.regressions) {
+    const cause = input.causes.get(`${reg.query}:${reg.provider}`);
     insights2.push({
-      id: `ins_${randomUUID().slice(0, 8)}`,
+      id: id(),
       type: "regression",
       severity: "high",
       title: `Lost ${reg.provider} citation for "${reg.query}"`,
@@ -1690,9 +1697,9 @@ function generateInsights(regressions, gains, health, causes) {
       createdAt: now
     });
   }
-  for (const gain of gains) {
+  for (const gain of input.gains) {
     insights2.push({
-      id: `ins_${randomUUID().slice(0, 8)}`,
+      id: id(),
       type: "gain",
       severity: "low",
       title: `New ${gain.provider} citation for "${gain.query}"`,
@@ -1706,24 +1713,263 @@ function generateInsights(regressions, gains, health, causes) {
       createdAt: now
     });
   }
+  for (const fc of input.firstCitations) {
+    insights2.push({
+      id: id(),
+      type: "first-citation",
+      severity: "medium",
+      title: `First citation for "${fc.query}" on ${fc.provider}`,
+      query: fc.query,
+      provider: fc.provider,
+      recommendation: {
+        action: "monitor",
+        target: fc.citationUrl,
+        reason: `"${fc.query}" had not been cited by any provider before this run. Monitor to confirm the citation persists.`
+      },
+      createdAt: now
+    });
+  }
+  for (const pp of input.providerPickups) {
+    insights2.push({
+      id: id(),
+      type: "provider-pickup",
+      severity: "low",
+      title: `${pp.provider} picked up "${pp.query}"`,
+      query: pp.query,
+      provider: pp.provider,
+      recommendation: {
+        action: "monitor",
+        target: pp.citationUrl,
+        reason: `${pp.provider} started citing "${pp.query}" alongside other providers. Monitor to confirm the citation persists.`
+      },
+      createdAt: now
+    });
+  }
+  for (const gap of input.persistentGaps) {
+    insights2.push({
+      id: id(),
+      type: "persistent-gap",
+      severity: "medium",
+      title: `"${gap.query}" uncited for ${gap.streak} runs`,
+      query: gap.query,
+      provider: QUERY_LEVEL_PROVIDER,
+      recommendation: {
+        action: "audit",
+        reason: `No provider has cited "${gap.query}" for ${gap.streak} consecutive runs. Audit content and schema for this topic.`
+      },
+      createdAt: now
+    });
+  }
+  for (const cg of input.competitorGains) {
+    insights2.push({
+      id: id(),
+      type: "competitor-gained",
+      severity: "medium",
+      title: `${cg.competitorDomain} appeared on "${cg.query}"`,
+      query: cg.query,
+      provider: QUERY_LEVEL_PROVIDER,
+      cause: {
+        cause: "competitor_gain",
+        competitorDomain: cg.competitorDomain,
+        details: `Tracked competitor ${cg.competitorDomain} just got cited on "${cg.query}".`
+      },
+      recommendation: {
+        action: "audit",
+        reason: `Investigate ${cg.competitorDomain}'s content for "${cg.query}" \u2014 they just earned a citation here.`
+      },
+      createdAt: now
+    });
+  }
+  for (const cl of input.competitorLosses) {
+    insights2.push({
+      id: id(),
+      type: "competitor-lost",
+      severity: "low",
+      title: `${cl.competitorDomain} dropped from "${cl.query}"`,
+      query: cl.query,
+      provider: QUERY_LEVEL_PROVIDER,
+      cause: {
+        cause: "competitor_loss",
+        competitorDomain: cl.competitorDomain,
+        details: `Tracked competitor ${cl.competitorDomain} lost their citation on "${cl.query}".`
+      },
+      recommendation: {
+        action: "monitor",
+        reason: `Opportunity: ${cl.competitorDomain} just lost "${cl.query}". Tighten your own coverage to fill the gap.`
+      },
+      createdAt: now
+    });
+  }
   return insights2;
 }
 
+// ../intelligence/src/first-citations.ts
+function detectFirstCitations(currentRun, previousRun) {
+  const previousCitedQueries = /* @__PURE__ */ new Set();
+  for (const snap of previousRun.snapshots) {
+    if (snap.cited) previousCitedQueries.add(snap.query);
+  }
+  const result = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const snap of currentRun.snapshots) {
+    if (!snap.cited) continue;
+    if (previousCitedQueries.has(snap.query)) continue;
+    const key = `${snap.query}:${snap.provider}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    result.push({
+      query: snap.query,
+      provider: snap.provider,
+      citationUrl: snap.citationUrl,
+      position: snap.position,
+      runId: currentRun.runId
+    });
+  }
+  return result;
+}
+
+// ../intelligence/src/provider-pickups.ts
+function detectProviderPickups(currentRun, previousRun) {
+  const previousCitedQueries = /* @__PURE__ */ new Set();
+  const previousCitedPairs = /* @__PURE__ */ new Set();
+  for (const snap of previousRun.snapshots) {
+    if (!snap.cited) continue;
+    previousCitedQueries.add(snap.query);
+    previousCitedPairs.add(`${snap.query}:${snap.provider}`);
+  }
+  const result = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const snap of currentRun.snapshots) {
+    if (!snap.cited) continue;
+    if (!previousCitedQueries.has(snap.query)) continue;
+    const key = `${snap.query}:${snap.provider}`;
+    if (previousCitedPairs.has(key)) continue;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    result.push({
+      query: snap.query,
+      provider: snap.provider,
+      citationUrl: snap.citationUrl,
+      position: snap.position,
+      runId: currentRun.runId
+    });
+  }
+  return result;
+}
+
+// ../intelligence/src/persistent-gaps.ts
+var PERSISTENT_GAP_THRESHOLD = 3;
+function detectPersistentGaps(runs2, threshold = PERSISTENT_GAP_THRESHOLD) {
+  if (runs2.length < threshold) return [];
+  const queries2 = /* @__PURE__ */ new Set();
+  for (const run of runs2) {
+    for (const snap of run.snapshots) {
+      if (snap.query) queries2.add(snap.query);
+    }
+  }
+  const result = [];
+  for (const query of queries2) {
+    let streak = 0;
+    for (let i = runs2.length - 1; i >= 0; i--) {
+      const run = runs2[i];
+      const snaps = run.snapshots.filter((s) => s.query === query);
+      if (snaps.length === 0) break;
+      const anyCited = snaps.some((s) => s.cited);
+      if (anyCited) break;
+      streak++;
+    }
+    if (streak >= threshold) {
+      result.push({ query, streak, threshold });
+    }
+  }
+  return result;
+}
+
+// ../intelligence/src/competitor-changes.ts
+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 (!tracked.has(domain)) continue;
+      const existing = result.get(domain) ?? /* @__PURE__ */ new Set();
+      existing.add(snap.query);
+      result.set(domain, existing);
+    }
+  }
+  return result;
+}
+function detectCompetitorGains(currentRun, previousRun, opts) {
+  const tracked = new Set(opts.trackedCompetitors);
+  if (tracked.size === 0) return [];
+  const currentMap = buildCompetitorQueryMap(currentRun, tracked);
+  const previousMap = buildCompetitorQueryMap(previousRun, tracked);
+  const result = [];
+  for (const competitorDomain of tracked) {
+    const currentQs = currentMap.get(competitorDomain) ?? /* @__PURE__ */ new Set();
+    const previousQs = previousMap.get(competitorDomain) ?? /* @__PURE__ */ new Set();
+    for (const query of currentQs) {
+      if (previousQs.has(query)) continue;
+      result.push({ query, competitorDomain });
+    }
+  }
+  return result;
+}
+function detectCompetitorLosses(currentRun, previousRun, opts) {
+  const tracked = new Set(opts.trackedCompetitors);
+  if (tracked.size === 0) return [];
+  const currentMap = buildCompetitorQueryMap(currentRun, tracked);
+  const previousMap = buildCompetitorQueryMap(previousRun, tracked);
+  const result = [];
+  for (const competitorDomain of tracked) {
+    const currentQs = currentMap.get(competitorDomain) ?? /* @__PURE__ */ new Set();
+    const previousQs = previousMap.get(competitorDomain) ?? /* @__PURE__ */ new Set();
+    for (const query of previousQs) {
+      if (currentQs.has(query)) continue;
+      result.push({ query, competitorDomain });
+    }
+  }
+  return result;
+}
+
 // ../intelligence/src/analyzer.ts
-function analyzeRuns(currentRun, previousRun, allRuns) {
+function analyzeRuns(currentRun, previousRun, opts = {}) {
+  const trackedCompetitors = opts.trackedCompetitors ?? [];
+  const history = opts.history ?? [];
+  const persistentGapThreshold = opts.persistentGapThreshold ?? PERSISTENT_GAP_THRESHOLD;
   const regressions = detectRegressions(currentRun, previousRun);
   const gains = detectGains(currentRun, previousRun);
+  const firstCitations = detectFirstCitations(currentRun, previousRun);
+  const providerPickups = detectProviderPickups(currentRun, previousRun);
+  const competitorGains = detectCompetitorGains(currentRun, previousRun, { trackedCompetitors });
+  const competitorLosses = detectCompetitorLosses(currentRun, previousRun, { trackedCompetitors });
+  const persistentGaps = history.length >= persistentGapThreshold ? detectPersistentGaps(history, persistentGapThreshold) : [];
   const health = computeHealth(currentRun);
-  const trend = allRuns ? computeHealthTrend(allRuns) : void 0;
+  const trend = history.length > 0 ? computeHealthTrend(history) : void 0;
   const causes = /* @__PURE__ */ new Map();
   for (const reg of regressions) {
     const cause = analyzeCause(reg, currentRun.snapshots);
     causes.set(`${reg.query}:${reg.provider}`, cause);
   }
-  const insights2 = generateInsights(regressions, gains, health, causes);
+  const insights2 = generateInsights({
+    regressions,
+    gains,
+    firstCitations,
+    providerPickups,
+    persistentGaps,
+    competitorGains,
+    competitorLosses,
+    health,
+    causes
+  });
   return {
     regressions,
     gains,
+    firstCitations,
+    providerPickups,
+    persistentGaps,
+    competitorGains,
+    competitorLosses,
     health,
     trend,
     insights: insights2
@@ -2149,6 +2395,452 @@ function isTrendBaseline(points) {
   return points.length < MIN_TREND_POINTS;
 }
 
+// ../intelligence/src/citation-scorecard.ts
+function buildCitationScorecard(snapshots, queryLookup) {
+  if (snapshots.length === 0) {
+    return { queries: [], providers: [], matrix: [], providerRates: [] };
+  }
+  const querySet = /* @__PURE__ */ new Set();
+  const providerSet = /* @__PURE__ */ new Set();
+  for (const snap of snapshots) {
+    const q = queryLookup.byId.get(snap.queryId);
+    if (!q) continue;
+    querySet.add(q);
+    providerSet.add(snap.provider);
+  }
+  const queryList = [...querySet].sort();
+  const providerList = [...providerSet].sort();
+  const matrix = queryList.map(
+    () => providerList.map(() => null)
+  );
+  const providerCounts = /* @__PURE__ */ new Map();
+  for (const snap of snapshots) {
+    const q = queryLookup.byId.get(snap.queryId);
+    if (!q) continue;
+    const qi = queryList.indexOf(q);
+    const pi = providerList.indexOf(snap.provider);
+    if (qi < 0 || pi < 0) continue;
+    matrix[qi][pi] = {
+      citationState: snap.citationState === CitationStates.cited ? "cited" : "not-cited",
+      answerMentioned: snap.answerMentioned ?? null,
+      model: snap.model
+    };
+    const counts = providerCounts.get(snap.provider) ?? { cited: 0, total: 0 };
+    counts.total++;
+    if (snap.citationState === CitationStates.cited) counts.cited++;
+    providerCounts.set(snap.provider, counts);
+  }
+  const providerRates = providerList.map((provider) => {
+    const counts = providerCounts.get(provider) ?? { cited: 0, total: 0 };
+    const citationRate = counts.total > 0 ? Math.round(counts.cited / counts.total * 100) : 0;
+    return {
+      provider,
+      citedCount: counts.cited,
+      totalCount: counts.total,
+      citationRate
+    };
+  });
+  return { queries: queryList, providers: providerList, matrix, providerRates };
+}
+
+// ../intelligence/src/domain-matching.ts
+function citedDomainBelongsToProject(citedDomain, projectDomains) {
+  const candidate = normalizeProjectDomain(citedDomain);
+  for (const domain of projectDomains) {
+    const normalized = normalizeProjectDomain(domain);
+    if (candidate === normalized || candidate.endsWith(`.${normalized}`)) return true;
+  }
+  return false;
+}
+
+// ../intelligence/src/competitor-landscape.ts
+function buildCompetitorLandscape(snapshots, competitorDomains, projectDomains, queryLookup) {
+  let projectCitationCount = 0;
+  const competitorMap = /* @__PURE__ */ new Map();
+  for (const c of competitorDomains) {
+    competitorMap.set(c, { count: 0, queries: /* @__PURE__ */ new Set(), pages: /* @__PURE__ */ new Map() });
+  }
+  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))) {
+      projectCitationCount++;
+    }
+    for (const competitor of competitorDomains) {
+      if (allDomains.some((d) => citedDomainBelongsToProject(d, [competitor]))) {
+        const entry = competitorMap.get(competitor);
+        entry.count++;
+        if (q) entry.queries.add(q);
+      }
+      const competitorNorm = normalizeUrlDomain(competitor);
+      for (const gs of snap.groundingSources) {
+        const host = normalizeUrlDomain(extractHostFromUri(gs.uri));
+        if (!host) continue;
+        if (host === competitorNorm || host.endsWith(`.${competitorNorm}`)) {
+          const entry = competitorMap.get(competitor);
+          const pageQueries = entry.pages.get(gs.uri) ?? /* @__PURE__ */ new Set();
+          if (q) pageQueries.add(q);
+          entry.pages.set(gs.uri, pageQueries);
+        }
+      }
+    }
+  }
+  const totalCitedSlots = projectCitationCount + [...competitorMap.values()].reduce((sum, v) => sum + v.count, 0);
+  const competitorRows = [...competitorMap.entries()].map(([domain, data]) => {
+    const total = snapshots.length;
+    const ratio = total > 0 ? data.count / total : 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 = totalCitedSlots > 0 ? Math.round(data.count / totalCitedSlots * 100) : 0;
+    const theirCitedPages = [...data.pages.entries()].map(([url, qs]) => ({ url, citedFor: [...qs].sort() })).sort((a, b) => b.citedFor.length - a.citedFor.length);
+    return {
+      domain,
+      citationCount: data.count,
+      totalCount: total,
+      pressureLabel,
+      citedQueries: [...data.queries].sort(),
+      sharePct,
+      theirCitedPages
+    };
+  });
+  competitorRows.sort((a, b) => b.citationCount - a.citationCount);
+  return { projectCitationCount, competitors: competitorRows };
+}
+function normalizeUrlDomain(domain) {
+  return domain.toLowerCase().replace(/^https?:\/\//, "").replace(/^www\./, "").replace(/\/$/, "");
+}
+function extractHostFromUri(uri) {
+  try {
+    return new URL(uri).hostname;
+  } catch {
+    return "";
+  }
+}
+
+// ../intelligence/src/mention-landscape.ts
+function buildMentionLandscape(snapshots, competitorDomains, projectDisplayName, 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() });
+  }
+  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(
+      text2,
+      projectDisplayName,
+      [...projectDomains]
+    );
+    if (projectMentioned) projectMentionCount++;
+    for (const competitor of competitorDomains) {
+      const brand = brandLabelFromDomain(competitor);
+      const mentioned = determineAnswerMentioned(text2, brand, [competitor]);
+      if (mentioned) {
+        const entry = 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 };
+}
+
+// ../intelligence/src/ai-source-origin.ts
+var DEFAULT_TOP_SOURCE_DOMAINS_LIMIT = 20;
+function buildAiSourceOrigin(snapshots, projectDomains, competitorDomains, topDomainsLimit = DEFAULT_TOP_SOURCE_DOMAINS_LIMIT) {
+  const categoryCounts = /* @__PURE__ */ new Map();
+  const domainCounts = /* @__PURE__ */ new Map();
+  let totalCitations = 0;
+  for (const snap of snapshots) {
+    for (const raw of snap.citedDomains) {
+      if (citedDomainBelongsToProject(raw, projectDomains)) continue;
+      const { category, domain } = categorizeSourceWithCompetitors(
+        raw,
+        competitorDomains,
+        citedDomainBelongsToProject
+      );
+      const bucketLabel = categoryLabel(category);
+      const cat = categoryCounts.get(category) ?? { label: bucketLabel, count: 0 };
+      cat.count++;
+      categoryCounts.set(category, cat);
+      domainCounts.set(domain, (domainCounts.get(domain) ?? 0) + 1);
+      totalCitations++;
+    }
+  }
+  const categories = [...categoryCounts.entries()].map(([category, { label, count }]) => ({
+    category,
+    label,
+    count,
+    sharePct: totalCitations > 0 ? Math.round(count / totalCitations * 100) : 0
+  })).sort((a, b) => b.count - a.count);
+  const topDomains = [...domainCounts.entries()].map(([domain, count]) => ({
+    domain,
+    count,
+    isCompetitor: citedDomainBelongsToProject(domain, competitorDomains)
+  })).sort((a, b) => b.count - a.count).slice(0, topDomainsLimit);
+  return { categories, topDomains };
+}
+
+// ../intelligence/src/movement-summary.ts
+function buildMovementSummary(currentSnapshots, previousSnapshots) {
+  if (previousSnapshots.length === 0) {
+    const citedCount = collectCitedQueryIds(currentSnapshots).size;
+    const tone2 = citedCount > 0 ? "positive" : "neutral";
+    return { gained: citedCount, lost: 0, tone: tone2, hasPreviousRun: false };
+  }
+  const latestCited = collectCitedQueryIds(currentSnapshots);
+  const previousCited = collectCitedQueryIds(previousSnapshots);
+  let gained = 0;
+  let lost = 0;
+  for (const id of latestCited) {
+    if (!previousCited.has(id)) gained++;
+  }
+  for (const id of previousCited) {
+    if (!latestCited.has(id)) lost++;
+  }
+  const tone = lost > gained ? "negative" : gained > lost ? "positive" : "neutral";
+  return { gained, lost, tone, hasPreviousRun: true };
+}
+function collectCitedQueryIds(snapshots) {
+  const cited = /* @__PURE__ */ new Set();
+  for (const s of snapshots) {
+    if (s.citationState === CitationStates.cited && s.queryId) cited.add(s.queryId);
+  }
+  return cited;
+}
+
+// ../intelligence/src/score-tones.ts
+function scoreTone(score) {
+  if (score >= 70) return "positive";
+  if (score >= 40) return "caution";
+  return "negative";
+}
+function pressureTone(label) {
+  if (label === "High") return "negative";
+  if (label === "Moderate") return "caution";
+  return "neutral";
+}
+function gapTone(gapCount, totalCount) {
+  if (gapCount === 0) return "positive";
+  const ratio = totalCount > 0 ? gapCount / totalCount : 0;
+  if (ratio >= 0.3) return "negative";
+  return "caution";
+}
+
+// ../intelligence/src/visibility-score.ts
+function buildVisibilityScore(snapshots, options) {
+  const tooltip = 'Percentage of tracked queries where your domain is cited by at least one AI answer engine. A query is "visible" if any configured provider includes your site in its response.';
+  if (snapshots.length === 0) {
+    return {
+      label: "Answer Visibility",
+      value: "No data",
+      delta: "Run a sweep first",
+      tone: "neutral",
+      description: "No visibility data yet. Trigger a run to start tracking.",
+      tooltip,
+      trend: []
+    };
+  }
+  const queryCited = /* @__PURE__ */ new Map();
+  for (const snap of snapshots) {
+    if (!queryCited.has(snap.queryId)) queryCited.set(snap.queryId, false);
+    if (snap.citationState === CitationStates.cited) queryCited.set(snap.queryId, true);
+  }
+  const totalCount = queryCited.size;
+  const citedCount = [...queryCited.values()].filter(Boolean).length;
+  const score = totalCount > 0 ? Math.round(citedCount / totalCount * 100) : 0;
+  const runProviders = new Set(snapshots.map((s) => s.provider));
+  const runApiProviderCount = options.configuredApiProviders.filter((p) => runProviders.has(p)).length;
+  const isPartialProviderRun = options.configuredApiProviders.length > 1 && runApiProviderCount < options.configuredApiProviders.length;
+  return {
+    label: "Answer Visibility",
+    value: `${score}`,
+    delta: `${citedCount} of ${totalCount} queries visible`,
+    tone: isPartialProviderRun ? "caution" : scoreTone(score),
+    description: `${citedCount} of ${totalCount} tracked queries found your domain in at least one AI answer engine.`,
+    tooltip,
+    trend: [],
+    progress: score,
+    providerCoverage: isPartialProviderRun ? `${runApiProviderCount} of ${options.configuredApiProviders.length} providers` : void 0
+  };
+}
+
+// ../intelligence/src/gap-query-score.ts
+function buildGapQueryScore(snapshots) {
+  const tooltip = "Tracked queries where a competitor is cited in the latest run but your domain is not.";
+  if (snapshots.length === 0) {
+    return {
+      label: "Gap Queries",
+      value: "No data",
+      delta: "Run a sweep first",
+      tone: "neutral",
+      description: "Run a visibility sweep to identify queries where competitors are cited and your domain is not.",
+      tooltip,
+      trend: []
+    };
+  }
+  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() };
+    if (snap.citationState === CitationStates.cited) current.cited = true;
+    for (const domain of snap.competitorOverlap) current.competitorOverlap.add(domain);
+    byQuery.set(key, current);
+  }
+  const totalCount = byQuery.size;
+  const gapCount = [...byQuery.values()].filter(
+    (entry) => !entry.cited && entry.competitorOverlap.size > 0
+  ).length;
+  const gapQueryLabel = gapCount === 1 ? "query" : "queries";
+  return {
+    label: "Gap Queries",
+    value: `${gapCount}`,
+    delta: `${gapCount} of ${totalCount} queries at risk`,
+    tone: gapTone(gapCount, totalCount),
+    description: gapCount > 0 ? `${gapCount} tracked ${gapQueryLabel} currently cite competitors without citing your domain.` : "No competitive query gaps detected in the latest visibility run.",
+    tooltip,
+    trend: [],
+    progress: totalCount > 0 ? Math.round(gapCount / totalCount * 100) : 0
+  };
+}
+
+// ../intelligence/src/competitor-pressure-score.ts
+function buildCompetitorPressureScore(snapshots, competitorDomains, totalTrackedCompetitors) {
+  const tooltip = "How often competitor domains appear alongside yours in AI answers. High pressure means competitors are frequently cited for the same queries.";
+  const description = totalTrackedCompetitors > 0 ? `${totalTrackedCompetitors} competitor${totalTrackedCompetitors > 1 ? "s" : ""} tracked.` : "No competitors configured.";
+  if (snapshots.length === 0 || competitorDomains.length === 0) {
+    return {
+      label: "Competitor Pressure",
+      value: "None",
+      delta: "No overlap detected",
+      tone: pressureTone("None"),
+      description,
+      tooltip,
+      trend: []
+    };
+  }
+  const competitorSet = new Set(competitorDomains);
+  let overlapCount = 0;
+  for (const snap of snapshots) {
+    if (snap.competitorOverlap.some((d) => competitorSet.has(d))) {
+      overlapCount++;
+    }
+  }
+  const ratio = overlapCount / snapshots.length;
+  const label = ratio >= 0.5 ? "High" : ratio >= 0.2 ? "Moderate" : overlapCount > 0 ? "Low" : "None";
+  return {
+    label: "Competitor Pressure",
+    value: label,
+    delta: overlapCount > 0 ? `${overlapCount} overlapping citations` : "No overlap detected",
+    tone: pressureTone(label),
+    description,
+    tooltip,
+    trend: []
+  };
+}
+function buildOverviewCompetitors(snapshots, competitors2, queryLookup) {
+  const uniqueQueries = /* @__PURE__ */ new Set();
+  for (const snap of snapshots) {
+    if (snap.queryId) uniqueQueries.add(snap.queryId);
+  }
+  const renderQuery = (queryId) => queryLookup?.byId.get(queryId) ?? queryId;
+  return competitors2.map((competitor, index2) => {
+    const citedQuerySet = /* @__PURE__ */ new Set();
+    for (const snap of snapshots) {
+      if (snap.competitorOverlap.includes(competitor.domain) || snap.citedDomains.includes(competitor.domain)) {
+        if (snap.queryId) citedQuerySet.add(snap.queryId);
+      }
+    }
+    const citedQueries = [...citedQuerySet].map(renderQuery).sort();
+    const ratio = uniqueQueries.size > 0 ? citedQuerySet.size / uniqueQueries.size : 0;
+    const pressureLabel = ratio >= 0.5 ? "High" : ratio >= 0.2 ? "Moderate" : citedQuerySet.size > 0 ? "Low" : "None";
+    return {
+      id: competitor.id || `comp_${index2}`,
+      domain: competitor.domain,
+      citationCount: citedQuerySet.size,
+      totalQueries: uniqueQueries.size,
+      pressureLabel,
+      citedQueries
+    };
+  });
+}
+
+// ../intelligence/src/provider-scores.ts
+function buildProviderScores(snapshots) {
+  const modelGroups = /* @__PURE__ */ new Map();
+  for (const snap of snapshots) {
+    const provider = snap.provider;
+    const model = snap.model ?? null;
+    const key = `${provider}::${model ?? "unknown"}`;
+    const group = modelGroups.get(key) ?? { provider, model, cited: 0, total: 0 };
+    group.total++;
+    if (snap.citationState === CitationStates.cited) group.cited++;
+    modelGroups.set(key, group);
+  }
+  return [...modelGroups.values()].sort(
+    (a, b) => a.provider.localeCompare(b.provider) || (a.model ?? "").localeCompare(b.model ?? "")
+  ).map(({ provider, model, cited, total }) => ({
+    provider,
+    model,
+    score: total > 0 ? Math.round(cited / total * 100) : 0,
+    cited,
+    total
+  }));
+}
+
+// ../intelligence/src/run-history.ts
+var DEFAULT_RUN_HISTORY_LIMIT = 12;
+function buildRunHistory(runs2, snapshotsByRunId, limit = DEFAULT_RUN_HISTORY_LIMIT) {
+  const recent = [...runs2].sort((a, b) => b.createdAt.localeCompare(a.createdAt)).slice(0, limit).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+  return recent.map((run) => {
+    const snapshots = snapshotsByRunId.get(run.id) ?? [];
+    const queryCited = /* @__PURE__ */ new Map();
+    for (const snap of snapshots) {
+      if (!queryCited.has(snap.queryId)) queryCited.set(snap.queryId, false);
+      if (snap.citationState === CitationStates.cited) queryCited.set(snap.queryId, true);
+    }
+    const totalCount = queryCited.size;
+    const citedCount = [...queryCited.values()].filter(Boolean).length;
+    const citationRate = totalCount > 0 ? Math.round(citedCount / totalCount * 100) : 0;
+    return {
+      runId: run.id,
+      createdAt: run.createdAt,
+      citedCount,
+      totalCount,
+      citationRate,
+      status: run.status
+    };
+  });
+}
+
 // src/intelligence-service.ts
 import crypto from "crypto";
 
@@ -2191,6 +2883,7 @@ function createLogger(module) {
 
 // src/intelligence-service.ts
 var RECURRENCE_LOOKBACK_RUNS = 5;
+var HISTORY_WINDOW_RUNS = Math.max(PERSISTENT_GAP_THRESHOLD, 5);
 var log = createLogger("IntelligenceService");
 var IntelligenceService = class {
   constructor(db) {
@@ -2207,7 +2900,7 @@ var IntelligenceService = class {
         eq(runs.projectId, projectId),
         or(eq(runs.status, "completed"), eq(runs.status, "partial"))
       )
-    ).orderBy(desc(runs.createdAt)).limit(2).all();
+    ).orderBy(desc(runs.finishedAt), desc(runs.createdAt)).limit(HISTORY_WINDOW_RUNS).all();
     if (recentRuns.length === 0) {
       log.info("intelligence.skip", { runId, reason: "no completed runs" });
       return null;
@@ -2222,10 +2915,14 @@ var IntelligenceService = class {
       log.info("intelligence.skip", { runId, reason: "no snapshots" });
       return null;
     }
-    const previousRunRecord = recentRuns.find((r) => r.id !== runId);
+    const orderedRecent = [...recentRuns].reverse();
+    const currentIdx = orderedRecent.findIndex((r) => r.id === runId);
+    const previousRunRecord = currentIdx > 0 ? orderedRecent[currentIdx - 1] : null;
     const previousRun = previousRunRecord ? this.buildRunData(previousRunRecord.id, projectId, previousRunRecord.finishedAt ?? previousRunRecord.createdAt) : null;
+    const trackedCompetitors = this.loadTrackedCompetitors(projectId);
+    const history = orderedRecent.slice(0, currentIdx + 1).map((r) => r.id === runId ? currentRun : this.buildRunData(r.id, projectId, r.finishedAt ?? r.createdAt));
     if (!previousRun) {
-      const result2 = analyzeRuns(currentRun, currentRun);
+      const result2 = analyzeRuns(currentRun, currentRun, { trackedCompetitors, history });
       log.info("intelligence.analyzed", {
         runId,
         regressions: 0,
@@ -2233,14 +2930,19 @@ var IntelligenceService = class {
         citedRate: result2.health.overallCitedRate,
         insights: 0
       });
-      this.persistResult({ ...result2, insights: [], regressions: [], gains: [] }, runId, projectId);
+      this.persistResult(this.emptyAnalysisResult(result2), runId, projectId);
       return result2;
     }
-    const result = analyzeRuns(currentRun, previousRun);
+    const result = analyzeRuns(currentRun, previousRun, { trackedCompetitors, history });
     log.info("intelligence.analyzed", {
       runId,
       regressions: result.regressions.length,
       gains: result.gains.length,
+      firstCitations: result.firstCitations.length,
+      providerPickups: result.providerPickups.length,
+      persistentGaps: result.persistentGaps.length,
+      competitorGains: result.competitorGains.length,
+      competitorLosses: result.competitorLosses.length,
       citedRate: result.health.overallCitedRate,
       insights: result.insights.length
     });
@@ -2252,18 +2954,20 @@ var IntelligenceService = class {
    * Analyze a single run given an explicit previous run (or null for first run).
    * Used by backfill where we control the run ordering.
    */
-  analyzeRunWithPrevious(runRecord, previousRunRecord) {
+  analyzeRunWithPrevious(runRecord, previousRunRecord, historyRecords) {
     const currentRun = this.buildRunData(runRecord.id, runRecord.projectId, runRecord.finishedAt ?? runRecord.createdAt);
     if (currentRun.snapshots.length === 0) {
       return null;
     }
     const previousRun = previousRunRecord ? this.buildRunData(previousRunRecord.id, previousRunRecord.projectId, previousRunRecord.finishedAt ?? previousRunRecord.createdAt) : 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));
     if (!previousRun) {
-      const result2 = analyzeRuns(currentRun, currentRun);
-      this.persistResult({ ...result2, insights: [], regressions: [], gains: [] }, runRecord.id, runRecord.projectId);
+      const result2 = analyzeRuns(currentRun, currentRun, { trackedCompetitors, history });
+      this.persistResult(this.emptyAnalysisResult(result2), runRecord.id, runRecord.projectId);
       return result2;
     }
-    const result = analyzeRuns(currentRun, previousRun);
+    const result = analyzeRuns(currentRun, previousRun, { trackedCompetitors, history });
     const tieredResult = this.tierResult(result, runRecord.id, runRecord.projectId);
     this.persistResult(tieredResult, runRecord.id, runRecord.projectId);
     return tieredResult;
@@ -2303,7 +3007,9 @@ var IntelligenceService = class {
       const run = targetRuns[i];
       const globalIdx = allRuns.indexOf(run);
       const previousRun = globalIdx > 0 ? allRuns[globalIdx - 1] : null;
-      const result = this.analyzeRunWithPrevious(run, previousRun);
+      const historyStart = Math.max(0, globalIdx - (HISTORY_WINDOW_RUNS - 1));
+      const historyRecords = allRuns.slice(historyStart, globalIdx + 1);
+      const result = this.analyzeRunWithPrevious(run, previousRun, historyRecords);
       if (result) {
         processed++;
         totalInsights += result.insights.length;
@@ -2315,6 +3021,26 @@ var IntelligenceService = class {
     }
     return { processed, skipped, totalInsights };
   }
+  loadTrackedCompetitors(projectId) {
+    return this.db.select({ domain: competitors.domain }).from(competitors).where(eq(competitors.projectId, projectId)).all().map((r) => r.domain);
+  }
+  /**
+   * Wipe transition signals from an analysis result while keeping health.
+   * Used when there's no baseline (first run) to avoid emitting false transitions.
+   */
+  emptyAnalysisResult(result) {
+    return {
+      ...result,
+      insights: [],
+      regressions: [],
+      gains: [],
+      firstCitations: [],
+      providerPickups: [],
+      persistentGaps: [],
+      competitorGains: [],
+      competitorLosses: []
+    };
+  }
   persistResult(result, runId, projectId) {
     const previouslyDismissed = /* @__PURE__ */ new Set();
     const existingInsights = this.db.select({ query: insights.query, provider: insights.provider, type: insights.type, dismissed: insights.dismissed }).from(insights).where(eq(insights.runId, runId)).all();
@@ -2426,7 +3152,7 @@ var IntelligenceService = class {
         provider: r.provider,
         cited: r.citationState === CitationStates.cited,
         citationUrl: domains[0] ?? void 0,
-        competitorDomain: competitors2[0] ?? void 0
+        competitorDomains: competitors2
       };
     });
     return { runId, projectId, completedAt, snapshots };
@@ -2477,6 +3203,18 @@ export {
   categorizeQueryByIntent,
   MIN_TREND_POINTS,
   isTrendBaseline,
+  buildCitationScorecard,
+  buildCompetitorLandscape,
+  buildMentionLandscape,
+  buildAiSourceOrigin,
+  buildMovementSummary,
+  buildVisibilityScore,
+  buildGapQueryScore,
+  buildCompetitorPressureScore,
+  buildOverviewCompetitors,
+  buildProviderScores,
+  DEFAULT_RUN_HISTORY_LIMIT,
+  buildRunHistory,
   createLogger,
   IntelligenceService
 };