Implemented the token/mirror, hook, rewards, ABI exports, vendored dependencies, and deployment documentation.

• forge build, forge test, and forge fmt --check pass.
• 33 tests pass, including 4,096 invariant calls with zero unexpected reverts.
• All three deployed contracts fit EIP-170.

Independent review and deployment remain separate workflow stages.

Added independent tests and offline dependencies entirely under test/.

• Offline forge build and forge test passed: 56 tests, zero failures or skips.
• New invariants completed 24,576 random calls.
• A 100-NFT whale buy measured approximately 1.71 million gas.
• No reproducible contract defects found.

Coverage and fixture limitations are documented in test notes.

Created launch.json matching the contracts, permissions, $poolManager, native ETH pairing, and fee 12500.

Schema validation, forge build, and all 57 tests passed. Notes document price/spacing assumptions and the treasury fallback for review. Only the manifest is delivered.

I found two problems, and the bigger one is in launch.json, not the contracts. At the manifest's starting price nobody can ever buy enough LING for a Swarmling. With no Swarmlings in existence, every distribute() sends all of the hook's fees to the hard-coded TREASURY wallet instead of to holders. Both findings, plus one coverage row for each of the 14 entry points, are in .imd-findings.json. I changed no files; my scratch tests are deleted.

Findings

1. Medium: the manifest price makes Swarmlings unreachable (launch.json:24, "initialPrice": "79228162514264337593543950336").

   • That value is 2^96, which puts 1 LING at 1 ETH. One Swarmling (300,000 LING) would cost at least 300,000 ETH, and the full supply would be valued at 1e9 ETH.
   • I reproduced it on a real v4 PoolManager with the manifest's exact pool settings and liquidity seeded with tokens only. 1,000 ETH bought 975.16 LING, so no Swarmling was created. distribute() then credited all 12.5 ETH of fees to owed[TREASURY].
   • The cause is this notifyReward branch: when no Swarmlings exist, owed[TREASURY] += msg.value (src/Swarmlings.sol:73).
   • This assumes the liquidity starts at the initial price, which is how token-only seeding works. The manifest's own notes say the price was copied from a unit-test fixture and "is not an approved economic valuation".
   • Fix: use a realistic price, for example the independent tests' tick 138180 (sqrtPriceX96 = 79299443975792720780679863727831), where one Swarmling costs about 0.3 ETH.
   • Someone should also confirm with the requester that a TREASURY fallback is wanted. The brief I was given doesn't mention one, and README.md:11 says there is "no treasury". The brief's hook, distribution and rewards sections (A–C) weren't in my copy, so I can't rule out that they approve it.

2. Low: ETH can get stuck in the token (lib/dn404/src/DN404.sol:1273).

   • Swarmlings inherits DN404's payable fallback. A call with value that uses one of DN404's read-only selectors, such as implementsDN404(), succeeds and keeps the ETH.
   • That ETH goes into neither the reward pool nor owed, and no function can ever pay it out. My test confirmed the call succeeds.
   • This contradicts the README's claim that plain ETH sends are rejected; that is only true for receive().
   • Fix: override the fallback in Swarmlings so it reverts when msg.value != 0.

Coverage

• Hook: all 4 swap types, the partial-fill guard, the fee claims (always fully backed by ETH in the PoolManager), the distribute/unlockCallback sequence, and the first-pool binding in afterInitialize all behave as intended.
• Token: reward tracking holds through ERC-20 transfers, the burns and mints they trigger, NFT moves through the mirror, setSkipNFT(false) opt-in, and claim, including duplicate ids and re-entry. The renderer tokenURI path also holds.
• Static-analysis leads: the high and medium leads (ETH sent to an "arbitrary user", ETH locked in the hook, state change after the external call, unchecked return) don't hold up. distribute only pays the token bound at launch, forwards every wei it redeems, and is protected against re-entry.
• Accepted design, not reported: anyone can buy or opt in to Swarmlings just before calling distribute() and share that payout. The README documents this. Borrowing LING from the PoolManager for it doesn't work, because distribute() cannot run inside another PoolManager unlock.
• Not covered: I didn't run a fork test against the live Sepolia renderer or PoolManager. The existing suite passed: 56 tests across 7 suites.

The review is complete. The findings file is written and valid, the scratch tests are removed, and the working tree is clean apart from the excluded output file.

Outcome. The hook fee arithmetic and the token's reward accumulator hold up under the Math Precision, Boundary and Numerical Gap checks. All 56 project tests pass, including the independent conservation invariant suite. I found no critical or high defects, so no proof tests were attached. Four findings are recorded in .imd-findings.json, with a coverage row for every listed entry point plus three invariants.

Findings, most severe first:

• Medium, manifest input. The launch manifest's initial price is 2^96, which opens the pool at 1 LING per ETH. With LING-only liquidity adjacent to that tick, buying one Swarmling's worth of tokens costs about 361,876 ETH. The project's own integration fixture uses a tick about one million times cheaper, around 0.3 ETH per Swarmling. The notes admit the value is a copied test fixture. An approved opening price is the missing evidence.
• Low, fee base asymmetry. Exact-input trades charge 1.25% of the user's ETH amount, while exact-output trades charge 1.25% of the pool's ETH amount. For an identical fill, the exact-output buyer pays a smaller hook fee. Measured on a real PoolManager: 0.0125 ETH versus 0.01234375 ETH for the same LING output. The README documents the four bases, so this is a known nuance rather than a hidden bug.
• Low, ETH sink. The inherited DN404 payable fallback accepts value on its view-dispatch selectors. Sending ETH with a totalNFTSupply() or balanceOfNFT() selector lands it in the token outside the reward ledger with no recovery path. Plain sends are correctly rejected, so the loss is self-inflicted.
• Info, opt-in gas. Opting in materialises all supported NFTs at once at roughly 14.5k gas each. A wallet holding the full supply needs about 48.2M gas, which exceeds a 36M block limit. This bound is inherent to DN404 receipts and the README warns about it.

What I verified as holding. Fee math handles the int256 minimum, cannot overflow, and keeps the hook delta strictly below the swap amount. The partial-fill equality check is exact for both signs. Reward settlement with per-wallet remainders equals the single-division view, duplicate IDs cannot multiply rewards, reentry during payout cannot re-credit, and ID recycling resets debt correctly. Fee claims are always ETH-backed in the manager, including on a token-only pool with zero manager ETH.

Not reached. No live Sepolia fork rehearsal, and no check of the exported ABI JSON files against the build, since Python is unavailable in this environment.

The findings file is in place at the repository root, the snippets match the tree line for line, and the scratch tests that back the two substantive findings pass against the current code. The harness ignores .imd-findings.json and test/scratch/ on its own, which is expected for a review that must not change tracked files.

Review outcome for the Access Control, Trust Gap and Asymmetry area

The permission model is small and sound: no owner, role, proxy, pause or mint path exists in either contract, every hook callback and the hook's receive function are gated to the PoolManager, the mirror link is established once in the constructor, and the fee claim path nets to zero for the hook on every swap mode. Three items are recorded in .imd-findings.json.

• Medium, hard-coded TREASURY beneficiary. The approved brief says the entire hook fee goes to Swarmling holders and that no privileged party exists. When no NFT is active, notifyReward credits the whole payment to a constant wallet that the brief never names. That state is the launch's starting state, because the factory, pool, distributor and lock contracts all skip NFTs. Four small buyers plus one permissionless distribute() call divert the first 0.01 ETH of fees to that wallet, and holders who appear later get nothing from it. The suggested fix is to carry zero-holder payments into the next notification or let the hook's claims wait, unless the requester explicitly authorizes the fallback.
• Low, first-native-pool binding is permissionless. afterInitialize binds launchPool and LING to whichever native pool arrives first. Under the documented atomic factory flow this is closed, and I verified a codeless predicted address cannot be pre-initialized. Any deviation from that ordering lets an outsider bind a junk pool permanently, after which the real pool never pays a fee. Taking the token as a $token constructor argument would narrow this.
• Info, snapshot-at-notification rewards. Distribution credits whoever holds NFTs at that instant, and both the trigger and the holder set are unprivileged. The README documents this, no flash path exists because distribute() needs its own unlock, and the round-trip fees make sniping unprofitable in normal operation. Recorded as a trust assumption only.

Coverage. All 14 listed entry points have a row, plus two invariant rows. Twelve hold, notifyReward and afterInitialize carry findings. Nothing was left unreached. I did not run a fork rehearsal against Sepolia's live manager, which is the service's separate check.

The review is complete. The findings file is written and valid, the working tree has no stray files, and the only files I created are .imd-findings.json and the scratch proof under test/scratch/.

Result: one medium, one low, one informational finding. The hook's fee arithmetic, delta composition, claim redemption, and the token's reward ledger all hold under the Economic Security, Invariant and Flow Gap checks. The weakness is in when rewards vest, not in the accounting.

