Delivered the pinned PvPad contracts, vendored dependencies, deployment tests, eight ABI exports, and updated documentation.

Verified with Solidity 0.8.26:

• forge build passes.
• forge test: 125 passed, zero failures.
• forge fmt --check passes.
• All ABI exports match compiled artifacts.

Manifest generation, independent review, and deployment remain assigned to later stages.

Created launch.json with dependency-ordered contracts, $owner roles, and Uniswap’s Sepolia PoolManager.

Schema and constructor ABI checks passed. forge build succeeded; forge test: 125 passed, 0 failed.

Only launch.json is included in the deliverable.

Review complete. The findings file is at .imd-findings.json in the repository root, with two low-severity findings and a coverage row for all 39 entry points (35 hold, 7 point at finding 1 or 2, none unreached). Scratch tests were removed, so no other file in the tree changed.

What I checked in the math area

• Curve arithmetic. The cap formula remaining + (remaining-1)/99 is the smallest gross input whose rounded fee leaves exactly the missing reserve, and net-of-fee is monotone, so reserves can never overshoot 4.2 ETH. Verified by reasoning and a 20,000-run fuzz. Both output formulas round toward the reserves, so the virtual product never decreases and the "insufficient liquidity" guards are provably unreachable.
• Graduation seeding. The canonical sqrt price equals the curve's terminal marginal price (tick 179027, about 59.5M tokens per ETH). Liquidity is the min of both sides, and v4's round-up amounts cannot exceed the swept amounts because the liquidity was rounded down first. Fuzzing 256 random buy/sell sequences before filling always graduated, leaving only about 1.7k wei ETH and 1.5k token-wei of dust.
• Hook fee math. The gross-up (m-1)/99 yields exactly 1% of gross for every magnitude, the partial-fill equality matches the vendored Hooks library's delta handling, and all four swap modes on the real PoolManager leave the hook with zero balance.
• Escrow, king and worker accounting. Share bounds, zero-value early returns, window boundaries and the bump formula all hold. The claim-price overflow needs a bid above 1e73 wei, so it is unreachable.

Findings

1. Low. The 1% fee rounds down in both the curve and the hook, so any ETH leg under 100 wei pays nothing and 199 wei pays 0.5%. Leakage is under 1 wei per trade and gas makes it unfarmable, but it contradicts the spec's fixed rate. Fix is to round the fee up in both _fee helpers.
2. Low. The factory's unconditional receive() accepts ETH from any sender, and no path can move it out, so a stray transfer is locked forever. Restricting it to registered curves preserves the graduation sweep.

No critical, high, or medium defects were found in the assigned area, so no proof tests are attached. Static-analysis leads in my area (the reentrancy and unused-return items around withdraw, flush and graduate) were traced and each is guarded or benign.

Review complete. The findings file is written and validated, all three snippets match the tree at the cited lines, and git reports no tracked-file changes (the findings file and test/scratch/ are gitignored).

Outcome. The permission model holds. I mapped every role and guard across the eight contracts and traced each of the 39 listed entry points plus the constructors against the Access Control, Asymmetry and Trust Gap checklists. No permission bypass, escalation, confused-deputy path, or asymmetric fee route reached funds. The existing 125-test suite is green, ABI exports match the build, and forge fmt --check passes.

Findings written to .imd-findings.json (3 total, none above low):

• Low, hook deployment salt. The hook constructor correctly refuses any address without the 0x08cc flag bits, but the manifest schema has no salt field and the protected floor deploys from service-supplied salts. Eight sequential salts all reverted in my scratch test. The gap is service evidence (mined salt, deployer, creation-code hash, predicted address), not a code change.
• Low, factory constructor needs live PoolManager code. Genesis creation reads slot0 and initializes the pool during construction, so a constructor simulation without the real PoolManager bytecode reverts. The floor must run on a Sepolia fork with a verified PoolManager address.
• Info, spoof binding on the shared hook. Any contract that answers factory() for its own token and escrow can bind a pool to the official hook and route its 1% fee to itself. Real launches, the real escrow and the king are isolated by per-pool keys, staticcalls and the reentrancy guard, so the impact is limited to frontends or indexers that treat the hook address as proof of a PvPad launch.

Coverage record. 45 rows: every listed entry point has a verdict (36 hold, bindPool is a finding), two constructor rows carry findings 1 and 2, three invariant rows hold, and one row marks the manifest review as unreached because no launch.json exists in this tree yet. Updater powers over the worker pot and the first-king capture of pre-crown fees are recorded as documented trust assumptions rather than defects, since neither has an unprivileged amplifier.

