aeorank 2.3.2 → 3.0.1

package/dist/browser.js

@@ -3,7 +3,7 @@ import {
   extractAllUrlsFromSitemap,
   extractInternalLinks,
   inferCategory
-} from "./chunk-PKJIKMLV.js";
+} from "./chunk-OCLAIHX6.js";
 
 // src/parked-domain.ts
 var PARKING_PATHS = ["/lander", "/parking", "/park", "/sedoparking"];
@@ -892,6 +892,15 @@ function checkTableListExtractability(data) {
   } else {
     findings.push({ severity: "low", detail: "No definition lists (<dl>) found", fix: "Use <dl>/<dt>/<dd> for term-definition pairs to improve AI extractability" });
   }
+  for (const table of tablesWithHeaders) {
+    const headerCells = (table.match(/<th[\s>]/gi) || []).length;
+    const dataCells = (table.match(/<td[\s>]/gi) || []).length;
+    if (headerCells >= 3 && dataCells >= headerCells * 2) {
+      score += 1;
+      findings.push({ severity: "info", detail: "Meaningful comparison table found (3+ columns \xD7 3+ rows)" });
+      break;
+    }
+  }
   return { criterion: "table_list_extractability", criterion_label: "Table & List Extractability", score: Math.min(10, score), status: score >= 7 ? "pass" : score >= 4 ? "partial" : "fail", findings, fix_priority: score >= 7 ? "P3" : "P2" };
 }
 function checkDefinitionPatterns(data) {
@@ -1815,7 +1824,83 @@ function extractRawDataSummary(data) {
     // Full-crawl stats
     crawl_discovered: data.crawlStats?.discovered ?? 0,
     crawl_fetched: data.crawlStats?.fetched ?? 0,
-    crawl_skipped: data.crawlStats?.skipped ?? 0
+    crawl_skipped: data.crawlStats?.skipped ?? 0,
+    // V2 criteria fields
+    citation_ready_sentences: (() => {
+      const combinedText = text + " " + (data.blogSample?.map((p) => p.text.replace(/<[^>]*>/g, " ")).join(" ") || "");
+      return (combinedText.match(/\b\w+\s+(is\s+(?:a|an)\s|refers\s+to|defined\s+as)\b/gi) || []).length;
+    })(),
+    answer_first_ratio: (() => {
+      const pages = [html, ...data.blogSample?.map((p) => p.text) || []];
+      let answerFirst = 0;
+      for (const pageHtml of pages) {
+        const bodyMatch = pageHtml.match(/<body[^>]*>([\s\S]*)/i);
+        const bodyHtml = bodyMatch ? bodyMatch[1] : pageHtml;
+        const earlyParas = bodyHtml.match(/<p[^>]*>([\s\S]*?)<\/p>/gi)?.slice(0, 5) || [];
+        for (const p of earlyParas) {
+          const pText = p.replace(/<[^>]*>/g, "").trim();
+          const wc = pText.split(/\s+/).length;
+          if (wc >= 40 && wc <= 80) {
+            answerFirst++;
+            break;
+          }
+        }
+      }
+      return pages.length > 0 ? Math.round(answerFirst / pages.length * 100) : 0;
+    })(),
+    evidence_citations_avg: (() => {
+      const allHtml = html + "\n" + (data.blogSample?.map((p) => p.text).join("\n") || "");
+      const paragraphs = allHtml.match(/<p[^>]*>[\s\S]*?<\/p>/gi) || [];
+      let citations = 0;
+      const domainLower = data.domain.replace(/^www\./, "").toLowerCase();
+      for (const p of paragraphs) {
+        const links = p.match(/<a[^>]*href=["'](https?:\/\/[^"']+)["'][^>]*>/gi) || [];
+        for (const link of links) {
+          const href = link.match(/href=["'](https?:\/\/[^"']+)["']/i);
+          if (href) {
+            try {
+              const ld = new URL(href[1]).hostname.replace(/^www\./, "").toLowerCase();
+              if (ld !== domainLower) citations++;
+            } catch {
+            }
+          }
+        }
+      }
+      const pageCount = Math.max(1, 1 + (data.blogSample?.length ?? 0));
+      return Math.round(citations / pageCount * 10) / 10;
+    })(),
+    entity_disambiguation_ratio: (() => {
+      const pages = [html, ...data.blogSample?.map((p) => p.text) || []];
+      let defined = 0;
+      for (const pageHtml of pages) {
+        const h1Match = pageHtml.match(/<h1[^>]*>([\s\S]*?)<\/h1>/i);
+        if (!h1Match) continue;
+        const h1Text = h1Match[1].replace(/<[^>]*>/g, "").trim();
+        const h1Words = h1Text.split(/\s+/).filter((w) => w.length > 3);
+        const primaryNoun = h1Words.sort((a, b) => b.length - a.length)[0] || "";
+        if (!primaryNoun) continue;
+        const pageText = pageHtml.replace(/<[^>]*>/g, " ").replace(/\s+/g, " ").slice(0, 500);
+        if (new RegExp(`\\b${primaryNoun.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b[^.]*\\b(is|refers|defined|means)\\b`, "i").test(pageText)) {
+          defined++;
+        }
+      }
+      return pages.length > 0 ? Math.round(defined / pages.length * 100) : 0;
+    })(),
+    extraction_friction_avg: (() => {
+      const combinedText = text + " " + (data.blogSample?.map((p) => p.text.replace(/<[^>]*>/g, " ")).join(" ") || "");
+      const sentences = combinedText.split(/[.!?]+/).filter((s) => s.trim().length > 5);
+      if (sentences.length === 0) return 0;
+      const totalWords = sentences.reduce((sum, s) => sum + s.trim().split(/\s+/).length, 0);
+      return Math.round(totalWords / sentences.length * 10) / 10;
+    })(),
+    image_figure_ratio: (() => {
+      const combinedHtml = html + "\n" + (data.blogSample?.map((p) => p.text).join("\n") || "");
+      const allImages = combinedHtml.match(/<img\s[^>]*>/gi) || [];
+      if (allImages.length === 0) return 0;
+      const figureBlocks = combinedHtml.match(/<figure[\s\S]*?<\/figure>/gi) || [];
+      const figuresWithCaption = figureBlocks.filter((f) => /<figcaption/i.test(f));
+      return Math.round(figuresWithCaption.length / allImages.length * 100);
+    })()
   };
 }
 function getPageTopicText(html) {
@@ -2047,6 +2132,432 @@ function checkContentDepth(data, topicCoherenceScore) {
   }
   return { criterion: "content_depth", criterion_label: "Content Depth", score: finalScore, status: finalScore >= 7 ? "pass" : finalScore >= 4 ? "partial" : "fail", findings, fix_priority: finalScore >= 7 ? "P3" : "P1" };
 }
