{"approach": "Only when self.s == 2 and 0.02 < phat < 0.1, halve the placed stock/bridge acquisition bid quantity while retaining its original full-size cash budget for that step, so the cut is not immediately redeployed into other orders. Model parameters, belief calculations and other-spread blocks remain unchanged. Tick-2–4 stock/probe bids had higher direct arbitrage losses than direct retail earnings; whole-run tests include their indirect contribution to funded asks. Selected for positive mean and trimmed gains and more runs up than down on independent choosing validation, before any confirming scores were inspected.", "blocked": null, "spread": 2, "base_mean_edge": 108.63974289615767, "found": ["Unmodified start, first 300 spread-2 choosing seeds; simulator revision b244530ee2a6247b5f930830eeca9dd950da0e7e; logging left scoring intact (all returned score/error fields equal on 20 uninstrumented reruns). Price bands refer to order limit prices, not latent probability; main means client ids a/b, stock/probe means other ids. Jump metrics count steps with a positive Poisson jump count, including that step's diffusion, not a no-jump counterfactual. Retail numbers below are all retail fills of the same order category, not an ex-post subset of orders selected because a jump eventually hit them.", "BUY:01:main: mean resting shares per step=7.906519500000008; actual-jump crossed resting shares/run=4.1626; all arb filled shares/run=595.1446666666667; all arb edge/run=-0.5389509065760328; actual-jump arb edge/run=-0.02813346275196379; retail filled shares/run=125.8454666666667; retail edge/run=0.8129077413114298.", "BUY:01:stock/probe: mean resting shares per step=806.5856753666573; actual-jump crossed resting shares/run=507.8736333333333; all arb filled shares/run=3479.3827666666443; all arb edge/run=-6.124752935562551; actual-jump arb edge/run=-2.5878843077886167; retail filled shares/run=9.35693333333334; retail edge/run=0.05932733904045589.", "BUY:02-04:main: mean resting shares per step=15.773514183333326; actual-jump crossed resting shares/run=26.6025; all arb filled shares/run=1525.977266666667; all arb edge/run=-2.983737722718901; actual-jump arb edge/run=-0.29304358060228236; retail filled shares/run=300.94543333333337; retail edge/run=2.8920267065207734.", "BUY:02-04:stock/probe: mean resting shares per step=3.662411216666665; actual-jump crossed resting shares/run=7.996933333333336; all arb filled shares/run=1022.6812000000267; all arb edge/run=-2.0798616332123316; actual-jump arb edge/run=-0.12718587639571127; retail filled shares/run=76.79959999999997; retail edge/run=0.4137145278623459.", "BUY:05-09:main: mean resting shares per step=4.6214478166666675; actual-jump crossed resting shares/run=2.5349; all arb filled shares/run=222.2470666666667; all arb edge/run=-0.6356113206334719; actual-jump arb edge/run=-0.031048588193162713; retail filled shares/run=198.62519999999992; retail edge/run=2.5070340252631986.", "BUY:05-09:stock/probe: mean resting shares per step=0.48683071666667277; actual-jump crossed resting shares/run=0.49889999999999995; all arb filled shares/run=120.9741999999992; all arb edge/run=-0.30049827040406446; actual-jump arb edge/run=-0.013849451855684949; retail filled shares/run=7.453300000000002; retail edge/run=0.06452828164844641.", "BUY:10-24:main: mean resting shares per step=2.9727199500000006; actual-jump crossed resting shares/run=7.314333333333334; all arb filled shares/run=166.1170333333333; all arb edge/run=-0.937857907420108; actual-jump arb edge/run=-0.3173921605171682; retail filled shares/run=191.54486666666676; retail edge/run=2.9383671297302976.", "BUY:10-24:stock/probe: mean resting shares per step=0.0020111999999999786; actual-jump crossed resting shares/run=0.006100000000000004; all arb filled shares/run=2.459466666666638; all arb edge/run=-0.024570137556409515; actual-jump arb edge/run=-0.00040859027508972527; retail filled shares/run=0.1750666666666668; retail edge/run=0.0014381096735546727.", "BUY:25-74:main: mean resting shares per step=2.9784105499999995; actual-jump crossed resting shares/run=5.3789; all arb filled shares/run=223.98016666666638; all arb edge/run=-1.5772846723298954; actual-jump arb edge/run=-0.5689323654924454; retail filled shares/run=239.69179999999994; retail edge/run=4.184776629398926.", "BUY:25-74:stock/probe: mean resting shares per step=0.00801655000000017; actual-jump crossed resting shares/run=0.014899999999999967; all arb filled shares/run=8.985666666666532; all arb edge/run=-0.10107542504028401; actual-jump arb edge/run=-0.0019141952399815809; retail filled shares/run=0.8322666666666669; retail edge/run=0.0079998871290531.", "BUY:75-99:main: mean resting shares per step=3.6707336833333333; actual-jump crossed resting shares/run=3.2557666666666667; all arb filled shares/run=50.247166666666665; all arb edge/run=-0.4494879324100094; actual-jump arb edge/run=-0.26618024459096956; retail filled shares/run=171.25366666666656; retail edge/run=2.8994524163213344.", "BUY:75-99:stock/probe: mean resting shares per step=0.004009000000000065; actual-jump crossed resting shares/run=0.00626666666666667; all arb filled shares/run=3.3495999999999513; all arb edge/run=-0.02963980709927928; actual-jump arb edge/run=-0.0007045742973191251; retail filled shares/run=0.5096333333333335; retail edge/run=0.0037903371153721857.", "SELL:01:stock/probe: mean resting shares per step=0.0007453499999999916; actual-jump crossed resting shares/run=0.0003666666666666666; all arb filled shares/run=0.13263333333333324; all arb edge/run=-0.0006752769903881321; actual-jump arb edge/run=-3.7214578550722914e-05; retail filled shares/run=0.16566666666666685; retail edge/run=0.00129833866536543.", "SELL:02-04:main: mean resting shares per step=176.1366739833341; actual-jump crossed resting shares/run=48.99516666666666; all arb filled shares/run=582.3662; all arb edge/run=-7.527804194312919; actual-jump arb edge/run=-6.641956536447027; retail filled shares/run=4477.1568; retail edge/run=78.86516781801296.", "SELL:02-04:stock/probe: mean resting shares per step=0.0006408333333333277; actual-jump crossed resting shares/run=0.0013333333333333337; all arb filled shares/run=0.4493333333333315; all arb edge/run=-0.0027148820258530424; actual-jump arb edge/run=-6.258838263551591e-05; retail filled shares/run=0.08216666666666671; retail edge/run=0.00043860028832787545.", "SELL:05-09:main: mean resting shares per step=12.331855366666673; actual-jump crossed resting shares/run=15.022566666666664; all arb filled shares/run=238.06766666666658; all arb edge/run=-1.7357668889183295; actual-jump arb edge/run=-1.2221134491432146; retail filled shares/run=525.6615333333331; retail edge/run=8.357109597174839.", "SELL:05-09:stock/probe: mean resting shares per step=0.0007818833333333248; actual-jump crossed resting shares/run=0.0015333333333333338; all arb filled shares/run=0.7488999999999957; all arb edge/run=-0.005916335333330526; actual-jump arb edge/run=-0.00028076682916239494; retail filled shares/run=0.08023333333333335; retail edge/run=0.0004704065420254226.", "SELL:10-24:main: mean resting shares per step=4.235158733333331; actual-jump crossed resting shares/run=5.240166666666666; all arb filled shares/run=150.7652; all arb edge/run=-1.2578187638412592; actual-jump arb edge/run=-0.6532460164089225; retail filled shares/run=290.4227333333332; retail edge/run=4.849848038682708.", "SELL:10-24:stock/probe: mean resting shares per step=0.0019097499999999768; actual-jump crossed resting shares/run=0.003500000000000002; all arb filled shares/run=2.0016666666666465; all arb edge/run=-0.01953413475861698; actual-jump arb edge/run=-0.0003995610936051874; retail filled shares/run=0.2041000000000001; retail edge/run=0.0016851531053523258.", "SELL:25-74:main: mean resting shares per step=3.093409466666665; actual-jump crossed resting shares/run=4.400699999999999; all arb filled shares/run=227.62456666666665; all arb edge/run=-1.5563417918649545; actual-jump arb edge/run=-0.48809654839173655; retail filled shares/run=248.81996666666643; retail edge/run=4.435925582896875.", "SELL:25-74:stock/probe: mean resting shares per step=0.008028016666666844; actual-jump crossed resting shares/run=0.014199999999999982; all arb filled shares/run=9.0201333333332; all arb edge/run=-0.10096901167520805; actual-jump arb edge/run=-0.0018346124262495944; retail filled shares/run=0.827333333333334; retail edge/run=0.008066952779301709.", "SELL:75-99:main: mean resting shares per step=1.4810772499999998; actual-jump crossed resting shares/run=2.2873666666666668; all arb filled shares/run=79.95216666666667; all arb edge/run=-0.3300819765846585; actual-jump arb edge/run=-0.09277726008406323; retail filled shares/run=78.74696666666664; retail edge/run=1.080790279540762.", "SELL:75-99:stock/probe: mean resting shares per step=0.004948850000000138; actual-jump crossed resting shares/run=0.012233333333333334; all arb filled shares/run=7.2545000000001165; all arb edge/run=-0.07782269787616736; actual-jump arb edge/run=-0.00045562960540802345; retail filled shares/run=0.26196666666666674; retail edge/run=0.0019513452154635007.", "All measured categories: mean edge=85.98934061878633; retail edge=114.38811524391916; arb edge=-28.39877462514502; jump-step arb edge=-13.33793758139097.", "Additional frozen-file diagnostic on first 150 choosing seeds only, using the unmodified start: all 150 instrumented score/error tuples matched the earlier unmodified results. Tail means the last mathematical half of each stock order at placement, filled after its first half. Bridge means qam placed at 0.02 < phat < 0.1; reservoir means q1. This diagnostic was collected after selection and did not change the frozen strategy. Direct order edge excludes the downstream liquidation benefit of stock.", "ammo:01 last-half: mean resting tail shares per step=0.11074206666666668; jump-crossed tail shares/run=0.4; arb tail shares/run=219.75080000000003; arb tail edge/run=-1.972354447883132; jump-step arb tail edge/run=-0.003749229045033329; retail tail shares/run=0.0; retail tail edge/run=0.0.", "ammo:02-04 last-half: mean resting tail shares per step=0.0695871; jump-crossed tail shares/run=0.25939999999999996; arb tail shares/run=103.89743333333332; arb tail edge/run=-0.3065693637679875; jump-step arb tail edge/run=-0.0034738360499583067; retail tail shares/run=2.1093666666666664; retail tail edge/run=0.006018696371252485.", "bridge:02-04 last-half: mean resting tail shares per step=1.847698766666667; jump-crossed tail shares/run=6.399766666666666; arb tail shares/run=376.3878333333333; arb tail edge/run=-0.7111056903843577; jump-step arb tail edge/run=-0.0870738576704258; retail tail shares/run=36.315233333333325; retail tail edge/run=0.23709650707022797.", "bridge:05-09 last-half: mean resting tail shares per step=0.2714049166666667; jump-crossed tail shares/run=0.0322; arb tail shares/run=67.33756666666667; arb tail edge/run=-0.16256566412925094; jump-step arb tail edge/run=-0.0022090600404005957; retail tail shares/run=4.0228; retail tail edge/run=0.036526066435830284.", "reservoir:01 last-half: mean resting tail shares per step=426.8678589000003; jump-crossed tail shares/run=227.91299999999998; arb tail shares/run=1597.0430000000003; arb tail edge/run=-1.7525894159944841; jump-step arb tail edge/run=-1.0003819942691634; retail tail shares/run=4.966900000000001; retail tail edge/run=0.03750601913031108.", "The tick-1 reservoir tail lost more on jump steps than it earned directly from retail, but its tested size cuts reduced whole-run edge. The retained bridge cut targets total adverse-selection cost: its measured direct jump-step loss alone was smaller than its direct retail edge. No claim of a jump-only improvement is made."], "holdout": {"mean_edge": 83.81252303826193, "retail_edge": 109.58700673641899, "arb_edge": -25.774483698146422, "failures": 0}, "diff": {"mean": 0.21772002139284313, "standard_error": 0.10743591152605705, "retail": -0.1423511925108348, "arb": 0.36007121390656066, "trimmed": 0.11153299835223145, "runs_up": 307, "runs_down": 194}, "others_identical": {"runs": 450, "identical": true}, "seconds": {"start": 100.79984298511408, "yours": 99.02853420283645}, "code": "\"\"\"Crossing-cover base with isolated, untuned per-spread overrides stacked: each acts only in runs of its own competitor spread.\"\"\"\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 == 4:\n                # Censored compound-Poisson flow likelihood, using only our fills.\n                self.f4_exposure = [0, 0]\n                self.f4_events = [0, 0]\n                self.f4_weights = [[0.0] * 9, [0.0] * 9]\n                self.f4_means = [2.64 + i * (6.336 - 2.64) / 8 for i in range(9)]\n                # Positive aggregate flow is approximately lognormal; +0.065\n                # accounts for the occasional second arrival in a timestep.\n                self.f4_mu = [math.log(m) - 0.72 + 0.065 for m in self.f4_means]\n                self.f4_last = [None, None]\n                self.f4_rate = 0.1265\n                self.f4_mean = 4.488\n                self.f4_flow = self.f4_rate * self.f4_mean\n                self.f4_extreme = inv(1 - 1e-6)\n            if self.s == 2:\n                self.params.update(dict(W=150, ammo_pmax=0.02, fy=0.7, fu=0.25, Hu=500))\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 == 4:\n            for side, filled, bound in ((0, state.sell_filled_quantity, ca), (1, state.buy_filled_quantity, cb)):\n                last = self.f4_last[side]\n                if last is None:\n                    continue\n                tick, conv, cap, old_bound, ids = last\n                if (side == 0 and bound > old_bound + 1) or (side == 1 and bound < old_bound - 1):\n                    continue\n                # Track only the main quote, excluding probes and stock orders.\n                remaining = sum(o.remaining_quantity for o in state.own_orders if o.order_id in ids)\n                value = max(0.0, cap - remaining * conv)\n                self.f4_exposure[side] += 1\n                if value > 0.01:\n                    self.f4_events[side] += 1\n                    censored = remaining < 0.011\n                    logv = math.log(max(value, 0.01))\n                    weights = self.f4_weights[side]\n                    for i, mu4 in enumerate(self.f4_mu):\n                        z4 = (logv - mu4) / 1.2\n                        weights[i] += math.log(max(1e-12, 1.0 - cdf(z4))) if censored else -0.5 * z4 * z4\n            if state.step % 25 == 0:\n                exposure = sum(self.f4_exposure)\n                events = sum(self.f4_events)\n                event_probability = (events + 80.0 * (1.0 - math.exp(-0.1265))) / (exposure + 80.0)\n                self.f4_rate = max(0.077, min(0.176, -math.log(max(1e-6, 1.0 - event_probability))))\n                weights = [a + b for a, b in zip(*self.f4_weights)]\n                peak = max(weights)\n                weights = [math.exp(w - peak) for w in weights]\n                self.f4_mean = sum(m * w for m, w in zip(self.f4_means, weights)) / sum(weights)\n                self.f4_flow = self.f4_rate * self.f4_mean\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            if self.s == 4:\n                exp = math.exp\n                if self.bc == cs and 1.0 <= wid <= 6.0 and nb == 8 * wid:\n                    # On this stationary grid, spacing is exactly 1/8 tick.\n                    # Equal index distances therefore have bit-identical d*d*k.\n                    # Reuse exp values while retaining the original sum order.\n                    kernel = []\n                    c0 = cs[0]\n                    for ci in self.bc:\n                        d = c0 - ci\n                        d2 = d * d * k\n                        kernel.append(exp(d2) if d2 > -12.5 else 0.0)\n                    kernel = kernel[:0:-1] + kernel\n                    for i in range(nb):\n                        t = uni\n                        start = nb - 1 - i\n                        for wi, e in zip(self.bw, kernel[start:start + nb]):\n                            if e:\n                                t += wi * e\n                        ws.append(t)\n                else:\n                    previous = tuple(zip(self.bc, self.bw))\n                    for c in cs:\n                        t = uni\n                        for ci, wi in previous:\n                            d = c - ci\n                            d2 = d * d * k\n                            if d2 > -12.5:\n                                t += wi * exp(d2)\n                        ws.append(t)\n            else:\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            if self.s == 4:\n                ja = jb = 0.0\n                for p, w in jp:\n                    if x > p:\n                        ja += w * (x - p)\n                    else:\n                        jb += w * (p - x)\n            else:\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            if self.s == 4 and tail <= 1e-6:\n                return min(P['qmax'], math.exp(mu + P['sig_n'] * self.f4_extreme) / px)\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            if self.s == 4 and phat * 100 - t < P['dmin']:\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            if self.s == 4 and t - phat * 100 < P['dmin']:\n                return 0.0\n            a, b = AB(t / 100.0)\n            if t - phat * 100 < P['dmin']:\n                return 0.0\n            if self.s == 4:\n                tail = b * kA / max(self.f4_rate * a, 1e-30)\n                if a <= 0 or tail >= 1.0:\n                    return 0.0\n                return min(P['qmax'], math.exp(math.log(self.f4_mean) - 0.72 + 1.2 * (self.f4_extreme if tail <= 1e-6 else inv(1 - tail))) / (t / 100.0))\n            if self.s == 2 and phat < 0.1:\n                a = max(0.0, a - 0.0015 * (1 - min(1.0, state.yes_inventory / 3000.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            threshold = max(P['min_ahead'], 20 * 100.0 / comp) if self.s == 3 and step == -1 and 1 <= comp <= 5 else P['min_ahead']\n            if sticky and sum(o.remaining_quantity for o in orders if o.price_ticks == comp and o.order_id in self.ahead) >= threshold:\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        if self.s == 1 and ask_t == 2 and ask_t < ca and phat < 0.01:\n            qa *= 5\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            flow_scale = self.f4_flow / 0.6 if self.s == 4 else 1.0\n            target = min(flow_scale * P['ydem'] * min(H, P['W']) / x, capw)\n            full = min(flow_scale * 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 == 4:\n                stock_rate *= self.f4_flow / 0.6\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) or (self.s == 1 and (o.side is Side.SELL) and o.price_ticks <= 2 and o.order_id in self.ahead)):\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            placed_q = fl(q * 0.5) if self.s == 2 and 0.02 < phat < 0.1 else q\n            if placed_q >= 0.01:\n                out.append(PlaceOrder(side=Side.BUY, price_ticks=amt, quantity=placed_q))\n            # Keep the original cash budget: do not redeploy the cut into other orders.\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                if self.s == 2:\n                    ub = min(ub, max(0.0, free - 200 * min(1.0, H / 50.0)))\n                unc = min(unc, ub / (1 - x))\n            q = fl(min(add_a, cov + unc))\n            if q >= 0.01:\n                oid = self._oid('a')\n                out.append(PlaceOrder(side=Side.SELL, price_ticks=ask_t, quantity=q, client_order_id=oid))\n                r = max(0.0, q - cov)\n                self.res[oid] = r\n                free -= r * (1 - x) + 1e-6\n                if ask_t < ca:\n                    self.ahead.add(oid)\n\n        # probes: tiny orders that the arbitrageur removes when p crosses them\n        f = int(math.floor(ptick + 1e-9))\n        r = max(int(P['rmin']), int(math.ceil(2.0 * s * 100)))\n        self.pb = set()\n        self.pa = set()\n        if free > 1.0:\n            for t in range(f, f + r + 1):\n                if cb < t < ca and 1 <= t <= 99:\n                    out.append(PlaceOrder(side=Side.BUY, price_ticks=t, quantity=PROBE))\n                    self.pb.add(t)\n            for t in range(f + 1 - r, f + 2):\n                if cb < t < ca and 1 <= t <= 99:\n                    out.append(PlaceOrder(side=Side.SELL, price_ticks=t, quantity=PROBE))\n                    self.pa.add(t)\n        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        if self.s == 4:\n            self.f4_last = [None, None]\n            # Eligibility is decided before observing fills, so depleted quotes\n            # remain in the sample as right-censored observations.\n            for side, tick, bound, conv, distance in (\n                (0, ask_t, ca, ask_t / 100.0, ask_t / 100.0 - phat),\n                (1, bid_t, cb, max(phat, 0.05), phat - bid_t / 100.0)):\n                if distance < max(0.01, 3.0 * self.st / 100.0):\n                    continue\n                if side == 0:\n                    if not (ask_t < ca or any(o.price_ticks == ask_t and o.order_id in self.ahead for o in asks)):\n                        continue\n                    orders = asks\n                    order_side = Side.SELL\n                else:\n                    if not (bid_t > cb or any(o.price_ticks == bid_t and o.order_id in self.ahead for o in bids)):\n                        continue\n                    if (qam > 0 and amt >= bid_t) or (q1 > 0 and bid_t <= 1):\n                        continue\n                    orders = bids\n                    order_side = Side.BUY\n                tracked = {o.order_id: o.remaining_quantity for o in orders if o.order_id in kept_ids and o.price_ticks == tick}\n                tracked.update({o.client_order_id: o.quantity for o in out if o.side is order_side and o.price_ticks == tick and o.client_order_id is not None})\n                cap = sum(tracked.values()) * conv\n                if cap >= 0.5:\n                    self.f4_last[side] = (tick, conv, cap, bound, tracked)\n        return actions + out\n", "code_sha256": "1ce5f0a6183adf0ff040e084e0ed269e26360fe11cffe457df842b82f64ead56", "tried": ["Earlier-file CLI check: 600 simulations, seeds 1000..1599, workers=4, no sandbox; mean edge=108.63974289615767; failures=0; seconds=471.7632980821654. The scorer overlapped the initial 300-run logging batch; seconds are elapsed wall time including that overlap. Exceeded 300 seconds, so halved subsequent specified run counts: alternating spread-2 seeds in each 8000-seed range; 150 instead of 300 per other spread; 100 instead of 200 timing runs. Diagnostic measurement used 300 choosing runs; exploratory candidate comparison used 150.", "Exploratory stockhalf (q1 *= 0.5 before budgeting, self.s == 2 only) on first 150 spread-2 seeds in 30000..37999: {'n': 150, 'mean': -1.1265142959073329, 'se': 0.4503726120709163, 'retail': -0.25082443074066757, 'arb': -0.8756898651706656, 'trimmed': -0.10608446231692258, 'up': 21, 'down': 39, 'failures': 0}.", "Exploratory stockquarter (q1 *= 0.25 before budgeting, self.s == 2 only) on first 150 spread-2 seeds in 30000..37999: {'n': 150, 'mean': -3.4428344497760013, 'se': 1.1402112879756052, 'retail': -0.4737022507626667, 'arb': -2.969132199012665, 'trimmed': -0.16240307861615397, 'up': 28, 'down': 32, 'failures': 0}.", "Exploratory stockcap (q1 = min(q1, existing qmax=3000) before budgeting, self.s == 2 only) on first 150 spread-2 seeds in 30000..37999: {'n': 150, 'mean': -3.0112463128773332, 'se': 1.412909984927341, 'retail': -0.19388790745200046, 'arb': -2.8173584054346668, 'trimmed': 0.0006998382746162636, 'up': 15, 'down': 29, 'failures': 0}.", "Exploratory bridgehalf (qam *= 0.5 when 0.02 < phat < 0.1, self.s == 2 only) on first 150 spread-2 seeds in 30000..37999: {'n': 150, 'mean': 0.12685592357599879, 'se': 0.17197085290510122, 'retail': -0.1268353678526679, 'arb': 0.2536912914293337, 'trimmed': 0.019325858593846112, 'up': 47, 'down': 27, 'failures': 0}.", "Exploratory bidhalf (qb *= 0.5 before management, self.s == 2 only) on first 150 spread-2 seeds in 30000..37999: {'n': 150, 'mean': -2.218476999764001, 'se': 0.6353869245830679, 'retail': -3.8825634366753357, 'arb': 1.6640864369253339, 'trimmed': -1.0441179633346163, 'up': 49, 'down': 101, 'failures': 0}.", "Exploratory askhalf (qa *= 0.5 before stock calculation and management, self.s == 2 only) on first 150 spread-2 seeds in 30000..37999: {'n': 150, 'mean': -1.8662768916153345, 'se': 3.212056516193439, 'retail': -10.350786712882002, 'arb': 8.484509821299334, 'trimmed': -1.9230477482784625, 'up': 44, 'down': 106, 'failures': 0}.", "Exploratory splitbid (half main bid target at bid_t, half at bid_t-1, with separate kept quantities and conservative free-cash budget, self.s == 2 only) on first 150 spread-2 seeds in 30000..37999: {'n': 150, 'mean': -2.562244305562667, 'se': 0.5837185440854097, 'retail': -3.674373964000002, 'arb': 1.1121296584373346, 'trimmed': -1.2554112920892315, 'up': 31, 'down': 119, 'failures': 0}.", "Exploratory splitask (half main ask target at ask_t, half at ask_t+1, with separate kept quantities, coverage and reserve accounting, self.s == 2 only) on first 150 spread-2 seeds in 30000..37999: {'n': 150, 'mean': -9.181234238012667, 'se': 2.6239838111632467, 'retail': -8.502035327253333, 'arb': -0.6791989107239987, 'trimmed': -2.798679989509999, 'up': 26, 'down': 124, 'failures': 0}.", "Exploratory bridgesplit (split qam equally between amt and amt-1 when 0.02 < phat < 0.1, reserving the original full-price budget, self.s == 2 only) on first 150 spread-2 seeds in 30000..37999: {'n': 150, 'mean': 0.03571780597266747, 'se': 0.1600291023618395, 'retail': -0.16000151810800203, 'arb': 0.1957193240826671, 'trimmed': 0.020619536607692335, 'up': 46, 'down': 28, 'failures': 0}.", "Exploratory bridgereserve (halve the placed qam quantity at 0.02 < phat < 0.1 but retain its original budget, avoiding same-step redeployment, self.s == 2 only) on first 150 spread-2 seeds in 30000..37999: {'n': 150, 'mean': 0.12733362042999935, 'se': 0.17199035280792496, 'retail': -0.12770568974933436, 'arb': 0.2550393101793337, 'trimmed': 0.020154317111538575, 'up': 47, 'down': 27, 'failures': 0}.", "bridgehalf independent choosing validation, alternating spread-2 seeds from 30000..37999 excluding all first 300 measured seeds: {'n': 839, 'mean': 0.13888324164255125, 'se': 0.09899233667052078, 'retail': -0.06522269226889099, 'arb': 0.20410593390941623, 'trimmed': 0.14324661935360253, 'up': 251, 'down': 161, 'failures': 0}.", "bridgesplit independent choosing validation, alternating spread-2 seeds from 30000..37999 excluding all first 300 measured seeds: {'n': 839, 'mean': 0.15569710988557822, 'se': 0.10189075668609827, 'retail': -0.05685261264183508, 'arb': 0.21254972252586427, 'trimmed': 0.13206139381929202, 'up': 253, 'down': 159, 'failures': 0}.", "bridgereserve independent choosing validation, alternating spread-2 seeds from 30000..37999 excluding all first 300 measured seeds: {'n': 839, 'mean': 0.13569776745470852, 'se': 0.09902784107330041, 'retail': -0.06849078104850945, 'arb': 0.20418854850178808, 'trimmed': 0.1528893164659346, 'up': 251, 'down': 161, 'failures': 0}.", "Selection rule fixed before confirmation: positive mean and trimmed choosing-validation differences, more runs up than down, no failures; choose the eligible candidate with highest trimmed difference. Confirmation may only accept or reject the frozen file, using the same broad-gain criteria, never tune it.", "Frozen candidate confirming result before accept/reject: {'n': 1006, 'mean': 0.21772002139284313, 'se': 0.10743591152605705, 'retail': -0.1423511925108348, 'arb': 0.36007121390656066, 'trimmed': 0.11153299835223145, 'up': 307, 'down': 194, 'failures': 0}; accepted=True; frozen code_sha256=1ce5f0a6183adf0ff040e084e0ed269e26360fe11cffe457df842b82f64ead56.", "Frozen before confirming: code_sha256=1ce5f0a6183adf0ff040e084e0ed269e26360fe11cffe457df842b82f64ead56; confirming seeds are every other spread-2 seed in 90000..97999, n=1006. Difference uses paired per-run total edge; SE is sample SD/sqrt(n); trimmed discards 20 largest absolute paired differences. Confirming start means: total=83.59480301686908, retail=109.72935792892982, arb=-26.134554912052984", "Other-spread comparison checked all SimulationResult fields, including inventories, final wealth and fills: 450 runs; identical=True; failures=0. Timing alternates run order in a single process on seeds 90000..90099: {'start': 100.79984298511408, 'yours': 99.02853420283645, 'ratio': 0.9824274648667933, 'runs': 100, 'failures': [0, 0]}"], "next": "Measure marginal retail liquidation value of bridge stock by current YES inventory and remaining horizon. Try reducing only inventory surplus beyond near-term ask demand; preserve tick-1 stock, since naive reservoir cuts increased whole-run arbitrage loss in these choosing runs."}