dsh-desktop-kit 0.0.0-stage → 2.0.0

package/skills/seo/assets/scripts/seo-audit.mjs

@@ -0,0 +1,1675 @@
+#!/usr/bin/env node
+/**
+ * seo-audit.mjs — технический SEO-аудит страницы: meta, canonical/robots, OG/Twitter,
+ * JSON-LD (schema.org), заголовки, изображения, ссылки (битые same-origin), hreflang,
+ * mixed content, вес/ресурсы, Core Web Vitals (LCP/CLS через PerformanceObserver).
+ *
+ * Работает через уже запущенный headless Chrome (CDP, по умолчанию http://127.0.0.1:9333)
+ * и общую инфраструктуру tools/design-qa/lib (fallback-запуск браузера там же).
+ *
+ * Usage:
+ *   node seo-audit.mjs <file|url> [--out dir] [--name] [--json] [--max-links 200]
+ *       [--viewports desktop,mobile] [--serve] [--no-links] [--no-robots] [--cdp url]
+ *
+ * Коды выхода: 0 — нет critical/serious; 2 — есть critical/serious; 1 — сбой инструмента.
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { parseArgs, safeFileName, UsageError, printHelpAndExit } from './lib/args.mjs';
+import {
+  connectChrome,
+  disposeChrome,
+  resolveTarget,
+  startStaticServer,
+  openPage,
+  closePage,
+  waitForFonts,
+  parseViewportList,
+  VIEWPORTS,
+} from './lib/browser.mjs';
+
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+const WORKSPACE = path.resolve(HERE, '..', '..');
+const DEFAULT_OUT = path.join(WORKSPACE, 'tmp', 'qa-artifacts');
+
+const SEVERITY = ['critical', 'serious', 'moderate', 'minor'];
+const SEVERITY_RANK = { critical: 4, serious: 3, moderate: 2, minor: 1 };
+
+const T = {
+  titleMin: 30,
+  titleMax: 65,
+  descMin: 70,
+  descMax: 160,
+  htmlMinor: 150 * 1024,
+  htmlModerate: 600 * 1024,
+  weightMinor: 3 * 1024 * 1024,
+  weightModerate: 6 * 1024 * 1024,
+  lcpSerious: 2500,
+  lcpCritical: 4000,
+  clsModerate: 0.1,
+  clsSerious: 0.25,
+  ttfbModerate: 800,
+  resourcesMinor: 100,
+};
+
+const FIX = {
+  'title-missing': 'Добавить <title> 30–65 символов с ключевым запросом и брендом.',
+  'title-length': 'Сократить/расширить title до 30–65 символов (важное — в начале).',
+  'title-duplicate': 'Оставить ровно один тег <title> в <head>.',
+  'description-missing': 'Добавить <meta name="description"> 70–160 символов: оффер + призыв.',
+  'description-length': 'Привести description к 70–160 символам (без «воды» и повторов).',
+  'description-duplicate': 'Оставить ровно одну meta description.',
+  'h1-missing': 'Добавить один <h1> с главным запросом страницы.',
+  'h1-multiple': 'Оставить ровно один <h1>, остальные понизить до h2.',
+  'h1-empty': 'Заполнить <h1> видимым осмысленным текстом.',
+  'heading-skip': 'Не пропускать уровни заголовков: h1 → h2 → h3.',
+  'lang-missing': 'Указать lang у <html> (для русской страницы lang="ru").',
+  'lang-invalid': 'Использовать корректный код языка: ru, en-US и т.п.',
+  'charset-missing': 'Добавить <meta charset="utf-8"> в первый килобайт <head>.',
+  'viewport-missing': 'Добавить <meta name="viewport" content="width=device-width, initial-scale=1">.',
+  'viewport-width': 'В viewport должно быть width=device-width, initial-scale=1.',
+  'viewport-zoom': 'Не блокировать зум (убрать user-scalable=no / maximum-scale<5).',
+  'canonical-missing': 'Добавить <link rel="canonical" href="абсолютный self-URL">.',
+  'canonical-multiple': 'Оставить ровно один canonical.',
+  'canonical-relative': 'Canonical должен быть абсолютным URL с протоколом и хостом.',
+  'canonical-not-self': 'Canonical должен указывать на саму страницу (без параметров/другого URL).',
+  'robots-noindex': 'Убрать noindex из meta robots / X-Robots-Tag, иначе страница не индексируется.',
+  'robots-nofollow': 'Проверить nofollow: ссылки не будут передавать вес.',
+  'og-missing': 'Добавить Open Graph: og:title, og:description, og:image, og:url, og:type.',
+  'og-image-relative': 'og:image должен быть абсолютным URL (желательно 1200×630).',
+  'og-image-format': 'og:image — JPG/PNG/WebP 1200×630; SVG соцсети не показывают.',
+  'twitter-missing': 'Добавить twitter:card (summary_large_image) и twitter:title/description/image.',
+  'schema-missing': 'Добавить JSON-LD schema.org (MedicalClinic/Organization/BreadcrumbList/FAQPage и т.п.).',
+  'schema-json-invalid': 'Исправить JSON в <script type="application/ld+json">.',
+  'schema-context': 'Указать "@context": "https://schema.org".',
+  'schema-type': 'Указать "@type" (Organization, MedicalClinic, Article, FAQPage…).',
+  'schema-required': 'Заполнить обязательные поля типа schema.org.',
+  'schema-faq': 'В FAQPage: mainEntity[] с Question (name + acceptedAnswer).',
+  'schema-breadcrumb': 'В BreadcrumbList: непустой itemListElement[] с position + name/item.',
+  'img-alt-missing': 'Добавить alt: описательный для смысловых, alt="" для декоративных.',
+  'img-dimensions-missing': 'Указать width/height (или aspect-ratio) — иначе скачет CLS.',
+  'img-lazy-missing': 'Добавить loading="lazy" изображениям ниже первого экрана.',
+  'img-nextgen': 'Крупные PNG/JPEG перевести в WebP/AVIF (или отдавать <picture>).',
+  'link-empty-anchor': 'Дать ссылке видимый текст или aria-label.',
+  'link-hash-placeholder': 'Заменить href="#" на реальный URL или кнопку.',
+  'link-empty-href': 'Убрать ссылки с пустым href.',
+  'link-javascript': 'Заменить javascript: на <button> с обработчиком.',
+  'link-broken': 'Исправить битые ссылки (404/сетевые ошибки).',
+  'link-broken-anchor': 'Исправить якоря: цели с таким id нет на странице.',
+  'link-target-blank': 'Для target="_blank" добавить rel="noopener".',
+  'http-links': 'Заменить http:// на https:// (или относительные ссылки).',
+  'mixed-content': 'Убрать http://-ресурсы на https-странице (mixed content блокируется браузером).',
+  'hreflang-invalid': 'Исправить формат hreflang (ru, en-US, x-default).',
+  'hreflang-relative': 'hreflang-ссылки должны быть абсолютными.',
+  'hreflang-duplicate': 'Убрать дубли hreflang.',
+  'hreflang-self': 'Добавить self-referencing hreflang (включая x-default).',
+  'html-too-big': 'Уменьшить HTML (вынести инлайн-данные, сократить разметку, пагинация).',
+  'render-blocking-css': 'Сократить render-blocking CSS в <head> (critical CSS, defer остальных).',
+  'render-blocking-js': 'Скрипты в <head> — с defer/async (или вынести в конец body).',
+  'resources-many': 'Сократить число запросов: объединить/инлайнить, лениво грузить.',
+  'weight-heavy': 'Снизить вес страницы: сжатие (gzip/brotli), WebP/AVIF, ленивая загрузка.',
+  'no-compression': 'Включить gzip/brotli для HTML.',
+  'lcp-slow': 'Ускорить LCP: preload hero-изображения/шрифта, убрать render-blocking, CDN.',
+  'cls-bad': 'Уменьшить CLS: width/height у медиа, резервировать место под баннеры/шрифты.',
+  'ttfb-slow': 'Ускорить TTFB: кеш страницы, CDN, оптимизация бэкенда.',
+  'long-tasks': 'Разбить длинные JS-задачи (code splitting, defer, web worker).',
+  'redirect-chain': 'Сократить цепочку редиректов до 1.',
+  'http-status': 'Исправить HTTP-статус страницы.',
+  'robots-missing': 'Опубликовать robots.txt со ссылкой на sitemap.',
+  'robots-disallow': 'robots.txt закрывает страницу от индексации — проверить правила.',
+  'sitemap-missing': 'Опубликовать sitemap.xml и указать его в robots.txt.',
+  'sitemap-not-listed': 'Добавить URL страницы в sitemap.xml.',
+  'dom-huge': 'Сократить DOM (>800–1500 элементов) — влияет на интерактивность.',
+  'perf-unavailable': 'Метрики CWV не собрались (проверить в реальном браузере).',
+};
+
+const HELP = `
+seo-audit.mjs — технический SEO-аудит страницы (meta, schema.org, ссылки, CWV).
+
+Использование:
+  node tools/seo-audit/seo-audit.mjs <путь-к-html|url> [опции]
+
+Опции:
+  --out <dir>          Каталог отчётов (по умолчанию tmp/qa-artifacts)
+  --name <name>        Имена файлов <name>-seo-audit.json / <name>-seo-audit.md
+  --viewports <list>   desktop,mobile или 1440x900,390x844 (по умолчанию desktop)
+  --max-links <n>      Сколько same-origin ссылок проверить на битость (по умолчанию 80)
+  --no-links           Не проверять битые ссылки (быстрее)
+  --no-robots          Не запрашивать robots.txt/sitemap.xml
+  --serve              Отдавать локальную страницу по http://127.0.0.1 (для ES-модулей/fetch)
+  --cdp <url>          CDP-эндпоинт (по умолчанию env CDP_URL или http://127.0.0.1:9333)
+  --timeout <ms>       Таймаут загрузки страницы (по умолчанию 30000)
+  --json               Полный JSON в stdout (логи — в stderr)
+  -h, --help           Эта справка
+
+Проверки: title (есть/длина/дубли), description, H1 и порядок заголовков, lang, charset,
+viewport, canonical, robots meta, OG/Twitter, JSON-LD schema.org (валидность и обязательные
+поля для MedicalClinic/MedicalWebPage/Physician/FAQPage/Article/Organization/BreadcrumbList),
+alt и размеры изображений, ленивая загрузка, внутренние/внешние ссылки (пустые анкоры,
+битые same-origin), hreflang, mixed content, http-ссылки, вес HTML/ресурсов, render-blocking,
+LCP/CLS/TTFB через PerformanceObserver, robots.txt и sitemap.xml (для http/https).
+
+Коды выхода: 0 — нет critical/serious; 2 — есть critical/serious; 1 — сбой инструмента.
+`;
+
+// ---------------------------------------------------------------------------
+// In-page: PerformanceObserver для LCP/CLS (ставится до загрузки страницы)
+// ---------------------------------------------------------------------------
+function PERF_OBSERVER() {
+  const store = (window.__seoPerf = { lcp: 0, lcpTime: 0, lcpElement: null, cls: 0, shifts: [], longTasks: 0 });
+  try {
+    new PerformanceObserver((list) => {
+      for (const e of list.getEntries()) {
+        const t = e.renderTime || e.loadTime || 0;
+        if (t > store.lcp) {
+          store.lcp = Math.round(t);
+          store.lcpTime = Math.round(t);
+          store.lcpElement = e.element
+            ? {
+                tag: e.element.tagName || '',
+                id: e.element.id || '',
+                cls:
+                  e.element.className && typeof e.element.className === 'string'
+                    ? e.element.className.slice(0, 120)
+                    : '',
+                url: e.url ? String(e.url).slice(0, 200) : '',
+              }
+            : null;
+        }
+      }
+    }).observe({ type: 'largest-contentful-paint', buffered: true });
+  } catch {
+    /* not supported */
+  }
+  try {
+    new PerformanceObserver((list) => {
+      for (const e of list.getEntries()) {
+        if (e.hadRecentInput) continue;
+        store.cls = Math.round((store.cls + e.value) * 10000) / 10000;
+        if (store.shifts.length < 20) store.shifts.push(Math.round(e.value * 10000) / 10000);
+      }
+    }).observe({ type: 'layout-shift', buffered: true });
+  } catch {
+    /* not supported */
+  }
+  try {
+    new PerformanceObserver((list) => {
+      store.longTasks += list.getEntries().length;
+    }).observe({ type: 'longtask', buffered: true });
+  } catch {
+    /* not supported */
+  }
+}
+
+// ---------------------------------------------------------------------------
+// In-page: сбор SEO-данных
+// ---------------------------------------------------------------------------
+function ANALYZE_DOM() {
+  const doc = document;
+  const q = (sel) => Array.from(doc.querySelectorAll(sel));
+  const attr = (el, n) => (el ? el.getAttribute(n) : null);
+  const norm = (s) => String(s ?? '').replace(/\s+/g, ' ').trim();
+  const clean = (s, n = 200) => {
+    const t = norm(s);
+    return t.length > n ? t.slice(0, n) + '…' : t;
+  };
+  const abs = (u) => {
+    try {
+      return new URL(u, location.href).href;
+    } catch {
+      return u;
+    }
+  };
+
+  const metas = q('meta').map((m) => ({
+    name: (attr(m, 'name') || '').toLowerCase(),
+    property: (attr(m, 'property') || '').toLowerCase(),
+    httpEquiv: (attr(m, 'http-equiv') || '').toLowerCase(),
+    content: attr(m, 'content') || '',
+  }));
+  const titleNodes = q('title');
+  const descriptions = metas.filter((m) => m.name === 'description');
+  const canonicals = q('link[rel~="canonical" i]').map((l) => ({ href: attr(l, 'href'), resolved: l.href }));
+  const robotsMetas = metas
+    .filter((m) => ['robots', 'googlebot', 'yandex', 'msnbot'].includes(m.name))
+    .map((m) => ({ name: m.name, content: m.content }));
+  const viewportMetas = metas.filter((m) => m.name === 'viewport');
+  const charsetMeta =
+    metas.find((m) => m.httpEquiv === 'content-type') || doc.querySelector('meta[charset]')
+      ? true
+      : false;
+
+  const og = {};
+  for (const m of metas) if (m.property.startsWith('og:') && m.content) og[m.property.slice(3)] = m.content;
+  const twitter = {};
+  for (const m of metas) if (m.name.startsWith('twitter:') && m.content) twitter[m.name.slice(8)] = m.content;
+
+  const headings = q('h1,h2,h3,h4,h5,h6').map((h) => ({
+    level: Number(h.tagName[1]),
+    text: clean(h.textContent, 160),
+    id: h.id || null,
+  }));
+  const h1s = headings.filter((h) => h.level === 1);
+
+  const imgRect = (img) => img.getBoundingClientRect();
+  const imgs = q('img')
+    .slice(0, 300)
+    .map((img) => {
+      const r = imgRect(img);
+      const src = (img.currentSrc || img.src || '').slice(0, 400);
+      return {
+        src,
+        alt: attr(img, 'alt'),
+        hasAlt: img.hasAttribute('alt'),
+        width: attr(img, 'width'),
+        height: attr(img, 'height'),
+        loading: (attr(img, 'loading') || '').toLowerCase(),
+        srcset: !!attr(img, 'srcset'),
+        format: src.toLowerCase().split('?')[0].split('.').pop().slice(0, 5),
+        top: Math.round(r.top + window.scrollY),
+        visible: r.width > 0 && r.height > 0,
+      };
+    });
+
+  const anchors = q('a[href]')
+    .slice(0, 500)
+    .map((a) => {
+      const aria = attr(a, 'aria-label');
+      const txt = norm(a.textContent || '');
+      const imgAlt = (a.querySelector('img[alt]')?.getAttribute('alt') || '').trim();
+      const title = (attr(a, 'title') || '').trim();
+      return {
+        href: attr(a, 'href') || '',
+        text: clean(aria || txt || imgAlt || title, 120),
+        rel: (attr(a, 'rel') || '').toLowerCase(),
+        target: (attr(a, 'target') || '').toLowerCase(),
+        hreflang: (attr(a, 'hreflang') || '').toLowerCase(),
+        hasText: !!(aria || txt || imgAlt || title),
+      };
+    });
+  const ids = q('[id]')
+    .map((el) => el.id)
+    .filter(Boolean);
+
+  const scripts = q('script').map((s) => ({
+    src: attr(s, 'src') || '',
+    async: s.async === true,
+    defer: s.defer === true,
+    type: (attr(s, 'type') || '').toLowerCase(),
+    inHead: !!s.closest('head'),
+    inlineLength: s.src ? 0 : (s.textContent || '').length,
+  }));
+  const cssLinks = q('link[rel~="stylesheet" i]').map((l) => ({
+    href: l.href,
+    media: attr(l, 'media') || '',
+    inHead: !!l.closest('head'),
+  }));
+  const preloads = q('link[rel="preload"]').map((l) => ({ as: attr(l, 'as') || '', href: l.href }));
+  const jsonLd = q('script[type="application/ld+json"]')
+    .slice(0, 20)
+    .map((s) => ({ raw: (s.textContent || '').slice(0, 40000) }));
+  const hreflangs = q('link[rel~="alternate" i][hreflang]').map((l) => ({
+    hreflang: (attr(l, 'hreflang') || '').toLowerCase(),
+    href: attr(l, 'href') || '',
+    resolved: l.href,
+  }));
+  const iframes = q('iframe')
+    .slice(0, 20)
+    .map((f) => ({ src: attr(f, 'src') || '', title: attr(f, 'title') || '' }));
+
+  let nav = null;
+  try {
+    const e = performance.getEntriesByType('navigation')[0];
+    if (e) {
+      nav = {
+        ttfb: Math.round(e.responseStart || 0),
+        domContentLoaded: Math.round(e.domContentLoadedEventEnd || 0),
+        load: Math.round(e.loadEventEnd || 0),
+        transferSize: e.transferSize || 0,
+        encodedBodySize: e.encodedBodySize || 0,
+        redirects: e.redirectCount || 0,
+        protocol: e.nextHopProtocol || '',
+      };
+    }
+  } catch {
+    /* ignore */
+  }
+
+  let resources = [];
+  try {
+    resources = performance
+      .getEntriesByType('resource')
+      .slice(0, 500)
+      .map((r) => ({
+        name: String(r.name).slice(0, 500),
+        type: r.initiatorType || 'other',
+        transferSize: r.transferSize || 0,
+        encodedBodySize: r.encodedBodySize || 0,
+        duration: Math.round(r.duration || 0),
+      }));
+  } catch {
+    /* ignore */
+  }
+
+  const mixed = {
+    resources: resources.filter((r) => /^http:\/\//i.test(r.name)).map((r) => r.name.slice(0, 200)),
+    images: imgs.filter((i) => /^http:\/\//i.test(i.src)).map((i) => i.src),
+    scripts: scripts.filter((s) => s.src && /^http:\/\//i.test(s.src)).map((s) => s.src.slice(0, 200)),
+    css: cssLinks.filter((l) => /^http:\/\//i.test(l.href)).map((l) => l.href.slice(0, 200)),
+  };
+  const httpAnchors = anchors.filter((a) => /^http:\/\//i.test(a.href)).slice(0, 20).map((a) => a.href.slice(0, 200));
+
+  return {
+    url: location.href,
+    title: titleNodes.length ? norm(titleNodes[0].textContent) : '',
+    titleCount: titleNodes.length,
+    description: descriptions.length ? norm(descriptions[0].content) : '',
+    descriptionCount: descriptions.length,
+    canonical: canonicals.length ? canonicals[0].resolved || abs(canonicals[0].href || '') : '',
+    canonicalRaw: canonicals.length ? canonicals[0].href : null,
+    canonicalCount: canonicals.length,
+    robotsMetas,
+    viewportMeta: viewportMetas.length ? viewportMetas[0].content : null,
+    viewportCount: viewportMetas.length,
+    charsetMeta,
+    charset: (doc.characterSet || '').toLowerCase(),
+    lang: doc.documentElement.getAttribute('lang'),
+    og,
+    twitter,
+    headings,
+    h1Count: h1s.length,
+    h1Texts: h1s.map((h) => h.text),
+    images: imgs,
+    links: anchors,
+    ids,
+    scripts,
+    cssLinks,
+    preloads,
+    jsonLd,
+    hreflangs,
+    iframes,
+    nav,
+    resources,
+    perf: window.__seoPerf || { lcp: 0, cls: 0, longTasks: 0, shifts: [], lcpElement: null },
+    domElements: doc.getElementsByTagName('*').length,
+    mixed,
+    httpAnchors,
+    metaRobotsFromHttpEquiv: metas.filter((m) => m.httpEquiv === 'x-robots-tag').map((m) => m.content),
+  };
+}
+
+// ===========================================================================
+// main
+// ===========================================================================
+
+async function main() {
+  const startedAt = new Date();
+  const t0 = Date.now();
+  const args = parseArgs(process.argv.slice(2), {
+    booleans: ['help', 'json', 'serve', 'links', 'robots', 'quiet'],
+    values: ['out', 'name', 'max-links', 'cdp', 'timeout', 'viewports'],
+    aliases: { h: 'help' },
+    defaults: {
+      help: false,
+      json: false,
+      serve: false,
+      links: true,
+      robots: true,
+      quiet: false,
+      out: undefined,
+      name: undefined,
+      maxLinks: '80',
+      timeout: '30000',
+      viewports: 'desktop',
+      cdp: undefined,
+    },
+  });
+  if (args.help) printHelpAndExit(HELP);
+  const log = args.json ? (...a) => console.error(...a) : (...a) => console.log(...a);
+
+  const target = args._[0];
+  if (!target) throw new UsageError('Не указан путь к HTML-файлу или URL (см. --help)');
+
+  const viewports = parseViewportList(args.viewports);
+  const maxLinks = Math.max(0, Math.min(400, Number(args.maxLinks) || 80));
+  const timeout = Math.max(1000, Number(args.timeout) || 30000);
+  const resolved = resolveTarget(String(target), { serve: args.serve });
+  const name = safeFileName(args.name || defaultName(resolved), 'page');
+  const outDir = path.resolve(process.cwd(), args.out || DEFAULT_OUT);
+  fs.mkdirSync(outDir, { recursive: true });
+  const files = args.name
+    ? { json: path.join(outDir, `${name}-seo-audit.json`), md: path.join(outDir, `${name}-seo-audit.md`) }
+    : { json: path.join(outDir, 'seo-audit.json'), md: path.join(outDir, 'seo-audit.md') };
+
+  const report = {
+    tool: 'design-qa/seo-audit',
+    schemaVersion: 1,
+    name,
+    source: resolved.source,
+    url: resolved.url,
+    kind: resolved.kind,
+    startedAt: startedAt.toISOString(),
+    finishedAt: null,
+    durationMs: null,
+    browser: null,
+    options: {
+      viewports: viewports.map((v) => ({ id: v.id, width: v.width, height: v.height })),
+      maxLinks,
+      checkLinks: Boolean(args.links),
+      checkRobots: Boolean(args.robots),
+      serve: Boolean(args.serve),
+    },
+    pages: [],
+    meta: null,
+    headings: null,
+    links: null,
+    images: null,
+    schema: null,
+    hreflang: null,
+    performance: null,
+    robots: null,
+    sitemap: null,
+    redirects: null,
+    http: null,
+    issues: [],
+    summary: null,
+    fatalError: null,
+    exitCode: 0,
+  };
+
+  let conn = null;
+  let server = null;
+  let fatal = null;
+
+  log(`[seo] ${resolved.source}`);
+  log(`[seo] viewports: ${viewports.map((v) => `${v.id} ${v.width}x${v.height}`).join(', ')}; max-links: ${maxLinks}`);
+
+  try {
+    conn = await connectChrome({ cdpUrl: args.cdp || undefined, log });
+    report.browser = {
+      endpoint: conn.endpoint,
+      launched: conn.launched,
+      browser: conn.version?.Browser || null,
+    };
+    log(`[seo] браузер: ${report.browser.browser || '?'} (${conn.launched ? 'fallback' : 'CDP ' + conn.endpoint})`);
+
+    if (args.serve) {
+      if (!resolved.abs) throw new UsageError('--serve поддерживается только для локальных html-файлов');
+      server = await startStaticServer(process.cwd());
+      const rel = path.relative(process.cwd(), resolved.abs).split(path.sep).join('/');
+      resolved.url = `${server.origin}/${rel}`;
+      report.url = resolved.url;
+      log(`[seo] локальный сервер: ${server.origin}`);
+    }
+
+    // ---- 1. Загрузка и сбор данных по viewport ----
+    for (const vp of viewports) {
+      log(`[seo] ${vp.id}: загрузка...`);
+      const handle = await openPage(conn.browser, {
+        viewport: vp,
+        dpr: 1,
+        theme: 'light',
+        reducedMotion: 'no-preference',
+      });
+      const page = handle.page;
+      let pageData = null;
+      try {
+        await page.addInitScript(PERF_OBSERVER);
+        let response = null;
+        try {
+          response = await page.goto(resolved.url, { waitUntil: 'load', timeout });
+        } catch (e) {
+          throw new Error(`Не удалось загрузить страницу: ${e.message}`);
+        }
+        await page.waitForLoadState('networkidle', { timeout: 5000 }).catch(() => {});
+        await waitForFonts(page);
+        await new Promise((r) => setTimeout(r, 1500)); // LCP финализируется после load
+        const data = await page.evaluate(ANALYZE_DOM);
+        let htmlBytes = null;
+        let headers = {};
+        if (response) {
+          headers = response.headers();
+          try {
+            htmlBytes = (await response.body()).length;
+          } catch {
+            /* ignore */
+          }
+        }
+        if (htmlBytes == null && resolved.abs) {
+          try {
+            htmlBytes = fs.statSync(resolved.abs).size;
+          } catch {
+            /* ignore */
+          }
+        }
+        const status = response ? response.status() : null;
+        pageData = {
+          viewport: vp.id,
+          width: vp.width,
+          height: vp.height,
+          finalUrl: page.url(),
+          status,
+          headers,
+          htmlBytes,
+          ...data,
+        };
+        report.pages.push(pageData);
+        log(
+          `[seo] ${vp.id}: status=${status ?? 'file'}, title=${JSON.stringify(pageData.title.slice(0, 60))}, ` +
+            `h1=${pageData.h1Count}, LCP=${pageData.perf?.lcp || '?'}ms, CLS=${pageData.perf?.cls ?? '?'}`,
+        );
+      } finally {
+        await closePage(handle);
+      }
+    }
+
+    // ---- 2. robots.txt / sitemap.xml (только http/https) ----
+    const first = report.pages[0];
+    const isHttp = /^https?:/i.test(first.finalUrl);
+    if (isHttp && args.robots) {
+      log('[seo] robots.txt / sitemap.xml...');
+      const context = null; // запросы делаем через отдельный контекст Playwright ниже
+      report.robots = await fetchRobots(conn, first.finalUrl, log);
+      report.sitemap = await fetchSitemap(conn, first.finalUrl, report.robots, log);
+    }
+
+    // ---- 3. Битые same-origin ссылки ----
+    if (args.links) {
+      log(`[seo] проверка ссылок (max ${maxLinks})...`);
+      report.links = await checkBrokenLinks(conn, first, { maxLinks, log });
+      log(`[seo] ссылки: проверено ${report.links.checked}, битых ${report.links.broken.length}`);
+    } else {
+      report.links = { checked: 0, broken: [], internal: countLinks(first).internal, external: countLinks(first).external, skipped: true };
+    }
+
+    // ---- 4. Агрегированные сущности и проверки ----
+    report.meta = buildMeta(first, report.pages);
+    report.headings = buildHeadings(first);
+    report.images = buildImages(first);
+    report.schema = validateSchema(first);
+    report.hreflang = buildHreflang(first);
+    report.performance = buildPerformance(report.pages);
+    report.redirects = buildRedirects(report.pages);
+    report.http = buildHttp(first);
+
+    const issues = [];
+    const add = (id, severity, category, help, extra = {}) =>
+      issues.push({ id, severity, category, help: help || FIX[id] || '', fix: FIX[id] || '', ...extra });
+
+    checkMetaTags(first, add);
+    checkHeadings(first, add);
+    checkCanonical(first, report.pages, add);
+    checkRobotsMeta(first, report.pages, add);
+    checkViewport(first, add);
+    checkOpenGraph(first, add);
+    checkSchema(report.schema, first, add);
+    checkImages(report.images, first, add);
+    checkLinks(report.links, first, add);
+    checkHreflang(report.hreflang, first, add);
+    checkHttp(report.http, first, add);
+    checkMixedContent(first, add);
+    checkPerformance(report.performance, add);
+    checkResources(first, report.performance, add);
+    checkRobots(conn, report.robots, report.sitemap, report.pages, add);
+    checkStatusAndRedirects(first, report.redirects, add);
+
+    report.issues = dedupeIssues(issues).sort(compareIssues);
+    const counts = countSeverities(report.issues);
+    report.summary = {
+      counts,
+      verdict: counts.critical + counts.serious > 0 ? 'FAIL' : 'PASS',
+      exitCode: counts.critical + counts.serious > 0 ? 2 : 0,
+      issuesTotal: report.issues.length,
+      metrics: {
+        htmlBytes: first.htmlBytes,
+        requestCount: first.resources.length,
+        transferBytes: report.performance.transferBytes,
+        lcp: report.performance.lcp,
+        cls: report.performance.cls,
+        ttfb: report.performance.ttfb,
+        domElements: first.domElements,
+      },
+    };
+    report.exitCode = report.summary.exitCode;
+  } catch (err) {
+    fatal = err;
+    report.fatalError = `${err?.name || 'Error'}: ${err?.message || err}`;
+    report.exitCode = 1;
+    log(`[seo] ОШИБКА: ${report.fatalError}`);
+  } finally {
+    if (server) await server.close().catch(() => {});
+    if (conn) await disposeChrome(conn);
+  }
+
+  if (!report.pages.length && fatal) {
+    // нечего агрегировать — пишем отчёт с ошибкой
+    report.summary = { counts: { critical: 0, serious: 0, moderate: 0, minor: 0 }, verdict: 'ERROR', exitCode: 1, issuesTotal: 0 };
+  }
+
+  report.finishedAt = new Date().toISOString();
+  report.durationMs = Date.now() - t0;
+
+  const json = JSON.stringify(report, null, 2);
+  fs.writeFileSync(files.json, json, 'utf8');
+  fs.writeFileSync(files.md, renderMarkdown(report), 'utf8');
+
+  log('');
+  if (report.fatalError) {
+    log(`[seo] вердикт: ОШИБКА ИНСТРУМЕНТА — ${report.fatalError}`);
+  } else {
+    const c = report.summary.counts;
+    log(
+      `[seo] вердикт: ${report.summary.verdict}; critical=${c.critical} serious=${c.serious} ` +
+        `moderate=${c.moderate} minor=${c.minor}; LCP=${report.performance?.lcp ?? '?'}ms, CLS=${report.performance?.cls ?? '?'}`,
+    );
+    const top = report.issues.slice(0, 10);
+    if (top.length) {
+      log('[seo] что чинить в первую очередь:');
+      top.forEach((i, n) => log(`  ${n + 1}. [${i.severity}] ${i.id} — ${shorten(i.help, 130)}`));
+    }
+  }
+  log(`[seo] отчёт: ${files.json}`);
+  log(`[seo] сводка: ${files.md}`);
+
+  if (args.json) process.stdout.write(json + '\n');
+  process.exitCode = report.exitCode;
+}
+
+// ===========================================================================
+// Сбор сущностей
+// ===========================================================================
+
+function defaultName(resolved) {
+  if (resolved.abs) return path.basename(resolved.abs, path.extname(resolved.abs));
+  try {
+    const u = new URL(resolved.url);
+    const last = u.pathname.split('/').filter(Boolean).pop() || 'page';
+    return path.basename(last, path.extname(last));
+  } catch {
+    return 'page';
+  }
+}
+
+function countLinks(pageData) {
+  const base = new URL(pageData.finalUrl);
+  let internal = 0;
+  let external = 0;
+  for (const a of pageData.links) {
+    if (!a.href || /^(#|mailto:|tel:|javascript:|data:)/i.test(a.href)) continue;
+    try {
+      const u = new URL(a.href, pageData.finalUrl);
+      if (u.origin === base.origin || u.protocol === 'file:') internal++;
+      else external++;
+    } catch {
+      /* ignore */
+    }
+  }
+  return { internal, external };
+}
+
+function buildMeta(pageData, pages) {
+  return {
+    title: pageData.title,
+    titleLength: pageData.title.length,
+    titleCount: pageData.titleCount,
+    description: pageData.description,
+    descriptionLength: pageData.description.length,
+    descriptionCount: pageData.descriptionCount,
+    canonical: pageData.canonical,
+    canonicalRaw: pageData.canonicalRaw,
+    canonicalCount: pageData.canonicalCount,
+    lang: pageData.lang,
+    charset: pageData.charset,
+    charsetMeta: pageData.charsetMeta,
+    viewport: pageData.viewportMeta,
+    robotsMetas: pageData.robotsMetas,
+    og: pageData.og,
+    twitter: pageData.twitter,
+    finalUrl: pageData.finalUrl,
+    status: pageData.status,
+    htmlBytes: pageData.htmlBytes,
+    contentType: pageData.headers?.['content-type'] || null,
+    xRobotsTag: pageData.headers?.['x-robots-tag'] || null,
+    contentEncoding: pageData.headers?.['content-encoding'] || null,
+    viewportsChecked: pages.map((p) => p.viewport),
+  };
+}
+
+function buildHeadings(pageData) {
+  const headings = pageData.headings;
+  const skips = [];
+  for (let i = 1; i < headings.length; i++) {
+    if (headings[i].level - headings[i - 1].level > 1) {
+      skips.push({ from: headings[i - 1], to: headings[i] });
+    }
+  }
+  return {
+    count: headings.length,
+    h1Count: pageData.h1Count,
+    h1Texts: pageData.h1Texts,
+    order: headings.map((h) => `h${h.level}`),
+    skips,
+    headings: headings.slice(0, 100),
+  };
+}
+
+function buildImages(pageData) {
+  const images = pageData.images || [];
+  const missingAlt = images.filter((i) => !i.hasAlt && i.visible);
+  const missingDimensions = images.filter((i) => i.visible && (!i.width || !i.height) && !i.srcset);
+  const belowFold = images.filter((i) => i.top > 1200);
+  const lazyMissing = belowFold.filter((i) => i.loading !== 'lazy');
+  const largeImages = images.filter((i) => i.visible && ['png', 'jpg', 'jpeg', 'gif'].includes(i.format));
+  return {
+    total: images.length,
+    visible: images.filter((i) => i.visible).length,
+    missingAlt: missingAlt.length,
+    missingAltList: missingAlt.slice(0, 20).map((i) => ({ src: i.src, top: i.top })),
+    missingDimensions: missingDimensions.length,
+    missingDimensionsList: missingDimensions.slice(0, 20).map((i) => ({ src: i.src })),
+    belowFold: belowFold.length,
+    lazyMissing: lazyMissing.length,
+    lazyMissingList: lazyMissing.slice(0, 20).map((i) => ({ src: i.src })),
+    legacyFormats: largeImages.length,
+    formats: [...new Set(images.map((i) => i.format).filter(Boolean))].slice(0, 10),
+  };
+}
+
+function validateSchema(pageData) {
+  const scripts = pageData.jsonLd || [];
+  const result = {
+    found: scripts.length > 0,
+    scripts: scripts.length,
+    nodes: [],
+    parseErrors: [],
+    contextErrors: [],
+    typeErrors: [],
+    missingFields: [],
+    faqIssues: [],
+    breadcrumbIssues: [],
+    types: [],
+  };
+  const rules = {
+    Organization: { required: ['name', 'url'], recommended: ['logo', 'sameAs'] },
+    MedicalOrganization: { required: ['name', 'address'], recommended: ['telephone', 'url'] },
+    MedicalClinic: { required: ['name', 'address'], recommended: ['telephone', 'url', 'openingHours'] },
+    Hospital: { required: ['name', 'address'], recommended: ['telephone', 'url'] },
+    LocalBusiness: { required: ['name', 'address'], recommended: ['telephone', 'url'] },
+    MedicalWebPage: { required: ['name'], recommended: ['url', 'description', 'lastReviewed'] },
+    WebPage: { required: ['name'], recommended: ['url'] },
+    WebSite: { required: ['name', 'url'], recommended: ['potentialAction'] },
+    Physician: { required: ['name'], recommended: ['medicalSpecialty', 'jobTitle', 'url'] },
+    Person: { required: ['name'], recommended: [] },
+    FAQPage: { required: ['mainEntity'], recommended: [] },
+    Article: { required: ['headline', 'author', 'datePublished'], recommended: ['image', 'publisher'] },
+    NewsArticle: { required: ['headline', 'author', 'datePublished'], recommended: ['image', 'publisher'] },
+    BlogPosting: { required: ['headline', 'author', 'datePublished'], recommended: ['image'] },
+    BreadcrumbList: { required: ['itemListElement'], recommended: [] },
+    ItemList: { required: ['itemListElement'], recommended: [] },
+    Product: { required: ['name'], recommended: ['offers', 'image'] },
+  };
+  const flatten = (obj) => {
+    if (!obj || typeof obj !== 'object') return [];
+    if (Array.isArray(obj)) return obj.flatMap(flatten);
+    if (Array.isArray(obj['@graph'])) return obj['@graph'].flatMap(flatten);
+    return [obj];
+  };
+  const hasValue = (v) => (Array.isArray(v) ? v.length > 0 : v !== undefined && v !== null && String(v).trim() !== '');
+
+  for (let si = 0; si < scripts.length; si++) {
+    let parsed;
+    try {
+      parsed = JSON.parse(scripts[si].raw);
+    } catch (e) {
+      result.parseErrors.push({ script: si + 1, message: e.message, raw: scripts[si].raw.slice(0, 200) });
+      continue;
+    }
+    for (const node of flatten(parsed)) {
+      if (!node || typeof node !== 'object') continue;
+      const ctx = node['@context'];
+      if (!ctx || !String(Array.isArray(ctx) ? ctx.join(' ') : ctx).includes('schema.org')) {
+        result.contextErrors.push({ script: si + 1, type: node['@type'] || null });
+      }
+      const types = Array.isArray(node['@type']) ? node['@type'] : node['@type'] ? [node['@type']] : [];
+      if (!types.length) {
+        result.typeErrors.push({ script: si + 1 });
+        continue;
+      }
+      for (const type of types) result.types.push(type);
+      for (const type of types) {
+        const rule = rules[type];
+        if (!rule) continue;
+        for (const field of rule.required) {
+          if (!hasValue(node[field])) {
+            result.missingFields.push({ script: si + 1, type, field, required: true, help: FIX['schema-required'] });
+          }
+        }
+        if (type === 'FAQPage') {
+          const items = Array.isArray(node.mainEntity) ? node.mainEntity : node.mainEntity ? [node.mainEntity] : [];
+          if (!items.length) result.faqIssues.push({ script: si + 1, message: 'mainEntity пустой' });
+          for (const q of items.slice(0, 20)) {
+            const qType = Array.isArray(q['@type']) ? q['@type'][0] : q['@type'];
+            if (!hasValue(q.name)) result.faqIssues.push({ script: si + 1, message: `вопрос без name (${qType || '?'})` });
+            const ans = q.acceptedAnswer;
+            if (!ans || !hasValue(ans.text)) {
+              result.faqIssues.push({ script: si + 1, message: `вопрос «${String(q.name || '?').slice(0, 60)}» без acceptedAnswer.text` });
+            }
+          }
+        }
+        if (type === 'BreadcrumbList') {
+          const items = Array.isArray(node.itemListElement)
+            ? node.itemListElement
+            : node.itemListElement
+              ? [node.itemListElement]
+              : [];
+          if (!items.length) result.breadcrumbIssues.push({ script: si + 1, message: 'itemListElement пустой' });
+          items.slice(0, 20).forEach((it, idx) => {
+            if (!hasValue(it.position)) result.breadcrumbIssues.push({ script: si + 1, message: `ListItem #${idx + 1} без position` });
+            if (!hasValue(it.name) && !hasValue(it.item)) result.breadcrumbIssues.push({ script: si + 1, message: `ListItem #${idx + 1} без name/item` });
+          });
+        }
+      }
+      result.nodes.push({
+        script: si + 1,
+        types,
+        requiredFields: types.flatMap((t) => rules[t]?.required || []),
+        recommendedFields: types.flatMap((t) => rules[t]?.recommended || []),
+        name: node.name || node.headline || null,
+        url: node.url || node['@id'] || null,
+      });
+      if (result.nodes.length >= 50) break;
+    }
+  }
+  return result;
+}
+
+function buildHreflang(pageData) {
+  const entries = pageData.hreflangs || [];
+  const problems = [];
+  const validRe = /^(x-default|[a-z]{2,3}(-[A-Za-z]{2,4})?)$/;
+  const seen = new Map();
+  for (const e of entries) {
+    if (!validRe.test(e.hreflang)) problems.push({ hreflang: e.hreflang, issue: 'invalid-format' });
+    if (!/^https?:/i.test(e.href) && !/^\/|^[^:/]+$/.test(e.href)) problems.push({ hreflang: e.hreflang, issue: 'relative' });
+    if (seen.has(e.hreflang)) problems.push({ hreflang: e.hreflang, issue: 'duplicate' });
+    seen.set(e.hreflang, e);
+  }
+  return {
+    count: entries.length,
+    entries: entries.slice(0, 50),
+    problems,
+    hasXDefault: entries.some((e) => e.hreflang === 'x-default'),
+    htmlLang: pageData.lang,
+  };
+}
+
+function buildPerformance(pages) {
+  let transferBytes = 0;
+  let requestCount = 0;
+  const resourceTypes = {};
+  const topResources = [];
+  for (const p of pages) {
+    for (const r of p.resources || []) {
+      requestCount++;
+      resourceTypes[r.type] = (resourceTypes[r.type] || 0) + 1;
+      const size = r.transferSize || r.encodedBodySize || 0;
+      transferBytes += size;
+      topResources.push({ name: r.name, size, type: r.type });
+    }
+  }
+  // file:// — transferSize часто 0; считаем размеры файлов напрямую
+  for (const p of pages) {
+    if (!/^file:/i.test(p.finalUrl)) continue;
+    for (const r of p.resources || []) {
+      if ((r.transferSize || r.encodedBodySize || 0) !== 0) continue;
+      try {
+        const fsPath = fileURLToPath(new URL(r.name));
+        const size = fs.statSync(fsPath).size;
+        transferBytes += size;
+        const existing = topResources.find((x) => x.name === r.name);
+        if (existing) existing.size = size;
+      } catch {
+        /* ignore */
+      }
+    }
+  }
+  topResources.sort((a, b) => b.size - a.size);
+  const lcp = Math.max(...pages.map((p) => p.perf?.lcp || 0));
+  const cls = Math.max(...pages.map((p) => p.perf?.cls || 0));
+  const lcpPage = pages.find((p) => (p.perf?.lcp || 0) === lcp) || pages[0];
+  const ttfb = Math.max(...pages.map((p) => p.nav?.ttfb || 0));
+  const longTasks = pages.reduce((s, p) => s + (p.perf?.longTasks || 0), 0);
+  const domElements = Math.max(...pages.map((p) => p.domElements || 0));
+  return {
+    lcp,
+    lcpViewport: lcpPage.viewport,
+    lcpElement: lcpPage.perf?.lcpElement || null,
+    cls,
+    clsViewport: pages.find((p) => (p.perf?.cls || 0) === cls)?.viewport || pages[0]?.viewport,
+    shifts: pages.map((p) => ({ viewport: p.viewport, shifts: p.perf?.shifts || [] })),
+    ttfb,
+    longTasks,
+    domElements,
+    requestCount,
+    transferBytes,
+    resourceTypes,
+    topResources: topResources.slice(0, 10),
+    nav: pages.map((p) => ({ viewport: p.viewport, ...(p.nav || {}) })),
+    htmlBytes: pages[0]?.htmlBytes || null,
+  };
+}
+
+function buildRedirects(pages) {
+  const nav = pages[0]?.nav;
+  return {
+    count: nav?.redirects || 0,
+    finalUrl: pages[0]?.finalUrl,
+    status: pages[0]?.status,
+  };
+}
+
+function buildHttp(pageData) {
+  return {
+    status: pageData.status,
+    finalUrl: pageData.finalUrl,
+    contentType: pageData.headers?.['content-type'] || null,
+    contentEncoding: pageData.headers?.['content-encoding'] || null,
+    xRobotsTag: pageData.headers?.['x-robots-tag'] || null,
+    cacheControl: pageData.headers?.['cache-control'] || null,
+    server: pageData.headers?.['server'] || null,
+    httpAnchors: pageData.httpAnchors || [],
+  };
+}
+
+// ===========================================================================
+// Проверки → issues
+// ===========================================================================
+
+function checkMetaTags(p, add) {
+  if (!p.title) add('title-missing', 'critical', 'meta', 'Нет <title> или он пустой', { nodes: [] });
+  else if (p.title.length < T.titleMin || p.title.length > T.titleMax) {
+    add('title-length', 'moderate', 'meta', `Длина title ${p.title.length} симв. (рекомендуется ${T.titleMin}–${T.titleMax})`, {
+      value: p.title,
+    });
+  }
+  if (p.titleCount > 1) add('title-duplicate', 'serious', 'meta', `Тегов <title> на странице: ${p.titleCount}`);
+
+  if (!p.description) add('description-missing', 'serious', 'meta', 'Нет meta description');
+  else if (p.description.length < T.descMin || p.description.length > T.descMax) {
+    add('description-length', 'moderate', 'meta', `Длина description ${p.description.length} симв. (рекомендуется ${T.descMin}–${T.descMax})`, {
+      value: p.description,
+    });
+  }
+  if (p.descriptionCount > 1) add('description-duplicate', 'serious', 'meta', `Meta description на странице: ${p.descriptionCount}`);
+
+  if (!p.lang) add('lang-missing', 'serious', 'meta', 'У <html> нет атрибута lang');
+  else if (!/^[a-zA-Z]{2,3}(-[a-zA-Z0-9]{2,8})*$/.test(p.lang)) add('lang-invalid', 'minor', 'meta', `Некорректный lang="${p.lang}"`);
+
+  if (!p.charsetMeta && !String(p.charset).includes('utf-8')) {
+    add('charset-missing', 'serious', 'meta', 'Нет meta charset и кодировка не UTF-8');
+  }
+}
+
+function checkHeadings(p, add) {
+  if (p.h1Count === 0) add('h1-missing', 'serious', 'headings', 'На странице нет <h1>');
+  else if (p.h1Count > 1) add('h1-multiple', 'serious', 'headings', `H1 на странице: ${p.h1Count}`, { nodes: p.h1Texts });
+  if (p.h1Count === 1 && !String(p.h1Texts[0] || '').trim()) add('h1-empty', 'serious', 'headings', 'Пустой <h1>');
+  const skips = [];
+  for (let i = 1; i < p.headings.length; i++) {
+    if (p.headings[i].level - p.headings[i - 1].level > 1) skips.push(`h${p.headings[i - 1].level} → h${p.headings[i].level}`);
+  }
+  if (skips.length) {
+    add('heading-skip', 'moderate', 'headings', `Пропуск уровней заголовков: ${skips.slice(0, 6).join(', ')}`, { nodes: skips.slice(0, 10) });
+  }
+  if (p.headings.length === 0) add('h1-missing', 'serious', 'headings', 'Заголовков H1–H6 нет вообще');
+}
+
+function checkCanonical(p, pages, add) {
+  if (p.canonicalCount === 0) {
+    add('canonical-missing', 'serious', 'indexing', 'Нет <link rel="canonical">');
+    return;
+  }
+  if (p.canonicalCount > 1) add('canonical-multiple', 'critical', 'indexing', `Canonical-тегов: ${p.canonicalCount}`);
+  if (!p.canonicalRaw) return;
+  const raw = String(p.canonicalRaw);
+  if (!/^(https?:)?\/\//i.test(raw) && !/^https?:/i.test(p.canonical)) {
+    add('canonical-relative', 'serious', 'indexing', `Canonical относительный: ${raw}`);
+    return;
+  }
+  const final = pages[0]?.finalUrl || p.finalUrl;
+  try {
+    const c = new URL(p.canonical);
+    const f = new URL(final);
+    const norm = (u) => `${u.origin}${u.pathname}`.replace(/\/+$/, '');
+    if (c.origin !== f.origin || norm(c) !== norm(f)) {
+      add('canonical-not-self', 'serious', 'indexing', `Canonical указывает не на себя: ${c.href} ≠ ${f.href}`, {
+        canonical: c.href,
+        page: f.href,
+      });
+    }
+  } catch {
+    add('canonical-relative', 'serious', 'indexing', `Canonical не является абсолютным URL: ${p.canonical}`);
+  }
+}
+
+function checkRobotsMeta(p, pages, add) {
+  const all = [
+    ...(p.robotsMetas || []).map((r) => ({ name: r.name, content: String(r.content || '').toLowerCase() })),
+  ];
+  const x = String(p.headers?.['x-robots-tag'] || '').toLowerCase();
+  if (x) all.push({ name: 'x-robots-tag', content: x });
+  const noindex = all.find((r) => r.content.includes('noindex'));
+  if (noindex) {
+    add('robots-noindex', 'critical', 'indexing', `Страница закрыта от индексации (${noindex.name}: noindex)`);
+  }
+  const nofollow = all.find((r) => r.content.includes('nofollow'));
+  if (nofollow) add('robots-nofollow', 'moderate', 'indexing', `nofollow в ${nofollow.name}`);
+  if (!p.robotsMetas?.length) {
+    // отсутствие meta robots — норма; отметим только как info в отчёте
+  }
+}
+
+function checkViewport(p, add) {
+  if (!p.viewportMeta) {
+    add('viewport-missing', 'serious', 'meta', 'Нет meta viewport');
+    return;
+  }
+  const v = String(p.viewportMeta).toLowerCase().replace(/\s+/g, '');
+  if (!v.includes('width=device-width')) add('viewport-width', 'serious', 'meta', `Viewport без width=device-width: ${p.viewportMeta}`);
+  if (v.includes('user-scalable=no') || /maximum-scale=(\d(\.\d+)?)/.test(v) && parseFloat(/maximum-scale=([\d.]+)/.exec(v)?.[1] || '5') < 5) {
+    add('viewport-zoom', 'moderate', 'meta', 'Viewport блокирует масштабирование');
+  }
+}
+
+function checkOpenGraph(p, add) {
+  const og = p.og || {};
+  const required = ['title', 'description', 'image', 'url'];
+  const missing = required.filter((k) => !og[k]);
+  if (!Object.keys(og).length) {
+    add('og-missing', 'moderate', 'social', 'Open Graph тегов нет (og:title/description/image/url)');
+  } else if (missing.length) {
+    add('og-missing', 'moderate', 'social', `Не хватает Open Graph: ${missing.map((k) => 'og:' + k).join(', ')}`, { missing });
+  }
+  if (og.image && !/^https?:\/\//i.test(og.image)) add('og-image-relative', 'moderate', 'social', `og:image не абсолютный: ${og.image}`);
+  if (og.image && /\.svg($|\?)/i.test(og.image)) add('og-image-format', 'moderate', 'social', 'og:image в SVG — соцсети (VK/Telegram/OK) не отображают SVG, нужен JPG/PNG 1200×630');
+  const tw = p.twitter || {};
+  if (!tw.card) add('twitter-missing', 'minor', 'social', 'Нет twitter:card (Twitter/X карточка)');
+}
+
+function checkSchema(schema, pageData, add) {
+  if (!schema.found) {
+    add('schema-missing', 'moderate', 'schema', 'Нет JSON-LD schema.org');
+    return;
+  }
+  for (const e of schema.parseErrors) {
+    add('schema-json-invalid', 'critical', 'schema', `Битый JSON-LD (script #${e.script}): ${e.message}`, { nodes: [e.raw] });
+  }
+  if (schema.contextErrors.length) {
+    add('schema-context', 'serious', 'schema', `Нет/неверный @context schema.org (${schema.contextErrors.length} узлов)`, {
+      nodes: schema.contextErrors.slice(0, 5),
+    });
+  }
+  if (schema.typeErrors.length) {
+    add('schema-type', 'serious', 'schema', `Нет @type у ${schema.typeErrors.length} JSON-LD-узлов`);
+  }
+  const missing = schema.missingFields || [];
+  const criticalTypes = new Set(['MedicalClinic', 'MedicalOrganization', 'Hospital', 'LocalBusiness', 'Article', 'NewsArticle', 'Organization', 'WebSite', 'BreadcrumbList']);
+  const seriousMissing = missing.filter((m) => criticalTypes.has(m.type) && m.required);
+  if (seriousMissing.length) {
+    add('schema-required', 'serious', 'schema', `Не хватает обязательных полей schema.org: ${seriousMissing.slice(0, 8).map((m) => `${m.type}.${m.field}`).join(', ')}`, {
+      nodes: seriousMissing.slice(0, 10),
+    });
+  } else if (missing.length) {
+    add('schema-required', 'moderate', 'schema', `Не хватает полей schema.org: ${missing.slice(0, 8).map((m) => `${m.type}.${m.field}`).join(', ')}`);
+  }
+  if (schema.faqIssues.length) add('schema-faq', 'serious', 'schema', `Проблемы FAQPage: ${schema.faqIssues.slice(0, 4).map((x) => x.message).join('; ')}`);
+  if (schema.breadcrumbIssues.length) add('schema-breadcrumb', 'moderate', 'schema', `Проблемы BreadcrumbList: ${schema.breadcrumbIssues.slice(0, 4).map((x) => x.message).join('; ')}`);
+}
+
+function checkImages(images, p, add) {
+  if (images.missingAlt > 0) {
+    add('img-alt-missing', 'serious', 'images', `Изображений без alt: ${images.missingAlt}`, { nodes: images.missingAltList });
+  }
+  if (images.missingDimensions > 0) {
+    add('img-dimensions-missing', 'moderate', 'images', `Изображений без width/height: ${images.missingDimensions} (риск CLS)`, { nodes: images.missingDimensionsList });
+  }
+  if (images.lazyMissing > 0) {
+    add('img-lazy-missing', 'minor', 'images', `Изображений ниже первого экрана без loading="lazy": ${images.lazyMissing}`, { nodes: images.lazyMissingList.slice(0, 10) });
+  }
+  if (images.legacyFormats > 20) {
+    add('img-nextgen', 'minor', 'images', `Много изображений в png/jpg/gif: ${images.legacyFormats} — рассмотреть WebP/AVIF`);
+  }
+}
+
+function checkLinks(links, p, add) {
+  const data = links || { broken: [], checked: 0 };
+  if (data.broken?.length) {
+    add('link-broken', 'serious', 'links', `Битых same-origin ссылок: ${data.broken.length}`, { nodes: data.broken.slice(0, 20) });
+  }
+  const empty = p.links.filter((a) => !a.hasText);
+  if (empty.length) {
+    add('link-empty-anchor', 'moderate', 'links', `Ссылок без текста/aria-label: ${empty.length}`, {
+      nodes: empty.slice(0, 15).map((a) => ({ href: a.href || '(пусто)', text: a.text || '' })),
+    });
+  }
+  const hashOnly = p.links.filter((a) => a.href === '#');
+  if (hashOnly.length) add('link-hash-placeholder', 'minor', 'links', `Ссылок href="#": ${hashOnly.length}`);
+  const emptyHref = p.links.filter((a) => a.href === '');
+  if (emptyHref.length) add('link-empty-href', 'moderate', 'links', `Ссылок с пустым href: ${emptyHref.length}`);
+  const jsLinks = p.links.filter((a) => /^javascript:/i.test(a.href));
+  if (jsLinks.length) add('link-javascript', 'moderate', 'links', `Ссылок javascript:: ${jsLinks.length}`);
+  const blankNoNoopener = p.links.filter((a) => a.target === '_blank' && !a.rel.includes('noopener'));
+  if (blankNoNoopener.length) add('link-target-blank', 'minor', 'links', `target="_blank" без rel="noopener": ${blankNoNoopener.length}`);
+  // существование целей якорей
+  const ids = new Set(p.ids || []);
+  const brokenAnchors = p.links
+    .filter((a) => a.href.startsWith('#') && a.href.length > 1)
+    .filter((a) => !ids.has(decodeURIComponent(a.href.slice(1))))
+    .map((a) => a.href);
+  if (brokenAnchors.length) add('link-broken-anchor', 'moderate', 'links', `Якорей без цели: ${brokenAnchors.length}`, { nodes: [...new Set(brokenAnchors)].slice(0, 15) });
+  const httpLinks = (p.httpAnchors || []).length;
+  if (httpLinks) add('http-links', 'minor', 'links', `Ссылок на http://: ${httpLinks}`, { nodes: (p.httpAnchors || []).slice(0, 15) });
+}
+
+function checkHreflang(hreflang, p, add) {
+  if (!hreflang.count) return;
+  const invalid = hreflang.problems.filter((x) => x.issue === 'invalid-format').map((x) => x.hreflang);
+  if (invalid.length) add('hreflang-invalid', 'moderate', 'i18n', `Некорректный hreflang: ${invalid.join(', ')}`);
+  const relative = hreflang.problems.filter((x) => x.issue === 'relative');
+  if (relative.length) add('hreflang-relative', 'moderate', 'i18n', `Относительные hreflang-ссылки: ${relative.map((x) => x.hreflang).join(', ')}`);
+  const dup = hreflang.problems.filter((x) => x.issue === 'duplicate');
+  if (dup.length) add('hreflang-duplicate', 'moderate', 'i18n', `Дубли hreflang: ${[...new Set(dup.map((x) => x.hreflang))].join(', ')}`);
+  if (!hreflang.hasXDefault) add('hreflang-self', 'minor', 'i18n', 'Нет hreflang x-default');
+}
+
+function checkHttp(http, p, add) {
+  if (http.status && http.status >= 400) {
+    add('http-status', 'critical', 'http', `HTTP-статус страницы: ${http.status}`);
+  }
+  const isHttpPage = /^https?:/i.test(p.finalUrl || '');
+  const htmlBytes = isHttpPage ? p.htmlBytes || 0 : 0;
+  if (isHttpPage && htmlBytes > 50 * 1024 && !http.contentEncoding) {
+    add('no-compression', 'minor', 'http', `Нет сжатия HTML (content-encoding отсутствует, ${Math.round(htmlBytes / 1024)} КБ)`);
+  }
+}
+
+function checkMixedContent(p, add) {
+  const isHttps = /^https:/i.test(p.finalUrl);
+  if (!isHttps) return;
+  const m = p.mixed || {};
+  const total =
+    (m.resources?.length || 0) +
+    (m.images?.length || 0) +
+    (m.scripts?.length || 0) +
+    (m.css?.length || 0);
+  if (total) {
+    add('mixed-content', 'serious', 'security', `Mixed content (http://-ресурсы на https): ${total}`, { nodes: [...(m.resources || []), ...(m.scripts || []), ...(m.css || [])].slice(0, 20) });
+  }
+}
+
+function checkPerformance(perf, add) {
+  if (!perf) return;
+  if (perf.lcp > 0) {
+    if (perf.lcp > T.lcpCritical) add('lcp-slow', 'critical', 'performance', `LCP ${(perf.lcp / 1000).toFixed(1)} с > 4 c (${perf.lcpViewport}) — плохо`, { metric: 'lcp', value: perf.lcp });
+    else if (perf.lcp > T.lcpSerious) add('lcp-slow', 'serious', 'performance', `LCP ${(perf.lcp / 1000).toFixed(1)} с > 2.5 c (${perf.lcpViewport}) — нужно улучшить`, { metric: 'lcp', value: perf.lcp });
+  } else {
+    add('perf-unavailable', 'minor', 'performance', 'LCP не измерен (PerformanceObserver не дал данных)');
+  }
+  if (perf.cls > 0) {
+    if (perf.cls > T.clsSerious) add('cls-bad', 'serious', 'performance', `CLS ${perf.cls} > 0.25 — плохо`, { metric: 'cls', value: perf.cls });
+    else if (perf.cls > T.clsModerate) add('cls-bad', 'moderate', 'performance', `CLS ${perf.cls} > 0.1 — нужно улучшить`, { metric: 'cls', value: perf.cls });
+  }
+  if (perf.ttfb > 0 && perf.ttfb > T.ttfbModerate) {
+    add('ttfb-slow', perf.ttfb > 1800 ? 'serious' : 'moderate', 'performance', `TTFB ${perf.ttfb} мс > ${T.ttfbModerate} мс`, { metric: 'ttfb', value: perf.ttfb });
+  }
+  if (perf.longTasks > 20) add('long-tasks', 'minor', 'performance', `Длинных JS-задач: ${perf.longTasks}`);
+}
+
+function checkResources(p, perf, add) {
+  const htmlBytes = perf.htmlBytes || 0;
+  if (htmlBytes > T.htmlModerate) add('html-too-big', 'moderate', 'performance', `HTML ${Math.round(htmlBytes / 1024)} КБ > 600 КБ`);
+  else if (htmlBytes > T.htmlMinor) add('html-too-big', 'minor', 'performance', `HTML ${Math.round(htmlBytes / 1024)} КБ > 150 КБ`);
+
+  const headCss = (p.cssLinks || []).filter((l) => l.inHead && (!l.media || l.media === 'all' || l.media === 'screen'));
+  if (headCss.length > 4) add('render-blocking-css', 'minor', 'performance', `Render-blocking CSS в <head>: ${headCss.length}`, { nodes: headCss.map((l) => l.href) });
+  const headBlockingJs = (p.scripts || []).filter((s) => s.inHead && s.src && !s.async && !s.defer);
+  if (headBlockingJs.length) {
+    add('render-blocking-js', 'moderate', 'performance', `Блокирующих скриптов в <head>: ${headBlockingJs.length}`, { nodes: headBlockingJs.map((s) => s.src) });
+  }
+  if (perf.requestCount > T.resourcesMinor) add('resources-many', 'minor', 'performance', `Запросов ресурсов: ${perf.requestCount} > 100`);
+  if (perf.transferBytes > T.weightModerate) add('weight-heavy', 'moderate', 'performance', `Вес страницы ${(perf.transferBytes / 1024 / 1024).toFixed(1)} МБ > 6 МБ`);
+  else if (perf.transferBytes > T.weightMinor) add('weight-heavy', 'minor', 'performance', `Вес страницы ${(perf.transferBytes / 1024 / 1024).toFixed(1)} МБ > 3 МБ`);
+  if (perf.domElements > 1500) add('dom-huge', 'moderate', 'performance', `DOM: ${perf.domElements} элементов > 1500`);
+  else if (perf.domElements > 800) add('dom-huge', 'minor', 'performance', `DOM: ${perf.domElements} элементов > 800`);
+}
+
+function checkRobots(conn, robots, sitemap, pages, add) {
+  if (!robots) return;
+  if (robots.error) {
+    add('robots-missing', 'moderate', 'indexing', `robots.txt недоступен: ${robots.error}`);
+  } else if (robots.status === 404) {
+    add('robots-missing', 'moderate', 'indexing', 'robots.txt не найден (404)');
+  } else if (robots.status && robots.status >= 400) {
+    add('robots-missing', 'moderate', 'indexing', `robots.txt: HTTP ${robots.status}`);
+  }
+  if (robots.disallowAll) {
+    add('robots-disallow', 'critical', 'indexing', 'robots.txt содержит Disallow: / для User-agent: * — сайт закрыт от индексации');
+  }
+  if (sitemap) {
+    if (sitemap.error) add('sitemap-missing', 'moderate', 'indexing', `sitemap.xml недоступен: ${sitemap.error}`);
+    else if (sitemap.status === 404) add('sitemap-missing', 'moderate', 'indexing', 'sitemap.xml не найден (404)');
+    else if (sitemap.status && sitemap.status >= 400) add('sitemap-missing', 'moderate', 'indexing', `sitemap.xml: HTTP ${sitemap.status}`);
+    else if (sitemap.found && sitemap.pageListed === false) {
+      const where = sitemap.isIndex ? ' (в sitemap-index + первом дочернем sitemap)' : '';
+      add('sitemap-not-listed', 'minor', 'indexing', `URL страницы не найден в sitemap${where}; URL в индексе: ${sitemap.urlsCount}`);
+    }
+  }
+}
+
+function checkStatusAndRedirects(p, redirects, add) {
+  if (redirects?.count > 2) add('redirect-chain', 'moderate', 'http', `Цепочка редиректов: ${redirects.count}`);
+}
+
+// ===========================================================================
+// Ссылки: проверка битых same-origin
+// ===========================================================================
+
+async function checkBrokenLinks(conn, pageData, { maxLinks, log }) {
+  const base = new URL(pageData.finalUrl);
+  const { api, close } = await getApi(conn);
+  const seen = new Set();
+  const broken = [];
+  let checked = 0;
+  let skippedExternal = 0;
+  let internal = 0;
+  let external = 0;
+  const isLocal = /^file:/i.test(base.href);
+
+  for (const a of pageData.links || []) {
+    const href = String(a.href || '').trim();
+    if (!href) continue;
+    if (/^(mailto:|tel:|javascript:|data:|blob:|sms:|whatsapp:)/i.test(href)) continue;
+    let abs;
+    try {
+      abs = new URL(href, pageData.finalUrl);
+    } catch {
+      continue;
+    }
+    if (abs.hash && abs.pathname === base.pathname && abs.search === base.search && abs.origin === base.origin) continue;
+    abs.hash = '';
+    const key = abs.href;
+    if (seen.has(key)) continue;
+    seen.add(key);
+
+    if (abs.protocol === 'file:') {
+      internal++;
+      checked++;
+      try {
+        const fsPath = fileURLToPath(abs);
+        if (!fs.existsSync(fsPath)) broken.push({ url: key, anchor: shorten(a.text, 80), error: 'файл не найден' });
+      } catch (e) {
+        broken.push({ url: key, anchor: shorten(a.text, 80), error: e.message });
+      }
+      continue;
+    }
+    if (abs.protocol !== 'http:' && abs.protocol !== 'https:') continue;
+    if (abs.origin === base.origin) internal++;
+    else {
+      external++;
+      skippedExternal++;
+      continue; // внешние не хаммерим
+    }
+    if (checked >= maxLinks) break;
+    checked++;
+    try {
+      let resp = await api.head(abs.href, { timeout: 10000, maxRedirects: 5, ignoreHTTPSErrors: true });
+      let status = resp.status();
+      if (status === 405 || status === 501 || status === 403) {
+        resp = await api.get(abs.href, { timeout: 12000, maxRedirects: 5, ignoreHTTPSErrors: true });
+        status = resp.status();
+      }
+      if (status >= 400) broken.push({ url: key, status, anchor: shorten(a.text, 80) });
+    } catch (e) {
+      broken.push({ url: key, error: String(e.message || e).split('\n')[0].slice(0, 200), anchor: shorten(a.text, 80) });
+    }
+  }
+  if (close) await close.close().catch(() => {});
+  return { checked, broken, internal, external, skippedExternal, maxLinks, localMode: isLocal };
+}
+
+/** APIRequestContext для HTTP-запросов (HEAD/GET robots, sitemap, битые ссылки). */
+async function getApi(conn) {
+  const existing = conn.browser.contexts()[0];
+  if (existing?.request) return { api: existing.request, close: null };
+  const tempCtx = await conn.browser.newContext();
+  return { api: tempCtx.request, close: tempCtx };
+}
+
+// ===========================================================================
+// robots.txt / sitemap.xml
+// ===========================================================================
+
+async function fetchRobots(conn, finalUrl, log) {
+  const origin = new URL(finalUrl).origin;
+  const { api, close } = await getApi(conn);
+  const out = { url: `${origin}/robots.txt`, status: null, found: false, sitemaps: [], disallowAll: false, text: null, error: null };
+  if (!api) return { ...out, error: 'нет APIRequestContext' };
+  try {
+    const resp = await api.get(out.url, { timeout: 10000, maxRedirects: 3, ignoreHTTPSErrors: true });
+    out.status = resp.status();
+    if (resp.status() === 200) {
+      out.found = true;
+      const text = (await resp.text()).slice(0, 50000);
+      out.text = text.slice(0, 20000);
+      out.sitemaps = [...text.matchAll(/^\s*sitemap:\s*(\S+)/gim)].map((m) => m[1]).slice(0, 5);
+      // Disallow: / для User-agent: *
+      let inStar = false;
+      for (const line of text.split(/\r?\n/)) {
+        const l = line.trim();
+        const ua = /^user-agent:\s*(.*)$/i.exec(l);
+        if (ua) inStar = ua[1].trim() === '*';
+        const dis = /^disallow:\s*(.*)$/i.exec(l);
+        if (dis && inStar && dis[1].trim() === '/') out.disallowAll = true;
+      }
+    }
+  } catch (e) {
+    out.error = String(e.message || e).split('\n')[0].slice(0, 200);
+  } finally {
+    if (close) await close.close().catch(() => {});
+  }
+  return out;
+}
+
+async function fetchSitemap(conn, finalUrl, robots, log) {
+  const origin = new URL(finalUrl).origin;
+  const { api, close } = await getApi(conn);
+  const candidates = [...(robots?.sitemaps || []), `${origin}/sitemap.xml`];
+  const out = {
+    url: null,
+    status: null,
+    found: false,
+    urlsCount: 0,
+    pageListed: null,
+    isIndex: false,
+    childUrl: null,
+    error: null,
+  };
+  if (!api) return { ...out, error: 'нет APIRequestContext' };
+  const parseLocs = (text) => [...text.matchAll(/<loc>\s*([^<\s]+)\s*<\/loc>/gi)].map((m) => m[1]);
+  const pagePathOf = (href) => {
+    try {
+      const u = new URL(href);
+      return { origin: u.origin, path: decodeURIComponent(u.pathname).replace(/\/+$/, '') };
+    } catch {
+      return null;
+    }
+  };
+  try {
+    for (const candidate of candidates.slice(0, 2)) {
+      try {
+        const resp = await api.get(candidate, { timeout: 10000, maxRedirects: 3, ignoreHTTPSErrors: true });
+        out.url = candidate;
+        out.status = resp.status();
+        if (resp.status() !== 200) continue;
+        let text = (await resp.text()).slice(0, 2_000_000);
+        const locs = parseLocs(text);
+        out.found = true;
+        const target = pagePathOf(finalUrl);
+        // sitemap-index: внутри лежат дочерние sitemap; забираем первый, чтобы проверить URL
+        if (/<sitemapindex[\s>]/i.test(text) || (locs.length && locs.every((l) => /\.xml(\?|$)/i.test(l)))) {
+          out.isIndex = true;
+          out.urlsCount = locs.length;
+          out.childUrl = locs[0] || null;
+          if (out.childUrl) {
+            try {
+              const child = await api.get(out.childUrl, { timeout: 10000, maxRedirects: 3, ignoreHTTPSErrors: true });
+              if (child.status() === 200) {
+                text = (await child.text()).slice(0, 2_000_000);
+                const childLocs = parseLocs(text);
+                out.urlsCount += childLocs.length;
+                out.pageListed = childLocs.some((loc) => {
+                  const p = pagePathOf(loc);
+                  return p && target && p.origin === target.origin && p.path === target.path;
+                });
+              }
+            } catch {
+              /* дочерний sitemap не проверился — pageListed остаётся null */
+            }
+          }
+        } else {
+          out.pageListed = locs.some((loc) => {
+            const p = pagePathOf(loc);
+            return p && target && p.origin === target.origin && p.path === target.path;
+          });
+          out.urlsCount = locs.length;
+        }
+        break;
+      } catch (e) {
+        out.error = String(e.message || e).split('\n')[0].slice(0, 200);
+      }
+    }
+  } finally {
+    if (close) await close.close().catch(() => {});
+  }
+  return out;
+}
+
+// ===========================================================================
+// Агрегация и отчёт
+// ===========================================================================
+
+function dedupeIssues(issues) {
+  const map = new Map();
+  for (const issue of issues) {
+    const key = `${issue.id}|${issue.help}|${issue.category}`;
+    const prev = map.get(key);
+    if (prev) {
+      prev.nodes = [...(prev.nodes || []), ...(issue.nodes || [])].slice(0, 40);
+      prev.count = (prev.count || 1) + 1;
+      continue;
+    }
+    map.set(key, { ...issue, count: 1 });
+  }
+  return [...map.values()];
+}
+
+function compareIssues(a, b) {
+  const s = (SEVERITY_RANK[b.severity] || 0) - (SEVERITY_RANK[a.severity] || 0);
+  if (s) return s;
+  return String(a.id).localeCompare(String(b.id));
+}
+
+function countSeverities(issues) {
+  const counts = { critical: 0, serious: 0, moderate: 0, minor: 0 };
+  for (const i of issues) counts[SEVERITY.includes(i.severity) ? i.severity : 'moderate']++;
+  return counts;
+}
+
+function shorten(text, n) {
+  const s = String(text ?? '').replace(/\s+/g, ' ').trim();
+  return s.length > n ? s.slice(0, n) + '…' : s;
+}
+
+// ---------------------------------------------------------------------------
+// Markdown
+// ---------------------------------------------------------------------------
+
+function renderMarkdown(report) {
+  const lines = [];
+  const push = (...l) => lines.push(...l);
+  const s = report.summary;
+  push(`# SEO-аудит: ${report.name}`, '');
+  push(`- **Источник:** \`${report.source}\``);
+  push(`- **URL:** ${report.pages[0]?.finalUrl || report.url}`);
+  push(`- **Дата:** ${report.finishedAt} (${((report.durationMs || 0) / 1000).toFixed(1)} c)`);
+  push(`- **Браузер:** ${report.browser?.browser || '—'}${report.browser?.launched ? ' (fallback)' : ' (CDP)'}`);
+  push(`- **Viewports:** ${report.options.viewports.map((v) => `${v.id} ${v.width}×${v.height}`).join(', ')}`);
+  push('');
+
+  if (report.fatalError) {
+    push('## Вердикт: ОШИБКА ИНСТРУМЕНТА', '', '```', report.fatalError, '```', '');
+    return lines.join('\n');
+  }
+
+  const m = s.metrics || {};
+  push(`## Вердикт: ${s.verdict === 'PASS' ? 'PASS ✅' : 'FAIL ❌'}`, '');
+  push(
+    `- critical: **${s.counts.critical}**, serious: **${s.counts.serious}**, moderate: ${s.counts.moderate}, minor: ${s.counts.minor}`,
+    `- LCP: **${m.lcp ? (m.lcp / 1000).toFixed(2) + ' c' : '?'}**; CLS: **${m.cls ?? '?'}**; TTFB: ${m.ttfb ? m.ttfb + ' мс' : '?'}`,
+    `- HTML: ${m.htmlBytes ? Math.round(m.htmlBytes / 1024) + ' КБ' : '?'}; запросов: ${m.requestCount}; вес: ${m.transferBytes ? (m.transferBytes / 1024 / 1024).toFixed(2) + ' МБ' : '?'}; DOM: ${m.domElements} элементов`,
+    `- HTTP-статус: ${report.http?.status ?? 'file'}; код выхода: **${s.exitCode}**`,
+    '',
+  );
+
+  push('## Что чинить в первую очередь', '');
+  const top = report.issues.slice(0, 10);
+  if (!top.length) push('Критичных проблем не найдено.', '');
+  else {
+    top.forEach((i, idx) => {
+      push(`${idx + 1}. **[${i.severity}] ${i.id}** — ${shorten(i.help, 240)}`);
+      if (i.fix) push(`   - *Как исправить:* ${shorten(i.fix, 300)}`);
+      const nodes = (i.nodes || []).slice(0, 3);
+      for (const n of nodes) push(`   - ${typeof n === 'string' ? n : JSON.stringify(n).slice(0, 200)}`);
+    });
+    push('');
+  }
+
+  push('## Сводка по категориям', '', '| категория | critical | serious | moderate | minor |', '|---|---:|---:|---:|---:|');
+  const cats = [...new Set(report.issues.map((i) => i.category))];
+  for (const cat of cats) {
+    const by = (sev) => report.issues.filter((i) => i.category === cat && i.severity === sev).length;
+    push(`| ${cat} | ${by('critical')} | ${by('serious')} | ${by('moderate')} | ${by('minor')} |`);
+  }
+  push('');
+
+  // Meta
+  push('## Meta и индексируемость', '');
+  push('| параметр | значение |', '|---|---|');
+  push(`| title | ${report.meta?.title ? `«${escapeMd(report.meta.title)}» (${report.meta.titleLength} симв.)` : '—'} |`);
+  push(`| description | ${report.meta?.description ? `«${escapeMd(shorten(report.meta.description, 120))}» (${report.meta.descriptionLength} симв.)` : '—'} |`);
+  push(`| canonical | ${report.meta?.canonical ? escapeMd(report.meta.canonical) : '—'} |`);
+  push(`| lang | ${report.meta?.lang || '—'} |`);
+  push(`| viewport | ${report.meta?.viewport ? escapeMd(report.meta.viewport) : '—'} |`);
+  push(`| robots meta | ${report.meta?.robotsMetas?.length ? report.meta.robotsMetas.map((r) => `${r.name}: ${r.content}`).join('; ') : '—'} |`);
+  push(`| X-Robots-Tag | ${report.meta?.xRobotsTag || '—'} |`);
+  push(`| charset | ${report.meta?.charset || '—'} |`);
+  push('');
+
+  // Заголовки
+  push('## Заголовки', '');
+  push(`- H1: **${report.headings?.h1Count}**${report.headings?.h1Texts?.[0] ? ` — «${escapeMd(shorten(report.headings.h1Texts[0], 120))}»` : ''}`);
+  push(`- Всего заголовков: ${report.headings?.count}; порядок: ${(report.headings?.order || []).slice(0, 30).join(' ')}`);
+  if (report.headings?.skips?.length) push(`- Пропуски уровней: ${report.headings.skips.map((x) => `h${x.from.level} → h${x.to.level}`).join(', ')}`);
+  push('');
+
+  // Schema
+  push('## JSON-LD schema.org', '');
+  if (!report.schema?.found) push('JSON-LD не найден.');
+  else {
+    push(`- Скриптов JSON-LD: ${report.schema.scripts}; узлов: ${report.schema.nodes.length}`);
+    push(`- Типы: ${[...new Set(report.schema.types)].join(', ') || '—'}`);
+    for (const e of report.schema.parseErrors || []) push(`- ❌ битый JSON (script #${e.script}): ${escapeMd(e.message)}`);
+    for (const mf of (report.schema.missingFields || []).slice(0, 15)) push(`- не хватает поля ${mf.type}.${mf.field}`);
+    for (const f of (report.schema.faqIssues || []).slice(0, 10)) push(`- FAQPage: ${escapeMd(f.message)}`);
+    for (const b of (report.schema.breadcrumbIssues || []).slice(0, 10)) push(`- BreadcrumbList: ${escapeMd(b.message)}`);
+  }
+  push('');
+
+  // OG
+  push('## Open Graph / Twitter', '');
+  push(`- og: ${Object.keys(report.meta?.og || {}).length ? Object.entries(report.meta.og).map(([k, v]) => `og:${k}=${escapeMd(shorten(v, 80))}`).join('; ') : '—'}`);
+  push(`- twitter: ${Object.keys(report.meta?.twitter || {}).length ? Object.entries(report.meta.twitter).map(([k, v]) => `twitter:${k}=${escapeMd(shorten(v, 60))}`).join('; ') : '—'}`);
+  push('');
+
+  // Изображения
+  push('## Изображения', '');
+  push(`- всего: ${report.images?.total}, видимых: ${report.images?.visible}`);
+  push(`- без alt: ${report.images?.missingAlt}; без width/height: ${report.images?.missingDimensions}; без lazy ниже экрана: ${report.images?.lazyMissing}`);
+  push(`- форматов: ${(report.images?.formats || []).join(', ') || '—'}`);
+  push('');
+
+  // Ссылки
+  push('## Ссылки', '');
+  push(`- проверено same-origin: ${report.links?.checked ?? 0}; внутренних: ${report.links?.internal ?? '?'}, внешних: ${report.links?.external ?? '?'}`);
+  if (report.links?.broken?.length) {
+    push(`- **битых: ${report.links.broken.length}**`);
+    for (const b of report.links.broken.slice(0, 20)) push(`  - ${b.status ? `HTTP ${b.status}` : b.error || 'ошибка'} — ${b.url}${b.anchor ? ` (анкор: «${escapeMd(b.anchor)}»)` : ''}`);
+  } else push('- битых same-origin ссылок не найдено ✅');
+  push('');
+
+  // hreflang
+  push('## hreflang', '');
+  if (!report.hreflang?.count) push('hreflang не задан (для одноязычной страницы — норма).');
+  else {
+    push(`- записей: ${report.hreflang.count}; x-default: ${report.hreflang.hasXDefault ? 'есть' : 'нет'}`);
+    for (const e of report.hreflang.entries.slice(0, 10)) push(`  - ${e.hreflang} → ${e.href}`);
+  }
+  push('');
+
+  // Производительность
+  push('## Производительность и Core Web Vitals', '');
+  push('| метрика | значение |', '|---|---|');
+  push(`| LCP | ${report.performance?.lcp ? report.performance.lcp + ' мс (' + report.performance.lcpViewport + ')' : '—'} |`);
+  push(`| CLS | ${report.performance?.cls ?? '—'} |`);
+  push(`| TTFB | ${report.performance?.ttfb || 0} мс |`);
+  push(`| запросов | ${report.performance?.requestCount} |`);
+  push(`| вес страницы | ${((report.performance?.transferBytes || 0) / 1024 / 1024).toFixed(2)} МБ |`);
+  push(`| DOM | ${report.performance?.domElements} элементов |`);
+  push(`| долгих JS-задач | ${report.performance?.longTasks} |`);
+  push(`| INP | не измеряется в headless (нет пользовательских взаимодействий) — проверять в PageSpeed/поле |`);
+  if (report.performance?.lcpElement) push(`- LCP-элемент: \`${escapeMd(JSON.stringify(report.performance.lcpElement))}\``);
+  if (report.performance?.topResources?.length) {
+    push('', 'Крупнейшие ресурсы:', '');
+    for (const r of report.performance.topResources.slice(0, 8)) push(`- ${(r.size / 1024).toFixed(1)} КБ — ${r.type} \`${escapeMd(shorten(r.name, 150))}\``);
+  }
+  push('');
+
+  // mixed / http
+  push('## Mixed content и http-ссылки', '');
+  push(`- mixed content (http-ресурсы на https): ${(report.issues.find((i) => i.id === 'mixed-content') ? 'есть' : (report.http?.status && /^https/.test(report.pages[0]?.finalUrl || '') ? 'нет' : 'n/a'))}`);
+  push(`- http-ссылок: ${report.issues.find((i) => i.id === 'http-links')?.help || 'нет'}`);
+  push('');
+
+  // robots/sitemap
+  push('## robots.txt и sitemap.xml', '');
+  if (report.robots) {
+    push(`- robots.txt: ${report.robots.error ? 'ошибка: ' + report.robots.error : `HTTP ${report.robots.status}${report.robots.found ? ', найден' : ''}`}${report.robots.disallowAll ? ' (**Disallow: /**)' : ''}`);
+    if (report.robots.sitemaps?.length) push(`- sitemap из robots: ${report.robots.sitemaps.join(', ')}`);
+  } else push('- robots.txt не проверялся (локальный файл или --no-robots)');
+  if (report.sitemap) {
+    const sm = report.sitemap;
+    const smStatus = sm.error ? 'ошибка: ' + sm.error : `HTTP ${sm.status}${sm.found ? `, URL: ${sm.urlsCount}${sm.isIndex ? ' (sitemap-index' + (sm.childUrl ? `, дочерний: ${sm.childUrl}` : '') + ')' : ''}` : ''}`;
+    push(`- sitemap.xml: ${smStatus}`);
+    if (sm.pageListed === false) push('- URL страницы в sitemap не найден');
+    if (sm.pageListed === true) push('- URL страницы есть в sitemap ✅');
+  }
+  push('');
+
+  push('## Все замечания', '');
+  if (!report.issues.length) push('Замечаний нет. ✅');
+  else {
+    push('| severity | id | что не так |', '|---|---|---|');
+    for (const i of report.issues) push(`| ${i.severity} | ${i.id} | ${escapeMd(shorten(i.help, 200))} |`);
+  }
+  push('');
+  push('---', '');
+  push('_Отчёт сгенерирован tools/seo-audit/seo-audit.mjs. Технический SEO, не заменяет аудит контента/семантики._');
+  return lines.join('\n');
+}
+
+function escapeMd(s) {
+  return String(s ?? '').replace(/\|/g, '\\|').replace(/\n/g, ' ');
+}
+
+main().catch((err) => {
+  if (err?.isUsageError) {
+    console.error(`[seo] ${err.message}`);
+    console.error('[seo] подсказка: запустите node tools/seo-audit/seo-audit.mjs --help');
+    process.exitCode = 1;
+    return;
+  }
+  console.error('[seo] НЕОЖИДАННАЯ ОШИБКА:', err);
+  process.exitCode = 1;
+});