Upload 34 files

app/data/content_swaps.json

@@ -192,5 +192,211 @@
   "alone": "solitary",
   "first": "initial",
   "second": "next",
-  "third": "another"
+  "third": "another",
+
+  "change": "shift",
+  "changes": "shifts",
+  "changed": "shifted",
+  "changing": "shifting",
+  "many": "numerous",
+  "much": "considerable",
+  "world": "globe",
+  "regions": "areas",
+  "region": "area",
+  "methods": "approaches",
+  "method": "approach",
+  "approach": "method",
+  "approaches": "methods",
+  "adapt": "adjust",
+  "adapts": "adjusts",
+  "adapted": "adjusted",
+  "survive": "endure",
+  "survives": "endures",
+  "survived": "endured",
+  "longer": "extended",
+  "unpredictable": "erratic",
+  "rainfall": "rain",
+  "droughts": "dry spells",
+  "drought": "dry spell",
+  "governments": "authorities",
+  "government": "authority",
+  "companies": "firms",
+  "company": "firm",
+  "better": "stronger",
+  "policies": "rules",
+  "policy": "rule",
+  "protect": "safeguard",
+  "protects": "safeguards",
+  "protected": "safeguarded",
+  "people": "communities",
+  "environment": "ecosystem",
+  "agriculture": "farming",
+  "farmers": "growers",
+  "farmer": "grower",
+  "reshaping": "remaking",
+  "reshape": "remake",
+  "across": "throughout",
+  "support": "aid",
+  "supports": "aids",
+  "supported": "aided",
+  "problem": "issue",
+  "problems": "issues",
+  "solution": "answer",
+  "solutions": "answers",
+  "important": "vital",
+  "crucial": "key",
+  "critical": "key",
+  "major": "primary",
+  "main": "primary",
+  "primary": "main",
+  "effect": "impact",
+  "effects": "impacts",
+  "impact": "effect",
+  "impacts": "effects",
+  "create": "build",
+  "creates": "builds",
+  "created": "built",
+  "develop": "build",
+  "develops": "builds",
+  "developed": "built",
+  "increase": "raise",
+  "increases": "raises",
+  "increased": "raised",
+  "decrease": "reduce",
+  "decreases": "reduces",
+  "decreased": "reduced",
+  "reduce": "lower",
+  "reduces": "lowers",
+  "reduced": "lowered",
+  "allow": "let",
+  "allows": "lets",
+  "allowed": "let",
+  "prevent": "stop",
+  "prevents": "stops",
+  "prevented": "stopped",
+  "include": "cover",
+  "includes": "covers",
+  "included": "covered",
+  "consider": "weigh",
+  "considers": "weighs",
+  "considered": "weighed",
+  "believe": "think",
+  "believes": "thinks",
+  "believed": "thought",
+  "understand": "grasp",
+  "understands": "grasps",
+  "understood": "grasped",
+  "explain": "clarify",
+  "explains": "clarifies",
+  "explained": "clarified",
+  "describe": "outline",
+  "describes": "outlines",
+  "described": "outlined",
+  "research": "study",
+  "studies": "research",
+  "study": "review",
+  "data": "evidence",
+  "information": "details",
+  "knowledge": "insight",
+  "system": "framework",
+  "systems": "frameworks",
+  "process": "procedure",
+  "processes": "procedures",
+  "workers": "staff",
+  "worker": "employee",
+  "team": "group",
+  "teams": "groups",
+  "project": "initiative",
+  "projects": "initiatives",
+  "goal": "aim",
+  "goals": "aims",
+  "success": "progress",
+  "successful": "effective",
+  "failure": "setback",
+  "challenge": "obstacle",
+  "challenges": "obstacles",
+  "opportunity": "chance",
+  "opportunities": "chances",
+  "benefit": "advantage",
+  "benefits": "advantages",
+  "risk": "hazard",
+  "risks": "hazards",
+  "quality": "standard",
+  "level": "degree",
+  "levels": "degrees",
+  "role": "part",
+  "roles": "parts",
+  "factor": "element",
+  "factors": "elements",
+  "example": "instance",
+  "examples": "instances",
+  "today": "nowadays",
+  "nowadays": "today",
+  "often": "frequently",
+  "rarely": "seldom",
+  "always": "consistently",
+  "clearly": "plainly",
+  "simply": "merely",
+  "really": "truly",
+  "very": "highly",
+  "quite": "fairly",
+  "rather": "somewhat",
+  "especially": "particularly",
+  "particularly": "especially",
+  "generally": "usually",
+  "usually": "typically",
+  "typically": "generally",
+  "global": "worldwide",
+  "local": "regional",
+  "public": "civic",
+  "private": "personal",
+  "social": "communal",
+  "economic": "financial",
+  "political": "civic",
+  "scientific": "technical",
+  "technology": "tech",
+  "digital": "online",
+  "online": "digital",
+  "communication": "dialogue",
+  "community": "society",
+  "communities": "societies",
+  "society": "community",
+  "education": "learning",
+  "health": "wellbeing",
+  "safety": "security",
+  "security": "safety",
+  "growth": "expansion",
+  "progress": "advancement",
+  "development": "growth",
+  "innovation": "novelty",
+  "strategy": "plan",
+  "strategies": "plans",
+  "decision": "choice",
+  "decisions": "choices",
+  "action": "step",
+  "actions": "steps",
+  "focus": "emphasis",
+  "focused": "centered",
+  "based": "grounded",
+  "related": "linked",
+  "connected": "linked",
+  "similar": "alike",
+  "various": "assorted",
+  "common": "usual",
+  "unique": "distinct",
+  "complex": "intricate",
+  "simple": "basic",
+  "basic": "simple",
+  "advanced": "sophisticated",
+  "traditional": "conventional",
+  "conventional": "traditional",
+  "efficient": "productive",
+  "useful": "helpful",
+  "helpful": "useful",
+  "harmful": "damaging",
+  "positive": "favorable",
+  "negative": "adverse",
+  "serious": "severe",
+  "severe": "serious",
+  "strong": "sturdy"
 }

