humanizer-pro 4.15.0__py3-none-any.whl

humanizer_audit.py

@@ -0,0 +1,2041 @@
+#!/usr/bin/env python3
+"""Deterministic audit CLI for Humanizer Pro."""
+
+from __future__ import annotations
+
+import argparse
+import difflib
+import hashlib
+import json
+import math
+import re
+import sys
+from collections import Counter
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Iterable
+from urllib.parse import parse_qsl, quote, urlencode, urlsplit, urlunsplit
+
+
+__version__ = "4.15.0"
+SCHEMA = "humanizer-audit.v1"
+SEVERITY_ORDER = {"info": 0, "warning": 1, "error": 2}
+
+AI_REFERRER_HOSTS = {
+    "chatgpt.com",
+    "claude.ai",
+    "copilot.com",
+    "grok.com",
+    "openai",
+    "perplexity.ai",
+}
+
+HOMOGLYPH_LATIN = {
+    # Cyrillic lookalikes
+    "а": "a", "е": "e", "о": "o", "р": "p", "с": "c", "х": "x",
+    "у": "y", "к": "k", "м": "m", "н": "h", "в": "b", "т": "t",
+    "А": "A", "Е": "E", "О": "O", "Р": "P", "С": "C", "Х": "X",
+    "У": "Y", "К": "K", "М": "M", "Н": "H", "В": "B", "Т": "T",
+    # Greek lookalikes
+    "ο": "o", "Ο": "O", "α": "a", "Α": "A", "ρ": "p", "Ρ": "P",
+}
+WORD_WITH_HOMOGLYPH_RE = re.compile(
+    "[A-Za-z{h}]*[A-Za-z][A-Za-z{h}]*".format(h="".join(HOMOGLYPH_LATIN))
+)
+
+# Invisible characters split into two policies. The always-strip set has no
+# legitimate use in the registers this skill meets (prose, wiki, chat), so a
+# hit is stray junk wherever it lands: zero-width space, word joiner, the
+# invisible math operators, a non-leading byte-order mark, and the deprecated
+# Mongolian vowel separator. Unicode tag characters (U+E0000-E007F) and
+# noncharacters carry the same verdict and are matched by range below — the tag
+# block is the newest text-hiding trick and has no visible rendering at all.
+ALWAYS_STRIP_INVISIBLES = frozenset(
+    {0x200B, 0x2060, 0x2061, 0x2062, 0x2063, 0x2064, 0xFEFF, 0x180E}
+)
+# The conditional set is legitimate in the right script and corrupts text if
+# stripped blindly: the zero-width joiner binds emoji sequences and shapes
+# Indic/Arabic ligatures, the non-joiner separates Persian/Devanagari letters,
+# and the variation selectors choose an emoji or text glyph. Each is kept when
+# its neighbours prove the legitimate context and stripped otherwise.
+CONDITIONAL_INVISIBLES = frozenset({0x200C, 0x200D, 0xFE0E, 0xFE0F})
+
+
+def _is_tag_char(cp: int) -> bool:
+    return 0xE0000 <= cp <= 0xE007F
+
+
+def _is_noncharacter(cp: int) -> bool:
+    return 0xFDD0 <= cp <= 0xFDEF or (cp & 0xFFFF) in (0xFFFE, 0xFFFF)
+
+
+def _is_managed_invisible(cp: int) -> bool:
+    """True for any codepoint the bypass pass may remove."""
+    return (
+        cp in ALWAYS_STRIP_INVISIBLES
+        or cp in CONDITIONAL_INVISIBLES
+        or _is_tag_char(cp)
+        or _is_noncharacter(cp)
+    )
+
+
+def _is_emoji_related(char: str) -> bool:
+    """A base, modifier, or selector that can appear in an emoji sequence."""
+    if not char:
+        return False
+    cp = ord(char)
+    return (
+        # The emoji/pictograph block already subsumes the regional-indicator
+        # (U+1F1E6-1F1FF) and skin-tone (U+1F3FB-1F3FF) ranges, so they need no
+        # separate clause.
+        0x1F000 <= cp <= 0x1FAFF  # emoji and pictograph blocks
+        or 0x2600 <= cp <= 0x27BF  # misc symbols and dingbats
+        or 0x2B00 <= cp <= 0x2BFF  # misc symbols and arrows
+        or 0xFE00 <= cp <= 0xFE0F  # variation selectors
+        or cp == 0x20E3  # combining enclosing keycap
+        or cp
+        in {0x203C, 0x2049, 0x2122, 0x2139, 0x2194, 0x21A9, 0x231A, 0x24C2, 0x25AA, 0x3030, 0x303D, 0x3297, 0x3299}
+    )
+
+
+def _is_emoji_base(char: str) -> bool:
+    """Emoji context that can legitimately anchor a variation selector.
+
+    This is ``_is_emoji_related`` minus the variation-selector block itself. A
+    variation selector is only meaningful directly after a real base glyph, so
+    one selector must not treat an adjacent selector as its context -- otherwise
+    two injected selectors between plain letters would each vouch for the other
+    and both survive the bypass pass.
+    """
+    if not char:
+        return False
+    if 0xFE00 <= ord(char) <= 0xFE0F:
+        return False
+    return _is_emoji_related(char)
+
+
+def _in_joining_script(char: str) -> bool:
+    """A letter from a script that uses the zero-width (non-)joiner for shaping."""
+    if not char:
+        return False
+    cp = ord(char)
+    return (
+        0x0590 <= cp <= 0x074F  # Hebrew, Arabic, Syriac
+        or 0x0750 <= cp <= 0x07BF  # Arabic Supplement, Thaana
+        or 0x08A0 <= cp <= 0x08FF  # Arabic Extended-A
+        or 0x0900 <= cp <= 0x0DFF  # Devanagari through Sinhala
+        or 0x1780 <= cp <= 0x17FF  # Khmer
+        or 0xA8E0 <= cp <= 0xA8FF  # Devanagari Extended
+        or 0xFB1D <= cp <= 0xFB4F  # Hebrew presentation forms
+        or 0xFB50 <= cp <= 0xFDCF  # Arabic Presentation Forms-A (below noncharacters)
+        or 0xFDF0 <= cp <= 0xFDFF  # Arabic Presentation Forms-A (above noncharacters)
+        or 0xFE70 <= cp <= 0xFEFC  # Arabic Presentation Forms-B
+    )
+
+
+def _strip_invisible(cp: int, prev_char: str, next_char: str) -> bool:
+    """Decide whether a managed invisible character is stray and should go.
+
+    The conditional joiners and variation selectors are kept when a neighbour
+    supplies the legitimate context (an emoji run, or a joining-script letter)
+    and removed otherwise. Every other managed codepoint is always removed.
+    """
+    if cp == 0x200D:  # zero-width joiner
+        return not (
+            _is_emoji_related(prev_char)
+            or _is_emoji_related(next_char)
+            or _in_joining_script(prev_char)
+            or _in_joining_script(next_char)
+        )
+    if cp == 0x200C:  # zero-width non-joiner
+        return not (_in_joining_script(prev_char) or _in_joining_script(next_char))
+    if cp in (0xFE0E, 0xFE0F):  # variation selectors 15 and 16
+        return not (_is_emoji_base(prev_char) or _is_emoji_base(next_char))
+    return True
+
+
+def _strip_invisibles(body: str, offset_base: int) -> tuple[str, int, int]:
+    """Remove stray invisibles from ``body``, keeping legitimate joiners.
+
+    Returns (cleaned_text, removed_count, first_removed_offset). Neighbour
+    lookups use the original text so an emoji or Arabic run is judged before any
+    character is dropped.
+    """
+    out: list[str] = []
+    removed = 0
+    first_offset = -1
+    length = len(body)
+    for index, char in enumerate(body):
+        if _is_managed_invisible(ord(char)):
+            prev_char = body[index - 1] if index > 0 else ""
+            next_char = body[index + 1] if index + 1 < length else ""
+            if _strip_invisible(ord(char), prev_char, next_char):
+                removed += 1
+                if first_offset < 0:
+                    first_offset = index + offset_base
+                continue
+        out.append(char)
+    return "".join(out), removed, first_offset
+
+
+@dataclass(frozen=True)
+class Rule:
+    id: str
+    family: int | None
+    regex: re.Pattern[str]
+    message: str
+    severity: str = "warning"
+    source_risk: bool = False
+    once_per_doc: bool = False
+
+
+@dataclass(frozen=True)
+class ProtectedToken:
+    kind: str
+    value: str
+    evidence: str
+    offset: int
+
+
+ARTIFACT_RULES = [
+    Rule(
+        "artifact.chatgpt_citation_stub",
+        9,
+        re.compile(r"(?:cite)?turn\d+(?:search|image|news|file)\d+", re.I),
+        "ChatGPT citation stub leaked into text",
+        "error",
+        True,
+    ),
+    Rule(
+        "artifact.content_reference",
+        9,
+        re.compile(r":?contentReference\[oaicite:\d+\]\{index=\d+\}|contentReference", re.I),
+        "ChatGPT contentReference citation residue",
+        "error",
+        True,
+    ),
+    Rule(
+        "artifact.oai_citation",
+        9,
+        re.compile(r"oaicite|oai_citation(?::\d+)?", re.I),
+        "OpenAI citation residue",
+        "error",
+        True,
+    ),
+    Rule(
+        "artifact.attribution_json",
+        9,
+        re.compile(r'attributableIndex|\(\{"attribution":\{"attributableIndex":"\d+-\d+"\}\}\)|\^\[[^\]]+\]\('),
+        "JSON attribution block leaked into prose",
+        "error",
+        True,
+    ),
+    Rule(
+        "artifact.perplexity_tag",
+        9,
+        re.compile(r"\[(?:attached_file|web):\d+\]", re.I),
+        "Perplexity source tag leaked into text",
+        "error",
+        True,
+    ),
+    Rule(
+        "artifact.grok_card",
+        9,
+        re.compile(r"grok[_-]card|<grok-card[^>]*>|grok_render_citation_card_json=\{[^}]*\}", re.I),
+        "Grok citation card leaked into text",
+        "error",
+        True,
+    ),
+    Rule(
+        "artifact.lenticular_reference",
+        9,
+        re.compile(r"【\d+†[^】]*】"),
+        "Line-reference citation marker leaked into prose",
+        "error",
+        True,
+    ),
+    Rule(
+        "artifact.ai_tracking_url",
+        9,
+        re.compile(
+            r"[?&](?:utm_source=(?:chatgpt\.com|claude\.ai|copilot\.com|openai|perplexity\.ai)"
+            r"|referrer=grok\.com)",
+            re.I,
+        ),
+        "AI-tool tracking parameter in URL",
+        "error",
+        True,
+    ),
+    Rule(
+        "artifact.roleplay_marker",
+        9,
+        re.compile(
+            r"(?<!\*)\*(?:nods|sighs|laughs|smiles|frowns|shrugs|grins|winks|chuckles|gasps|"
+            r"pauses|whispers|shouts|glances|smirks|blinks)(?:[^*\n]{0,60})?\*(?!\*)",
+            re.I,
+        ),
+        "Chat roleplay action marker leaked into text",
+        "error",
+        False,
+    ),
+    Rule(
+        "artifact.assistant_self_disclosure",
+        9,
+        re.compile(
+            # The assistant speaking as itself: "As an AI language model, I".
+            # Anchored on the first person so a sentence *about* a language
+            # model ("the film is about an AI language model") stays clear.
+            r"\b(?:as an? (?:ai|artificial intelligence|large language model|llm)(?: (?:language )?(?:model|assistant|chatbot|system))?,? i\b|"
+            r"i(?:'m| am) (?:just |only )?an? (?:ai|artificial intelligence|large language model|llm)(?: (?:language )?(?:model|assistant|chatbot))?\b|"
+            r"i (?:do not|don't) have (?:access to )?real-time (?:data|information|access)|"
+            r"i (?:cannot|can't|am unable to) browse the internet)",
+            re.I,
+        ),
+        "Assistant self-disclosure leaked from a chat reply",
+        "error",
+        False,
+    ),
+    Rule(
+        "artifact.humanizer_whitespace",
+        9,
+        re.compile(
+            # Thin, hair, six-per-em, figure, punctuation, and medium math
+            # spaces between letters. No keyboard produces them; "humanizer"
+            # tools swap them for ordinary spaces to break exact matching. The
+            # non-breaking space is left alone: editors and web copy use it.
+            r"(?<=[A-Za-z,.;:!?])[      ](?=[A-Za-z])",
+        ),
+        "Typographic space character where a keyboard space belongs",
+        "warning",
+        False,
+        True,
+    ),
+    Rule(
+        "artifact.bracket_placeholder",
+        9,
+        re.compile(
+            # Generic fill-in blanks ([Recipient Name], [Company], [Date]) as
+            # well as the on-wiki forms. A Markdown link or reference
+            # ("[Your account](url)", "[Company][1]", "[1]: url") and a wiki
+            # link ("[[Date]]") are not placeholders, so an opening bracket
+            # before, or a "(" ":" "[" after, cancels the match.
+            r"(?<!\[)\[(?:Your Name|Entertainer's Name|insert[^\]]*|describe[^\]]*|link to[^\]]*|"
+            r"(?:Your|Insert|Recipient|Client|Candidate|Author|Employer|Manager|Company|Product|"
+            r"Organization|Organisation|Address|City|State|Country|Email|Phone|Date|Name|Title|"
+            r"Position|Job Title|Signature|Website|URL|Number|Amount|Quantity|Reason|Topic|Subject)"
+            r"(?: [A-Za-z]+){0,3})\](?!\s*[\(\[:])",
+            re.I,
+        ),
+        "Unfilled bracket placeholder",
+        "error",
+        True,
+    ),
+    Rule(
+        "artifact.insert_placeholder",
+        9,
+        re.compile(r"\b(?:INSERT|PASTE|SOURCE)_[A-Z0-9_]+(?:_HERE)?\b"),
+        "Unfilled all-caps placeholder",
+        "error",
+        True,
+    ),
+    Rule(
+        "artifact.placeholder_comment",
+        9,
+        re.compile(r"<!--\s*Add (?:if available|[^>]*)-->", re.I),
+        "Unfilled HTML placeholder comment",
+        "error",
+        True,
+    ),
+    Rule(
+        "artifact.placeholder_date",
+        9,
+        re.compile(r"20\d{2}-(?:XX|\d{2})-XX|\b20XX\b", re.I),
+        "Placeholder date",
+        "error",
+        True,
+    ),
+]
+
+FAMILY_RULES = [
+    Rule(
+        "family1.significance_inflation",
+        1,
+        re.compile(
+            r"\b(?:stands as|serves as|pivotal role|pivotal moment|enduring commitment|lasting importance|"
+            r"scientific landscape|rich heritage|renowned|groundbreaking|vibrant|breathtaking|boasts)\b",
+            re.I,
+        ),
+        "Significance or promotional inflation",
+    ),
+    Rule(
+        "family2.vague_attribution",
+        2,
+        re.compile(
+            r"\b(?:experts (?:argue|believe)|observers note|studies show|researchers (?:say|believe)|"
+            r"gained recognition|featured in|cited in|national media|praised by critics|active social media)\b",
+            re.I,
+        ),
+        "Vague attribution or notability padding",
+        source_risk=True,
+    ),
+    Rule(
+        "family2.speculative_gap_filling",
+        2,
+        re.compile(
+            r"\b(?:is|was|are|were)\s+(?:widely\s+)?believed\s+to\s+have\b|"
+            r"\blikely\s+(?:began|started|joined|studied|served|worked)\b|"
+            r"\bappears?\s+to\s+have\s+(?:been|begun|studied|worked|served)\b|"
+            r"\bmaintains\s+a\s+relatively\s+low\s+(?:public\s+)?profile\b",
+            re.I,
+        ),
+        "Speculative gap-filling presented as fact",
+        source_risk=True,
+    ),
+    Rule(
+        "family2.vague_validation",
+        2,
+        re.compile(
+            r"\b(?:independent\s+(?:testing|tests|analysis|audits?)\s+(?:confirm|confirms|show|shows|validate|validates)|"
+            r"third-party\s+benchmarks?\s+(?:show|confirm|place|put)|"
+            r"analysts\s+(?:agree|say|note|believe)|"
+            r"studies\s+consistently\s+show)\b",
+            re.I,
+        ),
+        "Unnamed third-party validation",
+        source_risk=True,
+    ),
+    Rule(
+        "family3.filler_framing",
+        3,
+        re.compile(
+            # "it is important to note" is family5-only (anticipatory "it",
+            # catalog 5.1); listing it here too scored one phrase twice.
+            r"\b(?:in today's|in conclusion|in order to|due to the fact that|"
+            r"at its core|when it comes to|future belongs|exciting journey|journey toward excellence|"
+            r"highlighting|underscoring|showcasing|fostering)\b",
+            re.I,
+        ),
+        "Filler framing or superficial analysis",
+    ),
+    Rule(
+        "family5.syntactic_tell",
+        5,
+        re.compile(
+            r"\b(?:it is important to note|there are several|there exists|it can be argued|it has been shown|"
+            r"it should be emphasized|what matters is|not insignificant)\b",
+            re.I,
+        ),
+        "Syntactic tell or hedged construction",
+    ),
+    Rule(
+        "family6.verbosity_padding",
+        6,
+        re.compile(
+            r"\b(?:made the decision|has the ability to|is able to|general feeling|primary reason was the fact|"
+            r"communication with customers should be improved|at this point in time|provide an explanation|"
+            r"conduct an analysis)\b",
+            re.I,
+        ),
+        "Verbosity, nominalization, or padding",
+    ),
+    Rule(
+        "family7.rhetorical_formula",
+        7,
+        re.compile(
+            # The paired forms stay inside one sentence. With DOTALL and a
+            # greedy ".+", "not just" in one paragraph matched the last "but"
+            # anywhere later in the document.
+            r"\b(?:not just\b[^.!?]{0,150}?\bbut\b|not only\b[^.!?]{0,150}?\bbut also\b|"
+            # "not just X; it's Y" / "not just X. It's Y": the contrast lands in
+            # the next clause or sentence without a "but". Anchored on a
+            # preceding copula ("is/it's not just") so "had not just arrived"
+            # stays clear.
+            r"(?:is|'s|are|was|were)\s+not just\b[^.!?;,]{0,120}?[.;,:]\s*(?:it'?s|it is|that'?s|this is|they'?re)\b|"
+            r"here's the thing|you know what|watch this|"
+            r"what if i told you|let that sink in|plot twist|full stop|see what i did there)\b",
+            re.I,
+        ),
+        "Rhetorical formula or forced cadence",
+    ),
+    # The naive two-word triplet pattern ("\w+ \w+, \w+ \w+, and \w+ \w+") was
+    # removed from family7 after corpus measurement (corpus/RESULTS.md): it fired
+    # on 33% of human wiki documents (180/548) — ordinary enumerations of names,
+    # offices, and places — and three hits force-floor the risk score to review.
+    # Rule-of-three judgment is model-side (catalog §7.3, coverage-map).
+    Rule(
+        "family8.markdown_structure",
+        8,
+        re.compile(r"^\s*(?:---\s*$|#{3,}\s+|\|\s*[^|\n]+\s*\||[-*+]\s+\*\*[^*\n]+:\*\*)", re.M),
+        "Mechanical structure or Markdown formatting tell",
+        once_per_doc=True,
+        # once_per_doc calibrated against the human-control corpus: table-heavy
+        # human documents matched ~29 lines each, so this one rule alone maxed
+        # the family score cap and tripped the >=10-findings review floor.
+        # Whether mechanical structure is present is a document-level fact; one
+        # finding carries it.
+    ),
+    Rule(
+        "family8.list_label_period",
+        8,
+        re.compile(r"^\s*[-*+]\s+\*\*[^*\n]{1,40}?\.\*\*\s+\S", re.M),
+        "List label ends with a period instead of a colon",
+    ),
+    Rule(
+        "family9.humanizer_spacing",
+        9,
+        re.compile(
+            # "end.Next" — a sentence boundary with the space removed, the most
+            # common damage from rule-based humanizers (Pangram, Aug 2025).
+            # Two lowercase letters before the stop skip abbreviations (e.g.)
+            # and the lowercase after the capital skips file names and acronyms.
+            r"(?<=[a-z][a-z])[.!?](?=[A-Z][a-z]{2})"
+        ),
+        "Missing space after a sentence end",
+        "warning",
+        False,
+    ),
+    Rule(
+        "family9.tortured_phrase",
+        9,
+        re.compile(
+            # Known one-for-one synonym swaps that no writer chooses: the
+            # Problematic Paper Screener's classics plus a few stilted verbs.
+            # Also common in non-native English, so the message says "check".
+            r"\b(?:counterfeit consciousness|computerized reasoning|profound (?:learning|neural organi[sz]ation)|"
+            r"(?:irregular|arbitrary) (?:timberland|woodland)|bosom (?:peril|malignancy|malignant growth)|"
+            r"(?:colossal|huge) information|signal to commotion|mean square blunder|"
+            r"normal language handling|choice tree|(?:picture|discourse|face) acknowledgment|"
+            r"backing vector machine|fake neural organi[sz]ation|worldwide temperature alteration|"
+            r"require to (?:obtain|acquire|get)|creating a peculiar)\b",
+            re.I,
+        ),
+        "Phrase reads like a mechanical synonym swap; check the intended term",
+        "warning",
+        False,
+    ),
+    Rule(
+        "family9.chatbot_residue",
+        9,
+        re.compile(
+            # "of course!" sits outside the group: it ends in punctuation, so a
+            # closing \b only matched when a letter followed with no space.
+            r"\bof course!|"
+            r"\b(?:great question|here's a polished|i hope this helps|certainly|best regards|"
+            r"let me know if|would you like me|let me walk you through|here's how i'd think about|"
+            r"while i understand the appeal|"
+            r"(?:as of|up to|based on) my (?:last |most recent |latest )?(?:knowledge |training )?(?:update|cutoff|data)|"
+            r"my (?:knowledge|training) (?:cutoff|data)(?: only)? (?:goes|extends|runs) (?:up )?to|my knowledge cutoff|"
+            r"on the one hand\b.{0,120}\bon the other)\b",
+            re.I,
+        ),
+        "Chatbot wrapper or collaborative residue",
+    ),
+]
+
+# Tier 1A: words reported far more frequent in machine text than human text. The
+# frequency claim is inherited from the source catalogs, not measured here; a
+# cluster of these is still the strongest vocabulary evidence this CLI has.
+AI_VOCAB_TIER1 = {
+    "delve",
+    "emphasizing",
+    "enduring",
+    "garner",
+    "interplay",
+    "intricate",
+    "landscape",
+    "meticulous",
+    "pivotal",
+    "robust",
+    "showcase",
+    "showcasing",
+    "tapestry",
+    "testament",
+    "underscore",
+    "vibrant",
+}
+
+# Tier 2: legitimate on their own; evidence only in clusters.
+AI_VOCAB_TIER2 = {
+    "additionally",
+    "align",
+    "boasts",
+    "bolstered",
+    "cornerstone",
+    "crucial",
+    "enhance",
+    "foster",
+    "fostering",
+    "highlight",
+    "highlighting",
+    "leverage",
+    "unlock",
+    "valuable",
+}
+
+AI_VOCAB = AI_VOCAB_TIER1 | AI_VOCAB_TIER2
+
+# Tier 1B: wordiness and register inflation. Replacing these is good writing
+# regardless of who wrote the sentence, so they are reported as clarity edits,
+# carry no tell family, and contribute nothing to the risk score — a wordiness
+# fix must never push a document toward an AI classification.
+CLARITY_RULES = [
+    Rule(
+        "clarity.wordiness",
+        None,
+        re.compile(
+            r"\b(?:utiliz(?:e|es|ed|ing|ation)|commenc(?:e|es|ed|ing)|"
+            r"facilitat(?:e|es|ed|ing)|endeavor(?:s|ed|ing)?|ascertain(?:s|ed|ing)?|"
+            # Multi-word wrappers around a one-word meaning (HH). "due to the
+            # fact that" stays family3-only; listing it here too would
+            # double-count one phrase across tiers. "has the ability to" stays
+            # family6-only for the same reason.
+            r"in the event that|for the purpose of|"
+            r"with regard to|with respect to|in light of the fact that|"
+            r"despite the fact that)\b",
+            re.I,
+        ),
+        "Inflated register (a clarity edit, not authorship evidence)",
+        "info",
+    ),
+]
+
+SOURCE_RISK_RULES = [
+    Rule(
+        "source_risk.citation_markup",
+        None,
+        re.compile(r"<ref\b|</ref>|{{\s*cite\b|\[\^[^\]]+\]|\[[^\]]+\]\(https?://[^)]+\)", re.I),
+        "Citation markup or linked claim needs source verification",
+        source_risk=True,
+    ),
+    Rule(
+        "source_risk.bare_url",
+        None,
+        re.compile(r"https?://[^\s)>\]]+", re.I),
+        "Bare URL or linked source needs verification",
+        source_risk=True,
+    ),
+    Rule(
+        "source_risk.source_dependent_statement",
+        None,
+        re.compile(
+            r"\b(?:according to|reported|reports|study|studies|survey|records|cited|praised by|critics|"
+            r"observers note|experts|researchers|national media|available sources)\b",
+            re.I,
+        ),
+        "Source-dependent statement needs verification",
+        source_risk=True,
+    ),
+]
+
+# Backtick and tilde fences (CommonMark allows both). Opener and closer each
+# start a line and the closer matches the opener, so a sentence that mentions
+# ``` in passing cannot pair with a later fence and swallow the prose between.
+CODE_BLOCK_RE = re.compile(r"^[ \t]*(```|~~~)[^\n`~]*\n(?:.*?\n)?[ \t]*\1[ \t]*$", re.M | re.S)
+URL_RE = re.compile(r"https?://[^\s<>\]\)\"'|{}]+", re.I)
+MARKDOWN_LINK_RE = re.compile(r"(?<!!)\[([^\]\n]+)\]\(([^)\s]+(?:\s+\"[^\"]*\")?)\)")
+FOOTNOTE_REF_RE = re.compile(r"\[\^[^\]\n]+\]")
+FOOTNOTE_DEF_RE = re.compile(r"^\[\^[^\]\n]+\]:.*$", re.M)
+REF_TAG_RE = re.compile(r"<ref\b[^>]*(?:/>|>.*?</ref>)", re.I | re.S)
+CITE_TEMPLATE_RE = re.compile(r"{{\s*cite\b.*?}}", re.I | re.S)
+QUOTE_RE = re.compile(r'"[^"\n]{3,}"|“[^”\n]{3,}”')
+BLOCKQUOTE_RE = re.compile(r"^(?:>\s?.+(?:\n|$))+", re.M)
+DATE_RE = re.compile(
+    r"\b(?:20XX|\d{4}-(?:\d{2}|XX)-(?:\d{2}|XX)|"
+    r"(?:Jan(?:uary)?|Feb(?:ruary)?|Mar(?:ch)?|Apr(?:il)?|May|Jun(?:e)?|Jul(?:y)?|"
+    r"Aug(?:ust)?|Sep(?:tember)?|Oct(?:ober)?|Nov(?:ember)?|Dec(?:ember)?)\.?\s+"
+    r"\d{1,2},?\s+\d{4}|"
+    r"\d{1,2}\s+(?:Jan(?:uary)?|Feb(?:ruary)?|Mar(?:ch)?|Apr(?:il)?|May|Jun(?:e)?|"
+    r"Jul(?:y)?|Aug(?:ust)?|Sep(?:tember)?|Oct(?:ober)?|Nov(?:ember)?|Dec(?:ember)?)\.?\s+"
+    r"\d{4}|"
+    r"(?:Jan(?:uary)?|Feb(?:ruary)?|Mar(?:ch)?|Apr(?:il)?|May|Jun(?:e)?|Jul(?:y)?|"
+    r"Aug(?:ust)?|Sep(?:tember)?|Oct(?:ober)?|Nov(?:ember)?|Dec(?:ember)?)\.?\s+\d{4}|"
+    r"(?:1[6-9]\d{2}|20\d{2}|21\d{2}))\b",
+    re.I,
+)
+CURRENCY_RE = re.compile(
+    r"(?:[$€£]|USD|EUR|GBP)\s?\d[\d,]*(?:\.\d+)?"
+    r"(?:\s?(?:million|billion|trillion|thousand|m|bn|k))?",
+    re.I,
+)
+PERCENT_RE = re.compile(r"\b\d[\d,]*(?:\.\d+)?\s?%")
+RANGE_RE = re.compile(r"\b\d[\d,]*(?:\.\d+)?\s*(?:-|–|—|to)\s*\d[\d,]*(?:\.\d+)?\b", re.I)
+NUMBER_RE = re.compile(r"\b\d[\d,]*(?:\.\d+)?\b")
+NAME_RE = re.compile(
+    r"\b[A-Z][A-Za-z0-9'.&-]+(?:\s+(?:of|the|and|for|de|del|la|le|du|van|von|&|"
+    r"[A-Z][A-Za-z0-9'.&-]+)){1,}",
+)
+ORG_HINT_RE = re.compile(
+    r"\b(?:Agency|Association|Bureau|Committee|Commission|Company|Corporation|Council|Department|"
+    r"Foundation|Group|Institute|LLC|Ltd|Ministry|Office|Organization|Research|University)\b"
+)
+SOURCE_MARKER_RE = re.compile(
+    r"https?://|<ref\b|{{\s*cite\b|\[\^[^\]]+\]|\[[^\]]+\]\(|"
+    r"\b(?:according to|reported|reports|study|studies|survey|records|cited|evidence|data|"
+    r"researchers|observers|experts|said|announced|published|filed)\b",
+    re.I,
+)
+REPORTING_LANGUAGE_RE = re.compile(
+    r"\b(?:according to|reported|reports|study|studies|survey|records|cited|evidence|data|"
+    r"researchers|observers|experts|said|announced|published|filed)\b",
+    re.I,
+)
+NAME_CONNECTORS = {"and", "de", "del", "du", "for", "la", "le", "of", "the", "van", "von"}
+NAME_EXCLUDE_START = {"A", "An", "As", "At", "By", "For", "From", "If", "In", "It", "On", "Or", "The", "This", "To"}
+# A capital is evidence of a proper noun only when the author chose it. At the
+# head of a sentence the capital is grammar, so a run that opens a sentence has
+# its head token demoted when there is positive evidence the head is an ordinary
+# word: it appears lowercase somewhere in the compared texts, or it is a known
+# function word or sentence opener. Without this, ordinary copy edits reported
+# protected-name drift -- deleting a leading connective recapitalizes the next
+# word ("Additionally, comedian Dana Whitfield" -> "Comedian Dana Whitfield"), and
+# a determiner fix rewrites the head ("These UCBSD" -> "The UCBSD"). Only the
+# head is dropped, so the real name inside the run still compares. A head with
+# no such evidence is kept, so the check still fails closed on a real name.
+NAME_SENTENCE_END = ".!?"
+NAME_RUN_OPENERS = " \t\r\n\f\v'\"“”‘’([{*#:;|=<>"
+NAME_HEAD_RE = re.compile(r"\S+\s+")
+LOWERCASE_WORD_RE = re.compile(r"\b[a-z][A-Za-z0-9'.&-]*")
+# NAME_RE token characters include ".", so a greedy run swallows the period that
+# ends a sentence and joins the next sentence's first word ("... School
+# District. These UCBSD"). A boundary is a word of at least three letters ending
+# in a period, followed by a capital -- which leaves "St.", "U.S." and the named
+# abbreviations below joined to what follows them.
+NAME_SENTENCE_SPLIT_RE = re.compile(r"(?<=[A-Za-z]{3}\.)\s+(?=[A-Z])")
+NAME_ABBREVIATIONS = frozenset(
+    """
+    adm amb approx asst assoc bros capt col corp dept esq fig gen gov hon inc
+    jr ltd maj mrs prof pres rep rev sec sen sgt sr univ vol
+    """.split()
+)
+# Ordinary words that routinely open a sentence. A backstop for the lowercase
+# evidence above, which a short text may not supply. Grouped by part of speech
+# so later additions stay coherent rather than fitted to one failing case.
+NAME_SENTENCE_OPENERS = frozenset(
+    """
+    a an the this that these those each every either neither both all any some
+    many most much few several other another such various same
+    he she it they we you his her its their our your my him them us
+    who whom whose which what where when why how there here
+    and but or nor for yet so as if because although though while whereas
+    since until unless before after during despite besides beyond within
+    across against among between beneath under over above about into onto
+    from with without through throughout toward towards upon per via
+    is are was were be been being am has have had do does did
+    can could might must shall should would
+    not only also just even still again once then now today later
+    however meanwhile therefore thus hence instead rather nevertheless
+    nonetheless likewise similarly conversely accordingly consequently
+    additionally furthermore moreover subsequently ultimately alternatively
+    central main major minor primary secondary key local national regional
+    modern early earlier late recent current former original general public
+    private official large small new old further overall total annual daily
+    initial final following historically together part parts
+    one two three first second third last next
+    """.split()
+)
+
+
+def name_run_is_sentence_initial(text: str, start: int) -> bool:
+    """True when ``start`` opens a sentence, a heading, or a list item."""
+    index = start - 1
+    while index >= 0 and text[index] in NAME_RUN_OPENERS:
+        if text[index] in "\r\n":
+            return True
+        index -= 1
+    return index < 0 or text[index] in NAME_SENTENCE_END
+
+
+def name_vocabulary(*texts: str) -> set[str]:
+    """Words the compared texts show in lowercase at least once."""
+    words: set[str] = set()
+    for text in texts:
+        words.update(word.lower() for word in LOWERCASE_WORD_RE.findall(text))
+    return words
+
+
+def head_is_ordinary_word(head: str, ordinary: set[str]) -> bool:
+    lowered = head.lower().strip(".,:;")
+    return (
+        lowered in ordinary
+        or lowered in STOPWORDS
+        or lowered in NAME_SENTENCE_OPENERS
+        or head in NAME_EXCLUDE_START
+    )
+STOPWORDS = {
+    "a",
+    "an",
+    "and",
+    "are",
+    "as",
+    "at",
+    "be",
+    "by",
+    "for",
+    "from",
+    "has",
+    "have",
+    "in",
+    "is",
+    "it",
+    "of",
+    "on",
+    "or",
+    "that",
+    "the",
+    "their",
+    "this",
+    "to",
+    "was",
+    "were",
+    "with",
+}
+
+
+def line_starts(text: str) -> list[int]:
+    starts = [0]
+    for match in re.finditer(r"\n", text):
+        starts.append(match.end())
+    return starts
+
+
+def line_column(starts: list[int], offset: int) -> tuple[int, int]:
+    low = 0
+    high = len(starts) - 1
+    while low <= high:
+        mid = (low + high) // 2
+        if starts[mid] <= offset:
+            low = mid + 1
+        else:
+            high = mid - 1
+    line_index = max(0, high)
+    return line_index + 1, offset - starts[line_index] + 1
+
+
+def evidence(value: str) -> str:
+    collapsed = re.sub(r"\s+", " ", value).strip()
+    if len(collapsed) <= 120:
+        return collapsed
+    return collapsed[:117] + "..."
+
+
+def regex_spans(text: str, regex: re.Pattern[str]) -> list[tuple[int, int]]:
+    return [(match.start(), match.end()) for match in regex.finditer(text)]
+
+
+def blank_spans(text: str, spans: Iterable[tuple[int, int]]) -> str:
+    chars = list(text)
+    for start, end in spans:
+        for index in range(start, min(end, len(chars))):
+            if chars[index] != "\n":
+                chars[index] = " "
+    return "".join(chars)
+
+
+def normalize_space(value: str) -> str:
+    return re.sub(r"\s+", " ", value).strip()
+
+
+def normalize_url(raw_url: str) -> str:
+    trimmed = raw_url.strip().rstrip(").,;:!?")
+    parsed = urlsplit(trimmed)
+    query = urlencode(
+        [
+            (key, value)
+            for key, value in parse_qsl(parsed.query, keep_blank_values=True)
+            if not key.lower().startswith("utm_")
+            and not (key.lower() == "referrer" and value.lower() in AI_REFERRER_HOSTS)
+        ],
+        doseq=True,
+    )
+    return urlunsplit((parsed.scheme.lower(), parsed.netloc.lower(), parsed.path, query, parsed.fragment))
+
+
+def normalize_bypass_text(text: str) -> tuple[str, dict[str, int], int]:
+    """Strip hidden and lookalike characters before pattern matching.
+
+    Returns (normalized_text, counts, first_offset). Invisible bypass characters
+    are removed -- a single leading BOM is ordinary file encoding, not a trick,
+    and is exempt; the zero-width joiner/non-joiner and the variation selectors
+    are kept where their neighbours prove a legitimate emoji or joining-script
+    context, so multilingual text is never corrupted, while Unicode tag
+    characters and noncharacters are always removed. Cyrillic/Greek
+    Latin-lookalike characters are mapped back to Latin only inside mixed-script
+    words, so genuine Cyrillic or Greek prose is never rewritten. Findings that
+    follow are located in the normalized text: line numbers are unaffected,
+    columns can shift only on lines that contained the removed characters.
+    """
+    counts = {"invisible": 0, "homoglyph": 0}
+    homoglyph_offset = -1
+    lead_bom = text.startswith("")
+    body = text[1:] if lead_bom else text
+    offset_base = 1 if lead_bom else 0
+
+    def swap_word(match: re.Match[str]) -> str:
+        nonlocal homoglyph_offset
+        word = match.group(0)
+        if not any(char in HOMOGLYPH_LATIN for char in word):
+            return word
+        counts["homoglyph"] += sum(1 for char in word if char in HOMOGLYPH_LATIN)
+        if homoglyph_offset < 0:
+            homoglyph_offset = match.start() + offset_base
+        return "".join(HOMOGLYPH_LATIN.get(char, char) for char in word)
+
+    # The homoglyph swap is length-preserving, so offsets into ``swapped`` still
+    # index the original body and stay comparable with the leading-BOM base.
+    swapped = WORD_WITH_HOMOGLYPH_RE.sub(swap_word, body)
+    normalized, counts["invisible"], invisible_offset = _strip_invisibles(swapped, offset_base)
+    offsets = [value for value in (homoglyph_offset, invisible_offset) if value >= 0]
+    first_offset = min(offsets) if offsets else -1
+    if lead_bom:
+        normalized = "" + normalized
+    return normalized, counts, first_offset
+
+
+def normalize_citation(value: str) -> str:
+    normalized = URL_RE.sub(lambda match: normalize_url(match.group(0)), value)
+    return normalize_space(normalized).lower()
+
+
+def normalize_date(value: str) -> str:
+    return normalize_space(value.replace(",", "")).lower()
+
+
+def normalize_number(value: str) -> str:
+    normalized = normalize_space(value).lower().replace(",", "")
+    return re.sub(r"\s*(?:-|–|—|to)\s*", "-", normalized)
+
+
+def normalize_name(value: str) -> str:
+    return normalize_space(value).strip(".,:;").lower()
+
+
+def normalize_quote(value: str) -> str:
+    return normalize_space(value)
+
+
+def citation_spans(text: str) -> list[tuple[int, int]]:
+    spans = []
+    for regex in (MARKDOWN_LINK_RE, FOOTNOTE_DEF_RE, FOOTNOTE_REF_RE, REF_TAG_RE, CITE_TEMPLATE_RE):
+        spans.extend(regex_spans(text, regex))
+    return spans
+
+
+def masked_for_prose(text: str) -> str:
+    return blank_spans(text, regex_spans(text, CODE_BLOCK_RE) + citation_spans(text) + regex_spans(text, URL_RE))
+
+
+def token_from_match(kind: str, match: re.Match[str], value: str | None = None) -> ProtectedToken:
+    raw = match.group(0)
+    return ProtectedToken(kind, value if value is not None else normalize_space(raw), evidence(raw), match.start())
+
+
+def extract_url_tokens(text: str) -> list[ProtectedToken]:
+    return [
+        token_from_match("url", match, normalize_url(match.group(0)))
+        for match in URL_RE.finditer(blank_spans(text, regex_spans(text, CODE_BLOCK_RE)))
+    ]
+
+
+def extract_date_tokens(text: str) -> list[ProtectedToken]:
+    masked = masked_for_prose(text)
+    return [token_from_match("date", match, normalize_date(match.group(0))) for match in DATE_RE.finditer(masked)]
+
+
+def extract_number_tokens(text: str) -> list[ProtectedToken]:
+    prose = masked_for_prose(text)
+    masked = blank_spans(prose, regex_spans(prose, DATE_RE))
+    tokens = []
+    occupied: list[tuple[int, int]] = []
+    for regex in (CURRENCY_RE, PERCENT_RE, RANGE_RE):
+        for match in regex.finditer(blank_spans(masked, occupied)):
+            tokens.append(token_from_match("number", match, normalize_number(match.group(0))))
+            occupied.append((match.start(), match.end()))
+    for match in NUMBER_RE.finditer(blank_spans(masked, occupied)):
+        tokens.append(token_from_match("number", match, normalize_number(match.group(0))))
+    return tokens
+
+
+def extract_name_tokens(
+    text: str, ordinary: set[str] | None = None
+) -> list[ProtectedToken]:
+    prose = masked_for_prose(text)
+    masked_lines = []
+    for line in prose.splitlines(keepends=True):
+        if not line.lstrip().startswith("#"):
+            masked_lines.append(line)
+            continue
+        newline = "\n" if line.endswith("\n") else ""
+        body = line[:-1] if newline else line
+        masked_lines.append(" " * len(body) + newline)
+    prose = "".join(masked_lines)
+    if ordinary is None:
+        ordinary = name_vocabulary(prose)
+    tokens = []
+    for match in NAME_RE.finditer(prose):
+        # A greedy run can span a sentence boundary; each side of the boundary
+        # is judged on its own, and every piece after the first opens a sentence
+        # by construction.
+        pieces = []
+        position = 0
+        span = match.group(0)
+        for boundary in NAME_SENTENCE_SPLIT_RE.finditer(span):
+            word = re.findall(r"[A-Za-z]+", span[position : boundary.start()])
+            if word and word[-1].lower() in NAME_ABBREVIATIONS:
+                continue
+            pieces.append((match.start() + position, span[position : boundary.start()]))
+            position = boundary.end()
+        pieces.append((match.start() + position, span[position:]))
+        for index, (offset, piece) in enumerate(pieces):
+            trimmed = False
+            if index > 0 or name_run_is_sentence_initial(prose, offset):
+                head_match = NAME_HEAD_RE.match(piece)
+                if head_match and head_is_ordinary_word(
+                    piece[: head_match.end()].strip(), ordinary
+                ):
+                    offset += head_match.end()
+                    piece = piece[head_match.end() :]
+                    trimmed = True
+            raw = normalize_space(piece)
+            words_in_name = re.findall(r"[A-Za-z][A-Za-z0-9'.&-]*", raw)
+            semantic_words = [
+                word for word in words_in_name if word.lower() not in NAME_CONNECTORS
+            ]
+            if len(semantic_words) < 2:
+                continue
+            if (
+                not trimmed
+                and semantic_words[0] in NAME_EXCLUDE_START
+                and not ORG_HINT_RE.search(raw)
+            ):
+                continue
+            tokens.append(ProtectedToken("name", normalize_name(raw), evidence(raw), offset))
+    return tokens
+
+
+def extract_citation_tokens(text: str) -> list[ProtectedToken]:
+    masked = blank_spans(text, regex_spans(text, CODE_BLOCK_RE))
+    tokens = []
+    for match in MARKDOWN_LINK_RE.finditer(masked):
+        label = normalize_space(match.group(1)).lower()
+        target = normalize_url(match.group(2).split()[0])
+        tokens.append(ProtectedToken("citation", f"markdown:{label}->{target}", evidence(match.group(0)), match.start()))
+    for regex, prefix in (
+        (FOOTNOTE_DEF_RE, "footnote_def"),
+        (FOOTNOTE_REF_RE, "footnote_ref"),
+        (REF_TAG_RE, "ref"),
+        (CITE_TEMPLATE_RE, "cite"),
+    ):
+        for match in regex.finditer(masked):
+            tokens.append(
+                ProtectedToken("citation", f"{prefix}:{normalize_citation(match.group(0))}", evidence(match.group(0)), match.start())
+            )
+    return tokens
+
+
+def extract_quote_tokens(text: str) -> list[ProtectedToken]:
+    masked = blank_spans(text, regex_spans(text, CODE_BLOCK_RE))
+    tokens = [token_from_match("quote", match, normalize_quote(match.group(0))) for match in QUOTE_RE.finditer(masked)]
+    for match in BLOCKQUOTE_RE.finditer(masked):
+        tokens.append(token_from_match("quote", match, normalize_quote(match.group(0))))
+    return tokens
+
+
+def extract_code_block_tokens(text: str) -> list[ProtectedToken]:
+    tokens = []
+    for match in CODE_BLOCK_RE.finditer(text):
+        block = match.group(0)
+        digest = hashlib.sha256(block.encode("utf-8")).hexdigest()
+        first_line = block.splitlines()[0] if block.splitlines() else "```"
+        tokens.append(ProtectedToken("code_block", digest, evidence(first_line), match.start()))
+    return tokens
+
+
+def compare_finding(
+    finding_id: str,
+    message: str,
+    token: ProtectedToken,
+    starts: list[int],
+    side: str,
+    source_risk: bool = False,
+) -> dict[str, object]:
+    line, column = line_column(starts, token.offset)
+    return {
+        "id": finding_id,
+        "family": None,
+        "severity": "error",
+        "line": line,
+        "column": column,
+        "evidence": token.evidence,
+        "message": message,
+        "source_risk": source_risk,
+        "side": side,
+    }
+
+
+def token_buckets(tokens: list[ProtectedToken]) -> dict[str, list[ProtectedToken]]:
+    buckets: dict[str, list[ProtectedToken]] = {}
+    for token in tokens:
+        buckets.setdefault(token.value, []).append(token)
+    return buckets
+
+
+def compare_token_sets(
+    kind: str,
+    original_tokens: list[ProtectedToken],
+    revised_tokens: list[ProtectedToken],
+    original_starts: list[int],
+    revised_starts: list[int],
+) -> list[dict[str, object]]:
+    labels = {
+        "citation": "citation marker",
+        "date": "date",
+        "name": "name",
+        "number": "number",
+        "url": "URL target",
+    }
+    source_kinds = {"citation", "url"}
+    original_counts = Counter(token.value for token in original_tokens)
+    revised_counts = Counter(token.value for token in revised_tokens)
+    if kind == "name":
+        # What a name protects is the REFERENT, not how many times it is
+        # repeated. Trimming one of an article's many mentions of its own
+        # subject is a copy edit, not a dropped name, so a name still present in
+        # the other text raises nothing; only a name that disappears entirely,
+        # or appears from nowhere, is reported.
+        original_counts = Counter(dict.fromkeys(original_counts, 1))
+        revised_counts = Counter(dict.fromkeys(revised_counts, 1))
+    original_buckets = token_buckets(original_tokens)
+    revised_buckets = token_buckets(revised_tokens)
+    findings = []
+    for value, count in (original_counts - revised_counts).items():
+        for token in original_buckets[value][:count]:
+            findings.append(
+                compare_finding(
+                    f"compare.{kind}.dropped",
+                    f"Dropped protected {labels[kind]}",
+                    token,
+                    original_starts,
+                    "original",
+                    kind in source_kinds,
+                )
+            )
+    for value, count in (revised_counts - original_counts).items():
+        for token in revised_buckets[value][:count]:
+            findings.append(
+                compare_finding(
+                    f"compare.{kind}.introduced",
+                    f"Introduced protected {labels[kind]}",
+                    token,
+                    revised_starts,
+                    "revised",
+                    kind in source_kinds,
+                )
+            )
+    return findings
+
+
+def markdown_link_targets(text: str) -> dict[str, list[ProtectedToken]]:
+    """Link targets per label, in document order (a label can repeat)."""
+    masked = blank_spans(text, regex_spans(text, CODE_BLOCK_RE))
+    targets: dict[str, list[ProtectedToken]] = {}
+    for match in MARKDOWN_LINK_RE.finditer(masked):
+        label = normalize_space(match.group(1)).lower()
+        target = normalize_url(match.group(2).split()[0])
+        targets.setdefault(label, []).append(
+            ProtectedToken("citation", target, evidence(match.group(0)), match.start())
+        )
+    return targets
+
+
+def compare_markdown_targets(
+    original_text: str,
+    revised_text: str,
+    original_starts: list[int],
+) -> list[dict[str, object]]:
+    original_links = markdown_link_targets(original_text)
+    revised_links = markdown_link_targets(revised_text)
+    findings = []
+    for label, original_tokens in original_links.items():
+        # Pair repeated labels by occurrence; a dict keyed on label alone kept
+        # only the last link and missed a retargeted earlier one.
+        pairs = zip(original_tokens, revised_links.get(label, []))
+        for original_token, revised_token in pairs:
+            if revised_token.value == original_token.value:
+                continue
+            findings.append(
+                compare_finding(
+                    "compare.citation.changed_target",
+                    f"Changed Markdown link target for [{label}]",
+                    original_token,
+                    original_starts,
+                    "original",
+                    True,
+                )
+            )
+    return findings
+
+
+def compare_ordered_tokens(
+    kind: str,
+    original_tokens: list[ProtectedToken],
+    revised_tokens: list[ProtectedToken],
+    original_starts: list[int],
+    revised_starts: list[int],
+) -> list[dict[str, object]]:
+    changed_messages = {
+        "code_block": "Changed fenced code block",
+        "quote": "Changed quoted text or blockquote",
+    }
+    label = kind.replace("_", " ")
+
+    def finding(suffix: str, message: str, token: ProtectedToken, side: str) -> dict[str, object]:
+        starts = original_starts if side == "original" else revised_starts
+        return compare_finding(f"compare.{kind}.{suffix}", message, token, starts, side, False)
+
+    # Align the two sequences before comparing, so dropping the first quote
+    # reports one dropped quote instead of shifting every later quote into a
+    # false "changed" pair.
+    matcher = difflib.SequenceMatcher(
+        a=[token.value for token in original_tokens],
+        b=[token.value for token in revised_tokens],
+        autojunk=False,
+    )
+    findings = []
+    for tag, a_start, a_end, b_start, b_end in matcher.get_opcodes():
+        if tag == "equal":
+            continue
+        originals = original_tokens[a_start:a_end]
+        revised = revised_tokens[b_start:b_end]
+        paired = min(len(originals), len(revised)) if tag == "replace" else 0
+        for original_token in originals[:paired]:
+            findings.append(finding("changed", changed_messages[kind], original_token, "original"))
+        for token in originals[paired:]:
+            findings.append(finding("dropped", f"Dropped protected {label}", token, "original"))
+        for token in revised[paired:]:
+            findings.append(finding("introduced", f"Introduced protected {label}", token, "revised"))
+    return findings
+
+
+def sentence_records(text: str) -> list[dict[str, object]]:
+    records = []
+    pattern = re.compile(r".+?(?:(?<=[.!?])\s+(?=[A-Z0-9\"“'])|\n{2,}|$)", re.S)
+    for match in pattern.finditer(text):
+        sentence = match.group(0).strip()
+        if not sentence or not SOURCE_MARKER_RE.search(sentence):
+            continue
+        records.append(
+            {
+                "text": sentence,
+                "normalized": normalize_sentence(sentence),
+                "terms": meaningful_terms(sentence),
+                "markers": evidence_markers(sentence),
+                "offset": match.start() + len(match.group(0)) - len(match.group(0).lstrip()),
+            }
+        )
+    return records
+
+
+def normalize_sentence(sentence: str) -> str:
+    normalized = MARKDOWN_LINK_RE.sub(lambda match: match.group(1), sentence)
+    normalized = URL_RE.sub(" ", normalized)
+    normalized = REF_TAG_RE.sub(" ", normalized)
+    normalized = CITE_TEMPLATE_RE.sub(" ", normalized)
+    normalized = FOOTNOTE_REF_RE.sub(" ", normalized)
+    return re.sub(r"[^a-z0-9]+", " ", normalized.lower()).strip()
+
+
+def meaningful_terms(sentence: str) -> set[str]:
+    return {
+        term
+        for term in re.findall(r"[a-z0-9]+", normalize_sentence(sentence))
+        if len(term) > 2 and term not in STOPWORDS
+    }
+
+
+def evidence_markers(sentence: str) -> set[str]:
+    markers = set()
+    if URL_RE.search(sentence):
+        markers.add("url")
+    if MARKDOWN_LINK_RE.search(sentence):
+        markers.add("markdown_link")
+    if REF_TAG_RE.search(sentence):
+        markers.add("ref")
+    if CITE_TEMPLATE_RE.search(sentence):
+        markers.add("cite_template")
+    if FOOTNOTE_REF_RE.search(sentence):
+        markers.add("footnote")
+    if REPORTING_LANGUAGE_RE.search(sentence):
+        markers.add("reporting_language")
+    return markers
+
+
+def overlap_score(left_terms: set[str], right_terms: set[str]) -> float:
+    if not left_terms or not right_terms:
+        return 0.0
+    return len(left_terms & right_terms) / len(left_terms | right_terms)
+
+
+def best_sentence_match(record: dict[str, object], candidates: list[dict[str, object]]) -> tuple[dict[str, object] | None, float]:
+    best_record = None
+    best_score = 0.0
+    for candidate in candidates:
+        score = overlap_score(set(record["terms"]), set(candidate["terms"]))
+        if score > best_score:
+            best_score = score
+            best_record = candidate
+    return best_record, best_score
+
+
+def source_statement_token(record: dict[str, object]) -> ProtectedToken:
+    return ProtectedToken("source_statement", str(record["normalized"]), evidence(str(record["text"])), int(record["offset"]))
+
+
+def compare_source_statements(
+    original_text: str,
+    revised_text: str,
+    original_starts: list[int],
+    revised_starts: list[int],
+) -> list[dict[str, object]]:
+    original_records = sentence_records(original_text)
+    revised_records = sentence_records(revised_text)
+    revised_norms = {record["normalized"] for record in revised_records}
+    original_norms = {record["normalized"] for record in original_records}
+    findings = []
+    for record in original_records:
+        if record["normalized"] in revised_norms:
+            continue
+        candidate, score = best_sentence_match(record, revised_records)
+        token = source_statement_token(record)
+        if candidate and score >= 0.4:
+            dropped_markers = set(record["markers"]) - set(candidate["markers"])
+            if dropped_markers:
+                findings.append(
+                    compare_finding(
+                        "compare.source_statement.evidence_marker_dropped",
+                        "Source-dependent sentence changed without preserving its evidence marker",
+                        token,
+                        original_starts,
+                        "original",
+                        True,
+                    )
+                )
+        else:
+            findings.append(
+                compare_finding(
+                    "compare.source_statement.dropped",
+                    "Dropped source-dependent statement",
+                    token,
+                    original_starts,
+                    "original",
+                    True,
+                )
+            )
+    for record in revised_records:
+        if record["normalized"] in original_norms:
+            continue
+        candidate, score = best_sentence_match(record, original_records)
+        if not candidate or score < 0.4:
+            findings.append(
+                compare_finding(
+                    "compare.source_statement.introduced",
+                    "Introduced source-dependent statement",
+                    source_statement_token(record),
+                    revised_starts,
+                    "revised",
+                    True,
+                )
+            )
+    return findings
+
+
+def name_extractor_for(original_text: str, revised_text: str):
+    """Name extractor bound to the joint lowercase vocabulary of both texts."""
+    ordinary = name_vocabulary(original_text, revised_text)
+    return lambda text: extract_name_tokens(text, ordinary)
+
+
+def compare_texts(original_text: str, revised_text: str, original_path: str, revised_path: str) -> dict[str, object]:
+    original_starts = line_starts(original_text)
+    revised_starts = line_starts(revised_text)
+    findings: list[dict[str, object]] = []
+    findings.extend(compare_markdown_targets(original_text, revised_text, original_starts))
+    for kind, extractor in (
+        ("number", extract_number_tokens),
+        ("date", extract_date_tokens),
+        # Both sides share one lowercase vocabulary: a word the ORIGINAL
+        # shows in lowercase still proves it ordinary when the revision
+        # promotes it to a sentence head.
+        ("name", name_extractor_for(original_text, revised_text)),
+        ("url", extract_url_tokens),
+        ("citation", extract_citation_tokens),
+    ):
+        findings.extend(compare_token_sets(kind, extractor(original_text), extractor(revised_text), original_starts, revised_starts))
+    findings.extend(
+        compare_ordered_tokens(
+            "quote",
+            extract_quote_tokens(original_text),
+            extract_quote_tokens(revised_text),
+            original_starts,
+            revised_starts,
+        )
+    )
+    findings.extend(
+        compare_ordered_tokens(
+            "code_block",
+            extract_code_block_tokens(original_text),
+            extract_code_block_tokens(revised_text),
+            original_starts,
+            revised_starts,
+        )
+    )
+    findings.extend(compare_source_statements(original_text, revised_text, original_starts, revised_starts))
+    findings.sort(key=lambda item: (str(item["side"]), int(item["line"]), int(item["column"]), str(item["id"])))
+    return {
+        "original": original_path,
+        "revised": revised_path,
+        "findings": findings,
+    }
+
+
+def make_finding(rule: Rule, match: re.Match[str], starts: list[int]) -> dict[str, object]:
+    line, column = line_column(starts, match.start())
+    return {
+        "id": rule.id,
+        "family": rule.family,
+        "severity": rule.severity,
+        "line": line,
+        "column": column,
+        "evidence": evidence(match.group(0)),
+        "message": rule.message,
+        "source_risk": rule.source_risk,
+    }
+
+
+# Letters and digits in any script, joined by inner hyphens and straight or
+# curly apostrophes. An ASCII-only class split "café" into "caf" and "don’t"
+# into "don" + "t", which skewed word counts, sentence lengths, and MATTR on
+# accented or typographically quoted text.
+WORD_RE = re.compile(r"[^\W_]+(?:[-'’][^\W_]+)*")
+
+
+def words(text: str) -> list[str]:
+    return WORD_RE.findall(text)
+
+
+def paragraphs(text: str) -> list[str]:
+    return [block.strip() for block in re.split(r"\n\s*\n", text) if block.strip()]
+
+
+def sentences(text: str) -> list[str]:
+    body = "\n".join(line for line in text.splitlines() if not line.lstrip().startswith("#"))
+    parts = re.split(r"(?<=[.!?])\s+|\n{2,}", body)
+    return [part.strip() for part in parts if words(part)]
+
+
+def coefficient_of_variation(lengths: list[int]) -> float:
+    if not lengths:
+        return 0.0
+    mean = sum(lengths) / len(lengths)
+    if mean == 0:
+        return 0.0
+    variance = sum((length - mean) ** 2 for length in lengths) / len(lengths)
+    return math.sqrt(variance) / mean
+
+
+def moving_avg_type_token_ratio(token_list: list[str], window: int = 50) -> float | None:
+    """Moving-average type-token ratio (MATTR) over ``window``-token windows.
+
+    A length-robust lexical-diversity measure: unlike the plain type-token
+    ratio it does not decay as a text grows longer, because it averages the TTR
+    of a sliding fixed-size window rather than dividing uniques by total. Tokens
+    are lowercased so casing does not inflate the type count. Returned rounded
+    to 2 dp.
+
+    Returns None when the text is shorter than one window. A short text's
+    "MATTR" would just be its plain TTR, which is length-dependent and not
+    comparable with a true windowed value from a longer document.
+
+    Reported as a diagnostic stat only, never as a finding or a score input.
+    See reference/mattr-calibration.md for why.
+    """
+    if window < 1:
+        raise ValueError(f"window must be a positive integer, got {window}")
+    if len(token_list) < window:
+        return None
+    lowered = [token.lower() for token in token_list]
+    # Slide one count table across the text: O(n) instead of a fresh set per
+    # window.
+    counts = Counter(lowered[:window])
+    total_types = len(counts)
+    for index in range(window, len(lowered)):
+        incoming = lowered[index]
+        outgoing = lowered[index - window]
+        counts[outgoing] -= 1
+        if counts[outgoing] == 0:
+            del counts[outgoing]
+        counts[incoming] += 1
+        total_types += len(counts)
+    windows = len(lowered) - window + 1
+    return round(total_types / (windows * window), 2)
+
+
+def title_case_heading_count(text: str) -> int:
+    count = 0
+    for line in text.splitlines():
+        match = re.match(r"^\s{0,3}#{1,6}\s+(.+)$", line)
+        if not match:
+            continue
+        heading_words = [word for word in re.findall(r"[A-Za-z][A-Za-z'-]*", match.group(1)) if len(word) > 2]
+        if heading_words and sum(word[:1].isupper() for word in heading_words) / len(heading_words) >= 0.6:
+            count += 1
+    return count
+
+
+def max_uniform_run(sentence_lengths: list[int]) -> int:
+    """Longest run of consecutive sentences whose lengths stay within 5 words."""
+    best = run_start = 0
+    for index in range(len(sentence_lengths)):
+        window = sentence_lengths[run_start : index + 1]
+        while max(window) - min(window) > 5:
+            run_start += 1
+            window = sentence_lengths[run_start : index + 1]
+        best = max(best, index - run_start + 1)
+    return best
+
+
+def stats_for(text: str) -> dict[str, int | float]:
+    token_list = words(text)
+    sentence_list = sentences(text)
+    sentence_lengths = [len(words(sentence)) for sentence in sentence_list]
+    word_count = len(token_list)
+    unique_words = {word.lower() for word in token_list}
+    return {
+        "words": word_count,
+        "sentences": len(sentence_list),
+        "avg_sentence_words": round(sum(sentence_lengths) / len(sentence_lengths), 2) if sentence_lengths else 0,
+        "sentence_length_cv": round(coefficient_of_variation(sentence_lengths), 2),
+        "sentence_length_range": (max(sentence_lengths) - min(sentence_lengths)) if sentence_lengths else 0,
+        "midband_sentence_share": round(
+            sum(1 for length in sentence_lengths if 10 <= length <= 20) / len(sentence_lengths), 2
+        ) if sentence_lengths else 0,
+        "max_uniform_run": max_uniform_run(sentence_lengths),
+        "paragraphs": len(paragraphs(text)),
+        "type_token_ratio": round(len(unique_words) / word_count, 2) if word_count else 0,
+        "mattr_50": moving_avg_type_token_ratio(token_list, 50),
+        "em_dash_count": text.count("—"),
+        "heading_count": len(re.findall(r"^\s{0,3}#{1,6}\s+", text, re.M)),
+        "title_case_heading_count": title_case_heading_count(text),
+        "bold_marker_count": text.count("**"),
+        "table_line_count": len(re.findall(r"^\s*\|.+\|\s*$", text, re.M)),
+        "bullet_count": len(re.findall(r"^\s*[-*+]\s+", text, re.M)),
+        "code_block_count": len(CODE_BLOCK_RE.findall(text)),
+    }
+
+
+def regex_findings(text: str, rules: Iterable[Rule], starts: list[int]) -> list[dict[str, object]]:
+    found = []
+    for rule in rules:
+        for match in rule.regex.finditer(text):
+            found.append(make_finding(rule, match, starts))
+            if rule.once_per_doc:
+                break
+    return found
+
+
+def ai_vocab_findings(text: str, starts: list[int]) -> list[dict[str, object]]:
+    found_terms = [(match.group(0).lower(), match.start()) for match in re.finditer(r"[A-Za-z][A-Za-z'-]*", text)]
+    matched = [(term, offset) for term, offset in found_terms if term in AI_VOCAB]
+    # A cluster means distinct words. One topical word repeated ("robust
+    # estimators ... robust ... robust") is not a vocabulary cluster.
+    distinct_terms = {term for term, _offset in matched}
+    tier1_terms = distinct_terms & AI_VOCAB_TIER1
+    if len(distinct_terms) < 3 and len(tier1_terms) < 2:
+        paragraph_hits = []
+        cursor = 0
+        for paragraph in paragraphs(text):
+            start = text.find(paragraph, cursor)
+            cursor = start + len(paragraph)
+            terms = {term for term in re.findall(r"[A-Za-z][A-Za-z'-]*", paragraph.lower()) if term in AI_VOCAB}
+            if len(terms) >= 2:
+                paragraph_hits.append((sorted(terms), start))
+        if not paragraph_hits:
+            return []
+        terms, offset = paragraph_hits[0]
+    else:
+        terms = sorted(distinct_terms)
+        offset = matched[0][1]
+
+    line, column = line_column(starts, offset)
+    return [
+        {
+            "id": "family4.ai_vocab_cluster",
+            "family": 4,
+            "severity": "warning",
+            "line": line,
+            "column": column,
+            "evidence": ", ".join(terms[:12]),
+            "message": "AI-vocabulary cluster",
+            "source_risk": False,
+        }
+    ]
+
+
+def rhythm_findings(stats: dict[str, int | float]) -> list[dict[str, object]]:
+    findings = []
+    if stats["sentences"] >= 4 and stats["sentence_length_cv"] <= 0.2:
+        findings.append(
+            {
+                "id": "structure.low_sentence_variance",
+                "family": 8,
+                "severity": "info",
+                "line": 1,
+                "column": 1,
+                "evidence": f"sentence_length_cv={stats['sentence_length_cv']}",
+                "message": "Low sentence-length variance can read mechanically, even in human prose",
+                "source_risk": False,
+            }
+        )
+    if stats["paragraphs"] >= 4 and stats["sentences"] and stats["avg_sentence_words"] >= 18:
+        findings.append(
+            {
+                "id": "structure.long_uniform_paragraphs",
+                "family": 8,
+                "severity": "info",
+                "line": 1,
+                "column": 1,
+                "evidence": f"paragraphs={stats['paragraphs']}, avg_sentence_words={stats['avg_sentence_words']}",
+                "message": "Long regular paragraphs may need rhythm review",
+                "source_risk": False,
+            }
+        )
+    # Threshold calibrated against the human-control corpus (corpus/RESULTS.md):
+    # >=4 fires on 40% of human documents, >=6 on 11% — comparable to the other
+    # structure signals. Info severity either way; this is a rhythm nudge.
+    if stats["max_uniform_run"] >= 6:
+        findings.append(
+            {
+                "id": "structure.uniform_length_run",
+                "family": 8,
+                "severity": "info",
+                "line": 1,
+                "column": 1,
+                "evidence": f"max_uniform_run={stats['max_uniform_run']}",
+                "message": "Run of consecutive sentences within 5 words of each other",
+                "source_risk": False,
+            }
+        )
+    if (
+        stats["sentences"] >= 8
+        and stats["midband_sentence_share"] >= 0.6
+        and stats["sentence_length_range"] < 20
+    ):
+        findings.append(
+            {
+                "id": "structure.midband_dominance",
+                "family": 8,
+                "severity": "info",
+                "line": 1,
+                "column": 1,
+                "evidence": (
+                    f"midband_sentence_share={stats['midband_sentence_share']}, "
+                    f"sentence_length_range={stats['sentence_length_range']}"
+                ),
+                "message": "Most sentences sit in the 10-20 word band with a narrow range",
+                "source_risk": False,
+            }
+        )
+    return findings
+
+
+ANAPHORA_SKIP_WORDS = {
+    "the", "a", "an", "it", "i", "in", "this", "that", "he", "she", "they", "we", "you",
+}
+
+
+def anaphora_findings(text: str) -> list[dict[str, object]]:
+    """Three or more consecutive sentences opening with the same word (§7.13)."""
+    openers = []
+    for sentence in sentences(text):
+        tokens = words(sentence)
+        openers.append(tokens[0].lower() if tokens else "")
+    findings = []
+    index = 0
+    while index < len(openers):
+        run = 1
+        while index + run < len(openers) and openers[index + run] == openers[index]:
+            run += 1
+        opener = openers[index]
+        if run >= 3 and opener and opener not in ANAPHORA_SKIP_WORDS:
+            findings.append(
+                {
+                    "id": "structure.anaphora",
+                    "family": 8,
+                    "severity": "info",
+                    "line": 1,
+                    "column": 1,
+                    "evidence": f"opener='{opener}' x{run} consecutive sentences",
+                    "message": "Consecutive sentences share the same opening word",
+                    "source_risk": False,
+                }
+            )
+        index += run
+    return findings
+
+
+def risk_score(findings: list[dict[str, object]]) -> int:
+    artifact_count = sum(1 for finding in findings if str(finding["id"]).startswith("artifact."))
+    source_count = sum(1 for finding in findings if finding["source_risk"])
+    family_count = sum(1 for finding in findings if str(finding["id"]).startswith("family"))
+    family_coverage = {finding["family"] for finding in findings if str(finding["id"]).startswith("family")}
+    formula_count = sum(1 for finding in findings if finding["id"] == "family7.rhetorical_formula")
+    structure_count = sum(1 for finding in findings if str(finding["id"]).startswith("structure."))
+    score = 0
+    score += min(40, artifact_count * 10)
+    score += min(30, family_count * 5)
+    score += min(20, source_count * 4)
+    score += min(10, structure_count * 5)
+    if len(family_coverage) >= 5 or family_count >= 10 or formula_count >= 3 or (source_count and family_count >= 6):
+        score = max(score, 60)
+    return min(100, score)
+
+
+def bypass_findings(counts: dict[str, int], first_offset: int, starts: list[int]) -> list[dict[str, object]]:
+    total = counts["invisible"] + counts["homoglyph"]
+    if total == 0:
+        return []
+    line, column = line_column(starts, max(first_offset, 0))
+    return [
+        {
+            "id": "artifact.bypass_characters",
+            "family": 9,
+            "severity": "error",
+            "line": line,
+            "column": column,
+            "evidence": f"invisible={counts['invisible']}, homoglyph={counts['homoglyph']}",
+            "message": "Invisible or lookalike characters; strip them",
+            "source_risk": False,
+        }
+    ]
+
+
+# Inline code: a run of N backticks closed by a run of exactly N, on one line.
+INLINE_CODE_RE = re.compile(r"(?<!`)(`+)(?!`)[^\n]+?(?<!`)\1(?!`)")
+
+
+def mask_code(text: str) -> str:
+    """Blank fenced and inline code, keeping every offset and line break.
+
+    Code is not prose: `utilize()` in a README is an API name, not wordiness.
+    Only the prose rules and stats see the masked text. Artifact rules always
+    see everything: a chatbot reply pasted with its ```markdown wrapper still
+    carries its leaked citation tokens.
+    """
+    fenced = blank_spans(text, regex_spans(text, CODE_BLOCK_RE))
+    return blank_spans(fenced, regex_spans(fenced, INLINE_CODE_RE))
+
+
+def audit_text(text: str, path: str, include_code: bool = False) -> dict[str, object]:
+    original_starts = line_starts(text)
+    text, bypass_counts, bypass_offset = normalize_bypass_text(text)
+    # Bypass characters are judged on the whole text above; code is masked
+    # only for the prose rules and stats below.
+    code_block_count = len(CODE_BLOCK_RE.findall(text))
+    full_text = text
+    if not include_code:
+        text = mask_code(text)
+    # Masking blanks characters in place, so line starts are the same for both.
+    starts = line_starts(text)
+    stats = stats_for(text)
+    stats["code_block_count"] = code_block_count
+    findings = []
+    findings.extend(bypass_findings(bypass_counts, bypass_offset, original_starts))
+    findings.extend(regex_findings(full_text, ARTIFACT_RULES, starts))
+    findings.extend(regex_findings(text, FAMILY_RULES, starts))
+    findings.extend(ai_vocab_findings(text, starts))
+    findings.extend(regex_findings(text, SOURCE_RISK_RULES, starts))
+    findings.extend(regex_findings(text, CLARITY_RULES, starts))
+    findings.extend(rhythm_findings(stats))
+    findings.extend(anaphora_findings(text))
+    findings.sort(key=lambda item: (int(item["line"]), int(item["column"]), str(item["id"])))
+    return {
+        "path": path,
+        "risk_score": risk_score(findings),
+        "stats": stats,
+        "findings": findings,
+    }
+
+
+def severity_for(findings: list[dict[str, object]]) -> str:
+    if not findings:
+        return "info"
+    return max((str(finding["severity"]) for finding in findings), key=lambda value: SEVERITY_ORDER[value])
+
+
+def summarize(documents: list[dict[str, object]], fail_score: int) -> dict[str, object]:
+    all_findings = [finding for document in documents for finding in document["findings"]]
+    max_risk = max((int(document["risk_score"]) for document in documents), default=0)
+    max_severity = severity_for(all_findings)
+    has_error = any(finding["severity"] == "error" for finding in all_findings)
+    exit_code = 2 if has_error else 1 if max_risk >= fail_score else 0
+    return {
+        "documents": len(documents),
+        "max_risk_score": max_risk,
+        "max_severity": max_severity,
+        "artifact_count": sum(1 for finding in all_findings if str(finding["id"]).startswith("artifact.")),
+        "source_risk_count": sum(1 for finding in all_findings if finding["source_risk"]),
+        "family_hit_count": sum(1 for finding in all_findings if str(finding["id"]).startswith("family")),
+        "clarity_hit_count": sum(1 for finding in all_findings if str(finding["id"]).startswith("clarity.")),
+        "exit_code": exit_code,
+    }
+
+
+def summarize_compare(compare: dict[str, object]) -> dict[str, object]:
+    findings = list(compare["findings"])
+    exit_code = 2 if findings else 0
+    return {
+        "documents": 2,
+        "comparisons": 1,
+        "max_risk_score": 0,
+        "max_severity": severity_for(findings),
+        "artifact_count": 0,
+        "source_risk_count": sum(1 for finding in findings if finding["source_risk"]),
+        "family_hit_count": 0,
+        "compare_finding_count": len(findings),
+        "exit_code": exit_code,
+    }
+
+
+def iter_input_files(target: Path) -> list[Path]:
+    if target.is_file():
+        return [target]
+    if target.is_dir():
+        return sorted(path for path in target.rglob("*") if path.is_file() and path.suffix.lower() in {".md", ".txt"})
+    raise FileNotFoundError(f"No such file or directory: {target}")
+
+
+def audit_paths(paths: list[Path], include_code: bool = False) -> list[dict[str, object]]:
+    documents = []
+    for path in paths:
+        text = path.read_text(encoding="utf-8")
+        # Forward slashes on every OS, so JSON and text output (and tests)
+        # read the same on Windows as on Linux. SARIF already does this.
+        documents.append(audit_text(text, path.as_posix(), include_code))
+    return documents
+
+
+def compare_paths(original_path: Path, revised_path: Path) -> dict[str, object]:
+    original_text = original_path.read_text(encoding="utf-8")
+    revised_text = revised_path.read_text(encoding="utf-8")
+    return compare_texts(original_text, revised_text, original_path.as_posix(), revised_path.as_posix())
+
+
+def render_text_report(result: dict[str, object]) -> str:
+    lines = []
+    summary = result["summary"]
+    lines.append(
+        f"Humanizer audit: {summary['documents']} document(s), max risk {summary['max_risk_score']}, "
+        f"severity {summary['max_severity']}, exit {summary['exit_code']}"
+    )
+    for document in result["documents"]:
+        lines.append("")
+        lines.append(f"{document['path']} — risk {document['risk_score']}")
+        for finding in document["findings"]:
+            lines.append(
+                f"  {finding['severity'].upper()} L{finding['line']}:C{finding['column']} "
+                f"{finding['id']} — {finding['message']} [{finding['evidence']}]"
+            )
+    return "\n".join(lines)
+
+
+def render_compare_report(result: dict[str, object]) -> str:
+    summary = result["summary"]
+    compare = result["compare"]
+    lines = [
+        f"Humanizer compare: {compare['original']} -> {compare['revised']}, "
+        f"{summary['compare_finding_count']} finding(s), severity {summary['max_severity']}, "
+        f"exit {summary['exit_code']}"
+    ]
+    for finding in compare["findings"]:
+        lines.append(
+            f"  {finding['severity'].upper()} {finding['side']} L{finding['line']}:C{finding['column']} "
+            f"{finding['id']} — {finding['message']} [{finding['evidence']}]"
+        )
+    return "\n".join(lines)
+
+
+SARIF_LEVELS = {"error": "error", "warning": "warning", "info": "note"}
+SARIF_SCHEMA = "https://json.schemastore.org/sarif-2.1.0.json"
+INFORMATION_URI = "https://github.com/eddyplolz/humanizer-pro"
+
+
+def sarif_uri(path: str) -> str:
+    """A SARIF artifact URI: relative to the working directory when possible,
+    so GitHub code scanning can map it onto the checked-out repository."""
+    if path == "<stdin>":
+        return "stdin"
+    candidate = Path(path)
+    try:
+        relative = candidate.resolve().relative_to(Path.cwd().resolve())
+    except ValueError:
+        return candidate.resolve().as_uri()
+    return quote(relative.as_posix())
+
+
+def render_sarif(result: dict[str, object]) -> dict[str, object]:
+    """SARIF 2.1.0 log for an audit or compare result."""
+    located: list[tuple[str, dict[str, object]]] = []
+    if "compare" in result:
+        compare = result["compare"]
+        for finding in compare["findings"]:
+            located.append((str(compare[finding["side"]]), finding))
+    else:
+        for document in result["documents"]:
+            for finding in document["findings"]:
+                located.append((str(document["path"]), finding))
+    rule_index: dict[str, int] = {}
+    rules: list[dict[str, object]] = []
+    for _path, finding in sorted(located, key=lambda item: str(item[1]["id"])):
+        rule_id = str(finding["id"])
+        if rule_id in rule_index:
+            continue
+        rule_index[rule_id] = len(rules)
+        rules.append(
+            {
+                "id": rule_id,
+                "shortDescription": {"text": str(finding["message"])},
+                "defaultConfiguration": {"level": SARIF_LEVELS[str(finding["severity"])]},
+                "helpUri": INFORMATION_URI,
+            }
+        )
+    results = [
+        {
+            "ruleId": str(finding["id"]),
+            "ruleIndex": rule_index[str(finding["id"])],
+            "level": SARIF_LEVELS[str(finding["severity"])],
+            "message": {"text": f"{finding['message']}: {finding['evidence']}"},
+            "locations": [
+                {
+                    "physicalLocation": {
+                        "artifactLocation": {"uri": sarif_uri(path)},
+                        "region": {
+                            "startLine": int(finding["line"]),
+                            "startColumn": int(finding["column"]),
+                        },
+                    }
+                }
+            ],
+        }
+        for path, finding in located
+    ]
+    return {
+        "$schema": SARIF_SCHEMA,
+        "version": "2.1.0",
+        "runs": [
+            {
+                "tool": {
+                    "driver": {
+                        "name": "humanizer-audit",
+                        "version": __version__,
+                        "informationUri": INFORMATION_URI,
+                        "rules": rules,
+                    }
+                },
+                # Columns count Python code points, not SARIF's default UTF-16 units.
+                "columnKind": "unicodeCodePoints",
+                "results": results,
+            }
+        ],
+    }
+
+
+class AuditArgumentParser(argparse.ArgumentParser):
+    """argparse exits 2 on a usage error, which this CLI reserves for "block".
+
+    A CI job branching on exit codes must not read a typo in its own command
+    line as a leaked artifact, so usage errors exit 3 like read errors.
+    """
+
+    def error(self, message: str) -> None:  # type: ignore[override]
+        self.print_usage(sys.stderr)
+        self.exit(3, f"{self.prog}: error: {message}\n")
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = AuditArgumentParser(description="Audit text for Humanizer Pro tells and source-risk artifacts.")
+    parser.add_argument("targets", nargs="*", metavar="target", help="Files or directories to audit.")
+    parser.add_argument("--stdin", action="store_true", help="Read text from stdin instead of a path.")
+    parser.add_argument(
+        "--compare",
+        nargs=2,
+        metavar=("ORIGINAL", "REVISED"),
+        help="Compare an original and revised file for protected-content drift.",
+    )
+    parser.add_argument("--json", action="store_true", help="Emit JSON instead of a text report.")
+    parser.add_argument("--fail-score", type=int, default=60, help="Risk score that exits with review status 1.")
+    parser.add_argument(
+        "--include-code",
+        action="store_true",
+        help="Also apply prose rules inside fenced and inline code (skipped by default).",
+    )
+    parser.add_argument("--sarif", metavar="PATH", help="Also write findings as SARIF 2.1.0 to PATH.")
+    parser.add_argument("--version", action="version", version=f"humanizer-audit {__version__}")
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    if sum(1 for active in (args.stdin, bool(args.targets), bool(args.compare)) if active) != 1:
+        parser.error("provide exactly one input mode: <file-or-dir>..., --stdin, or --compare ORIGINAL REVISED")
+    try:
+        if args.compare:
+            compare = compare_paths(Path(args.compare[0]), Path(args.compare[1]))
+            summary = summarize_compare(compare)
+            result = {"schema": SCHEMA, "summary": summary, "documents": [], "compare": compare}
+        elif args.stdin:
+            # Decode stdin as strict UTF-8 like file input, rather than with the
+            # platform locale (cp1252 on many Windows setups), and translate
+            # newlines the way text-mode file reads do.
+            raw = sys.stdin.buffer.read().decode("utf-8")
+            text = raw.replace("\r\n", "\n").replace("\r", "\n")
+            documents = [audit_text(text, "<stdin>", args.include_code)]
+            summary = summarize(documents, args.fail_score)
+            result = {"schema": SCHEMA, "summary": summary, "documents": documents}
+        else:
+            paths: list[Path] = []
+            seen: set[Path] = set()
+            for target in args.targets:
+                found = iter_input_files(Path(target))
+                if not found:
+                    print(f"humanizer-audit: no .md or .txt files under {target}", file=sys.stderr)
+                for path in found:
+                    if path not in seen:
+                        seen.add(path)
+                        paths.append(path)
+            documents = audit_paths(paths, args.include_code)
+            summary = summarize(documents, args.fail_score)
+            result = {"schema": SCHEMA, "summary": summary, "documents": documents}
+        if args.sarif:
+            Path(args.sarif).write_text(
+                json.dumps(render_sarif(result), indent=2) + "\n", encoding="utf-8"
+            )
+    except (OSError, UnicodeDecodeError) as exc:
+        print(f"humanizer-audit: {exc}", file=sys.stderr)
+        return 3
+
+    # The text report quotes evidence verbatim, and a Windows pipe or redirect
+    # encodes stdout as cp1252, which cannot hold Cyrillic, CJK, or emoji
+    # evidence. Escape what the stream cannot encode instead of crashing.
+    if hasattr(sys.stdout, "reconfigure"):
+        sys.stdout.reconfigure(errors="backslashreplace")
+    if args.json:
+        print(json.dumps(result, indent=2, sort_keys=True))
+    elif args.compare:
+        print(render_compare_report(result))
+    else:
+        print(render_text_report(result))
+    return int(summary["exit_code"])
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())