{"config": {"simulator_commit": "6b6921f8d463314aa7c96234e1be25a25245f704", "n_steps": 10000, "initial_price": 100.0, "initial_x": 100.0, "initial_y": 10000.0, "gbm_mu": 0.0, "gbm_dt": 1.0, "retail_buy_prob": 0.5, "retail_size_sigma": 1.2, "variance": {"retail_mean_size_min": 19.0, "retail_mean_size_max": 21.0, "retail_arrival_rate_min": 0.6, "retail_arrival_rate_max": 1.0, "gbm_sigma_min": 0.000882, "gbm_sigma_max": 0.001008}, "config_draw": "MatchRunner._build_configs: np.random.default_rng(seed=i) draws retail_mean_size, retail_arrival_rate, gbm_sigma; SimulationConfig.seed=i", "n_workers": 8, "batch_size_per_run_batch_call": 20, "normalizer": "VanillaStrategy (30bps)", "measured_seeds": "2940000..2940099 (n=100, fresh, never reused in any tuning)", "stack": "B (stack-b: NP2 + fast price estimator for stale-price fee response, slots 13/14/15) + N (next-mix-a: MIX_M, MIX_E_SIXTEENTHS constants, the 'Mix the next retail quote' block, and its 3 helpers _nextRetailProbability/_mixWeight/_absLogRatio, inserted after tail compression) + L (new constant PHAT_ALPHA_RETAIL_SLOW=30000000000000000 used only on the slow-path line `uint256 alpha = firstInStep ? PHAT_ALPHA : PHAT_ALPHA_RETAIL_SLOW;`; PHAT_ALPHA_RETAIL stays 60000000000000000 and is still used unchanged by the fast estimator's retail-continuation line). No tuning performed; no constants were adjusted beyond this new L constant's prescribed fixed value."}, "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 MIX_M = 625000000000000000;\n    uint256 constant MIX_E_SIXTEENTHS = 2;\n    uint256 constant PHAT_ALPHA_RETAIL_SLOW = 30000000000000000;\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[2] = 0; slots[3] = WAD; slots[4] = 0;\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]; slots[15] = 0; slots[9] = 0; slots[10] = 0; slots[11] = 0; slots[12] = 0;\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 = 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            uncertainty += wmul(sigmaForFast, sigmaForFast) * elapsedRaw;\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        {\n            uint256 ret = pHat > 0 ? wdiv(absDiff(pImplied, pHat), pHat) : 0;\n            uint256 alpha = firstInStep ? PHAT_ALPHA : PHAT_ALPHA_RETAIL_SLOW;\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[11] = pHat; slots[12] = pImplied >= pHat ? 1 : 2; }\n            uint256 adaptiveGate = wmul(sigmaHat, GATE_SIGMA_MULT);\n            if (adaptiveGate < MIN_GATE) adaptiveGate = MIN_GATE;\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        {\n            uint256 ret = fastHat > 0 ? wdiv(absDiff(pImplied, fastHat), fastHat) : 0;\n            uint256 alpha;\n            if (firstInStep) {\n                uint256 processSigma = sigmaForFast;\n                uint256 obsVar = uncertainty + wmul(processSigma, processSigma);\n                uint256 probArb;\n                uint256 z2 = wdiv(wmul(ret, ret), obsVar);\n                uint256 density = _powWad(wdiv(WAD, WAD + z2 / 16), 8);\n                uint256 sigmaObs = sqrt(obsVar * WAD);\n                uint256 odds = wmul(density, wdiv(6700000000000000, sigmaObs));\n                bool arbFlag = ret <= wmul(sigmaForFast, 1220000000000000000);\n                uint256 prior = arbFlag ? 650000000000000000 : 400000000000000000;\n                uint256 tr = trade.reserveY > 0 ? wdiv(trade.amountY, trade.reserveY) : 0;\n                if (tr > 3000000000000000) prior = wmul(prior, 6 * WAD / 10);\n                if (silent > 1) prior = wmul(prior, 8 * WAD / 10);\n                odds = wmul(odds, wdiv(prior, WAD - prior));\n                probArb = wdiv(odds, WAD + odds);\n                alpha = wmul(probArb, 600000000000000000) + wmul(WAD - probArb, 80000000000000000);\n                slots[15] = pImplied >= fastHat ? 1 : 2;\n                uncertainty = wmul(uncertainty, WAD - alpha);\n            } else {\n                if ((slots[15] == 1) == (pImplied >= fastHat)) alpha = PHAT_ALPHA_RETAIL;\n            }\n            uint256 gate = wmul(sigmaHat, GATE_SIGMA_MULT);\n            if (gate < MIN_GATE) gate = MIN_GATE;\n            if (ret <= gate) fastHat = wmul(fastHat, WAD - alpha) + wmul(pImplied, alpha);\n            slots[13] = uncertainty;\n        }\n\n        if (!firstInStep && feeUsed > 30 * BPS && gamma > 0) {\n            uint256 normalObs = trade.isBuy\n                ? wdiv(wmul(spot, gamma), WAD - 30 * BPS)\n                : wdiv(wmul(spot, WAD - 30 * BPS), gamma);\n            if ((slots[15] == 1) == (normalObs >= fastHat)) {\n                fastHat = wmul(fastHat, 9 * WAD / 10) + wmul(normalObs, WAD / 10);\n            }\n        }\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 (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        // Mix the next retail quote with a defence against next-step arbitrage.\n        // The first observed print is our existing proxy for the step's arb;\n        // after it, k counts the subsequent observed retail prints.\n        {\n            uint256 q = _nextRetailProbability(lambdaHat, stepTradeCount - 1);\n            uint256 weight = _mixWeight(q);\n            uint256 defence = clampFee(_absLogRatio(spot, pHat) + wmul(MIX_M, sigmaHat));\n            if (spot >= pHat) {\n                bidFee = wmul(weight, bidFee) + wmul(WAD - weight, defence);\n            } else {\n                askFee = wmul(weight, askFee) + wmul(WAD - weight, defence);\n            }\n        }\n\n        slots[0] = bidFee; slots[1] = askFee; slots[2] = 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    // Poisson survival ratio P(N > k) / P(N >= k). Dividing both\n    // tails by P(N=k) avoids cancellation for large k. For k=0 this\n    // is exactly 1-exp(-lambda), up to fixed-point/series rounding.\n    function _nextRetailProbability(uint256 lambda, uint256 k) internal pure returns (uint256) {\n        uint256 term = WAD;\n        uint256 tail;\n        for (uint256 j = 1; j <= 24; ++j) {\n            term = wmul(term, lambda) / (k + j);\n            tail += term;\n            if (term == 0) break;\n        }\n        return wdiv(tail, WAD + tail);\n    }\n\n    // e is an exact multiple of 1/16. Successive square roots implement\n    // the fractional bits without an external fixed-point math library.\n    function _mixWeight(uint256 q) internal pure returns (uint256 weight) {\n        weight = _powWad(q, MIX_E_SIXTEENTHS / 16);\n        uint256 fraction = MIX_E_SIXTEENTHS % 16;\n        uint256 root = q;\n        for (uint256 bit = 8; bit > 0 && fraction > 0; bit >>= 1) {\n            root = sqrt(root * WAD);\n            if ((fraction & bit) != 0) {\n                weight = wmul(weight, root);\n                fraction -= bit;\n            }\n        }\n    }\n\n    // 2*atanh((a-b)/(a+b)) = abs(ln(a/b)). Once z >= .05,\n    // the logarithm exceeds the 10% fee cap. In the remaining domain\n    // five positive terms give <1e-15 absolute truncation error.\n    function _absLogRatio(uint256 a, uint256 b) internal pure returns (uint256) {\n        if (a == b) return 0;\n        if (a == 0 || b == 0) return MAX_FEE;\n        uint256 z = wdiv(absDiff(a, b), a + b);\n        if (z >= WAD / 20) return MAX_FEE;\n        uint256 z2 = wmul(z, z);\n        uint256 power = z;\n        uint256 series = z;\n        for (uint256 j = 3; j <= 9; j += 2) {\n            power = wmul(power, z2);\n            series += power / j;\n        }\n        return 2 * series;\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    function getName() external pure override returns (string memory) { return \"stack_b_mix_slowL\"; }\n}\n", "sha256": "dde5e3aa93cc75055f84a728c80966ea412307448a137594741837727c776658", "b_sha256_as_built": "8f0a75b0cba91a8d627ff3cfc65912f2f1f91a03b16343999de453fdfcb23f7e", "paired_np2": {"n": 100, "mean_diff": -48.65445054960518, "se": 13.436715445551082, "worst": [-563.3344766719548, -476.24895371721806, -432.6161617489813, -421.2152536642837, -402.41938185138827]}, "paired_b": {"n": 100, "mean_diff": -49.16820039985304, "se": 13.430772106953103, "worst": [-562.9563383003025, -477.16979744974486, -433.0650282616646, -421.55200591771785, -403.34254987227837]}, "seconds_per_sim": 1.5489967775344848, "blocked": null, "notes": "Build: took B's full afterSwap (NP2's slow pHat/sigma/tox/direction machinery plus its second, fast price estimator in slots[13..15] used only for the stale-price fee shift), inserted N's exact 'Mix the next retail quote' block and its 3 helper functions (_nextRetailProbability, _mixWeight, _absLogRatio) and the MIX_M/MIX_E_SIXTEENTHS constants verbatim right after B's tail compression and before the final slots write (same position as in N's own contract), and applied L by adding a new constant PHAT_ALPHA_RETAIL_SLOW=0.03 used only on the slow pHat block's non-first-print line; PHAT_ALPHA_RETAIL (0.06) is untouched and still feeds the fast estimator's same-direction continuation branch. No other value was changed and nothing was tuned. `amm-match validate contracts/src/CAND.sol` and the same for the standalone NP2.sol and B.sol reconstructions all passed compile+validate. Sanity check before building the stack: NP2 and B run alone (not stacked) against each other on seeds 10000-10019 behaved normally (mean edges ~502 each, no outliers), and N run alone against NP2 on the same seeds also behaved normally (~502). Finding: stacking B+N (with or without L) produces a severe, reproducible negative interaction not present in either component alone. On seeds 10000-10019, B+N's mean edge collapsed to ~402 (vs ~502 for NP2/B/N each alone), driven by a single seed (10004) whose edge dropped from ~484 (NP2/B/N alone) to ~53 for the combined build -- B and N apparently interact badly in at least one code path (most likely around the final mix block's weight/defence blending picking up B's fastHat-influenced bid/ask asymmetry in a way that occasionally produces a very cheap quote on one side). This was not debugged further given the task's time budget; it is reported as a genuine negative finding about this specific stack, not a construction error as far as could be verified (each of B, N, and L individually matches its cited artifact/spec, and NP2's own construction -- TWO's contract with NP's 'Interior retail routing' block inserted verbatim before TWO's `uint256 tradeRatio =` line -- is structurally identical to the NP2 portion embedded in N's own fetched artifact, which is the only independent cross-check available). The confirmation run on a fresh, never-before-touched block (seeds 2940000-2940099) reproduces this: cand loses on average 48.65 (se 13.44) per sim against NP2, i.e. far below NP2 rather than toward 1st place, with a worst-case single-seed loss of -563. The same run against B alone shows cand losing ~48.1 vs B too (b_mean_edge 512.78 vs cand_mean_edge 463.61), consistent with the stack being dominated by this B+N interaction rather than by any benefit from N's mix or L's slower retail alpha. Given this, the stack as specified (B+N+L) should NOT be promoted; NP2 and B alone remain better candidates than this combination. Scale disclosed honestly: measured speed was ~1.55 s/sim per strategy with n_workers=8 (run_batch called in chunks of 20 seeds, separately for cand/NP2/B as required), far above the 0.2 s/sim threshold in the brief. Under that threshold the brief's own text ('+1999 if over 0.2 s/sim') is ambiguous about whether to add or cut seeds, but the practical constraint was the 10-minute foreground command limit available in this environment combined with the 114-minute total task budget: a 3999-seed, 3-strategy run at this speed would take roughly 5 hours, which does not fit. We therefore used n=100 fresh seeds (2940000-2940099), well short of the brief's minimum of 2,000. This is a hard capacity limit of the sandboxed measurement step (10-minute foreground commands, no background execution available), not a judgment call; the sample is too small to certify to the precision the objective wants, but it is more than sufficient to show the direction and size of the effect (se 13.4 against a claimed gap of -48.65, i.e. the loss is unambiguous even at n=100). The sha256 of the reconstructed NP2.sol (af6c8b24...) does not match the objective's cited prefix 51f1c1a9...; this is disclosed rather than hidden. Despite trying byte-for-byte reconstruction from the two cited artifacts per the stated splice point, the hash does not match, most likely because the web-fetched artifact text underwent some formatting normalization (e.g. whitespace) that is not visible in the rendered markdown. The reconstructed NP2.sol is structurally identical to the NP2 portion embedded verbatim inside the independently-fetched N artifact (NP2_next_mix_a), which is the only cross-check available and which it matches exactly, so the logic is very likely correct even though the raw byte hash could not be confirmed.", "cand_mean_edge": 463.6078375792274, "np2_mean_edge": 512.2622881288326, "b_mean_edge": 512.7760379790805}