Failed on the agent's machine.

Refused by Codex's safety filter

• mediumAnti-snipe donation is paid to post-swap in-range liquidity, so just-in-time liquidity captures ~99% of it instead of the launch positionsrc/SIMDTESTHook.sol:120

  Merged from audit_flow, audit_permissions and audit_economics (same root cause). afterSwap hands the anti-snipe portion to PoolManager.donate, which credits feeGrowthGlobal pro rata to state.liquidity at the post-swap tick. The hook enables no add/remove-liquidity callback (getHookPermissions, lines 59-65), so liquidity provision is unrestricted during the 10-block window.

  A searcher can wrap any early buyer's swap in the same unlock (or bundle) with a narrow position whose liquidity dwarfs the launch seed, and receives the donation in proportion L_jit/(L_jit+L_seed). Measured on this code with 100x the seed liquidity on [-60,60]: of a 30 IMD donation plus 0.869 IMD base LP fee, the JIT position collected 30.563 IMD and the launch seed position 0.306 IMD (1%).

  The honest buyer pays exactly the same as without the attack and the treasury still receives 0.5 IMD, so the party harmed is the owner of the launch's 80% pool position, which the brief says the donation is meant to benefit.

  Calibration note: audit_flow's claim that the sniper lowers their own effective anti-snipe cost to ~3% does not hold. When the sniper is also the JIT LP, 90% of their buy fills against their own position (a wash); measured net result for a 9x JIT and a 100 IMD gross buy: 6.863 tokens acquired for 10.45 IMD, versus 6.863 tokens for 10.00 IMD with a plain 10 IMD buy.

  The deterrent against the buyer therefore stands; what fails is the brief's guarantee that the fee flows to the pool's liquidity. The README acknowledges JIT capture in one sentence, but the brief and launch.json notes do not, and the brief lists 'proper donation of anti-snipe fees back into liquidity' as a property tests must validate.

  Fix requires a scope decision by the author: (a) enable beforeAddLiquidity (hook flags become 0x28cc; manifest permissions must be updated) and revert additions while antiSnipeBps() != 0 unless sender is the launch factory, which keeps the donate-to-LP economics; or (b) route the anti-snipe amount elsewhere (treasury via take, or accumulate and donate after B+10).

  whole finding

  State: local real v4 PoolManager; SIMDTEST and a mock at the IMD address; hook mined to flags 0x20cc; pool initialized at sqrtPrice 2^96 (tick 0) in block B by the deployer; seed position liquidity 1e24 on [-600,600] salt 0; block B so hook.antiSnipeBps()==3000.

  One PoolManager.unlock by the searcher: (1) modifyLiquidity(key,{tickLower:-60,tickUpper:60,liquidityDelta:+100e24,salt:1}); (2) swap(key,{zeroForOne:(IMD is currency0),amountSpecified:-100e18,sqrtPriceLimitX96:MIN+1 or MAX-1}) (any buyer's exact-input buy of 100 IMD); (3) modifyLiquidity(key,{...,liquidityDelta:-100e24,salt:1}) and settle.

  Then the seed owner calls modifyLiquidity(liquidityDelta 0) on [-600,600].

  Expected per brief: the 30e18 IMD anti-snipe fee accrues to the launch pool's seeded liquidity.

  Actual: SwapFees(100e18, 30e18, 0.5e18) emitted, treasury +0.5e18, feesAccrued returned by step (3) = 30563118811881188118 wei IMD to the JIT position, and the seed position's feesAccrued = 305631188118811881 wei IMD.

  Reproduced by test/scratch/Review.t.sol testJitLiquidityCapturesDonationFromAnotherBuyer; the sniper-self-help counter-measurement is testJitSniperNetPosition in the same file.

  whole reproduction

• lowInitialization gate is bound to the constructor's direct caller, so a CREATE2 helper or periphery initializer in the factory path makes the pool impossible to opensrc/SIMDTESTHook.sol:50

  Merged from audit_flow and audit_permissions (same root cause). beforeInitialize (line 70: if (sender != launchFactory) revert NotLaunchFactory();) accepts only the address that executed the hook's CREATE2, and v4 passes the direct caller of PoolManager.initialize as sender. The manifest's deployer-resolved "$factory" argument exists for exactly this binding but launch.json constructorArgs are only ["$poolManager","$token"].

  If the launch factory creates the hook through any CREATE2 helper (deterministic-deployment proxy, internal deployer) launchFactory becomes the helper, and if it opens the pool through a periphery contract sender is the periphery; in both shapes every initialize attempt reverts and the hook has no second initialization path. The README documents the direct-call constraint, but the factory's internals are not in this repository and cannot be verified here.

  Impact is limited to liveness: the launch transaction reverts (if atomic) or the hook must be redeployed with a new salt; no funds are at risk, hence low rather than the medium audit_permissions assigned.

  Fix: take address factory as a third constructor argument, write constructorArgs as ["$poolManager","$token","$factory"], bind launchFactory to it, and state in the manifest notes whether the factory calls PoolManager.initialize directly.

  whole finding

  State: SIMDTEST deployed; local real PoolManager; the test contract plays the launch factory F.

  Case A: F deploys Create2Helper; mines a salt so create2(helper, salt, creationCode ++ abi.encode(manager, token)) has flag bits 0x20cc; helper.deploy(code, salt) gives hook.launchFactory() == address(helper).

  F calls PoolManager.initialize(key{token/IMD sorted, fee 12500, tickSpacing 60, hooks: hook}, 2^96).

  Expected: pool opens, initialized()==true.

  Actual: revert (HookCallFailed wrapping NotLaunchFactory), initialized() stays false, and nothing can ever initialize it because the helper never calls initialize.

  Case B: F deploys the hook directly (launchFactory()==F) and calls periphery.initializePool(manager, key, 2^96).

  Expected: pool opens.

  Actual: revert NotLaunchFactory because sender == periphery.

  Both cases reproduced: the attached proof (the specialist's test) fails on this code with 'factory could not initialize the launch pool: hook bound to the CREATE2 helper' and 'factory could not initialize through a periphery initializer'.

  whole reproduction
  proof · a Foundry test the fix has to pass

  // SPDX-License-Identifier: MIT
  pragma solidity 0.8.26;
  
  import {SIMDTEST} from "src/SIMDTEST.sol";
  import {SIMDTESTHook} from "src/SIMDTESTHook.sol";
  import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
  import {IHooks} from "@uniswap/v4-core/src/interfaces/IHooks.sol";
  import {Currency} from "@uniswap/v4-core/src/types/Currency.sol";
  import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
  
  interface Vm {
      function getCode(string calldata artifact) external returns (bytes memory);
      function etch(address target, bytes calldata code) external;
  }
  
  contract PairedStandIn {
      mapping(address => uint256) public balanceOf;
  }
  
  /// @dev A generic CREATE2 deployer such as the canonical deterministic-deployment proxy
  ///      (0x4e59b44847b379578588920cA78FbF26c0B4956C) or any factory-internal helper.
  contract Create2Deployer {
      function deploy(bytes memory initCode, bytes32 salt) external returns (address deployed) {
          assembly ("memory-safe") {
              deployed := create2(0, add(initCode, 32), mload(initCode), salt)
          }
          require(deployed != address(0), "create2 failed");
      }
  }
  
  /// @dev A periphery initializer (PositionManager.initializePool, a multicall router, etc.)
  contract PoolInitializer {
      function initializePool(IPoolManager manager, PoolKey memory key, uint160 price) external {
          manager.initialize(key, price);
      }
  }
  
  /// @title The initialization gate is the constructor's msg.sender, not the launch factory.
  /// @notice Fails on the current code: when the hook is created through a CREATE2 helper the
  ///         factory (this contract) can never initialize the pool, and when the hook is created
  ///         directly but initialized through a periphery contract the same lockout occurs.
  ///         Passes once the factory address is an explicit, deployer-resolved constructor
  ///         argument ("$factory") or the gate no longer depends on the direct caller.
  contract FactoryGateViaIntermediaryTest {
      Vm internal constant vm = Vm(address(uint160(uint256(keccak256("hevm cheat code")))));
      address internal constant PAIR = 0xD34a99Bc0f67aE1bbd63C660e6d0b0dd03E263B7;
      uint160 internal constant INITIAL_PRICE = 79228162514264337593543950336;
  
      IPoolManager internal manager;
      SIMDTEST internal token;
  
      function setUp() public {
          token = new SIMDTEST();
          vm.etch(PAIR, address(new PairedStandIn()).code);
          bytes memory code = abi.encodePacked(vm.getCode("PoolManager.sol:PoolManager"), abi.encode(address(this)));
          address deployed;
          assembly ("memory-safe") {
              deployed := create(0, add(code, 32), mload(code))
          }
          require(deployed != address(0), "manager deployment failed");
          manager = IPoolManager(deployed);
      }
  
      function _key(SIMDTESTHook hook) internal view returns (PoolKey memory) {
          return PoolKey({
              currency0: Currency.wrap(address(token) < PAIR ? address(token) : PAIR),
              currency1: Currency.wrap(address(token) < PAIR ? PAIR : address(token)),
              fee: 12500,
              tickSpacing: 60,
              hooks: IHooks(address(hook))
          });
      }
  
      function _mine(address deployer, bytes memory initCode) internal view returns (bytes32 salt) {
          bytes32 codeHash = keccak256(initCode);
          for (uint256 i;; ++i) {
              address predicted =
                  address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), deployer, bytes32(i), codeHash)))));
              if (uint160(predicted) & 0x3fff == 0x20cc && predicted.code.length == 0) return bytes32(i);
          }
      }
  
      function testFactoryCannotInitializeWhenHookIsCreatedThroughHelper() public {
          Create2Deployer helper = new Create2Deployer();
          bytes memory initCode =
              abi.encodePacked(vm.getCode("SIMDTESTHook.sol:SIMDTESTHook"), abi.encode(manager, address(token)));
          SIMDTESTHook hook = SIMDTESTHook(helper.deploy(initCode, _mine(address(helper), initCode)));
          require(hook.launchFactory() == address(helper), "gate bound to the helper, not the factory");
  
          // The launch factory (this contract) initializes its pool: refused.
          (bool ok,) = address(manager).call(abi.encodeCall(IPoolManager.initialize, (_key(hook), INITIAL_PRICE)));
          require(ok, "factory could not initialize the launch pool: hook bound to the CREATE2 helper");
          require(hook.initialized(), "pool not opened");
      }
  
      function testFactoryCannotInitializeThroughPeriphery() public {
          bytes memory initCode =
              abi.encodePacked(vm.getCode("SIMDTESTHook.sol:SIMDTESTHook"), abi.encode(manager, address(token)));
          bytes32 salt = _mine(address(this), initCode);
          address deployed;
          assembly ("memory-safe") {
              deployed := create2(0, add(initCode, 32), mload(initCode), salt)
          }
          SIMDTESTHook hook = SIMDTESTHook(deployed);
          require(hook.launchFactory() == address(this), "direct deployment");
  
          PoolInitializer periphery = new PoolInitializer();
          (bool ok,) =
              address(periphery).call(abi.encodeCall(PoolInitializer.initializePool, (manager, _key(hook), INITIAL_PRICE)));
          require(ok, "factory could not initialize through a periphery initializer");
          require(hook.initialized(), "pool not opened");
      }
  }

  whole proof

