The review is complete. No tracked file changed; the only new files are .imd-findings.json and the proof under test/scratch/.

Outcome: one high-severity defect, two lows, three informational notes. All 17 existing Annex tests pass, but they never parse the oracle body, which is where the defect hides.

High. requestAdmission always sends malformed JSON. admissionBody inlines the hook list inside the JSON question string as Hooks: ["0x..","0x.."] with raw double quotes. The question string closes at the first address, so a strict parser rejects the document. I dumped the real body and confirmed it with Python: it fails at character 580. The oracle-consumer reference says a refused body spends the price and never reaches the callback. So every admission request burns the asker's IMD, and no hook with swap permission bits can ever be admitted. There is no owner to repair it. The live judge avoids this by keeping ids only in guards.allow with a quote-free question. The proof test at test/scratch/AnnexBodyJson.t.sol runs a minimal strict JSON validator over the body. It fails on the current code and will pass once the quotes are escaped or dropped.

Low. post stores the uint256.max sentinel as postBalance when the author's balanceOf read fails, which guarantees a VoidSold forfeit on a BUY call. The hook reverts the post in that case.

Low. The launch.json in the tree is the hook launch's univ4_hook manifest. For this contracts-only launch it is schema-invalid and names no MarginaliaAnnex entry. The correct four constructor arguments are spelled out in the finding.

Info. hookAllowed ignores the dynamic-fee rule that only validateVenue enforces, though the integration guide points agents to it. The immutable Intake pin is version 1 while the reference recommends version 2. The coverage note lists what was read and verified.

Verified locally: runtime size is 24,001 bytes with 575 bytes of EIP-170 headroom, the constructor makes no external calls, no forbidden opcodes or admin paths exist, swap-flag bits match v4, and the observation, settlement, forfeit, counter-call and callback logic mirror the hook correctly.

Could not be reached: the live hook, Intake, pricer, PoolManager and guard hook on mainnet, since this environment has no RPC. Their behavior is assumed from the repo source and the pinned references.

Work is complete. The diff touches six files and every check passed.

What was done

• Malformed admission JSON (high, reproduced). The question string in admissionBody embedded the quoted hook list, so the body was not JSON and every admission request would have spent the asker's IMD for nothing. The question now names hooks bare, and guards.allow keeps the quoted list. The new testAdmissionBodyIsStrictJson parses the body with forge's strict JSON cheatcodes for one, two and four hooks. The callback was not touched, and it measured 167,201 gas at the full four-hook list.
• Unreadable balance on a BUY call (low, reproduced). A failed balanceOf read stored the sentinel as the post balance, which could only settle VoidSold. The post now reverts in that case, matching the hook. The regression uses a token whose read reverts for the author.
• Stale manifest (low, reproduced). The old hook-launch launch.json is removed, since the manifest step writes the new one. README states the four constructor values for that step.
• Fee-blind public predicate (info, reproduced). New view hookAllowedFor(hook, fee) carries the dynamic-fee rule, and validateVenue now calls it so the two cannot drift. AGENTS.md documents it. Two tests cover the guard, hookless, Marginalia and taxing hooks at static and dynamic fees, including an admitted hook passing the gate.
• Immutable Intake and signer (info). Left as the brief fixes them. Live reads over a public RPC confirmed the Intake price is 0.5 IMD, the hook exposes the interface the Annex reads, and the guard, pricer and Intake have code. Recorded as trust assumptions in ADAPTATION.md.

Verification

The fork suite was not run because no mainnet RPC is configured in the environment. The constructor still reads no chain state, takes four static arguments, and nothing in the build configuration or dependencies changed.

The review is complete. The findings file is written and validated, and no tracked file was changed.

What I found, written to .imd-findings.json with coverage rows for all 50 listed entry points plus three invariant rows:

1. High: one atomic adverse reading forfeits a RIGHT v4 call. Settlement takes the single most adverse observation, and an observation is the pool's spot at the moment observe runs. An attacker can dump, observe, and restore inside one PoolManager unlock, so no block passes and the only cost is the round-trip LP fee. The proof test shows a BUY call that traded 32% above its baseline all window settling Wrong, the 2 IMD bond forfeited and 0.2 IMD paid to the manipulator. The hook's own lines carry the same rule. A proof file is attached and fails on the current code.

