Upload 2 files

app.py

@@ -132,18 +132,20 @@ def upsell_html(up):
     icon = {"upgrade": "💎", "signin": "🔐", "limit": "⏳", "extra": "📄"}.get(kind, "✨")
     title = html.escape(getattr(up, "headline", "") or "Heads up")
     text = html.escape(getattr(up, "text", "") or str(up))
-    st = P.PLANS["monthly"]
+    st = P.PLANS["scholar"]
     perks = {
-        "upgrade": [f"Single document: {P.price_of('single', 'INR')} / {P.price_of('single', 'USD')}",
-                    f"Monthly plan: {st['docs_month']} documents for ₹{st['inr']:,} / ${st['usd']:,.0f}",
-                    "Word layout kept + PDF report", "Rigorous proofread included"],
-        "signin": [f"{P.FREE_TRIAL_DOCS} documents free", "Word & PDF upload", "Run history & re-downloads",
-                   "No card needed"],
-        "extra": [f"{P.price_of('single', 'INR')} / {P.price_of('single', 'USD')} per single document",
-                  "Continue straight away", "Single documents never expire",
-                  "Your monthly documents start again next month"],
+        "upgrade": [f"1 credit: {P.price_of('single', 'INR')} / {P.price_of('single', 'USD')} · 5 credits: "
+                    f"{P.price_of('pack', 'INR')} / {P.price_of('pack', 'USD')}",
+                    f"Scholar: {st['docs_month']} credits a month for ₹{st['inr']:,} / ${st['usd']:,.0f}",
+                    f"1 credit = 1 document up to {P.CREDIT_WORDS:,} words",
+                    "Word layout kept + PDF report + proofread"],
+        "signin": [f"Free trial document (up to {P.PLANS['free']['doc_words']:,} words)",
+                   f"{P.FREE_DETECT_DAY} detector reports a day", "Run history & re-downloads", "No card needed"],
+        "extra": [f"Extra credits: {P.price_of('extra', 'INR')} / {P.price_of('extra', 'USD')} each",
+                  "Continue straight away", f"Bought credits stay valid {P.CREDIT_MONTHS} months",
+                  "Your monthly credits start again next month"],
     }.get(kind, [])
