Upload 92 files

app/config.py

@@ -81,3 +81,10 @@ _ml_flag = (os.environ.get("ML_POLISH_ENABLED") or "true").strip().lower()
 ML_POLISH_AVAILABLE_DEFAULT = _ml_flag not in {"0", "false", "no", "off"}
 _ml_warm = (os.environ.get("ML_POLISH_WARM") or "false").strip().lower()
 ML_POLISH_WARM = _ml_warm in {"1", "true", "yes", "on"}
+
+# Grammar cleanup around rewrite (fixes ESL errors so they don't propagate/re-appear).
+# INPUT: clean the source before rewriting. OUTPUT: clean the rewrite before returning.
+_gfi = (os.environ.get("GRAMMAR_FIX_INPUT") or "true").strip().lower()
+GRAMMAR_FIX_INPUT = _gfi not in {"0", "false", "no", "off"}
+_gfo = (os.environ.get("GRAMMAR_FIX_OUTPUT") or "true").strip().lower()
+GRAMMAR_FIX_OUTPUT = _gfo not in {"0", "false", "no", "off"}

app/data/protected_phrases.json

@@ -0,0 +1,100 @@
+[
+  "how much",
+  "how many",
+  "so much",
+  "so many",
+  "too much",
+  "too many",
+  "as much",
+  "as many",
+  "how far",
+  "how long",
+  "fast food",
+  "fast foods",
+  "junk food",
+  "junk foods",
+  "street food",
+  "sea food",
+  "seafood",
+  "whole food",
+  "whole foods",
+  "comfort food",
+  "real estate",
+  "social media",
+  "climate change",
+  "artificial intelligence",
+  "machine learning",
+  "deep learning",
+  "customer service",
+  "public transport",
+  "public transportation",
+  "high school",
+  "middle school",
+  "primary school",
+  "mental health",
+  "public health",
+  "health care",
+  "healthcare",
+  "human rights",
+  "credit card",
+  "search engine",
+  "operating system",
+  "hard drive",
+  "smart phone",
+  "smartphone",
+  "video game",
+  "video games",
+  "power plant",
+  "supply chain",
+  "role model",
+  "common sense",
+  "point of view",
+  "quality of life",
+  "standard of living",
+  "cost of living",
+  "side effect",
+  "side effects",
+  "greenhouse gas",
+  "greenhouse gases",
+  "living room",
+  "dining room",
+  "waiting room",
+  "parking lot",
+  "bus stop",
+  "traffic jam",
+  "rush hour",
+  "full time",
+  "part time",
+  "long term",
+  "short term",
+  "day care",
+  "work out",
+  "grocery store",
+  "department store",
+  "small business",
+  "big data",
+  "world war",
+  "civil war",
+  "united states",
+  "middle east",
+  "solar system",
+  "black hole",
+  "blood pressure",
+  "heart attack",
+  "immune system",
+  "nervous system",
+  "birth rate",
+  "death rate",
+  "life expectancy",
+  "natural resources",
+  "renewable energy",
+  "fossil fuel",
+  "fossil fuels",
+  "global warming",
+  "air pollution",
+  "water pollution",
+  "drinking water",
+  "food chain",
+  "human being",
+  "human beings"
+]

app/pipeline/grammar_fix.py

