{
  "approach": "Returned the base code byte-for-byte. Lifetime sizing did not demonstrate a reliable tuning improvement, so no changed strategy is submitted. Tests valued a marginal share by retail-flow survival until its fill versus diffusion/jump crossing loss, using remaining time and the base probability filter; variants included continuous Gaussian jump tails, censored per-run flow learning, queue-capture windows, rival-replenishable ticks, a one-tick priority premium, and two tranches to preserve the front when size shrinks. Definitions: life1/fast use one-step loss-to-gain residence targets; value uses conditional overshoot; tail uses continuous latent jump tails; front preserves existing seats only; exact replaces rather than floors at ordinary size; high/low restrict probability regions; safe requires gap>3 posterior SD; narrow requires competitor gap<=5; eligible excludes unreplenishable asks<5 and bids>95; flow learns exposed sell notional with a prior. Selection used only spread-four tuning seeds in 8000..15999, with separate validation in 9000..10999. Unseen replay uses every spread-four seed in 60000..67999, n=2009. The other-spread check compares every SimulationResult field over 300 seeds per spread. Seconds are elapsed time for 200 paired simulations in one process, balanced strategy-order permutations. Final front shares and edge per position equal the base diagnostic above because the submitted code is unchanged. Simulator commit b244530ee2a6247b5f930830eeca9dd950da0e7e; default 2000-step simulations; standard-library Python; no sandbox. CLI scorer check uses 4000 simulations, seeds 4000..7999, workers=4. Timing uses 200 simulations each over seeds 60000..60199 in one process; strategy loading and configuration sampling are excluded. Method: elapsed engine construction+run, one process, balanced permutations of three strategies, one warmup each. The returned files are byte-identical strategies; differences between their timing samples are measurement variation, not a claimed strategy improvement.",
  "blocked": null,
  "spread": 4,
  "base_mean_edge": 98.4694596619638,
  "base_unseen": {
    "mean_edge": 163.47813945343543,
    "retail_edge": 191.20763318061364,
    "arb_edge": -27.729493727194825
  },
  "holdout": {
    "mean_edge": 163.47813945343543,
    "retail_edge": 191.20763318061364,
    "arb_edge": -27.729493727194825,
    "failures": 0
  },
  "diff": {
    "mean": 0.0,
    "standard_error": 0.0,
    "retail": 0.0,
    "arb": 0.0
  },
  "others_identical": {
    "runs": 900,
    "identical": true
  },
  "seconds": {
    "base": 595.4729134468362,
    "yours": 575.7384612760507
  },
  "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": [
    "eligiblefast1 (same replenishable-tick rule at scale 1): tuning seeds 8000_16000, spread 4, n=200, paired mean=-8.970933453224502, SE=5.237620658204073, retail=4.154451558718999, arb=-13.125385011932499, failures=0.",
    "eligiblefast (scale-0.25 reserve only for replenishable asks>=5 and bids<=95): tuning seeds 8000_16000, spread 4, n=200, paired mean=-0.11583157877350146, SE=1.4613911573831713, retail=2.144321010148999, arb=-2.260152588923, failures=0.",
    "eligibleflow (replenishable-tick scale-0.25 reserve with guarded clipped-fill-corrected per-run flow learning): tuning seeds 8000_16000, spread 4, n=200, paired mean=0.11985205611449955, SE=1.5718811016965868, retail=2.375070419571999, arb=-2.2552183634635, failures=0.",
    "eligibleflowopt (replenishable-tick scale-0.25 reserve with guarded clipped-fill-corrected per-run flow learning; exact arithmetic optimization): tuning seeds 8000_16000, spread 4, n=40, paired mean=2.583890574892502, SE=2.016262056502265, retail=2.3474434647024984, arb=0.23644711017749948, failures=0.",
    "eligiblevalue (overshoot valuation only at replenishable ticks): tuning seeds 8000_16000, spread 4, n=200, paired mean=-0.5420966563009995, SE=1.2915790693756368, retail=1.4414147464869966, arb=-1.9835114027925003, failures=0.",
    "fast01 (same reserve, scale 0.05): tuning seeds 8000_16000, spread 4, n=200, paired mean=-0.07116983341350096, SE=0.21961213169104635, retail=0.056685712672500055, arb=-0.12785554609000002, failures=0.",
    "fast1 (loss/gap hazard lifetime reserve, scale 1): tuning seeds 8000_16000, spread 4, n=200, paired mean=-29.276638738018995, SE=14.308181775272741, retail=4.344381919947998, arb=-33.6210206579655, failures=0.",
    "fast2 (same reserve, scale 0.25): tuning seeds 8000_16000, spread 4, n=200, paired mean=-9.354589902099502, SE=6.353506408554484, retail=2.2301189416894998, arb=-11.584708843793, failures=0.",
    "front1 (scale-1 reserve only at existing rival front): tuning seeds 8000_16000, spread 4, n=200, paired mean=-2.7152403590065006, SE=0.6784767715843286, retail=0.46809546366049903, arb=-3.1833358226654997, failures=0.",
    "highfast (scale-0.25 reserve above probability 0.05): tuning seeds 8000_16000, spread 4, n=200, paired mean=-0.057249068750501404, SE=0.5845944624728496, retail=0.967554871552498, arb=-1.0248039403044995, failures=0.",
    "hightail (continuous-tail reserve above probability 0.05): tuning seeds 8000_16000, spread 4, n=200, paired mean=-1.1563537056610003, SE=1.385666000483477, retail=0.5874459415574997, arb=-1.7437996472234998, failures=0.",
    "highvalue (overshoot reserve above probability 0.05): tuning seeds 8000_16000, spread 4, n=200, paired mean=-0.0020644010304990256, SE=0.6159787702255597, retail=1.1332292157614985, arb=-1.1352936167994998, failures=0.",
    "life1 (discrete-jump first-passage lifetime target, scale 1, 20000-share cap): tuning seeds 8000_16000, spread 4, n=200, paired mean=-27.0739053079435, SE=12.670420978078699, retail=3.579839889386499, arb=-30.653745197321, failures=0.",
    "low1 (scale-1 reserve only below probability 0.1): tuning seeds 8000_16000, spread 4, n=200, paired mean=-27.084389458997997, SE=14.26396126451206, retail=3.4568129883134997, arb=-30.541202447322497, failures=0.",
    "lowfront1 (same front-only reserve below probability 0.1): tuning seeds 8000_16000, spread 4, n=200, paired mean=-2.7185530927685, SE=0.6780659058839181, retail=0.4646161126984984, arb=-3.1831692054649996, failures=0.",
    "narrowfast (scale-0.25 reserve only at competitor quote gap<=5 ticks): tuning seeds 8000_16000, spread 4, n=200, paired mean=-9.354452006123001, SE=6.3535074302167756, retail=2.2301189416894998, arb=-11.5845709478165, failures=0.",
    "narrowtail (continuous-tail reserve at quote gap<=5): tuning seeds 8000_16000, spread 4, n=200, paired mean=-1.2387974192825013, SE=1.4482255219876954, retail=0.620390320219999, arb=-1.8591877395114997, failures=0.",
    "narrowvalue (overshoot reserve at quote gap<=5): tuning seeds 8000_16000, spread 4, n=200, paired mean=-0.9900782346484996, SE=1.3164230267186905, retail=1.4730667604014966, arb=-2.4631449950519997, failures=0.",
    "premium (continuous-tail target values only the one-tick queue-priority premium): tuning seeds 8000_16000, spread 4, n=200, paired mean=-0.20823797197199873, SE=0.32286240151987783, retail=0.04900686425400007, arb=-0.2572448362229994, failures=0.",
    "premiumflow (one-tick premium with per-run flow learning): tuning seeds 8000_16000, spread 4, n=200, paired mean=-0.24495053087700078, SE=0.31692930653451995, retail=0.02013618830449955, arb=-0.2650867191849997, failures=0.",
    "premiumnarrow (one-tick premium restricted to quote gap<=5): tuning seeds 8000_16000, spread 4, n=200, paired mean=-1.2363632234904989, SE=1.341291601794871, retail=0.044870679122000184, arb=-1.2812339026079993, failures=0.",
    "premiumsplit (one-tick premium with core/reserve tranches): tuning seeds 8000_16000, spread 4, n=200, paired mean=-0.20838289980899968, SE=0.32286367963495266, retail=0.04922753954399996, arb=-0.2576104393474994, failures=0.",
    "safefast (scale-0.25 reserve, gap>3 posterior SD and uncertainty-adjusted diffusion): tuning seeds 8000_16000, spread 4, n=200, paired mean=-4.209326263939501, SE=3.3384283155978416, retail=0.741097000405, arb=-4.9504232643465, failures=0.",
    "safetail (same safety gate with continuous-tail valuation): tuning seeds 8000_16000, spread 4, n=200, paired mean=-0.05579673362999994, SE=0.6905613457503084, retail=0.6058516982104989, arb=-0.6616484318340001, failures=0.",
    "safevalue (same safety gate with overshoot valuation): tuning seeds 8000_16000, spread 4, n=200, paired mean=-0.7901920886509994, SE=0.8692409767961822, retail=0.5480573068915008, arb=-1.3382493955544998, failures=0.",
    "tail025 (same continuous tail, scale 0.25): tuning seeds 8000_16000, spread 4, n=200, paired mean=0.033051733992000024, SE=0.032590446400003775, retail=0.03229142192299992, arb=0.0007603120680000974, failures=0.",
    "tail025opt (same continuous tail, scale 0.25; exact arithmetic optimization): tuning seeds 8000_16000, spread 4, n=40, paired mean=0.0024205577850009872, SE=0.002584280649933144, retail=-0.0016266660350002127, arb=0.0040472238150002175, failures=0.",
    "tail1 (continuous Gaussian latent jump tail, sigma 0.6, scale 1): tuning seeds 8000_16000, spread 4, n=200, paired mean=-1.2387577962230012, SE=1.448177257599763, retail=0.6261834855669989, arb=-1.8649412817999995, failures=0.",
    "tail_at (replace ordinary target only at existing rival front): tuning seeds 8000_16000, spread 4, n=200, paired mean=-6.358922670304001, SE=1.4657671621407, retail=-4.861645861560001, arb=-1.4972768087489998, failures=0.",
    "tail_exact (replace ordinary target with continuous-tail target everywhere): tuning seeds 8000_16000, spread 4, n=200, paired mean=-12.739364325515501, SE=2.630472291779543, retail=-22.338972604855, arb=9.5996082793735, failures=0.",
    "tail_low (replace ordinary target with continuous-tail target only for asks below probability 0.05): tuning seeds 8000_16000, spread 4, n=200, paired mean=-4.502212694104002, SE=2.075634915156972, retail=-7.054504512454, arb=2.5522918183645, failures=0.",
    "tail_lowhalf (low-ask replacement target at scale 0.25): tuning seeds 8000_16000, spread 4, n=200, paired mean=-19.887314247182502, SE=4.734307277376333, retail=-25.153799456040502, arb=5.266485208881001, failures=0.",
    "tailflow (low-ask replacement target with guarded clipped-fill-corrected per-run flow learning): tuning seeds 8000_16000, spread 4, n=200, paired mean=-2.093654807035, SE=4.0063408331931525, retail=-7.173253862113, arb=5.079599055088, failures=0.",
    "tailfront (continuous tail only at existing front): tuning seeds 8000_16000, spread 4, n=200, paired mean=-0.40422047723550136, SE=0.5555259255228817, retail=0.31377445226149847, arb=-0.7179949295014998, failures=0.",
    "tailsplit (continuous-tail reserve split into original one-step core plus lifetime tranche): tuning seeds 8000_16000, spread 4, n=200, paired mean=-1.2553697913240012, SE=1.445759682504231, retail=0.6300845403674983, arb=-1.8854543316979997, failures=0.",
    "value1 (conditional-overshoot marginal survival valuation, scale 1): tuning seeds 8000_16000, spread 4, n=200, paired mean=-0.9943835214564999, SE=1.3162823142482227, retail=1.4775375299444968, arb=-2.4719210514045, failures=0.",
    "value3 (same valuation, scale 3): tuning seeds 8000_16000, spread 4, n=200, paired mean=-12.931868635470003, SE=5.27053982690322, retail=3.930716028308498, arb=-16.862584663768, failures=0.",
    "valueflow (overshoot reserve with per-run flow learning): tuning seeds 8000_16000, spread 4, n=200, paired mean=-1.3543223816400003, SE=1.4932328569855189, retail=1.3727183941629995, arb=-2.7270407758139994, failures=0.",
    "valuefront (same valuation only at existing front): tuning seeds 8000_16000, spread 4, n=200, paired mean=-0.6397946642645005, SE=0.5942964334322326, retail=0.45920896089899815, arb=-1.0990036251654995, failures=0.",
    "eligiblefast (scale-0.25 reserve only for replenishable asks>=5 and bids<=95): tuning seeds 9000_11000, spread 4, n=400, paired mean=-0.09860881649424934, SE=0.9157563985723558, retail=1.320344283336501, arb=-1.41895309982625, failures=0.",
    "eligibleflow (replenishable-tick scale-0.25 reserve with guarded clipped-fill-corrected per-run flow learning): tuning seeds 9000_11000, spread 4, n=400, paired mean=0.18083224406125012, SE=0.711523593701385, retail=1.382130489404502, arb=-1.2012982453395, failures=0.",
    "fast01 (same reserve, scale 0.05): tuning seeds 9000_11000, spread 4, n=400, paired mean=-0.03880957884850028, SE=0.1627616043654035, retail=0.053320104136500325, arb=-0.09212968298424996, failures=0.",
    "tail025 (same continuous tail, scale 0.25): tuning seeds 9000_11000, spread 4, n=400, paired mean=-0.0006186158359996341, SE=0.0006640697093860962, retail=0.010793454246749743, arb=-0.011412070081499978, failures=0.",
    "Front-position diagnostic, first 30 spread-four tuning seeds: positions are main orders placed without a rival ahead and later observed at the rival best tick; edge sums own fills q*(p-price) for buys and q*(price-p) for sells. Base {\"positions\": 4222, \"initial\": 51.11413074372335, \"filled\": 14.96053292278541, \"edge\": 0.4965475692183387, \"retail\": 0.5149687657556327, \"arb\": -0.018421196537293953, \"lifetime_steps\": 14.670298436759829}; aggressive life1 {\"positions\": 5217, \"initial\": 92.7079125934445, \"filled\": 13.408198198198198, \"edge\": 0.4719411342764013, \"retail\": 0.485755823692097, \"arb\": -0.01381468941569575, \"lifetime_steps\": 21.873107149702893}.",
    "Flow-aware front-position diagnostic, first 30 tuning runs, same definition as above: {\"positions\": 4236, \"initial\": 61.66730642115203, \"filled\": 15.564386213408877, \"edge\": 0.5392405590990845, \"retail\": 0.5565761015803286, \"arb\": -0.01733554248124408, \"lifetime_steps\": 17.349386213408877}.",
    "Single frozen experimental candidate, SHA256 446e44d9cda52b4bed53dfee2fc05cd2d689b4bb6fd766fc49ccbe7b6e5ddaab, unseen spread-four n=2009, paired mean=-3.3483234647361373, SE=1.510332187739084, retail=2.2084078648600793, arb=-5.55673132959786, failures=0.",
    "Same frozen quoting policy with original arithmetic restored, independently rescored, SHA256 2f152a8f0e5d4bfb036618f3df83cd254c4fc44e3b7716c7a03481afdd319bbc, unseen spread-four n=2009, paired mean=-3.3483234647361373, SE=1.510332187739084, failures=0.",
    "Arithmetic-only repair: all 2009 unseen SimulationResult objects matched exactly between cached/inlined and original-arithmetic implementations; both independently replayed all seeds, with no quote-policy change.",
    "Final one-process timing record for fallback: {\"runs_each\": 200, \"seeds\": [60000, 60199], \"seconds\": {\"base\": 595.4729134468362, \"yours\": 575.7384612760507}, \"cpu_seconds\": {\"base\": 280.4675322390008, \"yours\": 266.26393209200023}, \"identical\": 200, \"failures\": 0, \"base_failures\": 0, \"method\": \"elapsed engine construction+run, one process, balanced permutations of three strategies, one warmup each\"}.",
    "Experimental implementation timing frozen: {\"runs_each\": 200, \"seeds\": [60000, 60199], \"seconds\": {\"base\": 595.4729134468362, \"yours\": 600.821925265016}, \"cpu_seconds\": {\"base\": 280.4675322390008, \"yours\": 281.6125549239998}, \"identical\": 169, \"failures\": 0, \"base_failures\": 0, \"method\": \"elapsed engine construction+run, one process, balanced permutations of three strategies, one warmup each\"}.",
    "Experimental implementation timing rawfrozen: {\"runs_each\": 200, \"seeds\": [60000, 60199], \"seconds\": {\"base\": 457.53154194378294, \"yours\": 463.15241725579835}, \"cpu_seconds\": {\"base\": 268.7882964329997, \"yours\": 272.7643407379997}, \"identical\": 169, \"method\": \"elapsed engine construction+run, one process, alternating two strategies, one warmup each\"}."
  ],
  "next": "Try a conservative parameter-mixture jump-crossing-loss bound for extra front shares, retaining the one-step core unchanged. The tested flow-aware reserve increased retail edge but lost more to arbitrage; require independent validation before expanding it."
}