Upload 81 files

app/bootstrap.py

@@ -34,6 +34,17 @@ def ensure_resources() -> None:
     except Exception as exc:  # noqa: BLE001
         print(f"[warn] NLTK WordNet setup: {exc}")
 
+    try:
+        from app.config import ML_POLISH_WARM
+
+        if ML_POLISH_WARM:
+            from app.pipeline.minilm import warm_minilm
+
+            ok = warm_minilm()
+            print(f"[info] MiniLM warm: {'ok' if ok else 'skipped/unavailable'}")
+    except Exception as exc:  # noqa: BLE001
+        print(f"[warn] MiniLM warm: {exc}")
+
 
 if __name__ == "__main__":
     ensure_resources()

app/config.py

@@ -57,3 +57,13 @@ GRAMMAR_MAX_CHARS = max(
 )
 _lt_flag = (os.environ.get("LANGUAGE_TOOL_ENABLED") or "true").strip().lower()
 LANGUAGE_TOOL_ENABLED = _lt_flag not in {"0", "false", "no", "off"} and bool(LANGUAGE_TOOL_URL)
+
+# MiniLM ML polish (optional Pro feature — synonym scoring / tone affinity)
+# Model id used by fastembed (or mapped for sentence-transformers fallback)
+MINILM_MODEL = (
+    os.environ.get("MINILM_MODEL") or "sentence-transformers/all-MiniLM-L6-v2"
+).strip()
+_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"}

app/data/casual_swaps.json

@@ -0,0 +1,102 @@
+{
+  "furthermore": "also",
+  "moreover": "also",
+  "nevertheless": "still",
+  "nonetheless": "still",
+  "therefore": "so",
+  "consequently": "so",
+  "thus": "so",
+  "hence": "so",
+  "additionally": "also",
+  "subsequently": "later",
+  "substantial": "big",
+  "substantially": "really",
+  "considerable": "big",
+  "considerably": "really",
+  "significant": "big",
+  "significantly": "really",
+  "numerous": "many",
+  "approximately": "about",
+  "facilitate": "help",
+  "facilitates": "helps",
+  "facilitated": "helped",
+  "commence": "start",
+  "commences": "starts",
+  "commenced": "started",
+  "utilize": "use",
+  "utilizes": "uses",
+  "utilized": "used",
+  "utilizing": "using",
+  "obtain": "get",
+  "obtains": "gets",
+  "obtained": "got",
+  "demonstrate": "show",
+  "demonstrates": "shows",
+  "demonstrated": "showed",
+  "indicate": "show",
+  "indicates": "shows",
+  "indicated": "showed",
+  "individuals": "people",
+  "individual": "person",
+  "regarding": "about",
+  "concerning": "about",
+  "essential": "needed",
+  "pivotal": "key",
+  "instrumental": "helpful",
+  "endeavor": "try",
+  "endeavors": "tries",
+  "attempt": "try",
+  "attempts": "tries",
+  "require": "need",
+  "requires": "needs",
+  "required": "needed",
+  "purchase": "buy",
+  "purchases": "buys",
+  "purchased": "bought",
+  "assistance": "help",
+  "methodology": "method",
+  "comprehensive": "full",
+  "robust": "solid",
+  "seamless": "smooth",
+  "optimize": "improve",
+  "optimizes": "improves",
+  "enhance": "improve",
+  "enhances": "improves",
+  "implement": "put in place",
+  "implements": "puts in place",
+  "implementation": "rollout",
+  "collaborate": "work together",
+  "collaboration": "teamwork",
+  "provide": "give",
+  "provides": "gives",
+  "provided": "gave",
+  "remain": "stay",
+  "remains": "stays",
+  "remaining": "left",
+  "currently": "now",
+  "initially": "at first",
+  "previously": "earlier",
+  "frequently": "often",
+  "entirely": "fully",
+  "completely": "fully",
+  "objective": "goal",
+  "objectives": "goals",
+  "determine": "figure out",
+  "determines": "figures out",
+  "determined": "figured out",
+  "sufficient": "enough",
+  "additional": "more",
+  "prior": "earlier",
+  "subsequent": "later",
+  "beneficial": "helpful",
+  "favorable": "good",
+  "unfavorable": "bad",
+  "however": "but",
+  "whilst": "while",
+  "upon": "on",
+  "amongst": "among",
+  "towards": "toward",
+  "aforementioned": "above",
+  "hereinafter": "below",
+  "notwithstanding": "even so"
+}

app/main.py

@@ -33,8 +33,15 @@ from app.config import (
     LANGUAGE_TOOL_LANGUAGE,
     LANGUAGE_TOOL_URL,
     MAX_CHARS,
+    ML_POLISH_AVAILABLE_DEFAULT,
 )
-from app.pipeline.grammar import check_grammar, languagetool_reachable, normalize_language, rules_fallback_result
+from app.pipeline.grammar import (
+    check_grammar,
+    languagetool_reachable,
+    normalize_language,
+    rules_fallback_result,
+)
+from app.pipeline.minilm import minilm_package_present
 from app.pipeline.nlp import spacy_available
 from app.pipeline.orchestrator import rewrite_text, similarity_check
 from app.pipeline.tones import normalize_tone
