seo 0.2.1 → 0.2.3

package/dist/mcp.js

@@ -1,5 +1,5 @@
 import { createRequire as __seoCreateRequire } from 'node:module'; const require = __seoCreateRequire(import.meta.url);
-import { n as load, t as version } from "./package-BTOI9tde.js";
+import { n as load, t as version } from "./package-Jl7x3QBx.js";
 import { Headers, fetch as fetch$1 } from "undici";
 import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
@@ -1732,7 +1732,7 @@ function effectiveSnippetControl(input) {
 }
 //#endregion
 //#region packages/core/dist/extract/canonical.js
-function headerValue$3(headers, name) {
+function headerValue$4(headers, name) {
 	const lower = name.toLowerCase();
 	return Object.entries(headers).find(([key]) => key.toLowerCase() === lower)?.[1];
 }
@@ -1816,7 +1816,7 @@ function parameter(value, name) {
 	return match?.[1] ?? match?.[2] ?? match?.[3];
 }
 function headerCandidates(headers, baseUrl) {
-	const link = headerValue$3(headers, "link");
+	const link = headerValue$4(headers, "link");
 	if (!link) return [];
 	const candidates = [];
 	for (const item of splitLinkHeader(link)) {
@@ -2485,7 +2485,7 @@ function safeText$1(value) {
 	const trimmed = value?.replace(/\s+/g, " ").trim();
 	return trimmed ? trimmed : void 0;
 }
-function headerValue$2(headers, name) {
+function headerValue$3(headers, name) {
 	const target = name.toLowerCase();
 	return Object.entries(headers).find(([key]) => key.toLowerCase() === target)?.[1];
 }
@@ -2584,6 +2584,7 @@ async function extractPage(fetchResult, extractor = "defuddle", dependencies = {
 		});
 		else invalidHreflangCount += 1;
 	}
+	const markdownAlternates = [...new Set($("head link[rel~=\"alternate\"][type][href]").toArray().filter((element) => $(element).attr("type")?.trim().toLowerCase() === "text/markdown").map((element) => httpUrl($(element).attr("href"), fetchResult.finalUrl)).filter((value) => Boolean(value)))].sort();
 	const openGraph = Object.fromEntries($("meta[property^=\"og:\"]").toArray().map((element) => [$(element).attr("property") ?? "", $(element).attr("content") ?? ""]).filter(([key, value]) => key && value));
 	const twitter = Object.fromEntries($("meta[name^=\"twitter:\"]").toArray().map((element) => [$(element).attr("name") ?? "", $(element).attr("content") ?? ""]).filter(([key, value]) => key && value));
 	const structuredData = extractStructuredData($, fetchResult.finalUrl);
@@ -2631,13 +2632,14 @@ async function extractPage(fetchResult, extractor = "defuddle", dependencies = {
 		title: safeText$1($("title").first().text()),
 		metaDescription: safeText$1($("meta[name=\"description\"]").attr("content")),
 		metaRobots,
-		xRobotsTag: safeText$1(headerValue$2(fetchResult.headers, "x-robots-tag")),
+		xRobotsTag: safeText$1(headerValue$3(fetchResult.headers, "x-robots-tag")),
 		canonical: canonicalEvidence.selectedRaw,
 		canonicalEvidence,
 		lang: safeText$1($("html").attr("lang")),
 		hasViewport: Boolean($("meta[name=\"viewport\"]").attr("content")),
 		headings,
 		links,
+		markdownAlternates,
 		hreflang,
 		jsonLd: structuredData.jsonLd,
 		invalidJsonLdCount: structuredData.invalidJsonLdSamples.length,
@@ -3442,7 +3444,7 @@ function safeText(value) {
 	const normalized = value?.replace(/\s+/g, " ").trim();
 	return normalized ? normalized.slice(0, MAX_TEXT_VALUE_LENGTH) : void 0;
 }
-function headerValue$1(headers, name) {
+function headerValue$2(headers, name) {
 	const expected = name.toLowerCase();
 	return Object.entries(headers).find(([key]) => key.toLowerCase() === expected)?.[1];
 }
@@ -3495,7 +3497,7 @@ function renderingDocumentSnapshot(result) {
 	const structuredData = extractStructuredData($, result.finalUrl);
 	const metaRobots = normalizedDirectiveValue([metaValue($, "robots")]);
 	const googlebotRobots = normalizedDirectiveValue([metaValue($, "googlebot")]);
-	const httpRobots = normalizedDirectiveValue([headerValue$1(result.headers, "x-robots-tag")]);
+	const httpRobots = normalizedDirectiveValue([headerValue$2(result.headers, "x-robots-tag")]);
 	const headings = $("h1, h2, h3, h4, h5, h6").toArray().map((element) => ({
 		level: Number.parseInt(element.tagName.slice(1), 10),
 		text: safeText($(element).text())
@@ -6030,8 +6032,1088 @@ function matchesFilters(issue, filters) {
 	return true;
 }
 //#endregion
-//#region packages/core/dist/analyze/crawler/ai-readiness.js
+//#region packages/core/dist/analyze/crawler/agent-discovery.js
+const MAX_BODY_BYTES = 2e6;
+const MAX_LLMS_LINKS = 100;
+const MAX_CURATED_LLMS_BYTES = 1e5;
+const MAX_SKILLS = 25;
+function sha256(value) {
+	return createHash("sha256").update(value).digest("hex");
+}
+function headerValue$1(headers, name) {
+	if (!headers) return void 0;
+	const target = name.toLowerCase();
+	return Object.entries(headers).find(([key]) => key.toLowerCase() === target)?.[1];
+}
+function linkEntries(value, base) {
+	if (!value) return [];
+	return value.split(/,(?=\s*<)/u).map((entry) => {
+		const match = entry.match(/^\s*<([^>]+)>\s*(.*)$/u);
+		if (!match?.[1]) return void 0;
+		try {
+			const url = new URL(match[1], base).toString();
+			const parameters = match[2] ?? "";
+			const rel = parameters.match(/(?:^|;)\s*rel=(?:"([^"]+)"|([^;\s]+))/iu);
+			const type = parameters.match(/(?:^|;)\s*type=(?:"([^"]+)"|([^;\s]+))/iu);
+			return {
+				url,
+				rel: (rel?.[1] ?? rel?.[2] ?? "").toLowerCase().split(/\s+/u),
+				type: (type?.[1] ?? type?.[2] ?? "").toLowerCase()
+			};
+		} catch {
+			return;
+		}
+	}).filter((entry) => Boolean(entry));
+}
+function normalizedDocumentUrl(value) {
+	const url = new URL(value);
+	url.hash = "";
+	if (url.pathname !== "/") url.pathname = url.pathname.replace(/\/$/u, "");
+	return url.toString();
+}
+function sameDocument(left, right) {
+	if (!left || !right) return null;
+	try {
+		return normalizedDocumentUrl(left) === normalizedDocumentUrl(right);
+	} catch {
+		return false;
+	}
+}
+function bodyWordCount(value) {
+	return value.replace(/^---[\s\S]*?---\s*/u, "").replace(/```[\s\S]*?```/gu, " ").replace(/[#>*_`[\]()|:-]/gu, " ").split(/\s+/u).filter(Boolean).length;
+}
+function repeatedProseLines(markdown) {
+	const counts = /* @__PURE__ */ new Map();
+	let inFrontmatter = false;
+	let fence;
+	for (const [index, rawLine] of markdown.split(/\r?\n/u).entries()) {
+		const line = rawLine.trim();
+		if (index === 0 && line === "---") {
+			inFrontmatter = true;
+			continue;
+		}
+		if (inFrontmatter) {
+			if (line === "---") inFrontmatter = false;
+			continue;
+		}
+		if (!fence && (line.startsWith("```") || line.startsWith("~~~"))) {
+			fence = line.startsWith("```") ? "```" : "~~~";
+			continue;
+		}
+		if (fence) {
+			if (line.startsWith(fence)) fence = void 0;
+			continue;
+		}
+		if (line.length < 40 || /^(?:#{1,6}\s|[-+*]\s|\d+[.)]\s|>|\||`|\]\()/u.test(line)) continue;
+		counts.set(line, (counts.get(line) ?? 0) + 1);
+	}
+	return [...counts.values()].reduce((duplicates, count) => duplicates + Math.max(0, count - 1), 0);
+}
+function responseIsNoindex(response, body) {
+	if ((response.headers.get("x-robots-tag") ?? "").toLowerCase().includes("noindex")) return true;
+	return [...body.matchAll(/<meta\s+[^>]*>/giu)].some((match) => {
+		const tag = match[0];
+		const name = tag.match(/\bname\s*=\s*["']([^"']+)["']/iu)?.[1];
+		const content = tag.match(/\bcontent\s*=\s*["']([^"']+)["']/iu)?.[1];
+		return name?.toLowerCase() === "robots" && /\bnoindex\b/iu.test(content ?? "");
+	});
+}
+function markdownQuality(markdown, page) {
+	const introProbe = (page.contentSample?.replace(/\s+/gu, " ").trim())?.split(" ").slice(0, 10).join(" ");
+	const normalizedMarkdown = markdown.replace(/\s+/gu, " ");
+	const codeFences = markdown.match(/^```/gmu)?.length ?? 0;
+	const wordCount = bodyWordCount(markdown);
+	const sourceWordCount = page.wordCount ?? 0;
+	return {
+		frontmatterTitle: /^---[\s\S]*?^title:\s*.+$/mu.test(markdown),
+		h1Count: markdown.match(/^#\s+\S.+$/gmu)?.length ?? 0,
+		codeFenceBalanced: codeFences % 2 === 0,
+		tableRows: markdown.match(/^\s*\|.*\|\s*$/gmu)?.length ?? 0,
+		links: markdown.match(/\[[^\]]+\]\([^)]+\)/gu)?.length ?? 0,
+		wordCount,
+		rawHtmlTags: markdown.match(/<(?:div|span|section|article|nav|button)\b/giu)?.length ?? 0,
+		rawSvgTags: markdown.match(/<svg\b/giu)?.length ?? 0,
+		rawScriptTags: markdown.match(/<script\b/giu)?.length ?? 0,
+		rawStyleTags: markdown.match(/<style\b/giu)?.length ?? 0,
+		suspiciousConcatenations: markdown.match(/\b[a-z]{4,}[A-Z][A-Za-z]{3,}\b/gu)?.length ?? 0,
+		repeatedLines: repeatedProseLines(markdown),
+		sourceWordCount,
+		wordRetentionRatio: sourceWordCount > 0 ? Math.round(wordCount / sourceWordCount * 1e3) / 1e3 : null,
+		introductoryCopyRetained: introProbe ? normalizedMarkdown.includes(introProbe) : null,
+		navigationOnly: bodyWordCount(markdown) < 25
+	};
+}
+function combinedSignal(timeoutMs, signal) {
+	const controller = new AbortController();
+	const abort = () => controller.abort();
+	const timer = setTimeout(abort, timeoutMs);
+	if (signal?.aborted) controller.abort();
+	else signal?.addEventListener("abort", abort, { once: true });
+	return {
+		signal: controller.signal,
+		cleanup: () => {
+			clearTimeout(timer);
+			signal?.removeEventListener("abort", abort);
+		}
+	};
+}
+async function readBoundedText(response) {
+	if (!response.body) return "";
+	const reader = response.body.getReader();
+	const chunks = [];
+	let size = 0;
+	try {
+		while (true) {
+			const result = await reader.read();
+			if (result.done) break;
+			size += result.value.byteLength;
+			if (size > MAX_BODY_BYTES) throw new Error(`Response exceeds ${MAX_BODY_BYTES} bytes.`);
+			chunks.push(result.value);
+		}
+	} finally {
+		await reader.cancel().catch(() => void 0);
+	}
+	return Buffer.concat(chunks).toString("utf8");
+}
+async function fetchRepresentation(input) {
+	const controller = combinedSignal(input.timeoutMs, input.signal);
+	try {
+		const response = await input.fetch(input.url, {
+			profile: "bot",
+			redirect: "follow",
+			headers: { accept: input.accept },
+			signal: controller.signal
+		});
+		const body = await readBoundedText(response);
+		const link = linkEntries(response.headers.get("link") ?? void 0, input.url);
+		const tokens = Number(response.headers.get("x-markdown-tokens"));
+		return {
+			observation: {
+				requestedUrl: input.url,
+				finalUrl: response.url || input.url,
+				status: response.status,
+				contentType: response.headers.get("content-type") ?? void 0,
+				bytes: Buffer.byteLength(body),
+				sha256: sha256(body),
+				canonicalUrl: link.find((entry) => entry.rel.includes("canonical"))?.url,
+				alternateUrl: link.find((entry) => entry.rel.includes("alternate") && entry.type === "text/markdown")?.url,
+				varyAccept: (response.headers.get("vary") ?? "").split(",").some((value) => value.trim().toLowerCase() === "accept"),
+				...Number.isInteger(tokens) && tokens >= 0 ? { markdownTokens: tokens } : {},
+				contentSignal: response.headers.get("content-signal") ?? void 0
+			},
+			body
+		};
+	} catch (error) {
+		return { observation: {
+			requestedUrl: input.url,
+			varyAccept: false,
+			error: error instanceof Error ? error.message : String(error)
+		} };
+	} finally {
+		controller.cleanup();
+	}
+}
+async function inspectMarkdownPage(input) {
+	const advertisedUrls = [...new Set(input.page.markdownAlternates ?? [])].sort();
+	const httpAlternateUrls = linkEntries(headerValue$1(input.page.responseHeaders, "link"), input.page.finalUrl).filter((entry) => entry.rel.includes("alternate") && entry.type === "text/markdown").map((entry) => entry.url).sort();
+	const observation = {
+		htmlUrl: input.page.finalUrl,
+		advertisedUrls,
+		htmlAlternateUnique: advertisedUrls.length === 1,
+		httpAlternateUrls,
+		explicitMatchesNegotiated: null,
+		repeatedHashStable: null,
+		markdownCanonicalMatchesHtml: null
+	};
+	if (advertisedUrls.length !== 1) return observation;
+	const explicitUrl = advertisedUrls[0];
+	const [explicit, negotiated, repeated] = await Promise.all([
+		fetchRepresentation({
+			url: explicitUrl,
+			accept: "text/markdown",
+			timeoutMs: input.timeoutMs,
+			fetch: input.fetch,
+			signal: input.signal
+		}),
+		fetchRepresentation({
+			url: input.page.finalUrl,
+			accept: "text/markdown",
+			timeoutMs: input.timeoutMs,
+			fetch: input.fetch,
+			signal: input.signal
+		}),
+		fetchRepresentation({
+			url: explicitUrl,
+			accept: "text/markdown",
+			timeoutMs: input.timeoutMs,
+			fetch: input.fetch,
+			signal: input.signal
+		})
+	]);
+	observation.explicit = explicit.observation;
+	observation.negotiated = negotiated.observation;
+	observation.repeated = repeated.observation;
+	observation.explicitMatchesNegotiated = explicit.observation.sha256 && negotiated.observation.sha256 ? explicit.observation.sha256 === negotiated.observation.sha256 : null;
+	observation.repeatedHashStable = explicit.observation.sha256 && repeated.observation.sha256 ? explicit.observation.sha256 === repeated.observation.sha256 : null;
+	observation.markdownCanonicalMatchesHtml = sameDocument(explicit.observation.canonicalUrl, input.page.finalUrl);
+	if (explicit.body) observation.quality = markdownQuality(explicit.body, input.page);
+	return observation;
+}
+async function fetchText(input) {
+	const controller = combinedSignal(input.timeoutMs, input.signal);
+	try {
+		const response = await input.fetch(input.url, {
+			profile: "bot",
+			redirect: input.redirect ?? "follow",
+			headers: input.accept ? { accept: input.accept } : void 0,
+			signal: controller.signal
+		});
+		return {
+			response,
+			body: await readBoundedText(response)
+		};
+	} finally {
+		controller.cleanup();
+	}
+}
+function safeError(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+async function inspectAgentSkills(input) {
+	const indexUrl = new URL("/.well-known/agent-skills/index.json", input.origin).toString();
+	try {
+		const { response, body } = await fetchText({
+			url: indexUrl,
+			timeoutMs: input.timeoutMs,
+			fetch: input.fetch,
+			signal: input.signal,
+			accept: "application/json"
+		});
+		const contentType = response.headers.get("content-type") ?? void 0;
+		const cors = response.headers.get("access-control-allow-origin") ?? void 0;
+		if (response.status < 200 || response.status >= 300) return {
+			indexUrl,
+			status: response.status,
+			contentType,
+			validIndex: false,
+			skills: []
+		};
+		const parsed = JSON.parse(body);
+		const entries = Array.isArray(parsed.skills) ? parsed.skills.slice(0, MAX_SKILLS) : [];
+		const skills = await Promise.all(entries.map(async (entry) => {
+			const name = typeof entry.name === "string" ? entry.name : void 0;
+			const declaredDigest = typeof entry.digest === "string" ? entry.digest : void 0;
+			const relativeUrl = typeof entry.url === "string" ? entry.url : void 0;
+			if (!relativeUrl) return {
+				name,
+				declaredDigest,
+				digestMatches: null,
+				frontmatterValid: null,
+				sameOrigin: false,
+				error: "Skill URL is missing."
+			};
+			const url = new URL(relativeUrl, indexUrl).toString();
+			const sameOrigin = new URL(url).origin === new URL(input.origin).origin;
+			if (!sameOrigin) return {
+				name,
+				url,
+				declaredDigest,
+				digestMatches: null,
+				frontmatterValid: null,
+				sameOrigin,
+				error: "Skill URL is off origin."
+			};
+			try {
+				const skill = await fetchText({
+					url,
+					timeoutMs: input.timeoutMs,
+					fetch: input.fetch,
+					signal: input.signal,
+					accept: "text/markdown,text/plain;q=0.9"
+				});
+				const observedDigest = `sha256:${sha256(skill.body)}`;
+				const frontmatterValid = /^---\s*\n[\s\S]*?^name:\s*\S.+$[\s\S]*?^description:\s*\S.+$[\s\S]*?^---\s*$/mu.test(skill.body);
+				return {
+					name,
+					url,
+					status: skill.response.status,
+					contentType: skill.response.headers.get("content-type") ?? void 0,
+					cors: skill.response.headers.get("access-control-allow-origin") ?? void 0,
+					declaredDigest,
+					observedDigest,
+					digestMatches: declaredDigest ? declaredDigest === observedDigest : null,
+					frontmatterValid,
+					sameOrigin
+				};
+			} catch (error) {
+				return {
+					name,
+					url,
+					declaredDigest,
+					digestMatches: null,
+					frontmatterValid: null,
+					sameOrigin,
+					error: safeError(error)
+				};
+			}
+		}));
+		return {
+			indexUrl,
+			status: response.status,
+			contentType,
+			cors,
+			validIndex: typeof parsed.$schema === "string" && Array.isArray(parsed.skills),
+			skills
+		};
+	} catch (error) {
+		return {
+			indexUrl,
+			validIndex: false,
+			skills: [],
+			error: safeError(error)
+		};
+	}
+}
+function markdownLinks(value, base) {
+	const links = [];
+	const invalidLinks = [];
+	for (const match of value.matchAll(/\[([^\u005d]+)\]\(([^)\s]+)(?:\s+"[^"]*")?\)/gu)) {
+		if (!match[1] || !match[2]) continue;
+		try {
+			links.push({
+				label: match[1],
+				url: new URL(match[2], base).toString()
+			});
+		} catch {
+			invalidLinks.push(match[2]);
+		}
+	}
+	return {
+		links,
+		invalidLinks
+	};
+}
+async function inspectLlmsTxt(input) {
+	const url = new URL("/llms.txt", input.origin).toString();
+	try {
+		const [first, second] = await Promise.all([fetchText({
+			url,
+			timeoutMs: input.timeoutMs,
+			fetch: input.fetch,
+			signal: input.signal,
+			accept: "text/plain,text/markdown;q=0.9"
+		}), fetchText({
+			url,
+			timeoutMs: input.timeoutMs,
+			fetch: input.fetch,
+			signal: input.signal,
+			accept: "text/plain,text/markdown;q=0.9"
+		})]);
+		const exists = first.response.status >= 200 && first.response.status < 300;
+		const parsed = markdownLinks(first.body, url);
+		const links = parsed.links.slice(0, MAX_LLMS_LINKS);
+		const linkLimitReached = parsed.links.length > links.length;
+		const counts = /* @__PURE__ */ new Map();
+		for (const link of links) counts.set(link.url, (counts.get(link.url) ?? 0) + 1);
+		const duplicateLinks = [...counts].filter(([, count]) => count > 1).map(([link]) => link).sort();
+		const crawlRoutes = new Set(input.pages.map((page) => normalizedDocumentUrl(page.finalUrl)));
+		const linkObservations = await Promise.all(links.map(async (link) => {
+			const sameOrigin = new URL(link.url).origin === new URL(input.origin).origin;
+			try {
+				const target = await fetchText({
+					url: link.url,
+					timeoutMs: input.timeoutMs,
+					fetch: input.fetch,
+					signal: input.signal
+				});
+				const indexableTarget = sameOrigin && target.response.status >= 200 && target.response.status < 300 ? !responseIsNoindex(target.response, target.body) : void 0;
+				const finalUrl = target.response.url || void 0;
+				return {
+					...link,
+					sameOrigin,
+					status: target.response.status,
+					finalUrl,
+					redirected: target.response.redirected,
+					...indexableTarget === void 0 ? {} : { indexableTarget }
+				};
+			} catch (error) {
+				return {
+					...link,
+					sameOrigin,
+					redirected: false,
+					error: safeError(error)
+				};
+			}
+		}));
+		const linkedCrawlRoutes = new Set(linkObservations.filter((link) => link.sameOrigin && !new URL(link.url).pathname.startsWith("/.well-known/") && !new URL(link.url).pathname.endsWith(".md")).map((link) => normalizedDocumentUrl(link.url)));
+		return {
+			url,
+			exists,
+			status: first.response.status,
+			contentType: first.response.headers.get("content-type") ?? void 0,
+			bytes: Buffer.byteLength(first.body),
+			sha256: sha256(first.body),
+			repeatedHashStable: sha256(first.body) === sha256(second.body),
+			headingCount: first.body.match(/^#{1,2}\s+\S/gmu)?.length ?? 0,
+			totalParsedLinks: parsed.links.length,
+			linkLimitReached,
+			links: linkObservations,
+			invalidLinks: parsed.invalidLinks.sort(),
+			duplicateLinks,
+			offSiteLinks: linkObservations.filter((link) => !link.sameOrigin).map((link) => link.url).sort(),
+			redirectedLinks: linkObservations.filter((link) => link.redirected).map((link) => link.url).sort(),
+			nonIndexableLinks: linkObservations.filter((link) => link.indexableTarget === false).map((link) => link.url).sort(),
+			missingCrawlRoutes: [...linkedCrawlRoutes].filter((route) => !crawlRoutes.has(route)).sort(),
+			oversized: Buffer.byteLength(first.body) > MAX_CURATED_LLMS_BYTES
+		};
+	} catch (error) {
+		return {
+			url,
+			exists: false,
+			repeatedHashStable: null,
+			headingCount: 0,
+			totalParsedLinks: 0,
+			linkLimitReached: false,
+			links: [],
+			invalidLinks: [],
+			duplicateLinks: [],
+			offSiteLinks: [],
+			redirectedLinks: [],
+			nonIndexableLinks: [],
+			missingCrawlRoutes: [],
+			oversized: false,
+			error: safeError(error)
+		};
+	}
+}
+async function inspectRouteManifest(input) {
+	const url = new URL("/agent-routes.json", input.origin).toString();
+	try {
+		const result = await fetchText({
+			url,
+			timeoutMs: input.timeoutMs,
+			fetch: input.fetch,
+			signal: input.signal,
+			accept: "application/json"
+		});
+		const parsed = JSON.parse(result.body);
+		const declared = Array.isArray(parsed.pages) ? parsed.pages : [];
+		const declaredHtmlRoutes = declared.map((page) => page.htmlPath).filter((path) => typeof path === "string").sort();
+		const declaredMarkdownRoutes = declared.map((page) => page.markdownPath).filter((path) => typeof path === "string").sort();
+		const crawledHtmlRoutes = new Set(input.pages.map((page) => new URL(page.finalUrl).pathname.replace(/\/$/u, "") || "/"));
+		const observedMarkdownRoutes = new Set(input.observations.flatMap((page) => page.advertisedUrls.map((value) => new URL(value).pathname)));
+		return {
+			url,
+			status: result.response.status,
+			valid: Array.isArray(parsed.pages),
+			declaredHtmlRoutes,
+			declaredMarkdownRoutes,
+			missingHtmlRoutes: declaredHtmlRoutes.filter((path) => !crawledHtmlRoutes.has(path.replace(/\/$/u, "") || "/")).sort(),
+			missingMarkdownRoutes: declaredMarkdownRoutes.filter((path) => !observedMarkdownRoutes.has(path)).sort(),
+			orphanMarkdownRoutes: [...observedMarkdownRoutes].filter((path) => !declaredMarkdownRoutes.includes(path)).sort()
+		};
+	} catch (error) {
+		return {
+			url,
+			valid: false,
+			declaredHtmlRoutes: [],
+			declaredMarkdownRoutes: [],
+			missingHtmlRoutes: [],
+			missingMarkdownRoutes: [],
+			orphanMarkdownRoutes: [],
+			error: safeError(error)
+		};
+	}
+}
+async function inspectProtocolVariant(input) {
+	try {
+		const result = await fetchText({
+			url: input.url,
+			timeoutMs: input.timeoutMs,
+			fetch: input.fetch,
+			signal: input.signal,
+			redirect: "manual"
+		});
+		return {
+			status: result.response.status,
+			location: result.response.headers.get("location") ?? void 0
+		};
+	} catch (error) {
+		return { error: safeError(error) };
+	}
+}
+async function collectAgentDiscovery(input) {
+	const origin = new URL(input.startUrl).origin;
+	const pages = input.pages.filter((page) => page.status >= 200 && page.status < 300 && /^\s*(?:text\/html|application\/xhtml\+xml)\b/iu.test(page.contentType ?? "")).sort((left, right) => left.finalUrl.localeCompare(right.finalUrl));
+	const queue = new PQueue({ concurrency: input.concurrency ?? 4 });
+	const observations = await Promise.all(pages.map((page) => queue.add(() => inspectMarkdownPage({
+		page,
+		timeoutMs: input.timeoutMs,
+		fetch: input.fetch,
+		signal: input.signal
+	}))));
+	const [agentSkills, llmsTxt, routeManifest] = await Promise.all([
+		inspectAgentSkills({
+			...input,
+			origin
+		}),
+		inspectLlmsTxt({
+			...input,
+			origin,
+			pages
+		}),
+		inspectRouteManifest({
+			...input,
+			origin,
+			pages,
+			observations
+		})
+	]);
+	const qZero = await fetchRepresentation({
+		url: input.startUrl,
+		accept: "text/markdown;q=0,text/html;q=1",
+		timeoutMs: input.timeoutMs,
+		fetch: input.fetch,
+		signal: input.signal
+	});
+	const start = new URL(input.startUrl);
+	const httpUrl = new URL(start);
+	httpUrl.protocol = "http:";
+	const wwwUrl = new URL(start);
+	wwwUrl.hostname = start.hostname.startsWith("www.") ? start.hostname.slice(4) : `www.${start.hostname}`;
+	const [http, www] = await Promise.all([inspectProtocolVariant({
+		...input,
+		url: httpUrl.toString()
+	}), inspectProtocolVariant({
+		...input,
+		url: wwwUrl.toString()
+	})]);
+	const httpLocation = http.location ? new URL(http.location, httpUrl).toString() : void 0;
+	const wwwLocation = www.location ? new URL(www.location, wwwUrl).toString() : void 0;
+	const qZeroContentType = qZero.observation.contentType;
+	const advertisedPages = observations.filter((observation) => observation.htmlAlternateUnique).length;
+	const evaluatedPages = observations.filter((observation) => observation.explicit?.status !== void 0).length;
+	const warnings = [...pages.length !== input.pages.length ? [`Agent representations were evaluated for ${pages.length} successful HTML pages from ${input.pages.length} retained documents.`] : [], ...routeManifest.valid ? [] : ["No valid public agent route manifest was available for orphan checks."]].sort();
+	const htmlContentSignals = pages.map((page) => headerValue$1(page.responseHeaders, "content-signal")).filter((value) => Boolean(value));
+	const markdownContentSignals = observations.map((observation) => observation.explicit?.contentSignal).filter((value) => Boolean(value));
+	const contentSignalValues = [.../* @__PURE__ */ new Set([...htmlContentSignals, ...markdownContentSignals])].sort();
+	return {
+		profile: "content",
+		profileApplicability: {
+			content: {
+				status: "evaluated",
+				reason: "This site publishes documents, so access, representations, discovery, identity, and extraction quality were evaluated."
+			},
+			api: {
+				status: "notApplicable",
+				reason: "No public API surface was selected for this content-site run."
+			},
+			application: {
+				status: "notApplicable",
+				reason: "A local MCP product does not make this website a public remote agent endpoint."
+			},
+			commerce: {
+				status: "notApplicable",
+				reason: "No product checkout or transactional surface was selected."
+			}
+		},
+		dataStatus: pages.length === 0 ? "unavailable" : evaluatedPages === pages.length ? "complete" : "partial",
+		markdownAlternates: {
+			eligibleHtmlPages: pages.length,
+			advertisedPages,
+			evaluatedPages,
+			exactByteMatches: observations.filter((observation) => observation.explicitMatchesNegotiated).length,
+			stableResponses: observations.filter((observation) => observation.repeatedHashStable).length,
+			pages: observations
+		},
+		contentNegotiation: {
+			qZeroHonoured: qZeroContentType !== void 0 ? !/^\s*text\/markdown\b/iu.test(qZeroContentType) : null,
+			qZeroStatus: qZero.observation.status,
+			qZeroContentType,
+			error: qZero.observation.error
+		},
+		routeManifest,
+		agentSkills,
+		llmsTxt,
+		contentSignals: {
+			htmlValues: [...new Set(htmlContentSignals)].sort(),
+			markdownValues: [...new Set(markdownContentSignals)].sort(),
+			missingHtmlPages: pages.length - htmlContentSignals.length,
+			missingMarkdownPages: observations.length - markdownContentSignals.length,
+			consistent: pages.length > 0 && observations.length > 0 ? contentSignalValues.length === 1 && htmlContentSignals.length === pages.length && markdownContentSignals.length === observations.length : null
+		},
+		protocolVariants: {
+			http: {
+				url: httpUrl.toString(),
+				status: http.status,
+				location: httpLocation,
+				permanentRedirectToHttps: http.status !== void 0 ? [301, 308].includes(http.status) && Boolean(httpLocation?.startsWith("https://")) : null,
+				error: http.error
+			},
+			www: {
+				url: wwwUrl.toString(),
+				status: www.status,
+				location: wwwLocation,
+				redirectsToPreferredHost: www.status !== void 0 ? [301, 308].includes(www.status) && Boolean(wwwLocation && new URL(wwwLocation).hostname === start.hostname && new URL(wwwLocation).protocol === "https:") : null,
+				error: www.error
+			},
+			hstsOnStartPage: pages.find((page) => normalizedDocumentUrl(page.finalUrl) === normalizedDocumentUrl(input.startUrl))?.hasHsts ?? null
+		},
+		warnings
+	};
+}
+//#endregion
+//#region packages/core/dist/analyze/crawler/agent-readiness.js
+function check$1(section, input) {
+	return {
+		section,
+		...input
+	};
+}
+function section$1(id, title, checks) {
+	return {
+		id,
+		title,
+		checks
+	};
+}
+function failedMarkdownUrls(discovery) {
+	return discovery.markdownAlternates.pages.filter((page) => !page.htmlAlternateUnique || page.httpAlternateUrls.length !== 1 || page.explicit?.status !== 200 || !/^\s*text\/markdown\b/iu.test(page.explicit.contentType ?? "") || page.explicitMatchesNegotiated !== true || page.repeatedHashStable !== true || page.markdownCanonicalMatchesHtml !== true || page.explicit?.varyAccept !== true || page.negotiated?.varyAccept !== true).map((page) => page.htmlUrl);
+}
+function qualityFailureUrls(discovery) {
+	return discovery.markdownAlternates.pages.filter((page) => {
+		const quality = page.quality;
+		if (!quality) return true;
+		return !quality.frontmatterTitle || quality.h1Count !== 1 || !quality.codeFenceBalanced || quality.rawHtmlTags > 0 || quality.rawSvgTags > 0 || quality.rawScriptTags > 0 || quality.rawStyleTags > 0 || quality.navigationOnly || quality.repeatedLines > 0 || quality.wordRetentionRatio !== null && quality.wordRetentionRatio < .4;
+	}).map((page) => page.htmlUrl);
+}
+function profileChecks(discovery) {
+	return [
+		"api",
+		"application",
+		"commerce"
+	].map((profile) => check$1("profile", {
+		id: `profile-${profile}`,
+		status: "notApplicable",
+		title: `${profile[0]?.toUpperCase()}${profile.slice(1)} checks are not applicable`,
+		plainEnglish: discovery.profileApplicability[profile].reason,
+		action: "Choose this profile only when the site exposes that capability publicly.",
+		evidence: {
+			profile,
+			selectedProfile: discovery.profile
+		}
+	}));
+}
+function summariseChecks(checks) {
+	const count = (status) => checks.filter((item) => item.status === status).length;
+	return {
+		checks: checks.length,
+		passed: count("pass"),
+		warnings: count("warning"),
+		failed: count("fail"),
+		unknown: count("unknown"),
+		information: count("info"),
+		notApplicable: count("notApplicable")
+	};
+}
+function markdownChecks(discovery) {
+	const markdown = discovery.markdownAlternates;
+	const failedUrls = failedMarkdownUrls(discovery);
+	const qualityUrls = qualityFailureUrls(discovery);
+	const coverageComplete = markdown.eligibleHtmlPages > 0 && markdown.advertisedPages === markdown.eligibleHtmlPages && markdown.evaluatedPages === markdown.eligibleHtmlPages;
+	const bytesMatch = markdown.eligibleHtmlPages > 0 && markdown.exactByteMatches === markdown.eligibleHtmlPages;
+	const stable = markdown.eligibleHtmlPages > 0 && markdown.stableResponses === markdown.eligibleHtmlPages;
+	const tokenHeaders = markdown.pages.filter((page) => page.explicit?.bytes !== void 0 && page.explicit?.markdownTokens !== void 0 && page.explicit.markdownTokens === Math.ceil(page.explicit.bytes / 4) && page.explicit.markdownTokens === page.negotiated?.markdownTokens).length;
+	return [
+		check$1("representations", {
+			id: "markdown-coverage",
+			status: markdown.eligibleHtmlPages === 0 ? "unknown" : coverageComplete ? "pass" : "fail",
+			title: coverageComplete ? "Every successful HTML page advertises one Markdown alternative" : "Markdown alternative coverage is incomplete",
+			plainEnglish: `${markdown.advertisedPages} of ${markdown.eligibleHtmlPages} successful HTML pages advertised one Markdown alternative, and ${markdown.evaluatedPages} were fetched.`,
+			action: coverageComplete ? "Keep route generation tied to the same deterministic page manifest." : "Add one text/markdown alternate for each public HTML page and make every advertised URL return successfully.",
+			evidence: {
+				eligibleHtmlPages: markdown.eligibleHtmlPages,
+				advertisedPages: markdown.advertisedPages,
+				evaluatedPages: markdown.evaluatedPages
+			},
+			urls: failedUrls.slice(0, 25)
+		}),
+		check$1("representations", {
+			id: "markdown-token-estimates",
+			status: markdown.evaluatedPages === 0 ? "unknown" : tokenHeaders === markdown.evaluatedPages ? "pass" : "warning",
+			title: tokenHeaders === markdown.evaluatedPages ? "Every Markdown response includes the same token estimate" : "Some Markdown responses are missing a stable token estimate",
+			plainEnglish: `${tokenHeaders} of ${markdown.evaluatedPages} evaluated pages returned matching X-Markdown-Tokens values on the explicit and negotiated responses. The value is a quick size estimate, not an exact model-specific token count.`,
+			action: "Generate the estimate from the stored Markdown bytes and return the same value for explicit and negotiated responses.",
+			urls: markdown.pages.filter((page) => page.explicit?.markdownTokens === void 0 || page.explicit.markdownTokens !== page.negotiated?.markdownTokens).map((page) => page.htmlUrl).slice(0, 25)
+		}),
+		check$1("representations", {
+			id: "markdown-negotiation",
+			status: markdown.eligibleHtmlPages === 0 ? "unknown" : bytesMatch && discovery.contentNegotiation.qZeroHonoured ? "pass" : "fail",
+			title: bytesMatch && discovery.contentNegotiation.qZeroHonoured ? "Explicit and negotiated Markdown use the same bytes" : "Content negotiation does not match the explicit Markdown contract",
+			plainEnglish: `${markdown.exactByteMatches} of ${markdown.eligibleHtmlPages} pages returned identical explicit and negotiated Markdown. A request that refuses Markdown ${discovery.contentNegotiation.qZeroHonoured ? "received HTML" : "did not produce confirmed HTML evidence"}.`,
+			action: "Use one stored Markdown artifact for both routes, honour Accept q-values, and send Vary: Accept on negotiated responses.",
+			evidence: {
+				exactByteMatches: markdown.exactByteMatches,
+				qZero: discovery.contentNegotiation
+			},
+			urls: failedUrls.slice(0, 25)
+		}),
+		check$1("representations", {
+			id: "markdown-determinism",
+			status: markdown.eligibleHtmlPages === 0 ? "unknown" : stable ? "pass" : "fail",
+			title: stable ? "Repeated Markdown responses are stable" : "Repeated Markdown responses changed during the audit",
+			plainEnglish: `${markdown.stableResponses} of ${markdown.eligibleHtmlPages} repeated explicit responses kept the same SHA-256 digest.`,
+			action: "Generate Markdown during the build and remove runtime rewriting, timestamps, or random output.",
+			evidence: { stableResponses: markdown.stableResponses },
+			urls: failedUrls.slice(0, 25)
+		}),
+		check$1("representations", {
+			id: "markdown-quality",
+			status: markdown.evaluatedPages === 0 ? "unknown" : qualityUrls.length === 0 ? "pass" : "warning",
+			title: qualityUrls.length === 0 ? "Markdown keeps the useful document structure cleanly" : "Some Markdown alternatives need an extraction review",
+			plainEnglish: qualityUrls.length === 0 ? "The evaluated alternatives retained one H1, frontmatter titles, balanced code fences, useful copy, and no leaked SVG, script, style, or layout tags." : `${qualityUrls.length} Markdown alternative${qualityUrls.length === 1 ? "" : "s"} lost important structure, looked navigation-only, or leaked presentation markup.`,
+			action: "Open the affected Markdown directly and fix the shared converter or component exclusion rules rather than patching generated files.",
+			urls: qualityUrls.slice(0, 25)
+		})
+	];
+}
+function discoveryChecks(discovery) {
+	const skills = discovery.agentSkills;
+	const skillsValid = skills.validIndex && skills.skills.length > 0 && skills.skills.every((skill) => skill.sameOrigin && skill.status === 200 && /^\s*text\/markdown\b/iu.test(skill.contentType ?? "") && Boolean(skill.cors) && skill.digestMatches === true && skill.frontmatterValid === true) && Boolean(skills.cors);
+	const llms = discovery.llmsTxt;
+	const llmsBroken = llms.links.filter((link) => !link.status || link.status < 200 || link.status >= 400);
+	const llmsValid = llms.exists && /^\s*(?:text\/plain|text\/markdown)\b/iu.test(llms.contentType ?? "") && llms.headingCount > 0 && llms.links.length > 0 && !llms.linkLimitReached && !llms.oversized && llms.invalidLinks.length === 0 && llms.duplicateLinks.length === 0 && llms.redirectedLinks.length === 0 && llms.nonIndexableLinks.length === 0 && llms.missingCrawlRoutes.length === 0 && llmsBroken.length === 0 && llms.repeatedHashStable === true;
+	return [
+		check$1("discovery", {
+			id: "agent-skills",
+			status: skillsValid ? "pass" : skills.status === 404 ? "info" : "warning",
+			title: skillsValid ? "Agent Skills discovery is valid and digest verified" : "Agent Skills discovery is absent or needs attention",
+			plainEnglish: skillsValid ? `${skills.skills.length} published skill${skills.skills.length === 1 ? "" : "s"} matched the declared SHA-256 digest, valid SKILL.md frontmatter, Markdown content type, and cross-origin access policy.` : "Agent Skills is optional for a content site, but a published index should resolve same-origin Markdown skill files, allow intended cross-origin clients, and verify their declared bytes.",
+			action: "If you publish Agent Skills, keep the discovery index and SHA-256 digests generated from the exact deployed skill bytes.",
+			evidence: skills
+		}),
+		check$1("discovery", {
+			id: "llms-txt",
+			status: llms.exists ? llmsValid ? "pass" : "warning" : "info",
+			title: llms.exists ? llmsValid ? "llms.txt is short, stable, and its links resolve" : "llms.txt exists but needs a content or link review" : "llms.txt is not published",
+			plainEnglish: llms.exists ? `${llms.links.length} declared links were checked. ${llms.invalidLinks.length} were malformed, ${llms.duplicateLinks.length} were duplicated, ${llms.redirectedLinks.length} redirected, ${llms.nonIndexableLinks.length} reached non-indexable pages, ${llmsBroken.length} did not resolve, and ${llms.missingCrawlRoutes.length} were missing from the crawl inventory. ${llms.offSiteLinks.length} linked to other sites.` : "llms.txt is optional and its absence is not a search ranking problem.",
+			action: llms.exists ? "Keep the file curated, deterministic, and limited to useful entry points whose links still resolve." : "Add it only when an intended consumer uses it. Do not treat it as a Google ranking requirement.",
+			evidence: {
+				status: llms.status,
+				contentType: llms.contentType,
+				bytes: llms.bytes,
+				oversized: llms.oversized,
+				totalParsedLinks: llms.totalParsedLinks,
+				linkLimitReached: llms.linkLimitReached,
+				links: llms.links.length,
+				invalidLinks: llms.invalidLinks,
+				duplicateLinks: llms.duplicateLinks,
+				offSiteLinks: llms.offSiteLinks,
+				redirectedLinks: llms.redirectedLinks,
+				nonIndexableLinks: llms.nonIndexableLinks,
+				missingCrawlRoutes: llms.missingCrawlRoutes,
+				repeatedHashStable: llms.repeatedHashStable
+			},
+			urls: [
+				...llmsBroken.map((link) => link.url),
+				...llms.redirectedLinks,
+				...llms.nonIndexableLinks,
+				...llms.missingCrawlRoutes
+			].slice(0, 25)
+		}),
+		check$1("discovery", {
+			id: "content-signals",
+			status: discovery.contentSignals.consistent === null ? "unknown" : discovery.contentSignals.consistent ? "pass" : "warning",
+			title: discovery.contentSignals.consistent ? "HTML and Markdown publish one explicit Content Signals policy" : "Content Signals are missing or inconsistent across representations",
+			plainEnglish: discovery.contentSignals.consistent ? `The same ${discovery.contentSignals.htmlValues[0]} policy was observed on every evaluated HTML and Markdown response.` : `${discovery.contentSignals.missingHtmlPages} HTML responses and ${discovery.contentSignals.missingMarkdownPages} Markdown responses were missing the header, or the observed values differed.`,
+			action: "Choose the site policy deliberately and return the same Content-Signal value on HTML and Markdown responses.",
+			evidence: discovery.contentSignals
+		}),
+		check$1("discovery", {
+			id: "route-manifest",
+			status: !discovery.routeManifest.valid ? "info" : discovery.routeManifest.missingHtmlRoutes.length === 0 && discovery.routeManifest.missingMarkdownRoutes.length === 0 && discovery.routeManifest.orphanMarkdownRoutes.length === 0 ? "pass" : "warning",
+			title: discovery.routeManifest.valid ? "The public route manifest agrees with the crawl" : "No public route manifest was available",
+			plainEnglish: discovery.routeManifest.valid ? `The manifest declared ${discovery.routeManifest.declaredHtmlRoutes.length} HTML routes and ${discovery.routeManifest.declaredMarkdownRoutes.length} Markdown routes. Missing or orphan routes are listed in the evidence.` : "A public route manifest is optional. Without one, this crawl cannot prove that no orphan Markdown files were deployed.",
+			action: "Generate one deterministic route inventory from the build when exact HTML and Markdown parity matters.",
+			evidence: discovery.routeManifest
+		})
+	];
+}
+function accessChecks(report, discovery) {
+	const bots = report.ai?.robotsTxt?.botAccess ?? [];
+	const blocked = bots.filter((bot) => bot.allowed === false);
+	const robotsKnown = report.ai?.robotsTxt?.availability === "available" || report.ai?.robotsTxt?.availability === "absent";
+	const protocol = discovery.protocolVariants;
+	return [check$1("access", {
+		id: "crawler-access",
+		status: !robotsKnown ? "unknown" : blocked.length > 0 ? "warning" : "pass",
+		title: blocked.length ? "robots.txt blocks selected crawler tokens" : "No selected crawler token is blocked at the start URL",
+		plainEnglish: robotsKnown ? `${blocked.length} of ${bots.length} selected crawler tokens were blocked by the start URL robots.txt policy.` : "The robots.txt response was not stable enough to make a crawler-access claim.",
+		action: "Keep blocks intentional. A crawler token being allowed here does not prove that the service will crawl, index, or cite the site.",
+		evidence: {
+			availability: report.ai?.robotsTxt?.availability,
+			blocked,
+			botAccess: bots
+		}
+	}), check$1("access", {
+		id: "protocol-canonicalization",
+		status: protocol.http.permanentRedirectToHttps === true && protocol.hstsOnStartPage === true ? "pass" : protocol.http.permanentRedirectToHttps === null ? "unknown" : "warning",
+		title: protocol.http.permanentRedirectToHttps === true && protocol.hstsOnStartPage === true ? "HTTP redirects permanently to HTTPS and HTTPS sends HSTS" : "Protocol canonicalization needs attention or could not be proven",
+		plainEnglish: `The HTTP variant ${protocol.http.permanentRedirectToHttps === true ? "redirected permanently to HTTPS" : "did not produce a confirmed permanent HTTPS redirect"}. The HTTPS start page ${protocol.hstsOnStartPage ? "sent HSTS" : "did not provide confirmed HSTS evidence"}.`,
+		action: "Use one permanent HTTP-to-HTTPS redirect and send HSTS only after HTTPS is stable across the site.",
+		evidence: protocol
+	})];
+}
+function identityChecks(report) {
+	const types = new Set(report.pages.flatMap((page) => page.schemaTypes ?? []));
+	const hasSoftware = types.has("SoftwareApplication");
+	const hasWebsite = types.has("WebSite");
+	const hasCreator = types.has("Person") || types.has("Organization");
+	const pageTypes = [
+		"WebPage",
+		"TechArticle",
+		"CollectionPage"
+	].filter((type) => types.has(type));
+	const officialProfiles = [...new Set(report.pages.flatMap((page) => [...page.schemaSameAs ?? [], ...page.socialProfileLinks ?? []]))];
+	return [check$1("identity", {
+		id: "identity-graph",
+		status: hasSoftware && hasWebsite && hasCreator && pageTypes.length > 0 ? "pass" : "warning",
+		title: hasSoftware && hasWebsite && hasCreator && pageTypes.length > 0 ? "Structured identity covers the software, website, creator, and pages" : "The structured identity graph is missing a useful entity layer",
+		plainEnglish: `Software identity: ${hasSoftware ? "present" : "missing"}. Website identity: ${hasWebsite ? "present" : "missing"}. Creator or publisher identity: ${hasCreator ? "present" : "missing"}. Page-level types: ${pageTypes.length ? pageTypes.join(", ") : "missing"}.`,
+		action: "Connect truthful SoftwareApplication, WebSite, creator or publisher, and page nodes. Use sameAs only for official profiles that identify the same entity.",
+		evidence: {
+			schemaTypes: [...types].sort(),
+			officialProfiles: officialProfiles.sort()
+		}
+	})];
+}
+function agentReadiness(report) {
+	const discovery = report.agentDiscovery;
+	if (!discovery) {
+		const profiles = {
+			content: {
+				status: "evaluated",
+				reason: "The content profile was selected but discovery evidence was not collected."
+			},
+			api: {
+				status: "notApplicable",
+				reason: "Not selected."
+			},
+			application: {
+				status: "notApplicable",
+				reason: "Not selected."
+			},
+			commerce: {
+				status: "notApplicable",
+				reason: "Not selected."
+			}
+		};
+		const missing = check$1("collection", {
+			id: "agent-discovery-evidence",
+			status: "unknown",
+			title: "Agent discovery evidence was not collected",
+			plainEnglish: "This saved crawl predates the focused content-profile checks or was run without them.",
+			action: "Run the agent-readiness report with a URL or start a fresh crawl with agent discovery enabled."
+		});
+		const scopeChecks = profileChecks({
+			profile: "content",
+			profileApplicability: profiles
+		});
+		const checks = [missing, ...scopeChecks];
+		return {
+			reportId: report.id,
+			url: report.config.url,
+			generatedAt: report.generatedAt,
+			profile: "content",
+			dataStatus: "unavailable",
+			assessment: "evidence-only",
+			headline: "No agent-discovery evidence is stored in this crawl. Run a fresh focused check.",
+			profileApplicability: profiles,
+			summary: summariseChecks(checks),
+			sections: [section$1("collection", "Evidence collection", [missing]), section$1("profile", "Profile scope", scopeChecks)],
+			checks,
+			topActions: [missing],
+			caveats: ["Not evaluated does not mean absent or broken.", "This report does not measure rankings, AI mentions, citations, or selection."]
+		};
+	}
+	const sections = [
+		section$1("profile", "Profile scope", profileChecks(discovery)),
+		section$1("access", "Crawler and protocol access", accessChecks(report, discovery)),
+		section$1("representations", "HTML and Markdown representations", markdownChecks(discovery)),
+		section$1("discovery", "Agent discovery files", discoveryChecks(discovery)),
+		section$1("identity", "Identity evidence", identityChecks(report))
+	];
+	const checks = sections.flatMap((item) => item.checks);
+	const actionable = checks.filter((item) => [
+		"fail",
+		"warning",
+		"unknown"
+	].includes(item.status));
+	const rank = {
+		fail: 0,
+		warning: 1,
+		unknown: 2,
+		pass: 3,
+		info: 4,
+		notApplicable: 5
+	};
+	const topActions = [...actionable].sort((left, right) => rank[left.status] - rank[right.status]).slice(0, 10);
+	const summary = summariseChecks(checks);
+	return {
+		reportId: report.id,
+		url: report.config.url,
+		generatedAt: report.generatedAt,
+		profile: discovery.profile,
+		dataStatus: discovery.dataStatus,
+		assessment: "evidence-only",
+		headline: `${summary.passed} checks passed, ${summary.warnings} need review, and ${summary.failed} failed for the content profile.`,
+		profileApplicability: discovery.profileApplicability,
+		summary,
+		sections,
+		checks,
+		topActions,
+		caveats: [
+			...report.caveats,
+			...discovery.warnings,
+			"A clean content profile does not prove indexing, rankings, AI mentions, citations, or selection.",
+			"A crawler token being allowed does not prove that a service fetched or used the page.",
+			"API, application, and commerce checks were not applicable to this content-site run."
+		]
+	};
+}
+//#endregion
+//#region packages/core/dist/analyze/crawler/entity-readiness.js
+const ENTITY_EVIDENCE_SCHEMA_TYPES = /* @__PURE__ */ new Set([
+	"organization",
+	"localbusiness",
+	"person",
+	"product",
+	"softwareapplication",
+	"website"
+]);
+const SITE_IDENTITY_SCHEMA_TYPES = /* @__PURE__ */ new Set(["organization", "localbusiness"]);
+const PROFILE_IDENTITY_SCHEMA_TYPES = /* @__PURE__ */ new Set([...SITE_IDENTITY_SCHEMA_TYPES, "person"]);
+function isEntityEvidenceSchemaType(type) {
+	return ENTITY_EVIDENCE_SCHEMA_TYPES.has(type.toLowerCase());
+}
+function isSiteIdentitySchemaType(type) {
+	return SITE_IDENTITY_SCHEMA_TYPES.has(type.toLowerCase());
+}
+function isProfileIdentitySchemaType(type) {
+	return PROFILE_IDENTITY_SCHEMA_TYPES.has(type.toLowerCase());
+}
+function unique$3(values) {
+	return [...new Set(values.filter((value) => Boolean(value)))];
+}
 function pct$3(part, total) {
+	return total ? Math.round(part / total * 100) : 0;
+}
+function entityReadiness(report) {
+	const pages = report.pages.filter((page) => page.indexable && page.status < 400);
+	const total = pages.length || 1;
+	const schemaTypes = {};
+	for (const page of pages) for (const type of page.schemaTypes ?? []) schemaTypes[type] = (schemaTypes[type] ?? 0) + 1;
+	const entitySchemaPages = pages.filter((page) => page.schemaTypes?.some(isEntityEvidenceSchemaType));
+	const sameAsEvidence = pages.flatMap((page) => page.schemaSameAsEvidence ?? []).filter((evidence) => evidence.subjectTypes.some(isProfileIdentitySchemaType));
+	const siteSameAsEvidence = sameAsEvidence.filter((evidence) => evidence.subjectTypes.some(isSiteIdentitySchemaType));
+	const sameAs = unique$3(sameAsEvidence.map((evidence) => evidence.url));
+	const sameAsByType = {};
+	for (const evidence of sameAsEvidence) for (const type of evidence.subjectTypes) {
+		if (!isProfileIdentitySchemaType(type)) continue;
+		sameAsByType[type] = unique$3([...sameAsByType[type] ?? [], evidence.url]);
+	}
+	const socialProfiles = unique$3(pages.flatMap((page) => page.socialProfileLinks ?? []));
+	const authors = unique$3(pages.map((page) => page.author));
+	const authorPages = pages.filter((page) => page.author || page.geo?.hasAuthor);
+	const datePages = pages.filter((page) => page.hasDate || page.geo?.hasDate);
+	const titlePages = pages.filter((page) => page.title && page.h1);
+	const checks = [
+		{
+			coverage: pct$3(entitySchemaPages.length, total),
+			check: {
+				id: "entity-schema",
+				title: "Entity schema is present",
+				plainEnglish: `${pct$3(entitySchemaPages.length, total)}% of evaluated indexable pages include Organization, LocalBusiness, Person, Product, SoftwareApplication, or WebSite schema.`,
+				action: "Add accurate schema only where it describes the software, website, organization, person, product, or local business shown on the page.",
+				evidence: { schemaTypes },
+				urls: pages.filter((page) => !entitySchemaPages.includes(page)).slice(0, 10).map((page) => page.finalUrl)
+			}
+		},
+		{
+			coverage: siteSameAsEvidence.length ? 100 : 0,
+			check: {
+				id: "same-as",
+				title: "Site entity profiles are connected",
+				plainEnglish: siteSameAsEvidence.length ? "The crawl found sameAs links attached to Organization or LocalBusiness structured data." : sameAs.length ? "The crawl found Person sameAs links, but no Organization or LocalBusiness profile evidence for the site entity." : socialProfiles.length ? "The crawl found social-domain links, but they are not enough to prove official profile ownership." : "The crawl did not find entity-scoped sameAs evidence.",
+				action: "Connect official profiles with sameAs on Organization, Person, or LocalBusiness schema. Use only profiles you control.",
+				evidence: {
+					sameAs,
+					siteSameAs: unique$3(siteSameAsEvidence.map((evidence) => evidence.url)),
+					sameAsEvidence,
+					unclassifiedSocialLinks: socialProfiles
+				}
+			}
+		},
+		{
+			coverage: Math.round((pct$3(authorPages.length, total) + pct$3(datePages.length, total)) / 2),
+			check: {
+				id: "authority-freshness",
+				title: "Author and date signals observed",
+				plainEnglish: `${pct$3(authorPages.length, total)}% of evaluated indexable pages expose an author signal and ${pct$3(datePages.length, total)}% expose a date signal.`,
+				action: "For editorial content, identify authors and show accurate published or modified dates when that information is useful to readers.",
+				evidence: {
+					authorCoverage: pct$3(authorPages.length, total),
+					dateCoverage: pct$3(datePages.length, total),
+					authors
+				}
+			}
+		},
+		{
+			coverage: pct$3(titlePages.length, total),
+			check: {
+				id: "entity-naming",
+				title: "Title and H1 coverage observed",
+				plainEnglish: `${pct$3(titlePages.length, total)}% of evaluated indexable pages have both a title and H1.`,
+				action: "Review pages missing either signal. Keep brand, product, and person names accurate wherever they appear."
+			}
+		}
+	].map(({ coverage, check }) => ({
+		...check,
+		status: "info",
+		evidence: {
+			...check.evidence,
+			observedCoveragePercent: coverage
+		}
+	}));
+	const dataStatus = report.status === "completed" && pages.length > 0 ? "complete" : "partial";
+	return {
+		reportId: report.id,
+		url: report.config.url,
+		generatedAt: report.generatedAt,
+		dataStatus,
+		evaluatedPages: pages.length,
+		crawlPages: report.pages.length,
+		assessment: "evidence-only",
+		headline: dataStatus === "partial" ? "Entity evidence is incomplete; treat these findings as scoped to the evaluated pages, not the whole site." : "Entity signals are reported as observations, not a ranking, visibility, or machine-understanding score.",
+		caveats: [
+			...report.caveats,
+			"This report deliberately has no aggregate entity score. Add schema, authors, dates, and sameAs only where they accurately fit the page and a documented use case.",
+			...dataStatus === "partial" ? [`Entity coverage is based on ${pages.length} evaluated indexable page${pages.length === 1 ? "" : "s"} from a ${report.status} crawl.`] : [],
+			...socialProfiles.length && !sameAs.length ? ["Social-domain links are unclassified navigation evidence, not proof that the linked profiles are official."] : []
+		],
+		checks,
+		entities: {
+			schemaTypes,
+			sameAs,
+			sameAsByType,
+			socialProfiles,
+			authors
+		}
+	};
+}
+//#endregion
+//#region packages/core/dist/analyze/crawler/ai-readiness.js
+function pct$2(part, total) {
 	if (total <= 0) return 0;
 	return Math.round(part / total * 100);
 }
@@ -6068,6 +7150,7 @@ function sampleUrls$1(pages, predicate) {
 	return pages.filter(predicate).slice(0, 10).map((page) => page.finalUrl);
 }
 function aiReadiness(report) {
+	const agentDiscovery = report.agentDiscovery;
 	const pages = indexablePages$1(report);
 	const pageCount = pages.length;
 	const hasIndexablePages = pageCount > 0;
@@ -6091,7 +7174,7 @@ function aiReadiness(report) {
 	const titlePages = pages.filter((page) => page.title && page.h1);
 	const metaPages = pages.filter((page) => page.metaDescription);
 	const langPages = pages.filter((page) => page.lang);
-	const entityPages = pages.filter((page) => page.schemaTypes?.some((type) => /^(Organization|LocalBusiness|Person|Product|WebSite)$/i.test(type)) || (page.schemaSameAs?.length ?? 0) > 0 || (page.socialProfileLinks?.length ?? 0) > 0);
+	const entityPages = pages.filter((page) => page.schemaTypes?.some(isEntityEvidenceSchemaType) || (page.schemaSameAs?.length ?? 0) > 0 || (page.socialProfileLinks?.length ?? 0) > 0);
 	const restrictedSnippets = pages.map((page) => ({
 		url: page.finalUrl,
 		control: effectiveSnippetControl({
@@ -6108,7 +7191,7 @@ function aiReadiness(report) {
 				section: "agent-access",
 				maxScore: 20,
 				evaluated: botAccessEvaluated,
-				score: robotsUnavailable ? 0 : botAccess.length ? blockedBots.length ? scoreFromPercent(pct$3(botAccess.length - blockedBots.length, botAccess.length), 20) : 20 : 8,
+				score: robotsUnavailable ? 0 : botAccess.length ? blockedBots.length ? scoreFromPercent(pct$2(botAccess.length - blockedBots.length, botAccess.length), 20) : 20 : 8,
 				title: robotsUnavailable ? "robots.txt crawler-policy evidence is unavailable" : !hasBotAccessEvidence ? "robots.txt crawler-policy evidence was not collected" : blockedBots.length ? "robots.txt blocks selected crawler tokens at the start URL" : "robots.txt allows selected crawler tokens at the start URL",
 				plainEnglish: robotsUnavailable ? "The robots.txt request failed, so this report cannot say whether selected crawler tokens are allowed at the start URL." : !hasBotAccessEvidence ? "This crawl does not include per-bot robots.txt policy data for the start URL." : blockedBots.length ? `robots.txt policy blocks ${blockedBots.length} selected crawler ${blockedBots.length === 1 ? "token" : "tokens"} at the start URL.` : "robots.txt policy does not block the selected crawler tokens at the start URL. This does not verify actual or site-wide fetchability.",
 				action: robotsUnavailable ? "Restore a stable robots.txt response, then rerun this report before making crawler-policy claims." : !hasBotAccessEvidence ? "Rerun the crawl with top-level per-bot robots.txt evidence before making crawler-policy claims." : blockedBots.length ? "Only block AI crawlers intentionally. If discovery matters, remove accidental Disallow rules for the blocked user agents." : "Keep robots.txt explicit and intentional so humans and agents can see what is allowed.",
@@ -6151,10 +7234,11 @@ function aiReadiness(report) {
 			maxScore: 0,
 			score: 0,
 			title: "llms.txt is optional",
-			plainEnglish: report.ai?.llmsTxt?.exists ? "An optional llms.txt file was found. Google says it has no positive or negative Search impact." : "No llms.txt file was found. Google says the file is not needed for Search and does not affect visibility.",
+			plainEnglish: report.ai?.llmsTxt?.exists ? agentDiscovery?.llmsTxt ? `An optional llms.txt file was found and its body was checked. It declared ${agentDiscovery.llmsTxt.links.length} links, ${agentDiscovery.llmsTxt.duplicateLinks.length} duplicates, and ${agentDiscovery.llmsTxt.missingCrawlRoutes.length} links outside the crawled route inventory. Google says llms.txt has no positive or negative Search impact.` : "An optional llms.txt file was found. Its body was not validated in this crawl. Google says it has no positive or negative Search impact." : "No llms.txt file was found. Google says the file is not needed for Search and does not affect visibility.",
 			action: "No SEO action is required. Generate one only for a specific agent or service that consumes it.",
 			evidence: {
 				llmsTxt: report.ai?.llmsTxt,
+				validation: agentDiscovery?.llmsTxt,
 				googleSearchImpact: "none",
 				guidanceUrl: "https://developers.google.com/search/updates#clarifying-guidance-on-llms-txt-files"
 			}
@@ -6177,7 +7261,7 @@ function aiReadiness(report) {
 				evaluated: hasIndexablePages,
 				score: 0,
 				title: "Short opening paragraphs are an unscored observation",
-				plainEnglish: hasIndexablePages ? `${pct$3(answerablePages.length, pageCount)}% of indexable pages have at least one 25-word paragraph near the start. This does not establish content quality, citation likelihood, or Google AI eligibility.` : "No indexable 2xx pages were available, so opening-paragraph coverage was not evaluated.",
+				plainEnglish: hasIndexablePages ? `${pct$2(answerablePages.length, pageCount)}% of indexable pages have at least one 25-word paragraph near the start. This does not establish content quality, citation likelihood, or Google AI eligibility.` : "No indexable 2xx pages were available, so opening-paragraph coverage was not evaluated.",
 				action: "Write for the reader and the page intent. Do not create artificial answer blocks or chunk content solely for AI Search.",
 				urls: sampleUrls$1(pages, (page) => !page.geo?.answerable),
 				evidence: {
@@ -6195,7 +7279,7 @@ function aiReadiness(report) {
 				evaluated: hasIndexablePages,
 				score: 0,
 				title: "Semantic HTML coverage observed",
-				plainEnglish: hasIndexablePages ? `${pct$3(semanticPages.length, pageCount)}% of indexable pages use semantic structure.` : "No indexable 2xx pages were available, so semantic HTML coverage was not evaluated.",
+				plainEnglish: hasIndexablePages ? `${pct$2(semanticPages.length, pageCount)}% of indexable pages use semantic structure.` : "No indexable 2xx pages were available, so semantic HTML coverage was not evaluated.",
 				action: "Use real headings, lists, tables, nav, main, article, and section elements instead of layout-only divs."
 			}),
 			check({
@@ -6205,7 +7289,7 @@ function aiReadiness(report) {
 				evaluated: hasIndexablePages,
 				score: 0,
 				title: "Title, H1, and description coverage observed",
-				plainEnglish: hasIndexablePages ? `${pct$3(titlePages.length, pageCount)}% of indexable pages have title/H1 coverage and ${pct$3(metaPages.length, pageCount)}% have meta descriptions.` : "No indexable 2xx pages were available, so title, H1, and description coverage was not evaluated.",
+				plainEnglish: hasIndexablePages ? `${pct$2(titlePages.length, pageCount)}% of indexable pages have title/H1 coverage and ${pct$2(metaPages.length, pageCount)}% have meta descriptions.` : "No indexable 2xx pages were available, so title, H1, and description coverage was not evaluated.",
 				action: "Write a unique title and descriptive H1. Add a useful meta description when a summary would help searchers understand the page."
 			}),
 			check({
@@ -6215,7 +7299,7 @@ function aiReadiness(report) {
 				evaluated: hasIndexablePages,
 				score: 0,
 				title: "HTML language declaration coverage observed",
-				plainEnglish: hasIndexablePages ? `${pct$3(langPages.length, pageCount)}% of indexable pages declare a language.` : "No indexable 2xx pages were available, so language declaration coverage was not evaluated.",
+				plainEnglish: hasIndexablePages ? `${pct$2(langPages.length, pageCount)}% of indexable pages declare a language.` : "No indexable 2xx pages were available, so language declaration coverage was not evaluated.",
 				action: "Set the html lang attribute so crawlers and assistive tech understand the page language."
 			})
 		]),
@@ -6226,7 +7310,7 @@ function aiReadiness(report) {
 			evaluated: hasIndexablePages,
 			score: 0,
 			title: "Entity-signal coverage observed",
-			plainEnglish: hasIndexablePages ? `${pct$3(entityPages.length, pageCount)}% of indexable pages include entity signals such as Organization, Person, Product, sameAs, or social profile links.` : "No indexable 2xx pages were available, so entity-signal coverage was not evaluated.",
+			plainEnglish: hasIndexablePages ? `${pct$2(entityPages.length, pageCount)}% of indexable pages include entity signals such as Organization, Person, Product, sameAs, or social profile links.` : "No indexable 2xx pages were available, so entity-signal coverage was not evaluated.",
 			action: "Make the homepage and key pages explicit about the brand, product, people, and official profiles using accurate schema and links.",
 			urls: sampleUrls$1(pages, (page) => !entityPages.includes(page))
 		}), check({
@@ -6270,12 +7354,52 @@ function aiReadiness(report) {
 				section: "technical-ux",
 				maxScore: 12,
 				evaluated: report.pages.length > 0,
-				score: scoreFromPercent(pct$3(pages.length, report.pages.length || 1), 12),
+				score: scoreFromPercent(pct$2(pages.length, report.pages.length || 1), 12),
 				title: report.pages.length ? "Crawled-page indexability observed" : "Crawled-page indexability was not evaluated",
-				plainEnglish: report.pages.length ? `${pct$3(pages.length, report.pages.length)}% of crawled pages are indexable 2xx pages.` : "No crawled pages were available, so status and indexability were not evaluated.",
+				plainEnglish: report.pages.length ? `${pct$2(pages.length, report.pages.length)}% of crawled pages are indexable 2xx pages.` : "No crawled pages were available, so status and indexability were not evaluated.",
 				action: "Fix 4xx/5xx pages, accidental noindex, and blocked internal URLs before expanding AI discovery work."
 			})
 		]),
+		section("agent-content", "Agent content observations", [
+			check({
+				id: "markdown-alternates",
+				section: "agent-content",
+				maxScore: 0,
+				score: 0,
+				evaluated: Boolean(agentDiscovery),
+				title: agentDiscovery ? "Markdown alternatives were checked" : "Markdown alternatives were not evaluated",
+				plainEnglish: agentDiscovery ? `${agentDiscovery.markdownAlternates.advertisedPages} of ${agentDiscovery.markdownAlternates.eligibleHtmlPages} successful HTML pages advertised one Markdown alternative. ${agentDiscovery.markdownAlternates.exactByteMatches} explicit responses matched content negotiation byte for byte.` : "This crawl does not include the focused representation checks, so it cannot say whether HTML pages publish stable Markdown alternatives.",
+				action: "Use the focused agent-readiness report when you need route coverage, content negotiation, byte stability, or extraction-quality evidence.",
+				evidence: agentDiscovery ? {
+					eligibleHtmlPages: agentDiscovery.markdownAlternates.eligibleHtmlPages,
+					advertisedPages: agentDiscovery.markdownAlternates.advertisedPages,
+					exactByteMatches: agentDiscovery.markdownAlternates.exactByteMatches,
+					stableResponses: agentDiscovery.markdownAlternates.stableResponses
+				} : void 0
+			}),
+			check({
+				id: "agent-skills-discovery",
+				section: "agent-content",
+				maxScore: 0,
+				score: 0,
+				evaluated: Boolean(agentDiscovery),
+				title: agentDiscovery ? "Agent Skills discovery was checked" : "Agent Skills discovery was not evaluated",
+				plainEnglish: agentDiscovery ? `${agentDiscovery.agentSkills.skills.length} published skill${agentDiscovery.agentSkills.skills.length === 1 ? "" : "s"} were found. ${agentDiscovery.agentSkills.skills.filter((skill) => skill.digestMatches).length} matched their declared SHA-256 digest.` : "This crawl checked common legacy descriptor paths but did not validate the Agent Skills discovery index or its file digests.",
+				action: "Publish Agent Skills only for real reusable capabilities. Generate the index digest from the exact deployed SKILL.md bytes.",
+				evidence: agentDiscovery?.agentSkills
+			}),
+			check({
+				id: "agent-content-profile",
+				section: "agent-content",
+				maxScore: 0,
+				score: 0,
+				evaluated: Boolean(agentDiscovery),
+				title: agentDiscovery ? "The content profile was selected explicitly" : "No focused agent-readiness profile was selected",
+				plainEnglish: agentDiscovery ? "Document access, representations, discovery, identity, and extraction quality were evaluated. API, application, and commerce checks were marked not applicable rather than failed." : "A normal crawl does not assume that a content site also exposes a public API, remote agent endpoint, or checkout.",
+				action: "Run a different profile only when that public capability really exists.",
+				evidence: agentDiscovery?.profileApplicability
+			})
+		]),
 		section("crawl-completeness", "Crawl completeness", [check({
 			id: "crawl-depth",
 			section: "crawl-completeness",
@@ -6326,117 +7450,6 @@ function aiReadiness(report) {
 	};
 }
 //#endregion
-//#region packages/core/dist/analyze/crawler/entity-readiness.js
-function unique$3(values) {
-	return [...new Set(values.filter((value) => Boolean(value)))];
-}
-function pct$2(part, total) {
-	return total ? Math.round(part / total * 100) : 0;
-}
-function entityReadiness(report) {
-	const pages = report.pages.filter((page) => page.indexable && page.status < 400);
-	const total = pages.length || 1;
-	const schemaTypes = {};
-	for (const page of pages) for (const type of page.schemaTypes ?? []) schemaTypes[type] = (schemaTypes[type] ?? 0) + 1;
-	const entitySchemaPages = pages.filter((page) => page.schemaTypes?.some((type) => /^(Organization|LocalBusiness|Person|Product|WebSite)$/i.test(type)));
-	const sameAsEvidence = pages.flatMap((page) => page.schemaSameAsEvidence ?? []).filter((evidence) => evidence.subjectTypes.some((type) => /^(Organization|LocalBusiness|Person)$/i.test(type)));
-	const siteSameAsEvidence = sameAsEvidence.filter((evidence) => evidence.subjectTypes.some((type) => /^(Organization|LocalBusiness)$/i.test(type)));
-	const sameAs = unique$3(sameAsEvidence.map((evidence) => evidence.url));
-	const sameAsByType = {};
-	for (const evidence of sameAsEvidence) for (const type of evidence.subjectTypes) {
-		if (!/^(Organization|LocalBusiness|Person)$/i.test(type)) continue;
-		sameAsByType[type] = unique$3([...sameAsByType[type] ?? [], evidence.url]);
-	}
-	const socialProfiles = unique$3(pages.flatMap((page) => page.socialProfileLinks ?? []));
-	const authors = unique$3(pages.map((page) => page.author));
-	const authorPages = pages.filter((page) => page.author || page.geo?.hasAuthor);
-	const datePages = pages.filter((page) => page.hasDate || page.geo?.hasDate);
-	const titlePages = pages.filter((page) => page.title && page.h1);
-	const checks = [
-		{
-			coverage: pct$2(entitySchemaPages.length, total),
-			check: {
-				id: "entity-schema",
-				title: "Entity schema is present",
-				plainEnglish: `${pct$2(entitySchemaPages.length, total)}% of evaluated indexable pages include Organization, LocalBusiness, Person, Product, or WebSite schema.`,
-				action: "Add accurate entity schema to the homepage and key product, author, organization, and local pages.",
-				evidence: { schemaTypes },
-				urls: pages.filter((page) => !entitySchemaPages.includes(page)).slice(0, 10).map((page) => page.finalUrl)
-			}
-		},
-		{
-			coverage: siteSameAsEvidence.length ? 100 : 0,
-			check: {
-				id: "same-as",
-				title: "Site entity profiles are connected",
-				plainEnglish: siteSameAsEvidence.length ? "The crawl found sameAs links attached to Organization or LocalBusiness structured data." : sameAs.length ? "The crawl found Person sameAs links, but no Organization or LocalBusiness profile evidence for the site entity." : socialProfiles.length ? "The crawl found social-domain links, but they are not enough to prove official profile ownership." : "The crawl did not find entity-scoped sameAs evidence.",
-				action: "Connect official profiles with sameAs on Organization, Person, or LocalBusiness schema. Use only profiles you control.",
-				evidence: {
-					sameAs,
-					siteSameAs: unique$3(siteSameAsEvidence.map((evidence) => evidence.url)),
-					sameAsEvidence,
-					unclassifiedSocialLinks: socialProfiles
-				}
-			}
-		},
-		{
-			coverage: Math.round((pct$2(authorPages.length, total) + pct$2(datePages.length, total)) / 2),
-			check: {
-				id: "authority-freshness",
-				title: "Author and date signals observed",
-				plainEnglish: `${pct$2(authorPages.length, total)}% of evaluated indexable pages expose an author signal and ${pct$2(datePages.length, total)}% expose a date signal.`,
-				action: "For editorial content, identify authors and show accurate published or modified dates when that information is useful to readers.",
-				evidence: {
-					authorCoverage: pct$2(authorPages.length, total),
-					dateCoverage: pct$2(datePages.length, total),
-					authors
-				}
-			}
-		},
-		{
-			coverage: pct$2(titlePages.length, total),
-			check: {
-				id: "entity-naming",
-				title: "Title and H1 coverage observed",
-				plainEnglish: `${pct$2(titlePages.length, total)}% of evaluated indexable pages have both a title and H1.`,
-				action: "Review pages missing either signal. Keep brand, product, and person names accurate wherever they appear."
-			}
-		}
-	].map(({ coverage, check }) => ({
-		...check,
-		status: "info",
-		evidence: {
-			...check.evidence,
-			observedCoveragePercent: coverage
-		}
-	}));
-	const dataStatus = report.status === "completed" && pages.length > 0 ? "complete" : "partial";
-	return {
-		reportId: report.id,
-		url: report.config.url,
-		generatedAt: report.generatedAt,
-		dataStatus,
-		evaluatedPages: pages.length,
-		crawlPages: report.pages.length,
-		assessment: "evidence-only",
-		headline: dataStatus === "partial" ? "Entity evidence is incomplete; treat these findings as scoped to the evaluated pages, not the whole site." : "Entity signals are reported as observations, not a ranking, visibility, or machine-understanding score.",
-		caveats: [
-			...report.caveats,
-			"This report deliberately has no aggregate entity score. Add schema, authors, dates, and sameAs only where they accurately fit the page and a documented use case.",
-			...dataStatus === "partial" ? [`Entity coverage is based on ${pages.length} evaluated indexable page${pages.length === 1 ? "" : "s"} from a ${report.status} crawl.`] : [],
-			...socialProfiles.length && !sameAs.length ? ["Social-domain links are unclassified navigation evidence, not proof that the linked profiles are official."] : []
-		],
-		checks,
-		entities: {
-			schemaTypes,
-			sameAs,
-			sameAsByType,
-			socialProfiles,
-			authors
-		}
-	};
-}
-//#endregion
 //#region packages/core/dist/analyze/crawler/geo-gaps.js
 const ELIGIBILITY_RULES = /* @__PURE__ */ new Set([
 	"connection_error",
@@ -6504,7 +7517,7 @@ function partialReasons(report) {
 	if (report.requestEvidenceStatus === "partial") reasons.push("request-evidence-partial");
 	if (report.requestEvidenceStatus === "unavailable") reasons.push("request-evidence-unavailable");
 	if (report.summary.pageLimitReached) reasons.push("page-limit-reached");
-	if (report.summary.skippedUrls > 0) reasons.push("skipped-urls");
+	if (report.summary.skippedUrlsByImpact.coverageAffecting > 0) reasons.push("coverage-affecting-skips");
 	if (report.summary.failedRequests > 0) reasons.push("failed-requests");
 	if (report.summary.extractionFailures > 0) reasons.push("extraction-failures");
 	return reasons;
@@ -6532,6 +7545,8 @@ function geoGapsReport(report, filters = {}) {
 			queuedUrls: report.summary.queuedUrls,
 			crawledUrls: report.summary.crawledUrls,
 			skippedUrls: report.summary.skippedUrls,
+			coverageAffectingSkippedUrls: report.summary.skippedUrlsByImpact.coverageAffecting,
+			nonImpactingSkippedUrls: report.summary.skippedUrlsByImpact.nonImpacting,
 			failedRequests: report.summary.failedRequests,
 			extractionFailures: report.summary.extractionFailures,
 			partialReasons: reasons
@@ -6594,8 +7609,56 @@ function candidatePages(report, options = {}) {
 }
 function auditLlmsTxt(report) {
 	const llmsTxt = report.ai?.llmsTxt;
+	const validation = report.agentDiscovery?.llmsTxt;
 	const pages = candidatePages(report);
 	const issues = [];
+	if (validation?.exists && !/^\s*(?:text\/plain|text\/markdown)\b/iu.test(validation.contentType ?? "")) issues.push({
+		id: "llms-content-type",
+		severity: "medium",
+		title: "llms.txt uses an unexpected content type",
+		plainEnglish: `The file returned ${validation.contentType ?? "no content type"} instead of plain text or Markdown.`,
+		action: "Serve the deterministic text file as text/plain or text/markdown so consumers do not mistake it for HTML.",
+		evidence: { contentType: validation.contentType }
+	});
+	if (validation?.exists && validation.headingCount === 0) issues.push({
+		id: "llms-structure",
+		severity: "medium",
+		title: "llms.txt has no useful heading structure",
+		plainEnglish: "The fetched file did not contain a level-one or level-two Markdown heading.",
+		action: "Start with one clear title, then group a short list of useful entry points under descriptive headings."
+	});
+	if (validation?.duplicateLinks.length) issues.push({
+		id: "llms-duplicate-links",
+		severity: "low",
+		title: "llms.txt repeats the same link",
+		plainEnglish: `${validation.duplicateLinks.length} URL${validation.duplicateLinks.length === 1 ? " appears" : "s appear"} more than once.`,
+		action: "Remove duplicate entries so the file remains short and deliberate.",
+		evidence: { urls: validation.duplicateLinks }
+	});
+	const brokenLinks = validation?.links.filter((link) => !link.status || link.status < 200 || link.status >= 400 || link.error) ?? [];
+	if (brokenLinks.length) issues.push({
+		id: "llms-broken-links",
+		severity: "medium",
+		title: "llms.txt links did not resolve",
+		plainEnglish: `${brokenLinks.length} declared link${brokenLinks.length === 1 ? "" : "s"} did not return a usable response during this audit.`,
+		action: "Update or remove stale entries, then rerun the focused agent-readiness report.",
+		evidence: { links: brokenLinks }
+	});
+	if (validation?.missingCrawlRoutes.length) issues.push({
+		id: "llms-outside-crawl",
+		severity: "low",
+		title: "llms.txt links fall outside the crawl inventory",
+		plainEnglish: `${validation.missingCrawlRoutes.length} same-origin route${validation.missingCrawlRoutes.length === 1 ? " was" : "s were"} not present in the retained crawl.`,
+		action: "Confirm those routes are intentional and indexable, or remove stale declarations.",
+		evidence: { urls: validation.missingCrawlRoutes }
+	});
+	if (validation?.repeatedHashStable === false) issues.push({
+		id: "llms-unstable-body",
+		severity: "medium",
+		title: "llms.txt changed between repeated requests",
+		plainEnglish: "Two requests in the same audit returned different SHA-256 digests.",
+		action: "Generate the file during the build and remove timestamps, random ordering, or runtime rewriting."
+	});
 	if (pages.length < 3) issues.push({
 		id: "thin-llms-inventory",
 		severity: "low",
@@ -6613,7 +7676,7 @@ function auditLlmsTxt(report) {
 		optional: true,
 		googleSearchImpact: "none",
 		guidanceUrl: "https://developers.google.com/search/updates#clarifying-guidance-on-llms-txt-files",
-		headline: llmsTxt?.exists ? "An optional llms.txt file is present. It has no Google Search visibility impact." : "No llms.txt file was found. This is not an SEO issue and requires no action.",
+		headline: llmsTxt?.exists ? validation ? issues.length ? `The optional llms.txt file was validated and ${issues.length} content or link issue${issues.length === 1 ? " needs" : "s need"} review. It has no Google Search visibility impact.` : `The optional llms.txt file was validated with ${validation.links.length} resolving link${validation.links.length === 1 ? "" : "s"} and a stable body. It has no Google Search visibility impact.` : "An optional llms.txt file is present, but its body was not validated in this crawl. It has no Google Search visibility impact." : "No llms.txt file was found. This is not an SEO issue and requires no action.",
 		issues,
 		recommendedPages: pages.slice(0, 25).map((page) => ({
 			url: page.finalUrl,
@@ -6712,8 +7775,6 @@ const SCORECARD_CHECK_ORDER = [
 	"entity-identity",
 	"answerable-content"
 ];
-const ENTITY_SCHEMA_PATTERN = /^(Organization|LocalBusiness|Person|Product|WebSite)$/i;
-const SITE_ENTITY_TYPE_PATTERN = /^(Organization|LocalBusiness)$/i;
 function indexablePages(report) {
 	return report.pages.filter((page) => page.indexable && page.status < 400);
 }
@@ -6921,8 +7982,8 @@ function entityIdentityCheck(report) {
 		finding: "Entity identity could not be evaluated because no indexable 2xx pages were available.",
 		verification
 	};
-	const hasEntitySchema = Object.keys(entity.entities.schemaTypes).some((type) => ENTITY_SCHEMA_PATTERN.test(type));
-	const siteSameAs = Object.entries(entity.entities.sameAsByType).filter(([type]) => SITE_ENTITY_TYPE_PATTERN.test(type)).flatMap(([, urls]) => urls);
+	const hasEntitySchema = Object.keys(entity.entities.schemaTypes).some(isEntityEvidenceSchemaType);
+	const siteSameAs = Object.entries(entity.entities.sameAsByType).filter(([type]) => isSiteIdentitySchemaType(type)).flatMap(([, urls]) => urls);
 	const uniqueSiteSameAs = [...new Set(siteSameAs)].sort();
 	const status = uniqueSiteSameAs.length ? "pass" : hasEntitySchema ? "warn" : "fail";
 	return {
@@ -6935,7 +7996,7 @@ function entityIdentityCheck(report) {
 			sameAs: entity.entities.sameAs,
 			socialProfiles: entity.entities.socialProfiles
 		},
-		finding: status === "pass" ? "The crawl found sameAs links attached to Organization or LocalBusiness structured data for the site entity." : status === "warn" ? "Entity schema is present, but no Organization or LocalBusiness sameAs evidence connects the site entity to official profiles." : "No Organization, LocalBusiness, Person, Product, or WebSite schema was found on the evaluated pages.",
+		finding: status === "pass" ? "The crawl found sameAs links attached to Organization or LocalBusiness structured data for the site entity." : status === "warn" ? "Entity schema is present, but no Organization or LocalBusiness sameAs evidence connects the site entity to official profiles." : "No Organization, LocalBusiness, Person, Product, SoftwareApplication, or WebSite schema was found on the evaluated pages.",
 		verification
 	};
 }
@@ -7428,7 +8489,7 @@ const RULE_DEFINITIONS = [
 		whyItMatters: "External links are part of the page experience and source trail. Broken references make content feel stale and less trustworthy.",
 		howToFix: "Replace the link with a working source, update the URL, or remove the reference if it no longer supports the page.",
 		impactIfIgnored: "Readers and agents following citations hit dead ends, which weakens trust in the content.",
-		howToVerify: "Re-run the crawl with external checks enabled and confirm the external link no longer appears in externalLinkChecks as broken."
+		howToVerify: "Re-run the crawl with external checks enabled and confirm the URL no longer has a confirmed-broken externalLinkChecks result."
 	},
 	{
 		id: "orphan_page",
@@ -8086,11 +9147,13 @@ function auditCrawlPages(pages, opts = {}) {
 			if (page.hasHsts === false) issues.push(issue("hsts_missing", page, void 0, { header: "strict-transport-security" }));
 		}
 		for (const link of page.externalLinkChecks ?? []) {
-			if (!isBrokenLinkStatus(link.status)) continue;
+			if (link.state !== "confirmed-broken") continue;
 			issues.push(issue("broken_external_link", page, link.url, {
 				url: link.url,
 				status: link.status,
-				error: link.error
+				error: link.error,
+				state: link.state,
+				attempts: link.attempts
 			}));
 		}
 		if (page.indexable && (page.internalInlinkCount ?? 0) === 0 && !sameUrl(page.url, opts.startUrl)) issues.push(issue("orphan_page", page, "No internal inlinks", { internalInlinkCount: page.internalInlinkCount ?? 0 }));
@@ -8225,6 +9288,80 @@ function auditCrawlPages(pages, opts = {}) {
 	return issues;
 }
 //#endregion
+//#region packages/core/dist/analyze/crawler/crawl-skip-reasons.js
+const CRAWL_SKIP_REASONS = [
+	"asset-url",
+	"configured-exclusion",
+	"duplicate-normalization",
+	"invalid-url",
+	"off-origin",
+	"origin-backpressure",
+	"queue-safety-limit",
+	"robots-disallowed",
+	"robots-uncertain",
+	"legacy-unclassified"
+];
+const SKIP_IMPACT = {
+	"asset-url": "non-impacting",
+	"configured-exclusion": "non-impacting",
+	"duplicate-normalization": "non-impacting",
+	"invalid-url": "non-impacting",
+	"off-origin": "non-impacting",
+	"origin-backpressure": "coverage-affecting",
+	"queue-safety-limit": "coverage-affecting",
+	"robots-disallowed": "coverage-affecting",
+	"robots-uncertain": "coverage-affecting",
+	"legacy-unclassified": "coverage-affecting"
+};
+const REASON_ORDER = new Map(CRAWL_SKIP_REASONS.map((reason, index) => [reason, index]));
+function isCrawlSkipReason(value) {
+	return typeof value === "string" && CRAWL_SKIP_REASONS.includes(value);
+}
+function validCount$1(value) {
+	return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : 0;
+}
+function crawlSkipImpact(reason) {
+	return SKIP_IMPACT[reason];
+}
+function normalizeCrawlSkipReasonCounts(input) {
+	const counts = /* @__PURE__ */ new Map();
+	if (Array.isArray(input.skipReasons)) for (const item of input.skipReasons) {
+		if (!item || typeof item !== "object") continue;
+		const { reason, count } = item;
+		if (!isCrawlSkipReason(reason)) continue;
+		const normalizedCount = validCount$1(count);
+		if (!normalizedCount) continue;
+		counts.set(reason, (counts.get(reason) ?? 0) + normalizedCount);
+	}
+	const declaredTotal = validCount$1(input.skippedUrls);
+	const classifiedTotal = [...counts.values()].reduce((total, count) => total + count, 0);
+	if (declaredTotal > classifiedTotal) counts.set("legacy-unclassified", (counts.get("legacy-unclassified") ?? 0) + declaredTotal - classifiedTotal);
+	const skipReasons = [...counts.entries()].map(([reason, count]) => ({
+		reason,
+		impact: crawlSkipImpact(reason),
+		count
+	})).sort((left, right) => (REASON_ORDER.get(left.reason) ?? Number.MAX_SAFE_INTEGER) - (REASON_ORDER.get(right.reason) ?? Number.MAX_SAFE_INTEGER));
+	const skippedUrlsByImpact = skipReasons.reduce((totals, item) => {
+		if (item.impact === "coverage-affecting") totals.coverageAffecting += item.count;
+		else totals.nonImpacting += item.count;
+		return totals;
+	}, {
+		coverageAffecting: 0,
+		nonImpacting: 0
+	});
+	return {
+		skippedUrls: skippedUrlsByImpact.coverageAffecting + skippedUrlsByImpact.nonImpacting,
+		skipReasons,
+		skippedUrlsByImpact
+	};
+}
+function crawlSkipReasonCountsFromRecord(input = {}) {
+	return normalizeCrawlSkipReasonCounts({ skipReasons: Object.entries(input).map(([reason, count]) => ({
+		reason,
+		count
+	})) }).skipReasons;
+}
+//#endregion
 //#region packages/core/dist/analyze/crawler/report.js
 const SENSITIVE_FIELD_NAMES = /* @__PURE__ */ new Set([
 	"authorization",
@@ -8263,6 +9400,7 @@ function normalizeCrawlConfig(input) {
 		respectRobots: input.respectRobots ?? true,
 		useSitemap: input.useSitemap ?? true,
 		checkExternal: input.checkExternal ?? true,
+		checkAgentDiscovery: input.checkAgentDiscovery ?? false,
 		js: normalizeJavaScriptRenderingMode(input.js),
 		refresh: input.refresh ?? false,
 		fetchRate: normalizeFetchRate(input)
@@ -8382,12 +9520,13 @@ function summarizeCrawlReport(input) {
 		}
 	}
 	for (const issue of input.issues) byCategory[issue.category] = (byCategory[issue.category] ?? 0) + 1;
+	const runStats = crawlRunStats(input.pages, input.stats);
 	return {
 		totalPages: input.pages.length,
 		indexablePages: input.pages.filter((page) => page.indexable).length,
 		nonIndexablePages: input.pages.filter((page) => !page.indexable).length,
 		statusErrors: input.pages.filter((page) => page.status === 0 || page.status >= 400).length,
-		...crawlRunStats(input.pages, input.stats),
+		...runStats,
 		attemptedRequests: input.requestEvidenceStatus === "unavailable" ? 0 : requests.length,
 		responseRequests: requests.filter((request) => request.outcome === "response").length,
 		failedRequests: failedRequests.length,
@@ -8412,11 +9551,17 @@ function crawlRunStats(pages, stats = {}) {
 		for (const url of page.sampleExternalLinks ?? []) discovered.add(url);
 		observedInternalLinks += page.outgoingInternalCount;
 	}
+	const skips = normalizeCrawlSkipReasonCounts({
+		skippedUrls: stats.skippedUrls,
+		skipReasons: stats.skipReasons ?? crawlSkipReasonCountsFromRecord(stats.skipReasonCounts)
+	});
 	return {
 		discoveredUrls: stats.discoveredUrls ?? discovered.size,
 		queuedUrls: stats.queuedUrls ?? pages.length,
 		crawledUrls: stats.crawledUrls ?? pages.length,
-		skippedUrls: stats.skippedUrls ?? 0,
+		skippedUrls: skips.skippedUrls,
+		skipReasons: skips.skipReasons,
+		skippedUrlsByImpact: skips.skippedUrlsByImpact,
 		failedUrls: stats.failedUrls ?? pages.filter((page) => page.status === 0 || page.status >= 400).length,
 		observedInternalLinks: stats.observedInternalLinks ?? observedInternalLinks,
 		pageLimitReached: stats.pageLimitReached ?? false
@@ -8506,6 +9651,7 @@ function createCrawlReport(input) {
 		...input.ai ? { ai: sanitizeTenantValue(input.ai) } : {},
 		...input.sitemapDiscovery ? { sitemapDiscovery: sanitizeTenantValue(input.sitemapDiscovery) } : {},
 		...input.externalLinkVerification ? { externalLinkVerification: sanitizeTenantValue(input.externalLinkVerification) } : {},
+		...input.agentDiscovery ? { agentDiscovery: sanitizeTenantValue(input.agentDiscovery) } : {},
 		warnings: sanitizeMessages(input.warnings).sort(compareText$13),
 		caveats: sanitizeMessages(input.caveats).sort(compareText$13)
 	};
@@ -8557,7 +9703,7 @@ function storageEnvelope(report) {
 	if (report.site) tenant.site = report.site;
 	return {
 		kind: "seo.crawl_report",
-		version: 5,
+		version: 6,
 		savedAt: (/* @__PURE__ */ new Date()).toISOString(),
 		...tenant.projectId || tenant.site ? { tenant } : {},
 		report
@@ -8593,7 +9739,7 @@ function saveCrawlReportToSqlite(report) {
 		totalPages: report.summary.totalPages,
 		issueCount: report.issues.length,
 		createdAt: report.generatedAt,
-		storageVersion: 5
+		storageVersion: 6
 	};
 }
 function listCrawlReportsFromSqlite(input = {}) {
@@ -8676,6 +9822,15 @@ function cancellationRace(signal) {
 //#endregion
 //#region packages/core/dist/analyze/crawler/external-link-checks.js
 const EXTERNAL_LINK_SELECTION_LIMIT = 200;
+const EXTERNAL_LINK_STATES = [
+	"available",
+	"confirmed-broken",
+	"transient",
+	"provider-blocked",
+	"rate-limited",
+	"method-rejected",
+	"unavailable"
+];
 function stableHash(value) {
 	let hash = 2166136261;
 	for (const character of value) hash = Math.imul(hash ^ (character.codePointAt(0) ?? 0), 16777619);
@@ -8745,32 +9900,73 @@ function selectCandidateUrls(candidates, limit) {
 	}
 	return [...selected];
 }
-async function checkExternalLink(url, timeoutMs, fetch, signal) {
+function isAvailableStatus(status) {
+	return status !== void 0 && status >= 200 && status < 400;
+}
+function isBrokenStatus(status) {
+	return status === 404 || status === 410;
+}
+function isMethodRejectedStatus(status) {
+	return status === 405 || status === 501;
+}
+function isProviderBlockedStatus(status) {
+	return status === 401 || status === 403 || status === 451;
+}
+function isTransientStatus(status) {
+	return status === 408 || status === 425 || status !== void 0 && status >= 500;
+}
+function stateForAttempts(attempts) {
+	const last = attempts.at(-1);
+	const statuses = attempts.map((attempt) => attempt.status).filter((status) => status !== void 0);
+	if (isAvailableStatus(last?.status)) return isMethodRejectedStatus(attempts[0]?.status) ? "method-rejected" : attempts.length > 1 ? "transient" : "available";
+	if (attempts.length >= 2 && isBrokenStatus(last?.status) && attempts.at(-2)?.status === last?.status) return "confirmed-broken";
+	if (last?.status === 429) return "rate-limited";
+	if (isProviderBlockedStatus(last?.status)) return "provider-blocked";
+	if (isMethodRejectedStatus(last?.status)) return "method-rejected";
+	if (isTransientStatus(last?.status) || statuses.some(isBrokenStatus) || statuses.length > 0 && attempts.some((attempt) => attempt.error)) return "transient";
+	return "unavailable";
+}
+async function requestExternalLink(url, method, timeoutMs, fetch, signal) {
 	const controller = abortController({
 		timeoutMs,
 		signal
 	});
 	try {
 		const response = await fetch(url, {
-			method: "HEAD",
+			method,
 			redirect: "follow",
 			signal: controller.signal
 		});
 		await response.body?.cancel().catch(() => void 0);
 		return {
-			url,
+			method,
 			status: response.status
 		};
 	} catch (error) {
 		return {
-			url,
-			status: 0,
+			method,
 			error: error instanceof Error ? error.message : String(error)
 		};
 	} finally {
 		controller.cleanup();
 	}
 }
+async function checkExternalLink(url, timeoutMs, fetch, signal) {
+	const attempts = [];
+	attempts.push(await requestExternalLink(url, "HEAD", timeoutMs, fetch, signal));
+	const head = attempts[0];
+	if (!signal?.aborted && !isAvailableStatus(head?.status) && head?.status !== 429 && !isProviderBlockedStatus(head?.status)) attempts.push(await requestExternalLink(url, "GET", timeoutMs, fetch, signal));
+	const last = attempts.at(-1);
+	if (!signal?.aborted && isBrokenStatus(last?.status) && attempts.at(-2)?.status !== last?.status) attempts.push(await requestExternalLink(url, "GET", timeoutMs, fetch, signal));
+	const finalAttempt = attempts.at(-1);
+	return {
+		url,
+		...finalAttempt?.status !== void 0 ? { status: finalAttempt.status } : {},
+		...finalAttempt?.error ? { error: finalAttempt.error } : {},
+		state: stateForAttempts(attempts),
+		attempts
+	};
+}
 async function verifyExternalLinks(input) {
 	const { candidates, discoveredLinkOccurrences, retainedLinkOccurrences } = collectCandidates(input.pages);
 	const urls = input.signal?.aborted ? [] : selectCandidateUrls(candidates, EXTERNAL_LINK_SELECTION_LIMIT);
@@ -8785,16 +9981,22 @@ async function verifyExternalLinks(input) {
 		const pageChecks = (page.sampleExternalLinks ?? []).map((url) => checks.get(url)).filter((value) => Boolean(value));
 		if (pageChecks.length) page.externalLinkChecks = pageChecks;
 	}
-	const fetchedUrls = [...checks.values()].filter((check) => typeof check.status === "number" && check.status > 0).length;
-	const failedUrls = checks.size - fetchedUrls;
+	const fetchedUrls = [...checks.values()].filter((check) => check.attempts?.some((attempt) => attempt.status !== void 0)).length;
+	const failedUrls = [...checks.values()].filter((check) => check.state === "unavailable").length;
+	const unresolvedMethodRejectedUrls = [...checks.values()].filter((check) => check.state === "method-rejected" && !isAvailableStatus(check.status)).length;
 	const deferredUrls = candidates.length - checks.size;
+	const outcomes = Object.fromEntries(EXTERNAL_LINK_STATES.map((state) => [state, [...checks.values()].filter((check) => check.state === state).length]));
 	const warnings = [];
 	if (discoveredLinkOccurrences > retainedLinkOccurrences) warnings.push(`Retained ${retainedLinkOccurrences} sampled external link occurrence${retainedLinkOccurrences === 1 ? "" : "s"} from ${discoveredLinkOccurrences} observed occurrence${discoveredLinkOccurrences === 1 ? "" : "s"}.`);
 	if (candidates.length > urls.length) warnings.push(`Selected ${urls.length} of ${candidates.length} retained external URLs using the ${EXTERNAL_LINK_SELECTION_LIMIT}-URL verification limit.`);
 	if (checks.size < urls.length) warnings.push(`Stopped before checking ${urls.length - checks.size} selected external URL${urls.length - checks.size === 1 ? "" : "s"}.`);
-	if (failedUrls) warnings.push(`${failedUrls} external URL request${failedUrls === 1 ? "" : "s"} failed before a response was received.`);
+	if (failedUrls) warnings.push(`${failedUrls} external URL${failedUrls === 1 ? "" : "s"} could not be reached after bounded verification.`);
+	if (outcomes.transient) warnings.push(`${outcomes.transient} external URL${outcomes.transient === 1 ? "" : "s"} returned inconsistent or temporary responses. Recheck ${outcomes.transient === 1 ? "it" : "them"} before changing the source page.`);
+	if (outcomes["provider-blocked"]) warnings.push(`${outcomes["provider-blocked"]} external URL${outcomes["provider-blocked"] === 1 ? "" : "s"} blocked automated verification. Open ${outcomes["provider-blocked"] === 1 ? "it" : "them"} manually before changing the source page.`);
+	if (outcomes["rate-limited"]) warnings.push(`${outcomes["rate-limited"]} external URL${outcomes["rate-limited"] === 1 ? "" : "s"} rate-limited verification. Recheck ${outcomes["rate-limited"] === 1 ? "it" : "them"} later.`);
+	if (unresolvedMethodRejectedUrls) warnings.push(`${unresolvedMethodRejectedUrls} external URL${unresolvedMethodRejectedUrls === 1 ? "" : "s"} rejected both verification methods. Open ${unresolvedMethodRejectedUrls === 1 ? "it" : "them"} manually before changing the source page.`);
 	return {
-		dataStatus: discoveredLinkOccurrences > retainedLinkOccurrences || deferredUrls > 0 || failedUrls > 0 ? "partial" : "complete",
+		dataStatus: discoveredLinkOccurrences > retainedLinkOccurrences || deferredUrls > 0 || failedUrls > 0 || outcomes.transient > 0 || outcomes["provider-blocked"] > 0 || outcomes["rate-limited"] > 0 || unresolvedMethodRejectedUrls > 0 ? "partial" : "complete",
 		discoveredLinkOccurrences,
 		retainedUrls: candidates.length,
 		selectedUrls: urls.length,
@@ -8802,6 +10004,7 @@ async function verifyExternalLinks(input) {
 		failedUrls,
 		deferredUrls,
 		limit: EXTERNAL_LINK_SELECTION_LIMIT,
+		outcomes,
 		warnings
 	};
 }
@@ -9402,6 +10605,7 @@ async function crawlOne(url, opts = {}) {
 			sampleExternalLinks: uniqueExternalLinks.slice(0, 25),
 			internalAnchorSamples: anchorSamples(extracted.links, true),
 			externalAnchorSamples: anchorSamples(extracted.links, false),
+			markdownAlternates: extracted.markdownAlternates,
 			schemaTypes: extracted.schemaTypes,
 			structuredDataFormats: extracted.structuredDataFormats ?? [],
 			googleRichResults: richResults.assessments,
@@ -9997,6 +11201,7 @@ function resolveCrawlSiteDependencies(dependencies = {}) {
 		queryPagesTopQueriesBatch: injectedMode === "batch" ? dependencies.queryPagesTopQueriesBatch : injectedMode ? void 0 : queryPagesTopQueriesBatch,
 		fetchLandingPageValues: dependencies.fetchLandingPageValues ?? fetchLandingPageValues,
 		landingValueForUrl: dependencies.landingValueForUrl ?? landingValueForUrl,
+		collectAgentDiscovery: dependencies.collectAgentDiscovery ?? collectAgentDiscovery,
 		now: dependencies.now ?? (() => /* @__PURE__ */ new Date())
 	};
 }
@@ -10322,6 +11527,11 @@ async function crawlSite(input, dependencies) {
 	const followLinks = config.mode === "site";
 	let queuedUrls = 0;
 	let skippedUrls = 0;
+	const skipReasonCounts = {};
+	const recordSkip = (reason) => {
+		skippedUrls += 1;
+		skipReasonCounts[reason] = (skipReasonCounts[reason] ?? 0) + 1;
+	};
 	let robotsDeferredUrls = 0;
 	let originBackpressureSkippedUrls = 0;
 	let queueSafetySkippedUrls = 0;
@@ -10388,7 +11598,7 @@ async function crawlSite(input, dependencies) {
 		const enqueue = (value, depth) => {
 			const normalized = normalizeUrl$1(value, config.url);
 			if (!normalized) {
-				skippedUrls += 1;
+				recordSkip("invalid-url");
 				emitStatus("url_skipped", {
 					url: value,
 					depth,
@@ -10405,7 +11615,7 @@ async function crawlSite(input, dependencies) {
 				return;
 			}
 			if (!sameOrigin(normalized, origin)) {
-				skippedUrls += 1;
+				recordSkip("off-origin");
 				emitStatus("url_skipped", {
 					url: normalized,
 					depth,
@@ -10414,7 +11624,7 @@ async function crawlSite(input, dependencies) {
 				return;
 			}
 			if (isLikelyAsset(normalized)) {
-				skippedUrls += 1;
+				recordSkip("asset-url");
 				emitStatus("url_skipped", {
 					url: normalized,
 					depth,
@@ -10423,7 +11633,7 @@ async function crawlSite(input, dependencies) {
 				return;
 			}
 			if (!passesFilters(normalized, config.include, config.exclude)) {
-				skippedUrls += 1;
+				recordSkip("configured-exclusion");
 				emitStatus("url_skipped", {
 					url: normalized,
 					depth,
@@ -10432,7 +11642,7 @@ async function crawlSite(input, dependencies) {
 				return;
 			}
 			if (queue.length + visited.size + inFlight.size >= config.maxPages * 5) {
-				skippedUrls += 1;
+				recordSkip("queue-safety-limit");
 				queueSafetySkippedUrls += 1;
 				emitStatus("url_skipped", {
 					url: normalized,
@@ -10541,7 +11751,7 @@ async function crawlSite(input, dependencies) {
 			});
 			requests.push(request);
 			if (request.outcome === "skipped") {
-				skippedUrls += 1;
+				recordSkip(request.reason === "robots-disallowed" ? "robots-disallowed" : request.reason === "robots-deferred" ? "robots-uncertain" : "origin-backpressure");
 				if (request.reason === "robots-deferred") {
 					robotsDeferredUrls += 1;
 					warnings.push(`${task.url}: crawl deferred because robots.txt availability is unknown.`);
@@ -10646,7 +11856,7 @@ async function crawlSite(input, dependencies) {
 				page.declaredIndexability = "robots-blocked";
 				storeDocument([]);
 				warnings.push(`${page.url}: skipped because robots.txt disallows it`);
-				skippedUrls += 1;
+				recordSkip("robots-disallowed");
 				emitStatus("page_skipped", {
 					url: page.url,
 					depth: task.depth,
@@ -10733,6 +11943,14 @@ async function crawlSite(input, dependencies) {
 				message: "Finished external link checks."
 			});
 		}
+		const agentDiscovery = !cancelled && config.checkAgentDiscovery ? await deps.collectAgentDiscovery({
+			startUrl: config.url,
+			pages,
+			timeoutMs: config.timeoutMs,
+			fetch: deps.fetch,
+			signal,
+			concurrency: Math.min(config.concurrency, 4)
+		}) : void 0;
 		for (const page of pages) {
 			if (!page.geo) continue;
 			page.geo = {
@@ -10759,6 +11977,7 @@ async function crawlSite(input, dependencies) {
 			},
 			...sitemapDiscovery ? { sitemapDiscovery } : {},
 			...externalLinkVerification ? { externalLinkVerification } : {},
+			...agentDiscovery ? { agentDiscovery } : {},
 			status: reportStatus,
 			warnings,
 			caveats: crawlCaveats({
@@ -10773,6 +11992,7 @@ async function crawlSite(input, dependencies) {
 				queuedUrls,
 				crawledUrls: pages.length,
 				skippedUrls,
+				skipReasonCounts,
 				failedUrls,
 				observedInternalLinks,
 				pageLimitReached
@@ -10967,7 +12187,7 @@ function completenessReasons(report) {
 	if (report.status !== "completed") reasons.push(`report-status-${report.status}`);
 	if (report.summary.pageLimitReached) reasons.push("crawl-page-limit-reached");
 	if (report.requestEvidenceStatus !== "available") reasons.push(`request-evidence-${report.requestEvidenceStatus}`);
-	if (report.summary.skippedUrls > 0) reasons.push("urls-skipped");
+	if (report.summary.skippedUrlsByImpact.coverageAffecting > 0) reasons.push("coverage-affecting-urls-skipped");
 	if (report.summary.failedRequests > 0) reasons.push("requests-failed");
 	if (report.summary.abortedRequests > 0) reasons.push("requests-aborted");
 	if (report.summary.extractionFailures > 0) reasons.push("document-extraction-failed");
@@ -10987,6 +12207,8 @@ function snapshotCompleteness(report) {
 		requestEvidenceStatus: report.requestEvidenceStatus,
 		pageLimitReached: report.summary.pageLimitReached,
 		skippedUrls: report.summary.skippedUrls,
+		skipReasons: report.summary.skipReasons,
+		skippedUrlsByImpact: report.summary.skippedUrlsByImpact,
 		failedRequests: report.summary.failedRequests,
 		abortedRequests: report.summary.abortedRequests,
 		extractionFailures: report.summary.extractionFailures,
@@ -11619,6 +12841,169 @@ function explainOkfValidation(validation) {
 	};
 }
 //#endregion
+//#region packages/core/dist/analyze/crawler/agent-discovery-schema.js
+const agentRepresentationResponseSchema = z.object({
+	requestedUrl: z.string().url(),
+	finalUrl: z.string().url().optional(),
+	status: z.number().int().optional(),
+	contentType: z.string().optional(),
+	bytes: z.number().int().nonnegative().optional(),
+	sha256: z.string().optional(),
+	canonicalUrl: z.string().url().optional(),
+	alternateUrl: z.string().url().optional(),
+	varyAccept: z.boolean(),
+	markdownTokens: z.number().int().nonnegative().optional(),
+	contentSignal: z.string().optional(),
+	error: z.string().optional()
+});
+const agentDiscoverySchema = z.object({
+	profile: z.literal("content"),
+	profileApplicability: z.record(z.enum([
+		"content",
+		"api",
+		"application",
+		"commerce"
+	]), z.object({
+		status: z.enum(["evaluated", "notApplicable"]),
+		reason: z.string()
+	})),
+	dataStatus: z.enum([
+		"complete",
+		"partial",
+		"unavailable"
+	]),
+	markdownAlternates: z.object({
+		eligibleHtmlPages: z.number().int().nonnegative(),
+		advertisedPages: z.number().int().nonnegative(),
+		evaluatedPages: z.number().int().nonnegative(),
+		exactByteMatches: z.number().int().nonnegative(),
+		stableResponses: z.number().int().nonnegative(),
+		pages: z.array(z.object({
+			htmlUrl: z.string().url(),
+			advertisedUrls: z.array(z.string().url()),
+			htmlAlternateUnique: z.boolean(),
+			httpAlternateUrls: z.array(z.string().url()),
+			explicit: agentRepresentationResponseSchema.optional(),
+			negotiated: agentRepresentationResponseSchema.optional(),
+			repeated: agentRepresentationResponseSchema.optional(),
+			explicitMatchesNegotiated: z.boolean().nullable(),
+			repeatedHashStable: z.boolean().nullable(),
+			markdownCanonicalMatchesHtml: z.boolean().nullable(),
+			quality: z.object({
+				frontmatterTitle: z.boolean(),
+				h1Count: z.number().int().nonnegative(),
+				codeFenceBalanced: z.boolean(),
+				tableRows: z.number().int().nonnegative(),
+				links: z.number().int().nonnegative(),
+				wordCount: z.number().int().nonnegative(),
+				rawHtmlTags: z.number().int().nonnegative(),
+				rawSvgTags: z.number().int().nonnegative(),
+				rawScriptTags: z.number().int().nonnegative(),
+				rawStyleTags: z.number().int().nonnegative(),
+				suspiciousConcatenations: z.number().int().nonnegative(),
+				repeatedLines: z.number().int().nonnegative(),
+				sourceWordCount: z.number().int().nonnegative(),
+				wordRetentionRatio: z.number().nonnegative().nullable(),
+				introductoryCopyRetained: z.boolean().nullable(),
+				navigationOnly: z.boolean()
+			}).optional()
+		}))
+	}),
+	contentNegotiation: z.object({
+		qZeroHonoured: z.boolean().nullable(),
+		qZeroStatus: z.number().int().optional(),
+		qZeroContentType: z.string().optional(),
+		error: z.string().optional()
+	}),
+	routeManifest: z.object({
+		url: z.string().url(),
+		status: z.number().int().optional(),
+		valid: z.boolean(),
+		declaredHtmlRoutes: z.array(z.string()),
+		declaredMarkdownRoutes: z.array(z.string()),
+		missingHtmlRoutes: z.array(z.string()),
+		missingMarkdownRoutes: z.array(z.string()),
+		orphanMarkdownRoutes: z.array(z.string()),
+		error: z.string().optional()
+	}),
+	agentSkills: z.object({
+		indexUrl: z.string().url(),
+		status: z.number().int().optional(),
+		contentType: z.string().optional(),
+		cors: z.string().optional(),
+		validIndex: z.boolean(),
+		skills: z.array(z.object({
+			name: z.string().optional(),
+			url: z.string().url().optional(),
+			status: z.number().int().optional(),
+			contentType: z.string().optional(),
+			declaredDigest: z.string().optional(),
+			observedDigest: z.string().optional(),
+			digestMatches: z.boolean().nullable(),
+			frontmatterValid: z.boolean().nullable(),
+			sameOrigin: z.boolean(),
+			cors: z.string().optional(),
+			error: z.string().optional()
+		})),
+		error: z.string().optional()
+	}),
+	llmsTxt: z.object({
+		url: z.string().url(),
+		exists: z.boolean(),
+		status: z.number().int().optional(),
+		contentType: z.string().optional(),
+		bytes: z.number().int().nonnegative().optional(),
+		sha256: z.string().optional(),
+		repeatedHashStable: z.boolean().nullable(),
+		headingCount: z.number().int().nonnegative(),
+		totalParsedLinks: z.number().int().nonnegative(),
+		linkLimitReached: z.boolean(),
+		links: z.array(z.object({
+			label: z.string(),
+			url: z.string().url(),
+			sameOrigin: z.boolean(),
+			status: z.number().int().optional(),
+			finalUrl: z.string().url().optional(),
+			redirected: z.boolean(),
+			indexableTarget: z.boolean().optional(),
+			error: z.string().optional()
+		})),
+		invalidLinks: z.array(z.string()),
+		duplicateLinks: z.array(z.string().url()),
+		offSiteLinks: z.array(z.string().url()),
+		redirectedLinks: z.array(z.string().url()),
+		nonIndexableLinks: z.array(z.string().url()),
+		missingCrawlRoutes: z.array(z.string().url()),
+		oversized: z.boolean(),
+		error: z.string().optional()
+	}),
+	contentSignals: z.object({
+		htmlValues: z.array(z.string()),
+		markdownValues: z.array(z.string()),
+		missingHtmlPages: z.number().int().nonnegative(),
+		missingMarkdownPages: z.number().int().nonnegative(),
+		consistent: z.boolean().nullable()
+	}),
+	protocolVariants: z.object({
+		http: z.object({
+			url: z.string().url(),
+			status: z.number().int().optional(),
+			location: z.string().url().optional(),
+			permanentRedirectToHttps: z.boolean().nullable(),
+			error: z.string().optional()
+		}),
+		www: z.object({
+			url: z.string().url(),
+			status: z.number().int().optional(),
+			location: z.string().url().optional(),
+			redirectsToPreferredHost: z.boolean().nullable(),
+			error: z.string().optional()
+		}),
+		hstsOnStartPage: z.boolean().nullable()
+	}),
+	warnings: z.array(z.string())
+});
+//#endregion
 //#region packages/core/dist/analyze/crawler/schemas.js
 const crawlerRuleSeveritySchema = z.enum([
 	"low",
@@ -12043,10 +13428,25 @@ const crawlPageSnapshotSchema = z.object({
 		href: z.string().url(),
 		text: z.string()
 	})).optional(),
+	markdownAlternates: z.array(z.string().url()).optional(),
 	externalLinkChecks: z.array(z.object({
 		url: z.string().url(),
 		status: z.number().int().optional(),
-		error: z.string().optional()
+		error: z.string().optional(),
+		state: z.enum([
+			"available",
+			"confirmed-broken",
+			"transient",
+			"provider-blocked",
+			"rate-limited",
+			"method-rejected",
+			"unavailable"
+		]).optional(),
+		attempts: z.array(z.object({
+			method: z.enum(["HEAD", "GET"]),
+			status: z.number().int().optional(),
+			error: z.string().optional()
+		})).optional()
 	})).optional(),
 	schemaTypes: z.array(z.string()).optional(),
 	structuredDataFormats: z.array(z.enum([
@@ -12327,6 +13727,15 @@ const crawlExternalLinkVerificationSchema = z.object({
 	failedUrls: z.number().int().nonnegative(),
 	deferredUrls: z.number().int().nonnegative(),
 	limit: z.number().int().positive(),
+	outcomes: z.record(z.enum([
+		"available",
+		"confirmed-broken",
+		"transient",
+		"provider-blocked",
+		"rate-limited",
+		"method-rejected",
+		"unavailable"
+	]), z.number().int().nonnegative()).optional(),
 	warnings: z.array(z.string())
 });
 const crawlConfigSchema = z.object({
@@ -12347,6 +13756,7 @@ const crawlConfigSchema = z.object({
 	respectRobots: z.boolean(),
 	useSitemap: z.boolean(),
 	checkExternal: z.boolean(),
+	checkAgentDiscovery: z.boolean(),
 	js: z.union([z.enum([
 		"auto",
 		"on",
@@ -12377,6 +13787,15 @@ const crawlReportSummarySchema = z.object({
 	queuedUrls: z.number().int(),
 	crawledUrls: z.number().int(),
 	skippedUrls: z.number().int(),
+	skipReasons: z.array(z.object({
+		reason: z.enum(CRAWL_SKIP_REASONS),
+		impact: z.enum(["coverage-affecting", "non-impacting"]),
+		count: z.number().int().positive()
+	})),
+	skippedUrlsByImpact: z.object({
+		coverageAffecting: z.number().int().nonnegative(),
+		nonImpacting: z.number().int().nonnegative()
+	}),
 	failedUrls: z.number().int(),
 	observedInternalLinks: z.number().int(),
 	pageLimitReached: z.boolean().default(false),
@@ -12459,6 +13878,7 @@ const crawlReportBaseSchema = z.object({
 	ai: crawlAiSignalsSchema.optional(),
 	sitemapDiscovery: crawlSitemapDiscoverySchema.optional(),
 	externalLinkVerification: crawlExternalLinkVerificationSchema.optional(),
+	agentDiscovery: agentDiscoverySchema.optional(),
 	warnings: z.array(z.string()),
 	caveats: z.array(z.string())
 });
@@ -18184,7 +19604,7 @@ function crawlInput(input) {
 	return {
 		pages,
 		evidence: sourceEvidence({
-			completeness: report ? report.summary.pageLimitReached ? "truncated" : report.status === "completed" ? "complete" : report.status === "partial" ? "partial" : "unknown" : "completeness" in input ? input.completeness : "unknown",
+			completeness: report ? report.summary.pageLimitReached ? "truncated" : report.status === "partial" || report.summary.skippedUrlsByImpact.coverageAffecting > 0 ? "partial" : report.status === "completed" ? "complete" : "unknown" : "completeness" in input ? input.completeness : "unknown",
 			rowsReceived: pages.length,
 			validUrls: urls.length,
 			uniqueUrls: uniqueUrls.size,
@@ -23236,14 +24656,14 @@ function workflowReport(input) {
 async function diagnosePropertyWorkflow(input) {
 	const narrative = await reportNarrative(input);
 	const skippedCount = narrative.diagnosis.skippedSections?.length ?? 0;
-	const stepSummary = narrative.dataStatus === "complete" ? "Generated diagnosis, movement, change, and monitoring narrative." : skippedCount ? `Generated ${narrative.dataStatus === "unavailable" ? "an" : "a"} ${narrative.dataStatus} diagnosis; ${skippedCount} sections were unavailable.` : "Generated a partial diagnosis because one or more source datasets were incomplete.";
+	const stepSummary = input.skipSearchData ? "Skipped provider-backed search diagnosis because no Search Console property was selected." : narrative.dataStatus === "complete" ? "Generated diagnosis, movement, change, and monitoring narrative." : skippedCount ? `Generated ${narrative.dataStatus === "unavailable" ? "an" : "a"} ${narrative.dataStatus} diagnosis; ${skippedCount} sections were unavailable.` : "Generated a partial diagnosis because one or more source datasets were incomplete.";
 	return workflowReport({
 		workflow: "diagnose-property",
 		site: input.site,
 		summary: narrative.headline,
 		steps: [{
 			tool: "seo_report_narrative",
-			status: "completed",
+			status: input.skipSearchData ? "skipped" : "completed",
 			summary: stepSummary
 		}],
 		actions: narrative.priorities.map((priority) => ({
@@ -24780,6 +26200,9 @@ function resolveSavedReportAlias(input) {
 	}
 	return loadCrawlReport(input.value);
 }
+function assertExclusiveReportInput(url, reportId) {
+	if (url && reportId) throw new SeoError("INVALID_INPUT", "Use either url or reportId, not both.");
+}
 function registerCrawlerTools(server) {
 	server.registerTool("seo_crawl_site", {
 		description: "Crawl a site and run technical SEO checks. The compact result separates prioritised fixes from review observations. Set includePages/includeIssues for raw data.",
@@ -24896,6 +26319,7 @@ function registerCrawlerTools(server) {
 		}
 	}, async ({ url, reportId, site, maxPages, maxDepth, fetchIntervalCap, fetchIntervalMs, refresh, category, limit }) => {
 		try {
+			assertExclusiveReportInput(url, reportId);
 			const report = url ? await crawlSite({
 				url,
 				site,
@@ -25022,6 +26446,40 @@ function registerCrawlerTools(server) {
 			return toolError(error);
 		}
 	});
+	server.registerTool("seo_agent_readiness", {
+		description: "Check a content site for stable Markdown alternatives, agent discovery, crawler access, and identity evidence without an aggregate score.",
+		inputSchema: {
+			url: z$1.string().url().optional(),
+			reportId: z$1.string().optional(),
+			site: z$1.string().optional(),
+			maxPages: z$1.number().int().positive().optional(),
+			fetchIntervalCap: z$1.number().int().positive().optional(),
+			fetchIntervalMs: z$1.number().int().positive().optional(),
+			refresh: z$1.boolean().optional()
+		}
+	}, async ({ url, reportId, site, maxPages, fetchIntervalCap, fetchIntervalMs, refresh }) => {
+		try {
+			assertExclusiveReportInput(url, reportId);
+			const report = url ? await crawlSite({
+				url,
+				site,
+				maxPages,
+				refresh,
+				checkAgentDiscovery: true,
+				useSitemap: true,
+				checkExternal: false,
+				fetchRate: fetchRateInput({
+					fetchIntervalCap,
+					fetchIntervalMs
+				})
+			}) : reportId ? loadCrawlReport(reportId) : latestCrawlReport(site);
+			if (!report) return toolError("No crawl report found. Pass url, reportId, or run seo_crawl_site with saveReport first.");
+			const readiness = agentReadiness(report);
+			return toolSuccess(readiness.headline, readiness);
+		} catch (error) {
+			return toolError(error);
+		}
+	});
 	server.registerTool("seo_ai_readiness", {
 		description: "Return AI-search technical evidence and optional observations without an aggregate score or citation prediction.",
 		inputSchema: {
@@ -26206,6 +27664,39 @@ const REPORT_DEPTH = {
 			}
 		]
 	},
+	"agent-readiness": {
+		readOrder: [
+			"profile, profileApplicability, dataStatus, and crawl caveats",
+			"summary and topActions",
+			"HTML and Markdown representation checks with affected URLs",
+			"Agent Skills, llms.txt, route manifest, crawler access, and identity evidence"
+		],
+		doNotClaim: [
+			"A clean content profile is not proof of indexing, rankings, AI mentions, citations, or selection.",
+			"API, application, and commerce checks marked notApplicable were outside this content-site run. They did not fail.",
+			"An allowed crawler token does not prove that a service fetched or used the page.",
+			"Optional discovery files are not Google ranking requirements."
+		],
+		verify: "Run the same content profile against the same public route scope after deployment and confirm each failed or warning check changed.",
+		related: [
+			{
+				id: "ai-readiness",
+				reason: "Checks AI search technical eligibility."
+			},
+			{
+				id: "llms-txt-audit",
+				reason: "Inspects llms.txt in more detail."
+			},
+			{
+				id: "entity-readiness",
+				reason: "Reviews identity evidence."
+			},
+			{
+				id: "site-crawl",
+				reason: "Creates a reusable crawl baseline."
+			}
+		]
+	},
 	"ai-readiness": {
 		readOrder: [
 			"dataStatus and crawl caveats",
@@ -27575,6 +29066,13 @@ const REPORT_GUIDANCE = {
 		avoidWhen: ["You have not run or selected a crawl yet.", "You need an overview of the most important crawl findings first."],
 		outcome: "A focused list of affected URLs with the evidence for each match."
 	},
+	"agent-readiness": {
+		name: "AI agent readiness",
+		description: "Check whether a content site gives agents clean, stable, machine-readable pages and discovery files.",
+		useWhen: ["You want to test Markdown alternatives, content negotiation, Agent Skills, llms.txt, identity, and crawler access together.", "You need evidence that the agent-facing version of a content site matches its public HTML routes."],
+		avoidWhen: ["You need an AI visibility, mention, citation, or ranking report.", "You are auditing a public API, interactive application, or commerce flow rather than a content site."],
+		outcome: "An unscored content-site assessment with failed routes, evidence, and clear next actions."
+	},
 	"ai-readiness": {
 		name: "AI search technical readiness",
 		description: "Check whether crawl, index, or snippet controls could block pages from Google AI search features.",
@@ -28348,6 +29846,7 @@ const reportGroups = [
 		register: registerCrawlerTools,
 		names: [
 			"seo_affected_urls",
+			"seo_agent_readiness",
 			"seo_ai_readiness",
 			"seo_audit_urls",
 			"seo_compare_crawl_reports",