• lowDuring the anti-snipe window any swap that empties the active range reverts, including token-specified partial fills the hook otherwise supportssrc/SIMDTESTHook.sol:119

  From audit_flow. afterSwap donates unconditionally whenever donation != 0. Pool.donate (lib/v4-core/src/libraries/Pool.sol:475) reverts NoLiquidityToReceiveFees when state.liquidity == 0 after the swap, and the revert propagates through the hook call and undoes the whole swap.

  Token-specified swaps (exact-input sell, exact-output buy) are designed to allow partial fills (README 'Routing limits'), but exactly the partial fills that drain the active range are the ones that end with zero liquidity, so for blocks B..B+9 they always revert while at B+10 the identical swap succeeds with a partial fill. Reachable with a concentrated seed range and early demand exceeding it, or a swarm holder selling through the lower bound.

  Liveness only and bounded (retry smaller; no fee charged on the failed swap), and the README documents the constraint, hence low.

  Fix options: when post-swap liquidity is zero (StateLibrary.getLiquidity via extsload) route the anti-snipe amount to TREASURY with take() instead of donating, or have the factory seed a range wide enough for expected early volume and keep the documented behavior.

  whole finding

  State: pool initialized in block B with liquidity 1e24 on [-600,600] at tick 0.

  Call: exact-input sell of 1e24 SIMDTEST (amountSpecified=-1e24, zeroForOne toward IMD, limit MIN+1/MAX-1), which drains the range.

  At block B+9 (antiSnipeBps()==300): unlock -> swap reverts (NoLiquidityToReceiveFees bubbled from donate), no state change.

  At block B+10 (antiSnipeBps()==0): the same call succeeds with a partial fill (token delta strictly between -1e24 and 0) and getLiquidity()==0 afterwards.

  Expected: a token-specified swap that is partially fillable at B+10 is partially fillable at B+9 with fees on the realized IMD.

  Reproduced by test/scratch/Review.t.sol testRangeDrainingSellRevertsInWindowButNotAfter and the existing test/SIMDTESTHook.t.sol testDonationRequiresInRangeLiquidity.

  whole reproduction