@@ -0,0 +1,296 @@
+"""Deterministic grammar cleanup applied around the rewrite.
+
+Two tiers, both safe to run offline:
+  1. High-precision lexical fixes (mass-noun plurals, do-support agreement) via regex.
+  2. spaCy-based subject/verb agreement fixes (pronoun/plural subject vs. verb form).
+Optionally applies self-hosted LanguageTool suggestions first when configured.
+
+The goal is narrow: fix the common ESL errors that the rewriter cannot fix on its
+own and that the MiniLM guard would otherwise re-inject when it reverts a sentence.
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+
+from app.pipeline.nlp import get_nlp
+
+logger = logging.getLogger("plainrewrite.grammar_fix")
+
+# Uncountable / irregular nouns that get wrongly pluralized.
+_MASS_NOUN_PLURALS: dict[str, str] = {
+    "peoples": "people",
+    "informations": "information",
+    "advices": "advice",
+    "equipments": "equipment",
+    "softwares": "software",
+    "hardwares": "hardware",
+    "knowledges": "knowledge",
+    "researches": "research",
+    "staffs": "staff",
+    "furnitures": "furniture",
+    "luggages": "luggage",
+    "moneys": "money",
+    "homeworks": "homework",
+    "houseworks": "housework",
+    "feedbacks": "feedback",
+    "traffics": "traffic",
+    "progresses": "progress",
+    "evidences": "evidence",
+    "musics": "music",
+    "slangs": "slang",
+    "childs": "children",
+    "mans": "men",
+    "womans": "women",
+    "foots": "feet",
+    "tooths": "teeth",
+}
+
+# Words ending in -s after do-support that are nouns, not verbs (skip stripping).
+_DO_NOUN_EXCEPTIONS = {"dishes", "chores", "sports", "maths", "backups"}
+
+# Modals / auxiliaries: if a verb is governed by one of these it keeps its base form.
+_MODALS_AUX = {
+    "will", "would", "shall", "should", "can", "could", "may", "might",
+    "must", "do", "does", "did", "to",
+}
+
+# Words that must never be treated as a base present-tense verb after a pronoun
+# in the no-spaCy regex fallback (copulas, auxiliaries, adverbs, invariant/past verbs).
+_AGREEMENT_SKIP = {
+    "is", "are", "was", "were", "be", "been", "being", "am",
+    "has", "have", "had", "will", "would", "shall", "should",
+    "can", "could", "may", "might", "must", "do", "does", "did",
+    "not", "never", "also", "just", "only", "always", "often",
+    "sometimes", "soon", "then", "here", "there", "really", "still",
+    "already", "even", "too", "so", "very", "quite", "almost",
+    # invariant or past-equal-to-base verbs (ambiguous → leave alone)
+    "read", "put", "cut", "set", "hit", "let", "hurt", "cost", "shut",
+    "split", "spread", "bet", "quit", "fit", "beat", "cast", "burst",
+    # common irregular past forms (valid with singular subject)
+    "went", "saw", "came", "took", "gave", "found", "made", "said",
+    "told", "knew", "grew", "ran", "felt", "kept", "left", "meant",
+    "brought", "bought", "caught", "taught", "thought", "sought", "got",
+    "sat", "stood", "won", "lost", "held", "led", "met", "paid", "spent",
+}
+
+
+def _match_case(sample: str, replacement: str) -> str:
+    if sample.isupper():
+        return replacement.upper()
+    if sample[:1].isupper():
+        return replacement[:1].upper() + replacement[1:]
+    return replacement
+
+
+def _fix_mass_nouns(text: str) -> str:
+    def repl(m: re.Match[str]) -> str:
+        return _match_case(m.group(0), _MASS_NOUN_PLURALS[m.group(0).lower()])
+
+    pattern = re.compile(
+        r"\b(" + "|".join(re.escape(k) for k in _MASS_NOUN_PLURALS) + r")\b",
+        re.IGNORECASE,
+    )
+    return pattern.sub(repl, text)
+
+
+def _fix_do_support(text: str) -> str:
+    """`don't realizes` → `don't realize`; `does works` → `does work`."""
+    aux = r"(do|does|did|don't|doesn't|didn't|do not|does not|did not)"
+    pattern = re.compile(rf"\b{aux}\s+([A-Za-z]+?)s\b", re.IGNORECASE)
+
+    def repl(m: re.Match[str]) -> str:
+        verb_s = m.group(2) + "s"
+        if verb_s.lower() in _DO_NOUN_EXCEPTIONS:
+            return m.group(0)
+        base = m.group(2)
+        # Keep words like "address" (ends in -ss) — those aren't "base+s".
+        if base.lower().endswith("s"):
+            return m.group(0)
+        return f"{m.group(1)} {base}"
+
+    return pattern.sub(repl, text)
+
+
+def _to_third_person(verb: str) -> str:
+    v = verb.lower()
+    irregular = {"be": "is", "have": "has", "do": "does", "go": "goes"}
+    if v in irregular:
+        return _match_case(verb, irregular[v])
+    if v.endswith(("s", "sh", "ch", "x", "z", "o")):
+        out = v + "es"
+    elif v.endswith("y") and len(v) > 1 and v[-2] not in "aeiou":
+        out = v[:-1] + "ies"
+    else:
+        out = v + "s"
+    return _match_case(verb, out)
+
+
+def _singular_to_base(verb_s: str) -> str:
+    """Invert a 3rd-person-singular verb to its base form (goes→go, tries→try)."""
+    v = verb_s.lower()
+    irregular = {"goes": "go", "does": "do", "has": "have"}
+    if v in irregular:
+        return _match_case(verb_s, irregular[v])
+    special_ies = {"dies": "die", "ties": "tie", "lies": "lie"}
+    if v in special_ies:
+        return _match_case(verb_s, special_ies[v])
+    if v.endswith("ies") and len(v) > 4:
+        out = v[:-3] + "y"
+    elif v.endswith(("ses", "zes", "xes", "ches", "shes", "oes")):
+        out = v[:-2]
+    elif v.endswith("s"):
+        out = v[:-1]
+    else:
+        return verb_s
+    return _match_case(verb_s, out)
+
+
+def _has_modal_or_aux(token) -> bool:
+    for child in token.lefts:
+        if child.dep_ in {"aux", "auxpass"} or child.lower_ in _MODALS_AUX:
+            return True
+    # Verb itself directly preceded by "to" (infinitive) — leave base form.
+    if token.i > 0:
+        prev = token.doc[token.i - 1]
+        if prev.lower_ in _MODALS_AUX:
+            return True
+    return False
+
+
+def _fix_agreement_spacy(text: str) -> str:
+    """Fix subject/verb agreement using the dependency parse (high precision)."""
+    nlp = get_nlp()
+    if nlp is None:
+        return text
+    doc = nlp(text)
+    # (start_char, end_char, replacement)
+    edits: list[tuple[int, int, str]] = []
+
+    for token in doc:
+        if token.pos_ not in {"VERB"}:
+            continue
+        subj = None
+        for child in token.lefts:
+            if child.dep_ in {"nsubj", "nsubjpass"}:
+                subj = child
+                break
+        if subj is None:
+            continue
+        if _has_modal_or_aux(token):
+            continue
+
+        subj_low = subj.lower_
+        # Singular 3rd-person subject needs a -s verb: "it affect" -> "it affects"
+        singular_3p = subj_low in {"it", "he", "she"} or (
+            subj.pos_ in {"NOUN", "PROPN"} and subj.tag_ in {"NN", "NNP"}
+        )
+        plural_or_first = subj_low in {"they", "we", "you", "i"} or (
+            subj.pos_ == "NOUN" and subj.tag_ == "NNS"
+        )
+
+        if singular_3p and token.tag_ == "VB":
+            new = _to_third_person(token.text)
+            if new != token.text:
+                edits.append((token.idx, token.idx + len(token.text), new))
+        elif plural_or_first and token.tag_ == "VBZ":
+            base = token.lemma_
+            if base and base != token.text.lower():
+                edits.append(
+                    (token.idx, token.idx + len(token.text), _match_case(token.text, base))
+                )
+
+    if not edits:
+        return text
+    edits.sort(key=lambda e: e[0], reverse=True)
+    out = text
+    for start, end, repl in edits:
+        out = out[:start] + repl + out[end:]
+    return out
+
+
+def _fix_agreement_regex(text: str) -> str:
+    """Conservative subject/verb agreement fix for the no-spaCy path.
+
+    Only touches clear pronoun-subject patterns; skips copulas, auxiliaries,
+    adverbs, and ambiguous invariant/past verbs to stay high-precision.
+    """
+
+    def third(m: re.Match[str]) -> str:
+        subj, verb = m.group(1), m.group(2)
+        vl = verb.lower()
+        if vl in _AGREEMENT_SKIP or vl.endswith(("s", "ed", "ing")) or len(vl) < 2:
+            return m.group(0)
+        return f"{subj} {_to_third_person(verb)}"
+
+    # "it/he/she + <base verb>" → third person (it affect → it affects)
+    text = re.sub(r"\b(it|he|she|It|He|She)\s+([A-Za-z]+)\b", third, text)
+
+    def base(m: re.Match[str]) -> str:
+        subj, verb_s = m.group(1), m.group(2)
+        vl = verb_s.lower()
+        if vl in _DO_NOUN_EXCEPTIONS or vl in _AGREEMENT_SKIP:
+            return m.group(0)
+        stem = _singular_to_base(verb_s)
+        if stem == verb_s or len(stem) < 2:
+            return m.group(0)
+        return f"{subj} {stem}"
+
+    # "they/we/i + <verb>s" → base (they runs → they run). "you" excluded (noisy).
+    text = re.sub(r"\b(they|we|i|They|We|I)\s+([A-Za-z]+s)\b", base, text)
+    return text
+
+
+def _apply_languagetool(text: str, language: str | None) -> str:
+    """Apply safe LanguageTool suggestions (spelling/grammar) when the server is up."""
+    try:
+        from app.config import LANGUAGE_TOOL_ENABLED
+        from app.pipeline.grammar import check_languagetool
+    except Exception:  # noqa: BLE001
+        return text
+    if not LANGUAGE_TOOL_ENABLED:
+        return text
+    try:
+        issues, _warning = check_languagetool(text, language)
+    except Exception as exc:  # noqa: BLE001
+        logger.warning("LanguageTool correction skipped: %s", exc)
+        return text
+    if not issues:
+        return text
+
+    # Apply only unambiguous spelling/grammar fixes, non-overlapping, right-to-left.
+    usable = [
+        i
+        for i in issues
+        if i.suggestion
+        and i.category in {"spelling", "grammar"}
+        and 0 <= i.start < i.end <= len(text)
+    ]
+    usable.sort(key=lambda i: i.start, reverse=True)
+    out = text
+    last_start = len(text) + 1
+    for issue in usable:
+        if issue.end > last_start:
+            continue  # overlaps a later edit
+        out = out[: issue.start] + issue.suggestion + out[issue.end :]
+        last_start = issue.start
+    return out
+
+
+def correct_text(text: str, language: str | None = None) -> str:
+    """Best-effort grammar cleanup. Never raises; returns input on failure."""
+    if not text or not text.strip():
+        return text
+    try:
+        out = _apply_languagetool(text, language)
+        out = _fix_mass_nouns(out)
+        out = _fix_do_support(out)
+        if get_nlp() is not None:
+            out = _fix_agreement_spacy(out)
+        else:
+            out = _fix_agreement_regex(out)
+        return out
+    except Exception as exc:  # noqa: BLE001
+        logger.warning("correct_text failed, returning original: %s", exc)
+        return text

app/pipeline/orchestrator.py

@@ -8,7 +8,9 @@ import time
 from dataclasses import dataclass
 from difflib import SequenceMatcher
 
+from app.config import GRAMMAR_FIX_INPUT, GRAMMAR_FIX_OUTPUT
 from app.pipeline.generative import generative_available, generative_paraphrase
+from app.pipeline.grammar_fix import correct_text
 from app.pipeline.mechanics import enforce_length_budget, scrub_phrases, tidy
 from app.pipeline.ml_context import (
     gen_was_used,
@@ -143,6 +145,16 @@ def rewrite_text(
     if not original:
         raise ValueError("Paste some text first.")
 
+    # Clean the source first so ESL errors don't propagate through the rewrite
+    # (and so the MiniLM meaning guard can't re-inject them when it reverts).
+    source = original
+    grammar_fixed_input = False
+    if GRAMMAR_FIX_INPUT:
+        cleaned = correct_text(original)
+        if cleaned and cleaned.strip():
+            grammar_fixed_input = cleaned.strip() != original.strip()
+            source = normalize_whitespace(cleaned)
+
     strength = max(0, min(2, int(strength)))
     tone = normalize_tone(tone)
     want_gen = bool(ml_polish) and generative_available()
@@ -151,7 +163,7 @@ def rewrite_text(
     # Still enable context for meaning guard helpers that check the flag.
     set_ml_polish(want_minilm and not want_gen)
     rng = _rng_for(
-        original
+        source
         + "|"
         + tone
         + "|"
@@ -166,7 +178,7 @@ def rewrite_text(
         logger.info("ML polish: aggressive generative rewrite (%s)…", tone)
         # Force at least Normal generative aggression
         draft = generative_paraphrase(
-            original,
+            source,
             tone=tone,
             strength=max(1, strength),
             max_sim=0.86,
@@ -179,15 +191,15 @@ def rewrite_text(
             rewritten = _light_polish_after_gen(working, tone, strength, rng)
             logger.info(
                 "ML polish: generative main path words %s→%s sim=%.3f",
-                word_count(original),
+                word_count(source),
                 word_count(rewritten),
-                _similarity_ratio(original, rewritten),
+                _similarity_ratio(source, rewritten),
             )
             # If still too similar, one more generative pass at Heavy
-            if _similarity_ratio(original, rewritten) > 0.88:
+            if _similarity_ratio(source, rewritten) > 0.88:
                 logger.info("ML polish: generative second pass (still too similar)")
                 draft2 = generative_paraphrase(
-                    original,
+                    source,
                     tone=tone,
                     strength=2,
                     max_sim=0.82,
@@ -203,56 +215,66 @@ def rewrite_text(
         # Full classical path (also when ML polish off, or gen missing)
         if want_minilm:
             set_ml_polish(True)
-        paragraphs = split_paragraphs(original)
+        paragraphs = split_paragraphs(source)
         out_paras = [_rewrite_paragraph(p, tone, strength, rng) for p in paragraphs]
         rewritten = tidy("\n\n".join(out_paras))
         rewritten = scrub_phrases(rewritten)
         rewritten = apply_tone_style(rewritten, tone, strength, rng)
         rewritten = apply_tone_contractions(rewritten, tone)
 
-    # Meaning guard: looser when generative wrote the draft
+    # Meaning guard: looser when generative wrote the draft.
+    # NOTE: guard against `source` (grammar-corrected) — so any revert restores
+    # the corrected sentence, never the original ESL error.
     if want_minilm:
         set_ml_polish(True)  # enable guard
         if used_gen_main:
             rewritten = apply_minilm_polish(
-                original, rewritten, tone, min_meaning=0.58
+                source, rewritten, tone, min_meaning=0.58
             )
         else:
-            rewritten = apply_minilm_polish(original, rewritten, tone)
+            rewritten = apply_minilm_polish(source, rewritten, tone)
         rewritten = tidy(rewritten)
         rewritten = apply_tone_style(rewritten, tone, strength, rng)
         rewritten = apply_tone_contractions(rewritten, tone)
 
-    rewritten = enforce_length_budget(original, rewritten, preserve_length)
+    rewritten = enforce_length_budget(source, rewritten, preserve_length)
     rewritten = tidy(rewritten)
 
-    ratio = _similarity_ratio(original, rewritten)
+    ratio = _similarity_ratio(source, rewritten)
     if ratio > 0.85 and not used_gen_main:
         logger.info("Low change detected (ratio=%.3f); running stronger second pass", ratio)
         rewritten = _force_more_changes(rewritten, tone, strength, rng)
         if want_minilm:
-            rewritten = apply_minilm_polish(original, rewritten, tone)
+            rewritten = apply_minilm_polish(source, rewritten, tone)
             rewritten = apply_tone_style(rewritten, tone, strength, rng)
             rewritten = apply_tone_contractions(rewritten, tone)
-        rewritten = enforce_length_budget(original, rewritten, preserve_length)
+        rewritten = enforce_length_budget(source, rewritten, preserve_length)
         rewritten = tidy(rewritten)
         tip = "Applied second pass (input was too similar after first rewrite)."
         notes = f"{notes} {tip}".strip() if notes else tip
-        ratio = _similarity_ratio(original, rewritten)
+        ratio = _similarity_ratio(source, rewritten)
     elif ratio > 0.90 and used_gen_main and want_gen:
         # Last resort: rules force-pass on top of weak generative output
         logger.info("Generative output still similar (%.3f); blending rules force pass", ratio)
         blended = _force_more_changes(rewritten, tone, min(2, strength + 1), rng)
         if want_minilm:
-            blended = apply_minilm_polish(original, blended, tone, min_meaning=0.58)
-        rewritten = enforce_length_budget(original, tidy(blended), preserve_length)
+            blended = apply_minilm_polish(source, blended, tone, min_meaning=0.58)
+        rewritten = enforce_length_budget(source, tidy(blended), preserve_length)
         rewritten = tidy(rewritten)
         tip = "Blended rules force-pass after generative stayed too similar."
         notes = f"{notes} {tip}".strip() if notes else tip
-        ratio = _similarity_ratio(original, rewritten)
+        ratio = _similarity_ratio(source, rewritten)
+
+    # Final grammar cleanup on the rewrite itself (catches residual agreement slips).
+    if GRAMMAR_FIX_OUTPUT:
+        cleaned_out = correct_text(rewritten)
+        if cleaned_out and cleaned_out.strip():
+            rewritten = tidy(cleaned_out)
 
     changed = rewritten.strip() != original.strip()
     engine_bits: list[str] = []
+    if GRAMMAR_FIX_INPUT or GRAMMAR_FIX_OUTPUT:
+        engine_bits.append("grammar")
     if gen_was_used():
         engine_bits.append("flan-t5")
     engine_bits.append("spacy" if spacy_available() else "regex-fallback")
@@ -274,6 +296,9 @@ def rewrite_text(
     elif ml_polish and want_gen and not want_minilm:
         tip = "ML polish: generative main path (MiniLM unavailable for meaning guard)."
         notes = f"{notes} {tip}".strip() if notes else tip
+    if grammar_fixed_input:
+        tip = "Corrected grammar in the source before rewriting."
+        notes = f"{notes} {tip}".strip() if notes else tip
 
     engine = "+".join(engine_bits)
     msg = (

app/pipeline/synonym.py

@@ -108,6 +108,45 @@ def _load_json_map(name: str) -> dict[str, str]:
     return {k.lower(): v for k, v in json.loads(path.read_text(encoding="utf-8")).items() if k != v}
 
 
+@lru_cache(maxsize=1)
+def load_protected_phrases() -> tuple[str, ...]:
+    """Multiword collocations whose component words must not be swapped.
+
+    Data-driven (app/data/protected_phrases.json) so it stays domain-agnostic —
+    e.g. 'fast food' must never become 'rapid food'.
+    """
+    path = DATA_DIR / "protected_phrases.json"
+    if not path.exists():
+        return ()
+    try:
+        raw = json.loads(path.read_text(encoding="utf-8"))
+    except Exception:
+        return ()
+    phrases = {str(p).strip().lower() for p in raw if str(p).strip()}
+    # Longest first so multi-word matches win.
+    return tuple(sorted(phrases, key=len, reverse=True))
+
+
+def _protected_spans(sentence: str) -> list[tuple[int, int]]:
+    """Character spans in `sentence` covered by a protected collocation."""
+    phrases = load_protected_phrases()
+    if not phrases:
+        return []
+    spans: list[tuple[int, int]] = []
+    low = sentence.lower()
+    for phrase in phrases:
+        for m in re.finditer(rf"\b{re.escape(phrase)}\b", low):
+            spans.append((m.start(), m.end()))
+    return spans
+
+
+def _in_protected_span(start: int, end: int, spans: list[tuple[int, int]]) -> bool:
+    for s, e in spans:
+        if start < e and end > s:  # any overlap
+            return True
+    return False
+
+
 @lru_cache(maxsize=1)
 def load_preferred_swaps() -> dict[str, str]:
     return _load_json_map("preferred_swaps.json")
@@ -281,8 +320,9 @@ def _join_tokens(tokens: list[str]) -> str:
             text = t
             continue
         prev = tokens[i - 1]
-        if re.match(r"\w", t) and (not prev or re.match(r"\w", prev[-1:])):
-            text += " " + t
+        # Keep contractions/possessives glued: don ' t → don't, cat ' s → cat's
+        if prev.endswith(("'", "’")) or t in {"'", "’"}:
+            text += t
         elif re.match(r"\w", t):
             text += " " + t
         else:
@@ -408,12 +448,18 @@ def rewrite_sentence_synonyms(
             ),
         )
 
-    def _force_min_changes(tokens: list[str], out: list[str], min_changes: int) -> list[str]:
+    def _force_min_changes(
+        tokens: list[str],
+        out: list[str],
+        min_changes: int,
+        protected_idx: set[int] | None = None,
+    ) -> list[str]:
+        protected_idx = protected_idx or set()
         changed = sum(1 for a, b in zip(tokens, out) if a.isalpha() and a != b)
         if changed >= min_changes:
             return out
         for i, tok in enumerate(tokens):
-            if not tok.isalpha():
+            if i in protected_idx or not tok.isalpha():
                 continue
             if out[i] != tok:
                 continue
@@ -427,7 +473,7 @@ def rewrite_sentence_synonyms(
         # Adj/adv WordNet fill only — never nouns/verbs (no domain lists needed)
         if changed < min_changes and max_wn > 0:
             for i, tok in enumerate(tokens):
-                if not tok.isalpha() or out[i] != tok:
+                if i in protected_idx or not tok.isalpha() or out[i] != tok:
                     continue
                 low = tok.lower()
                 if low in _STOP_SWAP or len(low) < 4 or _looks_inflected_verb(low):
@@ -453,9 +499,16 @@ def rewrite_sentence_synonyms(
         return out
 
     nlp = get_nlp()
+    spans = _protected_spans(sentence)
 
     if nlp is None:
-        tokens = re.findall(r"\w+|[^\w\s]", sentence, flags=re.UNICODE)
+        matches = list(re.finditer(r"\w+|[^\w\s]", sentence, flags=re.UNICODE))
+        tokens = [m.group(0) for m in matches]
+        protected_idx = {
+            i
+            for i, m in enumerate(matches)
+            if _in_protected_span(m.start(), m.end(), spans)
+        }
         content_n = sum(
             1
             for t in tokens
@@ -468,19 +521,26 @@ def rewrite_sentence_synonyms(
             min_ch = max(min_ch, max(2, content_n // 3))
         budget = [max_wn]
         out = [
-            transform(tok, None, budget, sentence_start=_is_sentence_start(tokens, i))
+            tok
+            if i in protected_idx
+            else transform(tok, None, budget, sentence_start=_is_sentence_start(tokens, i))
             for i, tok in enumerate(tokens)
         ]
-        out = _force_min_changes(tokens, out, min_ch)
+        out = _force_min_changes(tokens, out, min_ch, protected_idx)
         return _join_tokens(out)
 
     doc = nlp(sentence)
     budget = [max_wn]
     pieces: list[str] = []
     toks = list(doc)
+    protected_idx = {
+        i
+        for i, token in enumerate(toks)
+        if _in_protected_span(token.idx, token.idx + len(token.text), spans)
+    }
     for i, token in enumerate(toks):
         raw = token.text
-        if not token.is_alpha:
+        if i in protected_idx or not token.is_alpha:
             pieces.append(raw)
             continue
         prev_text = toks[i - 1].text if i else ""
@@ -543,5 +603,5 @@ def rewrite_sentence_synonyms(
     min_ch = {0: 1, 1: max(2, content_n // 4), 2: max(3, content_n // 3)}.get(strength, 2)
     if force_all_lexicon:
         min_ch = max(min_ch, max(2, content_n // 3))
-    pieces = _force_min_changes(raws, pieces, min_ch)
+    pieces = _force_min_changes(raws, pieces, min_ch, protected_idx)
     return "".join(p + t.whitespace_ for t, p in zip(doc, pieces)).strip()

frontend/dist/assets/index.js

@@ -972,7 +972,7 @@ function App() {
         ),
         h("label", {
           className: "check",
-          title: "FLAN-T5 paraphrase → rules → MiniLM meaning check (beta)",
+          title: "Aggressive FLAN-T5 rewrite → light rules → MiniLM meaning check (beta)",
         },
           h("input", {
             type: "checkbox",

frontend/src/App.tsx

@@ -1174,7 +1174,7 @@ export default function App() {
 
               <label
                 className="check"
-                title="FLAN-T5 paraphrase → rules → MiniLM meaning check (beta)"
+                title="Aggressive FLAN-T5 rewrite → light rules → MiniLM meaning check (beta)"
               >
                 <input
                   type="checkbox"

scripts/test_grammar_fix.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(ROOT))
+
+from app.pipeline.orchestrator import rewrite_text
+
+orig = (
+    "Nowadays many peoples are living unhealthy life because they don't have "
+    "enough times. Eating fast foods are becoming very common and peoples don't "
+    "realizes how much it affect their health."
+)
+
+for tone, st in [("Neutral", 1), ("Academic", 2), ("Casual", 2)]:
+    r = rewrite_text(orig, tone=tone, strength=st, preserve_length=True, ml_polish=False)
+    print("===", tone, "strength", st, "| changed=", r.changed, "| engine=", r.engine)
+    print(r.text)
+    print("notes:", r.notes)
+    print()
+
+# Collocation protection: 'fast food' must never become 'rapid food' etc.
+assert "rapid food" not in " ".join(
+    rewrite_text(orig, tone=t, strength=2, preserve_length=True).text.lower()
+    for t in ("Neutral", "Academic", "Casual")
+)
+# Grammar propagation: these ESL errors must be gone from Neutral output.
+neutral = rewrite_text(orig, tone="Neutral", strength=1, preserve_length=True).text.lower()
+for bad in ("peoples", "don't realizes", "it affect "):
+    assert bad not in neutral + " ", f"still present: {bad!r}"
+print("ALL ASSERTIONS PASSED")