Implemented the DCA token and 5% swap-fee hook, with ETH conversion and claim fallback for the specified creator wallet.

Verified: forge build, 48 passing tests, and forge fmt --check, including offline parallel checks.

Before trading, the owner must configure the ETH/FWA conversion pool and price limits. Deployment and operating instructions are in README.md.

Created launch.json with matching contracts, constructor arguments, permissions, and required pool settings. Notes document the owner’s required conversion configuration.

Only launch.json changed. Build succeeded with existing lint warnings; all 48 tests passed.

Review complete. No tracked file was changed; the findings are in .imd-findings.json at the repository root, with the proof test under test/scratch/.

What I found

The fee accounting itself holds. I traced all four swap modes in both currency orderings through v4's beforeSwap/afterSwap delta handling, the nested conversion swap, the claim burn/mint rollover, and the ETH take with its catch path. The hook's FWA and ETH deltas net to zero on every branch and the fee is 5% of gross FWA. Access control, reentrancy guards, the one-shot factory-only initialization, and the token are all sound. The 48 existing tests pass.

Three defects are reported, one with a Foundry proof:

1. Medium: the launch pool cannot trade until the owner sends a separate configuration transaction. Every swap reverts with ConversionNotConfigured from the moment the factory opens and seeds the pool. If the owner wallet never sends a correctly encoded setConversionPool call, the pool holding the launch liquidity is permanently untradeable. The proof test deploys a real PoolManager, initializes and seeds the pool as the factory would, and attempts a buy. It fails today and passes with the minimal fix: skip the conversion and hold the fee as FWA claims when no market is configured. I verified the pass against a patched copy that was then deleted.
2. Low: collected FWA fee claims have no exit except an in-swap conversion. If the ETH/FWA market is illiquid, drained, or stuck above the ceiling, the fee accumulates in the PoolManager with no function able to deliver it to the creator. A permissionless redemption that takes FWA straight to the fixed recipient would close this.
3. Low: FWA-specified swaps that reach the trader's price limit revert rather than partially filling, unlike DCA-specified swaps on the same pool. Documented by the author, but an asymmetry integrators will not expect.

Coverage

All nine listed entry points have a row, plus three invariant rows. The static-analysis leads (unused returns, reentrancy-events, state change after unlock) were each traced and found benign. Not reached: a mainnet fork rehearsal against the real FWA token and its live ETH/FWA pool, which the author also lists as outstanding. The paired token resolves to Fake World Assets, which does have an ETH pool, so the owner can configure a market, but that does not remove finding 1.

Sources: Fake World Assets on CoinGecko, ETH / FWA pool, FWA deployments

Review complete. The findings file is at .imd-findings.json, with the proof test under test/scratch/. No tracked file was changed.

Outcome. One substantive defect in the assigned area, three low findings, and coverage rows for all nine entry points plus three invariants.

• Medium, sandwichable fee conversion (DCAHook.sol:261). The hook sells the 5% FWA fee for ETH at the conversion market's spot price inside the same transaction as the launch swap. The only bound not under the swapper's control is the owner's static ceiling, which must leave slack. Any trader can push the ETH/FWA market toward the ceiling, trade on the launch pool so the hook sells into the moved price, and buy back. In the scratch test the creator receives 1,497 ETH instead of 4,654 ETH for the same 5,000 FWA fee, and the attacker nets about 3,087 FWA after LP fees. A 1 wei swap pays no fee but still sells the entire accumulated FWA claims backlog, so a deferred backlog can be dumped at a moment of the attacker's choosing right after the owner widens the ceiling. The proof file fails both of its tests on the current code and would pass under a fix that defers conversion when spot deviates from a reference set outside the caller's block.
• Low, owner-gated trading (DCAHook.sol:227). Every swap reverts until the immutable owner submits a conversion route, and the owner can halt trading later by pointing at an unusable route. Reported as a trust assumption with preconditions, not a bypass.
• Low, no FWA delivery path (DCAHook.sol:278). ETH owed to the creator has a permissionless redemption path, but FWA fee claims can only leave through a successful market sale. With no usable route or a lost owner key they are stranded.
• Low, token name (DCAToken.sol:8). The contract says "Acquisitions" while the request says "Acquisions". Outside my area, included because it is concrete.

