{"approach": "Fresh oracle work identified persistent FIFO priority as the useful gift: arbitrage completely removes stale orders, competitor replenishments arrive behind surviving participant orders, and retail spends cash into the best available prices. The standalone floor-ask policy proved the value of retaining that position, but its direct floor-reservation graft lost to the base. The delivered strategy instead preserves the base's probability filter, probes, quote prices and inventory policy while splitting each new named main bid or ask of at least 32 shares into sixteen equal, cent-share-rounded orders. Each child inherits the original priority status and its share of covered YES; when target size shrinks, the existing manager can retain feasible older pieces instead of cancelling one oversized order. Selection used only seeds 1000..1599; code was frozen before holdout scoring.", "blocked": null, "python_version": "3.13.5", "base_mean_edge": 102.33197908899267, "score": {"mean_edge": 108.11869389741317, "retail_edge": 136.6937171020847, "arb_edge": -28.575023204701665, "simulations": 600, "seed_start": 1000, "failures": 0}, "holdout": {"mean_edge": 96.07713311486467, "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.\nMain quotes are submitted in 16 FIFO chunks: downsizing can retain older\nshares instead of canceling one oversized order and losing its queue position.\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)\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            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        # Independent FIFO chunks allow resizing without discarding every older share.\n        split_out = []\n        for order in out:\n            oid = order.client_order_id\n            if oid and oid[0] in ('a', 'b') and order.quantity >= 32.0:\n                uncovered = self.res.pop(oid, 0.0)\n                covered = order.quantity - uncovered if order.side is Side.SELL else 0.0\n                leading = oid in self.ahead\n                self.ahead.discard(oid)\n                remaining = order.quantity\n                unit = fl(order.quantity / 16)\n                for k in range(16):\n                    q = fl(remaining if k == 16 - 1 else unit)\n                    remaining -= q\n                    child = self._oid(oid[0])\n                    split_out.append(PlaceOrder(order.side, order.price_ticks, q, client_order_id=child))\n                    if order.side is Side.SELL:\n                        cov = min(covered, q)\n                        covered -= cov\n                        self.res[child] = q - cov\n                    if leading:\n                        self.ahead.add(child)\n            else:\n                split_out.append(order)\n        out = split_out\n        return actions + out\n", "code_sha256": "82e060b6bf5f1a4b178419d6e7296e732fb015101c58237337fa69bc0e43e0e4", "tried": ["Scorer calibration: the untouched supplied base returned 102.33197908899267 on seeds 0..599, exactly its author's value; 600 simulations, zero failures. Its code stayed unread during fresh research; no other previous artifact was read.", "Actor gifts: arbitrage sweeps consume stale orders completely, making a surviving partial fill a retail/FIFO certificate; competitor replacements arrive on the opposite side at a fixed spread offset; retail buys spend a cash budget regardless of execution price. The chosen gift is priority that remains useful across competitor replenishment.", "Oracle protocol for the following twelve ideas: 600 seeds 1000..1599, exact next probability, next retail orders, competitor depth and spread. No one-tick-inside placements and no bids below 10. Reported finite-cash oracle scores and cash-unconstrained one-step opportunity envelopes screen defined quote families; they are not certified global dynamic upper bounds.", "Join at the competitor price: oracle mean 12.618101145980166; relaxed one-step envelope 23.828884276052264.", "Quote two ticks behind for overflow: oracle mean 3.3093233365715; relaxed one-step envelope 4.250092285217884.", "Quote at least five ticks behind for extreme retail tails: oracle mean 0.8955106349016667; relaxed one-step envelope 1.2314754011254643.", "Preposition at the known opposite-side replacement price: oracle mean 1.2556124729896667; relaxed one-step envelope 1.2565151643302876.", "Reuse prices observed in the last 20 steps: oracle mean 16.050551654571333; relaxed one-step envelope 27.138603837605853.", "Trade the interior of unusually wide competitor gaps: oracle mean 1.155644001874; relaxed one-step envelope 1.1565214673298736.", "Trade the initially empty center for the first 100 steps: oracle mean 1.0031117610141667; relaxed one-step envelope 1.0038727376712326.", "Trade immediately after a multi-tick quote sweep: oracle mean 1.6153645143561666; relaxed one-step envelope 1.7577708274067747.", "Sell to cash-denominated retail demand: oracle mean 11.640738087502166; relaxed one-step envelope 86.59304106548616.", "Buy retail supply at ticks 10 and above: oracle mean 11.491692067678168; relaxed one-step envelope 11.74290185939818.", "Save trading for the last 500 steps: oracle mean 10.541078472375167; relaxed one-step envelope 58.543264546443446.", "Use partial fills and surviving meaningful orders as feedback: oracle mean 12.633080066245833; relaxed one-step envelope 23.8502662071092.", "Naive queue joining: -48.15978215215 on 24 seeds 1000..1023. Behind-competitor ladders remained negative across 12 depth/size variants on seeds 1000..1059; e.g. two-share quotes eight ticks back scored -0.5987444267816666.", "Patience without a risk filter: holding ordinary same-price orders and delaying replacement improved the two-share candidate to -0.42680383725166665 on seeds 1000..1059; still rejected.", "Substantial-order probability filter with two-tick-inside quotes: best screen -1.98312859371 on seeds 1000..1099; rejected. No tiny information probes were used.", "Queue-priority oracle, seeds 1000..1119: forcing eight-share same-price orders ahead of all competitors changed -18.706261927596664 to 20.240440247891666, with zero failures. This motivated preservation of legally earned priority.", "High-probability retail-to-arbitrage inventory recycling, seeds 1200..1599: sixteen-share no-recycling control 0.605437251154; recycling at tick 99 scored 0.39715429479075. Rejected.", "Observed empty-side persistence: 3.815533723025 on 200 seeds 1000..1199 with 128-share orders and a 25-step confirmation period. Superseded by FIFO floor quoting.", "Near-zero floor strategy, hidden-depth oracle on seeds 1000..1299: changing exposure when hidden ahead notional fell below 30 scored 8.601714139252667 versus 8.613565309749 without that information; depth prediction was not pursued.", "Earlier floor-queue entry: 18 variants on seeds 1000..1299; strongest 512-share early-entry result 8.609530037662 versus the original 8.613565309749 on the same seeds. No improvement.", "Implementation checks: targeted ledger, FIFO and partial-fill tests; 4,000 single-step price comparisons (largest rounding-dust disadvantage 0.003918129200000009). Public priority certificates were checked against actual hidden sequence order in a 600-simulation stress exercise; no false certificate or collateral error occurred.", "Generic FIFO adapter, same core policy on all 600 tuning seeds: cancel/repost control 4.7273948024238335; generic retention 7.133452346072667; zero failures. Splitting into four or eight orders at each price produced exactly the same score in this control.", "Free just-cleared competitor bounds: best two-share one-step quote policy scored 0.05694474893466667 on all 600 tuning seeds; holding the inferred bound for three steps scored -0.5617163100896667. Rejected as the main mechanism.", "Public-priority stress check after reconciliation fixes: 1,200,000 callbacks, 55,467 certified ties checked with no false certificate, 24,928 promised retained orders all preserved, and zero reservation fallbacks. It recognized 55,467 of 55,513 actual front-of-queue ties.", "Supplementary strict-code check reads source before installing the upstream import hook, avoiding its pathlib loader defect; the fresh strategy then completed all 20 simulations at seeds 1500..1519 under the upstream import and builtin restrictions. This does not claim the official --sandbox loader passed.", "Replenishment-admission oracle on 600 tuning seeds: allowing newly placed orders to precede only same-step competitor replacements changed generic control 4.7273948024238335 to 4.8777321040945. Persistent legal retention reached 7.133452346072667; maintaining priority across later callbacks accounts for most of the gain.", "Selected fresh policy oracles on all 600 tuning seeds: ordinary 7.206228153587834; perfect same-price FIFO priority 9.619969291778833; exact next-step probability risk cancellation 8.781782323327167; both oracles 10.607608630471166. All oracle runs had zero failures; no oracle information enters delivered code.", "Fresh FIFO floor mechanism on all 600 tuning seeds 1000..1599: cancelling every step 4.6278235199181665; retaining priority 7.206228153587834; paired gain 2.578404633669667. Gain was 2.56178987359 on the first 300 and 2.5950193937493333 on the last 300; zero failures.", "Base first opened during the final half hour after independent research. Untouched base on 600 tuning seeds 1000..1599: 107.2442092237515; retail 135.80165652288784, arbitrage -28.557447299150834; zero failures.", "Public FIFO certification added to base, either asks only or both sides: 125.69520508572083 on seeds 1000..1119, exactly the untouched base on those seeds. The base already recognized the relevant existing main-order priority.", "Covered patient floor-ask screen, seeds 1000..1119: reserving fractions 0.05, 0.2, 0.5 and 1.0 scored 125.83647070787167, 125.68721451729833, 125.60959067171167 and 125.63801926563666. Earlier entry scored 125.628518835365; no failures.", "Side ablation, seeds 1120..1239: base 105.28724623882084; four/eight chunks on bids only 105.41257927237916/105.58113601983418; four/eight chunks on asks only 105.2776373030725/105.1110277293. All zero failures; only the bid-eight alternative was promoted to a full tuning test.", "Graft correctness: 7,202 equal-chunk quantity-conservation cases with three coverage states passed. A targeted front-of-queue downsizing test made the base cancel a 40-share order while the split version retained the oldest 10 shares. Original simulator files were unchanged.", "Official --sandbox on the frozen final code: all 20 seeds 1500..1519 failed before strategy loading with ImportError: Import of 'ntpath' is not allowed in sandbox mode. Official examples/starter_strategy.py failed all 20 identically on Python 3.13.5. This is the allowed shared sandbox failure, not a successful official sandbox check.", "Supplementary check of the frozen code under the upstream import hook and blocked builtins, with source read before that hook: all 20 seeds 1500..1519 passed and each edge exactly matched ordinary scoring. No simulator or sandbox source was modified.", "Frozen training rerun reproduced every seed exactly. Paired mean gain over base 0.8744846736616668; standard error 0.3176046282650462; first/last 300-seed gains 0.49210729726733277/1.256862050056001. These are tuning diagnostics, not independent evidence.", "Untouched holdout 30000..30599 evaluated only after freezing: final 96.07713311486467; base control 96.0405203261775; paired gain 0.036612788687167254 with standard error 0.2817268065582916. Both had zero failures. The control was diagnostic only; no code or selection changed after seeing this holdout.", "Patient covered floor ask, 5% of available YES: mean 106.765295527202, retail 136.01710773057965, arbitrage -29.251812203393 on all 600 tuning seeds 1000..1599; zero failures.", "Four equal chunks plus patient covered floor ask at 20%: mean 107.11039649276132, retail 136.6909944234585, arbitrage -29.580597930716497 on all 600 tuning seeds 1000..1599; zero failures.", "Untouched base control: mean 107.2442092237515, retail 135.80165652288784, arbitrage -28.557447299150834 on all 600 tuning seeds 1000..1599; zero failures.", "Eight descending geometric main-order chunks: mean 107.950364389242, retail 136.63908141998516, arbitrage -28.688717030770665 on all 600 tuning seeds 1000..1599; zero failures.", "Four descending geometric main-order chunks: mean 108.0194114879435, retail 136.56295128234066, arbitrage -28.54353979441533 on all 600 tuning seeds 1000..1599; zero failures.", "Eight equal main-bid chunks only: mean 108.02635744224933, retail 136.355117015534, arbitrage -28.3287595732965 on all 600 tuning seeds 1000..1599; zero failures.", "Four equal main-order chunks: mean 108.09389288954783, retail 136.4485921508415, arbitrage -28.354699261313666 on all 600 tuning seeds 1000..1599; zero failures.", "Eight equal main-order chunks: mean 108.1036108296595, retail 136.61717013093116, arbitrage -28.513559301294002 on all 600 tuning seeds 1000..1599; zero failures.", "SELECTED sixteen equal main-order chunks: mean 108.11869389741317, retail 136.6937171020847, arbitrage -28.575023204701665 on all 600 tuning seeds 1000..1599; zero failures. Frozen holdout 96.07713311486467 on 600 seeds, zero failures."], "next": "The untouched holdout did not establish a gain: paired improvement 0.036612788687167254 with standard error 0.2817268065582916, despite tuning gain 0.8744846736616668. Treat FIFO chunking as a tested mechanism, not a proven leaderboard improvement. On a new validation seed panel, test whether preserved queue priority permits lower inventory-acquisition exposure while maintaining retail revenue. The eight-piece bid-only alternative reduced tuning arbitrage loss more; combine this order-management idea with another lane's risk policy rather than retuning on seeds 30000..30599."}