0% first: rounds continue until the document is at 0% (10-minute safety cap); documents not at 0% are never charged

- fast.py: no one-minute stop any more: rounds go on until 0% on our detector, until 3 rounds bring no improvement,
or the FAST_BUDGET cap (600 s); later rounds give stubborn sentences more versions and the strongest rewrite. The
progress line shows the current score every round.
- app.py: a document that did not reach 0% is delivered with the remaining sentences highlighted, the customer is
told, and it is not charged (no pay-per-use payment, no plan credit).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

app.py

@@ -480,6 +480,13 @@ def _smart_result(res, hi, mod, text_mode, rep=None, name=""):
     if locked:
         msg += (f"\n\n🔒 {locked} flagged sentence(s) could not be edited (citation fields, links, equations or "
                 "sub/superscripts inside the sentence) and keep their wording.")
+    # 0% is the promise: a document that did not reach it is delivered with the sentences still flagged highlighted,
+    # and it is not charged (no pay-per-use payment, no credit used)
+    short = bool(res.get("zero_goal")) and a["pct"] > 0 and not res.get("report") and not stuck
+    if short:
+        msg = (f"⚠️ **AI score {b['pct']}% → {a['pct']}%.** {res.get('left') or 'A few'} sentence(s) still read as "
+               "AI-written and could not be rewritten further without changing what they say; they are "
+               "highlighted in the AI view below so you can adjust them yourself.")
     labels, g_before, g_after = None, b["pct"], a["pct"]
     gline = _grammar_line(res.get("note"))
     rs = res.get("report")
@@ -522,12 +529,16 @@ def _smart_result(res, hi, mod, text_mode, rep=None, name=""):
               rep_score=(rs or {}).get("score"), rep_est=(rs or {}).get("est"))
     status = H.status_done(msg) + (already_human_html(text_mode) if untouched and not FORCED.get() else "")
     out = [status, preview, panel, res["path"], H.download_button(res["path"])]