2. Medium: post has no bound on the baseline it records. The baseline is read from the posting block's spot after the funds are pulled, and only the MARG leg has a user bound. A same-block pump before the post records 1.32 as the baseline while the real price is 1.00. X then rises 25% and the +20% call still settles Wrong. Proof attached, fails on the current code.

3. Low: the hold rule reads balances literally. A token whose balance shrinks without a transfer, such as a negative rebase, turns a held BUY call into VoidSold and forfeits the bond. Reported as a documented limitation to decide on, with a concrete reproduction.

Coverage. All nine Annex entry points were traced in depth: bond, target, horizon, text and admission bounds, window ages, the 25:35 MARG split rounding, keeper split, difficulty floor, and overflow headroom on the settle comparison all hold. The hook's fundPot, beforeSwap and afterSwap hold on the Annex's quiet-buy path. Judge, Pages, Router and Treasury entry points are marked unreached as outside this area.

Checks run. The Annex suite passes 20 of 20. Both scratch proofs fail for the stated reason. Static-analysis leads in my area were examined and none substantiated as findings on their own.

Done. launch.json is written at the repository root and is the only changed file.

Manifest contents

• Kind evm_contracts, one contract: MarginaliaAnnex.
• Constructor arguments in declaration order, matching the compiled ABI (address hook_, address intake_, bytes32 action_, address signer_):
  1. 0xf0457dd0cf526686190e4f057ba19db14d34a0cc, the live MarginaliaHook of launch 1283.
  2. 0x1397434cd35e8a9C8aC312A61D3A285EB31dea56, the IdentityMD Intake.
  3. 0x6f7261636c652e72657175657374406f7261636c652d31000000000000000000, which is bytes32("oracle.request@oracle-1") as a static word.
  4. 0x5598Aa9146215Bc13eb26f2c692Ad1461Fd32982, the IdentityMD oracle signer.
• These equal the hook's INTAKE, ACTION and ORACLE_SIGNER constants in src/MarginaliaHook.sol.
• No $owner: the Annex has no owner, pause or upgrade, and its constructor takes no owner argument.
• Notes describe the venue rule, admission, economics and the pricer address in about 2,000 characters.

Verification

• The manifest parses as JSON with exactly the keys kind, contracts and notes.
• The constructor stores four values and reads no chain state. The signer setter only rejects zero and emits an event.
• forge build succeeded.
• forge test --match-path test/Annex.t.sol passed every test: 20 passed, 0 failed. The brief says 17; the accepted tree carries 20.
• Compiled Annex runtime is 24,293 bytes, under the 24,576-byte EIP-170 limit the protected check enforces.
• git status shows only the new launch.json.

The review is complete and the findings file is written. Working tree shows no tracked changes beyond the untracked findings file and the scratch tests (.imd-findings.json and test/scratch/ are ignored or untracked, as intended).

Summary

I audited the MarginaliaAnnex economics against the Economic Security, Invariant and Flow Gap guides. The shipped Annex suite passes as is. I reported four findings, one medium with a failing proof test, three low, and a coverage row for all 51 listed entry points plus three invariants.

Finding 1 (medium, with proof). Whoever controls a venue's active liquidity can turn a WRONG call into VoidNoData and recover the bond. The pricer reverts EmptyPool when active liquidity is zero, so every observe fails for the whole six-hour window. settle then takes the under-three-readings branch, books VoidNoData, skips the forfeit, and claimDeposit returns the full bond. The hold rule is checked after the count check, so a BUY author who sold also escapes VoidSold this way. This costs nothing: the LP removes the position at the horizon and re-adds it after the window. On the Annex's target venues, a launched token behind the guard hook with the project as sole LP, this is the normal state. The proof test at test/scratch/AnnexEconomics.t.sol fails on this tree with a 10 IMD bond returned instead of 9 IMD to the pools and 1 IMD to the settler.

Finding 2 (low). A stranger can pump, checkpointVenue, and unwind in one transaction. The pumped reading becomes the BUY baseline for the rest of the live window. Measured on the fixture: baseline 1.69x the real price, repeatable every six hours. Denial of posting, not loss. The live router shares this.

Finding 3 (low). The author can settle their own forfeit and keep the 10% keeper cut, so a WRONG bond costs 90%, and retract is strictly dominated on money.

Finding 4 (low). requestAdmission uses request without a failure path. A disagreeing panel spends the asker's IMD silently and the request stays pending forever.

