**No new contract meets the return gate. Retain QLX5; the #1 objective remains unachieved.** The most extensively tested replacement, **QLX5+AGE**, returned **−0.003911044007076425 over QLX5, SE 0.004711946262616144, n=1,024 completed fresh follow-up seeds**. Its observed candidate afterSwap peak was **208,377** in those follow-ups, **0 OOG**, **22,558 deployed bytes**, and **47,757 source characters**. Including the separate 256-seed pilot gives **−0.004574571866247901, SE 0.004312389928790002, n=1,280**, with candidate peak **209,329**, still **0 OOG**. These are descriptive pools of all completed blocks, including futility stops; the planned 2,048-seed follow-up was not completed. They do not establish the required +0.04. [AGE evidence merge][root-1-01]

The largest positive *individual engine screen* was pull α=0.2: **+0.016254, SE 0.012277, n=128**, peak **210,537**. It has no qualifying confirmation. The best final-round replica headline was clip 0.99675 plus pull 0.25: **+0.014173101144971834, SE 0.007000165218902842, n=512**, stopped during choosing. Neither is a winning contract. [Coarse engine screens][b09-merge-01], [final clip/pull result][b24-clip-pull]

**Credit:** Taylor (gtmcknight), [amm-sim at commit 4812a6382311624e1506aca131ca35c378f930d9, research/solved][Taylor], supplied the solved policy, Gaussian filter, exact-arithmetic arb/retail tell, U1 tables, and original replica. QLX5's drift-tolerant split test, the AGE stack, and the experiments here build on that work.

| Contract / status | Engine gain over QLX5 | n and SE | Observed afterSwap peak / OOG | Deployed bytes / source characters |
|---|---:|---|---|---|
| Unchanged QLX5, retained baseline | 0 by identity | No new comparative efficacy sample; SE not applicable. Historical engine/audit block n=512. | 208,366 / 0 on that historical block; 208,532 / 0 in the AGE pilot comparator | 22,440 / 47,230 |
| QLX5+AGE, rejected replacement | −0.003911044007076425 | 1,024 completed follow-up pairs; SE 0.004711946262616144 | 208,377 / 0 on those follow-ups | 22,558 / 47,757 |

Baseline figures come from the [QLX5 artifact][base], its [unrounded audit][b13-r3], and the [AGE pilot][b04-qa]. AGE's source SHA-256 is `c0fb05961b60655744bfc5597a098e2f91bc5b90db9e8688e488d077864fb5da`; its complete rejected source remains in the [build artifact][b01-qa]. No replacement is recommended or submitted.

**Complete retained `Strategy.sol`, for archival reproducibility.** This is the unchanged QLX5 baseline, not a newly qualifying return. Its SHA-256 is **`e183e5bc3fb794b7067703b10a7da9920267aa5f4caa968e16ca101b02338f40`**, exactly **47,230 UTF-8 bytes / characters**, including its final newline. It was decoded from `code_zb64.QLX5` in the [pinned source artifact][base]. The block preserves every byte, including the production table and historical comments. Its two imports are the challenge's `AMMStrategyBase.sol` and `IAMMStrategy.sol`; this report is not a new standalone build repository. Historical compilation used solc 0.8.24, optimizer 200, viaIR, Paris. [Engine provenance and compile record][root-1-01]

<details>
<summary>Expand the complete unchanged QLX5 Strategy.sol</summary>

