{
  "approach": "Preserves the base tick probes, sub-tick belief, queue management and cheap crossing-bid YES accumulation. Combines cover-bank planning with a reserve on new uncovered asks and an ask-gain charge when YES inventory is scarce. The dearer immediate-cover target spans min(steps remaining, 50) steps; the cheap crossing bank retains its separate min(steps remaining, 2000) target. New uncovered asks leave a $200 cash reserve, released linearly over the final 50 steps. The older premium-paying cover-buy branch stops above 2.0 cents. Ask expected gain is reduced by up to 0.0025 below estimated probability 0.1 when YES inventory is below 3000 shares. Selection uses tuning seeds 1000-1599 only; the holdout was evaluated after freezing.",
  "blocked": null,
  "python_version": "3.12.3",
  "base_mean_edge": 102.33197908899267,
  "score": {
    "mean_edge": 109.27254289017199,
    "retail_edge": 135.356137274445,
    "arb_edge": -26.083594384290333,
    "simulations": 600,
    "seed_start": 1000,
    "failures": 0
  },
  "holdout": {
    "mean_edge": 98.12413933736983,
    "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\"\"\"\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)\nP.update({'W': 50, 'ammo_pmax': 0.02, 'fy': 0.7, 'fu': 0.25, 'Hu': 500})\nC = {'W': 50, 'ammo_pmax': 0.02, 'fy': 0.7, 'reserve': 200, 'scar': 0.0025, 'fu': 0.25, 'Hu': 500}\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\n    def _oid(self, tag):\n        self.n += 1\n        return tag + str(self.n)\n\n    def on_step(self, state):\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        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            if phat < C.get('scar_p', .1):\n                a = max(0.0, a - C.get('scar', 0.0) * (1 - min(1.0, state.yes_inventory / C.get('stock', 3000.0))))\n            return min(C.get('askcap', P['qmax']), 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 = min(C.get('bidcap', 3000.0), 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 not (C.get('recover', 0) and o.side is Side.SELL and t < comp and self.res.get(o.order_id, 0.0) > 1 and state.yes_inventory > C.get('recover_yes', 1) and state.free_cash < C.get('recover_cash', 200)) and 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                ub = min(ub, max(0.0, free - C.get('reserve', 0.0) * min(1.0, H / C.get('release', 50.0))))\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        return actions + out\n",
  "code_sha256": "baef955ec10728839f7c3357016ec9eb0550e7ec689bbd5171b1cdd5c9e37273",
  "tried": [
    "Reproduced the public base using unmodified simulator commit b244530ee2a6247b5f930830eeca9dd950da0e7e: 600 simulations on seeds 0-599, mean 102.33197908899267, zero failures, exactly matching the supplied author measurement. Python 3.12.3. No simulator code or simulator-configuration changes were used for any reported score.",
    "Search used only seeds 1000-1599. Screens used 1000-1119; individual-rule removals and projected-deficit reserves used 1200-1439. The finalist was chosen among completed full 600-seed tuning scores and frozen at 2026-11-05T23:54:13.728137+00:00 before any 30000-30599 holdout evaluation. No seed detection or replay is used.",
    "Base cash diagnostics on seeds 1000-1119 reproduce mean 125.69520508572083. Main-bid/cover-bid allocation clipping first appears in steps 1000-1499. Low-price asks are policy-clipped before hard cash scarcity because YES is short. Clipping counts measure intended versus allowed quotes, not missed fills.",
    "One-cent crossing bids already hit their allocation cap in steps 0-499: 69 callbacks across 120 simulations, mean cash 822.2902304347826 and free cash 386.43162608695656. In steps 1500-1999: 548 callbacks, cash 29.816465328467153, free cash 6.466002372262773. Thus the large crossing bank binds before main-bid cash does.",
    "Instrumented bank50graft600 reproduces its first 120 tuning runs exactly (mean 128.76052186178583): 0 main-bid/cover-bid allocation clips versus base 631; late crossing-bank clips 121 versus base 548. These are callback allocation constraints, not missed fills.",
    "Initial separate cash-plan grafts: 6 completed candidates; best scar0025 on 1000-1119, mean 127.60070818948999, retail 153.02606022908915, arb -25.425352039700833, failures 0/120. Short-screen scores were never treated as holdout evidence.",
    "Fixed reserves and inventory scarcity charges: 20 completed candidates; best scar0.005_r200 on 1000-1119, mean 127.98393126167583, retail 152.76473011873, arb -24.7807988571275, failures 0/120. Short-screen scores were never treated as holdout evidence.",
    "Remaining-horizon scarcity targets and reservation renewal: 16 completed candidates; best dyn0.0025_h2000 on 1000-1119, mean 127.81112172194584, retail 152.88265589449665, arb -25.071534172610832, failures 0/120. Short-screen scores were never treated as holdout evidence.",
    "Exempting covered asks or enabling charges only after cash is low: 11 completed candidates; best cashscar1000_0.01 on 1000-1119, mean 128.03293256668084, retail 153.15769721577666, arb -25.1247646491725, failures 0/120. Short-screen scores were never treated as holdout evidence.",
    "Immediate cover-bank and crossing-bid budget changes: 14 completed candidates; best bank50_scar0.0025 on 1000-1119, mean 128.17552416864666, retail 152.07473425994166, arb -23.899210091380834, failures 0/120. Short-screen scores were never treated as holdout evidence.",
    "Scarcity-charge fade and price eligibility: 11 completed candidates; best scarfade500_0.005 on 1000-1119, mean 127.48700975599917, retail 152.88770001127082, arb -25.400690255344166, failures 0/120. Short-screen scores were never treated as holdout evidence.",
    "Remove individual cash-plan rules: 4 completed candidates; best ablate_W_200 on 1200-1439, mean 105.78738356520333, retail 133.81603286914, arb -28.028649303996666, failures 0/240. Short-screen scores were never treated as holdout evidence.",
    "Reserve cash against projected cover deficits: 4 completed candidates; best deficitH100_rate1.0 on 1200-1439, mean 105.20214567463375, retail 133.86326819619873, arb -28.661122521629583, failures 0/240. Short-screen scores were never treated as holdout evidence.",
    "Optional broad sweeps were stopped to prioritize complete full-range comparisons; incomplete runs were not used as measurements or candidates.",
    "Do not confuse the two bank horizons: shortening the cheap crossing bank Wf to 300 steps scored 120.1248647400075 on seeds 1000-1119, versus base 125.69520508572083. The beneficial change shortens the dearer immediate-cover target W while retaining the remaining-horizon cheap crossing bank.",
    "Unmodified-base-equivalent tuning control: mean 107.2442092237515, retail 135.80165652288784, arb -28.557447299150834, zero failures/600 on seeds 1000-1599.",
    "Full tuning comparison bestfixed600: mean 106.55214968546717, retail 135.78550409066733, arb -29.233354405220332, failures 0/600, seeds 1000-1599.",
    "Full tuning comparison recover600: mean 107.28735559816033, retail 136.13816145077536, arb -28.8508058526345, failures 0/600, seeds 1000-1599.",
    "Full tuning comparison dynamic600: mean 107.37338668871584, retail 136.02832512415267, arb -28.6549384354525, failures 0/600, seeds 1000-1599.",
    "Full tuning comparison askcap600: mean 107.38537077553067, retail 136.80668602388465, arb -29.421315248376498, failures 0/600, seeds 1000-1599.",
    "Full tuning comparison cashadaptive600: mean 107.55535117266733, retail 136.0681551732595, arb -28.512804000608334, failures 0/600, seeds 1000-1599.",
    "Full tuning comparison scar600: mean 107.93194353828117, retail 135.643328350876, arb -27.71138481261283, failures 0/600, seeds 1000-1599.",
    "Full tuning comparison graft600: mean 108.10341630082783, retail 135.76548660891515, arb -27.662070308104667, failures 0/600, seeds 1000-1599.",
    "Full tuning comparison coverW0_600: mean 108.34426375994883, retail 133.844903112341, arb -25.50063935241033, failures 0/600, seeds 1000-1599.",
    "Full tuning comparison bank25simple600: mean 108.61008643076383, retail 135.065489691378, arb -26.455403260636, failures 0/600, seeds 1000-1599.",
    "Full tuning comparison coverW200_600: mean 108.65847307037417, retail 135.69643049850765, arb -27.03795742815033, failures 0/600, seeds 1000-1599.",
    "Full tuning comparison bank100simple600: mean 108.67555762761016, retail 135.88296035010282, arb -27.207402722512168, failures 0/600, seeds 1000-1599.",
    "Full tuning comparison bank50simple600: mean 108.93907617649516, retail 135.50045397857266, arb -26.5613778020995, failures 0/600, seeds 1000-1599.",
    "Full tuning comparison reserve50_600: mean 108.97443149600551, retail 135.09493616985233, arb -26.120504673867, failures 0/600, seeds 1000-1599.",
    "Full tuning comparison bank100graft600: mean 109.13608921331333, retail 135.62150332740634, arb -26.485414114113834, failures 0/600, seeds 1000-1599.",
    "Full tuning comparison release250_600: mean 109.16375895231567, retail 135.171422550761, arb -26.007663598466667, failures 0/600, seeds 1000-1599.",
    "Full tuning comparison bank50graft600: mean 109.18129435236817, retail 135.360425511171, arb -26.179131158823665, failures 0/600, seeds 1000-1599.",
    "Full tuning comparison cutoff02_600: mean 109.21846903844917, retail 135.3107751034365, arb -26.092306065006, failures 0/600, seeds 1000-1599.",
    "Full tuning comparison expiryfade600: mean 109.26998910932316, retail 135.3835065577713, arb -26.113517448466, failures 0/600, seeds 1000-1599.",
    "Unmodified starter --sandbox on 20 simulations: 20/20 failed. ImportError: Import of 'ntpath' is not allowed in sandbox mode (pathlib before strategy loading).",
    "Frozen finalist --sandbox on 20 simulations: 20/20 failed. ImportError: Import of 'ntpath' is not allowed in sandbox mode (pathlib before strategy loading).",
    "Frozen finalist paired tuning gain 2.0283336664204996, standard error 0.35262349203866866. Dropping the single largest paired gain leaves 1.8680563725619364. Final code and repeat full tuning score match their frozen inputs exactly.",
    "After freezing, base holdout control on seeds 30000-30599: mean 96.0405203261775, retail 124.3725985363135, arb -28.332078210128167, zero failures/600. Finalist paired holdout change 2.083619011192334, standard error 0.4067546948632805. Holdout results did not change code or selection.",
    "No measurements, scores, inputs or source quotations were fabricated. The only unavailable verification is sandbox execution when the unmodified runtime fails before loading both the starter and finalist; unsandboxed simulation outcomes and that limitation are reported explicitly.",
    "Final frozen candidate reserve200_600: repeat tuning mean 109.27254289017199, retail 135.356137274445, arb -26.083594384290333, failures 0/600, seeds 1000-1599; one untouched holdout evaluation mean 98.12413933736983, failures 0/600, seeds 30000-30599. SHA256 baef955ec10728839f7c3357016ec9eb0550e7ec689bbd5171b1cdd5c9e37273."
  ],
  "next": "Estimate low-price retail notional flow per run and size the contingency bank to demand, distinguishing it from the large cheap crossing bank. Use fresh tuning seeds and a new untouched holdout; do not tune on seeds 30000-30599. The current fixed demand assumption may miss low- and high-flow regimes."
}