Re-enable primary T5 paraphrase for stronger out1→out2 divergence.

Turn paraphrase primary back on with tighter surface/divergence gates, install CPU torch and prefetch the model in Docker, and keep structural rotation from being overwritten by fallback.

Co-authored-by: Cursor <cursoragent@cursor.com>

.env.example

@@ -33,15 +33,15 @@ ENGINE_CLASSICAL_AGGRESSIVE=true
 ENGINE_STRUCTURAL_VARIATION=true
 MINILM_MODEL=sentence-transformers/all-MiniLM-L6-v2
 
-# Local CPU paraphraser — OFF by default (spaCy + phrase + lexical wording).
-ENGINE_PARAPHRASE=false
-ENGINE_PARAPHRASE_PRIMARY=false
+# Local CPU paraphraser — ON for generative pass divergence (needs torch + T5).
+ENGINE_PARAPHRASE=true
+ENGINE_PARAPHRASE_PRIMARY=true
 ENGINE_PARAPHRASE_MODEL=Vamsi/T5_Paraphrase_Paws
 ENGINE_PARAPHRASE_MIN_SIM=0.72
-ENGINE_PARAPHRASE_NUM_RETURN=5
+ENGINE_PARAPHRASE_NUM_RETURN=6
 ENGINE_PARAPHRASE_MAX_NEW_TOKENS=72
-ENGINE_PARAPHRASE_MAX_SURFACE=0.88
-ENGINE_PARAPHRASE_MIN_DIVERGENCE=0.14
+ENGINE_PARAPHRASE_MAX_SURFACE=0.70
+ENGINE_PARAPHRASE_MIN_DIVERGENCE=0.30
 
 # Phrase-level rewrite (verb–object spans via WordNet hyponyms + optional T5)
 ENGINE_PHRASE_REWRITE=true

Dockerfile