app/pipeline/mechanics.py

@@ -70,7 +70,10 @@ def tidy(text: str) -> str:
 
 
 def enforce_length_budget(original: str, rewritten: str, preserve_length: bool) -> str:
-    """Trim only when rewrite clearly ballooned past the original."""
+    """Trim only when rewrite clearly ballooned past the original.
+
+    Preserves paragraph breaks (\\n\\n) — never flattens the document.
+    """
     o = len(original.split())
     r = len(rewritten.split())
     if o == 0:
@@ -80,13 +83,25 @@ def enforce_length_budget(original: str, rewritten: str, preserve_length: bool)
     if r <= max_words:
         return rewritten
 
-    parts = re.split(r"(?<=[.!?])\s+", rewritten.strip())
-    kept: list[str] = []
+    paragraphs = [p.strip() for p in re.split(r"\n\s*\n", rewritten.strip()) if p.strip()]
+    if not paragraphs:
+        return rewritten
+
+    kept_paras: list[str] = []
     count = 0
-    for p in parts:
-        w = len(p.split())
-        if kept and count + w > max_words:
+    for para in paragraphs:
+        parts = re.split(r"(?<=[.!?])\s+", para.strip())
+        kept_sents: list[str] = []
+        for p in parts:
+            w = len(p.split())
+            if kept_sents and count + w > max_words:
+                break
+            if not kept_sents and kept_paras and count + w > max_words:
+                break
+            kept_sents.append(p)
+            count += w
+        if kept_sents:
+            kept_paras.append(" ".join(kept_sents))
+        if count >= max_words:
             break
-        kept.append(p)
-        count += w
-    return " ".join(kept).strip() or rewritten
+    return "\n\n".join(kept_paras).strip() or rewritten

app/pipeline/orchestrator.py

