I found two medium-severity defects and nothing critical or high. Both are in .imd-findings.json, and both quoted snippets match the tree at the stated lines. I changed no files.

Findings

1. Medium: launch.json is still the old Sepolia manifest (launch.json:4).

   • What it says: it names UnlkHook paired with native ETH, lists 8 permissions (flags 0x3fc0), and its notes give the old schedule with the full bypass at $5M.
   • What the brief needs: an UNLK/IMD launch with the 0.75% IMD treasury fee and a $50M bypass. Only src/mainnet/UnlkImdHook.sol implements that, and it needs ten permissions (flags 0x3fcc, both return-delta flags).
   • Why it matters: if this manifest is deployed on chainId 1, UnlkHook._verifyServices skips every factory, PoolManager, fees and registry pin, because it returns early on any chain other than Sepolia (src/UnlkHook.sol:270). The launch would get the wrong pair, no IMD treasury fee and the wrong gates.
   • Fix: regenerate the manifest for UnlkImdHook, paired with IMD 0xd34a99bc0f67ae1bbd63c660e6d0b0dd03e263b7, with the ten permissions and the same four constructor words.

2. Medium: a Uniswap protocol fee would halt the official pool indefinitely (src/mainnet/UnlkImdHook.sol:399).

   • The trigger: beforeSwap reverts every swap when the pool's protocolFee != 0, and UnlkImdOracle.fdvUsd (:102) reverts on the same condition. The v4 protocol fee controller can set that fee on any pool. On mainnet it is set: protocolFeeController() returns 0x89A5D5bF00a27D55c02951E49078a5C5771051dB (read from a public RPC today).
   • The effect: while the fee is nonzero, all trading and all gate progress stop. The seed principal also stays locked, because liquidity can never be removed. That gives a third party a pause switch, which the brief rules out, and the accepted risks don't cover it.
   • No proof test: a self-contained one needs the mainnet pins and a fork, which aren't allowed. A proof is only required for critical and high findings.

Contracts read

