Build an Estimator That Does Not Follow the Herd

Create standards_engine.py. Start with the vote table and the constants you will tune. Every weight here is a design decision: generation is near-zero because it is not evidence a human wanted anything, and acceptance is highest because it is the market, not the machine, talking.

import math
import random
from dataclasses import dataclass

SIGNAL_WEIGHTS = {
    "generated": 0.1,     # produced, but nobody acted on it (weak)
    "edit_kept": 0.5,     # a human left a generated block untouched
    "edit_reverted": -0.5,
    "sent": 1.0,          # the user staked their name on it
    "accepted": 3.0,      # the market accepted it (highest)
    "rejected": -1.5,
}
POSITIVE = {"sent", "accepted"}
NEGATIVE = {"edit_reverted", "rejected"}

HALF_LIFE_DAYS = 45.0   # a winning format fades this fast if it stops earning
GAMMA = 0.9             # sub-linear attachment: <1 keeps a live field
EPSILON_MIN = 0.10      # exploration floor, never 0
GRACE_TRIALS = 50       # protect a newborn variant from early variance
MIN_TRIALS = 30         # anti-fluke: a format must earn volume to be crowned
MARGIN = 0.15           # a challenger must clearly beat the incumbent
K_WINDOWS = 5           # and beat it for this many windows in a row
DIVERSITY_FLOOR = 0.6   # below this, monoculture alarm
LCB_QUANTILE = 0.10     # promote on the pessimistic 10% bound

You know this step worked if the file imports cleanly: run python -c "import standards_engine" and get no output and no error.

Add the state object and the update. The decay is the whole trick against lock-in: on every event you multiply the old standing by a half-life factor before adding the new vote, so popularity has to be renewed to survive. Preferential attachment is the motor (Barabasi and Albert, 1999); the decay is the brake that keeps QWERTY-style lock-in from freezing the field.

@dataclass
class FormatState:
    format_id: str
    S: float = 0.0        # decayed, quality-weighted standing
    alpha: float = 1.0    # Beta prior for acceptance
    beta: float = 1.0
    trials: int = 0
    last_ts: float = 0.0
    win_windows: int = 0

def _decay(dt_days):
    return math.exp(-math.log(2) * max(0.0, dt_days) / HALF_LIFE_DAYS)

def on_event(st, signal, ts_days):
    w = SIGNAL_WEIGHTS[signal]
    d = _decay(ts_days - st.last_ts)
    st.S = st.S * d + max(0.0, w)     # decayed cumulative advantage
    st.alpha *= d
    st.beta *= d
    if signal in POSITIVE:
        st.alpha += w
    elif signal in NEGATIVE:
        st.beta += abs(w)
    if signal == "sent":
        st.trials += 1    # one trial per document that actually went out
    st.last_ts = ts_days

You know this worked if you can feed one format two events and watch its standing rise: f = FormatState("A"); on_event(f, "sent", 0); on_event(f, "accepted", 0); print(f.S, f.alpha) should print a standing near 4.0 and an alpha near 5.0.