-    go = {"upgrade": ("💎 See plans", "cs-go-pricing"), "extra": ("📄 Buy single documents", "cs-go-pricing"),
+    go = {"upgrade": ("💎 See plans", "cs-go-pricing"), "extra": ("📄 Buy credits", "cs-go-pricing"),
           "signin": ("🔐 Sign in / Create free account", "cs-go-account")}.get(kind)
     perks_html = "".join(f'<li><span>✓</span>{html.escape(x)}</li>' for x in perks)
     btns = (f'<button class="cs-up-go" data-cs-go="{go[1]}">{go[0]}</button>' if go else "") + \
@@ -240,6 +242,8 @@ def _stable_uploads(args):
 def _stream(core, args, n, idx, user=None, need_login=False, request=None, tool="", words=None, paste=None,
             quota=True):
     args = _stable_uploads(args)
+    # the uploaded file's content key (folder name under inputs/): the same file re-run = free re-run
+    fkey = next((Path(str(a)).parent.name for a in args if isinstance(a, str) and a.startswith(str(_IN_DIR))), None)
     key = _job_key(user, request, tool, args)
     job = H.find_job(key)
     if job is not None and job.done.is_set() and (job.delivered or "error" in job.box):
@@ -251,7 +255,7 @@ def _stream(core, args, n, idx, user=None, need_login=False, request=None, tool=
             if need_login:
                 A._require(user)
                 if quota:
-                    P.check_doc(user, words)            # plan quota / credits / free trial + word cap
+                    P.check_doc(user, words, tool, fkey)   # credits / plan / free trial / free re-run + word cap
             if quota:
                 A.check_limit(user, request, need_login)
         except A.Upsell as up:                          # plan / sign-in / limit -> friendly pop-up, not an error
@@ -271,7 +275,7 @@ def _stream(core, args, n, idx, user=None, need_login=False, request=None, tool=
             if quota:
                 A.add_usage(user, request, need_login)
             if need_login and quota:
-                P.consume_doc(user)
+                P.consume_doc(user, words, tool, fkey)
                 j.extra["mailed"] = M.send_result(user, tool, meta)
             b_, a_ = meta.get("before"), meta.get("after")
             score = f" — AI score {b_}% → {a_}%" if (b_ is not None and a_ is not None) else ""
@@ -338,6 +342,16 @@ def _smart_result(res, hi, mod, text_mode, rep=None, name=""):
     # customers see only the headline; the pass log and engine notes go to the Space logs
     print(f"[smart] {name}: AI {b['pct']}% -> {a['pct']}% | " + " | ".join(res["log"]) + f" |{res['note']}", flush=True)
     msg = f"✅ **Done** — AI score {b['pct']}% → {a['pct']}%."
+    log_ = res.get("log") or []
+    n_pass = len({m.group(1) for m in (re.match(r"Pass (\d+): AI score .*rewrote", x) for x in log_) if m})
+    why = next((x.split(" — ", 1)[1] for x in reversed(log_) if " — " in x), "")
+    locked = max([int(m.group(1)) for m in (re.search(r"\((\d+) skipped", x) for x in log_) if m] or [0])
+    if n_pass:
+        msg += (f" ({n_pass} pass{'es' if n_pass != 1 else ''}"
+                + (f"; {why.replace('stopped: ', 'stopped after ')}" if why else "") + ")")
+    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.")
     labels, g_before, g_after = None, b["pct"], a["pct"]
     gline = _grammar_line(res.get("note"))
     rs = res.get("report")
@@ -477,7 +491,7 @@ def smart_text(text, target, passes, temp, mode, hi, mod, full_ai, vocab, report
 
 
 def smart_docx(path, target, passes, temp, mode, hi, mod, full_ai, vocab, report, rkind, user, request: gr.Request = None):
-    passes = P.max_passes(user, passes)
+    passes = P.max_passes(user, passes, document=True)
     yield from _stream(_smart_docx_core, (path, target, passes, temp, mode, hi, mod, bool(full_ai), vocab, report, rkind), 5, 0, user, True, request,
                        tool="Smart Humanize", words=P.doc_words(path) if path else None)
 
@@ -1750,13 +1764,19 @@ with gr.Blocks(title=f"{APP_NAME} · CS Software Solutions", theme=theme, css=CS
             _b = P.price_buttons(P.DEFAULT_CURRENCY)
             with gr.Row():
                 pr_single = gr.Button(_b[0])
-                pr_monthly = gr.Button(_b[1], variant="primary")
+                pr_pack = gr.Button(_b[1])
+                pr_scholar = gr.Button(_b[2], variant="primary")
+                pr_pro = gr.Button(_b[3], variant="primary")
             pr_pay = gr.HTML()
             gr.HTML('<div class="cs-gauge-cap" style="text-align:left;margin-top:10px">Prices in Indian rupees (₹) '
-                    'for India and US dollars ($) for other countries, switch with Currency above. A single document '
-                    'is a credit that never expires. The monthly plan runs for one month from the day it starts and '
-                    'includes ' + str(P.PLANS["monthly"]["docs_month"]) + ' documents for that month; unused documents '
-                    'do not carry over. A plan that is not renewed by its end date is switched off automatically. '
+                    'for India and US dollars ($) for other countries, switch with Currency above. One credit = one '
+                    'document up to ' + f"{P.CREDIT_WORDS:,}" + ' words (longer files use one credit per started '
+                    + f"{P.CREDIT_WORDS:,}" + ' words; the count is shown before the run). Bought credits are valid '
+                    + str(P.CREDIT_MONTHS) + ' months. Monthly plans run for one month from the day they start; '
+                    'unused monthly credits do not carry over, and a plan not renewed by its end date is switched off '
+                    'automatically. A run that fails costs nothing, and the same file can be re-run '
+                    + str(P.FREE_RERUNS) + ' times free within ' + str(P.RERUN_DAYS) + ' days. Refund: a credit is '
+                    'refunded if a run did not lower the AI score on our detector and the free re-runs did not either. '
                     'Results are indicators from our own detector and can differ from other checkers.</div>')
 
         # ============================ ABOUT / CONTACT ============================
@@ -1890,14 +1910,14 @@ with gr.Blocks(title=f"{APP_NAME} · CS Software Solutions", theme=theme, css=CS
                                 '(refund, misuse, user request); the user goes back to the free plan.</div>')
                         with gr.Row():
                             ad_p_email = gr.Textbox(label="User email", scale=3)
-                            ad_p_plan = gr.Dropdown(["monthly"], value="monthly",
+                            ad_p_plan = gr.Dropdown(list(P.ADMIN_PLANS), value="scholar",
                                                     label="Plan", scale=2)
                             ad_p_days = gr.Number(value=1, label="Months", precision=0, minimum=1, scale=1)
                             ad_p_amount = gr.Textbox(label="Amount received (optional)", scale=2)
                         with gr.Row():
                             ad_p_activate = gr.Button("✅ Activate plan", variant="primary")
-                            ad_p_credits_n = gr.Number(value=1, label="Single documents", precision=0)
-                            ad_p_credits = gr.Button("➕ Add single documents")
+                            ad_p_credits_n = gr.Number(value=1, label="Credits (1 single, 5 pack)", precision=0)
+                            ad_p_credits = gr.Button("➕ Add credits")
                         with gr.Row():
                             ad_t_reason = gr.Textbox(label="Reason for terminating (optional, sent to the user)",
                                                      scale=3)
@@ -2133,9 +2153,9 @@ with gr.Blocks(title=f"{APP_NAME} · CS Software Solutions", theme=theme, css=CS
     def _switch_currency(c):
         b = P.price_buttons(c)
         return (P.pricing_html(c),) + tuple(gr.update(value=x) for x in b)
-    pr_cur.change(_switch_currency, pr_cur, [pr_html, pr_single, pr_monthly], queue=False, **HID)
+    pr_cur.change(_switch_currency, pr_cur, [pr_html, pr_single, pr_pack, pr_scholar, pr_pro], queue=False, **HID)
 
-    for b, item in ((pr_single, "Single document"), (pr_monthly, "Monthly plan")):
+    for b, item in zip((pr_single, pr_pack, pr_scholar, pr_pro), P.BUY_ITEMS):
         b.click(lambda u, item=item: P.pay_instructions(u, item), user_state, pr_pay, **HID)
 
     # admin: plans, credits, requests, payments

plans.py

@@ -1,28 +1,29 @@
 """
-Pricing plans, quotas, credits and upgrade nudges.
-
-Who pays what (all paid plans are MONTHLY; ₹ in India, $ for international users)
-  guest      : paste only, 300 words, 15 runs/day, max 2 Smart passes
-  free       : + FREE_TRIAL_DOCS document runs (lifetime), 25 pastes/day
-  single     : ₹499 / $6 for one document (a credit that never expires)
-  monthly    : ₹4,999 / $59 a month · 300 documents per month (unused documents do not carry over)
-  admin      : everything free and unlimited, no nudges, never charged
-
-Subscriptions (users table)
-  plan_started : date the current subscription started (kept across on-time renewals)
-  period_start : start of the current paid month
-  plan_until   : end of the current paid month (same day next calendar month)
-  plan_status  : active / expired / free
-A plan that is not renewed by `plan_until` is switched off automatically (back to the free plan), recorded in
-`plan_history`, and the user gets an email. A renewal before the end date adds one month to the end date; a
-renewal after it starts a new subscription from today. "A day" for daily limits is the Indian calendar day (IST).
-
-Money comes in through `activate_plan()` / `add_credits()`:
-  * today   -> the Admin panel (manual activation after a UPI / bank payment)
-  * Razorpay -> call the same two functions from the payment webhook (see README).
+Pricing plans, credits, quotas and upgrade nudges (pricing policy of October 2026).
+
+Unit: one CREDIT = one document of up to CREDIT_WORDS (15,000) words; a longer document uses one credit per started
+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
+  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
+  pro          ₹2,999 / $39 a month  40 credits a month, pastes up to 5,000 words, priority
+  institution  ₹9,999 / $129 a month 150 credits a month (activated by the admin, invoice billing)
+  extra        ₹149 / $2   one extra credit for monthly-plan users whose month's credits are used
+  admin        everything free and unlimited
+Journal Finder: free. Journal Formatter: 1 file a month free, included in plans (5 / 20 / 60 a month), ₹99 / $2 per
+file otherwise (shown on the Pricing page; enforced once the Formatter shares the suite's login).
+Monthly plans: 30 days from activation, credits do not carry over, renewal before expiry adds a month on top;
+not renewed by the end date -> switched off automatically (plan_history + email). Prices include GST (INR).
+
+Money comes in through `activate_plan()` / `add_credits()` (Admin panel today, Razorpay webhook later).
 """
 import calendar
 import html
+import math
 import os
 import threading
 import time
@@ -31,34 +32,65 @@ import gradio as gr
 
 import auth as A
 
-FREE_TRIAL_DOCS = int(os.getenv("FREE_TRIAL_DOCS", "2"))
+
+def _env_i(k, d):
+    return int(os.getenv(k, str(d)))
+
+
+def _env_f(k, d):
+    return float(os.getenv(k, str(d)))
+
+
+FREE_TRIAL_DOCS = _env_i("FREE_TRIAL_DOCS", 1)
+FREE_DETECT_DAY = _env_i("FREE_DETECT_DAY", 3)           # detector file reports a day on the free account
+CREDIT_WORDS = _env_i("CREDIT_WORDS", 15000)              # words per credit
+CREDIT_MONTHS = _env_i("CREDIT_MONTHS", 6)                # bought credits stay valid this many months
+FREE_RERUNS = _env_i("FREE_RERUNS", 2)                    # free re-runs of the same file ...
+RERUN_DAYS = _env_i("RERUN_DAYS", 7)                      # ... within this many days
 PAY_EMAIL = os.getenv("PAY_EMAIL", "info@cssoftwaresolutions.tech")
-PAY_WHATSAPP = os.getenv("PAY_WHATSAPP", "918886306793")          # digits with country code, e.g. 9198xxxxxxxx
+PAY_WHATSAPP = os.getenv("PAY_WHATSAPP", "918886306793")
 PROMO_TEXT = os.getenv("PROMO_TEXT", "")
 UNLIMITED = 10 ** 9
 
-# docs_day: documents (reports) per day; 0 = unlimited
+# 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, doc_words=0),
-    "free":    dict(name="Free", inr=0, usd=0, docs_month=0, docs_day=0, pastes=25, paste_words=300, passes=2, doc_words=15000),
-    # the monthly plan; "student" / "agency" / "pro" are earlier plan names kept so existing subscriptions still work
-    "monthly": dict(name="Monthly", inr=int(os.getenv("PRICE_MONTHLY", "4999")),
-                    usd=float(os.getenv("PRICE_MONTHLY_USD", "59")), docs_month=int(os.getenv("MONTHLY_DOCS", "300")),
-                    docs_day=0, pastes=UNLIMITED, paste_words=5000, passes=10, doc_words=150000),
-    "admin":   dict(name="Admin", inr=0, usd=0, docs_month=0, docs_day=0, pastes=UNLIMITED, paste_words=20000, passes=10,
-                    doc_words=UNLIMITED),
+    "guest": dict(name="Guest", inr=0, usd=0, docs_month=0, docs_day=0, pastes=15, 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),
+    "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),
+    "pro": dict(name="Pro", inr=_env_i("PRICE_PRO", 2999), usd=_env_f("PRICE_PRO_USD", 39),
+                docs_month=_env_i("PRO_CREDITS", 40), docs_day=0, pastes=UNLIMITED, paste_words=5000, passes=10,
+                doc_words=150000, format_month=20, priority=True),
+    "institution": dict(name="Institution", inr=_env_i("PRICE_INSTITUTION", 9999),
+                        usd=_env_f("PRICE_INSTITUTION_USD", 129), docs_month=_env_i("INSTITUTION_CREDITS", 150),
+                        docs_day=0, pastes=UNLIMITED, paste_words=5000, passes=10, doc_words=150000,
+                        format_month=60, priority=True),
+    # earlier plan (₹4,999 for 300 documents a month): kept so existing subscriptions run to their end date
+    "monthly": dict(name="Monthly (earlier plan)", inr=4999, usd=59, docs_month=_env_i("MONTHLY_DOCS", 300),
+                    docs_day=0, pastes=UNLIMITED, paste_words=5000, passes=10, doc_words=150000, format_month=20,
+                    priority=True),
+    "admin": dict(name="Admin", inr=0, usd=0, docs_month=0, docs_day=0, pastes=UNLIMITED, paste_words=20000,
+                  passes=10, doc_words=UNLIMITED, format_month=UNLIMITED, priority=True),
 }
-for _old in ("student", "agency", "pro"):                 # legacy plan names -> the monthly plan
-    PLANS[_old] = PLANS["monthly"]
-PAID = ("monthly", "student", "agency", "pro")
-_PAID_SQL = "('monthly','student','agency','pro')"
-# Single document: one document credit (bought alone, or after the monthly 300 are used); never expires.
-SINGLE = dict(name="Single document", inr=int(os.getenv("PRICE_SINGLE", "499")),
-              usd=float(os.getenv("PRICE_SINGLE_USD", "6")))
-EXTRA_DOC = SINGLE                                         # older name
-INR_NOTE = os.getenv("PRICE_INR_NOTE", "")        # e.g. "Prices include 18% GST" / "+18% GST"
-# Pricing page currency: INR for India (₹), USD for international visitors ($). Visitors switch on the Pricing tab.
+for _old in ("student", "agency"):                       # names from an earlier price list
+    PLANS[_old] = PLANS["scholar"]
+PAID = ("scholar", "pro", "institution", "monthly", "student", "agency")
+_PAID_SQL = "('scholar','pro','institution','monthly','student','agency')"
+SELL = ("scholar", "pro")                                # monthly plans on the Pricing page (institution: on request)
+ADMIN_PLANS = ("scholar", "pro", "institution", "monthly")
+
+# credit products
+SINGLE = dict(name="Single credit", inr=_env_i("PRICE_SINGLE", 199), usd=_env_f("PRICE_SINGLE_USD", 3), credits=1)
+PACK = dict(name="Pack of 5 credits", inr=_env_i("PRICE_PACK", 799), usd=_env_f("PRICE_PACK_USD", 12), credits=5)
+EXTRA = dict(name="Extra credit", inr=_env_i("PRICE_EXTRA", 149), usd=_env_f("PRICE_EXTRA_USD", 2), credits=1)
+FORMAT_FILE = dict(name="Journal formatting", inr=_env_i("PRICE_FORMAT", 99), usd=_env_f("PRICE_FORMAT_USD", 2))
+EXTRA_DOC = SINGLE                                       # older name
+INR_NOTE = os.getenv("PRICE_INR_NOTE", "Prices include 18% GST.")
 DEFAULT_CURRENCY = os.getenv("PRICE_CURRENCY", "INR").strip().upper()
+_ITEMS = {"single": SINGLE, "pack": PACK, "extra": EXTRA, "format": FORMAT_FILE}
 
 
 def _cur(currency):
@@ -67,26 +99,33 @@ def _cur(currency):
 
 
 def money(amount, cur="INR", per=""):
-    """₹4,999 / $59 ('' -> Free)."""
+    """₹999 / $14 ('' -> Free)."""
     if not amount:
         return "Free"
     return f"₹{amount:,.0f}{per}" if cur == "INR" else f"${amount:,.0f}{per}"
 
 
 def price_of(item, cur="INR"):
-    p = SINGLE if item in ("single", "extra") else PLANS[item]
+    p = _ITEMS.get(item) or PLANS[item]
     return money(p["usd"] if cur == "USD" else p["inr"], cur)
 
 
 def both(item):
-    """'₹4,999 ($59)' with the default currency first."""
+    """'₹999 ($14)' with the default currency first."""
     c1 = _cur(DEFAULT_CURRENCY)
     c2 = "USD" if c1 == "INR" else "INR"
     return f"{price_of(item, c1)} ({price_of(item, c2)})"
 
 
+def credits_needed(words):
+    """Credits a document of `words` words uses (one per started CREDIT_WORDS words)."""
+    return max(1, math.ceil((words or 0) / CREDIT_WORDS))
+
+
 def per_day_text(p):
-    return f"{p['docs_month']} documents per month"
+    return f"{p['docs_month']} credits per month"
+
+
 # ---------------------------------------------------------------- storage
 def _db():
     con = A._db()
@@ -94,7 +133,7 @@ def _db():
     for c, ddl in (("plan", "TEXT DEFAULT 'free'"), ("plan_until", "TEXT"), ("period_start", "TEXT"),
                    ("period_docs", "INTEGER DEFAULT 0"), ("doc_credits", "INTEGER DEFAULT 0"),
                    ("trial_used", "INTEGER DEFAULT 0"), ("plan_started", "TEXT"),
-                   ("plan_status", "TEXT DEFAULT 'free'")):
+                   ("plan_status", "TEXT DEFAULT 'free'"), ("credits_until", "TEXT")):
         if c not in cols:
             try:
                 con.execute(f"ALTER TABLE users ADD COLUMN {c} {ddl}")
@@ -108,6 +147,10 @@ def _db():
     con.execute("CREATE TABLE IF NOT EXISTS plan_history (id INTEGER PRIMARY KEY AUTOINCREMENT, "
                 "ts TEXT DEFAULT CURRENT_TIMESTAMP, email TEXT, plan TEXT, started TEXT, until TEXT, "
                 "event TEXT, note TEXT)")
+    con.execute("CREATE TABLE IF NOT EXISTS reruns (email TEXT, fkey TEXT, first_ts TEXT, runs INTEGER DEFAULT 0, "
+                "PRIMARY KEY (email, fkey))")
+    con.execute("CREATE TABLE IF NOT EXISTS daily_usage (email TEXT, day TEXT, tool TEXT, n INTEGER DEFAULT 0, "
+                "PRIMARY KEY (email, day, tool))")
     return con
 
 
@@ -192,14 +235,24 @@ def state(user):
     """Everything the UI and the checks need about a user's plan."""
     if A.is_admin(user):
         return dict(key="admin", **PLANS["admin"], until=None, started=None, used=0, used_today=0, credits=0,
+                    credits_until=None,
                     trial_left=0, paid=True, admin=True, status="admin", month_end=None)
     if not user:
         return dict(key="guest", **PLANS["guest"], until=None, started=None, used=0, used_today=0, credits=0,
+                    credits_until=None,
                     trial_left=0, paid=False, admin=False, status="guest", month_end=None)
     with _db() as con:
         row = con.execute("SELECT plan, plan_until, plan_started, doc_credits, trial_used, plan_status, "
-                          "period_start, period_docs FROM users WHERE email=?", (user["email"],)).fetchone()
-    plan, until, started, credits, trial, status, pstart, pdocs = row or ("free", None, None, 0, 0, "free", None, 0)
+                          "period_start, period_docs, credits_until FROM users WHERE email=?",
+                          (user["email"],)).fetchone()
+    plan, until, started, credits, trial, status, pstart, pdocs, cuntil = \
+        row or ("free", None, None, 0, 0, "free", None, 0, None)
+    if credits and cuntil and _parse(cuntil) <= _now():     # bought credits are valid CREDIT_MONTHS months
+        with _db() as con:
+            con.execute("UPDATE users SET doc_credits=0 WHERE email=?", (user["email"],))
+            con.execute("INSERT INTO plan_history (email, plan, started, until, event, note) VALUES (?,?,?,?,?,?)",
+                        (user["email"], "credits", None, cuntil, "credits expired", f"{credits} credit(s)"))
+        credits = 0
     if plan in PAID and until and _parse(until) <= _now():
         expire_due(user["email"])                            # month over, not renewed: switch it off now
         plan, status = "free", "expired"
@@ -214,13 +267,14 @@ def state(user):
     p = PLANS.get(plan, PLANS["free"])
     return dict(key=plan if plan in PLANS else "free", **p, until=until if plan in PAID else None,
                 started=started if plan in PAID else None, used=used, used_today=used, credits=credits or 0,
+                credits_until=cuntil if credits else None,
                 trial_left=max(0, FREE_TRIAL_DOCS - (trial or 0)), month_end=month_end,
                 paid=plan in PAID or (credits or 0) > 0, admin=False,
                 status="active" if plan in PAID else (status or "free"))
 
 
 def docs_available(st):
-    """Documents the user can still run: monthly allowance left + single-document credits (+ free trial)."""
+    """Credits the user can still spend: monthly allowance left + bought credits (+ free trial documents)."""
     if st["key"] in PAID:
         return max(0, st["docs_month"] - st["used"]) + st["credits"]
     return st["credits"] + st["trial_left"]
@@ -231,31 +285,93 @@ def _upgrade_msg(reason):
     return f"{reason} See the 💎 Pricing tab to upgrade."
 
 
-def check_doc(user, words=None):
+def _ist_day():
+    return time.strftime("%Y-%m-%d", time.gmtime(_now() + 330 * 60))
+
+
+def _daily(email, tool):
+    with _db() as con:
+        r = con.execute("SELECT n FROM daily_usage WHERE email=? AND day=? AND tool=?",
+                        (email, _ist_day(), tool)).fetchone()
+    return r[0] if r else 0
+
+
+def _daily_add(email, tool):
+    with _db() as con:
+        k = con.execute("UPDATE daily_usage SET n=n+1 WHERE email=? AND day=? AND tool=?",
+                        (email, _ist_day(), tool)).rowcount
+        if not k:
+            con.execute("INSERT INTO daily_usage (email, day, tool, n) VALUES (?,?,?,1)", (email, _ist_day(), tool))
+
+
+def _free_rerun(email, fkey):
+    """True if this file was charged within RERUN_DAYS and still has free re-runs left."""
+    if not fkey:
+        return False
+    with _db() as con:
+        r = con.execute("SELECT first_ts, runs FROM reruns WHERE email=? AND fkey=?", (email, fkey)).fetchone()
+    return bool(r) and _parse(r[0]) + RERUN_DAYS * 86400 > _now() and (r[1] or 0) < FREE_RERUNS
+
+
+def _is_detector(tool):
+    return "detector" in str(tool or "").lower()
+
+
+def check_doc(user, words=None, tool="", fkey=None):
+    """Before a document run: plan / credits / trial / word cap. Raises A.Upsell with a friendly message."""
     st = state(user)
     if st["admin"]:
         return
-    if st["key"] in PAID:
-        if st["used"] >= st["docs_month"] and st["credits"] <= 0:
-            raise A.Upsell(f"You've used all {st['docs_month']} documents of this month's plan. Buy single documents "
-                           f"at {both('single')} each to continue now; your monthly documents start again on "
-                           f"{_ist_date(st['month_end'])}.", kind="extra", title="Monthly documents used up")
-        cap = st["doc_words"]
-    else:
-        if docs_available(st) <= 0:
-            msg = ("Your plan was not renewed, so it has been switched off. Renew it on the 💎 Pricing tab, or buy a "
-                   f"single document for {both('single')}." if st["status"] == "expired" else
-                   "Your subscription has been ended. Please contact us, or choose an option on the 💎 Pricing tab."
-                   if st["status"] == "terminated" else
-                   f"You've used your {FREE_TRIAL_DOCS} free documents. Buy a single document for {both('single')}, "
-                   f"or take the monthly plan: {PLANS['monthly']['docs_month']} documents for "
-                   f"{both('monthly')}/month.")
-            raise A.Upsell(msg, title="Your plan has ended" if st["status"] in ("expired", "terminated") else
-                           "Loved your free documents?")
-        cap = PLANS["free"]["doc_words"] if not st["credits"] else PLANS["monthly"]["doc_words"]
-    if words and words > cap:
-        raise A.Upsell(f"This document has {words:,} words; your plan allows up to {cap:,} words per document. "
-                       "A bigger plan handles longer documents.", title="This document is a bit long")
+    e = (user or {}).get("email")
+    if _is_detector(tool):                            # detector file reports: unlimited on plans, a few a day free
+        if st["key"] in PAID or st["credits"] > 0:
+            return
+        if _daily(e, "detector") >= FREE_DETECT_DAY:
+            raise A.Upsell(f"The free account includes {FREE_DETECT_DAY} detector file reports a day. Paste text "
+                           f"for more checks today, or take the Scholar plan ({both('scholar')}/month) for "
+                           "unlimited reports.", kind="limit", title="Today's free reports are used")
+        return
+    if e and _free_rerun(e, fkey):
+        return                                        # free re-run of a file charged in the last days
+    need = credits_needed(words)
+    cap = st["doc_words"] if st["key"] in PAID or st["credits"] > 0 else PLANS["free"]["doc_words"]
+    if st["key"] not in PAID and st["credits"] <= 0 and st["trial_left"] > 0:
+        if words and words > cap:
+            raise A.Upsell(f"This document has {words:,} words; the free trial covers documents up to {cap:,} words. "
+                           f"A single credit ({both('single')}) covers up to {CREDIT_WORDS:,} words.",
+                           title="This document is longer than the free trial")
+        return
+    have = docs_available(st)
+    if have < need:
+        if st["key"] in PAID:
+            raise A.Upsell(f"This document needs {need} credit{'s' if need > 1 else ''} ({words or 0:,} words; one "
+                           f"credit = {CREDIT_WORDS:,} words) and you have {have} left this month. Add extra credits "
+                           f"at {both('extra')} each; your monthly credits start again on "
+                           f"{_ist_date(st['month_end'])}.", kind="extra", title="Monthly credits used up")
+        msg = ("Your plan was not renewed, so it has been switched off. Renew it on the 💎 Pricing tab, or buy "
+               f"credits ({both('single')} each, {both('pack')} for 5)." if st["status"] == "expired" else
+               "Your subscription has been ended. Please contact us, or choose an option on the 💎 Pricing tab."
+               if st["status"] == "terminated" else
+               f"This document needs {need} credit{'s' if need > 1 else ''} (one credit = {CREDIT_WORDS:,} words). "
+               f"Buy a single credit for {both('single')}, a pack of 5 for {both('pack')}, or take Scholar: "
+               f"{PLANS['scholar']['docs_month']} credits for {both('scholar')}/month.")
+        raise A.Upsell(msg, title="Your plan has ended" if st["status"] in ("expired", "terminated") else
+                       "Credits needed")
+    biggest = st["doc_words"] if st["key"] in PAID else PLANS["scholar"]["doc_words"]   # bought credits: any size
+    if words and words > biggest:
+        raise A.Upsell(f"This document has {words:,} words; the largest document is {biggest:,} words. "
+                       "Split it into chapters.", title="This document is very long")
+
+
+def doc_cost_text(user, words, tool=""):
+    """'This run uses 2 credits (21,400 words)' for the upload area ('' when not applicable)."""
+    if not words or _is_detector(tool):
+        return ""
+    st = state(user)
+    if st["admin"]:
+        return ""
+    n = credits_needed(words)
+    return f"This document ({words:,} words) uses {n} credit{'s' if n > 1 else ''}; you have {docs_available(st)}."
 
 
 def paste_limit(user):
@@ -266,10 +382,10 @@ def check_paste(user, text):
     st = state(user)
     n = len((text or "").split())
     if n > st["paste_words"]:
-        if st["key"] in ("guest", "free"):
-            raise A.Upsell(f"Free pastes are up to {st['paste_words']} words (yours: {n:,}). The monthly plan allows "
-                           f"{PLANS['monthly']['paste_words']:,} words per paste — or upload a .docx.",
-                           title="Your text is longer than the free limit")
+        if st["key"] not in PAID:
+            raise A.Upsell(f"Free pastes are up to {st['paste_words']} words (yours: {n:,}). Scholar allows "
+                           f"{PLANS['scholar']['paste_words']:,} words and Pro {PLANS['pro']['paste_words']:,} per "
+                           "paste, or upload a .docx with a credit.", title="Your text is longer than the free limit")
         raise A.Upsell(f"Your plan allows {st['paste_words']:,} words per paste (yours: {n:,}). Upload a .docx for "
                        "longer text.", kind="limit", title="Your text is a bit long")
 
@@ -278,12 +394,17 @@ def daily_paste_limit(user):
     return state(user)["pastes"]
 
 
-def max_passes(user, requested):
-    return int(min(int(requested), state(user)["passes"]))
+def max_passes(user, requested, document=False):
+    """Smart Humanize passes: the plan's limit; the free trial document gets the full automatic passes."""
+    st = state(user)
+    cap = st["passes"]
+    if document and (st["credits"] > 0 or (st["key"] == "free" and st["trial_left"] > 0)):
+        cap = 10
+    return int(min(int(requested), cap))
 
 
 def doc_words(path):
-    """Quick word count of an uploaded file (for the per-document cap)."""
+    """Quick word count of an uploaded file (for credits and the word cap)."""
     try:
         p = str(path).lower()
         if p.endswith(".docx"):
@@ -306,19 +427,37 @@ def doc_words(path):
 
 
 # ---------------------------------------------------------------- consume (after a successful run)
-def consume_doc(user):
-    """Monthly plan: its 300 documents first, then single-document credits. Otherwise: credits, then the free trial."""
+def consume_doc(user, words=None, tool="", fkey=None):
+    """Charge a successful document run: free re-run if allowed; detector files only count on the free account;
+    otherwise credits_needed(words) from the month's allowance, then bought credits, then the free trial."""
     st = state(user)
     if st["admin"] or not user:
         return
     e = user["email"]
+    if _is_detector(tool):
+        if st["key"] not in PAID and st["credits"] <= 0:
+            _daily_add(e, "detector")
+        return
     with _db() as con:
-        if st["key"] in PAID and st["used"] < st["docs_month"]:
-            con.execute("UPDATE users SET period_docs=COALESCE(period_docs,0)+1 WHERE email=?", (e,))
-        elif st["credits"] > 0:
-            con.execute("UPDATE users SET doc_credits=MAX(0, doc_credits-1) WHERE email=?", (e,))
-        elif st["key"] not in PAID:
+        if fkey:
+            r = con.execute("SELECT first_ts, runs FROM reruns WHERE email=? AND fkey=?", (e, fkey)).fetchone()
+            if r and _parse(r[0]) + RERUN_DAYS * 86400 > _now() and (r[1] or 0) < FREE_RERUNS:
+                con.execute("UPDATE reruns SET runs=COALESCE(runs,0)+1 WHERE email=? AND fkey=?", (e, fkey))
+                A.request_sync()
+                return
+        need = credits_needed(words)
+        if st["key"] not in PAID and st["credits"] <= 0 and st["trial_left"] > 0:
             con.execute("UPDATE users SET trial_used=COALESCE(trial_used,0)+1 WHERE email=?", (e,))
+        else:
+            from_month = min(need, max(0, st["docs_month"] - st["used"])) if st["key"] in PAID else 0
+            if from_month:
+                con.execute("UPDATE users SET period_docs=COALESCE(period_docs,0)+? WHERE email=?", (from_month, e))
+            rest = need - from_month
+            if rest:
+                con.execute("UPDATE users SET doc_credits=MAX(0, COALESCE(doc_credits,0)-?) WHERE email=?", (rest, e))
+        if fkey:
+            con.execute("INSERT OR REPLACE INTO reruns (email, fkey, first_ts, runs) VALUES (?,?,?,0)",
+                        (e, fkey, _ts(_now())))
     A.request_sync()
 
 
@@ -399,17 +538,22 @@ def terminate_plan(email, reason="", notify=True, source="admin"):
 
 
 def add_credits(email, n, source="admin", amount="", note=""):
+    """Add bought credits (single, pack or extra); all of the user's bought credits are then valid CREDIT_MONTHS
+    months from today."""
     email = (email or "").strip().lower()
+    t = _now()
+    for _ in range(CREDIT_MONTHS):
+        t = add_month(t)
     with _db() as con:
-        k = con.execute("UPDATE users SET doc_credits=COALESCE(doc_credits,0)+? WHERE email=?",
-                        (int(n), email)).rowcount
+        k = con.execute("UPDATE users SET doc_credits=COALESCE(doc_credits,0)+?, credits_until=? WHERE email=?",
+                        (int(n), _ts(t), email)).rowcount
         if not k:
             return False, f"No user found with {email}."
         con.execute("INSERT INTO payments (email, item, amount, source, note) VALUES (?,?,?,?,?)",
-                    (email, f"{int(n)} single document(s)", amount, source, note))
+                    (email, f"{int(n)} credit(s)", amount, source, note))
         con.execute("UPDATE upgrade_requests SET status='done' WHERE email=? AND status='open'", (email,))
     A.request_sync()
-    return True, f"Added {int(n)} single document(s) to {email}."
+    return True, f"Added {int(n)} credit(s) to {email}, valid until {_ist_date(_ts(t))}."
 
 
 def request_upgrade(user, item):
@@ -438,43 +582,41 @@ def usage_line(user):
     if st["admin"]:
         return "Admin — everything is free and unlimited."
     if not user:
-        return (f"Guest: {st['paste_words']}-word pastes, {st['pastes']} runs a day. "
-                f"Sign up free for {FREE_TRIAL_DOCS} document uploads.")
+        return (f"Guest: {st['paste_words']}-word pastes, {st['pastes']} runs a day. Sign up free for a trial "
+                f"document (up to {PLANS['free']['doc_words']:,} words) and {FREE_DETECT_DAY} detector reports a day.")
     parts = []
     if st["key"] in PAID:
-        parts.append(f"Monthly plan: {min(st['used'], st['docs_month'])}/{st['docs_month']} documents this month "
-                     f"(new month starts {_ist_date(st['month_end'])}) · paid until {_ist_date(st['until'])}, "
-                     f"renew by then to keep it")
+        parts.append(f"{st['name']} plan: {min(st['used'], st['docs_month'])}/{st['docs_month']} credits used this "
+                     f"month (new month starts {_ist_date(st['month_end'])}) · paid until {_ist_date(st['until'])}, "
+                     "renew by then to keep it")
     elif st["status"] == "expired":
         parts.append("Your plan ended (not renewed). Renew on the Pricing tab")
     elif st["status"] == "terminated":
         parts.append("Your subscription has been ended. Contact us or choose an option on the Pricing tab")
     else:
-        parts.append(f"Free plan: {st['trial_left']} of {FREE_TRIAL_DOCS} free documents left")
+        parts.append(f"Free plan: {st['trial_left']} of {FREE_TRIAL_DOCS} trial document(s) left")
     if st["credits"]:
-        parts.append(f"{st['credits']} single document(s) available")
+        parts.append(f"{st['credits']} credit(s) available until {_ist_date(st.get('credits_until'))}")
+    parts.append(f"1 credit = 1 document up to {CREDIT_WORDS:,} words")
     return " · ".join(parts)
 
 
 def nudge(user, document):
     """Shown under a finished run for guests and free users."""
     st = state(user)
-    if st["admin"] or st["key"] in PAID:
+    if st["admin"] or st["key"] in PAID or st["credits"] > 0:
         return ""
-    mp = PLANS["monthly"]
-    offer = (f"Single document: {both('single')} · Monthly plan: {mp['docs_month']} documents for "
-             f"{both('monthly')}/month.")
+    offer = (f"1 credit {both('single')} · 5 credits {both('pack')} · Scholar {both('scholar')}/month "
+             f"({PLANS['scholar']['docs_month']} credits).")
     if not user:
-        msg = (f"Want to check a whole thesis? <b>Sign up free</b> and upload {FREE_TRIAL_DOCS} Word/PDF documents — "
-               f"layout kept, highlighted PDF report included.")
+        msg = (f"Want to check a whole chapter? <b>Sign up free</b> for a trial document (up to "
+               f"{PLANS['free']['doc_words']:,} words): layout kept, highlighted PDF report included.")
     elif st["status"] in ("expired", "terminated"):
         msg = f"<b>Your plan has ended.</b> {offer}"
-    elif st["credits"] > 0:
-        return ""
     elif st["trial_left"] > 0:
-        msg = f"<b>{st['trial_left']} of {FREE_TRIAL_DOCS} free documents left.</b> {offer}"
+        msg = f"<b>Your free trial document is waiting.</b> {offer}"
     else:
-        msg = f"<b>Your free documents are used up.</b> {offer}"
+        msg = f"<b>Your free trial is used.</b> {offer}"
     return f'<div class="cs-nudge">💎 {msg} Open the <b>Pricing</b> tab.</div>'
 
 
@@ -482,60 +624,79 @@ def pricing_html(currency=None):
     cur = _cur(currency)
     other = "USD" if cur == "INR" else "INR"
     where = "outside India" if other == "USD" else "in India"
-    mp = PLANS["monthly"]
-    common = ["Smart Humanize + AI Detector + PDF report", "Rigorous proofread", "AI / similarity report-guided rewriting",
-              "Word layout, tables and citations kept"]
+    sc, pr = PLANS["scholar"], PLANS["pro"]
+    common = ["Smart Humanize + AI detector PDF report", "Rigorous proofread", "Word layout, tables, citations and "
+              "equations kept", f"{FREE_RERUNS} free re-runs of the same file within {RERUN_DAYS} days"]
 
-    def card(title, price, per, alt, feats, featured=False):
+    def card(title, price, per, alt, feats, featured=False, tag_text="Best value"):
         li = "".join(f"<li>{html.escape(f)}</li>" for f in feats)
-        tag = '<div class="cs-pop">Best value</div>' if featured else ""
+        tag = f'<div class="cs-pop">{html.escape(tag_text)}</div>' if featured else ""
         return (f'<div class="cs-price{" cs-featured" if featured else ""}">{tag}<div class="cs-pname">'
                 f'{html.escape(title)}</div><div class="cs-pval">{price}<small>{per}</small></div>'
                 f'<div class="cs-inr">{alt} {where}</div><ul>{li}</ul></div>')
 
-    single = card("Single document", price_of("single", cur), "/document",
-                  f"{price_of('single', other)}/document",
-                  ["One document, any length up to 150,000 words", "Pay only when you need it",
-                   "Credit never expires"] + common)
-    monthly = card("Monthly plan", price_of("monthly", cur), "/month", f"{price_of('monthly', other)}/month",
-                   [f"{mp['docs_month']} documents every month", "Unlimited pasted-text runs",
-                    f"Documents up to {mp['doc_words']:,} words", "Need more in a month? Add single documents"]
-                   + common, featured=True)
+    cards = [
+        card("Single credit", price_of("single", cur), "/credit", f"{price_of('single', other)}/credit",
+             [f"1 document up to {CREDIT_WORDS:,} words", f"Valid {CREDIT_MONTHS} months",
+              "Journal formatting of the same file included"] + common),
+        card("Pack of 5", price_of("pack", cur), "/5 credits", f"{price_of('pack', other)}/5 credits",
+             ["5 documents (a full thesis)", f"Valid {CREDIT_MONTHS} months", "Journal formatting of each file "
+              "included"] + common),
+        card("Scholar", price_of("scholar", cur), "/month", f"{price_of('scholar', other)}/month",
+             [f"{sc['docs_month']} credits every month", f"Pasted text up to {sc['paste_words']:,} words, unlimited",
+              "Unlimited AI detector reports", f"{sc['format_month']} journal-formatting files a month",
+              f"Extra credits {price_of('extra', cur)} each"] + common, featured=True),
+        card("Pro", price_of("pro", cur), "/month", f"{price_of('pro', other)}/month",
+             [f"{pr['docs_month']} credits every month", f"Pasted text up to {pr['paste_words']:,} words, unlimited",
+              "Unlimited AI detector reports", f"{pr['format_month']} journal-formatting files a month",
+              "Priority queue", f"Extra credits {price_of('extra', cur)} each"] + common,
+             featured=True, tag_text="For heavy users"),
+    ]
     promo = f'<div class="cs-promo">🎉 {html.escape(PROMO_TEXT)}</div>' if PROMO_TEXT else ""
-    note = (f'<div class="cs-gauge-cap" style="text-align:left">{html.escape(INR_NOTE)}</div>'
-            if INR_NOTE and cur == "INR" else "")
-    return (promo + '<div class="cs-prices" style="grid-template-columns:repeat(2,minmax(0,1fr));max-width:860px;'
-            'margin:0 auto">' + single + monthly + "</div>" + note)
+    extra = (f'<div class="cs-gauge-cap" style="text-align:left;max-width:1100px;margin:10px auto 0">'
+             f'<b>Free account:</b> pasted text up to {PLANS["free"]["paste_words"]} words ({PLANS["free"]["pastes"]} a '
+             f'day), {FREE_TRIAL_DOCS} trial document up to {PLANS["free"]["doc_words"]:,} words, {FREE_DETECT_DAY} '
+             f'detector reports a day, 1 journal-formatting file a month. '
+             f'<b>Journal Finder:</b> free for everyone. <b>Journal formatting</b> on its own: '
+             f'{price_of("format", cur)} per file. <b>Institutions and agencies:</b> from '
+             f'{price_of("institution", cur)}/month for {PLANS["institution"]["docs_month"]} credits, several logins and '
+             f'a GST invoice, contact us.'
+             + (f' {html.escape(INR_NOTE)}' if INR_NOTE and cur == "INR" else "") + "</div>")
+    return (promo + '<div class="cs-prices" style="grid-template-columns:repeat(auto-fit,minmax(220px,1fr));'
+            'max-width:1100px;margin:0 auto">' + "".join(cards) + "</div>" + extra)
+
+
+BUY_ITEMS = ("Single credit", "Pack of 5 credits", "Scholar plan", "Pro plan")
 
 
 def price_buttons(currency=None):
-    """Labels of the two buy buttons in the chosen currency."""
+    """Labels of the four buy buttons in the chosen currency (same order as BUY_ITEMS)."""
     cur = _cur(currency)
-    return (f"Buy 1 document — {price_of('single', cur)}", f"Get the Monthly plan — {price_of('monthly', cur)}/month")
+    return (f"Buy 1 credit — {price_of('single', cur)}", f"Buy 5 credits — {price_of('pack', cur)}",
+            f"Scholar — {price_of('scholar', cur)}/month", f"Pro — {price_of('pro', cur)}/month")
 
 
 def pay_instructions(user, item):
-    """Until Razorpay is live: how to pay + the request is logged for the admin."""
+    """Until online payment is live: how to pay + the request is logged for the admin."""
     if A.is_admin(user):
         return '<div class="cs-authmsg cs-ok">You are an admin — every feature is free for you.</div>'
     if not user:
         return ('<div class="cs-authmsg cs-bad">Please sign in (or create a free account) first, so we can '
-                'activate the plan on your account.</div>')
+                'activate it on your account.</div>')
     request_upgrade(user, item)
     links = []
     if PAY_WHATSAPP:
-        txt = (f"Hi, I want to buy single documents for {user['email']}. How many: " if item == "Single document"
-               else f"Hi, I want the {item} for {user['email']}").replace(" ", "%20")
+        txt = f"Hi, I want to buy: {item} for {user['email']}".replace(" ", "%20")
         links.append(f'<a class="cs-dl" target="_blank" href="https://wa.me/{PAY_WHATSAPP}?text={txt}">'
                      f'💬 Pay via WhatsApp / UPI</a>')
     if PAY_EMAIL:
-        links.append(f'<a class="cs-dl" href="mailto:{PAY_EMAIL}?subject=Upgrade%20to%20{item.replace(" ", "%20")}'
+        links.append(f'<a class="cs-dl" href="mailto:{PAY_EMAIL}?subject={item.replace(" ", "%20")}'
                      f'&body=Account:%20{user["email"]}">✉️ Email us to pay</a>')
     contact = "".join(links) or (f'<div class="cs-gauge-cap" style="text-align:left">Contact us through '
                                  f'<a href="https://cssoftwaresolutions.in" target="_blank">cssoftwaresolutions.in</a>.</div>')
     return (f'<div class="cs-authmsg cs-ok"><b>{html.escape(item)}</b> requested for '
             f'<b>{html.escape(user["email"])}</b>. Online card payment is launching shortly; for now pay by UPI or '
-            f'bank transfer and your plan is switched on the same day.</div>{contact}')
+            f'bank transfer and it is switched on the same day.</div>{contact}')
 
 
 # ---------------------------------------------------------------- admin