{"approach": "Retains the base cheap crossing inventory and FIFO quoting, blending the original probability-grid estimate equally with the censored latent-score estimate while keeping the original grid uncertainty in quote sizing. The retained cash plan caps main bids at 3000 shares and asks at 6000, uses a 300-step fallback cover horizon with fallback buys below 3.5 cents, and reduces uncovered-ask funding while preserving the base low-price bid coefficients. New uncovered asks leave a $100 reserve, released over the final 50 steps. An inventory-scarcity charge reduces low-price ask edge when stock is small. When YES is below the 300-step cover target and more than 250 steps remain, a two-cent ask joins the competitor and preserves its queue mode until the estimate leaves the low-price range. Direct full replacement of the belief filter, the cash plan stronger low-price bids and unconditional two-cent joining were rejected in the ordered graft tests.", "blocked": null, "python_version": "3.14.4", "base_mean_edge": 102.331987422326, "score": {"mean_edge": 108.54670913062401, "retail_edge": 136.602853288088, "arb_edge": -28.056144157473664, "simulations": 600, "seed_start": 1000, "failures": 0}, "holdout": {"mean_edge": 96.739743692969, "simulations": 600, "seed_start": 30000, "failures": 0}, "code": "\"\"\"Passive quoting with mixed observable-state beliefs and planned YES cover.\n\nMix the probability-grid and censored latent-score estimates equally while\nretaining grid uncertainty in quote sizing. Fund retail asks with cheap YES\ncrossing purchases and a conservative allocation of uncovered-ask collateral.\nAll decisions use only the strategy callback and retained order history.\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=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)\nP.update({'W': 300.0, 'ammo_pmax': 0.035, 'fy': 0.7, 'H1': 250.0, 'kLb': 0.08, 'kLf': 0.08, 'fu': 0.25, 'Hu': 500.0, 'qmax': 6000.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\nNODES = [(-2.2, .06), (-1.3, .17), (-0.6, .27), (0.6, .27), (1.3, .17), (2.2, .06)]\nPROBE = 0.01\n\n\nBLAM = 0.0019\nBJS = 0.4\nLAT_LIK = 1.0\nLAT_JUMPINFO = 1.0\nMIXES = {}\nZTICKS = {}\ndef mixture(H):\n    if H not in MIXES:\n        v=math.exp(-H*BLAM)\n        arr=[]\n        for n in range(16):\n            arr.append((v,1.0/math.sqrt(max(H,1)*0.0004+n*BJS*BJS)))\n            v*=H*BLAM/(n+1)\n        MIXES[H]=arr\n    return MIXES[H]\ndef latent_tick(H,t):\n    if t<=0: return -12.0\n    if t>=100: return 12.0\n    key=(H,t)\n    if key not in ZTICKS:\n        mix=mixture(H)\n        z=inv(t/100.0)*math.sqrt(H*(0.0004+BLAM*BJS*BJS))\n        for _ in range(10):\n            prob=sum(w*cdf(z*r) for w,r in mix)\n            d=sum(w*r*pdf(z*r) for w,r in mix)\n            dz=max(-0.5,min(0.5,(prob-t/100.0)/max(d,1e-12)))\n            z-=dz\n            if abs(dz)<1e-8: break\n        ZTICKS[key]=z\n    return ZTICKS[key]\ndef normal_piece(mean,var,lo,hi):\n    sd=math.sqrt(max(var,1e-12))\n    a=(lo-mean)/sd;b=(hi-mean)/sd\n    if a>0:\n        mass=0.5*(math.erfc(a/SQ2)-math.erfc(b/SQ2))\n    elif b<0:\n        mass=0.5*(math.erfc(-b/SQ2)-math.erfc(-a/SQ2))\n    else:\n        mass=cdf(b)-cdf(a)\n    if mass<1e-200: return 0.0,mean,var\n    pa=pdf(a);pb=pdf(b)\n    shift=(pa-pb)/mass\n    m=mean+sd*shift\n    v=var*max(1e-8,1+(a*pa-b*pb)/mass-shift*shift)\n    return mass,m,v\n\n\ndef inverse_survival(q):\n    q=min(0.5,max(1e-300,q))\n    t=math.sqrt(-2.0*math.log(q))\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    for _ in range(5):\n        x+=(0.5*math.erfc(x/SQ2)-q)/max(pdf(x),1e-300)\n    return max(0.0,x)\n\ndef truncated_quantile(mean,sd,lo,hi,u):\n    a=(lo-mean)/sd;b=(hi-mean)/sd\n    if a>0:\n        qa=0.5*math.erfc(a/SQ2);qb=0.5*math.erfc(b/SQ2)\n        z=inverse_survival(qa+u*(qb-qa))\n    elif b<0:\n        qa=0.5*math.erfc(-a/SQ2);qb=0.5*math.erfc(-b/SQ2)\n        z=-inverse_survival(qa+u*(qb-qa))\n    else:\n        z=inv(cdf(a)+u*(cdf(b)-cdf(a)))\n    return min(hi,max(lo,mean+sd*z))\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.lcb = self.lca = None\n        self.pb = set()\n        self.pa = set()\n        self.tb = 0\n        self.s = None          # competitor spread parameter\n\n    def _oid(self, tag):\n        self.n += 1\n        return tag + str(self.n)\n\n    def remember(self, state, actions):\n        prev = {o.order_id:(o.side,o.price_ticks,o.remaining_quantity) for o in state.own_orders}\n        for action in actions:\n            if isinstance(action, CancelOrder):\n                prev.pop(action.order_id,None)\n            elif isinstance(action, PlaceOrder):\n                prev[action.client_order_id]=(action.side,action.price_ticks,action.quantity)\n        self.previous_orders = prev\n\n    def belief(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.lcb is None:\n            spread=max(1,(ca-cb+1)//2)\n            lo,hi=cb+spread-1,ca-spread+1\n        else:\n            lo,hi=min(cb,self.lcb),max(ca,self.lca)\n        for o in state.own_orders:\n            if o.side is Side.BUY: lo=max(lo,o.price_ticks)\n            else: hi=min(hi,o.price_ticks)\n        if LAT_JUMPINFO and self.lcb is not None:\n            if ca>self.lca+1: lo=max(lo,ca-1)\n            if cb<self.lcb-1: hi=min(hi,cb+1)\n        self.lcb,self.lca=cb,ca\n        if lo>=hi: lo,hi=min(lo,hi)-0.001,max(lo,hi)+0.001\n        prev=getattr(self,'previous_orders',{})\n        survivors={o.order_id:o.remaining_quantity for o in state.own_orders}\n        filled=[[],[]]\n        cuts={lo,hi}\n        for oid,(side,tick,qty) in prev.items():\n            rest=survivors.get(oid,0.0)\n            if qty-rest>0.005:\n                filled[0 if side is Side.BUY else 1].append((tick,qty-rest,rest))\n                if lo<tick<hi: cuts.add(tick)\n        bounds=sorted(cuts)\n        if not hasattr(self,'zm'):\n            zl=latent_tick(H,lo);zh=latent_tick(H,hi)\n            self.zm=(zl+zh)/2; self.zv=(zh-zl)**2/12\n        components=[]\n        points=[]\n        for l,h in zip(bounds,bounds[1:]):\n            c=(l+h)/2\n            like=1.0\n            if LAT_LIK:\n                for side,records in enumerate(filled):\n                    rq=cash=0.0\n                    for tick,qty,rest in records:\n                        isarb=tick>c if side==0 else tick<c\n                        if not isarb:\n                            rq+=qty;cash+=qty*tick/100.0\n                    if rq<=0.005:\n                        like*=0.875\n                    else:\n                        value=rq*max(c/100.0,0.05) if side==0 else cash\n                        k=(math.log(max(value,1e-9))-(math.log(4.5)-0.72))/1.2\n                        tail=1-cdf(k)\n                        if any(rest>0.005 for tick,qty,rest in records):\n                            tail=pdf(k)/max(value*1.2,1e-9)\n                        like*=max(1e-8,0.125*tail)\n            zl=latent_tick(H,l);zh=latent_tick(H,h)\n            for jump,weight in [(0,1-BLAM),(BJS*BJS,BLAM)]:\n                mass,m,v=normal_piece(self.zm,self.zv+0.0004+jump,zl,zh)\n                components.append((weight*mass*like,m,v))\n                if mass > 1e-100:\n                    sd=math.sqrt(self.zv+0.0004+jump)\n                    aa=cdf((zl-self.zm)/sd)\n                    bb=cdf((zh-self.zm)/sd)\n                    for u,qw in [(0.1127016654,5/18),(0.5,4/9),(0.8872983346,5/18)]:\n                        zz=truncated_quantile(self.zm,sd,zl,zh,u)\n                        pp=sum(w*cdf(zz*r) for w,r in mixture(H))\n                        points.append((weight*mass*like*qw,pp))\n        total=sum(w for w,m,v in components)\n        if total<=1e-150:\n            zl=latent_tick(H,lo);zh=latent_tick(H,hi)\n            self.zm=max(zl,min(zh,self.zm));self.zv=0.0004\n        else:\n            m=sum(w*m for w,m,v in components)/total\n            v=sum(w*(v+(mm-m)**2) for w,mm,v in components)/total\n            self.zm,self.zv=m,max(v,1e-10)\n        mean=sum(w*cdf(self.zm/math.sqrt(1/r**2+self.zv)) for w,r in mixture(H))\n        if total > 1e-150 and points:\n            mean=sum(w*pp for w,pp in points)/total\n            v=max(0,sum(w*(pp-mean)**2 for w,pp in points)/total)\n        else:\n            deriv=sum(w*r*pdf(self.zm*r) for w,r in mixture(H))\n            v=deriv**2*self.zv\n        return min(0.999999,max(0.000001,mean)),v\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        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        grid_p, grid_v = phat, var_t\n        latent_p, latent_v = self.belief(state)\n        phat = 0.5 * latent_p + (1 - 0.5) * grid_p\n        var_t = 1.0 * grid_v\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            if phat < 0.1:\n                a = max(0.0, a - 0.0025 * (1 - min(1.0, state.yes_inventory / 3000.0)))\n            return qsize(b, a, t / 100.0)\n\n        bids = [o for o in state.own_orders if o.side is Side.BUY and o.remaining_quantity > PROBE + 1e-9]\n        asks = [o for o in state.own_orders if o.side is Side.SELL and o.remaining_quantity > PROBE + 1e-9]\n        sticky = P['sticky'] > 0\n        def top(orders, comp, step):\n            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 = min(3000.0, qbid(bid_t))\n        qa = qask(ask_t)\n\n        Y = state.yes_inventory\n        if phat >= 0.02:\n            self.join_phase = False\n        if ask_t == 1 and H > 250 and Y < P['ydem'] * min(H, P['W']) / 0.01:\n            self.join_phase = True\n        join_low = ask_t == 1 and H > 250 and getattr(self, 'join_phase', False)\n        if join_low:\n            ask_t = 2\n            qa = qask(ask_t)\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            q1 = max(0.0, P['ydf1'] * min(H, P['Wf']) / (self.s / 100.0) - Y)\n        # order management\n        actions = []\n        free = state.free_cash - 2.0\n        keep_ask = 0.0\n        new_b = []\n        new_a = []\n        def cancel(o):\n            nonlocal free\n            actions.append(CancelOrder(o.order_id))\n            x = o.price_ticks / 100.0\n            if o.side is Side.BUY:\n                free += x * o.remaining_quantity\n            else:\n                free += (1 - x) * min(self.res.get(o.order_id, 0.0), o.remaining_quantity)\n            self.ahead.discard(o.order_id)\n            self.res.pop(o.order_id, None)\n        for o in state.own_orders:\n            if o.remaining_quantity <= PROBE + 1e-9:\n                cancel(o)\n        kept_ids = set()\n        def manage(orders, t, q, comp):\n            kept = 0.0\n            for o in orders:\n                if o.price_ticks == t and q > 0 and kept + o.remaining_quantity <= max(q * P['keep_hi'], 1.0):\n                    kept += o.remaining_quantity\n                    kept_ids.add(o.order_id)\n                else:\n                    cancel(o)\n            return kept\n        kb = manage(bids, bid_t, qb, cb)\n        ka = manage(asks, ask_t, qa, ca)\n        add_b = (qb - kb) if (kb < qb * P['keep_lo'] and bid_t != cb) else 0.0\n        add_a = (qa - ka) if (ka < qa * P['keep_lo'] and (ask_t != ca or join_low)) 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), client_order_id=self._oid('l')))\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, client_order_id=self._oid('m')))\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                ub = min(ub, max(0.0, free - 100.0 * min(1.0, H / 50.0)))\n                unc = min(unc, ub / (1 - x))\n            q = fl(min(add_a, cov + unc))\n            if q >= 0.01:\n                oid = self._oid('a')\n                out.append(PlaceOrder(side=Side.SELL, price_ticks=ask_t, quantity=q, client_order_id=oid))\n                r = max(0.0, q - cov)\n                self.res[oid] = r\n                free -= r * (1 - x) + 1e-6\n                if ask_t < ca:\n                    self.ahead.add(oid)\n\n        # probes: tiny orders that the arbitrageur removes when p crosses them\n        f = int(math.floor(ptick + 1e-9))\n        r = max(int(P['rmin']), int(math.ceil(2.0 * s * 100)))\n        self.pb = set()\n        self.pa = set()\n        if free > 1.0:\n            for t in range(f, f + r + 1):\n                if cb < t < ca and 1 <= t <= 99:\n                    out.append(PlaceOrder(side=Side.BUY, price_ticks=t, quantity=PROBE, client_order_id=self._oid('p')))\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, client_order_id=self._oid('p')))\n                    self.pa.add(t)\n        self.remember(state, actions + out)\n        return actions + out\n", "code_sha256": "f0092a833255eab4fa4ab34ebe4532469a42c17dfb0644dd5a5fb1d6c375512d", "tried": ["Unmodified public simulator commit b244530ee2a6247b5f930830eeca9dd950da0e7e. Python 3.14.4. --workers 4 was denied by PermissionError on AF_UNIX; independent serial runs were used. Final CLI and sandbox checks also use the unmodified simulator.", "Scorer check, supplied reference mean_edge=102.33197908899267: {\"mean_edge\":102.331987422326,\"retail_edge\":127.3199510028995,\"arb_edge\":-24.987963580578832,\"simulations\":600,\"seed_start\":0,\"failures\":0}", "Current base tuning control: {\"mean_edge\":107.2442092237515,\"retail_edge\":135.801656522888,\"arb_edge\":-28.557447299150834,\"simulations\":600,\"seed_start\":1000,\"failures\":0}", "Ordered step 1: direct censored latent belief graft, posterior sizing variance removed: {\"mean_edge\":105.47736546872316,\"retail_edge\":138.131417599906,\"arb_edge\":-32.65405213119983,\"simulations\":600,\"seed_start\":1000,\"failures\":0}", "Ordered step 2: full cash-plan graft after direct belief: {\"mean_edge\":103.87681671474083,\"retail_edge\":138.52367773485733,\"arb_edge\":-34.646861020132164,\"simulations\":600,\"seed_start\":1000,\"failures\":0}", "Ordered step 3: unconditional two-cent ask after belief and cash, stopped as unpromising after this completed screen: {\"mean_edge\":105.1899169896785,\"retail_edge\":139.18495595204502,\"arb_edge\":-33.995038962365,\"simulations\":200,\"seed_start\":1000,\"failures\":0}", "Belief screen: half posterior variance: {\"mean_edge\":112.86671990989251,\"retail_edge\":137.6979530229875,\"arb_edge\":-24.831233113159,\"simulations\":200,\"seed_start\":1000,\"failures\":0}", "Belief screen: full posterior variance: {\"mean_edge\":113.09998665082499,\"retail_edge\":136.8586168128255,\"arb_edge\":-23.7586301620335,\"simulations\":200,\"seed_start\":1000,\"failures\":0}", "Belief screen: disable fill-size likelihood: {\"mean_edge\":109.373782663732,\"retail_edge\":139.024223941572,\"arb_edge\":-29.65044127785,\"simulations\":200,\"seed_start\":1000,\"failures\":0}", "Belief screen: smaller assumed jump sigma 0.3: {\"mean_edge\":113.12523692709699,\"retail_edge\":139.2433874927655,\"arb_edge\":-26.118150565707502,\"simulations\":200,\"seed_start\":1000,\"failures\":0}", "Belief screen: use latent point estimate only below five cents: {\"mean_edge\":112.53519158707249,\"retail_edge\":135.801808396166,\"arb_edge\":-23.2666168091535,\"simulations\":200,\"seed_start\":1000,\"failures\":0}", "Two-cent ask alone on current base, stopped after screen: {\"mean_edge\":105.46838381782,\"retail_edge\":134.061204854168,\"arb_edge\":-28.5928210364215,\"simulations\":200,\"seed_start\":1000,\"failures\":0}", "Two-cent ask with one-tick-spread crossing-stock target halved, stopped after screen: {\"mean_edge\":105.983359094788,\"retail_edge\":133.714001782687,\"arb_edge\":-27.7306426879735,\"simulations\":200,\"seed_start\":1000,\"failures\":0}", "Remove grid posterior variance only: {\"mean_edge\":105.19729813998417,\"retail_edge\":138.26200980250516,\"arb_edge\":-33.0647116625325,\"simulations\":600,\"seed_start\":1000,\"failures\":0}; paired delta versus current base=-2.046911083767333, paired standard error=0.5391682660913996.", "Latent filter with half posterior variance, full-range extension: {\"mean_edge\":106.20498713486417,\"retail_edge\":136.7082851814695,\"arb_edge\":-30.503298046624,\"simulations\":600,\"seed_start\":1000,\"failures\":0}; paired delta versus current base=-1.0392220888873336, paired standard error=0.8168398774760959.", "Full cash plan on original filter: {\"mean_edge\":106.35239915569417,\"retail_edge\":137.19331853103284,\"arb_edge\":-30.840919375353998,\"simulations\":600,\"seed_start\":1000,\"failures\":0}; paired delta versus current base=-0.8918100680573341, paired standard error=0.5552703353429792.", "Smaller-jump latent filter without posterior variance plus revised cash plan: {\"mean_edge\":107.24152754505134,\"retail_edge\":138.83020864629634,\"arb_edge\":-31.588681101275167,\"simulations\":600,\"seed_start\":1000,\"failures\":0}; paired delta versus current base=-0.002681678700167763, paired standard error=0.8042254658988983.", "Ask cap plus unlatched scarce-stock two-cent join, YES below 1500 and H above 250: {\"mean_edge\":107.24931266812949,\"retail_edge\":136.36348647890165,\"arb_edge\":-29.114173810788834,\"simulations\":600,\"seed_start\":1000,\"failures\":0}; paired delta versus current base=0.005103444377999415, paired standard error=0.3264094780607288.", "Equal grid/latent point blend, original grid sizing variance: {\"mean_edge\":107.47491274075082,\"retail_edge\":135.936838086961,\"arb_edge\":-28.461925346220337,\"simulations\":600,\"seed_start\":1000,\"failures\":0}; paired delta versus current base=0.2307035169993335, paired standard error=0.607847345056203.", "Cash-plan ask cap alone: asks 6000, main bids 3000: {\"mean_edge\":107.4944125799505,\"retail_edge\":136.64956964013885,\"arb_edge\":-29.1551570602045,\"simulations\":600,\"seed_start\":1000,\"failures\":0}; paired delta versus current base=0.25020335619899936, paired standard error=0.23447187740227432.", "Belief blend with disagreement variance plus larger ask cap: {\"mean_edge\":107.50518750075267,\"retail_edge\":135.997214286802,\"arb_edge\":-28.492026786060336,\"simulations\":600,\"seed_start\":1000,\"failures\":0}; paired delta versus current base=0.2609782770011662, paired standard error=0.6160923111816842.", "Belief blend plus latched join with the same 300-step join forecast, base cash execution and cover sizing: {\"mean_edge\":107.873247264309,\"retail_edge\":135.8197494061972,\"arb_edge\":-27.946502141897835,\"simulations\":600,\"seed_start\":1000,\"failures\":0}; paired delta versus current base=0.6290380405575001, paired standard error=0.5573996085663854.", "Belief and revised cash plan without scarcity edge charge: {\"mean_edge\":108.077889862351,\"retail_edge\":136.247610143505,\"arb_edge\":-28.169720281161336,\"simulations\":600,\"seed_start\":1000,\"failures\":0}; paired delta versus current base=0.8336806385994997, paired standard error=0.6270027415315126.", "Belief and revised cash plan without absolute cash reserve: {\"mean_edge\":108.096069142835,\"retail_edge\":135.28448293110867,\"arb_edge\":-27.188413788282165,\"simulations\":600,\"seed_start\":1000,\"failures\":0}; paired delta versus current base=0.8518599190835004, paired standard error=0.6525951287767462.", "Revised cash plan plus latched cover-target two-cent join, original belief: {\"mean_edge\":108.16920627028284,\"retail_edge\":136.30805874767702,\"arb_edge\":-28.138852477411334,\"simulations\":600,\"seed_start\":1000,\"failures\":0}; paired delta versus current base=0.9249970465313326, paired standard error=0.43216005768870003.", "Revised cash plan without absolute cash reserve: {\"mean_edge\":108.18770896509618,\"retail_edge\":135.892378640083,\"arb_edge\":-27.70466967500567,\"simulations\":600,\"seed_start\":1000,\"failures\":0}; paired delta versus current base=0.9434997413446659, paired standard error=0.3794090079279496.", "All three without scarcity edge charge: {\"mean_edge\":108.26134214581249,\"retail_edge\":136.68731563769717,\"arb_edge\":-28.425973491893334,\"simulations\":600,\"seed_start\":1000,\"failures\":0}; paired delta versus current base=1.0171329220609997, paired standard error=0.6363428275864529.", "Belief and revised cash plan with 3000-share ask cap: {\"mean_edge\":108.29468589688734,\"retail_edge\":135.64866422728733,\"arb_edge\":-27.353978330410666,\"simulations\":600,\"seed_start\":1000,\"failures\":0}; paired delta versus current base=1.050476673135833, paired standard error=0.5702080572323336.", "Cash plan with original low-price bid coefficients restored: {\"mean_edge\":108.29688108057132,\"retail_edge\":136.44930641027167,\"arb_edge\":-28.15242532971767,\"simulations\":600,\"seed_start\":1000,\"failures\":0}; paired delta versus current base=1.0526718568198323, paired standard error=0.3756086549306726.", "Belief blend plus revised cash plan, no two-cent join: {\"mean_edge\":108.49333685203051,\"retail_edge\":136.2148266766215,\"arb_edge\":-27.721489824600496,\"simulations\":600,\"seed_start\":1000,\"failures\":0}; paired delta versus current base=1.2491276282789998, paired standard error=0.6155084458059281.", "Three-way stack: cash execution and cover changes contribution, join forecast held at 300 steps: paired mean delta=0.6734618663149996, standard error=0.5037197996181169, simulations=600.", "Three-way stack: belief blend contribution: paired mean delta=0.37750286034116737, standard error=0.5112614267976053, simulations=600.", "Three-way stack: latched two-cent join contribution; weak evidence relative to sampling uncertainty: paired mean delta=0.053372278593500036, standard error=0.2882970959069739, simulations=600.", "All search and selection used seeds 1000-1599 only; seeds 0-599 were used solely for the requested base scorer check. The original bank and crossing orders were preserved when grafting the older strategies. No seed recognition, hidden state or path replay is used by the submitted strategy.", "Unmodified --sandbox: final file passed 20/20 simulations on seeds 1000-1019; starter passed 20/20 too. nsjail is absent, so the runner used Python-level sandboxing. No sandbox patch was applied.", "Frozen selected code versus current base on the tuning range: paired mean delta=1.3024999068724998, standard error=0.6362861954777593, simulations=600.", "The holdout score is absolute performance: no base control was scored on seeds 30000-30599, and no holdout result was used for selection.", "Final selected blend_cashold_latched; code was frozen before CLI re-scoring and the single untouched holdout. Frozen CLI tuning score: {\"mean_edge\":108.54670913062401,\"retail_edge\":136.602853288088,\"arb_edge\":-28.056144157473664,\"simulations\":600,\"seed_start\":1000,\"failures\":0}; Untouched holdout, evaluated once with no subsequent strategy changes: {\"mean_edge\":96.739743692969,\"retail_edge\":124.67696603950249,\"arb_edge\":-27.937222346537336,\"simulations\":600,\"seed_start\":30000,\"failures\":0}."], "next": "Test a queue-depth and waiting-cost model for two-cent joins on fresh seeds. The join and belief increments are small relative to paired uncertainty, so preserve removal controls and do not reuse seeds 30000-30599 for further selection. Investigate joint model uncertainty and the future value of cash before another global constant sweep."}