Coverage. Access control holds everywhere I traced it: callbacks are manager-only, initialization is factory-only and one-shot, the setter is owner-only and rejects the launch pool as a route, redemption pays only the fixed recipient, and the unlock callback is reachable only from the hook's own redemption. Delta conservation across burn, nested swap, mint and take matches v4-core's accounting, including the failed-take path. The token is unmodified OpenZeppelin ERC-20. I did not run the project's full fuzz and invariant suites myself. Scratch files in /tmp were removed.

Added fee boundary, failure-path, redemption, reentrancy, and randomized accounting invariant tests under test/.

Verified offline: build passes; 77 tests pass, with zero failures or skips. No implementation defects were reproduced.

The review is complete. The findings file is written and valid, no tracked files were changed, and the scratch tests live under the ignored test/scratch directory.

Outcome: the fee math holds in every path I could reach. Two low findings are recorded in .imd-findings.json, one with a failing proof test.

What I verified in the math area

• Fee formula. All four swap modes in both currency orderings yield fee = floor(gross FWA / 20). The exact-output gross-up N/19 is algebraically equivalent, so the trader is never overcharged. Rounding favours the trader by at most 1 wei and gross below 20 wei pays nothing, which the README documents and which is dust with 18 decimals. I confirmed on mainnet that the paired token is Fake World Assets with 18 decimals.
• Delta accounting. The hook's FWA and native deltas net to zero on every branch of the conversion and payout, including a rejected ETH transfer, a manager with no ETH, and claim balances above 2^127, which are processed in chunks as the README says.
• Boundaries. Specified amounts at the int128 limit revert cleanly, the conversion price limit always sits strictly between spot and the owner's ceiling, the uint160 cast cannot overflow near the maximum price, and partial fills of FWA-specified swaps revert before any fee moves.

Findings

1. Low, with proof. The conversion sale inside every launch swap has no bound on ticks crossed, gas, or amount. On a tick-spacing-1 market that is thin above spot, anyone can seed one-tick dust positions across the 10% band. Measured gas per launch swap rose from about 372k to about 28.3M with 900 dust positions. The owner can mitigate by lowering the relative bound, and the likely production market has spacing 60, so I rated it low. The attached test fails on the current code.
2. Low, outside my area. The token's on-chain name is "Democratizing Collectable Acquisitions" while the brief says "Acquisions". Probably a corrected typo, but the requester must confirm so the manifest matches.

Coverage. All nine listed entry points have rows: eight hold, and afterSwap points at finding 1. Six extra rows record the invariants and boundaries I checked. One row is marked unreached: production market depth and the sandwich economics of the relative price bound, which belong to the economic specialist and need fork state.

The review is complete. The findings file is written and verified, and nothing else in the tree changed (git status shows only the ignored findings file and scratch tests).

Outcome: .imd-findings.json holds 4 findings and 14 coverage rows, one for each of the 9 listed entry points plus 5 invariant and economics rows. All cited snippets were checked against the tree. The existing 48-test suite passes unchanged.

Findings, most severe first:

