{"approach": "Returned the base code byte-for-byte unchanged. Tested waiting behind the rival at tick 4, horizon and probability gates, larger and persistent positions, separate entry/exit conditions, matching stock plans, and an inventory-coverage payback gate. None demonstrated both a pilot gain and an independent tuning-validation gain before the freeze. At very low probability, existing stock bought near fair value has little purchase-edge cost; waiting for a higher sale price can forfeit retail edge without an offsetting stock-cost saving. The simulator scores trade edge, not terminal inventory profit. Calibration uses the requested unsandboxed CPython CLI, 4000 seeds starting at 4000 with four workers. Unseen metrics cover all 2035 spread-3 seeds in [60000,68000), using unmodified sample_config and SimulationEngine exactly as run_batch does, under PyPy 3.12.15. Both files were executed separately on every unseen seed; every paired total, retail, and arbitrage score matches exactly. Other-spread checks execute each file separately on the first 300 seeds per spread 1,2,4 starting at 60000. Timing seconds below are observed wall time; concurrent jobs cause measurement noise between byte-identical files. No third-party runtime dependency is required by the strategy.", "blocked": null, "spread": 3, "base_mean_edge": 98.4694596619638, "base_unseen": {"mean_edge": 118.8141454312252, "retail_edge": 149.05823988395989, "arb_edge": -30.244094452722454}, "holdout": {"mean_edge": 118.8141454312252, "retail_edge": 149.05823988395989, "arb_edge": -30.244094452722454, "failures": 0}, "diff": {"mean": 0.0, "standard_error": 0.0, "retail": 0.0, "arb": 0.0}, "others_identical": {"runs": 900, "identical": true}, "seconds": {"base": 545.5852983874502, "yours": 546.8444346502656}, "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": ["wait0: Join rival ask <=4 below 1 cent; preserve an existing lower ask; no horizon gate. Pilot: all 91 spread-3 seeds in [8000,8400); delta=-9.415210078398902, paired SE=3.094557794555045, retail=-7.0788882865989, arb=-2.3363217918010997, changed runs=18, failures=0.", "wait600: Same, 600-step entry gate with existing-order continuation. Pilot: all 91 spread-3 seeds in [8000,8400); delta=-8.676231755592308, paired SE=3.047971603361209, retail=-6.229341817864835, arb=-2.446889937728572, changed runs=17, failures=0.", "wait1000: Same, 1000-step entry gate. Pilot: all 91 spread-3 seeds in [8000,8400); delta=-8.11506684606154, paired SE=3.012710143954367, retail=-5.695402896523077, arb=-2.419663949538462, changed runs=16, failures=0.", "wait5: Extend joining through rival ask 5 below 2 cents. Pilot: all 91 spread-3 seeds in [8000,8400); delta=-20.39127431639011, paired SE=6.043329623964851, retail=-18.10778178147802, arb=-2.283492534875825, changed runs=24, failures=0.", "deep1: Explicit move below estimated probability .003, size 1x, 600-step gate. Pilot: all 91 spread-3 seeds in [8000,8400); delta=-9.71115338236044, paired SE=3.400193222634588, retail=-7.3029119858219795, arb=-2.4082413965439575, changed runs=14, failures=0.", "deep3: Same, size 3x. Pilot: all 91 spread-3 seeds in [8000,8400); delta=-19.174100560342858, paired SE=11.255302488480716, retail=-8.347518030692308, arb=-10.82658252966044, changed runs=16, failures=0.", "deep6: Same, size 6x. Pilot: all 91 spread-3 seeds in [8000,8400); delta=-17.026825743465935, paired SE=11.230787924363252, retail=-6.226355371458242, arb=-10.800470372015385, changed runs=18, failures=0.", "deep10: Estimated probability below .001, size 10x, existing-order continuation. Pilot: all 91 spread-3 seeds in [8000,8400); delta=3.791605714311672e-05, paired SE=1.7025428513103823e-05, retail=-1.040383516460729e-06, arb=3.8956440659382245e-05, changed runs=6, failures=0.", "hyst: Tick-4 seat, entry p<.003/H>600, continuation p<.015/cb<=1 while seat survives. Pilot: all 91 spread-3 seeds in [8000,8400); delta=-3.1221190992230765, paired SE=1.4212154767480598, retail=-3.216351749706594, arb=0.09423265047802187, changed runs=5, failures=0.", "hystwide: Same, entry p<.01. Pilot: all 91 spread-3 seeds in [8000,8400); delta=-3.67720946368791, paired SE=1.362736824795212, retail=-3.8463656110901128, arb=0.16915614741868118, changed runs=8, failures=0.", "hyststock: Same plus planned stock purchases. Pilot: all 91 spread-3 seeds in [8000,8400); delta=-3.8922909096252725, paired SE=1.4154796777590182, retail=-3.8463285239758265, arb=-0.045962385630769355, changed runs=8, failures=0.", "hystowned: Same, require existing YES>10000 to enter. Pilot: all 91 spread-3 seeds in [8000,8400); delta=-3.67720946368791, paired SE=1.362736824795212, retail=-3.8463656110901128, arb=0.16915614741868118, changed runs=8, failures=0.", "plan4: Stock-only control: initial tick-1 stock plan uses future ask 4 instead of 3. Pilot: all 91 spread-3 seeds in [8000,8400); delta=-0.9353813980758217, paired SE=1.1645229238446724, retail=-0.3721633854648341, arb=-0.5632180126142861, changed runs=24, failures=0.", "planhyst: 4-cent stock plan plus separate entry/exit queue conditions. Pilot: all 91 spread-3 seeds in [8000,8400); delta=-2.9448837539549415, paired SE=1.2163862114235098, retail=-3.761117723130768, arb=0.8162339691945051, changed runs=25, failures=0.", "planstock: Same plus stock replenishment while waiting. Pilot: all 91 spread-3 seeds in [8000,8400); delta=-3.3024620799560394, paired SE=1.3022972387483984, retail=-3.761080636016482, arb=0.45861855608021945, changed runs=25, failures=0.", "planstay: 4-cent stock plan plus simple latched entry. Pilot: all 91 spread-3 seeds in [8000,8400); delta=-10.94739336568791, paired SE=5.176774239489008, retail=-11.38686339399011, arb=0.43947002829999954, changed runs=25, failures=0.", "scarce: Enter only if H>640+.05Y; estimate 80-step lot wait, retain seat, stock for remaining demand. Pilot: all 91 spread-3 seeds in [8000,8400); delta=0.0, paired SE=0.0, retail=0.0, arb=0.0, changed runs=0, failures=0.", "scarcefast: Same, H>320+.05Y. Pilot: all 91 spread-3 seeds in [8000,8400); delta=-0.482281543424176, paired SE=0.482281543424176, retail=-0.2377262859098899, arb=-0.24455525750549448, changed runs=1, failures=0.", "stay3: Latch tick-4 queue through rival turnover, entry p<.003/H>600, size 3x. Pilot: all 91 spread-3 seeds in [8000,8400); delta=-3.827244482181318, paired SE=1.8272213010206428, retail=-3.9357909423329684, arb=0.10854646014725257, changed runs=5, failures=0.", "stay6: Same, size 6x. Pilot: all 91 spread-3 seeds in [8000,8400); delta=-3.833052981341757, paired SE=1.8291360685602895, retail=-3.933327202103298, arb=0.10027422075714267, changed runs=5, failures=0.", "stay6wide: Same, entry p<.01. Pilot: all 91 spread-3 seeds in [8000,8400); delta=-11.436361227206595, paired SE=5.271771855106132, retail=-11.395310997521978, arb=-0.041050229687912276, changed runs=7, failures=0.", "stay6late: Same, entry H>200. Pilot: all 91 spread-3 seeds in [8000,8400); delta=-14.404169390984615, paired SE=4.493386286268943, retail=-14.135281617986815, arb=-0.26888777303186834, changed runs=16, failures=0.", "stock6: Latched size 6x plus stock target min(18000,.6H/.04), buys up to 400 per step. Pilot: all 91 spread-3 seeds in [8000,8400); delta=-4.338607804697801, paired SE=2.052708952902283, retail=-3.933327202103298, arb=-0.4052806025989013, changed runs=5, failures=0.", "stock6early: Same, entry H>1000. Pilot: all 91 spread-3 seeds in [8000,8400); delta=0.0, paired SE=0.0, retail=0.0, arb=0.0, changed runs=0, failures=0.", "stock6wide: Same, entry p<.01. Pilot: all 91 spread-3 seeds in [8000,8400); delta=-9.959718878745056, paired SE=4.856346261433193, retail=-9.967081237613188, arb=0.007362358876923009, changed runs=7, failures=0.", "stock3: Same, size/stock cap 9000. Pilot: all 91 spread-3 seeds in [8000,8400); delta=-4.03761073382857, paired SE=1.906653467846906, retail=-3.933327202103298, arb=-0.10428353172967056, changed runs=5, failures=0.", "wait0s: Move explicitly to rival ask <=4; no horizon gate. Pilot: all 91 spread-3 seeds in [8000,8400); delta=-49.43655493629011, paired SE=12.924446894797992, retail=-46.9520995494011, arb=-2.484455386882418, changed runs=33, failures=0.", "wait600s: Explicit move, 600-step gate with existing-order continuation. Pilot: all 91 spread-3 seeds in [8000,8400); delta=-14.507330325863737, paired SE=5.423425247389381, retail=-12.078280228225276, arb=-2.4290500976340663, changed runs=17, failures=0.", "wait1000s: Explicit move, 1000-step gate. Pilot: all 91 spread-3 seeds in [8000,8400); delta=-8.11506684606154, paired SE=3.012710143954367, retail=-5.695402896523077, arb=-2.419663949538462, changed runs=16, failures=0.", "wait5s: Explicit move through rival ask 5. Pilot: all 91 spread-3 seeds in [8000,8400); delta=-31.308080632578022, paired SE=9.82150483672604, retail=-28.914065964286813, arb=-2.3940146682835173, changed runs=25, failures=0.", "Independent tuning validation scarce, first 200 spread-3 seeds from [8400,16000), actual seed range 8401..9216, n=200: delta=0.0, paired SE=0.0, retail=0.0, arb=0.0, failures=0.", "Independent tuning validation deep10, first 200 spread-3 seeds from [8400,16000), actual seed range 8401..9216, n=200: delta=-0.13011597082949944, paired SE=0.1643530346119617, retail=-0.130205989562, arb=9.001873299989249e-05, failures=0.", "Diagnostic tuning seed 8099: first-generation existing-order continuation bypassed the intended early-entry gate; deep6 total edge=-1486.3274336259, base=-480.5015303879, extra arbitrage edge=-1005.825903238. A near-expiry jump swept added tick-4 asks. Later latched variants removed this accidental late entry.", "All scored simulations use the default 2000 steps and unsandboxed SimulationEngine. Exploratory validation was stopped after 200 completed pairs per candidate to reserve time for the required final checks; no unseen candidate score informed the freeze.", "CPython 3.12.3 and PyPy 3.12.15 produced exactly equal total, retail, and arbitrage edge in all 91 pilot baseline runs. Inventory averages and initial_probability differed in final floating-point bits across runtimes; all paired strategy comparisons use the same runtime.", "Timing: PyPy 3.12.15, one process, six paired warmups then 200 runs per file, alternating order by seed; CPU seconds base=111.59926011299997, returned=111.9553558860001; wall seconds base=545.5852983874502, returned=546.8444346502656. Other simulation jobs ran concurrently; identical source has identical algorithmic cost.", "Frozen source SHA256=dcf68e0c9a7b06f90cf70a833357b60e2208b5b3e2971e7dddf02986d4747076. Returned code is byte-for-byte base, so separate executions on all 2035 unseen spread-3 seeds have identical total, retail, and arbitrage scores; paired differences are exactly zero. Separate executions on 900 other-spread runs matched every SimulationResult field."], "next": "Estimate remaining rival-lot depth rather than paying for a fresh whole-lot wait. Gate entry on incremental stock actually needed after current inventory is sold, and preserve a surviving front tranche independently of any replenishment behind it. Keep a control for stock-plan changes: the 4-cent plan alone lost in this pilot. Do not treat a tiny probe-only gain as evidence for bulk queue entry. Another untested direction is mirrored bid-side waiting above 95 cents, gated by available cash and remaining horizon."}