• lowTreasury fee is taken from PoolManager reserves before the buyer settles, so a buy reverts whenever the singleton holds less IMD than 0.5% of the grosssrc/SIMDTESTHook.sol:123

  From audit_economics. PoolManager.take performs an immediate ERC-20 transfer of IMD from the PoolManager to the treasury inside afterSwap. On a buy the buyer settles only after swap() returns, so the transfer can only be funded by IMD the singleton already holds (this pool's IMD seed plus every other IMD pool and ERC-6909 claim).

  If that balance is below treasuryFee, the transfer fails and the whole swap reverts although the swap itself was executable.

  Concrete trigger: a pool seeded token-only (price at the edge of the seed range) on a PoolManager with no IMD cannot process any buy.

  Mitigating facts: the brief says the seed is paired with IMD, and on 2026-10-08 (block 26144975) the mainnet PoolManager 0x000000000004444c5dc75cB358380D2e3dE08A90 held 211,133 IMD, so a failing buy today would need gross above ~42M IMD plus 200x the pool's own IMD reserve; realistic trades are unaffected. Reported as low because the hook's liveness depends on external singleton balances and on the factory actually seeding IMD, neither of which the hook checks.

  Minimal fix: pay the treasury with poolManager.mint of ERC-6909 claims (claimable by the treasury) or document that the factory must seed IMD.

  whole finding

  State: local real PoolManager; pool initialized at tick 0; one token-only position of liquidity 1e24 on the side a buy moves into (ticks [60,6000] when SIMDTEST is currency0, [-6000,-60] when IMD is currency0); pair.balanceOf(manager)==0.

  Call: unlock -> swap(buy, amountSpecified=-1000e18 IMD) with settlement after swap.

  Expected: swap executes, buyer pays 1000e18 IMD, treasury receives 5e18.

  Actual: afterSwap -> take(IMD, TREASURY, 5e18) -> IMD transfer fails (Wrap__ERC20TransferFailed 0x90bfb865 wrapping the token's revert) and the whole swap reverts; still reverts at B+10.

  After minting 5e18 IMD to the manager (standing in for other pools' reserves) the identical buy succeeds.

  Reproduced by test/scratch/Review.t.sol testBuyRevertsWhenManagerHoldsNoImd.

  whole reproduction

• infoDonation raises claimable LP fee growth, not pool liquidity; brief wording 'increasing pool liquidity' is not what donate does and proceeds depend on the seed owner collectingsrc/SIMDTESTHook.sol:118

  From audit_economics; kept as an informational specification mismatch rather than a code defect, because the brief explicitly asks for PoolManager.donate and the code does that. PoolManager.donate only adds to feeGrowthGlobal{0,1}X128; state.liquidity and every position's liquidity are unchanged, so depth for later buyers does not improve and the IMD sits in the PoolManager as fees owed to positions in range at that instant.

  Those fees become real value only when the position owner calls modifyLiquidity on that position. If the launch's 80% pool position is held by a locker or factory contract with no collect path, every anti-snipe donation is stranded in the PoolManager. The README states 'increases claimable LP fees, not liquidity units L', which contradicts the brief's 'increasing pool liquidity'.

  The requester should either accept fee-growth semantics in the brief and confirm the seed position owner can collect, or change the design (a hook cannot compound into a position it does not control).

  whole finding

  State: pool at tick 0, liquidity 1e24 on [-600,600], block B.

  Before: getLiquidity(poolId)==1e24, IMD feeGrowthGlobal==0.

  Call: exact-input buy of 100e18 IMD.

  After: getLiquidity(poolId) is still exactly 1e24 (the existing suite asserts this at test/helpers/V4Fixture.sol:216), IMD feeGrowthGlobal increased by >= 30e18 * 2^128 / 1e24, and the PoolManager's IMD balance rose by the 30e18 donation, withdrawable only by owners of positions in range at that moment.

  Expected per brief wording: pool liquidity increases by the donated IMD.

  Actual: liquidity unchanged; value is a pending fee claim.

  Reproduced by test/scratch/Review.t.sol testDonationDoesNotChangeLiquidityUnits.

  whole reproduction

Failed on the agent's machine.

• mediumTreasury fee is taken from the PoolManager's physical IMD balance in afterSwap, so buys revert whenever the manager holds less IMD than 0.5% of the buysrc/SIMDTESTHook.sol:154

  afterSwap calls poolManager.take(PAIRED_CURRENCY, TREASURY, treasuryFee) while the swap is still being accounted. take performs a real ERC-20 transfer out of the PoolManager, but the buyer only settles its IMD after swap() returns, which is the order every v4 router uses. The transfer therefore needs the manager to already hold at least treasuryFee of IMD from other sources: the pool's own IMD reserve, uncollected IMD fees of positions, or IMD belonging to other pools.

  Once sellers push the price to the lower edge of the launch range the pool's IMD reserve is zero, and as soon as the launch position collects its accrued fees the manager's IMD balance is dust. From then on every buy whose 0.5% fee exceeds that dust reverts inside the paired token's transfer (arithmetic underflow, wrapped by v4 as HookCallFailed): the pool cannot be bought at all until some LP deposits IMD.

  The brief requires the 0.5% fee to be taken on every swap and sent to the treasury, not for swaps to fail. On mainnet the shared PoolManager's IMD from other pools masks this until that balance is also low, which is exactly the thin-liquidity condition a launch is in. The anti-snipe donation is unaffected because donate is accounting only.

  Candidate fixes: credit the treasury with ERC-6909 claims via poolManager.mint instead of take so no physical balance is needed, or keep the fee as a positive hook delta and transfer it outside the swap.

  whole finding

  Initialize the pool at price 1 with 1e24 liquidity in [-600, 600]; roll to openingBlock + 10; sell 1e24 launch tokens exact-input (the partial fill empties the range, manager liquidity is 0); collect the launch position's fees with a zero-delta modifyLiquidity.

  Manager IMD balance is now 1 wei.

  Buy with 10400 wei of IMD exact-input.

  Expected: the swap executes and the treasury receives 52 wei.

  Actual: unlock reverts with WrappedError(hook, afterSwap, WrappedError(IMD, transfer, Panic(0x11), ERC20TransferFailed), HookCallFailed).

  Run: forge test --match-path test/scratch/TreasuryTakeStarvation.t.sol

  whole reproduction
  proof · a Foundry test the fix has to pass

  // SPDX-License-Identifier: MIT
  pragma solidity 0.8.26;
  
  import {SIMDTEST} from "src/SIMDTEST.sol";
  import {SIMDTESTHook} from "src/SIMDTESTHook.sol";
  import {PoolManager} from "@uniswap/v4-core/src/PoolManager.sol";
  import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
  import {IHooks} from "@uniswap/v4-core/src/interfaces/IHooks.sol";
  import {IUnlockCallback} from "@uniswap/v4-core/src/interfaces/callback/IUnlockCallback.sol";
  import {Currency} from "@uniswap/v4-core/src/types/Currency.sol";
  import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
  import {PoolIdLibrary} from "@uniswap/v4-core/src/types/PoolId.sol";
  import {BalanceDelta, BalanceDeltaLibrary} from "@uniswap/v4-core/src/types/BalanceDelta.sol";
  import {StateLibrary} from "@uniswap/v4-core/src/libraries/StateLibrary.sol";
  import {TickMath} from "@uniswap/v4-core/src/libraries/TickMath.sol";
  
  interface ProofVm {
      function etch(address target, bytes calldata code) external;
      function roll(uint256 newHeight) external;
  }
  
  /// @dev Minimal ERC-20 stand-in installed at the IMD address. Plain balances, no hooks.
  contract ProofPairedToken {
      mapping(address => uint256) public balanceOf;
      uint256 public totalSupply;
  
      function mint(address to, uint256 amount) external {
          balanceOf[to] += amount;
          totalSupply += amount;
      }
  
      function transfer(address to, uint256 amount) external returns (bool) {
          balanceOf[msg.sender] -= amount;
          balanceOf[to] += amount;
          return true;
      }
  }
  
  /// @title A buy whose 0.5% treasury fee exceeds the IMD the PoolManager physically holds reverts.
  /// @dev Expected per the brief: every swap pays 0.5% of the paired amount to the treasury and
  ///      otherwise executes. Actual: afterSwap calls PoolManager.take for the treasury fee before
  ///      the swapper has settled, so when the manager's IMD balance is below the fee the
  ///      paired-token transfer underflows and the whole swap reverts. The pool is then unbuyable
  ///      above a size that shrinks with the manager's IMD balance until someone deposits IMD.
  contract TreasuryTakeStarvationTest is IUnlockCallback {
      using BalanceDeltaLibrary for BalanceDelta;
      using PoolIdLibrary for PoolKey;
      using StateLibrary for IPoolManager;
  
      ProofVm private constant vm = ProofVm(address(uint160(uint256(keccak256("hevm cheat code")))));
      address private constant PAIR = 0xD34a99Bc0f67aE1bbd63C660e6d0b0dd03E263B7;
      address private constant TREASURY = 0x3dD5F73dD1A4E62630fAd3909673F130aD429985;
      uint160 private constant PRICE = 79228162514264337593543950336;
      uint160 private constant FLAGS = 0x28cc;
  
      IPoolManager private manager;
      SIMDTEST private token;
      ProofPairedToken private pair;
      SIMDTESTHook private hook;
      PoolKey private key;
  
      function setUp() public {
          token = new SIMDTEST();
          vm.etch(PAIR, address(new ProofPairedToken()).code);
          pair = ProofPairedToken(PAIR);
          pair.mint(address(this), 1e27);
          manager = IPoolManager(address(new PoolManager(address(this))));
          bytes memory code =
              abi.encodePacked(type(SIMDTESTHook).creationCode, abi.encode(manager, address(token), address(this)));
          bytes32 codeHash = keccak256(code);
          for (uint256 nonce;; ++nonce) {
              bytes32 salt = bytes32(nonce);
              address predicted =
                  address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), salt, codeHash)))));
              if (uint160(predicted) & 0x3fff == FLAGS) {
                  hook = new SIMDTESTHook{salt: salt}(manager, address(token), address(this));
                  break;
              }
          }
          key = PoolKey({
              currency0: Currency.wrap(address(token) < PAIR ? address(token) : PAIR),
              currency1: Currency.wrap(address(token) < PAIR ? PAIR : address(token)),
              fee: 12500,
              tickSpacing: 60,
              hooks: IHooks(address(hook))
          });
          manager.initialize(key, PRICE);
          manager.unlock(abi.encode(uint8(1), abi.encode(int256(1e24))));
      }
  
      function testBuyRevertsWhenManagerHoldsLessImdThanTreasuryFee() public {
          // Past the anti-snipe window: only the fixed 0.5% treasury fee applies.
          vm.roll(hook.openingBlock() + 10);
          // Sellers push the price to the bottom of the launch range, taking every IMD out of the pool.
          manager.unlock(abi.encode(uint8(0), abi.encode(_params(false, true, 1e24))));
          require(manager.getLiquidity(key.toId()) == 0, "range not drained");
          // Factory collects its accrued fees; nothing else leaves IMD in the manager.
          manager.unlock(abi.encode(uint8(1), abi.encode(int256(0))));
          uint256 held = pair.balanceOf(address(manager));
          // A buy of IMD whose 0.5% fee exceeds what the manager holds. The buyer has the funds and
          // settles after the swap, as every v4 router does.
          uint256 amount = (held + 1) * 10000 / 50 + 10000;
          uint256 treasuryBefore = pair.balanceOf(TREASURY);
          (bool ok, bytes memory reason) =
              address(manager).call(abi.encodeCall(IPoolManager.unlock, (abi.encode(uint8(0), abi.encode(_params(true, true, amount))))));
          // Expected per the brief: the buy executes and the treasury receives exactly 0.5%.
          require(ok, string(abi.encodePacked("buy reverted; manager IMD was ", _u(held), " wei; reason length ", _u(reason.length))));
          require(pair.balanceOf(TREASURY) - treasuryBefore == amount * 50 / 10000, "treasury fee");
      }
  
      function _params(bool buy, bool exactInput, uint256 amount) private view returns (IPoolManager.SwapParams memory) {
          bool pairIs0 = Currency.unwrap(key.currency0) == PAIR;
          bool zeroForOne = buy == pairIs0;
          return IPoolManager.SwapParams({
              zeroForOne: zeroForOne,
              amountSpecified: exactInput ? -int256(amount) : int256(amount),
              sqrtPriceLimitX96: zeroForOne ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1
          });
      }
  
      function unlockCallback(bytes calldata data) external returns (bytes memory) {
          require(msg.sender == address(manager), "manager only");
          (uint8 action, bytes memory payload) = abi.decode(data, (uint8, bytes));
          BalanceDelta delta;
          if (action == 0) {
              delta = manager.swap(key, abi.decode(payload, (IPoolManager.SwapParams)), "");
          } else {
              (delta,) = manager.modifyLiquidity(
                  key,
                  IPoolManager.ModifyLiquidityParams({
                      tickLower: -600, tickUpper: 600, liquidityDelta: abi.decode(payload, (int256)), salt: bytes32(0)
                  }),
                  ""
              );
          }
          _settle(key.currency0, delta.amount0());
          _settle(key.currency1, delta.amount1());
          return abi.encode(delta);
      }
  
      function _settle(Currency currency, int128 amount) private {
          if (amount < 0) {
              manager.sync(currency);
              require(ProofPairedToken(Currency.unwrap(currency)).transfer(address(manager), uint256(-int256(amount))));
              manager.settle();
          } else if (amount > 0) {
              manager.take(currency, address(this), uint256(uint128(amount)));
          }
      }
  
      function _u(uint256 value) private pure returns (string memory) {
          if (value == 0) return "0";
          bytes memory buffer;
          while (value != 0) {
              buffer = abi.encodePacked(bytes1(uint8(48 + value % 10)), buffer);
              value /= 10;
          }
          return string(buffer);
      }
  }

  whole proof

Failed on the agent's machine.