{"approach": "The base strategy (probes that locate p to about a tick, a sub-tick grid filter, quotes one tick inside the competitor sized by a marginal retail-edge versus arbitrage-loss rule, YES ammunition below 5c) plus depth. What changed: (1) a level behind the best on each side, at the competitor's own tick, in the queue behind its remaining order; each share is quoted while rho * reach * gain exceeds kD * expected arbitrage loss, where reach is the lognormal chance that a retail order walks past our better-priced shares and the competitor's remaining size, averaged with that size uniform on [0, C] and C=48, which gives (G(v)-G(v+C))/C with G the lognormal partial expectation; bids convert through the max(p, 0.05) share rule; depth asks below 10c must be covered by YES. (2) Any order that has been better than the competitor's best is remembered as ahead, so if the competitor later replenishes at that tick it is kept as a second level rather than cancelled, unless it is under af=0.15 of what that tick could carry. (3) Constants re-tuned on seeds 0-599: m=6.5, kA=0.85, ydem=0.3, W=300, kD=1.4, kDL=0.1. Findings: depth paid about +3.7 in a near-final build (kD=1.0), nearly all in one-tick-spread runs near zero (spread-1 runs 20.5 to 35.6); a second level behind added nothing; deep orders took 9.5 of retail edge a run for 2.3 of arbitrage loss when the price moved through them. Mid-book, depth does little because the arbitrageur moves the competitor's best every few steps. Python was absent on this machine, so a standalone CPython 3.12.16 was installed under .cache and checked against its release SHA256SUMS. Holdout warning: the gain mostly did not carry over. On seeds 0-599 the frozen file beats the base by 6.35 (93.77 against 87.42), but on holdout seeds 20000-20599 by only 0.83 +- 1.16 (86.29 against 85.47, paired), which is not distinguishable from zero. The re-tuned constants look overfitted: they raised retail edge by about 6 on the holdout while arbitrage loss grew by 5.25.", "blocked": null, "python_version": "3.12.16", "base_mean_edge": 78.85441957511699, "score": {"mean_edge": 93.76595517582717, "retail_edge": 124.72376673420334, "arb_edge": -30.957811558353665, "simulations": 600, "seed_start": 0, "failures": 0}, "holdout": {"mean_edge": 86.2936744977625, "simulations": 600, "seed_start": 20000, "failures": 0}, "code": "\"\"\"Stale-quote defence with tick probes, a sub-tick belief, YES ammunition and depth.\n\nEvery step the arbitrageur removes any order on the wrong side of p, so tiny\ntwo-sided probes around the estimate locate p to a tick; a grid filter narrows\nthat further.  Quotes sit one tick inside the competitor and are sized by the\nmarginal rule: one more share is worth quoting while the chance a retail order\nreaches it, times its edge, exceeds the expected arbitrage loss.  Near p=0 a\nretail buy pays almost its whole notional as edge, so YES is held to cover low asks.\n\nDepth: one level behind the best sits in the queue at the competitor's tick and\nis sized by the same rule, where the chance of reaching a share averages over\nthe competitor's remaining size, taken as uniform on [0, C].  When retail clears\nthe competitor's order, the level is left at the front.  Orders that are already\nahead of a competitor order at its tick stay there as a second level unless they\nare under af of what that tick could carry.\n\"\"\"\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=6.5, sig_n=1.2, lam_j=0.0019, sig_j=0.35, sig=0.02,\n         qmax=3000.0, rmin=2, kA=0.85, kL=0.15, pL=0.05,\n         ammo=1.0, ydem=0.3, W=300.0, fy=0.6, ammo_q=60.0, ammo_pmax=0.05, ammo_maxpay=0.02,\n         fb=0.9, fu=0.5, 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=1500.0, H1=100.0,\n         L=1.0, kD=1.4, kDL=0.1, C=48.0, dfb=0.5, dq=3000.0, dcov=1.0, af=0.15, premin=0.0, dg=1.0)\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\ndef G(v, m, mu, sg):\n    # E[(N - v)+] for lognormal N with mean m\n    if v <= 1e-9:\n        return m - v\n    d2 = (mu - math.log(v)) / sg\n    return m * cdf(d2 + sg) - v * cdf(d2)\n\n\ndef reach(v, C, m, mu, sg):\n    # P(N > v + R), with R, the competitor's remaining level, uniform on [0, C]\n    return (G(v, m, mu, sg) - G(v + C, m, mu, sg)) / C\n\n\ndef depth_v(v0, tail, C, m, mu, sg):\n    # largest v >= v0 with reach(v) >= tail, else None\n    if tail >= reach(v0, C, m, mu, sg):\n        return None\n    lo, hi = v0, v0 + 8.0\n    while hi < 1e5 and reach(hi, C, m, mu, sg) > tail:\n        lo, hi = hi, hi * 2 + 8.0\n    for _ in range(10):\n        mid = 0.5 * (lo + hi)\n        if reach(mid, C, m, mu, sg) > tail:\n            lo = mid\n        else:\n            hi = mid\n    return lo\n\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\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        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 sb and eb:\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        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 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:\n                ah = sum(o.remaining_quantity for o in orders if o.price_ticks == comp and o.order_id in self.ahead)\n                if ah >= P['min_ahead']:\n                    if P['af'] <= 0 or ah >= P['af'] * (qbid(comp) if step > 0 else qask(comp)):\n                        return comp\n            return comp + step\n        for o in bids:\n            if o.price_ticks > cb:\n                self.ahead.add(o.order_id)\n        for o in asks:\n            if o.price_ticks < ca:\n                self.ahead.add(o.order_id)\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 = 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 < P['ammo_pmax']:\n            wealth = state.cash + Y * phat\n            x = max(ask_t, ptick + 1) / 100.0\n            target = min(P['ydem'] * min(H, P['W']) / x, P['fy'] * wealth / max(phat, 0.005))\n            if Y < target:\n                t = max(1, min(99, int(math.ceil(ptick + 1e-9))))\n                if bid_t <= t < ask_t and t / 100.0 - phat < P['ammo_maxpay']:\n                    amt = t\n                    qam = min(P['ammo_q'], target - Y)\n\n        if P['pre'] > 0 and ca == 2 and P['premin'] <= phat < 0.01 and H > P['H1'] and Y < P['pre'] and not qam:\n            amt, qam = 1, min(P['ammo_q'], P['pre'] - Y)\n        # depth: levels behind the best, each sized by the chance a retail order walks to it\n        def ladder(side, t0, q0, comp):\n            out = []\n            if P['L'] < 1 or comp is None or comp <= 0 or comp >= 100:\n                return out\n            if min(phat, 1.0 - phat) > P['dg']:\n                return out\n            m_, step = P['m'], (1 if side == 'a' else -1)\n            kD = P['kDL'] if phat < P['pL'] else P['kD']\n            own = q0 * (t0 / 100.0 if side == 'a' else max(phat, 0.05))\n            for k in range(1, int(P['L']) + 1):\n                t = t0 + k * step\n                if not 1 <= t <= 99:\n                    break\n                j = (t - comp) * step\n                if j < 0:\n                    continue\n                x = t / 100.0\n                a, b = AB(x)\n                loss, gain = (b, a) if side == 'a' else (a, b)\n                if gain <= 0:\n                    continue\n                # in units of retail notional: an ask share costs x, a bid share costs max(p, floor)\n                unit = x if side == 'a' else max(phat, 0.05)\n                C_ = P['C'] * unit / x\n                tail = kD * loss / (rho * gain)\n                v0 = own + j * C_\n                v = depth_v(v0, tail, C_, m_, mu, P['sig_n'])\n                if v is None:\n                    continue\n                q = min(P['dq'], (v - v0) / unit)\n                if q >= 0.01:\n                    out.append((t, q))\n                    own += q * unit\n            return out\n        lad_b = ladder('b', bid_t, qb, cb)\n        lad_a = ladder('a', ask_t, qa, ca)\n        if P['af'] > 0:\n            def second(lad, orders, t0, q0, comp, qf):\n                if t0 == comp:\n                    return lad\n                ah = sum(o.remaining_quantity for o in orders if o.price_ticks == comp and o.order_id in self.ahead)\n                if ah <= 0:\n                    return lad\n                q2 = min(ah, max(0.0, qf(comp) - q0))\n                d = dict(lad)\n                d[comp] = d.get(comp, 0.0) + q2\n                return sorted(d.items(), key=lambda kv: abs(kv[0] - t0))\n            lad_b = second(lad_b, bids, bid_t, qb, cb, qbid)\n            lad_a = second(lad_a, asks, ask_t, qa, ca, qask)\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, targets):\n            kept = {t: 0.0 for t in targets}\n            for o in orders:\n                q = targets.get(o.price_ticks, 0.0)\n                if q > 0 and kept[o.price_ticks] + o.remaining_quantity <= max(q * P['keep_hi'], 1.0):\n                    kept[o.price_ticks] += o.remaining_quantity\n                    kept_ids.add(o.order_id)\n                else:\n                    cancel(o)\n            return kept\n        tb = dict(lad_b)\n        tb[bid_t] = qb\n        ta = dict(lad_a)\n        ta[ask_t] = qa\n        kept_b = manage(bids, tb)\n        kept_a = manage(asks, ta)\n        kb, ka = kept_b[bid_t], kept_a[ask_t]\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        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        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        if ask_t <= 99 and add_a >= 0.01:\n            x = ask_t / 100.0\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                cov = max(0.0, cov - q)\n                free -= r * (1 - x) + 1e-6\n                if ask_t < ca:\n                    self.ahead.add(oid)\n\n        # depth orders: placed last, from what is left of the budget\n        for t, q in lad_b:\n            add = q - kept_b[t]\n            if kept_b[t] < q * P['keep_lo'] and add >= 0.01:\n                add = fl(min(add, P['dfb'] * max(free, 0.0) / (t / 100.0)))\n                if add >= 0.01:\n                    oid = self._oid('db')\n                    out.append(PlaceOrder(side=Side.BUY, price_ticks=t, quantity=add, client_order_id=oid))\n                    free -= add * t / 100.0 + 1e-6\n        for t, q in lad_a:\n            add = q - kept_a[t]\n            if kept_a[t] < q * P['keep_lo'] and add >= 0.01:\n                x = t / 100.0\n                c_ = max(0.0, cov)\n                unc = max(0.0, add - c_)\n                if unc > 0:\n                    ub = P['dfb'] * max(free, 0.0) if x >= P['xu'] and P['dcov'] <= 0 else 0.0\n                    if x >= P['xu'] and P['dcov'] > 0:\n                        ub = P['dfb'] * max(0.0, free - (1 - P['fu']) * max(state.cash, 0.0))\n                    unc = min(unc, ub / (1 - x))\n                add = fl(min(add, c_ + unc))\n                if add >= 0.01:\n                    oid = self._oid('da')\n                    out.append(PlaceOrder(side=Side.SELL, price_ticks=t, quantity=add, client_order_id=oid))\n                    r = max(0.0, add - c_)\n                    self.res[oid] = r\n                    cov = max(0.0, cov - add)\n                    free -= r * (1 - x) + 1e-6\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        return actions + out\n", "code_sha256": "ab37a1e3f765dae67e014f76a2e01ee694c28200036c3cb275ba307e837cd2fb", "tried": ["Environment: no Python on the machine although the brief says to report blocked in that case; the task's rules allow installing what is needed, so CPython 3.12.16 (python-build-standalone 20261026, SHA256 checked) went under .cache and the base reproduced exactly at 78.85441957511699 on seeds 0-199", "All scores below are means on seeds 0-599 from a local harness that runs the public engine in a process pool, paired by seed; +- is the paired standard error. A depth-free refactor (L=0) gave 87.417, identical to the base on those seeds (retail 116.131, arb -28.715)", "An interim file (first depth build: L=1, kD 0.7, kDL 0.15, no af, base constants) was scored on the holdout at 86.970 so a valid result existed; no tuning decision used that number", "Age model, learning the competitor's size from clears: 88.254, and 84.148 with L=2; size learning alone 87.194. Most detected clears were arbitrage sweeps at 2 to 4 of model notional, which biased size low and oversized depth (deep arb -7.7)", "Age model with fixed C=48: 91.078, against 91.324 without; deep arb fell to -0.150 with deep retail 7.980, but the total did not rise, so the simpler uniform model was kept. Kept off after kD 0.5 (91.098), L=2 (91.150), kDL 0.3 (90.401), C=32 (91.163)", "Sweeps with no gain, against 91.324: pre 3000 91.348, pre 6000 90.598, pL 0.08 90.494, xu 0.05 90.722, ammo below 8c 89.726, kA 0.5 90.639, kA 1.0 90.840, kL 0.08 90.971, kL 0.25 90.244, ammo_maxpay 0.008 91.302, min_ahead 0.5 91.304, min_ahead 6 91.364, premin gate 91.339 at most", "Second level from ahead orders, by af: 1.0 85.147, 0.6 89.153, 0.3 91.947, 0.15 92.385", "Against 91.947 or 92.385 as baseline, one at a time: W 60 89.770, W 120 91.183, lam_j 0.0012 91.180, lam_j 0.003 91.462, sig_j 0.25 90.955, sig_j 0.5 90.816, m 4 89.434, sig_n 1.0 89.441, lam_r 0.32 92.152, W 300 92.238, m 5.7 92.464, m 6.5 92.299, W 300 with ydem 0.3 92.621, sig_n 1.4 92.820, m 6.5 with kA 0.85 93.229", "Combined W 300, ydem 0.3 with: m 6 sig_n 1.3 kA 0.8 93.109; m 5.5 sig_n 1.4 kA 0.8 93.187; m 6.5 sig_n 1.3 kA 0.95 kL 0.12 93.401; m 6.5 kA 0.85 kL 0.12 93.481; m 6.5 kA 0.85 93.533", "Depth with no levels in that build (L=0): 89.849, a loss of 3.684 +- 0.768; spread-1 runs 20.5 against 35.6, other spreads about unchanged. Level split with L=1: deep retail 9.483, deep arb -2.318, on 651.5 shares a run taken by the arbitrageur; L=2: 93.508, deep arb -2.333, so the second level is almost never reached", "First depth build: kD 0.35 88.978, kD 0.7 90.852 (+3.435 +- 0.698 on the base; deep retail 8.428, deep arb -1.336), kD 1.0 with kDL 0.1 91.324, kD 1.2 91.179, kDL 0.05 90.942, kDL 0.4 89.898, C 24 89.898, C 90 90.794, L=2 90.866", "Rejected as within noise on the final build: kD 2.0 93.800, depth only below 10c or above 90c 93.707, only below 25c or above 75c 93.802, qmax 6000 93.609 (kD 1.0). Margins this small are likely selection noise, so the simpler form was kept", "Final: kD 1.4 at 93.766 in the harness (+0.233 +- 0.127 on kD 1.0)", "--sandbox on 20 simulations: the frozen file passed 20/20 (mean 89.689, Python-level sandbox, nsjail not found), and examples/starter_strategy.py also passed 20/20 at -4.396, so the reported 3.12 sandbox failure did not reproduce on 3.12.16 here", "Frozen file through the public CLI: 93.76595517582717 on seeds 0-599 and 86.2936744977625 on holdout seeds 20000-20599, with no failures", "Reported after freezing, changing nothing: on the same holdout the base scores 85.468 (retail 116.734, arb -31.266), the frozen file +0.826 +- 1.164 on it (retail 122.812, arb -36.518; deep retail 6.968, deep arb -3.617), and the interim depth-only file +1.502 +- 0.639. The interim file scoring higher is within noise and comes from the holdout, so the file was not switched back; a next seat should treat the depth-only form with base constants as the better-supported one and test it on fresh seeds"], "next": "First test, on fresh seeds, whether the depth-only form (L=1, base constants) beats this frozen file: on the holdout it was +1.50 +- 0.64 on the base against +0.83 +- 1.16 here, and the re-tuned m=6.5, kA=0.85 grew arbitrage loss by more on the holdout than on the tuning seeds. Use nested validation inside seeds 0-599 for constants, since gains under about 1.5 at 600 seeds did not survive. Depth is nearly exhausted: a second level adds nothing and only the quiet regions pay. Combine this one level with whatever other items find rather than extending it. Near zero with spread 1 the limit is YES held ahead of the competitor's replenished order: capture is about Q/(Q+C), and raising pre alone did not pay because each share costs 0.5 to 0.8c to buy; try buying YES at retail-sell fills or sizing it from demand measured inside the run. Size constants moved toward a larger, heavier retail tail (m=6.5 against about 4.5 true mean), which suggests a mixture over the run's unknown m and rate, or an online estimate, in place of one lognormal. A level-age model needs a clearance detector that separates retail clears from arbitrage sweeps; the simple one here did not."}