I fixed the build. forge build now compiles src/BurrowHook.sol with no errors, and all 9 of my scratch tests pass under the given fuzz seed.

Why it failed: the repository has no lib/, no foundry.toml and no remappings. Every @uniswap/... and @openzeppelin/... import pointed at code that isn't there. The only file I'm allowed to write is src/BurrowHook.sol, so I couldn't add those libraries.

The fix: the file now contains everything it needs. I copied in small versions of the parts of Uniswap v4 and OpenZeppelin that the hook uses: BaseHook, the v4 types (PoolKey, SwapParams, BalanceDelta, Currency), the hook permission flags, ReentrancyGuard, Ownable2Step and SafeERC20's forceApprove. They encode the same way as the real ones. The afterSwap selector, struct layouts, flag bits and pool-id hashing all match, and a test checks the selector against the v4 signature. Each copy has a Burrow… prefix so it won't clash if someone adds the real libraries later.

How the hook behaves:

• Permissions: only afterSwap and afterSwapReturnDelta, which means address flags 0x44. The constructor reverts if the deployed address doesn't carry exactly those flags.
• Fee: when a swap is exact-input and SQK is the output, it takes hookFeeBps (capped at 100) of the output. It pulls that with poolManager.take, approves the vault, calls vault.donate, and returns the fee so the swapper receives that much less.
• No fee when SQK isn't the output.
• If the vault's donate fails, the swap still goes through. The fee stays in the hook and anyone can send it on later with flush().

What the scratch tests covered: the address flags, the constructor rejecting an unflagged address, the fee going into the vault, no fee when the output isn't SQK or the swap is exact-output, the hold-then-flush path, only the PoolManager being able to call afterSwap, the owner-only fee setting with its cap, and the selector match.

Not committed: the change is staged but there's no commit, because this machine has no git name or email set and I didn't change its git config.

Assumptions the other contributors need to match:

1. Constructor: constructor(address poolManager, address sqk, address vault, uint16 hookFeeBps, address owner). It takes plain addresses, not IPoolManager/IERC20 types, so the deploy script and tests can pass addresses whether or not they use the real Uniswap or OpenZeppelin types. HookMiner should use type(BurrowHook).creationCode with abi.encode of those five values.
2. Vault: I assumed the vault has donate(uint256) and collects the SQK with transferFrom from the hook. The hook approves the exact fee amount just before each call.
3. Exact-output swaps that pay out SQK are not charged. In v4, afterSwap can only adjust the currency the swapper didn't fix, and in an exact-output swap that's the input currency, not SQK.
4. Type names differ from v4's: afterSwap takes BurrowPoolKey and BurrowSwapParams rather than v4's PoolKey and SwapParams. Tests that call it directly should use these, or call through a real PoolManager. hookFlags() returns 0x44 for the flag-matching test.
5. Owner: the owner's only power is setting hookFeeBps within the 100 cap, and ownership transfers take two steps. The vault and SQK addresses are fixed at construction.

Implemented BurrowValuer.sol.

Offline forge build succeeds. All 64 scratch tests pass, including two pinned Sepolia fork tests, using the supplied fuzz seed.

Integration details:

• Constructor: (owner, collection, powerTable, initialPrice, minimumPrice, maximumPrice, ltvBps).
• Table index zero represents level one. LTV and price bounds are immutable.
• Prices use SQK base units per whole power unit.
• Uses the live-verified level(uint256) NFT getter.
• Governance uses proposePricePerPower and executePricePerPower; the vault must enforce its liquidation freeze using lastPriceChange().

OpenZeppelin ownership code is bundled in the permitted file for offline compilation.

Implemented src/BurrowMarket.sol with escrowed listings, cancellations, SQK purchases, linear Dutch auctions, capped fees, vault donations, and reentrancy protection. OpenZeppelin dependencies are bundled.

Integration assumptions:

• vault.donate(uint256) pulls SQK.
• Liquidators own NFTs before calling startAuction.
• Constructor takes (sqk, squeek, vault, owner, feeBps, auctionDurationSeconds).

Formatting passed; 37 scratch tests prepared. Build and tests remain unverified: both Forge commands failed because Solidity 0.8.26 was unavailable and its download failed with a DNS error. Sepolia verification also failed. Nothing deployed.

Implemented src/BurrowVault.sol with self-contained dependencies, lending, reward repayment, liquidation surplus, donations, and vested NFT/v4 bonds.

Validation: forge build succeeded; 50 tests passed with the requested seed, including 128,000 invariant calls. Sepolia escrow, borrowing, repayment, and collateral return passed at block 12,031,523. Live staking returned zero rewards; positive reward repayment was verified with mocks.

Integration assumptions:

• Constructor accepts Config; interest uses WAD per second.
• Valuer exposes creditLine(uint256[]), ltvBps(), and lastPriceChange().
• LP bonds accept one constructor-pinned pool.
• Liquidators pay debt plus borrower equity after the capped bonus.
• Limits: 256 positions, 32 active bonds per user; first deposit permanently locks 1,000 share wei.

Deployment requires --optimize: optimized runtime is 20,582 bytes. Nothing was deployed.

Added three mainnet fork tests in test/BurrowVault.t.sol, pinned to block 26310460, covering real Permit2 transfers, redemption, and approval failures.

Verified:

• forge build succeeds.
• Full suite: 88 passed, 0 failed, 0 skipped, using the required fuzz seed.
• All nine mainnet/Sepolia fork tests passed.
• New tests skip correctly when MAINNET_RPC_URL is empty.

The findings file is written and every cited snippet matches the tree. No source files were changed.

Outcome: The Burrow implementation is largely sound. No critical or high defects were found. The suite of 79 unit tests passes, and the six Sepolia fork tests also pass when run against a live RPC at the pinned block, proving the round trip against the real staking and NFT contracts. I confirmed by direct calls to Sepolia that the live Squeek NFT exposes a level getter and that staking.accountPower returns two words, so the code's ABI assumptions hold.

Findings, ranked by severity, in .imd-findings.json:

• Medium: hook fee bypass. Exact-output swaps that buy SQK pay no fee because the hook returns early when amountSpecified is non-negative. Any trader avoids the whole swap fee by choosing swap mode. The brief asks for a skim whenever SQK is the output. Fixing it requires a scope decision, since a v4 afterSwap delta can only touch the unspecified currency.
• Medium: missing deliverables. No script/Deploy.s.sol, no README, no foundry.toml, no lib or remappings. OpenZeppelin, BaseHook and the cheatcode interface are all hand-vendored instead of imported from v4-periphery, OpenZeppelin and forge-std. The operator has nothing to run to deploy.
• Low: position-cap griefing. 256 addresses each escrowing one Squeek with zero debt fill the position table forever. Honest borrowers then get TooManyPositions and nobody can free a slot.
• Low: bad debt is never written off. Liquidators must always pay the full debt, so once collateral value drops below debt (three maximal 20% price cuts, or roughly 22 months at the 50% rate cap) the position is never liquidated and its debt plus continuing interest inflate totalAssets.
• Info: the Valuer accepts an LTV of zero at construction (the Vault rejects it later), and bonding dilutes the share price with no owner switch to pause it. Both match the brief and are recorded as observations.

Coverage: all 55 listed entry points have a verdict, plus three invariant rows. Four entry points carry a finding reference and the rest hold. No proof test files were written, since none of the findings reach high severity and the tree has no forge-std for a self-contained proof to import.