• The mainnet launch path, all of it: UnlkImdHook, ImdSpotUsdSource, ImdSpotMath, UnlkImdOracle, ImdFeeVault, ImdSetupVerifier, ImdSeedDepth, ImdReviewedCode, MainnetPins, WalletExecutor, UnlkToken, MerkleClaimEvidence, SuccessorFeeMath, NativeFeeMath, interfaces/IIntegration.sol and script/mainnet/PrepareImdLaunch.s.sol.
• Partly: src/UnlkHook.sol, only far enough to see what the manifest would deploy.
• Not reviewed in my time budget: UnlkSwapRouter, HookDeployer, HookFlags, src/candidate/*, src/successor/UnlkHookV3, and the historical price sources (ImdSampledUsdSource, ImdV4UsdSource, ImdUsdSource, StateProof, BlockState). The hook refuses those price sources' code, so none of them is the reference that gets admitted.

Checks run

• Build: forge build succeeds. UnlkImdHook runtime is 20,984 bytes, under the 24,576-byte limit.
• Pinned code hashes: all six (token, evidence, oracle, vault, verifier, price source) match the freshly built creation code.
• IMD/ETH pool id: the hard-coded POOL_ID matches the hash of its PoolKey (native ETH, IMD, 10000, 200, no hooks), checked with cast.
• Live chain: all nine pinned mainnet code hashes (factory, PoolManager, Universal Router, Quoter, Permit2, IMD, Chainlink ETH/USD, fees, registry) match the current chain. Chainlink's latest round was fresh.
• Tests: forge test --match-path 'test/mainnet/*' gave 134 passed, 0 failed, 0 skipped in 22 suites. I did not run the full suite or any fork test.

Checked and found sound

• The fee math in all four swap modes.
• The full-fill check.
• Buy and sell classification for both token orders.
• Swap sender checks (Universal Router and Quoter) and the initiator ledger.
• The quota formula and the brief's 1000 / 200 / +100 example.
• Same-block buy credit not being spendable until the next block.
• The 16-

Implemented both audit fixes, corrected the mainnet manifest and added verified owner-transaction preparation. Sepolia is preserved.

Checks passed: forge build, 438 submitted tests and 102 recorded-block simulation tests.

Mainnet deployment remains pending. Protected admission lacks its supplied harness; the mandatory platform panel, publication and actual release inputs are outstanding. No deployment was broadcast.

See ADAPTATION.md and release status.

The review is complete. The findings file holds an empty findings list and 94 coverage rows, the working tree is clean, and the scratch tests are removed.

Outcome: no reproducible math, boundary or numerical-gap defect in the mainnet release path. The findings list in .imd-findings.json is empty, and that is a verified result, not a skipped one.

What I traced in depth (the mainnet bundle that launch.json describes):

• Spot math. The 512-bit ImdSpotMath.fdv was differential-fuzzed in both currency orders against independent exact references: nested floor division for the inverted high-sqrt branch, single mulDiv for the low branch, and a reordered mulDiv for the direct high branch. All agreed. Saturation to uint256.max only occurs when the result already exceeds every gate, as the library comment claims.
• Fee rounding. Exact-input buy base was fuzz-proven maximal and exact-output sell gross fuzz-proven minimal, so the treasury fee is 75 bps within one wei in all four swap modes. The int128 casts in beforeSwap and afterSwap are bounded by the Universal Router's uint128 inputs.
• Gates and quota. Threshold comparison is strict-less on sixteen thresholds, so an exact touch opens the gate; p maps to 2000 plus 500 per tier with tier 16 the permanent bypass. Floor rounding in the IMD/USD and FDV steps can only delay a touch, never advance one. The cumulative E/S example from the brief and exact-threshold tests pass on this tree.
• Seed boundary. The floor-rounded principal is at or below the factory's round-up pull, which is at or below 870M and above the 861.3M band at the policy opening tick in both token orders, using the exact liquidity formula from the launch preparation script. Token-only boundary checks are inclusive on the correct side for each sorting.
• Claim evidence and vault. The heap layout of certifyRound and chunked reduce matches OpenZeppelin's StandardMerkleTree including the single-leaf case. The vault's accrual, redeem and payout accounting cannot underflow given its receipt checks.

Static-analysis leads in my area (divide-before-multiply, uninitialized locals, strict equalities, weak PRNG) were each checked and found to be either intentional floor arithmetic, zero-initialized locals, or exact balance receipts. None reproduced as a defect.

Coverage record. Every one of the 90 listed entry points has a row, plus four invariant rows. The mainnet contracts (UnlkImdHook, UnlkImdOracle, ImdFeeVault, MerkleClaimEvidence, UnlkToken, WalletExecutor) are marked holds. The preserved Sepolia hook and router, the undeployed candidate and successor hooks, the candidate native vault, and the proof-based historical source are honestly marked unreached: they are outside the release path and I did not re-trace them within budget. The historical sampled source is marked holds on its arithmetic only, since deployPriceSource rejects its code.

Limitations to note. I did not reproduce the gas-dependent seam where a swap with a tight gas limit lets the oracle call run out of gas inside the try/catch, so that swap's touch is not recorded. The existing suite documents that unobserved touches are not backfilled and anyone may checkpoint later, so I did not treat it as a defect.

Updated only launch.json, confirming constructors, ten hook permissions, and required pool settings. Notes are 3,782 characters.

Validation passed:

• forge build
• forge test: 438 passed, 0 failed/skipped, using the required seed
• Manifest regressions, ABI/hash checks, and deployment-size checks

No deployment is claimed. Platform admission/audits, publication/attestation, actual release inputs, and owner-signed setup remain pending.

The review is complete. The findings file is written and valid, the working tree is clean apart from the ignored findings file and my scratch test, and no repository file was changed.

Outcome

The mainnet production path (UnlkImdHook, ImdSpotUsdSource, UnlkImdOracle, ImdFeeVault, ImdSetupVerifier, MerkleClaimEvidence, UnlkToken, WalletExecutor) holds against the Access Control, Trust Gap and Asymmetry checklists. I found one low-severity trust gap and no higher-severity defect.

Finding 1 (low), anchored at src/mainnet/UnlkImdHook.sol:329. Activation is the only route out of stage 1 and it hard-requires round 0 to be certified by MerkleClaimEvidence. That contract refuses any tree with a repeated recipient, while the verified IMD distributor accepts such a tree and pays it out natively. If the platform records a round-0 root with a duplicate account, no call sequence can ever certify it, configureAndActivate reverts forever, and 87% of supply stays locked in a pool that rejects every swap. The off-chain plan builder checks uniqueness, but only when run before stage 1 against the exact root. Reproduced in test/scratch/DuplicateRoundZero.t.sol, which passes as a demonstration of the uncertifiable state.

What I verified as holding

• Every hook callback is manager-only and pool-bound. Initialization and liquidity are factory-only, principal removal is impossible, and the fee-claim path is zero-delta only.
• Swaps authenticate the pinned Universal Router by address and codehash and use its lock owner as initiator. The Quoter path can only run inside an always-reverting unlock. No spoofed sender or direct unlocker reaches accounting.
• Stage 2 is setup-authority-only, pre-activation-only, and can only deploy pinned creation code with on-chain-derived arguments. The pins match the current build, since the fixture tests stage real creation code and pass.
• Treasury fee flows symmetrically across all four swap modes into a vault whose beneficiary is the fixed wallet named in the brief. Payer and reward credits are deduplicated and never caller-chosen.
• The manifest matches the implementation. Constructor order, the ten permissions, flags 0x3fcc, fee and tick spacing all agree.

Test evidence

Coverage and limits. All 90 listed entry points have rows. The 31 production entry points are traced. The 59 historical and candidate entry points (UnlkHook, UnlkHookV2, UnlkHookV3, NftFeeVault, UnlkOracle, both custom routers) are marked unreached, since they are outside the mainnet release path and my budget went to the deployed design first. The Python artifact-pin script could not run because the host has no Python, so pin agreement rests on the Foundry fixtures instead.

The review is complete. .imd-findings.json holds an empty findings list and a 93-row coverage record.

Result: no reproducible defect in the assigned area. I traced the Execution Trace, Periphery and First Principles failure modes through the mainnet release path and could not substantiate any finding against the tree, so the findings list is empty rather than padded.

What I traced and confirmed

• UnlkImdHook swap flow. For all four swap modes, the hook's specified-side fee from beforeSwap, the unspecified-side fee from afterSwap, and the ERC-6909 mint to the vault net to a zero PoolManager delta. The pending-operation hash, complete-fill and in-range checks, pre-swap gate ordering for sales, one-block buy maturity and the quote path writing nothing all behave as the design states.
• Staging and activation. Companion code is pinned by creation-code hash with on-chain derived arguments, every check precedes every write, restaging the price source correctly invalidates a previously staged oracle, and activation requires a certified round 0 plus a valid current price.
• Periphery math. The hand-rolled 512-bit division in ImdSpotMath matched 392 Python big-integer reference vectors, including both currency orders, sqrt prices above 2^128 and saturation.
• Claim evidence. Chunked certification equals single-call certification on a 5-leaf tree, attestation accepts the correct leaf once and rejects a wrong amount, and leaf/internal-node second preimages are structurally impossible.
• Fee vault, token, wallet executor, legacy swap router. Access, accounting and balance-check paths hold.
• Manifest. Constructor argument order, ten permissions, fee 12500, spacing 60, lowercase paired currency and the 3100-character notes all conform.

Coverage honesty. Rows for the historical and candidate contracts not deployed by this launch are marked unreached with the reason stated. Those are the original Sepolia UnlkHook, UnlkHookV2, UnlkHookV3, UnlkOracle, UnlkRouterV2, NftFeeVault, ImdSampledUsdSource and ImdV4UsdSource.

Items that are not code defects but remain open for the release, all already recorded in the repository's status: no published commit, launch number, addresses, salt or sealed-setup evidence exists yet, and the explicitly accepted spot-manipulation and shared-executor risks remain disclosed rather than fixed.

The existing mainnet suite ran clean during the review (170 tests, 0 failures). Scratch tests were removed, so the only new file is the findings record.

The review is complete and .imd-findings.json holds the results. No code files were changed; the scratch probe was removed.

What I covered (economics, invariants, flow gaps) on the mainnet bundle

• UnlkImdHook swap path end to end: router and quoter admission, the 75 bps IMD fee in all four swap modes through before and after swap return deltas, complete-fill and seed-range checks, initiator E/S ledger, one-block buy maturity, sale checked against the gate already open, milestone update after accounting.
• The spot price chain: ImdSpotUsdSource (pool identity, liquidity, Chainlink freshness and bounds, currency order), UnlkImdOracle.fdvUsd (range, factory position liquidity, 1B supply scaling), and ImdSpotMath branches.
• ImdFeeVault accrual, redeem, withdraw and donation accounting; MerkleClaimEvidence certification and attestation; UnlkToken allocation receipts; ImdSetupVerifier allocation and position checks; stage 2 staging and activation.
• Manifest and policy compatibility: constructor order, ten permissions and flags 0x3fcc, fee 12500 in policy 34, IMD in the allowlist, 2500 IMD cap, notes length. The pinned creation-code hashes match the compiled contracts. The 96 existing mainnet economics tests pass.

Findings

1. Info, accepted-risk reassessment with numbers. Under the exact seed derivation, about 115.6K IMD of IMD-to-UNLK input walks the official pool to the $50M FDV bypass, buying about 854M UNLK. The same batch can then sell it all back because fullyUnlocked skips the quota. Net cost is roughly 4% in fees, about 4,600 IMD (around $31K at the recorded reference). After that every holder is permanently unquota'd. This is exactly what the requester accepted, so it is reported for the record, not as a defect.
2. Low, release input. The hook refuses any pool seed below 861.3M UNLK, while policy 34 carries liquidityBps 8000. If the deployer bound the policy split instead of the request's poolBps 8700, the stage-1 transaction reverts atomically in _recordSeed and the paid request is spent. The request body carries poolBps 8700 and the service check returned no blockers, so the deliverable is explicit confirmation of that binding before broadcast.

Not reached: the historical and candidate contracts not in the mainnet bundle (UnlkHook, V2, V3, NftFeeVault, both custom routers, UnlkOracle, the sampled and proof-based price sources) are marked unreached in the coverage record.

Added failure-path tests, arithmetic fuzzing, and custody/quota invariants under test/.

Validation: forge build passed; seeded forge test passed 464 tests, with 0 failures and 0 skips.

No new implementation defect was reproduced. Tests are offline simulations; no mainnet deployment occurred.

Coverage and results

Review complete. The findings file is written and validated against the tree.

Outcome

.imd-findings.json holds 3 findings and a 90-row coverage record whose targets match the verifier's entry-point list exactly. No critical, high or medium defect was found in the mainnet bundle. The full mainnet suite passed when I ran it.

Findings kept

• Low, merged from audit_permissions. Activation hard-requires certified(0) on the hook, but the pinned distributor accepts and pays from a duplicate-recipient round-0 tree that the evidence contract can never certify. If the platform's real root has that shape, stage 1 is final with no on-chain recovery. I reproduced it with a scratch test against the real MerkleDistributor and MerkleClaimEvidence.
• Info, merged from audit_economics. The $50M permanent bypass is reachable in one Universal Router batch for roughly the fees. This is the requester's accepted design, so it is reported as information with the code path traced, not as a defect.
• Info, downgraded from audit_economics low. Stage 1 reverts atomically unless the release binds poolBps 8700 rather than the policy default 8000. It is a deployment-input dependency, not a code defect, and the request already binds 8700.

Coverage

All 35 mainnet-bundle entry points are traced and marked holds, except configureAndActivate, which carries finding 1. The 55 entry points in preserved Sepolia and candidate code outside the manifest are marked unreached honestly, apart from NftFeeVault, which I diffed against ImdFeeVault and marked holds.

Static-analysis leads on the mainnet path (unused returns, uninitialized locals, reentrancy in afterSwap and the vault callback) were each checked and did not reproduce as defects. The scratch test under test/scratch/ is working material and is not part of the submission.