glippy-mcp 0.2.0 → 0.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "glippy-mcp",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "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

@@ -757,10 +757,27 @@ function aggregatePageScores(pageResults) {
  * @returns {string} - One of: 'faq', 'product', 'article', 'local-business', 'homepage', 'ecommerce', 'saas', 'generic'.
  */
 function detectPageType($, schemaTypes, pathname) {
-  // Check JSON-LD schema types first (most reliable signal)
-  if (['FAQPage'].some((t) => schemaTypes.has(t))) return 'faq';
-  if (['Product', 'Offer'].some((t) => schemaTypes.has(t))) return 'product';
+  // 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
+  // a 6,400-word guide with a FAQ at the bottom gets penalized as exceeding FAQ length.
+  const allH2s = $('h2');
+  const h2Count = allH2s.length;
+  let questionH2Count = 0;
+  allH2s.each((_, el) => {
+    const t = ($(el).text() || '').trim();
+    if (t.includes('?') || /^(how|what|why|when|where|who|which|can|do|does|is|are|should)\b/i.test(t)) {
+      questionH2Count++;
+    }
+  });
+  const isDominantlyFaq = h2Count > 0 && questionH2Count >= h2Count * 0.7;
+
+  if (schemaTypes.has('FAQPage') && isDominantlyFaq) 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';
+  if (['Product', 'Offer'].some((t) => schemaTypes.has(t))) return 'product';
   if (['LocalBusiness', 'Restaurant', 'Store'].some((t) => schemaTypes.has(t))) return 'local-business';
 
   // Heuristic: homepage detection (including language/locale-prefixed homepages like /en/, /de-DE/, /nl/)
@@ -769,9 +786,10 @@ function detectPageType($, schemaTypes, pathname) {
   const normalizedPath = pathname.replace(/^\/[a-z]{2}(?:[-_][a-z]{2,3})?\/?$/i, '/');
   if (normalizedPath === '/' || normalizedPath === '/index.html' || normalizedPath === '/index.php' || normalizedPath === '') return 'homepage';
 
-  // Heuristic: FAQ page via DOM
+  // Heuristic: FAQ page via DOM. Only treat as FAQ when FAQ-like elements dominate the
+  // structure - if the page has many topic H2s it's a guide that happens to include a FAQ.
   const faqIndicators = $('[class*="faq"], [id*="faq"], details, [class*="accordion"]');
-  if (faqIndicators.length >= 3) return 'faq';
+  if (faqIndicators.length >= 3 && (h2Count < 6 || isDominantlyFaq)) return 'faq';
 
   // Heuristic: article via DOM
   const hasArticle = $('article').length > 0;
@@ -2014,7 +2032,29 @@ function checkEntity($, jsonLdData) {
     });
   }
 
-  // 6. JSON-LD schema author with quality check
+  // 6. JSON-LD schema author with quality check.
+  // Only treat `author` as the page author when it's attached to a content type
+  // (Article, WebPage, Book, etc.) - NOT inside Review/Comment, where `author` is
+  // the reviewer/commenter and shouldn't be credited to the page.
+  const PAGE_AUTHOR_TYPES = new Set([
+    'Article', 'NewsArticle', 'BlogPosting', 'TechArticle', 'ScholarlyArticle', 'Report', 'OpinionNewsArticle',
+    'WebPage', 'AboutPage', 'CollectionPage', 'ItemPage', 'ProfilePage', 'QAPage', 'FAQPage',
+    'Book', 'Chapter', 'CreativeWork', 'CreativeWorkSeries', 'HowTo', 'Recipe', 'Course', 'LearningResource',
+    'VideoObject', 'AudioObject', 'PodcastEpisode', 'Podcast',
+    'DiscussionForumPosting', 'SocialMediaPosting',
+  ]);
+  const SKIP_AUTHOR_TYPES = new Set(['Review', 'Comment', 'UserComments', 'Rating']);
+  const isContentType = (t) => {
+    if (!t) return false;
+    const types = Array.isArray(t) ? t : [t];
+    return types.some((x) => PAGE_AUTHOR_TYPES.has(x));
+  };
+  const isSkipType = (t) => {
+    if (!t) return false;
+    const types = Array.isArray(t) ? t : [t];
+    return types.some((x) => SKIP_AUTHOR_TYPES.has(x));
+  };
+
   let hasAuthorSchema = false;
   let hasAuthorSameAs = false;
   let hasPersonSchema = false;
@@ -2022,12 +2062,14 @@ function checkEntity($, jsonLdData) {
     try {
       const processSchema = (schema) => {
         if (!schema) return;
-        if (schema.author) {
+        // Skip Review/Comment subtrees - their author is not the page author.
+        if (isSkipType(schema['@type'])) return;
+        if (schema.author && isContentType(schema['@type'])) {
           hasAuthorSchema = true;
           const authors = Array.isArray(schema.author) ? schema.author : [schema.author];
           authors.forEach((a) => {
             if (typeof a === 'string') authorNames.add(a);
-            else if (a.name) {
+            else if (a && a.name) {
               authorNames.add(a.name);
               if (a.sameAs) hasAuthorSameAs = true;
               if (a['@type'] === 'Person') hasPersonSchema = true;
@@ -2038,6 +2080,13 @@ function checkEntity($, jsonLdData) {
           hasPersonSchema = true;
           if (schema.sameAs) hasAuthorSameAs = true;
         }
+        // Recurse into common content-bearing fields, but skip review arrays.
+        ['mainEntity', 'mainEntityOfPage', 'about', 'isPartOf', 'hasPart', 'workExample', 'exampleOfWork'].forEach((key) => {
+          const val = schema[key];
+          if (!val) return;
+          if (Array.isArray(val)) val.forEach(processSchema);
+          else if (typeof val === 'object') processSchema(val);
+        });
       };
       if (Array.isArray(d)) d.forEach(processSchema);
       else if (d['@graph']) d['@graph'].forEach(processSchema);
@@ -2047,14 +2096,17 @@ function checkEntity($, jsonLdData) {
   if (hasAuthorSchema) authorSources.schema.push('JSON-LD author');
   if (hasPersonSchema) authorSources.schema.push('Person schema');
 
-  // 7. HTML byline elements - extended selectors
+  // 7. HTML byline elements - extended selectors.
+  // Exclude bylines inside review/comment/testimonial containers - they identify the
+  // reviewer, not the page author.
   const bylineSelectors = [
     '[class*="author"]', '[rel="author"]', '[itemprop="author"]',
     '.byline', '.post-author', '.article-author', '.entry-author',
     '[data-author]', '[data-byline]',
     'address.author', '.writer', '.contributor',
   ].join(', ');
-  const authorByline = $(bylineSelectors).first();
+  const reviewContextSel = '[itemtype*="Review"], [itemtype*="Comment"], .review, .reviews, .comment, .comments, .testimonial, .testimonials, [class*="review-"], [class*="reviews-"]';
+  const authorByline = $(bylineSelectors).filter((_, el) => $(el).closest(reviewContextSel).length === 0).first();
   if (authorByline.length > 0) {
     const bylineText = (authorByline.text() || '').trim();
     if (bylineText && bylineText.length < 100) {
@@ -2070,8 +2122,9 @@ function checkEntity($, jsonLdData) {
     authorSources.html.push('address element');
   }
 
-  // 9. Author profile links
-  const authorLinks = $('a[href*="/author/"], a[href*="/writers/"], a[href*="/contributors/"], a[href*="/team/"], a[rel="author"]');
+  // 9. Author profile links - skip review-context links (reviewer profile links).
+  const authorLinks = $('a[href*="/author/"], a[href*="/writers/"], a[href*="/contributors/"], a[href*="/team/"], a[rel="author"]')
+    .filter((_, el) => $(el).closest(reviewContextSel).length === 0);
   if (authorLinks.length > 0) {
     authorSources.links.push(`${authorLinks.length} author link(s)`);
     authorLinks.each((_, el) => {
@@ -3006,6 +3059,10 @@ function checkPerformance($) {
 // CHECK CATEGORY 10: Agent Interactivity (WebMCP + UCP)
 // ---------------------------------------------------------------------------
 
+// LATEST_UCP_VERSION: gating threshold for 2026-04-08 spec additions
+// (signing_keys, order webhook_url, etc. become required at this version).
+const LATEST_UCP_VERSION = '2026-04-08';
+
 function checkWebMCP($, pageType, ucpData) {
   const checks = [];
   let score = 0;
@@ -3350,6 +3407,40 @@ function checkWebMCP($, pageType, ucpData) {
       const capabilities = capsArray; // Already normalized above
       const transportKeys = ['rest', 'mcp', 'a2a', 'embedded'];
 
+      // UCP CHECK 2.5: Cache Headers (only when caller passed response headers)
+      const ucpHeaders = ucpData && ucpData.headers ? ucpData.headers : null;
+      if (ucpHeaders) {
+        const headerLookup = (n) => {
+          const lower = n.toLowerCase();
+          for (const k of Object.keys(ucpHeaders)) {
+            if (k.toLowerCase() === lower) return String(ucpHeaders[k] || '');
+          }
+          return '';
+        };
+        const ct = headerLookup('content-type').toLowerCase();
+        const cc = headerLookup('cache-control').toLowerCase();
+        const ctOk = ct.startsWith('application/json');
+        const ccTokens = cc.split(',').map(s => s.trim());
+        const hasPublic = ccTokens.includes('public');
+        const hasBadDirective = ccTokens.some(t => t === 'private' || t === 'no-store' || t === 'no-cache');
+        const maxAgeMatch = cc.match(/max-age=(\d+)/);
+        const maxAge = maxAgeMatch ? parseInt(maxAgeMatch[1], 10) : -1;
+        const ccOk = hasPublic && !hasBadDirective && maxAge >= 60;
+        maxScore += 5;
+        if (ctOk && ccOk) {
+          score += 5;
+          checks.push({ status: 'pass', label: 'UCP profile cache headers OK', detail: `Content-Type application/json with Cache-Control: public, max-age=${maxAge}` });
+        } else {
+          score += 2;
+          const issues = [];
+          if (!ctOk) issues.push(`content-type "${ct || 'missing'}" (expected application/json)`);
+          if (!hasPublic) issues.push('cache-control missing "public"');
+          if (hasBadDirective) issues.push('cache-control contains private/no-store/no-cache');
+          if (maxAge < 60) issues.push(`max-age=${maxAge >= 0 ? maxAge : 'missing'} (expected >=60)`);
+          checks.push({ status: 'warn', label: 'UCP profile cache headers need attention', detail: issues.slice(0, 3).join('; '), found: issues });
+        }
+      }
+
       // UCP CHECK 2: Profile Completeness
       let completenessIssues = [];
       if (!versionDatePattern.test(version)) completenessIssues.push('version not date-formatted (expected YYYY-MM-DD)');
@@ -3379,25 +3470,94 @@ function checkWebMCP($, pageType, ucpData) {
         checks.push({ status: 'warn', label: `UCP profile has ${completenessIssues.length} issue(s)`, detail: completenessIssues.slice(0, 3).join('; '), found: completenessIssues.slice(0, 5) });
       }
 
-      // UCP CHECK 3: Capability Coverage
+      // UCP CHECK 3: Capability Coverage (synced with extension processUCPProfile)
       const capNames = capabilities.map(c => c.name || '');
       const coreCapabilities = {
         'dev.ucp.shopping.checkout': 'Checkout',
         'dev.ucp.shopping.identity_linking': 'Identity Linking',
         'dev.ucp.shopping.order': 'Order Management',
+        'dev.ucp.shopping.cart': 'Cart',
       };
+      // Catalog has sub-capabilities; credit if any match the catalog prefix.
+      const hasCatalog = capNames.some(n => n.startsWith('dev.ucp.shopping.catalog'));
       const presentCore = Object.keys(coreCapabilities).filter(c => capNames.includes(c));
-      const missingCore = Object.entries(coreCapabilities).filter(([k]) => !capNames.includes(k)).map(([, v]) => v);
+      if (hasCatalog) presentCore.push('dev.ucp.shopping.catalog');
+      const missingEntries = Object.entries(coreCapabilities).filter(([k]) => !capNames.includes(k));
+      if (!hasCatalog) missingEntries.push(['dev.ucp.shopping.catalog', 'Catalog']);
+      const missingCore = missingEntries.map(([, v]) => v);
+      const totalCore = Object.keys(coreCapabilities).length + 1; // +1 for Catalog
 
       maxScore += 10;
-      if (presentCore.length === 3) {
+      if (presentCore.length === totalCore) {
         score += 10;
-        checks.push({ status: 'pass', label: 'All 3 core UCP capabilities declared', detail: 'Checkout, Identity Linking, and Order Management' });
+        checks.push({ status: 'pass', label: `All ${totalCore} core UCP capabilities declared`, detail: 'Checkout, Identity Linking, Order Management, Cart, and Catalog' });
       } else if (presentCore.length > 0) {
         score += 5;
-        checks.push({ status: 'warn', label: `${presentCore.length}/3 core UCP capabilities declared`, detail: `Missing: ${missingCore.join(', ')}`, found: presentCore });
+        checks.push({ status: 'warn', label: `${presentCore.length}/${totalCore} core UCP capabilities declared`, detail: `Missing: ${missingCore.join(', ')}`, found: presentCore });
       } else {
-        checks.push({ status: 'info', label: 'No core UCP capabilities declared', detail: 'Consider adding checkout, identity_linking, and order capabilities' });
+        checks.push({ status: 'info', label: 'No core UCP capabilities declared', detail: 'Consider adding checkout, identity_linking, order, cart, and catalog capabilities' });
+      }
+
+      // 2026-04-08 spec gating: declared version >= 2026-04-08?
+      const isV2 = versionDatePattern.test(version) && version >= LATEST_UCP_VERSION;
+
+      // UCP CHECK 3.5: Signing Keys (RFC 9421 ES256, mandatory in 2026-04-08)
+      const signingKeys = Array.isArray(profile.signing_keys) ? profile.signing_keys : null;
+      if (signingKeys && signingKeys.length > 0) {
+        const malformed = signingKeys.filter(k => !k || !k.kid || k.kty !== 'EC' || k.crv !== 'P-256' || !k.x || !k.y);
+        maxScore += 10;
+        if (malformed.length === 0) {
+          score += 10;
+          checks.push({ status: 'pass', label: `${signingKeys.length} UCP signing key(s) declared`, detail: 'Profile advertises EC P-256 JWK(s) for RFC 9421 message signing' });
+        } else {
+          score += 3;
+          checks.push({ status: 'warn', label: `${malformed.length}/${signingKeys.length} UCP signing key(s) malformed`, detail: 'Each key must have kid, kty=EC, crv=P-256, x, y', found: malformed.map(k => k && k.kid ? k.kid : '<missing kid>').slice(0, 5) });
+        }
+      } else if (isV2) {
+        maxScore += 10;
+        score += 3;
+        checks.push({ status: 'warn', label: 'UCP signing keys missing', detail: 'UCP 2026-04-08 mandates RFC 9421 ES256 signatures; profile must publish signing_keys[]' });
+      } else {
+        checks.push({ status: 'info', label: 'UCP signing keys not declared', detail: 'UCP 2026-04-08 will require signing_keys[]; consider adding for forward compatibility' });
+      }
+
+      // UCP CHECK 3.6: Catalog Sub-Capability Coverage
+      const catalogCaps = capabilities.filter(c => (c.name || '').startsWith('dev.ucp.shopping.catalog'));
+      if (catalogCaps.length > 0) {
+        const subs = ['search', 'lookup', 'get_product'];
+        const presentSubs = subs.filter(s => catalogCaps.some(c => c.name === `dev.ucp.shopping.catalog.${s}` || c.name === 'dev.ucp.shopping.catalog'));
+        const missingSubs = subs.filter(s => !presentSubs.includes(s));
+        maxScore += 5;
+        if (missingSubs.length === 0) {
+          score += 5;
+          checks.push({ status: 'pass', label: 'Catalog capability fully declared', detail: 'search, lookup, and get_product sub-capabilities all present' });
+        } else {
+          score += 3;
+          checks.push({ status: 'warn', label: `Catalog declared with ${presentSubs.length}/${subs.length} sub-capabilities`, detail: `Missing: ${missingSubs.join(', ')}`, found: missingSubs });
+        }
+      } else if (capNames.includes('dev.ucp.shopping.cart')) {
+        checks.push({ status: 'info', label: 'Cart declared without Catalog', detail: 'Consider adding catalog.search / catalog.lookup so agents can discover products before adding to cart' });
+      }
+
+      // UCP CHECK 3.7: Order Webhook URL (required in 2026-04-08)
+      const orderCap = capabilities.find(c => c.name === 'dev.ucp.shopping.order');
+      if (orderCap) {
+        const webhookUrl = orderCap.config && orderCap.config.webhook_url;
+        if (webhookUrl && typeof webhookUrl === 'string' && webhookUrl.startsWith('https://')) {
+          maxScore += 5;
+          score += 5;
+          checks.push({ status: 'pass', label: 'Order webhook URL declared', detail: 'config.webhook_url is HTTPS, enabling real-time order updates' });
+        } else if (webhookUrl) {
+          maxScore += 5;
+          score += 2;
+          checks.push({ status: 'warn', label: 'Order webhook URL is not HTTPS', detail: 'config.webhook_url must use https://' });
+        } else if (isV2) {
+          maxScore += 5;
+          score += 2;
+          checks.push({ status: 'warn', label: 'Order webhook URL missing', detail: 'UCP 2026-04-08 requires config.webhook_url on the order capability for real-time updates' });
+        } else {
+          checks.push({ status: 'info', label: 'Order webhook URL not declared', detail: 'UCP 2026-04-08 will require config.webhook_url on order capabilities' });
+        }
       }
 
       // UCP CHECK 4: Extension Support
@@ -3424,6 +3584,20 @@ function checkWebMCP($, pageType, ucpData) {
         }
       }
 
+      // Cart-specific transport recommendation (2026-04-08 adds embedded binding).
+      if (capNames.includes('dev.ucp.shopping.cart')) {
+        const cartTransports = new Set(allTransports.map(t => t.transport));
+        const cartRecommended = cartTransports.has('embedded') || cartTransports.has('mcp');
+        maxScore += 3;
+        if (cartRecommended) {
+          score += 3;
+          checks.push({ status: 'pass', label: 'Cart capability has embedded or MCP transport', detail: 'UCP 2026-04-08 recommends embedded or MCP transport for cart capability' });
+        } else {
+          score += 1;
+          checks.push({ status: 'warn', label: 'Cart capability missing embedded/MCP transport', detail: 'UCP 2026-04-08 recommends adding an embedded transport binding for cart so agents can hand off to checkout' });
+        }
+      }
+
       if (allTransports.length > 1) {
         maxScore += 10;
         const httpsTransports = allTransports.filter(t => (t.endpoint || '').startsWith('https://') && (t.schema || '').startsWith('https://'));
@@ -3470,8 +3644,8 @@ function checkWebMCP($, pageType, ucpData) {
       // UCP CHECK 8: Page-Type-Specific Recommendations
       const commercePageTypes = ['product', 'ecommerce', 'saas', 'local-business'];
       const ucpRecommendations = {
-        'product': 'Should have checkout + fulfillment + discount capabilities',
-        'ecommerce': 'Should have checkout + fulfillment; consider identity linking for personalization',
+        'product': 'Should have checkout + cart + catalog + fulfillment capabilities',
+        'ecommerce': 'Should have checkout + cart + catalog; consider identity linking for personalization',
         'saas': 'Should have checkout for subscription/trial flows',
         'local-business': 'Consider checkout for booking/purchasing services',
         'homepage': 'UCP profile should be accessible at domain root /.well-known/ucp',
@@ -3480,6 +3654,51 @@ function checkWebMCP($, pageType, ucpData) {
       if (ucpRecommendations[pageType]) {
         checks.push({ status: 'pass', label: `UCP detected on ${pageType} page`, detail: ucpRecommendations[pageType] });
       }
+
+      // UCP CHECK 9: Disclosure / Eligibility / Signals / Delegation feature advertisement (info-only).
+      const advertisedFeatures = new Set();
+      for (const cap of capabilities) {
+        const feats = Array.isArray(cap.features) ? cap.features : [];
+        for (const f of feats) {
+          if (typeof f === 'string') advertisedFeatures.add(f);
+        }
+      }
+      const trackedFeatures = ['eligibility_claims', 'signals', 'disclosure_messages', 'link_delegation'];
+      const presentFeats = trackedFeatures.filter(f => advertisedFeatures.has(f));
+      if (presentFeats.length > 0) {
+        checks.push({ status: 'info', label: `${presentFeats.length} UCP feature(s) advertised`, detail: `Capabilities advertise: ${presentFeats.join(', ')}`, found: presentFeats });
+      } else {
+        checks.push({ status: 'info', label: 'No optional UCP features advertised', detail: 'eligibility_claims, signals, disclosure_messages, and link_delegation are optional but improve agent trust negotiation' });
+      }
+
+      // UCP CHECK 10: Spec Version Currency (info-only).
+      if (versionDatePattern.test(version)) {
+        if (version === LATEST_UCP_VERSION) {
+          checks.push({ status: 'info', label: 'UCP version is current', detail: `Profile declares the latest known UCP version (${version})` });
+        } else if (version < LATEST_UCP_VERSION) {
+          checks.push({ status: 'info', label: 'UCP version is older than latest', detail: `Profile declares ${version}; latest known is ${LATEST_UCP_VERSION}` });
+        } else {
+          checks.push({ status: 'info', label: 'UCP version newer than checker knows', detail: `Profile declares ${version}; this checker is calibrated against ${LATEST_UCP_VERSION}` });
+        }
+      }
+
+      // UCP CHECK 11: A2A agent-card.json (only when profile advertises an a2a transport)
+      const agentCard = ucpData && ucpData.agentCard;
+      if (agentCard) {
+        if (agentCard.exists && agentCard.valid) {
+          maxScore += 3;
+          score += 3;
+          checks.push({ status: 'pass', label: 'A2A agent card found', detail: '/.well-known/agent-card.json is reachable and parses as JSON' });
+        } else if (agentCard.exists && !agentCard.valid) {
+          maxScore += 3;
+          checks.push({ status: 'warn', label: 'A2A agent card not valid JSON', detail: '/.well-known/agent-card.json was reachable but did not parse as JSON' });
+        } else if (agentCard.missing) {
+          maxScore += 3;
+          checks.push({ status: 'warn', label: 'A2A agent card not found', detail: 'Profile advertises an a2a transport but /.well-known/agent-card.json returns 404' });
+        } else {
+          checks.push({ status: 'info', label: 'A2A agent card unreachable', detail: agentCard.statusCode ? `HTTP ${agentCard.statusCode}` : 'fetch error' });
+        }
+      }
     }
   } else {
     // No UCP profile found — informational only, no penalty
@@ -3487,10 +3706,41 @@ function checkWebMCP($, pageType, ucpData) {
     if (commercePageTypes.includes(pageType)) {
       checks.push({ status: 'info', label: 'No UCP discovery file found', detail: 'UCP enables AI agents to discover commerce capabilities via /.well-known/ucp' });
     } else {
-      checks.push({ status: 'info', label: 'No UCP discovery file found', detail: 'UCP enables AI agents to discover commerce capabilities — most relevant for commerce pages' });
+      checks.push({ status: 'info', label: 'No UCP discovery file found', detail: 'UCP enables AI agents to discover commerce capabilities - most relevant for commerce pages' });
     }
   }
 
+  // Shopify dual-surface info shortcut (fires whether or not UCP profile exists).
+  if (ucpData && ucpData.shopifyHosted) {
+    checks.push({ status: 'info', label: 'Shopify-hosted: dual UCP surface expected', detail: 'Per-shop endpoint at /api/ucp/mcp; global catalog at https://discover.shopifyapps.com/global/mcp' });
+  }
+
+  // Baseline credit for purely informational pages.
+  // If the page has no forms, no WebMCP signals, no UCP profile, and no Shopify
+  // surface, there's nothing for it to expose to agents - WebMCP/UCP are N/A here.
+  // Without this, content-only pages are capped well below 100 even when there's
+  // nothing to fix, dragging the overall score unfairly.
+  const totalForms = $('form').length;
+  const hasUcp = !!(ucpData && ucpData.exists && ucpData.content);
+  const hasShopify = !!(ucpData && ucpData.shopifyHosted);
+  const hasNoInteractiveSurface =
+    totalForms === 0 &&
+    toolCount === 0 &&
+    !hasImperativeSignals &&
+    !webmcpSDKFound &&
+    !hasSchemaActions &&
+    !hasUcp &&
+    !hasShopify;
+
+  if (hasNoInteractiveSurface) {
+    checks.push({
+      status: 'info',
+      label: 'Informational page — Agent Interactivity not applicable',
+      detail: 'No forms or WebMCP/UCP signals detected. Pure-content pages can\'t expose tools to agents, so this category is scored as a baseline rather than penalized.',
+    });
+    return { checks, score: 80, category: 'Agent Interactivity', notApplicable: true };
+  }
+
   return { checks, score: maxScore > 0 ? Math.round((score / maxScore) * 100) : 0, category: 'Agent Interactivity' };
 }
 
@@ -3758,8 +4008,18 @@ function checkContentFreshness($, jsonLdData) {
     new RegExp('\\bin ' + currentYear + '\\b', 'i'),
     new RegExp('\\b(as of|updated)\\s+(january|february|march|april|may|june|july|august|september|october|november|december)\\s+' + currentYear + '\\b', 'i'),
   ];
+  // Historical/founding-context phrases - "records from 1841 to present", "since 1990",
+  // "established 1936" - are accurate facts, not stale temporal references.
+  const HISTORICAL_CONTEXT_PATTERNS = [
+    /\b(since|from|established|founded|operating since|serving since|in business since)\s+(in\s+)?\d{4}\b/i,
+    /\b\d{4}\s*(?:[‐-―−\-–—~]|to)\s*(present|current|today|now|\d{4})\b/i,
+    /\b(records?|archives?|documents?|history|heritage|founded|established|originated|dating back)\b[^.]{0,80}\b(from|since|in)\s+\d{4}\b/i,
+    /\b(historical|historic|vintage|legacy)\b/i,
+  ];
+  const hasHistoricalContext = HISTORICAL_CONTEXT_PATTERNS.some(p => p.test(visibleText));
   const hasCurrentRefs = CURRENT_YEAR_PATTERNS.some(p => p.test(visibleText));
-  const hasOutdatedRefs = OUTDATED_TEMPORAL_PATTERNS.some(p => p.test(visibleText));
+  const rawOutdatedHits = OUTDATED_TEMPORAL_PATTERNS.some(p => p.test(visibleText));
+  const hasOutdatedRefs = rawOutdatedHits && !hasHistoricalContext;
   maxScore += 20;
   if (hasCurrentRefs && !hasOutdatedRefs) {
     score += 20;
@@ -3776,13 +4036,16 @@ 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.
   const footerEl = $('footer');
   maxScore += 10;
   if (footerEl.length > 0) {
     const footerText = footerEl.text();
-    const copyrightMatch = footerText.match(/©\s*(\d{4})/);
-    if (copyrightMatch) {
-      const copyrightYear = parseInt(copyrightMatch[1], 10);
+    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) {
         score += 10;
         checks.push({ status: 'pass', label: `Copyright year current (${copyrightYear})`, detail: `Footer copyright is ${copyrightYear}` });
@@ -3870,22 +4133,36 @@ function checkInformationDensity($) {
   }
 
   // 13b. Self-Contained Section Scoring (25 pts)
+  // Sections with structured content (tables w/ headers, lists, definition lists) are
+  // self-contained even at lower word counts - the structure carries the meaning.
   const h2s = $('main h2, article h2, [role="main"] h2');
   maxScore += 25;
   if (h2s.length > 0) {
     let selfContainedCount = 0;
     h2s.each((_i, h2El) => {
       let sectionText = '';
+      let hasStructuredContent = false;
+      let hasLabeledTable = false;
       let sibling = $(h2El).next();
       while (sibling.length > 0 && !sibling.is('h2')) {
         sectionText += (sibling.text() || '') + ' ';
+        if (sibling.is('table, ul, ol, dl') || sibling.find('table, ul, ol, dl').length > 0) {
+          hasStructuredContent = true;
+        }
+        const tablesHere = sibling.is('table') ? sibling : sibling.find('table');
+        tablesHere.each((__, t) => {
+          if ($(t).find('th').length > 0) hasLabeledTable = true;
+        });
         sibling = sibling.next();
       }
       const wordCount = sectionText.trim().split(/\s+/).length;
       const hasData = /\d/.test(sectionText);
       const firstSentence = sectionText.split(/[.!?]/)[0] || '';
       const hasTopicSentence = firstSentence.trim().length > 30;
-      if (wordCount >= 150 && wordCount <= 500 && hasData && hasTopicSentence) {
+      const isStandardComplete = wordCount >= 150 && wordCount <= 500 && hasData && hasTopicSentence;
+      const isStructurallyComplete = hasStructuredContent && wordCount >= 40 && (hasData || hasLabeledTable);
+      const isLabeledTableSection = hasLabeledTable && wordCount >= 10;
+      if (isStandardComplete || isStructurallyComplete || isLabeledTableSection) {
         selfContainedCount++;
       }
     });
@@ -3905,6 +4182,8 @@ function checkInformationDensity($) {
   }
 
   // 13c. Claim-Evidence Pairing (20 pts)
+  // Tables with header cells provide column-level context for every numeric value,
+  // so data points inside labeled tables are considered already-paired by design.
   const DATA_SENTENCE = /\d+(\.\d+)?(%|x|\$|€|£)/;
   let dataSentences = 0;
   let pairedData = 0;
@@ -3919,14 +4198,26 @@ function checkInformationDensity($) {
       }
     }
   });
+  // Count data cells inside labeled tables - they're context-paired via column headers.
+  let labeledTableDataCells = 0;
+  const pairingTables = mainEl.length > 0 ? mainEl.find('table') : $('table');
+  pairingTables.each((_i, t) => {
+    const $t = $(t);
+    if ($t.find('th').length === 0) return;
+    $t.find('tbody td, td').each((__, td) => {
+      if (DATA_SENTENCE.test($(td).text() || '')) labeledTableDataCells++;
+    });
+  });
   maxScore += 20;
-  if (dataSentences === 0) {
+  const totalData = dataSentences + labeledTableDataCells;
+  const totalPaired = pairedData + labeledTableDataCells;
+  if (totalData === 0) {
     checks.push({ status: 'info', label: 'No data claims detected', detail: 'Add quantitative data points with context' });
   } else {
-    const pairedPct = Math.round((pairedData / dataSentences) * 100);
+    const pairedPct = Math.round((totalPaired / totalData) * 100);
     if (pairedPct > 80) {
       score += 20;
-      checks.push({ status: 'pass', label: `Claims well-paired (${pairedPct}%)`, detail: `${pairedPct}% of data claims have contextual explanations` });
+      checks.push({ status: 'pass', label: `Claims well-paired (${pairedPct}%)`, detail: `${pairedPct}% of data claims have contextual explanations${labeledTableDataCells > 0 ? ` (incl. ${labeledTableDataCells} table cells)` : ''}` });
     } else if (pairedPct >= 50) {
       score += 10;
       checks.push({ status: 'warn', label: `Claims partially paired (${pairedPct}%)`, detail: `${pairedPct}% of data claims have context — add more explanations` });
@@ -4766,11 +5057,54 @@ async function checkGEO(domain, options = {}) {
       const profile = JSON.parse(ucpRes.body);
       output.ucpProfile.exists = true;
       output.ucpProfile.content = profile;
+      output.ucpProfile.headers = ucpRes.headers || {};
     }
   } catch (err) {
     output.ucpProfile.error = err.message;
   }
 
+  // --- /.well-known/agent-card.json (A2A discovery; only meaningful when profile advertises a2a) ---
+  try {
+    const services = output.ucpProfile.content && output.ucpProfile.content.ucp && output.ucpProfile.content.ucp.services;
+    const advertisesA2a = services && Object.values(services).some(svc => svc && typeof svc === 'object' && svc.a2a);
+    if (advertisesA2a) {
+      const cardUrl = `${baseUrl}/.well-known/agent-card.json`;
+      const cardRes = await throttledFetchUrl(cardUrl, FETCH_TIMEOUT_MS, MAX_TEXT_BODY_SIZE).catch(() => ({ body: null, statusCode: null }));
+      if (cardRes.statusCode === 200 && cardRes.body) {
+        try {
+          JSON.parse(cardRes.body);
+          output.ucpProfile.agentCard = { url: cardUrl, exists: true, valid: true };
+        } catch {
+          output.ucpProfile.agentCard = { url: cardUrl, exists: true, valid: false };
+        }
+      } else if (cardRes.statusCode === 404) {
+        output.ucpProfile.agentCard = { url: cardUrl, exists: false, missing: true };
+      } else {
+        output.ucpProfile.agentCard = { url: cardUrl, exists: false, statusCode: cardRes.statusCode };
+      }
+    }
+  } catch (err) {
+    output.ucpProfile.agentCard = { error: err.message };
+  }
+
+  // --- Shopify host detection (for dual-surface info shortcut in checks) ---
+  try {
+    const homepageHeaders = homepageRes && homepageRes.headers ? homepageRes.headers : {};
+    const headerLookup = (n) => {
+      const lower = n.toLowerCase();
+      for (const k of Object.keys(homepageHeaders)) {
+        if (k.toLowerCase() === lower) return String(homepageHeaders[k] || '');
+      }
+      return '';
+    };
+    const host = (cleanDomain || '').toLowerCase();
+    const isShopifyDomain = host.endsWith('.myshopify.com') || host === 'myshopify.com';
+    const isShopifyByHeader = !!(headerLookup('x-shopid') || headerLookup('x-shardid') || headerLookup('x-shopify-stage') || headerLookup('powered-by').toLowerCase().includes('shopify'));
+    output.ucpProfile.shopifyHosted = isShopifyDomain || isShopifyByHeader;
+  } catch (err) {
+    output.ucpProfile.shopifyHosted = false;
+  }
+
   // --- Homepage (full 16-category analysis) ---
   try {
     output.homepage.statusCode = homepageRes.statusCode;