{"approach": "Start from the seat-845 crossing-cover base. Disable only the large ceiling-priced near-crossing ammunition branch (g_hi=-1), retaining ordinary small top-ups, lower resting bids, tick-1 reservoir, tick-1 asks, and crossing cover. Full late-game guard saved arbitrage but cost retail; narrowing the tick-1 reservoir lost edge. The selected ceiling-only cut gained total edge on discovery seeds 4000-4399 and independent checkpoint 6000-6099; combined retail delta over those 500 seeds was positive, although checkpoint retail alone was negative. Freeze preceded all final evaluation runs. Exact-arithmetic order-scan and filter-loop changes improve strategy speed; 400 discovery simulations matched the unoptimized candidate exactly. Final scoring retained standard-engine batches and used a scoring-only FIFO heap index for remaining batches, with official probability, fills, accounting, rounding and edge arithmetic unchanged; 100 discovery full-result equivalence checks, 100 additional untouched-simulator unseen audits, and 6000 order-index comparisons passed. Timing used the untouched simulator. NOT ELIGIBLE FOR ENTRY: unseen retail edge is below the base. This file records a rejected experiment, not a qualifying candidate.", "blocked": null, "python_version": "3.12.3", "base_mean_edge": 108.63974289615767, "base_unseen": {"mean_edge": 97.54703502577897, "retail_edge": 126.92890288111944, "arb_edge": -29.381867855334075}, "score": {"mean_edge": 98.27093814616242, "retail_edge": 125.13311240853785, "arb_edge": -26.862174262389626, "failures": 0, "simulations": 4000, "seed_start": 4000}, "holdout": {"mean_edge": 97.71291569824263, "retail_edge": 126.87219047831917, "arb_edge": -29.159274780069673, "failures": 0, "simulations": 4000, "seed_start": 50000}, "diff": {"mean": 0.1658806724636503, "standard_error": 0.03145024960903636, "retail": -0.05671240280027499, "arb": 0.2225930752644}, "seconds": {"base": 1121.0166670444887, "yours": 1092.748664598912}, "code": "\"\"\"Passive binary-market quotes with crossing-funded stock and selective low bids.\"\"\"\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=-1.0, 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\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 lo, hi = cb, ca\n sb, sa = set(), set()\n bids, asks = [], []\n for o in state.own_orders:\n if o.side is Side.BUY:\n lo = o.price_ticks if o.price_ticks > lo else lo\n if o.remaining_quantity <= PROBE + 1e-9:\n sb.add(o.price_ticks)\n else:\n bids.append(o)\n else:\n hi = o.price_ticks if o.price_ticks < hi else hi\n if o.remaining_quantity <= PROBE + 1e-9:\n sa.add(o.price_ticks)\n else:\n asks.append(o)\n if P['pinf'] > 0:\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 pairs = tuple(zip(self.bc, self.bw))\n exp = math.exp\n for c in cs:\n t = uni\n for ci, wi in pairs:\n d = c - ci\n d2 = d * d * k\n if d2 > -12.5:\n t += wi * exp(d2)\n ws.append(t)\n 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 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 q1 = max(0.0, P['ydf1'] * 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):\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 return actions + out\n", "code_sha256": "08fdb3c2412a8a1f49f85150468f3864dc077532a8e702a18d33fd83cddc1aa6", "tried": ["Official simulator commit b244530ee2a6247b5f930830eeca9dd950da0e7e; unsandboxed Python standard-library execution. Baseline seeds 1000-1599: {\"mean_edge\": 108.63974289615767, \"retail_edge\": 136.2713209771645, \"arb_edge\": -27.63157808101933, \"failures\": 0}. Exact match to supplied mean_edge=108.63974289615767.", "Discovery used seeds 4000-4399 (some refinements 4000-4299 or 4000-4199). Independent validation at selection used seeds 6000-6099. Extended validation and remaining exploratory trials were stopped after freeze to reserve CPU for complete mandatory evaluations; incomplete trials have no reported scores. All strategy selection preceded freeze 2026-11-06T07:12:10.728406+00:00; unseen seeds were excluded from selection. Final means use the official BatchResult arithmetic on the original per-simulation results; paired SE is sample standard deviation of per-seed differences divided by sqrt(4000).", "Baseline full tuning seeds 4000-7999: {\"mean_edge\": 98.0996956804193, \"retail_edge\": 125.17961744069841, \"arb_edge\": -27.079921760293374, \"failures\": 0}", "The ceiling-bid candidate was frozen after discovery plus a 100-seed independent checkpoint. The checkpoint paired difference was {\"mean\": 0.2790803294589994, \"standard_error\": 0.18400527677128747, \"retail\": -0.12144709526900244, \"arb\": 0.4005274247230001}. Trials incomplete at freeze were stopped for the required evaluations; incomplete trials have no claimed scores and did not alter the frozen code.", "Scoring-only acceleration: a lazy heap index replaces order lookup using the identical (price tick, sequence) priority, retaining all official matching, accounting, probability and rounding code. Every SimulationResult field matched the untouched engine on 50 base and 50 frozen-strategy simulations, seeds 4000-4049; 6000 randomized order lookup comparisons also matched. The official simulator checkout was not modified. Completed batches from the standard engine were retained, remaining batches used the indexed lookup; timing uses the untouched simulator. Helper source for reproducibility: \"\"\"Scoring-only index; original accounting, matching and probability code is retained.\"\"\"\nimport heapq\nfrom orderbook_pm_challenge.market import PredictionMarket,COMPETITOR,EPSILON\nfrom orderbook_pm_challenge.types import Side\n\ndef install():\n C=PredictionMarket\n if getattr(C,'_indexed_installed',False):return\n oi,op,oc,orr=C.__init__,C.place_order,C._create_competitor_order,C._remove_order\n def init(self,config):\n oi(self,config);self._book_index={Side.BUY:[],Side.SELL:[]};self._comp_index={Side.BUY:[],Side.SELL:[]}\n def index(self,o):\n key=(o.price_ticks if o.side is Side.SELL else -o.price_ticks,o.sequence,o.order_id,o)\n heapq.heappush(self._book_index[o.side],key)\n if o.owner==COMPETITOR:heapq.heappush(self._comp_index[o.side],key)\n def place(self,action,*,step):\n op(self,action,step=step);index(self,self._orders[next(reversed(self._orders))])\n def create(self,side,tick,*,submitted_step):\n before=len(self._orders);oc(self,side,tick,submitted_step=submitted_step)\n if len(self._orders)>before:index(self,self._orders[next(reversed(self._orders))])\n def top(self,heap,check_quantity):\n while heap:\n _,_,oid,o=heap[0]\n if self._orders.get(oid) is o and (not check_quantity or o.remaining_quantity>EPSILON):return o\n heapq.heappop(heap)\n return None\n def best(self,side):return top(self,self._book_index[side],True)\n def quotes(self):\n b=top(self,self._comp_index[Side.BUY],False);a=top(self,self._comp_index[Side.SELL],False)\n return (b.price_ticks if b is not None else None,a.price_ticks if a is not None else None)\n C.__init__=init;C.place_order=place;C._create_competitor_order=create;C._best_order=best;C.competitor_best_quotes=quotes;C._indexed_installed=True\n", "Single-process timing: 200 runs per strategy, seeds 4000-4199, alternating order each seed. Wall seconds={\"base\": 1121.0166670444887, \"final\": 1092.748664598912}; process CPU seconds={\"base\": 223.93421646299993, \"final\": 221.28200495500005}.", "Cancel ammunition above estimated probability only when inventory already covers desired ask. Incomplete exploratory trial stopped after freeze to reserve CPU for required final evaluations; no score claimed.", "Cap all above-probability ammunition bids by current desired ask quantity minus inventory. Incomplete exploratory trial stopped after freeze to reserve CPU for required final evaluations; no score claimed.", "Cap eager ammunition target by desired ordinary ask quantity. Incomplete exploratory trial stopped after freeze to reserve CPU for required final evaluations; no score claimed.", "Cap tick-1 reservoir target by max(desired ask quantity,1000 shares). Incomplete exploratory trial stopped after freeze to reserve CPU for required final evaluations; no score claimed.", "Halve tick-1 reservoir target coefficient to 0.3. Incomplete exploratory trial stopped after freeze to reserve CPU for required final evaluations; no score claimed.", "Restrict tick-1 reservoir to 1c100. Incomplete exploratory trial stopped after freeze to reserve CPU for required final evaluations; no score claimed.", "Size tick-1 reservoir with max(competitor spread, estimated probability in ticks) denominator. Discovery n=300: {\"mean_edge\": 112.72663511232167, \"retail_edge\": 138.698043871973, \"arb_edge\": -25.971408759591, \"failures\": 0}; paired vs base {\"mean\": -1.3105982359446666, \"standard_error\": 0.6663491068282609, \"retail\": -1.9031971923296664, \"arb\": 0.5925989563856668}.", "Late-game activation change alone: large tick-1 reservoir only for 1c1c. Discovery n=300: {\"mean_edge\": 113.99236235167467, \"retail_edge\": 140.59972172904233, \"arb_edge\": -26.60735937730867, \"failures\": 0}; paired vs base {\"mean\": -0.04487099659166622, \"standard_error\": 0.04369264806095804, \"retail\": -0.0015193352603336053, \"arb\": -0.04335166133199999}.", "Late-game ask change alone: suppress tick-1 asks with inventory<500 when H>100. Discovery n=400: {\"mean_edge\": 111.72769676601374, \"retail_edge\": 138.362804134896, \"arb_edge\": -26.635107368838, \"failures\": 0}; paired vs base {\"mean\": 0.00015228743749993613, \"standard_error\": 0.006303825440593434, \"retail\": 0.041975019571999964, \"arb\": -0.041822732134499996}.", "Disable only ceiling-priced near-crossing full-demand ammunition branch. Discovery n=400: {\"mean_edge\": 112.09161255871801, \"retail_edge\": 138.43131374028675, \"arb_edge\": -26.339701181527246, \"failures\": 0}; paired vs base {\"mean\": 0.3640680801417502, \"standard_error\": 0.24935053871625015, \"retail\": 0.11048462496275108, \"arb\": 0.2535834551762499}. Independent validation n=100: {\"mean_edge\": 91.86567104545901, \"retail_edge\": 117.573025651293, \"arb_edge\": -25.707354606025, \"failures\": 0}; paired vs base {\"mean\": 0.2790803294589994, \"standard_error\": 0.18400527677128747, \"retail\": -0.12144709526900244, \"arb\": 0.4005274247230001}.", "Cancel only ammunition bids strictly above estimated probability, from tick 2 upward. Discovery n=400: {\"mean_edge\": 112.462332777352, \"retail_edge\": 138.0567770908695, \"arb_edge\": -25.59444431347175, \"failures\": 0}; paired vs base {\"mean\": 0.7347882987757501, \"standard_error\": 0.3957519173778039, \"retail\": -0.2640520244544993, \"arb\": 0.9988403232317499}.", "Late-game ammunition guard alone: permit small ammunition only at tick 1 with p<1c; crossing-cover override retained. Discovery n=400: {\"mean_edge\": 112.55927952194625, \"retail_edge\": 137.9825913710705, \"arb_edge\": -25.42331184908, \"failures\": 0}; paired vs base {\"mean\": 0.8317350433700004, \"standard_error\": 0.4538558173827266, \"retail\": -0.3382377442534997, \"arb\": 1.1699727876235}.", "Independent untouched-simulator audit of indexed unseen scores: every SimulationResult field matched on 50 base runs, seeds 52400-52449, and 50 frozen-strategy runs, seeds 50400-50449. No strategy change resulted from this audit.", "Frozen selected strategy noceil with exact-arithmetic order-scan/filter optimization. Final tuning seeds 4000-7999: {\"mean_edge\": 98.27093814616242, \"retail_edge\": 125.13311240853785, \"arb_edge\": -26.862174262389626, \"failures\": 0}; paired vs base {\"mean\": 0.17124246574312466, \"standard_error\": 0.042370708794734806, \"retail\": -0.04650503216054958, \"arb\": 0.21774749790374995}. Unseen seeds 50000-53999: {\"mean_edge\": 97.71291569824263, \"retail_edge\": 126.87219047831917, \"arb_edge\": -29.159274780069673, \"failures\": 0}; paired vs base {\"mean\": 0.1658806724636503, \"standard_error\": 0.03145024960903636, \"retail\": -0.05671240280027499, \"arb\": 0.2225930752644}."], "next": "Use fresh discovery/validation seeds to test a demand-capped ceiling replenishment: limit an eager bid to desired ask quantity minus inventory rather than removing all large top-ups. Preserve tick-1 reservoir and crossing cover. Those cap experiments were started but stopped before complete results here. Require a new paired unseen set; seeds 50000-53999 are now disclosed."}