@forkpoint/agent-lighthouse-core 2.0.0 → 3.1.0

package/dist/index.mjs

@@ -8,6 +8,7 @@ var MAX_CONCURRENT_REQUESTS = 10;
 var SCANNER_USER_AGENT = "AgentLighthouse/1.0 (+https://github.com/ForkPoint/agent-lighthouse)";
 var TAG_SKIPPED_PAGE_TYPE = "skipped:page-type";
 var TAG_SCAN_ERROR = "scan-error";
+var TAG_SKIPPED_NO_EVIDENCE = "skipped:no-evidence";
 var CATEGORY_NAMES = {
   "access-crawl-control": "Access & Crawl Control",
   "content-extraction": "Content Extraction",
@@ -181,8 +182,40 @@ async function isSafeUrl(url) {
     return false;
   }
 }
-function createFetcher() {
+function createGate(limit) {
+  let inFlight = 0;
+  const waiting = [];
+  const release2 = () => {
+    inFlight -= 1;
+    const next = waiting.shift();
+    if (next) next();
+  };
+  return {
+    acquire: async () => {
+      if (inFlight >= limit) {
+        await new Promise((resolve4) => waiting.push(resolve4));
+      }
+      inFlight += 1;
+      return release2;
+    }
+  };
+}
+function boundedDispatcher(connections) {
+  return new Agent({ connections });
+}
+function createFetcher(fetcherOptions = {}) {
+  const dispatcher = fetcherOptions.dispatcher ?? noRedirectAgent;
+  const gate = fetcherOptions.maxConcurrent && fetcherOptions.maxConcurrent > 0 ? createGate(Math.floor(fetcherOptions.maxConcurrent)) : void 0;
   async function fetch(options) {
+    if (!gate) return issue(options);
+    const release2 = await gate.acquire();
+    try {
+      return await issue(options);
+    } finally {
+      release2();
+    }
+  }
+  async function issue(options) {
     const {
       url,
       timeout = REQUEST_TIMEOUT_MS,
@@ -222,10 +255,11 @@ function createFetcher() {
         headers: reqHeaders,
         body: currentBody,
         signal,
-        dispatcher: noRedirectAgent
+        dispatcher
       });
       let gateArmed;
       let hops = 0;
+      const redirectChain = [];
       while (followRedirects && REDIRECT_STATUS.has(response.statusCode) && response.headers["location"] !== void 0 && hops < MAX_REDIRECTS) {
         const rawLocation = response.headers["location"];
         const location = Array.isArray(rawLocation) ? rawLocation[0] : rawLocation;
@@ -261,6 +295,7 @@ function createFetcher() {
           currentMethod = "GET";
           currentBody = void 0;
         }
+        redirectChain.push({ status: response.statusCode, from: currentUrl, to: next });
         currentUrl = next;
         hops += 1;
         response = await request(currentUrl, {
@@ -268,7 +303,7 @@ function createFetcher() {
           headers: reqHeaders,
           body: currentBody,
           signal,
-          dispatcher: noRedirectAgent
+          dispatcher
         });
       }
       ttfbMs = performance.now() - start;
@@ -307,7 +342,8 @@ function createFetcher() {
         totalMs: Math.round(totalMs),
         contentType: headers["content-type"] ?? "",
         contentLength: bytes ? bytes.byteLength : truncatedBody.length,
-        ...bytes ? { bytes } : {}
+        ...bytes ? { bytes } : {},
+        ...redirectChain.length > 0 ? { redirectChain } : {}
       };
     } catch (err) {
       const totalMs = performance.now() - start;
@@ -556,12 +592,23 @@ function extractHeadings($) {
   });
   return headings;
 }
-function getMainContentText($) {
-  const root = $("main").first().length ? $("main").first() : $("body");
+function readableText(root) {
   const clone = root.clone();
   clone.find("script, style, noscript, template").remove();
   return clone.text().replace(/\s+/g, " ").trim();
 }
+function getMainContentText($) {
+  let best = "";
+  $("body").find("main").each((_, el) => {
+    const text3 = readableText($(el));
+    if (text3.length > best.length) best = text3;
+  });
+  if (best) return best;
+  return readableText($("body"));
+}
+function getRenderedText($) {
+  return readableText($("body"));
+}
 function getWordCount($) {
   const text3 = getMainContentText($);
   return text3.split(/\s+/).filter(Boolean).length;
@@ -795,6 +842,12 @@ var DeprecationNoticeSchema = z.object({
 var EvidenceGradeSchema = z.enum(["A", "B", "C", "D"]);
 var AuditTierSchema = z.enum(["scored", "informative", "experimental"]);
 var AUDIT_ID_PATTERN = /^[a-z-]+\/[a-z0-9-]+$/;
+var EvidenceKeySchema = z.enum([
+  "origin-reachable",
+  "unblocked-fetches",
+  "rendered-body",
+  "sample-adequate"
+]);
 var AuditMetaSchema = z.object({
   id: z.string().regex(AUDIT_ID_PATTERN, "audit id must be a `category/slug` path"),
   category: z.string(),
@@ -813,7 +866,10 @@ var AuditMetaSchema = z.object({
   // its weight comes from (grade + tier) and which dossier proves it.
   evidenceGrade: EvidenceGradeSchema,
   tier: AuditTierSchema,
-  dossier: z.string().min(1).max(500)
+  dossier: z.string().min(1).max(500),
+  // What the audit needs the scan to have obtained. Checked against the
+  // source by `scripts/check-requires.mjs`, not enforced here beyond shape.
+  requires: z.array(EvidenceKeySchema).optional()
 });
 var CheckResultSchema = z.object({
   // v2 ids are `category/slug` paths, which outgrew the old 20-char cap.
@@ -1038,6 +1094,210 @@ function calculateOverallScore(categories) {
   if (totalMass === 0) return 0;
   return Math.round(weighted / totalMass);
 }
+var GATED_MASS_UNSCORED_THRESHOLD = 0.35;
+function gatedMassShare(checks2) {
+  let gated = 0;
+  let total = 0;
+  for (const check of checks2) {
+    if (isInformative(check)) continue;
+    const mass = check.weight ?? 0;
+    if (mass <= 0) continue;
+    total += mass;
+    if (check.tags?.includes(TAG_SKIPPED_NO_EVIDENCE)) gated += mass;
+  }
+  return total === 0 ? 0 : gated / total;
+}
+
+// src/gatherers/domains.ts
+var MULTI_SUFFIX = /* @__PURE__ */ new Set([
+  "co.uk",
+  "org.uk",
+  "ac.uk",
+  "gov.uk",
+  "me.uk",
+  "net.uk",
+  "com.au",
+  "net.au",
+  "org.au",
+  "edu.au",
+  "gov.au",
+  "co.nz",
+  "co.jp",
+  "or.jp",
+  "ne.jp",
+  "co.za",
+  "co.kr",
+  "co.il",
+  "co.id",
+  "co.th",
+  "com.br",
+  "com.mx",
+  "com.ar",
+  "com.co",
+  "com.pe",
+  "co.in",
+  "com.sg",
+  "com.tr",
+  "com.cn",
+  "com.hk",
+  "com.tw",
+  "com.my",
+  "com.ph",
+  "com.ua",
+  "com.pl",
+  "com.es",
+  "com.pt",
+  "com.gr"
+]);
+function registrableDomain(host) {
+  const parts = host.toLowerCase().replace(/\.$/, "").split(".").filter(Boolean);
+  if (parts.length <= 2) return parts.join(".");
+  const lastTwo = parts.slice(-2).join(".");
+  return MULTI_SUFFIX.has(lastTwo) ? parts.slice(-3).join(".") : lastTwo;
+}
+function registrableOf(url) {
+  try {
+    return registrableDomain(new URL(url).hostname);
+  } catch {
+    return "";
+  }
+}
+
+// src/scan-evidence.ts
+var ALL_PAGE_TYPES = ["homepage", "category", "product", "content"];
+var HTML_TYPES = ["text/html", "application/xhtml+xml"];
+var PERMANENT_REDIRECT = /* @__PURE__ */ new Set([301, 308]);
+function bareHost(url) {
+  try {
+    return new URL(url).hostname.toLowerCase().replace(/^www\./, "");
+  } catch {
+    return "";
+  }
+}
+function registrableName(url) {
+  const domain = registrableOf(url);
+  if (!domain) return "";
+  const parts = domain.split(".");
+  return parts.length > 1 ? parts.slice(0, -1).join(".") : domain;
+}
+function reachedTheRequestedSite(requestedUrl, result) {
+  const requested = bareHost(requestedUrl);
+  const final = bareHost(result.finalUrl || result.url);
+  if (!final) return { ok: false, reason: `The homepage response carried no usable URL.` };
+  if (requested === final) return { ok: true };
+  const requestedDomain = registrableOf(requestedUrl);
+  const finalDomain = registrableOf(result.finalUrl || result.url);
+  if (requestedDomain && requestedDomain === finalDomain) return { ok: true };
+  const requestedName = registrableName(requestedUrl);
+  if (requestedName && requestedName === registrableName(result.finalUrl || result.url)) {
+    return { ok: true };
+  }
+  const chain = result.redirectChain ?? [];
+  const leaving = chain.filter((hop) => registrableOf(hop.from) !== registrableOf(hop.to));
+  if (leaving.length > 0 && leaving.every((hop) => PERMANENT_REDIRECT.has(hop.status))) {
+    return { ok: true };
+  }
+  return {
+    ok: false,
+    reason: `The requested host redirected to ${final}, a different site, without a permanent redirect.`
+  };
+}
+function originReachable(requestedUrl, result) {
+  if (result.error) {
+    return { met: false, reason: `The homepage could not be fetched: ${result.error}.` };
+  }
+  if (result.status < 200 || result.status > 299) {
+    return { met: false, reason: `The homepage answered HTTP ${result.status}.` };
+  }
+  const type = (result.contentType || "").toLowerCase();
+  if (!HTML_TYPES.some((html) => type.includes(html))) {
+    return {
+      met: false,
+      reason: `The homepage served ${result.contentType || "no content type"}, not HTML.`
+    };
+  }
+  const reached = reachedTheRequestedSite(requestedUrl, result);
+  return reached.ok ? { met: true } : { met: false, reason: reached.reason };
+}
+function unblockedFetches(homepageResult, waf) {
+  if (waf?.isBlocked) {
+    return waf.isRateLimit ? {
+      met: false,
+      reason: `The scan was throttled (${waf.name}): ${waf.reason}.`
+    } : { met: false, reason: `${waf.name} refused the scan: ${waf.reason}.` };
+  }
+  if (homepageResult.status === 429) {
+    return { met: false, reason: "The homepage answered HTTP 429: the scan was throttled." };
+  }
+  return { met: true };
+}
+function pageRendersText(page) {
+  const text3 = getRenderedText(page.$);
+  const wordCount2 = text3.split(/\s+/).filter(Boolean).length;
+  return wordCount2 > 50 || text3.length > 200;
+}
+function buildScanEvidence(input) {
+  const origin = originReachable(input.requestedUrl, input.homepageResult);
+  const unblocked = unblockedFetches(input.homepageResult, input.wafProtection);
+  const renderedByPage = {};
+  const usablePageTypes = /* @__PURE__ */ new Set();
+  for (const page of input.pages) {
+    const rendered = pageRendersText(page);
+    renderedByPage[page.url] = rendered;
+    if (rendered) usablePageTypes.add(page.pageType);
+  }
+  const renderedCount = Object.values(renderedByPage).filter(Boolean).length;
+  const met = {
+    "origin-reachable": origin.met,
+    "unblocked-fetches": unblocked.met,
+    "rendered-body": renderedCount > 0,
+    "sample-adequate": usablePageTypes.size > 0
+  };
+  const reasons = {};
+  if (origin.reason) reasons["origin-reachable"] = origin.reason;
+  if (unblocked.reason) reasons["unblocked-fetches"] = unblocked.reason;
+  if (!met["rendered-body"]) {
+    reasons["rendered-body"] = input.pages.length === 0 ? "The scan fetched no pages." : `None of the ${input.pages.length} fetched page(s) served readable text.`;
+  }
+  if (!met["sample-adequate"]) {
+    reasons["sample-adequate"] = input.pages.length === 0 ? "The scan fetched no pages." : "No fetched page of any type served readable text.";
+  }
+  return {
+    met,
+    reasons,
+    renderedByPage,
+    usablePageTypes,
+    // A shell site was seen. What it serves is a finding about it, so
+    // `rendered-body` and `sample-adequate` do not clear `judgeable`.
+    judgeable: met["origin-reachable"] && met["unblocked-fetches"]
+  };
+}
+function scanReadTheSite(evidence) {
+  return evidence.judgeable;
+}
+function unreadSiteReason(evidence) {
+  return evidence.reasons["origin-reachable"] ?? evidence.reasons["unblocked-fetches"] ?? "The scan obtained no response it could attribute to this site.";
+}
+function scanReadPageText(evidence) {
+  return evidence.met["rendered-body"];
+}
+function unreadPageTextReason(evidence) {
+  return evidence.reasons["rendered-body"] ?? "No fetched page served text a non-JS consumer can read.";
+}
+function allEvidenceMet() {
+  return {
+    met: {
+      "origin-reachable": true,
+      "unblocked-fetches": true,
+      "rendered-body": true,
+      "sample-adequate": true
+    },
+    reasons: {},
+    renderedByPage: {},
+    usablePageTypes: new Set(ALL_PAGE_TYPES),
+    judgeable: true
+  };
+}
 
 // src/audits/access-crawl-control/no-nofollow.ts
 var NoNofollowAudit = class _NoNofollowAudit extends Audit {
@@ -1052,6 +1312,9 @@ var NoNofollowAudit = class _NoNofollowAudit extends Audit {
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/access-crawl-control/no-nofollow.md",
+    // Gate exemption: being refused is what this category reports, and the meta tag and
+    // header this audit reads are served by a page whose body renders nothing.
+    requires: ["origin-reachable"],
     defaultPriority: "high",
     guidance: {
       impact: "A nofollow directive prevents AI crawlers from following links on your pages, effectively hiding all linked content from AI indexing. Your deeper pages become invisible to AI search engines, drastically reducing discoverability.",
@@ -1063,6 +1326,13 @@ var NoNofollowAudit = class _NoNofollowAudit extends Audit {
     }
   };
   audit(ctx) {
+    if (!scanReadTheSite(ctx.evidence)) {
+      return this.notApplicable(
+        "No page here can be attributed to this site, so its nofollow directives were not judged.",
+        "No site-wide nofollow directives",
+        unreadSiteReason(ctx.evidence)
+      );
+    }
     if (ctx.pages.length === 0) {
       return this.fail(
         "No pages scanned.",
@@ -1133,6 +1403,10 @@ var NoRedirectChainsAudit = class _NoRedirectChainsAudit extends Audit {
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/access-crawl-control/no-redirect-chains.md",
+    // Gate exemption: a hop that left the site is this audit's subject, and leaving the
+    // site is exactly what denies `origin-reachable`. It reads request URL against final
+    // URL, which every response carries, and reports "no pages scanned" itself.
+    requires: [],
     defaultPriority: "medium",
     guidance: {
       impact: "Redirect chains slow down AI crawlers and waste their limited crawl budget. Each extra redirect adds latency and increases the chance a crawler gives up before reaching the final page, leaving content unindexed.",
@@ -1143,17 +1417,6 @@ var NoRedirectChainsAudit = class _NoRedirectChainsAudit extends Audit {
     }
   };
   audit(ctx) {
-    if (ctx.pages.length === 0) {
-      return this.fail(
-        "No pages scanned.",
-        "No redirect chains (URL equals finalUrl or single redirect)",
-        "No pages scanned",
-        {
-          priority: "medium",
-          description: _NoRedirectChainsAudit.meta.description
-        }
-      );
-    }
     const redirected = [];
     for (const page of ctx.pages) {
       const requestUrl = page.fetchResult.url;
@@ -1163,6 +1426,24 @@ var NoRedirectChainsAudit = class _NoRedirectChainsAudit extends Audit {
       }
     }
     if (redirected.length === 0) {
+      if (!scanReadTheSite(ctx.evidence)) {
+        return this.notApplicable(
+          "No page here can be attributed to this site, so its redirect behaviour was not judged.",
+          "No redirect chains",
+          unreadSiteReason(ctx.evidence)
+        );
+      }
+      if (ctx.pages.length === 0) {
+        return this.fail(
+          "No pages scanned.",
+          "No redirect chains (URL equals finalUrl or single redirect)",
+          "No pages scanned",
+          {
+            priority: "medium",
+            description: _NoRedirectChainsAudit.meta.description
+          }
+        );
+      }
       return this.pass(
         `All ${ctx.pages.length} page(s) resolve without redirects.`,
         "No redirect chains",
@@ -1278,6 +1559,8 @@ var CanonicalLinksAudit = class extends Audit {
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/access-crawl-control/canonical.md",
+    // Gate exemption: being refused is what this category reports.
+    requires: ["origin-reachable", "rendered-body", "sample-adequate"],
     defaultPriority: "medium",
     guidance: {
       impact: "A canonical pointing at the wrong URL is worse than no canonical at all: when every page canonicalizes onto the homepage \u2014 a common CMS and SPA template bug \u2014 the pages consolidate onto one URL and drop out of the index that AI Overviews and AI Mode draw on. A canonical pointing at another domain hands the attribution there.",
@@ -1290,6 +1573,13 @@ var CanonicalLinksAudit = class extends Audit {
   };
   audit(ctx) {
     const expected = "Each page declares a canonical URL that points at itself";
+    if (!scanReadTheSite(ctx.evidence)) {
+      return this.notApplicable(
+        "No page here can be attributed to this site, so its canonical links were not judged.",
+        expected,
+        unreadSiteReason(ctx.evidence)
+      );
+    }
     if (ctx.pages.length === 0) {
       return this.notApplicable(
         "No pages were scanned, so no canonical links could be read.",
@@ -1726,6 +2016,8 @@ var GptbotAudit = class extends CrawlerBotAudit {
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/access-crawl-control/gptbot.md",
+    // Gate exemption: being refused is what this category reports.
+    requires: ["origin-reachable"],
     defaultPriority: "medium",
     guidance: {
       impact: "Blocking GPTBot prevents your content from being used by OpenAI's models and appearing in ChatGPT responses. Explicitly allowing it signals that your site welcomes AI indexing for the largest AI platform by user base.",
@@ -1756,6 +2048,8 @@ var GoogleExtendedAudit = class extends CrawlerBotAudit {
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/access-crawl-control/google-extended.md",
+    // Gate exemption: being refused is what this category reports.
+    requires: ["origin-reachable"],
     defaultPriority: "medium",
     guidance: {
       impact: "Blocking Google-Extended prevents your content from being used in Google's AI features like Gemini and AI Overviews. Allowing it ensures your site appears in Google's AI-powered search experiences alongside traditional results.",
@@ -1790,6 +2084,8 @@ var AnthropicAudit = class extends CrawlerBotAudit {
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/access-crawl-control/anthropic-ai.md",
+    // Gate exemption: being refused is what this category reports.
+    requires: ["origin-reachable"],
     defaultPriority: "medium",
     guidance: {
       impact: "Disallowing ClaudeBot keeps the site out of the web content Anthropic collects for potential model training. It is an effective, documented control, so it is only a problem where the block was not intended. It buys back very little traffic either way: Cloudflare Radar measures Anthropic's crawl-to-refer ratio at roughly 50,000:1, so the allow-side case is about corpus inclusion rather than referral visibility.",
@@ -1899,6 +2195,8 @@ var PerplexitybotAudit = class extends CrawlerBotAudit {
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/access-crawl-control/perplexitybot.md",
+    // Gate exemption: being refused is what this category reports.
+    requires: ["origin-reachable"],
     defaultPriority: "medium",
     guidance: {
       impact: "Blocking PerplexityBot prevents your content from appearing in Perplexity AI search results, one of the fastest-growing AI answer engines. Allowing it gives your content visibility in AI-native search.",
@@ -1929,6 +2227,8 @@ var ApplebotExtendedAudit = class extends CrawlerBotAudit {
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/access-crawl-control/applebot-extended.md",
+    // Gate exemption: being refused is what this category reports.
+    requires: ["origin-reachable"],
     defaultPriority: "medium",
     guidance: {
       impact: "Blocking Applebot-Extended prevents your content from being used in Apple Intelligence features, Siri AI answers, and Safari Highlights. Allowing it ensures visibility across Apple's AI ecosystem.",
@@ -1959,6 +2259,8 @@ var CcbotAudit = class extends CrawlerBotAudit {
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/access-crawl-control/ccbot.md",
+    // Gate exemption: being refused is what this category reports.
+    requires: ["origin-reachable"],
     defaultPriority: "medium",
     guidance: {
       impact: "Blocking CCBot prevents your content from being included in the Common Crawl dataset, which is a foundational training data source for many AI models. Allowing it broadens your content's reach across multiple AI systems.",
@@ -1990,6 +2292,8 @@ var MetaExternalAgentAudit = class extends CrawlerBotAudit {
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/access-crawl-control/meta-external-agent.md",
+    // Gate exemption: being refused is what this category reports.
+    requires: ["origin-reachable"],
     defaultPriority: "medium",
     guidance: {
       impact: "Disallowing Meta-ExternalAgent keeps the site out of Meta's foundation-model training corpus and out of the direct content indexing that improves Meta products. It is an effective, documented control, so it is only a problem where the block was not intended. It does not by itself govern Meta AI search citations \u2014 Meta documents Meta-WebIndexer as the token behind those.",
@@ -2082,6 +2386,8 @@ var AmazonbotAudit = class extends CrawlerBotAudit {
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/access-crawl-control/amazonbot.md",
+    // Gate exemption: being refused is what this category reports.
+    requires: ["origin-reachable"],
     defaultPriority: "medium",
     guidance: {
       impact: "Blocking Amazonbot prevents your content from appearing in Alexa AI answers and Amazon's AI-powered search features. Allowing it gives your content visibility in Amazon's voice and commerce AI ecosystem.",
@@ -2156,6 +2462,8 @@ var AiBotDirectivesAudit = class extends Audit {
     evidenceGrade: "B",
     tier: "scored",
     dossier: "docs/evidence/audits/access-crawl-control/ai-bot-directives.md",
+    // Gate exemption: being refused is what this category reports.
+    requires: ["origin-reachable"],
     defaultPriority: "medium",
     guidance: {
       impact: "Blocking YouBot removes the site from You.com's live search index; blocking AI2Bot removes it from the Allen Institute's open training corpora while leaving closed commercial crawlers untouched. Leaving either to the wildcard rule means the policy silently flips the day a blanket block is added. The other three tokens carry no comparable consumer, so this audit never penalises blocking them.",
@@ -2222,6 +2530,8 @@ var ChatgptUserAudit = class extends CrawlerBotAudit {
     evidenceGrade: "C",
     tier: "informative",
     dossier: "docs/evidence/audits/access-crawl-control/chatgpt-user.md",
+    // Gate exemption: being refused is what this category reports.
+    requires: ["origin-reachable"],
     defaultPriority: "medium",
     guidance: {
       impact: "Blocking ChatGPT-User prevents ChatGPT from browsing your site in real-time when users ask it to visit your pages. This blocks your content from being cited in ChatGPT Browse conversations, losing a significant source of AI-driven traffic.",
@@ -2252,6 +2562,8 @@ var ClaudeUserAudit = class extends CrawlerBotAudit {
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/access-crawl-control/claude-user.md",
+    // Gate exemption: being refused is what this category reports.
+    requires: ["origin-reachable"],
     defaultPriority: "medium",
     guidance: {
       impact: "Blocking Claude-User prevents Claude from browsing your site in real-time when users ask it to visit your pages. This blocks your content from being cited in Claude conversations with web access enabled.",
@@ -2281,6 +2593,8 @@ var OaiSearchbotAudit = class extends CrawlerBotAudit {
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/access-crawl-control/oai-searchbot.md",
+    // Gate exemption: being refused is what this category reports.
+    requires: ["origin-reachable"],
     defaultPriority: "medium",
     guidance: {
       impact: "Blocking OAI-SearchBot prevents your content from appearing in OpenAI's SearchGPT and ChatGPT web search results. Allowing it ensures your site is discoverable through OpenAI's real-time search features.",
@@ -2311,6 +2625,8 @@ var MetaExternalFetcherAudit = class extends CrawlerBotAudit {
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/access-crawl-control/meta-external-fetcher.md",
+    // Gate exemption: being refused is what this category reports.
+    requires: ["origin-reachable"],
     defaultPriority: "medium",
     guidance: {
       impact: "Blocking Meta-ExternalFetcher prevents Meta's AI from fetching your content in real-time for AI-powered features across Facebook, Instagram, and WhatsApp. Allowing it ensures your content can be surfaced in Meta's real-time AI experiences.",
@@ -2340,6 +2656,8 @@ var BravebotAudit = class extends CrawlerBotAudit {
     evidenceGrade: "C",
     tier: "informative",
     dossier: "docs/evidence/audits/access-crawl-control/bravebot.md",
+    // Gate exemption: being refused is what this category reports.
+    requires: ["origin-reachable"],
     defaultPriority: "medium",
     guidance: {
       impact: "Blocking Bravebot prevents your content from appearing in Brave Search AI answers and Brave Leo AI assistant responses. Allowing it gives your content visibility in the privacy-focused Brave browser ecosystem.",
@@ -2369,6 +2687,8 @@ var DuckassistbotAudit = class extends CrawlerBotAudit {
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/access-crawl-control/duckassistbot.md",
+    // Gate exemption: being refused is what this category reports.
+    requires: ["origin-reachable"],
     defaultPriority: "medium",
     guidance: {
       impact: "Blocking DuckAssistBot prevents your content from appearing in DuckDuckGo's AI-powered DuckAssist feature, which generates instant answers from crawled web pages. Allowing it ensures visibility in this privacy-first AI search experience.",
@@ -2398,6 +2718,8 @@ var MistralaiUserAudit = class extends CrawlerBotAudit {
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/access-crawl-control/mistralai-user.md",
+    // Gate exemption: being refused is what this category reports.
+    requires: ["origin-reachable"],
     defaultPriority: "medium",
     guidance: {
       impact: "Blocking MistralAI-User prevents Mistral AI's Le Chat from browsing your site in real-time when users ask it to visit your pages. Allowing it ensures your content can be cited in Mistral-powered AI conversations.",
@@ -2427,6 +2749,8 @@ var ClaudeSearchbotAudit = class extends CrawlerBotAudit {
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/access-crawl-control/claude-searchbot.md",
+    // Gate exemption: being refused is what this category reports.
+    requires: ["origin-reachable"],
     defaultPriority: "medium",
     guidance: {
       impact: "Blocking Claude-SearchBot prevents your content from appearing in Claude's web search results. Allowing it ensures your site is included when Claude searches the web to answer user questions.",
@@ -2456,6 +2780,8 @@ var NoBlanketBlockAudit = class extends Audit {
     evidenceGrade: "B",
     tier: "scored",
     dossier: "docs/evidence/audits/access-crawl-control/no-blanket-block.md",
+    // Gate exemption: being refused is what this category reports.
+    requires: ["origin-reachable"],
     defaultPriority: "critical",
     guidance: {
       impact: "A blanket Disallow: / under User-agent: * blocks every crawler, including all AI agents. Your site becomes completely invisible to AI search engines, ChatGPT Browse, Perplexity, Claude, and all other AI-powered discovery tools.",
@@ -2467,6 +2793,13 @@ var NoBlanketBlockAudit = class extends Audit {
     }
   };
   audit(ctx) {
+    if (!scanReadTheSite(ctx.evidence)) {
+      return this.notApplicable(
+        "No response here can be attributed to this site, so its robots.txt was not judged.",
+        "User-agent: * does not Disallow: / entirely",
+        unreadSiteReason(ctx.evidence)
+      );
+    }
     const robotsFile = ctx.rootFiles["/robots.txt"];
     if (!robotsFile || robotsFile.status !== 200 || !robotsFile.body) {
       return this.warn(
@@ -2609,6 +2942,8 @@ var SensitivePathsAudit = class extends Audit {
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/access-crawl-control/sensitive-paths.md",
+    // Gate exemption: being refused is what this category reports.
+    requires: ["origin-reachable", "rendered-body", "sample-adequate"],
     defaultPriority: "low",
     guidance: {
       impact: 'Cart, checkout, site-search, login and account URLs carry nothing an answer engine can cite, but they are crawled and can surface in AI answers as dead, session-bearing links. Apple documents Applebot and Applebot-Extended honouring "Disallow: /private/", and Meta documents the same for meta-externalagent, so a path-level rule keeps that noise out of AI crawls. Two limits matter: RFC 9309 states the protocol "is not a substitute for valid content security measures" and that listed paths become publicly discoverable, so never use robots.txt to protect anything; and user-initiated fetchers are documented not to obey it \u2014 OpenAI says of ChatGPT-User "Because these actions are initiated by a user, robots.txt rules may not apply", and Perplexity says Perplexity-User "generally ignores robots.txt rules".',
@@ -2704,6 +3039,8 @@ var CrawlDelayAudit = class extends Audit {
     evidenceGrade: "C",
     tier: "informative",
     dossier: "docs/evidence/audits/access-crawl-control/crawl-delay.md",
+    // Gate exemption: being refused is what this category reports.
+    requires: ["origin-reachable"],
     defaultPriority: "high",
     guidance: {
       impact: "Excessive Crawl-delay values (over 10 seconds) dramatically slow AI indexing, meaning your latest content may take days or weeks to appear in AI search results while competitors with lower delays get indexed faster.",
@@ -2714,6 +3051,13 @@ var CrawlDelayAudit = class extends Audit {
     }
   };
   audit(ctx) {
+    if (!scanReadTheSite(ctx.evidence)) {
+      return this.notApplicable(
+        "No response here can be attributed to this site, so its robots.txt was not judged.",
+        "If Crawl-delay is present, it is <= 10 seconds",
+        unreadSiteReason(ctx.evidence)
+      );
+    }
     const robotsFile = ctx.rootFiles["/robots.txt"];
     if (!robotsFile || robotsFile.status !== 200 || !robotsFile.body) {
       return this.warn(
@@ -2844,6 +3188,9 @@ var MetaRobotsNotBlockingAudit = class extends Audit {
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/access-crawl-control/robots-directives.md",
+    // Gate exemption: being refused is what this category reports, and robots directives
+    // live in the head and the headers, which arrive whether or not the body renders.
+    requires: ["origin-reachable"],
     defaultPriority: "high",
     guidance: {
       impact: 'A content page carrying "noindex" (in a robots meta tag, a per-bot meta tag, or the X-Robots-Tag response header) is dropped from the search index, and Google documents that a page must be indexed to appear in AI Overviews or AI Mode. "nosnippet", "noarchive" and "max-snippet:0" keep the page indexed but stop its text being used as a direct input for AI answers.',
@@ -2855,6 +3202,13 @@ var MetaRobotsNotBlockingAudit = class extends Audit {
     }
   };
   audit(ctx) {
+    if (!scanReadTheSite(ctx.evidence)) {
+      return this.notApplicable(
+        "No page here can be attributed to this site, so its robots directives were not judged.",
+        "No blocking robots directive on content pages",
+        unreadSiteReason(ctx.evidence)
+      );
+    }
     if (!ctx.pages || ctx.pages.length === 0) {
       return this.notApplicable(
         "No pages were scanned, so no robots directives could be read.",
@@ -2932,6 +3286,10 @@ var NoBotDetectionAudit = class extends Audit {
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/access-crawl-control/no-bot-detection.md",
+    // Gate exemption: being refused is what this category reports, and this audit names
+    // the firewall from `wafProtection` alone. Evidence a wall destroys is not evidence
+    // the wall finding needs.
+    requires: [],
     defaultPriority: "high",
     guidance: {
       impact: "Bot-detection services like Cloudflare Turnstile, DataDome, and reCAPTCHA can block legitimate AI agents from accessing your content. When agents are challenged, they cannot complete page fetches, making your content inaccessible to AI-powered search and assistants.",
@@ -2961,6 +3319,13 @@ var NoBotDetectionAudit = class extends Audit {
         }
       );
     }
+    if (!scanReadTheSite(ctx.evidence)) {
+      return this.notApplicable(
+        "No page here can be attributed to this site, so its scripts were not judged.",
+        "No JavaScript-based bot challenges that would block legitimate AI agents",
+        unreadSiteReason(ctx.evidence)
+      );
+    }
     if (!ctx.pages || ctx.pages.length === 0) {
       return this.warn(
         "No pages were scanned to check for bot-detection scripts.",
@@ -2986,6 +3351,13 @@ var NoBotDetectionAudit = class extends Audit {
       }
     }
     if (detectedServices.size === 0) {
+      if (!scanReadPageText(ctx.evidence)) {
+        return this.notApplicable(
+          "The scanned page served no readable text, so its scripts were not judged.",
+          "No JavaScript-based bot challenges that would block legitimate AI agents",
+          unreadPageTextReason(ctx.evidence)
+        );
+      }
       return this.pass(
         "No aggressive bot-detection scripts found on scanned pages.",
         "No JavaScript-based bot challenges that would block legitimate AI agents",
@@ -3093,6 +3465,8 @@ var TdmRepAudit = class extends Audit {
     evidenceGrade: "C",
     tier: "experimental",
     dossier: "docs/evidence/audits/access-crawl-control/tdm-rep.md",
+    // Gate exemption: being refused is what this category reports.
+    requires: ["origin-reachable", "rendered-body", "sample-adequate"],
     // Nothing consumes the signal, so nothing here should outrank an item that
     // changes what an agent can do.
     defaultPriority: "low",
@@ -3106,6 +3480,13 @@ var TdmRepAudit = class extends Audit {
     }
   };
   audit(ctx) {
+    if (!scanReadTheSite(ctx.evidence)) {
+      return this.notApplicable(
+        "No response here can be attributed to this site, so no TDM-Rep declaration was read.",
+        EXPECTED3,
+        unreadSiteReason(ctx.evidence)
+      );
+    }
     const pageUrl = ctx.pages[0]?.url;
     const header = readHeader(ctx);
     if (header) {
@@ -3241,6 +3622,8 @@ var AgentGovernanceAudit = class extends Audit {
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/access-crawl-control/agent-governance.md",
+    // Gate exemption: being refused is what this category reports.
+    requires: ["origin-reachable"],
     defaultPriority: "medium",
     guidance: {
       impact: "Without separate rules for training crawlers and live conversational agents, you cannot block dataset scraping while still appearing in ChatGPT, Claude, and Perplexity answers. A blanket policy either locks you out of AI-powered discovery entirely or leaves your content open to bulk training crawls you never agreed to.",
@@ -3376,6 +3759,8 @@ var AiContentDeclarationAudit = class extends Audit {
     evidenceGrade: "D",
     tier: "experimental",
     dossier: "docs/evidence/audits/access-crawl-control/ai-content-declaration.md",
+    // Gate exemption: being refused is what this category reports.
+    requires: ["origin-reachable", "rendered-body", "sample-adequate"],
     // Was `medium` on an invented directive; the whole class of signals is
     // pre-consumer, so nothing here should outrank an actionable item.
     defaultPriority: "low",
@@ -3389,6 +3774,13 @@ var AiContentDeclarationAudit = class extends Audit {
     }
   };
   audit(ctx) {
+    if (!scanReadTheSite(ctx.evidence)) {
+      return this.notApplicable(
+        "No response here can be attributed to this site, so no AI-usage declaration was read.",
+        EXPECTED4,
+        unreadSiteReason(ctx.evidence)
+      );
+    }
     const found = survey(ctx);
     if (found.aipref) {
       return this.pass(
@@ -3439,6 +3831,9 @@ var HttpsEnabledAudit = class extends Audit {
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/access-crawl-control/https-enabled.md",
+    // Gate exemption: a base URL on plain HTTP is proven by the request, with no response
+    // at all, and that fail is worth reporting on a site whose homepage never answered.
+    requires: [],
     defaultPriority: "critical",
     guidance: {
       impact: "HTTP-only sites are completely excluded from all major AI systems. GPTBot, ClaudeBot, Perplexity, and enterprise RAG pipelines refuse to connect to non-HTTPS origins due to security policies. Your entire site is invisible to AI-generated answers, product recommendations, and agentic workflows.",
@@ -3453,35 +3848,42 @@ var HttpsEnabledAudit = class extends Audit {
     const isHttps = ctx.baseUrl.startsWith("https://");
     const page = ctx.pages?.[0];
     const status200 = page?.fetchResult.status === 200;
-    if (isHttps && status200) {
-      return this.pass(
-        "Site is served over HTTPS with a valid TLS connection.",
+    if (!isHttps) {
+      return this.fail(
+        "Site is not served over HTTPS. AI agents require secure connections.",
         "Base URL uses https:// and homepage returns 200",
-        `${ctx.baseUrl} \u2014 status ${page?.fetchResult.status}`,
+        `Base URL: ${ctx.baseUrl}`,
+        {
+          priority: "critical",
+          description: "Enterprise AI frameworks refuse to interact with non-HTTPS sites due to security policies. GPTBot, ClaudeBot, and enterprise RAG systems all skip HTTP-only sites entirely, making your content invisible to AI-generated answers. Enable HTTPS with a valid TLS certificate.",
+          code: "# For nginx:\nserver {\n  listen 443 ssl;\n  ssl_certificate /path/to/cert.pem;\n  ssl_certificate_key /path/to/key.pem;\n}"
+        },
         page?.url
       );
     }
-    if (isHttps && !status200) {
-      return this.warn(
-        `Site uses HTTPS but homepage returned status ${page?.fetchResult.status ?? "unknown"}. Possible TLS or server error.`,
+    if (!scanReadTheSite(ctx.evidence)) {
+      return this.notApplicable(
+        "No homepage here can be attributed to this site, so its transport was not judged.",
         "Base URL uses https:// and homepage returns 200",
-        `${ctx.baseUrl} \u2014 status ${page?.fetchResult.status ?? "N/A"}`,
-        {
-          priority: "high",
-          description: "Enterprise AI frameworks refuse to interact with sites that have TLS errors. A non-200 HTTPS response prevents AI agents from ingesting your content, effectively making your site invisible to all AI systems. Fix server or TLS configuration to return a clean 200.",
-          code: "# Verify TLS with: curl -vI https://yoursite.com\n# Check for certificate expiry, chain issues, or redirect loops"
-        },
+        unreadSiteReason(ctx.evidence)
+      );
+    }
+    if (status200) {
+      return this.pass(
+        "Site is served over HTTPS with a valid TLS connection.",
+        "Base URL uses https:// and homepage returns 200",
+        `${ctx.baseUrl} \u2014 status ${page?.fetchResult.status}`,
         page?.url
       );
     }
-    return this.fail(
-      "Site is not served over HTTPS. AI agents require secure connections.",
+    return this.warn(
+      "Site uses HTTPS and the homepage answered, but the response carried no document, so an agent has nothing to read over that connection.",
       "Base URL uses https:// and homepage returns 200",
-      `Base URL: ${ctx.baseUrl}`,
+      `${ctx.baseUrl} \u2014 a 2xx response that carried no document`,
       {
-        priority: "critical",
-        description: "Enterprise AI frameworks refuse to interact with non-HTTPS sites due to security policies. GPTBot, ClaudeBot, and enterprise RAG systems all skip HTTP-only sites entirely, making your content invisible to AI-generated answers. Enable HTTPS with a valid TLS certificate.",
-        code: "# For nginx:\nserver {\n  listen 443 ssl;\n  ssl_certificate /path/to/cert.pem;\n  ssl_certificate_key /path/to/key.pem;\n}"
+        priority: "high",
+        description: "The homepage answered over HTTPS and returned no document \u2014 an empty 200 body, or a 2xx status that carries none. An AI agent that follows a link to this origin receives nothing, so nothing about the site can be indexed or quoted. Check the origin, the CDN cache entry and any edge rule that can strip a response body.",
+        code: "# Reproduce with:\ncurl -sSi https://yoursite.com | head -20"
       },
       page?.url
     );
@@ -3587,6 +3989,10 @@ var RobotsAiGroupShadowingAudit = class _RobotsAiGroupShadowingAudit extends Aud
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/access-crawl-control/robots-ai-group-shadowing.md",
+    // Gate exemption: being refused is what this category reports.
+    // Gate exemption: the verdict comes from robots.txt. The scanned pages only widen
+    // the probe path set, so a shell narrows the probe and changes nothing judged.
+    requires: ["origin-reachable"],
     defaultPriority: "high",
     guidance: {
       impact: "RFC 9309 \xA72.2.1 states the wildcard group is consulted only 'if no matching group exists'. Therefore, for any site with a named AI-bot group, the wildcard group's Disallow rules provably do not apply to that bot, and the operator's stated intent (expressed once in `*`) diverges from the enforced policy by exactly the symmetric difference of the two rule sets. Falsifiable by construction: given robots.txt R and token T, the set of paths where R_T and R_star disagree is computable and either empty or not.",
@@ -3605,6 +4011,13 @@ var RobotsAiGroupShadowingAudit = class _RobotsAiGroupShadowingAudit extends Aud
     };
   }
   audit(ctx) {
+    if (!scanReadTheSite(ctx.evidence)) {
+      return this.notApplicable(
+        "No response here can be attributed to this site, so its robots groups were not judged.",
+        EXPECTED5,
+        unreadSiteReason(ctx.evidence)
+      );
+    }
     const robots = ctx.rootFiles["/robots.txt"];
     if (!robots || robots.status !== 200 || !robots.body.trim()) {
       return this.notApplicable(
@@ -4045,6 +4458,8 @@ var AiCrawlerEdgeParityAudit = class extends Audit {
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/access-crawl-control/ai-crawler-edge-parity.md",
+    // Gate exemption: being refused is what this category reports.
+    requires: ["origin-reachable", "rendered-body", "sample-adequate"],
     defaultPriority: "critical",
     guidance: {
       impact: 'robots.txt (RFC 9309) is advisory metadata parsed by the crawler; the edge access decision is enforced independently by the WAF. A site can therefore publish "User-agent: PerplexityBot / Allow: /" and return a non-200 to every request carrying that user agent, and the operator \u2014 who reads their own robots.txt \u2014 believes they are open while the crawler never sees a byte. Falsifiable: fetch URL U with a browser UA and with crawler UA C; if robots.txt permits C for U and the C request is not 2xx while the browser request is 200, the two policy layers contradict each other. Cloudflare makes one branch deterministic \u2014 a challenge always carries cf-mitigated: challenge \u2014 and a 200 whose main-content text is under 40% of the baseline is a block wearing a 200.',
@@ -4260,6 +4675,8 @@ var BotContentDeltaDeclaredAudit = class extends Audit {
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/access-crawl-control/bot-content-delta-declared.md",
+    // Gate exemption: being refused is what this category reports.
+    requires: ["origin-reachable", "rendered-body", "sample-adequate"],
     defaultPriority: "high",
     guidance: {
       impact: "Google states that isAccessibleForFree: false with hasPart/cssSelector markup 'helps Google differentiate paywalled content from the practice of cloaking, which violates spam policies' \u2014 serving a crawler less than a user is sanctioned only when it is declared. The measurement is falsifiable both ways: extract the main text of URL U under a browser UA and under crawler UA C, and if the length ratio falls below 0.6 or the 5-gram shingle similarity below 0.7, the site conditions content on the User-Agent. The declaration is equally checkable, and the declared cssSelector must match a real element in the served HTML \u2014 which is where most implementations silently fail, leaving markup that validates and points at nothing. The second-order cost is not the spam risk: an answer engine that only ever sees the stub cites the stub.",
@@ -4560,6 +4977,8 @@ var AiUsageSignalCoherenceAcrossChannelsAudit = class extends Audit {
     weight: weightForGrade("B", "scored"),
     defaultPriority: "high",
     dossier: "docs/evidence/audits/access-crawl-control/ai-usage-signal-coherence-across-channels.md",
+    // Gate exemption: being refused is what this category reports.
+    requires: ["origin-reachable", "rendered-body", "sample-adequate"],
     guidance: {
       impact: "No standard defines precedence between these channels; each specifies only its own parsing. A crawler that reads TDM-Rep and a crawler that reads AIPREF therefore read disjoint inputs, and when those inputs disagree the two reach opposite conclusions about the same page. Whichever one you did not mean to publish is the one some operator will act on. The documented worst case is not even yours to make: Cloudflare\u2019s managed robots.txt prepends its own Content-Signal block above your file, so your stated policy can be contradicted at the edge without you knowing.",
       fix: "Decide the policy once, then say the same thing in every channel you publish. If you do not intend to maintain a channel, remove it rather than leaving a stale value \u2014 a contradicted signal is worse than a missing one. Where your CDN prepends its own robots.txt block, either turn that feature off or make your own declarations match it.",
@@ -4569,6 +4988,13 @@ var AiUsageSignalCoherenceAcrossChannelsAudit = class extends Audit {
     }
   };
   audit(ctx) {
+    if (!scanReadTheSite(ctx.evidence)) {
+      return this.notApplicable(
+        "No response here can be attributed to this site, so its AI-usage channels were not compared.",
+        "Every channel that carries an AI-usage signal says the same thing",
+        unreadSiteReason(ctx.evidence)
+      );
+    }
     if (ctx.pages.length === 0 && (ctx.rootFiles["/robots.txt"]?.status ?? 0) !== 200) {
       return this.notApplicable(
         "The scan read no page and no robots.txt, so no channel could carry a signal.",
@@ -4772,6 +5198,8 @@ var AiprefContentUsageDeclarationValidityAudit = class extends Audit {
     weight: weightForGrade("B", "scored"),
     defaultPriority: "medium",
     dossier: "docs/evidence/audits/access-crawl-control/aipref-content-usage-declaration-validity.md",
+    // Gate exemption: being refused is what this category reports.
+    requires: ["origin-reachable", "rendered-body", "sample-adequate"],
     guidance: {
       impact: "AIPREF is the one AI-usage vocabulary on the IETF standards track, so a declaration written in it is the one a future crawler is most likely to read. A crawler that cannot parse the line ignores it, and the site is then treated as having no preference at all \u2014 the same outcome as publishing nothing, after the work of publishing something. The costliest version is invisible: a preference attached to a path robots.txt disallows is discarded by the spec itself, so the line looks right and does nothing.",
       fix: "Write `Content-Usage: train-ai=n` \u2014 an RFC 8941 dictionary of `y`/`n` values against the `train-ai` and `search` categories. Use `yes`/`no` only in a Cloudflare `Content-Signal:` line, which is a different directive. Attach preferences to paths a crawler is allowed to fetch, and keep the robots.txt line and the response header saying the same thing for the same path.",
@@ -4781,6 +5209,13 @@ var AiprefContentUsageDeclarationValidityAudit = class extends Audit {
     }
   };
   audit(ctx) {
+    if (!scanReadTheSite(ctx.evidence)) {
+      return this.notApplicable(
+        "No response here can be attributed to this site, so no Content-Usage declaration was read.",
+        "Every Content-Usage declaration parses as an RFC 8941 dictionary of AIPREF categories, attaches to a crawlable path, and agrees with the other channel",
+        unreadSiteReason(ctx.evidence)
+      );
+    }
     const robots = ctx.rootFiles["/robots.txt"];
     const robotsBody = robots?.status === 200 ? robots.body : "";
     const groups = robotsBody === "" ? [] : parseRobots(robotsBody);
@@ -4963,6 +5398,8 @@ var RslLicensingTermsConformanceAudit = class extends Audit {
     weight: weightForGrade("B", "scored"),
     defaultPriority: "medium",
     dossier: "docs/evidence/audits/access-crawl-control/rsl-licensing-terms-conformance.md",
+    // Gate exemption: being refused is what this category reports.
+    requires: ["origin-reachable", "rendered-body", "sample-adequate"],
     guidance: {
       impact: 'RSL is the machine-readable form of "here are my terms". A crawler that cannot find the document applies its own defaults instead, and a document it finds but cannot parse is worth no more than one it never found. The specification mandates no default location, so a licence reachable only at a guessed path is one no crawler is obliged to look for. The quiet failure is a `<content url>` prefix that does not cover the pages the licence was written for: the terms load, parse, and apply to nothing.',
       fix: 'Point at the licence from robots.txt with an absolute `License:` URI, and add the `Link: <...>; rel="license"; type="application/rsl+xml"` response header so a crawler that never reads robots.txt still finds it. Serve the document as `application/rsl+xml`, keep the `https://rslstandard.org/rsl` namespace on the root element, and make every `<content url>` prefix cover the paths it licenses.',
@@ -5270,6 +5707,8 @@ var MachineActionable402PaidAccessAudit = class extends Audit {
     weight: weightForGrade("B", "scored"),
     defaultPriority: "medium",
     dossier: "docs/evidence/audits/access-crawl-control/machine-actionable-402-paid-access.md",
+    // Gate exemption: being refused is what this category reports.
+    requires: ["origin-reachable", "rendered-body", "sample-adequate"],
     guidance: {
       impact: "Charging for crawler access is a legitimate choice, and 402 is the status code for it. But a crawler is a program: it can pay only what it can parse. A 402 whose body is an HTML page explaining your licensing terms reads, to the client, as an unexplained refusal \u2014 the same outcome as a 403, after you built a paywall meant to earn revenue. A 402 that a shared cache is allowed to store is worse: the next crawler gets a stored refusal even after paying.",
       fix: 'Send one of the machine-readable forms with the 402: Cloudflare\u2019s `crawler-price: USD 0.01`, an x402 `PAYMENT-REQUIRED` challenge listing what you accept, or a `Link: rel=license` pointing at an RSL document whose `<payment type="crawl">` covers the path. Mark the response `Cache-Control: no-store` so a proxy cannot hand your 402 to a crawler that already paid.',
@@ -5474,6 +5913,8 @@ var WebBotAuthRequestToleranceAudit = class _WebBotAuthRequestToleranceAudit ext
     weight: weightForGrade("B", "scored"),
     defaultPriority: "medium",
     dossier: "docs/evidence/audits/access-crawl-control/web-bot-auth-request-tolerance.md",
+    // Gate exemption: being refused is what this category reports.
+    requires: ["origin-reachable"],
     guidance: {
       impact: "Web Bot Auth is how an agent says who it is in a way an origin can check, and the operators building it are the ones whose traffic you would most want to identify. An edge that answers a signed request with 400 or 403 turns that identification into a reason for refusal: the agents willing to declare themselves are the ones you turn away, and the ones that lie carry no signature headers at all and sail through. A 431 is the same outcome from a different cause \u2014 a header-size limit \u2014 and it is fixed differently.",
       fix: "Let unknown request headers through: `Signature`, `Signature-Input` and `Signature-Agent` are additive and safe to ignore. If your edge enforces a header-size budget, raise it enough for an Ed25519 signature. If you do vary behaviour on those headers, list them in `Vary` so a shared cache cannot serve the rejected variant to everyone.",
@@ -5662,6 +6103,9 @@ var ServerResponsivenessAudit = class extends Audit {
     evidenceGrade: "B",
     tier: "scored",
     dossier: "docs/evidence/audits/content-extraction/server-responsiveness.md",
+    // Gate exemption: TTFB is measured from the response, and a shell answers as fast
+    // or as slow as anything else the origin serves.
+    requires: ["origin-reachable", "unblocked-fetches"],
     defaultPriority: "medium",
     guidance: {
       impact: 'Google documents that crawl capacity falls when a host slows down ("if the site slows down\u2026 the limit goes down and Google crawls less"), and slow origins are where logged HTTP 499 client-closed-request clusters from AI fetchers appear. A slow origin therefore gets less of its content into the indexes AI answers are drawn from.',
@@ -5680,6 +6124,13 @@ var ServerResponsivenessAudit = class extends Audit {
         `Blocked by ${ctx.wafProtection.name}`
       );
     }
+    if (!scanReadTheSite(ctx.evidence)) {
+      return this.notApplicable(
+        "No page here can be attributed to this site, so its response time was not judged.",
+        EXPECTED8,
+        unreadSiteReason(ctx.evidence)
+      );
+    }
     const measured = ctx.pages.filter((p) => !p.fetchResult.error && p.fetchResult.status !== 0);
     const unmeasured = ctx.pages.length - measured.length;
     if (measured.length === 0) {
@@ -5740,6 +6191,8 @@ var LanguageAttributeAudit = class extends Audit {
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/content-extraction/language-attribute.md",
+    // Gate exemption: `<html lang>` is served before any body renders.
+    requires: ["origin-reachable", "unblocked-fetches"],
     defaultPriority: "high",
     guidance: {
       impact: "AI agents use the lang attribute to select the correct language model and tokenizer when processing your content. Without it, agents may misinterpret content language, leading to poor translations or incorrect answers in multilingual AI systems.",
@@ -5751,6 +6204,13 @@ var LanguageAttributeAudit = class extends Audit {
     }
   };
   audit(ctx) {
+    if (!scanReadTheSite(ctx.evidence)) {
+      return this.notApplicable(
+        "No page here can be attributed to this site, so its language attribute was not judged.",
+        '<html lang="..."> with a non-empty language code',
+        unreadSiteReason(ctx.evidence)
+      );
+    }
     const page = ctx.pages[0];
     const $ = page?.$;
     const lang = $?.("html").attr("lang") ?? "";
@@ -5889,6 +6349,7 @@ var MarkdownAlternateAudit = class extends Audit {
     weight: weightForGrade("A", "scored"),
     defaultPriority: "medium",
     dossier: "docs/evidence/audits/content-extraction/markdown-alternate.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     guidance: {
       impact: "A markdown alternate is a promise that an agent can read the page cheaply and get the same answer. A stale or partial alternate breaks that promise silently: the agent gets a document that looks authoritative, costs less, and says less than the page it claims to mirror. Serving it as `text/plain` or `text/html` is the same failure one level down \u2014 the client that negotiated for markdown cannot tell it got any. The consumers this is graded on are interactive coding agents \u2014 Claude Code, Cursor, Copilot Chat and CLI, Codex CLI \u2014 and GPTBot, measured taking markdown on 34.8% of fetches where a `.md` URL exists.",
       fix: 'Serve the alternate from the same source as the HTML, so headings and prose cannot drift, with `Content-Type: text/markdown` (a `charset` parameter is fine). Publish it on the page URL plus `.md`, or answer `Accept: text/markdown` on the page URL itself \u2014 those are the two routes with documented consumers. Declaring it with `<link rel="alternate" type="text/markdown" href="...">` saves an agent a guess, but the link relation itself has one single-sourced consumer, so this audit reports it rather than scoring it.',
@@ -6119,6 +6580,7 @@ var JsonLdDuplicationMassAudit = class extends Audit {
     weight: weightForGrade("C", "informative"),
     defaultPriority: "low",
     dossier: "docs/evidence/audits/content-extraction/json-ld-duplication-mass.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     guidance: {
       impact: "A non-rendering agent tokenizes the whole document, JSON-LD included. Where a block repeats the article body the DOM already carries, the page ships that text twice and the agent pays for both copies out of one context window. The same holds for a node declared identically in two blocks: the second copy adds tokens and no facts.",
       fix: "Keep JSON-LD to the facts a parser needs \u2014 identifiers, prices, dates, relationships \u2014 and let the prose live in the DOM. Where a schema property genuinely needs body text, a summary is usually enough. Merge blocks that declare the same `@id` into one.",
@@ -6228,6 +6690,7 @@ var SingleH1Audit = class extends Audit {
     evidenceGrade: "B",
     tier: "scored",
     dossier: "docs/evidence/audits/content-extraction/single-h1.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     defaultPriority: "high",
     guidance: {
       impact: "AI agents use the single <h1> as the authoritative page title for content indexing and answer generation. Multiple <h1> elements create ambiguity about the page's primary topic, causing agents to misidentify or conflate subjects when generating answers.",
@@ -6239,6 +6702,13 @@ var SingleH1Audit = class extends Audit {
     }
   };
   audit(ctx) {
+    if (!scanReadTheSite(ctx.evidence)) {
+      return this.notApplicable(
+        "No page here can be attributed to this site, so its headings were not judged.",
+        "Exactly one <h1> on the homepage",
+        unreadSiteReason(ctx.evidence)
+      );
+    }
     const homepage = ctx.pages[0];
     if (!homepage) {
       return this.fail(
@@ -6290,6 +6760,7 @@ var SequentialHeadingsAudit = class extends Audit {
     evidenceGrade: "B",
     tier: "scored",
     dossier: "docs/evidence/audits/content-extraction/sequential-headings.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     defaultPriority: "high",
     guidance: {
       impact: "AI systems build content outlines from heading levels to understand document hierarchy. Skipped levels (e.g., h1 directly to h3) break this hierarchy, causing agents to misinterpret section nesting and produce inaccurate content summaries with wrong parent-child relationships.",
@@ -6379,6 +6850,7 @@ var MainElementAudit = class extends Audit {
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/content-extraction/main-element.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     defaultPriority: "high",
     guidance: {
       impact: "Without a <main> element, AI scrapers cannot distinguish primary content from navigation, sidebars, and footer boilerplate. This causes agents to ingest menus, disclaimers, and repeated chrome into their context window, increasing hallucination risk and reducing answer relevance.",
@@ -6390,6 +6862,13 @@ var MainElementAudit = class extends Audit {
     }
   };
   audit(ctx) {
+    if (!scanReadTheSite(ctx.evidence)) {
+      return this.notApplicable(
+        "No page here can be attributed to this site, so its landmarks were not judged.",
+        "<main> element present on all pages",
+        unreadSiteReason(ctx.evidence)
+      );
+    }
     let pagesWithMain = 0;
     for (const page of ctx.pages) {
       if (page.$("main").length > 0) pagesWithMain++;
@@ -6436,6 +6915,7 @@ var ArticleElementAudit = class extends Audit {
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/content-extraction/article-element.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     applicablePageTypes: ["content"],
     defaultPriority: "medium",
     guidance: {
@@ -6448,6 +6928,13 @@ var ArticleElementAudit = class extends Audit {
     }
   };
   audit(ctx) {
+    if (!scanReadTheSite(ctx.evidence)) {
+      return this.notApplicable(
+        "No page here can be attributed to this site, so its landmarks were not judged.",
+        "<article> elements on content pages",
+        unreadSiteReason(ctx.evidence)
+      );
+    }
     let pagesWithArticle = 0;
     for (const page of ctx.pages) {
       if (page.$("article").length > 0) pagesWithArticle++;
@@ -6494,6 +6981,7 @@ var HeaderFooterAudit = class extends Audit {
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/content-extraction/header-footer.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     defaultPriority: "medium",
     guidance: {
       impact: "AI agents use <header> and <footer> landmarks to identify and exclude boilerplate content (navigation menus, copyright notices, legal links) from primary content extraction. Without these landmarks, agents may include footer disclaimers or nav menus in their content summaries, reducing answer accuracy.",
@@ -6505,6 +6993,13 @@ var HeaderFooterAudit = class extends Audit {
     }
   };
   audit(ctx) {
+    if (!scanReadTheSite(ctx.evidence)) {
+      return this.notApplicable(
+        "No page here can be attributed to this site, so its landmarks were not judged.",
+        "Both <header> and <footer> present on all pages",
+        unreadSiteReason(ctx.evidence)
+      );
+    }
     let pagesWithBoth = 0;
     let pagesWithHeader = 0;
     let pagesWithFooter = 0;
@@ -6585,6 +7080,7 @@ var AsideElementAudit = class extends Audit {
     evidenceGrade: "B",
     tier: "scored",
     dossier: "docs/evidence/audits/content-extraction/aside-element.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     applicablePageTypes: ["content"],
     defaultPriority: "low",
     guidance: {
@@ -6667,6 +7163,7 @@ var SectionHeadingsAudit = class extends Audit {
     evidenceGrade: "B",
     tier: "scored",
     dossier: "docs/evidence/audits/content-extraction/section-headings.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     defaultPriority: "medium",
     guidance: {
       impact: "AI agents use section headings to build a topic map of your page for retrieval-augmented generation. Unlabeled <section> elements are opaque to AI chunking systems, preventing them from indexing and retrieving your content by topic, which reduces your visibility in AI-generated answers.",
@@ -6845,6 +7342,7 @@ var SemanticListsAudit = class extends Audit {
     evidenceGrade: "B",
     tier: "scored",
     dossier: "docs/evidence/audits/content-extraction/semantic-lists.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     defaultPriority: "medium",
     guidance: {
       impact: 'AI agents recognize <ul>, <ol>, and <dl> as structured lists and extract them as bullet points, numbered steps or term/definition pairs. Content formatted as styled <div> elements \u2014 or as paragraphs that start with "1.", "2." \u2014 collapses into undelimited prose when the page is converted to markdown or an accessibility tree, so the agent has to re-infer where each item begins.',
@@ -6916,6 +7414,7 @@ var DataTablesAudit = class extends Audit {
     evidenceGrade: "B",
     tier: "scored",
     dossier: "docs/evidence/audits/content-extraction/data-tables.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     defaultPriority: "medium",
     guidance: {
       impact: "AI agents rely on <thead> and <th> elements to understand column headers and map cell values to their meanings. Without proper table structure, agents cannot interpret tabular data correctly, leading to garbled comparisons and inaccurate data extraction in AI-generated summaries.",
@@ -6927,6 +7426,13 @@ var DataTablesAudit = class extends Audit {
     }
   };
   audit(ctx) {
+    if (!scanReadTheSite(ctx.evidence)) {
+      return this.notApplicable(
+        "No page here can be attributed to this site, so its tables were not judged.",
+        "Tables have <thead> and <th> elements",
+        unreadSiteReason(ctx.evidence)
+      );
+    }
     let totalTables = 0;
     let properTables = 0;
     for (const page of ctx.pages) {
@@ -6939,6 +7445,13 @@ var DataTablesAudit = class extends Audit {
       });
     }
     if (totalTables === 0) {
+      if (!scanReadPageText(ctx.evidence)) {
+        return this.notApplicable(
+          "The scanned page served no readable text, so it held no tables to judge.",
+          "Tables have <thead> and <th> elements",
+          unreadPageTextReason(ctx.evidence)
+        );
+      }
       return this.pass(
         "No data tables found \u2014 check not applicable.",
         "Tables have <thead> and <th> elements",
@@ -6992,6 +7505,7 @@ var CodeLanguageAudit = class extends Audit {
     evidenceGrade: "C",
     tier: "informative",
     dossier: "docs/evidence/audits/content-extraction/code-language.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     applicablePageTypes: ["content"],
     defaultPriority: "low",
     guidance: {
@@ -7073,6 +7587,7 @@ var TimeElementAudit = class extends Audit {
     evidenceGrade: "C",
     tier: "informative",
     dossier: "docs/evidence/audits/content-extraction/time-element.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     applicablePageTypes: ["content"],
     defaultPriority: "medium",
     guidance: {
@@ -7123,6 +7638,7 @@ var ContentDepthAudit = class extends Audit {
     evidenceGrade: "B",
     tier: "scored",
     dossier: "docs/evidence/audits/content-extraction/content-depth.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     defaultPriority: "medium",
     guidance: {
       impact: "Pages with fewer than 300 words provide too little context for AI RAG systems to generate accurate, detailed answers. Thin content produces weak vector embeddings that rank poorly in retrieval, causing your pages to be excluded from AI-generated responses entirely.",
@@ -7132,6 +7648,13 @@ var ContentDepthAudit = class extends Audit {
     }
   };
   audit(ctx) {
+    if (!scanReadTheSite(ctx.evidence)) {
+      return this.notApplicable(
+        "No page here can be attributed to this site, so its content depth was not judged.",
+        "More than 300 words of content per page",
+        unreadSiteReason(ctx.evidence)
+      );
+    }
     let pagesAboveThreshold = 0;
     const wordCounts = [];
     for (const page of ctx.pages) {
@@ -7205,6 +7728,7 @@ var ImageAltTextAudit = class extends Audit {
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/content-extraction/image-alt-text.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     defaultPriority: "high",
     guidance: {
       impact: "An image with no text alternative has no accessible name, so it is an unnamed node in the accessibility-tree snapshots agent toolkits send to a model \u2014 Playwright MCP, Claude-in-Chrome read_page, Chrome DevTools take_snapshot \u2014 and it carries no subject matter for Google Images, which states it uses alt text to understand what an image shows. A multimodal agent that fetches the image bytes can caption it without one; a text-only crawler or a snapshot-driven agent cannot.",
@@ -7291,6 +7815,7 @@ var FigureFigcaptionAudit = class extends Audit {
     evidenceGrade: "C",
     tier: "informative",
     dossier: "docs/evidence/audits/content-extraction/figure-figcaption.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     defaultPriority: "medium",
     guidance: {
       impact: "AI agents use <figcaption> to understand the purpose and context of visual content beyond what alt text provides. Without captions, figures are treated as opaque image containers, and your charts, diagrams, and illustrations cannot be meaningfully cited in AI-generated answers.",
@@ -7302,6 +7827,13 @@ var FigureFigcaptionAudit = class extends Audit {
     }
   };
   audit(ctx) {
+    if (!scanReadTheSite(ctx.evidence)) {
+      return this.notApplicable(
+        "No page here can be attributed to this site, so its figures were not judged.",
+        "Images with context wrapped in <figure> with <figcaption>",
+        unreadSiteReason(ctx.evidence)
+      );
+    }
     let totalFigures = 0;
     let figuresWithCaption = 0;
     for (const page of ctx.pages) {
@@ -7330,6 +7862,13 @@ var FigureFigcaptionAudit = class extends Audit {
           }
         );
       }
+      if (!scanReadPageText(ctx.evidence)) {
+        return this.notApplicable(
+          "The scanned page served no readable text, so it held no images or figures to judge.",
+          "Images with context wrapped in <figure> with <figcaption>",
+          unreadPageTextReason(ctx.evidence)
+        );
+      }
       return this.pass(
         "No images or <figure> elements found \u2014 check not applicable.",
         "Images with context wrapped in <figure> with <figcaption>",
@@ -7413,6 +7952,7 @@ var SvgBloatAudit = class extends Audit {
     evidenceGrade: "B",
     tier: "scored",
     dossier: "docs/evidence/audits/content-extraction/svg-bloat.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     defaultPriority: "medium",
     guidance: {
       impact: "Large inline SVGs are inlined verbatim as path-data tokens when an LLM converts your page to Markdown. A single 10KB icon or chart can consume thousands of tokens of agent context per page load, inflating agent cost and pushing real content out of the context window \u2014 reducing the quality of what agents extract and say about your site.",
@@ -12823,6 +13363,7 @@ var TokenRatioAudit = class extends Audit {
     evidenceGrade: "B",
     tier: "scored",
     dossier: "docs/evidence/audits/content-extraction/token-ratio.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     defaultPriority: "high",
     guidance: {
       impact: "When less than 15% of your HTML is actual content, AI agents burn most of their context window and token budget on markup noise: inline scripts, CSS, SVG sprites, tracking tags, and deeply nested divs. The useful text that remains gets weaker attention from the model, and pages with extreme bloat may be truncated before the real content is even read.",
@@ -12833,6 +13374,13 @@ var TokenRatioAudit = class extends Audit {
     }
   };
   audit(ctx) {
+    if (!scanReadTheSite(ctx.evidence)) {
+      return this.notApplicable(
+        "No page here can be attributed to this site, so its token mix was not measured.",
+        "A homepage from this site whose token mix can be measured",
+        unreadSiteReason(ctx.evidence)
+      );
+    }
     const page = ctx.pages[0];
     const rawHtml = page?.fetchResult.body ?? "";
     if (!page || rawHtml.trim().length === 0) {
@@ -12954,6 +13502,7 @@ var FakeHeadingsAudit = class extends Audit {
     evidenceGrade: "B",
     tier: "scored",
     dossier: "docs/evidence/audits/content-extraction/fake-headings.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     defaultPriority: "medium",
     guidance: {
       impact: "AI agents build content outlines exclusively from <h1>\u2013<h6> elements. Text that only looks like a heading is treated as ordinary body copy, so agents miss your section structure entirely \u2014 summaries flatten into a wall of text, section-level citations become impossible, and chunking for retrieval splits content at arbitrary points instead of at your intended section boundaries.",
@@ -12965,6 +13514,13 @@ var FakeHeadingsAudit = class extends Audit {
     }
   };
   audit(ctx) {
+    if (!scanReadTheSite(ctx.evidence)) {
+      return this.notApplicable(
+        "No page here can be attributed to this site, so its headings were not judged.",
+        "All heading-like text uses semantic <h1>-<h6> elements",
+        unreadSiteReason(ctx.evidence)
+      );
+    }
     const found = [];
     for (const page of ctx.pages) {
       const $ = page.$;
@@ -12988,6 +13544,13 @@ var FakeHeadingsAudit = class extends Audit {
     const foundSummary = found.slice(0, 5).map((f) => `${f.url}: ${describe5(f.heading)}`).join("; ");
     const expected = "All heading-like text uses semantic <h1>-<h6> elements";
     if (found.length === 0) {
+      if (!scanReadPageText(ctx.evidence)) {
+        return this.notApplicable(
+          "The scanned page served no readable text, so it held no headings to judge.",
+          expected,
+          unreadPageTextReason(ctx.evidence)
+        );
+      }
       return this.pass(
         "No fake headings detected \u2014 heading-like text uses semantic heading elements.",
         expected,
@@ -13017,6 +13580,9 @@ var FakeHeadingsAudit = class extends Audit {
 };
 
 // src/audits/content-extraction/server-rendered.ts
+function withDetails(result, details) {
+  return { ...result, details: { ...result.details ?? {}, ...details } };
+}
 var ServerRenderedAudit = class extends Audit {
   static meta = {
     id: "content-extraction/server-rendered",
@@ -13029,6 +13595,8 @@ var ServerRenderedAudit = class extends Audit {
     evidenceGrade: "B",
     tier: "scored",
     dossier: "docs/evidence/audits/content-extraction/server-rendered.md",
+    // Gate exemption: A shell is what this audit reports. Gating it would delete the finding.
+    requires: ["origin-reachable", "unblocked-fetches"],
     defaultPriority: "critical",
     guidance: {
       impact: "AI crawlers (GPTBot, ClaudeBot, PerplexityBot) do not execute JavaScript. If your content is only rendered client-side, these crawlers see an empty or near-empty page. Your products, articles, and brand information are completely absent from AI knowledge bases, meaning AI-generated answers never reference your site.",
@@ -13040,37 +13608,64 @@ var ServerRenderedAudit = class extends Audit {
     }
   };
   audit(ctx) {
-    const page = ctx.pages?.[0];
-    if (!page) {
-      return this.warn(
-        "No homepage data available to check server-rendered content.",
-        "Homepage <main> has > 50 words or > 200 characters of text content",
-        "No homepage fetched",
-        void 0,
-        void 0
+    if (!scanReadTheSite(ctx.evidence)) {
+      return this.notApplicable(
+        "No page here can be attributed to this site, so its served HTML was not judged.",
+        "Every fetched page serves > 50 words or > 200 characters of readable text",
+        unreadSiteReason(ctx.evidence)
       );
     }
-    const $ = page.$;
-    const wordCount2 = getWordCount($);
-    const mainText2 = getMainContentText($);
-    if (wordCount2 > 50 || mainText2.length > 200) {
-      return this.pass(
-        `Homepage has meaningful server-rendered content (${wordCount2} words, ${mainText2.length} characters).`,
-        "Homepage <main> has > 50 words or > 200 characters of text content",
-        `${wordCount2} words, ${mainText2.length} characters`,
-        page.url
+    const pages = ctx.pages ?? [];
+    if (pages.length === 0) {
+      return this.notApplicable(
+        "The scan fetched no page, so there is no served HTML to judge.",
+        "Every fetched page serves > 50 words or > 200 characters of readable text",
+        "No page fetched"
+      );
+    }
+    const rendered = ctx.evidence.renderedByPage;
+    const emptyPages = pages.filter((page) => !(rendered[page.url] ?? pageRendersText(page))).map((page) => page.url);
+    const total = pages.length;
+    const renderedCount = total - emptyPages.length;
+    const expected = "Every fetched page serves > 50 words or > 200 characters of readable text";
+    const found = `${renderedCount} of ${total} page(s) served readable text`;
+    if (emptyPages.length === 0) {
+      return withDetails(
+        this.pass(
+          `All ${total} fetched page(s) serve their content in the HTML response.`,
+          expected,
+          found,
+          pages[0].url
+        ),
+        { pagesChecked: total, renderedPages: renderedCount }
       );
     }
-    return this.fail(
-      `Homepage has minimal server-rendered content (${wordCount2} words, ${mainText2.length} characters). AI agents cannot read client-side-only rendered content.`,
-      "Homepage <main> has > 50 words or > 200 characters of text content",
-      `${wordCount2} words, ${mainText2.length} characters`,
-      {
-        priority: "critical",
-        description: "AI crawlers like GPTBot and ClaudeBot do not execute JavaScript. Content only visible after JS execution is completely invisible to them, meaning your site effectively has no content in AI knowledge bases. Use SSR (server-side rendering) or SSG (static site generation) to serve content in the initial HTML response.",
-        code: "// Next.js SSR example:\nexport async function getServerSideProps() {\n  const data = await fetchData();\n  return { props: { data } };\n}"
-      },
-      page.url
+    const failGuidance = {
+      priority: "critical",
+      description: "AI crawlers like GPTBot and ClaudeBot do not execute JavaScript. Content only visible after JS execution is completely invisible to them, meaning your site effectively has no content in AI knowledge bases. Use SSR (server-side rendering) or SSG (static site generation) to serve content in the initial HTML response.",
+      code: "// Next.js SSR example:\nexport async function getServerSideProps() {\n  const data = await fetchData();\n  return { props: { data } };\n}"
+    };
+    if (renderedCount === 0) {
+      return withDetails(
+        this.fail(
+          `None of the ${total} fetched page(s) serve readable content in the HTML response. AI agents cannot read client-side-only rendered content.`,
+          expected,
+          found,
+          failGuidance,
+          pages[0].url
+        ),
+        { pagesChecked: total, renderedPages: 0, emptyPages }
+      );
+    }
+    return withDetails(
+      this.warn(
+        `${emptyPages.length} of ${total} fetched page(s) serve no readable content in the HTML response. AI agents read nothing on those pages.`,
+        expected,
+        found,
+        failGuidance,
+        emptyPages[0]
+      ),
+      { pagesChecked: total, renderedPages: renderedCount, emptyPages }
     );
   }
 };
@@ -13315,6 +13910,7 @@ var CssHiddenGhostContentAudit = class _CssHiddenGhostContentAudit extends Audit
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/content-extraction/css-hidden-ghost-content.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     defaultPriority: "medium",
     guidance: {
       impact: "This is provable from source, not inferred. Readability's visibility test consults only node.style.display, node.style.visibility, the hidden attribute and aria-hidden \u2014 it explicitly does not evaluate class-based CSS rules from stylesheets. AI crawlers do not render, so no cascade is ever computed. Therefore any subtree hidden by `.mobile-only{display:none}`, `.tab-panel:not(.active){display:none}` or `[data-state=closed]{display:none}` reaches the model as ordinary body text with full weight. Consequence is not just cost: the agent sees three parallel copies of a nav, both the collapsed and expanded FAQ answers, and often stale price text from a hidden variant block, and irrelevant/contradictory context measurably degrades answers.",
@@ -13333,6 +13929,13 @@ var CssHiddenGhostContentAudit = class _CssHiddenGhostContentAudit extends Audit
     };
   }
   async audit(ctx) {
+    if (!scanReadTheSite(ctx.evidence)) {
+      return this.notApplicable(
+        "No page here can be attributed to this site, so its hidden text was not measured.",
+        EXPECTED11,
+        unreadSiteReason(ctx.evidence)
+      );
+    }
     const s = await survey2(ctx);
     const partial = s.crossOrigin > 0 ? `; ${s.crossOrigin} cross-origin stylesheet not fetched` : "";
     if (s.totalChars === 0) {
@@ -13493,6 +14096,7 @@ var HydrationPayloadShareAudit = class _HydrationPayloadShareAudit extends Audit
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/content-extraction/hydration-payload-share.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     defaultPriority: "medium",
     guidance: {
       impact: "These blobs are inlined into every HTML response by design, and the framework vendor itself flags > 128 kB as a defect. A browser parses them and throws them away after hydration; a non-rendering AI crawler cannot \u2014 it tokenizes the JSON verbatim, including escaped HTML, CDN image variants, GraphQL type metadata and the full body text a second time. The causal claim is falsifiable per page: strip these script nodes, re-tokenize, and the delta is the exact context cost that carries zero incremental information, since duplicate #3 is byte-identical content the agent already has.",
@@ -13647,6 +14251,7 @@ var PreambleTaxTokensBeforeTheFirstContentTokenAudit = class extends Audit {
     weight: weightForGrade("B", "scored"),
     defaultPriority: "medium",
     dossier: "docs/evidence/audits/content-extraction/preamble-tax.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     guidance: {
       impact: "A non-rendering agent ingests the document as a linear stream, so DOM order is context order. A page that inlines a critical-CSS block and a serialized state blob ahead of its content does two things at once: it pushes the answer into the middle of the context window, where retrieval is measurably weakest, and it guarantees the answer is what gets cut when the fetching harness truncates to a byte or token cap.",
       fix: "Move inline `<style>` and `<script>` blocks below the main content or into external files, and put `<main>` as early in the body as the layout allows. Where critical CSS must be inline, keep it to the rules that paint the first screen rather than the whole stylesheet.",
@@ -13667,6 +14272,13 @@ var PreambleTaxTokensBeforeTheFirstContentTokenAudit = class extends Audit {
     }
   };
   audit(ctx) {
+    if (!scanReadTheSite(ctx.evidence)) {
+      return this.notApplicable(
+        "No page here can be attributed to this site, so its preamble was not measured.",
+        "A page from this site whose preamble can be measured",
+        unreadSiteReason(ctx.evidence)
+      );
+    }
     const page = ctx.pages[0];
     if (!page) {
       return this.notApplicable(
@@ -13791,6 +14403,7 @@ var BoilerplateTaxAudit = class extends Audit {
     weight: weightForGrade("B", "scored"),
     defaultPriority: "medium",
     dossier: "docs/evidence/audits/content-extraction/boilerplate-tax.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     guidance: {
       impact: "An agent answering a question about a site fetches several of its pages. If each fetch delivers the same navigation, the same promotional header and the same footer around a thin body, the agent pays for those tokens once per fetch and learns nothing new from them. The cost compounds with every page, and the distinct content it came for competes for what is left of the context window.",
       fix: "Cut repeated chrome down to what a reader needs on every page: collapse mega-menus to a short nav, move legal and marketing boilerplate to the pages that are about it, and let each page carry more of its own content. Where the chrome must stay for humans, keeping it out of `<main>` at least lets an extractor drop it.",
@@ -13916,6 +14529,7 @@ var ExtractionDeterminismAudit = class extends Audit {
     weight: weightForGrade("B", "scored"),
     defaultPriority: "high",
     dossier: "docs/evidence/audits/content-extraction/extraction-determinism.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     guidance: {
       impact: "Every agent pipeline strips a page down before a model reads it, and they do not all strip the same way. When the extractors disagree, the same URL yields different answers depending on which tool fetched it \u2014 and the page cannot be tested, because there is no single thing it says. When readability declines a page outright, the most widely deployed extractor of the three hands an agent nothing at all.",
       fix: "Put the article in one container \u2014 `<main>` or `<article>` \u2014 with the chrome outside it, and keep the largest block of prose on the page the one you want quoted. Readability keys on paragraph density and link density, so a body split across many small wrappers, or padded with link-heavy blocks, is what makes the three disagree.",
@@ -13925,6 +14539,13 @@ var ExtractionDeterminismAudit = class extends Audit {
     }
   };
   audit(ctx) {
+    if (!scanReadTheSite(ctx.evidence)) {
+      return this.notApplicable(
+        "No page here can be attributed to this site, so no extraction could be compared.",
+        "A page from this site whose extraction can be compared",
+        unreadSiteReason(ctx.evidence)
+      );
+    }
     const page = ctx.pages[0];
     if (!page) {
       return this.notApplicable(
@@ -14093,6 +14714,7 @@ var LlmsTxtExistsAudit = class extends Audit {
     evidenceGrade: "C",
     tier: "informative",
     dossier: "docs/evidence/audits/machine-discovery/llms-txt-exists.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     defaultPriority: "low",
     guidance: {
       impact: "Thousands of sites publish an llms.txt, including every major AI lab, but as publishers rather than readers. No vendor documentation names an agent that fetches it, and Google Search Central states Search ignores it. Publishing one is cheap and harmless; it is not a documented path to any AI answer.",
@@ -14173,6 +14795,7 @@ var LlmsTxtStructureAudit = class extends Audit {
     evidenceGrade: "C",
     tier: "informative",
     dossier: "docs/evidence/audits/machine-discovery/llms-txt-structure.md",
+    requires: ["origin-reachable"],
     defaultPriority: "low",
     guidance: {
       impact: "The reference llms.txt parser extracts the blockquote as a `summary` field and the H2 headings as a `sections` map, so a file that carries both is machine-navigable: an agent can read the summary and pick a section instead of consuming the whole file. No vendor documents an agent behaving differently when either element is absent, so this is reported, not scored.",
@@ -14236,6 +14859,7 @@ var LlmsTxtLinkDescriptionsAudit = class extends Audit {
     evidenceGrade: "C",
     tier: "informative",
     dossier: "docs/evidence/audits/machine-discovery/llms-txt-link-descriptions.md",
+    requires: ["origin-reachable"],
     defaultPriority: "medium",
     guidance: {
       impact: "Links without descriptions force AI agents to visit every page to understand its content, wasting crawl budget and slowing down response generation. Described links let agents filter relevant pages instantly.",
@@ -14331,6 +14955,7 @@ var LlmsTxtLinksValidAudit = class extends Audit {
     evidenceGrade: "C",
     tier: "informative",
     dossier: "docs/evidence/audits/machine-discovery/llms-txt-links-valid.md",
+    requires: ["origin-reachable"],
     defaultPriority: "low",
     guidance: {
       impact: "A broken link inside llms.txt points at nothing, the same as a broken link anywhere else. No documented agent consumer reads the file, so the cost is to any human or tool that follows it, not to a measured AI outcome.",
@@ -14412,6 +15037,7 @@ var LlmsFullTxtAudit = class extends Audit {
     evidenceGrade: "C",
     tier: "informative",
     dossier: "docs/evidence/audits/machine-discovery/llms-full-txt.md",
+    requires: ["origin-reachable"],
     defaultPriority: "high",
     guidance: {
       impact: "Without llms-full.txt, AI agents must crawl your site page by page, which is slow and often incomplete. This means AI assistants give shallow or outdated answers about your products and services.",
@@ -14423,6 +15049,13 @@ var LlmsFullTxtAudit = class extends Audit {
     }
   };
   audit(ctx) {
+    if (!scanReadTheSite(ctx.evidence)) {
+      return this.notApplicable(
+        "No response here can be attributed to this site, so no llms-full.txt was judged.",
+        "GET /llms-full.txt returns 200",
+        unreadSiteReason(ctx.evidence)
+      );
+    }
     const result = ctx.rootFiles["/llms-full.txt"];
     if (!result || !isOk5(result)) {
       return this.fail(
@@ -14480,6 +15113,7 @@ var SitemapExistsAudit = class extends Audit {
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/machine-discovery/sitemap-exists.md",
+    requires: ["origin-reachable"],
     defaultPriority: "critical",
     guidance: {
       impact: "Without a sitemap, AI crawlers must discover your pages solely through link-following, which is slow and incomplete. Pages deep in your site hierarchy may never be found, meaning AI search engines like Perplexity and ChatGPT Browse cannot surface your full content.",
@@ -14619,6 +15253,7 @@ var DiscoveryIndexCoverageAudit = class extends Audit {
     evidenceGrade: "B",
     tier: "scored",
     dossier: "docs/evidence/audits/machine-discovery/discovery-index-coverage.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     defaultPriority: "medium",
     guidance: {
       impact: "A page listed in no discovery index is reachable only through the link graph, and the major AI crawlers do not execute JavaScript \u2014 so a page missing from both the sitemap and llms.txt can stay invisible to AI search even though it exists on your site.",
@@ -14751,6 +15386,7 @@ var SitemapAbsoluteUrlsAudit = class extends Audit {
     evidenceGrade: "B",
     tier: "scored",
     dossier: "docs/evidence/audits/machine-discovery/sitemap-absolute-urls.md",
+    requires: ["origin-reachable"],
     defaultPriority: "high",
     guidance: {
       impact: "Relative URLs in your sitemap cannot be resolved by AI crawlers, causing them to silently skip those pages. Any page listed with a relative URL is effectively invisible to AI search engines.",
@@ -14855,6 +15491,7 @@ var SitemapLastmodAudit = class extends Audit {
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/machine-discovery/sitemap-lastmod.md",
+    requires: ["origin-reachable"],
     defaultPriority: "medium",
     guidance: {
       impact: "Without <lastmod> dates, AI crawlers must re-fetch every page on every visit because they cannot tell which pages have changed. This wastes crawl budget and delays indexing of your freshest content.",
@@ -14991,6 +15628,7 @@ var RssFeedAudit = class extends Audit {
     evidenceGrade: "B",
     tier: "scored",
     dossier: "docs/evidence/audits/machine-discovery/rss-feed.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     defaultPriority: "medium",
     guidance: {
       impact: "Without an RSS/Atom feed, AI agents have no efficient way to track new and updated content on your site. They must re-crawl your entire site to find changes, which means your latest posts and pages may take much longer to appear in AI search results.",
@@ -15001,6 +15639,13 @@ var RssFeedAudit = class extends Audit {
     }
   };
   async audit(ctx) {
+    if (!scanReadTheSite(ctx.evidence)) {
+      return this.notApplicable(
+        "No response here can be attributed to this site, so no feed was judged.",
+        "Feed returns HTTP 200",
+        unreadSiteReason(ctx.evidence)
+      );
+    }
     const links = autodiscoveryLinks(ctx);
     const feed = await findFeedResult(ctx, links);
     const linkNote = links.length > 0 ? `autodiscovery <link> present (${links[0].url})` : "no autodiscovery <link> in <head>";
@@ -15079,6 +15724,7 @@ var RssFeedContentAudit = class extends Audit {
     evidenceGrade: "C",
     tier: "informative",
     dossier: "docs/evidence/audits/machine-discovery/rss-feed-content.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     defaultPriority: "medium",
     guidance: {
       impact: "Truncated RSS feed items force AI agents to visit each page individually, increasing crawl time and often resulting in incomplete indexing. Full-content feeds let agents ingest all your articles in a single request, producing richer AI-generated answers.",
@@ -15234,6 +15880,7 @@ var InContentLinksAudit = class extends Audit {
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/machine-discovery/in-content-links.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     defaultPriority: "medium",
     guidance: {
       impact: "Google can only crawl a link that is an <a> element with an href, and the measured behaviour of GPTBot and ClaudeBot is that they do not execute JavaScript \u2014 so a page whose only links are in a client-rendered nav is a dead end for them. Links inside the body copy also tell an agent which pages belong together, which template chrome (identical on every page) cannot.",
@@ -15310,6 +15957,7 @@ var NoBrokenLinksAudit = class _NoBrokenLinksAudit extends Audit {
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/machine-discovery/no-broken-links.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     defaultPriority: "high",
     guidance: {
       impact: "Broken internal links waste AI crawlers' limited crawl budget by sending them to dead ends. This means fewer of your pages get indexed, and users asking AI about your site may encounter errors or missing information.",
@@ -15410,6 +16058,7 @@ var CorsAiFilesAudit = class extends Audit {
     evidenceGrade: "C",
     tier: "informative",
     dossier: "docs/evidence/audits/machine-discovery/cors-ai-files.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     defaultPriority: "medium",
     guidance: {
       impact: "Browser-based AI tools, ChatGPT plugins, and MCP clients all run in browser contexts governed by the same-origin policy. Without CORS headers on your llms.txt and AI catalog, these agents receive a network error instead of your content \u2014 making your AI-facing files completely invisible to the fastest-growing category of AI consumers.",
@@ -15531,6 +16180,7 @@ var AiFileDeliveryAudit = class extends Audit {
     evidenceGrade: "B",
     tier: "informative",
     dossier: "docs/evidence/audits/machine-discovery/ai-file-delivery.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     defaultPriority: "medium",
     guidance: {
       impact: "Incorrect Content-Type headers cause AI agents to misparse your files: JSON served as text/html breaks structured-data extraction, an XML sitemap served as text/plain hides it from crawl discovery, and llms.txt served as application/octet-stream triggers a download instead of a read. Missing caching headers make every agent re-download the full file on each visit rather than revalidating it.",
@@ -15624,6 +16274,7 @@ var NoBrokenAiEndpointsAudit = class extends Audit {
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/machine-discovery/no-broken-ai-endpoints.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     defaultPriority: "high",
     guidance: {
       impact: "Broken URLs in your AI manifest files (ai-catalog.json, llms.txt, navigation.json) cause agents to lose trust in your entire manifest. After encountering broken links, AI systems may stop following any of your listed endpoints, effectively making all your AI-facing resources undiscoverable.",
@@ -15702,6 +16353,15 @@ var NoBrokenAiEndpointsAudit = class extends Audit {
     for (const url of allUrls) {
       if (await isSafeUrl(url)) urls.push(url);
     }
+    if (urls.length === 0) {
+      return this.warn(
+        `${allUrls.length} AI endpoint URL(s) are listed, and none of them could be requested: each names localhost, a private address, or a host that does not resolve.`,
+        "All URLs from AI-related files return 200",
+        `${allUrls.length} URL(s) listed, 0 reachable to check`,
+        void 0,
+        page?.url
+      );
+    }
     const results = await Promise.all(
       urls.map(async (url) => {
         try {
@@ -15893,6 +16553,7 @@ var AiCrawlerSurfaceReachabilityAudit = class extends Audit {
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/machine-discovery/ai-crawler-surface-reachability.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     defaultPriority: "high",
     guidance: {
       impact: "The Sitemap: directive is host-global and user-agent independent (RFC 9309 \xA72.2.3), but the sitemap file, the feed files and every URL they list obey per-crawler rules \u2014 and under \xA72.2.1 a crawler with a named group ignores the '*' group entirely. OpenAI documents the consequence at the extreme: 'Sites that are opted out of OAI-SearchBot will not be shown in ChatGPT search answers.' So for any crawler whose named group disallows the advertised sitemap or feed path, or a majority of the URLs the sitemap lists, the site's whole pull-indexing surface is unreachable to that agent no matter how good the sitemap is. The common trigger is a bot-blocking plugin adding a broad pattern (Disallow: /*.xml$, Disallow: /feed/, Disallow: /) to an AI-bot group while the site keeps advertising those exact paths.",
@@ -16078,6 +16739,7 @@ var SitemapLastmodVerifiabilityAudit = class extends Audit {
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/machine-discovery/sitemap-lastmod-verifiability.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     defaultPriority: "medium",
     guidance: {
       impact: `Google states it uses <lastmod> "if it's consistently and verifiably (for example by comparing to the last modification of the page) accurate". lastmod is therefore a conditional signal an engine silently discards on divergence \u2014 and it is the only freshness hint a pull-based AI crawler gets from a sitemap. If sampled values disagree with every available page-level signal for a material share of URLs, the freshness channel is inert and re-crawl scheduling degrades to organic rediscovery. Two specific pathologies are detectable without guessing: over 90% of URLs sharing one lastmod equal to the last deploy date \u2014 a build stamp, exactly the pattern Google's "copyright date is not significant" rule disqualifies \u2014 and a lastmod in the future relative to the scan, which is never valid.`,
@@ -16459,6 +17121,7 @@ var CheckoutOfferFieldMappingAudit = class _CheckoutOfferFieldMappingAudit exten
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/agentic-commerce/checkout-offer-field-mapping.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     applicablePageTypes: ["product"],
     defaultPriority: "high",
     guidance: {
@@ -16655,6 +17318,7 @@ var AgentCommerceFeedParityAudit = class extends Audit {
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/machine-discovery/agent-commerce-feed-parity.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     defaultPriority: "high",
     guidance: {
       impact: `Google's automatic item updates repair feed/page discrepancies "using the structured data markup the crawlers find on your website", and state that where extractors cannot determine price, availability and condition, "your products will be subject to item-level disapprovals". Merchant Center separately requires that feed availability match the landing page and that price match the landing page and checkout. OpenAI's Product Feed Spec requires a strictly larger per-item set than Google's rich-result minimum: a stable item_id (<=100 chars), brand (<=70), seller_name, target_countries as ISO 3166-1 alpha-2, a plain-text description under 5000 characters, availability from a fixed enum, and price with an ISO 4217 currency. Falsifiable claim: a PDP missing brand, seller, itemCondition-as-URL, a stable SKU or a country signal passes every Google rich-result test yet cannot be reconciled by automatic item updates, so feed rejections are silent and unattributable. Second claim, sharper: where the JSON-LD price disagrees with the price the page renders, automatic item updates overwrite the feed with one value while an agent reading the page quotes the other.`,
@@ -17195,6 +17859,7 @@ var ConditionalRequestSupportAudit = class extends Audit {
     weight: weightForGrade("B", "scored"),
     defaultPriority: "medium",
     dossier: "docs/evidence/audits/machine-discovery/conditional-request-support.md",
+    requires: ["origin-reachable"],
     guidance: {
       impact: 'A crawler that wants to know what changed re-reads your sitemap and your feed on a schedule. If those responses carry no `ETag` and no `Last-Modified`, it cannot ask "has this changed?" \u2014 it can only download the file again, every time, forever. The cost is yours as much as theirs: bandwidth you serve for no new information, and a crawl budget spent re-reading a list instead of fetching the pages on it. A validator that changes on every build is the same cost wearing a correct-looking header.',
       fix: "Emit a strong `ETag` derived from the file\u2019s content, not from the build, and a `Last-Modified` that moves only when the content does. Answer `If-None-Match` and `If-Modified-Since` with 304 and an empty body. Keep `no-store` and `private` off public discovery surfaces \u2014 they tell a crawler not to keep the copy it just paid for.",
@@ -17348,6 +18013,7 @@ var FeedEntryIdentityAndCanonicalIntegrityAudit = class extends Audit {
     weight: weightForGrade("B", "scored"),
     defaultPriority: "medium",
     dossier: "docs/evidence/audits/machine-discovery/feed-entry-identity-and-canonical-integrity.md",
+    requires: ["origin-reachable"],
     guidance: {
       impact: 'A feed is how a consumer tracks what changed without re-crawling the site, and identity is what makes that possible: the id says "this is the same item you saw last time". An entry with no id, or with an id that repeats, forces the consumer to guess \u2014 usually by URL, which is exactly the thing that changes. A link that carries `utm_` parameters or redirects somewhere else creates a second address for one page, so the item the consumer stores is not the page the site considers canonical.',
       fix: "Give every entry a stable id \u2014 an `atom:id` that never changes, or an RSS `<guid>` that is an absolute URL when `isPermaLink` is true \u2014 and never reuse one. Point item links at the canonical URL itself, with no tracking parameters and no redirect in between. Serve the feed as its registered media type, with no byte-order mark before the first element.",
@@ -17527,6 +18193,7 @@ var RootTextFileResolutionIntegrityAudit = class extends Audit {
     weight: weightForGrade("B", "scored"),
     defaultPriority: "medium",
     dossier: "docs/evidence/audits/machine-discovery/root-text-file-resolution-integrity.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     guidance: {
       impact: "IndexNow proves ownership by fetching `https://host/{key}.txt` and byte-comparing the body to the key, and six engines discard the submission when that comparison fails. The same property decides whether any other root `.txt` file means anything: if an origin answers 200 for a path that does not exist, then a 200 for `/llms.txt` is not evidence the file is there. A catch-all rewrite ahead of static file serving turns every one of those signals into noise, with no visible symptom on the site itself.",
       fix: "Serve root-level `.txt` paths from static files and let a missing one answer 404. Order the static-file handler ahead of any SPA or catch-all rewrite, and make sure the rewrite does not cover `*.txt`. Serve `/robots.txt` as `text/plain`, not as `text/html` or `application/octet-stream`.",
@@ -17702,6 +18369,7 @@ var ThreeWayFreshnessLagAudit = class extends Audit {
     weight: weightForGrade("B", "scored"),
     defaultPriority: "medium",
     dossier: "docs/evidence/audits/machine-discovery/three-way-freshness-lag.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     guidance: {
       impact: "A pull-based crawler fetches the sitemap and the feed on a schedule and reads nothing else. When those two surfaces trail the site, everything published in between is discoverable only by link-following, which is the slow path the site published a sitemap to avoid. A feed whose `lastBuildDate` is older than its own newest item is worse than stale: consumers that poll conditionally on that timestamp skip the feed entirely, so the new items are never read at all.",
       fix: "Regenerate the sitemap and the feed when content changes, not on a nightly cron that can fail silently. Stamp `<lastBuildDate>` (or the Atom feed-level `<updated>`) from the newest item at generation time. Order feed items newest-first, since many consumers read only the head. Remove sitemap entries whose URLs 404 or are noindex.",
@@ -17856,6 +18524,7 @@ var WebsubHubAdvertisementAudit = class extends Audit {
     weight: 0,
     defaultPriority: "low",
     dossier: "docs/evidence/audits/machine-discovery/websub-hub-advertisement.md",
+    requires: ["origin-reachable"],
     guidance: {
       impact: "A hub subscription is verified against the feed\u2019s own `rel=self`. When that link is missing, relative, or points at a different URL than the one the feed is served from, verification cannot complete, and the push path degrades to whatever polling cadence subscribers happen to use. The publisher sees a hub that looks configured and no error anywhere. The benefit side is unproven: WebSub is a W3C Recommendation, but no AI answer engine is documented as a subscriber, which is why this audit reports and does not score.",
       fix: "Advertise the hub and the canonical topic URL in the feed\u2019s `Link:` response headers, which is where a subscriber looks first. Emit exactly one `rel=self` with an absolute URL identical to the address the feed is served from, and at least one `rel=hub` over HTTPS. If you run no hub, a hosted one (Google\u2019s pubsubhubbub, Superfeedr, websub.rocks) needs only the two link relations.",
@@ -17999,6 +18668,7 @@ var JsonLdPresentAudit = class extends Audit {
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/structured-data/json-ld-present.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     defaultPriority: "critical",
     guidance: {
       impact: "Without any JSON-LD structured data, AI agents like ChatGPT and Perplexity treat your site as unstructured text with no machine-readable identity. Your brand, products, and services become invisible to AI-powered discovery, search, and recommendation systems.",
@@ -18062,6 +18732,7 @@ var SchemaValidationAudit = class extends Audit {
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/structured-data/schema-validation.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     defaultPriority: "critical",
     guidance: {
       impact: "JSON-LD blocks missing @context or @type are silently ignored by every schema consumer, including Google, ChatGPT plugins, and RAG pipelines. Even if you have structured data on the page, invalid blocks provide zero value to AI agents.",
@@ -18188,6 +18859,7 @@ var OrganizationSchemaAudit = class extends Audit {
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/structured-data/organization-schema.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     applicablePageTypes: ["homepage"],
     defaultPriority: "high",
     guidance: {
@@ -18291,6 +18963,7 @@ var BreadcrumbSchemaAudit = class extends Audit {
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/structured-data/breadcrumb-schema.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     applicablePageTypes: ["category", "product", "content"],
     defaultPriority: "medium",
     guidance: {
@@ -18413,6 +19086,7 @@ var ArticleSchemaAudit = class extends Audit {
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/structured-data/article-schema.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     applicablePageTypes: ["content"],
     defaultPriority: "high",
     guidance: {
@@ -18539,6 +19213,7 @@ var FaqPageSchemaAudit = class extends Audit {
     evidenceGrade: "C",
     tier: "informative",
     dossier: "docs/evidence/audits/structured-data/faqpage-schema.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     defaultPriority: "medium",
     guidance: {
       impact: "AI answer engines like Perplexity and Google SGE give priority to FAQ-structured content for direct answers. Without FAQPage schema, your Q&A content is treated as unstructured text and is less likely to be surfaced as a featured answer in AI-generated responses.",
@@ -18692,6 +19367,7 @@ var ServiceSchemaAudit = class _ServiceSchemaAudit extends Audit {
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/structured-data/service-schema.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     // Where a service business publishes its offerings. NOT ['product'] —
     // that was inherited from the pre-split audit and inverted this check:
     // it skipped every service site (no product page in the scan) and ran only
@@ -18835,6 +19511,7 @@ var SpeakableSchemaAudit = class _SpeakableSchemaAudit extends Audit {
     evidenceGrade: "B",
     tier: "scored",
     dossier: "docs/evidence/audits/structured-data/speakable-schema.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     // News and article publishing is the whole documented scope of the
     // feature, so a scan with no content page never runs this audit at all.
     // The runtime guard below repeats the precondition for the pages that
@@ -18933,6 +19610,7 @@ var HowToSchemaAudit = class extends Audit {
     evidenceGrade: "C",
     tier: "informative",
     dossier: "docs/evidence/audits/structured-data/howto-schema.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     applicablePageTypes: ["content"],
     defaultPriority: "low",
     guidance: {
@@ -19081,6 +19759,7 @@ var LocalBusinessSchemaAudit = class extends Audit {
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/structured-data/local-business-schema.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     applicablePageTypes: ["homepage"],
     defaultPriority: "medium",
     guidance: {
@@ -19246,6 +19925,7 @@ var ReviewSchemaAudit = class extends Audit {
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/structured-data/review-schema.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     applicablePageTypes: ["homepage", "product"],
     defaultPriority: "medium",
     guidance: {
@@ -19363,6 +20043,7 @@ var AuthorSchemaAudit = class extends Audit {
     evidenceGrade: "C",
     tier: "informative",
     dossier: "docs/evidence/audits/structured-data/author-schema.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     applicablePageTypes: ["content"],
     defaultPriority: "medium",
     guidance: {
@@ -19485,6 +20166,7 @@ var ProductDetailsAudit = class extends Audit {
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/structured-data/advanced-product-details.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     applicablePageTypes: ["product"],
     defaultPriority: "medium",
     guidance: {
@@ -19638,6 +20320,7 @@ var ClaimreviewAdvisoryAudit = class extends Audit {
     evidenceGrade: "A",
     tier: "informative",
     dossier: "docs/evidence/audits/structured-data/claimreview-advisory.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     defaultPriority: "low",
     guidance: {
       impact: "Google's fact check documentation states plainly: 'We're phasing out support for ClaimReview markup in Google Search', with no deprecation date, and notes only one ClaimReview element per page qualifies for rich results. A check that scored ClaimReview coverage as an AI-readiness win would therefore push publishers to invest in a channel its largest documented consumer is actively withdrawing from. FALSIFIABLE and grade A on the evidence, but it measures the state of an external product, not the quality of the site \u2014 which is exactly why it must not contribute to a score.",
@@ -19793,6 +20476,7 @@ var MetaDescriptionAudit = class extends Audit {
     evidenceGrade: "B",
     tier: "scored",
     dossier: "docs/evidence/audits/answer-readiness/meta-description.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     defaultPriority: "high",
     guidance: {
       impact: "Google sometimes uses the meta description as the search snippet when it describes the page more accurately than the body text, and AI Overviews and AI Mode inherit that snippet pipeline. A missing, keyword-stuffed or off-topic description means the summary shown alongside your page is written by someone else.",
@@ -19887,6 +20571,7 @@ var MetaAuthorAudit = class extends Audit {
     evidenceGrade: "C",
     tier: "informative",
     dossier: "docs/evidence/audits/answer-readiness/meta-author.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     applicablePageTypes: ["content"],
     defaultPriority: "medium",
     guidance: {
@@ -19935,6 +20620,7 @@ var UniqueMetaAudit = class extends Audit {
     evidenceGrade: "C",
     tier: "informative",
     dossier: "docs/evidence/audits/answer-readiness/unique-meta.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     defaultPriority: "high",
     guidance: {
       impact: "AI crawlers use title and description pairs to distinguish between pages. Duplicate meta across pages causes agents to merge or skip content, meaning some pages become invisible in AI-generated answers.",
@@ -19945,6 +20631,13 @@ var UniqueMetaAudit = class extends Audit {
     }
   };
   audit(ctx) {
+    if (!scanReadTheSite(ctx.evidence)) {
+      return this.notApplicable(
+        "No page here can be attributed to this site, so its metadata was not judged.",
+        "Each page has a unique title + description combination",
+        unreadSiteReason(ctx.evidence)
+      );
+    }
     const canonicalGroups = /* @__PURE__ */ new Map();
     for (const page of ctx.pages) {
       let canon = (page.meta?.["canonical"] || page.url).trim();
@@ -19961,7 +20654,7 @@ var UniqueMetaAudit = class extends Audit {
     }
     const uniquePages = Array.from(canonicalGroups.values());
     if (uniquePages.length < 2) {
-      return this.pass(
+      return this.notApplicable(
         "Only one distinct canonical page scanned; uniqueness check not applicable.",
         "Each page has a unique title + description combination",
         "1 distinct page scanned"
@@ -20048,6 +20741,7 @@ var CoreOpenGraphAudit = class extends Audit {
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/answer-readiness/core-open-graph.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     defaultPriority: "high",
     guidance: {
       impact: "Link-preview crawlers use Open Graph tags to build the card shown wherever your page is shared, and Google uses og:title and og:site_name as inputs to the title link and site name on a result \u2014 the same labels that carry into AI Overviews source cards. Without them the crawler falls back to guessing.",
@@ -20131,6 +20825,7 @@ var OgTypeAudit = class extends Audit {
     evidenceGrade: "B",
     tier: "scored",
     dossier: "docs/evidence/audits/answer-readiness/og-type.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     defaultPriority: "medium",
     guidance: {
       impact: "AI agents use og:type to classify page content for type-specific handling. Without it, agents treat every page as generic content, missing opportunities for article freshness scoring or product-specific handling.",
@@ -20194,6 +20889,7 @@ var OgImageAltAudit = class extends Audit {
     evidenceGrade: "C",
     tier: "informative",
     dossier: "docs/evidence/audits/answer-readiness/og-image-alt.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     defaultPriority: "medium",
     guidance: {
       impact: "AI agents cannot process images directly and rely on og:image:alt text to understand your page's visual content. Without alt text, the OG image is invisible to text-based AI systems generating answers about your page.",
@@ -20265,6 +20961,7 @@ var FaqSectionsAudit = class _FaqSectionsAudit extends Audit {
     evidenceGrade: "C",
     tier: "informative",
     dossier: "docs/evidence/audits/answer-readiness/faq-sections.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     defaultPriority: "medium",
     guidance: {
       impact: 'FAQ sections with clear question headings are the highest-priority extraction target for AI-generated answers and "People Also Ask" results. Without them, your content misses the most direct path to appearing in AI answer snippets.',
@@ -20359,6 +21056,7 @@ var QuestionHeadingsAudit = class _QuestionHeadingsAudit extends Audit {
     evidenceGrade: "C",
     tier: "informative",
     dossier: "docs/evidence/audits/answer-readiness/question-headings.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     defaultPriority: "medium",
     guidance: {
       impact: "AI answer engines directly match user questions to heading text. Question-formatted headings are the primary signal for identifying which section answers a specific query. Without them, agents must guess which section is relevant, reducing your content's match rate.",
@@ -20527,6 +21225,7 @@ var DatesOnContentAudit = class extends Audit {
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/answer-readiness/dates-on-content.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     applicablePageTypes: ["content"],
     defaultPriority: "medium",
     guidance: {
@@ -20618,6 +21317,7 @@ var FirstParagraphAnswersAudit = class extends Audit {
     evidenceGrade: "C",
     tier: "informative",
     dossier: "docs/evidence/audits/answer-readiness/first-paragraph-answers.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     applicablePageTypes: ["content"],
     defaultPriority: "high",
     guidance: {
@@ -20783,6 +21483,7 @@ var DirectDefinitionsAudit = class extends Audit {
     evidenceGrade: "C",
     tier: "informative",
     dossier: "docs/evidence/audits/answer-readiness/direct-definitions.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     applicablePageTypes: ["content"],
     // Never a defect, so never above the actionable items.
     defaultPriority: "low",
@@ -20841,6 +21542,7 @@ var ComparisonTablesAudit = class _ComparisonTablesAudit extends Audit {
     evidenceGrade: "C",
     tier: "informative",
     dossier: "docs/evidence/audits/answer-readiness/comparison-tables.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     applicablePageTypes: ["category", "product", "content"],
     defaultPriority: "low",
     guidance: {
@@ -20916,6 +21618,7 @@ var SpecificNumbersAudit = class _SpecificNumbersAudit extends Audit {
     evidenceGrade: "B",
     tier: "scored",
     dossier: "docs/evidence/audits/answer-readiness/specific-numbers.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     defaultPriority: "medium",
     guidance: {
       impact: "AI answer engines strongly prefer content with concrete data points over vague claims. Pages with specific numbers, percentages, and metrics are ranked higher for data-driven queries because agents can cite exact figures in generated answers.",
@@ -20974,17 +21677,6 @@ var SpecificNumbersAudit = class _SpecificNumbersAudit extends Audit {
 };
 
 // src/audits/answer-readiness/content-without-clickthrough.ts
-function contentWordCount($) {
-  const main = $("main").first();
-  const extract = (sel) => {
-    const clone = sel.clone();
-    clone.find("script, style, noscript, template").remove();
-    return clone.text().replace(/\s+/g, " ").trim();
-  };
-  let text3 = main.length ? extract(main) : "";
-  if (!text3) text3 = extract($("body"));
-  return text3.split(/\s+/).filter(Boolean).length;
-}
 var TEASER_PATTERNS = [
   /click\s+(here\s+)?to\s+read\s+more/i,
   /contact\s+us\s+to\s+learn/i,
@@ -21007,6 +21699,7 @@ var ContentWithoutClickthroughAudit = class _ContentWithoutClickthroughAudit ext
     evidenceGrade: "B",
     tier: "scored",
     dossier: "docs/evidence/audits/answer-readiness/content-without-clickthrough.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     defaultPriority: "high",
     guidance: {
       impact: 'AI answer engines skip pages dominated by teaser content ("click to read more", "sign up to access"). These pages provide no extractable answers, so agents will never surface your content in AI-generated responses, costing you visibility in AI search.',
@@ -21017,6 +21710,13 @@ var ContentWithoutClickthroughAudit = class _ContentWithoutClickthroughAudit ext
     }
   };
   audit(ctx) {
+    if (!scanReadTheSite(ctx.evidence)) {
+      return this.notApplicable(
+        "No page here can be attributed to this site, so its teasers were not judged.",
+        'No "click to read more" or "contact us to learn" teasers dominating the page',
+        unreadSiteReason(ctx.evidence)
+      );
+    }
     const page = ctx.pages[0];
     if (!page) {
       return this.fail(
@@ -21058,7 +21758,7 @@ var ContentWithoutClickthroughAudit = class _ContentWithoutClickthroughAudit ext
         return !head2.startsWith("<?xml");
       });
       if (checkPage) {
-        const wordCount2 = contentWordCount(checkPage.$);
+        const wordCount2 = getWordCount(checkPage.$);
         if (wordCount2 < 50) {
           return this.warn(
             "Insufficient content to evaluate.",
@@ -21073,6 +21773,13 @@ var ContentWithoutClickthroughAudit = class _ContentWithoutClickthroughAudit ext
           );
         }
       }
+      if (!scanReadPageText(ctx.evidence)) {
+        return this.notApplicable(
+          "The scanned page served no readable text, so there was no content to judge for teasers.",
+          'No "click to read more" or "contact us to learn" teasers dominating the page',
+          unreadPageTextReason(ctx.evidence)
+        );
+      }
       return this.pass(
         "No excessive click-through teasers found.",
         'No "click to read more" or "contact us to learn" teasers dominating the page',
@@ -21149,6 +21856,7 @@ var NamedAuthorAudit = class extends Audit {
     evidenceGrade: "C",
     tier: "informative",
     dossier: "docs/evidence/audits/answer-readiness/named-author.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     applicablePageTypes: ["content"],
     defaultPriority: "high",
     guidance: {
@@ -21275,6 +21983,7 @@ var AuthorSameAsAudit = class extends Audit {
     evidenceGrade: "C",
     tier: "informative",
     dossier: "docs/evidence/audits/answer-readiness/author-same-as.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     applicablePageTypes: ["content"],
     defaultPriority: "medium",
     guidance: {
@@ -21394,6 +22103,7 @@ var AuthorPageAudit = class extends Audit {
     evidenceGrade: "C",
     tier: "informative",
     dossier: "docs/evidence/audits/answer-readiness/author-page.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     applicablePageTypes: ["content"],
     defaultPriority: "medium",
     guidance: {
@@ -21528,6 +22238,7 @@ var AboutCredentialsAudit = class extends Audit {
     evidenceGrade: "C",
     tier: "informative",
     dossier: "docs/evidence/audits/answer-readiness/about-credentials.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     defaultPriority: "medium",
     guidance: {
       impact: "AI engines crawl your about page to build an organizational authority profile. Without credential-rich content (team bios, expertise areas, certifications), agents cannot assess your organization's authority, reducing your content's trust score in AI-generated recommendations.",
@@ -21637,6 +22348,7 @@ var ExternalCitationsAudit = class extends Audit {
     evidenceGrade: "B",
     tier: "scored",
     dossier: "docs/evidence/audits/answer-readiness/external-citations.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     applicablePageTypes: ["content"],
     defaultPriority: "medium",
     guidance: {
@@ -21751,6 +22463,7 @@ var BrandNameAudit = class extends Audit {
     evidenceGrade: "C",
     tier: "informative",
     dossier: "docs/evidence/audits/answer-readiness/brand-name.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     defaultPriority: "medium",
     guidance: {
       impact: "AI engines build entity graphs by matching Organization schema names to in-content mentions. If your brand name only appears in schema but not body text, agents cannot associate your content with your entity, weakening brand recognition in AI responses.",
@@ -21845,7 +22558,7 @@ function statesZeroReviews(record3) {
   }
   return false;
 }
-function readableText(page) {
+function readableText2(page) {
   const body = page.$("body").clone();
   body.find("script, style, noscript, template").remove();
   return body.text().replace(/\s+/g, " ").trim();
@@ -21946,6 +22659,7 @@ var ReviewSignalsAudit = class extends Audit {
     evidenceGrade: "B",
     tier: "scored",
     dossier: "docs/evidence/audits/answer-readiness/review-signals.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     applicablePageTypes: ["homepage", "product"],
     defaultPriority: "medium",
     guidance: {
@@ -21993,7 +22707,7 @@ var ReviewSignalsAudit = class extends Audit {
       ).toArray().filter((el) => p.$(el).text().trim() !== "" || p.$(el).children().length > 0);
       if (widget.length > 0) {
         noteWeak("review widget markup", p.url);
-      } else if (/\b\d[\d,]*\s+reviews?\b/i.test(readableText(p))) {
+      } else if (/\b\d[\d,]*\s+reviews?\b/i.test(readableText2(p))) {
         noteWeak('"N reviews" text', p.url);
       }
     }
@@ -22053,7 +22767,7 @@ function isNonEnglish(page) {
   const lang = (page.$("html").attr("lang") ?? "").trim().toLowerCase();
   return lang !== "" && !lang.startsWith("en");
 }
-function readableText2(page) {
+function readableText3(page) {
   const body = page.$("body").clone();
   body.find("script, style, noscript, template").remove();
   return body.text().replace(/\s+/g, " ").trim();
@@ -22105,6 +22819,7 @@ var TrustSignalsAudit = class _TrustSignalsAudit extends Audit {
     evidenceGrade: "B",
     tier: "scored",
     dossier: "docs/evidence/audits/answer-readiness/trust-signals.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     applicablePageTypes: ["homepage"],
     defaultPriority: "low",
     guidance: {
@@ -22132,7 +22847,7 @@ var TrustSignalsAudit = class _TrustSignalsAudit extends Audit {
         "Non-English homepage \u2014 detector not applicable"
       );
     }
-    const text3 = readableText2(page);
+    const text3 = readableText3(page);
     const satisfied = [];
     const missing = [];
     let counted = 0;
@@ -22242,6 +22957,7 @@ var PublicationDateAudit = class extends Audit {
     evidenceGrade: "B",
     tier: "scored",
     dossier: "docs/evidence/audits/answer-readiness/publication-date.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     applicablePageTypes: ["content"],
     defaultPriority: "medium",
     guidance: {
@@ -22338,6 +23054,7 @@ var LastModifiedSchemaAudit = class extends Audit {
     evidenceGrade: "B",
     tier: "scored",
     dossier: "docs/evidence/audits/answer-readiness/last-modified-schema.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     applicablePageTypes: ["content"],
     defaultPriority: "medium",
     guidance: {
@@ -22424,6 +23141,7 @@ var UniqueDataAudit = class extends Audit {
     evidenceGrade: "B",
     tier: "scored",
     dossier: "docs/evidence/audits/answer-readiness/unique-data.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     defaultPriority: "medium",
     guidance: {
       impact: "AI generative engines prioritize content with unique, citable data points because agents can quote exact figures in generated answers. Content without specific numbers reads as opinion rather than evidence, reducing its chances of being cited.",
@@ -22521,6 +23239,8 @@ var DescriptiveUrlsAudit = class extends Audit {
     evidenceGrade: "C",
     tier: "informative",
     dossier: "docs/evidence/audits/answer-readiness/descriptive-urls.md",
+    // Gate exemption: a URL is readable whether or not the page behind it rendered text.
+    requires: ["origin-reachable", "unblocked-fetches"],
     defaultPriority: "high",
     guidance: {
       impact: "AI engines use URL text as a pre-fetch topic signal and display URLs in generated citations. Non-descriptive slugs with UUIDs or numeric IDs provide no topical context, reducing your content's relevance score before the page is even crawled.",
@@ -22531,6 +23251,13 @@ var DescriptiveUrlsAudit = class extends Audit {
     }
   };
   audit(ctx) {
+    if (!scanReadTheSite(ctx.evidence)) {
+      return this.notApplicable(
+        "No page here can be attributed to this site, so its URLs were not judged.",
+        "Page URLs use readable slugs (no UUIDs, no /post-123/, no encoded params)",
+        unreadSiteReason(ctx.evidence)
+      );
+    }
     const page = ctx.pages[0];
     if (!page) {
       return this.fail(
@@ -22776,6 +23503,7 @@ var SnippetGateCoverageAudit = class _SnippetGateCoverageAudit extends Audit {
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/answer-readiness/snippet-gate-coverage.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     defaultPriority: "high",
     guidance: {
       impact: "Google states the eligibility gate directly: to appear as a supporting link a page 'must be indexed and eligible to be shown in Google Search with a snippet', and names nosnippet, data-nosnippet, max-snippet and noindex as the controls that limit what AI Overviews and AI Mode can show. This makes the causal chain fully documented rather than inferred: a max-snippet value shorter than the answer sentence truncates the answer below usefulness, and data-nosnippet wrapping the answer removes it from AI surfaces entirely while leaving it visible to humans \u2014 an invisible failure that page-level SEO reports do not surface because the directive itself is technically 'valid'.",
@@ -22794,6 +23522,13 @@ var SnippetGateCoverageAudit = class _SnippetGateCoverageAudit extends Audit {
     };
   }
   audit(ctx) {
+    if (!scanReadTheSite(ctx.evidence)) {
+      return this.notApplicable(
+        "No page here can be attributed to this site, so snippet permissions were not resolved.",
+        EXPECTED22,
+        unreadSiteReason(ctx.evidence)
+      );
+    }
     const page = ctx.pages[0];
     if (!page) {
       return this.notApplicable(
@@ -22988,6 +23723,7 @@ var TextFragmentAddressabilityAudit = class _TextFragmentAddressabilityAudit ext
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/answer-readiness/text-fragment-addressability.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     defaultPriority: "medium",
     guidance: {
       impact: "Google Search auto-generates text-fragment URLs to land users on the exact featured-snippet text, and the spec requires each of prefix/start/end/suffix to match within a single block-level element. When an answer sentence is fragmented across block boundaries, or the header opt-out is set, the fragment silently fails and the link degrades to page-top. Falsifiable and directly testable: take the citing surface\u2019s own generated URL, load it, and observe whether the browser scrolls and highlights. Two failure classes are binary and deterministic \u2014 the opt-out header, and a start string that straddles two blocks.",
@@ -23135,6 +23871,7 @@ var ChunkBoundaryReferentIntegrityAudit = class extends Audit {
     weight: weightForGrade("B", "scored"),
     defaultPriority: "high",
     dossier: "docs/evidence/audits/answer-readiness/chunk-boundary-referent-integrity.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     guidance: {
       impact: 'An answer engine retrieves a passage, not a page. A section that opens "This means you should..." and never names its subject is unusable on arrival: the model either drops it or attributes it to whatever else is in the window. The fix is per-sentence and cheap, and it is invisible to a reader of the whole page \u2014 which is why it survives editing.',
       fix: 'Open each section with its subject rather than a pronoun, name the product or topic once in every section over about forty words, and replace "as described above" with the name of the thing described.',
@@ -23266,6 +24003,13 @@ function chainOf($, el) {
   const parents = $(el).parents().toArray().filter((parent) => !["html", "body"].includes(parent.tagName)).reverse().map(describe3);
   return [...parents, describe3(el)].join(" > ");
 }
+function lastElementContaining($, text3) {
+  const all = $("*").toArray();
+  for (let i = all.length - 1; i >= 0; i--) {
+    if ($(all[i]).text().includes(text3)) return all[i];
+  }
+  return void 0;
+}
 function needleOf(text3) {
   return normalizeText(text3).split(" ").slice(0, SPAN_WORDS).join(" ");
 }
@@ -23298,8 +24042,8 @@ function keySpans(page) {
       if (typeof value === "string") {
         const needle = needleOf(value);
         if (needle.split(" ").length >= 3 && bodyText.includes(needle)) {
-          const host = $(`:contains("${value.slice(0, 40).replace(/"/g, "")}")`).last();
-          push("json-ld", host[0] ?? $("body")[0], value);
+          const host = lastElementContaining($, value.slice(0, 40));
+          push("json-ld", host ?? $("body")[0], value);
         }
         return;
       }
@@ -23333,6 +24077,7 @@ var ExtractorSurvivalRecallAudit = class extends Audit {
     weight: weightForGrade("B", "scored"),
     defaultPriority: "high",
     dossier: "docs/evidence/audits/answer-readiness/extractor-survival-recall.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     guidance: {
       impact: 'An answer engine never sees the page; it sees whatever its extractor kept. A specification table inside `<aside class="related-specs">` is invisible to every pipeline that strips asides, and the answer about that product gets written without it. The loss is silent: the page looks complete to its author and to every human reviewer.',
       fix: 'Put facts inside the main content container, not in an aside, a footer, or a block whose class says "related" or "promo". Where a table must sit outside the article, repeat its facts in the prose so at least one copy survives.',
@@ -23342,6 +24087,13 @@ var ExtractorSurvivalRecallAudit = class extends Audit {
     }
   };
   audit(ctx) {
+    if (!scanReadTheSite(ctx.evidence)) {
+      return this.notApplicable(
+        "No page here can be attributed to this site, so no key span was measured.",
+        "A page from this site whose key spans can be measured",
+        unreadSiteReason(ctx.evidence)
+      );
+    }
     const page = ctx.pages[0];
     if (!page) {
       return this.notApplicable(
@@ -23465,6 +24217,7 @@ var SectionSplitRiskProfileAudit = class extends Audit {
     weight: weightForGrade("B", "scored"),
     defaultPriority: "medium",
     dossier: "docs/evidence/audits/answer-readiness/section-split-risk-profile.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     guidance: {
       impact: "Retrieval pipelines cut pages into fixed windows. A section longer than the window becomes one chunk carrying the heading and one or more tail chunks carrying none \u2014 and a tail chunk is text with no subject, which retrieves badly and cites worse. A page with no headings at all is cut at arbitrary offsets throughout.",
       fix: "Add an `h2` or `h3` roughly every 400 tokens of prose, and split a specification table that runs past the window into per-topic tables so the header row stays with its rows.",
@@ -23654,6 +24407,7 @@ var SiteWidePassageUniquenessRatioAudit = class extends Audit {
     weight: weightForGrade("B", "scored"),
     defaultPriority: "medium",
     dossier: "docs/evidence/audits/answer-readiness/site-wide-passage-uniqueness-ratio.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     guidance: {
       impact: "A search engine clusters duplicate and near-duplicate URLs and elects one canonical; the losers have their signals folded into the winner. A cluster of near-duplicate pages that each name themselves canonical therefore competes against itself, and at most one member stays citable however good the others are. Separately, a page whose sentences are mostly site-wide template produces chunks whose embeddings encode the template rather than the page, so every page built from that template lands in the same place in vector space and none is a distinctive match for any question.",
       fix: 'Merge near-duplicate pages into one, or point the weaker members at the strongest with rel="canonical" so the election has an answer. For pages that stay, raise the share of text that is theirs alone: cut the repeated intro, the repeated legal paragraph and the repeated call to action, and let each page carry the sentences only it can carry.',
@@ -23887,6 +24641,7 @@ var TableMarkdownRoundTripLossAudit = class extends Audit {
     weight: weightForGrade("B", "scored"),
     defaultPriority: "medium",
     dossier: "docs/evidence/audits/answer-readiness/table-markdown-round-trip-loss.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     guidance: {
       impact: "A model does not read your table markup. Something converts it to markdown first, and GFM markdown has no merged cells, no second header row and no lists inside a cell. A header spanning two columns arrives heading one of them; the other column of numbers arrives with no header at all. The model still answers the question \u2014 with a number read from the wrong column, stated as confidently as a right one.",
       fix: "Flatten spanned headers into one header row of plain `th` cells, repeating the text where a span used to cover two columns. Put the unit or currency in the header cell rather than in the caption. Take paragraphs and lists out of cells. Where a table is genuinely two tables, publish it as two.",
@@ -24154,6 +24909,7 @@ var OpenApiExistsAudit = class _OpenApiExistsAudit extends Audit {
     evidenceGrade: "B",
     tier: "informative",
     dossier: "docs/evidence/audits/agent-interfaces/openapi-exists.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     defaultPriority: "medium",
     guidance: {
       impact: "An agent that cannot find your API description cannot call it. Note that every documented consumer today (GPT Actions, Microsoft 365 Copilot API plugins) receives the document from a developer rather than fetching it from your site, so this check is informative and unscored.",
@@ -24294,6 +25050,7 @@ var OpenApiEndpointsAudit = class _OpenApiEndpointsAudit extends Audit {
     evidenceGrade: "B",
     tier: "scored",
     dossier: "docs/evidence/audits/agent-interfaces/openapi-endpoints.md",
+    requires: ["origin-reachable"],
     defaultPriority: "high",
     guidance: {
       impact: "An OpenAPI spec without endpoints is unusable -- AI agents see a spec file but have zero actions they can perform. Your site remains a passive document that agents cannot interact with programmatically.",
@@ -24421,6 +25178,7 @@ var OpenApiOperationIdsAudit = class _OpenApiOperationIdsAudit extends Audit {
     evidenceGrade: "B",
     tier: "scored",
     dossier: "docs/evidence/audits/agent-interfaces/openapi-operation-ids.md",
+    requires: ["origin-reachable"],
     defaultPriority: "medium",
     guidance: {
       impact: "AI agents use operationIds as stable function names when calling your API. Without unique operationIds, agents must infer endpoint names from URL paths, leading to ambiguous calls, naming collisions, and broken integrations.",
@@ -24600,6 +25358,7 @@ var OpenApiServersAudit = class _OpenApiServersAudit extends Audit {
     evidenceGrade: "B",
     tier: "scored",
     dossier: "docs/evidence/audits/agent-interfaces/openapi-servers.md",
+    requires: ["origin-reachable"],
     defaultPriority: "high",
     guidance: {
       impact: "Without a servers array, AI agents cannot determine the base URL for your API. Even if your endpoints are perfectly documented, agents cannot construct valid request URLs, rendering the entire OpenAPI spec unusable.",
@@ -24764,6 +25523,7 @@ var OpenApiSchemasAudit = class _OpenApiSchemasAudit extends Audit {
     evidenceGrade: "B",
     tier: "scored",
     dossier: "docs/evidence/audits/agent-interfaces/openapi-schemas.md",
+    requires: ["origin-reachable"],
     defaultPriority: "medium",
     guidance: {
       impact: "Without request/response schemas, AI agents must guess what data to send and what to expect back. This leads to malformed requests, failed API calls, and agents that cannot reliably use your endpoints.",
@@ -25168,6 +25928,7 @@ var AiCatalogExistsAudit = class _AiCatalogExistsAudit extends Audit {
     evidenceGrade: "C",
     tier: "informative",
     dossier: "docs/evidence/audits/agent-interfaces/ai-catalog-exists.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     defaultPriority: "medium",
     guidance: {
       impact: "Without an AI catalog, agents must probe multiple endpoints to discover your services. This wastes time, increases error rates, and often results in agents skipping your site entirely in favor of competitors with a machine-readable capability manifest.",
@@ -25288,6 +26049,7 @@ var AiCatalogMetadataAudit = class _AiCatalogMetadataAudit extends Audit {
     evidenceGrade: "B",
     tier: "scored",
     dossier: "docs/evidence/audits/agent-interfaces/ai-catalog-metadata.md",
+    requires: ["origin-reachable"],
     defaultPriority: "medium",
     guidance: {
       impact: "A thin catalog entry is a catalog entry nobody finds. Consumers match a user query against the entry text, so entries with no description, tags, capabilities or representative queries lose to better-described alternatives even when your service is the better answer.",
@@ -25423,6 +26185,7 @@ var AiCatalogUrlsAudit = class _AiCatalogUrlsAudit extends Audit {
     evidenceGrade: "B",
     tier: "scored",
     dossier: "docs/evidence/audits/agent-interfaces/ai-catalog-urls.md",
+    requires: ["origin-reachable"],
     defaultPriority: "medium",
     guidance: {
       impact: "A broken entry url makes an agent fail mid-task: it read your manifest, followed the link you published, and got nothing. Entries whose url points at a nested catalog or registry cut off everything behind them as well.",
@@ -25550,6 +26313,7 @@ var AgentsJsonAudit = class extends Audit {
     evidenceGrade: "C",
     tier: "informative",
     dossier: "docs/evidence/audits/agent-interfaces/agents-json.md",
+    requires: ["origin-reachable"],
     defaultPriority: "low",
     guidance: {
       impact: "Publishing agents.json is not known to make a site reachable to any agent: no vendor documents reading the file, and the specification has been dormant since 2025-08-21. What does matter is that a document already published at a well-known path can be read \u2014 a 200 carrying the site's HTML shell tells a conforming client the resource exists and then gives it nothing to parse, which is worse than a clean 404.",
@@ -25673,6 +26437,7 @@ var McpDiscoveryAudit = class _McpDiscoveryAudit extends Audit {
     evidenceGrade: "C",
     tier: "informative",
     dossier: "docs/evidence/audits/agent-interfaces/mcp-discovery.md",
+    requires: ["origin-reachable"],
     defaultPriority: "medium",
     guidance: {
       impact: "No shipping MCP client is documented as fetching `/.well-known/mcp/servers.json` or `/.well-known/ucp`, so publishing one is not known to make a site reachable to any agent. What does matter is that a document published at a well-known path can be read: a 200 carrying HTML or unparseable JSON tells a conforming client the resource exists and then gives it nothing to parse.",
@@ -25992,6 +26757,7 @@ var McpEndpointAudit = class _McpEndpointAudit extends Audit {
     evidenceGrade: "C",
     tier: "informative",
     dossier: "docs/evidence/audits/agent-interfaces/mcp-endpoint.md",
+    requires: ["origin-reachable"],
     defaultPriority: "high",
     guidance: {
       impact: "If your MCP endpoint does not answer an initialize handshake, AI assistants cannot connect at all. Capabilities and tool annotations come off the same connection: without them an agent cannot tell whether your server offers tools, or which of them are destructive enough to need user confirmation.",
@@ -26289,6 +27055,7 @@ var SearchEndpointAudit = class _SearchEndpointAudit extends Audit {
     evidenceGrade: "C",
     tier: "informative",
     dossier: "docs/evidence/audits/agent-interfaces/search-endpoint.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     defaultPriority: "low",
     guidance: {
       impact: 'Without a declared search endpoint, an agent asked to "find pricing info on Example.com" has to crawl the site to answer. Note that no vendor documents an agent that reads SearchAction today \u2014 Google retired its only documented consumer in 2024 \u2014 so this check is informative and unscored.',
@@ -26459,6 +27226,7 @@ var WebmcpRegisteredToolsAudit = class extends Audit {
     // detector that cannot distinguish "no tools" from "cannot see the tools".
     tier: "experimental",
     dossier: "docs/evidence/audits/agent-interfaces/webmcp-registered-tools.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     // Was `high` on an admittedly non-standard convention, so it outranked
     // genuinely actionable items in the recommendation list.
     defaultPriority: "low",
@@ -26574,6 +27342,7 @@ var WebmcpDeclarativeFormsAudit = class extends Audit {
     evidenceGrade: "B",
     tier: "scored",
     dossier: "docs/evidence/audits/agent-interfaces/webmcp-declarative-forms.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     // Softened from 'high': the feature is Baseline "limited" (Chrome 149 /
     // Edge 150 origin trials, Brave Leo experimental) and Apple's WebKit
     // standards position is "oppose", so this is worth doing, not urgent.
@@ -26701,6 +27470,7 @@ var OpenApiDescriptionQualityAudit = class _OpenApiDescriptionQualityAudit exten
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/agent-interfaces/openapi-description-quality.md",
+    requires: ["origin-reachable"],
     defaultPriority: "high",
     guidance: {
       impact: "LLM tool-calling treats your OpenAPI descriptions as the function-calling prompt. Missing or terse descriptions force the model to guess what each endpoint does and what each parameter accepts, producing wrong tool selection, malformed arguments, and failed API calls that erode user trust in agent-driven workflows on your site.",
@@ -26882,6 +27652,7 @@ var CorsApiRoutesAudit = class _CorsApiRoutesAudit extends Audit {
     evidenceGrade: "C",
     tier: "informative",
     dossier: "docs/evidence/audits/agent-interfaces/cors-api-routes.md",
+    requires: ["origin-reachable"],
     // The affected consumer class is small; nothing here should outrank an
     // item that changes what a crawler or an MCP client can do.
     defaultPriority: "low",
@@ -27041,6 +27812,7 @@ var McpModernEraReachabilityAudit = class extends Audit {
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/agent-interfaces/mcp-modern-era-reachability.md",
+    requires: ["origin-reachable"],
     defaultPriority: "high",
     guidance: {
       impact: "Revision 2026-07-28 abolished the `initialize` handshake and protocol-level sessions: version, client identity and capabilities now travel as per-request `_meta`, and `server/discover` is a MUST-implement RPC. The spec's own compatibility matrix states verbatim that a Modern client against a Legacy server FAILS, with no fall-forward path. Therefore: if a single POST of `server/discover` carrying `_meta` + `MCP-Protocol-Version: 2026-07-28` does not yield either a DiscoverResult or a recognized modern JSON-RPC error, then every client that has moved to the current revision cannot invoke a single tool on this server \u2014 the failure is total, not degraded. Conversely a 404/-32601 on `server/discover` from a server that otherwise answers modern requests is a direct MUST violation that breaks pre-consent capability presentation.",
@@ -27291,6 +28063,7 @@ var McpOauthDiscoveryChainAudit = class extends Audit {
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/agent-interfaces/mcp-oauth-discovery-chain.md",
+    requires: ["origin-reachable"],
     defaultPriority: "high",
     guidance: {
       impact: "The spec makes RFC 9728 mandatory for MCP servers and makes clients apply two hard identity checks: RFC 9728 \xA73.3 requires the PRM's `resource` value to be string-identical to the resource identifier used to construct the request URL, and the MCP AS-discovery rules require the fetched AS metadata's `issuer` to be string-identical to the issuer used to construct the well-known URL \u2014 on either mismatch the client MUST NOT use the metadata. MCP additionally strengthens RFC 9728 by requiring `authorization_servers` to carry at least one entry (it is merely OPTIONAL in the RFC). Each of these is a silent, total blocker: the discovery chain either resolves end to end or the agent never reaches an authorization prompt, so a single character of drift between the deployed endpoint URL and the `resource` claim makes the server unusable to every conforming client while the server's own logs show nothing but 401s.",
@@ -27547,6 +28320,7 @@ var McpToolContractValidityAudit = class extends Audit {
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/agent-interfaces/mcp-tool-contract-validity.md",
+    requires: ["origin-reachable"],
     defaultPriority: "critical",
     guidance: {
       impact: "The spec gives clients an explicit deletion instruction: 'Clients using the Streamable HTTP transport MUST reject tool definitions where any x-mcp-header value violates these constraints. Rejection means the client MUST exclude the invalid tool from the result of tools/list.' This makes malformed tool metadata a silent-invisibility bug rather than an error: the server returns the tool, logs a successful tools/list, and the model never sees it. The constraint set is fully machine-checkable with no network calls beyond the one list fetch \u2014 token syntax, no CR/LF, case-insensitive uniqueness, primitive types only with `number` explicitly excluded, and static reachability through a chain consisting solely of `properties` keys. Alongside it, `inputSchema` MUST be a valid JSON Schema object and not null; a null or scalar inputSchema breaks argument construction in every SDK.",
@@ -27803,6 +28577,7 @@ var McpToolsListDeterminismAudit = class extends Audit {
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/agent-interfaces/mcp-tools-list-determinism.md",
+    requires: ["origin-reachable"],
     defaultPriority: "medium",
     guidance: {
       impact: "The spec states its own causal rationale verbatim: deterministic ordering 'enables clients to reliably cache the tool list and improves LLM prompt cache hit rates when tools are included in model context.' Tool definitions sit near the front of the model's prompt; if their serialized bytes change between turns, the provider-side prefix cache misses and the full tool block is re-billed at uncached rates on every single turn. Separately, servers MUST include caching hints on complete results, and when ttlMs is absent clients SHOULD assume 0 \u2014 immediately stale \u2014 so an omitted hint converts one cheap cached read into a network round-trip on every access. Both defects are invisible in functional testing and both are measurable with three identical requests.",
@@ -27987,6 +28762,7 @@ var McpVersionDowngradeAudit = class extends Audit {
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/agent-interfaces/mcp-version-downgrade.md",
+    requires: ["origin-reachable"],
     defaultPriority: "medium",
     guidance: {
       impact: "With the handshake removed, the ONLY mechanism by which a client discovers a mutually supported version mid-flight is the `UnsupportedProtocolVersionError`: the spec requires code -32022 with `data.supported[]` listing the server's versions, and instructs clients to select from that list and retry. A server that instead returns a 500, a generic -32600/-32602, or a 400 with no `supported` array gives the client nothing to downgrade to \u2014 so a client whose preferred version is one revision ahead of the server's fails permanently even though a mutually supported version exists on both sides. Separately, the spec requires the header and the `_meta` value to agree, with a 400 + -32020 HeaderMismatch on divergence; a server that silently ignores the mismatch is trusting whichever source of truth its proxy layer did not, which is the exact split-brain the header-validation rules exist to prevent.",
@@ -28150,6 +28926,7 @@ var McpOriginValidationCorsAudit = class extends Audit {
     weight: weightForGrade("B", "scored"),
     defaultPriority: "high",
     dossier: "docs/evidence/audits/agent-interfaces/mcp-origin-validation-cors.md",
+    requires: ["origin-reachable"],
     guidance: {
       impact: "The transport spec is unambiguous: servers MUST validate the Origin header on all incoming connections, and answer 403 when it is present and invalid, because a server that does not is reachable from any web page the user has open. The provable defect is the CORS pairing: an endpoint that reflects the requesting Origin into `Access-Control-Allow-Origin` and returns `Access-Control-Allow-Credentials: true` has authorized any page to enumerate its tool surface and invoke tools with the user\u2019s session.",
       fix: "Validate `Origin` on every request and answer 403 when it is present and not one you allow. Never reflect an arbitrary Origin while allowing credentials: return a fixed allow-list, or drop `Access-Control-Allow-Credentials`. `Access-Control-Allow-Origin: *` is only safe on an endpoint that accepts no credentials at all.",
@@ -28271,61 +29048,6 @@ var McpOriginValidationCorsAudit = class extends Audit {
   }
 };
 
-// src/gatherers/domains.ts
-var MULTI_SUFFIX = /* @__PURE__ */ new Set([
-  "co.uk",
-  "org.uk",
-  "ac.uk",
-  "gov.uk",
-  "me.uk",
-  "net.uk",
-  "com.au",
-  "net.au",
-  "org.au",
-  "edu.au",
-  "gov.au",
-  "co.nz",
-  "co.jp",
-  "or.jp",
-  "ne.jp",
-  "co.za",
-  "co.kr",
-  "co.il",
-  "co.id",
-  "co.th",
-  "com.br",
-  "com.mx",
-  "com.ar",
-  "com.co",
-  "com.pe",
-  "co.in",
-  "com.sg",
-  "com.tr",
-  "com.cn",
-  "com.hk",
-  "com.tw",
-  "com.my",
-  "com.ph",
-  "com.ua",
-  "com.pl",
-  "com.es",
-  "com.pt",
-  "com.gr"
-]);
-function registrableDomain(host) {
-  const parts = host.toLowerCase().replace(/\.$/, "").split(".").filter(Boolean);
-  if (parts.length <= 2) return parts.join(".");
-  const lastTwo = parts.slice(-2).join(".");
-  return MULTI_SUFFIX.has(lastTwo) ? parts.slice(-3).join(".") : lastTwo;
-}
-function registrableOf(url) {
-  try {
-    return registrableDomain(new URL(url).hostname);
-  } catch {
-    return "";
-  }
-}
-
 // src/audits/agent-interfaces/mcp-registry-listing-ownership.ts
 var REGISTRY = "https://registry.modelcontextprotocol.io/v0.1/servers";
 var PROOF_PATH = "/.well-known/mcp-registry-auth";
@@ -28381,6 +29103,7 @@ var McpRegistryListingOwnershipAudit = class extends Audit {
     weight: weightForGrade("B", "scored"),
     defaultPriority: "medium",
     dossier: "docs/evidence/audits/agent-interfaces/mcp-registry-listing-ownership.md",
+    requires: ["origin-reachable"],
     guidance: {
       impact: 'The registry is the index a client resolves "the MCP server for this domain" against. A domain with no first-party entry is absent from it, so the only path to the server is a URL somebody pastes by hand. A listing under an aggregator\u2019s namespace is worse than absent in one way: the brand cannot update or revoke it, and agents routed through it reach a proxy rather than the origin. The reverse-DNS namespace that fixes this is granted on proof of domain control, and that proof has to keep being served.',
       fix: "Publish the server under your own reverse-DNS namespace (`com.example/...`), serve the proof at `/.well-known/mcp-registry-auth` in the exact `v=MCPv1; k=ed25519; p=<base64>` form and keep serving it after DNS migrations, keep the listing\u2019s version in step with what the server reports, and offer a `streamable-http` remote rather than only the deprecated `sse`.",
@@ -28597,6 +29320,7 @@ var McpToolDescriptionCoverageAudit = class extends Audit {
     weight: weightForGrade("B", "scored"),
     defaultPriority: "medium",
     dossier: "docs/evidence/audits/agent-interfaces/mcp-tool-description-coverage.md",
+    requires: ["origin-reachable"],
     guidance: {
       impact: "A tool description and its parameter descriptions are the only prose a model ever sees about a tool \u2014 they are the whole basis on which it decides whether to call it and what to pass. A required parameter with no description, no enum and no pattern gives the model nothing to derive a legal value from, so it guesses. Guessed values come back as validation errors, and the agent spends retry turns per call until it gives up on the tool.",
       fix: "Describe every tool and every parameter, in prose long enough to say what a legal value looks like. Constrain string parameters with `enum`, `format` or `pattern` where the legal set is finite. Declare an `outputSchema` so a client can parse the result rather than re-reading it, give each tool a `title` for the consent prompt, and return top-level `instructions` telling a model how the tools fit together.",
@@ -28834,6 +29558,7 @@ var OfferSchemaAudit = class extends Audit {
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/agentic-commerce/offer-schema.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     applicablePageTypes: ["product"],
     defaultPriority: "medium",
     guidance: {
@@ -28952,6 +29677,7 @@ var ProductIdentifiersAudit = class extends Audit {
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/agentic-commerce/product-identifiers.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     applicablePageTypes: ["product"],
     defaultPriority: "high",
     guidance: {
@@ -29069,6 +29795,7 @@ var ProductTransactionCertaintyAudit = class extends Audit {
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/agentic-commerce/product-transaction-certainty.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     applicablePageTypes: ["product"],
     defaultPriority: "high",
     guidance: {
@@ -29401,6 +30128,7 @@ var BuyableVariantResolutionAudit = class extends Audit {
     weight: weightForGrade("B", "scored"),
     defaultPriority: "high",
     dossier: "docs/evidence/audits/agentic-commerce/buyable-variant-resolution.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     applicablePageTypes: ["product"],
     guidance: {
       impact: "The agentic-commerce feed models a catalogue variant-first: every sellable thing is a variant with its own id, price and availability. A page that shows five sizes and three colours but publishes one Offer \u2014 or an AggregateOffer with only lowPrice and highPrice \u2014 gives an agent no purchasable unit to name and no single price to quote. The row is dropped at feed validation, or the checkout session comes back with `invalid` on the line item.",
@@ -29614,6 +30342,7 @@ var CartHandoffReachabilityAudit = class extends Audit {
     weight: weightForGrade("B", "scored"),
     defaultPriority: "high",
     dossier: "docs/evidence/audits/agentic-commerce/cart-handoff-reachability.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     guidance: {
       impact: "Every upstream signal can be perfect and the purchase still dies at the last click. If the cart 302s to a login form because guest checkout is off, or Turnstile is mounted on the checkout document alone, the agent walks the buyer to a wall it cannot pass. ACP reserves a `requires_sign_in` message code for exactly this case, which is a description of the failure, not a fix for it.",
       fix: "Allow guest checkout, or at least let an unauthenticated buyer reach the cart and see the totals. Keep bot challenges off the cart and checkout documents \u2014 challenge the payment submission instead, where a human is present. Allow ChatGPT-User in robots.txt and at the edge on cart paths: blocking GPTBot does not block it, and the two are separately tokened.",
@@ -29819,6 +30548,7 @@ var OfferTruthConsistencyAudit = class extends Audit {
     weight: weightForGrade("B", "scored"),
     defaultPriority: "high",
     dossier: "docs/evidence/audits/agentic-commerce/offer-truth-consistency.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     applicablePageTypes: ["product"],
     guidance: {
       impact: "An agent quotes from the structured data; the seller recomputes the real amount at checkout. When the two disagree the buyer has already committed, and the session comes back with `invalid` or `out_of_stock` \u2014 the most expensive moment at which a purchase can fail. Google says the same thing from the other side: structured data must be a true representation of the page content. Markup that is present and lying passes every syntax validator on the market.",
@@ -30168,6 +30898,7 @@ var AcpPolicyLinkSurfaceAudit = class _AcpPolicyLinkSurfaceAudit extends Audit {
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/agentic-commerce/acp-policy-link-surface.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     defaultPriority: "high",
     guidance: {
       impact: "Falsifiable claim: ACP spec 2026-04-17 makes `links` one of the 9 REQUIRED fields on every CheckoutSession response, with type enum {terms_of_use, privacy_policy, return_policy, shipping_policy, contact_us, about_us, faq, support}. Independently, the OpenAI product feed spec makes `seller_privacy_policy` and `seller_tos` HARD-REQUIRED whenever `is_eligible_checkout=true`. Therefore a merchant that cannot produce a resolvable HTTPS URL for terms_of_use and privacy_policy CANNOT set is_eligible_checkout=true and its catalogue is excluded from Instant Checkout no matter how good the feed is. Disproof condition: if a merchant with no reachable ToS URL is observed transacting via ACP Instant Checkout, the check is wrong.",
@@ -30418,6 +31149,7 @@ var LandedCostAndReturnsAudit = class _LandedCostAndReturnsAudit extends Audit {
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/agentic-commerce/landed-cost-and-returns.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     applicablePageTypes: ["product"],
     defaultPriority: "high",
     guidance: {
@@ -30546,6 +31278,7 @@ var AgentUaCommerceParityAudit = class extends Audit {
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/agentic-commerce/agent-ua-commerce-parity.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     defaultPriority: "critical",
     guidance: {
       impact: "OpenAI operates four separately-tokened agents with separately published IP ranges: OAI-SearchBot (search indexing), ChatGPT-User (user-initiated fetches \u2014 the shopper's agent), GPTBot (training) and OAI-AdsBot (ad landing-page validation). Falsifiable claim: if a product page returns 403, 429, 503 or a challenge interstitial to ChatGPT-User or OAI-SearchBot while returning 200 to a browser, ChatGPT cannot read live price and availability nor follow the buy link, so the product cannot be surfaced or transacted no matter how good the feed is. That block lives at the WAF or CDN edge, which is why an audit that only parses robots.txt is structurally blind to it. Disproof condition: a site 403ing ChatGPT-User on its product pages that still shows live, accurate prices in ChatGPT.",
@@ -30689,6 +31422,7 @@ var ContactFormAudit = class _ContactFormAudit extends Audit {
     evidenceGrade: "C",
     tier: "informative",
     dossier: "docs/evidence/audits/operability-safety/contact-form.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     defaultPriority: "high",
     guidance: {
       impact: 'When users ask AI agents to "contact this company for a quote" or "send a message to their support team," the agent needs a machine-submittable form or API endpoint. Without one, the agent cannot complete the request and users turn to competitors.',
@@ -30797,6 +31531,10 @@ var NoBlockingCaptchaAudit = class _NoBlockingCaptchaAudit extends Audit {
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/operability-safety/no-blocking-captcha.md",
+    // Gate exemption: a captcha wall is what this audit reports, and a wall denies
+    // `origin-reachable` — gating on it made the finding unreachable for the 403 that
+    // produced it. The wall branch reads `wafProtection`, not any response body.
+    requires: [],
     defaultPriority: "high",
     guidance: {
       impact: 'Blocking CAPTCHAs completely prevent AI agents from submitting forms on behalf of users. When a user asks an agent to "fill out the contact form," the CAPTCHA blocks the action entirely, forcing the user to do it manually or go to a competitor.',
@@ -30819,6 +31557,30 @@ var NoBlockingCaptchaAudit = class _NoBlockingCaptchaAudit extends Audit {
     }
   };
   audit(ctx) {
+    const waf = ctx.wafProtection;
+    if (waf?.isBlocked && !waf.isRateLimit) {
+      return this.fail(
+        `The site answered the scanner with a bot wall (${waf.name}). An AI agent acting for a user meets the same wall.`,
+        "No bot wall or blocking CAPTCHA between an agent and the page",
+        `${waf.name}: ${waf.reason}`,
+        { priority: "high", description: _NoBlockingCaptchaAudit.meta.description },
+        ctx.baseUrl
+      );
+    }
+    if (!scanReadTheSite(ctx.evidence)) {
+      return this.notApplicable(
+        "No page here can be attributed to this site, so no form was inspected for a CAPTCHA.",
+        "No recaptcha, hcaptcha, or turnstile script includes detected",
+        unreadSiteReason(ctx.evidence)
+      );
+    }
+    if (ctx.pages.length === 0) {
+      return this.notApplicable(
+        "No page was fetched, so no form could be inspected for a blocking CAPTCHA.",
+        "No recaptcha, hcaptcha, or turnstile script includes detected",
+        "No page fetched"
+      );
+    }
     const detectedCaptchas = [];
     for (const page of ctx.pages) {
       const html = page.fetchResult.body.toLowerCase();
@@ -30829,6 +31591,13 @@ var NoBlockingCaptchaAudit = class _NoBlockingCaptchaAudit extends Audit {
       }
     }
     if (detectedCaptchas.length === 0) {
+      if (!scanReadPageText(ctx.evidence)) {
+        return this.notApplicable(
+          "The scanned page served no readable text, so no form was inspected for a CAPTCHA.",
+          "No recaptcha, hcaptcha, or turnstile script includes detected",
+          unreadPageTextReason(ctx.evidence)
+        );
+      }
       return this.pass(
         "No blocking CAPTCHA scripts detected on scanned pages.",
         "No recaptcha, hcaptcha, or turnstile script includes detected",
@@ -30875,6 +31644,7 @@ var FormsNoJsAudit = class _FormsNoJsAudit extends Audit {
     evidenceGrade: "C",
     tier: "informative",
     dossier: "docs/evidence/audits/operability-safety/forms-no-js.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     defaultPriority: "medium",
     guidance: {
       impact: "Most AI agents do not execute JavaScript. If your forms rely on JS for submission (e.g., React/Vue event handlers with no HTML action), agents cannot submit them at all. This blocks lead capture, contact requests, and any form-based interaction.",
@@ -31054,6 +31824,7 @@ var FormActionabilityAudit = class extends Audit {
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/operability-safety/form-actionability.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     defaultPriority: "high",
     guidance: {
       impact: "AI agents do not render your page visually. Unlabeled fields, div-based fake inputs, and missing autocomplete attributes mean agents cannot tell which field is the email address or the name, so submissions fail silently or land in the wrong fields \u2014 lost leads, broken signups, and abandoned checkouts.",
@@ -31207,6 +31978,7 @@ var AriaLandmarksAudit = class extends Audit {
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/operability-safety/aria-landmarks.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     defaultPriority: "high",
     guidance: {
       impact: "Claude computer use and browser agents rely on ARIA landmarks to identify page regions (navigation, main content, footer). Missing landmarks force agents to guess page structure from raw HTML, leading to misclicked elements and incorrect content extraction.",
@@ -31346,7 +32118,19 @@ function defineA11yAudit(spec) {
   };
 }
 var base = {
-  category: "operability-safety"
+  category: "operability-safety",
+  /**
+   * Every audit built on this base reads the sampled pages through
+   * `A11yBackedAudit`, so they all carry the same requirement set. Declared
+   * once here; `scripts/check-requires.mjs` resolves it for each audit that
+   * spreads `base`.
+   */
+  requires: [
+    "origin-reachable",
+    "unblocked-fetches",
+    "rendered-body",
+    "sample-adequate"
+  ]
 };
 function graded(grade, slug) {
   const tier = grade === "A" || grade === "B" ? "scored" : "informative";
@@ -31456,6 +32240,7 @@ var FormErrorMessagesAudit = class _FormErrorMessagesAudit extends Audit {
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/operability-safety/form-error-messages.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     defaultPriority: "medium",
     guidance: {
       impact: "A field with no aria-errormessage or aria-describedby reference has no message attached to it in the accessibility tree, so an agent that submits a form and gets it back rejected cannot tell which field was wrong or why. It retries the same values or abandons the form.",
@@ -31861,6 +32646,7 @@ var SecurityHeaderHygieneAudit = class extends Audit {
     evidenceGrade: "C",
     tier: "informative",
     dossier: "docs/evidence/audits/operability-safety/security-header-hygiene.md",
+    requires: ["origin-reachable"],
     defaultPriority: "low",
     guidance: {
       impact: "Vulnerability-disclosure hygiene, reported for completeness. A conformant security.txt tells a security researcher who to contact; it is read by researchers and disclosure scanners, not by AI agents. Publishing one changes nothing about how an agent retrieves, parses or cites the site, which is why nothing here moves your score. If you do publish one, an expired or contactless file is worse than none: it advertises a disclosure route that no longer works.",
@@ -32119,6 +32905,7 @@ var FormAutofillTokenCoverageAudit = class _FormAutofillTokenCoverageAudit exten
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/operability-safety/form-autofill-token-coverage.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     defaultPriority: "high",
     guidance: {
       impact: 'Falsifiable claim: an agent filling a checkout must map each field to a value from user profile data. When the field declares autocomplete="postal-code", that mapping is a table lookup against a ratified vocabulary; when it declares name="field_7" with a visual-only label, the mapping is an inference that fails on ambiguous cases (address-line2 vs address-level2, cc-exp vs bday, tel-national vs tel). WebSuite measures the consequence directly: complex form filling succeeds 12.5% and 0% for the two agents tested, against 85%/76% for simple operational clicks. Test: add correct autocomplete tokens to a failing form and re-run the same fill task.',
@@ -32290,6 +33077,7 @@ var NativeControlSubstitutionAudit = class _NativeControlSubstitutionAudit exten
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/operability-safety/native-control-substitution.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     defaultPriority: "high",
     guidance: {
       impact: `Falsifiable claim: native <select>, <input type="date">, and <input type="file"> are single-call primitives in every mainstream agent toolkit (selectOption, fill, setInputFiles) and are keyboard-operable, so they succeed in one action with no actionability risk. A custom equivalent requires open \u2192 wait for popup \u2192 scroll the option list into view \u2192 locate the option \u2192 click, where each step is independently subject to Playwright's visible/stable/receives-events gates, and Anthropic documents dropdowns specifically as 'tricky for Claude to manipulate using mouse movements'. Test: instrument the same form with native vs custom controls and count tool calls and retries to reach an identical value.`,
@@ -32628,6 +33416,7 @@ var InvisibleInstructionScanAudit = class _InvisibleInstructionScanAudit extends
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/operability-safety/invisible-instruction-scan.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     defaultPriority: "critical",
     guidance: {
       impact: "If a page carries text nodes that a sighted human cannot perceive but that survive DOM-to-text serialization, an LLM browsing agent ingests them with the same weight as body copy and can act on them. Brave demonstrated exactly this against Comet (white-on-white text, HTML comments, invisible elements hidden in a Reddit spoiler tag) and confirmed Opera Neon was exploitable through 'hidden HTML elements and other non-rendered markup'. Falsifier: an agent that ingests only visually perceivable, rendered text would be immune \u2014 the disclosed incidents show current agents are not. Google's spam policy independently enumerates the same hiding techniques and their legitimate exceptions, giving the detector a canonical technique list and a false-positive allowlist.",
@@ -32646,6 +33435,13 @@ var InvisibleInstructionScanAudit = class _InvisibleInstructionScanAudit extends
     };
   }
   async audit(ctx) {
+    if (!scanReadTheSite(ctx.evidence)) {
+      return this.notApplicable(
+        "No page here can be attributed to this site, so its hidden text was not judged.",
+        EXPECTED50,
+        unreadSiteReason(ctx.evidence)
+      );
+    }
     const s = await survey9(ctx);
     const partial = s.crossOrigin > 0 ? `; ${s.crossOrigin} cross-origin stylesheet not fetched` : "";
     if (s.textNodesSeen === 0) {
@@ -32904,6 +33700,7 @@ var AriaLayerInjectionScanAudit = class _AriaLayerInjectionScanAudit extends Aud
     evidenceGrade: "A",
     tier: "scored",
     dossier: "docs/evidence/audits/operability-safety/aria-layer-injection-scan.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     defaultPriority: "critical",
     guidance: {
       impact: "Computer-use and browser agents drive pages through the DOM and accessibility tree, not pixels, so a11y attributes enter the model context with the same weight as visible text while remaining invisible to a sighted human. Anthropic names the vector explicitly: 'hidden malicious form fields in a webpage's DOM invisible to humans, and other hard-to-catch injections such as through the URL text and tab title that only an agent might see.' The divergence sub-check is a defect in its own right independent of injection: an agent that clicks by accessible name will actuate an aria-label that contradicts the rendered label. Falsifier: if every a11y attribute is short, descriptive, and token-consistent with its element's visible text, this channel carries no payload.",
@@ -32922,6 +33719,13 @@ var AriaLayerInjectionScanAudit = class _AriaLayerInjectionScanAudit extends Aud
     };
   }
   audit(ctx) {
+    if (!scanReadTheSite(ctx.evidence)) {
+      return this.notApplicable(
+        "No page here can be attributed to this site, so its non-visual values were not judged.",
+        EXPECTED51,
+        unreadSiteReason(ctx.evidence)
+      );
+    }
     const s = survey10(ctx);
     if (s.valuesSeen === 0) {
       return this.notApplicable(
@@ -32967,6 +33771,13 @@ var AriaLayerInjectionScanAudit = class _AriaLayerInjectionScanAudit extends Aud
         warnings[0].pageUrl
       );
     }
+    if (!scanReadPageText(ctx.evidence)) {
+      return this.notApplicable(
+        "The scanned page served no readable text, so its accessibility layer was not judged.",
+        EXPECTED51,
+        unreadPageTextReason(ctx.evidence)
+      );
+    }
     return this.pass(
       `All ${s.valuesSeen} non-visual value(s) are descriptions that agree with their element and carry no instruction addressed to an AI.`,
       EXPECTED51,
@@ -33067,6 +33878,7 @@ var GhostClickableElementRatioAudit = class _GhostClickableElementRatioAudit ext
     evidenceGrade: "B",
     tier: "scored",
     dossier: "docs/evidence/audits/operability-safety/ghost-clickable-element-ratio.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     defaultPriority: "high",
     guidance: {
       impact: "An element whose click behaviour comes only from a JS listener on a non-interactive tag, or from cursor:pointer styling, and which carries no role and no accessible name, is omitted from the serialized accessibility snapshot that agent toolkits send to the model. Playwright MCP's default mode is the accessibility tree, not pixel input: every action tool takes an exact element reference from the snapshot, and coordinate clicking exists only behind the optional vision capability. An element absent from the snapshot is therefore unaddressable by the default toolchain \u2014 the agent cannot emit a valid click and must fail or guess a URL. The accessibility linters cannot warn about it either: axe's button-name and link-name rules only fire on elements that already declare button or link semantics, so a bare unroled div is invisible to them by construction.",
@@ -33085,6 +33897,13 @@ var GhostClickableElementRatioAudit = class _GhostClickableElementRatioAudit ext
     };
   }
   async audit(ctx) {
+    if (!scanReadTheSite(ctx.evidence)) {
+      return this.notApplicable(
+        "No page here can be attributed to this site, so its click targets were not counted.",
+        EXPECTED52,
+        unreadSiteReason(ctx.evidence)
+      );
+    }
     const s = await survey11(ctx);
     const total = s.semantic + s.ghosts.length;
     const partial = s.crossOrigin > 0 ? `; ${s.crossOrigin} cross-origin stylesheet not fetched` : "";
@@ -33289,6 +34108,7 @@ var StatefulControlIntrospectabilityAudit = class _StatefulControlIntrospectabil
     evidenceGrade: "B",
     tier: "scored",
     dossier: "docs/evidence/audits/operability-safety/stateful-control-introspectability.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     defaultPriority: "high",
     guidance: {
       impact: 'An agent works as observe, act, verify. If a toggle\'s only "on" signal is `class="is-active"` and a colour change, the accessibility snapshot is byte-identical before and after the click, so the agent cannot verify the post-condition: it either clicks again and flips the state back, or reports success with no evidence. The accessibility linters cannot catch this, because `aria-required-attr` fires only once the element already declares `role="switch"` or `role="checkbox"` \u2014 the common class-only toggle declares no role and passes silently. Benchmarks put the cost high: WebSuite measures switch, accordion and dropdown primitives among the worst-performing interactions for web agents, and Operator\'s confirmation design assumes the agent can observe a state transition before acting on it.',
@@ -33498,6 +34318,7 @@ var HoverOnlyContentAndNavigationAudit = class _HoverOnlyContentAndNavigationAud
     evidenceGrade: "B",
     tier: "scored",
     dossier: "docs/evidence/audits/operability-safety/hover-only-content-and-navigation.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     defaultPriority: "high",
     guidance: {
       impact: "A submenu revealed only by an ancestor `:hover` rule is `display:none` or `visibility:hidden` in the resting DOM, and Playwright's actionability contract defines such an element as not visible \u2014 so every Playwright-derived agent refuses to click it, and the snapshot serializer omits it entirely. The agent never learns those destinations exist: it does not fail loudly, it simply reports that the site has no page for what the user asked. WebSuite measures the information half of the same defect at 0% success for tooltip-based retrieval across both agents it tested. The fix is cheap and it is the same fix keyboard users need, which is why it is worth doing once.",
@@ -33725,6 +34546,7 @@ var DragAndSliderDependencyAudit = class _DragAndSliderDependencyAudit extends A
     evidenceGrade: "B",
     tier: "scored",
     dossier: "docs/evidence/audits/operability-safety/drag-and-slider-dependency.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     defaultPriority: "high",
     guidance: {
       impact: 'A continuous pointer gesture asks an agent to synthesise a pointerdown, a run of intermediate pointermove events and a pointerup at a computed pixel offset, with no feedback between steps and no way to check the interim value. Every other agent action is discrete and verifiable. WebSuite measures slider interaction at 0% success for both agents it tested \u2014 the worst primitive in its taxonomy \u2014 and Anthropic separately documents scrollbars and dropdowns as unreliable under mouse control, recommending keyboard paths instead. Pair the slider with a numeric input bound to the same value and "set max price to 300" stops being a gesture and becomes a fill.',
@@ -33973,6 +34795,7 @@ var UrlAddressableStateAndPaginationFallbackAudit = class _UrlAddressableStateAn
     evidenceGrade: "B",
     tier: "scored",
     dossier: "docs/evidence/audits/operability-safety/url-addressable-state-and-pagination-fallback.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     defaultPriority: "high",
     applicablePageTypes: ["category"],
     guidance: {
@@ -34174,6 +34997,7 @@ var FirstContactConsentGateOperabilityAudit = class _FirstContactConsentGateOper
     evidenceGrade: "C",
     tier: "informative",
     dossier: "docs/evidence/audits/operability-safety/first-contact-consent-gate-operability.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     defaultPriority: "low",
     guidance: {
       impact: "An agent arriving with no cookies spends its first actions on the consent layer, before any step of the actual task. Three properties decide whether it can. A layer rendered inside a cross-origin iframe is invisible to a DOM-text extractor that reads only the top document, so the agent's text and its screenshot disagree and it acts on content it cannot actually see. Accept and reject controls built as unroled, unnamed divs are unaddressable in a snapshot for the same reason a ghost-clickable div is. And main content set `inert` or `aria-hidden=\"true\"` while the layer is open empties every snapshot until the layer is gone \u2014 axe's own guidance is that `aria-hidden` removes the element and all its children from the accessibility API. The evidence here is convention rather than documented consumer behaviour, which is why this audit reports rather than scores.",
@@ -34425,6 +35249,7 @@ var UnicodeCovertChannelScanAudit = class _UnicodeCovertChannelScanAudit extends
     evidenceGrade: "B",
     tier: "scored",
     dossier: "docs/evidence/audits/operability-safety/unicode-covert-channel-scan.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     defaultPriority: "critical",
     guidance: {
       impact: "Tag-block codepoints mirror ASCII and, per Unicode, render as nothing in tag-unaware implementations \u2014 while modern LLM tokenizers process them normally. A complete instruction can therefore ride inside a product description that no human and no visual QA pass can see. Bidi controls make the rendered order differ from the logical order a text-extracting agent reads, which is the Trojan Source class (CVE-2021-42574). Zero-width characters defeat naive substring matching on both sides at once: the site\u2019s own filters and the agent\u2019s. None of this is visible in a screenshot, a browser, or a review \u2014 only in the bytes.",
@@ -34443,6 +35268,13 @@ var UnicodeCovertChannelScanAudit = class _UnicodeCovertChannelScanAudit extends
     };
   }
   audit(ctx) {
+    if (!scanReadTheSite(ctx.evidence)) {
+      return this.notApplicable(
+        "No response here can be attributed to this site, so its codepoints were not judged.",
+        EXPECTED58,
+        unreadSiteReason(ctx.evidence)
+      );
+    }
     const hits2 = [];
     for (const page of ctx.pages) hits2.push(...scanPage(page));
     for (const path of ROOT_FILES) {
@@ -34469,6 +35301,16 @@ var UnicodeCovertChannelScanAudit = class _UnicodeCovertChannelScanAudit extends
       fillerCount: filler
     };
     if (hits2.length === 0) {
+      if (!scanReadPageText(ctx.evidence)) {
+        return {
+          ...this.notApplicable(
+            "The scanned page served no readable text, so its codepoints were not judged.",
+            EXPECTED58,
+            unreadPageTextReason(ctx.evidence)
+          ),
+          details
+        };
+      }
       return {
         ...this.pass(
           "No invisible codepoint carries text on the scanned pages or in the root files.",
@@ -34664,6 +35506,10 @@ var ThirdPartyDomWriteBlastRadiusAudit = class _ThirdPartyDomWriteBlastRadiusAud
     evidenceGrade: "B",
     tier: "scored",
     dossier: "docs/evidence/audits/operability-safety/third-party-dom-write-blast-radius.md",
+    // Gate exemption: every origin the served HTML names is counted whether or not the
+    // body renders, so a page that ships a vendor script statically is still reported.
+    // The empty census is the case a shell cannot support, and `audit()` declines it.
+    requires: ["origin-reachable", "unblocked-fetches"],
     defaultPriority: "high",
     guidance: {
       impact: 'An agent reads the DOM as one document with one level of trust. It has no way to tell text the site wrote from text a vendor script injected after load, so every third-party origin that can write to the page can write instructions the agent will read as the site\'s own. The count is the risk: eleven uncontrolled origins is eleven independent companies \u2014 and their own supply chains \u2014 with the same authority over what an agent believes about the site. A Content-Security-Policy with a nonce, a hash or `strict-dynamic` is what turns that list from "whoever" into "these, and only these". A policy whose sources include `https:` or `*` is present in the response and constrains nothing.',
@@ -34682,6 +35528,13 @@ var ThirdPartyDomWriteBlastRadiusAudit = class _ThirdPartyDomWriteBlastRadiusAud
     };
   }
   audit(ctx) {
+    if (!scanReadTheSite(ctx.evidence)) {
+      return this.notApplicable(
+        "No page here can be attributed to this site, so its third-party surface was not measured.",
+        EXPECTED59,
+        unreadSiteReason(ctx.evidence)
+      );
+    }
     if (ctx.pages.length === 0) {
       return this.notApplicable(
         "No page was fetched, so there is no third-party surface to measure.",
@@ -34721,6 +35574,17 @@ var ThirdPartyDomWriteBlastRadiusAudit = class _ThirdPartyDomWriteBlastRadiusAud
           details
         };
       }
+      if (!scanReadPageText(ctx.evidence)) {
+        return {
+          ...this.notApplicable(
+            "The scanned page served no readable text, so the origins writing into it were not counted.",
+            EXPECTED59,
+            unreadPageTextReason(ctx.evidence)
+          ),
+          displayValue: found,
+          details
+        };
+      }
       return {
         ...this.pass(
           "No third-party origin ships executable code into the page, so nothing but the site itself writes what an agent reads.",
@@ -34859,6 +35723,7 @@ var UnsafeAgentTriggerableAffordancesAudit = class _UnsafeAgentTriggerableAfford
     evidenceGrade: "B",
     tier: "scored",
     dossier: "docs/evidence/audits/operability-safety/unsafe-agent-triggerable-affordances.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     defaultPriority: "critical",
     guidance: {
       impact: "An agent exploring a site follows links, and a link that changes state changes it on the first fetch \u2014 no click, no intent, no confirmation. The same property makes the site a target for indirect prompt injection: text on a page can name the URL, and an agent that reads it as an instruction performs the action with the user's own session. Disallowing the path in robots.txt is only a partial mitigation, because a user-initiated fetch is documented as not necessarily bound by robots.txt. The underlying rule is older than agents: a GET is a safe method, meaning it must not have side effects, and everything here is a violation of that rule that agents simply make expensive.",
@@ -34877,6 +35742,13 @@ var UnsafeAgentTriggerableAffordancesAudit = class _UnsafeAgentTriggerableAfford
     };
   }
   audit(ctx) {
+    if (!scanReadTheSite(ctx.evidence)) {
+      return this.notApplicable(
+        "No page here can be attributed to this site, so its links were not inspected.",
+        EXPECTED60,
+        unreadSiteReason(ctx.evidence)
+      );
+    }
     if (ctx.pages.length === 0) {
       return this.notApplicable(
         "No page was fetched, so there is no link to inspect.",
@@ -34895,6 +35767,16 @@ var UnsafeAgentTriggerableAffordancesAudit = class _UnsafeAgentTriggerableAfford
       urls: findings.slice(0, 10).map((f) => f.href)
     };
     if (findings.length === 0) {
+      if (!scanReadPageText(ctx.evidence)) {
+        return {
+          ...this.notApplicable(
+            "The scanned page served no readable text, so it exposed no links or forms to inspect.",
+            EXPECTED60,
+            unreadPageTextReason(ctx.evidence)
+          ),
+          details
+        };
+      }
       return {
         ...this.pass(
           "No link or GET form on the scanned pages changes state when it is fetched.",
@@ -34996,6 +35878,7 @@ var ReflectedParameterInjectionCanaryAudit = class extends Audit {
     weight: weightForGrade("B", "scored"),
     defaultPriority: "critical",
     dossier: "docs/evidence/audits/operability-safety/reflected-parameter-injection-canary.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     guidance: {
       impact: "Agents and answer engines weight a source by domain authority, and a reflected-input URL passes human inspection because the hostname is genuine. If attacker-controlled query or path input lands in the page's own title, meta description, canonical link, or JSON-LD strings, the domain becomes a self-serve injection host: the attacker does not need to compromise anything, only to share a link. Reflection into rendered text is the same defect one step down, and it is only contained while the page stays out of an index.",
       fix: 'Escape URL-derived input before it reaches any template, and keep it out of `<title>`, `<meta name="description">`, `og:description`, `rel="canonical"` and JSON-LD entirely \u2014 those fields should describe the page, not the request. Where a search page must echo the query back to the visitor, render it as escaped text inside the body and mark the page `noindex`.',
@@ -35264,6 +36147,7 @@ var UgcTrustBoundaryMarkersAudit = class extends Audit {
     weight: weightForGrade("B", "scored"),
     defaultPriority: "high",
     dossier: "docs/evidence/audits/operability-safety/ugc-trust-boundary-markers.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     guidance: {
       impact: "Attacker-controllable text sits in the same DOM as first-party copy with no boundary, so anything a visitor types reads, to a fetching agent, as a statement the domain made. Google excludes text inside a `data-nosnippet` span, div or section from snippets across web search, Discover and AI Overviews, and includes everything outside it. The sanitizer arm matters most: if a comment body can carry an inline style or an iframe, hiding an instruction inside visitor text becomes self-serve on this site.",
       fix: 'Wrap each visitor-written region in a `<div data-nosnippet>` \u2014 the attribute is honoured on span, div and section only \u2014 and add `rel="ugc"` to links inside it. Strip inline `style`, `iframe`, `script` and remote `img` from submitted markup at render time rather than at submit time, so already-stored content is covered too.',
@@ -35385,6 +36269,7 @@ var AgentUaContentDivergenceDiffAudit = class extends Audit {
     weight: weightForGrade("B", "scored"),
     defaultPriority: "high",
     dossier: "docs/evidence/audits/operability-safety/agent-ua-content-divergence-diff.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     guidance: {
       impact: "An agent that reads a different page from the one a human sees cannot be checked by the human it answers to. Where the crawler copy is thinner, the answer engine quotes a page the visitor will never find; where it carries text the browser copy does not, the site is speaking to the model privately \u2014 which is the delivery mechanism for every instruction-injection attack that does not need a compromise. A JSON-LD block that differs between variants is the same problem in the field a machine trusts most.",
       fix: "Serve one document to every User-Agent. Where a bot-management rule reduces the page for unknown clients, allow the published AI-crawler UAs through it rather than branching on them, and keep the JSON-LD identical across variants. If a crawler should not read the site at all, block it in robots.txt and at the edge rather than serving it a different story.",
@@ -35755,6 +36640,7 @@ var C2paManifestSurvivesDeliveryAudit = class extends Audit {
     weight: weightForGrade("B", "scored"),
     defaultPriority: "medium",
     dossier: "docs/evidence/audits/operability-safety/c2pa-manifest-survives-delivery.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     guidance: {
       impact: "Signing an image at creation proves nothing if the bytes a crawler downloads are unsigned. Image transformation layers discard Content Credentials by default \u2014 Cloudflare states outright that with preservation disabled, existing Content Credentials are always discarded \u2014 so the publisher sees signed assets in their library while every consumer sees stripped ones. The provenance work is done and none of it reaches the reader.",
       fix: "Turn on Content Credentials preservation in the image pipeline (Cloudflare Images has an explicit setting; Next.js image optimization and most CDN resizers need the manifest copied through or the asset served unoptimized). Verify by fetching the URL the page actually renders, not the asset in the library.",
@@ -35904,6 +36790,7 @@ var C2paSignerTrustStatusAudit = class extends Audit {
     weight: weightForGrade("B", "scored"),
     defaultPriority: "medium",
     dossier: "docs/evidence/audits/operability-safety/c2pa-signer-trust-status.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     guidance: {
       impact: "A manifest that exists is not a manifest that verifies. A conforming C2PA validator resolves the signing certificate against the published Trust List and shows the credential as untrusted when it cannot \u2014 which is what a self-signed certificate always produces, and what an expired one produces the day it lapses. The publisher sees Content Credentials on every asset; the consumer sees a warning, or nothing at all.",
       fix: "Sign with a certificate from a CA on the C2PA Trust List rather than a self-signed one, renew before it expires, and include an RFC 3161 timestamp so credentials stay valid past the certificate\u2019s own expiry.",
@@ -36082,6 +36969,7 @@ var OrganizationIdentifierRegistryResolutionAudit = class extends Audit {
     weight: weightForGrade("B", "scored"),
     defaultPriority: "medium",
     dossier: "docs/evidence/audits/operability-safety/organization-identifier-registry-resolution.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     guidance: {
       impact: "A shopping or payment agent transacting with an unfamiliar merchant needs one thing no amount of markup can self-assert: a legal identity it can check against an authority. The LEI is the only schema.org organization identifier backed by a free, queryable, authoritative registry, which makes it the only one whose truth an outside party can establish. An identifier that resolves to nothing, or to a lapsed registration, or to a different legal name, is worse than none: it looks like verification and is not.",
       fix: 'Publish the LEI as `iso6523Code: "0199:<LEI>"` \u2014 Google documents a preference for the prefixed form over bare `leiCode` \u2014 keep the GLEIF registration renewed so its status stays ISSUED, and make sure the `legalName` in your markup is the name GLEIF has on record, not the trading name.',
@@ -36295,6 +37183,7 @@ var SyntheticMediaDisclosureValidityAudit = class extends Audit {
     weight: weightForGrade("B", "scored"),
     defaultPriority: "medium",
     dossier: "docs/evidence/audits/operability-safety/synthetic-media-disclosure-validity.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     guidance: {
       impact: "Disclosure only counts if a machine can read it. IPTC types `DigitalSourceType` as a URI from a controlled vocabulary, so a consumer matching against that vocabulary silently ignores `AI-generated`, a bare `trainedAlgorithmicMedia`, or an `https://` spelling of the `http://` vocabulary URI. The publisher believes the image is disclosed; every machine reader sees an undisclosed image. Worse is an asset whose XMP and C2PA manifest disagree about whether a human took the photo \u2014 two provenance channels, one of them wrong.",
       fix: "Write the full vocabulary URI, exactly: `http://cv.iptc.org/newscodes/digitalsourcetype/trainedAlgorithmicMedia`. Keep the `http` scheme the vocabulary itself uses, no trailing slash, no free text, and make sure the value agrees with the digital source type asserted in the asset\u2019s C2PA manifest.",
@@ -36464,6 +37353,7 @@ var TrustTxtReciprocityCoherenceAudit = class extends Audit {
     weight: 0,
     defaultPriority: "low",
     dossier: "docs/evidence/audits/operability-safety/trust-txt-reciprocity-coherence.md",
+    requires: ["origin-reachable"],
     guidance: {
       impact: "trust.txt association attributes are defined as reciprocal: `belongto=<association>` means something only if that association\u2019s own trust.txt carries `member=<this domain>`. That makes the claim checkable rather than self-asserted, which is the whole point of publishing it. Separately, `datatrainingallowed=no` beside a robots.txt that leaves GPTBot and ClaudeBot free to crawl states two opposite policies, and the channel that actually gates crawlers is the one that says yes. Adoption caveat: no AI engine, answer engine or crawler is documented as reading trust.txt.",
       fix: "Ask each association you claim to belong to for a reciprocal `member=` line, drop the ones that will not reciprocate, and make `datatrainingallowed=` say the same thing your robots.txt AI-bot groups say.",
@@ -36656,6 +37546,7 @@ var WikidataRoundTripVerificationAudit = class extends Audit {
     weight: weightForGrade("B", "scored"),
     defaultPriority: "medium",
     dossier: "docs/evidence/audits/operability-safety/wikidata-round-trip-verification.md",
+    requires: ["origin-reachable", "unblocked-fetches", "rendered-body", "sample-adequate"],
     guidance: {
       impact: "A knowledge-graph consumer that grounds a brand to an entity needs corroboration from the authority side, because `sameAs` carries no reciprocity requirement \u2014 Google documents it as a link to a page with more information, nothing more. Wikidata publishes that corroboration for free as P856. A claim whose entity points at an unrelated domain is either the wrong entity or an unbacked identity claim, and an answer engine that resolves it grounds the brand to somebody else.",
       fix: "Claim the entity that really is your organization, and make sure the Wikidata item carries your domain as its official website (P856). If the item has no P856 at all, add one: until it does, the claim cannot be corroborated by anyone.",
@@ -36860,6 +37751,7 @@ function outcomeOf(check) {
   const tags = check.tags ?? [];
   if (tags.includes(TAG_SCAN_ERROR)) return "error";
   if (tags.includes(TAG_SKIPPED_PAGE_TYPE)) return "skipped";
+  if (tags.includes(TAG_SKIPPED_NO_EVIDENCE)) return "gated";
   return "ran";
 }
 function traceFromCheck(check, durationMs) {
@@ -36921,7 +37813,31 @@ function stubCheck(meta2, tag2, explanation) {
     tier: meta2.tier
   };
 }
-function planAudits(ctx, config) {
+function unmetRequirements(ctx, meta2) {
+  const required = meta2.requires ?? [];
+  if (required.length === 0) return [];
+  const evidence = ctx.evidence;
+  const unmet = [];
+  for (const key2 of required) {
+    if (key2 === "sample-adequate") {
+      const wanted = meta2.applicablePageTypes?.length ? meta2.applicablePageTypes : ["homepage"];
+      if (!wanted.some((type) => evidence.usablePageTypes.has(type))) unmet.push(key2);
+      continue;
+    }
+    if (!evidence.met[key2]) unmet.push(key2);
+  }
+  return unmet;
+}
+function gateExplanation(ctx, meta2, unmet) {
+  const reasons = unmet.map((key2) => ctx.evidence.reasons[key2]).filter(Boolean);
+  if (unmet.includes("sample-adequate") && reasons.length === 0) {
+    const wanted = meta2.applicablePageTypes?.length ? meta2.applicablePageTypes.join("/") : "homepage";
+    return `Not assessed: no scanned ${wanted} page served readable text.`;
+  }
+  const why = reasons.length > 0 ? ` ${reasons.join(" ")}` : "";
+  return `Not assessed: this scan has no ${unmet.join(", ")} evidence.${why}`;
+}
+function planAudits(ctx, config, options = {}) {
   const scannedPageTypes = new Set(ctx.pages.map((p) => p.pageType));
   const runnable = [];
   const skipped = [];
@@ -36941,6 +37857,15 @@ function planAudits(ctx, config) {
           continue;
         }
       }
+      if (options.enforceEvidence) {
+        const unmet = unmetRequirements(ctx, reg2.meta);
+        if (unmet.length > 0) {
+          skipped.push(
+            stubCheck(reg2.meta, TAG_SKIPPED_NO_EVIDENCE, gateExplanation(ctx, reg2.meta, unmet))
+          );
+          continue;
+        }
+      }
       runnable.push({ reg: reg2, categoryId: cat.id });
     }
   }
@@ -37263,6 +38188,18 @@ function detectWafProtection(targetUrl, homepageResult, rootFiles, scannedPagesC
 
 // src/orchestrator.ts
 var A11Y_MAX_PAGES = Math.max(0, Number(process.env.SCANNER_A11Y_MAX_PAGES ?? 3));
+var RATE_LIMIT_BACKOFF_MS = 5e3;
+var MAX_RETRY_AFTER_MS = 3e4;
+async function fetchHomepage(fetcher, url, signal) {
+  const first5 = await fetcher.fetch({ url, signal });
+  if (first5.status !== 429) return first5;
+  const header = Number(first5.headers["retry-after"]);
+  const waitMs = Number.isFinite(header) && header > 0 ? Math.min(header * 1e3, MAX_RETRY_AFTER_MS) : RATE_LIMIT_BACKOFF_MS;
+  logger.debug({ url, waitMs }, `[orchestrator] Homepage answered 429; retrying once in ${waitMs}ms`);
+  await new Promise((resolve4) => setTimeout(resolve4, waitMs));
+  signal?.throwIfAborted();
+  return fetcher.fetch({ url, signal });
+}
 function discoverPages(homepageUrl, domain, rootFiles, homepage$, exclude, maxAdditional) {
   const discovered = /* @__PURE__ */ new Set();
   const sitemapBody = rootFiles["/sitemap.xml"]?.status === 200 ? rootFiles["/sitemap.xml"].body : rootFiles["/sitemap-index.xml"]?.status === 200 ? rootFiles["/sitemap-index.xml"].body : "";
@@ -37355,7 +38292,10 @@ async function runScan(url, options) {
   const signal = options?.signal;
   const tracker = new ProgressTracker((event) => onEvent?.(event));
   const start = performance.now();
-  const fetcher = createFetcher();
+  const fetcher = createFetcher({
+    dispatcher: options?.dispatcher,
+    maxConcurrent: options?.maxConcurrent
+  });
   const baseUrl = new URL(url).origin;
   const domain = new URL(url).hostname;
   const displayUrl = splitCredentials(url).url;
@@ -37413,13 +38353,18 @@ async function runScan(url, options) {
   ];
   logger.debug({ count: rootFilePaths.length }, "[orchestrator] Phase 1: Fetching root files");
   tracker.phaseStart("fetch-root", rootFilePaths.length);
+  const prefetchedRobots = options?.robotsTxt;
   const rootResults = await Promise.all(
-    rootFilePaths.map(
-      (path) => fetcher.fetch({ url: `${baseUrl}${path}`, signal }).then((result) => {
+    rootFilePaths.map((path) => {
+      if (path === "/robots.txt" && prefetchedRobots) {
+        tracker.unitDone(path);
+        return Promise.resolve(prefetchedRobots);
+      }
+      return fetcher.fetch({ url: `${baseUrl}${path}`, signal }).then((result) => {
         tracker.unitDone(path);
         return result;
-      })
-    )
+      });
+    })
   );
   const rootFiles = {};
   rootFilePaths.forEach((path, i) => {
@@ -37430,7 +38375,7 @@ async function runScan(url, options) {
   signal?.throwIfAborted();
   logger.debug("[orchestrator] Phase 2: Fetching pages");
   tracker.phaseStart("fetch-pages", 1);
-  const homepageResult = await fetcher.fetch({ url, signal });
+  const homepageResult = await fetchHomepage(fetcher, url, signal);
   tracker.unitDone(displayUrl);
   const homepage$ = homepageResult.status === 200 && homepageResult.body ? parseHtml(homepageResult.body) : null;
   const discoverLimit = Math.max(0, MAX_PAGES_PER_SCAN - 1 - overrideUrls.length);
@@ -37489,19 +38434,29 @@ async function runScan(url, options) {
   signal?.throwIfAborted();
   logger.debug("[orchestrator] Phase 3: Running audits");
   const wafProtection = detectWafProtection(url, homepageResult, rootFiles, pages.length);
+  const evidence = buildScanEvidence({
+    requestedUrl: url,
+    homepageResult,
+    pages,
+    rootFiles,
+    wafProtection: wafProtection ?? null
+  });
   const ctx = {
     rootFiles,
     pages,
     domain,
     baseUrl,
     fetch: (options2) => fetcher.fetch({ ...options2, signal }),
-    wafProtection: wafProtection ?? void 0
+    wafProtection: wafProtection ?? void 0,
+    evidence
   };
   const config = filterConfig(defaultConfig, {
     categories: options?.categories,
     includeExperimental: options?.includeExperimental ?? false
   });
-  const auditPlan = planAudits(ctx, config);
+  const auditPlan = planAudits(ctx, config, {
+    enforceEvidence: options?.enforceEvidenceGate ?? true
+  });
   tracker.phaseStart("audits", auditPlan.runnable.length);
   const {
     checks: allChecks,
@@ -37522,7 +38477,7 @@ async function runScan(url, options) {
   tracker.phaseStart("report", 1);
   logger.debug("[orchestrator] Phase 4: Building final report");
   const durationMs = Math.round(performance.now() - start);
-  const recommendations = allChecks.filter((c) => c.status !== "pass" && !isInformative(c)).slice().sort((a, b) => {
+  const recommendations = allChecks.filter((c) => (c.status === "fail" || c.status === "warn") && !isInformative(c)).slice().sort((a, b) => {
     const order = { critical: 0, high: 1, medium: 2, low: 3 };
     return (order[a.priority] ?? 3) - (order[b.priority] ?? 3);
   });
@@ -37534,13 +38489,23 @@ async function runScan(url, options) {
   const readinessScore = Math.round(
     readinessVitals.commerce * READINESS_WEIGHTS.commerce + readinessVitals.content * READINESS_WEIGHTS.content + readinessVitals.botAccessibility * READINESS_WEIGHTS.botAccessibility + readinessVitals.technical * READINESS_WEIGHTS.technical
   );
+  const gatedShare = gatedMassShare(allChecks);
+  const escalated = gatedShare > GATED_MASS_UNSCORED_THRESHOLD;
+  const unscoredReason = !evidence.judgeable ? Object.values(evidence.reasons).filter(Boolean).join(" ") || "The scan obtained too little evidence to judge this site." : escalated ? `The scan could not feed ${Math.round(gatedShare * 100)}% of the registry's evidence mass, so what remains is not a reading of this site.` : void 0;
+  const scored = unscoredReason === void 0;
   const report = {
     scanId: "",
     // Set by the caller
     url: displayUrl,
     domain,
-    overallScore,
-    scoreTier: getScoreTier(overallScore),
+    overallScore: scored ? overallScore : null,
+    scoreTier: scored ? getScoreTier(overallScore) : null,
+    scanValidity: {
+      judgeable: evidence.judgeable,
+      evidence: evidence.met,
+      reasons: evidence.reasons,
+      ...unscoredReason ? { unscoredReason } : {}
+    },
     summary: "",
     // Set below
     categories,
@@ -37561,7 +38526,7 @@ async function runScan(url, options) {
   report.summary = generateScanSummary(report);
   tracker.unitDone();
   tracker.phaseDone();
-  tracker.scanDone(overallScore);
+  tracker.scanDone(report.overallScore);
   logger.debug({ durationMs, score: overallScore }, "[orchestrator] runScan complete");
   return report;
 }
@@ -37730,6 +38695,7 @@ export {
   DEFAULT_SCAN_LIMIT,
   DeprecationNoticeSchema,
   EvidenceGradeSchema,
+  EvidenceKeySchema,
   FixEffortSchema,
   MAX_CONCURRENT_REQUESTS,
   MAX_PAGES_PER_SCAN,
@@ -37745,9 +38711,13 @@ export {
   SCORE_TIER_LABELS,
   ScoreDisplayModeSchema,
   TAG_SCAN_ERROR,
+  TAG_SKIPPED_NO_EVIDENCE,
   TAG_SKIPPED_PAGE_TYPE,
+  allEvidenceMet,
   allJsonLdNodes,
+  boundedDispatcher,
   buildCategoryResult,
+  buildScanEvidence,
   calculateCategoryScore,
   calculateOverallScore,
   classifyFetch,
@@ -37778,6 +38748,7 @@ export {
   formatTrace,
   getMainContentText,
   getPreset,
+  getRenderedText,
   getScoreTier,
   getTierColor,
   getTierLabel,