Checked and holding. Post pulls exactly stamp plus buy plus bond, the 25:10 split with minMargOut on the author share, post balance read after the take, baseline nonzero, counter rules, callback access, oracle verification and admit-only-asked-and-named, forfeit split, and the IMD balance invariant. The atomic dump-observe-unwind on v4 venues is documented as accepted design in SPEC.md and README.md, so I did not report it.

The review is complete. Findings are in .imd-findings.json (one finding, 51 coverage rows, snippet verified against the tree).

Outcome

The MarginaliaAnnex control flow holds up well. I traced every Annex entry point from input through guards, external calls and state writes (Execution Trace, Periphery and First Principles passes), and found one substantiated defect, which I rated low.

• Finding 1 (low), post() at src/MarginaliaAnnex.sol:274. The author can bound the MARG they receive and the deadline, but not the baseline the call is judged against. The baseline is read from the venue's spot after funds are pulled, so a same-block pump before the post and an unwind after it leave the author with an unwinnable call. Reproduced in test/scratch/AnnexProbe.t.sol: honest baseline 1.00, baseline seen by the post 1.69, price after unwind 1.00, call settles WRONG, settler takes 0.2 IMD of the 2 IMD bond. The attacker's swap fees exceed the bounty, so this is griefing rather than profit, and the README already documents the observation-side analogue. The Annex has no seal to mitigate it; a maxBaseline/minBaseline argument would close it in a few dozen bytes.

Leads checked and closed

• Callback stipend: 171,362 gas with an EOA signer and 178,500 gas with an ERC-1271 contract signer at the full four-hook list, both under 200k. I could not confirm whether the mainnet signer has code because the public RPC was unreachable, so I measured both paths.
• EIP-712 digest and callback selector match the protocol vector for the Annex deployed at the vector address.
• The body key guards.mustHaveCode is valid: the repo's paid probe used it and was attested.
• Hook permission constants match v4's library bit for bit. The guard hook carries only bit 13.
• Runtime is 24,293 bytes, 283 bytes under EIP-170.
• Static-analysis leads in the Annex (strict equalities, uninitialized locals, reentrancy-after-call) are all benign on inspection: statuses are written before external calls, every externally-triggered callback is sender-gated, and no approval residual survives.

Coverage. Every Annex entry point is holds except post (finding 1). Hook entry points the Annex depends on (fundPot, beforeSwap/afterSwap on the quiet-buy path, beforeInitialize, unlockCallback ACT_FUND) are holds for the traced path. Router, Judge, Pages and Treasury entry points are marked unreached as outside my area. The whole local suite passes: 287 tests including the scratch probes.

Review complete. The findings are in .imd-findings.json at the repository root. No source files were changed; the only additions are the findings file and a scratch test under test/scratch/, which is not kept.

Outcome for the assigned area (Access Control, Trust Gap, Asymmetry on MarginaliaAnnex): no permission bypass, no confused-deputy path over the held bonds, and no mirror-update gap between the Annex and the hook. Two items are reported, neither blocking.

• Low, trust-gap seam in observe and settle. Anyone may observe from inside a PoolManager unlock, an adverse reading is never displaced, and the settler earns 10% of a forfeit. One transaction of dump, observe, rebuy turned a BUY call that the market confirmed at +30% into WRONG, and the settler collected 1 IMD of a 10 IMD bond. On the deep fixture pool the attacker burned about 15.7k X in fees for that reward, so it pays only on thin pools or for someone selling anyway. This is the hook's own rule as the brief specifies it, so it is reported as an inherited design trade-off with the pricer's "pump-observe-unwind moves neither rule" claim being one-sided.
• Info, trust assumption. Signer, Intake v1 and action are fixed with no rotation path. A signer rotation or Intake retirement kills admission permanently while requests keep charging the price. The brief mandates these constants, so this is documentation, not a defect.

Leads closed with evidence: the live oracle signer is an EOA on mainnet, so no ERC-1271 gas lands on the 200k callback. The body keys the Annex sends match the live Judge and the probe job. Gas-starving the bounded balanceOf read in observe is arithmetically infeasible. Runtime size is 24,293 bytes, 283 under EIP-170. All 20 Annex tests pass.

Coverage: every Annex entry point is holds or finding. Hook functions the Annex depends on are holds. Judge, Pages, Router and Treasury entry points outside the area are marked unreached. No launch.json exists yet, so the manifest could not be reviewed.

The findings file is in place and excluded by the repository's own .git/info/exclude, which is how the harness expects it. The work is complete.