```solidity
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;
import {AMMStrategyBase} from "./AMMStrategyBase.sol";
import {TradeInfo} from "./IAMMStrategy.sol";
// Solved AMM policy by Taylor (gtmcknight), amm-sim 4812a638 research/solved: Gaussian filter + qm tables (qm_k1e-5.json),
// fee rule of real.py's qm variant (sd level, phase, synced flag). All credit for the policy, filter and tables: Taylor.
// Original tables compressed by qm-spline (cubic B-splines, QMS1 blob sha256 3ac7cb88...); filter, 3-slot state, math and fee conversion
// from trim-2 (port-3's filter); synced flag stored in bit 255 of slot 2.
// lookup-headroom: C0 (sha256 c68887cf...) with coefficient words loaded once per callback into memory and the
// second knot-span search of each axis walking forward from the first; same arithmetic, same fees.
// give-u1: lookup-u1 (Strategy.sol sha256 69c361ef...) plus one rule, the constant rival pull of GivePolicy (give.py sha256 8d871a6b...).
// lean-sol: give-u1 (Strategy.sol sha256 99d031f4...) with the exact-arithmetic isArb replaced by lb-4's LEAN TELL (bounded
// sell_one_division / buy_grid, budget 4): a first own trade is read as arbitrage iff the lean label is positive; negative, over
// budget and unsupported are misses; chance, filter, tables, pull, fee guard and storage slots unchanged (LEANBASE variant A).
// qlite-a: LEAN (sha256 a6dfc3ba...) plus the frozen qlgate rule cap24+GATE (qlgate.py sha256 0823f2d2..., qlite_int.capped_int cap 24):
// on a callback not read as arbitrage and at most 6 steps after the previous own callback, the capped router-quotient split test;
// a hit sets the rival spot to the marginal-price candidate, synced, and skips the 0.35 pull; a miss leaves LEAN unchanged.
// Credit: Taylor (gtmcknight), github.com/gtmcknight/amm-sim@4812a6382311624e1506aca131ca35c378f930d9 research/solved.
// Taylor source: https://github.com/gtmcknight/amm-sim/tree/4812a6382311624e1506aca131ca35c378f930d9/research/solved
contract Strategy is AMMStrategyBase {
    int256 constant U=1e18;
    int256 constant LN2=693147180559945309;
    uint256 constant M64=0xffffffffffffffff;
    // slots[0] = m (int128) | v (int128)<<128 ; slots[1] = sp (int128) | r (int128)<<128 ; slots[2] = fb | fa<<64 | t<<128 | cnt<<192
    function getName() external pure override returns(string memory) { unchecked {return "TellMinLookup";} }
    function mul(int256 a,int256 b) internal pure returns(int256){ unchecked {return a*b/U;} }
    function divi(int256 a,int256 b) internal pure returns(int256){ unchecked {return a*U/b;} }
    function ab(int256 x) internal pure returns(int256){ unchecked {return x<0?-x:x;} }
    function clip(int256 x,int256 a,int256 b) internal pure returns(int256){ unchecked {return x<a?a:(x>b?b:x);} }
    function ln(int256 x) internal pure returns(int256 z){ unchecked {
        require(x>0); int256 k;
        while(x< U){x*=2;k--;}
        while(x>=2*U){x/=2;k++;}
        int256 y=divi(x-U,x+U); int256 y2=mul(y,y); int256 q=y; z=y;
        for(int256 n=3;n<=29;n+=2){q=mul(q,y2);z+=q/n;}
        return 2*z+k*LN2;
    } }
    function exp(int256 x) internal pure returns(int256){ unchecked {
        if(x< -42*U)return 0; require(x<60*U);
        int256 k=(x>=0?x+LN2/2:x-LN2/2)/LN2; int256 r=x-k*LN2;
        int256 r2=mul(r,r);
        int256 even=665280*U+mul(r2,75600*U+mul(r2,840*U+r2));
        int256 odd=mul(r,332640*U+mul(r2,10080*U+mul(r2,42*U)));
        int256 s=divi(even+odd,even-odd);
        return k>=0?s*int256(uint256(1)<<uint256(k)):s/int256(uint256(1)<<uint256(-k));
    } }
    function root(int256 x) internal pure returns(int256){ unchecked {
        if(x<=0)return 0; uint256 n=uint256(x)*1e18;uint256 z=n;uint256 r=1;
        if(z>>128>0){z>>=128;r<<=64;} if(z>>64>0){z>>=64;r<<=32;}
        if(z>>32>0){z>>=32;r<<=16;} if(z>>16>0){z>>=16;r<<=8;}
        if(z>>8>0){z>>=8;r<<=4;} if(z>>4>0){z>>=4;r<<=2;} if(z>>2>0){r<<=1;}
        for(uint256 i=0;i<7;i++)r=(r+n/r)/2;
        return int256(r<n/r?r:n/r);
    } }
    function pdf(int256 x) internal pure returns(int256){ unchecked {if(ab(x)>10*U)return 0;return divi(exp(-mul(x,x)/2),2506628274631000200);} }
    // Hart rational normal tail approximation; erf(x)=2*Phi(x*sqrt(2))-1.
    function cdf(int256 x,int256 density) internal pure returns(int256){ unchecked {
        int256 y=ab(x);if(y>8*U)return x>0?U:int256(0);
        int256 n=35262496599891000;
        n=mul(n,y)+700383064443688000;n=mul(n,y)+6373962203531650000;
        n=mul(n,y)+33912866078383000000;n=mul(n,y)+112079291497871000000;
        n=mul(n,y)+221213596169931000000;n=mul(n,y)+220206867912376000000;
        int256 d=88388347648318400;
        d=mul(d,y)+1755667163182640000;d=mul(d,y)+16064177579207000000;
        d=mul(d,y)+86780732202946100000;d=mul(d,y)+296564248779674000000;
        d=mul(d,y)+637333633378831000000;d=mul(d,y)+793826512519948000000;
        d=mul(d,y)+440413735824752000000;
        int256 tail=mul(mul(density,2506628274631000200),divi(n,d));return x>0?U-tail:tail;
    } }
    function trunc(int256 m,int256 v,int256 lo,int256 hi) internal pure returns(int256 Z,int256 mt,int256 vt){ unchecked {
        if(v<=0)return (lo<=m&&m<=hi?U:int256(0),m,0);
        int256 sd=root(v);int256 a=divi(lo-m,sd);int256 b=divi(hi-m,sd);
        int256 pa=pdf(a);int256 pb=pdf(b);
        Z=cdf(b,pb)-cdf(a,pa);
        if(Z<1e6)return(Z,m<lo?lo:hi,v/4);
        int256 r=divi(pa-pb,Z);
        mt=m+mul(sd,r);vt=mul(v,U+divi(mul(a,pa)-mul(b,pb),Z)-mul(r,r));if(vt<0)vt=0;
    } }
    // ---- qm-spline lookup (QMS1 blob sha256 3ac7cb88..., 10,167 B): 5 cubic tensor B-splines over (row, column, sd level),
    // ask side only; bid = point mirror. Coefficients int16 (1/8 bps) as PUSH32 immediates, 16 lanes of (c+32768) per word.
    // coefficient words of table tb (16 lanes of c+32768 each, word 0 = the table's first 16 coefficients), stored once per callback
    bytes constant QPL=hex"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";
    struct QT {uint256 lk;uint256 r0;uint256 r1;uint256 r2;uint256 ck;uint256 nl;uint256 nr;uint256 nc;uint256 off;int256 scale;}
    function qt(uint256 tb) internal pure returns(QT memory t) {
if(tb==0) t=QT(0x70000,0x960095009400920090008d008900840081007c007b00780072007000550000,0x14000ab00aa00a700a3009d009c0097,0x0,0xc0b0a0908070605030100,2,24,11,540,250000000000000000);
else if(tb==1) t=QT(0x700030000,0x9200910090008f008c008b00880087008500820080007c0077006b00520000,0xa900a800a700a600a500a400a200a1009f009e009c009a0098009600940093,0x14000ca00bd00b900b500b200af00ad00ac00ab00aa,0x302a29282726252422201f1e1d1c1b1a191817161514131211100f0c0900,3,43,30,1116,500000000000000000);
else if(tb==2) t=QT(0x7000300020000,0x9400920090008f008e008d008b008a008800870085008400830069004a0000,0x14000ab00a900a800a700a500a400a1009e009d009c0097,0x0,0x301e1c1b1a1918171615131200,4,28,13,5115,500000000000000000);
else if(tb==3) t=QT(0x700030000,0x9b009900970095009300920091008f008e008b00890087007d007300510000,0xb600b200b000ae00ac00ab00aa00a900a800a700a600a500a300a1009f009e,0x14000bf00bc00b8,0x302a29282726252422201e1d1c1b191817161514131211100b00,3,36,26,6683,1000000000000000000);
else if(tb==4) t=QT(0x700030000,0xad00ab00a800a4009b009500920090008f008d008b008a00880078005b0000,0x140,0x0,0x301e1b1a191816151200,3,17,10,9599,500000000000000000);
    }
    function rk(QT memory t,uint256 i) internal pure returns(uint256){unchecked{return ((i<16?t.r0:(i<32?t.r1:t.r2))>>(16*(i%16)))&65535;}}
    function spanR(QT memory t,uint256 x) internal pure returns(uint256 a){unchecked{
        uint256 hi=t.nr-1;while(hi-a>1){uint256 m=(a+hi)/2;if(rk(t,m)<=x)a=m;else hi=m;}
    }}
    function spanC(QT memory t,uint256 x) internal pure returns(uint256 a){unchecked{
        uint256 hi=t.nc-1;while(hi-a>1){uint256 m=(a+hi)/2;if(((t.ck>>(8*m))&255)<=x)a=m;else hi=m;}
    }}
    function record(bytes memory b,QT memory t,uint256 l,uint256 r,uint256 c) internal pure returns(int256 v,int256 vn){unchecked{
        uint256 o=t.off+(l*t.nr+r)*(t.nc+1);
        v=int256(int16(uint16(uint8(b[o]))|(uint16(uint8(b[o+1]))<<8)));
        for(uint256 n=0;n<c;n++)v+=int256(int8(uint8(b[o+2+n])));
        vn=v+int256(int8(uint8(b[o+2+c])));v*=t.scale;vn*=t.scale;
    }}
    function lerp(int256 a,int256 b,int256 f) internal pure returns(int256){unchecked{return a+mul(b-a,f);}}
    function surf(QT memory t,bytes memory b,int256 pw,int256 p2,uint256 k,int256 tt,uint256 jm) internal pure returns(int256){unchecked{
        uint256 i=uint256(pw/U);if(i>319)i=319;int256 f=pw-int256(i)*U;
        uint256 j=uint256(p2/U);if(j>jm)j=jm;int256 g=p2-int256(j)*U;
        uint256 a;while(a<t.nl-2&&((t.lk>>(16*(a+1)))&65535)<=k)a++;
        uint256 r=spanR(t,i);uint256 c=spanC(t,j);
        int256[8] memory v;
        for(uint256 l=0;l<2;l++)for(uint256 row=0;row<2;row++)(v[l*4+row*2],v[l*4+row*2+1])=record(b,t,a+l,r+row,c);
        int256[2] memory lr;lr[0]=int256((t.lk>>(16*a))&65535);lr[1]=int256((t.lk>>(16*(a+1)))&65535);
        int256 rlo=int256(rk(t,r));int256 rd=int256(rk(t,r+1))-rlo;
        int256 clo=int256((t.ck>>(8*c))&255);int256 cd=int256((t.ck>>(8*(c+1)))&255)-clo;
        int256[2] memory levels;
        for(uint256 l=0;l<2;l++){
            int256 u=(int256(k+l)-lr[0])*U/(lr[1]-lr[0]);int256[4] memory q;
            for(uint256 z=0;z<4;z++)q[z]=lerp(v[z],v[z+4],u);
            int256[4] memory nodes;
            for(uint256 row=0;row<2;row++){
                int256 rf=(int256(i+row)-rlo)*U/rd;
                int256 x0=lerp(q[0],q[2],rf);int256 x1=lerp(q[1],q[3],rf);
                for(uint256 col=0;col<2;col++){
                    int256 cf=(int256(j+col)-clo)*U/cd;
                    int256 n=lerp(x0,x1,cf);nodes[row*2+col]=n>0?n:int256(0);
                }
            }
            levels[l]=lerp(lerp(nodes[0],nodes[2],f),lerp(nodes[1],nodes[3],f),g);
        }
        return lerp(levels[0],levels[1],tt);
    }}
    function w2l(uint256 L) internal pure returns(int256){ unchecked {
        uint256 K=L<16?0x7ff77ff67ff57ff47ff27fef7fec7fe77fe27fd87fce7fc47fb07f9c7f7e7f60:(L<32?0x800780068005800480038002800180007fff7ffe7ffd7ffc7ffb7ffa7ff97ff8:(L<48?0x808280648050803c80328028801e801980148011800e800c800b800a80098008:0x00000000000000000000000000000000000000000000000000000000000080a0));
        return int256((K>>(16*(L&15)))&0xffff)-32768;
    } }
    // real.py/evalpol _pos2 over pol_mid's W2L (grid units of 5 bps), WAD in and out
    function pos2(int256 v) internal pure returns(int256){ unchecked {
        if(v<=-160*U)return 0; if(v>=160*U)return 48*U;
        uint256 lo=0;uint256 hi=48;
        while(hi-lo>1){uint256 md=(lo+hi)>>1;if(w2l(md)*U<=v)lo=md;else hi=md;}
        int256 a=w2l(lo);return int256(lo)*U+(v-a*U)/(w2l(hi)-a);
    } }
    function sdl(uint256 k) internal pure returns(int256){ unchecked { return int256((0x221a14100c080400>>(8*k))&0xff); } }
    // qm fee rule: w, w2 offsets (WAD bps), phase, synced flag, belief variance v (WAD, ln-price^2)
    function fees(int256 w,int256 w2,uint256 ph,bool syn,int256 v) internal pure returns(int256 fb,int256 fa){ unchecked {
        int256 sd=root(v)*10000;uint256 k;
        while(k<6&&sd>=sdl(k+1)*U)k++;
        int256 tt=clip((sd-sdl(k)*U)/(sdl(k+1)-sdl(k)),0,U);
        int256 pw=clip(w/5+160*U,0,320*U);int256 wq=(pw-160*U)*5;
        uint256 tb;int256 p2;int256 nc1;
        if(ph==0){tb=0;p2=clip(w2/5,-6*U,6*U)+6*U;nc1=12;}
        else{tb=(ph==1?1:3)+(syn?0:1);p2=pos2(w2/5);nc1=48;}
        QT memory t=qt(tb);bytes memory b=QPL;
        int256 xa=surf(t,b,pw,p2,k,tt,uint256(nc1)-1)+wq-w;
        int256 xb=surf(t,b,320*U-pw,nc1*U-p2,k,tt,uint256(nc1)-1)+w-wq;
        fb=xb>0?U-exp(-xb/10000):int256(0);fa=xa>0?U-exp(-xa/10000):int256(0);
        fb=clip(fb,0,U/10);fa=clip(fa,0,U/10);
    } }
    function afterInitialize(uint256 x,uint256 y) external override returns(uint256,uint256){ unchecked {
        int256 sp=int256(y*1e18/x);
        slots[0]=uint256(uint128(int128(ln(sp))));
        slots[1]=uint256(uint128(int128(sp)))*(1+(uint256(1)<<128));
        slots[3]=x;slots[4]=y;slots[5]=0;
        slots[2]=2823606104386589*(1+(uint256(1)<<64));
        return(2823606104386589,2823606104386589);
    } }
    // filter update over a gap of dt steps; returns new m, v, rival spot r and the arb flag
    function update(int256 m,int256 v,int256 fb,int256 fa,int256 sp,int256 r,int256 s,bool buy,uint256 dt,bool hit,int256 chance) internal pure returns(int256,int256,int256,bool arb){ unchecked {
        int256 lo=ln(mul(sp,U-fb));int256 hi=ln(divi(sp,U-fa));
        uint256 n=dt-1;if(n>12)n=12;
        for(uint256 i=0;i<n;i++){v+=893025000000;(,m,v)=trunc(m,v,lo,hi);}
        v+=893025000000;
        int256 lp=ln(buy?mul(s,U-fb):divi(s,U-fa));
        int256 sd=root(v);int256 la=divi(pdf(divi(lp-m,sd)),sd);
        (int256 Z,int256 mt,int256 vt)=trunc(m,v,lo,hi);
        int256 d=ab(ln(divi(s,sp)));if(d<1e9)d=1e9;
        int256 pi=pdf(divi(ln(d)+6801595083153746944,1176000000000000000));
        int256 lr=divi(mul(mul(Z,260000000000000000),pi),mul(d,1176000000000000000));
        lr=mul(lr,chance);
        pi=hit&&la+lr>0?divi(la,la+lr):int256(0);arb=pi>U/2;
        if(pi>5e15&&pi<995e15){
            m=mul(pi,lp)+mul(U-pi,mt);
            v=mul(pi,mul(lp-m,lp-m))+mul(U-pi,vt+mul(mt-m,mt-m));
        }else if(arb){m=lp;v=0;}else{m=mt;v=vt;}
        int256 pe=exp(m);r=clip(r,mul(pe,997e15),divi(pe,997e15));
        return(m,v,r,arb);
    } }
    function afterSwap(TradeInfo calldata t) external override returns(uint256,uint256){ unchecked {
        uint256 s0=slots[0];uint256 s1=slots[1];uint256 s2=slots[2];
        int256 m=int256(int128(uint128(s0)));int256 v=int256(int128(uint128(s0>>128)));
        int256 sp=int256(int128(uint128(s1)));int256 r=int256(int128(uint128(s1>>128)));
        int256 fb=int256(s2&M64);int256 fa=int256(s2>>64&M64);uint256 cnt=s2>>192&0xffffffff;bool syn=s2>>255==1;
        int256 s=int256(t.reserveY*1e18/t.reserveX);bool arb;
        if(t.timestamp>(s2>>128&M64)){
            bool hit=TellMath.ltTell(slots[3],slots[4],uint256(t.isBuy?fb:fa),t.amountX,t.amountY,t.reserveY,t.isBuy)==1;
            int256 chance=hit?int256(TellMath.ulpOverGridWad(t.isBuy?t.amountX:t.amountY,t.isBuy?slots[3]:slots[4],t.isBuy?t.reserveX:t.reserveY)):int256(0);
            (m,v,r,arb)=update(m,v,fb,fa,sp,r,s,t.isBuy,t.timestamp-(s2>>128&M64),hit,chance);cnt=0;syn=false;
        }
        uint256 ph;
        if(!arb){
            int256 c=t.isBuy?divi(mul(s,U-fb),997e15):divi(mul(s,997e15),U-fa);
            // counting variant qlx5 (copy-b, e04-split-engine): tracked-offset split test (see copy-b result). Credit Taylor (gtmcknight).
            bool qx;if(t.timestamp<(s2>>128&M64)+7){int256 m0=int256(slots[6]);int256 mm;(qx,mm)=TellMath.qHitX(t.isBuy?t.amountX:t.amountY,slots[3],slots[4],uint256(t.isBuy?fb:fa),t.isBuy,m0,5);if(mm!=m0)slots[6]=uint256(mm);}if(qx||(t.isBuy?c<r:c>r)){r=c;syn=true;}
            // give: bound did not bind -> pull ln r 0.35 of the way to ln c (GivePolicy, alpha=alpha2=0.35)
            else if(c!=r){int256 lr=ln(r);r=exp(lr+mul(35e16,ln(c)-lr));syn=true;}
            cnt++;ph=cnt==1?1:2;
        }
        slots[3]=t.reserveX;slots[4]=t.reserveY;
        int256 w=(ln(s)-m)*10000;int256 rr=(ln(r)-m)*10000;
        (fb,fa)=fees(w,rr,ph,syn,v);
        fb=guardFee(fb);fa=guardFee(fa);
        slots[0]=uint256(uint128(int128(m)))|uint256(uint128(int128(v)))<<128;
        slots[1]=uint256(uint128(int128(s)))|uint256(uint128(int128(r)))<<128;
        slots[2]=uint256(fb)|uint256(fa)<<64|t.timestamp<<128|cnt<<192|(syn?uint256(1)<<255:0);
        return(uint256(fb),uint256(fa));
    } }

    // Complete integer preimage of Vanilla gamma under IEEE binary64 conversion.
    // Closest integer outside that interval; ties select the lower fee.
    function guardFee(int256 f) internal returns(int256) {
        if(f>=2999999999999948&&f<=3000000000000057){slots[5]++;return f-2999999999999947<=3000000000000058-f?int256(2999999999999947):int256(3000000000000058);}return f;
    }
    function guardShifts() external view returns(uint256) {return slots[5];}
    // lean label of a trade: 0 unsupported, 1 positive, 2 negative, 3 over budget; isArb = (label == 1). x (reserveX) is not used.
    function leanLabel(bool b,uint256 ax,uint256 ay,uint256,uint256 y,uint256 px,uint256 py,uint256 fb,uint256 fa) public pure returns(uint256) {return TellMath.ltTell(px,py,b?fb:fa,ax,ay,y,b);}
    // qlite-a decision as afterSwap takes it: p paid wad, px/py previous reserves, f fee wad of the paid side, dt steps since the previous own callback
    
    function isArb(bool b,uint256 ax,uint256 ay,uint256 x,uint256 y,uint256 px,uint256 py,uint256 fb,uint256 fa) external pure returns(bool) {return leanLabel(b,ax,ay,x,y,px,py,fb,fa)==1;}
}
library TellMath {
    uint256 internal constant WAD = 1e18;
    uint256 internal constant TWO53 = 1 << 53;
    uint256 internal constant TWO52 = 1 << 52;
    uint256 internal constant LIM = 1 << 128;

    /// floor(log2(x)) + 1, 0 for x = 0, by binary normalization.
    function bitLen(uint256 x) internal pure returns (uint256 n) {
        unchecked {
            if (x >= 1 << 128) { x >>= 128; n += 128; }
            if (x >= 1 << 64) { x >>= 64; n += 64; }
            if (x >= 1 << 32) { x >>= 32; n += 32; }
            if (x >= 1 << 16) { x >>= 16; n += 16; }
            if (x >= 1 << 8) { x >>= 8; n += 8; }
            if (x >= 1 << 4) { x >>= 4; n += 4; }
            if (x >= 1 << 2) { x >>= 2; n += 2; }
            if (x >= 1 << 1) { x >>= 1; n += 1; }
            if (x != 0) n += 1;
        }
    }

    /// num/den (both > 0) rounded to nearest-even double m*2^e, 2^52 <= m < 2^53.
    /// One division: the bit-length estimate is off by at most one binade, fixed by a shift.
    function rn(uint256 num, uint256 den) internal pure returns (uint256 q, int256 e) {
        e = int256(bitLen(num)) - int256(bitLen(den)) - 53;
        uint256 sn; uint256 sd;
        if (e < 0) { sn = num << uint256(-e); sd = den; } else { sn = num; sd = den << uint256(e); }
        q = sn / sd;
        // estimate gives q in [2^52, 2^54): at most one step down in precision
        if (q >= TWO53) {
            e += 1;
            if (e <= 0) { sn = num << uint256(-e); } else { sn = num; sd = den << uint256(e); }
            q = sn / sd;
        }
        uint256 r = sn - q * sd;
        uint256 twice = 2 * r;
        if (twice > sd || (twice == sd && (q & 1) == 1)) {
            q += 1;
            if (q == TWO53) { q = TWO52; e += 1; }
        }
    }

    /// e with 2^e * 1e18 <= w < 2^(e+1) * 1e18 (w > 0).
    function binade(uint256 w) internal pure returns (int256 e) {
        e = int256(bitLen(w)) - 60; // bitLen(1e18) = 60
        if (!_atLeast(w, e)) e -= 1;
        else if (_atLeast(w, e + 1)) e += 1;
    }

    function _atLeast(uint256 w, int256 e) private pure returns (bool) {
        return e >= 0 ? (WAD << uint256(e)) <= w : WAD <= (w << uint256(-e));
    }

    function _min(int256 a, int256 b) private pure returns (int256) { return a < b ? a : b; }

    /// log2 of the grid: min(binade(before), binade(after)) - 52.
    function gridExp(uint256 beforeW, uint256 afterW) internal pure returns (int256) {
        return _min(binade(beforeW), binade(afterW)) - 52;
    }

    /// min(1, ulp(paid)/grid) scaled by 1e18, paid = fl(paidW/1e18) (the double behind paidW).
    /// Returns 0 for out-of-bounds inputs. 1e18 means the paid amount is no finer than the grid.
    function ulpOverGridWad(uint256 paidW, uint256 beforeW, uint256 afterW) internal pure returns (uint256) {
        if (paidW == 0 || paidW >= LIM || beforeW == 0 || beforeW >= LIM || afterW == 0 || afterW >= LIM) return 0;
        (, int256 pe) = rn(paidW, WAD);
        int256 d = gridExp(beforeW, afterW) - pe;
        if (d <= 0) return WAD;
        if (d > 64) return 0;
        return WAD >> uint256(d);
    }

    // ---- LEAN TELL of result lb-4 (scratch/LeanTell.sol, functions verbatim): buy-grid's bounded sell_one_division / buy_grid tests,
    // budget 4, in exact integer binary64 (round-to-nearest-even) arithmetic. A double is m*2^e with 2^52 <= m <= 2^53; 1e18 = LT_C*2^7.
    // ltTell returns 0 unsupported, 1 positive, 2 negative, 3 over budget. Mirrors lean_tell.py bit for bit. Credit Taylor (gtmcknight).
    uint256 constant LT_C=7812500000000000;
    function ltMsb(uint256 x) internal pure returns(uint256 r){unchecked{
        if(x>>128!=0){x>>=128;r=128;}if(x>>64!=0){x>>=64;r+=64;}if(x>>32!=0){x>>=32;r+=32;}if(x>>16!=0){x>>=16;r+=16;}
        if(x>>8!=0){x>>=8;r+=8;}if(x>>4!=0){x>>=4;r+=4;}if(x>>2!=0){x>>=2;r+=2;}if(x>>1!=0)r++;
    }}
    // n / 2^s to nearest, ties to even; s >= 1.
    function ltRound(uint256 n,uint256 s) internal pure returns(uint256 q){unchecked{
        q=n>>s;uint256 rem=n&((uint256(1)<<s)-1);uint256 half=uint256(1)<<(s-1);
        if(rem>half||(rem==half&&(q&1)!=0))q++;
    }}
    // Wad::from_f64 of the double m*2^e: trunc(RN(m*2^e * 1e18)).
    function ltWad(uint256 m,int256 e) internal pure returns(uint256){unchecked{
        uint256 n=m*LT_C;uint256 s=n>>105!=0?53:52;uint256 p=ltRound(n,s);int256 t=e+7+int256(s);
        if(t>=0)return t>128?type(uint256).max:p<<uint256(t);
        return t<-64?0:p>>uint256(-t);
    }}
    // Wad of RN(d*2^e / g), g = G*2^-53, 0 < d < 2^53 exact.
    function ltDivWad(uint256 d,int256 e,uint256 G) internal pure returns(uint256){unchecked{
        uint256 n=(d<<110)/G;if(n*G!=d<<110)n|=1;
        uint256 s=ltMsb(n)-52;return ltWad(ltRound(n,s),e+int256(s)-57);
    }}
    // G = 2^53 * RN(1 - RN(RN(fee)/1e18)), fee <= 1e17.
    function ltGamma(uint256 f) internal pure returns(uint256){unchecked{
        if(f==0)return 1<<53;
        uint256 sf=ltMsb(f);
        if(sf>52){sf-=52;f=ltRound(f,sf);}else sf=0;
        uint256 n=(f<<110)/LT_C;if(n*LT_C!=f<<110)n|=1;
        uint256 s=ltMsb(n)-52;uint256 r=64-s-sf;
        return ltRound((uint256(1)<<(53+r))-ltRound(n,s),r);
    }}
    // Every double whose wad is w (2^60 <= w < 2^120): mantissas a, b (0 = absent), exponent e.
    function ltPre(uint256 w) internal pure returns(uint256 a,uint256 b,int256 e){unchecked{
        uint256 n=(w<<64)/1e18;uint256 h=ltMsb(n);uint256 m=n>>(h-52);e=int256(h)-116;
        if(ltWad(m,e)==w)a=m;
        if(ltWad(m+1,e)==w)b=m+1;
    }}
    // Virtual reserves xv = (m+k)*2^e > rx whose amount wad is ax.
    function ltGrid(uint256 m,int256 e,uint256 k0,uint256 G,uint256 ax) internal pure returns(uint256 hits){unchecked{
        if(m==0)return 0;
        uint256 lo=k0;uint256 hi=k0+1;if(k0>>48!=0){lo--;hi++;}
        if(lo==0)lo=1;
        for(uint256 k=lo;k<=hi;k++){
            uint256 t=m+k;if(t>>53!=0&&(t&1)!=0)continue;
            if(ltDivWad(k,e,G)==ax)hits++;
        }
    }}
    // px, py: previous callback's reserve wads; fee: the fee wad returned then for this side
    // (bid when the pool buys X); ax, ay, cy: this trade's amountX, amountY, reserveY.
    function ltTell(uint256 px,uint256 py,uint256 fee,uint256 ax,uint256 ay,uint256 cy,bool buy) internal pure returns(uint256){unchecked{
        if(fee>1e17)return 0;
        uint256 G=ltGamma(fee);
        if(buy){
            if(px>>60==0||px>>120!=0||ax==0||ax>px>>1)return 0;
            (uint256 a,uint256 b,int256 e)=ltPre(px);
            if((a|b)==0)return 0;
            uint256 k0=ax*G/(uint256(1e18)<<uint256(e+53));
            uint256 hits=ltGrid(a,e,k0,G,ax)+ltGrid(b,e,k0,G,ax);
            if((a!=0?1:0)+(b!=0?1:0)+hits>4)return 3;
            return hits!=0?1:2;
        }
        if(py>>60==0||py>>120!=0||cy>>60==0||cy>>120!=0||ay==0||ay>>120!=0)return 0;
        (uint256 y0,uint256 y1,int256 ey)=ltPre(py);(uint256 z0,uint256 z1,int256 ez)=ltPre(cy);
        if((y0|y1)==0||(z0|z1)==0)return 0;
        int256 de=ez-ey;if(de>1||de<-1)return 0;
        if(de==1){z0<<=1;z1<<=1;}else if(de==-1){y0<<=1;y1<<=1;ey=ez;}
        for(uint256 i=0;i<4;i++){
            uint256 y=i<2?y0:y1;uint256 z=(i&1)==0?z0:z1;
            if(y==0||z<=y)continue;
            z-=y;if(z>>53!=0)return 0;
            if(ltDivWad(z,ey,G)==ay)return 1;
        }
        return 2;
    }}
    // ---- qlite-a split test: qlgate.py cap24+GATE = qlite_int.capped_int(cap=24) in exact integer binary64 (round-to-nearest-even)
    // arithmetic, one candidate (preimage pair (0,0), z = r, k = n). Credit Taylor (gtmcknight), amm-sim 4812a638 research/solved.
    uint256 constant QG=8980177656976769;int256 constant QGE=-53; // 0.997
    uint256 constant QK=8782888972198741;int256 constant QKE=-43; // sqrt(1e6*0.997)
    // n > 0 to the nearest double m*2^s, 2^52 <= m < 2^53.
    function qR(uint256 n) internal pure returns(uint256 m,int256 s){unchecked{
        uint256 h=ltMsb(n);
        if(h<53)return(n<<(52-h),int256(h)-52);
        s=int256(h)-52;m=ltRound(n,uint256(s));if(m>>53!=0){m>>=1;s++;}
    }}
    // RN(a/b), a and b of 53 bits: m*2^s.
    function qD(uint256 a,uint256 b) internal pure returns(uint256 m,int256 s){unchecked{
        uint256 n=(a<<110)/b;if(n*b!=a<<110)n|=1;
        (m,s)=qR(n);s-=110;
    }}
    // RN(RN(w)/1e18), w > 0: float(w)/1e18.
    function qW(uint256 w) internal pure returns(uint256 m,int256 e){unchecked{
        int256 s;(m,e)=qR(w);(m,s)=qD(m,LT_C);e+=s-7;
    }}
    // pw: wad paid; rx, ry: previous callback's reserve wads; fee: fee wad returned then for the paid side; buy: the pool bought X.
    // Outside pw in (0, 2^128), rx, ry in [2^40, 2^128) the answer is a miss.
    function qHitX(uint256 pw,uint256 rx,uint256 ry,uint256 fee,bool buy,int256 m0,uint256 nc) internal pure returns(bool,int256){unchecked{
        if(pw==0||pw>>128!=0||rx>>40==0||rx>>128!=0||ry>>40==0||ry>>128!=0)return(false,m0);
        uint256 G=ltGamma(fee>1e17?1e17:fee); // gamma = G*2^-53
        (uint256 pm,int256 pe)=qW(pw);
        (uint256 am,int256 ae)=qW(buy?ry:rx);(uint256 vm,int256 ve)=qW(buy?rx:ry); // v: paid-side reserve, grid = ulp(v) = 2^ve
        int256 s;
        (am,s)=qR(am*G);ae+=s-53;(am,s)=qR(am*vm);ae+=s+ve; // a = (u*gamma)*v
        s=((ae-57)&1)!=0?int256(58):int256(57);
        uint256 M=am<<uint256(s);ae=(ae-s)/2-1;
        uint256 q=1<<56;while(true){uint256 y=(q+M/q)>>1;if(y>=q)break;q=y;} // floor sqrt
        (am,s)=qR(q<<1|(q*q!=M?1:0));ae+=s; // sqrt(a)
        (am,s)=qD(am,QK);ae+=s-QKE; // r
        (am,s)=qR(am*QG);ae+=s+QGE; // r*0.997
        s=ae<-53?ae:-53;
        (uint256 dm,int256 de)=qR((G<<uint256(-53-s))+(am<<uint256(ae-s)));de+=s; // d = gamma + r*0.997
        for(uint256 i;i<nc;++i){int256 m=m0+(i==0?int256(0):i==1?int256(1):i==2?int256(-1):i==3?int256(2):int256(-2));uint256 dc=uint256(int256(dm)+m);(uint256 nm,int256 ns)=qR(pm*dc);ns+=pe+de-ve;if(ns<0){if(ns<-54)continue;nm=ltRound(nm,uint256(-ns));if(nm==0)continue;ns=0;}if(ltDivWad(nm,ns+ve-de-53,dc)==pw)return(true,m);}return(false,m0); // trunc(((n*grid)/d)*1e18) == paid wad
    }}
}
```