+function checkCitationReadyWriting(data) {
+  const findings = [];
+  if (!data.homepage) {
+    findings.push({ severity: "critical", detail: "Could not fetch homepage" });
+    return { criterion: "citation_ready_writing", criterion_label: "Citation-Ready Writing Quality", score: 0, status: "not_found", findings, fix_priority: "P1" };
+  }
+  const combinedHtml = getCombinedHtml(data);
+  const text = combinedHtml.replace(/<[^>]*>/g, " ").replace(/\s+/g, " ");
+  const blogHtml = getBlogHtml(data);
+  const blogText = blogHtml ? blogHtml.replace(/<[^>]*>/g, " ").replace(/\s+/g, " ") : text;
+  const pageCount = Math.max(1, (data.blogSample?.length ?? 0) + 1);
+  let score = 0;
+  const defSentences = blogText.match(/\b\w+\s+(is\s+(?:a|an)\s|refers\s+to|defined\s+as)\b/gi) || [];
+  const avgDef = defSentences.length / pageCount;
+  if (avgDef >= 3) {
+    score += 3;
+    findings.push({ severity: "info", detail: `${defSentences.length} definition sentences found (avg ${avgDef.toFixed(1)}/page)` });
+  } else if (avgDef >= 1) {
+    score += 1;
+    findings.push({ severity: "low", detail: `${defSentences.length} definition sentences found (avg ${avgDef.toFixed(1)}/page)`, fix: "Add more self-contained definition sentences that AI can quote directly" });
+  } else {
+    findings.push({ severity: "medium", detail: "No definition sentences found", fix: 'Write clear "X is a..." and "X refers to..." sentences for key concepts' });
+  }
+  const sentences = text.split(/[.!?]+/).filter((s) => s.trim().length > 10);
+  const oneClaimSentences = sentences.filter((s) => {
+    const words = s.trim().split(/\s+/);
+    return words.length < 30 && !/,\s*(and|but|or|which|that|because|although|while)\s/i.test(s);
+  });
+  const avgOneClaim = oneClaimSentences.length / pageCount;
+  if (avgOneClaim >= 5) {
+    score += 3;
+    findings.push({ severity: "info", detail: `Strong single-claim sentence density (avg ${avgOneClaim.toFixed(1)}/page)` });
+  } else if (avgOneClaim >= 2) {
+    score += 1;
+    findings.push({ severity: "low", detail: `Moderate single-claim sentence density`, fix: "Write more concise, single-claim sentences that AI engines can quote" });
+  }
+  const qHeadings = extractQuestionHeadings(combinedHtml);
+  if (qHeadings.length > 0) {
+    let selfContained = 0;
+    for (const qh of qHeadings) {
+      const escaped = qh.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      const pat = new RegExp(escaped + "[\\s\\S]{0,200}?<\\/h[23]>\\s*<p[^>]*>([^<]{0,200})", "i");
+      const m = pat.exec(combinedHtml);
+      if (m && m[1] && !/^\s*(this|that|these|those|it)\s/i.test(m[1].trim())) {
+        selfContained++;
+      }
+    }
+    const selfContainedRatio = selfContained / qHeadings.length;
+    if (selfContainedRatio >= 0.8) {
+      score += 2;
+      findings.push({ severity: "info", detail: `${Math.round(selfContainedRatio * 100)}% of answer openings are self-contained (no dangling pronouns)` });
+    } else {
+      findings.push({ severity: "low", detail: `Only ${Math.round(selfContainedRatio * 100)}% of answer openings are self-contained`, fix: 'Start answer paragraphs with the entity name, not "This" or "That"' });
+    }
+  }
+  const quotableLines = sentences.filter(
+    (s) => /\d+(\.\d+)?%|\$[\d,.]+|\b\d{1,3}(,\d{3})+\b/.test(s) && /\b[A-Z][a-z]+(?:\s+[A-Z][a-z]+)*\b/.test(s)
+  );
+  const avgQuotable = quotableLines.length / pageCount;
+  if (avgQuotable >= 2) {
+    score += 2;
+    findings.push({ severity: "info", detail: `${quotableLines.length} quotation-ready lines with stats and sources` });
+  } else if (avgQuotable >= 1) {
+    score += 1;
+    findings.push({ severity: "low", detail: `${quotableLines.length} quotation-ready lines found`, fix: "Combine statistics with named sources for more citable content" });
+  } else {
+    findings.push({ severity: "medium", detail: "No quotation-ready lines found", fix: 'Write sentences that combine a statistic with a named source, e.g. "According to Harvard, 85% of..."' });
+  }
+  return { criterion: "citation_ready_writing", criterion_label: "Citation-Ready Writing Quality", score: Math.min(10, score), status: score >= 7 ? "pass" : score >= 4 ? "partial" : "fail", findings, fix_priority: score >= 7 ? "P3" : "P1" };
+}
+function checkAnswerFirstPlacement(data) {
+  const findings = [];
+  if (!data.homepage) {
+    findings.push({ severity: "critical", detail: "Could not fetch homepage" });
+    return { criterion: "answer_first_placement", criterion_label: "Answer-First Placement", score: 0, status: "not_found", findings, fix_priority: "P1" };
+  }
+  const pages = [stripScripts(data.homepage.text)];
+  if (data.blogSample) {
+    for (const p of data.blogSample) {
+      pages.push(stripScripts(p.text));
+    }
+  }
+  let score = 0;
+  let shortAnswerCount = 0;
+  let answerFirstCount = 0;
+  let entityFirstCount = 0;
+  const throatClearing = /^(In today|Welcome to|Have you ever|If you're looking|In this (article|post|guide))/i;
+  for (const pageHtml of pages) {
+    const bodyMatch = pageHtml.match(/<body[^>]*>([\s\S]*)/i);
+    const bodyHtml = bodyMatch ? bodyMatch[1] : pageHtml;
+    const bodyText = bodyHtml.replace(/<[^>]*>/g, " ").replace(/\s+/g, " ").trim();
+    const first300Words = bodyText.split(/\s+/).slice(0, 300).join(" ");
+    const earlyParagraphs = bodyHtml.match(/<p[^>]*>([\s\S]*?)<\/p>/gi)?.slice(0, 5) || [];
+    for (const p of earlyParagraphs) {
+      const pText = p.replace(/<[^>]*>/g, "").trim();
+      const wordCount = pText.split(/\s+/).length;
+      if (wordCount >= 40 && wordCount <= 80 && first300Words.includes(pText.slice(0, 50))) {
+        shortAnswerCount++;
+        break;
+      }
+    }
+    const firstPara = bodyHtml.match(/<p[^>]*>([\s\S]*?)<\/p>/i);
+    if (firstPara) {
+      const firstParaText = firstPara[1].replace(/<[^>]*>/g, "").trim();
+      if (!throatClearing.test(firstParaText)) {
+        answerFirstCount++;
+      }
+    }
+    const h1Match = pageHtml.match(/<h1[^>]*>([\s\S]*?)<\/h1>/i);
+    if (h1Match) {
+      const h1Text = h1Match[1].replace(/<[^>]*>/g, "").trim();
+      const h1Words = h1Text.split(/\s+/).filter((w) => w.length > 3 && /^[A-Z]/.test(w) || w.length > 5);
+      const firstSentence = bodyText.split(/[.!?]/)[0] || "";
+      if (h1Words.some((w) => firstSentence.toLowerCase().includes(w.toLowerCase()))) {
+        entityFirstCount++;
+      }
+    }
+  }
+  const totalPages = pages.length;
+  const shortAnswerRatio = shortAnswerCount / totalPages;
+  const answerFirstRatio = answerFirstCount / totalPages;
+  const entityFirstRatio = entityFirstCount / totalPages;
+  if (shortAnswerRatio >= 0.7) {
+    score += 4;
+    findings.push({ severity: "info", detail: `${Math.round(shortAnswerRatio * 100)}% of pages have a short answer block (40-80 words) early` });
+  } else if (shortAnswerRatio >= 0.3) {
+    score += 2;
+    findings.push({ severity: "low", detail: `${Math.round(shortAnswerRatio * 100)}% of pages have an early answer block`, fix: "Add a concise 40-80 word answer paragraph in the first 300 words of each page" });
+  } else {
+    findings.push({ severity: "medium", detail: "Few pages have an early answer block", fix: "Place a 40-80 word summary paragraph near the top of each page for AI snippet extraction" });
+  }
+  if (answerFirstRatio >= 0.7) {
+    score += 3;
+    findings.push({ severity: "info", detail: `${Math.round(answerFirstRatio * 100)}% of pages open with a direct answer (no throat-clearing)` });
+  } else if (answerFirstRatio >= 0.4) {
+    score += 1;
+    findings.push({ severity: "low", detail: `${Math.round(answerFirstRatio * 100)}% of pages open with a direct answer`, fix: `Avoid openers like "In today's world..." - start with the answer` });
+  } else {
+    findings.push({ severity: "medium", detail: "Most pages use throat-clearing openers instead of direct answers", fix: `Replace "In this article..." with a direct answer to the page's main question` });
+  }
+  if (entityFirstRatio >= 0.8) {
+    score += 3;
+    findings.push({ severity: "info", detail: `${Math.round(entityFirstRatio * 100)}% of pages mention the primary entity in the first sentence` });
+  } else if (entityFirstRatio >= 0.5) {
+    score += 1;
+    findings.push({ severity: "low", detail: `${Math.round(entityFirstRatio * 100)}% mention the primary entity in the first sentence`, fix: "Include the H1 topic in the first body sentence for AI extraction" });
+  } else {
+    findings.push({ severity: "low", detail: "Few pages mention the primary entity in the opening sentence", fix: "Start content with a sentence that names the page topic explicitly" });
+  }
+  return { criterion: "answer_first_placement", criterion_label: "Answer-First Placement", score: Math.min(10, score), status: score >= 7 ? "pass" : score >= 4 ? "partial" : "fail", findings, fix_priority: score >= 7 ? "P3" : "P1" };
+}
+function checkEvidencePackaging(data) {
+  const findings = [];
+  if (!data.homepage) {
+    findings.push({ severity: "critical", detail: "Could not fetch homepage" });
+    return { criterion: "evidence_packaging", criterion_label: "Evidence Packaging", score: 0, status: "not_found", findings, fix_priority: "P1" };
+  }
+  const combinedHtml = getCombinedHtml(data);
+  const text = combinedHtml.replace(/<[^>]*>/g, " ").replace(/\s+/g, " ");
+  const pageCount = Math.max(1, (data.blogSample?.length ?? 0) + 1);
+  let score = 0;
+  const paragraphs = combinedHtml.match(/<p[^>]*>[\s\S]*?<\/p>/gi) || [];
+  let inlineCitations = 0;
+  const domain = data.domain.replace(/^www\./, "").toLowerCase();
+  for (const p of paragraphs) {
+    const links = p.match(/<a[^>]*href=["'](https?:\/\/[^"']+)["'][^>]*>/gi) || [];
+    for (const link of links) {
+      const href = link.match(/href=["'](https?:\/\/[^"']+)["']/i);
+      if (href) {
+        try {
+          const linkDomain = new URL(href[1]).hostname.replace(/^www\./, "").toLowerCase();
+          if (linkDomain !== domain) inlineCitations++;
+        } catch {
+        }
+      }
+    }
+  }
+  const avgCitations = inlineCitations / pageCount;
+  if (avgCitations >= 3) {
+    score += 3;
+    findings.push({ severity: "info", detail: `${inlineCitations} inline citations to external sources (avg ${avgCitations.toFixed(1)}/page)` });
+  } else if (avgCitations >= 1) {
+    score += 1;
+    findings.push({ severity: "low", detail: `${inlineCitations} inline citations found`, fix: "Add more inline links to authoritative external sources within paragraphs" });
+  } else {
+    findings.push({ severity: "medium", detail: "No inline citations to external sources", fix: "Link to authoritative sources within your content paragraphs to strengthen evidence" });
+  }
+  const sourcesHeading = combinedHtml.match(/<h[2-4][^>]*>[^<]*(source|reference|citation|bibliography)[^<]*<\/h[2-4]>/gi) || [];
+  const sourceSections = sourcesHeading.length;
+  if (sourceSections > 0) {
+    const ratio = sourceSections / pageCount;
+    if (ratio >= 0.5) {
+      score += 2;
+      findings.push({ severity: "info", detail: `Sources/References section found on ${sourceSections} page(s)` });
+    } else {
+      score += 1;
+      findings.push({ severity: "low", detail: `Sources section found on ${sourceSections} page(s)`, fix: "Add a Sources or References section to more content pages" });
+    }
+  } else {
+    findings.push({ severity: "low", detail: "No Sources/References section found", fix: 'Add a "Sources" heading at the end of key articles' });
+  }
+  const attributionPhrases = text.match(/\baccording\s+to\s+[A-Z]|\b[A-Z][a-z]+\s+(found|says|reports|notes|states|estimates|suggests)\b/gi) || [];
+  const avgAttribution = attributionPhrases.length / pageCount;
+  if (avgAttribution >= 3) {
+    score += 3;
+    findings.push({ severity: "info", detail: `${attributionPhrases.length} attribution phrases found (avg ${avgAttribution.toFixed(1)}/page)` });
+  } else if (avgAttribution >= 1) {
+    score += 1;
+    findings.push({ severity: "low", detail: `${attributionPhrases.length} attribution phrases found`, fix: 'Add more "According to [Source]..." attribution for credibility' });
+  } else {
+    findings.push({ severity: "medium", detail: "No attribution phrases found", fix: 'Use "According to [Name]..." and "[Expert] reports..." to attribute claims' });
+  }
+  const sourcedStats = text.match(/\d+(\.\d+)?(%|\s*(million|billion|thousand|percent))\b[^.]*\b[A-Z][a-z]+\b/gi) || [];
+  const avgSourcedStats = sourcedStats.length / pageCount;
+  if (avgSourcedStats >= 2) {
+    score += 2;
+    findings.push({ severity: "info", detail: `${sourcedStats.length} sourced statistics found` });
+  } else if (avgSourcedStats >= 1) {
+    score += 1;
+    findings.push({ severity: "low", detail: `${sourcedStats.length} sourced statistics found`, fix: "Pair more statistics with named sources" });
+  }
+  return { criterion: "evidence_packaging", criterion_label: "Evidence Packaging", score: Math.min(10, score), status: score >= 7 ? "pass" : score >= 4 ? "partial" : "fail", findings, fix_priority: score >= 7 ? "P3" : "P1" };
+}
+function checkEntityDisambiguation(data) {
+  const findings = [];
+  if (!data.homepage) {
+    findings.push({ severity: "critical", detail: "Could not fetch homepage" });
+    return { criterion: "entity_disambiguation", criterion_label: "Entity Disambiguation", score: 0, status: "not_found", findings, fix_priority: "P2" };
+  }
+  const pages = [stripScripts(data.homepage.text)];
+  if (data.blogSample) {
+    for (const p of data.blogSample) {
+      pages.push(stripScripts(p.text));
+    }
+  }
+  let score = 0;
+  let definedEarlyCount = 0;
+  let consistentCount = 0;
+  let disambiguationCount = 0;
+  for (const pageHtml of pages) {
+    const text = pageHtml.replace(/<[^>]*>/g, " ").replace(/\s+/g, " ");
+    const h1Match = pageHtml.match(/<h1[^>]*>([\s\S]*?)<\/h1>/i);
+    if (!h1Match) continue;
+    const h1Text = h1Match[1].replace(/<[^>]*>/g, "").trim();
+    const h1Words = h1Text.split(/\s+/).filter((w) => w.length > 3);
+    const primaryNoun = h1Words.sort((a, b) => b.length - a.length)[0] || "";
+    if (!primaryNoun) continue;
+    const first500 = text.slice(0, 500);
+    if (new RegExp(`\\b${primaryNoun.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b[^.]*\\b(is|refers|defined|means)\\b`, "i").test(first500)) {
+      definedEarlyCount++;
+    }
+    const primaryNounLower = primaryNoun.toLowerCase();
+    const primaryRegex = new RegExp(`\\b${primaryNounLower.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`, "gi");
+    const mentions = text.match(primaryRegex) || [];
+    if (mentions.length >= 3) {
+      consistentCount++;
+    }
+    if (/\bunlike\s+\w/i.test(text) || /\bcompared\s+to\s+\w/i.test(text) || /\bnot\s+to\s+be\s+confused\s+with\b/i.test(text) || /\bas\s+opposed\s+to\b/i.test(text)) {
+      disambiguationCount++;
+    }
+  }
+  const totalPages = pages.length;
+  const definedRatio = definedEarlyCount / totalPages;
+  if (definedRatio >= 0.7) {
+    score += 4;
+    findings.push({ severity: "info", detail: `${Math.round(definedRatio * 100)}% of pages define the primary entity early` });
+  } else if (definedRatio >= 0.3) {
+    score += 2;
+    findings.push({ severity: "low", detail: `${Math.round(definedRatio * 100)}% of pages define the primary entity early`, fix: "Define the main topic within the first 500 characters of each page" });
+  } else {
+    findings.push({ severity: "medium", detail: "Few pages define the primary entity early", fix: "Start each page with a clear definition of the main topic" });
+  }
+  const consistentRatio = consistentCount / totalPages;
+  if (consistentRatio >= 0.7) {
+    score += 3;
+    findings.push({ severity: "info", detail: `${Math.round(consistentRatio * 100)}% of pages use consistent entity terminology` });
+  } else if (consistentRatio >= 0.3) {
+    score += 1;
+    findings.push({ severity: "low", detail: `${Math.round(consistentRatio * 100)}% of pages use consistent terminology`, fix: "Use the same primary term consistently instead of varying synonyms" });
+  } else {
+    findings.push({ severity: "low", detail: "Low entity terminology consistency across pages", fix: "Repeat the primary entity term consistently throughout each page" });
+  }
+  const disambigRatio = disambiguationCount / totalPages;
+  if (disambigRatio >= 0.3) {
+    score += 3;
+    findings.push({ severity: "info", detail: `${disambiguationCount} page(s) use disambiguation signals ("unlike X", "compared to")` });
+  } else if (disambiguationCount > 0) {
+    score += 1;
+    findings.push({ severity: "low", detail: `${disambiguationCount} page(s) use disambiguation signals`, fix: 'Add "unlike X" or "compared to Y" to clarify entity boundaries for AI' });
+  } else {
+    findings.push({ severity: "low", detail: "No disambiguation signals found", fix: 'Add "unlike X" or "not to be confused with Y" to help AI engines distinguish your topics' });
+  }
+  return { criterion: "entity_disambiguation", criterion_label: "Entity Disambiguation", score: Math.min(10, score), status: score >= 7 ? "pass" : score >= 4 ? "partial" : "fail", findings, fix_priority: score >= 7 ? "P3" : "P2" };
+}
+function checkExtractionFriction(data) {
+  const findings = [];
+  if (!data.homepage) {
+    findings.push({ severity: "critical", detail: "Could not fetch homepage" });
+    return { criterion: "extraction_friction", criterion_label: "Extraction Friction Score", score: 0, status: "not_found", findings, fix_priority: "P2" };
+  }
+  const combinedHtml = getCombinedHtml(data);
+  const text = combinedHtml.replace(/<[^>]*>/g, " ").replace(/\s+/g, " ");
+  let score = 0;
+  const sentences = text.split(/[.!?]+/).filter((s) => s.trim().length > 5);
+  const sentenceLengths = sentences.map((s) => s.trim().split(/\s+/).length);
+  const avgSentenceLen = sentenceLengths.length > 0 ? sentenceLengths.reduce((a, b) => a + b, 0) / sentenceLengths.length : 0;
+  if (avgSentenceLen > 0 && avgSentenceLen < 20) {
+    score += 3;
+    findings.push({ severity: "info", detail: `Average sentence length: ${avgSentenceLen.toFixed(1)} words - excellent for AI extraction` });
+  } else if (avgSentenceLen >= 20 && avgSentenceLen <= 25) {
+    score += 2;
+    findings.push({ severity: "info", detail: `Average sentence length: ${avgSentenceLen.toFixed(1)} words - good` });
+  } else if (avgSentenceLen > 25 && avgSentenceLen <= 35) {
+    score += 1;
+    findings.push({ severity: "low", detail: `Average sentence length: ${avgSentenceLen.toFixed(1)} words - slightly long`, fix: "Shorten sentences to under 25 words for easier AI extraction" });
+  } else if (avgSentenceLen > 35) {
+    findings.push({ severity: "medium", detail: `Average sentence length: ${avgSentenceLen.toFixed(1)} words - too long for AI snippets`, fix: "Break long sentences into shorter, single-claim statements" });
+  }
+  const pages = [stripScripts(data.homepage.text)];
+  if (data.blogSample) {
+    for (const p of data.blogSample) pages.push(stripScripts(p.text));
+  }
+  let voiceFriendlyCount = 0;
+  for (const pageHtml of pages) {
+    const h1Match = pageHtml.match(/<h1[^>]*>[\s\S]*?<\/h1>/i);
+    if (!h1Match) continue;
+    const afterH1 = pageHtml.slice(pageHtml.indexOf(h1Match[0]) + h1Match[0].length);
+    const leadParas = afterH1.match(/<p[^>]*>([\s\S]*?)<\/p>/gi)?.slice(0, 3) || [];
+    const leadText = leadParas.map((p) => p.replace(/<[^>]*>/g, "")).join(" ").trim();
+    const words = leadText.split(/\s+/).length;
+    const hasParentheticals = /\([^)]+\)/.test(leadText);
+    if (words <= 75 && words > 10 && !hasParentheticals) {
+      voiceFriendlyCount++;
+    }
+  }
+  const voiceFriendlyRatio = voiceFriendlyCount / pages.length;
+  if (voiceFriendlyRatio >= 0.7) {
+    score += 3;
+    findings.push({ severity: "info", detail: `${Math.round(voiceFriendlyRatio * 100)}% of pages have voice-friendly lead paragraphs` });
+  } else if (voiceFriendlyRatio >= 0.3) {
+    score += 1;
+    findings.push({ severity: "low", detail: `${Math.round(voiceFriendlyRatio * 100)}% have voice-friendly leads`, fix: "Keep the first 2-3 sentences under 75 words total, using active voice with no parentheticals" });
+  } else {
+    findings.push({ severity: "low", detail: "Few pages have voice-friendly lead paragraphs", fix: "Write concise opening paragraphs without parentheticals for voice assistant compatibility" });
+  }
+  const first500Words = text.split(/\s+/).slice(0, 500).join(" ");
+  const longWords = first500Words.match(/\b[a-z]{10,}\b/gi) || [];
+  const avgJargon = longWords.length / Math.max(1, pages.length);
+  if (avgJargon <= 2) {
+    score += 2;
+    findings.push({ severity: "info", detail: "Low jargon density in opening content" });
+  } else if (avgJargon <= 5) {
+    score += 1;
+    findings.push({ severity: "low", detail: "Moderate jargon in opening content", fix: "Define technical terms inline when first used" });
+  } else {
+    findings.push({ severity: "low", detail: "High jargon density in opening content", fix: "Replace or define complex terms to reduce extraction friction" });
+  }
+  const hasHiddenContent = /display\s*:\s*none|visibility\s*:\s*hidden|\bhidden\b/i.test(combinedHtml) && /<(div|section|p)[^>]*(?:style=["'][^"']*display\s*:\s*none|hidden)[^>]*>/i.test(combinedHtml);
+  if (hasHiddenContent) {
+    score = Math.max(0, score - 2);
+    findings.push({ severity: "medium", detail: "Hidden content detected (display:none or hidden attribute)", fix: "Make all content visible - hidden content is not extractable by AI engines" });
+  }
+  return { criterion: "extraction_friction", criterion_label: "Extraction Friction Score", score: Math.min(10, score), status: score >= 7 ? "pass" : score >= 4 ? "partial" : "fail", findings, fix_priority: score >= 7 ? "P3" : "P2" };
+}
+function checkImageContextAI(data) {
+  const findings = [];
+  if (!data.homepage) {
+    findings.push({ severity: "critical", detail: "Could not fetch homepage" });
+    return { criterion: "image_context_ai", criterion_label: "Image Context for AI", score: 0, status: "not_found", findings, fix_priority: "P2" };
+  }
+  const combinedHtml = getCombinedHtml(data);
+  let score = 0;
+  const allImages = combinedHtml.match(/<img\s[^>]*>/gi) || [];
+  if (allImages.length === 0) {
+    findings.push({ severity: "low", detail: "No images found on pages" });
+    return { criterion: "image_context_ai", criterion_label: "Image Context for AI", score: 5, status: "partial", findings, fix_priority: "P3" };
+  }
+  const figureBlocks = combinedHtml.match(/<figure[\s\S]*?<\/figure>/gi) || [];
+  const figuresWithCaption = figureBlocks.filter((f) => /<figcaption/i.test(f));
+  const figureRatio = figuresWithCaption.length / allImages.length;
+  if (figureRatio >= 0.5) {
+    score += 4;
+    findings.push({ severity: "info", detail: `${figuresWithCaption.length}/${allImages.length} images use <figure> + <figcaption>` });
+  } else if (figureRatio >= 0.25) {
+    score += 2;
+    findings.push({ severity: "low", detail: `${figuresWithCaption.length}/${allImages.length} images use <figure> + <figcaption>`, fix: "Wrap more images in <figure> with <figcaption> for AI context" });
+  } else {
+    findings.push({ severity: "medium", detail: "Few or no images use <figure> + <figcaption>", fix: "Wrap images in <figure> elements with descriptive <figcaption> tags" });
+  }
+  let goodAltCount = 0;
+  for (const img of allImages) {
+    const altMatch = img.match(/\salt=["']([^"']+)["']/i);
+    if (altMatch) {
+      const altText = altMatch[1].trim();
+      const words = altText.split(/\s+/).length;
+      const isGeneric = /^(image|photo|picture|img|icon|logo|banner|screenshot)$/i.test(altText);
+      if (words > 5 && !isGeneric) {
+        goodAltCount++;
+      }
+    }
+  }
+  const altQualityRatio = goodAltCount / allImages.length;
+  if (altQualityRatio >= 0.5) {
+    score += 3;
+    findings.push({ severity: "info", detail: `${goodAltCount}/${allImages.length} images have descriptive alt text (>5 words)` });
+  } else if (altQualityRatio >= 0.25) {
+    score += 1;
+    findings.push({ severity: "low", detail: `${goodAltCount}/${allImages.length} images have quality alt text`, fix: "Write descriptive alt text (>5 words) that explains the image content" });
+  } else {
+    findings.push({ severity: "medium", detail: "Most images lack descriptive alt text", fix: 'Add descriptive alt text (>5 words) to all images, avoiding generic terms like "image" or "photo"' });
+  }
+  const contextualImages = combinedHtml.match(/<(article|section)[^>]*>[\s\S]*?<img[^>]*>[\s\S]*?<\/\1>/gi) || [];
+  if (contextualImages.length > 0) {
+    const contextRatio = Math.min(contextualImages.length, allImages.length) / allImages.length;
+    if (contextRatio >= 0.5) {
+      score += 3;
+      findings.push({ severity: "info", detail: "Images are well-placed within semantic content sections" });
+    } else {
+      score += 1;
+      findings.push({ severity: "low", detail: "Some images placed within content sections", fix: "Place images within <article> or <section> elements for better AI context" });
+    }
+  } else {
+    findings.push({ severity: "low", detail: "Images not placed within semantic content sections", fix: "Move images inside <article> or <section> elements" });
+  }
+  return { criterion: "image_context_ai", criterion_label: "Image Context for AI", score: Math.min(10, score), status: score >= 7 ? "pass" : score >= 4 ? "partial" : "fail", findings, fix_priority: score >= 7 ? "P3" : "P2" };
+}
 function auditSiteFromData(data) {
   const topicCoherence = checkTopicCoherence(data);
   const cannibalization = checkContentCannibalization(data, topicCoherence.score);
@@ -2078,7 +2589,14 @@ function auditSiteFromData(data) {
     cannibalization,
     checkVisibleDateSignal(data),
     topicCoherence,
-    checkContentDepth(data, topicCoherence.score)
+    checkContentDepth(data, topicCoherence.score),
+    // V2 criteria (#29-#34)
+    checkCitationReadyWriting(data),
+    checkAnswerFirstPlacement(data),
+    checkEvidencePackaging(data),
+    checkEntityDisambiguation(data),
+    checkExtractionFriction(data),
+    checkImageContextAI(data)
   ];
 }
 async function auditSite(targetUrl) {
@@ -2141,7 +2659,21 @@ var WEIGHTS = {
   canonical_url: 0.01,
   rss_feed: 0.01,
   schema_coverage: 0.01,
-  speakable_schema: 0.01
+  speakable_schema: 0.01,
+  // ─── V2 Criteria (~15%) ───────────────────────────────────────────────────
+  // Citation quality, evidence packaging, and extraction friction.
+  citation_ready_writing: 0.04,
+  // Self-contained quotable sentences
+  answer_first_placement: 0.03,
+  // Answer block in first 300 words
+  evidence_packaging: 0.03,
+  // Inline citations and attribution
+  entity_disambiguation: 0.02,
+  // Clear entity boundaries
+  extraction_friction: 0.02,
+  // Sentence length, voice, jargon
+  image_context_ai: 0.01
+  // Figure/figcaption, alt text quality
 };
 function calculateOverallScore(criteria) {
   let totalWeight = 0;
@@ -2161,6 +2693,248 @@ function calculateOverallScore(criteria) {
   return score;
 }
 
+// src/pillars.ts
+var PILLARS = {
+  "Answer Readiness": [
+    "topic_coherence",
+    "original_data",
+    "content_depth",
+    "fact_density",
+    "citation_ready_writing",
+    "answer_first_placement",
+    "evidence_packaging"
+  ],
+  "Content Structure": [
+    "direct_answer_density",
+    "qa_content_format",
+    "query_answer_alignment",
+    "faq_section",
+    "table_list_extractability",
+    "definition_patterns",
+    "entity_disambiguation"
+  ],
+  "Trust & Authority": [
+    "entity_consistency",
+    "internal_linking",
+    "content_freshness",
+    "author_schema_depth",
+    "schema_markup"
+  ],
+  "Technical Foundation": [
+    "semantic_html",
+    "clean_html",
+    "visible_date_signal",
+    "extraction_friction",
+    "image_context_ai",
+    "schema_coverage",
+    "speakable_schema"
+  ],
+  "AI Discovery": [
+    "content_cannibalization",
+    "llms_txt",
+    "robots_txt",
+    "content_velocity",
+    "content_licensing",
+    "canonical_url",
+    "sitemap_completeness",
+    "rss_feed"
+  ]
+};
+var CLIENT_NAMES = {
+  topic_coherence: "Topical Authority",
+  original_data: "Original Research & Data",
+  content_depth: "Content Depth",
+  fact_density: "Fact & Data Density",
+  citation_ready_writing: "Citation-Ready Writing",
+  answer_first_placement: "Answer-First Placement",
+  evidence_packaging: "Evidence Packaging",
+  direct_answer_density: "Direct Answer Density",
+  qa_content_format: "Q&A Content Format",
+  query_answer_alignment: "Query-Answer Alignment",
+  faq_section: "FAQ Section",
+  table_list_extractability: "Tables & Lists",
+  definition_patterns: "Definition Patterns",
+  entity_disambiguation: "Entity Disambiguation",
+  entity_consistency: "Entity & Brand Authority",
+  internal_linking: "Internal Linking",
+  content_freshness: "Content Freshness",
+  author_schema_depth: "Author & Expert Schema",
+  schema_markup: "Schema Markup",
+  semantic_html: "Semantic HTML",
+  clean_html: "Clean HTML",
+  visible_date_signal: "Visible Date Signal",
+  extraction_friction: "Extraction Friction",
+  image_context_ai: "Image Context for AI",
+  schema_coverage: "Schema Coverage",
+  speakable_schema: "Speakable Schema",
+  content_cannibalization: "Content Cannibalization",
+  llms_txt: "llms.txt File",
+  robots_txt: "robots.txt for AI",
+  content_velocity: "Publishing Velocity",
+  content_licensing: "Content Licensing",
+  canonical_url: "Canonical URLs",
+  sitemap_completeness: "Sitemap Completeness",
+  rss_feed: "RSS/Atom Feed"
+};
+var PILLAR_WEIGHTS = {
+  topic_coherence: 0.14,
+  original_data: 0.1,
+  content_depth: 0.07,
+  fact_density: 0.06,
+  citation_ready_writing: 0.04,
+  answer_first_placement: 0.03,
+  evidence_packaging: 0.03,
+  direct_answer_density: 0.05,
+  qa_content_format: 0.05,
+  query_answer_alignment: 0.05,
+  faq_section: 0.04,
+  table_list_extractability: 0.03,
+  definition_patterns: 0.02,
+  entity_disambiguation: 0.02,
+  entity_consistency: 0.05,
+  internal_linking: 0.04,
+  content_freshness: 0.04,
+  author_schema_depth: 0.03,
+  schema_markup: 0.03,
+  semantic_html: 0.02,
+  clean_html: 0.02,
+  visible_date_signal: 0.02,
+  extraction_friction: 0.02,
+  image_context_ai: 0.01,
+  schema_coverage: 0.01,
+  speakable_schema: 0.01,
+  content_cannibalization: 0.02,
+  llms_txt: 0.02,
+  robots_txt: 0.02,
+  content_velocity: 0.02,
+  content_licensing: 0.02,
+  canonical_url: 0.01,
+  sitemap_completeness: 0.01,
+  rss_feed: 0.01
+};
+var CRITERION_EFFORT = {
+  topic_coherence: "High",
+  original_data: "High",
+  content_depth: "Medium",
+  fact_density: "Medium",
+  citation_ready_writing: "Medium",
+  answer_first_placement: "Medium",
+  evidence_packaging: "Medium",
+  direct_answer_density: "Medium",
+  qa_content_format: "Medium",
+  query_answer_alignment: "Medium",
+  faq_section: "Medium",
+  table_list_extractability: "Medium",
+  definition_patterns: "Low",
+  entity_disambiguation: "Medium",
+  entity_consistency: "Low",
+  internal_linking: "Medium",
+  content_freshness: "Low",
+  author_schema_depth: "Low",
+  schema_markup: "Medium",
+  semantic_html: "Low",
+  clean_html: "Medium",
+  visible_date_signal: "Low",
+  extraction_friction: "Medium",
+  image_context_ai: "Low",
+  schema_coverage: "Medium",
+  speakable_schema: "Low",
+  content_cannibalization: "Medium",
+  llms_txt: "Low",
+  robots_txt: "Low",
+  content_velocity: "High",
+  content_licensing: "Low",
+  canonical_url: "Low",
+  sitemap_completeness: "Low",
+  rss_feed: "Low"
+};
+var FIX_DESCRIPTIONS = {
+  topic_coherence: "Focus blog content on 2-3 core expertise areas instead of scattered topics.",
+  original_data: "Publish original research, case studies, or proprietary data that AI engines can cite.",
+  content_depth: "Expand articles to 1000+ words with structured H2/H3 sections and expert analysis.",
+  fact_density: "Add specific numbers, percentages, and statistics throughout content.",
+  citation_ready_writing: "Write self-contained definition sentences and one-claim statements AI can quote directly.",
+  answer_first_placement: "Place a 40-80 word answer block in the first 300 words of each page.",
+  evidence_packaging: "Add inline citations, attribution phrases, and a sources section to key pages.",
+  direct_answer_density: "Write concise 2-3 sentence answer paragraphs after each question heading.",
+  qa_content_format: "Add question-based H2/H3 headings matching common AI queries.",
+  query_answer_alignment: "Ensure every question heading is followed by a direct answer paragraph.",
+  faq_section: "Create a dedicated FAQ page with FAQPage schema markup.",
+  table_list_extractability: "Add comparison tables with headers and structured lists.",
+  definition_patterns: 'Include clear "X is defined as..." patterns for key terms.',
+  entity_disambiguation: "Define the primary entity early and use consistent terminology.",
+  entity_consistency: "Add Organization schema with consistent name, address, and sameAs links.",
+  internal_linking: "Strengthen internal linking with descriptive anchor text between related pages.",
+  content_freshness: "Add dateModified schema and visible last-updated dates.",
+  author_schema_depth: "Add Person schema for authors with credentials and sameAs links.",
+  schema_markup: "Implement JSON-LD structured data on key pages.",
+  semantic_html: "Use semantic HTML5 elements (main, article, nav, header, footer).",
+  clean_html: "Fix HTML structure, add meta tags, and ensure HTTPS.",
+  visible_date_signal: "Display dates using <time> elements and add datePublished to JSON-LD.",
+  extraction_friction: "Shorten sentences, use active voice, and avoid jargon in lead paragraphs.",
+  image_context_ai: "Wrap images in <figure>/<figcaption> with descriptive alt text.",
+  schema_coverage: "Extend structured data to inner pages (articles, services, products).",
+  speakable_schema: "Add SpeakableSpecification schema for voice assistant compatibility.",
+  content_cannibalization: "Consolidate overlapping pages or differentiate titles and H1 headings.",
+  llms_txt: "Create a /llms.txt file describing your site for AI engines.",
+  robots_txt: "Update robots.txt to explicitly allow AI crawlers.",
+  content_velocity: "Establish a regular publishing cadence with dated sitemap entries.",
+  content_licensing: "Create /ai.txt to declare AI usage permissions.",
+  canonical_url: 'Add rel="canonical" tags to all pages.',
+  sitemap_completeness: "Generate a comprehensive sitemap.xml with lastmod dates.",
+  rss_feed: "Add an RSS feed linked from your homepage."
+};
+var CRITERION_PILLAR_MAP = {};
+for (const [pillar, criteria] of Object.entries(PILLARS)) {
+  for (const c of criteria) {
+    CRITERION_PILLAR_MAP[c] = pillar;
+  }
+}
+function getCriterionPillar(criterionId) {
+  return CRITERION_PILLAR_MAP[criterionId] || "Unknown";
+}
+function computePillarScores(criteria) {
+  const criteriaMap = new Map(criteria.map((c) => [c.criterion, c]));
+  function pillarScore(pillarCriteria) {
+    let totalWeight = 0;
+    let weightedSum = 0;
+    for (const id of pillarCriteria) {
+      const c = criteriaMap.get(id);
+      const weight = PILLAR_WEIGHTS[id] ?? 0.02;
+      if (c) {
+        weightedSum += c.score / 10 * weight * 100;
+        totalWeight += weight;
+      }
+    }
+    return totalWeight === 0 ? 0 : Math.round(weightedSum / totalWeight);
+  }
+  return {
+    answerReadiness: pillarScore(PILLARS["Answer Readiness"]),
+    contentStructure: pillarScore(PILLARS["Content Structure"]),
+    trustAuthority: pillarScore(PILLARS["Trust & Authority"]),
+    technicalFoundation: pillarScore(PILLARS["Technical Foundation"]),
+    aiDiscovery: pillarScore(PILLARS["AI Discovery"])
+  };
+}
+function computeTopFixes(criteria, count = 3) {
+  const fixes = [];
+  for (const c of criteria) {
+    if (c.score >= 8) continue;
+    const weight = PILLAR_WEIGHTS[c.criterion] ?? 0.02;
+    const impactPoints = Math.round((10 - c.score) * weight * 100);
+    if (impactPoints <= 0) continue;
+    fixes.push({
+      criterion: c.criterion,
+      clientName: CLIENT_NAMES[c.criterion] || c.criterion_label,
+      description: FIX_DESCRIPTIONS[c.criterion] || `Improve ${c.criterion_label}`,
+      impactPoints,
+      effort: CRITERION_EFFORT[c.criterion] || "Medium"
+    });
+  }
+  fixes.sort((a, b) => b.impactPoints - a.impactPoints);
+  return fixes.slice(0, count);
+}
+
 // src/scorecard-builder.ts
 var CRITERION_LABELS = {
   "llms.txt File": "llms.txt File",
@@ -2190,7 +2964,13 @@ var CRITERION_LABELS = {
   "Content Cannibalization": "Content Cannibalization",
   "Visible Date Signal": "Visible Date Signal",
   "Topic Coherence": "Topic Coherence",
-  "Content Depth": "Content Depth"
+  "Content Depth": "Content Depth",
+  "Citation-Ready Writing Quality": "Citation-Ready Writing Quality",
+  "Answer-First Placement": "Answer-First Placement",
+  "Evidence Packaging": "Evidence Packaging",
+  "Entity Disambiguation": "Entity Disambiguation",
+  "Extraction Friction Score": "Extraction Friction Score",
+  "Image Context for AI": "Image Context for AI"
 };
 function scoreToStatus(score) {
   if (score === 0) return "MISSING";
@@ -2239,7 +3019,10 @@ function buildScorecard(results) {
       criterion: label,
       score: r.score,
       status: scoreToStatus(r.score),
-      keyFindings
+      keyFindings,
+      pillar: getCriterionPillar(r.criterion),
+      clientName: CLIENT_NAMES[r.criterion] || label,
+      weight: WEIGHTS[r.criterion]
     };
   });
 }
@@ -2306,7 +3089,14 @@ var CRITERION_WEIGHTS = {
   canonical_url: 0.01,
   rss_feed: 0.01,
   schema_coverage: 0.01,
-  speakable_schema: 0.01
+  speakable_schema: 0.01,
+  // V2 Criteria (~15%)
+  citation_ready_writing: 0.04,
+  answer_first_placement: 0.03,
+  evidence_packaging: 0.03,
+  entity_disambiguation: 0.02,
+  extraction_friction: 0.02,
+  image_context_ai: 0.01
 };
 var OPPORTUNITY_TEMPLATES = {
   llms_txt: {
@@ -2448,6 +3238,36 @@ var OPPORTUNITY_TEMPLATES = {
     name: "Increase Content Depth",
     effort: "Medium",
     description: "Expand articles to 1000+ words with structured H2/H3 sections, comparison tables, and expert analysis. Thin content (under 300 words) is rarely cited by AI engines. Deep, well-structured articles demonstrate expertise."
+  },
+  citation_ready_writing: {
+    name: "Improve Citation-Ready Writing",
+    effort: "Medium",
+    description: 'Write self-contained definition sentences and single-claim statements that AI engines can quote directly. Avoid pronouns like "this" or "that" at the start of answer paragraphs.'
+  },
+  answer_first_placement: {
+    name: "Add Answer-First Placement",
+    effort: "Medium",
+    description: 'Place a concise 40-80 word answer block in the first 300 words of each page. Avoid throat-clearing openers like "In this article..." and lead with the answer.'
+  },
+  evidence_packaging: {
+    name: "Package Evidence for AI",
+    effort: "Medium",
+    description: 'Add inline citations to external sources, "According to [Source]..." attribution phrases, and a Sources section at the end of key articles.'
+  },
+  entity_disambiguation: {
+    name: "Add Entity Disambiguation",
+    effort: "Medium",
+    description: 'Define the primary entity in the first 500 characters, use consistent terminology (same term 70%+), and add "unlike X" signals to help AI engines distinguish your topics.'
+  },
+  extraction_friction: {
+    name: "Reduce Extraction Friction",
+    effort: "Medium",
+    description: "Shorten sentences to under 25 words, use active voice in lead paragraphs, define jargon inline, and avoid hiding content behind accordions or display:none."
+  },
+  image_context_ai: {
+    name: "Add Image Context for AI",
+    effort: "Low",
+    description: 'Wrap images in <figure> elements with descriptive <figcaption> tags. Write alt text with 5+ words that describes the image content, not just "image" or "photo".'
   }
 };
 function calculateImpact(score, weight, effort) {
@@ -2569,8 +3389,8 @@ function generatePitchNumbers(score, rawData, scorecard) {
   const passing = scorecard.filter((s) => s.score >= 7).length;
   metrics.push({
     metric: "Criteria Passing",
-    value: `${passing}/28`,
-    significance: passing >= 18 ? "Excellent coverage across AEO dimensions" : passing >= 12 ? "Good foundation with room to improve remaining criteria" : `${26 - passing} criteria need attention for full AI visibility`
+    value: `${passing}/${scorecard.length}`,
+    significance: passing >= 18 ? "Excellent coverage across AEO dimensions" : passing >= 12 ? "Good foundation with room to improve remaining criteria" : `${scorecard.length - passing} criteria need attention for full AI visibility`
   });
   return metrics;
 }
@@ -2819,7 +3639,14 @@ var PAGE_CRITERIA = {
   semantic_html: { weight: 0.02, label: "Semantic HTML5 & Accessibility" },
   clean_html: { weight: 0.02, label: "Clean, Crawlable HTML" },
   // Technical Plumbing
-  canonical_url: { weight: 0.01, label: "Canonical URL Strategy" }
+  canonical_url: { weight: 0.01, label: "Canonical URL Strategy" },
+  // V2 Criteria
+  citation_ready_writing: { weight: 0.04, label: "Citation-Ready Writing Quality" },
+  answer_first_placement: { weight: 0.03, label: "Answer-First Placement" },
+  evidence_packaging: { weight: 0.03, label: "Evidence Packaging" },
+  entity_disambiguation: { weight: 0.02, label: "Entity Disambiguation" },
+  extraction_friction: { weight: 0.02, label: "Extraction Friction Score" },
+  image_context_ai: { weight: 0.01, label: "Image Context for AI" }
 };
 function extractJsonLdBlocks(html) {
   const blocks = [];
@@ -3106,6 +3933,168 @@ function scoreVisibleDateSignal(html) {
   }
   return cap(score, 10);
 }
+function scoreCitationReadyWriting(html) {
+  let score = 0;
+  const text = getTextContent(html);
+  const defSentences = text.match(/\b\w+\s+(is\s+(?:a|an)\s|refers\s+to|defined\s+as)\b/gi) || [];
+  if (defSentences.length >= 3) score += 3;
+  else if (defSentences.length >= 1) score += 1;
+  const sentences = text.split(/[.!?]+/).filter((s) => s.trim().length > 10);
+  const oneClaimSentences = sentences.filter((s) => {
+    const words = s.trim().split(/\s+/);
+    return words.length < 30 && !/,\s*(and|but|or|which|that|because|although|while)\s/i.test(s);
+  });
+  if (oneClaimSentences.length >= 5) score += 3;
+  else if (oneClaimSentences.length >= 2) score += 1;
+  const qHeadings = extractQuestionHeadings2(html);
+  if (qHeadings.length > 0) {
+    let selfContained = 0;
+    for (const qh of qHeadings) {
+      const escaped = qh.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      const pat = new RegExp(escaped + "[\\s\\S]{0,200}?<\\/h[23]>\\s*<p[^>]*>([^<]{0,200})", "i");
+      const m = pat.exec(html);
+      if (m && m[1] && !/^\s*(this|that|these|those|it)\s/i.test(m[1].trim())) {
+        selfContained++;
+      }
+    }
+    if (selfContained / qHeadings.length >= 0.8) score += 2;
+  }
+  const quotableLines = sentences.filter(
+    (s) => /\d+(\.\d+)?%|\$[\d,.]+|\b\d{1,3}(,\d{3})+\b/.test(s) && /\b[A-Z][a-z]+(?:\s+[A-Z][a-z]+)*\b/.test(s)
+  );
+  if (quotableLines.length >= 2) score += 2;
+  else if (quotableLines.length >= 1) score += 1;
+  return cap(score, 10);
+}
+function scoreAnswerFirstPlacement(html) {
+  let score = 0;
+  const bodyMatch = html.match(/<body[^>]*>([\s\S]*)/i);
+  const bodyHtml = bodyMatch ? bodyMatch[1] : html;
+  const bodyText = bodyHtml.replace(/<[^>]*>/g, " ").replace(/\s+/g, " ").trim();
+  const earlyParagraphs = bodyHtml.match(/<p[^>]*>([\s\S]*?)<\/p>/gi)?.slice(0, 5) || [];
+  const first300Words = bodyText.split(/\s+/).slice(0, 300).join(" ");
+  for (const p of earlyParagraphs) {
+    const pText = p.replace(/<[^>]*>/g, "").trim();
+    const wordCount = pText.split(/\s+/).length;
+    if (wordCount >= 40 && wordCount <= 80 && first300Words.includes(pText.slice(0, 50))) {
+      score += 4;
+      break;
+    }
+  }
+  const firstPara = bodyHtml.match(/<p[^>]*>([\s\S]*?)<\/p>/i);
+  if (firstPara) {
+    const firstParaText = firstPara[1].replace(/<[^>]*>/g, "").trim();
+    if (!/^(In today|Welcome to|Have you ever|If you're looking|In this (article|post|guide))/i.test(firstParaText)) {
+      score += 3;
+    }
+  }
+  const h1Match = html.match(/<h1[^>]*>([\s\S]*?)<\/h1>/i);
+  if (h1Match) {
+    const h1Text = h1Match[1].replace(/<[^>]*>/g, "").trim();
+    const h1Words = h1Text.split(/\s+/).filter((w) => w.length > 3);
+    const firstSentence = bodyText.split(/[.!?]/)[0] || "";
+    if (h1Words.some((w) => firstSentence.toLowerCase().includes(w.toLowerCase()))) {
+      score += 3;
+    }
+  }
+  return cap(score, 10);
+}
+function scoreEvidencePackaging(html) {
+  let score = 0;
+  const text = getTextContent(html);
+  const paragraphs = html.match(/<p[^>]*>[\s\S]*?<\/p>/gi) || [];
+  let inlineCitations = 0;
+  for (const p of paragraphs) {
+    const links = p.match(/<a[^>]*href=["'](https?:\/\/[^"']+)["'][^>]*>/gi) || [];
+    inlineCitations += links.length;
+  }
+  if (inlineCitations >= 3) score += 3;
+  else if (inlineCitations >= 1) score += 1;
+  if (/<h[2-4][^>]*>[^<]*(source|reference|citation|bibliography)[^<]*<\/h[2-4]>/i.test(html)) {
+    score += 2;
+  }
+  const attributionPhrases = text.match(/\baccording\s+to\s+[A-Z]|\b[A-Z][a-z]+\s+(found|says|reports|notes|states)\b/gi) || [];
+  if (attributionPhrases.length >= 3) score += 3;
+  else if (attributionPhrases.length >= 1) score += 1;
+  const sourcedStats = text.match(/\d+(\.\d+)?(%|\s*(million|billion|thousand|percent))\b[^.]*\b[A-Z][a-z]+\b/gi) || [];
+  if (sourcedStats.length >= 2) score += 2;
+  else if (sourcedStats.length >= 1) score += 1;
+  return cap(score, 10);
+}
+function scoreEntityDisambiguation(html) {
+  let score = 0;
+  const text = getTextContent(html);
+  const h1Match = html.match(/<h1[^>]*>([\s\S]*?)<\/h1>/i);
+  if (!h1Match) return 3;
+  const h1Text = h1Match[1].replace(/<[^>]*>/g, "").trim();
+  const h1Words = h1Text.split(/\s+/).filter((w) => w.length > 3);
+  const primaryNoun = h1Words.sort((a, b) => b.length - a.length)[0] || "";
+  if (!primaryNoun) return 3;
+  const first500 = text.slice(0, 500);
+  if (new RegExp(`\\b${primaryNoun.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b[^.]*\\b(is|refers|defined|means)\\b`, "i").test(first500)) {
+    score += 4;
+  }
+  const primaryRegex = new RegExp(`\\b${primaryNoun.toLowerCase().replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`, "gi");
+  const mentions = text.match(primaryRegex) || [];
+  if (mentions.length >= 3) score += 3;
+  else if (mentions.length >= 1) score += 1;
+  if (/\bunlike\s+\w/i.test(text) || /\bcompared\s+to\s+\w/i.test(text) || /\bnot\s+to\s+be\s+confused\s+with\b/i.test(text)) {
+    score += 3;
+  }
+  return cap(score, 10);
+}
+function scoreExtractionFriction(html) {
+  let score = 0;
+  const text = getTextContent(html);
+  const sentences = text.split(/[.!?]+/).filter((s) => s.trim().length > 5);
+  const avgLen = sentences.length > 0 ? sentences.map((s) => s.trim().split(/\s+/).length).reduce((a, b) => a + b, 0) / sentences.length : 0;
+  if (avgLen > 0 && avgLen < 20) score += 3;
+  else if (avgLen >= 20 && avgLen <= 25) score += 2;
+  else if (avgLen > 25 && avgLen <= 35) score += 1;
+  const h1Match = html.match(/<h1[^>]*>[\s\S]*?<\/h1>/i);
+  if (h1Match) {
+    const afterH1 = html.slice(html.indexOf(h1Match[0]) + h1Match[0].length);
+    const leadParas = afterH1.match(/<p[^>]*>([\s\S]*?)<\/p>/gi)?.slice(0, 3) || [];
+    const leadText = leadParas.map((p) => p.replace(/<[^>]*>/g, "")).join(" ").trim();
+    const words = leadText.split(/\s+/).length;
+    if (words <= 75 && words > 10 && !/\([^)]+\)/.test(leadText)) {
+      score += 3;
+    }
+  }
+  const first500Words = text.split(/\s+/).slice(0, 500).join(" ");
+  const longWords = first500Words.match(/\b[a-z]{10,}\b/gi) || [];
+  if (longWords.length <= 2) score += 2;
+  else if (longWords.length <= 5) score += 1;
+  if (/display\s*:\s*none|visibility\s*:\s*hidden/i.test(html) && /<(div|section|p)[^>]*(?:style=["'][^"']*display\s*:\s*none|hidden)[^>]*>/i.test(html)) {
+    score = Math.max(0, score - 2);
+  }
+  return cap(score, 10);
+}
+function scoreImageContextAI(html) {
+  let score = 0;
+  const allImages = html.match(/<img\s[^>]*>/gi) || [];
+  if (allImages.length === 0) return 5;
+  const figureBlocks = html.match(/<figure[\s\S]*?<\/figure>/gi) || [];
+  const figuresWithCaption = figureBlocks.filter((f) => /<figcaption/i.test(f));
+  const figureRatio = figuresWithCaption.length / allImages.length;
+  if (figureRatio >= 0.5) score += 4;
+  else if (figureRatio >= 0.25) score += 2;
+  let goodAltCount = 0;
+  for (const img of allImages) {
+    const altMatch = img.match(/\salt=["']([^"']+)["']/i);
+    if (altMatch) {
+      const altText = altMatch[1].trim();
+      if (altText.split(/\s+/).length > 5 && !/^(image|photo|picture|img|icon|logo|banner|screenshot)$/i.test(altText)) {
+        goodAltCount++;
+      }
+    }
+  }
+  if (goodAltCount / allImages.length >= 0.5) score += 3;
+  else if (goodAltCount > 0) score += 1;
+  const contextualImages = html.match(/<(article|section)[^>]*>[\s\S]*?<img[^>]*>[\s\S]*?<\/\1>/gi) || [];
+  if (contextualImages.length > 0) score += 3;
+  return cap(score, 10);
+}
 var SCORING_FUNCTIONS = {
   schema_markup: scoreSchemaMarkup,
   qa_content_format: scoreQAFormat,
@@ -3120,7 +4109,13 @@ var SCORING_FUNCTIONS = {
   fact_density: scoreFactDensity,
   definition_patterns: scoreDefinitionPatterns,
   canonical_url: scoreCanonicalUrl,
-  visible_date_signal: scoreVisibleDateSignal
+  visible_date_signal: scoreVisibleDateSignal,
+  citation_ready_writing: scoreCitationReadyWriting,
+  answer_first_placement: scoreAnswerFirstPlacement,
+  evidence_packaging: scoreEvidencePackaging,
+  entity_disambiguation: scoreEntityDisambiguation,
+  extraction_friction: scoreExtractionFriction,
+  image_context_ai: scoreImageContextAI
 };
 function scorePage(html, url) {
   let totalWeight = 0;
@@ -3133,8 +4128,10 @@ function scorePage(html, url) {
     weightedSum += score / 10 * weight * 100;
     totalWeight += weight;
   }
-  const aeoScore = totalWeight === 0 ? 0 : Math.round(weightedSum / totalWeight);
-  return { aeoScore, criterionScores };
+  let aeoScore = totalWeight === 0 ? 0 : Math.round(weightedSum / totalWeight);
+  const scoreCapped = aeoScore > 75;
+  if (scoreCapped) aeoScore = 75;
+  return { aeoScore, criterionScores, scoreCapped };
 }
 function scoreAllPages(siteData) {
   const results = [];
@@ -3191,7 +4188,7 @@ function checkNoH1(html) {
 function checkMultipleH1(html) {
   const h1Matches = html.match(/<h1[\s>]/gi);
   if (h1Matches && h1Matches.length > 1) {
-    return { check: "multiple-h1", label: `Multiple <h1> tags (${h1Matches.length})`, severity: "warning" };
+    return { check: "multiple-h1", label: `Multiple <h1> tags (${h1Matches.length})`, severity: "error" };
   }
   return null;
 }
@@ -3307,6 +4304,50 @@ function checkHasQuestionHeadings(html) {
   }
   return null;
 }
+function checkNoAnswerBlock(html) {
+  const bodyMatch = html.match(/<body[^>]*>([\s\S]*)/i);
+  const bodyHtml = bodyMatch ? bodyMatch[1] : html;
+  const earlyParagraphs = bodyHtml.match(/<p[^>]*>([\s\S]*?)<\/p>/gi)?.slice(0, 5) || [];
+  const bodyText = bodyHtml.replace(/<[^>]*>/g, " ").replace(/\s+/g, " ").trim();
+  const first300Words = bodyText.split(/\s+/).slice(0, 300).join(" ");
+  for (const p of earlyParagraphs) {
+    const pText = p.replace(/<[^>]*>/g, "").trim();
+    const wordCount = pText.split(/\s+/).length;
+    if (wordCount >= 40 && wordCount <= 80 && first300Words.includes(pText.slice(0, 50))) {
+      return null;
+    }
+  }
+  return { check: "no-answer-block", label: "No short answer block (40-80 words) in first 300 words", severity: "warning" };
+}
+function checkNoEvidence(html, url) {
+  const text = getTextContent2(html);
+  const paragraphs = html.match(/<p[^>]*>[\s\S]*?<\/p>/gi) || [];
+  let inlineCitations = 0;
+  for (const p of paragraphs) {
+    const links = p.match(/<a[^>]*href=["'](https?:\/\/[^"']+)["'][^>]*>/gi) || [];
+    inlineCitations += links.length;
+  }
+  const attributionPhrases = text.match(/\baccording\s+to\s+[A-Z]|\b[A-Z][a-z]+\s+(found|says|reports|notes|states)\b/gi) || [];
+  if (inlineCitations === 0 && attributionPhrases.length === 0) {
+    return { check: "no-evidence", label: "No inline citations or attribution phrases", severity: "warning" };
+  }
+  return null;
+}
+function checkHasCitationReadyContent(html) {
+  const text = getTextContent2(html);
+  const sentences = text.split(/[.!?]+/).filter((s) => s.trim().length > 10);
+  let quotable = 0;
+  for (const s of sentences) {
+    const hasData = /\d+(\.\d+)?%|\$[\d,.]+|\b\d{1,3}(,\d{3})+\b/.test(s);
+    const hasSource = /\b[A-Z][a-z]+(?:\s+[A-Z][a-z]+)*\b/.test(s);
+    const isShort = s.trim().split(/\s+/).length < 30;
+    if (hasData && hasSource && isShort) quotable++;
+  }
+  if (quotable >= 3) {
+    return { check: "has-citation-ready-content", label: `${quotable} citation-ready sentences with data and sources`, severity: "info" };
+  }
+  return null;
+}
 function analyzePage(html, url, category) {
   const title = extractTitle(html);
   const textContent = getTextContent2(html);
@@ -3323,14 +4364,17 @@ function analyzePage(html, url, category) {
     checkMissingOgTags(html),
     checkThinContent(wordCount),
     checkImagesMissingAlt(html),
-    checkNoInternalLinks(html, url)
+    checkNoInternalLinks(html, url),
+    checkNoAnswerBlock(html),
+    checkNoEvidence(html, url)
   ];
   for (const result of issueChecks) {
     if (result) issues.push(result);
   }
   const strengthChecks = [
     checkHasStructuredData(html),
-    checkHasQuestionHeadings(html)
+    checkHasQuestionHeadings(html),
+    checkHasCitationReadyContent(html)
   ];
   for (const result of strengthChecks) {
     if (result) strengths.push(result);
@@ -3619,7 +4663,14 @@ var CRITERION_WEIGHTS2 = {
   canonical_url: 0.01,
   rss_feed: 0.01,
   schema_coverage: 0.01,
-  speakable_schema: 0.01
+  speakable_schema: 0.01,
+  // V2 Criteria (~15%)
+  citation_ready_writing: 0.04,
+  answer_first_placement: 0.03,
+  evidence_packaging: 0.03,
+  entity_disambiguation: 0.02,
+  extraction_friction: 0.02,
+  image_context_ai: 0.01
 };
 var PHASE_CONFIG = [
   {
@@ -3644,7 +4695,11 @@ var PHASE_CONFIG = [
       "query_answer_alignment",
       "visible_date_signal",
       "topic_coherence",
-      "content_depth"
+      "content_depth",
+      "citation_ready_writing",
+      "answer_first_placement",
+      "evidence_packaging",
+      "entity_disambiguation"
     ]
   },
   {
@@ -3658,7 +4713,9 @@ var PHASE_CONFIG = [
       "author_schema_depth",
       "content_licensing",
       "entity_consistency",
-      "semantic_html"
+      "semantic_html",
+      "image_context_ai",
+      "extraction_friction"
     ]
   },
   {
@@ -4597,6 +5654,160 @@ Summarization: yes`,
       affectedPages: affected,
       pageCount: affected?.length
     }];
+  },
+  citation_ready_writing: (c, pages) => {
+    if (c.score >= 10) return [];
+    const impact = impactFromScore(c.score);
+    const effort = effortForCriterion("citation_ready_writing", c.score);
+    const affected = getAffectedPages("citation_ready_writing", pages);
+    return [{
+      id: `fix-${c.criterion}`,
+      criterion: c.criterion_label,
+      criterionId: c.criterion,
+      title: "Improve citation-ready writing quality",
+      description: "Write self-contained definition sentences and single-claim statements that AI engines can quote directly.",
+      impact,
+      effort,
+      impactScore: 0,
+      category: "content",
+      steps: [
+        'Write "X is a..." definition sentences for key concepts',
+        "Keep sentences under 30 words with a single claim each",
+        'Start answer paragraphs with the entity name, not "This" or "That"',
+        "Pair statistics with named sources for quotable lines"
+      ],
+      successCriteria: "Average 3+ definition sentences and 5+ single-claim sentences per page",
+      affectedPages: affected,
+      pageCount: affected?.length
+    }];
+  },
+  answer_first_placement: (c, pages) => {
+    if (c.score >= 10) return [];
+    const impact = impactFromScore(c.score);
+    const effort = effortForCriterion("answer_first_placement", c.score);
+    const affected = getAffectedPages("answer_first_placement", pages);
+    return [{
+      id: `fix-${c.criterion}`,
+      criterion: c.criterion_label,
+      criterionId: c.criterion,
+      title: "Add answer-first content placement",
+      description: "Place a concise answer block in the first 300 words of each page.",
+      impact,
+      effort,
+      impactScore: 0,
+      category: "content",
+      steps: [
+        "Add a 40-80 word answer paragraph within the first 300 words",
+        'Replace "In this article..." openers with direct answers',
+        "Include the H1 topic entity in the first body sentence"
+      ],
+      successCriteria: "70%+ of pages have an answer block in the first 300 words",
+      affectedPages: affected,
+      pageCount: affected?.length
+    }];
+  },
+  evidence_packaging: (c, pages) => {
+    if (c.score >= 10) return [];
+    const impact = impactFromScore(c.score);
+    const effort = effortForCriterion("evidence_packaging", c.score);
+    const affected = getAffectedPages("evidence_packaging", pages);
+    return [{
+      id: `fix-${c.criterion}`,
+      criterion: c.criterion_label,
+      criterionId: c.criterion,
+      title: "Package evidence for AI engines",
+      description: "Add inline citations, attribution phrases, and sources sections.",
+      impact,
+      effort,
+      impactScore: 0,
+      category: "content",
+      steps: [
+        "Add inline links to authoritative external sources within paragraphs",
+        'Use "According to [Source]..." attribution phrases',
+        'Add a "Sources" or "References" heading at the end of articles',
+        "Pair statistics with named source organizations"
+      ],
+      successCriteria: "Average 3+ inline citations and 3+ attribution phrases per page",
+      affectedPages: affected,
+      pageCount: affected?.length
+    }];
+  },
+  entity_disambiguation: (c, pages) => {
+    if (c.score >= 10) return [];
+    const impact = impactFromScore(c.score);
+    const effort = effortForCriterion("entity_disambiguation", c.score);
+    const affected = getAffectedPages("entity_disambiguation", pages);
+    return [{
+      id: `fix-${c.criterion}`,
+      criterion: c.criterion_label,
+      criterionId: c.criterion,
+      title: "Clarify entity boundaries",
+      description: "Define the primary entity early and use consistent terminology.",
+      impact,
+      effort,
+      impactScore: 0,
+      category: "content",
+      steps: [
+        "Define the primary entity within the first 500 characters",
+        "Use the same primary term consistently (avoid synonym soup)",
+        'Add "unlike X" or "compared to Y" disambiguation signals'
+      ],
+      successCriteria: "70%+ of pages define the primary entity early with consistent terminology",
+      affectedPages: affected,
+      pageCount: affected?.length
+    }];
+  },
+  extraction_friction: (c, pages) => {
+    if (c.score >= 10) return [];
+    const impact = impactFromScore(c.score);
+    const effort = effortForCriterion("extraction_friction", c.score);
+    const affected = getAffectedPages("extraction_friction", pages);
+    return [{
+      id: `fix-${c.criterion}`,
+      criterion: c.criterion_label,
+      criterionId: c.criterion,
+      title: "Reduce extraction friction",
+      description: "Make content easier for AI engines to extract by reducing sentence length and jargon.",
+      impact,
+      effort,
+      impactScore: 0,
+      category: "structure",
+      steps: [
+        "Shorten sentences to under 25 words on average",
+        "Use active voice in lead paragraphs (first 2-3 sentences)",
+        "Define jargon inline when first used",
+        "Remove display:none hidden content and accordion-only content"
+      ],
+      successCriteria: "Average sentence length under 25 words with no hidden content",
+      affectedPages: affected,
+      pageCount: affected?.length
+    }];
+  },
+  image_context_ai: (c, pages) => {
+    if (c.score >= 10) return [];
+    const impact = impactFromScore(c.score);
+    const effort = effortForCriterion("image_context_ai", c.score);
+    const affected = getAffectedPages("image_context_ai", pages);
+    return [{
+      id: `fix-${c.criterion}`,
+      criterion: c.criterion_label,
+      criterionId: c.criterion,
+      title: "Add image context for AI engines",
+      description: "Wrap images in <figure>/<figcaption> with descriptive alt text.",
+      impact,
+      effort,
+      impactScore: 0,
+      category: "trust",
+      steps: [
+        "Wrap images in <figure> elements with descriptive <figcaption>",
+        'Write alt text with 5+ descriptive words (avoid "image" or "photo")',
+        "Place images within <article> or <section> elements"
+      ],
+      codeExample: '<figure>\n  <img src="chart.png" alt="Bar chart showing 45% reduction in fall risk for walker users">\n  <figcaption>Walker users experienced a 45% reduction in fall risk (2025 study)</figcaption>\n</figure>',
+      successCriteria: "50%+ of images use <figure>/<figcaption> with descriptive alt text",
+      affectedPages: affected,
+      pageCount: affected?.length
+    }];
   }
 };
 function generateFixPlan(domain, overallScore, criteria, pagesReviewed, linkGraph) {
@@ -4838,7 +6049,7 @@ async function audit(domain, options) {
     }
   }
   if (options?.fullCrawl) {
-    const { crawlFullSite: crawlFullSite2 } = await import("./full-site-crawler-UIOMKOZA.js");
+    const { crawlFullSite: crawlFullSite2 } = await import("./full-site-crawler-BCJS67WQ.js");
     const crawlResult = await crawlFullSite2(siteData, {
       maxPages: options.maxPages ?? 200,
       concurrency: options.concurrency ?? 5
@@ -4857,6 +6068,10 @@ async function audit(domain, options) {
   const overallScore = calculateOverallScore(results);
   const rawData = extractRawDataSummary(siteData);
   if (renderedWithHeadless) rawData.rendered_with_headless = true;
+  const pillarScores = computePillarScores(results);
+  const topFixesRaw = computeTopFixes(results, 3);
+  const coherenceResult = results.find((r) => r.criterion === "topic_coherence");
+  const coherenceGated = !!(coherenceResult && coherenceResult.score < 6);
   const scorecard = buildScorecard(results);
   const detailedFindings = buildDetailedFindings(results);
   const verdict = generateVerdict(overallScore, scorecard, rawData, domain);
@@ -4878,6 +6093,10 @@ async function audit(domain, options) {
     pitchNumbers,
     bottomLine,
     pagesReviewed,
+    pillarScores,
+    coherenceGated,
+    criteriaScored: results.length,
+    topFixes: topFixesRaw.map((f) => ({ fix: f.clientName, impact: `+${f.impactPoints} pts`, effort: f.effort })),
     elapsed,
     ...renderedWithHeadless && { renderedWithHeadless: true }
   };
@@ -4924,7 +6143,10 @@ async function compare(domainA, domainB, options) {
   };
 }
 export {
+  CLIENT_NAMES,
   CRITERION_LABELS,
+  PILLARS,
+  WEIGHTS,
   analyzeAllPages,
   analyzePage,
   auditSite,
@@ -4934,6 +6156,8 @@ export {
   buildScorecard,
   calculateOverallScore,
   compare,
+  computePillarScores,
+  computeTopFixes,
   countRecentSitemapDates,
   crawlFullSite,
   detectParkedDomain,
@@ -4949,9 +6173,16 @@ export {
   generateOpportunities,
   generatePitchNumbers,
   generateVerdict,
+  getCriterionPillar,
   inferCategory,
   prefetchSiteData,
   scoreAllPages,
+  scoreAnswerFirstPlacement,
+  scoreCitationReadyWriting,
+  scoreEntityDisambiguation,
+  scoreEvidencePackaging,
+  scoreExtractionFriction,
+  scoreImageContextAI,
   scorePage,
   scoreToStatus,
   serializeLinkGraph