{"approach": "The base cancels still-profitable resting asks too aggressively when desired size falls, losing queue priority: only in spread 1, retain an existing ask up to three times the current target size instead of the base factor of 1.5. Price selection, new-order sizing, collateral handling, and cancellation when desired size is zero retain the base behavior. This is one conditional change in the existing order-retention test. Used the unmodified public simulator at commit b244530ee2a6247b5f930830eeca9dd950da0e7e, default configuration (2000 steps), standard-library Python only, without sandboxing. The required CLI check with 4000 simulations, seed-start 4000, and workers 4 exactly reproduced 98.4694596619638 with zero failures. Enumerated seeds using sample_config(ChallengeConfig(), ParameterVariance(), seed=N). There are 2036 spread-1 tuning seeds in [8000,15999], split into the first 1018 for discovery and the remaining 1018 for validation, and 1969 spread-1 unseen seeds in [60000,67999]. All three evaluated designs were coded and fully validated before the first unseen evaluation, which began after the 2026-11-06T08:44:51.649608+00:00 freeze. The initially selected broader rule lost unseen edge; two unchanged pre-existing alternatives were then evaluated. No strategy code was altered in response to unseen results. The final selection uses the stated eligibility gates across these three designs, so the reported paired standard error is unadjusted for that comparison. Base_unseen, holdout, and diff use only the 1969 spread-1 runs, paired by seed. The unchanged base results were reused as the common comparison for the alternatives. Each changed design was run on the first 300 unseen seeds of each other spread and compared against the complete corresponding base SimulationResult, 900 pairs per design. Timing uses the first 200 unseen spread-1 seeds in one process with rotating strategy order after one untimed warmup per strategy. Wall time includes engine construction and run; configuration sampling and strategy loading are excluded. Each timed result was checked against its scored result. Arb edge is signed: positive diff.arb means less loss. These are local simulator scores; nothing was submitted to Paradigm.", "blocked": null, "python_version": "3.13.5", "spread": 1, "base_mean_edge": 98.4694596619638, "runs": {"tuning": 2036, "unseen": 1969}, "base_unseen": {"mean_edge": 41.78494849744236, "retail_edge": 65.91107840022042, "arb_edge": -24.1261299027871}, "holdout": {"mean_edge": 42.04397041383997, "retail_edge": 66.17572732629792, "arb_edge": -24.131756912465974, "failures": 0}, "diff": {"mean": 0.2590219163976132, "standard_error": 0.05671861876306454, "retail": 0.26464892607750123, "arb": -0.005627009678872584}, "others_identical": {"runs": 900, "identical": true}, "seconds": {"base": 96.76859576650895, "yours": 96.61415343778208}, "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 * (3.0 if self.s == 1 and o.side is Side.SELL 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": "20846005744d3b4ef5e3ede11456fcc9896f798902ebc1d801735bf0200901fe", "tried": ["Quote at tick 2 below one cent, instead of undercutting to tick 1; rejected for lost retail fills. {\"ask2_c1.0_h0\":{\"runs\":128,\"mean\":-33.28112834764219,\"standard_error\":7.083785317689174,\"retail\":-32.644074234054685,\"arb\":-0.6370541135734379,\"failures\":0},\"ask2_c1.0_h100\":{\"runs\":128,\"mean\":-19.993768002771876,\"standard_error\":4.540122853822071,\"retail\":-21.349354725128126,\"arb\":1.3555867223617184,\"failures\":0},\"ask2_c1.5_h0\":{\"runs\":128,\"mean\":-21.095535246783594,\"standard_error\":5.264738992942875,\"retail\":-20.30377811706094,\"arb\":-0.7917571297125007,\"failures\":0}}", "Use tick 2 only when stock is scarce; deepen and retain the tick-2 queue. No compelling standalone gain. {\"ask2_stock10\":{\"runs\":128,\"mean\":0.031565985277344,\"standard_error\":0.04245207272225829,\"retail\":0.5997615807921868,\"arb\":-0.5681955955140625,\"failures\":0},\"ask2_stock30\":{\"runs\":128,\"mean\":-0.28177777592968734,\"standard_error\":0.23297068331830073,\"retail\":0.49512989522578077,\"arb\":-0.7769076711484376,\"failures\":0},\"ask2_stock60\":{\"runs\":128,\"mean\":-0.1683147782531249,\"standard_error\":0.41081336846493044,\"retail\":-0.30137794399140705,\"arb\":0.1330631657390624,\"failures\":0},\"ask2_depth\":{\"runs\":128,\"mean\":-25.822336138460155,\"standard_error\":5.335005519106736,\"retail\":-25.989712293939846,\"arb\":0.16737615548906198,\"failures\":0}}", "Combine the tick-2 variants with tick-1 bid-depletion information; not selected. {\"ask2_c1.0_h100_info\":{\"runs\":128,\"mean\":-3.660770508930469,\"standard_error\":4.030212925947274,\"retail\":-10.812640392374218,\"arb\":7.1518698834421865,\"failures\":0},\"ask2_stock10_info\":{\"runs\":128,\"mean\":5.209006783520312,\"standard_error\":3.425783104400106,\"retail\":-0.02809825849921968,\"arb\":5.2371050420218745,\"failures\":0},\"ask2_depth_info\":{\"runs\":128,\"mean\":-3.6898315561125004,\"standard_error\":7.883786789640876,\"retail\":-2.4743667676804693,\"arb\":-1.2154647884296892,\"failures\":0}}", "Delay large tick-1 inventory bids until estimated probability is near one cent. The two-cent cutoff failed independent validation. {\"screen\":{\"closebid_0.1\":{\"runs\":128,\"mean\":-13.178190891290626,\"standard_error\":11.919173399678307,\"retail\":-15.365842736357813,\"arb\":2.187651845077343,\"failures\":0},\"closebid_0.3\":{\"runs\":128,\"mean\":3.524909491415625,\"standard_error\":10.290821680078366,\"retail\":-9.904830785523437,\"arb\":13.429740276955467,\"failures\":0},\"closebid_0.5\":{\"runs\":128,\"mean\":8.333953313460936,\"standard_error\":9.213644155012682,\"retail\":-3.1860648940726564,\"arb\":11.520018207545313,\"failures\":0},\"closebid_1.0\":{\"runs\":128,\"mean\":10.014754302190624,\"standard_error\":9.10636103967291,\"retail\":-0.858250645896875,\"arb\":10.873004948089063,\"failures\":0},\"closebid_2.0\":{\"runs\":128,\"mean\":9.3178212056625,\"standard_error\":9.109853579088243,\"retail\":-0.8297732954703125,\"arb\":10.147594501134376,\"failures\":0}},\"two_cent_full_discovery\":{\"runs\":1018,\"mean\":1.7780759474039292,\"standard_error\":1.26138635250186,\"retail\":-0.6876310844608057,\"arb\":2.465707031864342,\"failures\":0},\"two_cent_validation\":{\"runs\":256,\"mean\":-1.178259938338672,\"standard_error\":0.8745026454790786,\"retail\":-1.3187571394539064,\"arb\":0.14049720111640626,\"failures\":0}}", "Increase low-price ask loss weight near settlement or for jumps; rejected on validation. {\"screen\":{\"termrisk_100\":{\"runs\":128,\"mean\":4.4396168936343745,\"standard_error\":6.655735206082513,\"retail\":-1.8924599963570314,\"arb\":6.3320768899960935,\"failures\":0},\"termrisk_300\":{\"runs\":128,\"mean\":2.956701311342187,\"standard_error\":5.384838965935918,\"retail\":-2.300349004592188,\"arb\":5.257050315941406,\"failures\":0},\"termrisk_600\":{\"runs\":128,\"mean\":4.549164782027343,\"standard_error\":5.649439233988516,\"retail\":-3.354517523128126,\"arb\":7.903682305157812,\"failures\":0},\"jumpask\":{\"runs\":128,\"mean\":3.473069608053124,\"standard_error\":5.677685053753217,\"retail\":-4.282867682576563,\"arb\":7.7559372906281245,\"failures\":0}},\"validation\":{\"termrisk_100\":{\"runs\":256,\"mean\":-1.2087272712394534,\"standard_error\":0.7090537615486401,\"retail\":-2.0501170544207032,\"arb\":0.8413897831781254,\"failures\":0},\"termrisk_600\":{\"runs\":256,\"mean\":-1.2242118251683594,\"standard_error\":0.7530296542370482,\"retail\":-2.852735629348047,\"arb\":1.6285238041750003,\"failures\":0}}}", "Do not cancel still-profitable asks merely to reduce their size. Small positive result in both tuning halves. {\"screen\":{\"keep_3.0\":{\"runs\":128,\"mean\":0.46558915044531207,\"standard_error\":0.22436188118773173,\"retail\":0.45620159253437476,\"arb\":0.009387557918750105,\"failures\":0},\"keep_10.0\":{\"runs\":128,\"mean\":0.4634994180890617,\"standard_error\":0.2244082361624766,\"retail\":0.45788355189296864,\"arb\":0.005615866202343905,\"failures\":0},\"fifo_keep\":{\"runs\":128,\"mean\":0.4120033162656243,\"standard_error\":0.21867598983295308,\"retail\":0.4154813236757812,\"arb\":-0.0034780074062497482,\"failures\":0},\"allask_keep\":{\"runs\":128,\"mean\":0.4634994180890617,\"standard_error\":0.2244082361624766,\"retail\":0.45788355189296864,\"arb\":0.005615866202343905,\"failures\":0}},\"full_discovery\":{\"runs\":1018,\"mean\":0.13101631339882117,\"standard_error\":0.056223857488088315,\"retail\":0.14478220970913552,\"arb\":-0.013765896311984197,\"failures\":0},\"full_validation\":{\"runs\":1018,\"mean\":0.25007482680697457,\"standard_error\":0.0933930590342362,\"retail\":0.21948393705029462,\"arb\":0.03059088975815322,\"failures\":0}}", "Require a small positive margin above one cent before large stock bids; this was not a floating-point-only issue. {\"boundary_1e-05\":{\"runs\":128,\"mean\":-0.001357664909375167,\"standard_error\":0.0013576649093751667,\"retail\":-0.5982244158953129,\"arb\":0.5968667509859376,\"failures\":0},\"boundary_0.01\":{\"runs\":128,\"mean\":-0.0013512463390626672,\"standard_error\":0.0013577236092835398,\"retail\":-0.5982244158953129,\"arb\":0.59687316955625,\"failures\":0},\"boundary_0.1\":{\"runs\":128,\"mean\":-0.15924278644296871,\"standard_error\":0.15927051947530485,\"retail\":-0.7904511491882813,\"arb\":0.6312083627445312,\"failures\":0}}", "Preserve inventory-bid FIFO priority while retaining the collateral budget; rejected because arbitrage loss outweighed extra retail edge. {\"runs\":128,\"mean\":-5.684016250667188,\"standard_error\":4.046382910351826,\"retail\":0.3603317955882813,\"arb\":-6.044348046253907,\"failures\":0}", "One-tick ask-depletion evidence at ticks >=10: small discovery gain, not independently validated or selected. {\"compask_high\":{\"runs\":128,\"mean\":0.06764381774687452,\"standard_error\":0.06366066251779305,\"retail\":-0.024480288242187086,\"arb\":0.09212410594921784,\"failures\":0},\"compboth\":{\"runs\":128,\"mean\":5.6910340738429674,\"standard_error\":3.809707778442353,\"retail\":-2.149725356799219,\"arb\":7.84075943059453,\"failures\":0}}", "Use only disappearing tick-1 competitor bids as probability evidence; positive in both tuning halves. {\"discovery\":{\"runs\":1018,\"mean\":1.1945519263622788,\"standard_error\":0.5419420027951904,\"retail\":-0.8226026176095286,\"arb\":2.0171545439710217,\"failures\":0},\"validation\":{\"runs\":1018,\"mean\":0.9770986790850688,\"standard_error\":0.3315649805768439,\"retail\":-0.41427157482495064,\"arb\":1.3913702539095285,\"failures\":0}}", "Veto a new bid-depletion bound when a surviving own bid contradicts it; rejected because both variants lost incremental edge on validation. {\"compbid_consistent\":{\"train\":{\"against_base\":{\"runs\":512,\"mean\":1.6278682307039054,\"standard_error\":1.1584088661069964,\"retail\":-2.9887713395326174,\"arb\":4.616639570235937,\"failures\":0},\"increment_over_unguarded\":0.028169704097460984,\"increment_standard_error\":0.01712271961572339},\"valid\":{\"against_base\":{\"runs\":512,\"mean\":0.8142866825339843,\"standard_error\":0.4981676750605344,\"retail\":-1.5271502226689455,\"arb\":2.3414369051876953,\"failures\":0},\"increment_over_unguarded\":-0.11147103713242172,\"increment_standard_error\":0.08162815812243672}},\"compbid_one_consistent\":{\"train\":{\"against_base\":{\"runs\":512,\"mean\":2.0710093996619134,\"standard_error\":0.9521940181534471,\"retail\":-1.364493147398438,\"arb\":3.4355025470611325,\"failures\":0},\"increment_over_unguarded\":0.05610597723593748,\"increment_standard_error\":0.04000095009765479},\"valid\":{\"against_base\":{\"runs\":512,\"mean\":0.5246796290041015,\"standard_error\":0.43561581527558463,\"retail\":-0.8510677178001952,\"arb\":1.3757473468027346,\"failures\":0},\"increment_over_unguarded\":-0.11810186623398455,\"increment_standard_error\":0.083017868544362}}}", "Broader bid-depletion rule with exact lazy quote sizing: positive in both tuning halves but rejected after its unseen mean was negative. {\"discovery\":{\"runs\":1018,\"mean\":0.9294801105931236,\"standard_error\":0.6460721012857276,\"retail\":-2.24397436235275,\"arb\":3.1734544729430256,\"failures\":0},\"validation\":{\"runs\":1018,\"mean\":2.1820621896582515,\"standard_error\":1.279986323210323,\"retail\":-1.4682858787368367,\"arb\":3.6503480683920433,\"failures\":0},\"unseen\":{\"mean\":-0.2595341251184359,\"standard_error\":0.2951767999774335,\"retail\":-2.498066352751295,\"arb\":2.2385322276411883},\"unseen_failures\":0,\"others_identical\":{\"runs\":900,\"identical\":true}}", "Evaluated only two additional designs already coded and fully validated before the first holdout; no strategy changes were made from unseen results. {\"opt_one\":{\"unseen\":{\"mean\":0.14735504741934988,\"standard_error\":0.2127378880848125,\"retail\":-1.4152511485455561,\"arb\":1.5626061959674962},\"failures\":0,\"others_identical\":{\"runs\":900,\"identical\":true},\"timed_seconds\":null},\"keep_3.0\":{\"unseen\":{\"mean\":0.2590219163976132,\"standard_error\":0.05671861876306454,\"retail\":0.26464892607750123,\"arb\":-0.005627009678872584},\"failures\":0,\"others_identical\":{\"runs\":900,\"identical\":true},\"timed_seconds\":96.61415343778208}}", "Delivered code: keep_3.0. Selection among the three unchanged pre-existing designs requires positive unseen mean, zero failures, identical other spreads, and measured time no greater than base; otherwise use the original base. {\"discovery\":{\"runs\":1018,\"mean\":0.13101631339882117,\"standard_error\":0.056223857488088315,\"retail\":0.14478220970913552,\"arb\":-0.013765896311984197,\"failures\":0},\"validation\":{\"runs\":1018,\"mean\":0.25007482680697457,\"standard_error\":0.0933930590342362,\"retail\":0.21948393705029462,\"arb\":0.03059088975815322,\"failures\":0},\"unseen\":{\"mean\":0.2590219163976132,\"standard_error\":0.05671861876306454,\"retail\":0.26464892607750123,\"arb\":-0.005627009678872584},\"seconds\":{\"base\":96.76859576650895,\"yours\":96.61415343778208},\"code_sha256\":\"20846005744d3b4ef5e3ede11456fcc9896f798902ebc1d801735bf0200901fe\"}"], "next": "Investigate how the value of an ask ahead of the competitor should affect resizing, using fresh tuning and unseen seeds. Inventory-bid persistence lost edge and should not be stacked. The narrow bid-observation rule is separately measured here, but combinations require their own validation. Seeds 60000-67999 have now been evaluated for three designs."}