Not reached. The resolved constructor arguments in the eventual manifest ($owner for the updater and genesis creator, the literal PoolManager address) still need review once the manifest assignment produces the file.

The review is complete. The findings file is in place and the working tree is otherwise unchanged (scratch tests removed).

Outcome: no fund-loss defect found in the assigned area. The core execution paths hold up under the Execution Trace, Periphery and First Principles checks, and the full suite passes locally (125 tests). Four findings were recorded in .imd-findings.json, none critical or high, so no proof files were required.

Findings, by severity

• Medium, hook deployment salt. The PvPadHook constructor only accepts an address carrying the 0x08cc permission bits. The manifest schema has no salt field and the protected deployment floor uses service-chosen salts. I reproduced that all 64 sequential salts revert the constructor, while a mined salt deploys. The manifest stage needs recorded evidence of a mined salt for the hook entry.
• Low, worker pot lock. The updater can call setEpoch with a window starting a century away. That reserves the whole pot where claims, recycling and updater rotation cannot touch it. The README documents the power, but a bound on the start distance would remove the irrecoverable state without changing the design.
• Low, factory constructor PoolManager dependency. The factory constructor reads and initializes the PoolManager for genesis. A codeless or wrong PoolManager argument, or a chain-id-only simulation, reverts the launch after the other three contracts deployed. Reproduced locally.
• Info, no manifest in the tree. The manifest assignment has not run, which the workflow allows. I recorded the concrete checklist the manifest review must apply: contract order, both PoolManager arguments identical and verified, and the two $owner arguments (updater custody and genesis creator fee recipient).

Coverage: all 39 listed entry points have rows, plus rows for the two constructors, the manifest and three cross-cutting invariants. Every static-analysis lead at medium or higher was checked; the reentrancy, arbitrary-send and locks-ether leads are not exploitable and are noted in the rows.

The review is complete. The findings file is written at the repository root, the scratch tests are removed, and no source or configuration file was changed.

Outcome. The frozen economics are implemented faithfully. I found no path that loses funds, misdirects fees, or breaks the fee, curve, graduation, king or worker invariants. Four findings are recorded, two medium and two informational.

Findings written to .imd-findings.json:

1. Medium, griefing of the launch deployment. The 16 candidate genesis token addresses are a pure function of the future factory address, and the shared hook has no beforeInitialize. Initializing those 16 pools at a foreign price costs about 858k gas and makes the factory constructor revert with UnexpectedPoolPrice. A retry at the same address fails again. The README documents this only for later launches, where the creator can change the salt. Fix options: a deployer-chosen bytes32 genesis salt constructor argument, or a service commitment not to pre-publish the factory address and to rotate its CREATE2 salt on failure.
2. Medium, deployment integration. The hook constructs only at a mined 0x08cc CREATE2 address (8 of 8 arbitrary salts reverted), and the factory constructor needs live PoolManager code. The manifest schema carries no salt, so the deployer service must mine it and simulate on a Sepolia fork. I listed the evidence the manifest reviewer should obtain rather than asking for new manifest fields.
3. Info. After the genesis curve fills, the first king claim at 0.01 ETH plus 1 wei collects 0.0212 ETH of pre-crown fees. Same-block crown sniping before large trades is also profitable. Both follow the spec, but belong in the README economics section.
4. Info. The hook takes its fee from the PoolManager before the swapper settles, so an exact-input buy whose 1% fee exceeds the PoolManager's whole ETH balance reverts. This needs a trade over 100 times the PoolManager's holdings, so it is a note only.

Coverage. All 40 listed entry points have a row, plus constructor and invariant rows. Verified by scratch tests: graduation strands only 1760 wei of ETH and 4369 token units, the pool's marginal price right after graduation equals the curve's terminal price, and all four swap modes charge exactly 1% of the ETH leg with the hook delta netting to zero. The full suite passes (125 tests) and all eight ABI exports match the build.

Not reached. I did not fuzz the worker Merkle path beyond the existing suites, and I did not test v4 protocol-fee interaction with the PartialFill check beyond reasoning through the vendored code.

Committed, tree clean, nothing left in scratch. The work is complete.

Summary

The existing suite was already extensive at the unit and per-component level, so I read the implementation adversarially and added the two layers it lacked: a whole-deployment invariant campaign and sharp stateless properties of the curve arithmetic. All 144 tests pass from a clean rebuild with an empty environment, as the verifier runs it. No implementation defect was found, so no findings file was written.

