glippy-mcp 0.3.1 → 0.3.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "glippy-mcp",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "description": "MCP server for GEO (Generative Engine Optimization) analysis — check any domain's AI-readiness",
   "main": "src/index.js",
   "type": "module",

package/src/geo-checker.js

@@ -31,22 +31,105 @@ function looksBotBlocked(res) {
 const FETCH_TIMEOUT_MS = 15_000;
 
 /**
- * Known AI crawler user-agent tokens.  These are checked against robots.txt
- * Disallow / Allow rules.
+ * Training-only crawlers. Blocking these is informational: it keeps content
+ * out of LLM training corpora but does not affect AI citation surfaces.
  */
-const AI_CRAWLERS = Object.freeze([
+const TRAINING_CRAWLERS = Object.freeze([
   'GPTBot',
-  'Google-Extended',
-  'CCBot',
-  'anthropic-ai',
   'ClaudeBot',
+  'anthropic-ai',
+  'CCBot',
+  'Google-Extended',
+  'Applebot-Extended',
   'Bytespider',
-  'PerplexityBot',
-  'ChatGPT-User',
-  'AmazonBot',
+  'FacebookBot',
+  'Meta-ExternalAgent',
   'cohere-ai',
+  'Diffbot',
+  'Omgili',
+  'Amazonbot',
+  'Timpibot',
+  'ImageSiftBot',
+  // Broadened: SEO/search/training crawlers commonly named in robots.txt.
+  'PetalBot',
+  'MJ12bot',
+  'AwarioBot',
+  'AhrefsBot',
+  'SemrushBot',
+  'DotBot',
+  'SeznamBot',
+  'magpie-crawler',
+  'DataForSeoBot',
+  'iaskbot',
+  'Pangu_Bot',
+  'claude-web',
+  'cohere-training-data-crawler',
+  'meta-externalfetcher',
+]);
+
+/**
+ * Citation/retrieval crawlers. Blocking these directly hurts AI visibility
+ * because answer engines cannot fetch content for inline citation.
+ */
+const CITATION_CRAWLERS = Object.freeze([
+  'OAI-SearchBot',
+  'ChatGPT-User',
+  'PerplexityBot',
+  'Perplexity-User',
+  'Applebot',
+  'Bingbot',
+  'Googlebot',
+  'DuckDuckBot',
+  'YouBot',
+  // Broadened: alternative answer engines and search crawlers.
+  'MistralAI-User',
+  'PhindBot',
+  'Komo',
+  'AndiBot',
+  'BraveBot',
+  'KagiBot',
+  'Yep',
+  'NeevaBot',
+  'Exabot',
+  'Qwantify',
+  'Seznam',
+  'GoogleOther',
+  'Google-CloudVertexBot',
+  'BingPreview',
 ]);
 
+/**
+ * Match a User-Agent token against a list of known crawlers using a
+ * case-insensitive longest-prefix match. This prevents short prefixes like
+ * "applebot" from incorrectly absorbing "applebot-extended" matches.
+ *
+ * @param {string} ua - User-Agent token from robots.txt or meta tag.
+ * @param {readonly string[]} crawlers - Crawler list to match against.
+ * @returns {string|null} - The matched crawler name (original casing) or null.
+ */
+function matchCrawler(ua, crawlers) {
+  if (!ua) return null;
+  const lower = ua.toLowerCase();
+  let bestMatch = null;
+  let bestLen = 0;
+  for (const c of crawlers) {
+    const cl = c.toLowerCase();
+    if (lower === cl || lower.startsWith(cl) || lower.includes(cl)) {
+      if (cl.length > bestLen) {
+        bestLen = cl.length;
+        bestMatch = c;
+      }
+    }
+  }
+  return bestMatch;
+}
+
+/**
+ * Combined AI crawler list, kept for back-compat with downstream callers
+ * that iterate the union (e.g. robots.txt block detection per crawler).
+ */
+const AI_CRAWLERS = Object.freeze([...TRAINING_CRAWLERS, ...CITATION_CRAWLERS]);
+
 /** Maximum number of redirects to follow when fetching a resource. */
 const MAX_REDIRECTS = 5;
 
@@ -759,7 +842,7 @@ function aggregatePageScores(pageResults) {
 function detectPageType($, schemaTypes, pathname) {
   // Check JSON-LD schema types first (most reliable signal).
   // A page can carry FAQPage schema for a small FAQ section while being a long-form
-  // guide. Only classify as "faq" when FAQPage is the dominant structure - otherwise
+  // guide. Only classify as "faq" when FAQPage is the dominant structure, otherwise
   // a 6,400-word guide with a FAQ at the bottom gets penalized as exceeding FAQ length.
   const allH2s = $('h2');
   const h2Count = allH2s.length;
@@ -772,11 +855,52 @@ function detectPageType($, schemaTypes, pathname) {
   });
   const isDominantlyFaq = h2Count > 0 && questionH2Count >= h2Count * 0.7;
 
-  if (schemaTypes.has('FAQPage') && isDominantlyFaq) return 'faq';
+  // Word count for length-based reclassification of FAQ-tagged guides.
+  const mainElForCount = $('main, article, [role="main"]');
+  const mainTextForCount = (mainElForCount.length > 0 ? mainElForCount.text() : $('body').text() || '').trim();
+  const wordCountForType = mainTextForCount.split(/\s+/).filter(w => w.length > 0).length;
+
+  // Non-FAQ schema types that, when coexisting with FAQPage, signal a hybrid
+  // guide rather than a pure FAQ page.
+  const NON_FAQ_GUIDE_TYPES = [
+    'Article', 'NewsArticle', 'BlogPosting', 'TechArticle', 'HowTo', 'Product',
+    'Dataset', 'Report', 'WebPage',
+    // Broadened: more schema types that imply guide/long-form rather than pure FAQ.
+    'Recipe', 'ScholarlyArticle', 'Guide', 'Course', 'Service',
+    'MedicalEntity', 'MedicalGuideline', 'Book', 'Chapter',
+    'LearningResource', 'Review', 'CollectionPage', 'ItemPage',
+  ];
+  const hasNonFaqGuideType = NON_FAQ_GUIDE_TYPES.some((t) => schemaTypes.has(t));
+
+  // Heuristic guide-title overrides: title or H1 phrasing strongly implies a guide.
+  const titleText = ($('title').text() || '').trim();
+  const h1Text = ($('h1').first().text() || '').trim();
+  const titleAndH1 = `${titleText} ${h1Text}`;
+  const GUIDE_TITLE_RE = /\b(?:complete|ultimate|definitive|comprehensive)?\s*guide\b/i;
+  const EVERYTHING_RE = /everything you need/i;
+  const HOW_TO_TITLE_RE = /how to/i;
+  const STEP_BY_STEP_RE = /step[- ]by[- ]step/i;
+  const matchesGuideTitle = GUIDE_TITLE_RE.test(titleAndH1)
+    || EVERYTHING_RE.test(titleAndH1)
+    || HOW_TO_TITLE_RE.test(titleAndH1)
+    || STEP_BY_STEP_RE.test(titleAndH1);
+
+  // Definition-list + multiple H2 sections is a strong guide signal.
+  const hasDefinitionListGuide = $('dl').length > 0 && h2Count >= 2;
+
+  // Long-form / heading-rich pages should never classify as pure FAQ.
+  const tooLongForFaq = wordCountForType > 2000;
+  const tooManyH2sForFaq = h2Count > 8;
+
+  if (matchesGuideTitle || hasDefinitionListGuide) return 'article';
+  if (schemaTypes.has('FAQPage') && isDominantlyFaq && !hasNonFaqGuideType
+      && wordCountForType <= 1500 && !tooManyH2sForFaq && !tooLongForFaq) return 'faq';
   if (['Article', 'NewsArticle', 'BlogPosting', 'TechArticle'].some((t) => schemaTypes.has(t))) return 'article';
-  // FAQPage schema present but page also has many topic-style H2s = guide with a FAQ section.
-  if (schemaTypes.has('FAQPage') && h2Count >= 6) return 'article';
-  if (schemaTypes.has('FAQPage')) return 'faq';
+  // FAQPage schema present but page is also long-form or carries another guide-type schema:
+  // treat as article so guide-style word/heading expectations apply.
+  if (schemaTypes.has('FAQPage') && (hasNonFaqGuideType || wordCountForType > 1500 || h2Count >= 6 || tooManyH2sForFaq || tooLongForFaq)) return 'article';
+  if (schemaTypes.has('FAQPage') && !tooManyH2sForFaq && !tooLongForFaq) return 'faq';
+  if (schemaTypes.has('FAQPage')) return 'article';
   if (['Product', 'Offer'].some((t) => schemaTypes.has(t))) return 'product';
   if (['LocalBusiness', 'Restaurant', 'Store'].some((t) => schemaTypes.has(t))) return 'local-business';
 
@@ -908,7 +1032,9 @@ function checkStructuredData($, pageType, jsonLdData, jsonLdValid, jsonLdInvalid
     checks.push({ status: 'pass', label: `GEO-critical schema types present (${foundImportant.length})`, detail: foundImportant.join(', ') });
   } else if (foundImportant.length > 0) {
     score += 5;
-    checks.push({ status: 'warn', label: `Only ${foundImportant.length} GEO-critical schema type(s)`, detail: `Found: ${foundImportant.join(', ')}. Consider adding: FAQPage, HowTo, Article, BreadcrumbList` });
+    const suggestions = ['FAQPage', 'HowTo', 'Article', 'BreadcrumbList'].filter((t) => !schemaTypes.has(t));
+    const consider = suggestions.length > 0 ? `. Consider adding: ${suggestions.join(', ')}` : '';
+    checks.push({ status: 'warn', label: `Only ${foundImportant.length} GEO-critical schema type(s)`, detail: `Found: ${foundImportant.join(', ')}${consider}` });
   } else {
     checks.push({ status: 'fail', label: 'No GEO-critical schema types', detail: 'Add FAQPage, Article, Organization, BreadcrumbList, etc.' });
   }
@@ -1853,38 +1979,66 @@ function checkMachineReadability($, robotsTxtData, llmsTxtData, responseHeaders)
     checks.push({ status: 'pass', label: 'No restrictive robots meta', detail: 'Page is open for indexing' });
   }
 
-  // Check for specific AI bot meta tags
-  const aiBotMeta = ['googlebot', 'bingbot', 'gptbot', 'chatgpt-user', 'anthropic-ai', 'claude-web', 'ccbot', 'google-extended', 'perplexitybot', 'claudebot'];
-  const blockedBots = [];
+  // Check for specific AI bot meta tags. Split blocked bots into training-only
+  // (informational) vs citation crawlers (real penalty) so a noindex on GPTBot
+  // is not weighted the same as a noindex on Googlebot.
+  const trainingBotMeta = TRAINING_CRAWLERS.map(c => c.toLowerCase());
+  const citationBotMeta = CITATION_CRAWLERS.map(c => c.toLowerCase()).concat(['claude-web']);
+  const aiBotMeta = [...new Set([...trainingBotMeta, ...citationBotMeta])];
+  const blockedTrainingBots = [];
+  const blockedCitationBots = [];
   aiBotMeta.forEach((bot) => {
     const content = $(`meta[name="${bot}"]`).attr('content') || '';
     if (content.includes('noindex')) {
-      blockedBots.push(bot);
+      if (citationBotMeta.includes(bot)) {
+        blockedCitationBots.push(bot);
+      } else {
+        blockedTrainingBots.push(bot);
+      }
     }
   });
 
   maxScore += 15;
-  if (blockedBots.length === 0) {
+  if (blockedCitationBots.length === 0 && blockedTrainingBots.length === 0) {
     score += 15;
     checks.push({ status: 'pass', label: 'No AI bot restrictions in meta', detail: 'No specific bot blocking detected in page HTML' });
+  } else if (blockedCitationBots.length === 0) {
+    score += 15;
+    checks.push({ status: 'info', label: `Training crawler meta blocks: ${blockedTrainingBots.join(', ')}`, detail: 'Training-only blocks do not affect AI citation visibility', found: blockedTrainingBots });
   } else {
-    checks.push({ status: 'warn', label: `AI bot blocking detected: ${blockedBots.join(', ')}`, detail: 'These bots are blocked via meta tags', found: blockedBots });
+    score += Math.max(0, 15 - blockedCitationBots.length * 3);
+    checks.push({ status: 'warn', label: `Citation crawler meta blocks: ${blockedCitationBots.join(', ')}`, detail: 'These citation crawlers are blocked via meta tags', found: blockedCitationBots });
+    if (blockedTrainingBots.length > 0) {
+      checks.push({ status: 'info', label: `Training crawler meta blocks: ${blockedTrainingBots.join(', ')}`, detail: 'Training-only blocks are informational', found: blockedTrainingBots });
+    }
   }
 
   // robots.txt integration (from server-side fetch)
   if (robotsTxtData) {
     maxScore += 10;
     if (robotsTxtData.exists) {
-      const crawlerBlocked = Object.entries(robotsTxtData.blocksCrawlers || {}).filter(([, v]) => v);
-      if (crawlerBlocked.length === 0) {
+      const blocks = robotsTxtData.blocksCrawlers || {};
+      const trainingLowercase = new Set(TRAINING_CRAWLERS.map(c => c.toLowerCase()));
+      const citationLowercase = new Set(CITATION_CRAWLERS.map(c => c.toLowerCase()));
+      const blockedAll = Object.entries(blocks).filter(([, v]) => v).map(([k]) => k);
+      const blockedTraining = blockedAll.filter(k => trainingLowercase.has(k.toLowerCase()));
+      const blockedCitation = blockedAll.filter(k => citationLowercase.has(k.toLowerCase()));
+
+      if (blockedCitation.length === 0 && blockedTraining.length === 0) {
+        score += 10;
+        checks.push({ status: 'pass', label: 'robots.txt: no AI crawlers blocked', detail: 'All known training and citation crawlers are allowed' });
+      } else if (blockedCitation.length === 0) {
         score += 10;
-        checks.push({ status: 'pass', label: 'robots.txt: no AI crawlers blocked', detail: 'All known AI crawlers are allowed' });
+        checks.push({ status: 'info', label: `robots.txt: ${blockedTraining.length} training crawler(s) blocked, citation crawlers allowed`, detail: 'Training-only blocks do not affect AI citation visibility', found: blockedTraining });
       } else {
-        score += Math.max(0, 10 - crawlerBlocked.length * 2);
-        checks.push({ status: 'warn', label: `robots.txt: ${crawlerBlocked.length} AI crawler(s) blocked`, detail: 'Blocked crawlers cannot index your content', found: crawlerBlocked.map(([k]) => k) });
+        score += Math.max(0, 10 - blockedCitation.length * 2);
+        checks.push({ status: 'warn', label: `robots.txt: ${blockedCitation.length} citation crawler(s) blocked`, detail: 'Blocking citation crawlers prevents inline AI citations', found: blockedCitation });
+        if (blockedTraining.length > 0) {
+          checks.push({ status: 'info', label: `robots.txt: ${blockedTraining.length} training crawler(s) blocked`, detail: 'Training-only blocks are informational and do not affect AI citation visibility', found: blockedTraining });
+        }
       }
       if (robotsTxtData.hasWildcardDisallow) {
-        checks.push({ status: 'warn', label: 'robots.txt: wildcard Disallow: /', detail: 'All crawlers are blocked by default - only overridden by specific Allow rules' });
+        checks.push({ status: 'warn', label: 'robots.txt: wildcard Disallow: /', detail: 'All crawlers are blocked by default, only overridden by specific Allow rules' });
       }
     } else {
       checks.push({ status: 'warn', label: 'No robots.txt found', detail: 'robots.txt helps control crawler access' });
@@ -4036,24 +4190,68 @@ function checkContentFreshness($, jsonLdData) {
   }
 
   // 12d. Copyright Year & Footer Freshness (10 pts)
-  // Year ranges ("© 1997 - 2026") signal a founding year + current year - take the END
-  // year as the freshness signal, not the founding year.
+  // Year ranges ("(c) 1997 - 2026") signal a founding year + current year, take
+  // the END year as the freshness signal, not the founding year.
+  // Also handles enumerated lists like "(c) 2010, 2015, 2026" by taking the max
+  // of all years in the same line as a copyright marker.
   const footerEl = $('footer');
   maxScore += 10;
   if (footerEl.length > 0) {
-    const footerText = footerEl.text();
-    const rangeMatch = footerText.match(/©\s*(\d{4})\s*(?:[‐-―−\-–—~]|to)\s*(\d{4})/);
-    const singleMatch = !rangeMatch ? footerText.match(/©\s*(\d{4})/) : null;
-    if (rangeMatch || singleMatch) {
-      const copyrightYear = parseInt((rangeMatch ? rangeMatch[2] : singleMatch[1]), 10);
-      if (copyrightYear === currentYear) {
+    // Strip "All Rights Reserved" boilerplate (en/fr/de) before parsing.
+    const rawFooterText = footerEl.text();
+    const footerText = rawFooterText
+      .replace(/all\s+rights\s+reserved/gi, '')
+      .replace(/tous\s+droits\s+r[ée]serv[ée]s/gi, '')
+      .replace(/alle\s+rechte\s+vorbehalten/gi, '');
+    // Broader prefix list: includes bracket variants and "Copyright ©" double prefix.
+    const COPYRIGHT_PREFIX = /(?:©|\(c\)|\(C\)|\[c\]|\[C\]|&copy;|copyright(?:\s*©)?)/i;
+    // Exclude founding year markers so "Est. 1998" / "Since 2001" do not get
+    // mistaken for a copyright year when no actual copyright marker is present.
+    const FOUNDING_PREFIX = /\b(?:est(?:ablished|\.)?|since|founded(?:\s+in)?)\s+\d{4}\b/i;
+    let copyrightYear = null;
+    // Sweep each line for a copyright marker; take the max year found on that line.
+    const lines = footerText.split(/\r?\n|<br\s*\/?>/i);
+    for (const rawLine of lines) {
+      const line = rawLine.trim();
+      if (!line) continue;
+      if (!COPYRIGHT_PREFIX.test(line)) continue;
+      // Skip lines that look like founding-year statements without a real © marker.
+      const hasRealMarker = /(?:©|\(c\)|\(C\)|\[c\]|\[C\]|&copy;|copyright)/i.test(line);
+      if (!hasRealMarker && FOUNDING_PREFIX.test(line)) continue;
+      const yearMatches = line.match(/\b(19|20)\d{2}\b/g);
+      if (yearMatches && yearMatches.length > 0) {
+        const maxYear = Math.max(...yearMatches.map(y => parseInt(y, 10)));
+        if (copyrightYear === null || maxYear > copyrightYear) copyrightYear = maxYear;
+      }
+    }
+    // Fallback: if the footer is a single blob without line breaks, sweep the
+    // whole text but only when a copyright marker exists.
+    if (copyrightYear === null && COPYRIGHT_PREFIX.test(footerText)) {
+      const yearMatches = footerText.match(/\b(19|20)\d{2}\b/g);
+      if (yearMatches && yearMatches.length > 0) {
+        copyrightYear = Math.max(...yearMatches.map(y => parseInt(y, 10)));
+      }
+    }
+    // Supplemental freshness signal: <time datetime="YYYY"> inside <footer>.
+    if (copyrightYear === null) {
+      footerEl.find('time[datetime]').each((_i, tEl) => {
+        const dt = ($(tEl).attr('datetime') || '').trim();
+        const ym = dt.match(/^(\d{4})/);
+        if (ym) {
+          const ty = parseInt(ym[1], 10);
+          if (copyrightYear === null || ty > copyrightYear) copyrightYear = ty;
+        }
+      });
+    }
+    if (copyrightYear !== null) {
+      if (copyrightYear >= currentYear - 1) {
         score += 10;
         checks.push({ status: 'pass', label: `Copyright year current (${copyrightYear})`, detail: `Footer copyright is ${copyrightYear}` });
-      } else if (copyrightYear === currentYear - 1) {
+      } else if (copyrightYear === currentYear - 2) {
         score += 5;
-        checks.push({ status: 'warn', label: `Copyright year slightly old (${copyrightYear})`, detail: `Footer shows ${copyrightYear} — update to ${currentYear}` });
+        checks.push({ status: 'warn', label: `Copyright year slightly old (${copyrightYear})`, detail: `Footer shows ${copyrightYear}, update to ${currentYear}` });
       } else {
-        checks.push({ status: 'fail', label: `Copyright year outdated (${copyrightYear})`, detail: `Footer shows ${copyrightYear} — update to ${currentYear}` });
+        checks.push({ status: 'fail', label: `Copyright year outdated (${copyrightYear})`, detail: `Footer shows ${copyrightYear}, update to ${currentYear}` });
       }
     } else {
       checks.push({ status: 'info', label: 'No copyright year in footer', detail: 'Add a copyright year to signal maintenance' });
@@ -4292,6 +4490,18 @@ function checkVerifiability($, domain) {
   const contentText = (mainEl.length > 0 ? mainEl.text() : $('body').text() || '').trim();
   const sentences = contentText.split(/[.!?]+/).filter(s => s.trim().length > 10);
 
+  // Visible body text (paragraphs, list items, blockquotes) for attribution
+  // patterns that often span sentence boundaries or live in elements that
+  // are tricky to split on punctuation alone.
+  const bodyTextEls = mainEl.length > 0
+    ? mainEl.find('p, li, blockquote, td, dd')
+    : $('p, li, blockquote, td, dd');
+  const bodyTextChunks = [];
+  bodyTextEls.each((_i, el) => {
+    const t = ($(el).text() || '').trim();
+    if (t.length > 0) bodyTextChunks.push(t);
+  });
+
   // 14a. External Citation Links (30 pts)
   const AUTHORITY_DOMAINS = ['.gov', '.edu', '.org', 'scholar.google', 'pubmed', 'arxiv.org', 'doi.org'];
   const externalLinks = mainEl.length > 0 ? mainEl.find('a[href^="http"]') : $('a[href^="http"]');
@@ -4312,7 +4522,7 @@ function checkVerifiability($, domain) {
     checks.push({ status: 'pass', label: `Strong citations (${totalExternalLinks} external, ${authorityLinks} authority)`, detail: `${totalExternalLinks} external links including ${authorityLinks} authority sources` });
   } else if (totalExternalLinks >= 1) {
     score += 15;
-    checks.push({ status: 'warn', label: `Some citations (${totalExternalLinks} external)`, detail: `${totalExternalLinks} external links — add authority sources (.gov, .edu)` });
+    checks.push({ status: 'warn', label: `Some citations (${totalExternalLinks} external)`, detail: `${totalExternalLinks} external links, add authority sources (.gov, .edu)` });
   } else {
     score += 5;
     checks.push({ status: 'fail', label: 'No external citations', detail: 'Add external links to authoritative sources' });
@@ -4320,25 +4530,58 @@ function checkVerifiability($, domain) {
 
   // 14b. Source Attribution in Text (25 pts)
   const SOURCE_ATTRIBUTION_PATTERNS = [
-    /\baccording to\s+[A-Z]/,
-    /\ba\s+(study|report|survey|analysis)\s+by\b/i,
-    /\b(published in|cited in|reported by)\b/i,
-    /\b(source|data from|based on)\s*:/i,
-    /\b(research\s+from|findings\s+of)\b/i,
+    /\baccording to\s+(?:the\s+|a\s+|an\s+)?[A-Z][\w'.-]*(?:\s+(?:of|for|on|and|the|de|van)\s+)?[A-Z\w'.-]*/,
+    /\b(?:a|an|the|new|recent|latest|major|landmark)?\s*(?:study|report|survey|analysis|paper|whitepaper|brief)\s+(?:by|from|published by)\b/i,
+    /\b(?:research|data|figures|statistics|findings)\s+(?:by|from|of|published by)\b/i,
+    /\b(?:published in|cited in|reported by|noted by|observed by)\b/i,
+    /\b(?:source|data from|based on)\s*:/i,
+    /\b(?:report|study|analysis)\s+(?:by|from)\b/i,
+    /\b[A-Z][\w'.-]+(?:\s+[A-Z][\w'.-]+){0,4}\s+(?:says|states|reports|found|concluded|notes|observed|estimates)\b/,
     /\[\d+\]/,
-    /\b(et al\.?|ibid\.?)\b/,
+    /\b(?:et al\.?|ibid\.?)\b/,
+    // Broadened patterns: "as reported by", "as documented in", etc.
+    /\bas\s+(?:reported|noted|stated|cited|documented|shown|described|outlined)\s+(?:by|in|on)\b/i,
+    // "per the WHO", "per CDC"
+    /\bper\s+(?:the\s+)?[A-Z]/,
+    // Possessive: "WHO's data", "CDC's findings"
+    /\b[A-Z][A-Za-z.&'-]+(?:'s|’s)\s+(?:data|report|study|analysis|findings|guidance|recommendations|guidelines)\b/,
+    // Parenthetical citation: "(source: ...)", "(via: ...)"
+    /\((?:source|src|via|cf|see)\s*:\s*[^)]+\)/i,
+    // DOI references
+    /\bdoi:\s*10\.\d+/i,
+    // Numeric brackets variants: "[1, 2]", "[1-3]"
+    /\[\d+(?:[,-]\s*\d+)*\]/,
+    // Author-year: "(Smith, 2023)", "(Smith et al., 2023)", "(Smith and Jones, 2023)"
+    /\([A-Z][a-zA-Z]+(?:\s+(?:et\s+al\.?|and\s+[A-Z][a-zA-Z]+))?,\s*\d{4}[a-z]?\)/,
+    // "<Org> data shows/reveals/indicates/suggests/confirms"
+    /\b[A-Z][\w'.-]+(?:\s+[A-Z][\w'.-]+){0,3}\s+data\s+(?:shows|reveals|indicates|suggests|confirms)\b/,
+    // "<Org> figures/findings show/reveal/indicate"
+    /\b[A-Z][\w'.-]+(?:\s+[A-Z][\w'.-]+){0,3}\s+(?:figures|findings)\s+(?:show|reveal|indicate)\b/,
+    // "in a recent study", "in a landmark report"
+    /\bin\s+(?:a|an)\s+(?:recent|new|landmark|seminal)\s+(?:study|report|survey|paper|analysis)\b/i,
+    // "verified by", "confirmed by", "documented in/by"
+    /\b(?:verified|confirmed)\s+by\b/i,
+    /\bdocumented\s+(?:in|by)\b/i,
+    // Government/regulatory bodies: "Department of Health", "Centers for Disease Control"
+    /\b(?:U\.?S\.?\s+)?(?:Department\s+of|Ministry\s+of|Office\s+of|Bureau\s+of|Centers\s+for|Federal|National|Royal)\s+[A-Z]/,
   ];
   let attrCount = 0;
   sentences.forEach(s => {
     if (SOURCE_ATTRIBUTION_PATTERNS.some(p => p.test(s))) attrCount++;
   });
+  bodyTextChunks.forEach(t => {
+    if (SOURCE_ATTRIBUTION_PATTERNS.some(p => p.test(t))) attrCount++;
+  });
   maxScore += 25;
   if (attrCount >= 3) {
     score += 25;
     checks.push({ status: 'pass', label: `Strong source attribution (${attrCount})`, detail: `${attrCount} source attribution patterns detected` });
+  } else if (attrCount >= 2) {
+    score += 18;
+    checks.push({ status: 'pass', label: `Source attribution found (${attrCount})`, detail: `${attrCount} attribution patterns detected` });
   } else if (attrCount >= 1) {
-    score += 12;
-    checks.push({ status: 'warn', label: `Some source attribution (${attrCount})`, detail: `${attrCount} attribution(s) — add more source references` });
+    score += 10;
+    checks.push({ status: 'warn', label: `Some source attribution (${attrCount})`, detail: `${attrCount} attribution(s), add more source references` });
   } else {
     score += 5;
     checks.push({ status: 'info', label: 'No source attribution detected', detail: 'Add "according to", "study by", or citation markers' });
@@ -4577,6 +4820,48 @@ function checkMultimodal($, jsonLdData) {
   }
 
   // 16b. Figure/Figcaption Usage (25 pts)
+  // Only evaluate coverage against content images. Decorative images (empty
+  // alt, presentation role, callouts, headshots, seals, logos, icons, small
+  // images, content nested in <aside>) are excluded from the denominator.
+  const DECORATIVE_CLASS_HINTS = /(callout|note|highlight|decorative|icon|headshot|avatar|seal|logo|badge|sidebar|bullet|arrow|divider|separator|spacer|pixel|tracking|analytics|placeholder|flag|star|rating)/i;
+  // Filename-style alt text like "img-23.jpg" / "photo.png" indicates a non-descriptive alt.
+  const FILENAME_ALT_RE = /^(?:img|image|photo|picture)?[-_ ]?\d*\.(?:jpg|jpeg|png|gif|svg|webp)$/i;
+  // Tracking pixel hints in src.
+  const TRACKING_SRC_RE = /(?:pixel|beacon|track|analytics)/i;
+  function isDecorativeImage(imgEl) {
+    const $img = $(imgEl);
+    const role = ($img.attr('role') || '').toLowerCase();
+    if (role === 'presentation' || role === 'none') return true;
+    // Explicit decorative attributes.
+    const ariaHidden = ($img.attr('aria-hidden') || '').toLowerCase();
+    if (ariaHidden === 'true') return true;
+    const dataDecorative = ($img.attr('data-decorative') || '').toLowerCase();
+    if (dataDecorative === 'true') return true;
+    const alt = $img.attr('alt');
+    if (alt !== undefined && alt.trim() === '') return true;
+    // Filename-style alt text is non-descriptive and treated as decorative.
+    if (alt !== undefined && FILENAME_ALT_RE.test(alt.trim())) return true;
+    if ($img.closest('aside').length > 0) return true;
+    // Broader ancestor selectors: chrome regions and ad/banner containers.
+    if ($img.closest('header, nav, footer, button, [role="banner"], [role="navigation"], [role="contentinfo"], .ad, .advertisement, .banner').length > 0) return true;
+    const cls = $img.attr('class') || '';
+    if (DECORATIVE_CLASS_HINTS.test(cls)) return true;
+    if ($img.closest(`[class*="callout"], [class*="note"], [class*="highlight"], [class*="decorative"], [class*="seal"], [class*="logo"], [class*="headshot"], [class*="avatar"], [class*="icon"]`).length > 0) return true;
+    const w = parseInt($img.attr('width'), 10);
+    const h = parseInt($img.attr('height'), 10);
+    // Tracking pixel: 1x1 (or 1xN/Nx1) images.
+    if ((Number.isFinite(w) && w === 1) || (Number.isFinite(h) && h === 1)) return true;
+    if (Number.isFinite(w) && w > 0 && w <= 100) return true;
+    if (Number.isFinite(h) && h > 0 && h <= 100) return true;
+    const src = $img.attr('src') || '';
+    if (src && TRACKING_SRC_RE.test(src)) return true;
+    return false;
+  }
+  let contentImageCount = 0;
+  fallbackImages.each((_i, imgEl) => {
+    if (!isDecorativeImage(imgEl)) contentImageCount++;
+  });
+
   const mainFigures = $('main figure, article figure, [role="main"] figure');
   const fallbackFigures = mainFigures.length > 0 ? mainFigures : $('figure');
   let figuresWithCaption = 0;
@@ -4587,16 +4872,19 @@ function checkMultimodal($, jsonLdData) {
   if (fallbackImages.length === 0) {
     score += 25;
     checks.push({ status: 'info', label: 'No images for figure evaluation', detail: 'No images found on page' });
+  } else if (contentImageCount === 0) {
+    score += 25;
+    checks.push({ status: 'info', label: 'Only decorative images detected', detail: 'No content images require figure/figcaption markup' });
   } else {
-    const figPct = fallbackImages.length > 0 ? Math.round((figuresWithCaption / fallbackImages.length) * 100) : 0;
-    if (figPct > 50) {
+    const figPct = Math.round((figuresWithCaption / contentImageCount) * 100);
+    if (figPct >= 50) {
       score += 25;
-      checks.push({ status: 'pass', label: `Good figure/caption usage (${figPct}%)`, detail: `${figPct}% of images wrapped in <figure> with <figcaption>` });
+      checks.push({ status: 'pass', label: `Good figure/caption usage (${figPct}%)`, detail: `${figuresWithCaption} of ${contentImageCount} content images wrapped in <figure> with <figcaption>` });
     } else if (figuresWithCaption > 0) {
       score += 12;
-      checks.push({ status: 'warn', label: 'Some figure/caption usage', detail: 'Some images use <figure>/<figcaption> — apply to more images' });
+      checks.push({ status: 'warn', label: 'Some figure/caption usage', detail: `${figuresWithCaption} of ${contentImageCount} content images wrapped, extend to remaining content images` });
     } else {
-      checks.push({ status: 'info', label: 'No figure/caption usage', detail: 'Wrap images in <figure> with <figcaption> for better context' });
+      checks.push({ status: 'info', label: 'No figure/caption usage', detail: 'Wrap content images in <figure> with <figcaption> for better context' });
     }
   }
 
@@ -5299,11 +5587,13 @@ function calculateGeoScore(data) {
   total += robotsScore;
   maxPossible += 5;
 
-  // 2. AI crawlers NOT blocked (1 pt per crawler, 7 max)
+  // 2. AI crawlers NOT blocked. Only citation crawlers (real impact on AI
+  // visibility) contribute to the score. Training-crawler blocks are reported
+  // in the detail string for transparency but do not deduct points.
   let crawlerScore = 0;
   const blocked = data.robotsTxt.blocksCrawlers || {};
   const crawlerDetails = [];
-  for (const crawler of AI_CRAWLERS) {
+  for (const crawler of CITATION_CRAWLERS) {
     if (blocked[crawler] === false || blocked[crawler] === undefined) {
       crawlerScore += 1;
       crawlerDetails.push(`${crawler}: allowed`);
@@ -5311,9 +5601,13 @@ function calculateGeoScore(data) {
       crawlerDetails.push(`${crawler}: BLOCKED`);
     }
   }
-  breakdown.aiCrawlerAccess = { score: crawlerScore, max: AI_CRAWLERS.length, detail: crawlerDetails.join('; ') };
+  for (const crawler of TRAINING_CRAWLERS) {
+    const status = (blocked[crawler] === false || blocked[crawler] === undefined) ? 'allowed' : 'blocked (training-only, informational)';
+    crawlerDetails.push(`${crawler}: ${status}`);
+  }
+  breakdown.aiCrawlerAccess = { score: crawlerScore, max: CITATION_CRAWLERS.length, detail: crawlerDetails.join('; ') };
   total += crawlerScore;
-  maxPossible += AI_CRAWLERS.length;
+  maxPossible += CITATION_CRAWLERS.length;
 
   // 3. llms.txt exists (10 pts)
   const llmsScore = data.llmsTxt.exists ? 10 : 0;