</details>

**Outcome against the requested score.** The supplied starting score is 528.3333 and supplied leader score is 528.4152: the difference is **0.0819**. Under the requester's exact engine-to-board transfer premise, a gain of 0.0819 would tie that score; exceeding it is needed for outright #1. Merely clearing the +0.04 contract-return gate would imply 528.3733, still 0.0419 short of that supplied leader. No measured gain here is approved for that projection. These are the task's pinned scores and arithmetic, not a fresh leaderboard observation.

**Evidence and measurement convention.** Engine edge means the submission arm's score when it runs separately against the fixed 30-bps Vanilla normalizer for 10,000 steps. Candidate, QLX5, and QT1 comparisons use the same seed/configuration, not direct candidate-versus-QLX5 matches. For differences d_i, pooled mean is S1/N and paired SE is `sqrt((S2 − S1²/N)/(N·(N−1)))`, with S1=sum(d_i) and S2=sum(d_i²). No block means are averaged without their sample counts. Adaptive stopping makes the pooled observations descriptive; `mean+2·SE` below is a stopping statistic, not a guaranteed confidence bound. Search arms sharing seeds are correlated and cannot be added as independent gains. [Engine records][root-1-01], [replica records][root-1-02]

**(a) QLX5 + AGE: implemented, checked, and retired for insufficient gain.** The stack changes the nonbinding retail pull, when no split hit occurs, from α=0.35 to `floor(7e17·age/(age+1))` in WAD units, with age measured since the last binding rival observation. Binding bounds and split hits refresh that timestamp; arb does not. The timestamp occupies slot-2 bits 224..254. Existing filter, tell, tables and split logic stay in place. This adds 527 source characters and 118 deployed bytes to QLX5. Taylor's attribution is retained. [Build][b01-qa], [check][b02-qa]

