{"item":"b","elapsed_minutes_since_setup_at_packaging":40.01493149201075,"blocked":null,"complete":true,"board_claim":null,"interrupted_attempt":{"name":"G0M0","sha256":"44a9f1d3c37dfd979e82c03798e56620f11a0eb6f9a1da3b6885e496509f8eb6","requested_seeds":[670032,670063],"completed_results_returned":0,"counters":"unavailable","selected":false,"handling":"Full 32-seed block rerun after restart; no partial results used."},"search_elapsed_seconds":342.4377631852403,"code":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\n\nimport {AMMStrategyBase} from \"./AMMStrategyBase.sol\";\nimport {TradeInfo} from \"./IAMMStrategy.sol\";\n\ncontract Strategy is AMMStrategyBase {\n    uint256 constant ELAPSED_CAP = 8;\n    uint256 constant SIGNAL_THRESHOLD = WAD / 650;\n    uint256 constant DIR_DECAY = 750000000000000000;\n    uint256 constant ACT_DECAY = 530000000000000000;\n    uint256 constant SIZE_DECAY = 530000000000000000;\n    uint256 constant TOX_DECAY = 910000000000000000;\n    uint256 constant SIGMA_DECAY = 690000000000000000;\n    uint256 constant LAMBDA_DECAY = 990000000000000000;\n    uint256 constant SIZE_BLEND_DECAY = 828000000000000000;\n    uint256 constant TOX_BLEND_DECAY = 51000000000000000;\n    uint256 constant ACT_BLEND_DECAY = 985000000000000000;\n    uint256 constant PHAT_ALPHA = 270000000000000000;\n    uint256 constant PHAT_ALPHA_RETAIL = 60000000000000000;\n    uint256 constant PHAT_ALPHA_SAME = 120000000000000000;\n    uint256 constant REVERT_U = 0;\n    uint256 constant DIR_IMPACT_MULT = 4;\n    uint256 constant GATE_SIGMA_MULT = 7200000000000000000;\n    uint256 constant MIN_GATE = 30000000000000000;\n    uint256 constant TRADE_TOX_BOOST = 3500 * BPS;\n    uint256 constant STALE_ATTRACT_FRAC = 1050000000000000000;\n    uint256 constant RET_CAP = WAD / 35;\n    uint256 constant TOX_CAP = WAD / 5;\n    uint256 constant TRADE_RATIO_CAP = WAD / 5;\n    uint256 constant LAMBDA_CAP = 1820000000000000000;\n    uint256 constant STEP_COUNT_CAP = 64;\n    uint256 constant BASE_FEE = 4 * BPS;\n    uint256 constant SIGMA_COEF = 200000000000000000;\n    uint256 constant LAMBDA_COEF = 12 * BPS;\n    uint256 constant FLOW_SIZE_COEF = 4842 * BPS;\n    uint256 constant TOX_COEF = 300 * BPS;\n    uint256 constant TOX_QUAD_COEF = 15000 * BPS;\n    uint256 constant ACT_COEF = 91843 * BPS;\n    uint256 constant DIR_COEF = 20 * BPS;\n    uint256 constant DIR_TOX_COEF = 100 * BPS;\n    uint256 constant STALE_DIR_COEF = 6850 * BPS;\n    uint256 constant SIGMA_TOX_COEF = 500 * BPS;\n    uint256 constant TAIL_KNEE = 600 * BPS;\n    uint256 constant TAIL_SLOPE_PROTECT = 930000000000000000;\n    uint256 constant TAIL_SLOPE_ATTRACT = 850000000000000000;\n\n    function afterInitialize(uint256 initialX, uint256 initialY) external override returns (uint256, uint256) {\n        slots[0] = BASE_FEE; slots[1] = BASE_FEE; slots[3] = WAD; \n        slots[5] = initialX > 0 ? wdiv(initialY, initialX) : 100 * WAD;\n        slots[6] = 950000000000000; slots[7] = 800000000000000000; slots[8] = 2000000000000000;\n        slots[13] = 902500000000; slots[14] = slots[5]; \n        return (BASE_FEE, BASE_FEE);\n    }\n\n    function afterSwap(TradeInfo calldata trade) external override returns (uint256, uint256) {\n        uint256 prevBidFee = slots[0]; uint256 prevAskFee = slots[1]; uint256 lastTs = uint64(slots[2]);\n        uint256 dirState = slots[3]; uint256 actEma = slots[4]; uint256 pHat = slots[5];\n        uint256 sigmaHat = slots[6]; uint256 lambdaHat = slots[7]; uint256 sizeHat = slots[8];\n        uint256 toxEma = slots[9]; uint256 stepTradeCount = slots[10];\n\n        uint256 sigmaForFast = sigmaHat;\n        uint256 fastHat = slots[14];\n        uint256 uncertainty = slots[13];\n        uint256 silent = trade.timestamp > lastTs ? trade.timestamp - lastTs : 0;\n        bool isNewStep = trade.timestamp > lastTs;\n        if (isNewStep) {\n            uint256 elapsedRaw = trade.timestamp - lastTs;\n            uint256 elapsed = elapsedRaw > ELAPSED_CAP ? ELAPSED_CAP : elapsedRaw;\n            dirState = _decayCentered(dirState, DIR_DECAY, elapsed);\n            actEma = wmul(actEma, _powWad(ACT_DECAY, elapsed));\n            sizeHat = wmul(sizeHat, _powWad(SIZE_DECAY, elapsed));\n            toxEma = wmul(toxEma, _powWad(TOX_DECAY, elapsed));\n            if (stepTradeCount > 0 && elapsedRaw > 0) {\n                uint256 lambdaInst = (stepTradeCount * WAD) / elapsedRaw;\n                if (lambdaInst > LAMBDA_CAP) lambdaInst = LAMBDA_CAP;\n                lambdaHat = wmul(lambdaHat, LAMBDA_DECAY) + wmul(lambdaInst, WAD - LAMBDA_DECAY);\n            }\n            // Process variance is propagated inside the censored update.\n            if (uncertainty > 100000000000000) uncertainty = 100000000000000;\n            stepTradeCount = 0;\n        }\n\n        bool firstInStep = stepTradeCount == 0;\n        uint256 spot = trade.reserveX > 0 ? wdiv(trade.reserveY, trade.reserveX) : pHat;\n        if (pHat == 0) pHat = spot;\n\n        uint256 feeUsed = trade.isBuy ? prevBidFee : prevAskFee;\n        uint256 gamma = feeUsed < WAD ? WAD - feeUsed : 0;\n        uint256 pImplied;\n        if (gamma == 0) { pImplied = spot; }\n        else { pImplied = trade.isBuy ? wmul(spot, gamma) : wdiv(spot, gamma); }\n\n        // S: infer a no-trade interval center from the last post-trade spot.\n        uint256 silenceScale = WAD;\n        if (firstInStep && silent > 1) {\n            uint256 g = silent - 1;\n            if (g > 1) g = 1;\n            uint256 w = WAD - _powWad(800000000000000000, g);\n            uint256 s = slots[2] >> 64;\n            if (s == 0) s = pHat;\n            uint256 c = (wmul(s, WAD - prevBidFee) + wdiv(s, WAD - prevAskFee)) / 2;\n            if (c >= pHat) pHat += wmul(w, c - pHat);\n            else pHat -= wmul(w, pHat - c);\n            silenceScale = WAD - wmul(300000000000000000, w);\n        }\n\n        {\n            uint256 ret = pHat > 0 ? wdiv(absDiff(pImplied, pHat), pHat) : 0;\n            uint256 alpha = firstInStep ? PHAT_ALPHA : PHAT_ALPHA_RETAIL;\n            uint256 prePhat = pHat;\n            bool secondPrint = !firstInStep && stepTradeCount == 1;\n            bool sameDir = false; bool oppDir = false;\n            if (secondPrint) {\n                bool up2 = pImplied >= pHat;\n                uint256 d1 = slots[12];\n                if (d1 != 0) { sameDir = (d1 == 1) == up2; oppDir = !sameDir; }\n                if (sameDir) alpha = PHAT_ALPHA_SAME;\n            }\n            if (firstInStep) { slots[12] = pImplied >= pHat ? 1 : 2; }\n            uint256 adaptiveGate = wmul(sigmaHat, GATE_SIGMA_MULT);\n            if (adaptiveGate < MIN_GATE) adaptiveGate = MIN_GATE;\n            alpha = wmul(alpha, silenceScale);\n            adaptiveGate = wmul(adaptiveGate, silenceScale);\n            if (ret <= adaptiveGate) { pHat = wmul(pHat, WAD - alpha) + wmul(pImplied, alpha); }\n            if (oppDir && REVERT_U > 0) {\n                uint256 pre = slots[11];\n                if (pre > pHat) pHat = pHat + wmul(pre - pHat, REVERT_U);\n                else pHat = pHat - wmul(pHat - pre, REVERT_U);\n            }\n            if (firstInStep) {\n                if (ret > RET_CAP) ret = RET_CAP;\n                sigmaHat = wmul(sigmaHat, SIGMA_DECAY) + wmul(ret, WAD - SIGMA_DECAY);\n            }\n        }\n\n        // Interior retail routing equalizes fee-adjusted marginal prices.\n        // Subsequent trades in a step cannot be the initial arbitrage trade.\n        if (!firstInStep && feeUsed > 30 * BPS && gamma > 0) {\n            uint256 normalSpot = trade.isBuy\n                ? wdiv(wmul(spot, gamma), WAD - 30 * BPS)\n                : wdiv(wmul(spot, WAD - 30 * BPS), gamma);\n            pHat = wmul(pHat, 90 * WAD / 100) + wmul(normalSpot, 10 * WAD / 100);\n        }\n\n        // Censored assumed-density posterior. No external or future inputs.\n        (fastHat, uncertainty) = _posterior(PosteriorInput(\n            fastHat, uncertainty, pImplied, spot, slots[2] >> 64,\n            prevBidFee, prevAskFee, firstInStep, silent, trade.isBuy,\n            trade.reserveY > 0 ? wdiv(trade.amountY, trade.reserveY) : 0\n        ));\n        slots[13] = uncertainty;\n        slots[14] = fastHat;\n        uint256 tradeRatio = trade.reserveY > 0 ? wdiv(trade.amountY, trade.reserveY) : 0;\n        if (tradeRatio > TRADE_RATIO_CAP) tradeRatio = TRADE_RATIO_CAP;\n\n        if (tradeRatio > SIGNAL_THRESHOLD) {\n            uint256 push = tradeRatio * DIR_IMPACT_MULT;\n            if (push > WAD / 4) push = WAD / 4;\n            if (trade.isBuy) {\n                dirState = dirState + push;\n                if (dirState > 2 * WAD) dirState = 2 * WAD;\n            } else {\n                dirState = dirState > push ? dirState - push : 0;\n            }\n            actEma = wmul(actEma, ACT_BLEND_DECAY) + wmul(tradeRatio, WAD - ACT_BLEND_DECAY);\n            sizeHat = wmul(sizeHat, SIZE_BLEND_DECAY) + wmul(tradeRatio, WAD - SIZE_BLEND_DECAY);\n            if (sizeHat > WAD) sizeHat = WAD;\n        }\n\n        uint256 tox = pHat > 0 ? wdiv(absDiff(spot, pHat), pHat) : 0;\n        if (tox > TOX_CAP) tox = TOX_CAP;\n        toxEma = wmul(toxEma, TOX_BLEND_DECAY) + wmul(tox, WAD - TOX_BLEND_DECAY);\n        uint256 toxSignal = toxEma;\n\n        stepTradeCount = stepTradeCount + 1;\n        if (stepTradeCount > STEP_COUNT_CAP) stepTradeCount = STEP_COUNT_CAP;\n\n        uint256 flowSize = wmul(lambdaHat, sizeHat);\n        uint256 fBase = BASE_FEE + wmul(SIGMA_COEF, sigmaHat) + wmul(LAMBDA_COEF, lambdaHat) + wmul(FLOW_SIZE_COEF, flowSize);\n        uint256 fMid = fBase + wmul(TOX_COEF, toxSignal) + wmul(TOX_QUAD_COEF, wmul(toxSignal, toxSignal)) + wmul(ACT_COEF, actEma);\n        fMid = fMid + wmul(SIGMA_TOX_COEF, wmul(sigmaHat, toxSignal));\n\n        uint256 dirDev; bool sellPressure;\n        if (dirState >= WAD) { dirDev = dirState - WAD; sellPressure = true; }\n        else { dirDev = WAD - dirState; sellPressure = false; }\n\n        uint256 skew = wmul(DIR_COEF, dirDev) + wmul(DIR_TOX_COEF, wmul(dirDev, toxSignal));\n        uint256 bidFee; uint256 askFee;\n        if (sellPressure) {\n            bidFee = fMid + skew;\n            askFee = fMid > skew ? fMid - skew : 0;\n        } else {\n            askFee = fMid + skew;\n            bidFee = fMid > skew ? fMid - skew : 0;\n        }\n\n        {\n            uint256 staleHat = wmul(pHat, 700000000000000000) + wmul(fastHat, 300000000000000000);\n            uint256 staleTox = wdiv(absDiff(spot, staleHat), staleHat);\n            if (staleTox > TOX_CAP) staleTox = TOX_CAP;\n            uint256 staleShift = wmul(STALE_DIR_COEF, staleTox);\n            uint256 attractShift = wmul(staleShift, STALE_ATTRACT_FRAC);\n            if (spot >= staleHat) {\n                bidFee = bidFee + staleShift;\n                askFee = askFee > attractShift ? askFee - attractShift : 0;\n            } else {\n                askFee = askFee + staleShift;\n                bidFee = bidFee > attractShift ? bidFee - attractShift : 0;\n            }\n        }\n\n        {\n            bool tradeAligned = (trade.isBuy && spot >= pHat) || (!trade.isBuy && spot < pHat);\n            if (tradeAligned) {\n                uint256 tradeBoost = wmul(TRADE_TOX_BOOST, tradeRatio);\n                if (!firstInStep && tradeBoost > 16 * BPS) tradeBoost = 16 * BPS;\n                if (trade.isBuy) { bidFee = bidFee + tradeBoost; }\n                else { askFee = askFee + tradeBoost; }\n            }\n        }\n\n        if (sellPressure) {\n            bidFee = clampFee(_compressTailWithSlope(bidFee, TAIL_SLOPE_PROTECT));\n            askFee = clampFee(_compressTailWithSlope(askFee, TAIL_SLOPE_ATTRACT));\n        } else {\n            askFee = clampFee(_compressTailWithSlope(askFee, TAIL_SLOPE_PROTECT));\n            bidFee = clampFee(_compressTailWithSlope(bidFee, TAIL_SLOPE_ATTRACT));\n        }\n\n        if (firstInStep) {\n            if (askFee > bidFee && bidFee > 30 * BPS) bidFee = 30 * BPS;\n            else if (bidFee > askFee && askFee > 30 * BPS) askFee = 30 * BPS;\n        }\n\n        if (bidFee > askFee && askFee > 36 * BPS) askFee = 36 * BPS;\n        else if (askFee > bidFee && bidFee > 36 * BPS) bidFee = 36 * BPS;\n\n        (bidFee, askFee) = _nextPolicy(bidFee, askFee, spot, fastHat, uncertainty, tradeRatio, stepTradeCount, trade.timestamp, lastTs);\n        slots[0] = bidFee; slots[1] = askFee; slots[2] = (spot << 64) | trade.timestamp;\n        slots[3] = dirState; slots[4] = actEma; slots[5] = pHat;\n        slots[6] = sigmaHat; slots[7] = lambdaHat; slots[8] = sizeHat;\n        slots[9] = toxEma; slots[10] = stepTradeCount;\n\n        return (bidFee, askFee);\n    }\n\n\n\n    // A quote is labelled only by the next own callback, never by its own print.\n    // 8 buckets: gap/uncertainty, observed size, callback count within timestamp.\n    function _nextPolicy(uint256 bid,uint256 ask,uint256 spot,uint256 fair,uint256 variance,uint256 size,uint256 count,uint256 ts,uint256 oldTs) internal returns(uint256,uint256) {\n        uint256 previous=slots[15];\n        if(previous>0) {\n            uint256 at=16+previous-1;\n            uint256 packed=slots[at];\n            uint256 n=uint64(packed); uint256 y=packed>>64;\n            if(n>=128) {n/=2;y/=2;}\n            n++;if(ts==oldTs)y++;\n            slots[at]=(y<<64)|n;\n        }\n        uint256 sd=_isqrt(variance*WAD);\n        uint256 gap=wdiv(absDiff(spot,fair),fair);\n        uint256 context=(gap>sd?1:0)+(size>2268885762962770?2:0)+(count>1?4:0);\n        slots[15]=context+1;\n        uint256 history=slots[16+context];\n        uint256 p=wdiv((history>>64)+8,uint64(history)+16);\n        // Context-conditioned variant interpolates online probability with size certainty.\n        if(2==2) p=wmul(p, WAD-wmul(574475163060396800,wdiv(size,size+2268885762962770)));\n        uint256 gate=2==1?(p>403725108926299456?WAD:0):p;\n        uint256 certainty=wdiv(gap,gap+sd+1);\n        uint256 large=wdiv(size,size+2268885762962770);\n        // Long quote: protect against drift and posterior uncertainty.\n        // Short quote: attract routing flow with a size-conditioned spread concession.\n        int256 common=(int256(wmul(WAD-gate,0))-int256(wmul(gate,wmul(27983050569762,large))));\n        uint256 shift=wmul(wmul(WAD-gate,certainty),0);\n        int256 dBid=common+(spot>=fair?int256(shift):-int256(shift));\n        int256 dAsk=common+(spot>=fair?-int256(shift):int256(shift));\n        return (_residual(bid,dBid),_residual(ask,dAsk));\n    }\n    function _residual(uint256 fee,int256 delta) internal pure returns(uint256) {\n        int256 cap=int256(8*BPS);\n        if(delta>cap)delta=cap;if(delta< -cap)delta= -cap;\n        int256 next=int256(fee)+delta;\n        return next<=0?0:clampFee(uint256(next));\n    }\n\n    struct PosteriorInput {\n        uint256 mu; uint256 v; uint256 obs; uint256 spot; uint256 preSpot;\n        uint256 bid; uint256 ask; bool first; uint256 silent; bool buy; uint256 size;\n    }\n    function _posterior(PosteriorInput memory x) internal pure returns (uint256, uint256) {\n        if (x.mu == 0) x.mu = x.spot;\n        if (x.v < 10000000000) x.v = 10000000000;\n        uint256 lo = wmul(x.preSpot, WAD-x.bid);\n        uint256 hi = wdiv(x.preSpot, WAD-x.ask);\n        if (x.first) {\n            if (x.silent>1 && x.preSpot>0) {\n                uint256 elapsed=x.silent>8?8:x.silent;\n                x.v += 902500000000*(elapsed-1);\n                (x.mu,x.v)=_band(x.mu,x.v,lo,hi);\n            }\n            x.v+=902500000000;\n        }\n        uint256 mRetail = x.mu;\n        uint256 vRetail = x.v;\n        // A missing own-pool trade is a censored price observation.\n        if (x.first && x.preSpot > 0) {\n            (mRetail, vRetail) = _band(x.mu, x.v, lo, hi);\n        }\n        if (!x.first) {\n            // A later print is retail. Only an interior route is an observation\n            // of the other pool, with explicit observation uncertainty.\n            uint256 fee = x.buy ? x.bid : x.ask;\n            if (fee > 30 * BPS) {\n                uint256 normal = x.buy ? wdiv(wmul(x.spot, WAD-fee), WAD-30*BPS)\n                    : wdiv(wmul(x.spot, WAD-30*BPS), WAD-fee);\n                uint256 residual = wdiv(absDiff(normal, x.mu),x.mu);\n                uint256 noise = 9000000000000 + wmul(residual,residual);\n                uint256 k = wdiv(x.v,x.v+noise);\n                return (_blend(x.mu,normal,k),wmul(x.v,WAD-k));\n            }\n            return (x.mu,x.v);\n        }\n        uint256 e = wdiv(absDiff(x.obs,x.mu),x.mu);\n        uint256 totalV = x.v + 22500000000;\n        uint256 z = wdiv(wmul(e,e),totalV);\n        uint256 density = _powWad(wdiv(WAD,WAD+z/8),4);\n        uint256 odds = wmul(density,wdiv(4000000000000000,_isqrt(totalV*WAD)));\n        if (x.size > 3000000000000000) odds = wmul(odds,4*WAD/10);\n        if (x.silent > 1) odds = wmul(odds,8*WAD/10);\n        uint256 sd = _isqrt(x.v*WAD);\n        uint256 width = wdiv(hi-lo,x.mu);\n        uint256 distance = x.mu<lo?lo-x.mu:(x.mu>hi?x.mu-hi:0);\n        uint256 zBand = wdiv(wdiv(distance,x.mu),sd);\n        uint256 mass = wmul(wdiv(width,width+2*sd),wdiv(WAD,WAD+wmul(zBand,zBand)));\n        if (mass < WAD/100) mass = WAD/100;\n        odds = wdiv(odds,mass);\n        uint256 prob = wdiv(odds,WAD+odds);\n        uint256 kArb = wdiv(x.v,totalV);\n        uint256 mArb = _blend(x.mu,x.obs,kArb);\n        uint256 mean = _blend(mRetail,mArb,prob);\n        uint256 between = wdiv(absDiff(mArb,mRetail),x.mu);\n        uint256 variance = wmul(prob,wmul(x.v,WAD-kArb)) + wmul(WAD-prob,vRetail)\n            + wmul(wmul(prob,WAD-prob),wmul(between,between));\n        if (variance > 100000000000000) variance = 100000000000000;\n        return (mean,variance);\n    }\n    function _blend(uint256 a,uint256 b,uint256 w) internal pure returns(uint256) {\n        return b>=a ? a+wmul(b-a,w) : a-wmul(a-b,w);\n    }\n    function _band(uint256 mu,uint256 v,uint256 lo,uint256 hi) internal pure returns(uint256,uint256) {\n        // Soft interval likelihood avoids discontinuities at quadrature nodes.\n        uint256 sd=wmul(mu,_isqrt(v*WAD));\n        uint256[3] memory acc;\n        for(uint256 j=0;j<7;j++) {\n            uint256 p=j<3 ? (mu>(3-j)*sd?mu-(3-j)*sd:1) : mu+(j-3)*sd;\n            uint256 w=j==3?72:(j==2||j==4?45:(j==1||j==5?10:1));\n            uint256 distance=p<lo?lo-p:(p>hi?p-hi:0);\n            uint256 z=sd>0?wdiv(distance,sd):0;\n            uint256 likelihood=wdiv(WAD,WAD+4*wmul(z,z));\n            w=wmul(w*WAD,likelihood);\n            acc[0]+=w;acc[1]+=wmul(w,p);\n            uint256 d=wdiv(absDiff(p,mu),mu);\n            acc[2]+=wmul(w,wmul(d,d));\n        }\n        uint256 m=wdiv(acc[1],acc[0]);\n        uint256 d=wdiv(absDiff(m,mu),mu);\n        uint256 second=wdiv(acc[2],acc[0]);\n        return(m,second>wmul(d,d)?second-wmul(d,d):10000000000);\n    }\n\n    function _compressTailWithSlope(uint256 fee, uint256 slope) internal pure returns (uint256) {\n        if (fee <= TAIL_KNEE) return fee;\n        return TAIL_KNEE + wmul(fee - TAIL_KNEE, slope);\n    }\n\n    function _powWad(uint256 factor, uint256 exp) internal pure returns (uint256 result) {\n        result = WAD;\n        while (exp > 0) {\n            if (exp & 1 == 1) result = wmul(result, factor);\n            factor = wmul(factor, factor);\n            exp >>= 1;\n        }\n    }\n\n    function _decayCentered(uint256 centered, uint256 decayFactor, uint256 elapsed) internal pure returns (uint256) {\n        uint256 mul = _powWad(decayFactor, elapsed);\n        if (centered >= WAD) { return WAD + wmul(centered - WAD, mul); }\n        uint256 below = wmul(WAD - centered, mul);\n        return below < WAD ? WAD - below : 0;\n    }\n\n    // Floor square root: bit-length seed and seven Newton steps (all uint256).\n    function _isqrt(uint256 x) internal pure returns (uint256 r) {\n        if (x == 0) return 0;\n        unchecked {\n            uint256 y = x;\n            r = 1;\n            if (y >> 128 != 0) { y >>= 128; r <<= 64; }\n            if (y >> 64 != 0) { y >>= 64; r <<= 32; }\n            if (y >> 32 != 0) { y >>= 32; r <<= 16; }\n            if (y >> 16 != 0) { y >>= 16; r <<= 8; }\n            if (y >> 8 != 0) { y >>= 8; r <<= 4; }\n            if (y >> 4 != 0) { y >>= 4; r <<= 2; }\n            if (y >> 2 != 0) { r <<= 1; }\n            r = (r + x / r) >> 1;\n            r = (r + x / r) >> 1;\n            r = (r + x / r) >> 1;\n            r = (r + x / r) >> 1;\n            r = (r + x / r) >> 1;\n            r = (r + x / r) >> 1;\n            r = (r + x / r) >> 1;\n            uint256 t = x / r;\n            return r < t ? r : t;\n        }\n    }\n\n    function getName() external pure override returns (string memory) { return \"censored_10\"; }\n}\n","sha256":"008aad665c799dc97d70440adcd1e8478f9b3e7c7b4d4c937b0926f05d31fb91","seeds_kind":"tuning","reference":{"url":"https://api.imdnotdead.fun/artifacts/33f54e81f3372088e9eced52c0174f310ac348af98ef5727b73785c088679194","sha256":"cd9bdb45ab0537ad25c4fd90ca8618898cef6386de3df65f192eaef65fbca245","calibration":"CH already verified in supplied V10 artifact; not rerun per item instruction.","config_and_decomposition":"Reused supplied V10 calibration config generator and tuning decomposition exactly."},"method":{"learner":"Beta(8,8) shrinkage over eight context buckets. Store each quote context in slots[15]; at next callback update that old context with the label timestamp==previous timestamp. Packed successes/total in slots[16..23]; halve both before increment when total>=128. Last quote remains unlabelled. No future or external inputs.","context":"Bits: relative spot/fastHat gap > posterior sd, amountY/reserveY > sizecut, own callback count in current timestamp >1. Context is stored for every quote, including the first.","gate_structures":["smooth: posterior probability","threshold: probability > threshold","context-conditioned: posterior probability*(1-sizeweight*size/(size+sizecut))"],"residuals":"Long-lifetime residual combines symmetric width and signed spot/fair gap shift weighted by gap/(gap+sd). Short-lifetime residual is a symmetric size-conditioned fee concession. Mix with learned probability, clip each bid/ask delta to +/-8 bp and final fees to [0,10%]. Applied after V10 final caps. V10 estimators unchanged.","zero_intervention":"generator strength=0 returns original V10 bytes exactly, verified by equality and pinned source hash. Nonzero intervention trains only on callbacks observed under its own quotes.","search":"Bounded evolutionary random search, NumPy default_rng(404). Initial one policy per gate; one Gaussian mutation per structure from its first candidate, constrained to bounds. Six candidates; rotating 32-seed CRN blocks. Eight scalar settings (including structure and fixed strength) plus eight learned context probabilities: at most sixteen policy parameters; packed counts are training sufficient statistics. No CMA-ES dependency.","bounds":{"long":[0,3],"short":[0,6],"skew":[0,5],"sizecut":[0.0005,0.006],"sizeweight":[0,1],"threshold":[0.1,0.9],"strength":[1,1],"mode":[0,2]},"matching":"Every arm alone against VanillaStrategy via run_batch(arm,Vanilla,configs,8); chunks <=20, counters reset/read around each chunk. No paired candidate/reference market.","config":"default_rng(seed): size uniform(19,21), rate uniform(.6,1), sigma uniform(.000882,.001008), in that order. build_config(seed=seed); 10000 steps; pinned simulator uses retail seed+1.","gas_validity":"Every recorded callback category for both roles checked for oog/revert/other_halt/tx_error/bad_return; any nonzero makes that completed run invalid."},"params":{"mode":2,"strength":1,"long":0.0,"short":0.27983050569762336,"skew":0.0,"sizecut":0.0022688857629627707,"sizeweight":0.5744751630603968,"threshold":0.4037251089262994},"freeze":{"name":"G1M2","sha256":"008aad665c799dc97d70440adcd1e8478f9b3e7c7b4d4c937b0926f05d31fb91","params":{"mode":2,"strength":1,"long":0.0,"short":0.27983050569762336,"skew":0.0,"sizecut":0.0022688857629627707,"sizeweight":0.5744751630603968,"threshold":0.4037251089262994},"utc":"2026-11-08T21:15:59.579487+00:00","selection":"Highest gas-valid mean paired gain on 674000..674255; select a novel policy even if gain is negative.","heldout_seen":false},"comparison_reference":"V10","arm_means":{"G1M2":{"edge":531.2959504373226,"retail":557.0346130656812,"arb":-25.738662628358636},"V10":{"edge":531.2931640105666,"retail":557.008645353246,"arb":-25.715481342679556}},"search_log":[{"name":"G0M0","generation":0,"params":{"mode":0,"strength":1,"long":0,"short":1,"skew":0,"sizecut":0.002,"sizeweight":0.5,"threshold":0.35},"sha256":"44a9f1d3c37dfd979e82c03798e56620f11a0eb6f9a1da3b6885e496509f8eb6","start":670032,"n":32,"paired":{"n":32,"mean_diff":-0.008481363605252312,"se":0.01620504555541703,"worst":[{"seed":670062,"diff":-0.12914075489948118},{"seed":670039,"diff":-0.12347104380376095},{"seed":670051,"diff":-0.10374842006774543},{"seed":670050,"diff":-0.09497363577952456},{"seed":670053,"diff":-0.0873850419648079}]},"retail_edge_delta":{"mean":0.0982914978443592,"se":0.012344206783956946},"arb_edge_delta":{"mean":-0.10677286144960518,"se":0.009586094877078078},"reconciliation_max_abs":7.105427357601002e-14,"valid":true,"gas":{"max_ok":220633,"init_max_ok":220987,"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0},"seconds":44.73621797002852},{"name":"G0M1","generation":0,"params":{"mode":1,"strength":1,"long":0,"short":1,"skew":0,"sizecut":0.002,"sizeweight":0.5,"threshold":0.35},"sha256":"a32c72e6e4cc58ae7a72839409d1394d18058b495d9aa309b7fb69ce21c309db","start":670032,"n":32,"paired":{"n":32,"mean_diff":-0.033871503232241196,"se":0.027735926340314698,"worst":[{"seed":670059,"diff":-0.43667581729107496},{"seed":670037,"diff":-0.2912004307793268},{"seed":670034,"diff":-0.2506332461611578},{"seed":670054,"diff":-0.1973666921043673},{"seed":670051,"diff":-0.17786008398866215}]},"retail_edge_delta":{"mean":0.1036107130611299,"se":0.027057738448291457},"arb_edge_delta":{"mean":-0.13748221629337043,"se":0.014053020800013916},"reconciliation_max_abs":8.526512829121202e-14,"valid":true,"gas":{"max_ok":220668,"init_max_ok":220987,"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0},"seconds":45.134613898117095},{"name":"G0M2","generation":0,"params":{"mode":2,"strength":1,"long":0,"short":1,"skew":0,"sizecut":0.002,"sizeweight":0.5,"threshold":0.35},"sha256":"edbc2101971ef204b009b4eb34ae0093499b82d84175ffb89606ca0dbd894c39","start":670032,"n":32,"paired":{"n":32,"mean_diff":-0.008128451778590673,"se":0.014882920874343121,"worst":[{"seed":670039,"diff":-0.16717645753305987},{"seed":670047,"diff":-0.1226068681196466},{"seed":670051,"diff":-0.11217109466804231},{"seed":670045,"diff":-0.10665379068746006},{"seed":670036,"diff":-0.08018556589496484}]},"retail_edge_delta":{"mean":0.07456769544435815,"se":0.012891149262602677},"arb_edge_delta":{"mean":-0.08269614722294583,"se":0.00942175465939114},"reconciliation_max_abs":7.815970093361102e-14,"valid":true,"gas":{"max_ok":220988,"init_max_ok":220990,"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0},"seconds":41.244922635145485},{"name":"G1M0","generation":1,"params":{"mode":0,"strength":1,"long":0.1981648302347054,"short":0.3839385196807146,"skew":0.3655035325258327,"sizecut":0.002209604428527353,"sizeweight":0.49493129263460295,"threshold":0.457154590824068},"sha256":"f1b9a6e0bf9d7eb1de36c8eed7863f202e87a69f78da001e02c36ccf13400ef4","start":670096,"n":32,"paired":{"n":32,"mean_diff":-0.03509937940930108,"se":0.037512240962825384,"worst":[{"seed":670103,"diff":-0.41926569536099123},{"seed":670106,"diff":-0.3903040361714716},{"seed":670105,"diff":-0.38626976066973384},{"seed":670108,"diff":-0.3721647204248484},{"seed":670126,"diff":-0.3287793345892851}]},"retail_edge_delta":{"mean":-0.33843488817545264,"se":0.03888948277606485},"arb_edge_delta":{"mean":0.30333550876615356,"se":0.011010273185460894},"reconciliation_max_abs":1.0302869668521453e-13,"valid":true,"gas":{"max_ok":218729,"init_max_ok":220984,"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0},"seconds":42.50916054099798},{"name":"G1M1","generation":1,"params":{"mode":1,"strength":1,"long":0.14845511795390814,"short":2.3644662580295916,"skew":0.0,"sizecut":0.001648483900322058,"sizeweight":0.44650372701628355,"threshold":0.5482969566666426},"sha256":"a8edc059870272ecb3817ff1c6bc4322097cc3f90a1632e0904d4c57fbe79249","start":670096,"n":32,"paired":{"n":32,"mean_diff":-0.09983388279279737,"se":0.03941011921029079,"worst":[{"seed":670105,"diff":-0.5567944567204677},{"seed":670106,"diff":-0.5336935059253278},{"seed":670099,"diff":-0.3931752777101565},{"seed":670103,"diff":-0.37083229778875193},{"seed":670108,"diff":-0.3374940828093713}]},"retail_edge_delta":{"mean":-0.2768384910100643,"se":0.039668562900696806},"arb_edge_delta":{"mean":0.17700460821728525,"se":0.009782989785223269},"reconciliation_max_abs":9.947598300641403e-14,"valid":true,"gas":{"max_ok":218797,"init_max_ok":221003,"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0},"seconds":43.341784487012774},{"name":"G1M2","generation":1,"params":{"mode":2,"strength":1,"long":0.0,"short":0.27983050569762336,"skew":0.0,"sizecut":0.0022688857629627707,"sizeweight":0.5744751630603968,"threshold":0.4037251089262994},"sha256":"008aad665c799dc97d70440adcd1e8478f9b3e7c7b4d4c937b0926f05d31fb91","start":670096,"n":32,"paired":{"n":32,"mean_diff":0.008756371299966759,"se":0.009530439712332976,"worst":[{"seed":670114,"diff":-0.08994296431660587},{"seed":670104,"diff":-0.08315549342546547},{"seed":670123,"diff":-0.05332979352147049},{"seed":670103,"diff":-0.050354528909679175},{"seed":670105,"diff":-0.05034684963459313}]},"retail_edge_delta":{"mean":0.029876551179242483,"se":0.0088214819383491},"arb_edge_delta":{"mean":-0.021120179879272283,"se":0.004511447186521248},"reconciliation_max_abs":8.526512829121202e-14,"valid":true,"gas":{"max_ok":219051,"init_max_ok":221006,"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0},"seconds":44.95067810593173}],"rechecks":[{"name":"G1M2","paired":{"n":256,"mean_diff":0.00612328412332519,"se":0.0053510776216468305,"worst":[{"seed":674107,"diff":-0.3927543450965345},{"seed":674161,"diff":-0.3085551950529748},{"seed":674131,"diff":-0.2967640124436457},{"seed":674053,"diff":-0.2063023440307461},{"seed":674040,"diff":-0.1760596462305557}]},"retail_edge_delta":{"mean":0.027051972375136124,"se":0.005431554720159333},"arb_edge_delta":{"mean":-0.020928688251807312,"se":0.0013682906491184858},"reconciliation_max_abs":1.1013412404281553e-13,"valid":true,"gas":{"max_ok":221225,"init_max_ok":221006,"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0}},{"name":"G0M2","paired":{"n":256,"mean_diff":-0.004575264440215943,"se":0.008640564479565568,"worst":[{"seed":674107,"diff":-0.44696631619092386},{"seed":674241,"diff":-0.41802864417957153},{"seed":674131,"diff":-0.3611171923068923},{"seed":674010,"diff":-0.3271118110118323},{"seed":674248,"diff":-0.3172318958602318}]},"retail_edge_delta":{"mean":0.07467334668402525,"se":0.009025981223509982},"arb_edge_delta":{"mean":-0.07924861112424181,"se":0.0029264582622870183},"reconciliation_max_abs":1.1368683772161603e-13,"valid":true,"gas":{"max_ok":221085,"init_max_ok":220990,"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0}}],"seed_ledger":[{"name":"G0M0","sha256":"44a9f1d3c37dfd979e82c03798e56620f11a0eb6f9a1da3b6885e496509f8eb6","start":670032,"end_inclusive":670063,"n":32,"purpose":"rotating CRN search","chunk_sizes":[20,12],"gas":{"Submission":{"max_ok":220633,"init_max_ok":220987,"halts":{"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0},"callback_counts":{"afterInitialize":32,"afterSwap":318245,"getName":32}},"Baseline":{"max_ok":22592,"init_max_ok":21796,"halts":{"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0},"callback_counts":{"afterInitialize":32,"afterSwap":327659,"getName":32}}},"seconds":44.73621797002852,"valid":true},{"name":"G0M1","sha256":"a32c72e6e4cc58ae7a72839409d1394d18058b495d9aa309b7fb69ce21c309db","start":670032,"end_inclusive":670063,"n":32,"purpose":"rotating CRN search","chunk_sizes":[20,12],"gas":{"Submission":{"max_ok":220668,"init_max_ok":220987,"halts":{"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0},"callback_counts":{"afterInitialize":32,"afterSwap":318487,"getName":32}},"Baseline":{"max_ok":22592,"init_max_ok":21796,"halts":{"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0},"callback_counts":{"afterInitialize":32,"afterSwap":327523,"getName":32}}},"seconds":45.134613898117095,"valid":true},{"name":"G0M2","sha256":"edbc2101971ef204b009b4eb34ae0093499b82d84175ffb89606ca0dbd894c39","start":670032,"end_inclusive":670063,"n":32,"purpose":"rotating CRN search","chunk_sizes":[20,12],"gas":{"Submission":{"max_ok":220988,"init_max_ok":220990,"halts":{"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0},"callback_counts":{"afterInitialize":32,"afterSwap":318167,"getName":32}},"Baseline":{"max_ok":22592,"init_max_ok":21796,"halts":{"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0},"callback_counts":{"afterInitialize":32,"afterSwap":327715,"getName":32}}},"seconds":41.244922635145485,"valid":true},{"name":"G0M2","sha256":"edbc2101971ef204b009b4eb34ae0093499b82d84175ffb89606ca0dbd894c39","start":674000,"end_inclusive":674255,"n":256,"purpose":"shortlist recheck","chunk_sizes":[20,20,20,20,20,20,20,20,20,20,20,20,16],"gas":{"Submission":{"max_ok":221085,"init_max_ok":220990,"halts":{"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0},"callback_counts":{"afterInitialize":256,"afterSwap":2596398,"getName":256}},"Baseline":{"max_ok":22592,"init_max_ok":21796,"halts":{"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0},"callback_counts":{"afterInitialize":256,"afterSwap":2705407,"getName":256}}},"seconds":340.3478712323122,"valid":true},{"name":"G1M0","sha256":"f1b9a6e0bf9d7eb1de36c8eed7863f202e87a69f78da001e02c36ccf13400ef4","start":670096,"end_inclusive":670127,"n":32,"purpose":"rotating CRN search","chunk_sizes":[20,12],"gas":{"Submission":{"max_ok":218729,"init_max_ok":220984,"halts":{"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0},"callback_counts":{"afterInitialize":32,"afterSwap":326562,"getName":32}},"Baseline":{"max_ok":22592,"init_max_ok":21796,"halts":{"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0},"callback_counts":{"afterInitialize":32,"afterSwap":346207,"getName":32}}},"seconds":42.50916054099798,"valid":true},{"name":"G1M1","sha256":"a8edc059870272ecb3817ff1c6bc4322097cc3f90a1632e0904d4c57fbe79249","start":670096,"end_inclusive":670127,"n":32,"purpose":"rotating CRN search","chunk_sizes":[20,12],"gas":{"Submission":{"max_ok":218797,"init_max_ok":221003,"halts":{"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0},"callback_counts":{"afterInitialize":32,"afterSwap":327065,"getName":32}},"Baseline":{"max_ok":22592,"init_max_ok":21796,"halts":{"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0},"callback_counts":{"afterInitialize":32,"afterSwap":346285,"getName":32}}},"seconds":43.341784487012774,"valid":true},{"name":"G1M2","sha256":"008aad665c799dc97d70440adcd1e8478f9b3e7c7b4d4c937b0926f05d31fb91","start":670096,"end_inclusive":670127,"n":32,"purpose":"rotating CRN search","chunk_sizes":[20,12],"gas":{"Submission":{"max_ok":219051,"init_max_ok":221006,"halts":{"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0},"callback_counts":{"afterInitialize":32,"afterSwap":328283,"getName":32}},"Baseline":{"max_ok":22592,"init_max_ok":21796,"halts":{"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0},"callback_counts":{"afterInitialize":32,"afterSwap":345543,"getName":32}}},"seconds":44.95067810593173,"valid":true},{"name":"G1M2","sha256":"008aad665c799dc97d70440adcd1e8478f9b3e7c7b4d4c937b0926f05d31fb91","start":674000,"end_inclusive":674255,"n":256,"purpose":"shortlist recheck","chunk_sizes":[20,20,20,20,20,20,20,20,20,20,20,20,16],"gas":{"Submission":{"max_ok":221225,"init_max_ok":221006,"halts":{"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0},"callback_counts":{"afterInitialize":256,"afterSwap":2593416,"getName":256}},"Baseline":{"max_ok":22592,"init_max_ok":21796,"halts":{"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0},"callback_counts":{"afterInitialize":256,"afterSwap":2706872,"getName":256}}},"seconds":346.59257897827774,"valid":true},{"name":"G1M2","sha256":"008aad665c799dc97d70440adcd1e8478f9b3e7c7b4d4c937b0926f05d31fb91","start":675000,"end_inclusive":675511,"n":512,"purpose":"heldout tuning only","chunk_sizes":[20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,12],"gas":{"Submission":{"max_ok":221233,"init_max_ok":221006,"halts":{"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0},"callback_counts":{"afterInitialize":512,"afterSwap":5259849,"getName":512}},"Baseline":{"max_ok":22592,"init_max_ok":21796,"halts":{"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0},"callback_counts":{"afterInitialize":512,"afterSwap":5526530,"getName":512}}},"seconds":468.9500998458825,"valid":true},{"name":"P0","sha256":"a5fd2e7e3edfad81be41d399c088af641b6f94a8ad2da68470bb35ab60cd14bc","start":670000,"end_inclusive":670001,"n":2,"purpose":"smoke","chunk_sizes":[2],"gas":{"Submission":{"max_ok":218650,"init_max_ok":220981,"halts":{"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0},"callback_counts":{"afterInitialize":2,"afterSwap":20598,"getName":2}},"Baseline":{"max_ok":22592,"init_max_ok":21796,"halts":{"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0},"callback_counts":{"afterInitialize":2,"afterSwap":22799,"getName":2}}},"seconds":3.187031720764935,"valid":true},{"name":"V10","sha256":"cd9bdb45ab0537ad25c4fd90ca8618898cef6386de3df65f192eaef65fbca245","start":670000,"end_inclusive":670001,"n":2,"purpose":"smoke","chunk_sizes":[2],"gas":{"Submission":{"max_ok":190635,"init_max_ok":220981,"halts":{"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0},"callback_counts":{"afterInitialize":2,"afterSwap":21208,"getName":2}},"Baseline":{"max_ok":22592,"init_max_ok":21796,"halts":{"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0},"callback_counts":{"afterInitialize":2,"afterSwap":22625,"getName":2}}},"seconds":2.575111181009561,"valid":true},{"name":"V10","sha256":"cd9bdb45ab0537ad25c4fd90ca8618898cef6386de3df65f192eaef65fbca245","start":670032,"end_inclusive":670063,"n":32,"purpose":"rotating CRN search","chunk_sizes":[20,12],"gas":{"Submission":{"max_ok":192715,"init_max_ok":220981,"halts":{"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0},"callback_counts":{"afterInitialize":32,"afterSwap":317653,"getName":32}},"Baseline":{"max_ok":22592,"init_max_ok":21796,"halts":{"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0},"callback_counts":{"afterInitialize":32,"afterSwap":327913,"getName":32}}},"seconds":40.788050134666264,"valid":true},{"name":"V10","sha256":"cd9bdb45ab0537ad25c4fd90ca8618898cef6386de3df65f192eaef65fbca245","start":670096,"end_inclusive":670127,"n":32,"purpose":"rotating CRN search","chunk_sizes":[20,12],"gas":{"Submission":{"max_ok":190647,"init_max_ok":220981,"halts":{"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0},"callback_counts":{"afterInitialize":32,"afterSwap":328159,"getName":32}},"Baseline":{"max_ok":22592,"init_max_ok":21796,"halts":{"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0},"callback_counts":{"afterInitialize":32,"afterSwap":345619,"getName":32}}},"seconds":37.53534700209275,"valid":true},{"name":"V10","sha256":"cd9bdb45ab0537ad25c4fd90ca8618898cef6386de3df65f192eaef65fbca245","start":674000,"end_inclusive":674255,"n":256,"purpose":"shortlist recheck","chunk_sizes":[20,20,20,20,20,20,20,20,20,20,20,20,16],"gas":{"Submission":{"max_ok":192826,"init_max_ok":220981,"halts":{"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0},"callback_counts":{"afterInitialize":256,"afterSwap":2592533,"getName":256}},"Baseline":{"max_ok":22592,"init_max_ok":21796,"halts":{"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0},"callback_counts":{"afterInitialize":256,"afterSwap":2707451,"getName":256}}},"seconds":311.8158061760478,"valid":true},{"name":"V10","sha256":"cd9bdb45ab0537ad25c4fd90ca8618898cef6386de3df65f192eaef65fbca245","start":675000,"end_inclusive":675511,"n":512,"purpose":"heldout tuning only","chunk_sizes":[20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,12],"gas":{"Submission":{"max_ok":192838,"init_max_ok":220981,"halts":{"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0},"callback_counts":{"afterInitialize":512,"afterSwap":5257732,"getName":512}},"Baseline":{"max_ok":22592,"init_max_ok":21796,"halts":{"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0},"callback_counts":{"afterInitialize":512,"afterSwap":5527643,"getName":512}}},"seconds":345.62148296879604,"valid":true}],"gas_by_hash":{"44a9f1d3c37dfd979e82c03798e56620f11a0eb6f9a1da3b6885e496509f8eb6":{"names":["G0M0"],"n_completed":32,"max_ok":220633,"init_max_ok":220987,"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0,"attempt_counter_coverage_complete":false},"a32c72e6e4cc58ae7a72839409d1394d18058b495d9aa309b7fb69ce21c309db":{"names":["G0M1"],"n_completed":32,"max_ok":220668,"init_max_ok":220987,"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0,"attempt_counter_coverage_complete":true},"edbc2101971ef204b009b4eb34ae0093499b82d84175ffb89606ca0dbd894c39":{"names":["G0M2"],"n_completed":288,"max_ok":221085,"init_max_ok":220990,"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0,"attempt_counter_coverage_complete":true},"f1b9a6e0bf9d7eb1de36c8eed7863f202e87a69f78da001e02c36ccf13400ef4":{"names":["G1M0"],"n_completed":32,"max_ok":218729,"init_max_ok":220984,"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0,"attempt_counter_coverage_complete":true},"a8edc059870272ecb3817ff1c6bc4322097cc3f90a1632e0904d4c57fbe79249":{"names":["G1M1"],"n_completed":32,"max_ok":218797,"init_max_ok":221003,"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0,"attempt_counter_coverage_complete":true},"008aad665c799dc97d70440adcd1e8478f9b3e7c7b4d4c937b0926f05d31fb91":{"names":["G1M2"],"n_completed":800,"max_ok":221233,"init_max_ok":221006,"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0,"attempt_counter_coverage_complete":true},"a5fd2e7e3edfad81be41d399c088af641b6f94a8ad2da68470bb35ab60cd14bc":{"names":["P0"],"n_completed":2,"max_ok":218650,"init_max_ok":220981,"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0,"attempt_counter_coverage_complete":true},"cd9bdb45ab0537ad25c4fd90ca8618898cef6386de3df65f192eaef65fbca245":{"names":["V10"],"n_completed":834,"max_ok":192838,"init_max_ok":220981,"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0,"attempt_counter_coverage_complete":true}},"gas":{"candidate":{"max_ok":221233,"oog":0,"init_max_ok":221006,"roles":{"Submission":{"max_ok":221233,"init_max_ok":221006,"halts":{"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0},"callback_counts":{"afterInitialize":512,"afterSwap":5259849,"getName":512}},"Baseline":{"max_ok":22592,"init_max_ok":21796,"halts":{"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0},"callback_counts":{"afterInitialize":512,"afterSwap":5526530,"getName":512}}}},"V10":{"max_ok":192838,"oog":0,"init_max_ok":220981,"roles":{"Submission":{"max_ok":192838,"init_max_ok":220981,"halts":{"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0},"callback_counts":{"afterInitialize":512,"afterSwap":5257732,"getName":512}},"Baseline":{"max_ok":22592,"init_max_ok":21796,"halts":{"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0},"callback_counts":{"afterInitialize":512,"afterSwap":5527643,"getName":512}}}}},"gas_scope":"gas contains held-out counters; gas_by_hash consolidates every completed simulation run. Init is separate. Interrupted G0M0 has unknown counters and is not the selected hash.","name":"G1M2","paired":{"n":512,"mean_diff":0.002786426756116178,"se":0.003451980091781939,"worst":[{"seed":675278,"diff":-0.8798294454360303},{"seed":675390,"diff":-0.25821454003653344},{"seed":675319,"diff":-0.22516838373792325},{"seed":675085,"diff":-0.21110330066665028},{"seed":675174,"diff":-0.1961910530693558}]},"retail_edge_delta":{"mean":0.025967712435194135,"se":0.0034113648431324853},"arb_edge_delta":{"mean":-0.023181285679078775,"se":0.0012605957497631225},"reconciliation_max_abs":1.1368683772161603e-13,"valid":true,"validation":{"passed":true,"setup":"Pinned wheel checksum passed; exact supplied setup executed once; StarterStrategy validated.","cli":{"command":["amm-match","validate","scratch/frozen.sol"],"exit_code":0,"stdout":"Validating strategy...\nCompiling strategy...\nStrategy 'censored_10' validated successfully!\n","stderr":""},"source_sha256":"008aad665c799dc97d70440adcd1e8478f9b3e7c7b4d4c937b0926f05d31fb91","generator_reproduces_frozen_source":true,"zero_intervention_exact_source":true,"compiler":"0.8.24 optimizer=200 viaIR=true evmVersion=paris","static_and_compile_validation":"amm-match validate completed successfully","causal_check":{"passed":true,"solidity_sha256":"008aad665c799dc97d70440adcd1e8478f9b3e7c7b4d4c937b0926f05d31fb91","callbacks":277,"rescale_events":3,"checks":["No training label on initial quote","Only stored previous quote context updated","Same-timestamp label uses next callback timestamp","Other context counters unchanged","Halving at n>=128 matches exact packed integer recurrence","Final quote remains unlabelled","Returned fees remain in [0,10%]","Zero-intervention exact pinned V10 source equality"],"note":"Synthetic callbacks are contract-state tests, not market simulation seeds. No estimated executor gas is used as evidence."},"no_market_validation_seeds_added":true,"source_passages":"Five URLs fetched and exact quoted substrings verified.","seed_completeness":"Packaging asserts every completed arm contains exactly all seeds in its declared inclusive interval, in order; no dropped seeds.","elapsed_minutes_since_setup":27.548531381289163,"output_checks":"Passed: JSON size, code SHA-256, embedded Python syntax, complete inclusive seed blocks, <=20 chunks, sample SE recomputation, edge reconciliation and all selected/reference halt counts."},"causal_check_source":"import json,sys,hashlib\nfrom pathlib import Path\nfrom decimal import Decimal as D\nfrom amm_competition.evm.compiler import SolidityCompiler\nfrom amm_competition.evm.executor import EVMStrategyExecutor\nfrom amm_competition.core.trade import TradeInfo\nfrom generator import generate,BASE\nsource=Path(sys.argv[1]).read_text()\nc=SolidityCompiler().compile(source);assert c.success,c.errors\nex=EVMStrategyExecutor(c.bytecode,c.abi);assert ex.after_initialize(D(100),D(10000)).success\nread=lambda i:ex.evm.storage(ex.deployed_address,i)\nassert read(15)==0 and all(read(i)==0 for i in range(16,24))\nseq=[1,1,3,3,3,7]+[7]*270+[10]\nold=0;rescaled=0\nfor index,ts in enumerate(seq):\n    context=read(15);before=[read(i) for i in range(16,24)]\n    trade=TradeInfo(side='buy' if index%2 else 'sell',amount_x=D('.2'),amount_y=D(20),timestamp=ts,reserve_x=D(100),reserve_y=D(10000))\n    fees=ex.after_swap_fast(trade)\n    assert all(0<=f<=10**17 for f in fees)\n    after=[read(i) for i in range(16,24)]\n    expected=before[:]\n    if context:\n        k=context-1;n=before[k]&((1<<64)-1);y=before[k]>>64\n        if n>=128:n//=2;y//=2;rescaled+=1\n        n+=1;y+=int(ts==old);expected[k]=(y<<64)|n\n    assert after==expected,(index,before,after,expected)\n    assert 1<=read(15)<=8\n    old=ts\nassert rescaled>=1\nzero=generate({'strength':0});assert zero==BASE\nout={'passed':True,'solidity_sha256':hashlib.sha256(source.encode()).hexdigest(),'callbacks':len(seq),'rescale_events':rescaled,'checks':['No training label on initial quote','Only stored previous quote context updated','Same-timestamp label uses next callback timestamp','Other context counters unchanged','Halving at n>=128 matches exact packed integer recurrence','Final quote remains unlabelled','Returned fees remain in [0,10%]','Zero-intervention exact pinned V10 source equality'],'note':'Synthetic callbacks are contract-state tests, not market simulation seeds. No estimated executor gas is used as evidence.'}\nPath('scratch/causal_check.json').write_text(json.dumps(out));print(json.dumps(out))\n","reproduction":["Clone pinned repository in a workspace and execute setup_source as scratch/setup.sh once; prefix later commands with . scratch/env.sh && <command>.","Fetch reference.url JSON, verify reference.sha256 over its code UTF-8 bytes, write its code to scratch/V10.sol.","Materialize harness_source as scratch/experiment.py, generator_source as scratch/generator.py, search_driver_source as scratch/search_driver.py, config_generator_source as scratch/calibrate.py, decomposition_source as scratch/search_original.py. Run python scratch/search_driver.py from checkout root.","causal_check_source materializes as scratch/causal_check.py; run python scratch/causal_check.py scratch/frozen.sol. Frozen generation must reproduce sha256. Do not use held-out results for new tuning."],"harness_source":"import json,time,hashlib,sys\nfrom pathlib import Path\nimport numpy as np\nimport amm_sim_rs as sim\nfrom amm_competition.evm.compiler import SolidityCompiler\nfrom calibrate import configs\nfrom search_original import decomposition\nfrom generator import generate\ncompiler=SolidityCompiler()\nb=compiler.compile(Path('contracts/src/VanillaStrategy.sol').read_text(),'VanillaStrategy');assert b.success,b.errors\n\ndef gas_merge(chunks):\n    out={}\n    for c in chunks:\n        for row in c['raw']:\n            key=row['role']+'/'+row['callback']\n            dst=out.setdefault(key,{k:0 for k in row if k not in ('role','callback')})\n            for k in dst:\n                dst[k]=max(dst[k],row[k]) if k=='max_ok_gas' else dst[k]+row[k]\n    return out\n\ndef run(name,start,n,source=None):\n    path=Path(f'scratch/{name}-{start}-{n}.json')\n    if path.exists():return json.loads(path.read_text())\n    source=source or Path('scratch/'+name+'.sol').read_text()\n    a=compiler.compile(source);assert a.success,a.errors\n    rows=[];chunks=[];t=time.monotonic()\n    for i in range(start,start+n,20):\n        sim.gas_stats_reset()\n        batch=sim.run_batch(list(a.bytecode),list(b.bytecode),configs(i,min(20,start+n-i)),8)\n        raw=sim.gas_stats();chunks.append({'start':i,'n':min(20,start+n-i),'raw':raw})\n        for r in batch.results:\n            arb,retail=decomposition(r)\n            rows.append({'seed':r.seed,'edge':r.edges['submission'],'arb':arb,'retail':retail})\n        del batch\n        print(name,i-start+len(rows[-min(20,start+n-i):]),'of',n,'seconds',round(time.monotonic()-t,1),flush=True)\n    gas=gas_merge(chunks)\n    valid=all(v.get(k,0)==0 for v in gas.values() for k in ['oog','revert','other_halt','tx_error','bad_return'])\n    out=dict(name=name,start=start,n=n,sha256=hashlib.sha256(source.encode()).hexdigest(),rows=rows,gas=gas,valid=valid,seconds=time.monotonic()-t,chunks=chunks)\n    path.write_text(json.dumps(out));return out\n\ndef compare(a,b):\n    assert [r['seed'] for r in a['rows']]==[r['seed'] for r in b['rows']]\n    ds={k:np.array([x[k]-y[k] for x,y in zip(a['rows'],b['rows'])]) for k in ['edge','retail','arb']}\n    n=len(ds['edge'])\n    return {'paired':{'n':n,'mean_diff':float(ds['edge'].mean()),'se':float(ds['edge'].std(ddof=1)/np.sqrt(n)),'worst':[{'seed':a['rows'][i]['seed'],'diff':float(ds['edge'][i])} for i in np.argsort(ds['edge'])[:5]]},'retail_edge_delta':{'mean':float(ds['retail'].mean()),'se':float(ds['retail'].std(ddof=1)/np.sqrt(n))},'arb_edge_delta':{'mean':float(ds['arb'].mean()),'se':float(ds['arb'].std(ddof=1)/np.sqrt(n))},'reconciliation_max_abs':float(np.max(np.abs(ds['edge']-ds['retail']-ds['arb']))),'valid':a['valid'] and b['valid']}\n\nif __name__=='__main__':\n    stage=sys.argv[1]\n    if stage=='smoke':\n        p=dict(mode=0,strength=1,long=1,short=1,skew=2,sizecut=.002,sizeweight=.5,threshold=.5)\n        Path('scratch/P0.sol').write_text(generate(p))\n        a=run('P0',670000,2);bb=run('V10',670000,2);print(json.dumps(compare(a,bb)),flush=True)\n","generator_source":"from pathlib import Path\nBASE=Path('scratch/V10.sol').read_text()\n\ndef generate(p):\n    if p['strength']==0:return BASE\n    call='''        (bidFee, askFee) = _nextPolicy(bidFee, askFee, spot, fastHat, uncertainty, tradeRatio, stepTradeCount, trade.timestamp, lastTs);\n'''\n    fn=r'''\n    // A quote is labelled only by the next own callback, never by its own print.\n    // 8 buckets: gap/uncertainty, observed size, callback count within timestamp.\n    function _nextPolicy(uint256 bid,uint256 ask,uint256 spot,uint256 fair,uint256 variance,uint256 size,uint256 count,uint256 ts,uint256 oldTs) internal returns(uint256,uint256) {\n        uint256 previous=slots[15];\n        if(previous>0) {\n            uint256 at=16+previous-1;\n            uint256 packed=slots[at];\n            uint256 n=uint64(packed); uint256 y=packed>>64;\n            if(n>=128) {n/=2;y/=2;}\n            n++;if(ts==oldTs)y++;\n            slots[at]=(y<<64)|n;\n        }\n        uint256 sd=_isqrt(variance*WAD);\n        uint256 gap=wdiv(absDiff(spot,fair),fair);\n        uint256 context=(gap>sd?1:0)+(size>SIZECUT?2:0)+(count>1?4:0);\n        slots[15]=context+1;\n        uint256 history=slots[16+context];\n        uint256 p=wdiv((history>>64)+8,uint64(history)+16);\n        // Context-conditioned variant interpolates online probability with size certainty.\n        if(MODE==2) p=wmul(p, WAD-wmul(SIZEWEIGHT,wdiv(size,size+SIZECUT)));\n        uint256 gate=MODE==1?(p>THRESHOLD?WAD:0):p;\n        uint256 certainty=wdiv(gap,gap+sd+1);\n        uint256 large=wdiv(size,size+SIZECUT);\n        // Long quote: protect against drift and posterior uncertainty.\n        // Short quote: attract routing flow with a size-conditioned spread concession.\n        int256 common=(int256(wmul(WAD-gate,LONGWIDTH))-int256(wmul(gate,wmul(SHORTWIDTH,large))));\n        uint256 shift=wmul(wmul(WAD-gate,certainty),SKEW);\n        int256 dBid=common+(spot>=fair?int256(shift):-int256(shift));\n        int256 dAsk=common+(spot>=fair?-int256(shift):int256(shift));\n        return (_residual(bid,dBid),_residual(ask,dAsk));\n    }\n    function _residual(uint256 fee,int256 delta) internal pure returns(uint256) {\n        int256 cap=int256(8*BPS);\n        if(delta>cap)delta=cap;if(delta< -cap)delta= -cap;\n        int256 next=int256(fee)+delta;\n        return next<=0?0:clampFee(uint256(next));\n    }\n'''\n    vals={'MODE':p['mode'],'SIZECUT':int(p['sizecut']*1e18),'SIZEWEIGHT':int(p['sizeweight']*1e18),'THRESHOLD':int(p['threshold']*1e18),'LONGWIDTH':int(p['long']*p['strength']*1e14),'SHORTWIDTH':int(p['short']*p['strength']*1e14),'SKEW':int(p['skew']*p['strength']*1e14)}\n    import re\n    for key,value in vals.items():fn=re.sub(r'\\b'+key+r'\\b',str(value),fn)\n    s=BASE.replace('        slots[0] = bidFee;',call+'        slots[0] = bidFee;')\n    return s.replace('    struct PosteriorInput {',fn+'\\n    struct PosteriorInput {')\n\nif __name__=='__main__':\n    import json,sys\n    p=json.loads(sys.argv[1]);Path(sys.argv[2]).write_text(generate(p))\n","search_driver_source":"import time,json,hashlib,datetime\nfrom pathlib import Path\nimport numpy as np\nfrom experiment import run,compare\nfrom generator import generate,BASE\n\nstart=time.monotonic();rng=np.random.default_rng(404)\nlog=[];specs={};best={};\nassert generate(dict(strength=0))==BASE\nPath('scratch/zero.sol').write_text(generate(dict(strength=0)))\n# Three structures, each evaluated over identical rotating CRN blocks.\n# Bounded evolutionary random search: one parent per structure, Gaussian mutations.\nfor generation in range(2):\n    seed=670032+generation*64\n    baseline=run('V10',seed,32)\n    for mode in range(3):\n        if generation<1:\n            templates=[(0,1,0),(.5,2,1),(0,0,2)]\n            l,s,k=templates[generation]\n            p=dict(mode=mode,strength=1,long=l,short=s,skew=k,sizecut=.002,sizeweight=.5,threshold=[.35,.5,.65][generation])\n        else:\n            parent=best[mode]['params']\n            p=dict(parent)\n            for key,scale,lo,hi in [('long',.5,0,3),('short',1.,0,6),('skew',.8,0,5),('threshold',.12,.1,.9),('sizecut',.0007,.0005,.006),('sizeweight',.2,0,1)]:\n                p[key]=float(np.clip(p[key]+rng.normal(0,scale),lo,hi))\n        name=f'G{generation}M{mode}';source=generate(p);Path(f'scratch/{name}.sol').write_text(source)\n        a=run(name,seed,32,source);metric=compare(a,baseline)\n        row={'name':name,'generation':generation,'params':p,'sha256':a['sha256'],'start':seed,'n':32,**metric,'gas':a['gas'],'seconds':a['seconds']}\n        log.append(row);specs[name]=p\n        if metric['valid'] and (mode not in best or metric['paired']['mean_diff']>best[mode]['paired']['mean_diff']):best[mode]=row\n        Path('scratch/search_log.json').write_text(json.dumps(log));Path('scratch/specs.json').write_text(json.dumps(specs))\n        print('SCORE',name,json.dumps(metric),flush=True)\n    if time.monotonic()-start>900:break\n# Recheck strongest two distinct hashes; all models are novel, even if both lose.\ntop=sorted([r for r in log if r['valid']],key=lambda x:x['paired']['mean_diff'],reverse=True)[:2]\nPath('scratch/shortlist.json').write_text(json.dumps(top))\nprint('TUNING_DONE',time.monotonic()-start,'shortlist',[r['name'] for r in top],flush=True)\nbase=run('V10',674000,256)\nchecks=[]\nfor row in top:\n    a=run(row['name'],674000,256);checks.append({'name':row['name'],**compare(a,base),'gas':a['gas']})\nPath('scratch/rechecks.json').write_text(json.dumps(checks))\nvalid=[r for r in checks if r['valid']];assert valid\nwinner=max(valid,key=lambda r:r['paired']['mean_diff']);name=winner['name']\nsource=Path(f'scratch/{name}.sol').read_text()\nfreeze={'name':name,'sha256':hashlib.sha256(source.encode()).hexdigest(),'params':specs[name],'utc':datetime.datetime.now(datetime.timezone.utc).isoformat(),'selection':'Highest gas-valid mean paired gain on 674000..674255; select a novel policy even if gain is negative.','heldout_seen':False}\nPath('scratch/freeze.json').write_text(json.dumps(freeze));Path('scratch/frozen.sol').write_text(source)\nprint('FROZEN',json.dumps(freeze),flush=True)\na=run(name,675000,512);base=run('V10',675000,512)\nPath('scratch/heldout.json').write_text(json.dumps({'name':name,**compare(a,base),'candidate_gas':a['gas'],'v10_gas':base['gas']}))\nprint('COMPLETE',time.monotonic()-start,flush=True)\n","config_generator_source":"import json,time\nfrom pathlib import Path\nimport numpy as np\nimport amm_sim_rs as sim\nfrom amm_competition.evm.compiler import SolidityCompiler\nfrom amm_competition.competition.config import build_config\n\ndef configs(start,n):\n    out=[]\n    for s in range(start,start+n):\n        r=np.random.default_rng(s)\n        size=r.uniform(19,21);rate=r.uniform(.6,1);sigma=r.uniform(.000882,.001008)\n        out.append(build_config(seed=s,gbm_sigma=sigma,retail_arrival_rate=rate,retail_mean_size=size))\n    return out\n","decomposition_source":"import numpy as np\ndef decomposition(r, initial_fee=0.0004):\n    steps=r.steps\n    fair=np.array([s.fair_price for s in steps])\n    spots=np.array([r.initial_fair_price]+[s.spot_prices['submission'] for s in steps[:-1]])\n    bids=np.array([initial_fee]+[s.fees['submission'][0] for s in steps[:-1]])\n    asks=np.array([initial_fee]+[s.fees['submission'][1] for s in steps[:-1]])\n    x0,y0=r.initial_reserves['submission'];k=x0*y0\n    x=np.sqrt(k/spots);y=np.sqrt(k*spots)\n    ga=1-asks;gb=1-bids\n    out=np.minimum(np.maximum(x-np.sqrt(k/(ga*fair)),0),.99*x)\n    paid=(k/(x-out)-y)/ga\n    buyprofit=np.maximum(out*fair-paid,0)\n    gross=np.maximum((np.sqrt(k*gb/fair)-x)/gb,0)\n    received=y-k/(x+gb*gross)\n    sellprofit=np.maximum(received-gross*fair,0)\n    arb=-float(np.sum(np.where(spots<fair,buyprofit,sellprofit)))\n    return arb,r.edges['submission']-arb\n","setup_source":"set -eu;R=$PWD/scratch;mkdir -p $R/tmp $R/bin $R/solcx\necho \"export TMPDIR=$R/tmp XDG_CACHE_HOME=$R/xc UV_CACHE_DIR=$R/uvc UV_PYTHON_INSTALL_DIR=$R/uvpy SOLCX_BINARY_PATH=$R/solcx VIRTUAL_ENV=$PWD/.venv PATH=$PWD/.venv/bin:$R/bin:\\$PATH\" >$R/env.sh;. $R/env.sh\ncommand -v uv >/dev/null||{ curl -LsSf https://github.com/astral-sh/uv/releases/latest/download/uv-x86_64-unknown-linux-gnu.tar.gz|tar --no-same-owner -xz -C $R/tmp;cp $R/tmp/uv-*/uv $R/bin/;}\nW=amm_sim_rs-0.1.0.post1-cp310-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl;curl -LsSf https://github.com/gtmcknight/amm-sim/releases/download/sim-6b6921f8/$W -o $R/$W\necho \"aedb68280aca34c110968f00148387c95885207913fb2cf19a1ab4c5cfd6887a  $R/$W\"|sha256sum -c -\nuv venv --python 3.12 .venv;uv pip install $R/$W numpy py-solc-x==2.1.0 pyrevm==0.3.7;uv pip install --no-deps -e .\npython -c \"import solcx;solcx.install_solc('0.8.24')\"\namm-match validate contracts/src/StarterStrategy.sol\n","limitations":["Tuning only: seeds 675000..675511 are a once-only held-out tuning block, not a >=5000000 confirmation block. No board claim or submission.","The fitted long-lifetime residual may collapse to zero; the selected parameters are reported without imposing nonzero interventions. This is an online lifetime-gated residual family, not a demonstrated broad mechanism gain.","Six-candidate search is small and subject to selection bias; 256-seed recheck chose one novel policy even if all policies lost.","The first search process was interrupted before any candidate metrics or counters were returned. V10 32-seed baseline completed and was cached. Search was restarted with a six-candidate cap; it reused that baseline. No partial candidate result was used, and all final comparisons use complete seed blocks. Counters for the interrupted in-flight candidate are unavailable.","Retail/arb split is the supplied analytical reconstruction, not direct simulator trade-type instrumentation. Their sum reconciles to total numerically; SEs do not add because of covariance.","Reproduction needs the pinned repository, simulator wheel, Python dependencies and solc 0.8.24; binaries are not embedded.","Gas maxima are observed over declared completed runs only, not a proof over all possible callback inputs. Online targets come from own-pool events, so interventions can change the callback process."],"interpretation":"Held-out mean gain 0.0027864 is smaller than its sample SE 0.0034520. This trial does not establish improvement over V10 or progress toward the goal-sized gain; no board claim."}