@@ -74,16 +74,26 @@ def _rewrite_paragraph(paragraph: str, tone: str, strength: int, rng: random.Ran
 
 
 def _force_more_changes(text: str, tone: str, strength: int, rng: random.Random) -> str:
-    """Second pass if first pass left text nearly identical — tone phrases, not verb WordNet."""
-    bumped = apply_tone_style(text, tone, min(2, strength + 1), rng)
+    """Stronger per-paragraph pass — preserves \\n\\n breaks."""
     bump = min(2, strength + 1)
-    nlp = get_nlp()
-    if nlp is not None:
-        sents = [s.text.strip() for s in nlp(bumped).sents if s.text.strip()]
-    else:
-        sents = split_sentences_regex(bumped)
-    out = [rewrite_sentence_synonyms(s, bump, rng, tone=tone) for s in sents]
-    return scrub_phrases(" ".join(out))
+    paras = split_paragraphs(text)
+    out_paras: list[str] = []
+    for para in paras:
+        bumped = apply_tone_style(para, tone, bump, rng)
+        nlp = get_nlp()
+        if nlp is not None:
+            sents = [s.text.strip() for s in nlp(bumped).sents if s.text.strip()]
+        else:
+            sents = split_sentences_regex(bumped)
+        rewritten = [
+            rewrite_sentence_synonyms(s, bump, rng, tone=tone, force_all_lexicon=True)
+            for s in sents
+        ]
+        joined = scrub_phrases(" ".join(rewritten))
+        joined = apply_tone_style(joined, tone, bump, rng)
+        joined = apply_tone_contractions(joined, tone)
+        out_paras.append(joined.strip())
+    return "\n\n".join(p for p in out_paras if p)
 
 
 def rewrite_text(
@@ -111,11 +121,9 @@ def rewrite_text(
 
     ratio = _similarity_ratio(original, rewritten)
     notes = ""
-    if ratio > 0.88:
+    if ratio > 0.85:
         logger.info("Low change detected (ratio=%.3f); running stronger second pass", ratio)
         rewritten = _force_more_changes(rewritten, tone, strength, rng)
-        rewritten = apply_tone_style(rewritten, tone, 2, 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)."

app/pipeline/synonym.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import json
 import random
 import re
+from difflib import SequenceMatcher
 from functools import lru_cache
 
 from app.config import DATA_DIR
@@ -27,6 +28,29 @@ _STOP_SWAP = {
     "across", "around", "without", "within", "beside", "behind", "above", "below",
 }
 
+# Known bad WordNet lookalikes / truncated / wrong-sense forms
+_BLOCKED_SYNONYMS = {
+    "clime",
+    "climates",
+    "erstwhile",
+    "downhearted",
+    "reason",  # as synonym for ground
+    "late",  # as synonym for deep
+    "betimes",
+    "perceive",
+    "perceived",
+    "perceives",
+    "mood",  # climate.n.02 wrong sense
+    "moods",
+}
+
+# Prefer lexicon; avoid WordNet on short/concrete nouns that often misfire
+_RISKY_WN_NOUNS = {
+    "ground", "blue", "sky", "time", "day", "way", "thing", "part", "place",
+    "man", "woman", "boy", "girl", "seed", "once", "climate", "change",
+    "world", "people", "water", "fire", "earth", "light", "dark", "home",
+}
+
 _OPENERS = {
     "Academic": {
         "but": "However",
@@ -110,7 +134,7 @@ def _lexicon_for(tone: str, strength: int) -> dict[str, str]:
         return {**content, **load_elevate_swaps()}
     # preferred first, content overrides for everyday wording
     merged = {**load_preferred_swaps(), **content}
-    if tone_l == "Neutral" and strength >= 2:
+    if tone_l == "Neutral" and strength >= 1:
         # Mild elevate fill-ins when content didn't cover the token
         for k, v in load_elevate_swaps().items():
             merged.setdefault(k, v)
@@ -134,42 +158,52 @@ def _looks_inflected_verb(word: str) -> bool:
     return w in _IRREGULAR_PAST or w.endswith(("ing", "ed"))
 
 
-def _same_ending_shape(original: str, candidate: str) -> bool:
+def _is_morph_cousin(original: str, candidate: str) -> bool:
+    """Reject truncated / lookalike forms (climate→clime) that are not real paraphrases."""
     o, c = original.lower(), candidate.lower()
-    for end in ("ing", "ed", "ies", "es", "ly", "s"):
-        if o.endswith(end):
-            return c.endswith(end)
-    if c.endswith(("ing", "ed")):
-        return False
-    return True
+    if o.startswith(c) or c.startswith(o):
+        if abs(len(o) - len(c)) <= 3 and min(len(o), len(c)) >= 3:
+            return True
+    # Very high string overlap usually means same stem, not a paraphrase
+    if SequenceMatcher(None, o, c).ratio() >= 0.82:
+        return True
+    return False
 
 
 def _looks_safe_synonym(original: str, candidate: str) -> bool:
+    """Allow real paraphrases; reject stopwords, junk, and lookalike truncations.
+
+    NOTE: Do NOT require high character similarity — that rejects happy→glad
+    and accepts climate→clime.
+    """
     o, c = original.lower(), candidate.lower()
     if c in _STOP_SWAP or c == o:
         return False
+    if c in _BLOCKED_SYNONYMS:
+        return False
     if not c.isalpha() or " " in c:
         return False
-    if len(o) < 4 or len(c) < 4 or abs(len(c) - len(o)) > 5:
+    if len(o) < 4 or len(c) < 4:
         return False
-    if c.endswith(("ish", "ness", "ment", "ly")) and not o.endswith(
-        ("ish", "ness", "ment", "ly")
-    ):
+    if abs(len(c) - len(o)) > 8:
+        return False
+    if c.endswith(("ish", "ness", "ment")) and not o.endswith(("ish", "ness", "ment")):
         return False
     if o in {"first", "second", "third", "fourth", "fifth", "last", "next"}:
         return False
-    if not _same_ending_shape(o, c):
+    if _is_morph_cousin(o, c):
         return False
-    from difflib import SequenceMatcher
-
-    return SequenceMatcher(None, o, c).ratio() >= 0.58
+    return True
 
 
 @lru_cache(maxsize=4096)
 def _wordnet_synonyms(word: str, pos: str | None = None) -> tuple[str, ...]:
     if not _ensure_wordnet():
         return ()
-    if word.lower() in _STOP_SWAP or _looks_inflected_verb(word):
+    if word.lower() in _STOP_SWAP:
+        return ()
+    # Skip heavily inflected surface forms — lemma path handles verbs via spaCy
+    if _looks_inflected_verb(word):
         return ()
     from nltk.corpus import wordnet as wn
 
@@ -178,14 +212,18 @@ def _wordnet_synonyms(word: str, pos: str | None = None) -> tuple[str, ...]:
     elif pos in {"a", "r", "n"}:
         order = [pos]
     else:
-        order = ["a", "r", "n"]
+        # Prefer adjectives/adverbs before nouns (noun senses are often wrong)
+        order = ["a", "r", "v", "n"]
     out: list[str] = []
     for p in order:
         synsets = wn.synsets(word, pos=p)
         if not synsets:
             continue
+        # Only the most common sense — extra synsets cause ground→reason, blue→sad
         for lemma in synsets[0].lemmas():
             name = lemma.name().replace("_", " ").lower()
+            if " " in name:
+                continue
             if _looks_safe_synonym(word, name) and name not in out:
                 out.append(name)
         if out:
@@ -193,6 +231,14 @@ def _wordnet_synonyms(word: str, pos: str | None = None) -> tuple[str, ...]:
     return tuple(out[:5])
 
 
+@lru_cache(maxsize=4096)
+def _wordnet_synonyms_lemma(lemma: str, pos: str | None = None) -> tuple[str, ...]:
+    """Synonyms for a lemma (used for verbs after spaCy lemmatization)."""
+    if not lemma or len(lemma) < 3:
+        return ()
+    return _wordnet_synonyms(lemma, pos)
+
+
 def _match_case(original: str, replacement: str) -> str:
     if " " in replacement:
         parts = replacement.split()
@@ -246,6 +292,7 @@ def rewrite_sentence_synonyms(
     rng: random.Random,
     *,
     tone: str = "Neutral",
+    force_all_lexicon: bool = False,
 ) -> str:
     """
     Dynamic per-token rewrite for any input:
@@ -254,12 +301,17 @@ def rewrite_sentence_synonyms(
     lexicon = _lexicon_for(tone, strength)
     tone_l = (tone or "").strip()
     openers = _OPENERS.get(tone_l, {})
-    allow_wordnet = tone_l not in {"Academic", "Formal"}
-    nlp = get_nlp()
-    max_wn = {0: 1, 1: 3, 2: 5}.get(strength, 3) if allow_wordnet else 0
-    wn_rate = {0: 0.45, 1: 0.75, 2: 1.0}.get(strength, 0.75)
-    # Lexicon hits always apply at Normal+; Light still usually applies
-    lex_rate = {0: 0.7, 1: 1.0, 2: 1.0}.get(strength, 1.0)
+    # Lexicon carries Formal/Academic register; WordNet often picks wrong senses there
+    if tone_l in {"Academic", "Formal"}:
+        max_wn = 0
+        wn_rate = 0.0
+    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)
+    # Lexicon hits always apply at Normal+; Light usually applies; second pass forces all
+    lex_rate = 1.0 if force_all_lexicon else {0: 0.85, 1: 1.0, 2: 1.0}.get(strength, 1.0)
+
+    # Prefer lexicon; avoid WordNet on short/concrete nouns that often misfire
 
     def transform(
         raw: str,
@@ -267,7 +319,7 @@ def rewrite_sentence_synonyms(
         wn_budget: list[int],
         *,
         sentence_start: bool,
-        force_lex: bool = False,
+        lemma: str | None = None,
     ) -> str:
         low = raw.lower()
         if not raw.isalpha():
@@ -276,13 +328,19 @@ def rewrite_sentence_synonyms(
             return openers[low]
         if low in _STOP_SWAP or len(low) < 4:
             return raw
-        if low in lexicon and (force_lex or rng.random() < lex_rate):
+        if low in lexicon and rng.random() < lex_rate:
             return _match_case(raw, lexicon[low])
-        if not allow_wordnet or _looks_inflected_verb(low):
-            return raw
         if wn_budget[0] <= 0 or rng.random() > wn_rate:
             return raw
-        cands = list(_wordnet_synonyms(low, pos))
+        if low in _RISKY_WN_NOUNS:
+            return raw
+        if lemma and _looks_inflected_verb(low) and pos == "v":
+            return raw
+        lookup = low
+        lookup_pos = pos
+        cands = list(_wordnet_synonyms(lookup, lookup_pos))
+        if not cands and lemma and lemma.lower() == low:
+            cands = list(_wordnet_synonyms_lemma(lemma, lookup_pos))
         if not cands:
             return raw
         wn_budget[0] -= 1
@@ -296,7 +354,7 @@ def rewrite_sentence_synonyms(
             if not tok.isalpha():
                 continue
             if out[i] != tok:
-                continue  # already rewritten
+                continue
             low = tok.lower()
             if low in _STOP_SWAP or len(low) < 4 or low not in lexicon:
                 continue
@@ -304,8 +362,30 @@ def rewrite_sentence_synonyms(
             changed += 1
             if changed >= min_changes:
                 break
+        # If still short, try WordNet on remaining content words (Neutral/Casual only)
+        if changed < min_changes and max_wn > 0:
+            for i, tok in enumerate(tokens):
+                if 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)
+                    or low in _RISKY_WN_NOUNS
+                ):
+                    continue
+                cands = list(_wordnet_synonyms(low, None))
+                if not cands:
+                    continue
+                out[i] = _match_case(tok, cands[0])
+                changed += 1
+                if changed >= min_changes:
+                    break
         return out
 
+    nlp = get_nlp()
+
     if nlp is None:
         tokens = re.findall(r"\w+|[^\w\s]", sentence, flags=re.UNICODE)
         content_n = sum(
@@ -313,9 +393,11 @@ def rewrite_sentence_synonyms(
             for t in tokens
             if t.isalpha() and t.lower() not in _STOP_SWAP and len(t) >= 4
         )
-        min_ch = {0: 1, 1: max(2, content_n // 5), 2: max(3, content_n // 4)}.get(
+        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))
         budget = [max_wn]
         out = [
             transform(tok, None, budget, sentence_start=_is_sentence_start(tokens, i))
@@ -337,8 +419,13 @@ def rewrite_sentence_synonyms(
         start = i == 0 or prev_text in {".", "!", "?", "…"}
         if token.ent_type_ or token.pos_ in {"PROPN", "PRON", "DET", "ADP", "PART"}:
             low = raw.lower()
-            # Still allow lexicon on adjectives mis-tagged? Keep ADP locked.
-            pieces.append(openers[low] if start and low in openers else raw)
+            # Allow lexicon even on locked POS when we have an explicit swap
+            if low in lexicon and token.pos_ not in {"PROPN", "PRON", "DET"} and (
+                force_all_lexicon or rng.random() < lex_rate
+            ):
+                pieces.append(_match_case(raw, lexicon[low]))
+            else:
+                pieces.append(openers[low] if start and low in openers else raw)
             continue
         if token.pos_ in {"CCONJ", "SCONJ"}:
             low = raw.lower()
@@ -351,14 +438,30 @@ def rewrite_sentence_synonyms(
             continue
         if token.pos_ in {"VERB", "AUX"}:
             low = raw.lower()
-            if low in lexicon:
+            if low in lexicon and (force_all_lexicon or rng.random() < lex_rate):
                 pieces.append(_match_case(raw, lexicon[low]))
             elif not _looks_inflected_verb(low):
-                pieces.append(transform(raw, "v", budget, sentence_start=start))
+                pieces.append(
+                    transform(
+                        raw,
+                        "v",
+                        budget,
+                        sentence_start=start,
+                        lemma=token.lemma_,
+                    )
+                )
             else:
                 pieces.append(raw)
             continue
-        pieces.append(transform(raw, _wn_pos(token.tag_), budget, sentence_start=start))
+        pieces.append(
+            transform(
+                raw,
+                _wn_pos(token.tag_),
+                budget,
+                sentence_start=start,
+                lemma=token.lemma_,
+            )
+        )
 
     # Force lexicon fills if barely changed
     raws = [t.text for t in toks]
@@ -367,6 +470,8 @@ def rewrite_sentence_synonyms(
         for t in toks
         if t.is_alpha and t.text.lower() not in _STOP_SWAP and len(t.text) >= 4
     )
-    min_ch = {0: 1, 1: max(2, content_n // 5), 2: max(3, content_n // 4)}.get(strength, 2)
+    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)
     return "".join(p + t.whitespace_ for t, p in zip(doc, pieces)).strip()

app/pipeline/syntax_rewrite.py

@@ -17,31 +17,47 @@ def strip_hedges(sentence: str) -> str:
 def maybe_split_long(sentence: str, strength: int, rng: random.Random) -> list[str]:
     """Split long sentences on clause-like joins — based on length, not fixed content."""
     words = sentence.split()
-    min_len = {0: 28, 1: 22, 2: 18}.get(strength, 22)
-    chance = {0: 0.35, 1: 0.55, 2: 0.75}.get(strength, 0.55)
+    min_len = {0: 22, 1: 16, 2: 12}.get(strength, 16)
+    chance = {0: 0.45, 1: 0.7, 2: 0.9}.get(strength, 0.7)
     if len(words) < min_len or rng.random() > chance:
         return [sentence]
     if '"' in sentence or "'" in sentence or "“" in sentence or "”" in sentence:
         return [sentence]
 
-    for sep in ["; ", ", and ", ", but ", ", so ", ", which "]:
-        if sep in sentence:
-            left, right = sentence.split(sep, 1)
-            left, right = left.strip(), right.strip()
-            if len(left.split()) >= 6 and len(right.split()) >= 6:
-                if right and right[0].islower():
-                    right = right[0].upper() + right[1:]
-                if not left.endswith((".", "!", "?")):
-                    left += "."
-                if not right.endswith((".", "!", "?")):
-                    right += "."
-                return [left, right]
+    for sep in [
+        "; ",
+        ", and ",
+        ", but ",
+        ", so ",
+        ", which ",
+        ", although ",
+        ", because ",
+        ", while ",
+        ", whereas ",
+        " although ",
+        " because ",
+        " whereas ",
+    ]:
+        if sep not in sentence:
+            continue
+        left, right = sentence.split(sep, 1)
+        left, right = left.strip(), right.strip()
+        # Avoid splitting tiny fragments
+        if len(left.split()) < 5 or len(right.split()) < 5:
+            continue
+        if right and right[0].islower():
+            right = right[0].upper() + right[1:]
+        if not left.endswith((".", "!", "?")):
+            left += "."
+        if not right.endswith((".", "!", "?")):
+            right += "."
+        return [left, right]
     return [sentence]
 
 
 def maybe_passive_to_active(sentence: str, strength: int, rng: random.Random) -> str:
     """Light-touch: 'X was VERBed by Y' → 'Y VERBed X' when parse looks safe."""
-    if strength < 1 or rng.random() > 0.25 * strength:
+    if strength < 1 or rng.random() > 0.4 * strength:
         return sentence
     nlp = get_nlp()
     if nlp is None:
@@ -61,7 +77,7 @@ def maybe_passive_to_active(sentence: str, strength: int, rng: random.Random) ->
                             break
             if agent is None or verb.tag_ not in {"VBN"}:
                 continue
-            if len(doc) > 18:
+            if len(doc) > 22:
                 return sentence
             agent_span = agent.text
             for chunk in doc.noun_chunks: