Pricing for profit on every run: price = 5 x cost after GST and fees (was 4 x), at least Rs 49 (was Rs 10); a document lowered but not to 0% pays half (was free; half is still about 2.5 x cost), one not lowered stays free; Turnitin's set price never below cost + 30%; free tier trimmed (5 pastes a day, trial document up to 1,500 words, guests 3 pastes); Pricing page states the half-price rule; Admin -> Profit tab: net profit after GST, fees, language model, reports and the always-on GPU bill, cost of free use, paid runs needed to cover the fixed bills, runs below cost, profit by tool (7 / 30 / 90 days)

app.py

@@ -211,6 +211,7 @@ def already_human_html(text_mode):
 # Set for a job of a signed-in customer without credits: the job runs, the scores are shown, and the result is
 # locked behind a charge priced from what the job used.
 PAYG_FOR = __import__("contextvars").ContextVar("pay_per_use_for", default=None)
+SHORT_PRICE_FACTOR = float(os.getenv("SHORT_PRICE_FACTOR", "0.5"))   # lowered, but not to 0%: this share of the price
 LOCKED_PREVIEW = ('<div class="cs-scores cs-empty"><div>🔒 The text is shown after payment. Your scores are above.'
                   '</div></div>')
 
@@ -506,7 +507,8 @@ def _start_billed_job(key, core, args, user, request, tool, need_login, words, q
                                           meta.get("external_usd", 0), words, meta.get("name") or tool)["charged"]
                 j.extra["wallet"] = (charged, W.available(who))
             else:
-                charged = W.settle(wallet["ref"], time.time() - t0, llm, words, meta.get("name") or tool)["charged"]
+                charged = W.settle(wallet["ref"], time.time() - t0, llm, words, meta.get("name") or tool,
+                                   factor=meta.get("price_factor", 1.0))["charged"]
                 j.extra["wallet"] = (charged, W.available(who))
         if paid_order:                              # paid on the page (PhonePe): the order is used up
             charged = W.finish_report_order(paid_order, int(meta.get("units_ok", 1)))
@@ -642,7 +644,8 @@ def _smart_result(res, hi, mod, text_mode, rep=None, name=""):
         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)
+    # at SHORT_PRICE_FACTOR of the price from the wallet (the owner's rule, 2026-10-28: it was free, which lost money
+    # on every such run)
     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 "
@@ -696,10 +699,12 @@ def _smart_result(res, hi, mod, text_mode, rep=None, name=""):
         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 short:                                          # lowered, not to 0%: half price (still above its cost)
+        if rep is not None and hasattr(rep, "meta"):
+            rep.meta.update(price_factor=SHORT_PRICE_FACTOR)
+        if S.G.WALLET_CAP.get() is not None:          # a wallet run (credits and plans are used as usual)
+            out[0] = H.status_done(msg + f"\n\n💳 **Charged at {SHORT_PRICE_FACTOR:.0%} of the price**, because it "
+                                         "did not reach 0%.")
     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:
@@ -2923,6 +2928,21 @@ with gr.Blocks(title=SITE_TITLE, theme=theme, css=CSS + UI.css() + FND.CSS, js=F
                         gr.HTML('<div class="cs-settings-title">🏆 Most active users (30 days)</div>')
                         ad_ov_top = gr.Dataframe(headers=["Name", "Email", "Runs", "Documents", "Words", "Last run"],
                                                  interactive=False, wrap=True)
+                # ---------- profit ----------
+                with gr.Tab("Profit") as ad_pf_tab:
+                    with gr.Row():
+                        gr.HTML('<div class="cs-auth-title" style="text-align:left">Profit</div>')
+                        ad_pf_days = gr.Dropdown([("Last 7 days", 7), ("Last 30 days", 30), ("Last 90 days", 90)],
+                                                 value=30, label="Period", scale=0, min_width=160)
+                        ad_pf_refresh = gr.Button("Refresh", size="sm", scale=0, elem_classes="cs-topbtn")
+                    ad_pf_tiles = gr.HTML()
+                    with gr.Column(elem_classes="cs-card"):
+                        gr.HTML('<div class="cs-settings-title">Profit by tool</div>'
+                                '<div class="cs-gauge-cap" style="text-align:left">Revenue is what runs were charged '
+                                '(wallet and pay-on-page reports). Profit = revenue after GST and the payment fee, '
+                                'minus the language model and bought reports. The GPU bill is a fixed cost, shown '
+                                'above, not split by tool.</div>')
+                        ad_pf_table = gr.Dataframe(headers=W.PROFIT_COLS, interactive=False, wrap=True)
                 # ---------- activity ----------
                 with gr.Tab("Activity") as ad_act_tab:
                     with gr.Row():
@@ -3136,6 +3156,13 @@ with gr.Blocks(title=SITE_TITLE, theme=theme, css=CSS + UI.css() + FND.CSS, js=F
         tiles, chart, tools, top = DB.admin_overview(u)
         return DB._tiles(P.admin_revenue_tiles(u)) + tiles, chart, tools, top
 
+    def profit(u, days):
+        A._need_admin(u)
+        tiles, rows = W.profit_dashboard(int(days or 30))
+        return DB._tiles(tiles), rows
+
+    for ev in (ad_pf_refresh.click, ad_pf_days.change, ad_pf_tab.select):
+        ev(profit, [user_state, ad_pf_days], [ad_pf_tiles, ad_pf_table], **HID)
     ad_ov_refresh.click(overview, user_state, ov_out, **HID)
     ad_ov_tab.select(overview, user_state, ov_out, **HID)
     admin_tab.select(overview, user_state, ov_out, **HID)

plans.py

@@ -5,8 +5,9 @@ Unit: one CREDIT = one document of up to CREDIT_WORDS (15,000) words; a longer d
 15,000 words (a 40,000-word thesis = 3 credits). The number is shown before the run and charged only after a
 successful run (a failed run costs nothing). The same file can be re-run FREE_RERUNS times free within RERUN_DAYS.
 
-  guest        paste only: 300 words a paste, 15 a day, 2 Smart passes
-  free         25 pastes a day (300 words); 1 trial document up to 5,000 words; 3 detector files a day
+  guest        paste only: 300 words a paste, 3 a day, 2 Smart passes
+  free         5 pastes a day (300 words); 1 trial document up to 1,500 words; 3 detector files a day
+               (trimmed 2026-10-28 so free use costs at most about Rs 15 a day per account)
   single       ₹199 / $3   one credit, valid 6 months
   pack         ₹799 / $12  five credits, valid 6 months
   scholar      ₹999 / $14 a month    10 credits a month, pastes up to 1,500 words, unlimited detector
@@ -55,10 +56,11 @@ UNLIMITED = 10 ** 9
 
 # docs_month = credits per subscription month; format_month = Journal Formatter files a month (display)
 PLANS = {
-    "guest": dict(name="Guest", inr=0, usd=0, docs_month=0, docs_day=0, pastes=15, paste_words=300, passes=2,
+    "guest": dict(name="Guest", inr=0, usd=0, docs_month=0, docs_day=0, pastes=_env_i("GUEST_PASTES", 3),
+                  paste_words=300, passes=2,
                   doc_words=0, format_month=0, priority=False),
-    "free": dict(name="Free", inr=0, usd=0, docs_month=0, docs_day=0, pastes=25, paste_words=300, passes=2,
-                 doc_words=_env_i("FREE_DOC_WORDS", 5000), format_month=1, priority=False),
+    "free": dict(name="Free", inr=0, usd=0, docs_month=0, docs_day=0, pastes=_env_i("FREE_PASTES", 5),
+                 paste_words=300, passes=2, doc_words=_env_i("FREE_DOC_WORDS", 1500), format_month=1, priority=False),
     "scholar": dict(name="Scholar", inr=_env_i("PRICE_SCHOLAR", 999), usd=_env_f("PRICE_SCHOLAR_USD", 14),
                     docs_month=_env_i("SCHOLAR_CREDITS", 10), docs_day=0, pastes=UNLIMITED, paste_words=1500,
                     passes=10, doc_words=150000, format_month=5, priority=False),
@@ -776,10 +778,10 @@ def pay_instructions(user, item):
 PAY_PER_USE = os.getenv("PAY_PER_USE", "1") != "0"
 COST_GPU_HOUR_USD = _env_f("COST_GPU_HOUR_USD", 0.40)
 COST_IDLE_FACTOR = max(1.0, _env_f("COST_IDLE_FACTOR", 5))
-PRICE_MARGIN = _env_f("PRICE_MARGIN", 200)               # profit, percent of cost
+PRICE_MARGIN = _env_f("PRICE_MARGIN", 400)               # profit, percent of cost (as the wallet)
 PRICE_GST = _env_f("PRICE_GST", 18)
 PRICE_USD_INR = _env_f("PRICE_USD_INR", 85)
-PRICE_MIN_INR = _env_f("PRICE_MIN_INR", 10)              # smallest charge (a payment below this is not worth its fee)
+PRICE_MIN_INR = _env_f("PRICE_MIN_INR", 49)              # smallest charge (a payment below this is not worth its fee)
 PAY_URL = os.getenv("PAY_URL", "").strip()
 
 

tests/test_app_rephrase_anyway.py

@@ -136,9 +136,9 @@ def test_a_free_stuck_pay_per_use_run_is_marked_so_it_earns_no_free_reruns(monke
     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."""
+def test_a_document_not_at_zero_percent_pays_half(monkeypatch):
+    """A document the engine brought down but not to 0% is delivered (remaining sentences highlighted) at half price
+    (the owner's rule of 2026-10-28; it used to be free); a document at 0% is charged in full."""
     class Rep:
         meta = {}
 
@@ -151,13 +151,21 @@ def test_a_document_not_at_zero_percent_is_never_charged(monkeypatch):
     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
+    assert "No charge" not in status
+    assert rep.meta.get("price_factor") == 0.5 and not rep.meta.get("no_charge")
+    tok = app.S.G.WALLET_CAP.set(1.0)                                  # a wallet run says so on the page
+    try:
+        rep3 = Rep()
+        rep3.meta = {}
+        status = app._smart_result(r, 0.8, 0.5, False, rep3, "paper.docx")[0]
+    finally:
+        app.S.G.WALLET_CAP.reset(tok)
+    assert "Charged at 50% of the price" in status
     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
+    assert len(locks) == 1 and "price_factor" not in rep2.meta         # at 0%: charged in full
 
 
 def test_a_reconnecting_page_re_attaches_to_the_tools_job_instead_of_starting_again():

tests/test_dashboard.py

@@ -49,7 +49,7 @@ def test_results_waiting_for_payment_are_shown_with_a_pay_link(user, tmp_path):
     price = P.usage_price(300, 0.20)
     ref = P.create_charge(user["email"], "Smart Humanize", "thesis.docx", 5120, price, str(tmp_path / "t.docx"))
     h = DB._pending_html(user["email"])
-    assert "thesis.docx" in h and ref in h and "₹111" in h and "Pay now" in h and 'target="_blank"' in h
+    assert "thesis.docx" in h and ref in h and "₹184" in h and "Pay now" in h and 'target="_blank"' in h
     tiles = DB.user_dashboard(user)[0]
     assert ref in tiles
     P.settle_charge(ref, source="admin")

tests/test_pricing.py

@@ -39,9 +39,9 @@ def test_price_is_cost_plus_margin_plus_gst():
     assert p["gpu_usd"] == pytest.approx(300 * 0.40 / 3600)
     assert p["space_usd"] == pytest.approx(p["gpu_usd"] * 4)     # idle share of the always-on Space
     assert p["cost_usd"] == pytest.approx(p["gpu_usd"] * 5 + 0.20)
-    assert p["profit_usd"] == pytest.approx(2 * p["cost_usd"])   # 200% margin: price before tax = 3 x cost
-    assert p["gst_usd"] == pytest.approx(0.18 * 3 * p["cost_usd"])
-    assert p["inr"] == 111                                       # $1.298 x 85, rounded up
+    assert p["profit_usd"] == pytest.approx(4 * p["cost_usd"])   # 400% margin: price before tax = 5 x cost
+    assert p["gst_usd"] == pytest.approx(0.18 * 5 * p["cost_usd"])
+    assert p["inr"] == 184                                       # $2.164 x 85, rounded up
     assert P.usage_price(1, 0)["inr"] == P.PRICE_MIN_INR         # never below the smallest charge
 
 
@@ -66,7 +66,7 @@ def test_charge_is_locked_until_it_is_settled(tmp_path, monkeypatch):
         c = app._payg_lock(out, "Smart Humanize", "paper.docx", 4000, 300, None)
     finally:
         app.PAYG_FOR.reset(tok)
-    assert c["status"] == "pending" and c["amount_inr"] == 111 and c["ref"].startswith("CS-")
+    assert c["status"] == "pending" and c["amount_inr"] == 184 and c["ref"].startswith("CS-")
     user = {"email": "payer@example.com"}
     status, file, dl = app.claim_paid(user)
     assert "not confirmed yet" in status and "Pay now" in status and not isinstance(file, str)

tests/test_profit_rules.py

@@ -0,0 +1,62 @@
+"""Pricing of 2026-10-28: price = 5 x cost (after GST and fees), at least Rs 49; a document that came down but not to
+0% pays half (still above its cost); the free tier is small; the admin's profit page adds up."""
+import os
+import tempfile
+import uuid
+
+os.environ.setdefault("USERS_DB", os.path.join(tempfile.mkdtemp(), "users.db"))
+os.environ.setdefault("SKIP_MODEL_LOAD", "1")
+import plans as P  # noqa: E402
+import wallet as W  # noqa: E402
+
+
+def _held(paise):
+    email = f"pf-{uuid.uuid4().hex[:8]}@example.com"
+    W.adjust(email, paise, "test money")
+    return email, W.reserve(email, paise, "Smart Humanize")
+
+
+def test_margin_and_minimum():
+    assert W.MARGIN >= 400 and W.MIN_INR >= 49
+    assert W.price_paise(0) == 4900
+    b = W.breakdown(300, 0.40)
+    assert b["inr"] - b["gst_inr"] - b["fee_inr"] >= 5 * b["cost_usd"] * W.USD_INR - 0.01
+
+
+def test_half_price_when_not_at_zero_still_covers_the_cost():
+    email, ref = _held(100000)
+    full = W.breakdown(300, 0.40)["paise"]
+    got = W.settle(ref, 300, 0.40, 3500, "x.docx", factor=0.5)["charged"]
+    assert abs(got - full / 2) <= 100
+    cost_inr = W.breakdown(300, 0.40)["cost_usd"] * W.USD_INR
+    assert got / 100 * W._KEEP > cost_inr                         # half price is still above the cost
+    assert W.balance(email) == 100000 - got
+
+
+def test_half_price_never_below_the_minimum():
+    _, ref = _held(10000)
+    assert W.settle(ref, 1, 0.0, 50, "tiny", factor=0.5)["charged"] == int(W.MIN_INR * 100)
+
+
+def test_turnitin_price_keeps_a_minimum_margin():
+    secs, llm = W.usual("turnitin", 0)
+    p = W.usual_price("turnitin", 0)
+    assert p / 100 * W._KEEP >= (W.gpu_usd(secs) + llm) * W.USD_INR * (1 + W.SET_MIN_MARGIN / 100) - 1
+
+
+def test_free_tier_is_trimmed():
+    assert P.PLANS["free"]["pastes"] <= 5 and P.PLANS["guest"]["pastes"] <= 3
+    assert P.PLANS["free"]["doc_words"] <= 1500
+
+
+def test_profit_dashboard_adds_up():
+    tool = f"Test tool {uuid.uuid4().hex[:6]}"
+    W.record_cost("a@example.com", tool, 2500, 120, 0.30, 17500, "wallet")
+    W.record_cost("b@example.com", tool, 300, 20, 0.04, 0, "free")
+    tiles, rows = W.profit_dashboard(7)
+    row = next(r for r in rows if r[0] == tool)
+    assert row[1:4] == [2, 1, 1] and row[4] == "₹175"
+    profit = 175 * W._KEEP - (0.34 * W.USD_INR)
+    assert row[6] == f"₹{profit:,.0f}"
+    labels = [t[0] for t in tiles]
+    assert "Net profit (7d)" in labels and "GPU bill (always on)" in labels and "Cost of free use" in labels

tests/test_result_email.py

@@ -90,7 +90,7 @@ def test_document_run_through_the_job_runner_is_mailed(monkeypatch, tmp_path):
         rep.meta.update(name="synopsis.docx", words=3539, before=18, after=1, output=str(out), no_charge=True)
         return ("done", None, None, str(out), "")
 
-    frames = list(app._stream(core, (str(doc),), 5, 0, user, True, None, tool="Smart Humanize", words=3539))
+    frames = list(app._stream(core, (str(doc),), 5, 0, user, True, None, tool="Smart Humanize", words=1200))
     assert sent and sent[0][0] == email and str(out) in sent[0][1], frames[-1][0][:300]
     assert "emailed" in frames[-1][0]
 

wallet.py

@@ -35,12 +35,12 @@ def _f(k, d):
 
 GPU_HOUR_USD = _f("COST_GPU_HOUR_USD", 0.40)          # Hugging Face Nvidia T4 small
 IDLE_FACTOR = max(1.0, _f("COST_IDLE_FACTOR", 5))     # each busy GPU second carries this many seconds of the bill
-MARGIN = _f("PRICE_MARGIN", 300)                      # profit, % of cost
+MARGIN = _f("PRICE_MARGIN", 400)                      # profit, % of cost (price = 5 x cost, after GST and fees)
 GST = _f("PRICE_GST", 18)
 FEE = _f("PAY_FEE_PCT", 2.0)                          # payment gateway fee, % of the amount paid ...
 FEE_GST = _f("PAY_FEE_GST", 18)                       # ... plus GST on that fee
 USD_INR = _f("PRICE_USD_INR", 85)
-MIN_INR = _f("PRICE_MIN_INR", 10)
+MIN_INR = _f("PRICE_MIN_INR", 49)                     # smallest charge: covers the fee, start-up and after-work
 HOLD_X = _f("WALLET_HOLD_X", 2.0)                     # reservation = this x the usual price of the job
 TOPUPS = [int(x) for x in os.getenv("WALLET_TOPUPS", "100,250,500,1000").split(",") if x.strip()]
 TOPUP_MIN, TOPUP_MAX = int(_f("WALLET_TOPUP_MIN", 50)), int(_f("WALLET_TOPUP_MAX", 20000))
@@ -101,14 +101,15 @@ def usual(kind, words):
 MARGINS = {"turnitin": _f("REILAA_MARGIN", MARGIN)}
 
 
-# a set price per run (₹, incl. GST); never below the break-even price, so every run stays in profit
+# a set price per run (₹, incl. GST); never below cost + SET_MIN_MARGIN %, so every run stays in profit
 SET_PRICE = {"turnitin": _f("REILAA_PRICE_INR", 550)}
+SET_MIN_MARGIN = _f("SET_PRICE_MIN_MARGIN", 30)
 
 
 def usual_price(kind, words):
     secs, llm = usual(kind, words)
     if SET_PRICE.get(kind):
-        floor = price_paise(gpu_usd(secs) + llm, 0)    # cost + GST + fee, no profit
+        floor = price_paise(gpu_usd(secs) + llm, SET_MIN_MARGIN)   # cost + GST + fee + a minimum profit
         return max(int(round(SET_PRICE[kind])) * 100, floor)
     return price_paise(gpu_usd(secs) + llm, MARGINS.get(kind))
 
@@ -198,10 +199,13 @@ def reserve(email, paise, tool=""):
     return ref
 
 
-def settle(ref, seconds, llm_usd, words=0, name=""):
+def settle(ref, seconds, llm_usd, words=0, name="", factor=1.0):
     """Charge a finished job its actual price (at most what was reserved) and release the rest. Returns the
-    breakdown with the amount charged."""
+    breakdown with the amount charged. factor < 1: a reduced price (a run that did not reach 0% pays half), never
+    below the minimum charge."""
     b = breakdown(seconds, llm_usd)
+    if factor < 1:
+        b["paise"] = max(int(MIN_INR * 100), int(math.ceil(b["paise"] * max(0.0, factor) / 100)) * 100)
     with _lock, _db() as con:
         row = con.execute("SELECT email, paise, tool, status FROM wallet_holds WHERE ref=?", (ref,)).fetchone()
         if not row or row[3] != "active":
@@ -500,6 +504,70 @@ def profit_report(days=30):
                 jobs=jobs, paid_jobs=paid_jobs, gpu_hours_busy=secs / 3600, breakeven_jobs=breakeven)
 
 
+FIXED_MONTH_INR = _f("COST_FIXED_MONTH_INR", 0)        # other monthly bills (domain, storage, mail ...), ₹
+PROFIT_COLS = ["Tool", "Runs", "Paid runs", "Free / plan runs", "Revenue (incl. GST)", "Direct cost",
+               "Profit", "Margin"]
+
+
+def profit_dashboard(days=30):
+    """The admin's profit page: (tiles [(label, value)], rows per tool) for the last `days` days, in ₹.
+    Revenue = what runs were charged (wallet and pay-on-page reports); out of it go GST and the gateway fee.
+    Direct cost = the language model and bought reports (Turnitin) of every run, paid or free. Fixed cost = the
+    GPU billed every hour, busy or not, plus COST_FIXED_MONTH_INR."""
+    since = f"-{int(days)} days"
+    with _db() as con:
+        rows = con.execute("SELECT tool, how, COUNT(*), COALESCE(SUM(charged_paise),0), COALESCE(SUM(llm_usd),0), "
+                           "COALESCE(SUM(seconds),0), COALESCE(SUM(charged_paise > 0),0) FROM job_costs "
+                           "WHERE ts >= datetime('now', ?) GROUP BY tool, how", (since,)).fetchall()
+        losers = con.execute("SELECT COUNT(*) FROM job_costs WHERE ts >= datetime('now', ?) AND charged_paise > 0 "
+                             "AND charged_paise / 100.0 * ? < llm_usd * ?", (since, _KEEP, USD_INR)).fetchone()[0]
+    keep = lambda inr_: inr_ * _KEEP                       # what stays after GST and the gateway fee
+    tools, tot = {}, dict(runs=0, paid=0, free=0, rev=0.0, cost=0.0, free_cost=0.0, secs=0.0)
+    for tool, how, n, paise, llm, secs, paid in rows:
+        t = tools.setdefault(tool or "—", dict(runs=0, paid=0, free=0, rev=0.0, cost=0.0))
+        cost = llm * USD_INR
+        free = n - paid
+        for d in (t, tot):
+            d["runs"] += n
+            d["paid"] += paid
+            d["free"] += free
+            d["rev"] += paise / 100
+            d["cost"] += cost
+        tot["secs"] += secs
+        if how in ("free", "plan") or not paise:
+            tot["free_cost"] += cost
+    gpu_bill = days * 24 * GPU_HOUR_USD * USD_INR
+    fixed = gpu_bill + FIXED_MONTH_INR * days / 30
+    gst = tot["rev"] - tot["rev"] / (1 + GST / 100)
+    fee = tot["rev"] - gst - keep(tot["rev"])
+    gross = keep(tot["rev"]) - tot["cost"]                 # before the fixed bills
+    net = gross - fixed
+    per_paid = gross / tot["paid"] if tot["paid"] else 0
+    need = math.ceil(fixed / per_paid) if per_paid > 0 else None
+    r = lambda v: f"₹{v:,.0f}"
+    tiles = [
+        (f"Net profit ({days}d)", ("" if net >= 0 else "−") + r(abs(net))),
+        ("Revenue (incl. GST)", r(tot["rev"])), ("GST to pay", r(gst)), ("Payment fees", r(fee)),
+        ("Language model + reports", r(tot["cost"])), ("GPU bill (always on)", r(gpu_bill)),
+        ("Other fixed bills", r(fixed - gpu_bill)),
+        ("Profit before fixed bills", r(gross)),
+        ("Paid runs", f"{tot['paid']:,}"), ("Free / plan runs", f"{tot['free']:,}"),
+        ("Cost of free use", r(tot["free_cost"])),
+        ("Avg profit per paid run", r(per_paid) if tot["paid"] else "—"),
+        ("Paid runs to cover fixed bills", f"{need:,}" if need else "—"),
+        ("Paid runs below cost", f"{losers:,}"),
+        ("GPU busy", f"{tot['secs'] / 3600:,.1f} h of {days * 24:,} h"),
+        ("Price rule", f"cost × {1 + MARGIN / 100:g}, min {inr(int(MIN_INR * 100))}"),
+    ]
+    out = []
+    for name, t in sorted(tools.items(), key=lambda kv: -kv[1]["rev"]):
+        profit = keep(t["rev"]) - t["cost"]
+        out.append([name, t["runs"], t["paid"], t["free"], r(t["rev"]), r(t["cost"]),
+                    ("" if profit >= 0 else "−") + r(abs(profit)),
+                    f"{100 * profit / t['cost']:.0f}%" if t["cost"] else "—"])
+    return tiles, out
+
+
 # ---------------------------------------------------------------------------------------------------- pricing page
 def pricing_html(free_note=""):
     """The Pricing page: pay as you go from a prepaid wallet, with the usual price of common jobs."""
@@ -521,7 +589,9 @@ def pricing_html(free_note=""):
             f'</div><ul><li>Add {tops} or any amount from {inr(TOPUP_MIN * 100)}: UPI, cards, net banking '
             f'(PhonePe)</li><li>Each run is priced by what it actually used (its length and the work it needed)'
             f'</li><li>The usual price is shown before a run starts; you are never charged more than it reserved'
-            f'</li><li>A run that fails or is stopped costs nothing</li><li>Your balance never expires</li>'
+            f'</li><li>A humanized document that comes down but does not reach 0% AI is charged half price; one '
+            f'whose score does not come down costs nothing</li>'
+            f'<li>A run that fails or is stopped costs nothing</li><li>Your balance never expires</li>'
             f'<li>Prices include {GST:.0f}% GST</li></ul></div>'
             f'<table class="cs-wallet-table" style="width:100%;margin-top:14px;border-collapse:collapse">'
             f'<thead><tr><th style="text-align:left">Usual price of a run</th><th style="text-align:left">Length'