{"approach": "Returned the original base code unchanged. The following describes the frozen experiment, not the returned code: Spread 2 only: partition each new main order of at least 0.8 shares placed ahead of the competitor into FIFO lots of 5%, 15%, 30%, and the remainder (50% apart from cent-share rounding). Aggregate placement size, prices, sizing model, collateral budgets, and zero-target exits remain the base's. When a positive target shrinks, the existing manager can retain an early prefix and cancel back lots, instead of throwing away one indivisible front order. This preserves some priority without retaining the whole oversized exposure. An exact spread-2-only belief-loop optimization caches the prior grid pairs and skips points outside the base's existing five-sigma cutoff; it preserves summation order and the original cutoff test. All SimulationResult fields matched the base on 160 equivalence runs for this optimization alone. No seed is available to or recognized by the strategy.\n\nThe search used the first 160 spread-2 seeds in [8000,16000). Validation used matching-spread indices [800,1200) in that same range, a disjoint 400-run slice. The graduated-lot change gained 0.17783648010812395 on the search slice and 1.4502470343417495 on validation (paired SE 1.3350540927677748, zero failures). The code was frozen before its unseen results were observed; later alternative validation results did not change that selection. Final spread-specific metrics use every one of the 1987 spread-2 seeds in [60000,68000), each sampled and executed exactly like run_batch. The baseline scorer uses the requested CLI, 4000 seeds [4000,8000), four workers, no sandbox. Simulator commit: b244530ee2a6247b5f930830eeca9dd950da0e7e.\n\nWays to lose priority: a smaller positive target, a zero target, changing the selected tick, the two-share top() threshold, removal of <=0.01-share remnants, and complete consumption by retail or arbitrage. The base also cannot extend a front lot because it refuses additions at the rival's price. The tried entries quantify policy effects, not independent additive costs for individual cancellations: keeping all positive-target fronts lost 4.308651662662501 per search run; also keeping zero-target fronts lost another 3.3826498618662497; lowering the front threshold alone lost 0.19967437573250135; unrestricted at-rival replenishment alone lost 1.542370398851876. Bounded handoffs and safer-price parking were tested separately. Arbitrage consumption is adverse selection, whereas retail consumption realizes positive edge and only then ends priority; preserving consumed shares is impossible. Tiny-remnant cleanup was observed but was not assigned an invented isolated edge cost. Detailed cancellation counts and paired retail/arbitrage decompositions are in tried.\n\nUntouched spreads are checked on 300 seeds each for spreads 1, 3, and 4, starting at 60000; equality means every SimulationResult field, not just aggregate edge. seconds records elapsed wall time for 200 complete matching-spread runs of each strategy in one process, alternating equal 25-run blocks; process CPU time is also retained in the local timing check to distinguish contention from computation. All reported numbers are unrounded measurements. Sources pin the simulator and original strategy; score measurements are local, reproducible experiments rather than externally certified results.\n Final selection: unchanged base; no qualifying improving strategy was established. The frozen experiment was stopped before its unseen batch completed after persistent preliminary slowdown; no partial experimental unseen metrics are reported. Its complete 200-run timing comparison is recorded in tried. For the returned byte-identical base, both seconds labels reuse the same actual 200-run base measurement; no second independent measurement is claimed. The experiment and the base each completed their separate 200-run timing comparison in one process.", "blocked": null, "spread": 2, "base_mean_edge": 98.4694596619638, "base_unseen": {"mean_edge": 75.37891657984132, "retail_edge": 102.41461084785999, "arb_edge": -27.035694268030902}, "holdout": {"mean_edge": 75.37891657984132, "retail_edge": 102.41461084785999, "arb_edge": -27.035694268030902, "failures": 0}, "diff": {"mean": 0.0, "standard_error": 0.0, "retail": 0.0, "arb": 0.0}, "others_identical": {"runs": 900, "identical": true}, "seconds": {"base": 861.7034215284511, "yours": 861.7034215284511}, "code": "\"\"\"Crossing-cover base with isolated, untuned spread overrides.\"\"\"\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        self.flow_notional = 0.0\n        self.flow_exposure = 0\n        self.last_ask_tick = None\n        self.last_quote_exposed = False\n        self.last_flow_ca = None\n        self.last_flow_cap = 0.0\n        self.last_flow_correction = 1.0\n        self.params = P.copy()\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            if self.s == 1:\n                self.params.update({'dmin': 0.3, 'pfl': 1e-06})\n            if self.s == 3:\n                self.params.update({'flow_prior': 200, 'flow_level': 0.6, 'flow_strength': 1.0, 'flow_safety': 2.0, 'flow_exposure_min': 5.0})\n        P = self.params\n        if self.s == 3 and self.last_quote_exposed and ca <= self.last_flow_ca + 1:\n            self.flow_exposure += 1\n            self.flow_notional += min(self.last_flow_cap, state.sell_filled_quantity * self.last_ask_tick / 100.0) * self.last_flow_correction\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            stock_rate = P['ydf1']\n            if self.s == 3:\n                flow = (self.flow_notional + P['flow_prior'] * P['flow_level']) / (P['flow_prior'] + self.flow_exposure)\n                scale = max(0.5, min(2.0, flow / P['flow_level']))\n                stock_rate *= 1.0 + P['flow_strength'] * (scale - 1.0)\n            q1 = max(0.0, stock_rate * min(H, P['Wf']) / (self.s / 100.0) - Y)\n\n        # Bridge expected retail demand until another tick crossing is available.\n        if 0.02 < phat < 0.1:\n            ct = max(2, min(99, int(math.floor(ptick))))\n            wealth = state.cash + Y * phat\n            goal = min(1 * qa, 0.3 * max(wealth, 0.0) / phat)\n            if Y < goal and ct < ask_t:\n                amt, qam = ct, min(3000.0, goal - 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        if self.s == 3:\n            self.last_ask_tick = ask_t\n            self.last_flow_ca = ca\n            exposed_qty = ka + sum(o.quantity for o in out if o.side is Side.SELL and o.price_ticks == ask_t and o.quantity > PROBE)\n            self.last_flow_cap = exposed_qty * ask_t / 100.0\n            self.last_quote_exposed = ask_t / 100.0 > phat + max(0.005, P['flow_safety'] * self.st / 100.0) and self.last_flow_cap >= P['flow_exposure_min']\n            if self.last_quote_exposed:\n                logcap = math.log(self.last_flow_cap)\n                mu_flow = math.log(P['m']) - 0.5 * P['sig_n'] ** 2\n                clipped = P['m'] * cdf((logcap - mu_flow - P['sig_n'] ** 2) / P['sig_n']) + self.last_flow_cap * (1.0 - cdf((logcap - mu_flow) / P['sig_n']))\n                self.last_flow_correction = min(3.0, P['m'] / max(clipped, 0.01))\n        return actions + out\n", "code_sha256": "dcf68e0c9a7b06f90cf70a833357b60e2208b5b3e2971e7dddf02986d4747076", "tried": ["Frozen-strategy timing on 200 full spread-2 runs each, one process, alternating 25-run blocks: wall={\"base\":861.7034215284511,\"yours\":993.1953251338564}, process_cpu={\"base\":285.3919762769999,\"yours\":317.455430012}. Eligibility requires no wall-time or CPU-time regression.", "replenish to target at rival price with original cancellation rules [addonly.py.small.json]: n=160, paired={\"mean\":-1.542370398851876,\"standard_error\":0.5266852263565651,\"retail\":0.24493157130500007,\"arb\":-1.7873019701556248}, failures=0", "two-share front anchor with adjustable tail and lower front threshold [anchor.py.small.json]: n=160, paired={\"mean\":-0.6192897391812506,\"standard_error\":0.10140809351060862,\"retail\":-0.07194534292624905,\"arb\":-0.5473443962362493}, failures=0", "positive-target full front retention for SELL orders only [askkeep.py.small.json]: n=160, paired={\"mean\":-13.411034234908126,\"standard_error\":3.069222413773352,\"retail\":-6.652349221008124,\"arb\":-6.758685013884374}, failures=0", "positive-target full front retention for BUY orders only [bidkeep.py.small.json]: n=160, paired={\"mean\":-0.2642181265356256,\"standard_error\":0.4313448687470111,\"retail\":1.5645190890825005,\"arb\":-1.8287372156112496}, failures=0", "allow front size up to 2x fresh target while target positive [cap2.py.small.json]: n=160, paired={\"mean\":0.2916365113537503,\"standard_error\":0.25699260996288376,\"retail\":0.30321937812875144,\"arb\":-0.011582866779999595}, failures=0", "allow front size up to 3x fresh target while target positive [cap3.py.small.json]: n=160, paired={\"mean\":-0.5513920560106255,\"standard_error\":0.3402174811716105,\"retail\":0.44374325702375056,\"arb\":-0.9951353130412495}, failures=0", "allow front size up to 5x fresh target while target positive [cap5.py.small.json]: n=160, paired={\"mean\":-0.9762145634168751,\"standard_error\":0.6312299886888217,\"retail\":0.6233148737625023,\"arb\":-1.599529437194375}, failures=0", "split ahead quotes into two equal FIFO lots; original risk targets [chunks2.py.small.json]: n=160, paired={\"mean\":0.03607199756062401,\"standard_error\":0.12307153328240568,\"retail\":0.1769614406850018,\"arb\":-0.14088944313062457}, failures=0", "split ahead quotes into four equal FIFO lots; original risk targets [chunks4.py.small.json]: n=160, paired={\"mean\":0.14436643629562373,\"standard_error\":0.3090382817675222,\"retail\":0.38316549221250046,\"arb\":-0.2387990559049995}, failures=0", "split ahead quotes into eight equal FIFO lots; original risk targets [chunks8.py.small.json]: n=160, paired={\"mean\":0.23919845718374944,\"standard_error\":0.3145345709181622,\"retail\":0.6069670628556261,\"arb\":-0.36776860565937447}, failures=0", "base with exact spread-2 five-sigma grid cutoff and cached prior pairs [fastbase.py.small.json]: n=160, paired={\"mean\":0.0,\"standard_error\":0.0,\"retail\":0.0,\"arb\":0.0}, failures=0", "split ahead quotes into FIFO lots of 5%,15%,30%,50%; original risk targets [geo.py.small.json]: n=160, paired={\"mean\":0.17783648010812395,\"standard_error\":0.22297442276411625,\"retail\":0.3971423154456255,\"arb\":-0.21930583532812456}, failures=0", "split ahead quotes into FIFO lots of 10%,20%,30%,40%; original risk targets [geo10.py.small.json]: n=160, paired={\"mean\":0.045125470358747505,\"standard_error\":0.24910337414450948,\"retail\":0.32731730434499834,\"arb\":-0.28219183398187464}, failures=0", "positive-target full retention plus twelve-step queued-order handoff [handoff12.py.small.json]: n=160, paired={\"mean\":-6.320837710202501,\"standard_error\":1.3227108017959672,\"retail\":2.2144821691468746,\"arb\":-8.5353198793125}, failures=0", "positive-target full retention plus four-step queued-order handoff [handoff4.py.small.json]: n=160, paired={\"mean\":-7.406430648805,\"standard_error\":2.073249048942586,\"retail\":2.5470073880543738,\"arb\":-9.95343803684125}, failures=0", "positive-target full retention plus forty-step queued-order handoff [handoff40.py.small.json]: n=160, paired={\"mean\":-7.361535816457501,\"standard_error\":1.3326651963903475,\"retail\":0.4117484636381259,\"arb\":-7.773284280055}, failures=0", "retain the entire selected front lot even when target reaches zero [keep.py.small.json]: n=160, paired={\"mean\":-7.691301524528751,\"standard_error\":1.0886967346843326,\"retail\":3.5825162728643756,\"arb\":-11.27381779734375}, failures=0", "positive-target front retention plus keeping safer marked orders one tick away [park1.py.small.json]: n=160, paired={\"mean\":-4.309141065882502,\"standard_error\":1.0499054653236612,\"retail\":2.168155268789999,\"arb\":-6.477296334661875}, failures=0", "positive-target front retention plus keeping safer marked orders two ticks away [park2.py.small.json]: n=160, paired={\"mean\":-6.509774894671876,\"standard_error\":1.3804835772083355,\"retail\":3.9273242532400006,\"arb\":-10.437099147886874}, failures=0", "original risk/size cancellations; retain only safer marked orders one tick away [parkbase1.py.small.json]: n=160, paired={\"mean\":0.0060113850537485795,\"standard_error\":0.02669643231573307,\"retail\":0.011576263204375898,\"arb\":-0.005564878167499617}, failures=0", "original risk/size cancellations; retain only safer marked orders two ticks away [parkbase2.py.small.json]: n=160, paired={\"mean\":-1.770249444711876,\"standard_error\":0.9747608684732366,\"retail\":1.1048824951668748,\"arb\":-2.8751319398643744}, failures=0", "retain the entire selected front lot while target remains positive [positive.py.small.json]: n=160, paired={\"mean\":-4.308651662662501,\"standard_error\":1.0544810492074042,\"retail\":2.1765870329249997,\"arb\":-6.48523869557}, failures=0", "full front retention plus replenishment to target behind the rival [refill.py.small.json]: n=160, paired={\"mean\":-9.0560790309375,\"standard_error\":1.1716140184742203,\"retail\":4.030842598625624,\"arb\":-13.086921629509375}, failures=0", "quarter-target replenishment, original cancellations and twelve-step handoff [safehandoff12.py.small.json]: n=160, paired={\"mean\":-0.7225471212968757,\"standard_error\":0.9957593481863856,\"retail\":-0.37621280182687455,\"arb\":-0.34633431944812504}, failures=0", "quarter-target replenishment, original cancellations and four-step handoff [safehandoff4.py.small.json]: n=160, paired={\"mean\":-1.3440019220787505,\"standard_error\":0.3927386025411091,\"retail\":-0.041161377725626044,\"arb\":-1.302840544345625}, failures=0", "lower the two-share front threshold to 0.010001 shares only [threshold.py.small.json]: n=160, paired={\"mean\":-0.19967437573250135,\"standard_error\":0.08177541461510478,\"retail\":-0.24252291277624774,\"arb\":0.04284853703562539}, failures=0", "full front retention/replenishment plus lowering the two-share threshold [tiny.py.small.json]: n=160, paired={\"mean\":-9.247860718026875,\"standard_error\":1.2101112906357476,\"retail\":3.790654997883125,\"arb\":-13.038515715863749}, failures=0", "positive-target full retention/refill and promote existing inside-price orders [track.py.small.json]: n=160, paired={\"mean\":-7.745949124017501,\"standard_error\":2.188373856702752,\"retail\":2.5702054354887487,\"arb\":-10.316154559491874}, failures=0", "2x positive-target front cap plus numerically identical spread-2 belief optimization [cap2_fast.py.valid.json]: n=400, paired={\"mean\":1.4462238463504986,\"standard_error\":1.3343602041243912,\"retail\":0.27577367004649905,\"arb\":1.1704501762952497}, failures=0", "four equal FIFO lots plus numerically identical spread-2 belief optimization [chunks4_fast.py.valid.json]: n=400, paired={\"mean\":1.7004038142862496,\"standard_error\":1.341851072029059,\"retail\":0.41194980492799915,\"arb\":1.2884540093584997}, failures=0", "5%,15%,30%,50% FIFO lots plus numerically identical spread-2 belief optimization [geo_fast.py.valid.json]: n=400, paired={\"mean\":1.4502470343417495,\"standard_error\":1.3350540927677748,\"retail\":0.2578324278604989,\"arb\":1.1924146064844996}, failures=0", "retain safer marked orders one tick away plus exact spread-2 belief optimization [parkbase1_fast.py.valid.json]: n=400, paired={\"mean\":0.033613261719749536,\"standard_error\":0.004151103133877377,\"retail\":0.059361968947249245,\"arb\":-0.025748707228500263}, failures=0", "Additional effect of keeping front orders even when target is zero: n=160, paired={\"mean\":-3.3826498618662497,\"standard_error\":0.2585693132250201,\"retail\":1.4059292399393761,\"arb\":-4.78857910177375}", "Additional effect of full replenishment with full front retention: n=160, paired={\"mean\":-1.3647775064087497,\"standard_error\":0.49975514027069773,\"retail\":0.44832632576124914,\"arb\":-1.8131038321656252}", "Additional effect of lowering the front threshold with retention/replenishment: n=160, paired={\"mean\":-0.1917816870893742,\"standard_error\":0.08532328352507787,\"retail\":-0.24018760074249967,\"arb\":0.04840591364562518}", "Cancellation instrumentation on the first 160 spread-2 tuning runs: {\"counts\":{\"quote_changed\":19052,\"target_shrunk\":25479,\"front_below_two_share_threshold\":1545,\"target_zero\":16074},\"cancelled_price_notional\":{\"quote_changed\":128340.2864999988,\"target_shrunk\":277524.46699999867,\"target_zero\":69340.18879999999},\"runs\":160}. Cancelled price notional is exposure, not a causal edge cost; use paired ablations above for edge effects.", "Frozen experiment unseen computation was stopped before completion; no partial unseen scores are reported. {\"reason\":\"Rejected for persistent preliminary runtime regression; stopped unfinished unseen computation to reserve the hard run budget for complete baseline and returned-base checks. No partial unseen scores are used.\",\"preliminary_runs_each\":75,\"cpu_seconds\":{\"base\":112.92119804300002,\"yours\":125.616831827},\"wall_seconds\":{\"base\":582.8694429141469,\"yours\":623.1486153500155}}. Only the returned, unchanged base has complete unseen metrics in this result.", "Returned unchanged base: both labels reuse the same completed 200-run base measurement because the strategy code is byte-identical, wall={\"base\":861.7034215284511,\"yours\":861.7034215284511}, process_cpu={\"base\":285.3919762769999,\"yours\":285.3919762769999}. This is one shared measurement for identical code, not two independently measured timings. The experimental strategy was separately measured for 200 runs in that same process."], "next": "Use fresh tuning/validation windows before changing the lot partition or count. Eight equal lots gained 0.23919845718374944 on the initial 160 runs but were not selected from that noisy sample. A 2x front-size tolerance gained 0.2916365113537503 there and merits independent follow-up. Focus on retaining a small FIFO prefix while removing risky back exposure; unrestricted retention, tiny anchors, threshold lowering, and at-rival replenishment all had negative initial paired results. A queued order is behind the rival until that rival lot actually disappears; do not credit it with priority early. Do not tune against the unseen window reported here.\n Four equal lots subsequently gained 1.7004038142862496 on the 400-run validation slice (SE 1.341851072029059); this arrived after freezing graduated lots and did not change the selected code. It is a simpler follow-up, subject to a fresh unseen evaluation. Keeping an already-ahead order one safer tick away, with original size cancellations unchanged, subsequently validated at +0.033613261719749536 (SE 0.004151103133877377) on 400 runs. It was not substituted after the freeze; independently test its unseen generalization as a small, simpler alternative. The 2x front-size cap also later validated at +1.4462238463504986 (SE 1.3343602041243912) on the same 400-run slice, after the freeze. It adds no queue lots, so benchmark it as a lower-order-count alternative before spending a fresh unseen window."}