Outcome. The full suite passes: 307 tests, 0 failures, 1 skipped (the fork test, by design). The delivered test/Annex.t.sol is untouched and still passes its 20 tests. I added two files under test/ and wrote three low/info findings to .imd-findings.json. No critical or high defect was found, so no proof files were needed.

New file: test/AnnexAdversarial.t.sol (23 tests, all failure paths the delivered suite did not walk)

• Deployment shape: the constructor stores four values against addresses with no code, refuses each zero value, and the runtime of a fresh deploy sits under EIP-170.
• Exact boundaries: BUY 11000 posts and 10999 does not, SELL 9000 and 9001, horizon 90 and 91, bond 0.25 and 10 IMD and one wei outside, text of 280 and 281 bytes, deadline now versus one second ago.
• Money paths: slippage and unfunded authors take nothing, the 25:10 split is exact integer arithmetic with no MARG or claims retained, unlockCallback refuses a direct caller and a stranger who holds the PoolManager lock.
• Price windows: too young, exactly one hour, extended without resetting, expired after six hours, restarted and refused in its own block.
• Settlement: SELL right (the author sold through the horizon) and SELL wrong, the most adverse reading decides, three readings inside an hour are no data, a more adverse reading replaces the last and a breach is never replaced, the 16-reading cap and the reserved last slot, every refusal on unknown, closed and hook-owned ids.
• Hold rule: gifts count as held, a balance read that starts failing after the post settles VoidSold.
• Scoring: exact difficulty from the pricer, retract is half, a 10 IMD bond scores the same as a 1 IMD bond.
• Counters: retracted, settled, thesis and hook-retracted parents are all refused, and a counter leaves the parent untouched.
• Admission: each attestation field at its refusal edge (expired, future, wrong key, wrong domain, panel 4, quorum 3, agreed below quorum, wrong answer types), an empty answer is stored not reverted, one oracle UUID serves one request, list and price rules, the asker never spends the bonds, the cold full-list callback fits a 180k gas limit, and the protocol's signing vector reproduces the digest and canonical selector.

New file: test/AnnexInvariant.t.sol (handler plus six invariants, 96 runs by inline config)

• The handler posts on both venues, trades, moves X, observes singly and in full series, settles as a keeper, retracts, claims, and runs admissions through the mock Intake with signed answers, keeping its own ledger.
• Invariants: IMD held equals the deposits recorded equals the ledger, bonds in equal held plus claimed plus keeper plus pools, no MARG retained, statuses never reopen and deposits match status, records count outcomes once, admission is permanent.

Findings reported (.imd-findings.json, none severe)

• Low: noteOf returns an empty view with status Open for unknown ids where the hook reverts.
• Low: an author who controls all of a venue's liquidity can pull it during the window and recover a falsified call's bond as VoidNoData. The hook shares this rule.
• Info: the full-list callback needs between 160k and 170k gas, bisected with gas-bounded calls.

One thing worth knowing for anyone extending the handler: with via_ir the compiler caches block.number within a function, so a second vm.roll computed from it is a no-op. The handler uses vm.getBlockNumber() and vm.getBlockTimestamp() throughout for that reason.

The review is complete and .imd-findings.json holds the result.

Verdict on the specialist audit. Thirteen specialist findings reduced to seven after reproduction and merging. Nothing was dropped as irreproducible except the callback-gas headroom note, which reports no defect. One finding was raised, one lowered.

Findings kept, by severity:

1. High. One atomic dump, observe, rebuy inside a single PoolManager unlock forfeits a right call and pays the attacker 10% of the bond. Merged from audit_math and audit_permissions. My self-contained proof at test/scratch/AnnexFlashAdverse.t.sol fails on this tree: status Wrong, 0.2 IMD to the attacker, price restored within 0.2% in the same transaction. The rule is inherited from the live hook, but the pricer's stated guarantee is broken in the only direction that moves money.
2. Medium. Whoever holds a venue's in-range liquidity removes it for the six-hour window, every observe reverts EmptyPool, and a wrong call settles VoidNoData with the whole bond returned. Merged from audit_economics and the test writer. Confirmed in a scratch test with a 10 IMD bond.
3. Medium. The post baseline is the posting block's spot with no author-side bound. A same-block pump before the post, or a pump-checkpoint-unwind on the window, makes a BUY call unwinnable. Merged from three specialists. Confirmed in a scratch test: baseline recorded 1.32 against an honest 1.00.
4. Low. The author can settle their own forfeit and keep the keeper cut.
5. Low. Admission relies on Intake v1 with no failure callback, no deadline, and a signer fixed forever. Merged two reports into one documentation-level finding.
6. Low. The hold rule treats any balance decrease as a sale, so rebasing tokens forfeit held BUY calls.
7. Info. noteOf returns an empty Open view for unknown ids instead of reverting like the hook.