• Medium, reward sniping through distribute(). Fees sit as ERC-6909 claims until anyone calls distribute(), and only then does notifyReward split them by the NFTs active at that instant. An actor who held nothing while fees accrued can buy, distribute, claim and sell in one transaction. My scratch test shows a sniper buying 3 NFTs against a single honest holder nets about 0.036 ETH profit after paying both legs' fees, and the honest holder keeps 0.028 ETH of the 0.1 ETH earned while she was the only holder. The proof test is embedded in the finding and fails on the current code. The suggested fix attributes fees per swap through an accounting-only notification from the hook, with the design tradeoff stated.
• Low, zero-holder fallback payee. When no NFT exists, the whole distribution is credited to the hardcoded TREASURY wallet rather than carried forward to the first holders. The brief names no beneficiary besides NFT holders, and the manifest notes defer authorization to review. A carry-forward alternative is described.
• Info, fee only on the launch pool. Any other ETH/LING pool, with this hook at another fee tier or with no hook, trades without the 1.25% holder fee. This is inherent to v4 and documented, reported for disclosure only.

Coverage: all 14 listed entry points have rows, plus three invariant rows. Twelve entry points hold; notifyReward and distribute point at finding 1. Static-analysis leads were checked: the arbitrary-send-eth and uninitialized-local lines are false positives for this code, and the unused-return and reentrancy lines are benign. The existing 53 non-invariant tests pass on this tree; I did not rerun the invariant suites.

Review complete. The findings file is at .imd-findings.json in the repository root; no tracked file was changed and the scratch tests were removed.

What I did. I read the workflow, the four specialist reports, the static-analysis leads, the pinned references and the protected floor tests, then reproduced every specialist finding against a real v4 PoolManager in scratch Foundry tests. The existing suite passes with 56 tests. The ABI exports match the build and the manifest is schema-valid.

Kept findings (7), merged and recalibrated

• High, launch.json:24. The manifest opens the pool at 2^96, which is 1 LING per ETH. With token-only seeding one Swarmling costs over 300,000 ETH. Measured: 1000 ETH buys 975 LING, and an exact-output buy of one unit costs 361,876 ETH. No market buyer can ever hold an NFT, so every distribution flows to the fallback wallet. Merged from the flow and math specialists. No Foundry proof is attached because a test cannot read launch.json without fs permissions.
• Medium, src/Swarmlings.sol:73. With zero active NFTs the whole payment is credited to a hard-coded TREASURY wallet the brief never names. This is the launch's starting state, and the manifest notes themselves leave its authorization open. Merged from permissions, economics and flow.
• Medium, src/Swarmlings.sol:75. Rewards vest to holders at distribution time, so an atomic buy, distribute, claim, sell is profitable. The specialist proof fails on current code as described and is attached to this finding. Merged from economics and permissions.
• Low. Inherited payable fallback strands ETH sent with view selectors. Exact-output swaps pay an effective 1.2346% hook fee rather than 1.25%. afterInitialize binds the first native pool regardless of token, a trust assumption on the atomic factory flow.
• Info. Opting in a whole-supply wallet costs about 48.2M gas.

Dropped. The "other pools trade fee-free" item is documented design, not a defect, and is recorded in the coverage table instead. The slither and aderyn leads all resolved to either the findings above or intended behavior.

Coverage. All 14 entry points are answered, plus three invariant rows. My own pass with the Pashov mindset found no additional defects beyond the specialists' set. Of note, delta accounting, callback authorization, the one-shot unlock flag, claim reentrancy via the mirror, and reward-debt handling on mint, burn, direct transfer and ID recycling all hold.

Fixed the fallback ETH sink, added regression tests, and updated ABI/documentation. All six verdicts are recorded in .imd-responses.json.

Three findings are disputed against explicit requirements. Reward sniping remains reproducible and documented; its supplied proof still fails.

Validation passed: forge build, 37 delivered tests, formatting, ABI consistency, and EIP-170 size checks.

Extended the existing tests with fallback ETH rejection in randomized conservation sequences and a regression covering zero holders, the last NFT burn, and subsequent claims.

Only test/ changed.

Offline verification passed: forge build and forge test—61 passed, zero failures or skips, including 24,576 invariant calls.

Updated launch.json to tick 138180 (sqrtPriceX96: 79299443975792720780679863727831) and revised its price notes.

Reproduced the defect and recorded the fix in .imd-responses.json.

Validation passed: manifest schema, forge build, and all 65 tests.

Wrote .imd-findings.json: 0 retained findings, all 14 entry points recorded; 13 verified and 1 unreached.

• Opening price and payable fallback: fixes confirmed.
• Fee asymmetry and opt-in gas: documentation remedies confirmed.
• First-pool binding: remains conditional on atomic deployment.
• Reward sniping: still reproduces; retained as a disclosed design risk, not an established implementation violation.
• Treasury payout: reproduced, but authorization remains unverified because the cited section C was not supplied.

All 61 delivered tests and five targeted checks passed. The unchanged sniping proof failed as reported. Accepted files remain unchanged; temporary test files were removed.