patina-cli 3.11.0

package/patina-max/composite.py

@@ -0,0 +1,457 @@
+#!/usr/bin/env python3
+"""patina-max composite: deterministic 4-axis winner reselection over an
+existing patina-max run directory.
+
+The default patina-max winner picker only sees AI-likeness and MPS, so it
+goes noise-bound when a baseline is already humanized. This script adds two
+Korean-aware deterministic metrics — Register Stability Score (RSS) and
+Edit Conservativeness (EditCons) — and reselects the winner.
+
+Usage
+-----
+    python3 patina-max/composite.py <run_dir> [--weights ...]
+
+Layout consumed
+---------------
+    <run_dir>/
+        input.md      baseline source MDX (required)
+        claude.md     candidate (optional; absent → "missing")
+        gemini.md     candidate (optional)
+        codex.md      candidate (optional; may be a failure note)
+        meta.md       YAML; per-candidate ai_score / mps / status (recommended)
+
+Layout produced
+---------------
+    <run_dir>/
+        composite.md   per-candidate metric table + weighted totals
+        winner.md      winning candidate's text (or a none-found notice)
+
+Default weights (renormalised after dropping the LLM-Judge slot):
+
+    AI=0.353  MPS=0.235  RSS=0.235  EditCons=0.176
+
+Override via .patina.default.yaml:
+
+    composite-weights:
+      ai: 0.353
+      mps: 0.235
+      rss: 0.235
+      edit_cons: 0.176
+
+Or inline:
+
+    python3 patina-max/composite.py <run_dir> --weights ai=0.4,rss=0.3
+"""
+
+from __future__ import annotations
+
+import argparse
+import difflib
+import math
+import re
+import sys
+from collections import Counter
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional
+
+
+# ---------------------------------------------------------------------------
+# Korean register / edit metrics
+# ---------------------------------------------------------------------------
+
+# Sentence-final ending vocabulary. Order matters — longer forms first so the
+# regex engine matches `합니다` before falling back to `다`.
+_ENDING_PATTERNS = [
+    # 합쇼체 (deferential formal): ~ㅂ니다 / ~습니다 / ~ㅂ니까 / ~습니까 / ~십시오
+    ("hapsho", r"(?:[가-힣]니다|[가-힣]니까|[가-힣]시오|십시오|십시요)"),
+    # 해요체 (polite informal)
+    ("haeyo", r"(?:세요|예요|이에요|에요|해요|어요|아요|네요|군요|지요|죠|[가-힣]요)"),
+    # 해라체 (plain declarative / imperative)
+    ("haera", r"(?:[가-힣]는다|한다|[가-힣]다|하라|마라|보라|들라|[가-힣]아라|[가-힣]어라|[가-힣]라)"),
+    # 해체 (casual / 반말)
+    ("hae", r"(?:해|야|아|어|네|군|지)"),
+]
+
+_SENTENCE_SPLIT = re.compile(r"[.!?。]+\s+|\n+")
+_TRAILING_PUNCT = re.compile(r"[\s.,!?;:。、]+$")
+
+
+def _strip_markdown_noise(text: str) -> str:
+    """Drop fenced code blocks, JSX tags, image lines, and href payloads.
+
+    Composite metrics are about Korean prose. MDX fences and JSX scaffolding
+    would otherwise inflate the token count and skew Edit Conservativeness.
+    """
+    text = re.sub(r"```[\s\S]*?```", "", text)
+    text = re.sub(r"<[A-Z][\w]*\b[^>]*?/?>", "", text)
+    text = re.sub(r"</[A-Z][\w]*>", "", text)
+    text = re.sub(r"!\[[^\]]*\]\([^)]*\)", "", text)
+    text = re.sub(r"\[([^\]]*)\]\([^)]*\)", r"\1", text)
+    text = re.sub(r"\A---\n[\s\S]*?\n---\n", "", text)
+    return text
+
+
+def _split_sentences(text: str) -> list[str]:
+    cleaned = _strip_markdown_noise(text)
+    parts = _SENTENCE_SPLIT.split(cleaned)
+    sentences: list[str] = []
+    for part in parts:
+        for line in part.splitlines():
+            line = line.strip()
+            if not line:
+                continue
+            line = re.sub(r"^\s*([>#\-*]+\s*)+", "", line)
+            line = re.sub(r"^\*\*[^*]+\*\*[\s:—-]*", "", line)
+            line = line.strip()
+            if line:
+                sentences.append(line)
+    return sentences
+
+
+def ending_distribution(text: str) -> Counter[str]:
+    dist: Counter[str] = Counter()
+    for sentence in _split_sentences(text):
+        tail = _TRAILING_PUNCT.sub("", sentence)
+        if not tail:
+            continue
+        bucket = "other"
+        for name, pattern in _ENDING_PATTERNS:
+            if re.search(pattern + r"$", tail):
+                bucket = name
+                break
+        dist[bucket] += 1
+    return dist
+
+
+def cosine_similarity(a: Counter[str], b: Counter[str]) -> float:
+    keys = set(a) | set(b)
+    if not keys:
+        return 0.0
+    dot = sum(a[k] * b[k] for k in keys)
+    norm_a = math.sqrt(sum(v * v for v in a.values()))
+    norm_b = math.sqrt(sum(v * v for v in b.values()))
+    if norm_a == 0 or norm_b == 0:
+        return 0.0
+    return dot / (norm_a * norm_b)
+
+
+def register_stability(baseline: str, candidate: str) -> float:
+    """RSS: cosine similarity of register distributions, scaled to 0-100."""
+    return cosine_similarity(ending_distribution(baseline), ending_distribution(candidate)) * 100.0
+
+
+def edit_conservativeness(baseline: str, candidate: str) -> float:
+    """EditCons: SequenceMatcher ratio on whitespace tokens (0-100)."""
+    base_tokens = _strip_markdown_noise(baseline).split()
+    cand_tokens = _strip_markdown_noise(candidate).split()
+    if not base_tokens and not cand_tokens:
+        return 100.0
+    if not base_tokens or not cand_tokens:
+        return 0.0
+    matcher = difflib.SequenceMatcher(None, base_tokens, cand_tokens, autojunk=False)
+    return matcher.ratio() * 100.0
+
+
+# ---------------------------------------------------------------------------
+# Composite scoring + run-dir IO
+# ---------------------------------------------------------------------------
+
+DEFAULT_WEIGHTS = {
+    "ai": 0.353,
+    "mps": 0.235,
+    "rss": 0.235,
+    "edit_cons": 0.176,
+}
+
+CANDIDATE_MODELS = ("claude", "gemini", "codex")
+RUN_FRONTMATTER = re.compile(r"\A---\n([\s\S]*?)\n---\n", re.MULTILINE)
+NUMBER_RANGE = re.compile(r"(\d+(?:\.\d+)?)\s*[-–~]\s*(\d+(?:\.\d+)?)")
+SINGLE_NUMBER = re.compile(r"(\d+(?:\.\d+)?)")
+NON_NUMERIC_PLACEHOLDERS = {"n/a", "na", "none", "—", "-", "pending", "tbd", "unknown"}
+
+
+@dataclass
+class Candidate:
+    model: str
+    text: str
+    ai_score: Optional[float] = None
+    mps: Optional[float] = None
+    rss: Optional[float] = None
+    edit_cons: Optional[float] = None
+    composite: Optional[float] = None
+    status: str = "unknown"
+    notes: list[str] = field(default_factory=list)
+
+
+def parse_metric(raw: Optional[str]) -> Optional[float]:
+    """Coerce metric strings from meta.md into floats.
+
+    `0-2 (within noise floor)` -> 1.0 (midpoint)
+    `92 (all anchors preserved)` -> 92.0
+    `n/a` / `pending` / `—` -> None
+    """
+    if raw is None:
+        return None
+    raw = str(raw).strip().strip('"').strip("'")
+    if not raw or raw.lower() in NON_NUMERIC_PLACEHOLDERS:
+        return None
+    range_match = NUMBER_RANGE.search(raw)
+    if range_match:
+        return (float(range_match.group(1)) + float(range_match.group(2))) / 2.0
+    single_match = SINGLE_NUMBER.search(raw)
+    if single_match:
+        return float(single_match.group(1))
+    return None
+
+
+def parse_meta_candidates(meta_text: str) -> dict[str, dict[str, str]]:
+    """Pull per-candidate score lines from meta.md without a YAML library."""
+    info: dict[str, dict[str, str]] = {}
+    in_candidates = False
+    current: Optional[dict[str, str]] = None
+    for raw_line in meta_text.splitlines():
+        line = raw_line.rstrip()
+        if not line.startswith(" ") and line.endswith(":"):
+            in_candidates = line.strip() == "candidates:"
+            current = None
+            continue
+        if not in_candidates:
+            continue
+        stripped = line.lstrip()
+        if stripped.startswith("- model:"):
+            model = stripped.split(":", 1)[1].strip()
+            current = {"model": model}
+            info[model] = current
+            continue
+        if current is None:
+            continue
+        if ":" not in stripped:
+            continue
+        key, value = stripped.split(":", 1)
+        key = key.strip()
+        value = value.strip()
+        if value == "|":
+            value = "<multiline>"
+        if key in {"ai_score", "ai_score_instructional", "ai_score_technical", "mps", "status", "wall_time_seconds"}:
+            current[key] = value
+    return info
+
+
+def read_candidate_text(path: Path) -> str:
+    if not path.exists():
+        return ""
+    text = path.read_text(encoding="utf-8")
+    return RUN_FRONTMATTER.sub("", text, count=1)
+
+
+def normalise_weights(weights: dict[str, float]) -> dict[str, float]:
+    total = sum(weights.values())
+    if total <= 0:
+        raise ValueError("weights must sum to a positive number")
+    return {k: v / total for k, v in weights.items()}
+
+
+def parse_weight_overrides(spec: str) -> dict[str, float]:
+    overrides: dict[str, float] = {}
+    for chunk in spec.split(","):
+        chunk = chunk.strip()
+        if not chunk:
+            continue
+        if "=" not in chunk:
+            raise ValueError(f"invalid weight override `{chunk}` (expected key=value)")
+        key, value = chunk.split("=", 1)
+        key = key.strip().lower()
+        if key not in DEFAULT_WEIGHTS:
+            raise ValueError(f"unknown weight key `{key}`; valid: {sorted(DEFAULT_WEIGHTS)}")
+        try:
+            overrides[key] = float(value)
+        except ValueError as exc:
+            raise ValueError(f"weight `{key}` not a number: {value}") from exc
+    return overrides
+
+
+def load_yaml_weights(yaml_path: Path) -> dict[str, float]:
+    """Pick `composite-weights:` out of the patina config without PyYAML."""
+    if not yaml_path.exists():
+        return {}
+    weights: dict[str, float] = {}
+    in_block = False
+    for raw_line in yaml_path.read_text(encoding="utf-8").splitlines():
+        if raw_line.startswith("composite-weights:"):
+            in_block = True
+            continue
+        if in_block:
+            if not raw_line.startswith(" "):
+                break
+            stripped = raw_line.strip()
+            if not stripped or stripped.startswith("#"):
+                continue
+            if ":" not in stripped:
+                break
+            key, value = stripped.split(":", 1)
+            key = key.strip().lower()
+            try:
+                weights[key] = float(value.strip().split("#", 1)[0].strip())
+            except ValueError:
+                continue
+    return {k: v for k, v in weights.items() if k in DEFAULT_WEIGHTS}
+
+
+def resolve_weights(yaml_path: Path, cli_override: Optional[str]) -> dict[str, float]:
+    weights = dict(DEFAULT_WEIGHTS)
+    weights.update(load_yaml_weights(yaml_path))
+    if cli_override:
+        weights.update(parse_weight_overrides(cli_override))
+    return normalise_weights(weights)
+
+
+def composite_score(candidate: Candidate, weights: dict[str, float]) -> Optional[float]:
+    if candidate.status != "success":
+        return None
+    if any(v is None for v in (candidate.ai_score, candidate.mps, candidate.rss, candidate.edit_cons)):
+        return None
+    return (
+        (100.0 - candidate.ai_score) * weights["ai"]
+        + candidate.mps * weights["mps"]
+        + candidate.rss * weights["rss"]
+        + candidate.edit_cons * weights["edit_cons"]
+    )
+
+
+def render_composite_md(
+    run_dir: Path,
+    weights: dict[str, float],
+    candidates: list[Candidate],
+    winner: Optional[Candidate],
+) -> str:
+    lines: list[str] = []
+    lines.append(f"# patina-composite scores for `{run_dir.name}`")
+    lines.append("")
+    lines.append("Generated by `patina-max/composite.py` — deterministic 4-axis reselection.")
+    lines.append("")
+    lines.append("## Weights")
+    lines.append("")
+    lines.append("| Axis | Weight |")
+    lines.append("|------|-------:|")
+    for key in ("ai", "mps", "rss", "edit_cons"):
+        lines.append(f"| {key} | {weights[key]:.4f} |")
+    lines.append("")
+    lines.append("## Candidate scores")
+    lines.append("")
+    lines.append("| Model | Status | AI | MPS | RSS | EditCons | Composite |")
+    lines.append("|-------|--------|---:|----:|----:|--------:|----------:|")
+    for cand in candidates:
+        ai = "—" if cand.ai_score is None else f"{cand.ai_score:.1f}"
+        mps = "—" if cand.mps is None else f"{cand.mps:.1f}"
+        rss = "—" if cand.rss is None else f"{cand.rss:.1f}"
+        edit = "—" if cand.edit_cons is None else f"{cand.edit_cons:.1f}"
+        comp = "—" if cand.composite is None else f"{cand.composite:.2f}"
+        lines.append(f"| {cand.model} | {cand.status} | {ai} | {mps} | {rss} | {edit} | {comp} |")
+    lines.append("")
+    if winner:
+        lines.append(f"**Winner:** `{winner.model}` — composite {winner.composite:.2f}")
+    else:
+        lines.append("**Winner:** none (no candidate scored successfully)")
+    lines.append("")
+    if any(cand.notes for cand in candidates):
+        lines.append("")
+        lines.append("## Notes")
+        for cand in candidates:
+            for note in cand.notes:
+                lines.append(f"- **{cand.model}**: {note}")
+    return "\n".join(lines) + "\n"
+
+
+def main(argv: Optional[list[str]] = None) -> int:
+    parser = argparse.ArgumentParser(description="patina-max composite winner reselection.")
+    parser.add_argument("run_dir", type=Path, help="path to a patina-max run dir")
+    parser.add_argument(
+        "--weights",
+        type=str,
+        default=None,
+        help="override weights, comma-separated (e.g. ai=0.4,rss=0.3)",
+    )
+    parser.add_argument(
+        "--config",
+        type=Path,
+        default=Path(__file__).resolve().parents[1] / ".patina.default.yaml",
+        help="patina config to read composite-weights from",
+    )
+    args = parser.parse_args(argv)
+
+    run_dir: Path = args.run_dir.resolve()
+    if not run_dir.is_dir():
+        print(f"error: not a directory: {run_dir}", file=sys.stderr)
+        return 2
+
+    input_path = run_dir / "input.md"
+    if not input_path.exists():
+        print(f"error: missing required file: {input_path}", file=sys.stderr)
+        return 2
+    baseline = read_candidate_text(input_path)
+
+    meta_path = run_dir / "meta.md"
+    meta_info: dict[str, dict[str, str]] = {}
+    if meta_path.exists():
+        meta_info = parse_meta_candidates(meta_path.read_text(encoding="utf-8"))
+    else:
+        print(f"warning: missing meta.md at {meta_path}; AI/MPS will be marked unknown", file=sys.stderr)
+
+    weights = resolve_weights(args.config, args.weights)
+
+    candidates: list[Candidate] = []
+    for model in CANDIDATE_MODELS:
+        path = run_dir / f"{model}.md"
+        if not path.exists():
+            candidates.append(Candidate(model=model, text="", status="missing"))
+            continue
+        text = read_candidate_text(path)
+        info = meta_info.get(model, {})
+        cand = Candidate(
+            model=model,
+            text=text,
+            status=info.get("status", "unknown"),
+            ai_score=parse_metric(info.get("ai_score") or info.get("ai_score_instructional") or info.get("ai_score_technical")),
+            mps=parse_metric(info.get("mps")),
+        )
+        if cand.status == "success" and cand.text.strip():
+            cand.rss = register_stability(baseline, cand.text)
+            cand.edit_cons = edit_conservativeness(baseline, cand.text)
+        else:
+            cand.notes.append("skipping deterministic metrics (status not success or empty text)")
+        cand.composite = composite_score(cand, weights)
+        if cand.status == "success" and cand.composite is None:
+            cand.notes.append("composite undefined — at least one of AI/MPS could not be parsed from meta.md")
+        candidates.append(cand)
+
+    scored = [c for c in candidates if c.composite is not None]
+    winner: Optional[Candidate] = max(scored, key=lambda c: c.composite) if scored else None
+
+    composite_path = run_dir / "composite.md"
+    composite_path.write_text(
+        render_composite_md(run_dir, weights, candidates, winner),
+        encoding="utf-8",
+    )
+
+    winner_path = run_dir / "winner.md"
+    if winner is not None:
+        winner_path.write_text(
+            f"---\nwinner_model: {winner.model}\ncomposite_score: {winner.composite:.2f}\n---\n\n{winner.text.lstrip()}",
+            encoding="utf-8",
+        )
+    else:
+        winner_path.write_text("# winner.md\n\nNo candidate scored successfully.\n", encoding="utf-8")
+
+    cwd = Path.cwd()
+    print(f"wrote {composite_path.relative_to(cwd) if composite_path.is_relative_to(cwd) else composite_path}")
+    print(f"wrote {winner_path.relative_to(cwd) if winner_path.is_relative_to(cwd) else winner_path}")
+    if winner:
+        print(f"winner: {winner.model} (composite {winner.composite:.2f})")
+    else:
+        print("winner: none")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/patterns/en-communication.md