The build's small smokes passed. The subsequent check reported P/T/F passes: on seeds 74200..74249 it compared 549,905 autonomous callbacks and 549,733 fixed-input callbacks with zero reported label/state branch mismatches. Fee checks covered 100,000 callbacks per stream; maximum reported errors were 6.0834e-10 bps and 8.254e-11 bps, below 0.01 bps. Its G field covered size, not an independent engine gas replay. Later engine blocks supplied measured gas/OOG evidence. Candidate Q was cancelled; neither Q nor E should be inferred from the check's `all=pass`. One source flag attaches to that check; the failed quotation is not identified. [Check][b02-qa], [evidence qualification][root-1-01]

All fresh AGE efficacy blocks are listed below. SE is paired. Values in this table are rounded to nine decimal places; the opening and pooled table retain full precision. The eight gas-only seeds 10202048..10202055 are excluded from efficacy. “Peak” always means the candidate's peak, not the maximum across the three arms.

| Block / source | Completed seed range | n | Δ QLX5 | SE | Δ QT1 | Candidate peak | Disposition |
|---|---|---:|---:|---:|---:|---:|---|
| [Pilot][b04-qa] | 10200000..10200255 | 256 | −0.007228683 | 0.010490848 | +3.300198470 | 209329 | Separate exploratory block |
| [s1][b11-s1] | 10208000..10208255 | 256 | +0.014754469 | 0.009765127 | +3.375054389 | 207006 | Finished, below bar |
| [s2][b11-s2] | 10208256..10208383 | 128 | −0.018355604 | 0.014726233 | +3.169496475 | 208123 | Futility stop |
| [s3][b11-s3] | 10208512..10208639 | 128 | −0.006058037 | 0.014212115 | +3.132954465 | 207158 | Futility stop |
| [s4][b11-s4] | 10208768..10208895 | 128 | −0.007991124 | 0.013177712 | +3.447945401 | 208377 | Futility stop |
| [s5][b12-s5] | 10209024..10209151 | 128 | +0.010271608 | 0.010939691 | +3.360276871 | 206153 | Futility stop |
| [s6][b12-s6] | 10209280..10209407 | 128 | −0.007357393 | 0.011503175 | +3.384224290 | 207617 | Futility stop |
| [s7][b12-s7] | 10209536..10209663 | 128 | −0.031306741 | 0.013727037 | +3.256379096 | 207618 | Futility stop |
| [s8][b12-s8] | None; lease 10209792..10210047 retired | 0 | Unmeasured | Unmeasured | Unmeasured | Unmeasured | Unrun |

