Rank: best acted-spread mean_diff/SE; flagged rows follow eligible rows. Inputs: `.imd/reads/artifacts/item-{key}` for each key below (task-pinned hashes verified). Each JSON row cites its input by key. These are reported screens, not finalist evidence. No simulations run.

|key|spread|mean_diff|se|overall|flag|
|---|---:|---:|---:|---:|---|
|f-side-size-ratio|1|0.012636|0.120495|-0.345147|none|
|f-end-flatten|1|-0.037418|0.038382|-0.160306|none|
|f-behind-level|1|-4.936568|1.832626|-18.194943|none|
|f-fill-prob-pricing|4|-90.746876|8.572285|-45.080412|none|
|f-retail-clock|3|0.786224|1.387385|0.023166|old failures|
|f-loss-budget-stop|4|0.005728|0.013371|-0.054288|old failure|
|f-exposure-ratchet|1|-4.378567|2.201416|-34.637674|failed runs|
|f-post-fill-other-side|1|-12.076402|2.038618|-19.167952|failures/checks|

```json
{"rows":[{"key":"f-exposure-ratchet","spreads_acted":[1,2,3,4],"off_equals_n":true,"code_sha256":"4cc20e7b283dd38b42589255fdc0a04877b2588568d66146e6964167be8af1da","assembled_sha256":"4e51e7fe7f19e8334bcece9f5e250d8781aedf9fadd6ee54a2435651d4fe8798","code":"from dataclasses import replace as _ratchet_replace\nfrom orderbook_pm_challenge.types import PlaceOrder as _RP, CancelAll as _RCA, CancelOrder as _RC\n\nclass Strategy(_N):\n    ratchet_enabled = True\n    ratchet_hold = 50\n    ratchet_spreads = (1, 2, 3, 4)\n\n    def on_step(self, state):\n        actions = super().on_step(state)\n        if not self.ratchet_enabled or self.s not in self.ratchet_spreads:\n            return actions\n        t = state.step\n        if t == 0:\n            self._er_pending = []\n            self._er_mid = None\n            self._er_last_trigger = None\n            self._er_scales = {}\n        bid = state.competitor_best_bid_ticks\n        ask = state.competitor_best_ask_ticks\n        mid = (bid + ask) / 2.0 if bid is not None and ask is not None else None\n        # Fills reported at t happened at t-1; use its pre-fill midpoint.\n        if self._er_mid is not None and t > 0:\n            if state.buy_filled_quantity > 0:\n                self._er_pending.append((t-1, self._er_mid, 1))\n            if state.sell_filled_quantity > 0:\n                self._er_pending.append((t-1, self._er_mid, -1))\n        pending = []\n        hit = False\n        for filled_at, ref, direction in self._er_pending:\n            if t - filled_at <= 3:\n                if mid is not None and direction * (mid - ref) <= -2.0:\n                    hit = True\n                else:\n                    pending.append((filled_at, ref, direction))\n        self._er_pending = pending\n        self._er_mid = mid\n        if hit:\n            self._er_last_trigger = t\n        scale = 1.0\n        if self._er_last_trigger is not None:\n            age = t - self._er_last_trigger\n            hold = self.ratchet_hold\n            if age < hold:\n                scale = 0.5\n            elif age < 2 * hold:\n                scale = 0.5 + 0.5 * (age - hold) / hold\n        self._er_scales[t] = scale\n        # N's cancellations remain authoritative. Reduce retained orders only\n        # when the multiplier falls; recovery applies to newly placed orders.\n        actions = list(actions)\n        all_cancelled = any(isinstance(a, _RCA) for a in actions)\n        cancelled = {a.order_id for a in actions if isinstance(a, _RC)}\n        retained = []\n        extra_cancels = []\n        if not all_cancelled:\n            for o in state.own_orders:\n                old = self._er_scales.get(o.submitted_step, 1.0)\n                if o.order_id not in cancelled and scale < old - 1e-12:\n                    extra_cancels.append(_RC(o.order_id))\n                    q = int((o.remaining_quantity * scale / old + 1e-9) * 100) / 100\n                    if q >= 0.01:\n                        retained.append(_RP(o.side, o.price_ticks, q, o.order_id))\n        out = list(extra_cancels)\n        for a in actions:\n            if isinstance(a, _RP) and scale < 1.0:\n                q = int((a.quantity * scale + 1e-9) * 100) / 100\n                if q >= 0.01:\n                    out.append(_ratchet_replace(a, quantity=q))\n            else:\n                out.append(a)\n        out.extend(retained)\n        return self._er_cap(state, out) if scale < 1.0 else out\n\n    def _er_cap(self, state, actions):\n        # Lower bound on free collateral; no private simulator state is used.\n        from orderbook_pm_challenge.types import Side as _RS\n        cash = max(0.0, state.free_cash)\n        yes = max(0.0, state.yes_inventory)\n        live = {o.order_id: (o.side, o.price_ticks, o.remaining_quantity)\n                for o in state.own_orders}\n        out = []\n        for i, a in enumerate(actions):\n            if isinstance(a, _RCA):\n                live.clear()\n                cash = max(0.0, state.cash)\n                out.append(a)\n            elif isinstance(a, _RC):\n                o = live.pop(a.order_id, None)\n                if o is not None:\n                    side, tick, qty = o\n                    cash += qty * tick / 100 if side == _RS.BUY else max(0.0, qty - yes) * (1 - tick / 100)\n                out.append(a)\n            elif isinstance(a, _RP):\n                price = a.price_ticks / 100\n                free_yes = max(0.0, yes - sum(q for side, tick, q in live.values() if side == _RS.SELL))\n                limit = cash / price if a.side == _RS.BUY else free_yes + cash / (1 - price)\n                qty = int((min(a.quantity, max(0.0, limit)) + 1e-10) * 100) / 100\n                if qty < 0.01:\n                    continue\n                cost = qty * price if a.side == _RS.BUY else max(0.0, qty - free_yes) * (1 - price)\n                cash = max(0.0, cash - cost)\n                live[a.client_order_id if a.client_order_id else ('new', i)] = (a.side, a.price_ticks, qty)\n                out.append(_ratchet_replace(a, quantity=qty))\n            else:\n                out.append(a)\n        return out\n","failures":[{"phase":"tuning","seed":320109,"strategy":"h100","error":"orderbook_pm_challenge.market.OrderBookError: Insufficient free cash for order collateral"},{"phase":"tuning","seed":320151,"strategy":"h50","error":"orderbook_pm_challenge.market.OrderBookError: Insufficient free cash for order collateral"},{"phase":"tuning","seed":320151,"strategy":"h100","error":"orderbook_pm_challenge.market.OrderBookError: Insufficient free cash for order collateral"},{"phase":"tuning","seed":320154,"strategy":"h100","error":"orderbook_pm_challenge.market.OrderBookError: Insufficient free cash for order collateral"},{"phase":"holdout","seed":430009,"strategy":"h50safe","error":"orderbook_pm_challenge.market.OrderBookError: Insufficient free cash for order collateral"},{"phase":"holdout","seed":430108,"strategy":"h50safe","error":"orderbook_pm_challenge.market.OrderBookError: Insufficient free cash for order collateral"},{"phase":"holdout","seed":430216,"strategy":"h50safe","error":"orderbook_pm_challenge.market.OrderBookError: Insufficient free cash for order collateral"}],"python_version":"3.12.3","mech":"Exposure ratchet: a reported own buy (sell) followed by a visible rival midpoint decline (rise) of >=2 ticks within 3 steps resets a 0.5 size multiplier. Hold 50 steps, then recover linearly over 50 s","complete":true,"h_n":500,"incumbent_mean":95.54201511346659,"mean_diff":-34.6376738491442,"se":2.089998586073646,"retail_diff":-14.0172621364234,"arb_diff":-20.6204117127372,"tuning_mean":-32.7877908789785,"tuning_se":3.1579851611629355,"by_spread":{"1":{"n":131,"mean_diff":-4.378567387093893,"se":2.2014157528683014,"sum_d":-573.5923277093,"sum_d2":85042.83198770859},"2":{"n":120,"mean_diff":-25.287980400550833,"se":2.2897877600142116,"sum_d":-3034.5576480661,"sum_d2":151609.70196744482},"3":{"n":133,"mean_diff":-47.668633567344365,"se":4.2212400411709705,"sum_d":-6339.9282644568,"sum_d2":615043.7548515502},"4":{"n":116,"mean_diff":-63.54102314086121,"se":5.264245777537733,"sum_d":-7370.7586843399,"sum_d2":838027.4114357055}},"check_values_ok":true,"flag":"Tuning failures and 3 failed holdout runs; only 497 successful. complete=true means attempted; reported statistics include partial edges."},{"key":"f-side-size-ratio","spreads_acted":[1,2,3,4],"off_equals_n":{"equal":true,"seeds":"310000..310009","steps_compared":20000,"steps_differing":0,"seeds_equal":10,"how":"overlay with SPREADS = () (off); repr of every action list compared with N's at every step; total edge also identical on all 10 seeds","also_identity_at_rb_ra_1":{"steps_differing":0,"seeds_equal":10}},"code_sha256":"1a930d17d399b7f6491e0b2c6d3c7a4e46376fd106ffc2b1c508106391664e11","assembled_sha256":"9a1ca39e05580cc0936f7705a43b36bf1970c398c05d2fda5a51bf39b68f3ee0","code":"# Overlay f-side-size-ratio: scale N's bid sizes by RB and ask sizes by RA\n# while the rival midpoint is between LO and HI ticks, on the spreads in SPREADS.\nfrom orderbook_pm_challenge.types import CancelAll as _ZCA\nfrom orderbook_pm_challenge.types import CancelOrder as _ZCO\nfrom orderbook_pm_challenge.types import PlaceOrder as _ZPO\nfrom orderbook_pm_challenge.types import Side as _ZSide\n\n\nclass Strategy(_N):\n    RB = 1.3  # multiplier on BUY (bid) order sizes\n    RA = 1.3  # multiplier on SELL (ask) order sizes\n    LO = 20.0  # rival midpoint band, in ticks (cents), inclusive\n    HI = 80.0\n    SPREADS = (1, 2, 3, 4)  # rival spreads (N's self.s) acted on; () switches the overlay off\n\n    def on_step(self, state):\n        acts = super().on_step(state)\n        if not acts or getattr(self, \"s\", None) not in self.SPREADS:\n            return acts\n        bid = state.competitor_best_bid_ticks\n        ask = state.competitor_best_ask_ticks\n        if bid is None or ask is None:\n            return acts\n        mid = 0.5 * (bid + ask)\n        if mid < self.LO or mid > self.HI:\n            return acts\n        rb = float(self.RB)\n        ra = float(self.RA)\n        if rb == 1.0 and ra == 1.0:\n            return acts\n        src = list(acts)\n        out = self._z_scale(state, src, rb, ra)\n        if out is None and (rb > 1.0 or ra > 1.0):\n            # scaled-up sizes do not fit the collateral: only apply the cuts\n            rb = min(rb, 1.0)\n            ra = min(ra, 1.0)\n            if rb == 1.0 and ra == 1.0:\n                return acts\n            out = self._z_scale(state, src, rb, ra)\n        return acts if out is None else out\n\n    @staticmethod\n    def _z_scale(state, src, rb, ra):\n        \"\"\"Resize every PlaceOrder; replay the simulator's collateral rule on a\n        conservative model of the account and return None if anything would not fit.\"\"\"\n        cash = float(state.cash)\n        yes = float(state.yes_inventory)\n        free = float(state.free_cash)\n        buy_res = 0.0\n        sell_rem = 0.0\n        for o in state.own_orders:\n            if o.side is _ZSide.BUY:\n                buy_res += o.price_ticks / 100.0 * o.remaining_quantity\n            else:\n                sell_rem += o.remaining_quantity\n        covered = (float(state.reserved_cash) - buy_res) < 1e-6  # resting asks all backed by YES\n        avail = max(0.0, yes - sell_rem)\n        live = {}\n        for o in state.own_orders:\n            if o.side is _ZSide.BUY:\n                live[o.order_id] = (o.price_ticks / 100.0 * o.remaining_quantity, 0.0)\n            else:\n                live[o.order_id] = (0.0, o.remaining_quantity if covered else 0.0)\n        out = []\n        for act in src:\n            if isinstance(act, _ZCA):\n                free = cash\n                avail = yes\n                live = {}\n                out.append(act)\n            elif isinstance(act, _ZCO):\n                rel = live.pop(act.order_id, None)\n                if rel is not None:\n                    free += rel[0]\n                    avail += rel[1]\n                out.append(act)\n            elif isinstance(act, _ZPO):\n                f = rb if act.side is _ZSide.BUY else ra\n                q0 = float(act.quantity)\n                if f == 1.0:\n                    q = int(q0 * 100.0 + 1e-6) / 100.0\n                else:\n                    q = max(0.01, int(q0 * f * 100.0 + 1e-6) / 100.0)\n                price = act.price_ticks / 100.0\n                if act.side is _ZSide.BUY:\n                    need = price * q\n                    use_yes = 0.0\n                else:\n                    use_yes = min(q, avail)\n                    need = (1.0 - price) * (q - use_yes)\n                if free - need < 1e-6:\n                    return None\n                free -= need\n                avail -= use_yes\n                if act.client_order_id is not None:\n                    live[act.client_order_id] = (need, use_yes)\n                out.append(act if f == 1.0 else _ZPO(act.side, act.price_ticks, q, act.client_order_id))\n            else:\n                out.append(act)\n        return out\n","failures":[],"python_version":"3.12.3","mech":"side size ratio: multiply N's bid sizes by rb and ask sizes by ra (each from 0.5, 0.7, 1.0, 1.3) while the rival midpoint is between 20 and 80 cents","complete":true,"h_n":500,"incumbent_mean":95.542015,"mean_diff":-0.345147,"se":0.139503,"retail_diff":0.400066,"arb_diff":-0.745212,"tuning_mean":-0.228254,"tuning_se":0.178406,"by_spread":{"1":{"n":131,"mean_diff":0.012636,"se":0.120495,"sum_d":1.655292,"sum_d2":247.281806},"2":{"n":120,"mean_diff":-0.58246,"se":0.148576,"sum_d":-69.895196,"sum_d2":355.938503},"3":{"n":133,"mean_diff":-0.432418,"se":0.438619,"sum_d":-57.511539,"sum_d2":3402.411069},"4":{"n":116,"mean_diff":-0.403637,"se":0.258376,"sum_d":-46.82188,"sum_d2":909.45312}},"check_values_ok":true,"flag":null},{"key":"f-end-flatten","spreads_acted":[1,2,3,4],"off_equals_n":{"ok":true,"seeds":"310000..310009","steps_compared":20000,"how":"END_E=0; repr of the action list returned each step compared with N's, identical on all 2000 steps of each of the 10 seeds"},"code_sha256":"69be55c4b7e1f403bea3b449bf80b14126b26b0a4a3253ebd58c6af1cc377e19","assembled_sha256":"592f5596f3fef8426992798d2effe6619e46099ab27898d2a052d6dd20f8283e","code":"# Overlay f-end-flatten: in the last E steps, cancel every order on the side\n# that would increase |net inventory| (net = yes - no). Flat book: unchanged.\nfrom orderbook_pm_challenge.types import CancelAll, CancelOrder, PlaceOrder, Side\n\nEND_E = 10\nACT_SPREADS = (1, 2, 3, 4)\nFLAT_EPS = 1e-9\n\n\nclass Strategy(_N):\n    def on_step(self, state):\n        acts = list(super().on_step(state))\n        E = END_E\n        if E <= 0 or state.steps_remaining > E:\n            return acts\n        if getattr(self, \"s\", None) not in ACT_SPREADS:\n            return acts\n        net = state.yes_inventory - state.no_inventory\n        if net > FLAT_EPS:\n            bad = Side.BUY\n        elif net < -FLAT_EPS:\n            bad = Side.SELL\n        else:\n            return acts\n        live = {o.order_id: o.side for o in state.own_orders}\n        out = []\n        for a in acts:\n            if isinstance(a, CancelAll):\n                live.clear()\n                out.append(a)\n            elif isinstance(a, CancelOrder):\n                live.pop(a.order_id, None)\n                out.append(a)\n            elif isinstance(a, PlaceOrder):\n                if a.side == bad:\n                    continue\n                if a.client_order_id is not None:\n                    live[a.client_order_id] = a.side\n                out.append(a)\n            else:\n                out.append(a)\n        for oid, side in live.items():\n            if side == bad:\n                out.append(CancelOrder(oid))\n        return out\n","failures":0,"python_version":"3.12.3","mech":"f-end-flatten","complete":true,"h_n":500,"incumbent_mean":95.542015,"mean_diff":-0.160306,"se":0.064781,"retail_diff":-0.203748,"arb_diff":0.043442,"tuning_mean":-0.280823,"tuning_se":0.181428,"by_spread":{"1":{"n":131,"mean_diff":-0.037418,"se":0.038382,"sum_d":-4.901703,"sum_d2":25.271429},"2":{"n":120,"mean_diff":-0.162475,"se":0.078158,"sum_d":-19.497041,"sum_d2":90.398684},"3":{"n":133,"mean_diff":-0.252603,"se":0.183635,"sum_d":-33.596193,"sum_d2":600.508338},"4":{"n":116,"mean_diff":-0.191019,"se":0.15953,"sum_d":-22.15826,"sum_d2":343.732472}},"check_values_ok":true,"flag":null},{"key":"f-fill-prob-pricing","spreads_acted":[3,4],"off_equals_n":{"passed":true,"seeds":{"start":310000,"end":310009,"inclusive":true},"steps_compared":20000,"mismatches":0,"edge_equal_on_all_seeds":true,"method":"Separate N and disabled frozen-overlay simulations; SHA-256 of the ordered action types and all action fields compared at every step.","code_sha256":"3f2378590590b1c0315557f9b16c4bc699714d68ff3310a8ca73f30fcbe90500"},"code_sha256":"3f2378590590b1c0315557f9b16c4bc699714d68ff3310a8ca73f30fcbe90500","assembled_sha256":"5864c054e2ae51ed5692e433a04b4aa6ad715c68d500c6b2cad5d28b49d14245","code":"# Append to the hash-verified incumbent after renaming its Strategy to _N.\nimport math as _fp_math\nfrom orderbook_pm_challenge.types import (\n    CancelAll as _FPAll, CancelOrder as _FPCancel,\n    PlaceOrder as _FPPlace, Side as _FPSide,\n)\n\n\nclass Strategy(_N):\n    \"\"\"Empirical fill probability times midpoint edge, outside rival quotes.\"\"\"\n\n    _fp_enabled = True\n    _fp_spreads = (3, 4)\n    _fp_prior_mass = 64.0\n    _fp_half_life = 1024.0\n\n    def _fp_init(self):\n        self._fp_counts = [[0.0] * 199 for _ in range(2)]\n        self._fp_hits = [[0.0] * 199 for _ in range(2)]\n        self._fp_last = [[0] * 199 for _ in range(2)]\n        self._fp_prior = [0.03 * _fp_math.exp(-0.65 * k / 2)\n                          for k in range(199)]\n        self._fp_previous = ([], [])\n        self._fp_moves = 0\n        self._fp_observations = 0\n\n    def _fp_learn(self, state):\n        # Fills consume participant price levels in price-time order, even\n        # though competitor liquidity may stand between those levels.\n        for side, filled in enumerate((state.buy_filled_quantity,\n                                       state.sell_filled_quantity)):\n            for distance, quantity in self._fp_previous[side]:\n                if 1 <= distance <= 198:\n                    factor = 2.0 ** (-(state.step - self._fp_last[side][distance])\n                                     / self._fp_half_life)\n                    self._fp_counts[side][distance] = (\n                        factor * self._fp_counts[side][distance] + 1.0)\n                    self._fp_hits[side][distance] = (\n                        factor * self._fp_hits[side][distance]\n                        + float(filled > 1e-9))\n                    self._fp_last[side][distance] = state.step\n                    self._fp_observations += 1\n                filled = max(0.0, filled - quantity)\n\n    def _fp_probabilities(self, side, step):\n        # Beta shrinkage and decreasing isotonic regression keep sparse,\n        # distant observations from creating an increasing fill curve.\n        blocks = []\n        for k in range(1, 199):\n            factor = 2.0 ** (-(step - self._fp_last[side][k])\n                             / self._fp_half_life)\n            successes = self._fp_hits[side][k] * factor\n            exposures = self._fp_counts[side][k] * factor\n            numerator = successes + self._fp_prior_mass * self._fp_prior[k]\n            weight = exposures + self._fp_prior_mass\n            blocks.append([k, k, numerator, weight])\n            while len(blocks) > 1:\n                left, right = blocks[-2], blocks[-1]\n                if left[2] * right[3] >= right[2] * left[3]:\n                    break\n                blocks.pop()\n                blocks.pop()\n                blocks.append([left[0], right[1], left[2] + right[2],\n                               left[3] + right[3]])\n        probabilities = [0.0] * 199\n        for lo, hi, numerator, weight in blocks:\n            probability = numerator / weight\n            for k in range(lo, hi + 1):\n                probabilities[k] = probability\n        return probabilities\n\n    @staticmethod\n    def _fp_side(side):\n        return 0 if side == _FPSide.BUY else 1\n\n    @staticmethod\n    def _fp_quantity(quantity):\n        return round(_fp_math.floor((float(quantity) + 1e-9) / 0.01) * 0.01, 10)\n\n    def on_step(self, state):\n        actions = super().on_step(state)\n        if not self._fp_enabled or self.s not in self._fp_spreads:\n            return actions\n        if not hasattr(self, '_fp_counts'):\n            self._fp_init()\n        self._fp_learn(state)\n        self._fp_previous = ([], [])\n        bid = state.competitor_best_bid_ticks\n        ask = state.competitor_best_ask_ticks\n        if bid is None or ask is None or bid >= ask:\n            # No two-sided midpoint: defer to N and collect no exposure.\n            return actions\n        midpoint2 = bid + ask\n        probabilities = [self._fp_probabilities(side, state.step)\n                         for side in range(2)]\n\n        def target(side, old_tick):\n            # Outward-only moves cannot increase collateral at N's size.\n            ticks = (range(min(old_tick, bid), 0, -1) if side == 0\n                     else range(max(old_tick, ask), 100))\n            best_tick = None\n            best_value = -1.0\n            for tick in ticks:\n                distance = midpoint2 - 2 * tick if side == 0 else 2 * tick - midpoint2\n                value = distance * probabilities[side][distance]\n                if value > best_value + 1e-15:\n                    best_tick, best_value = tick, value\n            return best_tick\n\n        # Track the book after N's actions. Entries carry IDs only where\n        # cancellations can refer to them; newly generated IDs are unnecessary.\n        book = {order.order_id: (self._fp_side(order.side), order.price_ticks,\n                                order.remaining_quantity, order.side, True)\n                for order in state.own_orders}\n        output = []\n        for index, action in enumerate(actions):\n            if isinstance(action, _FPAll):\n                book.clear()\n                output.append(action)\n            elif isinstance(action, _FPCancel):\n                book.pop(action.order_id, None)\n                output.append(action)\n            elif isinstance(action, _FPPlace):\n                side = self._fp_side(action.side)\n                tick = target(side, action.price_ticks)\n                if tick != action.price_ticks:\n                    self._fp_moves += 1\n                    action = _FPPlace(action.side, tick, action.quantity,\n                                      action.client_order_id)\n                output.append(action)\n                key = action.client_order_id if action.client_order_id else ('new', index)\n                book[key] = (side, tick, self._fp_quantity(action.quantity),\n                             action.side, False)\n            else:\n                output.append(action)\n\n        for order_id, (side, old_tick, quantity, side_enum, retained) in list(book.items()):\n            if not retained:\n                continue\n            tick = target(side, old_tick)\n            if tick != old_tick:\n                output.extend((_FPCancel(order_id),\n                               _FPPlace(side_enum, tick, quantity, order_id)))\n                book[order_id] = (side, tick, quantity, side_enum, False)\n                self._fp_moves += 1\n\n        levels = ({}, {})\n        for side, tick, quantity, _, _ in book.values():\n            levels[side][tick] = levels[side].get(tick, 0.0) + quantity\n        for side in range(2):\n            for tick in sorted(levels[side], reverse=(side == 0)):\n                distance = midpoint2 - 2 * tick if side == 0 else 2 * tick - midpoint2\n                self._fp_previous[side].append((distance, levels[side][tick]))\n        return output\n","failures":[],"python_version":"3.13.5","mech":"fill-probability pricing","complete":true,"h_n":500,"incumbent_mean":95.54201511346659,"mean_diff":-45.0804122913764,"se":3.562208961966889,"retail_diff":-42.3941188218194,"arb_diff":-2.6862934695700003,"tuning_mean":-50.021377253598004,"tuning_se":6.001043708645096,"by_spread":{"1":{"n":131,"mean_diff":0.0,"se":0.0,"sum_d":0.0,"sum_d2":0.0},"2":{"n":120,"mean_diff":0.0,"se":0.0,"sum_d":0.0,"sum_d2":0.0},"3":{"n":133,"mean_diff":-90.32758279451355,"se":8.133570885812732,"sum_d":-12013.5685116703,"sum_d2":2246573.351719773},"4":{"n":116,"mean_diff":-90.74687615532672,"se":8.572284838974317,"sum_d":-10526.6376340179,"sum_d2":1935536.9402954134}},"check_values_ok":true,"flag":null},{"key":"f-post-fill-other-side","spreads_acted":[1,2,3,4],"off_equals_n":true,"code_sha256":"224272791f9eab883fb38491d962ee9b34e0c287c6f57c136c9bf4e9996c7b18","assembled_sha256":"1556a07dae2a79038d844f36e6425b037e7942dbb23929aea7ef84f9ba707cf1","code":"from orderbook_pm_challenge.strategy import BaseStrategy\nfrom orderbook_pm_challenge.types import CancelAll, CancelOrder, PlaceOrder, Side, StepState\n\n\nclass Strategy(_N):\n    def __init__(self):\n        super().__init__()\n        self._post_side = None\n        self._post_left = 0\n\n    def on_step(self, state: StepState):\n        actions = list(super().on_step(state))\n        if not True:\n            return actions\n\n        spread = getattr(self, \"s\", None)\n        if spread not in (1, 2, 3, 4):\n            return actions\n        if state.buy_filled_quantity > 0.0:\n            self._post_side = Side.SELL\n            self._post_left = 1\n        elif state.sell_filled_quantity > 0.0:\n            self._post_side = Side.BUY\n            self._post_left = 1\n\n        if self._post_left <= 0 or self._post_side is None:\n            return actions\n\n        cancelled = {a.order_id for a in actions if isinstance(a, CancelOrder)}\n        cancelled_all = any(isinstance(a, CancelAll) for a in actions)\n        candidates = [o for o in state.own_orders\n                      if o.side is self._post_side and o.order_id not in cancelled]\n        if not cancelled_all and candidates:\n            if self._post_side is Side.SELL:\n                order = min(candidates, key=lambda o: (o.price_ticks, o.submitted_step))\n                price = order.price_ticks - 1\n            else:\n                order = max(candidates, key=lambda o: (o.price_ticks, -o.submitted_step))\n                price = order.price_ticks + 1\n            # Moving inward raises collateral.  Skip when the callback's\n            # currently free cash cannot cover the worst-case increment;\n            # cancellation itself releases the old order's reservation.\n            delta = abs(price - order.price_ticks) * order.remaining_quantity / 100.0\n            incumbent_reserve = sum(\n                (a.price_ticks if a.side is Side.BUY else 100 - a.price_ticks)\n                * max(0.0, float(a.quantity)) / 100.0\n                for a in actions if isinstance(a, PlaceOrder)\n            )\n            if (1 <= price <= 99 and order.remaining_quantity > 0.0\n                    and state.free_cash + 1e-9 >= delta + incumbent_reserve + 500.0):\n                actions.append(CancelOrder(order.order_id))\n                actions.append(PlaceOrder(self._post_side, price, order.remaining_quantity))\n        self._post_left -= 1\n        if self._post_left <= 0:\n            self._post_side = None\n        return actions\n","failures":{"incumbent":0,"candidate":0,"tuning_candidate_one":11,"tuning_candidate_two":14},"python_version":"3.12.3","mech":"post-fill other side: move the opposite side best own order one tick inward after a fill; one callback variant selected","complete":true,"h_n":500,"incumbent_mean":95.54201511346659,"mean_diff":-19.1679517670396,"se":1.0955187096270393,"retail_diff":-7.1281592681174,"arb_diff":-12.0397924989072,"tuning_mean":-64.2338984686665,"tuning_se":7.979057702600135,"by_spread":{"1":{"n":131,"mean_diff":-12.076401637144274,"se":2.038618203352837,"sum_d":-1582.0086144658999,"sum_d2":89881.04139078992},"2":{"n":120,"mean_diff":-26.161987241735,"se":1.8693341153858618,"sum_d":-3139.4384690082,"sum_d2":132034.12447142552},"3":{"n":133,"mean_diff":-17.567561715896243,"se":1.548083035949384,"sum_d":-2336.4857082142003,"sum_d2":83120.38330658896},"4":{"n":116,"mean_diff":-21.776233550271552,"se":3.0377702820421177,"sum_d":-2526.0430918315,"sum_d2":178109.8684671258}},"check_values_ok":false,"flag":"11 one-callback and 14 two-callback tuning failures. Check values disagree with seven other inputs; unresolved."},{"key":"f-retail-clock","spreads_acted":[1,2,3,4],"off_equals_n":{"passed":true,"seeds":{"start":310000,"end":310009,"inclusive":true},"callbacks":20000,"method":"One engine run per seed, forwarding each actual N state to separate N and disabled-overlay instances and asserting action equality every step. Disabled early-return path unchanged by both collateral repairs."},"code_sha256":"8bc98c28c0086a79616b2611c92c395c41ba3900931c216332eefd12b087da07","assembled_sha256":"bd3791eaad2b71e7e03fa777c309b77307d7c9cf6565cefd44afcaac7ef283ec","code":"from collections import deque as _ClockDeque\nfrom dataclasses import replace as _clock_replace\nfrom orderbook_pm_challenge.types import PlaceOrder as _ClockPlace, CancelAll as _ClockCancelAll, CancelOrder as _ClockCancel, Side as _ClockSide\nfrom orderbook_pm_challenge.utils import quantize_down as _clock_floor\n\nclass Strategy(_N):\n    # Midpoint of the documented randomized retail arrival-rate band.\n    clock_prior = (0.154 + 0.352) / 2.0\n    clock_lo = 0.9\n    clock_hi = 1.1\n    clock_enabled = True\n    clock_spreads = (1, 2, 3, 4)\n\n    def on_step(self, state):\n        actions = super().on_step(state)\n        if not self.clock_enabled or self.s not in self.clock_spreads:\n            return actions\n        if not hasattr(self, '_retail_clock_fills'):\n            self._retail_clock_fills = _ClockDeque(maxlen=100)\n        if state.step > 0:\n            # Only aggregate side quantities are observable: count filled sides.\n            self._retail_clock_fills.append(\n                int(state.buy_filled_quantity > 0) +\n                int(state.sell_filled_quantity > 0))\n        if len(self._retail_clock_fills) < 100:\n            return actions\n        rate = sum(self._retail_clock_fills) / 100.0\n        scale = min(self.clock_hi, max(self.clock_lo, rate / self.clock_prior))\n        # Track a conservative collateral budget through the action sequence.\n        # Existing sell-order cash reservations are not exposed in StepState;\n        # individual cancellations therefore need not release their collateral.\n        # CancelAll restores the exact starting cash and inventory budget.\n        free = max(0.0, state.free_cash)\n        yes = max(0.0, state.yes_inventory - sum(\n            o.remaining_quantity for o in state.own_orders\n            if o.side == _ClockSide.SELL))\n        reservations = {\n            o.order_id: (round(o.price_ticks / 100.0 * o.remaining_quantity, 10), 0.0)\n            if o.side == _ClockSide.BUY else (0.0, 0.0)\n            for o in state.own_orders}\n        result = []\n        for a in actions:\n            if isinstance(a, _ClockCancelAll):\n                free = max(0.0, state.cash)\n                yes = max(0.0, state.yes_inventory)\n                reservations.clear()\n                result.append(a)\n            elif isinstance(a, _ClockCancel):\n                cash_refund, yes_refund = reservations.pop(a.order_id, (0.0, 0.0))\n                free += cash_refund\n                yes += yes_refund\n                result.append(a)\n            elif isinstance(a, _ClockPlace):\n                q = _clock_floor(a.quantity * scale, 0.01)\n                price = a.price_ticks / 100.0\n                capacity = (free / price if a.side == _ClockSide.BUY\n                            else yes + free / (1.0 - price))\n                q = min(q, _clock_floor(max(0.0, capacity - 1e-8), 0.01))\n                if q < 0.01:\n                    continue\n                if a.side == _ClockSide.BUY:\n                    cash_used = round(price * q, 10)\n                    covered = 0.0\n                else:\n                    covered = min(yes, q)\n                    cash_used = round((1.0 - price) * (q - covered), 10)\n                free = max(0.0, free - cash_used)\n                yes -= covered\n                if a.client_order_id is not None:\n                    reservations[a.client_order_id] = (cash_used, covered)\n                result.append(_clock_replace(a, quantity=q))\n            else:\n                result.append(a)\n        return result\n","failures":[{"phase":"superseded_revision_on_tuning_seeds","seed":320001,"variant":"wide","error":"orderbook_pm_challenge.market.OrderBookError: Insufficient free cash for order collateral","resolution":"Replaced incomplete collateral guards with an action-by-action ledger; the same three bound settings were then screened under safe2 revision IDs. Preflight outcomes excluded from tuning statistics; every (seed, revision ID) ran once; cached N observations reused."},{"phase":"superseded_revision_on_tuning_seeds","seed":320196,"variant":"mild_safe","error":"orderbook_pm_challenge.market.OrderBookError: Insufficient free cash for order collateral","resolution":"Replaced incomplete collateral guards with an action-by-action ledger; the same three bound settings were then screened under safe2 revision IDs. Preflight outcomes excluded from tuning statistics; every (seed, revision ID) ran once; cached N observations reused."}],"python_version":"3.12.3","mech":"retail clock","complete":true,"h_n":500,"incumbent_mean":95.54201511346659,"mean_diff":0.023166249447399926,"se":0.6164045815354549,"retail_diff":1.175439528368601,"arb_diff":-1.1522732789392003,"tuning_mean":-0.45149286061200117,"tuning_se":0.3228258775237606,"by_spread":{"1":{"n":131,"mean_diff":-0.016762931348855186,"se":1.5402068676754244,"sum_d":-2.1959440067000293,"sum_d2":40399.23624530289},"2":{"n":120,"mean_diff":-0.8979633625125003,"se":0.736439679411548,"sum_d":-107.75560350150003,"sum_d2":7841.424356210039},"3":{"n":133,"mean_diff":0.7862240086300754,"se":1.3873851660724037,"sum_d":104.56779314780002,"sum_d2":33874.662598209026},"4":{"n":116,"mean_diff":0.14626619900086205,"se":0.9749923379289188,"sum_d":16.966879084099997,"sum_d2":12683.619868240661}},"check_values_ok":true,"flag":"Two superseded tuning-revision collateral failures; selected repaired revision reports complete holdout. Strict failure flag retained."},{"key":"f-loss-budget-stop","spreads_acted":[1,2,3,4],"off_equals_n":{"passed":true,"seeds":[310000,310009],"steps_per_seed":[2000,2000,2000,2000,2000,2000,2000,2000,2000,2000],"steps_compared":20000,"repair_validation":"The entire disabled-path prefix is unchanged after collateral repair; 20,000 step comparisons remain applicable."},"code_sha256":"7c8d907a83b66c8a909633b2631200c73008c93e915fd7d4cb7e30e27abe2d78","assembled_sha256":"8fa1ffbf3ac07d76bdf9eef344a6c5c669d6df7838adc9386baecc9cd0f294f3","code":"from orderbook_pm_challenge.types import PlaceOrder as _LBPlace, CancelAll as _LBAll, CancelOrder as _LBCancel\nimport math as _lbmath\n\nclass Strategy(_N):\n    # Realized fill edge marked once, at the next callback's rival midpoint.\n    loss_budget = 80.0\n    loss_budget_enabled = True\n    loss_budget_spreads = (1, 2, 3, 4)\n\n    def on_step(self, state):\n        actions = super().on_step(state)\n        if not self.loss_budget_enabled or self.s not in self.loss_budget_spreads:\n            return actions\n        bid = state.competitor_best_bid_ticks\n        ask = state.competitor_best_ask_ticks\n        mid = (bid + ask) / 200.0 if bid is not None and ask is not None else None\n        if not hasattr(self, '_lb_previous'):\n            self._lb_previous = (state.cash, state.no_inventory)\n            self._lb_edge = 0.0\n            self._lb_stopped = False\n            self._lb_mid = mid\n        old_cash, old_no = self._lb_previous\n        mark = mid if mid is not None else self._lb_mid\n        if mark is not None:\n            # NO minting consumes one cash dollar; add it back to recover\n            # the signed YES trade cashflow, including uncovered sells.\n            self._lb_edge += (state.cash - old_cash + state.no_inventory - old_no\n                             + mark * (state.buy_filled_quantity - state.sell_filled_quantity))\n        self._lb_previous = (state.cash, state.no_inventory)\n        if mid is not None:\n            self._lb_mid = mid\n        first_stop = not self._lb_stopped and self._lb_edge < -self.loss_budget\n        self._lb_stopped = self._lb_stopped or first_stop\n        if not self._lb_stopped:\n            return actions\n        # Rebuild the desired book to recompute collateral after resizing.\n        # Existing reduced orders retain their size after the initial stop.\n        desired = {}\n        for order in state.own_orders:\n            q = order.remaining_quantity * (0.5 if first_stop else 1.0)\n            desired[order.order_id] = _LBPlace(order.side, order.price_ticks, q, order.order_id)\n        new_index = 0\n        for action in actions:\n            if isinstance(action, _LBAll):\n                desired.clear()\n            elif isinstance(action, _LBCancel):\n                desired.pop(action.order_id, None)\n            elif isinstance(action, _LBPlace):\n                new_index += 1\n                key = action.client_order_id if action.client_order_id is not None else ('new', new_index)\n                desired[key] = _LBPlace(action.side, action.price_ticks, action.quantity * 0.5, action.client_order_id)\n        result = [_LBAll()]\n        cash = max(0.0, state.cash)\n        yes = max(0.0, state.yes_inventory)\n        for order in desired.values():\n            price = order.price_ticks / 100.0\n            is_buy = order.side.value == 'BUY'\n            capacity = cash / price if is_buy else yes + cash / (1.0 - price)\n            quantity = _lbmath.floor(min(order.quantity, capacity) * 100.0 + 1e-9) / 100.0\n            if quantity < 0.01:\n                continue\n            if is_buy:\n                cash -= round(price * quantity, 10)\n            else:\n                covered = min(yes, quantity)\n                yes -= covered\n                cash -= round((1.0 - price) * (quantity - covered), 10)\n            cash = max(0.0, cash)\n            result.append(_LBPlace(order.side, order.price_ticks, quantity, order.client_order_id))\n        return result\n","failures":[{"phase":"initial tuning implementation","seed":320001,"strategy":"L5","error":"orderbook_pm_challenge.market.OrderBookError: Insufficient free cash for order collateral","resolution":"Rebuilt the reduced desired book with collateral caps. Initial seeds 320000 and 320001 excluded from selection; no seed/strategy pair rerun. Repaired variants evaluated on 320002..320199."}],"python_version":"3.14.4","mech":"f-loss-budget-stop","complete":true,"h_n":500,"incumbent_mean":95.5420151134666,"mean_diff":-0.05428840167759999,"se":0.03248791303525023,"retail_diff":-0.02120072151219992,"arb_diff":-0.03308768016500005,"tuning_mean":-0.0008670297237373037,"tuning_se":0.0008670297237373037,"by_spread":{"1":{"n":131,"mean_diff":-0.13815827357328242,"se":0.09864433908360343,"sum_d":-18.098733838099996,"sum_d2":168.21440675502728},"2":{"n":120,"mean_diff":-0.08088432760666629,"se":0.08088432760666629,"sum_d":-9.706119312799956,"sum_d2":94.20875211430828},"3":{"n":133,"mean_diff":-2.8553031578961335e-05,"se":2.855303157896133e-05,"sum_d":-0.0037975532000018575,"sum_d2":1.4421410306844347e-05},"4":{"n":116,"mean_diff":0.005728016080172046,"se":0.013371149512016709,"sum_d":0.6644498652999573,"sum_d2":2.3888330874107866}},"check_values_ok":true,"flag":"Initial L5 tuning collateral failure; repaired tuning excludes 320000 and 320001. Strict failure flag retained."},{"key":"f-behind-level","spreads_acted":[1,2,3,4],"off_equals_n":{"passed":true,"seeds":[310000,310009],"steps":20000,"method":"Two independent instances receive identical StepState each callback; compare complete action lists, execute N actions."},"code_sha256":"0e0ae3279638bb6672854065fa1a1ccf0dd7ab912e3022093f8e1bf073c5a1a2","assembled_sha256":"b459788a5040f3fe023c4fb6512e868cb54c7c39f3f92a27029ca16599969689","code":"from orderbook_pm_challenge.types import PlaceOrder as _Place, CancelOrder as _Cancel, CancelAll as _CancelAll, Side as _Side\nfrom dataclasses import replace as _replace\n\nclass Strategy(_N):\n    enabled = True\n    spreads_acted = (1, 2, 3, 4)\n\n    def on_step(self, state):\n        actions = list(super().on_step(state))\n        if not self.enabled or self.s not in self.spreads_acted:\n            return actions\n        bid = state.competitor_best_bid_ticks\n        ask = state.competitor_best_ask_ticks\n        if bid is None or ask is None or not 40 <= bid + ask <= 160:\n            return actions\n\n        def behind(side, price):\n            if side == _Side.BUY and price >= bid and bid > 1:\n                return bid - 1\n            if side == _Side.SELL and price <= ask and ask < 99:\n                return ask + 1\n            return price\n\n        moved = [\n            _replace(a, price_ticks=behind(a.side, a.price_ticks))\n            if isinstance(a, _Place) else a for a in actions\n        ]\n        # Resting orders that N leaves alive must follow the same price rule.\n        if not any(isinstance(a, _CancelAll) for a in actions):\n            cancelled = {a.order_id for a in actions if isinstance(a, _Cancel)}\n            adjustments = []\n            for order in state.own_orders:\n                if order.order_id in cancelled:\n                    continue\n                price = behind(order.side, order.price_ticks)\n                if price != order.price_ticks:\n                    adjustments.extend([\n                        _Cancel(order.order_id),\n                        _Place(order.side, price, order.remaining_quantity),\n                    ])\n            moved = adjustments + moved\n        return moved\n","failures":[],"python_version":"3.12.3","mech":"rest behind rival best inside midpoint band","complete":true,"h_n":500,"incumbent_mean":95.54201511346659,"mean_diff":-18.194942736904398,"se":0.994381862011086,"retail_diff":-16.7792795159174,"arb_diff":-1.4156632209834006,"tuning_mean":-20.227735149642,"tuning_se":1.510522893938135,"by_spread":{"1":{"n":131,"mean_diff":-4.936567857247327,"se":1.8326264778516703,"sum_d":-646.6903892993998,"sum_d2":60388.02330811718},"2":{"n":120,"mean_diff":-9.789734443769165,"se":0.6215109125284222,"sum_d":-1174.7681332522998,"sum_d2":17016.686687058947},"3":{"n":133,"mean_diff":-22.531983059945116,"se":1.4338349013541491,"sum_d":-2996.7537469727004,"sum_d2":103615.87825895115},"4":{"n":116,"mean_diff":-36.89016464592931,"se":2.3448759705751696,"sum_d":-4279.2590989278,"sum_d2":231211.80657589808}},"check_values_ok":true,"flag":null}],"top":[{"key":"f-side-size-ratio","code_sha256":"1a930d17d399b7f6491e0b2c6d3c7a4e46376fd106ffc2b1c508106391664e11","assembled_sha256":"9a1ca39e05580cc0936f7705a43b36bf1970c398c05d2fda5a51bf39b68f3ee0","code":"# Overlay f-side-size-ratio: scale N's bid sizes by RB and ask sizes by RA\n# while the rival midpoint is between LO and HI ticks, on the spreads in SPREADS.\nfrom orderbook_pm_challenge.types import CancelAll as _ZCA\nfrom orderbook_pm_challenge.types import CancelOrder as _ZCO\nfrom orderbook_pm_challenge.types import PlaceOrder as _ZPO\nfrom orderbook_pm_challenge.types import Side as _ZSide\n\n\nclass Strategy(_N):\n    RB = 1.3  # multiplier on BUY (bid) order sizes\n    RA = 1.3  # multiplier on SELL (ask) order sizes\n    LO = 20.0  # rival midpoint band, in ticks (cents), inclusive\n    HI = 80.0\n    SPREADS = (1, 2, 3, 4)  # rival spreads (N's self.s) acted on; () switches the overlay off\n\n    def on_step(self, state):\n        acts = super().on_step(state)\n        if not acts or getattr(self, \"s\", None) not in self.SPREADS:\n            return acts\n        bid = state.competitor_best_bid_ticks\n        ask = state.competitor_best_ask_ticks\n        if bid is None or ask is None:\n            return acts\n        mid = 0.5 * (bid + ask)\n        if mid < self.LO or mid > self.HI:\n            return acts\n        rb = float(self.RB)\n        ra = float(self.RA)\n        if rb == 1.0 and ra == 1.0:\n            return acts\n        src = list(acts)\n        out = self._z_scale(state, src, rb, ra)\n        if out is None and (rb > 1.0 or ra > 1.0):\n            # scaled-up sizes do not fit the collateral: only apply the cuts\n            rb = min(rb, 1.0)\n            ra = min(ra, 1.0)\n            if rb == 1.0 and ra == 1.0:\n                return acts\n            out = self._z_scale(state, src, rb, ra)\n        return acts if out is None else out\n\n    @staticmethod\n    def _z_scale(state, src, rb, ra):\n        \"\"\"Resize every PlaceOrder; replay the simulator's collateral rule on a\n        conservative model of the account and return None if anything would not fit.\"\"\"\n        cash = float(state.cash)\n        yes = float(state.yes_inventory)\n        free = float(state.free_cash)\n        buy_res = 0.0\n        sell_rem = 0.0\n        for o in state.own_orders:\n            if o.side is _ZSide.BUY:\n                buy_res += o.price_ticks / 100.0 * o.remaining_quantity\n            else:\n                sell_rem += o.remaining_quantity\n        covered = (float(state.reserved_cash) - buy_res) < 1e-6  # resting asks all backed by YES\n        avail = max(0.0, yes - sell_rem)\n        live = {}\n        for o in state.own_orders:\n            if o.side is _ZSide.BUY:\n                live[o.order_id] = (o.price_ticks / 100.0 * o.remaining_quantity, 0.0)\n            else:\n                live[o.order_id] = (0.0, o.remaining_quantity if covered else 0.0)\n        out = []\n        for act in src:\n            if isinstance(act, _ZCA):\n                free = cash\n                avail = yes\n                live = {}\n                out.append(act)\n            elif isinstance(act, _ZCO):\n                rel = live.pop(act.order_id, None)\n                if rel is not None:\n                    free += rel[0]\n                    avail += rel[1]\n                out.append(act)\n            elif isinstance(act, _ZPO):\n                f = rb if act.side is _ZSide.BUY else ra\n                q0 = float(act.quantity)\n                if f == 1.0:\n                    q = int(q0 * 100.0 + 1e-6) / 100.0\n                else:\n                    q = max(0.01, int(q0 * f * 100.0 + 1e-6) / 100.0)\n                price = act.price_ticks / 100.0\n                if act.side is _ZSide.BUY:\n                    need = price * q\n                    use_yes = 0.0\n                else:\n                    use_yes = min(q, avail)\n                    need = (1.0 - price) * (q - use_yes)\n                if free - need < 1e-6:\n                    return None\n                free -= need\n                avail -= use_yes\n                if act.client_order_id is not None:\n                    live[act.client_order_id] = (need, use_yes)\n                out.append(act if f == 1.0 else _ZPO(act.side, act.price_ticks, q, act.client_order_id))\n            else:\n                out.append(act)\n        return out\n"},{"key":"f-end-flatten","code_sha256":"69be55c4b7e1f403bea3b449bf80b14126b26b0a4a3253ebd58c6af1cc377e19","assembled_sha256":"592f5596f3fef8426992798d2effe6619e46099ab27898d2a052d6dd20f8283e","code":"# Overlay f-end-flatten: in the last E steps, cancel every order on the side\n# that would increase |net inventory| (net = yes - no). Flat book: unchanged.\nfrom orderbook_pm_challenge.types import CancelAll, CancelOrder, PlaceOrder, Side\n\nEND_E = 10\nACT_SPREADS = (1, 2, 3, 4)\nFLAT_EPS = 1e-9\n\n\nclass Strategy(_N):\n    def on_step(self, state):\n        acts = list(super().on_step(state))\n        E = END_E\n        if E <= 0 or state.steps_remaining > E:\n            return acts\n        if getattr(self, \"s\", None) not in ACT_SPREADS:\n            return acts\n        net = state.yes_inventory - state.no_inventory\n        if net > FLAT_EPS:\n            bad = Side.BUY\n        elif net < -FLAT_EPS:\n            bad = Side.SELL\n        else:\n            return acts\n        live = {o.order_id: o.side for o in state.own_orders}\n        out = []\n        for a in acts:\n            if isinstance(a, CancelAll):\n                live.clear()\n                out.append(a)\n            elif isinstance(a, CancelOrder):\n                live.pop(a.order_id, None)\n                out.append(a)\n            elif isinstance(a, PlaceOrder):\n                if a.side == bad:\n                    continue\n                if a.client_order_id is not None:\n                    live[a.client_order_id] = a.side\n                out.append(a)\n            else:\n                out.append(a)\n        for oid, side in live.items():\n            if side == bad:\n                out.append(CancelOrder(oid))\n        return out\n"},{"key":"f-behind-level","code_sha256":"0e0ae3279638bb6672854065fa1a1ccf0dd7ab912e3022093f8e1bf073c5a1a2","assembled_sha256":"b459788a5040f3fe023c4fb6512e868cb54c7c39f3f92a27029ca16599969689","code":"from orderbook_pm_challenge.types import PlaceOrder as _Place, CancelOrder as _Cancel, CancelAll as _CancelAll, Side as _Side\nfrom dataclasses import replace as _replace\n\nclass Strategy(_N):\n    enabled = True\n    spreads_acted = (1, 2, 3, 4)\n\n    def on_step(self, state):\n        actions = list(super().on_step(state))\n        if not self.enabled or self.s not in self.spreads_acted:\n            return actions\n        bid = state.competitor_best_bid_ticks\n        ask = state.competitor_best_ask_ticks\n        if bid is None or ask is None or not 40 <= bid + ask <= 160:\n            return actions\n\n        def behind(side, price):\n            if side == _Side.BUY and price >= bid and bid > 1:\n                return bid - 1\n            if side == _Side.SELL and price <= ask and ask < 99:\n                return ask + 1\n            return price\n\n        moved = [\n            _replace(a, price_ticks=behind(a.side, a.price_ticks))\n            if isinstance(a, _Place) else a for a in actions\n        ]\n        # Resting orders that N leaves alive must follow the same price rule.\n        if not any(isinstance(a, _CancelAll) for a in actions):\n            cancelled = {a.order_id for a in actions if isinstance(a, _Cancel)}\n            adjustments = []\n            for order in state.own_orders:\n                if order.order_id in cancelled:\n                    continue\n                price = behind(order.side, order.price_ticks)\n                if price != order.price_ticks:\n                    adjustments.extend([\n                        _Cancel(order.order_id),\n                        _Place(order.side, price, order.remaining_quantity),\n                    ])\n            moved = adjustments + moved\n        return moved\n"}],"notes":"Sources: .imd/reads/artifacts/item-{key}, mapped one-to-one to rows. Metrics copied from paired.overall/by_spread; tuning_mean/se are selected-variant paired differences, not absolute scores. mech is truncated to 200 characters where needed. All eight UTF-8 code hashes verified; input hashes match task pins. Assembled hashes copied, not independently reconstructed. Check values agree within 0.000001 across seven inputs; post-fill differs. Incumbent means agree at reported precision (95.542015 versus 95.54201511346659/6), so no substantive discrepancy flag. Strict flags include superseded failures. Exposure complete=true copied despite failed runs. Rank by maximum mean_diff/se on acted spreads with positive SE; 0/0 excluded. Top rows are screens, not promotions. Holdout 430000..430499; tuning 320000..320199 except loss-budget 320002..320199. No simulations or finalist seeds run. N hash: bf0d179f3e47d28819f6fa7e0d25548c2ced43374c216d36460b00a26a26ffae. Task reports source warnings for exposure-ratchet (1), side-size-ratio (4), end-flatten (1), retail-clock (1); external-source claims from those items remain unverified and are not used to justify ranking. Only supplied measurements are ranked; no data fabricated."}
```