Upload 90 files

app/engine/fallback/__init__.py

@@ -7,14 +7,29 @@ from app.engine.plan import build_plan
 from app.engine.rewrite import generate_candidates, reorder_quality_ok
 from app.engine.templates import (
     try_because_front,
+    try_by_agent_front,
     try_complex_clause_swap,
     try_copula_np_invert,
     try_for_purpose_front,
+    try_in_both_front,
     try_in_pp_front,
     try_such_as_front,
+    try_when_clause_front,
 )
 from app.engine.voice import active_to_passive
 
+_DEDICATED = frozenset(
+    {
+        "for_purpose_front",
+        "in_pp_front",
+        "copula_np_invert",
+        "such_as_front",
+        "when_clause_front",
+        "by_agent_front",
+        "in_both_front",
+    }
+)
+
 
 def structural_fallback_candidates(
     text: str,
@@ -43,25 +58,21 @@ def structural_fallback_candidates(
             return
         if not sufficiently_changed(source, cleaned):
             return
-        # Dedicated fallbacks already preserve meaning; skip the generic
-        # opener guard that rejects valid PP/predicate fronts.
-        if template_id not in {
-            "for_purpose_front",
-            "in_pp_front",
-            "copula_np_invert",
-            "such_as_front",
-        } and not reorder_quality_ok(source, cleaned):
+        if template_id not in _DEDICATED and not reorder_quality_ok(source, cleaned):
             return
         seen.add(key)
         results.append((template_id, cleaned, confidence))
 
+    _add("when_clause_front", try_when_clause_front(source), 0.80)
+    _add("because_front", try_because_front(source), 0.78)
     _add("for_purpose_front", try_for_purpose_front(source), 0.76)
+    _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("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)
     _add("active_to_passive", active_to_passive(source), 0.68)
-    _add("because_front", try_because_front(source), 0.78)
-    _add("complex_clause_swap", try_complex_clause_swap(source), 0.74)
 
     plan = build_plan(source, min_confidence=min_confidence)
     if plan.safe:

app/engine/lexical/__init__.py

@@ -1,4 +1,4 @@
-"""Conservative, context-aware vocabulary refinement."""
+"""Conservative, context-aware vocabulary refinement (no hard-coded word lists)."""
 
 from __future__ import annotations
 
@@ -20,6 +20,7 @@ from app.config import (
     ENGINE_WORDNET_LEXICON,
 )
 from app.engine.models import LexicalChange
+from app.engine.quality import substitution_pos_stable
 from app.pipeline.nlp import get_nlp
 
 _POS_MAP = {"NOUN": "n", "VERB": "v", "ADJ": "a", "ADV": "r"}
@@ -30,57 +31,6 @@ _CITATION = re.compile(
 )
 _QUOTES = frozenset({'"', "“", "”", "‘", "’"})
 _CLEFT_PREFIX = re.compile(r"^it is\b", re.I)
-# Collocation-sensitive light verbs: do not swap when the object is idiomatic.
-_LIGHT_VERB_OBJECTS: dict[str, frozenset[str]] = {
-    "play": frozenset({"role", "roles", "part", "parts", "host", "hosts"}),
-    "take": frozenset({"place", "part", "care", "advantage", "effect"}),
-    "make": frozenset({"sense", "sure", "way", "difference"}),
-    "do": frozenset({"homework", "favor", "favours", "justice"}),
-}
-_BLOCKED_LEMMA_SWAPS = frozenset(
-    {
-        ("play", "act"),
-        ("act", "play"),
-        ("play", "perform"),
-        ("perform", "play"),
-        # Archaic WordNet sense: "science" ≈ problem-solving skill.
-        ("skill", "science"),
-        ("science", "skill"),
-        # Wrong everyday sense / awkward wording.
-        ("equip", "fit"),
-        ("fit", "equip"),
-        ("teammate", "mate"),
-        ("mate", "teammate"),
-        ("improve", "better"),
-        ("better", "improve"),
-        ("overcome", "master"),
-        ("master", "overcome"),
-    }
-)
-# Closed compounds must not be opened ("teamwork" → "team work").
-_CLOSED_COMPOUNDS = frozenset(
-    {
-        "teamwork",
-        "teammate",
-        "teammates",
-        "workplace",
-        "lifestyle",
-        "classmate",
-        "classroom",
-        "homework",
-        "feedback",
-        "deadline",
-        "workflow",
-        "workforce",
-        "online",
-        "database",
-    }
-)
-# Plural "individuals" should become everyday "people", not "persons".
-_CURATED_SURFACE = {
-    ("individual", "NNS"): "people",
-    ("individual", "NNPS"): "People",
-}
 logger = logging.getLogger("plainrewrite.lexical")
 
 
@@ -97,8 +47,6 @@ def _get_wordnet() -> Any | None:
     try:
         import wn
 
-        # FastAPI executes synchronous endpoints in worker threads. Wn must
-        # permit its shared SQLite pool to be used across those workers.
         wn.config.allow_multithreading = True
         return wn.Wordnet(ENGINE_WORDNET_LEXICON)
     except Exception as exc:
@@ -124,17 +72,11 @@ def _context_terms(doc, target) -> set[str]:
 
 
 def _terms_from_text(text: str, stop_words: set[str]) -> set[str]:
-    terms = {
-        match.group(0).lower()
-        for match in _WORD.finditer(text or "")
-    }
+    terms = {match.group(0).lower() for match in _WORD.finditer(text or "")}
     return {term for term in terms if len(term) >= 3 and term not in stop_words}
 
 
-def _gloss_terms(
-    synset,
-    stop_words: set[str],
-) -> tuple[set[str], set[str]]:
+def _gloss_terms(synset, stop_words: set[str]) -> tuple[set[str], set[str]]:
     definition = _terms_from_text(synset.definition(), stop_words)
     examples: set[str] = set()
     try:
@@ -160,46 +102,40 @@ def _sense_score(synset, context: set[str], stop_words: set[str]) -> float:
 def _eligible(token, doc) -> bool:
     if token.pos_ not in _POS_MAP:
         return False
+    lemma = token.lemma_.lower()
     if (
         token.pos_ == "PROPN"
         or token.ent_type_
         or token.is_stop
         or not token.is_alpha
-        or len(token.lemma_) < 3
+        or len(lemma) < 3
         or token.dep_ in {"aux", "auxpass", "neg", "mark"}
         or _PROTECTED_MARKER.search(token.text)
     ):
         return False
-    # Keep gerund subjects/cleft foci stable ("Planning ..." / "It is planning ...").
     if token.tag_ == "VBG" and token.dep_ in {"ROOT", "csubj", "nsubj", "attr"}:
         return False
     if token.tag_ == "VBG" and token.i <= 2 and _CLEFT_PREFIX.search(doc.text):
         return False
-    # Prefer content heads; skip light copulas already handled above.
-    if token.lemma_.lower() in {"be", "have", "do"}:
+    if lemma in {"be", "have", "do"}:
         return False
-    # In clefts, refine the predicate rather than the dummy subject.
     if _CLEFT_PREFIX.search(doc.text) and token.text.lower() in {"it"}:
         return False
-    # Freeze ability constructions: "better equipped to …", "prepared to …".
-    if token.tag_ in {"VBN", "VBD"} and token.i + 1 < len(doc):
-        if doc[token.i + 1].lower_ == "to":
-            return False
-    # Keep closed compounds intact.
-    if token.text.lower() in _CLOSED_COMPOUNDS or token.lemma_.lower() in {
-        "teamwork",
-        "teammate",
-    }:
+    # Freeze "* to …" constructions (equipped to, bring to, get to, …).
+    if token.i + 1 < len(doc) and doc[token.i + 1].lower_ == "to":
         return False
     return True
 
 
 def _impact_rank(token) -> int:
-    """Lower score = safer / lower-impact wording change."""
     if token.pos_ == "ADV":
         return 0
     if token.pos_ == "ADJ":
         return 1
+    if token.pos_ == "VERB" and token.dep_ != "ROOT":
+        return 2
+    if token.pos_ == "VERB":
+        return 3
     if token.pos_ == "NOUN" and token.dep_ in {
         "attr",
         "acomp",
@@ -208,23 +144,15 @@ def _impact_rank(token) -> int:
         "dobj",
         "appos",
     }:
-        return 2
-    if token.pos_ == "VERB" and token.dep_ != "ROOT":
-        return 3
-    if token.pos_ == "NOUN":
         return 4
-    if token.pos_ == "VERB":
+    if token.pos_ == "NOUN":
         return 5
     return 6
 
 
 def _inflect(lemma: str, token) -> str | None:
-    curated = _CURATED_SURFACE.get((token.lemma_.lower(), token.tag_))
-    if curated and lemma in {"person", "individual", "someone", "somebody"}:
-        value = curated
-    else:
-        forms = getInflection(lemma, tag=token.tag_)
-        value = forms[0] if forms else lemma
+    forms = getInflection(lemma, tag=token.tag_)
+    value = forms[0] if forms else lemma
     if not value or not _WORD.fullmatch(value) or " " in value or "_" in value:
         return None
     if token.text.isupper():
@@ -264,7 +192,7 @@ def _phrase_zipf(word: str, left: str, right: str) -> float:
     return max(scores)
 
 
-def _verb_collocation_ok(
+def _collocation_ok(
     source_lemma: str,
     candidate_lemma: str,
     token,
@@ -272,47 +200,47 @@ def _verb_collocation_ok(
     left: str,
     right: str,
 ) -> bool:
-    """Reject swaps that break light-verb / neighbor collocations."""
-    if (source_lemma, candidate_lemma) in _BLOCKED_LEMMA_SWAPS:
-        return False
+    """Reject swaps that collapse local collocations (algorithmic, no denylist)."""
     obj = _object_lemma(token)
-    protected = _LIGHT_VERB_OBJECTS.get(source_lemma)
-    if protected and obj in protected:
-        # Freeze idiomatic light verbs ("play a role", "take place").
-        return False
+    checks: list[tuple[float, float]] = []
     if obj:
-        source_vo = zipf_frequency(f"{source_lemma} {obj}", "en")
-        candidate_vo = zipf_frequency(f"{candidate_lemma} {obj}", "en")
-        # Only reject a sharp collocation collapse, not ordinary near-synonyms.
-        if source_vo >= 3.5 and candidate_vo + 0.85 < source_vo:
-            return False
-        if source_vo >= 4.0 and candidate_vo < 2.0:
-            return False
+        checks.append(
+            (
+                zipf_frequency(f"{source_lemma} {obj}", "en"),
+                zipf_frequency(f"{candidate_lemma} {obj}", "en"),
+            )
+        )
     if right:
-        source_right = zipf_frequency(f"{source_lemma} {right}", "en")
-        candidate_right = zipf_frequency(f"{candidate_lemma} {right}", "en")
-        if source_right >= 4.0 and candidate_right + 0.85 < source_right:
-            return False
+        checks.append(
+            (
+                zipf_frequency(f"{source_lemma} {right}", "en"),
+                zipf_frequency(f"{candidate_lemma} {right}", "en"),
+            )
+        )
     if left:
-        source_left = zipf_frequency(f"{left} {source_lemma}", "en")
-        candidate_left = zipf_frequency(f"{left} {candidate_lemma}", "en")
-        if source_left >= 4.0 and candidate_left + 0.85 < source_left:
+        checks.append(
+            (
+                zipf_frequency(f"{left} {source_lemma}", "en"),
+                zipf_frequency(f"{left} {candidate_lemma}", "en"),
+            )
+        )
+    for source_score, candidate_score in checks:
+        if source_score >= 3.5 and candidate_score + 0.85 < source_score:
+            return False
+        if source_score >= 4.0 and candidate_score < 2.0:
             return False
     return True
 
 
 def _frequency_ok(source_frequency: float, candidate_frequency: float) -> bool:
-    """Accept common everyday replacements; reject rarer/advanced wording."""
     if candidate_frequency < ENGINE_LEXICAL_MIN_ZIPF:
         return False
     if ENGINE_LEXICAL_PREFER_SIMPLER:
-        # Allow a larger move toward more common words.
         if candidate_frequency > source_frequency:
             return (
                 candidate_frequency - source_frequency
                 <= ENGINE_LEXICAL_MAX_SIMPLER_GAP
             )
-        # Only a tiny step toward less common / more advanced words.
         return source_frequency - candidate_frequency <= ENGINE_LEXICAL_MAX_HARDER_GAP
     return (
         abs(candidate_frequency - source_frequency)
@@ -321,11 +249,8 @@ def _frequency_ok(source_frequency: float, candidate_frequency: float) -> bool:
 
 
 def _candidate_for_synset(synset, token, doc) -> tuple[str, float] | None:
-    """Return (replacement, simplicity_gain) for the best everyday synonym."""
     source = token.lemma_.lower()
     source_surface = token.text.lower()
-    # Use surface frequency too so inflected forms like "equipped" are not
-    # treated as rare just because the lemma "equip" is uncommon.
     source_frequency = max(
         zipf_frequency(source, "en"),
         zipf_frequency(source_surface, "en"),
@@ -337,7 +262,6 @@ def _candidate_for_synset(synset, token, doc) -> tuple[str, float] | None:
     except Exception:
         return None
 
-    # Rank: higher everyday frequency, stronger collocation, shorter word.
     ranked: list[tuple[float, float, float, str]] = []
     for word in words:
         lemma = (word.lemma() or "").replace("_", " ").strip().lower()
@@ -348,9 +272,7 @@ def _candidate_for_synset(synset, token, doc) -> tuple[str, float] | None:
             or not _WORD.fullmatch(lemma)
         ):
             continue
-        if (source, lemma) in _BLOCKED_LEMMA_SWAPS:
-            continue
-        if token.pos_ == "VERB" and not _verb_collocation_ok(
+        if not _collocation_ok(
             source,
             lemma,
             token,
@@ -358,11 +280,10 @@ def _candidate_for_synset(synset, token, doc) -> tuple[str, float] | None:
             right=right,
         ):
             continue
-        candidate_frequency = zipf_frequency(lemma, "en")
-        # Curated everyday plurals (individuals→people) use the surface zipf.
         replacement = _inflect(lemma, token)
         if not replacement or replacement.lower() == token.text.lower():
             continue
+        candidate_frequency = zipf_frequency(lemma, "en")
         rank_frequency = zipf_frequency(replacement.lower(), "en")
         if not _frequency_ok(
             source_frequency,
@@ -370,9 +291,6 @@ def _candidate_for_synset(synset, token, doc) -> tuple[str, float] | None:
         ):
             continue
         phrase = _phrase_zipf(replacement.lower(), left, right)
-        # Reject rare collocations. For adjective+noun pairs, also reject a
-        # jump into a more common but wrong sense ("daily tasks" ->
-        # "daily projects").
         if phrase + 0.55 < source_phrase:
             continue
         if left and token.pos_ == "NOUN":
@@ -380,7 +298,6 @@ def _candidate_for_synset(synset, token, doc) -> tuple[str, float] | None:
             candidate_bigram = zipf_frequency(
                 f"{left} {replacement.lower()}", "en"
             )
-            # Keep noun compounds stable ("teamwork skills" not "teamwork sciences").
             if source_bigram >= 3.0 and candidate_bigram + 0.45 < source_bigram:
                 continue
         if (
@@ -391,9 +308,15 @@ def _candidate_for_synset(synset, token, doc) -> tuple[str, float] | None:
             and phrase > source_phrase + 0.25
         ):
             continue
-        brevity = -float(len(replacement))
+        if not substitution_pos_stable(doc.text, token.i, replacement):
+            continue
         ranked.append(
-            (max(candidate_frequency, rank_frequency), phrase, brevity, replacement)
+            (
+                max(candidate_frequency, rank_frequency),
+                phrase,
+                -float(len(replacement)),
+                replacement,
+            )
         )
 
     if not ranked:
@@ -436,11 +359,11 @@ def refine_sentence(
         return LexicalResult(text=source, reason="parse_failed")
 
     stop_words = set(nlp.Defaults.stop_words)
-    # (wsd, impact, -simplicity_gain, offset, token_i, replacement, synset)
     proposals: list[tuple[float, int, float, int, int, str, Any]] = []
     for token in doc:
         if not _eligible(token, doc):
             continue
+        # Prefer low-impact slots: modifiers first; nouns/verbs need stronger sense support.
         context = _context_terms(doc, token)
         try:
             synsets = list(
@@ -451,43 +374,51 @@ def refine_sentence(
             )
         except Exception:
             continue
-        best: tuple[float, Any] | None = None
-        for synset in synsets:
-            score = _sense_score(synset, context, stop_words)
-            if best is None or score > best[0]:
-                best = (score, synset)
-        if best is not None and best[0] == 0.0 and len(synsets) == 1:
-            # A single available sense is unambiguous even when its short
-            # gloss shares no literal words with the sentence context.
-            best = (min_wsd, best[1])
-        if (
-            synsets
-            and (best is None or best[0] < min_wsd)
-            and ENGINE_LEXICAL_PREFER_SIMPLER
-        ):
-            # Soft path: only the primary WordNet sense. Secondary senses cause
-            # meaning errors like skill→science ("problem-domain ability").
-            primary = synsets[0]
-            trial = _candidate_for_synset(primary, token, doc)
-            if trial is not None and trial[1] >= 0.45:
-                best = (min_wsd, primary)
-        if best is None or best[0] < min_wsd:
+        if not synsets:
             continue
-        picked = _candidate_for_synset(best[1], token, doc)
-        if picked:
-            replacement, simplicity_gain = picked
-            # Prefer low-impact slots, then larger gains toward simpler words.
-            proposals.append(
-                (
-                    best[0],
-                    _impact_rank(token),
-                    -simplicity_gain,
-                    token.idx,
-                    token.i,
-                    replacement,
-                    best[1],
-                )
+
+        # Nouns/verbs stay on the primary WordNet sense only. Secondary senses
+        # create meaning errors (skill→science) even with partial gloss overlap.
+        if token.pos_ in {"NOUN", "VERB"}:
+            chosen = synsets[0]
+            best_score = _sense_score(chosen, context, stop_words)
+            if best_score < min_wsd:
+                continue
+        else:
+            scored: list[tuple[float, Any]] = []
+            for synset in synsets:
+                scored.append((_sense_score(synset, context, stop_words), synset))
+            scored.sort(key=lambda item: item[0], reverse=True)
+            best_score, best_synset = scored[0]
+            chosen = None
+            if best_score >= min_wsd:
+                chosen = best_synset
+            elif len(synsets) == 1:
+                chosen = best_synset
+                best_score = min_wsd
+            elif ENGINE_LEXICAL_PREFER_SIMPLER and best_score == 0.0:
+                trial = _candidate_for_synset(synsets[0], token, doc)
+                if trial is not None and trial[1] >= 0.45:
+                    chosen = synsets[0]
+                    best_score = min_wsd
+            if chosen is None:
+                continue
+
+        picked = _candidate_for_synset(chosen, token, doc)
+        if not picked:
+            continue
+        replacement, simplicity_gain = picked
+        proposals.append(
+            (
+                best_score,
+                _impact_rank(token),
+                -simplicity_gain,
+                token.idx,
+                token.i,
+                replacement,
+                chosen,
             )
+        )
 
     if not proposals:
         return LexicalResult(text=source, reason="no_confident_candidate")
@@ -504,7 +435,6 @@ def refine_sentence(
     ):
         token = doc[token_index]
         output = output[:offset] + replacement + output[offset + len(token.text) :]
-        # Keep a/an agreement when an adjective or noun changes.
         if token_index > 0 and doc[token_index - 1].lower_ in {"a", "an"}:
             prev = doc[token_index - 1]
             needed = _article_for(replacement)
@@ -521,7 +451,7 @@ def refine_sentence(
                 replacement=replacement,
                 token_index=token_index,
                 lemma=token.lemma_,
-                synset_id=str(synset.id),
+                synset_id=str(getattr(synset, "id", synset)),
                 confidence=round(confidence, 4),
             )
         )

app/engine/orchestrator.py

@@ -185,27 +185,28 @@ def _apply_paraphrase_fallback(
     min_confidence: float,
     use_minilm: bool,
 ) -> SentenceRecord:
-    """Dynamic paraphrase, then varied structural reorders — never fixed clefts."""
-    if not enabled or record.sentence_type not in _REWRITEABLE_TYPES:
+    """Paraphrase (optional) then structural reorders for unchanged sentences."""
+    if record.sentence_type not in _REWRITEABLE_TYPES:
         return record
     if not _unchanged(record):
         return record
 
     options: list[tuple[str, str, float, str]] = []
-    result = paraphrase_sentence(record.original)
-    if (
-        result.text
-        and result.text != record.original
-        and sufficiently_changed(record.original, result.text)
-    ):
-        options.append(
-            (
-                "paraphrase",
-                result.text,
-                max(0.55, result.confidence),
-                "paraphrase_fallback",
+    if enabled:
+        result = paraphrase_sentence(record.original)
+        if (
+            result.text
+            and result.text != record.original
+            and sufficiently_changed(record.original, result.text)
+        ):
+            options.append(
+                (
+                    "paraphrase",
+                    result.text,
+                    max(0.55, result.confidence),
+                    "paraphrase_fallback",
+                )
             )
-        )
 
     for template_id, candidate, confidence in structural_fallback_candidates(
         record.original

app/engine/quality/__init__.py

@@ -0,0 +1,200 @@
+"""Algorithmic rewrite quality gates (no word/phrase denylists)."""
+
+from __future__ import annotations
+
+import re
+from collections import Counter
+
+from app.pipeline.nlp import get_nlp
+
+_WORD = re.compile(r"[A-Za-z][A-Za-z']*")
+_MODAL = frozenset(
+    {"can", "could", "will", "would", "may", "might", "should", "must", "shall"}
+)
+
+
+def _alpha_tokens(text: str) -> list[str]:
+    return [m.group(0).lower() for m in _WORD.finditer(text or "")]
+
+
+def closed_compounds_not_split(original: str, candidate: str) -> bool:
+    """Reject when a solid source token is opened into two words (teamwork→team work)."""
+    source_tokens = _alpha_tokens(original)
+    cand = re.sub(r"\s+", " ", (candidate or "").lower())
+    cand_token_set = set(_alpha_tokens(candidate))
+    for token in source_tokens:
+        if len(token) < 6:
+            continue
+        if token in cand_token_set:
+            continue
+        for index in range(3, len(token) - 2):
+            left, right = token[:index], token[index:]
+            if f"{left} {right}" in cand:
+                return False
+    return True
+
+
+def modal_head_pos_preserved(original: str, candidate: str) -> bool:
+    """Keep modal/aux clause heads stable in POS and lexical relatedness."""
+    nlp = get_nlp()
+    if nlp is None:
+        return True
+    try:
+        source_doc = nlp(original or "")
+        cand_doc = nlp(candidate or "")
+    except Exception:
+        return True
+
+    def _modal_heads(doc) -> list[tuple[str, str, str]]:
+        heads: list[tuple[str, str, str]] = []
+        for token in doc:
+            lemma = token.lemma_.lower()
+            is_modal = lemma in _MODAL or (
+                token.pos_ == "AUX" and token.dep_ in {"aux", "auxpass"}
+            )
+            if not is_modal:
+                continue
+            head = token.head
+            if head.i == token.i:
+                continue
+            heads.append((lemma, head.pos_, head.lemma_.lower()))
+        return heads
+
+    def _verb_related(source_lemma: str, candidate_lemma: str) -> bool:
+        if source_lemma == candidate_lemma:
+            return True
+        try:
+            import wn
+            from app.config import ENGINE_WORDNET_LEXICON
+
+            wn.config.allow_multithreading = True
+            resource = wn.Wordnet(ENGINE_WORDNET_LEXICON)
+            synsets = list(resource.synsets(source_lemma, pos="v"))
+        except Exception:
+            # If lexicon is unavailable, keep POS-only behavior.
+            return True
+        for synset in synsets:
+            try:
+                words = {
+                    (word.lemma() or "").replace("_", " ").strip().lower()
+                    for word in synset.words()
+                }
+            except Exception:
+                continue
+            if candidate_lemma in words:
+                return True
+        return False
+
+    source_heads = _modal_heads(source_doc)
+    if not source_heads:
+        return True
+    cand_heads = _modal_heads(cand_doc)
+    cand_by_modal: dict[str, list[tuple[str, str]]] = {}
+    for modal, pos, lemma in cand_heads:
+        cand_by_modal.setdefault(modal, []).append((pos, lemma))
+    for modal, pos, lemma in source_heads:
+        options = cand_by_modal.get(modal)
+        if not options:
+            continue
+        matched = False
+        for cand_pos, cand_lemma in options:
+            if cand_pos != pos:
+                continue
+            if _verb_related(lemma, cand_lemma):
+                matched = True
+                break
+        if not matched:
+            return False
+    return True
+
+
+def content_pos_balance_ok(original: str, candidate: str) -> bool:
+    """Reject large shifts in content POS counts (noun/verb/adj)."""
+    nlp = get_nlp()
+    if nlp is None:
+        return True
+    try:
+        source_doc = nlp(original or "")
+        cand_doc = nlp(candidate or "")
+    except Exception:
+        return True
+
+    def _counts(doc) -> Counter:
+        return Counter(
+            token.pos_
+            for token in doc
+            if token.is_alpha and not token.is_stop and token.pos_ in {"NOUN", "VERB", "ADJ"}
+        )
+
+    source = _counts(source_doc)
+    cand = _counts(cand_doc)
+    for pos in ("NOUN", "VERB", "ADJ"):
+        if abs(source[pos] - cand[pos]) > 2:
+            return False
+    return True
+
+
+def substitution_pos_stable(
+    sentence: str,
+    token_index: int,
+    replacement: str,
+) -> bool:
+    """Require the replaced span to keep the same coarse POS after re-parse."""
+    nlp = get_nlp()
+    if nlp is None:
+        return True
+    try:
+        doc = nlp(sentence)
+    except Exception:
+        return True
+    if token_index < 0 or token_index >= len(doc):
+        return False
+    token = doc[token_index]
+    updated = sentence[: token.idx] + replacement + sentence[token.idx + len(token.text) :]
+    try:
+        new_doc = nlp(updated)
+    except Exception:
+        return True
+    # Locate replacement by character offset.
+    target = None
+    for item in new_doc:
+        if item.idx == token.idx:
+            target = item
+            break
+    if target is None:
+        # Fallback: first overlapping alpha token near the old index.
+        for item in new_doc:
+            if item.is_alpha and abs(item.idx - token.idx) <= max(1, len(replacement)):
+                target = item
+                break
+    if target is None:
+        return False
+    return target.pos_ == token.pos_
+
+
+def meaning_ok(original: str, candidate: str, *, min_sim: float = 0.72) -> bool | None:
+    """MiniLM meaning check when available; None means backend unavailable."""
+    try:
+        from app.pipeline.minilm import score_candidate
+
+        scored = score_candidate(original, candidate)
+    except Exception:
+        return None
+    if scored is None:
+        return None
+    return float(scored) >= min_sim
+
+
+def naturalness_reasons(original: str, candidate: str) -> list[str]:
+    """Algorithmic naturalness failures (no phrase denylist)."""
+    reasons: list[str] = []
+    if not closed_compounds_not_split(original, candidate):
+        reasons.append("compound_split")
+    if not modal_head_pos_preserved(original, candidate):
+        reasons.append("modal_pos_shift")
+    if not content_pos_balance_ok(original, candidate):
+        reasons.append("pos_balance")
+    meaning = meaning_ok(original, candidate)
+    if meaning is False:
+        reasons.append("meaning_drop")
+    return reasons

app/engine/safety/__init__.py

@@ -7,6 +7,7 @@ from collections.abc import Iterable
 from dataclasses import dataclass
 from difflib import SequenceMatcher
 
+from app.engine.quality import naturalness_reasons
 from app.pipeline.candidate_validator import validate_candidate
 from app.pipeline.meaning_safety import polarity_safe
 from app.pipeline.nlp import get_nlp
@@ -14,20 +15,6 @@ from app.pipeline.nlp import get_nlp
 _URL = re.compile(r"https?://[^\s<>\"']+|www\.[^\s<>\"']+", re.I)
 _EMAIL = re.compile(r"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b")
 _NUMBER = re.compile(r"\b\d[\d,]*(?:\.\d+)?%?\b")
-_CLOSED_COMPOUNDS = (
-    "teamwork",
-    "teammate",
-    "teammates",
-    "workplace",
-    "lifestyle",
-    "classmate",
-    "classroom",
-    "homework",
-    "feedback",
-    "deadline",
-    "workflow",
-    "workforce",
-)
 
 
 @dataclass
@@ -65,26 +52,6 @@ def _numbers(text: str) -> set[str]:
     return {m.group(0).replace(",", "") for m in _NUMBER.finditer(text or "")}
 
 
-def _closed_compounds_preserved(original: str, candidate: str) -> bool:
-    """Reject opening closed compounds (teamwork → team work)."""
-    source = original or ""
-    cand = candidate or ""
-    for word in _CLOSED_COMPOUNDS:
-        if not re.search(rf"\b{re.escape(word)}\b", source, flags=re.I):
-            continue
-        if re.search(rf"\b{re.escape(word)}\b", cand, flags=re.I):
-            continue
-        for index in range(3, len(word) - 2):
-            left, right = word[:index], word[index:]
-            if re.search(
-                rf"\b{re.escape(left)}\s+{re.escape(right)}\b",
-                cand,
-                flags=re.I,
-            ):
-                return False
-    return True
-
-
 def _tense_aux_ok(
     original: str,
     candidate: str,
@@ -139,8 +106,7 @@ def check_safety(
     if not polarity_safe(o, c):
         reasons.append("negation")
 
-    if not _closed_compounds_preserved(o, c):
-        reasons.append("closed_compound")
+    reasons.extend(naturalness_reasons(o, c))
 
     if hard_invariants_only:
         # Forced rule fallbacks may add cleft auxiliaries; keep only hard facts.
@@ -152,8 +118,6 @@ def check_safety(
         o_nums, c_nums = _numbers(o), _numbers(c)
         if o_nums and not o_nums.issubset(c_nums):
             reasons.append("numbers")
-        if not _closed_compounds_preserved(o, c) and "closed_compound" not in reasons:
-            reasons.append("closed_compound")
         surface_sim = SequenceMatcher(None, o.lower(), c.lower()).ratio()
         return SafetyResult(
             ok=not reasons,
@@ -250,6 +214,10 @@ def check_safety(
             "broken",
             "duration_front",
             "stranded_prep",
+            "compound_split",
+            "modal_pos_shift",
+            "pos_balance",
+            "meaning_drop",
         }
         or r.startswith("entity:")
         or r.startswith("meaning:")

app/engine/templates/__init__.py

@@ -386,10 +386,10 @@ def try_in_pp_front(text: str) -> str | None:
 
 
 def try_copula_np_invert(text: str) -> str | None:
-    """Gerund/clause subject + is a/an NP → A/an NP is subject."""
+    """Subject + is/are a/an/the NP → NP is/are subject."""
     raw, end = _sentence_end(text)
     match = re.match(
-        r"^(?P<subj>(?:[A-Z][a-z]+ing|[A-Z][a-z]+ing\b.+?))\s+"
+        r"^(?P<subj>[A-Z][^,]{1,100}?)\s+"
         r"(?P<be>is|are|was|were)\s+"
         r"(?P<pred>(?:a|an|the)\s+[^,;:]+)$",
         raw,
@@ -400,18 +400,105 @@ def try_copula_np_invert(text: str) -> str | None:
     subject = match.group("subj").strip(" ,")
     predicate = match.group("pred").strip(" ,")
     be = match.group("be")
-    if len(subject.split()) < 2 or len(predicate.split()) < 2:
+    if len(subject.split()) < 1 or len(predicate.split()) < 2:
+        return None
+    # Avoid inverting long clausal subjects with internal finite verbs.
+    if re.search(
+        r"\b(that|which|who|when|where|because|while|although)\b",
+        subject,
+        flags=re.I,
+    ):
         return None
-    # Keep article capitalization on the fronted NP.
     front = predicate[0].upper() + predicate[1:]
-    lowered = subject[0].lower() + subject[1:]
-    # Number agreement: "a/an ..." prefers singular "is".
+    lowered = subject[0].lower() + subject[1:] if subject[:1].isupper() else subject
     if re.match(r"^(a|an)\b", predicate, flags=re.I) and be in {"are", "were"}:
         be = "is" if be == "are" else "was"
+    if re.match(r"^the\b", predicate, flags=re.I) and be in {"is", "was"}:
+        # Keep agreement for pluralish subjects ending with s when obvious.
+        if subject.lower().endswith("s") and not subject.lower().endswith(
+            ("ss", "ness", "ics")
+        ):
+            be = "are" if be == "is" else "were"
     body = f"{front} {be} {lowered}"
     return re.sub(r"\s+", " ", body).strip() + end
 
 
+def try_when_clause_front(text: str) -> str | None:
+    """Main … when Sub → When Sub, main …"""
+    raw, end = _sentence_end(text)
+    match = re.match(
+        r"^(?P<main>.+?)\s+when\s+(?P<sub>.+)$",
+        raw,
+        flags=re.I,
+    )
+    if not match:
+        return None
+    main = match.group("main").strip(" ,")
+    sub = match.group("sub").strip(" ,")
+    if len(main.split()) < 4 or len(sub.split()) < 3:
+        return None
+    if re.search(r"\bwhen\b", main, flags=re.I) or re.search(
+        r"\bwhen\b", sub, flags=re.I
+    ):
+        return None
+    body = (
+        f"When {sub[0].lower() + sub[1:]}, "
+        f"{main[0].lower() + main[1:]}"
+    )
+    return re.sub(r"\s+", " ", body).strip() + end
+
+
+def try_by_agent_front(text: str) -> str | None:
+    """… are/is VERBen by AGENT → By AGENT, … are/is VERBen."""
+    raw, end = _sentence_end(text)
+    match = re.match(
+        r"^(?P<head>.+?)\s+"
+        r"(?P<be>is|are|was|were)\s+"
+        r"(?P<verb>\w+ed|\w+en)\s+"
+        r"by\s+(?P<agent>.+)$",
+        raw,
+        flags=re.I,
+    )
+    if not match:
+        return None
+    head = match.group("head").strip(" ,")
+    agent = match.group("agent").strip(" ,")
+    if len(head.split()) < 3 or len(agent.split()) < 2:
+        return None
+    if re.search(r"\bby\b", head, flags=re.I):
+        return None
+    lowered = head[0].lower() + head[1:] if head[:1].isupper() else head
+    body = (
+        f"By {agent}, {lowered} {match.group('be')} {match.group('verb')}"
+    )
+    return re.sub(r"\s+", " ", body).strip() + end
+
+
+def try_in_both_front(text: str) -> str | None:
+    """X is Y in both A and B → In both A and B, x is Y."""
+    raw, end = _sentence_end(text)
+    match = re.match(
+        r"^(?P<head>.+?)\s+"
+        r"(?P<be>is|are|was|were)\s+"
+        r"(?P<pred>.+?)\s+"
+        r"in both\s+(?P<scope>.+)$",
+        raw,
+        flags=re.I,
+    )
+    if not match:
+        return None
+    head = match.group("head").strip(" ,")
+    pred = match.group("pred").strip(" ,")
+    scope = match.group("scope").strip(" ,")
+    if len(head.split()) < 1 or len(pred.split()) < 2 or len(scope.split()) < 3:
+        return None
+    lowered = head[0].lower() + head[1:] if head[:1].isupper() else head
+    body = (
+        f"In both {scope}, {lowered} {match.group('be')} {pred}"
+    )
+    return re.sub(r"\s+", " ", body).strip() + end
+
+
 def try_such_as_front(text: str) -> str | None:
     """Label such as EXAMPLES can TAIL → EXAMPLES can TAIL as label."""
     raw, end = _sentence_end(text)