New file: test/SystemLifecycleInvariant.t.sol (3 tests, 5 invariants, 96 runs × 48 calls) A handler drives the real factory, PoolManager, shared hook, escrow, king and worker pot through random sequences: launches created on the fly, curve buys and sells, fills, permissionless graduation, all four swap modes on graduated pools, crown changes, injected escrow outages with deferred fees and retries, withdrawals, pre-crown fee assignment, donations pushed into curves outside any trade, and a probe of every privileged or malformed entry point. Fees are measured from ETH that actually moved, never read back from the counters being checked. Invariants cover token conservation per launch, curve custody, graduation finality with the locked full-range position unchanged, the 50/50 fee split per payee against an independent ledger, and the worker pot and claim-price economics. A scratch run confirmed the random campaign reaches graduation, post-graduation swaps and deferrals on its own.

New file: test/CurveMathProperties.t.sol (16 tests, 512 fuzz runs) Properties from random prior fills: quotes equal execution; the cap is the smallest filling input and one wei less lands exactly one wei short; inputs below the cap never reach the threshold; cap excess is refunded to the sender, not the recipient; fee-free dust and trades of any size cannot be round-tripped at a profit; later buyers never get a better price; a holder can always exit the whole circulating supply leaving at most one wei; a synthetic over-balance sale is rejected; guards leave state untouched; graduation seeds the pool at the curve's terminal price with sub-million-wei dust.

Failure paths exercised include wrong launch fees, empty names, unknown launches, early and repeated graduation, trading on a full or graduated curve, swaps on ungraduated pools, failed token pulls, unauthorized escrow, hook, worker and factory calls, rebinding a pool, under-priced crown bids, and failed fee delivery with later retry.

The test README table documents both files. Behaviours that are by design but worth knowing, such as donated ETH or tokens staying in a curve forever and rounding dust staying in the factory, are asserted as the source states them rather than reported as defects.

The review is written to .imd-findings.json: 6 findings (3 medium, 2 low, 1 info) and a coverage record answering all 39 entry points plus 4 invariants. No tracked file was changed, and my scratch tests under test/scratch/ are removed.

Findings kept

#	Severity	Finding	Specialists merged
1	medium	The protected deployment floor fails offline: PvPadFactory's constructor needs live PoolManager code (src/PvPadFactory.sol:242).	permissions (low), flow (low), half of economics' deployment finding
2	medium	PvPadHook only constructs at a mined 0x08cc address, and the manifest cannot carry a salt (src/hooks/PvPadHook.sol:77).	permissions (low), flow (medium), economics (medium)
3	medium	Pre-initializing the 16 predictable genesis pools makes the factory constructor revert, on every retry (src/PvPadFactory.sol:114).	economics
4	low	Unguarded receive() on PvPadFactory and BondingCurve locks stray ETH.	math, extended by me to the curve
5	low	setEpoch has no bound on how far ahead a window may start, so one updater call can lock the whole pot (src/WorkerSubsidy.sol:90).	flow
6	info	Anyone can bind a self-made pool to the shared hook; real launches are unaffected.	permissions

• Finding 1 was raised to medium because I ran the supplied Project.protected.t.sol unchanged with this manifest's resolved arguments. Without a fork it fails with "project constructor failed"; on a Sepolia fork with a mined hook salt it passes.
• Finding 2 was shown the same way: on the fork, changing only the hook's salt to an unmined one fails the floor. The Solidity is correct; what is missing is the service's mined salt and predicted address.
• Finding 3 carries the only proof. It fails on the current code with UnexpectedPoolPrice() and requires the 5-argument constructor to deploy with genesis at the canonical price. A fix that changes the constructor signature would not compile against it.
• Findings 4–6 were each reproduced with a scratch test; the exact inputs are in the file.

Dropped, with reasons

• Fee rounds down (math, low): reproduces (99 wei buys pay no fee), but it is the documented and tested design, and the loss is under 1 wei per trade.
• First king captures pre-crown fees (economics, info): reproduces only as the behaviour SPEC.md specifies; not a defect.
• Hook takes its fee before the swapper settles (economics, info): reproduces only against a fresh local PoolManager. The Sepolia PoolManager holds about 3,874 ETH, so it would need a single buy above roughly 387,000 ETH.
• No launch.json in the tree (flow, info): obsolete. The manifest is now present and I checked it against the schema and the constructors.

