{
 "approach": "Base strategy unchanged in mechanism (tick probes, sub-tick belief filter, quotes one tick inside the competitor, marginal sizing, cheap YES stock near zero) plus a new one no earlier seat built: online estimation of each run's retail flow, which every earlier version held as fixed constants (lam_r=0.25, m=5) although the regime varies it about fivefold. The strategy remembers its own main orders resting ahead of the competitor. A partial fill is one retail order of known notional (qty*price for buys, qty*max(p,0.05) for sells); a full fill is a censored lower bound, unless every probe on that side up to its price was also eaten, in which case it is an arbitrage sweep and is ignored. The arrival rate is the fraction of exposed side-steps with a retail hit (prior 300 side-steps at 0.253); the mean notional is a censored-lognormal EM with sigma 1.2 (prior weight 40 at 4.488). Both are multiplied by fixed calibration factors (1.177 and 1.137) that remove a measured downward bias; the estimates correlate about 0.83 with the true regime by the end of a run. On a per-run copy of the parameter dict (so serial runs do not leak state), lam_r and m are rescaled each step by estimate/prior, and the slow YES-stock target ydem by sqrt(estimated demand / prior demand). The crossing and tick-1 stock targets (ydf, ydf1) are not rescaled: doing that online lost money, even though an oracle gained from it.",
 "blocked": null,
 "python_version": "3.12.3",
 "base_mean_edge": 102.33197908899267,
 "score": {
  "mean_edge": 108.54841494177967,
  "retail_edge": 136.43005690744866,
  "arb_edge": -27.881641965698503,
  "simulations": 600,
  "seed_start": 1000,
  "failures": 0
 },
 "holdout": {
  "mean_edge": 96.7683741257685,
  "simulations": 600,
  "seed_start": 30000,
  "failures": 0
 },
 "code": "\"\"\"Stale-quote defence with tick probes, a sub-tick belief and cheap YES stock.\n\nEvery step the arbitrageur removes any order on the wrong side of p, so tiny\ntwo-sided probes around the estimate locate p to a tick; a grid filter narrows\nthat further.  Quotes sit one tick inside the competitor and are sized by the\nmarginal rule: one more share is worth quoting while the chance a retail order\nreaches it, times its edge, exceeds the expected arbitrage loss.  Near p=0 a\nretail buy pays almost its whole notional as edge, so YES is held to cover low\nasks.  That YES is bought when it is cheap: a large bid rests at tick 1 while p\nis above it, so the arbitrageur fills it on the crossing for about 0.1 tick a\nshare instead of nearly a full tick once p is near zero, and smaller bids sit on\nwhichever tick p is within 0.15 of.  Below tick 1 the estimate of p decays with\nthe time spent there, since no probe can see it.\n\nRetail flow is learned per run: main orders resting ahead of the competitor\nreveal each retail order that partially fills them (its notional exactly) or\nfully fills them (a lower bound, unless the probes show an arbitrage sweep).\nThe arrival rate and a censored lognormal mean feed the quote-sizing constants\nand, damped, the slow YES-stock target.\n\"\"\"\nimport math\nfrom orderbook_pm_challenge.strategy import BaseStrategy\nfrom orderbook_pm_challenge.types import CancelOrder, PlaceOrder, Side\n\nP = dict(lam_r=0.25, m=5.0, sig_n=1.2, lam_j=0.0019, sig_j=0.35, sig=0.02,\n         qmax=3000.0, rmin=2, kA=0.7, kL=0.15, pL=0.05,\n         ammo=1.0, ydem=0.4, W=200.0, fy=0.6, ammo_q=60.0, ammo_pmax=0.05, ammo_maxpay=0.02,\n         fb=0.9, fu=0.7, xu=0.1, sticky=1.0, min_ahead=2.0, keep_hi=1.5, keep_lo=0.7, Hu=300.0, bins=8.0, filt=1.0, uni=0.01, jumpinfo=1.0, dmin=0.0, kLb=0.08, kLf=0.08, pinf=1.0, pre=0.0, H1=100.0,\n         ydf=0.6, Wf=2000.0, g_hi=0.15, g_lo=0.15, qf=400.0, pmaxf=0.05, pre_gap=1.0,\n         ydf1=0.6, g1=5.0, f1=0.6, a1=100.0, nb1=0.0, gs=1.0, p1t=1.0, m1=1.0, zd=1.0, pfl=0.0005,\n         est=1.0, n0=300.0, k0=40.0, mc=1.114, dexp=0.5, lam0=0.253, mn0=4.488, sigr=1.2, eh=1.0, cl=1.177, cm=1.137)\nSQ2 = math.sqrt(2.0)\nSQ2PI = math.sqrt(2.0 * math.pi)\ndef cdf(x): return 0.5 * (1.0 + math.erf(x / SQ2))\ndef pdf(x): return math.exp(-0.5 * x * x) / SQ2PI\ndef inv(p):\n    p = min(max(p, 1e-9), 1 - 1e-9)\n    t = math.sqrt(-2.0 * math.log(min(p, 1 - p)))\n    x = t - (2.515517 + 0.802853 * t + 0.010328 * t * t) / (1 + 1.432788 * t + 0.189269 * t * t + 0.001308 * t ** 3)\n    x = -x if p < 0.5 else x\n    for _ in range(2):\n        d = pdf(x)\n        if d < 1e-12:\n            break\n        x -= (cdf(x) - p) / d\n    return x\ndef lpm(k):\n    return pdf(k) + k * cdf(k)\ndef fl(q):\n    return math.floor(q * 100 + 1e-9) / 100\n\nNODES = [(-2.2, .06), (-1.3, .17), (-0.6, .27), (0.6, .27), (1.3, .17), (2.2, .06)]\nPROBE = 0.01\n\n\nclass Strategy(BaseStrategy):\n    def __init__(self):\n        self.n = 0\n        self.ahead = set()     # main orders placed strictly ahead of any competitor order at their tick\n        self.res = {}          # order id -> uncovered quantity at placement\n        self.bc = None         # belief: sub-tick grid centres (ticks)\n        self.bw = None         # belief: weights\n        self.st = 0.5          # last one-step sd in ticks\n        self.pcb = self.pca = None\n        self.pb = set()\n        self.pa = set()\n        self.tb = 0\n        self.s = None          # competitor spread parameter\n        self.P = dict(P)       # per-run copy: retail constants are re-estimated online\n        self.prev = {}         # main order id -> (side, price, remaining) after our actions last step\n        self.ex = 0.0          # exposure: side-steps with a main order at the top of the book\n        self.ev = 0.0          # retail arrivals seen on those\n        self.lu = []           # log notionals, uncensored\n        self.lc = []           # log lower bounds, censored\n        self.Pa0 = set()\n        self.Pb0 = set()\n        self.mu = None\n\n    def _oid(self, tag):\n        self.n += 1\n        return tag + str(self.n)\n\n    def _learn(self, state, phat_prev):\n        cur = {o.order_id: o.remaining_quantity for o in state.own_orders}\n        sa = {o.price_ticks for o in state.own_orders if o.side is Side.SELL and o.remaining_quantity <= PROBE + 1e-9}\n        sb = {o.price_ticks for o in state.own_orders if o.side is Side.BUY and o.remaining_quantity <= PROBE + 1e-9}\n        for side in (Side.BUY, Side.SELL):\n            orders = [(i, v) for i, v in self.prev.items() if v[0] is side]\n            if not orders:\n                continue\n            self.ex += 1.0\n            d = 0.0\n            full = False\n            part = False\n            x = orders[0][1][1]\n            for i, (sd_, px, rem) in orders:\n                c = cur.get(i, 0.0)\n                if rem - c > 1e-9:\n                    d += rem - c\n                    if c > 1e-9:\n                        part = True\n                    else:\n                        full = True\n            if d <= 0:\n                continue\n            if side is Side.SELL:\n                probes = self.Pa0\n                eaten = probes - sa\n                arb = full and not part and probes and all(t in eaten for t in probes if t <= x)\n                notional = d * x / 100.0\n            else:\n                probes = self.Pb0\n                eaten = probes - sb\n                arb = full and not part and probes and all(t in eaten for t in probes if t >= x)\n                notional = d * max(phat_prev, 0.05)\n            if arb:\n                self.ex -= 1.0\n                continue\n            self.ev += 1.0\n            if notional > 1e-6:\n                (self.lu if part else self.lc).append(math.log(notional))\n        P0 = P\n        sr = P0['sigr']\n        mu0 = math.log(P0['mn0']) - 0.5 * sr * sr\n        mu = self.mu if self.mu is not None else mu0\n        nu = len(self.lu) + len(self.lc)\n        if nu:\n            for _ in range(3):\n                tot = sum(self.lu)\n                for c in self.lc:\n                    a = (c - mu) / sr\n                    tl = max(1.0 - cdf(a), 1e-9)\n                    tot += mu + sr * pdf(a) / tl if a < 6 else c + sr / max(a, 1e-3)\n                mu = (tot + P0['k0'] * mu0) / (nu + P0['k0'])\n        self.mu = mu\n        mhat = math.exp(mu + 0.5 * sr * sr) * (P0['cm'] if nu else 1.0)\n        n0 = P0['n0']\n        pe = (self.ev + n0 * (1 - math.exp(-P0['lam0'] / 2))) / (self.ex + n0)\n        lam = -2.0 * math.log(max(1e-6, 1.0 - min(pe, 0.9))) * P0['cl']\n        Q = self.P\n        if True:\n            Q['lam_r'] = P0['lam_r'] * lam / P0['lam0']\n            Q['m'] = P0['m'] * mhat / P0['mn0']\n        f = (lam * mhat / (P0['lam0'] * P0['mn0'])) ** P0['dexp']\n        Q['ydem'] = P0['ydem'] * f       # only the slow YES target follows demand\n\n    def on_step(self, state):\n        if self.P['est'] > 0 and self.bc is not None:\n            self._learn(state, self.ph)\n        P = self.P\n        H = max(1, state.steps_remaining)\n        cb = state.competitor_best_bid_ticks or 0\n        ca = state.competitor_best_ask_ticks or 100\n        if self.s is None:\n            self.s = max(1, (ca - cb + 1) // 2)\n        lo, hi = cb, ca\n        for o in state.own_orders:\n            if o.side is Side.BUY:\n                lo = max(lo, o.price_ticks)\n            else:\n                hi = min(hi, o.price_ticks)\n        if P['pinf'] > 0:\n            sb = {o.price_ticks for o in state.own_orders if o.side is Side.BUY and o.remaining_quantity <= PROBE + 1e-9}\n            sa = {o.price_ticks for o in state.own_orders if o.side is Side.SELL and o.remaining_quantity <= PROBE + 1e-9}\n            ea = self.pa - sa\n            eb = self.pb - sb\n            if sa and ea:\n                lo = max(lo, min(max(ea), hi))\n            if eb and (sb or min(eb) <= P['p1t']):\n                hi = min(hi, max(min(eb), lo))\n        if P['jumpinfo'] > 0 and self.pcb is not None:\n            if ca > self.pca + 1:\n                lo = max(lo, ca - 1)\n            if cb < self.pcb - 1:\n                hi = min(hi, cb + 1)\n        self.pcb, self.pca = cb, ca\n        if lo > hi:\n            lo, hi = hi, lo\n        # sub-tick belief over p_(t-1): predict with one-step noise, truncate to [lo, hi]\n        wid = max(hi - lo, 1e-6)\n        nb = max(2, min(48, int(round(wid * P['bins']))))\n        cs = [lo + (i + 0.5) * wid / nb for i in range(nb)]\n        if self.bc is None or P['filt'] <= 0:\n            ws = [1.0 / nb] * nb\n        else:\n            sg = max(self.st, 0.6 * wid / nb)\n            k = -0.5 / (sg * sg)\n            ws = []\n            uni = P['uni'] * sg\n            for c in cs:\n                t = uni\n                for ci, wi in zip(self.bc, self.bw):\n                    d = c - ci\n                    d2 = d * d * k\n                    if d2 > -12.5:\n                        t += wi * math.exp(d2)\n                ws.append(t)\n            tot = sum(ws)\n            ws = [w / tot for w in ws]\n        self.bc, self.bw = cs, ws\n        mean_t = sum(c * w for c, w in zip(cs, ws))\n        var_t = max(sum(c * c * w for c, w in zip(cs, ws)) - mean_t * mean_t, 0.0)\n        phat = min(max(mean_t / 100.0, 0.002), 0.998)\n        self.ph = phat\n        var = P['sig'] ** 2 + P['lam_j'] * P['sig_j'] ** 2\n        sd = math.sqrt(H * var)\n        self.tb = self.tb + 1 if hi <= 1 else 0\n        if self.tb > 0 and P['zd'] > 0:\n            # below the last tick there is no probe: the score keeps walking away from it\n            phat = min(phat, max(P['pfl'], cdf(inv(0.01) - P['zd'] * 0.02 * math.sqrt(self.tb) / sd)))\n        z = inv(phat)\n        Z = z * sd\n        sp = pdf(z) / sd * P['sig']\n        self.st = sp * 100.0\n        s = math.sqrt(sp * sp + var_t / 1e4 + 1e-8)\n        sd1 = math.sqrt(max(1.0, H - 1.0) * var)\n        jp = [(cdf((Z + n * P['sig_j']) / sd1), w) for n, w in NODES]\n        lj = P['lam_j']\n\n        def AB(x):\n            k = (x - phat) / s\n            a = s * lpm(k)\n            b = a - (x - phat)\n            ja = sum(w * max(0.0, x - p) for p, w in jp)\n            jb = sum(w * max(0.0, p - x) for p, w in jp)\n            return (1 - lj) * a + lj * ja, (1 - lj) * b + lj * jb\n\n        if H == 1:\n            def AB(x):\n                return (1 - phat) * x, phat * (1 - x)\n        rho = P['lam_r'] * 0.5\n        mu = math.log(P['m']) - 0.5 * P['sig_n'] ** 2\n        kA = P['kL'] if phat < P['pL'] else P['kA']\n\n        def qsize(loss, gain, px):\n            loss *= kA\n            if gain <= 0:\n                return 0.0\n            tail = loss / (rho * gain)\n            if tail >= 1.0:\n                return 0.0\n            return min(P['qmax'], math.exp(mu + P['sig_n'] * inv(1 - max(tail, 1e-6))) / px)\n\n        ptk = phat * 100\n        def qbid(t):\n            if not 1 <= t <= 99:\n                return 0.0\n            a, b = AB(t / 100.0)\n            if phat * 100 - t < P['dmin']:\n                return 0.0\n            if P['nb1'] > 0 and self.s == 1 and t == 1 and ptk < 1.0:\n                return 0.0\n            if phat < P['pL']:\n                ytg = P['ydem'] * min(H, P['W']) / max(ca - 1, ptk + 1) * 100.0\n                a *= (P['kLb'] if state.yes_inventory < ytg else P['kLf']) / P['kL']\n            return qsize(a, b, max(phat, 0.05))\n\n        def qask(t):\n            if not 1 <= t <= 99:\n                return 0.0\n            a, b = AB(t / 100.0)\n            if t - phat * 100 < P['dmin']:\n                return 0.0\n            return qsize(b, a, t / 100.0)\n\n        bids = [o for o in state.own_orders if o.side is Side.BUY and o.remaining_quantity > PROBE + 1e-9]\n        asks = [o for o in state.own_orders if o.side is Side.SELL and o.remaining_quantity > PROBE + 1e-9]\n        sticky = P['sticky'] > 0\n        def top(orders, comp, step):\n            if sticky and sum(o.remaining_quantity for o in orders if o.price_ticks == comp and o.order_id in self.ahead) >= P['min_ahead']:\n                return comp\n            return comp + step\n        bid_t = top(bids, cb, 1)\n        ask_t = top(asks, ca, -1)\n        qb = qbid(bid_t)\n        qa = qask(ask_t)\n\n        Y = state.yes_inventory\n        if ask_t == 1 and H > P['H1'] and P['pre'] > 0:\n            qa = qa if Y >= P['a1'] > 0 else 0.0          # let the competitor's 2-tick ask erode instead of fronting it for nothing\n        # ammunition: hold YES so that low asks are covered\n        ptick = phat * 100\n        amt = 0\n        qam = 0.0\n        if P['ammo'] > 0 and ask_t >= 2 and phat < max(P['ammo_pmax'], P['pmaxf']):\n            wealth = state.cash + Y * phat\n            x = max(ask_t, ptick + 1) / 100.0\n            capw = P['fy'] * wealth / max(phat, 0.005)\n            target = min(P['ydem'] * min(H, P['W']) / x, capw)\n            full = min(P['ydf'] * min(H, P['Wf']) / x, capw) if phat < P['pmaxf'] else 0.0\n            t = max(1, min(99, int(math.ceil(ptick + 1e-9))))\n            g = t - ptick\n            if Y < full and g <= P['g_hi'] and bid_t <= t < ask_t:\n                amt, qam = t, min(P['qf'], full - Y)     # a tick p has just crossed: nearly free\n            elif Y < target and phat < P['ammo_pmax'] and bid_t <= t < ask_t and t / 100.0 - phat < P['ammo_maxpay']:\n                amt, qam = t, min(P['ammo_q'], target - Y)\n            elif Y < full and t >= 2 and 1.0 - g <= P['g_lo']:\n                amt, qam = t - 1, min(P['qf'], full - Y)  # rest just under p: filled only on the crossing, or by retail\n\n        if P['pre'] > 0 and ca == 2 and phat < 0.01 and H > P['H1'] and Y < P['pre'] and not qam and 1.0 - ptick < P['pre_gap']:\n            amt, qam = 1, min(P['ammo_q'], P['pre'] - Y)\n        q1 = 0.0\n        if P['ydf1'] > 0 and P['m1'] < ptick < P['g1'] + 1.0 and amt != 1:\n            q1 = max(0.0, P['ydf1'] * min(H, P['Wf']) / (self.s / 100.0) - Y)\n        # order management\n        actions = []\n        free = state.free_cash - 2.0\n        keep_ask = 0.0\n        new_b = []\n        new_a = []\n        def cancel(o):\n            nonlocal free\n            actions.append(CancelOrder(o.order_id))\n            x = o.price_ticks / 100.0\n            if o.side is Side.BUY:\n                free += x * o.remaining_quantity\n            else:\n                free += (1 - x) * min(self.res.get(o.order_id, 0.0), o.remaining_quantity)\n            self.ahead.discard(o.order_id)\n            self.res.pop(o.order_id, None)\n        for o in state.own_orders:\n            if o.remaining_quantity <= PROBE + 1e-9:\n                cancel(o)\n        kept_ids = set()\n        def manage(orders, t, q, comp):\n            kept = 0.0\n            for o in orders:\n                if o.price_ticks == t and q > 0 and kept + o.remaining_quantity <= max(q * P['keep_hi'], 1.0):\n                    kept += o.remaining_quantity\n                    kept_ids.add(o.order_id)\n                else:\n                    cancel(o)\n            return kept\n        kb = manage(bids, bid_t, qb, cb)\n        ka = manage(asks, ask_t, qa, ca)\n        add_b = (qb - kb) if (kb < qb * P['keep_lo'] and bid_t != cb) else 0.0\n        add_a = (qa - ka) if (ka < qa * P['keep_lo'] and ask_t != ca) else 0.0\n\n        budget = P['fb'] * max(free, 0.0)\n        cost = add_b * bid_t / 100.0 + qam * amt / 100.0\n        if cost > budget:\n            f = budget / cost\n            add_b *= f\n            qam *= f\n            cost = budget\n        out = []\n        q1 = min(q1, P['f1'] * max(budget - cost, 0.0) * 100.0)\n        if q1 >= 0.01:\n            out.append(PlaceOrder(side=Side.BUY, price_ticks=1, quantity=fl(q1)))\n            free -= fl(q1) / 100.0 + 1e-6\n        if amt and qam >= 0.01:\n            q = fl(qam)\n            out.append(PlaceOrder(side=Side.BUY, price_ticks=amt, quantity=q))\n            free -= q * amt / 100.0 + 1e-6\n        if bid_t >= 1 and add_b >= 0.01:\n            q = fl(add_b)\n            oid = self._oid('b')\n            out.append(PlaceOrder(side=Side.BUY, price_ticks=bid_t, quantity=q, client_order_id=oid))\n            free -= q * bid_t / 100.0 + 1e-6\n            if bid_t > cb:\n                self.ahead.add(oid)\n        if ask_t <= 99 and add_a >= 0.01:\n            x = ask_t / 100.0\n            covk = sum(o.remaining_quantity - min(self.res.get(o.order_id, 0.0), o.remaining_quantity)\n                       for o in asks if o.order_id in kept_ids)\n            cov = max(0.0, Y - covk - 0.1)\n            unc = max(0.0, add_a - cov)\n            if unc > 0:\n                ub = max(0.0, free - (1 - P['fu']) * max(state.cash, 0.0)) if x >= P['xu'] else 0.0\n                if H < P['Hu'] and phat < 0.05:\n                    ub = max(0.0, free * (1 - H / P['Hu']))\n                unc = min(unc, ub / (1 - x))\n            q = fl(min(add_a, cov + unc))\n            if q >= 0.01:\n                oid = self._oid('a')\n                out.append(PlaceOrder(side=Side.SELL, price_ticks=ask_t, quantity=q, client_order_id=oid))\n                r = max(0.0, q - cov)\n                self.res[oid] = r\n                free -= r * (1 - x) + 1e-6\n                if ask_t < ca:\n                    self.ahead.add(oid)\n\n        # probes: tiny orders that the arbitrageur removes when p crosses them\n        f = int(math.floor(ptick + 1e-9))\n        r = max(int(P['rmin']), int(math.ceil(2.0 * s * 100)))\n        self.pb = set()\n        self.pa = set()\n        if free > 1.0:\n            for t in range(f, f + r + 1):\n                if cb < t < ca and 1 <= t <= 99:\n                    out.append(PlaceOrder(side=Side.BUY, price_ticks=t, quantity=PROBE))\n                    self.pb.add(t)\n            for t in range(f + 1 - r, f + 2):\n                if cb < t < ca and 1 <= t <= 99:\n                    out.append(PlaceOrder(side=Side.SELL, price_ticks=t, quantity=PROBE))\n                    self.pa.add(t)\n        cancelled = {a.order_id for a in actions}\n        self.prev = {}\n        for o in state.own_orders:\n            if o.order_id in cancelled or o.remaining_quantity <= PROBE + 1e-9:\n                continue\n            if o.order_id[:1] in 'ab' and (o.order_id in self.ahead):\n                self.prev[o.order_id] = (o.side, o.price_ticks, o.remaining_quantity)\n        for a in out:\n            if a.client_order_id and a.client_order_id in self.ahead and a.price_ticks not in (cb, ca):\n                self.prev[a.client_order_id] = (a.side, a.price_ticks, a.quantity)\n        self.Pa0, self.Pb0 = set(self.pa), set(self.pb)\n        return actions + out\n",
 "code_sha256": "6237974f61207575fc1ca82a65871f9f31115d71fa36e0f0dfa17fc644398d13",
 "tried": [
  "Scorer check: base on seeds 0-599 scored 102.33197908899267, the same as its author's figure. Base on 1000-1599: 107.244. Base on holdout 30000-30599: 96.041 (measured for comparison only).",
  "Oracle bounds on 1000-1599 (scratch runner feeding the true regime into P, not a candidate): true lam_r/m 108.29; true jump lam/sigma 107.57; both 108.78; true m scaled by 5/4.488 109.91 (rc 108.91); plus stock targets ydem/ydf/ydf1 scaled by true demand (rcD) 110.32. So per-run retail knowledge is worth about +1.7 to +3.1, and jump parameters about +0.3.",
  "Online estimator v1, no bias calibration, rescaling lam_r, m and all stock targets: 105.63 (-1.6). The estimates ran about 15% (rate) and 12% (size) low, so everything was sized too small.",
  "With calibration factors cl=1.177 and cm=1.137, still rescaling all stock targets fully: 107.27 (flat).",
  "Stock targets rescaled only, quoting constants fixed: 106.62. Stock targets at exponent 0.5 with quoting rescaled: 108.06.",
  "Quoting constants (lam_r, m) rescaled, stock untouched: 108.287 (+1.04). Holdout 96.659, against base 96.041.",
  "Neighbours of that on 1000-1599: cl 1.0 108.24, cl 1.35 107.54, cm 1.0 108.23, cm 1.3 106.92, rate prior n0 100 108.03, size prior k0 15 107.85. A plateau, so kept as is.",
  "Rescaling stock targets with the quoting update: all three at exponent 0.25 108.26; ydf1 only at exponent 0.5 107.87; ydem and ydf at 0.5 108.52; ydem at 0.75 108.54; ydem at 1.0 108.53; ydem at 0.5 with n0 600 108.32; ydem at 0.5 with cl 1.25 108.26.",
  "--sandbox fails on Python 3.12 for examples/starter_strategy.py and for this file alike: pathlib imports ntpath, which the sandbox's import allow-list refuses. On a scratch copy of the simulator that also allows ntpath and posixpath, the final file passed 20/20 sandboxed with mean 95.95839358697, identical to the unsandboxed run. --workers 30 worked here.",
  "FINAL (best): quoting constants follow the online retail estimate, and ydem follows sqrt(estimated demand): 108.548 on 1000-1599 (+1.30 over base), holdout 30000-30599 96.768 (+0.73 over base's 96.041), 0 failures."
 ],
 "next": "Most of the remaining oracle gap (about 1.8 on 1000-1599) is in sizing the YES stock to each run's demand. Online it fails because stock is bought early, before the estimate has converged, and the estimator only sees runs where our quote is ahead of the competitor. Spread-1 runs give it no exposure at all, so they stay at the prior. Next: (1) estimate demand from tick-1 sales near zero as well (retail buys at 1c reveal notional as qty*0.01), and from fills at the competitor's tick; (2) let the big tick-1 bid (ydf1) shrink with the estimate only when it is confident, using a posterior variance rather than a fixed exponent; (3) combine with a per-run jump-intensity estimate from probe jumps, which an oracle puts at about +0.3; (4) use the estimated rate to choose kA per run, since the arbitrage/retail trade-off depends on retail volume."
}