seo 0.10.0 → 0.12.0

package/dist/mcp.js

@@ -1,5 +1,5 @@
 import { createRequire as __seoCreateRequire } from 'node:module'; const require = __seoCreateRequire(import.meta.url);
-import { i as __toESM, n as version, r as __commonJSMin, t as load } from "./esm-CM7xTOjT.js";
+import { i as __toESM, n as version, r as __commonJSMin, t as load } from "./esm-CQJgJ8TD.js";
 import { createHash, randomUUID, sign } from "node:crypto";
 import { ZodOptional, z } from "zod";
 import { arch, homedir, platform, tmpdir, totalmem } from "node:os";
@@ -26,6 +26,7 @@ import { TextDecoder as TextDecoder$1, promisify } from "node:util";
 import { execFile } from "node:child_process";
 import "pino";
 import "pino-pretty";
+import { request } from "node:https";
 import * as z3rt from "zod/v3";
 import { ZodFirstPartyTypeKind } from "zod/v3";
 import * as z4mini from "zod/v4-mini";
@@ -13789,7 +13790,7 @@ async function googleJson(gfetch, url, input) {
 	return readJson(response, input.label, { maxBytes: input.maxBytes });
 }
 const GSC = "https://www.googleapis.com/webmasters/v3";
-const PAGE_ROWS = 25e3;
+const PAGE_ROWS$1 = 25e3;
 async function searchAnalyticsRows(gfetch, site, body, options) {
 	const rows = [];
 	const { maxRows: requested, ...apiBody } = body;
@@ -13800,7 +13801,7 @@ async function searchAnalyticsRows(gfetch, site, body, options) {
 	while (true) {
 		const remaining = typeof maxRows === "number" ? maxRows - rows.length : void 0;
 		if (typeof remaining === "number" && remaining <= 0) break;
-		const rowLimit = Math.min(apiBody.rowLimit ?? PAGE_ROWS, remaining ?? PAGE_ROWS, PAGE_ROWS);
+		const rowLimit = Math.min(apiBody.rowLimit ?? PAGE_ROWS$1, remaining ?? PAGE_ROWS$1, PAGE_ROWS$1);
 		const json = await googleJson(gfetch, url, {
 			...options,
 			label: "Search Console",
@@ -13877,7 +13878,7 @@ async function runAnalyticsReport(gfetch, propertyId, body, options) {
 //#endregion
 //#region packages/core/dist/bing/api.js
 const BASE = "https://ssl.bing.com/webmaster/api.svc/json";
-const MAX_BYTES$2 = 8e6;
+const MAX_BYTES$4 = 8e6;
 function bingCall(auth, options) {
 	return async (method, params = {}) => {
 		const url = new URL(`${BASE}/${method}`);
@@ -13902,7 +13903,7 @@ function bingCall(auth, options) {
 			if (response.status === 429 || /throttle/i.test(detail)) throw new SeoError("RATE_LIMITED", "Bing Webmaster is limiting requests. Try again in a few minutes.");
 			throw new SeoError("OPTIONAL_PROVIDER_UNAVAILABLE", `Bing Webmaster answered ${response.status}. ${detail}`.trim());
 		}
-		return (await readJson(response, "Bing Webmaster", { maxBytes: MAX_BYTES$2 })).d;
+		return (await readJson(response, "Bing Webmaster", { maxBytes: MAX_BYTES$4 })).d;
 	};
 }
 function day(value) {
@@ -16411,6 +16412,7 @@ const MEBIBYTE$2 = 1024 * 1024;
 const CACHE_MAX_AGE_MS = 720 * 60 * 60 * 1e3;
 const CACHE_LIMITS = {
 	gsc_cache: 48 * MEBIBYTE$2,
+	url_inspection_cache: 16 * MEBIBYTE$2,
 	ga4_cache: 24 * MEBIBYTE$2,
 	provider_cache: 32 * MEBIBYTE$2,
 	http_cache: 128 * MEBIBYTE$2,
@@ -16428,6 +16430,16 @@ const CACHE_POLICIES = [
 			"response_json"
 		]
 	},
+	{
+		table: "url_inspection_cache",
+		keys: ["site_url", "url"],
+		timestamp: "fetched_at",
+		sizeColumns: [
+			"site_url",
+			"url",
+			"status_json"
+		]
+	},
 	{
 		table: "ga4_cache",
 		keys: ["property_id", "query_hash"],
@@ -16731,6 +16743,17 @@ CREATE INDEX IF NOT EXISTS idx_url_inspection_reservations_minute
     credential_key, property_site_url, created_at
   );
 
+CREATE TABLE IF NOT EXISTS url_inspection_cache (
+  site_url TEXT NOT NULL,
+  url TEXT NOT NULL,
+  status_json TEXT NOT NULL,
+  fetched_at INTEGER NOT NULL,
+  expires_at INTEGER NOT NULL,
+  PRIMARY KEY(site_url, url)
+) WITHOUT ROWID;
+CREATE INDEX IF NOT EXISTS idx_url_inspection_cache_expires
+  ON url_inspection_cache(expires_at);
+
 CREATE TABLE IF NOT EXISTS performance_reports (
   id TEXT PRIMARY KEY,
   url TEXT NOT NULL,
@@ -16763,10 +16786,12 @@ function initDb(database, isNewDatabase) {
 		database.exec("DROP TABLE IF EXISTS provider_spend_notices");
 		ensureColumn(database, "http_cache", "metadata_json", "TEXT");
 	}).immediate();
-	runCacheMaintenance(database, {
-		compact: true,
-		allowFullVacuum: true
-	});
+	try {
+		runCacheMaintenance(database, {
+			compact: true,
+			allowFullVacuum: true
+		});
+	} catch {}
 }
 function getDb() {
 	if (db) return db;
@@ -16777,12 +16802,41 @@ function getDb() {
 		mode: 448
 	});
 	ensurePrivateDatabaseFiles(path);
-	db = new SqliteDatabase(path);
-	ensurePrivateDatabaseFiles(path);
-	initDb(db, isNewDatabase);
-	ensurePrivateDatabaseFiles(path);
+	const opened = new SqliteDatabase(path);
+	try {
+		ensurePrivateDatabaseFiles(path);
+		initDb(opened, isNewDatabase);
+		ensurePrivateDatabaseFiles(path);
+	} catch (error) {
+		opened.close();
+		throw error;
+	}
+	db = opened;
 	return db;
 }
+let memoryDb;
+function memoryCache() {
+	if (!memoryDb) {
+		memoryDb = new SqliteDatabase(":memory:");
+		memoryDb.exec(CREATE_SQL);
+	}
+	return memoryDb;
+}
+function cacheDb() {
+	if (memoryDb) return memoryDb;
+	try {
+		return getDb();
+	} catch {
+		return memoryCache();
+	}
+}
+function writeToCache(write) {
+	try {
+		write(cacheDb());
+	} catch {
+		memoryCache();
+	}
+}
 function noteCacheWrite(sizeBytes = 0, database = getDb()) {
 	const counter = cacheMaintenanceCounters.get(database) ?? {
 		writes: 0,
@@ -16810,7 +16864,7 @@ function ga4RequestCanUseCache(body) {
 }
 async function runGa4Report(propertyId, body, opts = {}) {
 	const { client, identity } = await createGoogleAccessTokenClient(opts.accountEmail);
-	const db = getDb();
+	const db = cacheDb();
 	const queryHash = hashKey([
 		propertyId,
 		identity,
@@ -16823,10 +16877,12 @@ async function runGa4Report(propertyId, body, opts = {}) {
 	if (cacheable) {
 		const requestJson = JSON.stringify(body);
 		const responseJson = JSON.stringify(result);
-		db.prepare(`INSERT OR REPLACE INTO ga4_cache
-    (property_id, query_hash, request_json, response_json, row_count, fetched_at, expires_at)
-    VALUES (?, ?, ?, ?, ?, ?, ?)`).run(propertyId, queryHash, requestJson, responseJson, result.rowCount ?? result.rows?.length ?? 0, Date.now(), Date.now() + 864e5);
-		noteCacheWrite(Buffer.byteLength(requestJson) + Buffer.byteLength(responseJson));
+		writeToCache((database) => {
+			database.prepare(`INSERT OR REPLACE INTO ga4_cache
+          (property_id, query_hash, request_json, response_json, row_count, fetched_at, expires_at)
+          VALUES (?, ?, ?, ?, ?, ?, ?)`).run(propertyId, queryHash, requestJson, responseJson, result.rowCount ?? result.rows?.length ?? 0, Date.now(), Date.now() + 864e5);
+			noteCacheWrite(Buffer.byteLength(requestJson) + Buffer.byteLength(responseJson), database);
+		});
 	}
 	return result;
 }
@@ -19198,7 +19254,7 @@ async function fetchRobotsSource(origin, refresh, options) {
 	const robotsUrl = new URL("/robots.txt", origin).toString();
 	const key = hashKey(["robots", robotsUrl]);
 	if (!refresh) {
-		const cached = getDb().prepare("SELECT status, body_blob, expires_at FROM http_cache WHERE url_hash = ?").get(key);
+		const cached = cacheDb().prepare("SELECT status, body_blob, expires_at FROM http_cache WHERE url_hash = ?").get(key);
 		if (cached?.body_blob && cached.status !== void 0 && cacheableStatus(cached.status) && cached.expires_at && cached.expires_at > Date.now()) return {
 			robotsUrl,
 			status: cached.status,
@@ -19217,12 +19273,12 @@ async function fetchRobotsSource(origin, refresh, options) {
 			signal: controller.signal
 		});
 		const text = await readBoundedResponseText(response, MAX_ROBOTS_RESPONSE_BYTES, "robots.txt response");
-		if (options.writeCache !== false && cacheableStatus(response.status)) {
-			getDb().prepare(`INSERT OR REPLACE INTO http_cache
-          (url_hash, url, status, headers_json, body_blob, etag, fetched_at, expires_at)
-          VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(key, robotsUrl, response.status, "{}", Buffer.from(text), null, Date.now(), Date.now() + 864e5);
-			noteCacheWrite(Buffer.byteLength(text));
-		}
+		if (options.writeCache !== false && cacheableStatus(response.status)) writeToCache((database) => {
+			database.prepare(`INSERT OR REPLACE INTO http_cache
+            (url_hash, url, status, headers_json, body_blob, etag, fetched_at, expires_at)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(key, robotsUrl, response.status, "{}", Buffer.from(text), null, Date.now(), Date.now() + 864e5);
+			noteCacheWrite(Buffer.byteLength(text), database);
+		});
 		return {
 			robotsUrl,
 			status: response.status,
@@ -19329,7 +19385,6 @@ function decodePageFetchCacheEvidence(value) {
 }
 async function fetchPlain(url, refresh = false, timeoutMs = 2e4, rate, signal, respectRobots = false, writeCache = true) {
 	const startedAt = Date.now();
-	const db = getDb();
 	const key = hashKey(["page", url]);
 	const host = new URL(url).host;
 	let robots = respectRobots ? await fetchRobots(new URL(url).origin, url, refresh, {
@@ -19337,7 +19392,7 @@ async function fetchPlain(url, refresh = false, timeoutMs = 2e4, rate, signal, r
 		signal
 	}) : void 0;
 	if (robots && robots.allowed !== true) throw new RobotsAccessError(robots.allowed === false ? "robots-disallowed" : "robots-deferred", robots);
-	const cached = db.prepare("SELECT status, headers_json, body_blob, metadata_json, expires_at FROM http_cache WHERE url_hash = ? AND expires_at > ?").get(key, Date.now());
+	const cached = cacheDb().prepare("SELECT status, headers_json, body_blob, metadata_json, expires_at FROM http_cache WHERE url_hash = ? AND expires_at > ?").get(key, Date.now());
 	if (!refresh && cached) {
 		const evidence = decodePageFetchCacheEvidence(cached.metadata_json);
 		return {
@@ -19439,12 +19494,12 @@ async function fetchPlain(url, refresh = false, timeoutMs = 2e4, rate, signal, r
 		warnings: [...robots.allowed === null ? [`robots.txt availability is unknown${robots.status ? ` after HTTP ${robots.status}` : ""}; this fetch does not prove crawler access is allowed.`] : [], ...accessBlock ? [`${accessBlock.guidance.summary} Identify the crawler as ${accessBlock.crawler.userAgent}.`] : []],
 		robotsTxt: pageRobotsEvidence(robots)
 	};
-	if (!accessBlock && writeCache) {
-		db.prepare(`INSERT OR REPLACE INTO http_cache
-      (url_hash, url, status, headers_json, body_blob, metadata_json, etag, fetched_at, expires_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(key, url, response.response.status, JSON.stringify(headerMap), Buffer.from(html), encodePageFetchCacheEvidence(result), response.response.headers.get("etag"), Date.now(), Date.now() + 36e5);
-		noteCacheWrite(Buffer.byteLength(html));
-	}
+	if (!accessBlock && writeCache) writeToCache((database) => {
+		database.prepare(`INSERT OR REPLACE INTO http_cache
+          (url_hash, url, status, headers_json, body_blob, metadata_json, etag, fetched_at, expires_at)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(key, url, response.response.status, JSON.stringify(headerMap), Buffer.from(html), encodePageFetchCacheEvidence(result), response.response.headers.get("etag"), Date.now(), Date.now() + 36e5);
+		noteCacheWrite(Buffer.byteLength(html), database);
+	});
 	return result;
 }
 //#endregion
@@ -20197,6 +20252,19 @@ function reserveUrlInspectionQuota(input) {
 	if ("error" in result) throw result.error;
 	return result.reservation;
 }
+function readUrlInspectionQuota(input) {
+	const database = input.database ?? getDb();
+	const now = input.now ?? /* @__PURE__ */ new Date();
+	const bucket = database.prepare(`SELECT limit_count, used_count, reserved_count, blocked_until
+      FROM url_inspection_quota_buckets
+      WHERE credential_key = ? AND property_site_url = ? AND quota_date = ?`).get(input.credentialKey, input.property, urlInspectionQuotaDate(now));
+	const limit = bucket?.limit_count ?? 2e3;
+	return {
+		used: (bucket?.blocked_until ?? 0) > now.getTime() ? limit : Math.min(limit, (bucket?.used_count ?? 0) + (bucket?.reserved_count ?? 0)),
+		limit,
+		resetAt: urlInspectionQuotaResetAt(now).toISOString()
+	};
+}
 function finalizeUrlInspectionQuota(input) {
 	const database = input.database ?? getDb();
 	const now = input.now ?? /* @__PURE__ */ new Date();
@@ -20241,6 +20309,13 @@ function inspectionResponseError(response, input) {
 	if (response.status >= 500) return new SeoError("PROVIDER_UNAVAILABLE", `Google URL Inspection is unavailable (${response.status}). Try again later.`);
 	return new SeoError("PROVIDER_UNAVAILABLE", `URL Inspection failed with ${response.status}.`);
 }
+async function urlInspectionQuota(input) {
+	const { quotaIdentity } = await getAuthorized(input.accountEmail ?? await cloudAccountFor(input.siteUrl));
+	return readUrlInspectionQuota({
+		credentialKey: credentialKey(quotaIdentity),
+		property: input.siteUrl
+	});
+}
 async function inspectUrl(input) {
 	const inspectionUrl = assertUrlMatchesGscProperty(input.siteUrl, input.inspectionUrl);
 	const { client, quotaIdentity } = await getAuthorized(input.accountEmail ?? await cloudAccountFor(input.siteUrl));
@@ -20302,7 +20377,7 @@ function resolveSearchDateWindow(input = 28) {
 }
 async function querySearchAnalytics(site, body, opts = {}) {
 	const { client, identity } = await getAuthorized(opts.accountEmail ?? await cloudAccountFor(site));
-	const db = getDb();
+	const db = cacheDb();
 	const queryHash = hashKey([
 		site,
 		identity,
@@ -20322,10 +20397,12 @@ async function querySearchAnalytics(site, body, opts = {}) {
 	const calls = result.calls;
 	const requestJson = JSON.stringify(body);
 	const responseJson = JSON.stringify(allRows);
-	db.prepare(`INSERT OR REPLACE INTO gsc_cache
-    (site_url, query_hash, request_json, response_json, row_count, fetched_at, expires_at)
-    VALUES (?, ?, ?, ?, ?, ?, ?)`).run(site, queryHash, requestJson, responseJson, allRows.length, Date.now(), Date.now() + 864e5);
-	noteCacheWrite(Buffer.byteLength(requestJson) + Buffer.byteLength(responseJson));
+	writeToCache((database) => {
+		database.prepare(`INSERT OR REPLACE INTO gsc_cache
+        (site_url, query_hash, request_json, response_json, row_count, fetched_at, expires_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?)`).run(site, queryHash, requestJson, responseJson, allRows.length, Date.now(), Date.now() + 864e5);
+		noteCacheWrite(Buffer.byteLength(requestJson) + Buffer.byteLength(responseJson), database);
+	});
 	return {
 		rows: allRows,
 		calls,
@@ -20461,8 +20538,10 @@ async function queryPagesTopQueriesBatch(site, pageUrls, range = 28) {
 //#region packages/core/dist/gsc/client/sites.js
 async function listSites(_refresh = false, accountEmail) {
 	const entries = !accountEmail && cloudLinked() ? await allCloudSites() : await listSearchConsoleSites(googleFetchFor((await getAuthorized(accountEmail)).client), LOCAL_SIGN_IN);
-	const insert = getDb().prepare("INSERT OR REPLACE INTO sites (site_url, display_name, permission, added_at, is_default) VALUES (?, ?, ?, ?, COALESCE((SELECT is_default FROM sites WHERE site_url = ?), 0))");
-	for (const site of entries) insert.run(site.siteUrl, site.siteUrl, site.permissionLevel ?? null, Date.now(), site.siteUrl);
+	writeToCache((database) => {
+		const insert = database.prepare("INSERT OR REPLACE INTO sites (site_url, display_name, permission, added_at, is_default) VALUES (?, ?, ?, ?, COALESCE((SELECT is_default FROM sites WHERE site_url = ?), 0))");
+		for (const site of entries) insert.run(site.siteUrl, site.siteUrl, site.permissionLevel ?? null, Date.now(), site.siteUrl);
+	});
 	return entries;
 }
 async function allCloudSites() {
@@ -22083,7 +22162,7 @@ const actionPriority = new Map([
 	"unverified",
 	"covered"
 ].map((type, index) => [type, index]));
-function plural$6(count, singular, pluralLabel) {
+function plural$7(count, singular, pluralLabel) {
 	return count === 1 ? singular : pluralLabel;
 }
 function actionable(item) {
@@ -22117,7 +22196,7 @@ function pageOpportunityVerdict(input) {
 	if (focus === "unverified") return "GSC visibility exists, but the page was not verified and no specific change is justified yet.";
 	if (focus === "covered") return "The verified page covers the sampled queries and CTR is not materially below its directional benchmark.";
 	const count = analysis.summary.opportunities;
-	const prefix = `${count} ${plural$6(count, "actionable observation", "actionable observations")} found.`;
+	const prefix = `${count} ${plural$7(count, "actionable observation", "actionable observations")} found.`;
 	if (focus === "content-gap") return `${prefix} Verified body coverage is the main issue; confirm intent before expanding the page.`;
 	if (focus === "serp-framing") return `${prefix} The body is relevant, but its title, meta description, or H1 framing is weak.`;
 	if (focus === "ranking") return `${prefix} Most upside requires stronger relevance or authority; no CTR-only lift is claimed for page-two queries.`;
@@ -22132,7 +22211,7 @@ function pageOpportunityRecommendations(analysis) {
 	}
 	const recommendations = [`Start with "${top.query}". ${top.recommendation}`];
 	const technical = actions.filter((item) => item.opportunityType === "technical-check").length;
-	if (technical) recommendations.push(`Resolve the technical evidence affecting ${technical} ${plural$6(technical, "row", "rows")} before content work.`);
+	if (technical) recommendations.push(`Resolve the technical evidence affecting ${technical} ${plural$7(technical, "row", "rows")} before content work.`);
 	const gaps = actions.filter((item) => item.opportunityType === "content-gap").length;
 	if (gaps >= 3) recommendations.push(`Group the ${gaps} verified content gaps into useful sections rather than adding one thin paragraph per query.`);
 	return recommendations;
@@ -25207,7 +25286,7 @@ function availabilityOf(status) {
 function errorText(error) {
 	return error instanceof Error ? error.message : String(error);
 }
-async function get(input, url, headers, readBody = true) {
+async function get$1(input, url, headers, readBody = true) {
 	const controller = abortController({
 		timeoutMs: input.timeoutMs,
 		signal: input.signal
@@ -25264,7 +25343,7 @@ function llmsLinks(text, base) {
 	return links;
 }
 async function checkLlmsTxt(input) {
-	const result = await get(input, new URL("/llms.txt", input.url).toString());
+	const result = await get$1(input, new URL("/llms.txt", input.url).toString());
 	const availability = result.availability === "available" && isHtml(result.contentType) ? "absent" : result.availability;
 	const exists = availability === "available";
 	const base = {
@@ -25281,7 +25360,7 @@ async function checkLlmsTxt(input) {
 	for (const url of found.slice(0, LLMS_LINK_LIMIT)) {
 		if (input.signal?.aborted) break;
 		checked += 1;
-		const link = brokenLink(await get(input, url, void 0, false), false);
+		const link = brokenLink(await get$1(input, url, void 0, false), false);
 		if (link) broken.push(link);
 	}
 	return {
@@ -25325,7 +25404,7 @@ function sitemapUrlsFromRobots(text) {
 	return [...urls];
 }
 async function checkRobotsAiAccess(input) {
-	const result = await get(input, new URL("/robots.txt", input.url).toString());
+	const result = await get$1(input, new URL("/robots.txt", input.url).toString());
 	const exists = result.availability === "available";
 	const unknown = result.availability === "rate-limited" || result.availability === "unreachable";
 	const declared = exists ? declaredUserAgents(result.text) : /* @__PURE__ */ new Set();
@@ -25354,7 +25433,7 @@ async function checkAgentResources(input) {
 	const resources = [];
 	for (const path of AGENT_RESOURCE_PATHS) {
 		if (input.signal?.aborted) break;
-		const result = await get(input, new URL(path, input.url).toString());
+		const result = await get$1(input, new URL(path, input.url).toString());
 		const exists = result.availability === "available" && !isHtml(result.contentType);
 		let validJson;
 		if (exists && /\bjson\b/i.test(result.contentType)) try {
@@ -25374,7 +25453,7 @@ async function checkAgentResources(input) {
 	return resources;
 }
 async function checkMarkdownNegotiation(input) {
-	const result = await get(input, input.url, { accept: "text/markdown" }, false);
+	const result = await get$1(input, input.url, { accept: "text/markdown" }, false);
 	const vary = result.headers?.get("vary") ?? "";
 	return {
 		url: result.url,
@@ -25421,7 +25500,7 @@ async function checkMarkdownCopies(input) {
 		const url = page.markdownAlternates?.[0];
 		if (!url || !input.allows(url)) continue;
 		checked += 1;
-		const result = await get({
+		const result = await get$1({
 			...input,
 			url
 		}, url);
@@ -26587,7 +26666,7 @@ function taskIds(value) {
 	}
 }
 function readProviderCache(key, schema, options = {}) {
-	const database = options.database ?? getDb();
+	const database = options.database ?? cacheDb();
 	const now = options.now ?? Date.now();
 	const hash = requestHash(key, stableProviderRequestJson(key.request));
 	const row = database.prepare(`SELECT response_json, row_count, source_cost_micros, task_ids_json,
@@ -26608,9 +26687,11 @@ function readProviderCache(key, schema, options = {}) {
 			taskIds: taskIds(row.task_ids_json)
 		};
 	} catch {
-		database.prepare(`DELETE FROM provider_cache
-         WHERE provider = ? AND credential_scope = ? AND operation = ?
-           AND request_hash = ?`).run(key.provider, key.credentialScope, key.operation, hash);
+		try {
+			database.prepare(`DELETE FROM provider_cache
+           WHERE provider = ? AND credential_scope = ? AND operation = ?
+             AND request_hash = ?`).run(key.provider, key.credentialScope, key.operation, hash);
+		} catch {}
 		return null;
 	}
 }
@@ -26621,19 +26702,22 @@ function writeProviderCache(key, input, options = {}) {
 		code: "configuration",
 		message: `Provider cache TTL must be between 1 and ${CACHE_MAX_AGE_MS} milliseconds.`
 	});
-	const database = options.database ?? getDb();
 	const now = options.now ?? Date.now();
 	const expiresAt = now + input.ttlMs;
 	const requestJson = stableProviderRequestJson(key.request);
 	const responseJson = JSON.stringify(input.data);
 	const normalizedTaskIds = [...new Set(input.taskIds)].filter((id) => id.length > 0 && id.length <= 100).sort((left, right) => left < right ? -1 : left > right ? 1 : 0).slice(0, 20);
 	const taskIdsJson = JSON.stringify(normalizedTaskIds);
-	database.prepare(`INSERT OR REPLACE INTO provider_cache (
-        provider, credential_scope, operation, request_hash, request_json,
-        response_json, row_count, source_cost_micros, task_ids_json,
-        fetched_at, expires_at
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(key.provider, key.credentialScope, key.operation, requestHash(key, requestJson), requestJson, responseJson, input.rowCount, input.sourceCostMicros, taskIdsJson, now, expiresAt);
-	noteCacheWrite(Buffer.byteLength(requestJson) + Buffer.byteLength(responseJson) + Buffer.byteLength(taskIdsJson), database);
+	const save = (database) => {
+		database.prepare(`INSERT OR REPLACE INTO provider_cache (
+          provider, credential_scope, operation, request_hash, request_json,
+          response_json, row_count, source_cost_micros, task_ids_json,
+          fetched_at, expires_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(key.provider, key.credentialScope, key.operation, requestHash(key, requestJson), requestJson, responseJson, input.rowCount, input.sourceCostMicros, taskIdsJson, now, expiresAt);
+		noteCacheWrite(Buffer.byteLength(requestJson) + Buffer.byteLength(responseJson) + Buffer.byteLength(taskIdsJson), database);
+	};
+	if (options.database) save(options.database);
+	else writeToCache(save);
 	return {
 		data: input.data,
 		storedAt: new Date(now).toISOString(),
@@ -27181,7 +27265,7 @@ const installedPackageJsonSchema = z.object({
 function packageDirectory(packagesDir, packageName) {
 	return join(packagesDir, "node_modules", ...packageName.split("/"));
 }
-function inside(parent, child) {
+function inside$1(parent, child) {
 	const path = relative(parent, child);
 	return path === "" || !path.startsWith("..") && !isAbsolute(path);
 }
@@ -27213,14 +27297,14 @@ async function loadOne(installed, registry, options) {
 async function loadProviderPackage(input, options) {
 	const importModule = options.importModule ?? ((url) => import(url));
 	const packageDir = realpathSync(packageDirectory(options.packagesDir, input.package));
-	if (!inside(realpathSync(options.packagesDir), packageDir)) throw new Error("Installed provider package resolves outside the provider directory.");
+	if (!inside$1(realpathSync(options.packagesDir), packageDir)) throw new Error("Installed provider package resolves outside the provider directory.");
 	const packageJsonPath = join(packageDir, "package.json");
 	const packageJson = installedPackageJsonSchema.parse(JSON.parse(readFileSync(packageJsonPath, "utf8")));
 	if (packageJson.name !== input.package || packageJson.version !== input.version) throw new Error("Installed provider package does not match its saved record.");
 	const packageRegistry = new ProviderExtensionRegistry();
 	for (const entry of packageJson.seo.providers) {
 		const entryPath = realpathSync(resolve(dirname(packageJsonPath), entry));
-		if (!inside(packageDir, entryPath)) throw new Error("Provider entry point resolves outside its package.");
+		if (!inside$1(packageDir, entryPath)) throw new Error("Provider entry point resolves outside its package.");
 		await providerActivate((await importModule(`${pathToFileURL(entryPath).href}?seo-provider=${encodeURIComponent(input.version)}`)).default)(packageRegistry.hostFor({
 			package: input.package,
 			version: input.version
@@ -27256,7 +27340,7 @@ async function loadInstalledProviderExtensions(options = {}) {
 const DEFAULT_MAX_REQUESTS = 8;
 const MAX_RESPONSE_BYTES$1 = 10 * 1024 * 1024;
 const MAX_REQUEST_BODY_BYTES = 64 * 1024;
-const TIMEOUT_MS$1 = 15e3;
+const TIMEOUT_MS$3 = 15e3;
 function normalizeProviderExtensionAccount(provider, account) {
 	const fields = provider.connection.fields.filter((field) => field.kind === "account");
 	const allowed = new Set(fields.map((field) => field.id));
@@ -27303,7 +27387,7 @@ function runtimeForProvider(provider, options = {}) {
 				},
 				fetch: providerFetch,
 				maxResponseBytes: MAX_RESPONSE_BYTES$1,
-				timeoutMs: TIMEOUT_MS$1,
+				timeoutMs: TIMEOUT_MS$3,
 				retry: (input.method ?? "GET") === "GET" ? "safe" : "never",
 				schema: z.unknown()
 			});
@@ -28866,7 +28950,7 @@ function analyzeCtrUnderperformersFromRows(input) {
 const MAX_GSC_ROWS$3 = 1e5;
 const DEFAULT_DAYS$3 = 28;
 const MAX_DAYS$2 = 548;
-function plural$5(count, singular, pluralLabel = `${singular}s`) {
+function plural$6(count, singular, pluralLabel = `${singular}s`) {
 	return count === 1 ? singular : pluralLabel;
 }
 async function ctrUnderperformersReportWith(input, dependencies) {
@@ -28969,11 +29053,11 @@ async function ctrUnderperformersReportWith(input, dependencies) {
 			minImpressions,
 			limit,
 			brandFiltering: input.includeBrand ? "included" : "excluded",
-			verdict: top ? `${selection.eligibleUnderperformers} CTR ${plural$5(selection.eligibleUnderperformers, "underperformer")} found in retained rows, with a calculated heuristic shortfall of ${totalClickShortfall.toFixed(0)} clicks for this window. Start review with "${top.query}" because it has the largest gap.` : dataStatus === "partial" ? "No material CTR underperformers remained in the validated retained rows, but partial evidence prevents an all-clear." : `No high-impression rows at average position below 4 in the retained rows are materially below the heuristic CTR benchmark.`
+			verdict: top ? `${selection.eligibleUnderperformers} CTR ${plural$6(selection.eligibleUnderperformers, "underperformer")} found in retained rows, with a calculated heuristic shortfall of ${totalClickShortfall.toFixed(0)} clicks for this window. Start review with "${top.query}" because it has the largest gap.` : dataStatus === "partial" ? "No material CTR underperformers remained in the validated retained rows, but partial evidence prevents an all-clear." : `No high-impression rows at average position below 4 in the retained rows are materially below the heuristic CTR benchmark.`
 		},
 		items,
 		caveats: [
-			`Date window: ${range.startDate} to ${range.endDate} (${days} ${plural$5(days, "day")}), using final GSC data where available.`,
+			`Date window: ${range.startDate} to ${range.endDate} (${days} ${plural$6(days, "day")}), using final GSC data where available.`,
 			`Brand queries: ${input.includeBrand ? "included" : "excluded"}. Brand terms used: ${brand.terms.join(", ") || "none"} (${brand.source === "provided" ? "provided" : "host forms, plus the bare domain stem only when Search Console shows the site is its navigational answer"}).`,
 			`Only rows at average position below 4 with at least ${minImpressions} impressions were checked. Rows at position 4 to 10 belong to quick-wins, which uses the same site CTR curve.`,
 			minImpressionsCaveat({
@@ -28981,13 +29065,13 @@ async function ctrUnderperformersReportWith(input, dependencies) {
 				belowMinimumRows: selection.belowMinimumRows
 			}),
 			"Expected CTR uses the site CTR curve from all page-one rows (75th percentile of qualified URL CTRs per position) when enough peer data exists, otherwise the fallback position curve.",
-			...selection.fragmentRows ? [`${selection.fragmentRows} source ${plural$5(selection.fragmentRows, "row")} with a #fragment URL ${selection.fragmentRows === 1 ? "was" : "were"} merged into the base URL.`] : [],
-			...selection.flaggedRows ? [`${selection.flaggedRows} eligible ${plural$5(selection.flaggedRows, "row")} carry heuristic query flags (likely-automated or navigational-other) and rank after unflagged rows.`] : [],
+			...selection.fragmentRows ? [`${selection.fragmentRows} source ${plural$6(selection.fragmentRows, "row")} with a #fragment URL ${selection.fragmentRows === 1 ? "was" : "were"} merged into the base URL.`] : [],
+			...selection.flaggedRows ? [`${selection.flaggedRows} eligible ${plural$6(selection.flaggedRows, "row")} carry heuristic query flags (likely-automated or navigational-other) and rank after unflagged rows.`] : [],
 			"CTR benchmarks and calculated click shortfalls are directional heuristics, not forecasts or proof that clicks are available. Validate the search intent and live SERP before editing.",
-			...selection.invalidRows ? [`${selection.invalidRows} invalid provider ${plural$5(selection.invalidRows, "row")} ${selection.invalidRows === 1 ? "was" : "were"} excluded, so this report is partial.`] : [],
-			...selection.duplicateRows ? [`${selection.duplicateRows} repeated query/page ${plural$5(selection.duplicateRows, "row")} ${selection.duplicateRows === 1 ? "was" : "were"} aggregated before CTR and average position were calculated.`] : [],
+			...selection.invalidRows ? [`${selection.invalidRows} invalid provider ${plural$6(selection.invalidRows, "row")} ${selection.invalidRows === 1 ? "was" : "were"} excluded, so this report is partial.`] : [],
+			...selection.duplicateRows ? [`${selection.duplicateRows} repeated query/page ${plural$6(selection.duplicateRows, "row")} ${selection.duplicateRows === 1 ? "was" : "were"} aggregated before CTR and average position were calculated.`] : [],
 			...possiblyTruncated ? [`The retained-row limit of ${MAX_GSC_ROWS$3} was reached, so lower-ranked source rows may be absent.`] : [],
-			...selection.limitedUnderperformers ? [`${selection.limitedUnderperformers} eligible ${plural$5(selection.limitedUnderperformers, "underperformer")} ${selection.limitedUnderperformers === 1 ? "was" : "were"} omitted by the output limit.`] : []
+			...selection.limitedUnderperformers ? [`${selection.limitedUnderperformers} eligible ${plural$6(selection.limitedUnderperformers, "underperformer")} ${selection.limitedUnderperformers === 1 ? "was" : "were"} omitted by the output limit.`] : []
 		],
 		recommendations: top ? [
 			`Review the live SERP and displayed snippet for "${top.query}" first. Test the title or meta description only if the observed framing does not match the query intent.`,
@@ -29007,11 +29091,11 @@ function ctrUnderperformersReport(input, dependencies = defaultDependencies$9) {
 }
 //#endregion
 //#region packages/core/dist/phrasing.js
-function plural$4(count, singular, pluralLabel = `${singular}s`) {
+function plural$5(count, singular, pluralLabel = `${singular}s`) {
 	return count === 1 ? singular : pluralLabel;
 }
 function countLabel(count, singular, pluralLabel = `${singular}s`) {
-	return `${count.toLocaleString("en-GB")} ${plural$4(count, singular, pluralLabel)}`;
+	return `${count.toLocaleString("en-GB")} ${plural$5(count, singular, pluralLabel)}`;
 }
 //#endregion
 //#region packages/core/dist/analyze/diagnosis-priorities.js
@@ -32770,7 +32854,7 @@ function anomalyEvidence(anomaly) {
 	if (anomaly.direction === "normal") return `${formatMetric(anomaly.metric)} changed ${changePhrase} (${anomaly.baselineMean.toLocaleString("en-GB")} -> ${anomaly.comparisonMean.toLocaleString("en-GB")} per observed day${anomaly.zScore === null ? "; the baseline had no observed variance" : `, z ${anomaly.zScore}`}).`;
 	return `${formatMetric(anomaly.metric)} ${direction} ${changePhrase} (${anomaly.baselineMean.toLocaleString("en-GB")} -> ${anomaly.comparisonMean.toLocaleString("en-GB")} per observed day${anomaly.zScore === null ? "; outside the flat observed baseline" : `, z ${anomaly.zScore}`}).`;
 }
-function plural$3(count, singular, pluralLabel = `${singular}s`) {
+function plural$4(count, singular, pluralLabel = `${singular}s`) {
 	return count === 1 ? singular : pluralLabel;
 }
 function strongestSignal(anomalies) {
@@ -32826,13 +32910,13 @@ function interpretUpdateCorrelation(input) {
 		summary,
 		evidence: [
 			...input.anomalies.map(anomalyEvidence),
-			hasUpdate ? `${input.overlappingUpdates.length} official Google Ranking update ${plural$3(input.overlappingUpdates.length, "window")} overlapped the change date or comparison window: ${updateNames.join(", ")}.` : "No official Google Ranking update windows overlapped the change date or comparison window.",
+			hasUpdate ? `${input.overlappingUpdates.length} official Google Ranking update ${plural$4(input.overlappingUpdates.length, "window")} overlapped the change date or comparison window: ${updateNames.join(", ")}.` : "No official Google Ranking update windows overlapped the change date or comparison window.",
 			largeMovement ? "Both clicks and impressions moved sharply in the same direction." : "Clicks and impressions did not both meet the sharp-movement evidence threshold.",
 			hasConfounders ? `Known overlapping site changes: ${confounders.map((confounder) => confounder.title).join("; ")}.` : "No overlapping site changes were supplied."
 		],
 		caveats: [
 			`GSC window: ${input.days} days; recent comparison window: ${input.recentDays} days.`,
-			`Update overlap padding: ${input.paddingDays} ${plural$3(input.paddingDays, "day")} either side of the step-change date, or of the recent comparison window when no step change was found.`,
+			`Update overlap padding: ${input.paddingDays} ${plural$4(input.paddingDays, "day")} either side of the step-change date, or of the recent comparison window when no step change was found.`,
 			input.refresh ? "Data freshness: cache bypassed for GSC data." : "Data freshness: local GSC cache may have been used.",
 			"Source: official Google Search Status Dashboard Ranking incidents only; third-party volatility and unconfirmed chatter are not included.",
 			"An update-window overlap cannot establish causation, even when movement is large and no known site change was recorded.",
@@ -33000,7 +33084,7 @@ function analyzeTrafficAnomalyRows(input) {
 		if (step && changeDate) {
 			const previousDate = aggregated.rows[step.index - 1]?.keys[0];
 			const gap = previousDate ? calendarDays(previousDate, changeDate) - 2 : 0;
-			stepCaveats.push(`${formatMetric(metric)} changed level on ${changeDate}, so its baseline is every observed day before that date and its comparison is every observed day from it.`, ...gap > 0 ? [`The ${metric} change date follows ${gap} missing ${plural$3(gap, "day")}; the change may have started on one of them.`] : []);
+			stepCaveats.push(`${formatMetric(metric)} changed level on ${changeDate}, so its baseline is every observed day before that date and its comparison is every observed day from it.`, ...gap > 0 ? [`The ${metric} change date follows ${gap} missing ${plural$4(gap, "day")}; the change may have started on one of them.`] : []);
 			return compareSegments({
 				site: input.site,
 				metric,
@@ -33031,9 +33115,9 @@ function analyzeTrafficAnomalyRows(input) {
 	const comparisonMissingDays = input.recentDays - comparisonRows.length;
 	const missingDays = expectedDays - aggregated.rows.length;
 	const caveats = [
-		...missingDays > 0 ? [`${missingDays} requested calendar ${plural$3(missingDays, "day")} had no returned date aggregate and ${missingDays === 1 ? "was" : "were"} not filled with zeros.`] : [],
-		...aggregated.invalidRows > 0 ? [`${aggregated.invalidRows} invalid provider ${plural$3(aggregated.invalidRows, "row")} ${aggregated.invalidRows === 1 ? "was" : "were"} excluded.`] : [],
-		...aggregated.duplicateRows > 0 ? [`${aggregated.duplicateRows} duplicate date ${plural$3(aggregated.duplicateRows, "row")} ${aggregated.duplicateRows === 1 ? "was" : "were"} aggregated before analysis.`] : [],
+		...missingDays > 0 ? [`${missingDays} requested calendar ${plural$4(missingDays, "day")} had no returned date aggregate and ${missingDays === 1 ? "was" : "were"} not filled with zeros.`] : [],
+		...aggregated.invalidRows > 0 ? [`${aggregated.invalidRows} invalid provider ${plural$4(aggregated.invalidRows, "row")} ${aggregated.invalidRows === 1 ? "was" : "were"} excluded.`] : [],
+		...aggregated.duplicateRows > 0 ? [`${aggregated.duplicateRows} duplicate date ${plural$4(aggregated.duplicateRows, "row")} ${aggregated.duplicateRows === 1 ? "was" : "were"} aggregated before analysis.`] : [],
 		...stepCaveats
 	];
 	return {
@@ -34114,7 +34198,7 @@ const VOID = /* @__PURE__ */ new Set([
 	"col",
 	"embed"
 ]);
-const ENTITIES = {
+const ENTITIES$1 = {
 	amp: "&",
 	lt: "<",
 	gt: ">",
@@ -34139,7 +34223,7 @@ function decode(text) {
 			const point = Number.parseInt(code.slice(hex ? 2 : 1), hex ? 16 : 10);
 			return point > 0 && point <= 1114111 ? String.fromCodePoint(point) : "";
 		}
-		return ENTITIES[code.toLowerCase()] ?? match;
+		return ENTITIES$1[code.toLowerCase()] ?? match;
 	});
 }
 const clean$1 = (value) => value.split(A_OPEN).join("").replace(/\s+/g, " ").trim();
@@ -34379,7 +34463,7 @@ var SentenceStore = class SentenceStore {
 		});
 	}
 };
-const bareHost = (host) => host.toLowerCase().replace(/^www\./, "");
+const bareHost$1 = (host) => host.toLowerCase().replace(/^www\./, "");
 function crawlUrl(value, base) {
 	try {
 		const url = base ? new URL(value, base) : new URL(value);
@@ -34445,10 +34529,10 @@ async function crawlForLinks(input) {
 async function crawl(input, robots, sentences, renderer, warnings) {
 	const start = crawlUrl(input.startUrl) ?? input.startUrl;
 	let origin = new URL(start).origin;
-	const site = bareHost(new URL(start).host);
+	const site = bareHost$1(new URL(start).host);
 	const sameSite = (url) => {
 		try {
-			return bareHost(new URL(url).host) === site;
+			return bareHost$1(new URL(url).host) === site;
 		} catch {
 			return false;
 		}
@@ -34942,15 +35026,15 @@ function internalLinksReportRange(input, fallbackDays, now) {
 		days: Math.round((Date.parse(`${endDate}T00:00:00Z`) - Date.parse(`${startDate}T00:00:00Z`)) / DAY$1) + 1
 	};
 }
-const plural$2 = (count, word) => `${count} ${word}${count === 1 ? "" : "s"}`;
+const plural$3 = (count, word) => `${count} ${word}${count === 1 ? "" : "s"}`;
 function internalLinksVerdict(report) {
 	const { counts } = report;
 	if (report.dataStatus === "blocked") return "robots.txt does not allow this crawler to read the site, so nothing was checked.";
 	if (report.dataStatus === "empty") return "No HTML page could be crawled, so there is nothing to link.";
 	if (report.dataStatus === "target-not-crawled") return "The target page could not be crawled as its own page (it failed, left the site, or names another page as canonical). Check it with seo page first.";
 	if (report.dataStatus === "target-not-linkable") return `The target is ${report.target?.noindex ? "noindex" : `a ${report.target?.type?.replaceAll("_", " ")} page`}, so no links to it are suggested.`;
-	const judged = report.judge.status === "used" || report.judge.status === "partial" ? `${counts.strong} strong and ${counts.possible} possible link${counts.strong + counts.possible === 1 ? "" : "s"} judged by ${report.judge.model}${counts.heuristic ? `, plus ${plural$2(counts.heuristic, "heuristic link")} where a request failed` : ""}` : `${plural$2(counts.heuristic, "heuristic link")} (no decision model)`;
-	const scope = report.mode === "url" ? `to ${report.target?.url}` : `across ${plural$2(counts.pagesCrawled, "page")}`;
+	const judged = report.judge.status === "used" || report.judge.status === "partial" ? `${counts.strong} strong and ${counts.possible} possible link${counts.strong + counts.possible === 1 ? "" : "s"} judged by ${report.judge.model}${counts.heuristic ? `, plus ${plural$3(counts.heuristic, "heuristic link")} where a request failed` : ""}` : `${plural$3(counts.heuristic, "heuristic link")} (no decision model)`;
+	const scope = report.mode === "url" ? `to ${report.target?.url}` : `across ${plural$3(counts.pagesCrawled, "page")}`;
 	const capped = report.crawl.capReached ? ` The crawl stopped at its limit of ${report.crawl.pageLimit} pages, so pages beyond it were not checked.` : "";
 	return `${judged} ${scope}${counts.heldBack ? `; ${counts.heldBack} held back by the evidence floors` : ""}.${capped}`;
 }
@@ -36851,7 +36935,7 @@ function reportId$1(input) {
 	})).digest("hex").slice(0, 20)}`;
 }
 function cacheGet(id, now) {
-	const row = getDb().prepare("SELECT report_json FROM performance_reports WHERE id = ? AND expires_at > ?").get(id, now);
+	const row = cacheDb().prepare("SELECT report_json FROM performance_reports WHERE id = ? AND expires_at > ?").get(id, now);
 	if (!row?.report_json) return void 0;
 	try {
 		const report = JSON.parse(row.report_json);
@@ -36866,10 +36950,12 @@ function cacheSet(report, now) {
 		raw: void 0
 	};
 	const reportJson = JSON.stringify(stored);
-	getDb().prepare(`INSERT OR REPLACE INTO performance_reports
-      (id, url, strategy, report_json, created_at, expires_at)
-      VALUES (?, ?, ?, ?, ?, ?)`).run(report.id, report.url, report.strategy, reportJson, Date.parse(report.generatedAt), now + CACHE_TTL_MS);
-	noteCacheWrite(Buffer.byteLength(reportJson));
+	writeToCache((database) => {
+		database.prepare(`INSERT OR REPLACE INTO performance_reports
+        (id, url, strategy, report_json, created_at, expires_at)
+        VALUES (?, ?, ?, ?, ?, ?)`).run(report.id, report.url, report.strategy, reportJson, Date.parse(report.generatedAt), now + CACHE_TTL_MS);
+		noteCacheWrite(Buffer.byteLength(reportJson), database);
+	});
 }
 async function fallbackReport(input) {
 	const fetched = await fetchPage(input.url, {
@@ -37386,14 +37472,14 @@ function* retainedQueryClusterRows(input) {
 		};
 	}
 }
-function plural$1(count, singular, pluralLabel = `${singular}s`) {
+function plural$2(count, singular, pluralLabel = `${singular}s`) {
 	return count === 1 ? singular : pluralLabel;
 }
 function reportVerdict(input) {
 	if (!input.clusters.length) return "No query clusters were generated for this scope.";
 	if (input.highOpportunityClusters > 0) {
 		const verb = input.highOpportunityClusters === 1 ? "has" : "have";
-		return `${input.highOpportunityClusters} ${plural$1(input.highOpportunityClusters, "cluster")} ${verb} enough demand and weak enough performance to review first.`;
+		return `${input.highOpportunityClusters} ${plural$2(input.highOpportunityClusters, "cluster")} ${verb} enough demand and weak enough performance to review first.`;
 	}
 	return "No obvious high-opportunity clusters were found. Use this report for content structure and intent mapping rather than urgent fixes.";
 }
@@ -37534,7 +37620,7 @@ function movementLine(report) {
 }
 function countPhrase(count, singular, pluralLabel = `${singular}s`) {
 	if (count === 0) return `no ${pluralLabel}`;
-	return `${count} ${plural(count, singular, pluralLabel)}`;
+	return `${count} ${plural$1(count, singular, pluralLabel)}`;
 }
 function headlineLine(report) {
 	const parts = [
@@ -37589,7 +37675,7 @@ function decayDiagnosisLabel(diagnosis) {
 	if (diagnosis === "lost_clicks") return "clicks dropped without one dominant signal";
 	return diagnosis.replaceAll("_", " ");
 }
-function plural(count, singular, pluralLabel = `${singular}s`) {
+function plural$1(count, singular, pluralLabel = `${singular}s`) {
 	return count === 1 ? singular : pluralLabel;
 }
 function decayClusterLine(report) {
@@ -37597,7 +37683,7 @@ function decayClusterLine(report) {
 	if (!group) return "No material decay cluster stood out.";
 	const diagnosis = decayDiagnosisLabel(group.diagnosis);
 	const samples = group.sampleQueries.slice(0, 2).join("; ");
-	return `Top decay cluster: ${group.count} ${plural(group.count, "finding")} in the ${group.template.label} template (${diagnosis}), ${group.totalClickLoss.toFixed(0)} fewer observed clicks across rows retained in both windows. Action: ${group.recommendation}${samples ? ` Example queries: ${samples}.` : ""}`;
+	return `Top decay cluster: ${group.count} ${plural$1(group.count, "finding")} in the ${group.template.label} template (${diagnosis}), ${group.totalClickLoss.toFixed(0)} fewer observed clicks across rows retained in both windows. Action: ${group.recommendation}${samples ? ` Example queries: ${samples}.` : ""}`;
 }
 function cannibalSuppressionLine(report) {
 	const suppressed = report.cannibalization.selection.suppressedQueries;
@@ -37615,21 +37701,21 @@ function contentOpportunityBullets(report) {
 	if (unavailableSections.length) bullets.push(`Could not assess ${unavailableSections.join(", ")} opportunities in this run; see report caveats.`);
 	if (report.summary.decayItems) {
 		const top = report.decay.items[0];
-		bullets.push(top ? `${report.summary.decayItems} observed retained query/page ${plural(report.summary.decayItems, "decline")} need review. Start with "${top.query}" on ${top.url}; it had ${top.clickLoss.toFixed(0)} fewer clicks.` : `${report.summary.decayItems} observed retained query/page ${plural(report.summary.decayItems, "decline")} need review.`);
+		bullets.push(top ? `${report.summary.decayItems} observed retained query/page ${plural$1(report.summary.decayItems, "decline")} need review. Start with "${top.query}" on ${top.url}; it had ${top.clickLoss.toFixed(0)} fewer clicks.` : `${report.summary.decayItems} observed retained query/page ${plural$1(report.summary.decayItems, "decline")} need review.`);
 		bullets.push(decayClusterLine(report));
 	}
 	if (report.summary.cannibalItems) {
 		const top = report.cannibalization.items[0];
-		bullets.push(top ? `${report.summary.cannibalItems} multi-URL query ${plural(report.summary.cannibalItems, "candidate")} need intent and technical review. Start with "${top.query}" and decide whether ${top.pages.length} ranking URLs answer the same intent.` : `${report.summary.cannibalItems} multi-URL query ${plural(report.summary.cannibalItems, "candidate")} need intent and technical review.`);
+		bullets.push(top ? `${report.summary.cannibalItems} multi-URL query ${plural$1(report.summary.cannibalItems, "candidate")} need intent and technical review. Start with "${top.query}" and decide whether ${top.pages.length} ranking URLs answer the same intent.` : `${report.summary.cannibalItems} multi-URL query ${plural$1(report.summary.cannibalItems, "candidate")} need intent and technical review.`);
 	}
 	if (report.cannibalization.selection.suppressedQueries) bullets.push(cannibalSuppressionLine(report));
 	if (report.summary.strikingDistanceItems) {
 		const top = report.strikingDistance.items[0];
-		bullets.push(top ? `${countLabel(report.summary.strikingDistanceItems, "query/page candidate")} ${plural(report.summary.strikingDistanceItems, "has", "have")} an average GSC position above 10 and at most 20. Start by investigating "${top.query}" on ${top.url}; it averages position ${top.position.toFixed(1)} with ${top.impressions.toFixed(0)} impressions.` : `${countLabel(report.summary.strikingDistanceItems, "query/page candidate")} ${plural(report.summary.strikingDistanceItems, "has", "have")} an average GSC position above 10 and at most 20.`);
+		bullets.push(top ? `${countLabel(report.summary.strikingDistanceItems, "query/page candidate")} ${plural$1(report.summary.strikingDistanceItems, "has", "have")} an average GSC position above 10 and at most 20. Start by investigating "${top.query}" on ${top.url}; it averages position ${top.position.toFixed(1)} with ${top.impressions.toFixed(0)} impressions.` : `${countLabel(report.summary.strikingDistanceItems, "query/page candidate")} ${plural$1(report.summary.strikingDistanceItems, "has", "have")} an average GSC position above 10 and at most 20.`);
 	}
 	if (!skippedReason(report, "quick-win opportunities") && report.summary.quickWinItems) {
 		const top = report.quickWins.items[0];
-		bullets.push(top ? `${report.summary.quickWinItems} retained query/page ${plural(report.summary.quickWinItems, "candidate")} fell below a site-peer or versioned heuristic CTR target. Start with "${top.query}" on ${top.url}; it had ${top.impressions.toFixed(0)} impressions at average position ${top.position.toFixed(1)}.` : `${report.summary.quickWinItems} CTR-target ${plural(report.summary.quickWinItems, "candidate")} need review.`);
+		bullets.push(top ? `${report.summary.quickWinItems} retained query/page ${plural$1(report.summary.quickWinItems, "candidate")} fell below a site-peer or versioned heuristic CTR target. Start with "${top.query}" on ${top.url}; it had ${top.impressions.toFixed(0)} impressions at average position ${top.position.toFixed(1)}.` : `${report.summary.quickWinItems} CTR-target ${plural$1(report.summary.quickWinItems, "candidate")} need review.`);
 	}
 	const templateLine = templateOpportunityLine(report);
 	if (!templateLine.startsWith("No dominant")) bullets.push(templateLine);
@@ -37989,10 +38075,10 @@ function applyVerification(item, coverage) {
 function verdict(report) {
 	if (report.dataStatus === "empty") return "Google Search Console returned no retained query/page rows for this window.";
 	if (report.dataStatus === "filtered") return "No pages met the position, brand, and minimum-impression criteria.";
-	if (report.technical > 0) return `${countLabel(report.eligible, "eligible average-position page")} found; ${countLabel(report.technical, "returned page")} ${plural$4(report.technical, "has", "have")} verified technical issues to fix before content changes.`;
-	if (report.failed > 0) return `${countLabel(report.eligible, "eligible average-position page")} found; ${countLabel(report.failed, "returned page")} could not be verified and ${plural$4(report.failed, "needs", "need")} a fetch check before content changes.`;
-	if (report.content > 0) return `${countLabel(report.eligible, "eligible average-position page")} found; ${countLabel(report.content, "returned page")} ${plural$4(report.content, "has", "have")} verified content or search-framing gaps.`;
-	return `${countLabel(report.eligible, "eligible average-position page")} found; ${countLabel(report.returned, "page")} ${plural$4(report.returned, "is", "are")} returned in priority order for investigation.`;
+	if (report.technical > 0) return `${countLabel(report.eligible, "eligible average-position page")} found; ${countLabel(report.technical, "returned page")} ${plural$5(report.technical, "has", "have")} verified technical issues to fix before content changes.`;
+	if (report.failed > 0) return `${countLabel(report.eligible, "eligible average-position page")} found; ${countLabel(report.failed, "returned page")} could not be verified and ${plural$5(report.failed, "needs", "need")} a fetch check before content changes.`;
+	if (report.content > 0) return `${countLabel(report.eligible, "eligible average-position page")} found; ${countLabel(report.content, "returned page")} ${plural$5(report.content, "has", "have")} verified content or search-framing gaps.`;
+	return `${countLabel(report.eligible, "eligible average-position page")} found; ${countLabel(report.returned, "page")} ${plural$5(report.returned, "is", "are")} returned in priority order for investigation.`;
 }
 function reportRecommendations(items) {
 	const first = items[0];
@@ -39053,7 +39139,7 @@ async function updatePostmortemWorkflow(input, dependencies = {}) {
 //#endregion
 //#region packages/core/dist/clicky/api.js
 const ENDPOINT$1 = "https://api.clicky.com/api/stats/4";
-const MAX_BYTES$1 = 5e6;
+const MAX_BYTES$3 = 5e6;
 var ClickyError = class extends Error {
 	code;
 	constructor(code, message) {
@@ -39080,7 +39166,7 @@ async function clickyStats(site, types, options = {}) {
 		throw new ClickyError("remote", "Could not reach Clicky. Try again.");
 	});
 	if (!response.ok) throw new ClickyError("remote", `Clicky returned ${response.status}.`);
-	const groups = await readJson(response, "Clicky", { maxBytes: MAX_BYTES$1 });
+	const groups = await readJson(response, "Clicky", { maxBytes: MAX_BYTES$3 });
 	if (!Array.isArray(groups)) throw new ClickyError("remote", "Clicky returned invalid data.");
 	const failed = groups.find((group) => typeof group?.error === "string");
 	if (failed?.error) throw /sitekey|site id|authenticat|permission/iu.test(failed.error) ? new ClickyError("auth", `Clicky rejected site ID ${site.siteId} or its sitekey.`) : new ClickyError("remote", `Clicky: ${failed.error.slice(0, 200)}`);
@@ -40835,6 +40921,392 @@ async function withDomainRating(rows, key) {
 		added: true
 	};
 }
+const MAX_INSPECT_LIMIT = 2e3;
+const CONCURRENCY = 20;
+const REFERRING_KEPT = 10;
+const LABELS = {
+	fix: "the evidence shows a fault on the site",
+	check: "a person should look; the evidence alone does not settle it",
+	expected: "the evidence shows the site works as built, nothing to fix",
+	indexed: "Google indexes it and the live check shows no fault"
+};
+const AUTH_SEGMENTS = /* @__PURE__ */ new Set([
+	"account",
+	"admin",
+	"api",
+	"auth",
+	"cart",
+	"checkout",
+	"dashboard",
+	"login",
+	"logout",
+	"my-account",
+	"oauth",
+	"sign-in",
+	"signin",
+	"wp-admin",
+	"wp-login.php"
+]);
+const bareHost = (url) => new URL(url).hostname.replace(/^www\./, "");
+const sameSite = (a, b) => {
+	try {
+		return bareHost(a) === bareHost(b);
+	} catch {
+		return false;
+	}
+};
+function variantOf(url, target) {
+	const from = new URL(url);
+	const to = new URL(target);
+	if (from.pathname !== to.pathname || from.search !== to.search) return null;
+	if (!sameSite(url, target)) return null;
+	if (from.protocol !== to.protocol) return "http:// variant";
+	if (from.host !== to.host) return `host variant (${from.host})`;
+	return null;
+}
+const samePath = (a, b) => {
+	const [from, to] = [new URL(a), new URL(b)];
+	return from.pathname === to.pathname && from.search === to.search;
+};
+const authPath = (url) => AUTH_SEGMENTS.has(new URL(url).pathname.split("/")[1]?.toLowerCase() ?? "");
+const plural = (count, word) => `${count} ${word}${count === 1 ? "" : "s"}`;
+function labelOf(e) {
+	const { url, status, live } = e;
+	const { first, hops, last } = live;
+	const indexed = status.verdict === "PASS";
+	const coverage = status.coverage ?? "";
+	const referring = status.referring_urls.filter((item) => item !== url && sameSite(item, url) && !samePath(item, url));
+	const pointers = [e.inSitemap ? "the sitemap lists it" : null, referring.length ? `Google lists ${plural(referring.length, "referring page")} on this site as of its last crawl (${referring[0]}${referring.length > 1 ? ", and more" : ""})` : null].filter(Boolean);
+	if (first.error) return indexed ? {
+		label: "indexed",
+		why: `Google indexes it. The live check failed (${first.error}).`
+	} : {
+		label: "check",
+		why: `The live check failed (${first.error}), so only Google's reason is shown.`
+	};
+	const temporary = hops.find((hop) => hop.kind === "temporary" && new URL(hop.from).host === new URL(hop.to).host);
+	if (temporary) return {
+		label: "fix",
+		why: `${temporary.from} sends a ${temporary.status} (temporary) redirect to ${temporary.to} on the same host; a permanent move uses 301 or 308.`
+	};
+	if (!last) return {
+		label: "fix",
+		why: `The redirects loop or pass 5 hops (${hops.map((hop) => hop.status).join(" > ")}).`
+	};
+	if (last.error) return {
+		label: "check",
+		why: `It redirects to ${last.url}, which could not be fetched (${last.error}).`
+	};
+	const end = last.status ?? 0;
+	const now = hops.length ? `redirects to ${last.url}, which returns ${end}` : `returns ${end} now`;
+	const via = `It ${now}`;
+	if (end === 404 || end === 410) {
+		if (pointers.length) return {
+			label: "fix",
+			why: `${via}, and ${pointers.join(" and ")}.`
+		};
+		if (hops.length) return {
+			label: "fix",
+			why: `${via}: a redirect to a missing page.`
+		};
+		return {
+			label: "expected",
+			why: `${via}, and neither the sitemap nor any referring page Google lists on this site points to it.`
+		};
+	}
+	if ((end === 401 || end === 403) && !hops.length) {
+		if (e.inSitemap) return {
+			label: "fix",
+			why: `${via}, but the sitemap lists it.`
+		};
+		if (end === 401 && first.www_authenticate) return {
+			label: "expected",
+			why: `${via} with a WWW-Authenticate header (${first.www_authenticate.split(/\s/)[0]}), so the server asks for sign-in here.`
+		};
+		if (authPath(url)) return {
+			label: "expected",
+			why: `${via} on a path that looks like a sign-in area (heuristic: from the path only).`
+		};
+		return {
+			label: "check",
+			why: `${via} with no WWW-Authenticate header and no sign-in path, so the evidence does not show whether it should be public.`
+		};
+	}
+	if (hops.length) {
+		const codes = hops.map((hop) => hop.status).join(" > ");
+		if (end !== 200) return {
+			label: "check",
+			why: `${via} (${codes}).`
+		};
+		if (e.inSitemap) return {
+			label: "fix",
+			why: `The sitemap lists it, but it redirects (${codes}) to ${last.url}.`
+		};
+		const declared = last.canonical === last.url ? "declares itself canonical" : e.sitemap.has(last.url) ? "is in the sitemap" : null;
+		const variant = variantOf(url, last.url);
+		const moved = `${variant ? `An ${variant}` : "A permanent redirect"}: ${codes} to ${last.url}`;
+		const stale = indexed ? " Google still indexes this URL as of its last crawl." : "";
+		const links = referring.length ? ` ${pointers.at(-1)}.` : "";
+		if (declared) return {
+			label: "expected",
+			why: `${moved}, which returns 200 and ${declared}.${stale}${links}`
+		};
+		return {
+			label: "check",
+			why: `${moved}, which declares ${last.canonical ? `${last.canonical} as canonical` : "no canonical"}.${stale}${links}`
+		};
+	}
+	if (/^(Crawled|Discovered) - currently not indexed$|^URL is unknown to Google$/i.test(coverage)) return {
+		label: "check",
+		why: `${coverage.startsWith("Crawled") ? "Google crawled it but has not indexed it, and gives no further reason" : coverage.startsWith("Discovered") ? "Google knows the URL but has not crawled it yet" : "Google has no record of this URL"}.${e.inSitemap ? " The sitemap lists it." : ""} It returns ${end} now.`
+	};
+	const robots = last.robots ? ` with robots "${last.robots}"` : " with no robots meta tag or X-Robots-Tag header";
+	if (/noindex/i.test(coverage) && !/noindex/i.test(last.robots ?? "")) return {
+		label: "check",
+		why: `Google saw noindex when it last crawled${status.last_crawl ? ` (${status.last_crawl.slice(0, 10)})` : ""}, but it ${now}${robots}, so Google's reason may be out of date.${e.inSitemap ? " The sitemap lists it." : ""}`
+	};
+	const declaredCanonical = status.user_canonical ?? last.canonical;
+	if (status.google_canonical && declaredCanonical && status.google_canonical !== declaredCanonical) return {
+		label: "check",
+		why: `Google chose ${status.google_canonical} as canonical; the page declares ${declaredCanonical}.`
+	};
+	if (indexed) return end === 200 ? {
+		label: "indexed",
+		why: "Google indexes it and it returns 200 now."
+	} : {
+		label: "check",
+		why: `Google indexes it, but it ${now}.`
+	};
+	if (e.inSitemap) return {
+		label: "fix",
+		why: `The sitemap lists it, but Google does not index it. It ${now}${robots}.`
+	};
+	if (status.google_canonical && status.google_canonical === status.user_canonical && status.google_canonical !== url) return {
+		label: "expected",
+		why: `The page declares ${status.user_canonical} as canonical and Google uses it.`
+	};
+	return {
+		label: "check",
+		why: /noindex/i.test(last.robots ?? "") ? `${via}${robots} and the sitemap does not list it. Whether it should be indexed is the site's call.` : `${via}${robots}. No rule here settles this reason.`
+	};
+}
+function indexingRow(e, sources, inspectedAt) {
+	const { status, live } = e;
+	const { label, why } = labelOf(e);
+	return {
+		reason: status.coverage ?? status.verdict ?? "No reason returned",
+		url: e.url,
+		label,
+		why,
+		verdict: status.verdict,
+		indexing: status.indexing,
+		status: live.first.status,
+		redirects: live.hops.length ? live.hops.map((hop) => `${hop.status} ${hop.kind}`).join(" > ") : null,
+		redirects_to: live.first.redirects_to,
+		final_url: live.last?.url ?? null,
+		final_status: live.last?.status ?? null,
+		page_canonical: live.last?.canonical ?? null,
+		user_canonical: status.user_canonical,
+		google_canonical: status.google_canonical,
+		in_sitemap: e.inSitemap,
+		referring_urls: status.referring_urls.slice(0, REFERRING_KEPT),
+		last_crawl: status.last_crawl,
+		inspected_at: inspectedAt,
+		page_fetch: status.page_fetch,
+		robots_txt: status.robots_txt,
+		crawled_as: status.crawled_as,
+		sources,
+		...live.first.error ? { live_error: live.first.error } : {}
+	};
+}
+const byText = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+function sortRows(rows) {
+	return [...rows].sort((a, b) => byText(a.reason, b.reason) || byText(a.url, b.url));
+}
+function byReason(rows) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		const counts = groups.get(row.reason) ?? {
+			fix: 0,
+			check: 0,
+			expected: 0,
+			indexed: 0
+		};
+		counts[row.label] += 1;
+		groups.set(row.reason, counts);
+	}
+	return [...groups].sort((a, b) => byText(a[0], b[0])).map(([reason, counts]) => ({
+		reason,
+		urls: counts.fix + counts.check + counts.expected + counts.indexed,
+		...counts
+	}));
+}
+const isCode = (error, codes) => codes.includes(String(error?.code));
+function knownUrls(input) {
+	const found = /* @__PURE__ */ new Map();
+	const add = (url, source) => {
+		const sources = found.get(url) ?? [];
+		if (!sources.includes(source)) sources.push(source);
+		found.set(url, sources);
+	};
+	const pages = input.pages.filter((page) => page.impressions > 0 && !page.url.includes("#")).sort((a, b) => b.clicks - a.clicks || b.impressions - a.impressions || byText(a.url, b.url));
+	for (const url of input.lost) add(url, "lost_clicks");
+	for (const page of pages) add(page.url, "search_console");
+	for (const url of input.sitemap.urls) add(url, "sitemap");
+	if (input.home) add(input.home, "home");
+	return {
+		urls: [...found].map(([url, sources]) => ({
+			url,
+			sources
+		})),
+		sitemap: input.sitemap,
+		searchConsole: pages.length,
+		searchConsoleCapped: input.pagesCapped,
+		lostClicks: input.lost.length
+	};
+}
+async function inspectKnown(site, known, deps, asked = 100) {
+	const cap = Math.min(Math.max(1, Math.floor(asked)), MAX_INSPECT_LIMIT);
+	const wanted = known.urls.slice(0, cap);
+	let saved = /* @__PURE__ */ new Map();
+	try {
+		saved = deps.savedInspections?.read(site, wanted.map((item) => item.url)) ?? saved;
+	} catch {}
+	const missing = wanted.filter((item) => !saved.has(item.url));
+	const quota = deps.inspectionQuota ? await deps.inspectionQuota(site).catch(() => null) : null;
+	const left = quota ? Math.max(0, quota.limit - quota.used) : missing.length;
+	const asking = new Set(missing.slice(0, left).map((item) => item.url));
+	const queue = wanted.filter((item) => saved.has(item.url) || asking.has(item.url));
+	const quotaShort = left < missing.length;
+	const statuses = /* @__PURE__ */ new Map();
+	const rows = [];
+	const failed = [];
+	const sitemap = new Set(known.sitemap.urls);
+	const now = () => (deps.now?.() ?? /* @__PURE__ */ new Date()).toISOString();
+	let quotaStop = false;
+	let next = 0;
+	let fatal = null;
+	const worker = async () => {
+		while (fatal === null && next < queue.length) {
+			const item = queue[next++];
+			const stored = saved.get(item.url);
+			let status;
+			let inspectedAt;
+			if (stored) {
+				status = stored.status;
+				inspectedAt = stored.inspectedAt;
+			} else {
+				if (quotaStop) continue;
+				try {
+					status = await deps.inspect(site, item.url);
+					inspectedAt = now();
+				} catch (error) {
+					if (isCode(error, ["RATE_LIMITED"])) quotaStop = true;
+					else if (isCode(error, [
+						"AUTH_EXPIRED",
+						"AUTH_REQUIRED",
+						"NOT_CONNECTED"
+					])) fatal = error;
+					else failed.push({
+						url: item.url,
+						error: error instanceof Error ? error.message : String(error)
+					});
+					continue;
+				}
+				try {
+					deps.savedInspections?.save(site, item.url, status);
+				} catch {}
+			}
+			statuses.set(item.url, status);
+			const live = await deps.liveCheck(item.url);
+			rows.push(indexingRow({
+				url: item.url,
+				status,
+				live,
+				inSitemap: item.sources.includes("sitemap"),
+				sitemap
+			}, item.sources, inspectedAt));
+		}
+	};
+	await Promise.all(Array.from({ length: CONCURRENCY }, worker));
+	if (fatal !== null) throw fatal;
+	const reused = rows.filter((row) => saved.has(row.url));
+	const oldest = reused.reduce((first, row) => first === null || row.inspected_at < first ? row.inspected_at : first, null);
+	return {
+		rows: sortRows(rows),
+		statuses,
+		known,
+		limit: cap,
+		inspected: rows.length,
+		fromSaved: reused.length,
+		oldestSaved: oldest,
+		failed: failed.sort((a, b) => byText(a.url, b.url)),
+		stoppedBy: quotaStop || quotaShort ? "quota" : known.urls.length > wanted.length ? "limit" : null,
+		quota
+	};
+}
+const n = (value) => value.toLocaleString("en-US");
+function liveCell(row) {
+	if (row.live_error) return `error: ${row.live_error}`;
+	if (!row.redirects) return String(row.status ?? "");
+	return `${row.redirects.replace(/ (permanent|temporary)/g, "")} > ${row.final_status ?? "loop"}`;
+}
+function indexingText(site, run, page, origin, askMore, now) {
+	const { known } = run;
+	const total = known.urls.length;
+	const notInspected = total - run.inspected - run.failed.length;
+	const sources = [
+		`lost-click pages ${n(known.lostClicks)}`,
+		`Search Console pages with impressions in the last 28 days ${n(known.searchConsole)}${known.searchConsoleCapped ? ", capped" : ""}`,
+		`sitemap ${n(known.sitemap.urls.length)} from ${plural(known.sitemap.files, "file")}${known.sitemap.partial ? ", partial" : ""}`
+	];
+	const lowerBound = known.sitemap.partial || known.searchConsoleCapped ? " at least" : "";
+	const asked = run.inspected - run.fromSaved;
+	const most = Math.min(total, MAX_INSPECT_LIMIT, run.quota ? run.inspected + run.quota.limit - run.quota.used - asked : MAX_INSPECT_LIMIT);
+	const days = run.oldestSaved ? Math.floor((now.getTime() - Date.parse(run.oldestSaved)) / 864e5) : 0;
+	const savedNote = run.fromSaved ? ` (${n(asked)} asked of Google now, ${n(run.fromSaved)} from saved results; the oldest was inspected ${run.oldestSaved?.slice(0, 16).replace("T", " ")} UTC, ${days === 0 ? "under a day" : plural(days, "day")} ago. Saved results are reused for 7 days)` : "";
+	const stop = run.stoppedBy === "quota" ? "The URL Inspection quota stopped it." : run.stoppedBy === "limit" ? `It stopped at ${n(run.limit)}, the number of inspections for this run${askMore && most > run.limit ? `; to inspect more, up to the quota left today: ${askMore(most)}` : ""}.` : "Every known URL has a result.";
+	const lines = [
+		`Google's indexing reasons for ${site}, from URL Inspection. Search Console's Page indexing report has no API, so known URLs are inspected one at a time, in a fixed order (lost-click pages, Search Console pages by clicks then impressions, sitemap URLs, then the rest), and checked live from here.`,
+		`Known URLs:${lowerBound} ${n(total)} (${sources.join("; ")}). Inspected ${n(run.inspected)} of ${n(total)}${savedNote}. ${stop}${notInspected > 0 ? ` The ${n(notInspected)} URLs not inspected have no result here, so this is not an all-clear for them.` : ""}${known.sitemap.notes.length ? ` Sitemap: ${known.sitemap.notes.join("; ")}.` : ""}`,
+		run.quota ? `URL Inspection quota: this machine had used ${n(run.quota.used)} of ${n(run.quota.limit)} today for this property before the run. Google also counts inspections from other tools.` : "URL Inspection quota: not counted on this server; Google stops inspections at 2,000 a day per property."
+	];
+	if (run.failed.length) lines.push(`URL Inspection failed for ${plural(run.failed.length, "URL")}: ${run.failed.slice(0, 5).map((item) => `${item.url} (${item.error})`).join("; ")}${run.failed.length > 5 ? "; and more" : ""}.`);
+	const groups = byReason(run.rows);
+	if (groups.length) lines.push(`By Google's reason, with labels from the rules below (not Google's):\n${table(groups, [
+		"reason",
+		"urls",
+		"fix",
+		"check",
+		"expected",
+		"indexed"
+	], null)}`);
+	const listed = run.rows.filter((row) => row.label !== "indexed");
+	const shown = page.summary ? listed.filter((row) => row.label === "fix" || row.label === "check") : listed;
+	const indexedCount = run.rows.length - listed.length;
+	const expectedCount = listed.length - shown.length;
+	const pageRows = shown.slice(page.offset, page.offset + page.size).map((row) => ({
+		reason: row.reason,
+		label: row.label,
+		url: row.url,
+		live: liveCell(row),
+		final_url: row.final_url === row.url ? "" : row.final_url,
+		in_sitemap: row.in_sitemap ? "yes" : "no",
+		last_crawl: row.last_crawl?.slice(0, 10) ?? "",
+		why: row.why
+	}));
+	const end = page.offset + pageRows.length;
+	const more = shown.length - end;
+	const others = page.summary ? [
+		more ? `${more} more labelled fix or check` : null,
+		expectedCount ? `${expectedCount} expected` : null,
+		indexedCount ? `${indexedCount} indexed with no fault found (in the full result)` : null
+	].filter(Boolean) : [];
+	if (page.summary && (more || expectedCount)) others.push(`every row but the indexed ones: ${page.more(0)}`);
+	lines.push(`${shown.length === 0 ? `No inspected URL is labelled ${page.summary ? "fix or check" : "fix, check or expected"}.` : `${page.summary ? "URLs labelled fix or check" : "URLs that are not indexed or show a fault"}, ${page.offset + 1} to ${end} of ${shown.length}:\n${table(pageRows, Object.keys(pageRows[0] ?? {}), origin, 400)}`}${others.length ? `\nNot listed here: ${others.join("; ")}.` : ""}`, `Labels: ${Object.entries(LABELS).map(([label, text]) => `${label}, ${text}`).join("; ")}. Rules: a same-host 302 or 307 is fix; a 404 or 410 that the sitemap or a referring page on this site points to is fix; a sitemap URL that redirects or that Google does not index is fix; a URL outside the sitemap (such as an http:// or host variant) that permanently redirects to a page declaring itself canonical is expected; a 401 with a WWW-Authenticate header is expected, and a 401 or 403 on a sign-in path is expected by heuristic; "Crawled - currently not indexed", "Discovered - currently not indexed" and a Google canonical that differs from the declared one are check. Referring pages are as of Google's last crawl. Live checks are server responses, so a browser-only HSTS "307 Internal Redirect" never shows here.`);
+	if (!page.summary && more) lines.push(`More rows: ${page.more(end)}.`);
+	return lines;
+}
 //#endregion
 //#region packages/core/dist/commands/internal-links.js
 const SUMMARY_ROWS = 10;
@@ -40897,8 +41369,8 @@ function internalLinksText(report, options) {
 //#endregion
 //#region packages/core/dist/commands/page-facts.js
 const MAX_PAGES = 20;
-const TIMEOUT_MS = 6e3;
-const MAX_BYTES = 1e6;
+const TIMEOUT_MS$2 = 6e3;
+const MAX_BYTES$2 = 1e6;
 const clean = (value) => value?.trim().replace(/\s+/g, " ") || null;
 async function boundedText(response) {
 	if (!response.body) return "";
@@ -40906,7 +41378,7 @@ async function boundedText(response) {
 	const decoder = new TextDecoder();
 	let text = "";
 	let total = 0;
-	while (total < MAX_BYTES) {
+	while (total < MAX_BYTES$2) {
 		const { done, value } = await reader.read();
 		if (done) return text + decoder.decode();
 		total += value.byteLength;
@@ -40986,12 +41458,14 @@ async function facts(url) {
 				"user-agent": SEO_CRAWLER_USER_AGENT,
 				accept: "text/html"
 			},
-			signal: AbortSignal.timeout(TIMEOUT_MS)
+			signal: AbortSignal.timeout(TIMEOUT_MS$2)
 		});
 		out.status = response.status;
 		const location = response.headers.get("location");
 		if (location) out.redirects_to = new URL(location, url).toString();
 		const headerRobots = response.headers.get("x-robots-tag");
+		const auth = response.headers.get("www-authenticate");
+		if (auth) out.www_authenticate = auth.slice(0, 200);
 		if (response.status !== 200 || !response.headers.get("content-type")?.includes("html")) {
 			out.robots = headerRobots;
 			await response.body?.cancel();
@@ -41008,6 +41482,37 @@ async function facts(url) {
 function checkPages(urls) {
 	return Promise.all(urls.slice(0, MAX_PAGES).map(facts));
 }
+const MAX_HOPS = 5;
+const redirectKind = (status) => status === 301 || status === 308 ? "permanent" : status === 302 || status === 303 || status === 307 ? "temporary" : null;
+async function liveCheck(url) {
+	const first = await facts(url);
+	const hops = [];
+	const seen = /* @__PURE__ */ new Set([url]);
+	let last = first;
+	while (last.redirects_to && last.status !== null) {
+		const kind = redirectKind(last.status);
+		if (!kind) break;
+		const to = last.redirects_to;
+		hops.push({
+			from: last.url,
+			status: last.status,
+			to,
+			kind
+		});
+		if (seen.has(to) || hops.length > MAX_HOPS) return {
+			first,
+			hops,
+			last: null
+		};
+		seen.add(to);
+		last = await facts(to);
+	}
+	return {
+		first,
+		hops,
+		last
+	};
+}
 function temporaryRedirectNote(pages) {
 	const temporary = pages.filter((page) => (page.status === 302 || page.status === 307) && page.redirects_to !== null && new URL(page.redirects_to).host === new URL(page.url).host);
 	if (!temporary.length) return null;
@@ -41602,17 +42107,137 @@ async function runResearch(input, keys, options) {
 	};
 }
 //#endregion
+//#region packages/core/dist/commands/sitemap-urls.js
+const MAX_FILES = 20;
+const MAX_URLS = 5e4;
+const MAX_BYTES$1 = 2e7;
+const TIMEOUT_MS$1 = 1e4;
+async function boundedBytes(body) {
+	if (!body) return /* @__PURE__ */ new Uint8Array();
+	const reader = body.getReader();
+	const chunks = [];
+	let total = 0;
+	while (true) {
+		const { done, value } = await reader.read();
+		if (done) break;
+		total += value.byteLength;
+		if (total > MAX_BYTES$1) {
+			await reader.cancel();
+			return null;
+		}
+		chunks.push(value);
+	}
+	const bytes = new Uint8Array(total);
+	let offset = 0;
+	for (const chunk of chunks) {
+		bytes.set(chunk, offset);
+		offset += chunk.byteLength;
+	}
+	return bytes;
+}
+async function get(url) {
+	const response = await fetch(url, {
+		headers: { "user-agent": SEO_CRAWLER_USER_AGENT },
+		signal: AbortSignal.timeout(TIMEOUT_MS$1)
+	});
+	if (!response.ok) {
+		await response.body?.cancel();
+		throw new Error(`answered ${response.status}`);
+	}
+	let bytes = await boundedBytes(response.body);
+	if (bytes && bytes[0] === 31 && bytes[1] === 139) bytes = await boundedBytes(new Response(bytes).body?.pipeThrough(new DecompressionStream("gzip")) ?? null);
+	if (!bytes) throw new Error(`is larger than ${MAX_BYTES$1} bytes`);
+	return new TextDecoder().decode(bytes);
+}
+const ENTITIES = {
+	amp: "&",
+	lt: "<",
+	gt: ">",
+	quot: "\"",
+	apos: "'"
+};
+function locs(xml) {
+	return [...xml.matchAll(/<loc>\s*(?:<!\[CDATA\[)?([\s\S]*?)(?:\]\]>)?\s*<\/loc>/gi)].map((match) => (match[1] ?? "").trim().replace(/&(amp|lt|gt|quot|apos);/g, (_, name) => ENTITIES[name] ?? ""));
+}
+const inside = (site, url) => {
+	try {
+		return assertUrlMatchesGscProperty(site, url);
+	} catch {
+		return null;
+	}
+};
+async function sitemapUrls(site) {
+	const origin = new URL(originOf(site)).origin;
+	const notes = [];
+	const declared = [...(await get(`${origin}/robots.txt`).catch(() => "")).matchAll(/^\s*sitemap:\s*(\S+)/gim)].map((match) => match[1] ?? "").filter(Boolean);
+	const queue = declared.length ? declared : [`${origin}/sitemap.xml`];
+	const seenFiles = /* @__PURE__ */ new Set();
+	const urls = /* @__PURE__ */ new Set();
+	let files = 0;
+	let partial = false;
+	while (queue.length) {
+		const file = queue.shift();
+		if (seenFiles.has(file)) continue;
+		seenFiles.add(file);
+		if (files >= MAX_FILES) {
+			partial = true;
+			notes.push(`stopped at ${MAX_FILES} sitemap files`);
+			break;
+		}
+		files += 1;
+		let xml;
+		try {
+			xml = await get(file);
+		} catch (error) {
+			if (!declared.length && files === 1) {
+				notes.push(`robots.txt names no sitemap and ${file} ${error instanceof Error ? error.message : "could not be read"}`);
+				continue;
+			}
+			partial = true;
+			notes.push(`${file} ${error instanceof Error ? error.message : "could not be read"}`);
+			continue;
+		}
+		if (/<sitemapindex[\s>]/i.test(xml)) {
+			queue.push(...locs(xml));
+			continue;
+		}
+		for (const loc of locs(xml)) {
+			const url = inside(site, loc);
+			if (!url) continue;
+			if (urls.size >= MAX_URLS) {
+				partial = true;
+				notes.push(`stopped at ${MAX_URLS.toLocaleString("en-US")} URLs`);
+				queue.length = 0;
+				break;
+			}
+			urls.add(url);
+		}
+	}
+	return {
+		urls: [...urls],
+		files,
+		partial,
+		notes: [...new Set(notes)]
+	};
+}
+//#endregion
 //#region packages/core/dist/commands/site.js
 function indexStatusFrom(result) {
 	const status = result?.inspectionResult?.indexStatusResult ?? result?.indexStatusResult ?? {};
 	const text = (value) => typeof value === "string" ? value : null;
+	const list = (value) => Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
 	return {
 		verdict: text(status.verdict),
 		coverage: text(status.coverageState),
 		indexing: text(status.indexingState),
 		last_crawl: text(status.lastCrawlTime),
 		google_canonical: text(status.googleCanonical),
-		user_canonical: text(status.userCanonical)
+		user_canonical: text(status.userCanonical),
+		page_fetch: text(status.pageFetchState),
+		robots_txt: text(status.robotsTxtState),
+		crawled_as: text(status.crawledAs),
+		referring_urls: list(status.referringUrls),
+		sitemaps: list(status.sitemap)
 	};
 }
 async function runPage(input, deps) {
@@ -41633,13 +42258,22 @@ async function runPage(input, deps) {
 		}]
 	});
 	const full = input.detail === "full";
-	const [[facts], indexed, now, then, markdown] = await Promise.all([
-		deps.checkPages([input.url]),
-		deps.inspect(input.site, input.url),
+	const [live, indexed, sitemap, now, then, markdown] = await Promise.all([
+		deps.liveCheck(input.url),
+		deps.inspect(input.site, input.url).catch(() => null),
+		sitemapUrls(input.site),
 		query(range),
 		query(before),
 		full && deps.pageMarkdown ? deps.pageMarkdown(input.url).catch((error) => ({ error: error instanceof Error ? error.message : String(error) })) : null
 	]);
+	const facts = live.first;
+	const reason = indexed ? indexingRow({
+		url: input.url,
+		status: indexed,
+		live,
+		inSitemap: sitemap.urls.includes(input.url),
+		sitemap: new Set(sitemap.urls)
+	}, [], (deps.now?.() ?? /* @__PURE__ */ new Date()).toISOString()) : null;
 	const old = new Map(then.rows.map((row) => [row.keys[0], row]));
 	const seen = /* @__PURE__ */ new Set();
 	const rows = now.rows.map((row) => {
@@ -41677,8 +42311,9 @@ async function runPage(input, deps) {
 			rowsText({
 				title: `${input.url} in ${input.site}, ${range.startDate} to ${range.endDate} against ${before.startDate} to ${before.endDate}.`,
 				notes: [
-					`Live page (fetched now, no redirects followed):\n${facts ? pageFactsTable([facts], null) : "Not fetched."}`,
+					`Live page (fetched now):\n${pageFactsTable([facts], null)}${live.hops.length ? `\nRedirects: ${live.hops.map((hop) => `${hop.status} to ${hop.to}`).join(", ")}${live.last ? `, which returns ${live.last.status ?? live.last.error}` : ", then loop or pass 5 hops"}.` : ""}`,
 					indexed ? `Google index status:\n${table([indexed], Object.keys(indexed), null)}` : "Google index status: not available for this URL.",
+					...reason ? [`Google's reason: ${reason.reason}. Label: ${reason.label}. ${reason.why} (Labels are rules over this evidence, not Google's; ${deps.call("index")} explains them.)`] : [],
 					`Query totals: clicks ${sum(now.rows, "clicks")} (was ${sum(then.rows, "clicks")}), impressions ${sum(now.rows, "impressions")} (was ${sum(then.rows, "impressions")}). Search Console hides rare queries, so these can be lower than the page total.`,
 					deps.pageMarkdown ? `Main content as Markdown: ${deps.call("page", {
 						url: input.url,
@@ -41703,8 +42338,9 @@ async function runPage(input, deps) {
 			url: input.url,
 			range,
 			comparisonRange: before,
-			page: facts ?? null,
+			page: facts,
 			index: indexed,
+			reason,
 			totalQueries: rows.length,
 			queries: rows.slice(offset, offset + 50),
 			...full ? { markdown } : {}
@@ -41759,6 +42395,7 @@ const MIN_LOST = 3;
 const CHECKED = 20;
 const INSPECTED = 10;
 const SITE_WIDE_MIN = 5;
+const PAGE_ROWS = 25e3;
 function indexSummary(inspected, home) {
 	const known = inspected.filter((item) => item?.verdict != null);
 	const indexed = known.filter((item) => item.verdict === "PASS").length;
@@ -41791,6 +42428,7 @@ function indexSummary(inspected, home) {
 	};
 }
 const LOST_PAGES_RULE = `Pages that had at least ${MIN_LOST} clicks in the previous 28 days and kept ${LOST_SHARE * 100}% or less of them in the last 28 days, with a live check of the top ${CHECKED} and Google’s index status for the top ${INSPECTED} and the home page.`;
+const INDEXING_RULE = `Google’s indexing reasons for 100 known URLs a run in a fixed order (lost-click pages, Search Console pages by clicks then impressions, sitemap URLs, then the rest), each checked live and labelled fix, check, expected or indexed from the evidence, sorted by reason then URL.`;
 async function runLostPages(input, deps) {
 	const range = dateWindow(input, 28);
 	const before = earlierRange(range);
@@ -41798,9 +42436,13 @@ async function runLostPages(input, deps) {
 		...window,
 		dimensions: ["page"],
 		type: "web",
-		maxRows: 25e3
+		maxRows: PAGE_ROWS
 	});
-	const [now, then] = await Promise.all([read(range), read(before)]);
+	const [now, then, sitemap] = await Promise.all([
+		read(range),
+		read(before),
+		sitemapUrls(input.site)
+	]);
 	const current = new Map(now.rows.map((row) => [row.keys[0], row.clicks]));
 	const lost = then.rows.filter((row) => row.clicks >= MIN_LOST && !row.keys[0]?.includes("#")).map((row) => ({
 		url: row.keys[0] ?? "",
@@ -41808,48 +42450,107 @@ async function runLostPages(input, deps) {
 		clicks: current.get(row.keys[0]) ?? 0
 	})).filter((row) => row.clicks <= row.previous_clicks * LOST_SHARE).sort((a, b) => b.previous_clicks - b.clicks - (a.previous_clicks - a.clicks) || a.url.localeCompare(b.url));
 	const top = lost.slice(0, CHECKED);
-	const homeUrl = top[0] ? `${new URL(top[0].url).origin}/` : null;
-	const [facts, indexed, homeStatus] = await Promise.all([
-		deps.checkPages(top.map((row) => row.url)),
-		Promise.all(top.slice(0, INSPECTED).map((row) => deps.inspect(input.site, row.url))),
-		homeUrl && !top.slice(0, INSPECTED).some((row) => row.url === homeUrl) ? deps.inspect(input.site, homeUrl).catch(() => null) : null
-	]);
-	const homeIndex = top.slice(0, INSPECTED).findIndex((row) => row.url === homeUrl);
-	const summary = indexSummary(homeIndex >= 0 ? indexed.filter((_, index) => index !== homeIndex) : indexed, homeUrl ? {
+	const first = top[0]?.url ?? sitemap.urls[0] ?? now.rows[0]?.keys[0];
+	const homeUrl = first ? `${new URL(first).origin}/` : null;
+	const known = knownUrls({
+		lost: lost.map((row) => row.url),
+		home: homeUrl,
+		sitemap,
+		pages: now.rows.map((row) => ({
+			url: row.keys[0] ?? "",
+			clicks: row.clicks,
+			impressions: row.impressions
+		})),
+		pagesCapped: now.rows.length >= PAGE_ROWS
+	});
+	const [facts, run] = await Promise.all([deps.checkPages(top.map((row) => row.url)), inspectKnown(input.site, known, deps, input.maxUrls)]);
+	const status = (url) => url ? run.statuses.get(url) ?? null : null;
+	const summary = indexSummary(top.slice(0, INSPECTED).filter((row) => row.url !== homeUrl).map((row) => status(row.url)), top.length && homeUrl ? {
 		url: homeUrl,
-		status: homeIndex >= 0 ? indexed[homeIndex] ?? null : homeStatus
+		status: status(homeUrl)
 	} : null);
-	const rows = top.map((row, index) => ({
-		...row,
-		status: facts[index]?.status ?? null,
-		redirects_to: facts[index]?.redirects_to ?? null,
-		robots: facts[index]?.robots ?? null,
-		canonical: facts[index]?.canonical ?? null,
-		verdict: indexed[index]?.verdict ?? null,
-		coverage: indexed[index]?.coverage ?? null,
-		google_canonical: indexed[index]?.google_canonical ?? null
-	}));
-	return {
-		text: [
-			`Pages that lost their clicks on ${input.site}: ${range.startDate} to ${range.endDate} against ${before.startDate} to ${before.endDate}.`,
-			`${lost.length} pages kept ${LOST_SHARE * 100}% or less of at least ${MIN_LOST} clicks${lost.length > CHECKED ? `; the top ${CHECKED} by clicks lost are shown` : ""}.`,
-			rows.length ? table(rows, Object.keys(rows[0] ?? {}), originOf(input.site)) : "No pages lost their clicks.",
-			summary.text,
-			"Live checks are fetched now with no redirects followed. Index status is from URL Inspection; Google allows about 2,000 inspections a day per property.",
-			temporaryRedirectNote(rows),
-			`Next: ${deps.call("page")} for one URL; ${deps.call("report", {
+	const rows = top.map((row, index) => {
+		const indexed = index < INSPECTED ? status(row.url) : null;
+		return {
+			...row,
+			status: facts[index]?.status ?? null,
+			redirects_to: facts[index]?.redirects_to ?? null,
+			robots: facts[index]?.robots ?? null,
+			canonical: facts[index]?.canonical ?? null,
+			verdict: indexed?.verdict ?? null,
+			coverage: indexed?.coverage ?? null,
+			google_canonical: indexed?.google_canonical ?? null
+		};
+	});
+	const detail = input.detail ?? "summary";
+	const offset = input.offset ?? 0;
+	const origin = originOf(input.site);
+	const firstFix = run.rows.find((row) => row.label === "fix");
+	const reasons = indexingText(input.site, run, {
+		summary: detail === "summary",
+		offset,
+		size: detail === "summary" ? 25 : 50,
+		more: (next) => deps.call("index", {
+			site: input.site,
+			max_urls: input.maxUrls,
+			detail: "rows",
+			offset: next
+		})
+	}, origin, deps.inspectionQuota ? (count) => deps.call("index", {
+		site: input.site,
+		max_urls: count
+	}) : null, deps.now?.() ?? /* @__PURE__ */ new Date());
+	const lostText = [
+		`Pages that lost their clicks on ${input.site}: ${range.startDate} to ${range.endDate} against ${before.startDate} to ${before.endDate}.`,
+		`${lost.length} pages kept ${LOST_SHARE * 100}% or less of at least ${MIN_LOST} clicks${lost.length > CHECKED ? `; the top ${CHECKED} by clicks lost are shown` : ""}.`,
+		rows.length ? table(rows, Object.keys(rows[0] ?? {}), origin) : "No pages lost their clicks.",
+		summary.text,
+		"Live checks are fetched now with no redirects followed. Index status is from URL Inspection.",
+		temporaryRedirectNote(rows)
+	];
+	const indexing = {
+		rule: INDEXING_RULE,
+		known: {
+			total: known.urls.length,
+			sitemap: sitemap.urls.length,
+			sitemapFiles: sitemap.files,
+			sitemapPartial: sitemap.partial,
+			searchConsole: known.searchConsole,
+			searchConsoleCapped: known.searchConsoleCapped,
+			lostClicks: known.lostClicks
+		},
+		limit: run.limit,
+		inspected: run.inspected,
+		fromSaved: run.fromSaved,
+		oldestSaved: run.oldestSaved,
+		failed: run.failed,
+		stoppedBy: run.stoppedBy,
+		quota: run.quota,
+		byReason: byReason(run.rows),
+		rows: run.rows
+	};
+	return {
+		text: [...detail === "full" ? [`Google's indexing reasons for ${input.site}, every inspected URL as JSON, sorted by reason then URL:`, JSON.stringify(indexing)] : [
+			...detail === "summary" ? lostText : [],
+			...reasons,
+			`To see what changed, keep this run's full result (${deps.call("index", {
+				site: input.site,
+				max_urls: input.maxUrls,
+				detail: "full"
+			})}) and compare it with the next run by url and reason. Inspect the same number each week: the order is fixed, so the same first URLs come back. Where results are saved (the CLI and the local MCP), a URL inspected in the last 7 days is reused; any other URL is inspected again and uses URL Inspection quota.`,
+			`Next: ${firstFix ? deps.call("page", { url: firstFix.url }) : deps.call("page")} for one URL, including a URL from a Search Console email that is not in this set; ${deps.call("report", {
 				site: input.site,
 				section: "content-decay"
-			})} for pages that lost part of their clicks.`,
-			FACTS_ONLY
-		].filter(Boolean).join("\n\n"),
+			})} for pages that lost part of their clicks.`
+		], FACTS_ONLY].filter(Boolean).join("\n\n"),
 		data: {
 			range,
 			comparisonRange: before,
 			rule: LOST_PAGES_RULE,
 			lostPages: lost.length,
 			index: summary.data,
-			pages: rows
+			pages: rows,
+			indexing
 		}
 	};
 }
@@ -41992,16 +42693,26 @@ const SHARED_TOOLS = [
 	tool({
 		name: "seo_index",
 		command: "index",
-		title: "Pages that lost their clicks",
-		description: `${LOST_PAGES_RULE} It shows pages that broke, redirect, block indexing or dropped out of Google.`,
+		title: "Google indexing reasons and pages that lost their clicks",
+		description: `${INDEXING_RULE} Use it for a first baseline and then weekly: keep the full result and compare by URL and reason to find new reasons. Also: ${LOST_PAGES_RULE}`,
 		input: z.object({
 			site,
-			...dates
+			...dates,
+			...detail
+		}),
+		localInput: z.object({
+			site,
+			...dates,
+			max_urls: z.number().int().min(1).max(MAX_INSPECT_LIMIT).optional().describe(`URLs to inspect with Google, 100 by default, up to the URL Inspection quota left today.`),
+			...detail
 		}),
 		run: async (surface, input) => runLostPages({
 			site: await surface.resolveSite(input.site),
 			startDate: input.start_date,
-			endDate: input.end_date
+			endDate: input.end_date,
+			detail: input.detail,
+			offset: input.offset,
+			maxUrls: input.max_urls
 		}, surface.deps)
 	}),
 	tool({
@@ -42098,15 +42809,15 @@ const SHARED_TOOLS = [
 		}
 	})
 ];
-async function runSharedTool(tool, surface, input) {
-	const parsed = tool.input.safeParse(input ?? {});
+async function runSharedTool(tool, surface, input, local = false) {
+	const parsed = (local && tool.localInput || tool.input).safeParse(input ?? {});
 	if (!parsed.success) throw new CommandError("INVALID_INPUT", parsed.error.issues.map((issue) => `${issue.path.join(".") || "input"}: ${issue.message}`).join("; "));
 	return tool.run(surface, parsed.data);
 }
 const MCP_INSTRUCTIONS = `SEO Skill reads the person's own Search Console, Google Analytics, Bing Webmaster Tools, Clicky and optional keyword accounts, and returns facts with their dates and limits. It gives no advice.
 1. seo_sites: the properties the connected accounts can read.
 2. seo_report: the main report. Run it without a section first; it shows the overview and every section's count and top rows. Then ask for the one section you need.
-3. seo_page for one URL, seo_compare for before and after a date, seo_index for pages that lost their clicks, seo_research for keyword, competitor and backlink data, and whether AI answers cite the site, from the DataForSEO or Ahrefs key the person saved, seo_data for raw rows, including Google Analytics, Bing and Clicky.`;
+3. seo_page for one URL, seo_compare for before and after a date, seo_index for Google's indexing reasons and pages that lost their clicks, seo_research for keyword, competitor and backlink data, and whether AI answers cite the site, from the DataForSEO or Ahrefs key the person saved, seo_data for raw rows, including Google Analytics, Bing and Clicky.`;
 const mcpCall = (command, args) => {
 	const name = `seo_${command.replace("-", "_")}`;
 	const shown = Object.entries(args ?? {}).filter(([, value]) => value !== void 0);
@@ -42120,6 +42831,36 @@ const SKILL_RESOURCE = {
 	mimeType: "text/markdown"
 };
 //#endregion
+//#region packages/core/dist/gsc/client/inspection-cache.js
+const INSPECTION_FRESH_MS = 7 * 864e5;
+function readSavedInspections(site, urls, now = Date.now()) {
+	const found = /* @__PURE__ */ new Map();
+	try {
+		const statement = cacheDb().prepare(`SELECT status_json, fetched_at FROM url_inspection_cache
+      WHERE site_url = ? AND url = ? AND fetched_at > ?`);
+		for (const url of urls) {
+			const row = statement.get(site, url, now - INSPECTION_FRESH_MS);
+			if (!row) continue;
+			found.set(url, {
+				status: JSON.parse(row.status_json),
+				inspectedAt: new Date(row.fetched_at).toISOString()
+			});
+		}
+	} catch {
+		return /* @__PURE__ */ new Map();
+	}
+	return found;
+}
+function saveInspection(site, url, status, now = Date.now()) {
+	const json = JSON.stringify(status);
+	writeToCache((database) => {
+		database.prepare(`INSERT OR REPLACE INTO url_inspection_cache
+        (site_url, url, status_json, fetched_at, expires_at)
+        VALUES (?, ?, ?, ?, ?)`).run(site, url, json, now, now + INSPECTION_FRESH_MS);
+		noteCacheWrite(Buffer.byteLength(json) + url.length, database);
+	});
+}
+//#endregion
 //#region packages/core/dist/providers/api-key-credentials.js
 function createApiKeyCredentialStore(input) {
 	const normalize = (value) => {
@@ -42299,16 +43040,19 @@ function nodeCommandDeps(options) {
 			accountEmail: options.account
 		}),
 		checkPages,
-		inspect: async (site, url) => {
-			try {
-				return indexStatusFrom(await inspectUrl({
-					siteUrl: site,
-					inspectionUrl: url,
-					accountEmail: options.account
-				}));
-			} catch {
-				return null;
-			}
+		liveCheck,
+		inspect: async (site, url) => indexStatusFrom(await inspectUrl({
+			siteUrl: site,
+			inspectionUrl: url,
+			accountEmail: options.account
+		})),
+		inspectionQuota: (site) => urlInspectionQuota({
+			siteUrl: site,
+			accountEmail: options.account
+		}),
+		savedInspections: {
+			read: (site, urls) => options.refresh ? /* @__PURE__ */ new Map() : readSavedInspections(site, urls),
+			save: saveInspection
 		},
 		pageMarkdown: async (url) => extractMainMarkdown(await fetchPage(url, { refresh: options.refresh })),
 		call: options.call,
@@ -42759,6 +43503,94 @@ var LocalCredentialsProvider = class {
 };
 new LocalCredentialsProvider();
 //#endregion
+//#region packages/core/dist/update-notice.js
+const REGISTRY_URL = "https://registry.npmjs.org/seo/latest";
+const CHECK_EVERY_MS = 864e5;
+const TIMEOUT_MS = 2e3;
+const MAX_BYTES = 65536;
+let checking = false;
+function runByNpx(env, cliPath) {
+	if (env.npm_command === "exec" || /npx/i.test(env.npm_execpath ?? "")) return true;
+	if (!cliPath) return false;
+	let path = cliPath;
+	try {
+		path = realpathSync(cliPath);
+	} catch {}
+	return /[\\/](?:_npx|dlx)[\\/]/.test(path);
+}
+function isNewerVersion(current, latest) {
+	const parse = (value) => value.replace(/^v/, "").split("-")[0]?.split(".").map((part) => Number.parseInt(part, 10)) ?? [];
+	const currentParts = parse(current);
+	const latestParts = parse(latest);
+	for (let index = 0; index < 3; index += 1) {
+		const currentPart = currentParts[index] ?? 0;
+		const latestPart = latestParts[index] ?? 0;
+		if (!Number.isFinite(currentPart) || !Number.isFinite(latestPart)) return false;
+		if (latestPart > currentPart) return true;
+		if (latestPart < currentPart) return false;
+	}
+	return false;
+}
+function isLatestCache(value) {
+	if (!value || typeof value !== "object") return false;
+	const cache = value;
+	return typeof cache.checkedAt === "number" && typeof cache.latest === "string" && /^\d+\.\d+\.\d+$/.test(cache.latest);
+}
+function checkRegistry(cacheFile, now) {
+	if (checking) return;
+	checking = true;
+	const done = () => {
+		checking = false;
+	};
+	const req = request(REGISTRY_URL, { headers: { accept: "application/json" } });
+	const timer = setTimeout(() => req.destroy(), TIMEOUT_MS);
+	timer.unref();
+	req.on("socket", (socket) => socket.unref());
+	req.on("error", () => void 0);
+	req.on("close", () => {
+		clearTimeout(timer);
+		done();
+	});
+	req.on("response", (response) => {
+		const chunks = [];
+		let size = 0;
+		response.on("error", () => void 0);
+		response.on("data", (chunk) => {
+			size += chunk.length;
+			if (size > MAX_BYTES) req.destroy();
+			else chunks.push(chunk);
+		});
+		response.on("end", () => {
+			if (response.statusCode !== 200 || size > MAX_BYTES) return;
+			readJson(new Response(Buffer.concat(chunks)), "The npm registry").then((body) => {
+				const cache = {
+					checkedAt: now,
+					latest: body.version
+				};
+				if (isLatestCache(cache)) writeJsonAtomic(cacheFile, cache, 384);
+			}).catch(() => void 0);
+		});
+	});
+	req.end();
+}
+function updateNotice(options = {}) {
+	try {
+		const env = options.env ?? process.env;
+		const argv = options.argv ?? process.argv;
+		if (env.NO_UPDATE_NOTIFIER || argv.includes("--no-update-notifier") || isTelemetryCi(env)) return;
+		const cacheFile = options.cacheFile ?? join(getSeoCliPaths().cacheDir, "latest-version.json");
+		const now = (options.now ?? /* @__PURE__ */ new Date()).getTime();
+		const stored = readJsonFile(cacheFile);
+		const cache = isLatestCache(stored) ? stored : void 0;
+		if (!cache || now - cache.checkedAt >= CHECK_EVERY_MS) checkRegistry(cacheFile, now);
+		const current = options.version ?? SEO_VERSION;
+		if (!cache || !isNewerVersion(current, cache.latest)) return void 0;
+		return runByNpx(env, options.cliPath ?? argv[1]) ? `seo ${cache.latest} is out (you have ${current}). Run npx -y seo@latest; in an MCP config use seo@latest, then restart the client.` : `seo ${cache.latest} is out (you have ${current}). Update with: npm i -g seo`;
+	} catch {
+		return;
+	}
+}
+//#endregion
 //#region packages/mcp/src/agent-output-budget.ts
 const AGENT_STRUCTURED_OUTPUT_MAX_BYTES = 96 * 1024;
 function jsonBytes(value) {
@@ -45305,7 +46137,7 @@ function text(value) {
 		text: value
 	}] };
 }
-async function counted(command, args, telemetry, run) {
+async function countedRun(command, args, telemetry, run) {
 	const report = telemetry ? telemetryReportFor(command, {
 		section: typeof args.section === "string" ? args.section : void 0,
 		action: typeof args.action === "string" ? args.action : void 0
@@ -45317,10 +46149,22 @@ async function counted(command, args, telemetry, run) {
 		else trackTelemetryReportComplete(report, telemetry());
 		return result;
 	} catch (error) {
-		if (report && telemetry) trackTelemetryReportFailed(report, error, telemetry());
-		return toolError(localError(error));
+		const failure = localError(error);
+		if (report && telemetry) trackTelemetryReportFailed(report, failure, telemetry());
+		return toolError(failure);
 	}
 }
+async function counted(command, args, telemetry, run) {
+	const result = await countedRun(command, args, telemetry, run);
+	const notice = updateNotice();
+	return notice ? {
+		...result,
+		content: [...result.content, {
+			type: "text",
+			text: notice
+		}]
+	} : result;
+}
 function registerSharedTools(server, options = {}) {
 	const surface = {
 		deps: nodeCommandDeps({ call: mcpCall }),
@@ -45335,10 +46179,10 @@ function registerSharedTools(server, options = {}) {
 	for (const shared of SHARED_TOOLS) server.registerTool(shared.name, {
 		title: shared.title,
 		description: shared.description,
-		inputSchema: shared.input.shape,
+		inputSchema: (shared.localInput ?? shared.input).shape,
 		annotations: readOnly
 	}, async (input) => counted(shared.command, input, options.telemetry, async () => {
-		return text((await runSharedTool(shared, surface, input)).text);
+		return text((await runSharedTool(shared, surface, input, true)).text);
 	}));
 	server.registerTool("seo_crawl", {
 		title: "Crawl a site",
@@ -45433,6 +46277,7 @@ async function startMcpServer(opts = {}) {
 	}
 	const transport = new StdioServerTransport();
 	await server.connect(transport);
+	updateNotice();
 }
 //#endregion
 export { AGENT_STRUCTURED_OUTPUT_MAX_BYTES, REPORT_CATEGORIES, compactAgentWorkflowOutput, createServer, describeReport, executeReport, listReports, runReport, startMcpServer };