Checks beyond the specialists

• Manifest: schema fields, dependency order, argument types and the two $owner roles (worker-epoch updater and genesis creator-fee beneficiary) match the source.
• PoolManager literal: cast code shows the address has code on chain 11155111.
• Fork lifecycle: constructor, a second createLaunch, two graduations and all four swap modes succeeded against the live PoolManager.
• Protected floor on the fork: no forbidden opcodes in the four runtimes, and the factory runtime is 21,990 bytes.
• ABIs: docs/abi/*.json matches the build for all eight contracts.
• Existing suite: forge test gives 144 passed, 0 failed.

Not verified

• Gas headroom: the launch token plus the four application constructors used 12,179,459 gas on the fork. I could not check whether the service's own steps fit under the deployer's gas ceiling or the 16,777,216 per-transaction cap. This is noted inside finding 1, not as its own finding.
• Service side: the salt scheme, attestation and admission were out of reach.
• Tools: Slither and Aderyn were not run by me; I treated their supplied output as leads and none produced a finding beyond thos

Revision complete. All three reopening findings are answered, the binding proof passes, and the full suite is green.

What changed in source

• PvPadHook gained realignPool(key, target), a registry-only zero-value price reset for an initialized, empty pool, plus the matching unlockCallback. It refuses callers other than the bound factory, pools already at the target or uninitialized, and any pool holding liquidity. The callback reverts unless the swap delta is exactly zero and the price lands on the target. It never calls back into the factory, so constructor-created genesis can use it.
• PvPadFactory._selectSalt keeps the bounded re-salt the brief requires but no longer reverts when all 16 candidates are poisoned. It returns the first candidate and the pool is realigned through the hook, re-checked against the canonical price, and LaunchPoolRealigned is emitted. The factory's receive now rejects anyone but a registered curve.
• BondingCurve lost its receive, so stray ETH is refunded by the revert instead of locked.
• WorkerSubsidy.setEpoch also bounds the start to 90 days ahead, so one updater call can delay the pot by at most two windows.
• New script/MineHookSalt.s.sol prints the deployer, PoolManager, init-code hash, salt, predicted address and flag bits offline, with no environment reads or broadcasting.

Findings and verdicts in .imd-responses.json

• Genesis poisoning (medium, proof attached): fixed. The reviewer's proof failed on the starting tree with UnexpectedPoolPrice and passes now.
• Constructor needs live PoolManager code (medium): disputed as a service configuration item. The finding itself recommends against deferring genesis, and the reviewer's own proof asserts the genesis pool price immediately after construction, which needs the PoolManager. The README now has a prerequisites section for the deployer.
• Hook needs a mined salt (medium): disputed as a source defect. The constraint is Uniswap v4's and the brief's. The new script gives the service a one-command evidence generator, and the docs warn that the hook's creation code changed, so earlier salts are void.
• Unguarded receive (low): fixed. Epoch start bound (low): fixed. Shared-hook binding by foreign contracts (info): documented for integrators, no code change, as the finding asked.

Verification

Check	Result
forge build	clean
forge test	136 passed, 0 failed, 20 suites (135 in-tree plus the proof copy)
forge fmt --check	clean
tools/export_abis.py --check	all 8 match, hook and factory ABIs regenerated
Reviewer proof Proof_9d5b3504d43a	passes

New tests cover the all-16-poisoned genesis and create paths, realignment from both extreme prices with no value moved, every realignment refusal case on the real PoolManager, stray ETH refusal with the graduation sweep still landing, the epoch start bound, and the salt script deploying a hook while unmined salts fail. README, CHANGELOG, docs/ABI.md and test/README.md describe the new behaviour, the two service prerequisites, and the integrator guidance.

Two items remain outside this tree for the service: mine the hook salt against the real deployer with the script, and run the protected floor and admission simulations against Sepolia state.

The manifest is regenerated and validated. Only launch.json changed.

What I found

• The accepted tree is the post-review revision (134 tests pass with forge build --offline and forge test --offline). Its constructor signatures and ABI exports still match the existing manifest: WorkerSubsidy($owner), KingOfThePad($contract:WorkerSubsidy), PvPadHook(Sepolia PoolManager), PvPadFactory(PoolManager, WorkerSubsidy, King, Hook, $owner). The token stays LaunchToken as "Pepe Values Pepe" / "PVP" with 18 decimals and no constructor arguments.
• The old notes predated the revision and no longer described the accepted behaviour.

What changed in launch.json

• Contracts, order, constructor arguments and the pool object are unchanged.
• Notes now describe what the revision added: permissionless-safe realignPool on the hook and the factory's LaunchPoolRealigned fallback when all 16 salt candidates are poisoned, the guarded factory receive() and curve without one, the 90-day bound on epoch window start, the changed hook creation code that voids every previously mined salt and the offline salt-mining script, and the requirement that the protected floor, admission and gas estimation run against Sepolia state with live PoolManager code, with the measured constructor gas. The warning that any contract can bind a pool to the shared hook is included.
• Notes are 3595 characters, ASCII only.

Verification

• A scratch checker in test/scratch/check_manifest.mjs confirmed the schema fields, patterns and limits, uniqueness and reserved names, backward-only $contract references placed in address-typed inputs per the ABI constructors, the initialPrice bound, native ETH pairing, and that the token name and symbol match src/LaunchToken.sol.
• git diff --stat shows one file changed, launch.json. The other untracked entries in git status are sandbox device nodes, not files I created.

Added recovery fuzz tests, five rollback/retry cases, and lifecycle invariant coverage. Corrected the stale ETH-donation expectation.

Offline verification: forge build passes; forge test reports 160 passed, 0 failed, 0 skipped.

Only test/ changed. No new contract defects found.

Round-2 review is complete: nothing blocking remains. The four fixes hold, the two disputed mediums are settled in the author's favour as service prerequisites, and I found no new defect. .imd-findings.json holds two info-level notes and a coverage record answering all 40 entry points, all holds, plus two invariant rows.

Settlement of the earlier findings

Finding	Was	Outcome
9d5b3504 genesis pool poisoning blocks the factory constructor	medium	Fixed.
c277ec36 floor fails without live PoolManager code	medium	Dispute accepted, kept as info.
2f83f316 hook needs a mined CREATE2 salt	medium	Dispute accepted, kept as info.
7c805a4c stray ETH locked in factory and curve	low	Fixed.
16f06cc7 unbounded epoch start	low	Fixed.
03bcff93 anyone can bind a pool to the shared hook	info	Settled by documentation, as proposed.

• 9d5b3504: my attached proof now passes. My own tests poisoned all 16 genesis candidates at 2^96, MIN_SQRT_PRICE, MAX_SQRT_PRICE-1 and canonical±1. In each case the constructor succeeds with the canonical price and tick, and graduation and a 1%-fee swap follow. The two extreme cases behave the same against the live Sepolia PoolManager on a fork. realignPool refuses a spoof registry on a real pool and refuses a graduated pool. Worst-case extra constructor gas is about 0.56M (7.20M to 7.76M for the factory creation frame).
• c277ec36: the fact still reproduces: the protected floor fails offline at the factory and passes on a Sepolia fork. My first-round text already said the remedy is service-side, so nothing is asked of the author. The floor, admission and gas estimate must run against Sepolia state.
• 2f83f316: script/MineHookSalt.s.sol works offline. For deployer 0x…0F4C70 it gives salt 0x3c62 and hook 0xc8d7…88Cc, and the fork floor passes with it. My old salt 0x2f76 now fails, as the README warns. The service still has to mine a salt for its real deployer.
• 7c805a4c: a 1 ETH plain transfer to the factory or to a curve reverts, and the graduation sweep still works.
• 16f06cc7: an epoch start at +36500 days or +90 days + 1 reverts InvalidWindow with the pot untouched; +90 days exactly is accepted and recyclable.
• 03bcff93: the README and docs/ABI.md now tell integrators to identify launches only through the factory.

Other checks

• Changed lines read as new code: realignPool, the hook's unlockCallback, the _selectSalt fallback, both receive changes, the setEpoch bound and the mining script. No new defect.
• Full suite: 161 tests pass.
• ABIs: all eight docs/abi/*.json files match the compiled ABIs.
• Manifest: launch.json has the five schema keys and unchanged constructor arguments; its notes are 3,595 characters.
• Sizes: factory runtime is 22,410 bytes, 2,166 under the EIP-170 limit.

Not done

• No Slither or Aderyn run of my own; I used the supplied output as leads.
• The fee-rounding and king-economics items from the specialists were not reopened; they were not among the findings I kept in round 1.
• I did not check the 16,777,216 per-transaction gas cap against the real ProjectFactory, whose own overhead is unknown to me.

No tracked file was changed; the scratch tests under test/scratch/ were removed.