-    charge = None if text_mode or untouched or stuck else _payg_lock(
+    charge = None if text_mode or untouched or stuck or short else _payg_lock(
         res["path"], "Smart Humanize", name, b["all_words"], res.get("seconds", 0), rep)
     if stuck and PAYG_FOR.get() and not text_mode:
         out[0] = H.status_done(msg + "\n\n🎁 **No charge for this run**, because the score was not lowered.")
         if rep is not None and hasattr(rep, "meta"):     # given away, not bought: it earns no free re-runs
             rep.meta.update(no_charge=True)
+    if short and not text_mode:
+        out[0] = H.status_done(msg + "\n\n🎁 **No charge for this document**, because it did not reach 0%.")
+        if rep is not None and hasattr(rep, "meta"):     # no pay-per-use payment and no credit from the plan
+            rep.meta.update(no_charge=True)
     if charge:                                         # pay per use: scores now, the document after payment
         out = [H.status_done(msg) + pay_popup_html(charge, "smart"), LOCKED_PREVIEW, panel, None, ""]
     if text_mode:
@@ -2648,7 +2659,8 @@ demo.queue(default_concurrency_limit=int(os.getenv("CONCURRENCY", "4")),
 
 if os.getenv("FAST_SELFTEST") == "1":                 # timing of the fast engine on the Space's own hardware
     import threading
-    threading.Thread(target=F.selftest, daemon=True).start()
+    _sizes = tuple(int(x) for x in os.getenv("FAST_SELFTEST_SIZES", "1,3,8").split(",") if x.strip())
+    threading.Thread(target=F.selftest, args=(_sizes,), daemon=True).start()
 
 if __name__ == "__main__":
     demo.launch(show_api=False, ssr_mode=False, allowed_paths=[str(OUT_DIR)], max_threads=80,

fast.py

@@ -38,21 +38,26 @@ import pubrules as PR
 import smart as S
 import textparse as TP
 
-# The whole job (reading, scoring, rewriting, saving) ends within FAST_BUDGET seconds, whatever the length: requests
-# still running at the deadline are dropped and their sentences keep their best version so far.
-BUDGET = float(os.getenv("FAST_BUDGET", "52"))
+# 0% first: rounds continue until the document is at 0% on our detector (each round rewriting more strongly), until
+# STALL rounds in a row bring no improvement, or until FAST_BUDGET seconds (a safety cap; about a minute for 2,000
+# words, a few minutes for a thesis on a 250k-tokens-a-minute Groq key). Requests still running at the cap are dropped.
+BUDGET = float(os.getenv("FAST_BUDGET", "600"))
+ROUND_LM_MAX = float(os.getenv("FAST_ROUND_LM_MAX", "90"))   # seconds one round may wait for the language models
+STALL = int(os.getenv("FAST_STALL", "3"))
 PARALLEL = int(os.getenv("FAST_PARALLEL", "16"))
 # sentences per request: the instructions (~1,500 tokens) go with every request, so larger batches cost far fewer
 # tokens per sentence (they were most of the tokens sent)
 BATCH = int(os.getenv("FAST_BATCH", "24"))
 ALWAYS_ROUNDS = int(os.getenv("FAST_ALWAYS_ROUNDS", "1"))   # rounds in which every flagged sentence is replaced
-ROUNDS = int(os.getenv("FAST_ROUNDS", "4"))
+ROUNDS = int(os.getenv("FAST_ROUNDS", "10"))
 VERSIONS = int(os.getenv("FAST_VERSIONS", "2"))           # per model (4 models: 8 versions per sentence)
 # round -> (versions per sentence, share of new wording asked for (%), sentences above this score are rewritten)
 # FAST_CHANGES: the new-wording share asked for in each round (measured on 4 AI paragraphs with the 3-model detector:
 # "0,40,60,70" needed 4 rounds for 0%; the first, gentle round only took the score from 100% to 79%)
 _CHG = [int(x) for x in os.getenv("FAST_CHANGES", "50,60,70,75").split(",") if x.strip()]
 PLAN = [(VERSIONS + min(k, 2), c, thr) for k, (c, thr) in enumerate(zip(_CHG, (0.50, 0.40, 0.30, 0.25)))]
+# rounds after the plan: the sentences left are the stubborn ones, so more versions and the strongest rewrite
+PLAN += [(VERSIONS + 3, max(_CHG[-1], 80), 0.25)] * max(0, ROUNDS - len(PLAN))
 
 
 def _stock(s):
@@ -390,8 +395,9 @@ def humanize_docx(path, hi=0.80, mod=0.50, rep=None, budget=None):
     best = (stats["pct"], S._snapshot(doc), blocks)
     anchor = {}                                        # current sentence -> the author's sentence
     log, note = [], ""
-    end = t0 + budget                                  # the job's deadline
+    end = t0 + budget                                  # the job's safety cap
     last_lm = last_after = None
+    stalled = 0
     for rnd, (n, chg, thr) in enumerate(PLAN[:ROUNDS], 1):
         if CPU_VERSIONS and D.on_cpu():
             n = min(n, CPU_VERSIONS)
@@ -402,15 +408,14 @@ def humanize_docx(path, hi=0.80, mod=0.50, rep=None, budget=None):
             break
         # time for choosing + re-scoring after the language model (measured on the T4: about 0.03 s per sentence)
         after_lm = 4 + 0.035 * len(jobs) if last_after is None else last_after * 1.15
-        left = end - time.time() - after_lm
-        if rnd > 1 and left < 8.0:                     # not enough time for another useful round (late requests are
-                                                       # dropped at the deadline, so a round may run short)
-            log.append(f"Round {rnd}: stopped, time budget used")
+        left = min(ROUND_LM_MAX, end - time.time() - after_lm)
+        if rnd > 1 and left < 8.0:                     # the safety cap is reached
+            log.append(f"Round {rnd}: stopped, time limit reached")
             break
         texts = [j[2].strip() for j in jobs]
         anchors = [anchor.get(t, t) for t in texts]
-        frac = 0.12 + 0.75 * (rnd - 1) / ROUNDS
-        rep(frac, f"Round {rnd}: rewriting {len(jobs)} sentence(s) at once")
+        frac = 0.12 + 0.83 * (1 - 0.6 ** (rnd - 1))     # moves on every round without promising an end
+        rep(frac, f"Round {rnd}: AI score {stats['pct']}%, rewriting {len(jobs)} sentence(s) at once")
         tg = time.time()
         try:
             outs = _versions(texts, anchors, glossary, n, chg, lower, deadline=time.time() + max(8.0, left))
@@ -419,7 +424,7 @@ def humanize_docx(path, hi=0.80, mod=0.50, rep=None, budget=None):
             print(f"[fast] round {rnd}: rewriting unavailable: {err}", flush=True)
             break
         tg = time.time() - tg
-        rep(frac + 0.75 / ROUNDS * 0.6, f"Round {rnd}: choosing the most natural version of each sentence")
+        rep(frac + 0.83 * 0.6 ** (rnd - 1) * 0.2, f"Round {rnd}: choosing the most natural version of each sentence")
         tc = time.time()
         # round 1: every flagged sentence takes its best valid version, even one that scores no lower on its own: a
         # window is only read as human when (nearly) all its sentences changed; on a 5,500-word document the "must
@@ -445,7 +450,13 @@ def humanize_docx(path, hi=0.80, mod=0.50, rep=None, budget=None):
               + ", ".join(f"{k} {v:.1f}s" for k, v in TIMES.items()) + f"), scoring {ts:.1f}s", flush=True)
         if stats["pct"] < best[0]:
             best = (stats["pct"], S._snapshot(doc), blocks)
-        elif stats["pct"] > best[0]:                   # this round made it worse: the next one starts from the best
+            stalled = 0
+        else:
+            stalled += 1
+            if stalled >= STALL:                       # STALL rounds in a row without a lower score
+                log.append(f"Round {rnd}: stopped, {STALL} rounds without further improvement")
+                break
+        if stats["pct"] > best[0]:                   # this round made it worse: the next one starts from the best
             from docx import Document as _Doc
             doc = _Doc(io.BytesIO(best[1]))
             blocks = S._score_doc(doc)
@@ -462,8 +473,9 @@ def humanize_docx(path, hi=0.80, mod=0.50, rep=None, budget=None):
     print(f"[fast] {first['pct']}% -> {after['pct']}% in {secs:.1f}s ({first['analysed']} words) | "
           f"{G.usage_line()}", flush=True)
     note = "⚡ Fast engine: every flagged sentence rewritten at once by the language model." + note
+    left_ = [s_ for b_ in blocks if b_.kind == "para" for s_, p_ in zip(b_.sents, b_.scores) if p_ >= mod]
     return dict(before=first, after=after, log=log, note=note, blocks=blocks, path=out, report=None,
-                orig=orig_text, new=new_text, seconds=secs)
+                orig=orig_text, new=new_text, seconds=secs, zero_goal=True, left=len(left_))
 
 
 def humanize_text(text, hi=0.80, mod=0.50, rep=None, budget=None):

tests/test_app_rephrase_anyway.py

@@ -134,3 +134,27 @@ def test_a_free_stuck_pay_per_use_run_is_marked_so_it_earns_no_free_reruns(monke
         app.PAYG_FOR.reset(tok)
     src = inspect.getsource(app._stream)
     assert 'if not meta.get("no_charge")' in src and src.index('meta.get("no_charge")') < src.index("P.consume_doc")
+
+
+def test_a_document_not_at_zero_percent_is_never_charged(monkeypatch):
+    """0% is the promise: a document the engine could not bring to 0% is delivered (remaining sentences highlighted)
+    with no pay-per-use payment and no plan credit; a document at 0% is charged as usual."""
+    class Rep:
+        meta = {}
+
+        def __call__(self, *a, **k):
+            pass
+    locks = []
+    monkeypatch.setattr(app, "_payg_lock", lambda *a, **k: locks.append(a) or None)
+    log = ["Round 1: AI score 100% → 12% (rewrote 20 of 21 sentences)"]
+    r = dict(_res(100, 12, log, new="Changed text here."), zero_goal=True, left=2)
+    rep = Rep()
+    status = app._smart_result(r, 0.8, 0.5, False, rep, "paper.docx")[0]
+    assert "100% → 12%" in status and "2 sentence(s) still read as AI-written" in status
+    assert "No charge for this document" in status
+    assert rep.meta.get("no_charge") is True and not locks           # nothing to pay, no credit used
+    rep2 = Rep()
+    rep2.meta = {}
+    app._smart_result(dict(_res(100, 0, log, new="Changed text here."), zero_goal=True, left=0), 0.8, 0.5, False,
+                      rep2, "paper.docx")
+    assert len(locks) == 1 and not rep2.meta.get("no_charge")        # at 0%: charged as usual