{"approach": "Spread 1 only. Preposition larger ask lots at tick 2 while estimated probability is below 1 cent: raise the size cap from 3000 to 15000, retaining the existing probability-distance and jump-loss sizing. Preserve front orders while their size target stays positive and remaining size is at most 10 times the target. Main quote management still does not add new quantity at the rival tick. Also keep orders already ahead of the rival when the active quote moves to a more aggressive tick, but only while the dormant order fits its own one-step risk-based size limit. Use the original two-share minimum for recognizing fronts and for retaining dormant lots. Discovery used the first 160 spread-1 seeds from the tuning range 8000 through 15999; the next 640 gained 1.3072192047237499 per run with this policy. The remaining 1236 tuning seeds independently gained 2.0175483427961165 per run with the same policy. On the first 100 tuning runs, mean reserved cash was 25.104623850500005 versus 23.9950437205 for the base. Optimizations only in spread 1 avoid redundant size calculations and reuse identical arithmetic; other spreads retain the base behavior. Unseen metrics use all 1969 spread-1 seeds in 60000 through 67999, paired seed by seed against the base. Other-spread checks compare all result fields on 300 runs of each spread from 60000. Seconds are elapsed time for 200 runs of each strategy, alternating order in one process on the first 200 spread-1 seeds from 60000.", "blocked": null, "spread": 1, "base_mean_edge": 98.4694596619638, "base_unseen": {"mean_edge": 41.78494849744236, "retail_edge": 65.91107840022042, "arb_edge": -24.1261299027871}, "holdout": {"mean_edge": 43.426520210636106, "retail_edge": 67.51536306454042, "arb_edge": -24.08884285391234, "failures": 0}, "diff": {"mean": 1.6415717131937533, "standard_error": 0.21510271201250636, "retail": 1.6042846643200102, "arb": 0.03728704887475871}, "others_identical": {"runs": 900, "identical": true}, "seconds": {"base": 521.38564748512, "yours": 517.6833946831757}, "code": "\"\"\"Crossing-cover base with isolated, untuned spread overrides.\"\"\"\nimport math\nfrom functools import reduce\nfrom operator import add, mul\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        if self.s == 1:\n            bids, asks, sb, sa = [], [], set(), set()\n            for o in state.own_orders:\n                if o.side is Side.BUY:\n                    lo = max(lo, o.price_ticks)\n                    if o.remaining_quantity <= PROBE + 1e-9:\n                        sb.add(o.price_ticks)\n                    else:\n                        bids.append(o)\n                else:\n                    hi = min(hi, o.price_ticks)\n                    if o.remaining_quantity <= PROBE + 1e-9:\n                        sa.add(o.price_ticks)\n                    else:\n                        asks.append(o)\n        else:\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            if self.s != 1:\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 == 1 and wid / nb == 0.125 and len(self.bc) > 1\n                    and self.bc[1] - self.bc[0] == 0.125):\n                # These grid centres are exact binary fractions. Equal index\n                # differences have exactly equal Gaussian transition weights.\n                m = len(self.bc)\n                delta = cs[0] - self.bc[0]\n                kernel = []\n                for offset in range(1 - m, nb):\n                    d = delta + offset * 0.125\n                    d2 = d * d * k\n                    kernel.append(math.exp(d2) if d2 > -12.5 else 0.0)\n                for i in range(nb):\n                    ws.append(reduce(add, map(mul, self.bw, reversed(kernel[i:i + m])), uni))\n            elif self.s == 1:\n                grid_pairs = tuple(zip(self.bc, self.bw))\n                exp = math.exp\n                for c in cs:\n                    t = uni\n                    for ci, wi in grid_pairs:\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 == 1:\n                ja = sum(w * (x - p) for p, w in jp if x > p)\n                jb = sum(w * (p - x) for p, w in jp if 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, cap=None):\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((cap if cap is not None else 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 == 1 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 == 1 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            return qsize(b, a, t / 100.0, 15000 if self.s == 1 and t == 2 and phat < 0.01 else None)\n\n        if self.s != 1:\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            if self.s == 1:\n                bound_t, bound_q = t, q\n            for o in orders:\n                if self.s == 1 and o.order_id in self.ahead and o.remaining_quantity >= P['min_ahead'] and o.price_ticks != t:\n                    safer = (o.side is Side.SELL and o.price_ticks > t) or (o.side is Side.BUY and o.price_ticks < t)\n                    if safer:\n                        # At a safer bid the optimal quantity cannot fall; at a\n                        # safer ask the optimal notional cannot fall. Respect\n                        # the ordinary quantity cap in this quick lower bound.\n                        enough = bound_q > 0 and (\n                            o.remaining_quantity <= bound_q if o.side is Side.BUY else\n                            o.remaining_quantity * o.price_ticks <= min(bound_q, P['qmax']) * bound_t)\n                        if enough:\n                            kept_ids.add(o.order_id)\n                            continue\n                        if o.price_ticks == bound_t:\n                            capacity = bound_q\n                        else:\n                            capacity = qask(o.price_ticks) if o.side is Side.SELL else qbid(o.price_ticks)\n                            bound_t, bound_q = o.price_ticks, capacity\n                        if capacity > 0 and o.remaining_quantity <= max(capacity, 1.0):\n                            kept_ids.add(o.order_id)\n                            continue\n                if o.price_ticks == t and q > 0 and kept + o.remaining_quantity <= max(q * (10.0 if self.s == 1 and o.order_id in self.ahead else 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": "d5a76ce3ac426619d1e4fe4e3864afb7b88acbea5b4d63b35f59c09ae3dff3bb", "tried": ["camp10p0: Multiply both main quantities by named factor; retain front lots up to 10x target and recognize 0.02 shares. discovery={\"n\":160,\"mean\":-42.81151805115688,\"standard_error\":12.6142579277919,\"retail\":-0.4038704508831252,\"arb\":-42.40764760030375,\"failures\":0}", "camp1p0: Multiply both main quantities by named factor; retain front lots up to 10x target and recognize 0.02 shares. discovery={\"n\":160,\"mean\":0.4751365159324985,\"standard_error\":0.18145892173006148,\"retail\":0.4524649884568744,\"arb\":0.0226715274937493,\"failures\":0}; other_tuning={\"n\":640,\"mean\":0.2236364934782812,\"standard_error\":0.0942779135177186,\"retail\":0.2449686885460935,\"arb\":-0.021332195070781233,\"failures\":0}", "camp2p0: Multiply both main quantities by named factor; retain front lots up to 10x target and recognize 0.02 shares. discovery={\"n\":160,\"mean\":6.5519964163674995,\"standard_error\":7.4412453951200055,\"retail\":4.4661588334993745,\"arb\":2.0858375828599987,\"failures\":0}; other_tuning={\"n\":640,\"mean\":-3.9056127147171877,\"standard_error\":1.34218221498829,\"retail\":3.883778109147812,\"arb\":-7.7893908238875,\"failures\":0}", "camp4p0: Multiply both main quantities by named factor; retain front lots up to 10x target and recognize 0.02 shares. discovery={\"n\":160,\"mean\":-16.077103130478754,\"standard_error\":14.182639828913702,\"retail\":8.6029849735675,\"arb\":-24.680088104063124,\"failures\":0}", "cycle2_15000: Persist the subcent dwell clock across rival lot cycles; named boundary, cap and retention variant. discovery={\"n\":160,\"mean\":-22.974557780081874,\"standard_error\":7.304277069934008,\"retail\":-10.77567868214375,\"arb\":-12.198879097928124,\"failures\":0}", "cycle2_15000keep: Persist the subcent dwell clock across rival lot cycles; named boundary, cap and retention variant. discovery={\"n\":160,\"mean\":-22.61036138893375,\"standard_error\":7.320477656550434,\"retail\":-10.59743191172375,\"arb\":-12.012929477185626,\"failures\":0}", "cycle2_3000: Persist the subcent dwell clock across rival lot cycles; named boundary, cap and retention variant. discovery={\"n\":160,\"mean\":-23.567922299840625,\"standard_error\":7.352215603681508,\"retail\":-10.02749362080875,\"arb\":-13.540428679018126,\"failures\":0}", "cycle2_3000keep: Persist the subcent dwell clock across rival lot cycles; named boundary, cap and retention variant. discovery={\"n\":160,\"mean\":-23.219782429850625,\"standard_error\":7.367350652540253,\"retail\":-9.867647944043124,\"arb\":-13.352134485778752,\"failures\":0}", "cycle3_15000: Persist the subcent dwell clock across rival lot cycles; named boundary, cap and retention variant. discovery={\"n\":160,\"mean\":-25.084899345861253,\"standard_error\":7.244395379919502,\"retail\":-11.854975367149375,\"arb\":-13.229923978704374,\"failures\":0}", "cycle3_15000keep: Persist the subcent dwell clock across rival lot cycles; named boundary, cap and retention variant. discovery={\"n\":160,\"mean\":-24.4417410068475,\"standard_error\":7.095611355952759,\"retail\":-12.2794577303075,\"arb\":-12.162283276519377,\"failures\":0}", "cycle3_3000: Persist the subcent dwell clock across rival lot cycles; named boundary, cap and retention variant. discovery={\"n\":160,\"mean\":-26.300949031344373,\"standard_error\":7.440618317954364,\"retail\":-11.10666597166375,\"arb\":-15.194283059668749,\"failures\":0}", "cycle3_3000keep: Persist the subcent dwell clock across rival lot cycles; named boundary, cap and retention variant. discovery={\"n\":160,\"mean\":-25.673850944395628,\"standard_error\":7.271286100593615,\"retail\":-11.549542555605,\"arb\":-14.124308388765627,\"failures\":0}", "deep0p001_10000: Quote tick 2 behind existing rivals only below named probability threshold, with named size cap. discovery={\"n\":160,\"mean\":-2.5402917764487496,\"standard_error\":0.6793969659964981,\"retail\":-2.499874631896875,\"arb\":-0.040417144545000325,\"failures\":0}", "deep0p001_30000: Quote tick 2 behind existing rivals only below named probability threshold, with named size cap. discovery={\"n\":160,\"mean\":-2.5402917764487496,\"standard_error\":0.6793969659964981,\"retail\":-2.499874631896875,\"arb\":-0.040417144545000325,\"failures\":0}", "deep0p003_10000: Quote tick 2 behind existing rivals only below named probability threshold, with named size cap. discovery={\"n\":160,\"mean\":-6.754902579050625,\"standard_error\":1.3484721573359002,\"retail\":-7.355330126316249,\"arb\":0.6004275472799996,\"failures\":0}", "deep0p003_30000: Quote tick 2 behind existing rivals only below named probability threshold, with named size cap. discovery={\"n\":160,\"mean\":-6.754902579050625,\"standard_error\":1.3484721573359002,\"retail\":-7.355330126316249,\"arb\":0.6004275472799996,\"failures\":0}", "deep0p006_10000: Quote tick 2 behind existing rivals only below named probability threshold, with named size cap. discovery={\"n\":160,\"mean\":-14.918775170436252,\"standard_error\":2.996046764616547,\"retail\":-15.36889609688875,\"arb\":0.45012092645187457,\"failures\":0}", "deep0p006_30000: Quote tick 2 behind existing rivals only below named probability threshold, with named size cap. discovery={\"n\":160,\"mean\":-14.918775170436252,\"standard_error\":2.996046764616547,\"retail\":-15.36889609688875,\"arb\":0.45012092645187457,\"failures\":0}", "entry_allask_1p5: Scale advance ask quantity at tick 2 or all asks through tick 10; retain fronts up to 3x target. discovery={\"n\":160,\"mean\":9.562179204800625,\"standard_error\":7.5777844913705685,\"retail\":1.5260805466368745,\"arb\":8.0360986581775,\"failures\":0}; other_tuning={\"n\":640,\"mean\":-0.6427607382870314,\"standard_error\":0.7451929447311699,\"retail\":2.103470874806094,\"arb\":-2.7462316130925,\"failures\":0}", "entry_allask_2: Scale advance ask quantity at tick 2 or all asks through tick 10; retain fronts up to 3x target. discovery={\"n\":160,\"mean\":6.180044347234374,\"standard_error\":7.995822674540318,\"retail\":3.7812279992656244,\"arb\":2.3988163480043743,\"failures\":0}", "entry_allask_4: Scale advance ask quantity at tick 2 or all asks through tick 10; retain fronts up to 3x target. discovery={\"n\":160,\"mean\":-4.1409505319056255,\"standard_error\":9.114971287930784,\"retail\":3.45778361045125,\"arb\":-7.59873414234625,\"failures\":0}", "entry_allask_8: Scale advance ask quantity at tick 2 or all asks through tick 10; retain fronts up to 3x target. discovery={\"n\":160,\"mean\":-33.33468987383312,\"standard_error\":14.706548957971183,\"retail\":-1.4459670688899995,\"arb\":-31.888722804924374,\"failures\":0}", "entry_ask2_1p5: Scale advance ask quantity at tick 2 or all asks through tick 10; retain fronts up to 3x target. discovery={\"n\":160,\"mean\":2.180351038924374,\"standard_error\":2.0594769680721687,\"retail\":0.47713514435187465,\"arb\":1.70321589459375,\"failures\":0}", "entry_ask2_2: Scale advance ask quantity at tick 2 or all asks through tick 10; retain fronts up to 3x target. discovery={\"n\":160,\"mean\":3.131220164329374,\"standard_error\":2.095784859616738,\"retail\":1.1064371452349993,\"arb\":2.0247830191274994,\"failures\":0}; other_tuning={\"n\":640,\"mean\":-0.9950312711532809,\"standard_error\":1.1158516193775085,\"retail\":0.9030581887973439,\"arb\":-1.8980894599584375,\"failures\":0}", "entry_ask2_4: Scale advance ask quantity at tick 2 or all asks through tick 10; retain fronts up to 3x target. discovery={\"n\":160,\"mean\":2.5656301203856238,\"standard_error\":2.6484057624058597,\"retail\":2.0041945378862502,\"arb\":0.5614355825131245,\"failures\":0}", "entry_ask2_8: Scale advance ask quantity at tick 2 or all asks through tick 10; retain fronts up to 3x target. discovery={\"n\":160,\"mean\":2.0777743641456237,\"standard_error\":2.5867038616138567,\"retail\":2.523672430474999,\"arb\":-0.4458980663225005,\"failures\":0}", "frontforever: Keep current front orders whenever their target stays positive; named reserve cap, no size-shrink cancellation. discovery={\"n\":160,\"mean\":0.4753368428531234,\"standard_error\":0.1814661437219773,\"retail\":0.45271788373812444,\"arb\":0.0226189591337493,\"failures\":0}", "future: Preposition at the opposite rival lot plus or minus one tick when the visible gap exceeds two ticks. discovery={\"n\":160,\"mean\":0.0,\"standard_error\":0.0,\"retail\":0.0,\"arb\":0.0,\"failures\":0}", "futureask: Preposition at the opposite rival lot plus or minus one tick when the visible gap exceeds two ticks. discovery={\"n\":160,\"mean\":0.0,\"standard_error\":0.0,\"retail\":0.0,\"arb\":0.0,\"failures\":0}", "futurebid: Preposition at the opposite rival lot plus or minus one tick when the visible gap exceeds two ticks. discovery={\"n\":160,\"mean\":0.0,\"standard_error\":0.0,\"retail\":0.0,\"arb\":0.0,\"failures\":0}", "keep3: Use named front-retention multiplier and 0.02-share recognition. discovery={\"n\":160,\"mean\":0.45972969233187344,\"standard_error\":0.1811720883011467,\"retail\":0.43129574737312415,\"arb\":0.0284339449787492,\"failures\":0}", "keep30: Use named front-retention multiplier and 0.02-share recognition. discovery={\"n\":160,\"mean\":0.4753368428531234,\"standard_error\":0.1814661437219773,\"retail\":0.45271788373812444,\"arb\":0.0226189591337493,\"failures\":0}", "keeponly: Retain current front orders up to 10x target without changing the two-share recognition threshold. discovery={\"n\":160,\"mean\":0.4197141024412484,\"standard_error\":0.18119064781326044,\"retail\":0.41587015437562497,\"arb\":0.0038439480700000516,\"failures\":0}", "ladder_ask_1: Keep safer front orders after the active quote moves; scope and risk-capacity multiplier are named. discovery={\"n\":160,\"mean\":0.43130815755999896,\"standard_error\":0.34214117937005084,\"retail\":0.30879101948874976,\"arb\":0.12251713805437454,\"failures\":0}", "ladder_ask_3: Keep safer front orders after the active quote moves; scope and risk-capacity multiplier are named. discovery={\"n\":160,\"mean\":0.43167076427499895,\"standard_error\":0.34213996252021067,\"retail\":0.30922863335499995,\"arb\":0.12244213090312453,\"failures\":0}", "ladder_both_1: Keep safer front orders after the active quote moves; scope and risk-capacity multiplier are named. discovery={\"n\":160,\"mean\":1.7890404468412497,\"standard_error\":1.0405070320669851,\"retail\":0.6687293911937493,\"arb\":1.1203110556562494,\"failures\":0}; other_tuning={\"n\":640,\"mean\":0.958841400709062,\"standard_error\":0.2704142965646465,\"retail\":0.8117551454270313,\"arb\":0.14708625527812488,\"failures\":0}", "ladder_both_3: Keep safer front orders after the active quote moves; scope and risk-capacity multiplier are named. discovery={\"n\":160,\"mean\":1.7884099518399998,\"standard_error\":1.0405108358523112,\"retail\":0.6695194177649993,\"arb\":1.1188905340837494,\"failures\":0}", "ladder_lowask_1: Keep safer front orders after the active quote moves; scope and risk-capacity multiplier are named. discovery={\"n\":160,\"mean\":0.2688225402268748,\"standard_error\":0.32678229587031116,\"retail\":0.21092740307937427,\"arb\":0.05789513714874989,\"failures\":0}", "ladder_lowask_3: Keep safer front orders after the active quote moves; scope and risk-capacity multiplier are named. discovery={\"n\":160,\"mean\":0.2688225402268748,\"standard_error\":0.32678229587031116,\"retail\":0.21092740307937427,\"arb\":0.05789513714874989,\"failures\":0}", "low0p1: Indiscriminately quote tick 2 below 1 cent, permitting joins behind the rival; named quantity multiplier. discovery={\"n\":160,\"mean\":-33.00771305130125,\"standard_error\":9.93781803155685,\"retail\":-44.703947058391876,\"arb\":11.696234007111874,\"failures\":0}", "low0p25: Indiscriminately quote tick 2 below 1 cent, permitting joins behind the rival; named quantity multiplier. discovery={\"n\":160,\"mean\":-28.620298272845627,\"standard_error\":8.257248614845864,\"retail\":-37.92680941588,\"arb\":9.306511143044373,\"failures\":0}", "low0p5: Indiscriminately quote tick 2 below 1 cent, permitting joins behind the rival; named quantity multiplier. discovery={\"n\":160,\"mean\":-23.991961989336875,\"standard_error\":7.010664316962054,\"retail\":-33.10875289819625,\"arb\":9.11679090885875,\"failures\":0}", "low1p0: Indiscriminately quote tick 2 below 1 cent, permitting joins behind the rival; named quantity multiplier. discovery={\"n\":160,\"mean\":-32.77245812664312,\"standard_error\":5.922715013359444,\"retail\":-32.610128622001255,\"arb\":-0.16232950463125034,\"failures\":0}", "low2p0: Indiscriminately quote tick 2 below 1 cent, permitting joins behind the rival; named quantity multiplier. discovery={\"n\":160,\"mean\":-38.2983287423175,\"standard_error\":7.755352568322731,\"retail\":-35.02909729138938,\"arb\":-3.269231450917501,\"failures\":0}", "minonly: Lower front-recognition minimum from 2 to 0.02 shares without other changes. discovery={\"n\":160,\"mean\":0.05685038490312472,\"standard_error\":0.04444926463832853,\"retail\":0.03605521818374906,\"arb\":0.020795166731874544,\"failures\":0}", "reserve15000: Increase ask-at-2 size cap only below 1 cent; keep suffix adds 10x front retention and 0.02-share front detection. discovery={\"n\":160,\"mean\":-0.9476143594318749,\"standard_error\":0.5599982880322476,\"retail\":-0.7380523302125004,\"arb\":-0.20956202922000006,\"failures\":0}", "reserve15000forever: Keep current front orders whenever their target stays positive; named reserve cap, no size-shrink cancellation. discovery={\"n\":160,\"mean\":1.0462364783743732,\"standard_error\":0.5991632740774304,\"retail\":0.7975303801193748,\"arb\":0.24870609827437434,\"failures\":0}", "reserve15000keep: Increase ask-at-2 size cap only below 1 cent; keep suffix adds 10x front retention and 0.02-share front detection. discovery={\"n\":160,\"mean\":1.0460361514537484,\"standard_error\":0.5991622873099192,\"retail\":0.7972774848381248,\"arb\":0.24875866663437435,\"failures\":0}; other_tuning={\"n\":640,\"mean\":0.4015891369912499,\"standard_error\":0.1280600097880337,\"retail\":0.463236917936875,\"arb\":-0.06164778095093756,\"failures\":0}", "reserve50000: Increase ask-at-2 size cap only below 1 cent; keep suffix adds 10x front retention and 0.02-share front detection. discovery={\"n\":160,\"mean\":-0.9476143594318749,\"standard_error\":0.5599982880322476,\"retail\":-0.7380523302125004,\"arb\":-0.20956202922000006,\"failures\":0}", "reserve50000keep: Increase ask-at-2 size cap only below 1 cent; keep suffix adds 10x front retention and 0.02-share front detection. discovery={\"n\":160,\"mean\":1.0460361514537484,\"standard_error\":0.5991622873099192,\"retail\":0.7972774848381248,\"arb\":0.24875866663437435,\"failures\":0}", "reserve6000: Increase ask-at-2 size cap only below 1 cent; keep suffix adds 10x front retention and 0.02-share front detection. discovery={\"n\":160,\"mean\":-0.9476143594318749,\"standard_error\":0.5599982880322476,\"retail\":-0.7380523302125004,\"arb\":-0.20956202922000006,\"failures\":0}", "reserve6000forever: Keep current front orders whenever their target stays positive; named reserve cap, no size-shrink cancellation. discovery={\"n\":160,\"mean\":0.9366030956287485,\"standard_error\":0.5207283350785602,\"retail\":0.6878588808812491,\"arb\":0.2487442147668743,\"failures\":0}", "reserve6000keep: Increase ask-at-2 size cap only below 1 cent; keep suffix adds 10x front retention and 0.02-share front detection. discovery={\"n\":160,\"mean\":0.9364027687081237,\"standard_error\":0.5207269344165614,\"retail\":0.6876059855999991,\"arb\":0.24879678312687434,\"failures\":0}", "reserve_ladder: Retain larger tick-2 fronts plus safely sized dormant front orders on both sides. discovery={\"n\":160,\"mean\":2.5395516727793748,\"standard_error\":1.0360097333733225,\"retail\":1.478253978114999,\"arb\":1.0612976946993742,\"failures\":0}; other_tuning={\"n\":640,\"mean\":1.3416826674057813,\"standard_error\":0.3047353404625637,\"retail\":1.2250709554467192,\"arb\":0.1166117119524999,\"failures\":0}", "reserve_ladder_bounds: Retain larger tick-2 fronts plus safely sized dormant front orders on both sides. other_tuning={\"n\":1236,\"mean\":2.049862616162298,\"standard_error\":0.8749681637611156,\"retail\":1.4535723644349516,\"arb\":0.5962902517330096,\"failures\":0}", "reserve_ladder_nodust: Combined queue policy, preserving the base two-share minimum for front and dormant lots. discovery={\"n\":160,\"mean\":2.5189615952274993,\"standard_error\":1.0252671159340507,\"retail\":1.4103219692999998,\"arb\":1.1086396259331246,\"failures\":0}; other_tuning={\"n\":1876,\"mean\":1.7752185728780383,\"standard_error\":0.5840126139072016,\"retail\":1.3066030432070899,\"arb\":0.468615529671375,\"failures\":0}", "toehold20: Place the named minimum shares at the next replacement tick on favorable price movement, overriding zero-size decisions. discovery={\"n\":160,\"mean\":-29.583416700510003,\"standard_error\":2.2491157441989866,\"retail\":4.947469784050624,\"arb\":-34.530886484537504,\"failures\":0}", "toehold200: Place the named minimum shares at the next replacement tick on favorable price movement, overriding zero-size decisions. discovery={\"n\":160,\"mean\":-179.78862234861498,\"standard_error\":12.431152643506394,\"retail\":-18.491274543595626,\"arb\":-161.29734780503125,\"failures\":0}", "toehold60: Place the named minimum shares at the next replacement tick on favorable price movement, overriding zero-size decisions. discovery={\"n\":160,\"mean\":-97.82934422620374,\"standard_error\":5.9726571545381155,\"retail\":5.830027587839375,\"arb\":-103.65937181402876,\"failures\":0}", "toehold600: Place the named minimum shares at the next replacement tick on favorable price movement, overriding zero-size decisions. discovery={\"n\":160,\"mean\":-137.44207664540875,\"standard_error\":12.288782665046133,\"retail\":-49.45927506761625,\"arb\":-87.98280157779125,\"failures\":0}", "tranche_ask2: Split initial front orders into named count of geometric tranches; resize by canceling later pieces. discovery={\"n\":160,\"mean\":-0.02056163056249924,\"standard_error\":0.1747488153917326,\"retail\":-0.0034699520806252943,\"arb\":-0.017091678476250805,\"failures\":0}", "tranche_ask4: Split initial front orders into named count of geometric tranches; resize by canceling later pieces. discovery={\"n\":160,\"mean\":0.040465748659998774,\"standard_error\":0.1999931170960636,\"retail\":0.05131928893937515,\"arb\":-0.010853540280000571,\"failures\":0}", "tranche_ask8: Split initial front orders into named count of geometric tranches; resize by canceling later pieces. discovery={\"n\":160,\"mean\":-0.026368578138126146,\"standard_error\":0.17482702350222426,\"retail\":-0.0021908446806247683,\"arb\":-0.024177733449375675,\"failures\":0}", "tranche_both2: Split initial front orders into named count of geometric tranches; resize by canceling later pieces. discovery={\"n\":160,\"mean\":-0.0027858379193748343,\"standard_error\":0.1753684112912093,\"retail\":0.010228835368124856,\"arb\":-0.013014673286250106,\"failures\":0}", "tranche_both4: Split initial front orders into named count of geometric tranches; resize by canceling later pieces. discovery={\"n\":160,\"mean\":0.0763782636549999,\"standard_error\":0.19996473849696714,\"retail\":0.08103991461874979,\"arb\":-0.00466165096500058,\"failures\":0}", "tranche_both8: Split initial front orders into named count of geometric tranches; resize by canceling later pieces. discovery={\"n\":160,\"mean\":-0.0017292099112506578,\"standard_error\":0.1755612192108611,\"retail\":0.016830764292500026,\"arb\":-0.018559974199375225,\"failures\":0}", "tranche_lowask2: Split initial front orders into named count of geometric tranches; resize by canceling later pieces. discovery={\"n\":160,\"mean\":-0.017519911873124978,\"standard_error\":0.16965801424218063,\"retail\":-0.0015836517131247896,\"arb\":-0.015936260157499993,\"failures\":0}", "tranche_lowask4: Split initial front orders into named count of geometric tranches; resize by canceling later pieces. discovery={\"n\":160,\"mean\":0.05605138857500023,\"standard_error\":0.19502757100327991,\"retail\":0.05602365116687509,\"arb\":2.7737405624994604e-05,\"failures\":0}", "tranche_lowask8: Split initial front orders into named count of geometric tranches; resize by canceling later pieces. discovery={\"n\":160,\"mean\":-0.01751087885750006,\"standard_error\":0.16965773400476628,\"retail\":-0.001574618699374819,\"arb\":-0.015936260157499993,\"failures\":0}", "Collateral audit of first 100 tuning seeds: {\"base\":{\"runs\":100,\"mean_order_count\":1.6779,\"mean_dormant_cash\":0.008795108500000001,\"mean_reserved_cash\":23.9950437205,\"front2_fraction\":0.015905,\"mean_front2_shares_when_present\":878.9190097453632,\"mean_front2_uncovered_cash_when_present\":7.0346562716126995,\"before_arrival_steps\":1388,\"mean_edge\":24.956120059318,\"retail_edge\":68.917924742826,\"arb_edge\":-43.961804683497},\"reserve_ladder_nodust\":{\"runs\":100,\"mean_order_count\":2.694455,\"mean_dormant_cash\":1.1254655605000012,\"mean_reserved_cash\":25.104623850500005,\"front2_fraction\":0.019585,\"mean_front2_shares_when_present\":1928.5586699004293,\"mean_front2_uncovered_cash_when_present\":18.537191626244574,\"before_arrival_steps\":1348,\"mean_edge\":28.414428286853,\"retail_edge\":70.652698567692,\"arb_edge\":-42.238270280825}}", "Initial reserve-policy collateral audit of first 100 tuning seeds: {\"base\":{\"runs\":100,\"mean_reserved_cash\":23.9950437205,\"front2_fraction\":0.015905,\"mean_front2_shares_when_present\":878.9190097453632,\"mean_front2_uncovered_cash_when_present\":7.0346562716126995,\"before_arrival_steps\":1388,\"mean_edge\":24.956120059318,\"retail_edge\":68.917924742826,\"arb_edge\":-43.961804683497},\"reserve15000keep\":{\"runs\":100,\"mean_reserved_cash\":24.011772788,\"front2_fraction\":0.021355,\"mean_front2_shares_when_present\":1956.3006181222154,\"mean_front2_uncovered_cash_when_present\":14.847759494263638,\"before_arrival_steps\":1388,\"mean_edge\":26.447483858833998,\"retail_edge\":70.036003971618,\"arb_edge\":-43.588520112739}}", "Spread-1 numerical optimizations checked against the original combined strategy: kernel, reduce, early size rejection, one-pass order scan and monotone capacity bounds each produced identical full results on 160 discovery seeds.", "Frozen candidate final checks: {\"candidate\":\"reserve_ladder_nodust\",\"unseen_completed\":1969,\"seconds\":{\"base\":521.38564748512,\"yours\":517.6833946831757},\"others\":{\"runs\":900,\"identical\":true},\"gain\":1.6415717131937533,\"standard_error\":0.21510271201250636,\"failures\":0,\"eligible\":true}", "Frozen candidate final checks: {\"candidate\":\"reserve_ladder_final\",\"unseen_completed\":1969,\"seconds\":{\"base\":586.5856056488701,\"yours\":601.5186426179425},\"others\":{\"runs\":900,\"identical\":true},\"gain\":1.6992477667164045,\"standard_error\":0.2154390761242142,\"failures\":0,\"eligible\":false}", "Frozen candidate final checks: {\"candidate\":\"reserve_priority_fast\",\"unseen_completed\":1969,\"seconds\":{\"base\":463.62119487818563,\"yours\":459.0489998169942},\"others\":{\"runs\":900,\"identical\":true},\"gain\":0.8711178958203146,\"standard_error\":0.1538190764315685,\"failures\":0,\"eligible\":true}", "Frozen candidate final checks: {\"candidate\":\"reserve15000keep_fast\",\"unseen_completed\":1969,\"seconds\":{\"base\":722.7183306259685,\"yours\":722.3897439079592},\"others\":{\"runs\":900,\"identical\":true},\"gain\":0.8711178958203146,\"standard_error\":0.1538190764315685,\"failures\":0,\"eligible\":true}", "Selection rule, fixed before seeing the combined-policy unseen scores: {\"preferred\": [\"reserve_ladder_nodust\", \"reserve_ladder_final\", \"reserve_priority_fast\", \"reserve15000keep_fast\"], \"reason\": \"Prefer the combined queue policy after positive tuning validation, using the original two-share floor to avoid tiny dormant orders. Next use its 0.02-share-floor variant. If their runtime fails, use the conservative proven queue policy, preferring an exact faster implementation. Eligibility requires positive unseen gain, zero failures, identical other-spread results on 900 runs, and measured elapsed runtime no larger than its paired base. The unseen gain magnitude is not used to tune or rank the policies.\"}", "Baseline CLI: 4000 simulations, seed-start 4000, workers 4, no sandbox; mean_edge 98.4694596619638; failures 0. All 8 source quotations were refetched and matched exactly.", "The initial conservative policy and the selected two-share policy each matched their independent scoring results on all 200 timed seeds, for both base and candidate factories. The optimized conservative implementation matched all 1969 full unseen results of its original implementation. The grid, arithmetic, scan, size-bound and early-rejection shortcuts each matched the original combined policy on 160 tuning runs."], "next": "Explore a limit on dormant front order fragments or a larger minimum retained lot, using the already public quote and fill history to estimate the value of waiting. Keep risk-based size near 1 cent; broad behind-rival tick-2 quoting, zero-size overrides, persistent subcent beliefs, and broad size multipliers failed tuning. Preserve both the independent validation gain and the runtime gate."}