aifingerprint 1.0.0__tar.gz

aifingerprint-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sander Buruma
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

aifingerprint-1.0.0/PKG-INFO

@@ -0,0 +1,23 @@
+Metadata-Version: 2.4
+Name: aifingerprint
+Version: 1.0.0
+Summary: Detect AI writing patterns — scores text 0-100 for AI fingerprints
+Author: Sander Buruma
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/sanderburuma/aifingerprint
+Project-URL: Repository, https://github.com/sanderburuma/aifingerprint
+Project-URL: Issues, https://github.com/sanderburuma/aifingerprint/issues
+Keywords: ai,detection,writing,nlp,heuristics,text-analysis
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Text Processing :: Linguistic
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+License-File: LICENSE
+Dynamic: license-file

aifingerprint-1.0.0/README.md

@@ -0,0 +1,91 @@
+# aifingerprint
+
+Scores text 0–100 for AI writing fingerprints. Catches the stuff LLMs can't help doing — flat rhythm, hedge words, compression patterns, that weird punctuation sameness. No API keys, no model downloads, just stdlib Python.
+
+## Installation
+
+```bash
+pip install .
+# or for development:
+pip install -e .
+```
+
+## Usage
+
+```bash
+# Analyze a file
+aifingerprint input.txt
+
+# Read from clipboard
+aifingerprint --clipboard
+
+# Read from stdin
+echo "text to analyze" | aifingerprint
+
+# Generate a markdown report
+aifingerprint input.txt --report
+aifingerprint input.txt --report output.md
+```
+
+## Score interpretation
+
+| Score | Label | Meaning |
+|-------|-------|---------|
+| 0–20 | CLEAN | Looks human |
+| 21–40 | MILD | A few AI-ish traits, probably human |
+| 41–60 | NOTICEABLE | Smells like AI |
+| 61–80 | OBVIOUS | Yeah, that's AI |
+| 81–100 | BLATANT | Copy-pasted straight from ChatGPT |
+
+## What it checks
+
+Ten weighted checks, each scoring 0.0–1.0:
+
+| Check | Weight | What it measures |
+|-------|--------|-----------------|
+| Compression | 20% | LZMA similarity to a known AI corpus |
+| Sentence rhythm | 15% | Coefficient of variation in sentence lengths |
+| Tone | 15% | Hedging, enthusiasm, formality, word length |
+| Punctuation | 12% | Shannon entropy of punctuation distribution |
+| Connectives | 10% | Density of discourse markers (however, moreover...) |
+| Burstiness | 8% | Whether content words cluster or distribute evenly |
+| Vocabulary | 8% | Known AI-favored words (delve, leverage, utilize...) |
+| Structure | 7% | Paragraph uniformity, parallelism, five-paragraph essay |
+| Phrases | 5% | Cliches, hedges, openers, closers |
+| Formatting | 0% | Em dashes, bold bullets, header density (disabled) |
+
+## HTML reports
+
+Generate a markdown report, then convert to styled HTML:
+
+```bash
+aifingerprint input.txt --report
+python -m aifingerprint.html report.md
+```
+
+## How it compares
+
+We tested against the **RoBERTa OpenAI detector** (`openai-community/roberta-base-openai-detector` via HuggingFace Transformers) — the only other pip-installable thing that runs offline on prose. 27 samples, 8 AI-generated, 19 human-written:
+
+| | aifingerprint | RoBERTa |
+|---|---|---|
+| AI samples (avg) | **58%** | 97% |
+| Human samples (avg) | **18%** | 97% |
+| Separation | **40pp gap** | ~0 — labels everything as AI |
+
+RoBERTa was trained on GPT-2 output back in 2019. It thinks Paul Graham, Reddit posts, and Seth Godin are all 100% AI. Basically useless on anything written after 2022. aifingerprint uses heuristics instead of a model, so it doesn't go stale when the next GPT drops.
+
+Other packages in this space:
+
+| Package | Why it doesn't work |
+|---------|-------------------|
+| [gptzero](https://github.com/Haste171/gptzero/) | API wrapper — requires paid GPTZero API key |
+| [openai-detector](https://github.com/promptslab/openai-detector) | Thin wrapper around the same broken RoBERTa model |
+| [sloppylint](https://github.com/rsionnach/sloppylint) | Detects AI patterns in code, not prose |
+| [finbert-ai-detector](https://huggingface.co/msperlin/finbert-ai-detector) | Fine-tuned for financial documents only |
+| [ai-slop-detector](https://github.com/flamehaven/ai-slop-detector) | Browser-based, requires Gemma 270M model download |
+| [textstat](https://github.com/textstat/textstat) | Readability metrics (Flesch, SMOG, etc.) — doesn't attempt detection |
+
+## No dependencies
+
+Runs on Python 3.10+ using only the standard library.

aifingerprint-1.0.0/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["setuptools>=68.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "aifingerprint"
+version = "1.0.0"
+description = "Detect AI writing patterns — scores text 0-100 for AI fingerprints"
+requires-python = ">=3.10"
+license = "MIT"
+authors = [{ name = "Sander Buruma" }]
+keywords = ["ai", "detection", "writing", "nlp", "heuristics", "text-analysis"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Text Processing :: Linguistic",
+    "Typing :: Typed",
+]
+
+[project.urls]
+Homepage = "https://github.com/sanderburuma/aifingerprint"
+Repository = "https://github.com/sanderburuma/aifingerprint"
+Issues = "https://github.com/sanderburuma/aifingerprint/issues"
+
+[project.scripts]
+aifingerprint = "aifingerprint.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]

aifingerprint-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

aifingerprint-1.0.0/src/aifingerprint/__init__.py

@@ -0,0 +1,5 @@
+"""AI writing fingerprint analyzer — detect AI writing patterns in text."""
+
+from aifingerprint.analyzer import analyze, score_label
+
+__all__ = ["analyze", "score_label"]

aifingerprint-1.0.0/src/aifingerprint/__main__.py

@@ -0,0 +1,5 @@
+"""Allow running as `python -m aifingerprint`."""
+
+from aifingerprint.cli import main
+
+main()

aifingerprint-1.0.0/src/aifingerprint/analyzer.py

@@ -0,0 +1,34 @@
+"""Core analyzer — orchestrates all checks and produces a weighted score."""
+
+from aifingerprint.checks import CHECKS
+from aifingerprint.patterns import CATEGORY_WEIGHTS
+
+
+def analyze(text: str) -> tuple[int, dict]:
+    """Run all checks on text and return (score 0-100, results dict).
+
+    Results dict maps category name → (hits: list[str], raw_score: float).
+    """
+    lines = text.splitlines()
+    results = {}
+    weighted_total = 0.0
+
+    for name, fn in CHECKS.items():
+        hits, raw_score = fn(text, lines)
+        results[name] = (hits, raw_score)
+        weighted_total += raw_score * CATEGORY_WEIGHTS[name]
+
+    final_score = max(0, min(100, int(round(weighted_total * 100))))
+    return final_score, results
+
+
+def score_label(score: int) -> str:
+    if score <= 20:
+        return "CLEAN"
+    if score <= 40:
+        return "MILD"
+    if score <= 60:
+        return "NOTICEABLE"
+    if score <= 80:
+        return "OBVIOUS"
+    return "BLATANT"

aifingerprint-1.0.0/src/aifingerprint/checks/__init__.py

@@ -0,0 +1,27 @@
+"""Check functions — each scores text on a specific AI writing dimension."""
+
+from aifingerprint.checks.vocabulary import check as check_vocabulary
+from aifingerprint.checks.phrases import check as check_phrases
+from aifingerprint.checks.structure import check as check_structure
+from aifingerprint.checks.formatting import check as check_formatting
+from aifingerprint.checks.tone import check as check_tone
+from aifingerprint.checks.rhythm import check as check_sentence_rhythm
+from aifingerprint.checks.punctuation import check as check_punctuation
+from aifingerprint.checks.connectives import check as check_connectives
+from aifingerprint.checks.burstiness import check as check_burstiness
+from aifingerprint.checks.compression import check as check_compression
+
+CheckResult = tuple[list[str], float]
+
+CHECKS: dict[str, callable] = {
+    "vocabulary": check_vocabulary,
+    "phrases": check_phrases,
+    "structure": check_structure,
+    "formatting": check_formatting,
+    "tone": check_tone,
+    "sentence_rhythm": check_sentence_rhythm,
+    "punctuation": check_punctuation,
+    "connectives": check_connectives,
+    "burstiness": check_burstiness,
+    "compression": check_compression,
+}

aifingerprint-1.0.0/src/aifingerprint/checks/burstiness.py

@@ -0,0 +1,68 @@
+"""Word burstiness — measures how evenly content words are distributed."""
+
+import math
+import re
+
+STOPWORDS = {
+    "the", "and", "that", "this", "with", "from", "have", "been", "were",
+    "they", "their", "there", "which", "would", "could", "should", "about",
+    "into", "than", "then", "them", "these", "those", "other", "after",
+    "before", "being", "between", "does", "doing", "during", "each",
+    "every", "under", "over", "again", "further", "where", "when", "while",
+    "also", "just", "more", "most", "some", "such", "only", "very",
+    "will", "what", "your", "still",
+}
+
+MIN_WORD_LENGTH = 4  # Only track content words longer than this
+MIN_OCCURRENCES = 3  # Need 3+ occurrences to measure gaps
+MIN_TOTAL_WORDS = 50
+
+BURSTINESS_VERY_LOW = 0.5
+BURSTINESS_LOW = 0.7
+# Score mapping: burstiness 0.3-1.0 → score 1.0-0.0
+SCORE_CEILING = 1.0
+SCORE_RANGE = 0.7
+
+
+def check(text: str, lines: list[str]) -> tuple[list[str], float]:
+    """Human writing clusters topic words; AI distributes them evenly.
+    Measure CV of inter-occurrence gaps for content words."""
+    hits = []
+    words = re.findall(r"\b[a-z]+\b", text.lower())
+    if len(words) < MIN_TOTAL_WORDS:
+        return hits, 0.0
+
+    positions: dict[str, list[int]] = {}
+    for i, w in enumerate(words):
+        if len(w) > MIN_WORD_LENGTH and w not in STOPWORDS:
+            positions.setdefault(w, []).append(i)
+
+    burstiness_values = []
+    for w, pos_list in positions.items():
+        if len(pos_list) < MIN_OCCURRENCES:
+            continue
+        gaps = [pos_list[i + 1] - pos_list[i] for i in range(len(pos_list) - 1)]
+        mean_gap = sum(gaps) / len(gaps)
+        if mean_gap == 0:
+            continue
+        std_gap = math.sqrt(sum((g - mean_gap) ** 2 for g in gaps) / len(gaps))
+        burstiness_values.append(std_gap / mean_gap)
+
+    if not burstiness_values:
+        return hits, 0.0
+
+    avg_burstiness = sum(burstiness_values) / len(burstiness_values)
+
+    if avg_burstiness < BURSTINESS_VERY_LOW:
+        hits.append(
+            f"  Word burstiness: {avg_burstiness:.2f} (very low) "
+            f"— content words are distributed too evenly"
+        )
+    elif avg_burstiness < BURSTINESS_LOW:
+        hits.append(
+            f"  Word burstiness: {avg_burstiness:.2f} (low) "
+            f"— content words lack natural clustering"
+        )
+
+    raw = max(0.0, min(1.0, (SCORE_CEILING - avg_burstiness) / SCORE_RANGE))
+    return hits, raw

aifingerprint-1.0.0/src/aifingerprint/checks/compression.py

@@ -0,0 +1,64 @@
+"""LZMA compression similarity — compares text against known AI corpus."""
+
+import lzma
+import os
+
+# From corpus testing: AI leave-one-out mean ~0.47, human mean ~0.36
+SIMILARITY_HIGH = 0.45
+SIMILARITY_MODERATE = 0.38
+# Score mapping: similarity 0.30-0.50 → score 0.0-1.0
+SCORE_FLOOR = 0.30
+SCORE_RANGE = 0.20
+MIN_TEXT_BYTES = 100
+
+_seed_bytes: bytes | None = None
+
+
+def _load_seed() -> bytes:
+    global _seed_bytes
+    if _seed_bytes is not None:
+        return _seed_bytes
+    seed_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "..", "..", "ai_seed_corpus.txt")
+    seed_path = os.path.normpath(seed_path)
+    if os.path.exists(seed_path):
+        with open(seed_path) as f:
+            _seed_bytes = f.read().encode("utf-8")
+    else:
+        _seed_bytes = b""
+    return _seed_bytes
+
+
+def check(text: str, lines: list[str]) -> tuple[list[str], float]:
+    """Compare how well text compresses when appended to a known AI corpus.
+    AI-like text shares patterns with the seed, producing a higher compression ratio."""
+    hits = []
+    seed = _load_seed()
+    if not seed:
+        return hits, 0.0
+
+    text_bytes = text.encode("utf-8")
+    if len(text_bytes) < MIN_TEXT_BYTES:
+        return hits, 0.0
+
+    seed_compressed = len(lzma.compress(seed))
+    combined_compressed = len(lzma.compress(seed + text_bytes))
+    text_alone = len(lzma.compress(text_bytes))
+
+    if text_alone == 0:
+        return hits, 0.0
+    overhead = combined_compressed - seed_compressed
+    similarity = 1.0 - (overhead / text_alone)
+
+    if similarity > SIMILARITY_HIGH:
+        hits.append(
+            f"  Compression similarity: {similarity:.3f} (high) "
+            f"— text compresses well against AI corpus"
+        )
+    elif similarity > SIMILARITY_MODERATE:
+        hits.append(
+            f"  Compression similarity: {similarity:.3f} (moderate) "
+            f"— some pattern overlap with AI corpus"
+        )
+
+    raw = max(0.0, min(1.0, (similarity - SCORE_FLOOR) / SCORE_RANGE))
+    return hits, raw

aifingerprint-1.0.0/src/aifingerprint/checks/connectives.py

@@ -0,0 +1,41 @@
+"""Discourse connective density — however, moreover, furthermore, etc."""
+
+import re
+
+from aifingerprint.patterns import DISCOURSE_CONNECTIVES
+from aifingerprint.text import split_sentences
+
+DENSITY_HIGH = 0.5  # connectives per sentence
+DENSITY_MODERATE = 0.25
+SCORE_FLOOR = 0.1
+SCORE_RANGE = 0.5
+
+
+def check(text: str, lines: list[str]) -> tuple[list[str], float]:
+    """AI overuses discourse connectives like however, moreover, furthermore."""
+    hits = []
+    sentences = split_sentences(text)
+    if len(sentences) < 3:
+        return hits, 0.0
+
+    words = re.findall(r"\b[a-z]+\b", text.lower())
+    count = sum(1 for w in words if w in DISCOURSE_CONNECTIVES)
+    density = count / len(sentences)
+
+    if density > DENSITY_HIGH:
+        found = [w for w in words if w in DISCOURSE_CONNECTIVES]
+        unique_found = list(dict.fromkeys(found))[:5]
+        hits.append(
+            f"  Connective density: {density:.2f}/sentence (high) "
+            f"— {', '.join(unique_found)}"
+        )
+    elif density > DENSITY_MODERATE:
+        found = [w for w in words if w in DISCOURSE_CONNECTIVES]
+        unique_found = list(dict.fromkeys(found))[:5]
+        hits.append(
+            f"  Connective density: {density:.2f}/sentence (moderate) "
+            f"— {', '.join(unique_found)}"
+        )
+
+    raw = max(0.0, min(1.0, (density - SCORE_FLOOR) / SCORE_RANGE))
+    return hits, raw

aifingerprint-1.0.0/src/aifingerprint/checks/formatting.py

@@ -0,0 +1,51 @@
+"""Formatting pattern detection — em dashes, bold bullets, headers."""
+
+from aifingerprint.patterns import FORMAT_PATTERNS
+
+EM_DASH_PER_500_LIMIT = 2
+BOLD_BULLET_MIN = 3
+HEADER_PER_500_LIMIT = 4
+SHORT_TEXT_HEADER_LIMIT = 3
+SHORT_TEXT_WORD_LIMIT = 500
+
+
+def check(text: str, lines: list[str]) -> tuple[list[str], float]:
+    hits = []
+    total_words = len(text.split())
+
+    # Em dashes
+    em_dashes = FORMAT_PATTERNS["em_dash"].findall(text)
+    em_count = len(em_dashes)
+    if total_words > 0:
+        per_500 = em_count / (total_words / 500)
+        if per_500 > EM_DASH_PER_500_LIMIT:
+            hits.append(f"  Em dash density: {per_500:.1f} per 500 words (limit: {EM_DASH_PER_500_LIMIT}) — {em_count} total")
+
+    # Bold-first bullets
+    bold_bullets = FORMAT_PATTERNS["bold_first_bullet"].findall(text)
+    if len(bold_bullets) >= BOLD_BULLET_MIN:
+        hits.append(f"  Bold-first bullets: {len(bold_bullets)} instances")
+
+    # Header density
+    headers = FORMAT_PATTERNS["header"].findall(text)
+    if total_words > 0 and total_words < SHORT_TEXT_WORD_LIMIT and len(headers) > SHORT_TEXT_HEADER_LIMIT:
+        hits.append(f"  Header density: {len(headers)} headers in {total_words} words — excessive")
+    elif total_words > 0:
+        per_500 = len(headers) / (total_words / 500)
+        if per_500 > HEADER_PER_500_LIMIT:
+            hits.append(f"  Header density: {per_500:.1f} per 500 words — excessive")
+
+    # Title case headers
+    title_case = FORMAT_PATTERNS["title_case_header"].findall(text)
+    if title_case:
+        hits.append(f"  Title Case headers: {len(title_case)} instances (prefer sentence case)")
+
+    score_parts = []
+    if em_count > 0 and total_words > 0:
+        score_parts.append(min(1.0, (em_count / (total_words / 500)) / 6))
+    if bold_bullets:
+        score_parts.append(min(1.0, len(bold_bullets) / 8))
+    if headers and total_words > 0:
+        score_parts.append(min(1.0, (len(headers) / (total_words / 500)) / 8))
+
+    return hits, (sum(score_parts) / max(1, len(score_parts))) if score_parts else 0.0

aifingerprint-1.0.0/src/aifingerprint/checks/phrases.py

@@ -0,0 +1,31 @@
+"""Banned phrase detection — cliches, hedges, openers, closers."""
+
+from aifingerprint.patterns import BANNED_PHRASES, BANNED_SENTENCE_STARTERS
+from aifingerprint.text import split_sentences, find_line
+
+HITS_PER_100_MAX = 3.0  # 3+ per 100 words = max score
+
+
+def check(text: str, lines: list[str]) -> tuple[list[str], float]:
+    hits = []
+
+    for category, phrases in BANNED_PHRASES.items():
+        for phrase in phrases:
+            for i, line in enumerate(lines, 1):
+                if phrase.lower() in line.lower():
+                    idx = line.lower().index(phrase.lower())
+                    matched = line[idx:idx + len(phrase) + 20].rstrip()
+                    hits.append(f"  Line {i}: \"{matched}...\" [{category}]")
+
+    sentences = split_sentences(text)
+    for sent in sentences:
+        for starter in BANNED_SENTENCE_STARTERS:
+            if sent.lower().startswith(starter):
+                line_num = find_line(lines, sent[:30])
+                hits.append(f"  Line {line_num}: starts with \"{starter}\" [transition]")
+
+    total_words = len(text.split())
+    if total_words == 0:
+        return hits, 0.0
+    density = len(hits) / (total_words / 100)
+    return hits, min(1.0, density / HITS_PER_100_MAX)

aifingerprint-1.0.0/src/aifingerprint/checks/punctuation.py

@@ -0,0 +1,39 @@
+"""Punctuation diversity — Shannon entropy of punctuation distribution."""
+
+import math
+from collections import Counter
+
+_PUNCT_CHARS = set('.,;:!?\u2014\u2013-()"\u201c\u201d\'\u2018\u2019')
+
+ENTROPY_VERY_LOW = 0.30
+ENTROPY_LOW = 0.45
+NORM_FLOOR = 0.20  # Below this → max score
+NORM_CEILING = 0.60  # Above this → zero score
+
+
+def check(text: str, lines: list[str]) -> tuple[list[str], float]:
+    """AI uses a narrow range of punctuation. Measure entropy of punct distribution."""
+    hits = []
+    punct = [ch for ch in text if ch in _PUNCT_CHARS]
+    if len(punct) < 10:
+        return hits, 0.0
+
+    freqs = Counter(punct)
+    total = len(punct)
+    entropy = -sum((c / total) * math.log2(c / total) for c in freqs.values())
+    max_entropy = math.log2(len(_PUNCT_CHARS))
+    normalized = entropy / max_entropy if max_entropy > 0 else 0
+
+    if normalized < ENTROPY_VERY_LOW:
+        hits.append(
+            f"  Punctuation diversity: entropy={entropy:.2f} (very low) "
+            f"— almost only commas and periods"
+        )
+    elif normalized < ENTROPY_LOW:
+        hits.append(
+            f"  Punctuation diversity: entropy={entropy:.2f} (low) "
+            f"— limited punctuation variety"
+        )
+
+    raw = max(0.0, min(1.0, (NORM_CEILING - normalized) / (NORM_CEILING - NORM_FLOOR)))
+    return hits, raw

aifingerprint-1.0.0/src/aifingerprint/checks/rhythm.py

@@ -0,0 +1,40 @@
+"""Sentence rhythm analysis — coefficient of variation in sentence lengths."""
+
+import math
+
+from aifingerprint.text import split_sentences
+
+# From corpus testing: AI mean CV ~0.45, human ~0.72
+CV_VERY_LOW = 0.35
+CV_LOW = 0.50
+CV_FLOOR = 0.30  # Below this → max score
+CV_CEILING = 0.70  # Above this → zero score
+
+
+def check(text: str, lines: list[str]) -> tuple[list[str], float]:
+    """AI produces sentences of uniform length. Measure coefficient of variation."""
+    hits = []
+    sentences = split_sentences(text)
+    if len(sentences) < 5:
+        return hits, 0.0
+
+    lengths = [len(s.split()) for s in sentences]
+    mean_len = sum(lengths) / len(lengths)
+    if mean_len == 0:
+        return hits, 0.0
+    std_len = math.sqrt(sum((ln - mean_len) ** 2 for ln in lengths) / len(lengths))
+    cv = std_len / mean_len
+
+    if cv < CV_VERY_LOW:
+        hits.append(
+            f"  Sentence rhythm: CV={cv:.2f} (very low) "
+            f"— sentence lengths are unnaturally uniform"
+        )
+    elif cv < CV_LOW:
+        hits.append(
+            f"  Sentence rhythm: CV={cv:.2f} (low) "
+            f"— sentence lengths lack natural variation"
+        )
+
+    raw = max(0.0, min(1.0, (CV_CEILING - cv) / (CV_CEILING - CV_FLOOR)))
+    return hits, raw