{"approach": "Returned the base code unchanged. Rejected the frozen whole-lot lifetime valuation because nonpositive reserved-tuning gain, experimental unseen batch stopped after the reserved gate failed. The returned code was independently replayed on every unseen seed and matched the baseline; experimental differences are reported in tried. Experimental mechanism: A front lot cannot be reduced without losing FIFO priority. Only for self.s == 2, when the ordinary size rule would cancel a main order still ahead at the rival best tick, value every remaining share over its remaining life. Approximate share-q retail-before-crossing survival by rho/(rho+h)*exp(-h*q/rate); h combines diffusion distance in latent-score space and the base jump mixture. Crossing cost is the one-step option loss divided by h; integrate value over the lot after our earlier retained quantity, truncate reachable flow at the remaining horizon, and charge crossing exposure on unreachable shares. Keep the indivisible lot only when total value is positive. H<100 retains the original settlement behavior. The initial quote rule and 3000-share placement cap remain the base's. Run-specific flow uses the supplied guarded/clipped-fill estimator already used by the base at spread 3; its new use is confined to spread 2. Reusing immutable prior belief pairs changes no float operation order; 60 full-result comparisons verified this optimization. Simulator commit b244530ee2a6247b5f930830eeca9dd950da0e7e; default 2000 steps; standard library; no sandbox. Screened the first 240 spread-2 seeds in 8000..9031 and 51 additional completed development runs beginning at 10000. Fixed model parameters before the first 250 reserved spread-2 seeds in 12000..15999. Experimental code SHA 48af77a87843087a6a6ac40a60f7d1b07d3eb3fb0baa6ced3197d5d9f042e395 frozen at 2026-11-06T07:20:48.316400+00:00 before any candidate unseen scoring. The returned unchanged base is independently replayed on all 1987 spread-2 seeds in 60000..67999 and compared seed by seed to the separate baseline batch. The rejected experiment was stopped after its reserved gate failed; only its completed unseen runs are reported as diagnostics, with no claim of a full experimental holdout. Other-spread check independently runs the returned file and baseline, comparing every SimulationResult field on 300 seeds each of spreads 1,3,4 from 60000. Timings alternate execution order on the same 200 spread-2 seeds from 60000 in one process, after one warmup per strategy, excluding configuration sampling and loading. Timing ran alongside independent checks; both timed factories use the identical returned base code.", "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": 1118.44346037379, "yours": 1114.0341465319507}, "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": ["64-step aggregate-demand sizing, both sides, 12000 cap, no settlement guard; completed development N=120, paired differences={\"mean\": -3.102659194689168, \"standard_error\": 2.6835178170011367, \"retail\": 2.3362642239841676, \"arb\": -5.438923418656666}, failures=0", "64-step aggregate-demand sizing, H>=100, full option-risk charge; completed development N=160, paired differences={\"mean\": 0.18530394060562266, \"standard_error\": 0.3870624743565084, \"retail\": 0.5519713659437497, \"arb\": -0.3666674253293746}, failures=0", "256-step extension of low-priced asks, 12000 cap; completed development N=160, paired differences={\"mean\": -0.6095961583712504, \"standard_error\": 1.277108112794546, \"retail\": 0.9792350232500002, \"arb\": -1.5888311816149998}, failures=0", "Replace one-step low-ask quantity with 1024-step quantity; completed development N=240, paired differences={\"mean\": -1.075265428292083, \"standard_error\": 1.084906735861858, \"retail\": -1.1058906477633337, \"arb\": 0.030625219484166723}, failures=0", "1024-step extension only at asks >=3 where a rival front is possible; completed development N=240, paired differences={\"mean\": -1.4721639610116666, \"standard_error\": 1.2284375070271483, \"retail\": 0.029172025702083104, \"arb\": -1.5013359867137495}, failures=0", "Add observed guarded flow to the preceding lifetime size rule; completed development N=240, paired differences={\"mean\": 0.16364840962708324, \"standard_error\": 0.5570926055697772, \"retail\": 0.33180676925833413, \"arb\": -0.1681583596316665}, failures=0", "Explicit exponential retail-before-crossing marginal-share model; completed development N=240, paired differences={\"mean\": -0.06378385711749981, \"standard_error\": 0.8754985600513748, \"retail\": -0.11575889104541727, \"arb\": 0.05197503393041681}, failures=0", "Same crossing model without the 12000 quantity cap; completed development N=160, paired differences={\"mean\": 0.07917118937937531, \"standard_error\": 1.1162478933242082, \"retail\": -0.05040352005625026, \"arb\": 0.12957470944250032}, failures=0", "Include waiting for the first retail arrival in crossing survival; completed development N=240, paired differences={\"mean\": -0.4974158255333332, \"standard_error\": 1.3598374797617114, \"retail\": -0.4443840794441675, \"arb\": -0.053031746082916296}, failures=0", "Tick-3 full-horizon demand weighted by margin and crossing option loss; completed development N=240, paired differences={\"mean\": -0.9659011848266663, \"standard_error\": 0.5207812368384782, \"retail\": -0.024151737505833756, \"arb\": -0.9417494473166665}, failures=0", "Tick-3 aggregate-demand quantile against terminal crossing cost; completed development N=240, paired differences={\"mean\": -13.842504021232916, \"standard_error\": 7.257290132466621, \"retail\": 1.2979255829262495, \"arb\": -15.140429604167917}, failures=0", "Restrict floor-margin enlargement to p<0.015 or an established front; completed development N=240, paired differences={\"mean\": 0.054738743319583234, \"standard_error\": 0.054738743319583234, \"retail\": 0.022675926093749865, \"arb\": 0.03206281722625001}, failures=0", "Apply the same seat restriction to the exponential crossing model; completed development N=240, paired differences={\"mean\": -0.03415691812541648, \"standard_error\": 0.0983380868477409, \"retail\": -0.015749740344583547, \"arb\": -0.018407177779166665}, failures=0", "16-step demand horizon, observed flow, both sides, 3000 cap; completed development N=240, paired differences={\"mean\": -0.07044370090791692, \"standard_error\": 0.08837190339609756, \"retail\": 0.09539252092375035, \"arb\": -0.1658362218270833}, failures=0", "64-step tick-3 sizing, original low-price risk charge, 3000 cap; completed development N=240, paired differences={\"mean\": -0.6938302172337494, \"standard_error\": 0.463574715561571, \"retail\": -0.007739987217500636, \"arb\": -0.686090230014583}, failures=0", "Whole-lot retention before correcting for our earlier quantity; completed development N=151, paired differences={\"mean\": 0.2771035258019867, \"standard_error\": 0.11041067644963884, \"retail\": 0.22036806283973423, \"arb\": 0.05673546296225152}, failures=0", "Whole-lot retention including our own queue ahead (frozen model); completed development N=240, paired differences={\"mean\": 0.11291654295708385, \"standard_error\": 0.06593060191592721, \"retail\": 0.1346750059554158, \"arb\": -0.021758463000833502}, failures=0", "Mandatory baseline CLI: 4000 simulations, seeds 4000..7999, workers=4, no sandbox; measured mean_edge=98.4694596619638, failures=0", "Separate completed development segment for frozen model, N=51, differences={\"mean\": 0.12657479118431578, \"standard_error\": 0.07790951635858016, \"retail\": 0.11075079535293901, \"arb\": 0.01582399581960765}", "Reserved tuning, frozen model N=250: {\"mean\": -0.012926293316400656, \"standard_error\": 0.11918642506252958, \"retail\": -0.04436873920600023, \"arb\": 0.03144244588639983}", "Reserved tuning, fixed aggregate-flow sizing alternative N=250: {\"mean\": -2.3878554523384015, \"standard_error\": 3.303236996697053, \"retail\": 0.6177257465083993, \"arb\": -3.005581198847601}", "Rejected experiment completed unseen diagnostics N=151: {\"base\": {\"mean_edge\": 75.37891657984132, \"retail_edge\": 102.41461084785999, \"arb_edge\": -27.035694268030902}, \"frozen\": {\"mean_edge\": 58.26723086632451, \"retail_edge\": 75.49291609025231, \"arb_edge\": -17.22568522392781}, \"diff\": {\"mean\": 0.02191544778344278, \"standard_error\": 0.015395196213229826, \"retail\": 0.03752876478211894, \"arb\": -0.01561331699403984}, \"failures\": 0}", "Front-position diagnostics for the rejected experimental rule on the same first 120 development runs. The returned unchanged code has identical before/after values to the baseline. A position is a main order initially placed strictly ahead and later observed sharing the rival best tick; edge covers its whole fill history. Before={\"runs\": 120, \"orders\": 19011, \"shares_per_order\": 34.962053021934665, \"entry_shares_per_order\": 32.849529745936564, \"filled_per_order\": 10.559372468570828, \"edge_per_order\": 0.1664547036164679, \"retail_per_order\": 0.18398364549250773, \"arb_per_order\": -0.017528941876039834}; after={\"runs\": 120, \"orders\": 18980, \"shares_per_order\": 34.99481401475237, \"entry_shares_per_order\": 32.87982349841939, \"filled_per_order\": 10.803210221285564, \"edge_per_order\": 0.17147052316144248, \"retail_per_order\": 0.1890706192524391, \"arb_per_order\": -0.017600096090996605}", "Pure optimizations: 30 full-result comparisons for crossing/terminal models, 60 original-vs-optimized flow comparisons, then 60 original-vs-cached comparisons; all identical, no failures.", "Final unchanged-base 200-pair wall timing: {\"base\": 1118.44346037379, \"yours\": 1114.0341465319507}"], "next": "Replace the mean-flow exponential fill kernel with compound-Poisson/lognormal queue-tail survival, retaining the whole-lot valuation and accounting for our earlier orders at the tick. Test initial size increases only after this retention rule is established; broad early size increases lost to jumps."}