Every measured efficacy block reports zero OOG and zero other callback failures. s8 has null failure/gas observations, not measured zeros. Six follow-up blocks stopped after 128 seeds on `mean+2·SE < 0.04`; only s1 completed 256. Every follow-up has `advance=false`. Thus 1,024 of 2,048 reserved follow-up seeds were observed; unrun tails are not samples, and no positive block was cherry-picked. [All block evidence][root-1-01]

| Pool | n | Δ QLX5 | SE vs QLX5 | Δ QT1 | SE vs QT1 |
|---|---:|---:|---:|---:|---:|
| All completed follow-ups | 1024 | -0.003911044007076425 | 0.004711946262616144 | 3.3126731718382834 | 0.03257987160754803 |
| Pilot plus every completed follow-up | 1280 | -0.004574571866247901 | 0.004312389928790002 | 3.3101782313777894 | 0.029419720289595903 |

The follow-up QLX5 sufficient statistics are **S1=−4.004909063246259**, **S2=23.273871269261853**, **N=1024**; with the pilot, **S1=−5.855451988797313**, **S2=30.471826982670372**, **N=1280**. These were recomputed for this report from all decoded unrounded rows. The QT1 advantage largely belongs to the pre-existing QLX5 policy; it does not rescue AGE's negative incremental result. The historical AGE-over-LEAN result (+0.032, SE 0.008, 512 seeds) uses a different baseline and does not add to QLX5's historical improvement. AGE is closed, not an assumed base for further stacking. [Historical AGE engine result][AGE-engine], [AGE engine evidence][root-1-01]

**(b) Engine-faithful replica: the useful positive deliverable.** The work corrected much more than constant K: every quote and arb-size calculation recomputes K from rounded reserves; it preserves binary64 operation order, arb caps/profit tests and requoting, incremental fee/reserve accounting, both pools' ordering, pre-callback split decisions, dust thresholds, and WAD conversions. The integer policy preserves fixed-point arithmetic, signed truncation, production tables, tell decisions and tracked split offsets. [Core and policy evidence][root-1-01], [policy bundle][b07-r3]

The key additional defect was the exponential implementation in retail LogNormal/Poisson draws. Price GBM uses host exp, but the audited retail stream required the Rust libm/fdlibm path. The original r3/r4 constant-fee cores achieved only 16/128 bit-identical scores, despite maximum relative error 5.943033337599645e-11. r1/r2's corrected cores reported 128/128 exact constant-fee runs. Such small constant-policy error was not sufficient evidence for QLX5: the corrected dynamic policy is sensitive to low bits in fills. [Core comparison][root-1-01]

The four initial policy ports compared 512 saved rows per policy at six-decimal precision. Their maximum QLX5 discrepancy, 4.994752202946984e-7, was consistent with rounded input rows; those tests alone did **not** prove the requested 1e-8 dynamic parity. The later audit reran the release engine with unrounded outputs and reported **512/512 bit-identical QLX5 scores, maximum error 0**, seeds **10010512..10011023**, and **5,626,901 callbacks**. Separately, four proof seeds × three policies produced **1,348,988 trace comparisons with zero mismatches**, covering RNG/orders, routing/fills, reserves, fees, state and accounting. That is the evidence for using the corrected replica. [Unrounded audit][b13-r3]

The audit's negative control is consequential: switching retail exp back to host exp changes an order by one ULP at seed 9700000, step 6. QLX5 then accumulates 57,722 trace mismatches and an engine-minus-port edge difference of 0.03738953382651289 on that proof seed. This is why the older constant-K fast LEAN replica and uncorrected cores must not supply QLX5 efficacy claims. It is a demonstrated sensitivity, not a forecast of profitable strategy changes. [Audit negative control][b13-r3]

The retained implementation and evidence identities are:

| Asset | Full SHA-256 | Retrieval / meaning |
|---|---|---|
| Integer policy `qlxcore.py` | `701dbfd1175fee7d129de92db21b1ddc78645796c422b29d8efba2eda501ab00` | [Policy bundle][b07-r3] |
| Corrected `enginecore_f.py` | `60af56a7570fabd603c6374d38a38f88b3c35a8f1e8192f588769460a96bfcfd` | Same bundle; retain corrected retail exp and reserve arithmetic |
| Production `qlx_tables.json` | `8c6d33c5c1024bc23593f46123aad1712c0cc8af3f4a118c5875258f9d7b81a6` | Same bundle / table generator from pinned QLX5 |
| Policy bundle's decoded tar | `0e8adc477297130b731395b8494b6652c982d2c865306a317e139835d21e27f3` | Container hash differs from member hashes |
| Audit artifact | `362fb97f041087bf3548c302af4c0f82d2537d6a6c0157a95ac06d0cb70a5ce4` | [512-row and trace audit][b13-r3] |
| Cython `qlxhot.py` | `3d28cffd8e4fe258e412c9e42f7be7b8f590a719e1267293704af5c0f53d3e93` | [Speed build][speed-build] |
| Cython wrapper | `7e1d0d75ab5f315f03a1f74185aed0351dbed9bc7e871ddf0c5a145bd4d8aa72` | Same speed build |
| Independent speed-check artifact | `72b58a1407966f0223f06ab7c6ddd979a24fb4593f1a9b3dc43508a7f133d00b` | [Rebuild/parity check][speed-check] |

The independent Cython check reproduced exact scores on the same 512 old engine rows and agreement with the original integer port. Twenty trace runs—four seeds × default/four knob variants—matched control callback inputs, fees, state and labels; 48,360 arithmetic helper cases also passed. Median wall speedup was about **1.52715×** (the build reported 1.5397×). This is a computational improvement, **zero strategy gain**. The changed-knob traces compare implementations; they are not fresh engine confirmations of each changed strategy. Engine labels in the check were summary counts, not a complete new per-callback engine-label oracle. [Independent check][speed-check], [speed evidence merge][root-1-02]

Reproduction information retained in those artifacts specifies the Cython build recipe `cyqlx/cyport/build_cy.sh`, Cython 3.1.4 and setuptools 80.9.0. Generated C/source were reproducible; native shared-object hashes depend on build paths. Separate Numba cache directories are needed for each implementation. The policy remains big-integer arithmetic. The replica does not establish EVM gas/revert/OOG behavior for new variants, and the finite default-policy parity evidence is not a universal proof for all configurations. All future candidate T/F/G checks remain necessary. [Build][speed-build], [check][speed-check]

Retuning **was attempted** on this repaired model in c3 and c4. It produced no surviving candidate; the absence is a successful tuned policy, not the absence of tuning work.

**(c) Structural search: 32 engine items, then two bounded replica rounds; no promotion.** The coarse map covered table levels, phase thresholds, rival clip/band widths, synced-table switches, split-test controls and tell floors. It compiled all 64 one-knob LO/HI variants, within 47,258 characters and 22,493 deployed bytes. Each of 32 items ran both variants against QLX5 on its own 128 fresh engine seeds; leases span **10203000..10207095**. This is 4,096 distinct screening seeds, not a 4,096-seed confirmation of one strategy. [Map][b08-map], [first half][b09-merge-01], [second half][b09-merge-02]

| Leading coarse screen | Δ QLX5 | SE | n | Candidate peak | Evidence |
|---|---:|---:|---:|---:|---|
| Pull α=0.2 | +0.016254 | 0.012277 | 128 | 210537 | [k02][b09-merge-01] |
| Three split candidates | +0.012183704885763369 | 0.007291343969593435 | 128 | 201803 | [k25][b09-merge-02] |
| Phase-1 tables for all retail | +0.010694784003180136 | 0.018751205545714963 | 128 | 205181 | [k13][b09-merge-01] |
| Split gap ≤9 | +0.0092041703876653 | 0.005181513506594154 | 128 | 216164 | [k04][b09-merge-01] |

None reached +0.02, much less the return gate. All 64 screens report peak checks passing, but the merged summaries preserve explicit zero OOG/revert counters only for k20/k22; missing counters elsewhere are not converted to zeros. These screens were QLX5/LO/HI comparisons, without a full QT1-paired return-gate confirmation. Large changes were often harmful: 15-bps rival clip −2.785455; log-fee scales 0.97/1.03 −1.1846334028201224/−1.8618988782159183; 2.5%/5% caps −33.62738878988017/−10.972542103216606. Inert sampled changes included both move-floor arms, both mass-floor arms and tell budget 6. The detailed 32-item table is preserved in the [first root merge][root-1-01].

After requester note 1, structural work moved to the faithful replica, in groups of at most five items, using 128-seed rounds and stopping each arm at `mean+2·SE < 0.03`. Choosing is 64000..65023; only a surviving setting can be frozen before its 2,048-seed report on 10000..12047. Promotion requires a complete report with gain ≥0.03. c3 tested **40 settings across ten items**. Every setting stopped at n=128..512; none froze, no report block opened, and all 30 downstream build/check/engine items were cancelled. [c3/c4 merge][root-1-02], goal history episode 4

The following c3 numbers identify the stopped diagnostics followed up by c4; they are rounded, not selected winners. In particular, pull-window's reported headline is the longer-tested α=0.15 arm rather than its largest terminal point estimate; clip-fine's top-level null/n=0 is a schema defect despite measured arms.

| c3 item / diagnostic | Δ QLX5 | SE | n |
|---|---:|---:|---:|
| window | +0.007697 | 0.006222 | 128 |
| three-window | +0.005497 | 0.006883 | 128 |
| pull-window headline | +0.008663 | 0.008609 | 512 |
| pull-three | +0.009970 | 0.007569 | 256 |
| three-way | +0.004903 | 0.012527 | 256 |
| sd-fine | +0.008603 | 0.009835 | 128 |
| clip-fine, gamma=0.99675 measured arm | +0.013262 | 0.006935 | 512 |
| fee-scale-fine | −0.002574 | 0.013289 | 256 |
| fee-offset-fine | −0.000749 | 0.011900 | 128 |
| phase2-blend | +0.012453 | 0.007293 | 512 |

These values are from the [c3 merge][root-1-02] and episode-4 notes. Wider windows largely saturated: W17/W25 matched on 127/128 seeds; using three candidates reduced split hit rate to about 0.818 from 0.891 without a promotion-level gain. Positive point estimates were hypotheses for testing interactions, not evidence that their gains add.

c4 supplied **nine accepted search results, 34 measured settings**. The tenth planned item, **clip-blend-pull**, failed and has no supplied result or stated cause; its outcome is **unknown**, not zero and not another measured futility stop. The nine accepted results all have `advance=false`. All downstream c4 build/check/engine batches settled without accepted outputs. Four c4-search-a results and four of five c4-search-b results carry source flags; level-curve is unflagged. goal.json snapshot (digest below), [final-result merge][root-1-02]

For clarity, L is the numerator of a synced phase-2 log-fee blend toward phase-1 table 1, denominator 10000, applied before axis correction and exponentiation. Clip gamma changes the rival bound, while the marginal candidate gamma remains 0.997. Pull α applies on nonbinding retail without a split hit. Joint configurations were measured jointly; their component gains were not added. Every row below is a terminal **choosing-only** paired replica measurement, rounded to nine decimals, on a consecutive prefix of 64000..65023. Every row met the futility stop. [Joint definitions][b24-clip-blend], [pull definition][b24-clip-pull]

| Item / source | Setting | n | Δ QLX5 | SE | Mean + 2 SE |
|---|---|---:|---:|---:|---:|
| [b24-clip-blend][b24-clip-blend] | γ=.9965, L=2500 | 768 | +0.009379350 | 0.007251509 | 0.023882369 |
| [b24-clip-blend][b24-clip-blend] | γ=.9965, L=5000 | 640 | +0.010171755 | 0.008295189 | 0.026762133 |
| [b24-clip-blend][b24-clip-blend] | γ=.99675, L=2500 | 640 | +0.013074948 | 0.006710503 | 0.026495954 |
| [b24-clip-blend][b24-clip-blend] | γ=.99675, L=5000 | 768 | +0.011485426 | 0.007091657 | 0.025668740 |
| [b24-clip-pull][b24-clip-pull] | γ=.99675, α=.10 | 640 | +0.010877125 | 0.007914697 | 0.026706518 |
| [b24-clip-pull][b24-clip-pull] | γ=.99675, α=.15 | 512 | +0.011596176 | 0.008586522 | 0.028769221 |
| [b24-clip-pull][b24-clip-pull] | γ=.99675, α=.25 | 512 | +0.014173101 | 0.007000165 | 0.028173432 |
| [b24-clip-pull][b24-clip-pull] | γ=.99675, α=.30 | 512 | +0.008320974 | 0.006704405 | 0.021729784 |
| [b24-blend-pull][b24-blend-pull] | L=5000, α=.10 | 512 | +0.004934687 | 0.010271872 | 0.025478431 |
| [b24-blend-pull][b24-blend-pull] | L=5000, α=.15 | 640 | +0.009129257 | 0.008684207 | 0.026497672 |
| [b24-blend-pull][b24-blend-pull] | L=5000, α=.25 | 640 | +0.009252276 | 0.007455884 | 0.024164044 |
| [b24-blend-pull][b24-blend-pull] | L=5000, α=.30 | 512 | +0.013641421 | 0.007699042 | 0.029039505 |
| [b24-clip-blend-window][b24-clip-blend-window] | γ=.99675, L=5000, α=.15, W=9 | 896 | +0.012436593 | 0.007808052 | 0.028052697 |
| [b24-clip-blend-window][b24-clip-blend-window] | γ=.99675, L=5000, α=.15, W=13 | 768 | +0.012469742 | 0.008208449 | 0.028886640 |
| [b24-clip-blend-window][b24-clip-blend-window] | γ=.99675, L=5000, α=.15, W=17 | 768 | +0.012928297 | 0.008132579 | 0.029193456 |
| [b24-clip-blend-window][b24-clip-blend-window] | γ=.99675, L=5000, α=.15, W=25 | 768 | +0.012664405 | 0.008150045 | 0.028964494 |
| [b28-split-radius][b28-split-radius] | nc=7 | 128 | +0.003257925 | 0.002584632 | 0.008427190 |
| [b28-split-radius][b28-split-radius] | nc=9 | 128 | +0.001645917 | 0.004035652 | 0.009717222 |
| [b28-sd-phase][b28-sd-phase] | phase 1 ×.9 | 128 | -0.003945621 | 0.011487655 | 0.019029689 |
| [b28-sd-phase][b28-sd-phase] | phase 1 ×1.1 | 128 | -0.000866708 | 0.010442226 | 0.020017744 |
| [b28-sd-phase][b28-sd-phase] | phase 2 ×.9 | 128 | +0.006542679 | 0.009920061 | 0.026382801 |
| [b28-sd-phase][b28-sd-phase] | phase 2 ×1.1 | 384 | +0.014100087 | 0.006643500 | 0.027387088 |
| [b28-rival-phase][b28-rival-phase] | phase 1 ×.9 | 128 | -0.052012964 | 0.022605989 | -0.006800985 |
| [b28-rival-phase][b28-rival-phase] | phase 1 ×1.1 | 128 | -0.044520680 | 0.024758186 | 0.004995691 |
| [b28-rival-phase][b28-rival-phase] | phase 2 ×.9 | 128 | -0.044953246 | 0.014947992 | -0.015057263 |
| [b28-rival-phase][b28-rival-phase] | phase 2 ×1.1 | 256 | -0.008219836 | 0.011305855 | 0.014391874 |
| [b28-level-curve][b28-level-curve] | B=−5000 | 128 | +0.004745285 | 0.007800794 | 0.020346873 |
| [b28-level-curve][b28-level-curve] | B=−2500 | 128 | +0.010633143 | 0.007503429 | 0.025640002 |
| [b28-level-curve][b28-level-curve] | B=+2500 | 128 | -0.000999715 | 0.008057207 | 0.015114699 |
| [b28-level-curve][b28-level-curve] | B=+5000 | 384 | +0.010623441 | 0.006259046 | 0.023141532 |
| [b28-second-retail][b28-second-retail] | cnt=2, L=1250 | 128 | +0.011280488 | 0.008722660 | 0.028725807 |
| [b28-second-retail][b28-second-retail] | cnt=2, L=2500 | 128 | +0.007498059 | 0.010396284 | 0.028290627 |
| [b28-second-retail][b28-second-retail] | cnt=2, L=5000 | 128 | +0.002688547 | 0.013535799 | 0.029760145 |
| [b28-second-retail][b28-second-retail] | cnt=2, L=7500 | 128 | -0.000376238 | 0.013049576 | 0.025722914 |

All **13,440 arm-seed pairs** in this table were decoded and recomputed for this report. They share only **896 distinct baseline seed IDs**, so they must not be described as 13,440 independent confirmation seeds. Baseline binary64 scores agree across the nine supplied results wherever seeds overlap. Every arm first crosses its requested stop threshold at its recorded last 128-seed round. None reaches 1,024 choosing seeds, none opens 10000..12047, and none runs a fresh engine screen. The largest mean+2·SE is still below 0.03. These are stopping decisions at the specified bar; they do not prove every smaller effect is zero.

A compile detail omitted by the second root merge matters: **clip-blend-window did compile its four variants**, with **22,649 deployed bytes**, W9 **47,687 characters**, W13/W17/W25 **47,689**. W9 source SHA-256 is `86d4d57d248ed241d0d0e674a17f4d1a966ccd06a88440e3417a290f1b265373`. **split-radius also compiled** nc7/nc9: **22,461 deployed bytes**, **47,246 characters** each; source hashes are `44bd1d79befd68d3d16e6d44d5e9b522d737b8310e8954214db58289abb4a2f2` and `87eda5c2c2e032d5795abaa09cd6eba73caef72629f198d4725a6b862d2c03a3`. Neither compile establishes fees/labels, engine peak, OOG, or E for those variants. No candidate gas figure is inferred from QLX5's baseline gas. [Window compile records][b24-clip-blend-window], [split-radius compile records][b28-split-radius]

The final mechanisms were active: phase-specific SD changes affected their assigned phases; level curvature affected roughly 42% of fee evaluations; second-retail blending affected about 14.7% of callbacks. Their lack of promotion was not simply a disabled branch. Joint clip/blend/pull estimates clustered around +0.009..+0.014 rather than producing the required +0.03 replica screen. Wider split search barely changed edge, and phase-specific rival-coordinate changes were negative. [SD][b28-sd-phase], [level curve][b28-level-curve], [second retail][b28-second-retail], [rival phase][b28-rival-phase]

**(d) Idea sweep: all twenty declined promotion.** The original twenty mechanisms were tested on the older constant-K **LEAN** replica, separately added to LEAN and to AGE. Choosing was 64000..65023; the supplied idea merges report 2,048-seed results on **10000..12047**. Thus report data exist for this older idea sweep, even though the later faithful-replica c3/c4 searches never opened their report block. These are not QLX5 or engine measurements. Initial sweep selection used the earlier `mean+3·SE<0` rule; it should not be represented as compliance with the requester's later two-SE/+0.03 protocol. [Ideas 1–10][b10-merge-01], [ideas 11–20][b10-merge-02]

Every row below is `promote=false`; figures are the supplied report means (SE), rounded to six decimals where needed. “On AGE” means mechanism+AGE minus AGE, not minus QLX5. All rows have n=2,048 for each listed comparison.

| Mechanism | Δ LEAN (SE) | Increment on AGE (SE) |
|---|---|---|
| fill-size | +0.002270 (0.003436) | +0.000241 (0.003519) |
| fee-memory | −0.000630 (0.000962) | −0.000264 (0.000942) |
| silence-bound | −0.000828 (0.001924) | −0.000669 (0.001916) |
| age-fee | +0.000524 (0.002399) | −0.001480 (0.002419) |
| share-feedback | −0.001591 (0.002847) | −0.006530 (0.002804) |
| inventory | −0.008810 (0.002750) | −0.008590 (0.002400) |
| undercut | −0.004691 (0.002193) | −0.009579 (0.002208) |
| same-step | −0.014588 (0.002856) | −0.010747 (0.002724) |
| post-arb-skew | −0.022000 (0.002300) | −0.022800 (0.002400) |
| size-run | −0.049924 (0.003578) | −0.053940 (0.003716) |
| tell-coverage | +0.006329 (0.002453) | +0.004592 (0.002451) |
| lookahead | +0.003492 (0.002146) | +0.000506 (0.002289) |
| sd-extrap | −0.000105 (0.000258) | +0.000152 (0.000432) |
| endgame | +0.000359 (0.000323) | +0.000039 (0.000328) |
| drift | +0.003879 (0.002265) | −0.000171 (0.002565) |
| mixture-branch | +0.000526 (0.000736) | −0.000455 (0.000733) |
| second-order | +0.004102 (0.001829) | −0.000580 (0.001850) |
| sync-grade | +0.003221 (0.001723) | −0.003490 (0.003145) |
| side-imbalance | −0.001620 (0.002079) | −0.004244 (0.003286) |
| markout | −0.035103 (0.003312) | −0.037481 (0.003495) |

The largest on-AGE value, tell-coverage +0.004592, did not increase tell coverage; a simultaneous fee raise is an unresolved confound. Some mechanisms were already partly represented in Taylor's policy, such as silence conditioning, inventory coordinates and first/later retail phases; their tests addressed an additional variant. Several searches selected a least-negative arm after all settings stopped. None warrants a Solidity promotion, and none was rerun as an engine-certified QLX5 gain. Cost sketches in these results are estimates or isolated probes, not integrated G passes. [Full mechanisms and limitations][root-1-01]

Two final probes used the faithful replica to diagnose specific information gaps, always `advance=false`:

| Probe | Changed information | Δ QLX5 | SE | n / seeds |
|---|---|---:|---:|---|
| [split-truth][b32-split-truth] | Replace only qx with the current order's true two-pool routing decision, retaining normal offset tracking and bound logic | +0.004405971168401912 | 0.00550865041961138 | 128 / 64000..64127 |
| [arb-truth][b32-arb-truth] | Replace only first-callback posterior pi with the actual arb/retail event type | +0.010618736694635977 | 0.0071337180886503525 | 128 / 64000..64127 |

Both stopped after one round; their exact edge rows reproduce these statistics. Truth is engine-internal and is unavailable to the deployed callback. The split probe treats both routed amounts above 0.0001 as truth, even if the later normalizer fill were to fail. The arb probe leaves same-step callbacks and qx unchanged. **Neither is a rigorous upper bound on improved inference or total strategy headroom.** The second root merge's later wording that the probes “cap” headroom is too strong; the primary results explicitly disclaim that claim. Neither positive estimate has a positive lower endpoint under the simple mean−2·SE diagnostic, and the shared seed set provides no basis for adding them. [Split limitations][b32-split-truth], [arb limitations][b32-arb-truth]

The probes explain why another broad split-window/first-callback-label sweep has weak support: 409 of 462 decisive split false negatives occurred beyond the existing window; first-callback label errors totalled 273 in the arb probe's baseline trace. Those are diagnostic counts on their own paths, not independent trials or deployable truth feeds. They do not justify repeating the failed grid or the already-spent compression/refit, price-belief variants, per-run sigma/rate, exact rival carry, residual heads, or kappa lines. [Split diagnostics][b32-split-truth], [arb diagnostics][b32-arb-truth]

**Gate disposition and what is still missing.** Administrative completion of research is separate from achievement of the leaderboard goal. There is no new strategy with the required combined evidence:

| Gate / limit | Requirement | Current disposition |
|---|---|---|
| P | Kit/Taylor-reference policy checks | Reported for QLX5/AGE; no complete new c3/c4 candidate certification |
| Q | Choose 64000..65023; freeze; report 10000..12047 | AGE cancelled. All faithful-replica search settings stopped before freeze; no complete candidate report |
| T | Contract labels equal its Python reference | AGE reported zero mismatches; candidate-specific proof still needed for any changed policy |
| F | Contract/reference fees within 0.01 bps | AGE errors far below tolerance; candidate-specific check still needed |
| G | ≤50,000 source characters; ≤24,576 deployed bytes; measured engine afterSwap peak ≤245,000; 0 OOG | AGE fits observed samples. Several variants fit compiled size, but no new promoted variant has a complete gas/OOG gate |
| E | One frozen candidate, ≥1,024 fresh engine seeds, paired QLX5 and QT1, ≥+0.04 over QLX5 | No pass. AGE negative and follow-up plan incomplete; structural screens too small; c3/c4 engine stages did not run |
| Board goal | Gain sufficient to exceed the supplied 528.4152 leader | No supported improvement; supplied starting gap remains 0.0819 to a tie |

QLX5's original certificate covered P/T/F, not a new Q/G/E run. Its old 512-seed gas and later parity evidence do not create a fresh return-gate success. Preserve its source while seeking a distinct observable mechanism; this report offers no candidate justified for another automatic confirmation wave. If later work finds one, it still needs a frozen complete replica report, independent P/T/F and measured G, then a prespecified complete ≥1,024-seed fresh engine confirmation with every planned block accounted for, including negative/partial blocks. Passing +0.04 alone would still leave a material gap to #1. [Original certification][cert], [goal evidence][root-1-01]

**Seed ledger for continuation.** Every lease remains retired even when it was cancelled, unused, or stopped early. No fresh seed was consumed while writing this report. The latest goal notes reserve through 10216559; **next free start is 10217000**, not an unused tail of a prior lease.

| Retired inclusive lease | Purpose / observation |
|---|---|
| 10200000..10202047 | AGE pilot and original seven-block wide plan; pilot completed 10200000..10200255; original wide plan cancelled |
| 10202048..10202055 | AGE build gas-only; eight seeds, excluded from efficacy |
| 10203000..10207095 | 32 coarse structural engine screens, 128 seeds each |
| 10208000..10210047 | Replacement AGE wide plan; 1,024 completed pairs, all remaining tails retired |
| 10211000..10213559 | Ten c3 engine-screen leases; downstream stages cancelled |
| 10214000..10216559 | Ten c4 engine-screen leases; no accepted engine result; all leases retired |

Proof-only reuse of 9700000..9700511 and 10010512..10011023 is not fresh E. T/F seeds 74200..74249 are not E. Replica choosing/report banks have their separate roles. The unused numerical gaps between recorded leases are not being offered for reuse; use the recorded next free start. Goal notes episodes 1–4 (snapshot digest below), [completed engine blocks][root-1-01]

**Orchestration record and repository status.** The supplied `goal.json` is episode 4, records 98 of 400 goal items used, no refused decisions, and all 32 named batches settled. Its `trunk` is **null**: there is **no goal code repository or wave commit to name**. All batches are research mode; code is carried in result payloads. Upstream repositories are Taylor's [amm-sim][Taylor], the [evaluation kit at 45e7563d1a29ffca9d608fdf60c90bf2624d2d01][kit], and the [engine at 6b6921f8d463314aa7c96234e1be25a25245f704][engine]. Those upstream commits are not goal-trunk commits. Item use was not the full 400-item allowance; neither the state nor this report establishes that the whole strategy space was exhausted.

The work was divided into one assigned unit per item. The table records the evidenced scope and expected result, not verbatim complete briefs: the supplied snapshot truncates every batch brief to 500 characters, so full historic brief wording and every embedded hash cannot be independently audited from this snapshot.

| Batches | One item's piece of work | Result needed to judge that piece |
|---|---|---|
| a-build | Build the single QLX5+AGE stack and reference | Credited source/reference, hashes, rule, compile/smoke sizes and readiness |
| a-check; a-q | Independently check the stack; separately score its replica | Explicit gate outcomes and mismatch evidence; separate Q score/seed evidence |
| a-engine; a-wide; a2-age-a; a2-age-b | Evaluate one leased block of the same frozen AGE contract | Unrounded CAND/QLX5/QT1 rows, n/mean/SE, source/config, gas/OOG, stopping and lease disposition |
| b-core | Produce one independently implemented engine core | Reproducible code, stream/arithmetic checks, per-seed error and first divergence |
| b-qlx | Port LEAN/QLX5 to that core | Policy/tables, knobs, per-seed engine comparison and precise tolerance |
| b2-audit | Audit one dynamic replica and any localized defect | Unrounded parity, traces, negative controls, source identity and residual limitations |
| c-map | Map the 32 structural knobs | Exact edits/ranges and compile/size results |
| c-round1 | Test one mapped knob at LO/HI | Paired 128-seed QLX5/LO/HI engine rows/moments, source identity and peak |
| d-ideas | Test one new mechanism | Mechanism/configuration, choose/report results vs LEAN and on AGE, costs, promotion decision |
| c3-search-a/b; c4-search-a/b | Search one bounded structural family | Per-arm rounds, unrounded pairs, stop status; freeze and complete report only if a survivor exists |
| c3-build-a/b; c4-build-a/b | Port one frozen upstream setting | Credited Solidity/reference, complete source hashes, sizes and readiness |
| c3-check-a/b; c4-check-a/b | Independently certify that setting | P/Q/T/F/G evidence and a valid advancement decision |
| c3-engine-a/b; c4-engine-a/b | Screen that unchanged certified setting on one fresh lease | CAND/QLX5/QT1 pairs and moments, gas/OOG and explicit stop/advance status |
| b3-speed; b3-speed-check | Speed up one unchanged policy; independently check it | Source/build recipe, parity and timed comparisons with scope limits |
| d4-opportunity | Test one counterfactual information hook | OFF parity, paired effects/confusion counts and limitations; always advance=false |

The AGE and replica work used `after` dependencies. c3/c4 used paired search → build → check → engine chains gated on `advance=true`. Earlier AGE fields were `ready`, `gates.all` and `go`; the replacement AGE engine blocks followed the accepted check without claiming that its size-only G was independently measured gas. Linux-x64/minCpus=4 was specified for initial Solidity/engine items; after requester note 1, new engine items used minCpus=8, ≤256 seeds per item, and bounded rounds. Later wide searches used batches of at most five. These are the recorded orchestration choices, not new submissions or instructions to run another wave.

The final write-up disposition is preserved as one JSON object in the reference's decisions shape. It is embedded because this assignment authorizes **only `report.md`**, not a separate decisions file. This is the report's disposition, not a claim to recover an unavailable historical terminal decision. `finish=true` means that the available research is being written up; it does not mean #1 was achieved. No new batch brief is being issued.

```json
{
  "notes": "Credit Taylor (gtmcknight), amm-sim@4812a6382311624e1506aca131ca35c378f930d9 research/solved. Close this research write-up with no qualifying replacement and no submission. Retain unchanged QLX5. AGE failed incremental efficacy; all 34 supplied c4 settings stopped; clip-blend-pull has no result. Preserve the audited integer replica and checked Cython speedup. The leaderboard target is unachieved. All prior leases remain retired; next fresh start 10217000. Any future submission requires the requester to ask the user.",
  "spawn": [],
  "finish": true
}
```

**Source limitations and reconciliations.** Source flags mean some cited material failed the plane's reread checks; the precise failed URLs/passages were not supplied. They weaken external attribution claims and cannot be erased by a worker's assertion that it rechecked its own citations. They do not, by themselves, identify a numerical falsification in the embedded rows. The AGE check, several core/port/audit sources, all seven nonempty wide AGE blocks, all c3 searches, eight of nine supplied c4 searches and split-truth carry such flags. The independent Cython check, level-curve and arb-truth are unflagged. The [first][root-1-01] and [second][root-1-02] root merges retain the detailed flag lists.

This report corrects four overbroad readings of the second merge: oracle interventions are not headroom caps; some c4 variants were compiled; repaired-model tuning was attempted but yielded no candidate; and AGE is already retired by the engine evidence in the first merge. Its statements that report seeds were unopened and no engine seeds were run apply to its c3/c4 search/probe results, not to the older idea sweep or AGE/coarse-engine work. No absence of a result is treated as a measured zero.

