humanizer-ru 3.19.0

package/skills/humanizer-ru/scripts/humanizer_metrics/score.py

@@ -0,0 +1,182 @@
+"""Score чистоты: сворачивает детерминированные сигналы в одно число 0-100.
+
+Выше = текст читается живее/человечнее. Это НЕ детектор и НЕ вероятность ИИ:
+просто агрегат уже считаемых метрик (хард-баны, маркеры, ритм, морфология),
+поданный как обратная связь «было/стало». Опирается на пороги, которые уже
+откалиброваны в burstiness/morphology и задокументированы в eval/RESULTS.md.
+
+Пороги штрафов подобраны на eval/corpus (human → высокий score, raw-AI →
+низкий, humanized → между). Калибровочный прогон: см. eval/run_eval.py.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from .burstiness import CV_HUMAN_TARGET
+from .markers import (GENRE_MUTED_BANS, GENRE_MUTED_CATEGORIES,
+                      effective_hard_bans, mute_by_genre)
+from .morphology import NV_TARGET
+from .structure import (
+    LISTICLE_MIN_ITEMS,
+    LISTICLE_SHARE_AI,
+    PARA_CV_AI,
+    PARA_MIN_COUNT,
+)
+
+# Тире — отдельный случай: оно и хард-бан, и штатная русская пунктуация
+# (Википедия, диапазоны, «это —»). Поэтому в score не рубим потолком, а
+# штрафуем по плотности с допуском. Имя берём из HARD_BANS markers.py.
+EM_DASH_NAME = "Длинное тире"
+COPY_PASTE_CATEGORY = "Артефакты копипасты"
+
+# Полосы. Совпадают с порогами вмешательства из SKILL.md.
+BAND_CLEAN = 85   # ≥ — следы ИИ не мешают, не править
+BAND_EDIT = 60    # ≥ — точечная правка; < — полный рерайт
+
+# Доля ЛЮДЕЙ, у которых текст такой длины совсем без банов и без маркеров.
+# Измерено на 14 973 человеческих текстах (Пикабу, M4, AINL), см. eval/.
+#
+# Зачем это здесь. Score мерит расстояние до нуля, а не до человека, и молча
+# внушает, что цель это сто из ста. Человек нулём почти не бывает: на тексте в
+# три сотни слов идеально чистых людей 15%, а не 100%. То есть высшая оценка
+# означает попадание в редкий хвост распределения. Один такой текст неотличим;
+# корпус из тысячи таких текстов отличим тривиально, потому что у людей хвост
+# есть, а у вычищенного корпуса его нет.
+#
+# Штрафовать за чистоту мы не будем: это сломало бы сравнение «было и стало».
+# Вместо этого при нулевом счёте отдаём заметку, чтобы цель читалась как
+# «попади в типичную частоту», а не как «вычисти всё».
+HUMAN_ZERO_SHARE: tuple[tuple[int, float], ...] = ((100, 42.2), (200, 21.0), (400, 15.1))
+STERILE_MIN_WORDS = 100
+
+
+@dataclass
+class ScoreResult:
+    score: int                       # 0-100, выше = чище
+    band: str                        # "чисто" | "правка" | "рерайт"
+    penalties: list[tuple[str, int]]  # (причина, -очки) — это и есть verbose-отчёт
+    notes: list[str] = field(default_factory=list)  # замечания без штрафа
+
+    def as_dict(self) -> dict:
+        return {
+            "score": self.score,
+            "band": self.band,
+            "penalties": [{"reason": r, "points": p} for r, p in self.penalties],
+            "notes": list(self.notes),
+        }
+
+
+def _band(score: float) -> str:
+    if score >= BAND_CLEAN:
+        return "чисто"
+    if score >= BAND_EDIT:
+        return "правка"
+    return "рерайт"
+
+
+def _per100(count: int, words: int) -> float:
+    return (count / words * 100) if words else 0.0
+
+
+def cleanliness_score(report, genre: str | None = None) -> ScoreResult:
+    """Считает score 0-100 из готового Report (см. humanizer_metrics.analyze).
+
+    genre снимает штрафы за маркеры, законные для регистра (научный,
+    юридический, художественный). Без genre режим строгий, как раньше.
+    """
+    words = report.rhythm.words or 1
+    markers = mute_by_genre(report.markers, genre, GENRE_MUTED_CATEGORIES)
+    dash_muted = EM_DASH_NAME in GENRE_MUTED_BANS.get(genre or "", set())
+    penalties: list[tuple[str, int]] = []
+    notes: list[str] = []
+    score = 100.0
+
+    # 1. Фразовые хард-баны (кроме тире). Однозначные AI-обороты: дорого.
+    #    Частотные баны («Является») штрафуются только выше порога плотности.
+    eff_bans = mute_by_genre(
+        effective_hard_bans(report.hard_bans, report.rhythm.words),
+        genre, GENRE_MUTED_BANS)
+    hard_phrase = sum(h.count for h in eff_bans if h.marker != EM_DASH_NAME)
+    if hard_phrase:
+        pen = min(45, 12 * hard_phrase)
+        score -= pen
+        penalties.append((f"хард-баны (фразы): {hard_phrase}", -pen))
+
+    # 2. Артефакты копипасты из чат-бота: текст буквально вставлен из ответа ИИ.
+    copy_paste = sum(h.count for h in markers if h.category == COPY_PASTE_CATEGORY)
+    if copy_paste:
+        pen = 60
+        score -= pen
+        penalties.append((f"артефакты копипасты: {copy_paste}", -pen))
+
+    # 3. Мягкие маркеры (кроме копипасты) по плотности на 100 слов.
+    soft = sum(h.count for h in markers if h.category != COPY_PASTE_CATEGORY)
+    if soft:
+        pen = min(30, round(2 * _per100(soft, words)))
+        if pen:
+            score -= pen
+            penalties.append((f"маркеры: {soft} ({_per100(soft, words):.1f}/100 слов)", -pen))
+
+    # 4. Длинное тире по плотности с допуском ~2 на 100 слов: «—» штатно
+    #    используется в русском (Википедия, «это —», диапазоны). Штраф мягкий,
+    #    потому что на изданной прозе оно частая норма; сам бан держится на
+    #    парном замере (markers.py, комментарий про парный замер).
+    dash_density = 0.0 if dash_muted else _per100(report.rhythm.em_dash, words)
+    if dash_density > 2.0:
+        pen = min(8, round(3 * (dash_density - 2.0)))
+        if pen:
+            score -= pen
+            penalties.append((f"тире: {report.rhythm.em_dash} ({dash_density:.1f}/100 слов)", -pen))
+
+    # 5. Ровный ритм: чем ниже CV относительно цели 0.45, тем больше штраф.
+    cv = report.rhythm.cv_len
+    if report.rhythm.sentences >= 4 and cv < CV_HUMAN_TARGET:
+        pen = min(20, round((CV_HUMAN_TARGET - cv) / CV_HUMAN_TARGET * 30))
+        if pen:
+            score -= pen
+            penalties.append((f"ровный ритм (CV={cv}, цель ≥{CV_HUMAN_TARGET})", -pen))
+
+    # 6. Номинальность: сущ./глаг. выше цели 2.5 = канцелярит. Слабый сигнал и
+    #    главный источник ложных срабатываний (энциклопедический/юр. регистр
+    #    легитимно номинален), поэтому штраф мягкий и низко ограничен.
+    nv = report.morph.noun_verb_ratio
+    if nv > NV_TARGET:
+        pen = min(8, round((nv - NV_TARGET) / 0.5 * 3))
+        if pen:
+            score -= pen
+            penalties.append((f"номинальность (сущ./глаг.={nv}, цель ≤{NV_TARGET})", -pen))
+
+    # 7. Document-level: ровные по длине абзацы (burstiness абзацев). Срабатывает
+    #    только на достаточно многоабзацном тексте, иначе инертно (короткая проза).
+    st = report.structure
+    if st.paragraphs >= PARA_MIN_COUNT and st.para_cv < PARA_CV_AI:
+        pen = min(10, round((PARA_CV_AI - st.para_cv) / PARA_CV_AI * 20))
+        if pen:
+            score -= pen
+            penalties.append((f"ровные абзацы (CV={st.para_cv}, цель ≥{PARA_CV_AI})", -pen))
+
+    # 8. Document-level: listicle-сигнатура (засилье однотипных пунктов). Инертно
+    #    на прозе без списков, бьёт по шаблонным гайдам/постам.
+    if st.list_items >= LISTICLE_MIN_ITEMS and st.listicle_share > LISTICLE_SHARE_AI:
+        pen = min(12, round((st.listicle_share - LISTICLE_SHARE_AI) * 30))
+        if pen:
+            score -= pen
+            penalties.append((f"листикл ({st.list_items} пунктов, {int(st.listicle_share*100)}% строк)", -pen))
+
+    # Заметка о стерильности. Не штраф: цель показать, что ноль это не середина
+    # человеческого распределения, а его редкий край.
+    #
+    # Условие ровно то, что измерялось: ноль банов и ноль маркеров. Ритм,
+    # номинальность и структура сюда не входят, иначе текст с минусом за ровный
+    # ритм терял бы заметку, хотя по лексике он как раз стерилен.
+    if not (hard_phrase or copy_paste or soft) and words >= STERILE_MIN_WORDS:
+        share = next((s for limit, s in HUMAN_ZERO_SHARE if words < limit),
+                     HUMAN_ZERO_SHARE[-1][1])
+        notes.append(
+            f"стерильно: ни одного маркера. Так пишет {share:.0f}% людей на тексте "
+            f"в {words} слов, остальные {100 - share:.0f}% что-нибудь да используют. "
+            "Цель не ноль, а типичная для жанра частота: вычищать дальше незачем")
+
+    final = max(0, min(100, round(score)))
+    return ScoreResult(score=final, band=_band(final), penalties=penalties, notes=notes)

package/skills/humanizer-ru/scripts/humanizer_metrics/structure.py

@@ -0,0 +1,154 @@
+"""Структурные метрики уровня документа: burstiness абзацев и listicle-сигнатура.
+
+Дополняет burstiness.py (там ритм ПРЕДЛОЖЕНИЙ) тем, что детекторы оценивают на
+УРОВНЕ ДОКУМЕНТА: одинаковая длина абзацев и засилье однотипных списков выдают
+шаблонную генерацию, даже когда каждое предложение по отдельности вычищено.
+
+Эти сигналы целят в многосекционный/листикл-текст (посты, гайды). На прозе
+одним блоком они инертны (мало абзацев, нет списков) и в score не вносят штраф,
+поэтому не задевают калибровку основного корпуса.
+"""
+
+from __future__ import annotations
+
+import re
+import statistics
+from dataclasses import dataclass
+
+from razdel import sentenize
+
+from .morphology import _morph
+
+# Строка-пункт списка: маркер «- * •» или «1. / 1)» в начале строки.
+_LIST_RE = re.compile(r"^\s*(?:[-*•]|\d+[.)])\s+\S")
+
+# Заголовок: markdown-решётки либо короткая строка без конечной пунктуации,
+# за которой идёт пустая строка или абзац.
+_HEADING_RE = re.compile(r"^\s*(?:#{1,6}\s+)?(\S.{0,79})$")
+_WORD_RE = re.compile(r"[А-Яа-яЁё][А-Яа-яЁё-]*")
+# Имя собственное капитализируется законно: тег pymorphy3 или незнакомое
+# словарю слово (Стэнфорд, Хогвартс). Считаем только заглавные у нарицательных.
+_PROPER_TAGS = {"Name", "Surn", "Geox", "Orgn", "Patr"}
+# Служебные слова в заголовках пишутся строчными и в английском Title Case,
+# поэтому их регистр ничего не говорит.
+_STOPWORDS = {"и", "в", "на", "с", "к", "по", "для", "из", "о", "об", "а", "но", "или", "у", "за"}
+
+
+@dataclass
+class StructureStats:
+    paragraphs: int          # число непустых абзацев (разделитель — пустая строка)
+    para_mean_sent: float    # средняя длина абзаца в предложениях
+    para_cv: float           # коэффициент вариации длин абзацев (burstiness абзацев)
+    list_items: int          # строк-пунктов списка
+    listicle_share: float    # доля строк-пунктов среди непустых строк
+    title_case_headings: int  # заголовки в английском Title Case (паттерн #56)
+    truncated_ending: bool    # текст оборван на полуслове (паттерн #57)
+
+    def as_dict(self) -> dict:
+        return self.__dict__.copy()
+
+
+def _is_common_noun_capitalized(word: str) -> bool:
+    """Слово с заглавной, которое словарь знает как нарицательное: «Жизнь»,
+    «Образование». Имена собственные и незнакомые словарю слова не в счёт."""
+    if not word[:1].isupper():
+        return False
+    if word.lower() in _STOPWORDS:
+        return False
+    p = _morph().parse(word.lower())[0]
+    if not p.is_known:
+        return False
+    return not (_PROPER_TAGS & set(p.tag.grammemes))
+
+
+def count_title_case_headings(text: str) -> int:
+    """Заголовки, где с заглавной стоит не только первое слово: «Ранняя Жизнь
+    и Образование». В русском так не пишут, это калька с английского."""
+    hits = 0
+    lines = text.splitlines()
+    for i, raw in enumerate(lines):
+        s = raw.strip()
+        if not s:
+            continue
+        is_md_heading = s.startswith("#")
+        # Строка без конечной пунктуации, короткая, за ней пусто: тоже заголовок.
+        looks_like_heading = (
+            len(s) <= 80 and s[-1] not in ".!?:;,"
+            and (i + 1 >= len(lines) or not lines[i + 1].strip())
+            and not _LIST_RE.match(raw)
+        )
+        if not (is_md_heading or looks_like_heading):
+            continue
+        words = _WORD_RE.findall(s)
+        if len(words) < 3:
+            continue  # на двух словах отличить заголовок от имени нельзя
+        if sum(1 for w in words[1:] if _is_common_noun_capitalized(w)) >= 2:
+            hits += 1
+    return hits
+
+
+def is_truncated(text: str) -> bool:
+    """Текст оборван на полуслове: модель упёрлась в лимит токенов, а человек
+    скопировал как есть. Последняя содержательная строка прозы обязана
+    заканчиваться знаком конца предложения."""
+    lines = [ln.rstrip() for ln in text.splitlines() if ln.strip()]
+    if not lines:
+        return False
+    last = lines[-1]
+    if last.startswith("#") or _LIST_RE.match(last) or last.startswith(("|", ">", "```")):
+        return False  # заголовок, пункт списка, таблица: пунктуация не нужна
+    if len(_WORD_RE.findall(last)) < 4:
+        return False  # подпись, дата, короткая пометка
+    return last[-1] not in ".!?…:»)\"'*_"
+
+
+def structure_stats(text: str) -> StructureStats:
+    paras = [p.strip() for p in re.split(r"\n\s*\n", text) if p.strip()]
+    sent_lens = [len(list(sentenize(p))) for p in paras]
+    sent_lens = [n for n in sent_lens if n > 0]
+    n = len(sent_lens)
+
+    mean = statistics.mean(sent_lens) if sent_lens else 0.0
+    stdev = statistics.pstdev(sent_lens) if n > 1 else 0.0
+    cv = (stdev / mean) if mean else 0.0
+
+    lines = [ln for ln in text.splitlines() if ln.strip()]
+    list_items = sum(1 for ln in lines if _LIST_RE.match(ln))
+    share = (list_items / len(lines)) if lines else 0.0
+
+    return StructureStats(
+        paragraphs=n,
+        para_mean_sent=round(mean, 1),
+        para_cv=round(cv, 3),
+        list_items=list_items,
+        listicle_share=round(share, 3),
+        title_case_headings=count_title_case_headings(text),
+        truncated_ending=is_truncated(text),
+    )
+
+
+# Пороги (эвристика, согласована с логикой burstiness.py для предложений).
+# Срабатывают только на достаточно длинном/структурированном тексте, чтобы не
+# штрафовать короткую прозу одним-двумя абзацами.
+PARA_CV_AI = 0.35          # ниже = слишком ровные по длине абзацы
+PARA_MIN_COUNT = 6         # по нескольким коротким абзацам cv ненадёжен (малая
+                           # выборка), судим о ритме абзацев только на длинном тексте
+LISTICLE_SHARE_AI = 0.30   # доля строк-пунктов выше — текст «листиклом»
+LISTICLE_MIN_ITEMS = 6     # и не меньше стольких пунктов (порог шаблонности)
+
+
+def structure_verdict(s: StructureStats) -> str:
+    parts = []
+    if s.paragraphs >= PARA_MIN_COUNT and s.para_cv < PARA_CV_AI:
+        parts.append(f"⚠ ровные абзацы (CV={s.para_cv}, цель ≥{PARA_CV_AI})")
+    else:
+        parts.append(f"✓ абзацы: {s.paragraphs}, CV={s.para_cv}")
+    if s.list_items >= LISTICLE_MIN_ITEMS and s.listicle_share > LISTICLE_SHARE_AI:
+        parts.append(f"⚠ листикл ({s.list_items} пунктов, {int(s.listicle_share*100)}% строк)")
+    elif s.list_items:
+        parts.append(f"пунктов списка: {s.list_items}")
+    if s.title_case_headings:
+        parts.append(f"⚠ Title Case в заголовках: {s.title_case_headings} (#56)")
+    if s.truncated_ending:
+        parts.append("⚠ обрыв на полуслове (#57)")
+    return "; ".join(parts)

package/skills/humanizer-ru/scripts/scan.py

@@ -0,0 +1,177 @@
+#!/usr/bin/env python3
+"""CLI-сканер: прогоняет текст через детерминированные метрики humanizer-ru.
+
+Использование (из корня репо; у установленного скилла путь: <папка скилла>/scripts/scan.py):
+    python skills/humanizer-ru/scripts/scan.py path/to/text.txt
+    echo "ваш текст" | python skills/humanizer-ru/scripts/scan.py -
+    python skills/humanizer-ru/scripts/scan.py text.txt --json
+
+Это машинная половина режима «Аудит». Для полного очеловечивания (семантика,
+голос, рерайт) нужен сам скилл — этот сканер только подсвечивает грепабельные
+маркеры и считает метрики, которые LLM не умеет мерить на глаз.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+try:
+    from humanizer_metrics import analyze, cleanliness_score
+    from humanizer_metrics.burstiness import rhythm_verdict
+    from humanizer_metrics.markers import (GENRE_MUTED_BANS, GENRE_MUTED_CATEGORIES,
+                                            GENRES, effective_hard_bans, marker_verdict,
+                                            mute_by_genre)
+    from humanizer_metrics.morphology import morph_verdict
+    from humanizer_metrics.structure import structure_verdict
+except ImportError as exc:
+    print(f"[ошибка] не хватает зависимостей сканера ({exc.name}).\n"
+          "Поставьте один раз: pip install razdel pymorphy3", file=sys.stderr)
+    raise SystemExit(2)
+
+
+def _read(src: str) -> str:
+    if src == "-":
+        return sys.stdin.read()
+    try:
+        return Path(src).read_text(encoding="utf-8")
+    except FileNotFoundError:
+        print(f"[ошибка] файл не найден: {src}", file=sys.stderr)
+        raise SystemExit(2)
+    except (IsADirectoryError, UnicodeDecodeError) as exc:
+        print(f"[ошибка] не могу прочитать {src}: {exc}", file=sys.stderr)
+        raise SystemExit(2)
+
+
+def _line_numbers(text: str, positions: list[int], limit: int = 3) -> str:
+    """Номера строк первых вхождений: «стр. 3, 7» — чтобы находку можно
+    было найти в тексте глазами."""
+    lines = sorted({text.count("\n", 0, p) + 1 for p in positions})
+    shown = ", ".join(str(n) for n in lines[:limit])
+    more = f", +{len(lines) - limit}" if len(lines) > limit else ""
+    return f"стр. {shown}{more}"
+
+
+def _cyrillic_share(text: str) -> float:
+    letters = re.findall(r"[^\W\d_]", text)
+    if not letters:
+        return 0.0
+    cyr = sum(1 for ch in letters if "а" <= ch.lower() <= "я" or ch.lower() == "ё")
+    return cyr / len(letters)
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description="Детерминированный сканер AI-маркеров (humanizer-ru)")
+    ap.add_argument("source", help="файл с текстом или '-' для stdin")
+    ap.add_argument("--json", action="store_true", help="вывод в JSON")
+    ap.add_argument("--genre", choices=GENRES, default="marketing",
+                    help="жанр текста: снимает маркеры, законные для регистра "
+                         "(academic, legal, fiction). По умолчанию marketing: "
+                         "строгий режим, под него откалиброваны пороги")
+    args = ap.parse_args()
+
+    text = _read(args.source)
+
+    if not text.strip():
+        if args.json:
+            print(json.dumps({"empty": True}, ensure_ascii=False))
+        else:
+            print("Текст пуст, сканировать нечего.")
+        return 0
+
+    rep = analyze(text)
+    genre = args.genre
+    sc = cleanliness_score(rep, genre)
+    # Частотные баны («Является» до порога 1/500 слов) не валят exit и не
+    # показываются как ⛔ — они остаются в мягких маркерах.
+    bans = effective_hard_bans(rep.hard_bans, rep.rhythm.words)
+    # Жанровый фильтр: в научном, юридическом и художественном регистре часть
+    # банов законна. Замер на AINL-Eval показал, что без фильтра сканер ловит
+    # людей чаще, чем модели (см. markers.GENRE_MUTED_BANS).
+    bans = mute_by_genre(bans, genre, GENRE_MUTED_BANS)
+    soft = mute_by_genre(rep.markers, genre, GENRE_MUTED_CATEGORIES)
+    muted_bans = len(effective_hard_bans(rep.hard_bans, rep.rhythm.words)) - len(bans)
+    muted_soft = len(rep.markers) - len(soft)
+    EM_DASH_MUTED = "Длинное тире" in GENRE_MUTED_BANS.get(genre, set())
+
+    if args.json:
+        out = rep.as_dict()
+        out["score"] = sc.as_dict()
+        # Ключи те же, что без жанра: меняется только состав после фильтра.
+        out["genre"] = genre
+        out["hard_bans"] = [(h.marker, h.count) for h in bans]
+        out["hard_ban_count"] = sum(h.count for h in bans)
+        out["markers"] = [(h.category, h.marker, h.count) for h in soft]
+        out["marker_count"] = sum(h.count for h in soft)
+        out["muted_by_genre"] = {"hard_bans": muted_bans, "markers": muted_soft}
+        if _cyrillic_share(text) < 0.3:
+            out["warning"] = "текст не похож на русский, метрики не применимы"
+        print(json.dumps(out, ensure_ascii=False, indent=2))
+        return 1 if bans else 0
+
+    print(f"=== humanizer-ru scan: {args.source} ===")
+    if genre != "marketing":
+        print(f"жанр: {genre} (снято маркеров по жанру: "
+              f"{muted_bans} банов, {muted_soft} мягких)")
+    print()
+
+    if _cyrillic_share(text) < 0.3:
+        print("⚠ Текст не похож на русский: скилл и метрики рассчитаны на русский "
+              "язык, отчёт ниже не показателен.\n")
+
+    print(f"ЧИСТОТА: {sc.score}/100  [{sc.band}]")
+    print("  (≥85 чисто · 60-84 точечная правка · <60 рерайт)")
+    if sc.penalties:
+        for reason, pts in sc.penalties:
+            print(f"  {pts:+d}  {reason}")
+    else:
+        print("  без штрафов")
+    for note in sc.notes:
+        print(f"  ℹ  {note}")
+    print()
+
+    print("HARD BANS:")
+    if bans:
+        for h in bans:
+            note = " (штраф по плотности, допуск ~2/100 слов)" if h.marker == "Длинное тире" else ""
+            print(f"  ⛔ {h.marker} ×{h.count} ({_line_numbers(text, h.positions)}){note}")
+    else:
+        print("  ✓ чисто")
+    print()
+
+    print(f"Маркеры (быстрый сканер): {marker_verdict(soft)}")
+    top = sorted(soft, key=lambda x: -x.count)
+    for h in top[:12]:
+        print(f"  • [{h.category}] «{h.marker}» ×{h.count} ({_line_numbers(text, h.positions)})")
+    if len(top) > 12:
+        print(f"  … и ещё {len(top) - 12}")
+    print()
+
+    print("Ритм / типографика:")
+    print(f"  {rhythm_verdict(rep.rhythm, dash_ok=EM_DASH_MUTED)}")
+    print(f"  предложений: {rep.rhythm.sentences}, средняя длина: {rep.rhythm.mean_len:.1f} "
+          f"(min {rep.rhythm.min_len} / max {rep.rhythm.max_len}), CV: {rep.rhythm.cv_len}")
+    print(f"  многоточий: {rep.rhythm.ellipsis}, скобок: {rep.rhythm.parentheses}, "
+          f"вопросов: {rep.rhythm.questions}")
+    print()
+
+    print("Морфология:")
+    print(f"  {morph_verdict(rep.morph)}")
+    print(f"  сущ.: {rep.morph.nouns}, глаг.форм: {rep.morph.verbs}, "
+          f"номинализаций: {rep.morph.nominalizations}")
+    print()
+
+    print("Структура (уровень документа):")
+    print(f"  {structure_verdict(rep.structure)}")
+
+    # Exit code: ненулевой, если есть HARD BANS — удобно для CI/pre-commit.
+    return 1 if bans else 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())