{
  "approach": "Retained the start file unchanged. Measured post-event arbitrage losses with an observational simulator copy, then tested faster belief updates and temporary exposure reductions only under self.s == 4. No candidate established a broad gain on unused choosing runs; blanket pauses sacrificed retail edge. The returned code is exactly the original artifact.",
  "blocked": null,
  "spread": 4,
  "base_mean_edge": 108.64128535876738,
  "found": [
    "Unmodified start: 200 spread-4 choosing runs, seeds in 30000..30799; diagnostic versus original engine identical in every SimulationResult field; mean edge 158.4253052193445, mean arbitrage loss 22.570226729425. Runtime Python 3.10.12.",
    "shift, lag 1: runs=200, events=9547, marked_steps=9547, loss_total=207.77269764096755, loss_per_run=1.0388634882048378, loss_per_step=0.021763140006385677; plain_steps=362366, plain_loss_total=3927.1305439880284, plain_loss_per_run=19.635652719940143, plain_loss_per_step=0.010837469696354629.",
    "shift, lag 2: runs=200, events=9547, marked_steps=9542, loss_total=160.75960352281317, loss_per_run=0.8037980176140658, loss_per_step=0.01684757949306351; plain_steps=362366, plain_loss_total=3927.1305439880284, plain_loss_per_run=19.635652719940143, plain_loss_per_step=0.010837469696354629.",
    "shift, lag 3: runs=200, events=9547, marked_steps=9534, loss_total=146.33719446545376, loss_per_run=0.7316859723272688, loss_per_step=0.015348982008123669; plain_steps=362366, plain_loss_total=3927.1305439880284, plain_loss_per_run=19.635652719940143, plain_loss_per_step=0.010837469696354629.",
    "shift, lag 4: runs=200, events=9547, marked_steps=9528, loss_total=171.67466377209425, loss_per_run=0.8583733188604712, loss_per_step=0.018017911814870884; plain_steps=362366, plain_loss_total=3927.1305439880284, plain_loss_per_run=19.635652719940143, plain_loss_per_step=0.010837469696354629.",
    "shift, lag 5: runs=200, events=9547, marked_steps=9518, loss_total=155.76626542087948, loss_per_run=0.7788313271043974, loss_per_step=0.016365440788072765; plain_steps=362366, plain_loss_total=3927.1305439880284, plain_loss_per_run=19.635652719940143, plain_loss_per_step=0.010837469696354629.",
    "shift, lag 1..5: runs=200, events=9547, marked_steps=37634, loss_total=586.9148019141849, loss_per_run=2.9345740095709245, loss_per_step=0.015595334057346354; plain_steps=362366, plain_loss_total=3927.1305439880284, plain_loss_per_run=19.635652719940143, plain_loss_per_step=0.010837469696354629.",
    "outward, lag 1: runs=200, events=8650, marked_steps=8650, loss_total=201.86312287209725, loss_per_run=1.0093156143604862, loss_per_step=0.02333677721064671; plain_steps=366091, plain_loss_total=3957.8203426594387, plain_loss_per_run=19.789101713297192, plain_loss_per_step=0.010811028795192064.",
    "outward, lag 2: runs=200, events=8650, marked_steps=8645, loss_total=141.69310163303217, loss_per_run=0.7084655081651609, loss_per_step=0.016390179483288796; plain_steps=366091, plain_loss_total=3957.8203426594387, plain_loss_per_run=19.789101713297192, plain_loss_per_step=0.010811028795192064.",
    "outward, lag 3: runs=200, events=8650, marked_steps=8637, loss_total=136.49777272417856, loss_per_run=0.6824888636208928, loss_per_step=0.01580384076926915; plain_steps=366091, plain_loss_total=3957.8203426594387, plain_loss_per_run=19.789101713297192, plain_loss_per_step=0.010811028795192064.",
    "outward, lag 4: runs=200, events=8650, marked_steps=8631, loss_total=167.6863291120644, loss_per_run=0.838431645560322, loss_per_step=0.019428377837105854; plain_steps=366091, plain_loss_total=3957.8203426594387, plain_loss_per_run=19.789101713297192, plain_loss_per_step=0.010811028795192064.",
    "outward, lag 5: runs=200, events=8650, marked_steps=8621, loss_total=153.26231406770177, loss_per_run=0.7663115703385088, loss_per_step=0.0177777884314696; plain_steps=366091, plain_loss_total=3957.8203426594387, plain_loss_per_run=19.789101713297192, plain_loss_per_step=0.010811028795192064.",
    "outward, lag 1..5: runs=200, events=8650, marked_steps=33909, loss_total=556.2250032427675, loss_per_run=2.7811250162138372, loss_per_step=0.01640346230330463; plain_steps=366091, plain_loss_total=3957.8203426594387, plain_loss_per_run=19.789101713297192, plain_loss_per_step=0.010811028795192064.",
    "probe_any, lag 1: runs=200, events=399178, marked_steps=398980, loss_total=4470.913000616888, loss_per_run=22.35456500308444, loss_per_step=0.011205857438012126; plain_steps=795, plain_loss_total=30.796841152631778, plain_loss_per_run=0.15398420576315888, plain_loss_per_step=0.03873816497186385.",
    "probe_any, lag 2: runs=200, events=399178, marked_steps=398782, loss_total=4475.420842388931, loss_per_run=22.377104211944655, loss_per_step=0.011222725304527576; plain_steps=795, plain_loss_total=30.796841152631778, plain_loss_per_run=0.15398420576315888, plain_loss_per_step=0.03873816497186385.",
    "probe_any, lag 3: runs=200, events=399178, marked_steps=398583, loss_total=4464.988077082545, loss_per_run=22.324940385412724, loss_per_step=0.011202153822625963; plain_steps=795, plain_loss_total=30.796841152631778, plain_loss_per_run=0.15398420576315888, plain_loss_per_step=0.03873816497186385.",
    "probe_any, lag 4: runs=200, events=399178, marked_steps=398384, loss_total=4462.832224124001, loss_per_run=22.314161120620007, loss_per_step=0.011202338005856604; plain_steps=795, plain_loss_total=30.796841152631778, plain_loss_per_run=0.15398420576315888, plain_loss_per_step=0.03873816497186385.",
    "probe_any, lag 5: runs=200, events=399178, marked_steps=398185, loss_total=4463.211499392863, loss_per_run=22.316057496964312, loss_per_step=0.01120888908269783; plain_steps=795, plain_loss_total=30.796841152631778, plain_loss_per_run=0.15398420576315888, plain_loss_per_step=0.03873816497186385.",
    "probe_any, lag 1..5: runs=200, events=399178, marked_steps=399205, loss_total=4483.2485047496, loss_per_run=22.416242523748, loss_per_step=0.011230441764884665; plain_steps=795, plain_loss_total=30.796841152631778, plain_loss_per_run=0.15398420576315888, plain_loss_per_step=0.03873816497186385.",
    "probe, lag 1: runs=200, events=399176, marked_steps=398978, loss_total=4470.913000616888, loss_per_run=22.35456500308444, loss_per_step=0.011205913610820843; plain_steps=801, plain_loss_total=30.796841152631778, plain_loss_per_run=0.15398420576315888, plain_loss_per_step=0.03844799145147536.",
    "probe, lag 2: runs=200, events=399176, marked_steps=398780, loss_total=4475.420842388931, loss_per_run=22.377104211944655, loss_per_step=0.011222781589824253; plain_steps=801, plain_loss_total=30.796841152631778, plain_loss_per_run=0.15398420576315888, plain_loss_per_step=0.03844799145147536.",
    "probe, lag 3: runs=200, events=399176, marked_steps=398581, loss_total=4464.988077082545, loss_per_run=22.324940385412724, loss_per_step=0.01120221003280067; plain_steps=801, plain_loss_total=30.796841152631778, plain_loss_per_run=0.15398420576315888, plain_loss_per_step=0.03844799145147536.",
    "probe, lag 4: runs=200, events=399176, marked_steps=398382, loss_total=4462.832224124001, loss_per_run=22.314161120620007, loss_per_step=0.011202394245034107; plain_steps=801, plain_loss_total=30.796841152631778, plain_loss_per_run=0.15398420576315888, plain_loss_per_step=0.03844799145147536.",
    "probe, lag 5: runs=200, events=399176, marked_steps=398183, loss_total=4463.211499392863, loss_per_run=22.316057496964312, loss_per_step=0.01120894538288685; plain_steps=801, plain_loss_total=30.796841152631778, plain_loss_per_run=0.15398420576315888, plain_loss_per_step=0.03844799145147536.",
    "probe, lag 1..5: runs=200, events=399176, marked_steps=399199, loss_total=4483.2485047496, loss_per_run=22.416242523748, loss_per_step=0.0112306105595224; plain_steps=801, plain_loss_total=30.796841152631778, plain_loss_per_run=0.15398420576315888, plain_loss_per_step=0.03844799145147536.",
    "arb, lag 1: runs=200, events=399373, marked_steps=399175, loss_total=4486.651885454027, loss_per_run=22.433259427270137, loss_per_step=0.011239811825528178; plain_steps=531, plain_loss_total=16.168253609701967, plain_loss_per_run=0.08084126804850983, plain_loss_per_step=0.03044868853051216.",
    "arb, lag 2: runs=200, events=399373, marked_steps=398977, loss_total=4485.581477203576, loss_per_run=22.42790738601788, loss_per_step=0.011242706915949394; plain_steps=531, plain_loss_total=16.168253609701967, plain_loss_per_run=0.08084126804850983, plain_loss_per_step=0.03044868853051216.",
    "arb, lag 3: runs=200, events=399373, marked_steps=398778, loss_total=4483.805175753728, loss_per_run=22.41902587876864, loss_per_step=0.011243862940670979; plain_steps=531, plain_loss_total=16.168253609701967, plain_loss_per_run=0.08084126804850983, plain_loss_per_step=0.03044868853051216.",
    "arb, lag 4: runs=200, events=399373, marked_steps=398579, loss_total=4483.411609580188, loss_per_run=22.41705804790094, loss_per_step=0.011248489282128129; plain_steps=531, plain_loss_total=16.168253609701967, plain_loss_per_run=0.08084126804850983, plain_loss_per_step=0.03044868853051216.",
    "arb, lag 5: runs=200, events=399373, marked_steps=398380, loss_total=4481.979210602224, loss_per_run=22.40989605301112, loss_per_step=0.011250512602548798; plain_steps=531, plain_loss_total=16.168253609701967, plain_loss_per_run=0.08084126804850983, plain_loss_per_step=0.03044868853051216.",
    "arb, lag 1..5: runs=200, events=399373, marked_steps=399469, loss_total=4497.877092292549, loss_per_run=22.489385461462742, loss_per_step=0.011259639902705123; plain_steps=531, plain_loss_total=16.168253609701967, plain_loss_per_run=0.08084126804850983, plain_loss_per_step=0.03044868853051216.",
    "main_arb, lag 1: runs=200, events=18774, marked_steps=18772, loss_total=757.2033893698457, loss_per_run=3.7860169468492284, loss_per_step=0.040336852193154624; plain_steps=319138, plain_loss_total=3121.699425778539, plain_loss_per_run=15.608497128892695, plain_loss_per_step=0.009781660052329883.",
    "main_arb, lag 2: runs=200, events=18774, marked_steps=18770, loss_total=327.2024742670277, loss_per_run=1.6360123713351384, loss_per_step=0.017432204276346834; plain_steps=319138, plain_loss_total=3121.699425778539, plain_loss_per_run=15.608497128892695, plain_loss_per_step=0.009781660052329883.",
    "main_arb, lag 3: runs=200, events=18774, marked_steps=18768, loss_total=348.3391837632919, loss_per_run=1.7416959188164594, loss_per_step=0.018560271939646825; plain_steps=319138, plain_loss_total=3121.699425778539, plain_loss_per_run=15.608497128892695, plain_loss_per_step=0.009781660052329883.",
    "main_arb, lag 4: runs=200, events=18774, marked_steps=18765, loss_total=383.1008750151298, loss_per_run=1.915504375075649, loss_per_step=0.020415714096196382; plain_steps=319138, plain_loss_total=3121.699425778539, plain_loss_per_run=15.608497128892695, plain_loss_per_step=0.009781660052329883.",
    "main_arb, lag 5: runs=200, events=18774, marked_steps=18763, loss_total=391.26233789593704, loss_per_run=1.9563116894796853, loss_per_step=0.0208528667002042; plain_steps=319138, plain_loss_total=3121.699425778539, plain_loss_per_run=15.608497128892695, plain_loss_per_step=0.009781660052329883.",
    "main_arb, lag 1..5: runs=200, events=18774, marked_steps=80862, loss_total=1392.3459201227101, loss_per_run=6.961729600613551, loss_per_step=0.017218791522877988; plain_steps=319138, plain_loss_total=3121.699425778539, plain_loss_per_run=15.608497128892695, plain_loss_per_step=0.009781660052329883.",
    "Events: shift=absolute change >=2 ticks in either rival quote, assigned to the move preceding first visible callback; outward=ask rises >=2 or bid falls >=2 ticks (the candidate trigger); probe_any=any actual fill of a <=0.01-share order; probe=arbitrage fill of such an order; arb=any participant arbitrage fill; main_arb=fill of a larger order. Plain means no same-category event during previous five steps. Lag windows overlap and their totals must not be added; these are descriptive, not causal effects. Almost-every-step probe fills explain the very small plain sample for probe/arb.",
    "Outward event frequency by horizon on the same 200 runs: [{\"steps_remaining_before_move\": [1, 100], \"events\": 1143, \"events_per_run\": 5.715, \"events_per_step\": 0.05715}, {\"steps_remaining_before_move\": [101, 500], \"events\": 3215, \"events_per_run\": 16.075, \"events_per_step\": 0.0401875}, {\"steps_remaining_before_move\": [501, 1000], \"events\": 2012, \"events_per_run\": 10.06, \"events_per_step\": 0.02012}, {\"steps_remaining_before_move\": [1001, 2000], \"events\": 2280, \"events_per_run\": 11.4, \"events_per_step\": 0.0114}]. Overall events per run=43.25; a raw two-tick shift is not an observed latent-jump label."
  ],
  "holdout": {
    "mean_edge": 156.84702391218806,
    "retail_edge": 183.34976581173123,
    "arb_edge": -26.502741899557513,
    "failures": 0
  },
  "diff": {
    "mean": 0.0,
    "standard_error": 0.0,
    "retail": 0.0,
    "arb": 0.0,
    "trimmed": 0.0,
    "runs_up": 0,
    "runs_down": 0
  },
  "others_identical": {
    "runs": 900,
    "identical": true
  },
  "seconds": {
    "start": 169.607766214991,
    "yours": 169.1865227050148
  },
  "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            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                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": "4bbf720ff34be09b441e84a7e0c1bf47cba036b5211c4118e44a597f941453db",
  "tried": [
    "Scorer check: official unsandboxed CLI, 600 simulations, seed-start 1000, workers 4; Python 3.10.12; mean=108.64128535876738; failures=0; wall_seconds=178.78. Supplied author mean=108.63974289615767 on Python 3.12.3; observed difference=0.001542462609705808. Exact author reproduction not claimed. Below five minutes: no run counts halved. All paired experiments use the same Python runtime and unmodified simulator commit b244530ee2a6247b5f930830eeca9dd950da0e7e.",
    "Start-file choosing baseline, all spread-4 seeds in 30000..37999: {\"total_edge\": 155.99523135870106, \"retail_edge\": 180.19596961365767, \"arb_edge\": -24.200738254963902, \"failures\": 0, \"n\": 2050}.",
    "reset_shift: Uniform posterior after an outward rival quote shift of at least two ticks; paired metrics {\"screen_200_seeds_30000_30799\": {\"mean\": -0.0696454725204976, \"standard_error\": 0.12811505284872526, \"retail\": 0.018092431353500107, \"arb\": -0.08773790387649981, \"trimmed\": -0.0019934292266649816, \"runs_up\": 85, \"runs_down\": 93, \"n\": 200}, \"screen_failures\": 0}.",
    "mix_shift: Increase the existing uniform prior component to 0.5*sd only after that shift; no constant search; paired metrics {\"screen_200_seeds_30000_30799\": {\"mean\": 0.012103105006500638, \"standard_error\": 0.09820994592845425, \"retail\": 0.09454928027149924, \"arb\": -0.08244617526949996, \"trimmed\": 0.003827809169999563, \"runs_up\": 90, \"runs_down\": 88, \"n\": 200}, \"screen_failures\": 0, \"all_choosing_30000_37999\": {\"mean\": 0.0037762488505854717, \"standard_error\": 0.024474278007899437, \"retail\": 0.029716027571512232, \"arb\": -0.025939778716682956, \"trimmed\": -0.007970252033891543, \"runs_up\": 896, \"runs_down\": 903, \"n\": 2050}, \"unused_choosing_30800_37999\": {\"mean\": 0.002876048185081129, \"standard_error\": 0.024966231686653385, \"retail\": 0.022707027279621747, \"arb\": -0.01983097908935139, \"trimmed\": -0.008721801666939854, \"runs_up\": 806, \"runs_down\": 815, \"n\": 1850}, \"extended_failures\": 0}.",
    "reset_probe: Uniform posterior after any missing probe or outward quote shift; paired metrics {\"screen_200_seeds_30000_30799\": {\"mean\": -15.370546544978998, \"standard_error\": 1.6130160958590254, \"retail\": -6.205567414862499, \"arb\": -9.164979130198, \"trimmed\": -9.214460326293333, \"runs_up\": 11, \"runs_down\": 189, \"n\": 200}, \"screen_failures\": 0}.",
    "caution_shift: For the next three callbacks after an outward shift, keep main quote ticks at least one tick from estimated probability; paired metrics {\"screen_200_seeds_30000_30799\": {\"mean\": -0.3338565076259995, \"standard_error\": 0.11267003240431665, \"retail\": -0.009037820549999314, \"arb\": -0.32481868707199996, \"trimmed\": -0.1659512142033333, \"runs_up\": 35, \"runs_down\": 123, \"n\": 200}, \"screen_failures\": 0}.",
    "caution_after: For three callbacks after an outward shift, halve main quote and stock quantities; paired metrics {\"screen_200_seeds_30000_30799\": {\"mean\": -0.021272798998498453, \"standard_error\": 0.2859568742221578, \"retail\": -1.1734228315199984, \"arb\": 1.1521500325310001, \"trimmed\": -0.32158855915499834, \"runs_up\": 83, \"runs_down\": 106, \"n\": 200}, \"screen_failures\": 0}.",
    "pause_stock: For five callbacks after downward outward shift, suppress stock orders only; paired metrics {\"screen_200_seeds_30000_30799\": {\"mean\": -0.1481549056670004, \"standard_error\": 0.11574606989109697, \"retail\": -0.15112939475599949, \"arb\": 0.0029744890880000208, \"trimmed\": -0.0005694818927778221, \"runs_up\": 12, \"runs_down\": 11, \"n\": 200}, \"screen_failures\": 0}.",
    "pause_adverse: For five callbacks after downward/upward outward shift, suppress buys/asks respectively, including stock buys; paired metrics {\"screen_200_seeds_30000_30799\": {\"mean\": -0.702976748300999, \"standard_error\": 0.305631738592559, \"retail\": -1.2632555777355001, \"arb\": 0.5602788294284999, \"trimmed\": -0.4530968556638877, \"runs_up\": 55, \"runs_down\": 131, \"n\": 200}, \"screen_failures\": 0}.",
    "reset_farprobe: Uniform posterior after outward rival shift or a probe beyond max(one tick,two old standard deviations); paired metrics {\"screen_200_seeds_30000_30799\": {\"mean\": -0.0696454725204976, \"standard_error\": 0.12811505284872526, \"retail\": 0.018092431353500107, \"arb\": -0.08773790387649981, \"trimmed\": -0.0019934292266649816, \"runs_up\": 85, \"runs_down\": 93, \"n\": 200}, \"screen_failures\": 0}.",
    "reset_excluded: Uniform posterior only when an outward shift excludes the previous posterior centre; paired metrics {\"screen_200_seeds_30000_30799\": {\"mean\": -0.0696454725204976, \"standard_error\": 0.12811505284872526, \"retail\": 0.018092431353500107, \"arb\": -0.08773790387649981, \"trimmed\": -0.0019934292266649816, \"runs_up\": 85, \"runs_down\": 93, \"n\": 200}, \"screen_failures\": 0}.",
    "latent_jump: After outward rival shift, transform the existing latent-score jump Gaussian to probability space and condition it on public bounds; paired metrics {\"screen_200_seeds_30000_30799\": {\"mean\": -0.059345021149498266, \"standard_error\": 0.132306438366182, \"retail\": 0.031141633692000372, \"arb\": -0.09048665484249992, \"trimmed\": 0.0022063892438902843, \"runs_up\": 91, \"runs_down\": 100, \"n\": 200}, \"screen_failures\": 0}.",
    "pause_fillstock: Five-callback stock replenishment pause after aggregate buy fills >0.01 and a falling estimate; aggregate trigger can include multiple probes, so not a clean main-fill signal; paired metrics {\"screen_200_seeds_30000_30799\": {\"mean\": -7.090674606193499, \"standard_error\": 3.255307683481434, \"retail\": -7.230848386427001, \"arb\": 0.14017378022800012, \"trimmed\": 0.6023540056033333, \"runs_up\": 69, \"runs_down\": 32, \"n\": 200}, \"screen_failures\": 0}.",
    "pause_mainfillstock: Five-callback stock replenishment pause after a falling estimate and buy fills exceeding the maximum quantity of all previous buy probes; ordinary main bids unchanged; paired metrics {\"screen_200_seeds_30000_30799\": {\"mean\": -0.5456601097644989, \"standard_error\": 1.050443572623097, \"retail\": -0.5949546857864989, \"arb\": 0.049294576024000336, \"trimmed\": 0.4174811854016678, \"runs_up\": 76, \"runs_down\": 19, \"n\": 200}, \"screen_failures\": 0, \"all_choosing_30000_37999\": {\"mean\": -0.30516386209112206, \"standard_error\": 0.20315467877305832, \"retail\": -0.6242162566509757, \"arb\": 0.31905239456043905, \"trimmed\": 0.3472851807313299, \"runs_up\": 666, \"runs_down\": 245, \"n\": 2050}, \"unused_choosing_30800_37999\": {\"mean\": -0.2791642677480543, \"standard_error\": 0.1945201296114721, \"retail\": -0.6273796697174056, \"arb\": 0.34821540196978373, \"trimmed\": 0.34530185015502707, \"runs_up\": 590, \"runs_down\": 226, \"n\": 1850}, \"extended_failures\": 0}.",
    "limit_fillstock: After the same adverse main-fill proxy, cap new stock purchases to the shortfall needed for one current main ask for five callbacks, rather than disabling stock purchases; paired metrics {\"screen_200_seeds_30000_30799\": {\"mean\": 0.020856707220500575, \"standard_error\": 0.295440915441368, \"retail\": -0.16777996486349978, \"arb\": 0.1886366720850003, \"trimmed\": 0.2541815131838891, \"runs_up\": 60, \"runs_down\": 15, \"n\": 200}, \"screen_failures\": 0, \"all_choosing_30000_37999\": {\"mean\": -0.002908271377122051, \"standard_error\": 0.1372858906617679, \"retail\": -0.09836444128600012, \"arb\": 0.09545616990946347, \"trimmed\": 0.38072213504458113, \"runs_up\": 522, \"runs_down\": 132, \"n\": 2050}, \"unused_choosing_30800_37999\": {\"mean\": -0.005477458252540713, \"standard_error\": 0.14875621039146997, \"retail\": -0.09086006035870285, \"arb\": 0.08538260210670273, \"trimmed\": 0.3834548543830599, \"runs_up\": 462, \"runs_down\": 117, \"n\": 1850}, \"extended_failures\": 0}.",
    "Selection fixed before reading extended comparisons: a changed file must have positive full choosing mean, positive unused choosing mean, positive unused trimmed mean, more unused runs up than down, reduced unused arbitrage losses, and positive mean in each unused half (30800..34399 and 34400..37999). Screen candidates with a negative mean and negative trimmed mean are not extended. The main-fill pause is extended despite a noisy negative 200-run mean because 76 changed runs improved versus 19 worsened and its trimmed mean is positive. No strategy constants will be tuned. A nonpositive confirmation mean, nonpositive trimmed mean, or more losses than gains triggers the unchanged-start fallback. mix_shift: {\"eligible\": false, \"criteria\": {\"full_mean_positive\": true, \"unused_mean_positive\": true, \"unused_trim_positive\": false, \"unused_more_wins\": false, \"unused_arb_improves\": false, \"both_unused_halves_positive\": false, \"no_failures\": true}, \"unused_halves_mean\": [-0.04957870038534787, 0.05647734863683098], \"unused_halves_n\": [935, 915]} pause_mainfillstock: {\"eligible\": false, \"criteria\": {\"full_mean_positive\": false, \"unused_mean_positive\": false, \"unused_trim_positive\": true, \"unused_more_wins\": true, \"unused_arb_improves\": true, \"both_unused_halves_positive\": false, \"no_failures\": true}, \"unused_halves_mean\": [-0.1953968913409628, -0.3647626250602188], \"unused_halves_n\": [935, 915]} limit_fillstock: {\"eligible\": false, \"criteria\": {\"full_mean_positive\": false, \"unused_mean_positive\": false, \"unused_trim_positive\": true, \"unused_more_wins\": true, \"unused_arb_improves\": true, \"both_unused_halves_positive\": false, \"no_failures\": true}, \"unused_halves_mean\": [-0.021929563151229445, 0.011334255496392581], \"unused_halves_n\": [935, 915]} Chosen: start. Selection uses choosing seeds only; no confirming results have been read.",
    "Frozen before confirming: start, sha256=4bbf720ff34be09b441e84a7e0c1bf47cba036b5211c4118e44a597f941453db; confirmation uses all 1937 spread-4 seeds in 90000..97999. Other-spread check compares every SimulationResult field on the first 300 seeds of each other spread from 90000 onward. Timing uses 200 spread-4 seeds from 90000 onward, serially in one Python process, one full start batch then one full returned-file batch; loading excluded. All constants were fixed per idea, with no constant grid search or seed recognition."
  ],
  "next": "Investigate the stock cap's large negative tails: it improved 462 unused runs and worsened 117, with trimmed gain 0.3834548543830599 but mean -0.005477458252540713. Measure whether those losses follow inventory depletion, uncovered asks, or cash constraints, and gate a revised cap using observable coverage and cash. For recentering, estimate jump-versus-diffusion odds from the old belief and new interval; raw two-tick outward shifts occur 43.25 times per run and become much more frequent near expiry."
}