@@ -1,87 +1,104 @@
-# Existing React interface
-FROM node:22-alpine AS frontend
-WORKDIR /web
-ENV NODE_TLS_REJECT_UNAUTHORIZED=0
-COPY frontend/package.json frontend/package-lock.json ./
-RUN npm ci
-COPY frontend/ ./
-RUN npm run build
-
-# Backend API + embedded LanguageTool for HF Spaces / single-container
-FROM python:3.12-slim
-
-ENV PYTHONDONTWRITEBYTECODE=1 \
-    PYTHONUNBUFFERED=1 \
-    PIP_NO_CACHE_DIR=1 \
-    HOST=0.0.0.0 \
-    PORT=7860 \
-    APP_TITLE="ZuZu Writer" \
-    WN_DATA_DIR=/opt/wn_data \
-    ENGINE_PARAPHRASE=false \
-    ENGINE_PARAPHRASE_PRIMARY=false \
-    ENGINE_FORCE_REWRITE=false \
-    ENGINE_USE_MINILM_SAFETY=false \
-    ENGINE_CLASSICAL_AGGRESSIVE=true \
-    ENGINE_STRUCTURAL_VARIATION=true \
-    ENGINE_LEXICAL_REFINEMENT=true \
-    ENGINE_PHRASE_REWRITE=true \
-    ENGINE_PHRASE_USE_T5=false \
-    ENGINE_PRESERVE_LENGTH=true \
-    ENGINE_SPLIT_LONG=true \
-    HF_HOME=/opt/hf_cache \
-    TRANSFORMERS_CACHE=/opt/hf_cache \
-    LANGUAGETOOL_HOME=/opt/languagetool \
-    LANGUAGETOOL_PORT=8010 \
-    LANGUAGE_TOOL_URL=http://127.0.0.1:8010 \
-    LANGUAGE_TOOL_ENABLED=true \
-    LANGUAGE_TOOL_EMBEDDED=true \
-    LANGUAGE_TOOL_LANGUAGE=en-US \
-    LANGUAGE_TOOL_TIMEOUT=90 \
-    LANGUAGE_TOOL_CHUNK_CHARS=1800 \
-    GRAMMAR_MAX_CHARS=12000 \
-    LANGUAGETOOL_JAVA_OPTS="-Xms256m -Xmx1024m"
-
-WORKDIR /app
-
-RUN apt-get update && apt-get install -y --no-install-recommends \
-    build-essential \
-    curl \
-    ca-certificates \
-    unzip \
-    openjdk-21-jre-headless \
-    && rm -rf /var/lib/apt/lists/*
-
-# LanguageTool stable server (self-hosted grammar)
-RUN curl -fsSL -o /tmp/lt.zip https://languagetool.org/download/LanguageTool-stable.zip \
-    && unzip -q /tmp/lt.zip -d /opt \
-    && LT_DIR="$(find /opt -maxdepth 1 -type d -name 'LanguageTool-*' | head -n 1)" \
-    && mv "$LT_DIR" /opt/languagetool \
-    && rm -f /tmp/lt.zip \
-    && test -f /opt/languagetool/languagetool-server.jar
-
-COPY requirements.txt .
-# spaCy model wheel is listed in requirements.txt.
-# Torch/T5 are not installed — rewrite is spaCy + WordNet phrase/lexical.
-RUN pip install --upgrade pip \
-    && pip install -r requirements.txt
-# Offline lexical resource used only when ENGINE_LEXICAL_REFINEMENT=true.
-RUN curl -fsSL -o /tmp/oewn.xml.gz \
-      https://github.com/globalwordnet/english-wordnet/releases/download/2025-edition/english-wordnet-2025.xml.gz \
-    && python -c "import wn; wn.add('/tmp/oewn.xml.gz')" \
-    && rm -f /tmp/oewn.xml.gz
-# No MiniLM/T5 prefetch — classical spaCy + WordNet only.
-
-COPY app ./app
-COPY app.py .
-COPY README.md .
-COPY scripts/start.sh /app/scripts/start.sh
-RUN sed -i 's/\r$//' /app/scripts/start.sh && chmod +x /app/scripts/start.sh
-COPY --from=frontend /web/dist ./frontend/dist
-
-EXPOSE 7860
-
-# LT cold-start can take 1–2 minutes
-HEALTHCHECK --interval=30s --timeout=5s --start-period=180s --retries=5 \
-  CMD curl -fsS http://127.0.0.1:7860/health || exit 1
-
-CMD ["/app/scripts/start.sh"]
+# Existing React interface
+FROM node:22-alpine AS frontend
+WORKDIR /web
+ENV NODE_TLS_REJECT_UNAUTHORIZED=0
+COPY frontend/package.json frontend/package-lock.json ./
+RUN npm ci
+COPY frontend/ ./
+RUN npm run build
+
+# Backend API + embedded LanguageTool for HF Spaces / single-container
+FROM python:3.12-slim
+
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1 \
+    PIP_NO_CACHE_DIR=1 \
+    HOST=0.0.0.0 \
+    PORT=7860 \
+    APP_TITLE="ZuZu Writer" \
+    WN_DATA_DIR=/opt/wn_data \
+    ENGINE_PARAPHRASE=true \
+    ENGINE_PARAPHRASE_PRIMARY=true \
+    ENGINE_PARAPHRASE_MODEL=Vamsi/T5_Paraphrase_Paws \
+    ENGINE_PARAPHRASE_MIN_SIM=0.72 \
+    ENGINE_PARAPHRASE_NUM_RETURN=6 \
+    ENGINE_PARAPHRASE_MAX_NEW_TOKENS=72 \
+    ENGINE_PARAPHRASE_MAX_SURFACE=0.70 \
+    ENGINE_PARAPHRASE_MIN_DIVERGENCE=0.30 \
+    ENGINE_FORCE_REWRITE=false \
+    ENGINE_USE_MINILM_SAFETY=true \
+    ENGINE_CLASSICAL_AGGRESSIVE=true \
+    ENGINE_STRUCTURAL_VARIATION=true \
+    ENGINE_LEXICAL_REFINEMENT=true \
+    ENGINE_PHRASE_REWRITE=true \
+    ENGINE_PHRASE_USE_T5=false \
+    ENGINE_PRESERVE_LENGTH=true \
+    ENGINE_SPLIT_LONG=true \
+    HF_HOME=/opt/hf_cache \
+    TRANSFORMERS_CACHE=/opt/hf_cache \
+    SENTENCE_TRANSFORMERS_HOME=/opt/hf_cache \
+    LANGUAGETOOL_HOME=/opt/languagetool \
+    LANGUAGETOOL_PORT=8010 \
+    LANGUAGE_TOOL_URL=http://127.0.0.1:8010 \
+    LANGUAGE_TOOL_ENABLED=true \
+    LANGUAGE_TOOL_EMBEDDED=true \
+    LANGUAGE_TOOL_LANGUAGE=en-US \
+    LANGUAGE_TOOL_TIMEOUT=90 \
+    LANGUAGE_TOOL_CHUNK_CHARS=1800 \
+    GRAMMAR_MAX_CHARS=12000 \
+    LANGUAGETOOL_JAVA_OPTS="-Xms256m -Xmx1024m"
+
+WORKDIR /app
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential \
+    curl \
+    ca-certificates \
+    unzip \
+    openjdk-21-jre-headless \
+    && rm -rf /var/lib/apt/lists/*
+
+# LanguageTool stable server (self-hosted grammar)
+RUN curl -fsSL -o /tmp/lt.zip https://languagetool.org/download/LanguageTool-stable.zip \
+    && unzip -q /tmp/lt.zip -d /opt \
+    && LT_DIR="$(find /opt -maxdepth 1 -type d -name 'LanguageTool-*' | head -n 1)" \
+    && mv "$LT_DIR" /opt/languagetool \
+    && rm -f /tmp/lt.zip \
+    && test -f /opt/languagetool/languagetool-server.jar
+
+COPY requirements.txt .
+# spaCy model wheel is listed in requirements.txt.
+# CPU torch + transformers power the local T5 paraphraser and MiniLM ranker.
+RUN pip install --upgrade pip \
+    && pip install --index-url https://download.pytorch.org/whl/cpu torch \
+    && pip install -r requirements.txt
+# Offline lexical resource used only when ENGINE_LEXICAL_REFINEMENT=true.
+RUN curl -fsSL -o /tmp/oewn.xml.gz \
+      https://github.com/globalwordnet/english-wordnet/releases/download/2025-edition/english-wordnet-2025.xml.gz \
+    && python -c "import wn; wn.add('/tmp/oewn.xml.gz')" \
+    && rm -f /tmp/oewn.xml.gz
+
+COPY app ./app
+COPY app.py .
+COPY README.md .
+COPY scripts/start.sh /app/scripts/start.sh
+RUN sed -i 's/\r$//' /app/scripts/start.sh && chmod +x /app/scripts/start.sh
+COPY --from=frontend /web/dist ./frontend/dist
+# Prefetch paraphrase + MiniLM so Space cold-start does not hit the Hub.
+RUN python - <<'PY'
+from transformers import AutoModelForSeq2SeqLM, AutoTokenizer
+name = "Vamsi/T5_Paraphrase_Paws"
+AutoTokenizer.from_pretrained(name)
+AutoModelForSeq2SeqLM.from_pretrained(name)
+from app.pipeline.minilm import warm_minilm
+ok = warm_minilm()
+print("prefetch ok", name, "minilm", ok)
+PY
+
+EXPOSE 7860
+
+# LT cold-start can take 1–2 minutes
+HEALTHCHECK --interval=30s --timeout=5s --start-period=180s --retries=5 \
+  CMD curl -fsS http://127.0.0.1:7860/health || exit 1
+
+CMD ["/app/scripts/start.sh"]

README.md

@@ -31,9 +31,10 @@ copy .env.example .env
 
 Structural rewriting is the first pass. Unchanged rewriteable sentences are
 then paraphrased with a local CPU T5 model and ranked by MiniLM similarity.
-Low-impact synonyms can still apply afterward. Set
-`ENGINE_PARAPHRASE=true` (default) and keep `ENGINE_FORCE_REWRITE=false`
-to avoid the old fixed `It is … that …` cleft style.
+With `ENGINE_PARAPHRASE_PRIMARY=true`, a more divergent paraphrase can also
+replace a light structural rewrite so a second pass (out1→out2) moves further.
+Low-impact synonyms can still apply afterward. Keep
+`ENGINE_FORCE_REWRITE=false` to avoid the old fixed `It is … that …` cleft.
 
 ### 3. Build the existing UI
 

app/config.py

@@ -161,10 +161,10 @@ ENGINE_REQUIRE_WORDING_CHANGE = _erw in {"1", "true", "yes", "on"}
 _efr = (os.environ.get("ENGINE_FORCE_REWRITE") or "false").strip().lower()
 ENGINE_FORCE_REWRITE = _efr in {"1", "true", "yes", "on"}
 
-# Local CPU T5 paraphraser (off by default — wording uses phrase + lexical).
-_ep = (os.environ.get("ENGINE_PARAPHRASE") or "false").strip().lower()
+# Local CPU T5 paraphraser (primary rewrite path when the model is available).
+_ep = (os.environ.get("ENGINE_PARAPHRASE") or "true").strip().lower()
 ENGINE_PARAPHRASE = _ep in {"1", "true", "yes", "on"}
-_epp = (os.environ.get("ENGINE_PARAPHRASE_PRIMARY") or "false").strip().lower()
+_epp = (os.environ.get("ENGINE_PARAPHRASE_PRIMARY") or "true").strip().lower()
 ENGINE_PARAPHRASE_PRIMARY = _epp in {"1", "true", "yes", "on"}
 ENGINE_PARAPHRASE_MODEL = (
     os.environ.get("ENGINE_PARAPHRASE_MODEL")
@@ -179,7 +179,7 @@ ENGINE_PARAPHRASE_MIN_SIM = max(
 )
 ENGINE_PARAPHRASE_NUM_RETURN = max(
     1,
-    min(int(os.environ.get("ENGINE_PARAPHRASE_NUM_RETURN", "5") or "5"), 8),
+    min(int(os.environ.get("ENGINE_PARAPHRASE_NUM_RETURN", "6") or "6"), 8),
 )
 ENGINE_PARAPHRASE_MAX_NEW_TOKENS = max(
     16,
@@ -192,7 +192,7 @@ ENGINE_PARAPHRASE_MAX_NEW_TOKENS = max(
 ENGINE_PARAPHRASE_MAX_SURFACE = max(
     0.5,
     min(
-        float(os.environ.get("ENGINE_PARAPHRASE_MAX_SURFACE", "0.88") or "0.88"),
+        float(os.environ.get("ENGINE_PARAPHRASE_MAX_SURFACE", "0.70") or "0.70"),
         0.99,
     ),
 )
@@ -201,7 +201,7 @@ ENGINE_PARAPHRASE_MIN_DIVERGENCE = max(
     0.0,
     min(
         float(
-            os.environ.get("ENGINE_PARAPHRASE_MIN_DIVERGENCE", "0.14") or "0.14"
+            os.environ.get("ENGINE_PARAPHRASE_MIN_DIVERGENCE", "0.30") or "0.30"
         ),
         0.6,
     ),

app/engine/fallback/__init__.py

@@ -16,6 +16,7 @@ from app.engine.templates import (
     try_in_both_front,
     try_in_pp_front,
     try_such_as_front,
+    try_unfront_opener,
     try_when_clause_front,
 )
 from app.engine.voice import active_to_passive, passive_to_active
@@ -87,6 +88,7 @@ def structural_fallback_candidates(
     _add("in_both_front", try_in_both_front(source), 0.75)
     _add("in_pp_front", try_in_pp_front(source), 0.74)
     _add("complex_clause_swap", try_complex_clause_swap(source), 0.74)
+    _add("unfront_opener", try_unfront_opener(source), 0.77)
     _add("by_agent_front", try_by_agent_front(source), 0.73)
     _add("copula_np_invert", try_copula_np_invert(source), 0.72)
     _add("such_as_front", try_such_as_front(source), 0.70)

app/engine/orchestrator.py

@@ -383,7 +383,10 @@ def _apply_paraphrase_fallback(
                     )
                 )
 
-    if _unchanged(record) or not options:
+    # Structural fallbacks only fill gaps. If the plan path already rewrote the
+    # sentence, overwriting it here would discard per-request rotation and pin
+    # every sentence to the single highest-ranked fallback.
+    if _unchanged(record):
         structural = rotate(
             structural_fallback_candidates(record.original),
             seed=variation_seed,
@@ -391,8 +394,6 @@ def _apply_paraphrase_fallback(
             confidence_of=lambda item: item[2],
         )
         for template_id, candidate, confidence in structural:
-            if not _unchanged(record) and options:
-                break
             options.append(
                 (template_id, candidate, confidence, "structure_fallback")
             )

app/engine/paraphrase/__init__.py

@@ -117,7 +117,10 @@ def surface_similarity(source: str, candidate: str) -> float:
     right = re.sub(r"\s+", " ", (candidate or "").strip().lower()).rstrip(".!?")
     if not left or not right:
         return 0.0
-    return SequenceMatcher(None, left, right).ratio()
+    # autojunk discards any character filling >1% of a sequence longer than 200,
+    # which for prose means every space and common letter. The ratio would then
+    # be decided by rare letters alone and swing wildly on long inputs.
+    return SequenceMatcher(None, left, right, autojunk=False).ratio()
 
 
 def sufficiently_changed(

app/engine/templates/__init__.py

@@ -158,6 +158,87 @@ def try_complex_clause_swap(text: str) -> str | None:
     return f"{_cap(main)}{separator}{continuation}{end}"
 
 
+# Connectives relate the sentence to the previous one; moving them to the tail
+# breaks the link the writer set up.
+_DISCOURSE_OPENERS = frozenset(
+    {
+        "however", "moreover", "therefore", "thus", "also", "instead",
+        "nevertheless", "nonetheless", "meanwhile", "furthermore", "besides",
+        "otherwise", "consequently", "similarly", "conversely", "finally",
+        "first", "firstly", "second", "secondly", "third", "thirdly", "next",
+        "then", "overall", "generally", "typically", "unfortunately",
+        "fortunately", "importantly", "specifically", "notably",
+    }
+)
+
+
+@lru_cache(maxsize=2048)
+def try_unfront_opener(text: str) -> str | None:
+    """Move a sentence-initial modifier phrase to the end.
+
+    The inverse of the ``*_front`` family. Fronted openers are otherwise a dead
+    end: the fronting templates regenerate the same sentence, so a text that
+    already opens with "For the success of any business, ..." has no remaining
+    structural move.
+    """
+    raw = (text or "").strip()
+    if "," not in raw:
+        return None
+    nlp = get_nlp()
+    if nlp is None:
+        return None
+    try:
+        doc = nlp(raw)
+    except Exception:
+        return None
+
+    comma = next((token for token in doc if token.text == ","), None)
+    root = next((token for token in doc if token.dep_ == "ROOT"), None)
+    if comma is None or root is None or root.i <= comma.i:
+        return None
+    # A second comma usually means a list or an embedded aside; the opener is
+    # then no longer a clean prefix to relocate.
+    if any(token.text == "," for token in doc[comma.i + 1 :]):
+        return None
+
+    opener_head = next(
+        (
+            token
+            for token in doc
+            if token.head.i == root.i
+            and token.dep_ in {"prep", "advmod", "npadvmod", "nmod"}
+            and min(part.i for part in token.subtree) == 0
+            and max(part.i for part in token.subtree) == comma.i - 1
+        ),
+        None,
+    )
+    if opener_head is None:
+        return None
+    if doc[0].lower_ in _DISCOURSE_OPENERS:
+        return None
+    # The subject must follow the comma, otherwise the "opener" is really part
+    # of the subject and moving it would strand the verb. Copular sentences
+    # carry a clausal subject ("providing good service is vital").
+    subject = next(
+        (
+            child
+            for child in root.children
+            if child.dep_ in {"nsubj", "nsubjpass", "csubj"}
+        ),
+        None,
+    )
+    if subject is None or subject.i < comma.i:
+        return None
+
+    end = _terminal(raw)
+    core = raw[:-1].rstrip() if raw.endswith((".", "!", "?")) else raw
+    opener, main = (part.strip() for part in core.split(",", 1))
+    if len(opener.split()) < 2 or len(main.split()) < 4:
+        return None
+    continuation = opener[0].lower() + opener[1:] if not doc[0].pos_ == "PROPN" else opener
+    return f"{_cap(main)} {continuation}{end}"
+
+
 def _manner_before_verb(slots: SentenceSlots) -> bool:
     return not slots.verb_starts_with_aux
 

app/engine/voice/__init__.py

@@ -127,6 +127,26 @@ def active_to_passive(text: str) -> str | None:
         if any(token.text == "," for token in between):
             return None
 
+    # The same list can parse as a bare adverbial clause instead of a conjunct
+    # ("appreciate companies that reply, resolve issues, and treat them well"
+    # hangs "resolve" off the ROOT as advcl). Rebuilding leaves that tail behind
+    # the agent, so refuse. Genuine adverbial clauses carry a subordinating mark,
+    # their own subject, or an infinitival "to".
+    stray_verb_phrase = any(
+        child.dep_ == "advcl"
+        and child.pos_ == "VERB"
+        and child.tag_ in {"VB", "VBP", "VBZ", "VBD"}
+        and child.i > root.i
+        and not any(
+            grand.dep_ in {"mark", "nsubj", "nsubjpass", "aux"}
+            or grand.pos_ == "SCONJ"
+            for grand in child.children
+        )
+        for child in root.children
+    )
+    if stray_verb_phrase:
+        return None
+
     subject = next((child for child in root.children if child.dep_ == "nsubj"), None)
     if subject is None or subject.pos_ == "PRON":
         return None

tests/test_api.py

@@ -9,6 +9,8 @@ os.environ.setdefault("LANGUAGE_TOOL_ENABLED", "false")
 os.environ.setdefault("LANGUAGE_TOOL_URL", "")
 os.environ.setdefault("GRAMMAR_FIX_OUTPUT", "false")
 os.environ.setdefault("ENGINE_USE_MINILM_SAFETY", "false")
+os.environ.setdefault("ENGINE_LEXICAL_REFINEMENT", "false")
+os.environ.setdefault("ENGINE_FORCE_REWRITE", "false")
 
 from fastapi.testclient import TestClient
 
@@ -18,7 +20,10 @@ main_module = importlib.import_module("app.main")
 client = TestClient(app)
 
 
-def test_rewrite_accepts_text_only():
+def test_rewrite_accepts_text_only(monkeypatch):
+    monkeypatch.setattr(main_module, "ENGINE_LEXICAL_REFINEMENT", False)
+    monkeypatch.setattr(main_module, "ENGINE_FORCE_REWRITE", False)
+    monkeypatch.setattr(main_module, "ENGINE_PARAPHRASE", False)
     response = client.post(
         "/v1/rewrite",
         json={"text": "Ram went to school yesterday happily."},
@@ -36,7 +41,10 @@ def test_rewrite_accepts_text_only():
     assert "ml_polish" not in body["meta"]
 
 
-def test_legacy_ui_controls_are_ignored():
+def test_legacy_ui_controls_are_ignored(monkeypatch):
+    monkeypatch.setattr(main_module, "ENGINE_LEXICAL_REFINEMENT", False)
+    monkeypatch.setattr(main_module, "ENGINE_FORCE_REWRITE", False)
+    monkeypatch.setattr(main_module, "ENGINE_PARAPHRASE", False)
     response = client.post(
         "/v1/rewrite",
         json={
@@ -47,16 +55,20 @@ def test_legacy_ui_controls_are_ignored():
         },
     )
     assert response.status_code == 200
-    assert response.json()["rewrite"] == "Yesterday, Ram happily went to school."
+    # ml_polish still enables lexical when the env stage is off; force stays off.
+    assert "Yesterday" in response.json()["rewrite"]
+    assert "Ram" in response.json()["rewrite"]
 
 
-def test_ml_polish_checkbox_controls_enabled_lexical_stage(monkeypatch):
-    captured: dict[str, bool] = {}
+def test_ml_polish_checkbox_boosts_lexical_changes(monkeypatch):
+    captured: dict[str, object] = {}
     original = main_module.rewrite_document
 
     def capture(text: str, **kwargs):
         captured["enabled"] = kwargs["use_lexical_refinement"]
-        return original(text, use_lexical_refinement=False)
+        captured["max_changes"] = kwargs.get("lexical_max_changes")
+        captured["polish"] = kwargs.get("lexical_polish")
+        return original(text, use_lexical_refinement=False, force_rewrite=False)
 
     monkeypatch.setattr(main_module, "ENGINE_LEXICAL_REFINEMENT", True)
     monkeypatch.setattr(main_module, "rewrite_document", capture)
@@ -69,15 +81,45 @@ def test_ml_polish_checkbox_controls_enabled_lexical_stage(monkeypatch):
     )
     assert response.status_code == 200
     assert captured["enabled"] is True
+    assert captured["max_changes"] is None
+    assert captured["polish"] is True
     assert response.json()["meta"]["ml_polish_requested"] is True
 
 
+def test_ml_polish_changes_output_more_aggressively():
+    text = (
+        "The manager subsequently assisted several diligent students during "
+        "the unusually difficult afternoon workshop."
+    )
+    plain = client.post("/v1/rewrite", json={"text": text, "ml_polish": False})
+    polished = client.post("/v1/rewrite", json={"text": text, "ml_polish": True})
+    assert plain.status_code == 200
+    assert polished.status_code == 200
+    plain_body = plain.json()
+    polished_body = polished.json()
+    assert plain_body["rewrite"] != polished_body["rewrite"]
+    plain_changes = [
+        change
+        for sentence in plain_body["sentences"]
+        for change in sentence["lexical_changes"]
+    ]
+    polished_changes = [
+        change
+        for sentence in polished_body["sentences"]
+        for change in sentence["lexical_changes"]
+    ]
+    assert len(polished_changes) > len(plain_changes)
+
+
 def test_health_reports_rewrite_service():
     response = client.get("/health")
     assert response.status_code == 200
     body = response.json()
     assert body["service"] == "rewrite-api"
-    assert body["rewrite_engine"]["mode"] == "structural"
+    assert body["rewrite_engine"]["mode"] == (
+        "structural+paraphrase-primary+phrase+ensure"
+    )
+    assert body["rewrite_engine"]["paraphrase"]["primary"] is True
     assert body["ui"] == "react"
     assert "ml_polish" not in body
 

tests/test_round_trip_stability.py

@@ -2,8 +2,10 @@
 
 from __future__ import annotations
 
+import pytest
+
 from app.engine import orchestrator
-from app.engine.paraphrase import surface_similarity
+from app.engine.paraphrase import paraphrase_resource_available, surface_similarity
 
 
 CUSTOMER_SAMPLE = (
@@ -35,21 +37,32 @@ _BAD = (
 )
 
 
-def _rewrite(text: str, *, polish: bool, seed: int | None = None):
+def _rewrite(
+    text: str,
+    *,
+    polish: bool,
+    seed: int | None = None,
+    use_paraphrase: bool = False,
+):
     return orchestrator.rewrite_document(
         text,
         lexical_polish=polish,
         use_lexical_refinement=True,
-        use_paraphrase=False,
-        use_minilm_safety=False,
+        use_paraphrase=use_paraphrase,
+        use_minilm_safety=use_paraphrase,
         require_wording_change=True,
         variation_seed=seed,
     )
 
 
-def _round_trip(text: str, *, polish: bool) -> tuple[str, str, float, float]:
-    first = _rewrite(text, polish=polish)
-    second = _rewrite(first.text, polish=polish)
+def _round_trip(
+    text: str,
+    *,
+    polish: bool,
+    use_paraphrase: bool = False,
+) -> tuple[str, str, float, float]:
+    first = _rewrite(text, polish=polish, use_paraphrase=use_paraphrase)
+    second = _rewrite(first.text, polish=polish, use_paraphrase=use_paraphrase)
     hop1 = surface_similarity(text, first.text)
     hop2 = surface_similarity(first.text, second.text)
     return first.text, second.text, hop1, hop2
@@ -65,10 +78,9 @@ def test_round_trip_polish_true_keeps_meaning_on_both_hops():
     out1, out2, hop1, hop2 = _round_trip(CUSTOMER_SAMPLE, polish=True)
     print(f"polish=true hop1(input->out1)={hop1:.4f} hop2(out1->out2)={hop2:.4f}")
     print(f"identical={out1 == out2}")
-    # Wording is a fixed point after pass 1; any second-hop movement comes from
-    # structure (a voice flip), never from marginal WordNet senses.
     assert out1 != CUSTOMER_SAMPLE
-    assert hop1 < 0.90, hop1
+    # Corrected SequenceMatcher (autojunk=False) scores long prose higher.
+    assert hop1 < 0.95, hop1
     for text in (out1, out2):
         _assert_no_bad(text)
         for marker in ("vital", "employee", "reputation"):
@@ -87,8 +99,30 @@ def test_round_trip_reports_similarity_for_inspection():
     out1, out2, hop1, hop2 = _round_trip(CUSTOMER_SAMPLE, polish=True)
     print(f"round_trip hop1={hop1:.4f} hop2={hop2:.4f}")
     print(f"out1_words={len(out1.split())} out2_words={len(out2.split())}")
-    assert hop1 < 0.90
-    assert hop2 > 0.85
+    assert hop1 < 0.95
+    # Classical-only path: second hop may only flip structure lightly.
+    assert hop2 > 0.70
+
+
+@pytest.mark.skipif(
+    not paraphrase_resource_available(),
+    reason="T5 paraphraser unavailable in this environment",
+)
+def test_generative_round_trip_diverges_below_half():
+    """Primary T5 paraphrase should drive out1→out2 well below classical levels."""
+    out1, out2, hop1, hop2 = _round_trip(
+        CUSTOMER_SAMPLE, polish=True, use_paraphrase=True
+    )
+    print(f"generative hop1={hop1:.4f} hop2={hop2:.4f}")
+    print(f"out1={out1[:180]}...")
+    print(f"out2={out2[:180]}...")
+    assert out1 != CUSTOMER_SAMPLE
+    assert out1 != out2
+    assert hop2 < 0.40, hop2
+    for text in (out1, out2):
+        _assert_no_bad(text)
+        for marker in ("vital", "employee", "reputation"):
+            assert marker in text.lower()
 
 
 def test_repeated_requests_pick_different_structures(structural_variation):

tests/test_structural_variation.py

@@ -65,6 +65,38 @@ def test_active_and_passive_are_not_mutually_reachable():
     assert passive_to_active(passive) is not None
 
 
+def test_active_to_passive_refuses_misattached_coordinate_tails():
+    """spaCy may hang list verbs as advcl; rebuilding would strand them."""
+    text = (
+        "Customers appreciate companies that respond quickly to their questions, "
+        "resolve issues efficiently, and treat them with respect."
+    )
+    assert active_to_passive(text) is None
+
+
+def test_unfront_opener_moves_prepositional_prefix():
+    from app.engine.templates import try_unfront_opener
+
+    assert try_unfront_opener(
+        "For the success of any business, supplying excellent customer service "
+        "is vital."
+    ) == (
+        "Supplying excellent customer service is vital for the success of any "
+        "business."
+    )
+    assert try_unfront_opener(
+        "By consistently delivering high-quality service, organizations can "
+        "establish a strong reputation."
+    ) == (
+        "Organizations can establish a strong reputation by consistently "
+        "delivering high-quality service."
+    )
+    # Discourse connectives must stay fronted.
+    assert try_unfront_opener(
+        "However, the committee approved the budget today."
+    ) is None
+
+
 def test_coordinated_split_repeats_subject_instead_of_stranding_a_verb():
     text = (
         "By consistently delivering high-quality service, organizations can "