@@ -0,0 +1,89 @@
+---
+pack: en-communication
+language: en
+name: Communication Patterns
+version: 1.1.0
+patterns: 4
+---
+
+# Communication Patterns
+
+### 19. Collaborative Communication Artifacts
+
+**Watch words:** I hope this helps!, Let me know if you need, Feel free to ask, Happy to help, Don't hesitate to reach out, I'd be glad to, Is there anything else, Hope that clarifies things, Let me know if you'd like me to
+
+**Fire condition:** Any chatbot-style conversational phrase appears in content that is not a live interactive conversation.
+
+**Exclusion:** Acceptable in transcripts of actual live chat sessions, intentional UI microcopy for chatbot interfaces, or dialogue being quoted and analyzed.
+
+**Problem:** AI includes chatbot conversational phrases in written content. These are appropriate in a live chat but not in articles, reports, or documentation.
+
+**Semantic Risk:** LOW
+
+**Before:**
+> The French Revolution began in 1789, driven by fiscal crisis and food shortages. I hope this helps! Let me know if you need more details on any specific aspect of the revolution. Feel free to ask about the key figures involved.
+
+**After:**
+> The French Revolution began in 1789, driven by fiscal crisis and food shortages. The immediate trigger was the near-bankruptcy of the French state and a bread price spike that hit Paris hardest.
+
+---
+
+### 20. Knowledge-Cutoff Disclaimers
+
+**Watch words:** as of my last update, I don't have access to real-time, my training data, I cannot verify current, as of my knowledge cutoff, I'm not able to browse, please verify this information, this may have changed since
+
+**Fire condition:** Any AI self-reference or training-data caveat appears in editorial, journalistic, or analytical content.
+
+**Exclusion:** Acceptable in technical documentation explicitly about AI systems, or in content that intentionally discloses AI generation (with a proper disclosure note). Also acceptable if the caveat is replaced with a dated, source-cited fact.
+
+**Problem:** AI includes training-data caveats in content that should not reference AI limitations. These disclaimers break the fourth wall and remind readers the text was machine-generated.
+
+**Semantic Risk:** MEDIUM
+**Preservation Note:** The disclaimer sometimes carries a genuine factual caveat about data currency; removing it without replacing the claim with a dated source may leave an unverified assertion that the reader cannot assess.
+
+**Before:**
+> As of my last update in April 2024, the company had around 5,000 employees. I don't have access to real-time data, so please verify this information with current sources.
+
+**After:**
+> The company had about 5,000 employees as of its 2024 annual report.
+
+---
+
+### 21. Sycophantic/Servile Tone
+
+**Watch words:** Great question!, That's an excellent point, You've raised a fascinating, What a thoughtful, That's a really interesting, Absolutely!, You're absolutely right, What a great observation
+
+**Fire condition:** Any flattering or servile opener appears before substantive content.
+
+**Exclusion:** None — this pattern has no valid context in editorial, analytical, or journalistic writing. Even in conversational formats, drop the flattery and start with the answer.
+
+**Problem:** AI flatters the reader or questioner before answering. This servile opener adds no information and signals AI generation.
+
+**Semantic Risk:** LOW
+
+**Before:**
+> Great question! That's a really fascinating topic. You've raised an excellent point about the economic factors at play. Let me break this down for you.
+
+**After:**
+> The main economic factor is the gap between housing supply and demand. Building permits in the metro area dropped 18% last year while population grew 2.1%.
+
+---
+
+### 29. False Nuance (Retroactive Reframing)
+
+**Watch words:** Actually, it's more nuanced than that, To be more precise, Well, it's not quite that simple, That said, the reality is more complex, More accurately, In fairness, it's more that, If we're being precise, Though to be fair
+
+**Fire condition:** The text restates or lightly reframes the preceding claim under the guise of adding nuance, without introducing new information, evidence, or a genuinely different perspective.
+
+**Exclusion:** Acceptable when the reframe introduces a substantive correction, cites new evidence, or genuinely shifts the analytical frame in a way that changes the conclusion. Also acceptable in dialogue transcripts where the speaker is visibly self-correcting with new data.
+
+**Problem:** AI hedges its own statements by immediately re-qualifying them in a way that sounds thoughtful but adds nothing. The "nuance" is cosmetic — the second sentence says the same thing as the first in slightly different words. This creates an illusion of depth while padding the text.
+
+**Semantic Risk:** HIGH
+**Preservation Note:** Removing the reframing clause may delete a genuine qualification or exception; verify that the retained primary claim accurately stands alone before removing the "nuance" sentence.
+
+**Before:**
+> Remote work increases productivity. Actually, it's more nuanced than that — remote work can enhance productivity in certain contexts while presenting challenges in others, and the net effect depends on organizational culture and individual work styles.
+
+**After:**
+> Remote work increases productivity for focused solo tasks — a Stanford study found a 13% gain for call center workers. It hurts spontaneous collaboration, though: Microsoft's 2021 internal data showed cross-team communication dropped 25% after going fully remote.

