@@ -8,12 +8,13 @@ import {Order} from "../../../libs/funds/Order.sol";
 /// @notice Owner-set yield and duration estimates feeding the principal-cap formulas.
 /// @param requestYieldRate The expected bridge-loan yield rate (WAD per 365 days)
 /// @param borrowRate The expected venue borrow rate on existing debt (WAD per 365 days)
-/// @param collateralYieldRate The expected collateral yield rate (WAD per 365 days)
+/// @param collateralYieldRate Reserved for storage and ABI compatibility; ignored
 /// @param subscriptionDuration The expected DEPOSIT settlement duration in seconds
 /// @param redemptionDuration The expected REDEEM settlement duration in seconds
 struct YieldEstimates {
   uint64 requestYieldRate;
   uint64 borrowRate;
+  // Retained to preserve the deployed proxy storage layout.
   uint64 collateralYieldRate;
   uint32 subscriptionDuration;
   uint32 redemptionDuration;
@@ -26,7 +27,7 @@ struct YieldEstimates {
 ///        tickDuration; doubles as the consumption window length (capital entry closes this
 ///        long after the loan clock origin)
 /// @param maxYieldBps The owner ceiling on per-operation yield caps, at most 5000
-/// @param principalBufferBps The headroom over the computed principal cap, at most 2000
+/// @param principalBufferBps Reserved for storage and ABI compatibility; ignored
 /// @param collateralResidualExponent The settlement tolerance for the collateral asset:
 ///        balances strictly below 2^exponent pass the residual gate, so dust donations
 ///        cannot grief settlement (zero keeps the gate exact)
@@ -419,15 +420,9 @@ interface IRetargetter {
   function bridgeOutstanding() external view returns (bool);
 
   /// @notice Computes the current principal cap for the bound position manager.
-  /// @dev Quoter formula on live state with the owner estimates, auto-detected direction,
-  ///      times one plus the principal buffer. Below target the cap is further bounded by
-  ///      the one-trip repayment bound, so a cap-sized, fully deployed operation can always
-  ///      borrow its worst permitted repayment back at target in a single settlement trip.
-  ///      This view sizes that bound on the config yield-cap ceiling, a safe floor for
-  ///      every permissible operation; the operation gates size it on the effective
-  ///      per-operation cap (zero for a SYNC window, whose flash repayment carries no
-  ///      yield) and can admit up to that looser bound. Reverts if no position manager is
-  ///      bound.
+  /// @dev Uses the quoter formula on live state with the owner estimates and auto-detected
+  ///      direction. Auction yield limits govern accepted offers separately. Reverts if no
+  ///      position manager is bound.
   /// @return The principal cap in debt-asset units
   function maxPrincipal() external view returns (uint256);
 
 
@@ -24,7 +24,7 @@ interface IRetargetterQuoter {
   /// @param targetLtv The target loan-to-value ratio (WAD)
   /// @param requestYieldRate The bridge-loan yield rate (WAD per 365 days)
   /// @param borrowRate The venue borrow rate on existing debt (WAD per 365 days)
-  /// @param collateralYieldRate The collateral yield rate (WAD per 365 days)
+  /// @param collateralYieldRate Deprecated compatibility parameter; ignored
   /// @param subscriptionDuration The expected subscription settlement duration in seconds
   /// @param redemptionDuration The expected redemption settlement duration in seconds
   /// @return principal The bridge-loan principal in debt-asset units (rounded down)
@@ -41,16 +41,16 @@ interface IRetargetterQuoter {
 
   /// @notice Computes the borrow principal that brings an under-leveraged position to target.
   /// @dev Sized so the position sits exactly at target once the subscription settles and the
-  ///      bridge repayment is drawn as new debt, accounting for debt drift, collateral yield
-  ///      and bridge yield over the window. Returns 0 when the position is at or above target
-  ///      once those accruals are applied. Reverts with `InvalidParameters` only at a full
+  ///      bridge repayment is drawn as new debt, accounting for debt drift and bridge yield
+  ///      over the window. Returns 0 when the position is at or above target once debt drift
+  ///      is applied. Reverts with `InvalidParameters` only at a full
   ///      target LTV combined with a zero bridge yield estimate.
   /// @param collateralQuoted The aggregate collateral value in debt-asset units
   /// @param debt The aggregate debt in debt-asset units
   /// @param targetLtv The target loan-to-value ratio (WAD)
   /// @param requestYieldRate The bridge-loan yield rate (WAD per 365 days)
   /// @param borrowRate The venue borrow rate on existing debt (WAD per 365 days)
-  /// @param collateralYieldRate The collateral yield rate (WAD per 365 days)
+  /// @param collateralYieldRate Deprecated compatibility parameter; ignored
   /// @param duration The expected subscription settlement duration in seconds
   /// @return principal The bridge-loan principal in debt-asset units (rounded down)
   function ltvUpPrincipal(
@@ -66,16 +66,16 @@ interface IRetargetterQuoter {
   /// @notice Computes the borrow principal that brings an over-leveraged position to target.
   /// @dev Sized so the position sits exactly at target once the bridge principal has repaid
   ///      debt and the freed collateral's redemption has covered the bridge repayment,
-  ///      accounting for debt drift, collateral yield and bridge yield over the window.
-  ///      Returns (0, 0) when the position is at or below target once those accruals are
+  ///      accounting for debt drift and bridge yield over the window.
+  ///      Returns (0, 0) when the position is at or below target once debt drift is
   ///      applied. Reverts with `InvalidParameters` on economically unreasonable rate inputs
   ///      (a non-positive sizing denominator).
   /// @param collateralQuoted The aggregate collateral value in debt-asset units
   /// @param debt The aggregate debt in debt-asset units
   /// @param targetLtv The target loan-to-value ratio (WAD)
   /// @param requestYieldRate The bridge-loan yield rate (WAD per 365 days)
   /// @param borrowRate The venue borrow rate on existing debt (WAD per 365 days)
-  /// @param collateralYieldRate The collateral yield rate (WAD per 365 days)
+  /// @param collateralYieldRate Deprecated compatibility parameter; ignored
   /// @param duration The expected redemption settlement duration in seconds
   /// @return principal The bridge-loan principal in debt-asset units (rounded down)
   /// @return collateralToFreeQuoted The collateral value to withdraw and redeem so proceeds
@@ -93,22 +93,18 @@ interface IRetargetterQuoter {
   /// @notice Computes the one-trip repayment bound of an LTV-up operation.
   /// @dev The largest principal whose worst permitted repayment (the principal plus the full
   ///      flat yield cap) can still be borrowed at target once the subscription has landed as
-  ///      collateral: `P * (1 + yieldCap) <= targetLtv * (K * (1 + Yc) + P) - D * (1 + Rb)`.
-  ///      Same accrual terms as `ltvUpPrincipal`, with the bridge yield estimate replaced
-  ///      by the flat cap because repayment prices actual YT supply, not the estimate.
-  ///      The bound is exact in integers: the collateral growth floors before the target
-  ///      applies (matching the settlement LTV check's own arithmetic) and the drifted debt
-  ///      rounds up, so the worst repayment of a bound-sized principal is always borrowable
-  ///      at target in one settlement trip.
-  ///      Returns 0 when the position is at or above target once the accruals are applied.
+  ///      collateral: `P * (1 + yieldCap) <= targetLtv * (K + P) - D * (1 + Rb)`.
+  ///      This compatibility quote is not part of the Retargetter principal cap; auction
+  ///      yield limits govern accepted offers without changing the requested principal.
+  ///      Returns 0 when the position is at or above target once debt drift is applied.
   ///      Reverts with `InvalidParameters` only at a full target LTV combined with a zero
   ///      yield cap.
   /// @param collateralQuoted The aggregate collateral value in debt-asset units
   /// @param debt The aggregate debt in debt-asset units
   /// @param targetLtv The target loan-to-value ratio (WAD)
   /// @param maxYieldBps The flat yield cap bounding the operation's YT supply (basis points)
   /// @param borrowRate The venue borrow rate on existing debt (WAD per 365 days)
-  /// @param collateralYieldRate The collateral yield rate (WAD per 365 days)
+  /// @param collateralYieldRate Deprecated compatibility parameter; ignored
   /// @param duration The expected subscription settlement duration in seconds
   /// @return principal The one-trip repayment bound in debt-asset units (rounded down)
   function ltvUpOneTripPrincipal(
@@ -157,15 +153,13 @@ interface IRetargetterQuoter {
 
   /// @notice Computes the settlement-time cash mismatch of an LTV-down operation under price drift.
   /// @dev The bridge repayment is fixed when the operation is sized while the redemption
-  ///      settles at the realized price; the delta is that cash mismatch. The freed collateral
-  ///      was sized net of its own expected yield, so the drift is measured against the
-  ///      expected growth `1 + Yc` rather than unity: a price that moves exactly as forecast
-  ///      yields a zero delta. Positive means surplus (fold into position debt), negative
-  ///      means shortfall (owner-only borrow top-up). Shortfalls round up so a remediation
-  ///      sized from this value always covers the gap.
+  ///      settles at the realized price; the delta is that cash mismatch measured from the
+  ///      start price. Positive means surplus (fold into position debt), negative means
+  ///      shortfall (owner-only borrow top-up). Shortfalls round up so a remediation sized
+  ///      from this value always covers the gap.
   /// @param principal The bridge-loan principal in debt-asset units
   /// @param requestYieldRate The bridge-loan yield rate (WAD per 365 days)
-  /// @param collateralYieldRate The collateral yield rate used when sizing (WAD per 365 days)
+  /// @param collateralYieldRate Deprecated compatibility parameter; ignored
   /// @param duration The realized settlement duration in seconds
   /// @param priceDriftWad The settlement price ratio `rho = p1 / p0` (WAD)
   /// @return delta The signed cash mismatch in debt-asset units
 
@@ -42,10 +42,6 @@ uint24 constant MAX_TICK_DURATION = 30 days;
 /// @custom:value 5,000
 uint16 constant MAX_YIELD_CAP_BPS = 5000;
 
-/// @dev Maximum headroom over the computed principal cap: 20% (2000 basis points).
-/// @custom:value 2,000
-uint16 constant MAX_PRINCIPAL_BUFFER_BPS = 2000;
-
 /// @dev Maximum number of accounts holding a registered mint authorization at once. Bounds
 ///      every loop over the authorization set (pruning, revocation at the first pull of
 ///      funds, clearing at resolve), so a consumer handing out dust authorizations cannot
 
@@ -25,7 +25,6 @@ import {
   MAX_HORIZON,
   MAX_TICK_DURATION,
   MAX_YIELD_CAP_BPS,
-  MAX_PRINCIPAL_BUFFER_BPS,
   MAX_AUTHORIZED_ACCOUNTS,
   REPAYMENT_DEADLINE_OFFSET,
   FULL_BALANCE_SENTINEL,
@@ -36,7 +35,6 @@ import {
   BALANCE_TSLOT,
   REENTRANCY_TSLOT
 } from "../../libs/manager/rebalancer/LibRetargetterConstants.sol";
-import {BPS} from "../../libs/Constants.sol";
 import {LibChecks} from "../../libs/common/LibChecks.sol";
 import {LibTransientSlot} from "../../libs/common/LibTransientSlot.sol";
 import {EnumerableSetLib} from "lib/solady/src/utils/EnumerableSetLib.sol";
@@ -217,7 +215,7 @@ contract Retargetter is IRetargetter, IFlashLoanReceiver, OwnableRoles, Initiali
     }
 
     RetargetterOperation storage operation_ = LibStorage.operationStorage();
-    address positionManager = _checkStart(operation_, fund, principal, effectiveYieldCap);
+    address positionManager = _checkStart(operation_, fund, principal);
 
     // Safe: block.timestamp + 90 days fits in uint40 for ~35,000 years
     // forge-lint: disable-next-line(unsafe-typecast)
@@ -280,9 +278,7 @@ contract Retargetter is IRetargetter, IFlashLoanReceiver, OwnableRoles, Initiali
     operation_.checkYield(offer.amount, offer.expectedReturn);
     operation_.checkConsumptionWindow();
     ytAmount = IRequest(request).consume(offer, signature, ptAmount);
-    operation_.checkPrincipalCap(
-      request, 0, _maxPrincipal(LibStorage.assetsStorage().positionManager, operation_.operationMaxYieldBps)
-    );
+    operation_.checkPrincipalCap(request, 0, _maxPrincipal(LibStorage.assetsStorage().positionManager));
     emit OfferConsumed(request, offer.maker, ptAmount, ytAmount);
   }
 
@@ -309,11 +305,7 @@ contract Retargetter is IRetargetter, IFlashLoanReceiver, OwnableRoles, Initiali
     accounts.remove(to);
     if (ptAmount != 0 || ytAmount != 0) {
       operation_.checkOffer(
-        request,
-        ptAmount,
-        ytAmount,
-        ptAmount,
-        _maxPrincipal(LibStorage.assetsStorage().positionManager, operation_.operationMaxYieldBps)
+        request, ptAmount, ytAmount, ptAmount, _maxPrincipal(LibStorage.assetsStorage().positionManager)
       );
       // The capacity bound keeps every loop over the set within gas reach; see the constant
       accounts.add(to, MAX_AUTHORIZED_ACCOUNTS);
@@ -612,9 +604,7 @@ contract Retargetter is IRetargetter, IFlashLoanReceiver, OwnableRoles, Initiali
     onlyOwnerOrRebalancer
   {
     RetargetterOperation storage operation_ = LibStorage.operationStorage();
-    // The flash repayment carries no yield, so the window's principal cap is sized on a
-    // zero yield cap (the pure one-trip headroom bound)
-    address positionManager = _checkStart(operation_, fund, flashLoanAmount, 0);
+    address positionManager = _checkStart(operation_, fund, flashLoanAmount);
     if (!LibStorage.whitelistsStorage().flashLoanModules[flashLoanModule]) {
       revert LibRetargetterErrors.ModuleNotWhitelisted();
     }
@@ -815,13 +805,9 @@ contract Retargetter is IRetargetter, IFlashLoanReceiver, OwnableRoles, Initiali
   }
 
   /// @inheritdoc IRetargetter
-  /// @dev Sized on the config ceiling maxYieldBps, the largest yield cap any operation may
-  ///      carry, so this view is a safe floor for every permissible operation; the operation
-  ///      gates size on the effective per-operation cap instead (zero for a SYNC window,
-  ///      whose flash repayment carries no yield) and can admit up to that looser bound.
-  ///      See {_maxPrincipal} for the formula. Reverts if no position manager is bound.
+  /// @dev See {_maxPrincipal} for the formula. Reverts if no position manager is bound.
   function maxPrincipal() public view returns (uint256) {
-    return _maxPrincipal(LibStorage.assetsStorage().positionManager, LibStorage.configStorage().maxYieldBps);
+    return _maxPrincipal(LibStorage.assetsStorage().positionManager);
   }
 
   /// @inheritdoc IRetargetter
@@ -885,7 +871,7 @@ contract Retargetter is IRetargetter, IFlashLoanReceiver, OwnableRoles, Initiali
     if (
       config_.horizon < MIN_HORIZON || config_.horizon > MAX_HORIZON || config_.tickDuration == 0
         || config_.tickDuration > MAX_TICK_DURATION || config_.tickThreshold >= config_.tickDuration
-        || config_.maxYieldBps > MAX_YIELD_CAP_BPS || config_.principalBufferBps > MAX_PRINCIPAL_BUFFER_BPS
+        || config_.maxYieldBps > MAX_YIELD_CAP_BPS
     ) {
       revert LibRetargetterErrors.InvalidParameters();
     }
@@ -906,9 +892,8 @@ contract Retargetter is IRetargetter, IFlashLoanReceiver, OwnableRoles, Initiali
   ///      and a SYNC window keeps it populated, so this also locks out starts smuggled into a
   ///      window payload. Requires a bound position manager (unbound means the instance was
   ///      abandoned), a whitelisted fund, and the requested amount within the live principal
-  ///      cap sized on the operation's yield cap (fail-fast for ASYNC, where the cap re-runs
-  ///      at every consume; zero for SYNC, whose flash repayment carries no yield).
-  function _checkStart(RetargetterOperation storage operation_, address fund, uint256 amount, uint16 yieldCapBps)
+  ///      cap (fail-fast for ASYNC, where the cap re-runs at every consume).
+  function _checkStart(RetargetterOperation storage operation_, address fund, uint256 amount)
     internal
     view
     returns (address positionManager)
@@ -918,7 +903,7 @@ contract Retargetter is IRetargetter, IFlashLoanReceiver, OwnableRoles, Initiali
     positionManager = LibStorage.assetsStorage().positionManager;
     if (positionManager == address(0)) revert LibRetargetterErrors.PositionManagerNotBound();
     if (!LibStorage.whitelistsStorage().funds[fund]) revert LibRetargetterErrors.FundNotWhitelisted();
-    if (amount > _maxPrincipal(positionManager, yieldCapBps)) revert LibRetargetterErrors.PrincipalCapExceeded();
+    if (amount > _maxPrincipal(positionManager)) revert LibRetargetterErrors.PrincipalCapExceeded();
   }
 
   /// @dev Shared preamble of the wrappers acting on the live order: requires an active
@@ -962,12 +947,9 @@ contract Retargetter is IRetargetter, IFlashLoanReceiver, OwnableRoles, Initiali
   ///      from live position manager state, so the cap self-corrects: once a rebalance moves
   ///      the position to target the cap collapses toward zero and further consumption is
   ///      blocked. An empty position reverts EmptyPosition; debt against zero collateral
-  ///      reverts BadDebtPosition. Below target the buffered cap is further bounded by the
-  ///      quoter's one-trip repayment bound: repayment prices actual YT supply, which the
-  ///      flat yield cap bounds rather than the yield estimate, so the buffer alone would
-  ///      let a cap-sized operation owe more than the post-supply target-LTV borrow
-  ///      capacity can fund in one settlement trip.
-  function _maxPrincipal(address positionManager, uint16 yieldCapBps) internal view returns (uint256) {
+  ///      reverts BadDebtPosition. Auction yield limits govern accepted offers separately and
+  ///      do not change this position-sizing result.
+  function _maxPrincipal(address positionManager) internal view returns (uint256) {
     uint256 collateralQuoted = IPositionManager(positionManager).collateralAmountQuoted();
     uint256 debt = IPositionManager(positionManager).debtAmount();
     if (collateralQuoted == 0) {
@@ -990,19 +972,7 @@ contract Retargetter is IRetargetter, IFlashLoanReceiver, OwnableRoles, Initiali
         estimates.subscriptionDuration,
         estimates.redemptionDuration
       );
-    uint256 buffered = principal * (BPS + config_.principalBufferBps) / BPS;
-    if (debt.divWad(collateralQuoted) >= target) return buffered;
-    uint256 oneTrip = IRetargetterQuoter(_QUOTER)
-      .ltvUpOneTripPrincipal(
-        collateralQuoted,
-        debt,
-        target,
-        yieldCapBps,
-        estimates.borrowRate,
-        estimates.collateralYieldRate,
-        estimates.subscriptionDuration
-      );
-    return buffered.min(oneTrip);
+    return principal;
   }
 
   /// @dev Current owed amount on the operation's Request, priced on the repayment terms