{"approach":"For spread 4 only, remove the special low-price bid-risk discount by setting kLb and kLf to the existing kL during initialization. Separate crossing-cover and stock orders remain available. Logging identified buying stock above the moved probability as the largest measured low-price leak; restoring the ordinary penalty reduces speculative replenishment while retaining retail asks. No new constant, seed recognition, external dependency, or changes to other spreads. Static capacity diagnostics are not claimed as causal backtest gains.","blocked":null,"spread":4,"base_mean_edge":108.63974289615767,"found":["Provenance: simulator commit b244530ee2a6247b5f930830eeca9dd950da0e7e; start code SHA256 4bbf720ff34be09b441e84a7e0c1bf47cba036b5211c4118e44a597f941453db. All measurements use unmodified engine scoring; market subclass only records observations.","Choosing: 2050 spread-4 seeds in [30000,38000); 259 rich runs have true post-move probability below 0.02 for more than 500 steps. Mean such steps=807.9073359073359. No run-count halving: scorer calibration took 84.17 seconds.","Rich-run means during those low-price steps: offered retail BUY dollars=449.0493547219894; participant ask edge retained=398.703310034005; static ask-capacity edge gap=9.008276504530185; static no-stock edge gap=0.5260888439308633; static worse-tick edge gap=0.0025772618874534757; arbitrage loss on bids filled below 2c=14.790665960201736.","Whole rich-run means, including steps above 2c: offered retail BUY dollars=1129.3614709670753; retained participant ask edge=506.5963866931555. Both additional logging passes reproduced edge, retail edge and arbitrage edge exactly on all 259 rich runs.","Capacity gaps are observational proxies, include lot-rounding dust and risk-withheld quotes, and are not independently executable gains: opportunity is offered dollars*(1-p/front_price), front_price=(current competitor ask-1)/100. The price gap is computed only on our actual sale notional. Remaining nonnegative gap is no_stock when YES 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 == 4:\n # Use the existing low-price risk penalty on bids too; inventory\n # cover orders already provide the separate stocking mechanism.\n self.params['kLb'] = self.params['kLf'] = self.params['kL']\n # Censored compound-Poisson flow likelihood, using only our fills.\n self.f4_exposure = [0, 0]\n self.f4_events = [0, 0]\n self.f4_weights = [[0.0] * 9, [0.0] * 9]\n self.f4_means = [2.64 + i * (6.336 - 2.64) / 8 for i in range(9)]\n # Positive aggregate flow is approximately lognormal; +0.065\n # accounts for the occasional second arrival in a timestep.\n self.f4_mu = [math.log(m) - 0.72 + 0.065 for m in self.f4_means]\n self.f4_last = [None, None]\n self.f4_rate = 0.1265\n self.f4_mean = 4.488\n self.f4_flow = self.f4_rate * self.f4_mean\n self.f4_extreme = inv(1 - 1e-6)\n if self.s == 2:\n self.params.update(dict(W=150, ammo_pmax=0.02, fy=0.7, fu=0.25, Hu=500))\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 == 4:\n for side, filled, bound in ((0, state.sell_filled_quantity, ca), (1, state.buy_filled_quantity, cb)):\n last = self.f4_last[side]\n if last is None:\n continue\n tick, conv, cap, old_bound, ids = last\n if (side == 0 and bound > old_bound + 1) or (side == 1 and bound < old_bound - 1):\n continue\n # Track only the main quote, excluding probes and stock orders.\n remaining = sum(o.remaining_quantity for o in state.own_orders if o.order_id in ids)\n value = max(0.0, cap - remaining * conv)\n self.f4_exposure[side] += 1\n if value > 0.01:\n self.f4_events[side] += 1\n censored = remaining < 0.011\n logv = math.log(max(value, 0.01))\n weights = self.f4_weights[side]\n for i, mu4 in enumerate(self.f4_mu):\n z4 = (logv - mu4) / 1.2\n weights[i] += math.log(max(1e-12, 1.0 - cdf(z4))) if censored else -0.5 * z4 * z4\n if state.step % 25 == 0:\n exposure = sum(self.f4_exposure)\n events = sum(self.f4_events)\n event_probability = (events + 80.0 * (1.0 - math.exp(-0.1265))) / (exposure + 80.0)\n self.f4_rate = max(0.077, min(0.176, -math.log(max(1e-6, 1.0 - event_probability))))\n weights = [a + b for a, b in zip(*self.f4_weights)]\n peak = max(weights)\n weights = [math.exp(w - peak) for w in weights]\n self.f4_mean = sum(m * w for m, w in zip(self.f4_means, weights)) / sum(weights)\n self.f4_flow = self.f4_rate * self.f4_mean\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 if self.s == 4:\n exp = math.exp\n if self.bc == cs and 1.0 <= wid <= 6.0 and nb == 8 * wid:\n # On this stationary grid, spacing is exactly 1/8 tick.\n # Equal index distances therefore have bit-identical d*d*k.\n # Reuse exp values while retaining the original sum order.\n kernel = []\n c0 = cs[0]\n for ci in self.bc:\n d = c0 - ci\n d2 = d * d * k\n kernel.append(exp(d2) if d2 > -12.5 else 0.0)\n kernel = kernel[:0:-1] + kernel\n for i in range(nb):\n t = uni\n start = nb - 1 - i\n for wi, e in zip(self.bw, kernel[start:start + nb]):\n if e:\n t += wi * e\n ws.append(t)\n else:\n previous = tuple(zip(self.bc, self.bw))\n for c in cs:\n t = uni\n for ci, wi in previous:\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 == 4:\n ja = jb = 0.0\n for p, w in jp:\n if x > p:\n ja += w * (x - p)\n else:\n jb += w * (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):\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 if self.s == 4 and tail <= 1e-6:\n return min(P['qmax'], math.exp(mu + P['sig_n'] * self.f4_extreme) / px)\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 if self.s == 4 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 == 4 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 if self.s == 4:\n tail = b * kA / max(self.f4_rate * a, 1e-30)\n if a <= 0 or tail >= 1.0:\n return 0.0\n return min(P['qmax'], math.exp(math.log(self.f4_mean) - 0.72 + 1.2 * (self.f4_extreme if tail <= 1e-6 else inv(1 - tail))) / (t / 100.0))\n if self.s == 2 and phat < 0.1:\n a = max(0.0, a - 0.0015 * (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 threshold = max(P['min_ahead'], 20 * 100.0 / comp) if self.s == 3 and step == -1 and 1 <= comp <= 5 else P['min_ahead']\n if sticky and sum(o.remaining_quantity for o in orders if o.price_ticks == comp and o.order_id in self.ahead) >= threshold:\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 if self.s == 1 and ask_t == 2 and ask_t < ca and phat < 0.01:\n qa *= 5\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 flow_scale = self.f4_flow / 0.6 if self.s == 4 else 1.0\n target = min(flow_scale * P['ydem'] * min(H, P['W']) / x, capw)\n full = min(flow_scale * 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 == 4:\n stock_rate *= self.f4_flow / 0.6\n if self.s == 3:\n flow = (self.flow_notional + P['flow_prior'] * P['flow_level']) / (P['flow_prior'] + self.flow_exposure)\n scale = max(0.5, min(2.0, flow / P['flow_level']))\n stock_rate *= 1.0 + P['flow_strength'] * (scale - 1.0)\n q1 = max(0.0, stock_rate * min(H, P['Wf']) / (self.s / 100.0) - Y)\n\n # Bridge expected retail demand until another tick crossing is available.\n if 0.02 < phat < 0.1:\n ct = max(2, min(99, int(math.floor(ptick))))\n wealth = state.cash + Y * phat\n goal = min(1 * qa, 0.3 * max(wealth, 0.0) / phat)\n if Y < goal and ct < ask_t:\n amt, qam = ct, min(3000.0, goal - Y)\n # order management\n actions = []\n free = state.free_cash - 2.0\n keep_ask = 0.0\n new_b = []\n new_a = []\n def cancel(o):\n nonlocal free\n actions.append(CancelOrder(o.order_id))\n x = o.price_ticks / 100.0\n if o.side is Side.BUY:\n free += x * o.remaining_quantity\n else:\n free += (1 - x) * min(self.res.get(o.order_id, 0.0), o.remaining_quantity)\n self.ahead.discard(o.order_id)\n self.res.pop(o.order_id, None)\n for o in state.own_orders:\n if o.remaining_quantity <= PROBE + 1e-9:\n cancel(o)\n kept_ids = set()\n def manage(orders, t, q, comp):\n kept = 0.0\n for o in orders:\n if o.price_ticks == t and q > 0 and (kept + o.remaining_quantity <= max(q * P['keep_hi'], 1.0) or (self.s == 1 and (o.side is Side.SELL) and o.price_ticks <= 2 and o.order_id in self.ahead)):\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 if self.s == 2:\n ub = min(ub, max(0.0, free - 200 * 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))\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 if self.s == 4:\n self.f4_last = [None, None]\n # Eligibility is decided before observing fills, so depleted quotes\n # remain in the sample as right-censored observations.\n for side, tick, bound, conv, distance in (\n (0, ask_t, ca, ask_t / 100.0, ask_t / 100.0 - phat),\n (1, bid_t, cb, max(phat, 0.05), phat - bid_t / 100.0)):\n if distance < max(0.01, 3.0 * self.st / 100.0):\n continue\n if side == 0:\n if not (ask_t < ca or any(o.price_ticks == ask_t and o.order_id in self.ahead for o in asks)):\n continue\n orders = asks\n order_side = Side.SELL\n else:\n if not (bid_t > cb or any(o.price_ticks == bid_t and o.order_id in self.ahead for o in bids)):\n continue\n if (qam > 0 and amt >= bid_t) or (q1 > 0 and bid_t <= 1):\n continue\n orders = bids\n order_side = Side.BUY\n tracked = {o.order_id: o.remaining_quantity for o in orders if o.order_id in kept_ids and o.price_ticks == tick}\n tracked.update({o.client_order_id: o.quantity for o in out if o.side is order_side and o.price_ticks == tick and o.client_order_id is not None})\n cap = sum(tracked.values()) * conv\n if cap >= 0.5:\n self.f4_last[side] = (tick, conv, cap, bound, tracked)\n return actions + out\n","code_sha256":"41f2bb431d34c009ae17d19e19551fbce150cd1b23166374e759ed4f92f0a570","tried":["Remove above-probability ammunition refills: discovery diagnostic, n=309, mean=0.16290298170420753, retail=-0.3158293258948222, arb=0.47873230759579294, trimmed=0.2078419280346028, up/down=73/7.","Remove low-price bids when above existing 200-step stock target: discovery diagnostic, n=309, mean=-1.340853434446927, retail=-2.39756332801683, arb=1.0567098935546926, trimmed=0.11218257671730004, up/down=89/56.","Shorten stock horizon to 1000: discovery diagnostic, n=309, mean=-0.07420303314110051, retail=0.0, arb=-0.0742030331427184, trimmed=0.0, up/down=7/3.","Shorten stock horizon to 500: discovery diagnostic, n=309, mean=-1.1020392822527494, retail=-0.14688616134789656, arb=-0.9551531209084141, trimmed=0.12059022668823591, up/down=29/18.","Restore existing kL on all low-price bids (same rule as submitted): discovery diagnostic, n=309, mean=0.5916321883019424, retail=-0.1392597911349518, arb=0.7308919794339807, trimmed=0.4706406707370243, up/down=122/30.","Numeric full-stock risk probe 0.3: discovery diagnostic, n=309, mean=0.49011199923042315, retail=-0.4645904985608411, arb=0.9547024977919094, trimmed=0.5800712216017322, up/down=116/31.","Use existing normal-price risk only above stock target: discovery diagnostic, n=309, mean=0.3515502741498393, retail=-0.7548943436647249, arb=1.106444617813916, trimmed=0.5340311833560574, up/down=109/39.","Raise low-price ask cap to 12000: discovery diagnostic, n=309, mean=0.08961231701747568, retail=0.11114326073300972, arb=-0.021530943715857623, trimmed=0.0, up/down=6/4.","Remove main bids below 5c: discovery diagnostic, n=309, mean=-3.082432580300646, retail=-3.5760014841857606, arb=0.4935689038592233, trimmed=-0.685585732984428, up/down=75/77.","Remove main bids below 2c: discovery diagnostic, n=309, mean=-0.2100393695731394, retail=-0.3467768867110024, arb=0.13673751713268611, trimmed=0.11912922867681572, up/down=102/36.","Limit ammunition overpayment to 0.005: discovery diagnostic, n=309, mean=0.009457995982201334, retail=-0.210072707216181, arb=0.21953070319741097, trimmed=0.07512857475986225, up/down=52/7.","Limit tick-1 stock target to 10000: discovery diagnostic, n=309, mean=-0.74832610304466, retail=-0.0799373375459547, arb=-0.6683887655016181, trimmed=0.0, up/down=10/8.","Restoring existing kL on low-price bids, discovery [30000,34000): {\"runs\":1026,\"mean\":0.5395040516642303,\"standard_error\":0.08597329974012581,\"retail\":-0.10240573364035155,\"arb\":0.6419097853049708,\"trimmed\":0.5771069476670978,\"runs_up\":394,\"runs_down\":96,\"failures\":0}","Restore kL only above existing stock target, discovery only: {\"runs\":1026,\"mean\":0.5143329677070178,\"standard_error\":0.07699818646452122,\"retail\":-0.06627613445107236,\"arb\":0.5806091021576997,\"trimmed\":0.5383276258343939,\"runs_up\":404,\"runs_down\":80,\"failures\":0}","Numeric horizon/cap/risk probes were rejected as a basis for a setting; no new numerical constant is submitted. Remaining numeric sweep cancelled. Submitted rule restores the already-existing kL coefficient.","Calibration: python3 -m orderbook_pm_challenge run ../early.py --simulations 600 --seed-start 1000 --workers 4 --json; Python 3.12.3; no sandbox; 600 successes; exact mean 108.63974289615767.","Other-spread comparison checks every SimulationResult field, 300 seeds per spread 1/2/3 from 90000 onward. Timing runs 200 spread-4 seeds for each strategy serially in one process."],"next":"Measure a structural stock-order cap based on already available expected retail demand, and distinguish ask-capacity misses from competitor ladder movement. Do not enlarge asks based on a static tail-fill estimate alone; the competitor refresh path changes. Confirm on fresh seeds before combining seats."}