package/patterns/en-content.md

@@ -0,0 +1,133 @@
+---
+pack: en-content
+language: en
+name: Content Patterns
+version: 1.0.0
+patterns: 6
+---
+
+# Content Patterns
+
+### 1. Undue Emphasis on Significance
+
+**Watch words:** significant milestone, pivotal moment, groundbreaking, transformative, paradigm shift, revolutionary, game-changing, unprecedented, landmark achievement, watershed moment, trailblazing, monumental
+
+**Fire condition:** 2+ emphasis words appear in the same paragraph, or a single word like "revolutionary" or "groundbreaking" applied to an ordinary product or event.
+
+**Exclusion:** Genuine historical events of large scale (first moon landing, eradication of a disease) where the adjective is proportionate. Use judgment on actual impact.
+
+**Semantic Risk:** HIGH
+**Preservation Note:** Removing emphasis words may delete the author's actual claim about significance; over-correction can convert a genuinely notable event into an unremarkable one.
+
+**Problem:** AI inflates the importance of ordinary topics. Everything becomes a "significant milestone" or a "paradigm shift," regardless of actual impact.
+
+**Before:**
+> The company's new mobile app represents a groundbreaking paradigm shift in how users interact with grocery delivery services. This transformative, game-changing platform marks an unprecedented milestone in the retail industry.
+
+**After:**
+> The company launched a grocery delivery app. It lets users schedule same-day deliveries and track orders in real time. Downloads hit 2 million in the first month.
+
+---
+
+### 2. Undue Emphasis on Notability/Media
+
+**Watch words:** garnered significant attention, widely recognized, has been featured in, attracted widespread interest, gained international acclaim, made headlines, captured the imagination of, has been praised by critics and audiences alike
+
+**Fire condition:** A claim of broad attention, coverage, or acclaim appears without a named publication, outlet, or specific figure.
+
+**Exclusion:** Statements like "widely used" backed by a rough scale ("used in 50 countries", "over 10 million installs") — specificity makes them acceptable even without named sources.
+
+**Semantic Risk:** HIGH
+**Preservation Note:** Correcting unsourced attention claims may remove a core assertion about recognition or impact that the author intended as a factual claim.
+
+**Problem:** AI claims broad media coverage or public attention without citing specific sources or evidence.
+
+**Before:**
+> Her artwork has garnered significant attention from critics and audiences alike, and has been widely recognized as a defining voice of her generation. Her exhibitions have attracted widespread interest across the globe.
+
+**After:**
+> The New York Times reviewed her 2023 exhibition, calling her use of recycled materials "quietly radical." The show sold out its three-week run at the Whitechapel Gallery.
+
+---
+
+### 3. Superficial -ing Analyses
+
+**Watch words:** showcasing, highlighting, underscoring, demonstrating, illustrating, reflecting, signaling, exemplifying, reinforcing, embodying, encapsulating
+
+**Fire condition:** 3+ present-participle phrases chained in a single sentence or consecutive clauses with no concrete causal explanation.
+
+**Exclusion:** A single well-placed participle for genuine causal or temporal connection ("the policy increased costs, pushing firms to cut staff") is acceptable and not this pattern.
+
+**Semantic Risk:** HIGH
+**Preservation Note:** Replacing participle chains with concrete explanation restructures the argument; if the causal relationship is not well understood, the correction may introduce a claim the original did not make.
+
+**Problem:** AI uses present participle chains as filler analysis. Instead of explaining *why* something matters, it strings together "-ing" words that gesture at significance without saying anything concrete.
+
+**Before:**
+> The festival brings together artists from 30 countries, showcasing the diversity of contemporary dance, highlighting the importance of cross-cultural dialogue, and underscoring the role of the arts in fostering global understanding.
+
+**After:**
+> The festival brings together artists from 30 countries. This year, a butoh troupe from Tokyo collaborated with a hip-hop crew from Lagos — a pairing that would not have happened without the festival's residency program.
+
+---
+
+### 4. Promotional Language
+
+**Watch words:** stunning, breathtaking, world-class, gem of, hidden treasure, crown jewel, vibrant, nestled in, boasts, a must-visit, unparalleled, exquisite, awe-inspiring, picturesque
+
+**Fire condition:** 2+ promotional adjectives modifying the same subject, or a single strong superlative ("world-class", "breathtaking", "must-visit") used as descriptive prose rather than quoted marketing copy.
+
+**Exclusion:** Direct quotations from marketing or promotional materials being analyzed — the promotional language belongs to the source, not the author.
+
+**Semantic Risk:** MEDIUM
+**Preservation Note:** Replacing promotional adjectives with neutral description may remove genuine qualitative assessments the author intended as their own voice or evaluation.
+
+**Problem:** AI uses tourism-brochure language instead of neutral description, especially when writing about places, food, or cultural events.
+
+**Before:**
+> Nestled in the rolling hills of Tuscany, this stunning village boasts breathtaking views, world-class cuisine, and an exquisite charm that makes it a must-visit hidden gem for any discerning traveler.
+
+**After:**
+> The village sits on a hill about 40 minutes south of Florence. It has one restaurant, a weekly market on Thursdays, and a 14th-century church with frescoes that are slowly being restored.
+
+---
+
+### 5. Vague Attributions
+
+**Watch words:** experts say, many believe, it is widely accepted, studies show, research indicates, critics argue, according to sources, observers note, analysts predict, some suggest, it is generally agreed
+
+**Fire condition:** Any claim of authority appears with an unspecified source rather than a named one (person, institution, publication, or study with date).
+
+**Exclusion:** Well-established consensus facts with no reasonable controversy ("doctors say smoking causes lung cancer") — use judgment on whether a named source is genuinely necessary.
+
+**Semantic Risk:** HIGH
+**Preservation Note:** Removing vague attributions without replacement deletes the author's sourcing claim; correction must substitute a real source or remove the claim entirely, which changes the text's evidentiary basis.
+
+**Problem:** AI cites unnamed "experts" and "studies" instead of specific sources. This creates an illusion of authority without any verifiable backing.
+
+**Before:**
+> Experts say that remote work is here to stay. Studies show that productivity increases when employees work from home, and many believe this trend will reshape the commercial real estate market.
+
+**After:**
+> A 2023 Stanford study by Nicholas Bloom found that hybrid workers were 3% more productive than full-time office workers. Kastle Systems data shows U.S. office occupancy has stabilized at about 50% of pre-pandemic levels.
+
+---
+
+### 6. Formulaic "Challenges and Prospects"
+
+**Watch words:** despite these challenges, remains to be seen, poised for growth, at a crossroads, on the cusp of, only time will tell, the road ahead, faces significant hurdles but, with continued effort, looking forward
+
+**Fire condition:** A paragraph or conclusion contains both a generic challenge phrase AND a generic optimism phrase — the classic two-step pattern of acknowledging problems then pivoting to vague hope.
+
+**Exclusion:** Genuine uncertainty expressed with specific caveats ("FDA approval takes 14 months; if denied by Q3, we shift to EU trials") — precision makes it acceptable. Only trigger when both poles are vague.
+
+**Semantic Risk:** HIGH
+**Preservation Note:** Replacing the challenge-prospect formula restructures the argument's conclusion; the corrected version must not omit actual challenges or prospects the author named, even vaguely.
+
+**Problem:** AI wraps up with a generic challenges-then-optimism formula: acknowledge problems, then pivot to vague hope. This pattern appears at the end of almost every AI-generated article or essay.
+
+**Before:**
+> Despite these challenges, the industry remains poised for significant growth. While it remains to be seen how regulations will evolve, the sector stands at a crossroads, and with continued innovation and collaboration, a bright future lies ahead.
+
+**After:**
+> The biggest obstacle is the FDA approval timeline — the average wait is 14 months. Two of the five pending applications were filed before 2022 and still have no decision date. The company says it will shift trials to the EU if U.S. approval is not granted by Q3.