My own checks found no additional defect. The runtime is 24,293 bytes with no forbidden opcodes, the creation code with arguments is well under the 49,152 limit, the manifest uses only schema keys with the four constants the brief names, the constructor reads no chain state, and the unlock callback is reachable only through the Annex's own unlock. All 44 existing Annex tests pass.

Coverage. All 48 entry points have rows: 18 hold, 10 carry a finding, 20 are honestly unreached. The unreached rows are the live Judge, Pages and most of the Hook and Router, which are outside this launch's manifest.

The responses file is in place (git's local exclude list hides it from status, which is the harness's own setup). Build and tests are green. Work is complete.

Recap

All three reopened findings reproduced against the accepted code and are fixed in src/MarginaliaAnnex.sol. Runtime is now 24,501 bytes, 75 under EIP-170.

Fixed (reproduced first, each with a kept regression test in test/Annex.t.sol):

• Flash dump-observe-rebuy (high). The attacker contract settled a RIGHT call Wrong and took 0.2 IMD. Now observe and checkpointVenue revert Unlocked whenever the PoolManager's transient lock slot is set, so no price is read from inside anyone's unlock. The "most adverse decides" rule is untouched. The residual, a three-transaction builder bundle, is stated plainly in ADAPTATION.md since the live hook shares it and the brief fixes the rule.
• Emptied venue refunds a wrong call (medium). Pulling liquidity gave VoidNoData and returned 10 IMD. Now an observation on a venue with zero in-range liquidity records a priceless reading, ranked above any price, and settle treats it as adverse: Wrong, or VoidSold on a sold BUY. Genuine no-observer windows still refund.
• Sandwiched baseline (medium). A same-block pump set the baseline 32% high and the call settled Wrong. post now takes a sixth argument, baselineBound, checked right after the baseline read, reverting Slippage with nothing taken. Zero keeps the old behaviour. The checkpoint path is closed by the same unlock rule. AGENTS.md and README.md document the new signature.
• noteOf on unknown id (info). Now reverts NotOpen, matching the hook.

Disputed with documentation, no code change: author settling their own forfeit (a second wallet bypasses any exclusion), Intake v1 trust assumptions (the brief pins them), and rebasing-token hold-rule behaviour (now a stated limitation in AGENTS.md).

Verification:

Not run: the mainnet fork suite, since no RPC URL is set. .imd-responses.json answers all seven findings.

The findings file is excluded by the network's own .git/info/exclude, so it is read from the working tree as the brief intends. The proof still fails on the current code. The work is complete.

Recap

What changed in the implementation after my last round, and what I did about it. The revision added a sixth baselineBound argument to post, refused reads while the PoolManager is unlocked, made a zero-liquidity venue record a priceless reading that settles WRONG, and made noteOf revert on unknown ids. My two suites no longer compiled. I adapted them and left the rest as accepted.

Files touched (only my two test files):

• test/AnnexAdversarial.t.sol: signature fixes, noteOf now asserted to revert for hook ids, unknown ids, zero and the next unissued id. Five new tests: the bound is inclusive at the quoted baseline and refuses one wei inside with nothing taken, zero and extreme bounds are no constraint, each side is bounded against its own window extreme, priceless readings rank below a hold breach and above any price and are never replaced by one, two priceless readings still settle as no data, and an LP pull cannot turn a wrong call into a refund.
• test/AnnexInvariant.t.sol: the handler now posts with a bound quoted from the contract (exact on the X venue, 1% slack on MARG), lets the venue's LP pull and refill both positions, prefers a live window when observing, and checks a reading is priceless exactly when the venue has no liquidity. All six invariants held over 96 runs of 48 calls, including sequences with priceless readings and forfeits.

Results. forge test passes with 318 tests across 24 suites. test/Annex.t.sol alone passes its 26.

Finding reported in .imd-findings.json, with a self-contained failing proof. The new rule reads zero in-range liquidity as a pulled pool, but v4's getLiquidity is the liquidity at the current tick. When the price runs past the last tick of a concentrated position, which is what a correct BUY call on a thin launch pool looks like, every reading is priceless and the right author settles WRONG, losing the whole bond with 10% to the settler. The pre-revision code refunded that case. A third party can also now hurt a call by moving the price in the call's own direction past the range edge for one standing block, which the old rule could not do. The proof posts a 10 IMD BUY call, buys through the range, observes three times, and shows status Wrong with 1 IMD to the settler. Rated high.

Second item, info only. On the MARG venue the post's own 0.35 IMD purchase moves the spot before the baseline is read, so a BUY call bounded at the exactly quoted postPrice reverts Slippage there. The invariant handler surfaced this. AGENTS.md already says to allow a few percent, so it is a documentation nuance, not a code change.

Not run. The fork test needs an RPC and was skipped. No Slither or Mythril ran.

The review is done and written to .imd-findings.json. The scratch proof is under test/scratch/, which is not kept, so the tree shows no other change.

Settlement of my earlier findings

• cc1b37a1 (high, atomic dump-observe-rebuy): fixed. observe and checkpointVenue now read the manager through _lockedManager, which reverts Unlocked when the PoolManager's transient lock slot is set. The slot matches the vendored v4-core Lock.sol, and the author's two regression tests pass. The stated residual holds: a builder bundle of three separate transactions in one block is not an unlock, as on the live hook.
• baf2967b (medium, LP pull turns a wrong call into a refund): fixed for the reported state, but the fix over-reaches. See the new finding below.
• 552c2633 (medium, unbounded post baseline): fixed. post takes baselineBound; a sandwiched post reverts Slippage and the whole transaction unwinds, so nothing is taken. The checkpoint path is closed by the same Unlocked rule.
• 7842833a (info, noteOf on an unknown id): fixed. It now reverts NotOpen.
• 7c77dba1, 0869bd11, dfe3edd0 (low, disputed): each still reproduces as described and is now documented. The brief fixes the keeper rule, the Intake version and the constants, so I dropped them as defects.

Findings this round

1. High, src/MarginaliaAnnex.sol line 333. The revision reads zero in-range liquidity as a pulled pool. v4's getLiquidity is also zero when the price has moved past the only position's range with every LP still in place. That is what a correct BUY call looks like on a single-range launched pool once it sells out above target. My standalone proof posts a +20% BUY call, buys the pool past tick 6000, takes three readings, and settles: expected Right with the bond back, actual Wrong, 1 IMD to the settler, 9 IMD to the pools. Before the revision the same state refunded as VoidNoData, so this is a regression, and a third party can trigger it by pushing the price in the call's own direction for one standing block. The proof fails on this tree for that reason and is attached.
2. Info, line 259. On the MARG venue the post's own 0.35 IMD purchase lands before the baseline is read, so a BUY call bounded at the exactly quoted postPrice reverts Slippage. Measured: quoted 1.0e18, recorded 1.000000069e18. Documentation nuance only.

The specialists' other findings were pre-fix reports of the same root causes as cc1b37a1 and 552c2633 and are merged into those settlements.

Coverage: all 48 entry points have a row. The nine Annex entry points, the three MARG token functions and MarginaliaHook.fundPot are traced. The remaining live hook, judge, router, treasury and the not-yet-launched Pages entry points are marked unreached, since they are outside this launch and I did not re-trace them this round.

The revision is complete. The reopened finding reproduced and is fixed; the advisory one reproduced and is documented with a pinned test.

The high finding, reproduced and fixed. The reviewer's scenario failed on the unchanged tree exactly as described: a right BUY call whose pool sold out above its target settled Wrong, paid the settler 1 IMD and refused the claim. The cause was that v4's current-tick liquidity reads zero past a range's edge as well as on a pulled pool. The fix in src/MarginaliaAnnex.sol replaces the priceless reading with a standing-price read. A new private _spot helper prices the pool's slot0 through the pricer's own fromSqrt when nothing is in range, with the quote leg read the same way the pricer does. The pull-liquidity closure from the previous round stays, since an emptied venue is read rather than voided.

A flaw I caught in my own first draft. Past the last initialised tick a swap moves the price for nothing, so a keeper could push a sold-out pool to an extreme the pricer cannot express and still plant an adverse "no price" reading. The standing sqrt price is therefore clamped into the pricer's expressible range before it is read. An extreme reads as the extreme itself, adverse to one side only, and nothing is ever a missing reading. The dead priceless branches in settle and the adverse ranking were removed.

Size. The fix pushed the runtime over EIP-170, so I made behaviour-preserving reductions in the same file: a shared bounded read helper, literal panel numbers in the admission body with byte-identical output, a simpler form of the same hook predicate, two dead checks removed, and an unused return value dropped. Runtime is now 24,493 bytes with 83 bytes of headroom. The callback measures 167,188 gas at the full list and its write-set is untouched.

Tests and docs.

• test/Annex.t.sol: three new tests (the reviewer's sold-out scenario with free pushes both ways, a pulled pool pushed to both extremes where a keeper's reading decides, and the MARG-venue baseline note), one updated to the standing-price rule.
• The advisory MARG-venue finding reproduced, and the reviewer asked for documentation only. AGENTS.md now names the MARG venue as the one where the exactly quoted bound is refused, and describes the free-swap residual on pools with no positions.
• ADAPTATION.md has a new top section listing each change, why it was needed and the residual. .imd-responses.json answers all eight finding ids.

Verification.

• forge build clean. Annex suite: 29 passed. Full local suite outside scratch and fork: 291 passed.
• The supplied protected contracts floor ran in scratch against the new creation code with the four constructor arguments and passed.
• Not run: the mainnet fork suite, since there is no RPC in this environment. No build configuration, dependency, git or environment path changed, and there is no launch.json in the tree.

Updated Annex regressions and invariants for empty-pool observations, sold-out SELL calls, and hold breaches. A bytecode-equivalent fixture change resolved compiler memory failures. All changes are under test/.

Validation: forge build passed; forge test reported 324 passed, 0 failed, 1 skipped. Annex invariants completed 4,608 calls with zero reverts. The mainnet fork suite skipped without RPC configuration.

Done. The manifest at launch.json is rewritten and is the only changed file, so this round carries a real diff rather than the empty one that was rejected.

What the manifest declares

• One contract, MarginaliaAnnex, with four static constructor arguments in declaration order: the live MarginaliaHook of launch 1283, the IdentityMD Intake, the oracle action as a right-padded bytes32, and the IdentityMD oracle signer.
• The bytes32 for the action was recomputed with cast and matches the earlier value.
• No $owner, token, pool, funding or initialization entries. The contract has no owner, pause or upgrade, and the constructor reads no chain state.
• Notes were refreshed to describe the tree as it stands, including the six-argument post signature with baselineBound, and stay within the limit.

Checks run on this tree

git status shows only launch.json modified.

The review is complete. The findings file is written and validated, the scratch test is removed, and the tree is otherwise unchanged.

Round-1 findings settled

• High, sold-out range settled WRONG (8c23b075): fixed. The Annex now reads a venue with no in-range liquidity at its standing slot0 price, clamped to the pricer's expressible range, and the priceless-reading branches are gone from settle and the replacement rule. I re-ran my exact round-1 scenario as a fresh scratch test. A held BUY call whose single-range pool sold out above the target now settles Right, the settler's balance is unchanged, and the author claims the full 10 IMD bond back. The earlier closure also survives: a pulled pool keeps its last price, so a wrong call on it is still forfeited.
• Info, MARG venue baseline bound (30d57a4c): resolved as documented. The integration guide now says the MARG venue is the one where the exactly quoted price is refused, and a test pins it. No code change was asked for.

Pre-fix specialist findings were all from an older tree. The baseline sandwich is closed by the baseline bound, the flash dump-observe is closed by the locked-manager check, and the pulled-liquidity refund is closed by the standing-price read. The rest, such as author self-settlement, the fixed signer, the literal hold rule and the missing failure callback, are design points the integration guide states. None reopens.

One new note, info only, not blocking. Once a venue has no position at all, the standing price moves for nothing in both directions, and the clamped extreme is recorded as a real price. Whoever can pull a venue's whole liquidity, or anyone after such a pull, can then forfeit every open call on it for the 10% settler cut. This is the acknowledged residual of the fix, stated in the guide and shown by the author's own test. I recorded it so the trade-off is on the record.

Deployability holds. The runtime is 24,493 bytes against the 24,576 limit, the constructor reads no chain state, and the manifest's four arguments match the brief, including the action bytes.

Coverage answers all 48 entry points. The nine Annex functions, the MARG token and the hook's fundPot and unlockCallback are traced as holding. The remaining live-contract functions of the hook, judge, router, pages and treasury are marked unreached because they are not deployed by this launch.