@@ -63,6 +70,7 @@ class RewriteRequest(BaseModel):
     tone: str = "Neutral"
     strength: int = Field(1, ge=0, le=2)
     preserve_length: bool = True
+    ml_polish: bool = False
 
 
 class SimilarityRequest(BaseModel):
@@ -91,6 +99,9 @@ def health():
     lt_ok = languagetool_reachable()
     if lt_ok:
         engines.append("languagetool")
+    ml_pkg = minilm_package_present()
+    if ml_pkg:
+        engines.append("minilm")
     return {
         "status": "ok",
         "app": APP_TITLE,
@@ -103,6 +114,12 @@ def health():
             "reachable": lt_ok,
             "default_language": LANGUAGE_TOOL_LANGUAGE or "en-US",
         },
+        "ml_polish": {
+            "enabled": bool(ML_POLISH_AVAILABLE_DEFAULT),
+            "available": ml_pkg,
+            "backend": "fastembed|sentence-transformers" if ml_pkg else None,
+            "plans": ["pro", "plus"],
+        },
     }
 
 
@@ -144,7 +161,20 @@ def api_rewrite(
 
     ip = _client_ip(request)
     input_words = len(text.split())
-    assert_can_rewrite(user, input_words, client_ip=ip)
+    account_pre = assert_can_rewrite(user, input_words, client_ip=ip)
+
+    use_ml = bool(body.ml_polish)
+    if use_ml and AUTH_ENABLED:
+        plan_id = "guest"
+        if account_pre is not None:
+            plan_id = account_pre.plan.plan_id
+        elif user is not None:
+            plan_id = get_account_state(user).plan.plan_id
+        if plan_id not in {"pro", "plus"}:
+            raise HTTPException(
+                status_code=403,
+                detail="ML polish (beta) requires a Pro or Plus plan.",
+            )
 
     try:
         result = rewrite_text(
@@ -152,6 +182,7 @@ def api_rewrite(
             tone=normalize_tone(body.tone),
             strength=body.strength,
             preserve_length=body.preserve_length,
+            ml_polish=use_ml,
         )
     except ValueError as exc:
         raise HTTPException(status_code=400, detail=str(exc)) from exc
@@ -169,6 +200,7 @@ def api_rewrite(
             "strength": result.strength,
             "changed": result.changed,
             "notes": result.notes,
+            "ml_polish": use_ml,
         },
         "account": account_payload(account),
     }

app/pipeline/minilm.py

@@ -0,0 +1,239 @@
+"""MiniLM semantic scoring for synonym / rewrite candidates (optional ML polish).
+
+Uses fastembed (ONNX MiniLM) when installed; otherwise sentence-transformers.
+If neither is available, scoring is a no-op and callers fall back to rules.
+"""
+
+from __future__ import annotations
+
+import logging
+import threading
+from functools import lru_cache
+from typing import Sequence
+
+from app.config import MINILM_MODEL, ML_POLISH_AVAILABLE_DEFAULT
+
+logger = logging.getLogger("plainrewrite.minilm")
+
+_lock = threading.Lock()
+_model = None
+_backend: str | None = None
+_failed = False
+
+# Short register exemplars — used to nudge synonym picks toward the selected tone.
+_TONE_EXEMPLARS: dict[str, tuple[str, ...]] = {
+    "Casual": (
+        "This really helps a lot and feels easy to read.",
+        "We can't wait to try it out with the team.",
+        "So the change makes a big difference for people.",
+    ),
+    "Formal": (
+        "This approach substantially improves professional outcomes.",
+        "We cannot proceed without the required approval.",
+        "The results demonstrate a clear operational benefit.",
+    ),
+    "Academic": (
+        "This approach constitutes a significant scholarly contribution.",
+        "Further investigation remains warranted given these findings.",
+        "The results carry considerable implications for the field.",
+    ),
+    "Neutral": (
+        "This approach improves outcomes for most readers.",
+        "We cannot proceed without approval.",
+        "The results show a clear benefit.",
+    ),
+}
+
+
+def minilm_package_present() -> bool:
+    """True if a MiniLM backend package is installed (does not load weights)."""
+    if not ML_POLISH_AVAILABLE_DEFAULT:
+        return False
+    try:
+        import fastembed  # noqa: F401
+
+        return True
+    except Exception:
+        pass
+    try:
+        import sentence_transformers  # noqa: F401
+
+        return True
+    except Exception:
+        return False
+
+
+def minilm_available() -> bool:
+    """True if a MiniLM backend can be loaded (or already is)."""
+    if not ML_POLISH_AVAILABLE_DEFAULT:
+        return False
+    if _failed:
+        return False
+    if _model is not None:
+        return True
+    if not minilm_package_present():
+        return False
+    try:
+        _ensure_model()
+        return _model is not None
+    except Exception:
+        return False
+
+
+def _ensure_model():
+    global _model, _backend, _failed
+    if _model is not None or _failed:
+        return _model
+    with _lock:
+        if _model is not None or _failed:
+            return _model
+        # Prefer fastembed (ONNX, lighter than full PyTorch)
+        try:
+            from fastembed import TextEmbedding
+
+            _model = TextEmbedding(model_name=MINILM_MODEL)
+            _backend = "fastembed"
+            logger.info("MiniLM loaded via fastembed (%s)", MINILM_MODEL)
+            return _model
+        except Exception as exc:
+            logger.warning("fastembed MiniLM unavailable: %s", exc)
+
+        try:
+            from sentence_transformers import SentenceTransformer
+
+            # Common HF id when fastembed model name differs
+            st_name = MINILM_MODEL
+            if "/" not in st_name:
+                st_name = "sentence-transformers/all-MiniLM-L6-v2"
+            _model = SentenceTransformer(st_name)
+            _backend = "sentence-transformers"
+            logger.info("MiniLM loaded via sentence-transformers (%s)", st_name)
+            return _model
+        except Exception as exc:
+            logger.warning("sentence-transformers MiniLM unavailable: %s", exc)
+            _failed = True
+            _model = None
+            _backend = None
+            return None
+
+
+def backend_name() -> str | None:
+    _ensure_model()
+    return _backend
+
+
+def _embed_texts(texts: Sequence[str]) -> list[list[float]]:
+    model = _ensure_model()
+    if model is None:
+        return []
+    cleaned = [t.strip() or " " for t in texts]
+    if _backend == "fastembed":
+        # fastembed returns a generator of numpy arrays
+        return [list(map(float, vec)) for vec in model.embed(cleaned)]
+    # sentence-transformers
+    vectors = model.encode(cleaned, normalize_embeddings=True)
+    return [list(map(float, v)) for v in vectors]
+
+
+def _cosine(a: Sequence[float], b: Sequence[float]) -> float:
+    if not a or not b or len(a) != len(b):
+        return 0.0
+    dot = sum(x * y for x, y in zip(a, b))
+    # Vectors from ST are normalized; fastembed MiniLM is typically L2-normalized too.
+    # Still guard with norms for safety.
+    na = sum(x * x for x in a) ** 0.5
+    nb = sum(y * y for y in b) ** 0.5
+    if na <= 1e-9 or nb <= 1e-9:
+        return 0.0
+    return float(dot / (na * nb))
+
+
+@lru_cache(maxsize=8)
+def _tone_centroid(tone: str) -> tuple[float, ...] | None:
+    exemplars = _TONE_EXEMPLARS.get(tone) or _TONE_EXEMPLARS["Neutral"]
+    vectors = _embed_texts(exemplars)
+    if not vectors:
+        return None
+    dim = len(vectors[0])
+    acc = [0.0] * dim
+    for v in vectors:
+        for i, x in enumerate(v):
+            acc[i] += x
+    n = float(len(vectors))
+    return tuple(x / n for x in acc)
+
+
+def score_candidate(
+    original: str,
+    candidate: str,
+    *,
+    tone: str = "Neutral",
+) -> float:
+    """Higher is better. Mixes meaning retention with tone affinity."""
+    if not original.strip() or not candidate.strip():
+        return 0.0
+    vectors = _embed_texts([original, candidate])
+    if len(vectors) < 2:
+        return 0.0
+    meaning = _cosine(vectors[0], vectors[1])
+    # Reject meaning drift
+    if meaning < 0.62:
+        return meaning * 0.25
+    centroid = _tone_centroid(tone)
+    tone_sim = _cosine(vectors[1], centroid) if centroid else 0.0
+    return 0.72 * meaning + 0.28 * tone_sim
+
+
+def pick_best_candidate(
+    original_sentence: str,
+    candidates: Sequence[str],
+    *,
+    tone: str = "Neutral",
+    min_meaning: float = 0.68,
+) -> str | None:
+    """Pick the candidate sentence with best MiniLM score, or None if scoring fails."""
+    uniq = []
+    seen: set[str] = set()
+    for c in candidates:
+        key = (c or "").strip()
+        if not key or key in seen:
+            continue
+        seen.add(key)
+        uniq.append(key)
+    if not uniq:
+        return None
+    if len(uniq) == 1:
+        return uniq[0]
+    if _ensure_model() is None:
+        return None
+
+    best: str | None = None
+    best_score = -1.0
+    orig_vec = _embed_texts([original_sentence])
+    if not orig_vec:
+        return None
+    o = orig_vec[0]
+    cand_vecs = _embed_texts(uniq)
+    centroid = _tone_centroid(tone)
+    for text, vec in zip(uniq, cand_vecs):
+        meaning = _cosine(o, vec)
+        if meaning < min_meaning:
+            continue
+        tone_sim = _cosine(vec, centroid) if centroid else 0.0
+        score = 0.72 * meaning + 0.28 * tone_sim
+        if score > best_score:
+            best_score = score
+            best = text
+    return best
+
+
+def warm_minilm() -> bool:
+    """Optional startup warm — returns True if model is ready."""
+    try:
+        ok = minilm_available()
+        if ok:
+            _embed_texts(["warm up"])
+        return ok
+    except Exception as exc:
+        logger.warning("MiniLM warm failed: %s", exc)
+        return False

app/pipeline/ml_context.py

@@ -0,0 +1,25 @@
+"""Per-request ML polish flag (ContextVar — safe across async workers)."""
+
+from __future__ import annotations
+
+from contextvars import ContextVar
+
+_ml_polish: ContextVar[bool] = ContextVar("ml_polish", default=False)
+_ml_used: ContextVar[bool] = ContextVar("ml_used", default=False)
+
+
+def set_ml_polish(enabled: bool) -> None:
+    _ml_polish.set(bool(enabled))
+    _ml_used.set(False)
+
+
+def ml_polish_enabled() -> bool:
+    return bool(_ml_polish.get())
+
+
+def mark_ml_used() -> None:
+    _ml_used.set(True)
+
+
+def ml_was_used() -> bool:
+    return bool(_ml_used.get())

app/pipeline/ml_polish.py

@@ -0,0 +1,68 @@
+"""Sentence-level MiniLM polish — meaning guard + tone affinity."""
+
+from __future__ import annotations
+
+from app.pipeline.ml_context import mark_ml_used, ml_polish_enabled
+from app.pipeline.minilm import pick_best_candidate, score_candidate
+from app.pipeline.normalize import split_paragraphs, split_sentences_regex
+from app.pipeline.nlp import get_nlp
+from app.pipeline.tones import normalize_tone
+
+
+def _split_sents(text: str) -> list[str]:
+    nlp = get_nlp()
+    if nlp is not None:
+        return [s.text.strip() for s in nlp(text).sents if s.text.strip()]
+    return [s for s in split_sentences_regex(text) if s.strip()]
+
+
+def apply_minilm_polish(original: str, rewritten: str, tone: str) -> str:
+    """
+    When ML polish is on, compare sentence pairs and keep the better MiniLM score.
+    If sentence counts diverge, score the whole paragraph blocks instead.
+    """
+    if not ml_polish_enabled():
+        return rewritten
+    tone_l = normalize_tone(tone)
+    orig_paras = split_paragraphs(original)
+    rew_paras = split_paragraphs(rewritten)
+    if len(orig_paras) != len(rew_paras):
+        # Whole-doc fallback
+        best = pick_best_candidate(original, [rewritten, original], tone=tone_l)
+        if best:
+            mark_ml_used()
+            return best
+        return rewritten
+
+    out_paras: list[str] = []
+    used = False
+    for op, rp in zip(orig_paras, rew_paras):
+        o_sents = _split_sents(op)
+        r_sents = _split_sents(rp)
+        if len(o_sents) == len(r_sents) and o_sents:
+            merged: list[str] = []
+            for o, r in zip(o_sents, r_sents):
+                if o == r:
+                    merged.append(r)
+                    continue
+                # Prefer rewrite if it keeps meaning and leans toward tone
+                score_r = score_candidate(o, r, tone=tone_l)
+                score_o = score_candidate(o, o, tone=tone_l)
+                if score_r + 0.02 >= score_o * 0.92 and score_r >= 0.55:
+                    merged.append(r)
+                    used = True
+                else:
+                    # Meaning drift — keep original sentence
+                    merged.append(o)
+                    used = True
+            out_paras.append(" ".join(merged))
+        else:
+            best = pick_best_candidate(op, [rp, op], tone=tone_l)
+            if best:
+                out_paras.append(best)
+                used = True
+            else:
+                out_paras.append(rp)
+    if used:
+        mark_ml_used()
+    return "\n\n".join(p for p in out_paras if p)

app/pipeline/orchestrator.py

@@ -9,6 +9,9 @@ from dataclasses import dataclass
 from difflib import SequenceMatcher
 
 from app.pipeline.mechanics import enforce_length_budget, scrub_phrases, tidy
+from app.pipeline.ml_context import ml_was_used, set_ml_polish
+from app.pipeline.ml_polish import apply_minilm_polish
+from app.pipeline.minilm import minilm_available
 from app.pipeline.nlp import get_nlp, spacy_available
 from app.pipeline.normalize import (
     normalize_whitespace,
@@ -105,6 +108,7 @@ def rewrite_text(
     tone: str = "Neutral",
     strength: int = 1,
     preserve_length: bool = True,
+    ml_polish: bool = False,
 ) -> RewriteResult:
     started = time.perf_counter()
     original = normalize_whitespace(text or "")
@@ -113,13 +117,21 @@ def rewrite_text(
 
     strength = max(0, min(2, int(strength)))
     tone = normalize_tone(tone)
-    rng = _rng_for(original + "|" + tone + "|" + str(strength))
+    want_ml = bool(ml_polish) and minilm_available()
+    set_ml_polish(want_ml)
+    rng = _rng_for(original + "|" + tone + "|" + str(strength) + ("|ml" if want_ml else ""))
 
     paragraphs = split_paragraphs(original)
     out_paras = [_rewrite_paragraph(p, tone, strength, rng) for p in paragraphs]
 
     rewritten = tidy("\n\n".join(out_paras))
     rewritten = scrub_phrases(rewritten)
+    if want_ml:
+        rewritten = apply_minilm_polish(original, rewritten, tone)
+        rewritten = tidy(rewritten)
+        # Re-apply register after MiniLM sentence swaps
+        rewritten = apply_tone_style(rewritten, tone, strength, rng)
+        rewritten = apply_tone_contractions(rewritten, tone)
     rewritten = enforce_length_budget(original, rewritten, preserve_length)
     rewritten = tidy(rewritten)
 
@@ -128,6 +140,10 @@ def rewrite_text(
     if ratio > 0.85:
         logger.info("Low change detected (ratio=%.3f); running stronger second pass", ratio)
         rewritten = _force_more_changes(rewritten, tone, strength, rng)
+        if want_ml:
+            rewritten = apply_minilm_polish(original, 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 = tidy(rewritten)
         notes = "Applied second pass (input was too similar after first rewrite)."
@@ -135,6 +151,11 @@ def rewrite_text(
 
     changed = rewritten.strip() != original.strip()
     engine_bits = ["rules", "structure", "wordnet", "mechanics", "tone"]
+    if want_ml and ml_was_used():
+        engine_bits.append("minilm")
+    elif ml_polish and not minilm_available():
+        tip = "ML polish requested but MiniLM is unavailable on this server."
+        notes = f"{notes} {tip}".strip() if notes else tip
     if spacy_available():
         engine_bits.insert(0, "spacy")
     else:
@@ -144,7 +165,7 @@ def rewrite_text(
     msg = (
         f"rewrite engine={engine} strength={strength} tone={tone} "
         f"words={word_count(original)}->{word_count(rewritten)} "
-        f"changed={changed} similarity={ratio:.3f}"
+        f"changed={changed} similarity={ratio:.3f} ml_polish={want_ml}"
     )
     logger.info(msg)
     # HF Spaces often hide logger INFO; print shows in Space Logs

app/pipeline/sentence_transform.py

@@ -322,8 +322,8 @@ def front_subordinate(
     if main.lower().startswith(linker.lower()):
         return None
     body = main[0].lower() + main[1:] if main and main[0].isupper() else main
-    # Academic always prefers fronting; Formal usually; Casual sometimes keeps end
-    if is_casual(tone) and rng.random() < 0.35:
+    # Academic always prefers fronting; Formal usually; Casual often keeps clause at end
+    if is_casual(tone) and rng.random() < 0.55:
         return None
     link = linker
     if is_academic(tone) and linker.lower() == "while":
@@ -388,12 +388,19 @@ def transform_sentence(
     strength = max(0, min(2, int(strength)))
     max_n = max_transforms if max_transforms is not None else {0: 1, 1: 2, 2: 3}.get(strength, 2)
     tone_l = normalize_tone(tone)
+    # Academic / Formal lean into unpackers; Casual prefers punchy conversational ones
     tone_boost = {
-        "Casual": 0.1,
-        "Neutral": 0.05,
-        "Formal": 0.12,
-        "Academic": 0.18,
+        "Casual": 0.18,
+        "Neutral": 0.04,
+        "Formal": 0.14,
+        "Academic": 0.22,
     }.get(tone_l, 0.05)
+    # Casual: slightly fewer stacked transforms so text stays snappy
+    if max_transforms is None and is_casual(tone_l):
+        max_n = {0: 1, 1: 2, 2: 2}.get(strength, 2)
+    # Academic: allow one extra at Heavy
+    if max_transforms is None and is_academic(tone_l) and strength >= 2:
+        max_n = 4
     # At Normal+, almost always attempt high-value unpackers first
     base_chance = {0: 0.6, 1: 0.92, 2: 1.0}.get(strength, 0.92) + tone_boost
 

app/pipeline/synonym.py

@@ -9,8 +9,10 @@ from difflib import SequenceMatcher
 from functools import lru_cache
 
 from app.config import DATA_DIR
+from app.pipeline.ml_context import mark_ml_used, ml_polish_enabled
+from app.pipeline.minilm import pick_best_candidate
 from app.pipeline.nlp import get_nlp
-from app.pipeline.tones import is_academic, is_elevated, normalize_tone
+from app.pipeline.tones import is_academic, is_casual, is_elevated, normalize_tone
 
 _WORDNET_READY = False
 
@@ -33,6 +35,18 @@ _STOP_SWAP = {
 # Dynamic safety: POS gating (adj/adv WordNet only) + structural filters below.
 
 _OPENERS = {
+    # Conversational — short spoken connectors
+    "Casual": {
+        "but": "Still",
+        "so": "So",
+        "and": "Plus",
+        "yet": "Still",
+        "however": "Still",
+        "therefore": "So",
+        "additionally": "Also",
+        "furthermore": "Also",
+        "moreover": "Also",
+    },
     # Business / professional — restrained connectors
     "Formal": {
         "but": "Yet",
@@ -40,6 +54,8 @@ _OPENERS = {
         "and": "Also",
         "yet": "Still",
         "also": "Additionally",
+        "therefore": "Accordingly",
+        "however": "Nevertheless",
     },
     # Scholarly — denser discourse markers
     "Academic": {
@@ -49,6 +65,8 @@ _OPENERS = {
         "yet": "Nevertheless",
         "still": "Nevertheless",
         "also": "Moreover",
+        "therefore": "Accordingly",
+        "thus": "Hence",
     },
 }
 
@@ -110,13 +128,19 @@ def load_academic_swaps() -> dict[str, str]:
     return _load_json_map("academic_swaps.json")
 
 
+@lru_cache(maxsize=1)
+def load_casual_swaps() -> dict[str, str]:
+    return _load_json_map("casual_swaps.json")
+
+
 def _lexicon_for(tone: str, strength: int) -> dict[str, str]:
     """
     Merge lexicons by canonical tone:
     - content_swaps for every tone
     - Formal: elevate_swaps on top
     - Academic: elevate + academic_swaps (scholarly overlay)
-    - Neutral/Casual: preferred_swaps; Neutral also mild elevate fill-ins
+    - Casual: preferred + casual downshift overlay (wins over content)
+    - Neutral: preferred_swaps; mild elevate fill-ins at Normal+
     """
     content = load_content_swaps()
     tone_l = normalize_tone(tone)
@@ -124,6 +148,9 @@ def _lexicon_for(tone: str, strength: int) -> dict[str, str]:
         return {**content, **load_elevate_swaps(), **load_academic_swaps()}
     if is_elevated(tone_l):  # Formal
         return {**content, **load_elevate_swaps()}
+    if is_casual(tone_l):
+        # preferred + content, then casual wins on conflicts (stronger downshift)
+        return {**content, **load_preferred_swaps(), **load_casual_swaps()}
     merged = {**load_preferred_swaps(), **content}
     if tone_l == "Neutral" and strength >= 1:
         for k, v in load_elevate_swaps().items():
@@ -263,11 +290,41 @@ def _join_tokens(tokens: list[str]) -> str:
     return re.sub(r"\s+([,.;:!?])", r"\1", text)
 
 
-def _pick(cands: list[str], tone: str, rng: random.Random) -> str:
+def _pick(
+    cands: list[str],
+    tone: str,
+    rng: random.Random,
+    *,
+    original_sentence: str = "",
+    original_word: str = "",
+) -> str:
     if not cands:
         return ""
-    if is_elevated(tone):
+    tone_l = normalize_tone(tone)
+
+    # MiniLM polish: score full-sentence variants when enabled
+    if ml_polish_enabled() and original_sentence and original_word:
+        variants: list[str] = []
+        low = original_word.lower()
+        for c in cands[:5]:
+            # Replace first case-insensitive whole-word hit
+            pat = re.compile(rf"\b{re.escape(original_word)}\b", re.I)
+            if not pat.search(original_sentence):
+                pat = re.compile(rf"\b{re.escape(low)}\b", re.I)
+            nxt = pat.sub(_match_case(original_word, c), original_sentence, count=1)
+            variants.append(nxt)
+        best_sent = pick_best_candidate(original_sentence, variants, tone=tone_l)
+        if best_sent:
+            for c, variant in zip(cands[:5], variants):
+                if variant == best_sent:
+                    mark_ml_used()
+                    return c
+
+    if is_elevated(tone_l):
         return max(cands, key=len)
+    if is_casual(tone_l):
+        # Prefer shorter, punchier synonyms
+        return min(cands, key=lambda w: (len(w), w))
     return rng.choice(cands)
 
 
@@ -296,10 +353,14 @@ def rewrite_sentence_synonyms(
     lexicon = _lexicon_for(tone, strength)
     tone_l = normalize_tone(tone)
     openers = _OPENERS.get(tone_l, {})
-    # Formal: lexicon-only register. Neutral/Casual: adj/adv WordNet allowed.
+    # Formal/Academic: lexicon-only register. Casual: mostly lexicon (safer downshift).
+    # Neutral: adj/adv WordNet allowed more freely.
     if is_elevated(tone_l):
         max_wn = 0
         wn_rate = 0.0
+    elif is_casual(tone_l):
+        max_wn = {0: 0, 1: 1, 2: 2}.get(strength, 1)
+        wn_rate = {0: 0.0, 1: 0.35, 2: 0.55}.get(strength, 0.35)
     else:
         max_wn = {0: 1, 1: 3, 2: 5}.get(strength, 3)
         wn_rate = {0: 0.4, 1: 0.7, 2: 0.9}.get(strength, 0.7)
@@ -336,7 +397,16 @@ def rewrite_sentence_synonyms(
         if not cands:
             return raw
         wn_budget[0] -= 1
-        return _match_case(raw, _pick(cands, tone, rng))
+        return _match_case(
+            raw,
+            _pick(
+                cands,
+                tone,
+                rng,
+                original_sentence=sentence,
+                original_word=raw,
+            ),
+        )
 
     def _force_min_changes(tokens: list[str], out: list[str], min_changes: int) -> list[str]:
         changed = sum(1 for a, b in zip(tokens, out) if a.isalpha() and a != b)
@@ -367,7 +437,16 @@ def rewrite_sentence_synonyms(
                     cands = list(_wordnet_synonyms(low, "r"))
                 if not cands:
                     continue
-                out[i] = _match_case(tok, cands[0])
+                out[i] = _match_case(
+                    tok,
+                    _pick(
+                        cands,
+                        tone,
+                        rng,
+                        original_sentence=sentence,
+                        original_word=tok,
+                    ),
+                )
                 changed += 1
                 if changed >= min_changes:
                     break

app/pipeline/syntax_rewrite.py

@@ -139,7 +139,12 @@ def apply_tone_contractions(text: str, tone: str) -> str:
         (r"\byou are\b", "you're"),
         (r"\bthey are\b", "they're"),
         (r"\bI am\b", "I'm"),
+        (r"\bI have\b", "I've"),
+        (r"\blet us\b", "let's"),
+        (r"\bwho is\b", "who's"),
+        (r"\bwhat is\b", "what's"),
     ]
+    # Casual: full contraction set. Neutral: core negatives only (subtler).
     use = pairs if is_casual(tone_l) else pairs[:12]
     out = text
     for pat, repl in use:

app/pipeline/tones.py

@@ -1,8 +1,8 @@
 """Tone options — four meaningfully distinct registers.
 
-  - Neutral  — balanced default
-  - Casual   — conversational
-  - Formal   — professional / business elevated
+  - Neutral  — balanced default (mild elevate fill-ins at Normal+)
+  - Casual   — conversational (downshift lexicon, full contractions, punchy transforms)
+  - Formal   — professional / business elevated (no contractions)
   - Academic — scholarly register (denser lexicon, discourse markers, frames)
 """
 

frontend/dist/assets/index.css

@@ -643,6 +643,21 @@ textarea {
   accent-color: var(--accent);
 }
 
+.check-locked {
+  opacity: 0.78;
+}
+
+.check-badge {
+  font-size: 0.68rem;
+  font-weight: 700;
+  letter-spacing: 0.04em;
+  text-transform: uppercase;
+  color: var(--accent);
+  border: 1px solid color-mix(in srgb, var(--accent) 35%, transparent);
+  border-radius: 0.35rem;
+  padding: 0.08rem 0.35rem;
+}
+
 .toolbar-actions {
   display: flex;
   align-items: center;

frontend/dist/assets/index.js

@@ -632,6 +632,7 @@ function App() {
   const [tone, setTone] = useState("Neutral");
   const [strength, setStrength] = useState("Normal");
   const [preserveLength, setPreserveLength] = useState(true);
+  const [mlPolish, setMlPolish] = useState(false);
   const [loading, setLoading] = useState(false);
   const [error, setError] = useState("");
   const [meta, setMeta] = useState("");
@@ -654,6 +655,8 @@ function App() {
   const activeProduct = PRODUCTS.find((p) => p.id === product) || PRODUCTS[0];
   const isGuest = !!(authEnabled && !session);
   const maxWords = (account && account.plan && account.plan.max_words_per_request) || (isGuest ? guestMaxWords : 50000);
+  const planId = (account && account.plan && account.plan.id) || (authEnabled ? "guest" : "dev");
+  const canMlPolish = !authEnabled || planId === "pro" || planId === "plus";
 
   useEffect(() => {
     if (!copied) return undefined;
@@ -761,12 +764,21 @@ function App() {
     setError("");
     setMeta("Rewriting…");
     setFreshOut(false);
+    const wantMl = mlPolish && canMlPolish;
+    if (mlPolish && !canMlPolish) {
+      setShowUpgrade(true);
+      setError("ML polish (beta) is available on Pro and Plus.");
+      setMeta("");
+      setLoading(false);
+      return;
+    }
     try {
       const result = await rewriteText({
         text,
         tone,
         strength: STRENGTH_MAP[strength],
         preserve_length: preserveLength,
+        ml_polish: wantMl,
       }, session && session.access_token);
       setOutput(result.rewrite);
       setFreshOut(true);
@@ -968,6 +980,27 @@ function App() {
           h("input", { type: "checkbox", checked: preserveLength, onChange: (e) => setPreserveLength(e.target.checked) }),
           " Match length",
         ),
+        h("label", {
+          className: canMlPolish ? "check" : "check check-locked",
+          title: canMlPolish
+            ? "MiniLM scores synonym picks for meaning + tone (Pro beta)"
+            : "ML polish (beta) requires Pro or Plus",
+        },
+          h("input", {
+            type: "checkbox",
+            checked: mlPolish && canMlPolish,
+            onChange: (e) => {
+              if (!canMlPolish) {
+                setShowUpgrade(true);
+                setMlPolish(false);
+                return;
+              }
+              setMlPolish(e.target.checked);
+            },
+          }),
+          " ML polish (beta)",
+          canMlPolish ? null : h("span", { className: "check-badge" }, "Pro"),
+        ),
         h("div", { className: "toolbar-actions" },
           h("button", {
             type: "button",

frontend/src/App.tsx

@@ -103,10 +103,10 @@ const SAMPLE_TEXT =
   "Artificial intelligence has significantly transformed the way individuals create written content in recent years. Many professionals now rely on advanced language models to generate initial drafts quickly and efficiently. However, the resulting text can sometimes appear repetitive, overly formal, or lacking a natural human voice. Therefore, it is essential to carefully refine AI-generated material so that it communicates clearly, remains original in wording, and feels authentic to the intended audience.";
 
 const TONE_HINT: Record<Tone, string> = {
-  Neutral: "Clear and balanced",
-  Casual: "Conversational",
-  Formal: "Professional",
-  Academic: "Scholarly",
+  Neutral: "Clear and balanced — light elevate only",
+  Casual: "Conversational — contractions + downshift lexicon",
+  Formal: "Professional — elevated wording, no contractions",
+  Academic: "Scholarly — denser lexicon + discourse markers",
 };
 
 function wordCount(text: string): number {
@@ -631,6 +631,7 @@ export default function App() {
   const [tone, setTone] = useState<Tone>("Neutral");
   const [strength, setStrength] = useState<StrengthLabel>("Normal");
   const [preserveLength, setPreserveLength] = useState(true);
+  const [mlPolish, setMlPolish] = useState(false);
   const [loading, setLoading] = useState(false);
   const [error, setError] = useState("");
   const [meta, setMeta] = useState("");
@@ -656,6 +657,8 @@ export default function App() {
   const maxWords = isGuest
     ? guestMaxWords
     : account?.plan.max_words_per_request ?? 50000;
+  const planId = account?.plan.id ?? (authEnabled ? "guest" : "dev");
+  const canMlPolish = !authEnabled || planId === "pro" || planId === "plus";
 
   useEffect(() => {
     if (!copied) return;
@@ -685,7 +688,7 @@ export default function App() {
     window.addEventListener("keydown", onKey);
     return () => window.removeEventListener("keydown", onKey);
     // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [input, tone, strength, preserveLength, loading, session, product, grammarText, grammarLoading, grammarLanguage]);
+  }, [input, tone, strength, preserveLength, mlPolish, loading, session, product, grammarText, grammarLoading, grammarLanguage]);
 
   function openAuth(mode: "signin" | "signup", title?: string) {
     setAuthMode(mode);
@@ -795,6 +798,14 @@ export default function App() {
     setError("");
     setMeta("Rewriting…");
     setFreshOut(false);
+    const wantMl = mlPolish && canMlPolish;
+    if (mlPolish && !canMlPolish) {
+      setShowUpgrade(true);
+      setError("ML polish (beta) is available on Pro and Plus.");
+      setMeta("");
+      setLoading(false);
+      return;
+    }
     try {
       const result = await rewriteText(
         {
@@ -802,6 +813,7 @@ export default function App() {
           tone,
           strength: STRENGTH_MAP[strength],
           preserve_length: preserveLength,
+          ml_polish: wantMl,
         },
         session?.access_token,
       );
@@ -1169,6 +1181,30 @@ export default function App() {
                 />
                 Match length
               </label>
+
+              <label
+                className={`check${canMlPolish ? "" : " check-locked"}`}
+                title={
+                  canMlPolish
+                    ? "MiniLM scores synonym picks for meaning + tone (Pro beta)"
+                    : "ML polish (beta) requires Pro or Plus"
+                }
+              >
+                <input
+                  type="checkbox"
+                  checked={mlPolish && canMlPolish}
+                  onChange={(e) => {
+                    if (!canMlPolish) {
+                      setShowUpgrade(true);
+                      setMlPolish(false);
+                      return;
+                    }
+                    setMlPolish(e.target.checked);
+                  }}
+                />
+                ML polish (beta)
+                {!canMlPolish ? <span className="check-badge">Pro</span> : null}
+              </label>
             </div>
 
             <div className="toolbar-actions">

frontend/src/api.ts

@@ -63,6 +63,7 @@ export async function rewriteText(
     tone: Tone;
     strength: number;
     preserve_length: boolean;
+    ml_polish?: boolean;
   },
   accessToken?: string | null,
 ): Promise<RewriteResponse> {

frontend/src/index.css

@@ -643,6 +643,21 @@ textarea {
   accent-color: var(--accent);
 }
 
+.check-locked {
+  opacity: 0.78;
+}
+
+.check-badge {
+  font-size: 0.68rem;
+  font-weight: 700;
+  letter-spacing: 0.04em;
+  text-transform: uppercase;
+  color: var(--accent);
+  border: 1px solid color-mix(in srgb, var(--accent) 35%, transparent);
+  border-radius: 0.35rem;
+  padding: 0.08rem 0.35rem;
+}
+
 .toolbar-actions {
   display: flex;
   align-items: center;

requirements.txt

@@ -9,3 +9,5 @@ python-multipart>=0.0.9
 httpx>=0.27.0
 PyJWT[crypto]>=2.8.0
 python-dotenv>=1.0.0
+# Optional MiniLM scoring for Pro "ML polish" (ONNX via fastembed; graceful no-op if missing)
+fastembed>=0.4.2