• High, src/DCAHook.sol:261. The conversion's price limit is recomputed from the market's spot on every swap, and any swap re-sells the entire accumulated FWA claim backlog, including a 19-wei swap that pays zero fee. An attacker waits for a backlog (deferral is the normal state whenever spot sits above the owner's ceiling), then repeats dust swaps in one block. In the fixture, 4 free triggers sold a 19,865 FWA backlog while walking the market 43% past the configured 10% bound. The creator received 16,532 ETH-equivalent instead of 19,866, and the attacker bought the dip back for the difference. The proof test under test/scratch fails on current code with that shortfall. Suggested fix: anchor the bound per block and skip backlog sales when the triggering fee is zero.
• Medium, test/helpers/HookFixture.sol:93. The real FWA token on mainnet ("Fake World Assets") locks all transfers except owner, distributors, and PoolManager transfers covered by a transient allowance that only FWA's own hook bumps on its own pool. An ordinary router can neither pay FWA into the launch pool nor take FWA out of it. The repository models the wrong restriction (blocking transfers to the hook only), so every integration test passes on a path mainnet refuses. The hook's own claims-based fee path is unaffected. Verified on chain: the Universal Router is not a distributor. Needed evidence: the launch router is an FWA distributor or settles FWA as ERC-6909 claims.
• Medium, src/DCAHook.sol:227. Every swap reverts until the owner EOA configures a conversion pool, so the launch opens dead and trading liveness stays tied to that key and the chosen market. The guide's intended behavior is deferring the fee as claims, not blocking trades.
• Low, src/DCAToken.sol:8. The contract name is "Acquisitions" while the brief says "Acquisions"; the manifest's token name must match the deployed string either way.

Coverage notes: The fee arithmetic, hook-delta credit timing, FWA and ETH delta conservation, claim mint/burn branches, redemption re-entry guards and the unlock callback all traced clean. The static-analysis leads (unused getSlot0 return, redeemEth reentrancy) are benign and were not promoted. Not reached: a mainnet fork rehearsal against FWA's hooked pool, which the network restrictions of the verifier would not allow anyway.

The review is complete. The findings file is written at .imd-findings.json and nothing else in the tree changed (git status is clean apart from the ignored report).

What I did

I rebuilt the project, ran its 77 tests (all pass), re-ran both specialist proofs (both fail as claimed), fetched the verified source of the real FWA token and its hook from Sourcify, read live chain state, and wrote my own proof for the top finding. The thirteen specialist findings reduced to seven after merging duplicates and reproducing each one.

Findings kept, by severity

1. High. Fee conversion is sandwichable and the relative bound is meaningless within a block. The hook anchors its 10% price bound to the market's spot in the same transaction and sells the entire FWA backlog on any swap, including a 1 wei DCA sell that pays no fee. My proof shows an attacker gaining about 3,087 FWA for 1 wei of DCA while the creator receives 1,497 ETH for 5,000 FWA, and eight dust swaps moving the market price by 98% under a "10%" bound. Merged from economics and permissions.
2. Medium. The pool opens untradeable. Every swap reverts until the owner sends a separate configuration transaction, and trading remains coupled to the conversion route afterwards. The audit_flow proof is attached. Merged from three specialists.
3. Medium. The real FWA token blocks ordinary routers. Verified from the mainnet source: FWA refuses ERC-20 transfers to or from the PoolManager unless its own hook bumped a transient allowance, which only happens on FWA's own pool. The Universal Router is not a distributor on-chain. A buy or sell of DCA through a normal router reverts in both directions. The hook's own fee path is unaffected, but the launch needs evidence of a distributor or claims-based router. No proof attached since no change to this code can fix it.
4. Low. FWA fee claims have no exit other than an in-swap conversion.
5. Low. A tick-spacing-1 conversion market seeded with dust positions pushes each launch swap to about 28M gas. The audit_math proof is attached.
6. Low. FWA-specified swaps revert at a price limit instead of partially filling.
7. Low. Token name spelling differs from the brief. Merged from three specialists.

Coverage

All nine entry points are answered, plus three invariant rows. The static-analysis leads did not reproduce as defects and are recorded as holding with the reason.

All findings are answered, the code is revised, and every check passes.

Checks

What changed in the hook (src/DCAHook.sol)

• Sandwich / backlog dumping (high): fixed. The relative price bound is now measured from an anchor price observed in an earlier block, using the lower of anchor and spot, so a same-block spike defers the sale. A swap whose fee is zero sells nothing. Old claims sold beside a new fee are capped at four times that fee, so draining the backlog costs the trader a real fee paid to the creator. Configuring the market resets the anchor, so sales resume the next block.
• Pool untradeable before configuration (medium): fixed. Swaps no longer require a configured market. Without one, the fee is held as FWA claims. The market sale runs in try/catch with a 2,000,000 gas stipend, so a reverting, uninitialized or gas-burning market defers to claims instead of blocking trading. The supplied proof now passes.
• FWA claims had no exit (low): fixed with owner-only redeemPair(), which takes FWA from the manager straight to the fixed recipient and preserves claims if FWA refuses the transfer.
• Dust-tick gas griefing (low): fixed by the same stipend and backlog cap.
• Token name (low): fixed. DCAToken now returns the brief's exact spelling, "Democratizing Collectable Acquisions".

FWA transfer restriction (medium) cannot be fixed in this code. The FWA mock now implements the real guard, the fixture runs every integration test on it, a new test shows a non-distributor router failing both directions, and the README states that the launch needs a distributor router or a claims-based router before anyone can trade. The partial-fill asymmetry is answered as disputed, since v4 cannot refund a specified-side fee, with the router guidance the reviewer proposed added to the README.

Tests live in the new test/ConversionBounds.t.sol (sandwich scenario, same-block deferral, fee-free dust swaps, backlog cap, one-block bound, next-block promotion, reverting and gas-burning markets, redeemPair, FWA guard) and two rewritten tests in test/SwapFee.t.sol. README, docs/SECURITY.md and docs/VALIDATION.md describe the new bounds, the no-configuration behaviour, the FWA dependency and the updated counts. .imd-responses.json holds the seven verdicts.

Operator items that remain open: obtain evidence of an FWA-distributor or claims-based router before launch, and set the conversion market after launch. Nothing was committed; the working tree holds the revision.

Revised launch.json and verified it. Only that file changed; the scratch test lives under the ignored test/scratch directory.

What was wrong in the previous manifest

• The token name read "Acquisitions", but the brief and the accepted DCAToken contract both spell it "Acquisions". The manifest now matches the contract.
• The notes described an older hook. They said the owner must call setConversionPool before swaps can execute and that an unusable route can block swaps. The accepted hook never gates trading: every swap pays its 5% from the launch block, unsold FWA waits as ERC-6909 claims, and the market sale runs in try/catch with a gas stipend. The notes also omitted the owner-only redeemPair exit and the FWA transfer-guard router dependency.

What the manifest now states

• Hook contract DCAHook with constructor arguments $poolManager, $token, $factory, $owner in declaration order.
• Permissions beforeInitialize, beforeSwap, afterSwap, beforeSwapReturnDelta, afterSwapReturnDelta, exactly what getHookPermissions returns.
• Token DCAToken, name "Democratizing Collectable Acquisions", symbol DCA, 18 decimals.
• Pool paired with FWA at the required lowercase address, fee 12500, tick spacing 60, initial price "79228162514264337593543950336".
• Notes of 3274 characters describing the fee path, conversion bounds, ETH payout and claim fallback, the fixed recipient, the immutable owner powers, caller restrictions, and the FWA router dependency.

Checks run

• forge build passes and forge test reports 58 passed, 0 failed, 0 skipped.
• A scratch test parsed the manifest, deployed the real DCAHook at a flag-matching address, and confirmed the permission list, constructor placeholder order, token name and symbol and decimals from the real DCAToken, the pool fields, and the notes length. It passed.
• git status shows launch.json as the only modified tracked file.

The revision is complete. The suite passes with 95 tests across 14 suites, zero failures, and only paths under test/ changed.

What this round covered. The implementation was revised after my previous tests: it gained an owner-only FWA exit, a per-block price anchor for the conversion bound, a backlog cap, and gas-bounded market sales. My earlier tests still passed against it, so I left them alone and added coverage for the new mechanics only.

• New file test/AnchorAndPairExit.t.sol (7 tests). A market move made in an earlier block defers exactly one attempt and is then promoted as the anchor. A lowered spot tightens the bound to the spot rather than the stale anchor. Reconfiguration resets the anchor and restarts observation. A 400-case property shows no sale ever passes the owner's relative bound or absolute ceiling under same-block or earlier-block manipulation in either direction. The owner's FWA exit is tested with a separate owner and recipient (recipient cannot configure, owner receives nothing on either side), chunks above the signed-delta limit, moves only FWA while the ETH exit moves only ETH, and is refused from inside a foreign unlock without leaving a pending authorization.
• Extended lifecycle invariant handler. Three new random actions: direct market manipulation in both directions, block advances, and the owner's FWA exit with and without the token guard allowing the recipient. Every hook sale is now read from the market's own Swap event and checked against the bound from the promoted anchor and the ceiling. Conservation now includes FWA paid out by the owner's exit. The end-of-campaign liveness check drains the backlog at the capped pace across fresh blocks and requires anything left to clear through the owner's exit.

Results. The lifecycle campaign ran 256 sequences of 64 calls with zero unexpected reverts on the default seed and two extra seeds. Coverage of the hook is 99.40% lines and 92.68% branches.

No defect found. I wrote no findings file. Two things I examined are design limits already stated in the README rather than defects: the one-block anchor defers conversion when a market is held above the bound across a block boundary, and an owner-chosen conversion market with its own hook is trusted by the owner, who per the README is the same wallet as the recipient. I recorded both in test/CONTRIBUTOR_TESTS.md along with the updated pass and coverage figures.

Review complete. The findings file is written and validated.

Earlier findings, settled against the revised code

• Same-block sandwich and backlog dump (high): fixed as reported. Fee-free swaps sell nothing, the backlog sold per swap is capped at four times the new fee, and the bound is measured from an earlier block. The author's tests pass. A residual two-block variant remains, reported below.
• Pool untradeable until setConversionPool (medium): fixed. The gate is gone from _validateSwap, the fee is minted as claims without a market, and the sale runs in try/catch. My attached proof now passes.
• Real FWA guard (medium): addressed as asked. The mock now implements the verified guard, the fixture runs on it, and the README documents the distributor or claims-router dependency.
• No FWA exit (low): fixed by owner-only redeemPair, which takes straight to the recipient and keeps claims on a refused transfer.
• Gas griefing (low): fixed by the 2,000,000 gas stipend in try/catch. The earlier proof now passes.
• Partial fill (low): dispute accepted and dropped. The mitigation is in the README.
• Token name (low): fixed to the brief's spelling. The manifest matches.

The full suite passes with 95 tests, and the hook is well under the size limits.

One new finding (medium), with a self-contained proof at test/scratch/Proof_AnchorJump.t.sol. The anchor is promoted wholesale from the previous block's observed spot, with no bound relative to the prior anchor. A trader who pushes the market up in block N, records it with a 20 wei buy, and holds one block gets that price as the full reference in block N+1. On a 5,000 FWA backlog the hook sold 6,250 FWA for about 1,859 ETH worth, and the attacker netted about 965 FWA. The README's claim that the anchor shifts at most the configured bps per block is not what the code does. I verified on a patched copy that ratcheting the promotion by the bound makes the proof pass and leaves the attacker at a loss.

Coverage answers all ten entry points, nine holding and afterSwap carrying the finding, plus rows for the settled findings, the manifest, and the static-analysis leads, none of which reproduced as defects.

The finding reproduced exactly and is fixed. The revision touches the anchor promotion in the hook, adds four regression tests, and corrects the documentation.

Reproduction. I rebuilt the reviewer's scenario in test/scratch against the accepted code. The anchor was promoted wholesale to 1.8×Q96 after a one-block hold, the whole 5,000 FWA backlog plus the 1,250 FWA trigger fee was sold into the spike, the creator received about 1,859 ETH for 6,250 FWA, and the attacker netted about 965 FWA. These match the reported numbers.

Fix in src/DCAHook.sol. The promotion of the observed price into the anchor is now ratcheted. When the observation is above the previous anchor, the anchor rises by at most one sqrt(1 + maxPriceMoveBps/10000) step. A lower observation is still adopted in full, since a lower reference only tightens the sale. The step factor is shared with the sale bound through a new internal helper. I also closed the adjacent window the suggested patch left open: sale attempts in the configuration block, when the anchor is still zero, no longer record spot, so a trade back-running the owner's setter in the same block cannot seed the first anchor. With the fix, the same proof ends with the anchor at 1.0488×Q96, all 6,250 FWA still held as claims, no ETH paid cheaply, and the attacker down about 3,366 FWA.

Tests added to test/ConversionBounds.t.sol:

• the cross-block hold scenario from the finding, asserting the one-step anchor, no sale, and attacker loss
• a genuine 1.3× sqrt-price rise followed in five one-step promotions before conversion resumes
• a genuine fall adopted at once, never ratcheted
• a back-run of the configuration setter that cannot seed the first anchor

Documentation. The README now describes the ratchet, the catch-up rate for genuine moves, and the remaining caveat that a trade front-running the setter in the same block still sets the configured price. SECURITY.md and VALIDATION.md were updated to match. The response for the reviewer is in .imd-responses.json with verdict fixed.

Checks run:

The protected verifier tests were read but not executed here, as before. The forge lint notes on the hook are the same guarded-callback patterns already reviewed in SECURITY.md. Nothing was committed, matching the previous rounds where the harness recorded the commit.

The manifest is updated and verified. Only launch.json changed.

What I found. The previous round's launch.json already matched the accepted tree in every structural field: contract names DCAHook and DCAToken, constructor order $poolManager, $token, $factory, $owner, the five permissions, the FWA pair address in lowercase, fee 12500, tick spacing 60 and the one-to-one initial price. The only hook change since the manifest was written is the latest contributor commit, which ratchets the conversion anchor so it rises by at most one bound step per block. The notes still described the older anchor.

What I changed. One clause in the notes now describes the ratcheted anchor: it is observed in an earlier block, rises by at most one bound step per block, falls at once, and a spike held across blocks still defers the sale to claims. Nothing else in the manifest moved. Notes are 3385 characters, under the 4000 cap.

Verification.

• forge build passes.
• The full suite passes with 62 tests, plus one scratch test I added under test/scratch that deploys DCAHook at a mined address and asserts its getHookPermissions equals the manifest's permission list and that every manifest field matches the brief. That scratch file is not submitted.
• A JSON check confirmed the first key is "kind": "univ4_hook", only schema keys are present, fee, tickSpacing and decimals are numbers, initialPrice is a decimal string below 2^256, all addresses are lowercase, and no stand-in address appears.

No placeholder gaps remain. The hook needs no address beyond $poolManager, $token, $factory and $owner, and the fee recipient is the wallet the brief names, hardcoded in the hook.

The findings file is in place at the repository root and is excluded from git by the harness's own rule, as intended. Work is complete.

Summary

The implementation changed under my tests. The other contributor replaced the wholesale anchor promotion with a ratchet (at most one sqrt(1 + bps/10000) step upward per promotion, unbounded downward). One of my accepted tests encoded the old behaviour and failed. This revision changes only what that required and adds coverage of the new logic.

Changes in test/:

• AnchorAndPairExit.t.sol: the stale test now expects one capped step per block for a held 12% move (two deferrals, then sale, then exact catch-up). The 400-case fuzz property additionally asserts the first anchor is the configured price and no promotion exceeds one step. A new test counts the deferral a held dip causes (seven blocks for a 0.7x dip) and checks recovery with no lost fees.
• helpers/ClaimLifecycleHandler.sol and ClaimLifecycleInvariant.t.sol: a ghost model of the ratchet checked after every trade and as a new invariant: anchor changes only inside a trade or configuration, first value equals the configured price, at most one step up per promotion, at most one change per block. The deterministic sequence was retuned to a move that is over one step but under two.
• CONTRIBUTOR_TESTS.md updated.

Result: forge build clean, forge test 100 passed, 0 failed, 0 skipped across 14 suites (256 invariant runs × 64 depth, fail-on-revert, 0 reverts).

Defect reported, not tested around (.imd-findings.json, with a self-contained proof that fails now):

• Medium. A promotion happens on any fee-bearing swap, and a 20-wei buy pays a 1-wei fee. An attacker holding a 1.8x spike walks the anchor up in 13 blocks for 13 wei total, then a 25,000 FWA buy makes the hook sell 5,820 FWA into the spike for 1,735 ETH. The attacker nets +666 FWA. This is the reviewer's round-2 attack delayed, not prevented; the README's claim that each step costs a 5% fee describes 1 wei. The owner's absolute ceiling is the only bound that holds.
• Low. A dip held across a block is adopted in full, letting a griefer defer conversion for several blocks at their own cost. Tested with the count asserted and noted as a liveness limit.

Review complete. The findings file is written and validated.

Round-2 finding (one-block anchor jump, e68c2cbaa4ce): fixed. I re-ran the round-2 steps on the revised code. The anchor now rises by at most one sqrt(1.1) step per promotion, nothing is sold into the held spike, the creator's ETH is untouched and the attacker ends with less FWA than they started with. The author's own test covers the same scenario.

Specialist findings from the prior panel, settled against this code:

• Trading gated on setConversionPool (three reports): fixed. Unconfigured swaps now mint the fee as claims. The attached proof passes.
• No FWA exit for stranded claims (two reports): fixed by owner-only redeemPair(), which pays only the fixed recipient.
• Dense-tick gas griefing: fixed by the 2,000,000 gas stipend in try/catch. The attached proof passes at 210,804 gas.
• Same-block sandwich and fee-free backlog dump: fixed by the fee-free skip, the 4x backlog cap and the earlier-block anchor.
• Token name: the contract and manifest now carry the brief's spelling.
• FWA-specified partial fills and the real FWA transfer guard: design limits outside the hook's control, now documented. Dropped as defects.

One new finding, low. The tester's 13-block dust walk reproduces exactly as described. One 20 wei buy per block, paying 1 wei of fee, promotes the anchor one step per block, so a spike held for 13 blocks under a 4x ceiling is eventually sold into. The attacker's gain matches my round-2 numbers delayed by twelve blocks, which is the limit the ratchet was designed to impose. The documented guarantee holds. What does not hold is the README's cost claim that each promotion swap pays a meaningful 5% fee. With the ceiling set one step above spot, as the README advises, the same walk loses the attacker about 3,031 FWA, so the absolute ceiling is the binding defence. The fix is documentation, with an optional minimum-gross threshold for recording an observation. I merged the tester's dip-pin griefing report into it as the same root cause.

Coverage answers all ten entry points plus six checked invariants. The full suite passes (100 tests). No repository files were changed; scratch tests live only under the ignored test/scratch directory.