**Local checks for this deliverable.** The thirteen supplied artifact digests matched their stated SHA-256 values and the JSON artifacts parsed. The archived QLX5 block decoded to exactly the pinned 47,230-byte source/hash, without changing its credit or tables. The AGE payloads were fetched from the content-addressed links in the supplied first merge, decoded as data, checked for unique seeds and a consistent candidate source, and all 1,280 completed three-arm pairs recomputed. All 34 c4 arm statistics, both oracle statistics, overlapping baseline bits and terminal stopping rounds were also recomputed. Payload checksums were checked where supplied. No artifact's embedded program was executed. These checks validate this report's extraction and arithmetic; **no Solidity compilation, engine simulation, or behavioral certification was rerun for this write-up**. Observed gas and parity remain attributed worker measurements.

The report contains its own complete baseline source and all outcome-critical figures; removed `.imd/reads` paths are not needed to read it. Linked payloads retain detailed reproducibility evidence. No dependency was installed for the write-up. No replacement strategy was deployed, and no leaderboard submission was made. **The requester must ask the user before any future submission.**

**Supplied-result register.** Each link is the result's full content-addressed SHA-256 URL, not a source-code hash. The original files below are inputs, not delivered repository files.

| Input | Original result path | SHA-256 |
|---|---|---|
| [root-1-01][root-1-01] | `artifacts/goal/roots/1/01/result.md` | `ce102c988e78bc3f3ac1354d6df136be00429cd03e3f96ea9e6e57687aaf6816` |
| [root-1-02][root-1-02] | `artifacts/goal/roots/1/02/result.md` | `f0e477c748bb8a1444b742ae929ead69a7ecb4f294dc9aac13eec2437190d343` |
| [b24-clip-blend][b24-clip-blend] | `artifacts/goal/batches/c4-search-a/items/clip-blend/result.json` | `04a1b3d4849280152e73f585c1b7856be38ea1950a38ca6555b9db1d3a3e5c61` |
| [b24-clip-pull][b24-clip-pull] | `artifacts/goal/batches/c4-search-a/items/clip-pull/result.json` | `8c7445559900d225acb0bec396fc6689bbdb741faa9ecd863b6d3ea9ea3c05b7` |
| [b24-blend-pull][b24-blend-pull] | `artifacts/goal/batches/c4-search-a/items/blend-pull/result.json` | `e8d8e960eeec965fef56a59c85d09e0405d646d0b04d3e50dd60093c520e003f` |
| [b24-clip-blend-window][b24-clip-blend-window] | `artifacts/goal/batches/c4-search-a/items/clip-blend-window/result.json` | `2c8ed35c09df0fed8ccfb15594d76c4bc0a572117ed9b523c166d2e0eb7816b0` |
| [b28-split-radius][b28-split-radius] | `artifacts/goal/batches/c4-search-b/items/split-radius/result.json` | `9b0303f9051ad723bb7dbfd5f47e05d0daf36db1b245e41a55d1ab6e7c5e188d` |
| [b28-sd-phase][b28-sd-phase] | `artifacts/goal/batches/c4-search-b/items/sd-phase/result.json` | `8674ab6a1e1555f6b603bd4e8e4eccdc9feb70ac2ca1547b17c757b777a4532a` |
| [b28-rival-phase][b28-rival-phase] | `artifacts/goal/batches/c4-search-b/items/rival-phase/result.json` | `8f337cef9787753961fa22fd6ea62d1daaf46519d0295c8d002ef8c22328772f` |
| [b28-level-curve][b28-level-curve] | `artifacts/goal/batches/c4-search-b/items/level-curve/result.json` | `0fcf6cf90af2a58c482f7f667d4c8021e607716a0e47100f839749ab0973cbb7` |
| [b28-second-retail][b28-second-retail] | `artifacts/goal/batches/c4-search-b/items/second-retail/result.json` | `10fd2ef61fc3e25ebd140b854e4badb76475f42fe5fec7cbf7278f2e41466a7a` |
| [b32-split-truth][b32-split-truth] | `artifacts/goal/batches/d4-opportunity/items/split-truth/result.json` | `9d06411b9d249e074a426b33b08474edac375f300111ace5bb34928f853531e6` |
| [b32-arb-truth][b32-arb-truth] | `artifacts/goal/batches/d4-opportunity/items/arb-truth/result.json` | `6c23d23d4a21a37a502bf47a69d9f87b4c7ac84f614f2097e2488c6d5e6dd164` |

Goal-history snapshot SHA-256: `9bc19d0da869261a48ccdaca05181ce5f02897f8135b540b0a8ea4f489e237b5`. Its notes, requester note 1, batch outcomes and `trunk:null` were read as task evidence; the snapshot itself is not delivered.

[AGE-engine]: https://api.imd.fun/artifacts/87dfbac60f00625d53477537621d5d15b2b95529011ed061eab3bb64452d677c
[Taylor]: https://github.com/gtmcknight/amm-sim/tree/4812a6382311624e1506aca131ca35c378f930d9/research/solved
[b01-qa]: https://api.imd.fun/artifacts/5ea62c673b4209edeb110939538195fafd35943b6796a659f5ffb57683cc8eec
[b02-qa]: https://api.imd.fun/artifacts/dcda482dfdc67a08edbd81196d26cff298d5a34e18483fa7dd4ce356662baed0
[b04-qa]: https://api.imd.fun/artifacts/d86d42204cc75a022d939e17fd8dfb35d2a716fea35b896a71e79f3287f1b9f9
[b07-r3]: https://api.imd.fun/artifacts/60dc237fa0a4d42f3b6e2d2bed61c1a2df08d27c31ccd95cce508ee9c8689de4
[b08-map]: https://api.imd.fun/artifacts/f921f2133d55d8ce81b5d809494003e898fc2a72d1fe47cdc34606ff269d676e
[b09-merge-01]: https://api.imd.fun/artifacts/7e4de1eb8bb3c9a765b69dfcfef48fb733f991f22ef2c1eeabb531cf7a6b3059
[b09-merge-02]: https://api.imd.fun/artifacts/314ef0c35e184deecd663bbeac5464776fe56aa200c5bc663cd896e1673dbab8
[b10-merge-01]: https://api.imd.fun/artifacts/11370d30d60924389d256b8f912ddaabd471a5b47b24c6e066394f1a4bc8998b
[b10-merge-02]: https://api.imd.fun/artifacts/10baa5ddac1390f4d516d601c707adce24d5e67416c8f4acb5f0dc1777bc49d8
[b11-s1]: https://api.imd.fun/artifacts/b8f2b229f15d55d7be109b329aa10b3fbecc52e3ef7e0b89d5d4f790d6f877d0
[b11-s2]: https://api.imd.fun/artifacts/9a65b24d78ea78874cd967955b882f8dd5aaae093b3872f887e060205560294b
[b11-s3]: https://api.imd.fun/artifacts/a448e15cdedc7c93ccb621ce7210c21c486129208097e10ed303bf268fe08909
[b11-s4]: https://api.imd.fun/artifacts/32a751ea60a0e329bc9b5f9b20b9580ba26b16603c573390c67f978a07377fd6
[b12-s5]: https://api.imd.fun/artifacts/6658ece654095a55edd7f4e5262185c86005f7f3ab820463be10c847fa47b08e
[b12-s6]: https://api.imd.fun/artifacts/6901af970cb651a9ba754b4a995990ef5e6bb1a4fe0dc6ce22b806d3a98ac633
[b12-s7]: https://api.imd.fun/artifacts/56f8992531f9e64cae6b1e74a163a0ee07653ff64ffcd8501500c61b5ecec8ab
[b12-s8]: https://api.imd.fun/artifacts/3f17310b2240f2a0677865c59a59cf5e25deee9e6d084adaaddaf6b7dbae12db
[b13-r3]: https://api.imd.fun/artifacts/362fb97f041087bf3548c302af4c0f82d2537d6a6c0157a95ac06d0cb70a5ce4
[b24-blend-pull]: https://api.imd.fun/artifacts/e8d8e960eeec965fef56a59c85d09e0405d646d0b04d3e50dd60093c520e003f
[b24-clip-blend]: https://api.imd.fun/artifacts/04a1b3d4849280152e73f585c1b7856be38ea1950a38ca6555b9db1d3a3e5c61
[b24-clip-blend-window]: https://api.imd.fun/artifacts/2c8ed35c09df0fed8ccfb15594d76c4bc0a572117ed9b523c166d2e0eb7816b0
[b24-clip-pull]: https://api.imd.fun/artifacts/8c7445559900d225acb0bec396fc6689bbdb741faa9ecd863b6d3ea9ea3c05b7
[b28-level-curve]: https://api.imd.fun/artifacts/0fcf6cf90af2a58c482f7f667d4c8021e607716a0e47100f839749ab0973cbb7
[b28-rival-phase]: https://api.imd.fun/artifacts/8f337cef9787753961fa22fd6ea62d1daaf46519d0295c8d002ef8c22328772f
[b28-sd-phase]: https://api.imd.fun/artifacts/8674ab6a1e1555f6b603bd4e8e4eccdc9feb70ac2ca1547b17c757b777a4532a
[b28-second-retail]: https://api.imd.fun/artifacts/10fd2ef61fc3e25ebd140b854e4badb76475f42fe5fec7cbf7278f2e41466a7a
[b28-split-radius]: https://api.imd.fun/artifacts/9b0303f9051ad723bb7dbfd5f47e05d0daf36db1b245e41a55d1ab6e7c5e188d
[b32-arb-truth]: https://api.imd.fun/artifacts/6c23d23d4a21a37a502bf47a69d9f87b4c7ac84f614f2097e2488c6d5e6dd164
[b32-split-truth]: https://api.imd.fun/artifacts/9d06411b9d249e074a426b33b08474edac375f300111ace5bb34928f853531e6
[base]: https://api.imd.fun/artifacts/1ef80bfb6d6791b877b1f4048a5e63cf2ae54153e6e8763ae3f8ab13132dfb15
[cert]: https://api.imd.fun/artifacts/d73c1749574cce67042552e9278be2ba20c8fedf9720bdee71c27d4019f21f02
[engine]: https://github.com/benedictbrady/amm-challenge/tree/6b6921f8d463314aa7c96234e1be25a25245f704
[kit]: https://github.com/identity-md-launches/goal-3178-build-shared-evaluation-kit/tree/45e7563d1a29ffca9d608fdf60c90bf2624d2d01
[root-1-01]: https://api.imd.fun/artifacts/ce102c988e78bc3f3ac1354d6df136be00429cd03e3f96ea9e6e57687aaf6816
[root-1-02]: https://api.imd.fun/artifacts/f0e477c748bb8a1444b742ae929ead69a7ecb4f294dc9aac13eec2437190d343
[speed-build]: https://api.imd.fun/artifacts/8d5400696659b56bc12eeffc34dec5e58c5c119ddddaca681792db59586dd760
[speed-check]: https://api.imd.fun/artifacts/72b58a1407966f0223f06ab7c6ddd979a24fb4593f1a9b3dc43508a7f133d00b