diff --git a/cadence/contracts/FlowALPModels.cdc b/cadence/contracts/FlowALPModels.cdc
index 42f60eb5..1647be14 100644
--- a/cadence/contracts/FlowALPModels.cdc
+++ b/cadence/contracts/FlowALPModels.cdc
@@ -947,17 +947,30 @@ access(all) contract FlowALPModels {
         /// The annual insurance rate applied to total debit when computing credit interest (default 0.1%)
         access(all) view fun getInsuranceRate(): UFix64
 
-        /// Timestamp of the last insurance collection for this token.
-        access(all) view fun getLastInsuranceCollectionTime(): UFix64
-
         /// Swapper used to convert this token to MOET for insurance collection.
         access(all) view fun getInsuranceSwapper(): {DeFiActions.Swapper}?
 
         /// The stability fee rate to calculate stability (default 0.05, 5%).
         access(all) view fun getStabilityFeeRate(): UFix64
 
-        /// Timestamp of the last stability collection for this token.
-        access(all) view fun getLastStabilityFeeCollectionTime(): UFix64
+        /// Timestamp of the last protocol fee collection for this token.
+        access(all) view fun getLastProtocolFeeCollectionTime(): UFix64
+
+        /// Returns the accumulated insurance fee income as UFix64, ready for collection.
+        access(all) view fun getCollectInsuranceAmount(): UFix64
+
+        /// Resets the accumulated insurance fee income to zero after successful collection.
+        access(EImplementation) fun resetCollectInsuranceAmount()
+
+        /// Returns the accumulated stability fee income as UFix64, ready for collection.
+        access(all) view fun getCollectStabilityAmount(): UFix64
+
+        /// Resets the accumulated stability fee income to zero after successful collection.
+        access(EImplementation) fun resetCollectStabilityAmount()
+
+        /// Accumulates protocol fees (insurance + stability) for elapsed time since last collection.
+        /// Called before any balance or rate change to capture fees at the current rates and balances.
+        access(EImplementation) fun accumulateProtocolFees()
 
         /// Per-position limit fraction of capacity (default 0.05 i.e., 5%)
         access(all) view fun getDepositLimitFraction(): UFix64
@@ -993,9 +1006,6 @@ access(all) contract FlowALPModels {
         /// Sets the insurance rate. See getInsuranceRate for additional details.
         access(EImplementation) fun setInsuranceRate(_ rate: UFix64)
 
-        /// Sets the last insurance collection timestamp. See getLastInsuranceCollectionTime for additional details.
-        access(EImplementation) fun setLastInsuranceCollectionTime(_ lastInsuranceCollectionTime: UFix64)
-
         /// Sets the insurance swapper. See getInsuranceSwapper for additional details.
         /// If non-nil, the swapper must accept this token type as input and output MOET.
         access(EImplementation) fun setInsuranceSwapper(_ swapper: {DeFiActions.Swapper}?)
@@ -1018,9 +1028,6 @@ access(all) contract FlowALPModels {
         /// Sets the stability fee rate. See getStabilityFeeRate for additional details.
         access(EImplementation) fun setStabilityFeeRate(_ rate: UFix64)
 
-        /// Sets the last stability fee collection timestamp. See getLastStabilityFeeCollectionTime for additional details.
-        access(EImplementation) fun setLastStabilityFeeCollectionTime(_ lastStabilityFeeCollectionTime: UFix64)
-
         /// Sets the deposit capacity. See getDepositCapacity for additional details.
         access(EImplementation) fun setDepositCapacity(_ capacity: UFix64)
 
@@ -1112,14 +1119,16 @@ access(all) contract FlowALPModels {
         access(self) var interestCurve: {FlowALPInterestRates.InterestCurve}
         /// The annual insurance rate applied to total debit when computing credit interest (default 0.1%)
         access(self) var insuranceRate: UFix64
-        /// Timestamp of the last insurance collection for this token.
-        access(self) var lastInsuranceCollectionTime: UFix64
         /// Swapper used to convert this token to MOET for insurance collection.
         access(self) var insuranceSwapper: {DeFiActions.Swapper}?
         /// The stability fee rate to calculate stability (default 0.05, 5%).
         access(self) var stabilityFeeRate: UFix64
-        /// Timestamp of the last stability collection for this token.
-        access(self) var lastStabilityFeeCollectionTime: UFix64
+        /// Timestamp of the last protocol fee accumulation (shared by insurance and stability).
+        access(self) var lastProtocolFeeCollectionTime: UFix64
+        /// Accrued stability fee income not yet withdrawn from reserves.
+        access(self) var accumulatedStabilityFeeIncome: UFix128
+        /// Accrued insurance fee income not yet withdrawn from reserves.
+        access(self) var accumulatedInsuranceFeeIncome: UFix128
         /// Per-position limit fraction of capacity (default 0.05 i.e., 5%)
         access(self) var depositLimitFraction: UFix64
         /// The rate at which depositCapacity can increase over time. This is a tokens per hour rate,
@@ -1158,10 +1167,11 @@ access(all) contract FlowALPModels {
             self.currentDebitRate = 1.0
             self.interestCurve = interestCurve
             self.insuranceRate = 0.0
-            self.lastInsuranceCollectionTime = getCurrentBlock().timestamp
             self.insuranceSwapper = nil
             self.stabilityFeeRate = 0.05
-            self.lastStabilityFeeCollectionTime = getCurrentBlock().timestamp
+            self.lastProtocolFeeCollectionTime = getCurrentBlock().timestamp
+            self.accumulatedStabilityFeeIncome = 0.0
+            self.accumulatedInsuranceFeeIncome = 0.0
             self.depositLimitFraction = 0.05
             self.depositRate = depositRate
             self.depositCapacity = depositCapacityCap
@@ -1223,11 +1233,6 @@ access(all) contract FlowALPModels {
             return self.insuranceRate
         }
 
-        /// Returns the timestamp of the last insurance collection for this token.
-        access(all) view fun getLastInsuranceCollectionTime(): UFix64 {
-            return self.lastInsuranceCollectionTime
-        }
-
         /// Returns the swapper used to convert this token to MOET for insurance collection.
         access(all) view fun getInsuranceSwapper(): {DeFiActions.Swapper}? {
             return self.insuranceSwapper
@@ -1238,9 +1243,29 @@ access(all) contract FlowALPModels {
             return self.stabilityFeeRate
         }
 
-        /// Returns the timestamp of the last stability fee collection for this token.
-        access(all) view fun getLastStabilityFeeCollectionTime(): UFix64 {
-            return self.lastStabilityFeeCollectionTime
+        /// Returns the timestamp of the last protocol fee collection for this token.
+        access(all) view fun getLastProtocolFeeCollectionTime(): UFix64 {
+            return self.lastProtocolFeeCollectionTime
+        }
+
+        /// Returns the accumulated insurance fee income as UFix64, ready for collection.
+        access(all) view fun getCollectInsuranceAmount(): UFix64 {
+            return FlowALPMath.toUFix64RoundDown(self.accumulatedInsuranceFeeIncome)
+        }
+
+        /// Resets the accumulated insurance fee income to zero after successful collection.
+        access(EImplementation) fun resetCollectInsuranceAmount() {
+            self.accumulatedInsuranceFeeIncome = 0.0
+        }
+
+        /// Returns the accumulated stability fee income as UFix64, ready for collection.
+        access(all) view fun getCollectStabilityAmount(): UFix64 {
+            return FlowALPMath.toUFix64RoundDown(self.accumulatedStabilityFeeIncome)
+        }
+
+        /// Resets the accumulated stability fee income to zero after successful collection.
+        access(EImplementation) fun resetCollectStabilityAmount() {
+            self.accumulatedStabilityFeeIncome = 0.0
         }
 
         /// Returns the per-position limit fraction of capacity (default 0.05 i.e., 5%).
@@ -1282,12 +1307,9 @@ access(all) contract FlowALPModels {
 
         /// Sets the insurance rate. See TokenState.setInsuranceRate.
         access(EImplementation) fun setInsuranceRate(_ rate: UFix64) {
+            self.accumulateProtocolFees()
             self.insuranceRate = rate
-        }
-
-        /// Sets the last insurance collection timestamp. See TokenState.setLastInsuranceCollectionTime.
-        access(EImplementation) fun setLastInsuranceCollectionTime(_ lastInsuranceCollectionTime: UFix64) {
-            self.lastInsuranceCollectionTime = lastInsuranceCollectionTime
+            self.updateForUtilizationChange()
         }
 
         /// Sets the insurance swapper. See TokenState.setInsuranceSwapper.
@@ -1329,12 +1351,9 @@ access(all) contract FlowALPModels {
 
         /// Sets the stability fee rate. See TokenState.setStabilityFeeRate.
         access(EImplementation) fun setStabilityFeeRate(_ rate: UFix64) {
+            self.accumulateProtocolFees()
             self.stabilityFeeRate = rate
-        }
-
-        /// Sets the last stability fee collection timestamp. See TokenState.setLastStabilityFeeCollectionTime.
-        access(EImplementation) fun setLastStabilityFeeCollectionTime(_ lastStabilityFeeCollectionTime: UFix64) {
-            self.lastStabilityFeeCollectionTime = lastStabilityFeeCollectionTime
+            self.updateForUtilizationChange()
         }
 
         /// Sets the deposit capacity. See TokenState.setDepositCapacity.
@@ -1344,6 +1363,7 @@ access(all) contract FlowALPModels {
 
         /// Sets the interest curve. Recalculates interest rates immediately. See TokenState.setInterestCurve.
         access(EImplementation) fun setInterestCurve(_ curve: {FlowALPInterestRates.InterestCurve}) {
+            self.accumulateProtocolFees()
             self.interestCurve = curve
             // Update rates immediately to reflect the new curve
             self.updateInterestRates()
@@ -1401,33 +1421,28 @@ access(all) contract FlowALPModels {
             let insuranceRate = UFix128(self.insuranceRate)
             let stabilityFeeRate = UFix128(self.stabilityFeeRate)
 
-            var creditRate: UFix128 = 0.0
             // Total protocol cut as a percentage of debit interest income
             let protocolFeeRate = insuranceRate + stabilityFeeRate
+            self.currentDebitRate = FlowALPMath.perSecondInterestRate(yearlyRate: debitRate)
+            let debitRatePerSecond = self.currentDebitRate - 1.0
 
             // Two calculation paths based on curve type:
-            // 1. FixedCurve: simple spread model (creditRate = debitRate * (1 - protocolFeeRate))
+            // 1. FixedCurve: simple spread model
             //    Used for stable assets like MOET where rates are governance-controlled
             // 2. KinkCurve (and others): reserve factor model
             //    Insurance and stability are percentages of interest income, not a fixed spread
             if self.interestCurve.getType() == Type<FlowALPInterestRates.FixedCurve>() {
-                // FixedRate path: creditRate = debitRate * (1 - protocolFeeRate))
-                // This provides a fixed, predictable spread between borrower and lender rates
-                creditRate = debitRate * (1.0 - protocolFeeRate)
+                // FixedRate path: creditRatePerSec = debitRatePerSec * (1 - protocolFeeRate)
+                self.currentCreditRate = 1.0 + debitRatePerSecond * (1.0 - protocolFeeRate)
             } else {
                 // KinkCurve path (and any other curves): reserve factor model
-                // protocolFeeAmount = debitIncome * protocolFeeRate (percentage of income)
-                // creditRate = (debitIncome - protocolFeeAmount) / totalCreditBalance
-                let debitIncome = self.totalDebitBalance * debitRate
-                let protocolFeeAmount = debitIncome * protocolFeeRate
-
+                // creditRatePerSec = debitRatePerSec * (1 - protocolFeeRate) * totalDebit / totalCredit
                 if self.totalCreditBalance > 0.0 {
-                    creditRate = (debitIncome - protocolFeeAmount) / self.totalCreditBalance
+                    self.currentCreditRate = 1.0 + debitRatePerSecond * (1.0 - protocolFeeRate) * self.totalDebitBalance / self.totalCreditBalance
+                } else {
+                    self.currentCreditRate = 1.0
                 }
             }
-
-            self.currentCreditRate = FlowALPMath.perSecondInterestRate(yearlyRate: creditRate)
-            self.currentDebitRate = FlowALPMath.perSecondInterestRate(yearlyRate: debitRate)
         }
 
         /// Updates the credit and debit interest indices for elapsed time since last update.
@@ -1486,12 +1501,14 @@ access(all) contract FlowALPModels {
 
         /// Increases total credit balance by the given amount and recalculates interest rates.
         access(EImplementation) fun increaseCreditBalance(by amount: UFix128) {
+            self.accumulateProtocolFees()
             self.totalCreditBalance = self.totalCreditBalance + amount
             self.updateForUtilizationChange()
         }
 
         /// Decreases total credit balance by the given amount (floored at 0) and recalculates interest rates.
         access(EImplementation) fun decreaseCreditBalance(by amount: UFix128) {
+            self.accumulateProtocolFees()
             if amount >= self.totalCreditBalance {
                 self.totalCreditBalance = 0.0
             } else {
@@ -1502,12 +1519,14 @@ access(all) contract FlowALPModels {
 
         /// Increases total debit balance by the given amount and recalculates interest rates.
         access(EImplementation) fun increaseDebitBalance(by amount: UFix128) {
+            self.accumulateProtocolFees()
             self.totalDebitBalance = self.totalDebitBalance + amount
             self.updateForUtilizationChange()
         }
 
         /// Decreases total debit balance by the given amount (floored at 0) and recalculates interest rates.
         access(EImplementation) fun decreaseDebitBalance(by amount: UFix128) {
+            self.accumulateProtocolFees()
             if amount >= self.totalDebitBalance {
                 self.totalDebitBalance = 0.0
             } else {
@@ -1515,6 +1534,35 @@ access(all) contract FlowALPModels {
             }
             self.updateForUtilizationChange()
         }
+
+        /// Accumulates insurance and stability fee income for the elapsed time since the last call.
+        /// Updates lastProtocolFeeCollectionTime to the current block timestamp.
+        /// Must be called before any balance or rate change to settle fees at current rates.
+        /// Note: This function only accrues fee income and does not withdraw it from the reserve.
+        /// This is intentional—if the protocol becomes insolvent, fees should remain in the reserve
+        /// and continue to accumulate until the protocol recovers, rather than being withdrawn.
+        access(EImplementation) fun accumulateProtocolFees() {
+            let currentTime = getCurrentBlock().timestamp
+            
+            let totalProtocolFeeRate = self.insuranceRate + self.stabilityFeeRate
+            if totalProtocolFeeRate == 0.0 {
+                self.lastProtocolFeeCollectionTime = currentTime
+                return 
+            }
+
+            let timeElapsed = currentTime - self.lastProtocolFeeCollectionTime
+
+            let debitIncome = self.totalDebitBalance * (FlowALPMath.powUFix128(self.currentDebitRate, timeElapsed) - 1.0)
+            let creditIncome = self.totalCreditBalance * (FlowALPMath.powUFix128(self.currentCreditRate, timeElapsed) - 1.0)
+            let protocolFeeIncome: UFix128 = debitIncome > creditIncome ? debitIncome - creditIncome : 0.0
+
+            let insuranceFeeAmount = protocolFeeIncome * UFix128(self.insuranceRate) / UFix128(totalProtocolFeeRate)
+            let stabilityFeeAmount = protocolFeeIncome - insuranceFeeAmount
+
+            self.accumulatedInsuranceFeeIncome = self.accumulatedInsuranceFeeIncome + insuranceFeeAmount
+            self.accumulatedStabilityFeeIncome = self.accumulatedStabilityFeeIncome + stabilityFeeAmount
+            self.lastProtocolFeeCollectionTime = currentTime
+        }
     }
 
     /* --- POOL STATE --- */
diff --git a/cadence/contracts/FlowALPv0.cdc b/cadence/contracts/FlowALPv0.cdc
index 224bf8e1..42bc212e 100644
--- a/cadence/contracts/FlowALPv0.cdc
+++ b/cadence/contracts/FlowALPv0.cdc
@@ -264,7 +264,7 @@ access(all) contract FlowALPv0 {
         /// Returns nil if the token type is not supported.
         access(all) view fun getLastStabilityCollectionTime(tokenType: Type): UFix64? {
             if let tokenState = self.state.getTokenState(tokenType) {
-                return tokenState.getLastStabilityFeeCollectionTime()
+                return tokenState.getLastProtocolFeeCollectionTime()
             }
 
             return nil
@@ -282,7 +282,7 @@ access(all) contract FlowALPv0 {
         /// Returns nil if the token type is not supported
         access(all) view fun getLastInsuranceCollectionTime(tokenType: Type): UFix64? {
             if let tokenState = self.state.getTokenState(tokenType) {
-                return tokenState.getLastInsuranceCollectionTime()
+                return tokenState.getLastProtocolFeeCollectionTime()
             }
             return nil
         }
@@ -1491,7 +1491,7 @@ access(all) contract FlowALPv0 {
                 )
             }
             // Collect all insurance fees accrued under the old rate before applying the new one, the new rate applies only to time elapsed from this point forward
-            self.updateInterestRatesAndCollectInsurance(tokenType: tokenType)
+            self._collectInsurance(tokenType: tokenType)
 
             tsRef.setInsuranceRate(insuranceRate)
 
@@ -1536,7 +1536,7 @@ access(all) contract FlowALPv0 {
             pre {
                 self.isTokenSupported(tokenType: tokenType): "Unsupported token type"
             }
-            self.updateInterestRatesAndCollectInsurance(tokenType: tokenType)
+            self._collectInsurance(tokenType: tokenType)
         }
 
         /// Updates the per-deposit limit fraction for a given token (fraction in [0,1])
@@ -1602,7 +1602,7 @@ access(all) contract FlowALPv0 {
                 ?? panic("Invariant: token state missing")
 
             // Collect all stability fees accrued under the old rate before applying the new one, the new rate applies only to time elapsed from this point forward
-            self.updateInterestRatesAndCollectStability(tokenType: tokenType)
+            self._collectStability(tokenType: tokenType)
 
             tsRef.setStabilityFeeRate(stabilityFeeRate)
 
@@ -1647,7 +1647,7 @@ access(all) contract FlowALPv0 {
             pre {
                 self.isTokenSupported(tokenType: tokenType): "Unsupported token type"
             }
-            self.updateInterestRatesAndCollectStability(tokenType: tokenType)
+            self._collectStability(tokenType: tokenType)
         }
 
         /// Regenerates deposit capacity for all supported token types
@@ -1888,7 +1888,7 @@ access(all) contract FlowALPv0 {
         /// This method should be called periodically to ensure rates are current and fee amounts are collected.
         ///
         /// @param tokenType: The token type to update rates for
-        access(self) fun updateInterestRatesAndCollectStability(tokenType: Type) {
+        access(self) fun _collectStability(tokenType: Type) {
             let tokenState = self._borrowUpdatedTokenState(type: tokenType)
             tokenState.updateInterestRates()
 
@@ -1901,7 +1901,7 @@ access(all) contract FlowALPv0 {
             let reserveRef = self.state.borrowReserve(tokenType)!
 
             // Collect stability and get token vault
-            if let collectedVault <- self._collectStability(tokenState: tokenState, reserveVault: reserveRef) {
+            if let collectedVault <- self._withdrawStability(tokenState: tokenState, reserveVault: reserveRef) {
                 let collectedBalance = collectedVault.balance
                 // Deposit collected token into stability fund
                 if !self.state.hasStabilityFund(tokenType) {
@@ -1915,7 +1915,7 @@ access(all) contract FlowALPv0 {
                     poolUUID: self.uuid,
                     tokenType: tokenType.identifier,
                     stabilityAmount: collectedBalance,
-                    collectionTime: tokenState.getLastStabilityFeeCollectionTime()
+                    collectionTime: tokenState.getLastProtocolFeeCollectionTime()
                 )
             }
         }
@@ -1928,52 +1928,39 @@ access(all) contract FlowALPv0 {
         /// fees will not be settled under the old rate. When reserves eventually recover, the entire
         /// elapsed window — including the period before the rate change — will be collected under the
         /// new rate, causing over- or under-collection for that period.
-        access(self) fun _collectInsurance(
+        access(self) fun _withdrawInsurance(
             tokenState: auth(FlowALPModels.EImplementation) &{FlowALPModels.TokenState},
             reserveVault: auth(FungibleToken.Withdraw) &{FungibleToken.Vault},
             oraclePrice: UFix64,
             maxDeviationBps: UInt16
         ): @MOET.Vault? {
-            let currentTime = getCurrentBlock().timestamp
 
-            if tokenState.getInsuranceRate() == 0.0 {
-                tokenState.setLastInsuranceCollectionTime(currentTime)
-                return nil
-            }
-
-            let timeElapsed = currentTime - tokenState.getLastInsuranceCollectionTime()
-            if timeElapsed <= 0.0 {
-                return nil
-            }
-
-            let debitIncome = tokenState.getTotalDebitBalance() * (FlowALPMath.powUFix128(tokenState.getCurrentDebitRate(), timeElapsed) - 1.0)
-            let insuranceAmount = debitIncome * UFix128(tokenState.getInsuranceRate())
-            let insuranceAmountUFix64 = FlowALPMath.toUFix64RoundDown(insuranceAmount)
+            tokenState.accumulateProtocolFees()
+            let insuranceAmount = tokenState.getCollectInsuranceAmount()
 
-            if insuranceAmountUFix64 == 0.0 {
-                tokenState.setLastInsuranceCollectionTime(currentTime)
+            if insuranceAmount == 0.0 {
                 return nil
             }
 
-            if insuranceAmountUFix64 > reserveVault.balance {
+            if insuranceAmount > reserveVault.balance {
                 // do not collect the insurance fee if the reserve doesn't have enough tokens to cover the full amount 
                 return nil
             }
 
-            let insuranceVault <- reserveVault.withdraw(amount: insuranceAmountUFix64)
+            let insuranceVault <- reserveVault.withdraw(amount: insuranceAmount)
             let insuranceSwapper = tokenState.getInsuranceSwapper() ?? panic("missing insurance swapper")
 
             assert(insuranceSwapper.inType() == reserveVault.getType(), message: "Insurance swapper input type must be same as reserveVault")
             assert(insuranceSwapper.outType() == Type<@MOET.Vault>(), message: "Insurance swapper must output MOET")
 
-            let quote = insuranceSwapper.quoteOut(forProvided: insuranceAmountUFix64, reverse: false)
+            let quote = insuranceSwapper.quoteOut(forProvided: insuranceAmount, reverse: false)
             let dexPrice = quote.outAmount / quote.inAmount
             assert(
                 FlowALPMath.dexOraclePriceDeviationInRange(dexPrice: dexPrice, oraclePrice: oraclePrice, maxDeviationBps: maxDeviationBps),
                 message: "DEX/oracle price deviation exceeds \(maxDeviationBps)bps. Dex price: \(dexPrice), Oracle price: \(oraclePrice)",
             )
             var moetVault <- insuranceSwapper.swap(quote: quote, inVault: <-insuranceVault) as! @MOET.Vault
-            tokenState.setLastInsuranceCollectionTime(currentTime)
+            tokenState.resetCollectInsuranceAmount()
             return <-moetVault
         }
 
@@ -1985,39 +1972,25 @@ access(all) contract FlowALPv0 {
         /// fees will not be settled under the old rate. When reserves eventually recover, the entire
         /// elapsed window — including the period before the rate change — will be collected under the
         /// new rate, causing over- or under-collection for that period.
-        access(self) fun _collectStability(
+        access(self) fun _withdrawStability(
             tokenState: auth(FlowALPModels.EImplementation) &{FlowALPModels.TokenState},
             reserveVault: auth(FungibleToken.Withdraw) &{FungibleToken.Vault}
         ): @{FungibleToken.Vault}? {
-            let currentTime = getCurrentBlock().timestamp
-
-            if tokenState.getStabilityFeeRate() == 0.0 {
-                tokenState.setLastStabilityFeeCollectionTime(currentTime)
-                return nil
-            }
-
-            let timeElapsed = currentTime - tokenState.getLastStabilityFeeCollectionTime()
-            if timeElapsed <= 0.0 {
-                return nil
-            }
 
-            let stabilityFeeRate = UFix128(tokenState.getStabilityFeeRate())
-            let interestIncome = tokenState.getTotalDebitBalance() * (FlowALPMath.powUFix128(tokenState.getCurrentDebitRate(), timeElapsed) - 1.0)
-            let stabilityAmount = interestIncome * stabilityFeeRate
-            let stabilityAmountUFix64 = FlowALPMath.toUFix64RoundDown(stabilityAmount)
+            tokenState.accumulateProtocolFees()
+            let stabilityAmount = tokenState.getCollectStabilityAmount()
 
-            if stabilityAmountUFix64 == 0.0 {
-                tokenState.setLastStabilityFeeCollectionTime(currentTime)
+            if stabilityAmount == 0.0 {
                 return nil
             }
 
-            if stabilityAmountUFix64 > reserveVault.balance {
+            if stabilityAmount > reserveVault.balance {
                 // do not collect the stability fee if the reserve doesn't have enough tokens to cover the full amount 
                 return nil
             }
 
-            let stabilityVault <- reserveVault.withdraw(amount: stabilityAmountUFix64)  
-            tokenState.setLastStabilityFeeCollectionTime(currentTime)
+            let stabilityVault <- reserveVault.withdraw(amount: stabilityAmount)  
+            tokenState.resetCollectStabilityAmount()
             return <-stabilityVault
         }
 
@@ -2116,7 +2089,7 @@ access(all) contract FlowALPv0 {
         /// This method should be called periodically to ensure rates are current and insurance is collected.
         ///
         /// @param tokenType: The token type to update rates for
-        access(self) fun updateInterestRatesAndCollectInsurance(tokenType: Type) {
+        access(self) fun _collectInsurance(tokenType: Type) {
             let tokenState = self._borrowUpdatedTokenState(type: tokenType)
             tokenState.updateInterestRates()
 
@@ -2130,7 +2103,7 @@ access(all) contract FlowALPv0 {
             if let reserveRef = self.state.borrowReserve(tokenType) {
                 // Collect insurance and get MOET vault
                 let oraclePrice = self.config.getPriceOracle().price(ofToken: tokenType)!
-                if let collectedMOET <- self._collectInsurance(
+                if let collectedMOET <- self._withdrawInsurance(
                     tokenState: tokenState,
                     reserveVault: reserveRef,
                     oraclePrice: oraclePrice,
@@ -2144,7 +2117,7 @@ access(all) contract FlowALPv0 {
                         poolUUID: self.uuid,
                         tokenType: tokenType.identifier,
                         insuranceAmount: collectedMOETBalance,
-                        collectionTime: tokenState.getLastInsuranceCollectionTime()
+                        collectionTime: tokenState.getLastProtocolFeeCollectionTime()
                     )
                 }
             }
diff --git a/cadence/tests/insurance_collection_formula_test.cdc b/cadence/tests/insurance_collection_formula_test.cdc
index 254d4154..e1d5888e 100644
--- a/cadence/tests/insurance_collection_formula_test.cdc
+++ b/cadence/tests/insurance_collection_formula_test.cdc
@@ -44,14 +44,14 @@ fun test_collectInsurance_success_fullAmount() {
     createPosition(admin: PROTOCOL_ACCOUNT, signer: lp, amount: 10000.0, vaultStoragePath: MOET.VaultStoragePath, pushToDrawDownSink: false)
 
     // setup borrower with FLOW collateral
-    // With 0.8 CF and 1.3 target health: 1000 FLOW collateral allows borrowing ~615 MOET
-    // borrow = (collateral * price * CF) / targetHealth = (1000 * 1.0 * 0.8) / 1.3 ≈ 615.38
+    // With 0.8 CF and 1.3 target health: 15000 FLOW collateral allows borrowing ~9231 MOET
+    // borrow = (collateral * price * CF) / targetHealth = (15000 * 1.0 * 0.8) / 1.3 ≈ 9230.77
     let borrower = Test.createAccount()
     setupMoetVault(borrower, beFailed: false)
-    transferFlowTokens(to: borrower, amount: 1000.0)
+    transferFlowTokens(to: borrower, amount: 15000.0)
 
-    // borrower deposits FLOW and auto-borrows MOET (creates debit balance ~615 MOET)
-    createPosition(admin: PROTOCOL_ACCOUNT, signer: borrower, amount: 1000.0, vaultStoragePath: FLOW_VAULT_STORAGE_PATH, pushToDrawDownSink: true)
+    // borrower deposits 15000 FLOW and auto-borrows MOET (creates debit balance ~9231 MOET)
+    createPosition(admin: PROTOCOL_ACCOUNT, signer: borrower, amount: 15000.0, vaultStoragePath: FLOW_VAULT_STORAGE_PATH, pushToDrawDownSink: true)
 
     // setup protocol account with MOET vault for the swapper
     setupMoetVault(PROTOCOL_ACCOUNT, beFailed: false)
@@ -61,8 +61,7 @@ fun test_collectInsurance_success_fullAmount() {
     let swapperResult = setInsuranceSwapper(signer: PROTOCOL_ACCOUNT, tokenTypeIdentifier: MOET_TOKEN_IDENTIFIER, priceRatio: 1.0)
     Test.expect(swapperResult, Test.beSucceeded())
 
-    // set 10% annual debit rate
-    // insurance is calculated on debit income, not debit balance
+    // set 10% annual debit rate; credit rate = 0.1 × (1 − 0.15) = 0.085
     setInterestCurveFixed(signer: PROTOCOL_ACCOUNT, tokenTypeIdentifier: MOET_TOKEN_IDENTIFIER, yearlyRate: 0.1)
 
     // set insurance rate (10% of debit income)
@@ -90,25 +89,35 @@ fun test_collectInsurance_success_fullAmount() {
     let reserveBalanceAfter = getReserveBalance(vaultIdentifier: MOET_TOKEN_IDENTIFIER)
     Test.assert(reserveBalanceAfter < reserveBalanceBefore, message: "Reserves should have decreased after collection")
 
-    let collectedAmount = finalInsuranceBalance - initialInsuranceBalance
+    let collectedInsuranceAmount = finalInsuranceBalance - initialInsuranceBalance
 
+    // collectInsurance accumulates both insurance AND stability in one call,
+    // and only insurance was withdrawn, with insuranceRate=0.1.
+    let stabilityFundBalance = getStabilityFundBalance(tokenTypeIdentifier: MOET_TOKEN_IDENTIFIER) ?? 0.0
+    Test.assertEqual(0.0, stabilityFundBalance)
     let amountWithdrawnFromReserves = reserveBalanceBefore - reserveBalanceAfter
-    // verify the amount withdrawn from reserves equals the collected amount (1:1 swap ratio)
-    Test.assertEqual(amountWithdrawnFromReserves, collectedAmount)
+    // Total withdrawn = insurance (→ fund via swap with 1:1 ratio)
+    Test.assertEqual(amountWithdrawnFromReserves, collectedInsuranceAmount)
 
     // verify last insurance collection time was updated to current block timestamp
     let currentTimestamp = getBlockTimestamp()
     let lastInsuranceCollectionTime = getLastInsuranceCollectionTime(tokenTypeIdentifier: MOET_TOKEN_IDENTIFIER)
     Test.assertEqual(currentTimestamp, lastInsuranceCollectionTime!)
 
-    // verify formula: insuranceAmount = debitIncome * insuranceRate
-    // where debitIncome = totalDebitBalance * (currentDebitRate^timeElapsed - 1.0)
-    // = (1.0 + 0.1 / 31_557_600)^31_557_600 = 1.10517091665
-    // debitBalance ≈ 615.38 MOET
-    // With 10% annual debit rate over 1 year: debitIncome ≈ 615.38 * (1.10517091665 - 1) ≈ 64.72
-    // Insurance = debitIncome * 0.1 ≈ 6.472 MOET
-
-    let expectedCollectedAmount = 6.472
-    Test.assert(equalWithinVariance(expectedCollectedAmount, collectedAmount, 0.001),
-        message: "Insurance collected should be around \(expectedCollectedAmount) but current \(collectedAmount)")
+    // verify formula (index-based, accounts for credit offset):
+    //   protocolFee = debitIncome - creditIncome
+    //   insuranceAmount = protocolFee × insuranceRate / totalProtocolFeeRate
+    //
+    //   debitBalance  ≈ 15000 × 0.8 / 1.3 ≈ 9230.77 MOET
+    //   creditBalance = 10000 MOET
+    //   debitGrowth   = e^0.1 ≈ 1.10517091807  (e^rate ≈ (1 + rate/N)^N for big N)
+    //   creditGrowth  = e^(0.085) ≈ 1.0887170667   (creditRate = debitRate × (1 − 0.15) = 0.085)
+    //   debitIncome   = 9230.77 × 0.10517091807 ≈ 970.808555393
+    //   creditIncome  = 10000  × 0.0887170667 ≈ 887.170667
+    //   protocolFee   = 970.808555393 - 887.170667 = 83.637888393 MOET
+    //   insuranceAmt  = 83.637888393 × 0.1 / 0.15 ≈ 55.758 MOET
+    //
+    let expectedCollectedAmount = 55.758
+
+    Test.assert(equalWithinVariance(expectedCollectedAmount, collectedInsuranceAmount, 0.001), message: "Insurance collected should be around \(expectedCollectedAmount) but current \(collectedInsuranceAmount)")
 }
diff --git a/cadence/tests/insurance_collection_test.cdc b/cadence/tests/insurance_collection_test.cdc
index 74571fda..bf6345f1 100644
--- a/cadence/tests/insurance_collection_test.cdc
+++ b/cadence/tests/insurance_collection_test.cdc
@@ -165,8 +165,10 @@ fun test_collectInsurance_insufficientReserves() {
     Test.assertEqual(0.0, finalInsuranceBalance)
     Test.assertEqual(reserveBalanceBefore, reserveBalanceAfter)
 
-    // time should not change
-    Test.assertEqual(lastCollectionTimeBefore, lastCollectionTimeAfter)
+    // In the accumulator model, accumulateProtocolFees() is always called and updates the timestamp
+    // even when reserves are insufficient. Fees accumulate in the accumulator until reserves recover.
+    Test.assert(lastCollectionTimeAfter! > lastCollectionTimeBefore!, message: "Timestamp should be updated even on failed collection")
+
 }
 
 // -----------------------------------------------------------------------------
@@ -245,11 +247,11 @@ fun test_collectInsurance_success_fullAmount() {
     let swapperResult = setInsuranceSwapper(signer: PROTOCOL_ACCOUNT, tokenTypeIdentifier: MOET_TOKEN_IDENTIFIER, priceRatio: 1.0)
     Test.expect(swapperResult, Test.beSucceeded())
 
-    // set 10% annual debit rate
-    // Insurance is calculated on debit income, not debit balance directly
-    setInterestCurveFixed(signer: PROTOCOL_ACCOUNT, tokenTypeIdentifier: MOET_TOKEN_IDENTIFIER, yearlyRate: 0.1)
+    // set 10% annual debit rate using KinkCurve (slope1=0/slope2=0 → constant rate regardless of
+    // utilization), ensuring protocolFeeIncome > 0 at the ~6% utilization of this test setup.
+    setInterestCurveKink(signer: PROTOCOL_ACCOUNT, tokenTypeIdentifier: MOET_TOKEN_IDENTIFIER, optimalUtilization: 0.9, baseRate: 0.1, slope1: 0.0, slope2: 0.0)
 
-    // set insurance rate (10% of debit income)
+    // set insurance rate (10% of spread income)
     let rateResult = setInsuranceRate(signer: PROTOCOL_ACCOUNT, tokenTypeIdentifier: MOET_TOKEN_IDENTIFIER, insuranceRate: 0.1)
     Test.expect(rateResult, Test.beSucceeded())
 
@@ -269,7 +271,11 @@ fun test_collectInsurance_success_fullAmount() {
     let reserveBalanceAfter = getReserveBalance(vaultIdentifier: MOET_TOKEN_IDENTIFIER)
     Test.assert(reserveBalanceAfter < reserveBalanceBefore, message: "Reserves should have decreased after collection")
 
-    // verify the amount withdrawn from reserves equals the insurance fund balance (1:1 swap ratio)
+    // verify the total amount withdrawn from reserves equals insurance collected (1:1 swap ratio).
+    // collectInsurance only drains the insurance accumulator; stability remains in its accumulator
+    // until collectStability is called separately.
+    let stabilityFundBalance = getStabilityFundBalance(tokenTypeIdentifier: MOET_TOKEN_IDENTIFIER) ?? 0.0
+    Test.assertEqual(0.0, stabilityFundBalance)
     let amountWithdrawnFromReserves = reserveBalanceBefore - reserveBalanceAfter
     Test.assertEqual(amountWithdrawnFromReserves, finalInsuranceBalance)
 
@@ -334,10 +340,10 @@ fun test_collectInsurance_multipleTokens() {
     let flowSwapperResult = setInsuranceSwapper(signer: PROTOCOL_ACCOUNT, tokenTypeIdentifier: FLOW_TOKEN_IDENTIFIER, priceRatio: 1.0)
     Test.expect(flowSwapperResult, Test.beSucceeded())
 
-    // set 10% annual debit rates
-    // Insurance is calculated on debit income, not debit balance directly
-    setInterestCurveFixed(signer: PROTOCOL_ACCOUNT, tokenTypeIdentifier: MOET_TOKEN_IDENTIFIER, yearlyRate: 0.1)
-    setInterestCurveFixed(signer: PROTOCOL_ACCOUNT, tokenTypeIdentifier: FLOW_TOKEN_IDENTIFIER, yearlyRate: 0.1)
+    // set 10% annual debit rates using KinkCurve (slope1=0/slope2=0 → constant rate), ensuring
+    // protocolFeeIncome > 0 at the low utilization levels created by this test setup.
+    setInterestCurveKink(signer: PROTOCOL_ACCOUNT, tokenTypeIdentifier: MOET_TOKEN_IDENTIFIER, optimalUtilization: 0.9, baseRate: 0.1, slope1: 0.0, slope2: 0.0)
+    setInterestCurveKink(signer: PROTOCOL_ACCOUNT, tokenTypeIdentifier: FLOW_TOKEN_IDENTIFIER, optimalUtilization: 0.9, baseRate: 0.1, slope1: 0.0, slope2: 0.0)
 
     // set different insurance rates for each token type (percentage of debit income)
     let moetRateResult = setInsuranceRate(signer: PROTOCOL_ACCOUNT, tokenTypeIdentifier: MOET_TOKEN_IDENTIFIER, insuranceRate: 0.1) // 10%
@@ -434,8 +440,9 @@ fun test_collectInsurance_dexOracleSlippageProtection() {
     let swapperResult = setInsuranceSwapper(signer: PROTOCOL_ACCOUNT, tokenTypeIdentifier: FLOW_TOKEN_IDENTIFIER, priceRatio: 0.5)
     Test.expect(swapperResult, Test.beSucceeded())
 
-    // set 10% annual debit rate and 10% insurance rate
-    setInterestCurveFixed(signer: PROTOCOL_ACCOUNT, tokenTypeIdentifier: FLOW_TOKEN_IDENTIFIER, yearlyRate: 0.1)
+    // set 10% annual debit rate using KinkCurve (slope1=0/slope2=0 → constant rate), ensuring
+    // protocolFeeIncome > 0 at 20% utilization so the slippage check is actually triggered.
+    setInterestCurveKink(signer: PROTOCOL_ACCOUNT, tokenTypeIdentifier: FLOW_TOKEN_IDENTIFIER, optimalUtilization: 0.9, baseRate: 0.1, slope1: 0.0, slope2: 0.0)
     let rateResult = setInsuranceRate(signer: PROTOCOL_ACCOUNT, tokenTypeIdentifier: FLOW_TOKEN_IDENTIFIER, insuranceRate: 0.1)
     Test.expect(rateResult, Test.beSucceeded())
 
@@ -475,8 +482,9 @@ fun test_collectInsurance_midPeriodRateChange() {
     let swapperResult = setInsuranceSwapper(signer: PROTOCOL_ACCOUNT, tokenTypeIdentifier: FLOW_TOKEN_IDENTIFIER, priceRatio: 1.0)
     Test.expect(swapperResult, Test.beSucceeded())
 
-    // set interest curve
-    setInterestCurveFixed(signer: PROTOCOL_ACCOUNT, tokenTypeIdentifier: FLOW_TOKEN_IDENTIFIER, yearlyRate: 0.1)
+    // set interest curve — KinkCurve with slope1=0/slope2=0 gives constant 10% debit rate,
+    // ensuring protocolFeeIncome > 0 at any utilization (5% here: 500 debit / 10000 credit).
+    setInterestCurveKink(signer: PROTOCOL_ACCOUNT, tokenTypeIdentifier: FLOW_TOKEN_IDENTIFIER, optimalUtilization: 0.9, baseRate: 0.1, slope1: 0.0, slope2: 0.0)
     // set insurance rate
     var rateResult = setInsuranceRate(signer: PROTOCOL_ACCOUNT, tokenTypeIdentifier: FLOW_TOKEN_IDENTIFIER, insuranceRate: 0.1)
     Test.expect(rateResult, Test.beSucceeded())
@@ -515,18 +523,17 @@ fun test_collectInsurance_midPeriodRateChange() {
     // Advance to ONE_YEAR
     Test.moveTime(by: ONE_YEAR)
 
-    // Phase 1 expected insurance calculation:
-    //   yearly rate        = 0.1   (yearly debit rate, FixedCurve)
-    //   insuranceRate1     = 0.1   (fraction of debit income)
-    //
-    //   debitIncome_1 = totalDebitBalance * (pow(perSecondDebitRate, timeElapsed) - 1.0)
-    //   perSecondRate = 1 + (yearlyRate / 31_557_600)
-    //   insuranceAmount = debitIncome * insuranceRate
+    // Phase 1 expected insurance calculation (KinkCurve compound formula):
+    //   insuranceRate1 = 0.1, stabilityFeeRate = 0.05 (default), protocolFeeRate = 0.15
+    //   U = 500/10000 = 0.05
     //
-    //   perSecondRate = 1 + (0.1 / 31557600) = 1.00000000317
-    //   debitIncome_1 = 500 * (1.00000000317^31557600 - 1) = 52.58545895 FLOW
-    //   insuranceAmount = debitIncome_1 * insurRate1 = 52.58545895 * 0.1 = 5.25854589
-    let expectedCollectedInsuranceAmountAfterPhase1 = 5.25854589
+    //   debitRatePerSec  = 0.1 / 31557600
+    //   debitIncome      = 500  * (pow(1 + debitRatePerSec, ONE_YEAR) - 1)       ≈ 52.58545895
+    //   creditIncome     = 10000 * (pow(1 + debitRatePerSec * (1-0.15) * 0.05, ONE_YEAR) - 1)
+    //                    ≈ 10000 * (e^0.00425 - 1)                                ≈ 42.59044
+    //   protocolFeeIncome = debitIncome - creditIncome                            ≈  9.99502
+    //   insuranceFeeAmount_1 = protocolFeeIncome * 0.1 / 0.15                    ≈  6.66334
+    let expectedCollectedInsuranceAmountAfterPhase1 = 6.66334
 
    // change the insurance rate to 20% for phase 2
     rateResult = setInsuranceRate(signer: PROTOCOL_ACCOUNT, tokenTypeIdentifier: FLOW_TOKEN_IDENTIFIER, insuranceRate: 0.2)
@@ -545,18 +552,16 @@ fun test_collectInsurance_midPeriodRateChange() {
 
     Test.moveTime(by: ONE_YEAR)
 
-    // Phase 2 expected insurance calculation:
-    //   yearly rate        = 0.1   (yearly debit rate, FixedCurve)
-    //   insuranceRate2     = 0.2   (fraction of debit income)
-    //
-    //   debitIncome_2 = totalDebitBalance * (pow(perSecondDebitRate, timeElapsed) - 1.0)
-    //   perSecondRate = 1 + (yearlyRate / 31_557_600)
-    //   insuranceAmount_2 = debitIncome * insuranceRate2
+    // Phase 2 expected insurance calculation (KinkCurve compound formula):
+    //   insuranceRate2 = 0.2, stabilityFeeRate = 0.05 (default), protocolFeeRate = 0.25
+    //   U = 0.05 (unchanged)
     //
-    //   perSecondRate = 1 + (0.1 / 31557600) = 1.00000000317
-    //   debitIncome_2 = 500 * (1.00000000317^31557600 - 1) = 52.58545895 FLOW
-    //   insuranceAmount_2 = debitIncome_2 * insuranceRate2 = 52.58545895 * 0.2 = 10.51709179
-    let expectedCollectedInsuranceAmountAfterPhase2 = 10.51709179
+    //   debitIncome      = 500  * (pow(1 + debitRatePerSec, ONE_YEAR) - 1)       ≈ 52.58545895
+    //   creditIncome     = 10000 * (pow(1 + debitRatePerSec * (1-0.25) * 0.05, ONE_YEAR) - 1)
+    //                    ≈ 10000 * (e^0.00375 - 1)                                ≈ 37.57040
+    //   protocolFeeIncome = debitIncome - creditIncome                            ≈ 15.01506
+    //   insuranceFeeAmount_2 = protocolFeeIncome * 0.2 / 0.25                    ≈ 12.01205
+    let expectedCollectedInsuranceAmountAfterPhase2 = 12.01205
 
     // change the insurance rate to 25%
     rateResult = setInsuranceRate(signer: PROTOCOL_ACCOUNT, tokenTypeIdentifier: FLOW_TOKEN_IDENTIFIER, insuranceRate: 0.25)
diff --git a/cadence/tests/stability_collection_formula_test.cdc b/cadence/tests/stability_collection_formula_test.cdc
index ef5b72aa..7183cd36 100644
--- a/cadence/tests/stability_collection_formula_test.cdc
+++ b/cadence/tests/stability_collection_formula_test.cdc
@@ -44,17 +44,16 @@ fun test_collectStability_success_fullAmount() {
     createPosition(admin: PROTOCOL_ACCOUNT, signer: lp, amount: 10000.0, vaultStoragePath: MOET.VaultStoragePath, pushToDrawDownSink: false)
 
     // setup borrower with FLOW collateral
-    // With 0.8 CF and 1.3 target health: 1000 FLOW collateral allows borrowing ~615 MOET
-    // borrow = (collateral * price * CF) / targetHealth = (1000 * 1.0 * 0.8) / 1.3 ≈ 615.38
+    // With 0.8 CF and 1.3 target health: 15000 FLOW collateral allows borrowing ~9231 MOET
+    // borrow = (collateral * price * CF) / targetHealth = (15000 * 1.0 * 0.8) / 1.3 ≈ 9230.77
     let borrower = Test.createAccount()
     setupMoetVault(borrower, beFailed: false)
-    transferFlowTokens(to: borrower, amount: 1000.0)
+    transferFlowTokens(to: borrower, amount: 15000.0)
 
-    // borrower deposits FLOW and auto-borrows MOET (creates debit balance ~615 MOET)
-    createPosition(admin: PROTOCOL_ACCOUNT, signer: borrower, amount: 1000.0, vaultStoragePath: FLOW_VAULT_STORAGE_PATH, pushToDrawDownSink: true)
+    // borrower deposits 15000 FLOW and auto-borrows MOET (creates debit balance ~9231 MOET)
+    createPosition(admin: PROTOCOL_ACCOUNT, signer: borrower, amount: 15000.0, vaultStoragePath: FLOW_VAULT_STORAGE_PATH, pushToDrawDownSink: true)
 
-    // set 10% annual debit rate
-    // stability is calculated on interest income, not debit balance directly
+    // set 10% annual debit rate; credit rate = 0.1 × (1 − 0.1) = 0.09
     setInterestCurveFixed(signer: PROTOCOL_ACCOUNT, tokenTypeIdentifier: MOET_TOKEN_IDENTIFIER, yearlyRate: 0.1)
 
     // set stability fee rate (10% of interest income)
@@ -84,10 +83,12 @@ fun test_collectStability_success_fullAmount() {
     let reserveBalanceAfter = getReserveBalance(vaultIdentifier: MOET_TOKEN_IDENTIFIER)
     Test.assert(reserveBalanceAfter < reserveBalanceBefore, message: "Reserves should have decreased after collection")
 
-    let collectedAmount = finalStabilityBalance! - initialStabilityBalance!
+    // initialStabilityBalance may be nil if the first collection collected nothing (fee ≈ 0)
+    let collectedAmount = (finalStabilityBalance ?? 0.0) - (initialStabilityBalance ?? 0.0)
 
     let amountWithdrawnFromReserves = reserveBalanceBefore - reserveBalanceAfter
-    // verify the amount withdrawn from reserves equals the collected amount
+    // With insuranceRate=0 (default), all protocolFee goes to stability, nothing to insurance.
+    // So amountWithdrawnFromReserves == stabilityCollected == collectedAmount.
     Test.assertEqual(amountWithdrawnFromReserves, collectedAmount)
 
     // verify last stability collection time was updated to current block timestamp
@@ -95,14 +96,19 @@ fun test_collectStability_success_fullAmount() {
     let lastStabilityCollectionTime = getLastStabilityCollectionTime(tokenTypeIdentifier: MOET_TOKEN_IDENTIFIER)
     Test.assertEqual(currentTimestamp, lastStabilityCollectionTime!)
 
-    // verify formula: stabilityAmount = interestIncome * stabilityFeeRate
-    // where interestIncome = totalDebitBalance * (currentDebitRate^timeElapsed - 1.0) 
-    // = (1.0 + 0.1 / 31_557_600)^31_557_600 = 1.10517091665
-    // debitBalance ≈ 615.38 MOET
-    // With 10% annual debit rate over 1 year: interestIncome ≈ 615.38 * (1.10517091665 - 1) ≈ 64.72
-    // Stability = interestIncome * 0.1 ≈ 6.472 MOET
-    
-    let expectedCollectedAmount = 6.472
-    Test.assert(equalWithinVariance(expectedCollectedAmount, collectedAmount, 0.001),
-        message: "Stability collected should be around \(expectedCollectedAmount) but current \(collectedAmount)")
+    // verify formula (index-based, accounts for credit offset):
+    //   protocolFee = debitIncome - creditIncome
+    //   stabilityAmount = protocolFee × stabilityFeeRate / totalProtocolFeeRate
+    //
+    //   debitBalance  ≈ 15000 × 0.8 / 1.3 ≈ 9230.76923077 MOET
+    //   creditBalance = 10000 MOET
+    //   debitGrowth   = e^0.1 ≈ 1.10517091808
+    //   creditGrowth  = e^0.09 ≈ 1.09417428371 (creditRate = debitRate × (1 − 0.1) = 0.09)
+    //   debitIncome   = 9230.76923077 × 0.10517091808 ≈ 970.8084
+    //   creditIncome  = 10000 × 0.09417428371 ≈ 941.7428
+    //   protocolFee   ≈ 29.0656 MOET
+    //   stabilityAmt  = 29.0656 × 0.1 / 0.1 = 29.065637485 MOET  (all to stability since insuranceRate=0)
+    //
+    let expectedCollectedAmount = 29.065
+    Test.assert(equalWithinVariance(expectedCollectedAmount, collectedAmount, 0.001), message: "Stability collected should be around \(expectedCollectedAmount) but current \(collectedAmount)")
 }
\ No newline at end of file
diff --git a/cadence/tests/stability_collection_test.cdc b/cadence/tests/stability_collection_test.cdc
index 709df83b..2d8bc50c 100644
--- a/cadence/tests/stability_collection_test.cdc
+++ b/cadence/tests/stability_collection_test.cdc
@@ -112,8 +112,9 @@ fun test_collectStability_insufficientReserves() {
     Test.assertEqual(nil, finalStabilityBalance)
     Test.assertEqual(reserveBalanceBefore, reserveBalanceAfter)
 
-    // time should not change
-    Test.assertEqual(lastCollectionTimeBefore, lastCollectionTimeAfter)
+    // In the accumulator model, accumulateProtocolFees() is always called and updates the timestamp
+    // even when reserves are insufficient. Fees accumulate in the accumulator until reserves recover.
+    Test.assert(lastCollectionTimeAfter! > lastCollectionTimeBefore!, message: "Timestamp should be updated even on failed collection")
 }
 
 // -----------------------------------------------------------------------------
@@ -165,10 +166,12 @@ fun test_collectStability_tinyAmount_roundsToZero_returnsNil() {
 // -----------------------------------------------------------------------------
 access(all)
 fun test_collectStability_multipleTokens() {
-    // set 10% annual debit rates
-    // Stability is calculated on interest income, not debit balance directly
-    setInterestCurveFixed(signer: PROTOCOL_ACCOUNT, tokenTypeIdentifier: MOET_TOKEN_IDENTIFIER, yearlyRate: 0.1)
-    setInterestCurveFixed(signer: PROTOCOL_ACCOUNT, tokenTypeIdentifier: FLOW_TOKEN_IDENTIFIER, yearlyRate: 0.1)
+    // set 10% annual debit rates using KinkCurve with slope1=0/slope2=0 so the rate is
+    // constant at baseRate=0.1 regardless of utilization. This guarantees
+    // creditIncome = debitIncome * (1 - protocolFeeRate) and therefore
+    // protocolFeeIncome > 0 even at low utilization.
+    setInterestCurveKink(signer: PROTOCOL_ACCOUNT, tokenTypeIdentifier: MOET_TOKEN_IDENTIFIER, optimalUtilization: 0.9, baseRate: 0.1, slope1: 0.0, slope2: 0.0)
+    setInterestCurveKink(signer: PROTOCOL_ACCOUNT, tokenTypeIdentifier: FLOW_TOKEN_IDENTIFIER, optimalUtilization: 0.9, baseRate: 0.1, slope1: 0.0, slope2: 0.0)
 
     let moetRateResult = setStabilityFeeRate(signer: PROTOCOL_ACCOUNT, tokenTypeIdentifier: MOET_TOKEN_IDENTIFIER, stabilityFeeRate: 0.1)
     Test.expect(moetRateResult, Test.beSucceeded())
@@ -317,8 +320,10 @@ fun test_collectStability_zeroRate_returnsNil() {
 // -----------------------------------------------------------------------------
 access(all)
 fun test_collectStability_midPeriodRateChange() {
-    // set interest curve
-    setInterestCurveFixed(signer: PROTOCOL_ACCOUNT, tokenTypeIdentifier: FLOW_TOKEN_IDENTIFIER, yearlyRate: 0.1)
+    // set interest curve — KinkCurve with slope1=0/slope2=0 gives constant 10% debit rate,
+    // which ensures creditIncome = debitIncome * (1 - protocolFeeRate) at any utilization
+    // so the formula stabilityAmount = debitIncome * stabilityFeeRate holds exactly.
+    setInterestCurveKink(signer: PROTOCOL_ACCOUNT, tokenTypeIdentifier: FLOW_TOKEN_IDENTIFIER, optimalUtilization: 0.9, baseRate: 0.1, slope1: 0.0, slope2: 0.0)
 
     // provide FLOW liquidity so the borrower can actually borrow
     let lp = Test.createAccount()
@@ -354,18 +359,18 @@ fun test_collectStability_midPeriodRateChange() {
     // Advance ONE_YEAR
     Test.moveTime(by: ONE_YEAR)
 
-    // Phase 1 expected stability calculation:
-    //   yearly rate        = 0.1   (yearly debit rate, FixedCurve)
-    //   stabilityFeeRate1  = 0.05  (default)
+    // Phase 1 expected stability calculation (KinkCurve compound formula):
+    //   stabilityFeeRate1  = 0.05  (default), insuranceRate = 0.0
+    //   protocolFeeRate    = 0.05
+    //   U = totalDebit/totalCredit = 500/10000 = 0.05
     //
-    //   stabilityIncome_1 = totalDebitBalance * (pow(perSecondDebitRate, timeElapsed) - 1.0)
-    //   perSecondRate = 1 + (yearlyRate / 31_557_600)
-    //   stabilityAmount = stabilityIncome * stabilityFeeRate
-    //
-    //   perSecondRate     = 1 + (0.1 / 31557600) = 1.00000000317
-    //   stabilityIncome_1 = 500 * (1.00000000317^31557600 - 1) = 52.58545895 FLOW
-    //   stabilityAmount_1 = stabilityIncome_1 * stabilityFeeRate1 = 52.58545895 * 0.05 = 2.62927294
-    let expectedStabilityAmountAfterPhase1 = 2.62927294
+    //   debitRatePerSec  = 0.1 / 31557600
+    //   debitIncome      = 500  * (pow(1 + debitRatePerSec, ONE_YEAR) - 1)        ≈ 52.58545895
+    //   creditIncome     = 10000 * (pow(1 + debitRatePerSec * (1-0.05) * 0.05, ONE_YEAR) - 1)
+    //                    ≈ 10000 * (e^0.00475 - 1)                                 ≈ 47.61283
+    //   protocolFeeIncome = debitIncome - creditIncome                             ≈  4.97263
+    //   stabilityAmount_1 = protocolFeeIncome  (insuranceRate=0, so 100% to stability)
+    let expectedStabilityAmountAfterPhase1 = 4.97246762
 
     // change the stability fee rate to 20% for phase 2
     var rateResult = setStabilityFeeRate(signer: PROTOCOL_ACCOUNT, tokenTypeIdentifier: FLOW_TOKEN_IDENTIFIER, stabilityFeeRate: 0.2)
@@ -387,14 +392,17 @@ fun test_collectStability_midPeriodRateChange() {
     // Advance another ONE_YEAR
     Test.moveTime(by: ONE_YEAR)
 
-    // Phase 2 expected stability calculation:
-    //   yearly rate        = 0.1   (yearly debit rate, FixedCurve)
-    //   stabilityFeeRate2  = 0.2   (fraction of debit income)
+    // Phase 2 expected stability calculation (KinkCurve compound formula):
+    //   stabilityFeeRate2  = 0.2, insuranceRate = 0.0
+    //   protocolFeeRate    = 0.2
+    //   U = 500/10000 = 0.05  (unchanged)
     //
-    //   totalDebitBalance = 500 FLOW  (scaled balance — does not compound, index does)
-    //   stabilityIncome_2 = 500 * (1.00000000317^31557600 - 1) = 52.58545895 FLOW
-    //   stabilityAmount_2 = stabilityIncome_2 * stabilityFeeRate2 = 52.58545895 * 0.2 = 10.51709179
-    let expectedStabilityAmountAfterPhase2 = 10.51709179
+    //   debitIncome      = 500  * (pow(1 + debitRatePerSec, ONE_YEAR) - 1)        ≈ 52.58545895
+    //   creditIncome     = 10000 * (pow(1 + debitRatePerSec * (1-0.2) * 0.05, ONE_YEAR) - 1)
+    //                    ≈ 10000 * (e^0.004 - 1)                                   ≈ 40.08011
+    //   protocolFeeIncome = debitIncome - creditIncome                             ≈ 12.50535
+    //   stabilityAmount_2 = protocolFeeIncome  (insuranceRate=0, so 100% to stability)
+    let expectedStabilityAmountAfterPhase2 = 12.50535218
 
     // change the stability rate to 25%
     rateResult = setStabilityFeeRate(signer: PROTOCOL_ACCOUNT, tokenTypeIdentifier: FLOW_TOKEN_IDENTIFIER, stabilityFeeRate: 0.25)
diff --git a/cadence/tests/withdraw_stability_funds_test.cdc b/cadence/tests/withdraw_stability_funds_test.cdc
index 8da94f1d..aa33c63e 100644
--- a/cadence/tests/withdraw_stability_funds_test.cdc
+++ b/cadence/tests/withdraw_stability_funds_test.cdc
@@ -56,8 +56,10 @@ fun setupStabilityFundWithBalance(): UFix64 {
     // borrower deposits FLOW and auto-borrows MOET (creates debit balance)
     createPosition(admin: PROTOCOL_ACCOUNT, signer: borrower, amount: 1000.0, vaultStoragePath: FLOW_VAULT_STORAGE_PATH, pushToDrawDownSink: true)
 
-    // set 10% annual debit rate (stability is calculated on interest income)
-    setInterestCurveFixed(signer: PROTOCOL_ACCOUNT, tokenTypeIdentifier: MOET_TOKEN_IDENTIFIER, yearlyRate: 0.1)
+    // set 10% annual debit rate using KinkCurve with slope1=0/slope2=0 so the rate is
+    // constant at baseRate=0.1 regardless of utilization, ensuring protocolFeeIncome > 0
+    // even at the ~6% utilization created by this test setup.
+    setInterestCurveKink(signer: PROTOCOL_ACCOUNT, tokenTypeIdentifier: MOET_TOKEN_IDENTIFIER, optimalUtilization: 0.9, baseRate: 0.1, slope1: 0.0, slope2: 0.0)
 
     // set stability fee rate (10% of interest income)
     let rateResult = setStabilityFeeRate(signer: PROTOCOL_ACCOUNT, tokenTypeIdentifier: MOET_TOKEN_IDENTIFIER, stabilityFeeRate: 0.1)
diff --git a/docs/interest_rate_and_protocol_fees.md b/docs/interest_rate_and_protocol_fees.md
index 3ecf29ee..d3bfc5bf 100644
--- a/docs/interest_rate_and_protocol_fees.md
+++ b/docs/interest_rate_and_protocol_fees.md
@@ -8,11 +8,11 @@ The FlowALP protocol uses a dual-rate interest system:
 - **Debit Rate**: The interest rate charged to borrowers
 - **Credit Rate**: The interest rate paid to lenders (depositors)
 
-The credit rate is calculated as the debit income minus protocol fees. Protocol fees consist of two components:
+The credit rate is derived from the debit rate after deducting protocol fees. Protocol fees consist of two components:
 - **Insurance Fee**: Collected and converted to MOET to build a permanent insurance reserve for covering bad debt
 - **Stability Fee**: Collected in native tokens and available for governance withdrawal to ensure MOET stability
 
-Both fees are deducted from interest income to protect the protocol and fund operations.
+Both fees come out of the spread between debit and credit income — they do not reduce the borrower's rate, they reduce the fraction of that income returned to lenders.
 
 ## Protocol Fee Components
 
@@ -20,15 +20,15 @@ Both fees are deducted from interest income to protect the protocol and fund ope
 
 #### Insurance Fund
 
-The insurance fund serves as the protocol's **reserve for covering bad debt**, acting as the liquidator of last resort. A percentage of lender interest income is collected as interest accrues and swapped to MOET, building a safety buffer that grows over time. When there are liquidations that aren't able to be covered and would normally create bad debt in the protocol, the MOET is swapped for that specific asset to cover that delta of bad debt. These funds are **never withdrawable** by governance and exist solely to protect lenders from losses.
+The insurance fund serves as the protocol's **reserve for covering bad debt**, acting as the liquidator of last resort. A percentage of protocol spread income is collected as interest accrues and swapped to MOET, building a safety buffer that grows over time. When there are liquidations that aren't able to be covered and would normally create bad debt in the protocol, the MOET is swapped for that specific asset to cover that delta of bad debt. These funds are **never withdrawable** by governance and exist solely to protect lenders from losses.
 
 #### Stability Fund
 
-The stability fund provides **flexible funding for MOET stability operations**. A percentage of lender interest income is collected and held in native token vaults (FLOW, USDC, etc.), with each token type having its own separate vault. These funds can be withdrawn by the governance committee via `withdrawStabilityFund()` to improve the stability of MOET at their discretion—whether by adding liquidity to specific pools, repurchasing MOET if it's trading under peg compared to the underlying basket of assets, or other stabilization strategies. All withdrawals emit `StabilityFundWithdrawn` events for public accountability and transparency.
+The stability fund provides **flexible funding for MOET stability operations**. A percentage of protocol spread income (borrower income − lender cost) is collected and held in native token vaults (FLOW, USDC, etc.), with each token type having its own separate vault. These funds can be withdrawn by the governance committee via `withdrawStabilityFund()` to improve the stability of MOET at their discretion—whether by adding liquidity to specific pools, repurchasing MOET if it's trading under peg compared to the underlying basket of assets, or other stabilization strategies. All withdrawals emit `StabilityFundWithdrawn` events for public accountability and transparency.
 
 ### Fee Deduction from Lender Returns
 
-Both fees are deducted from the interest income that would otherwise go to lenders:
+Both fees are deducted from the spread income that would otherwise go to lenders:
 
 ## Interest Rate Calculation
 
@@ -125,46 +125,46 @@ This is the mechanism that helps protect withdrawal liquidity under stress.
 
 ### 2. Credit Rate Calculation
 
-The credit rate (deposit nominal yearly rate) is derived from debit-side income after protocol fees.
+The credit rate is derived from the **per-second** debit rate, not the nominal annual rate directly. This is important: the protocol computes per-second rates first and then scales the credit side, not the other way around.
 
 Shared definitions:
 
 ```
 protocolFeeRate = insuranceRate + stabilityFeeRate
+debitRatePerSecond = perSecondInterestRate(yearlyRate: debitRate) - 1.0
 ```
 
 and `protocolFeeRate` must be `< 1.0`.
 
 For **FixedCurve** (used for stable assets like MOET):
 ```
-creditRate = debitRate * (1 - protocolFeeRate)
+creditRatePerSecond = debitRatePerSecond * (1.0 - protocolFeeRate)
+currentCreditRate = 1.0 + creditRatePerSecond
 ```
 
-This gives a simple spread model between borrow and lend nominal yearly rates.
+The per-second credit excess is the debit excess scaled down by `(1 - protocolFeeRate)`. This is a fixed spread at the per-second level, independent of utilization.
 
-For **KinkCurve** and other non-fixed curves:
+For **KinkCurve** and other non-fixed curves (reserve factor model):
 ```
-debitIncome = totalDebitBalance * debitRate
-protocolFeeRate = insuranceRate + stabilityFeeRate
-protocolFeeAmount = debitIncome * protocolFeeRate
-creditRate = (debitIncome - protocolFeeAmount) / totalCreditBalance
+creditRatePerSecond = debitRatePerSecond * (1.0 - protocolFeeRate) * totalDebitBalance / totalCreditBalance
+currentCreditRate = 1.0 + creditRatePerSecond
 ```
 
-This computes lender yield from actual debit-side income, after reserve deductions.
+The per-second credit excess is further scaled by the utilization ratio (`totalDebit / totalCredit`). This ensures the total interest paid by borrowers equals the total interest earned by lenders plus protocol fees, regardless of the utilization level.
 
 **Important**: The combined `insuranceRate + stabilityFeeRate` must be less than 1.0 to avoid underflow in credit rate calculation. This is enforced by preconditions when setting either rate.
 
 ### 3. Per-Second Rate Conversion
 
-Both credit and debit rates are converted from nominal annual rates to per-second compounding rates:
+The nominal annual debit rate is converted to a per-second compounding rate:
 
 ```
-perSecondRate = (yearlyRate / secondsInYear) + 1.0
+perSecondDebitRate = (yearlyRate / secondsInYear) + 1.0
 ```
 
 Where `secondsInYear = 31_557_600` (365.25 days × 24 hours × 60 minutes × 60 seconds).
 
-This conversion allows for discrete per-second compounding of interest over time.
+The credit rate is **not** converted from an annual rate independently — it is derived directly in per-second terms from the per-second debit rate (see Section 2 above).
 
 Important terminology: the configured `yearlyRate` is a **nominal yearly rate**, not a promise that a balance will grow by exactly that percentage over one calendar year. For positive fixed rates, the effective one-year growth is slightly higher because of compounding. For variable curves, realized growth also depends on when utilization changes and the rate is recomputed.
 
@@ -220,34 +220,70 @@ This design allows:
 Interest indices are updated whenever:
 1. A user interacts with the protocol (deposit, withdraw, borrow, repay)
 2. `updateForTimeChange()` is called explicitly
-3. `updateInterestRatesAndCollectInsurance()` or `updateInterestRatesAndCollectStability()` is called
 
 The update calculates the time elapsed since `lastUpdate` and compounds the interest indices accordingly. When rates are variable, realized growth over a period depends on the sequence of utilization changes and the rate recomputations they trigger, so the displayed yearly rate should not be interpreted as an exact promised one-year payoff.
 
+## Protocol Fee Accumulation
+
+### `accumulateProtocolFees()` Accumulator
+
+Insurance and stability fees are both computed in a single `TokenState.accumulateProtocolFees()` method. It is called automatically before every balance or rate mutation to ensure fees settle at the rate that was in effect when they accrued:
+
+```
+currentDebitRate = 1.0 + debitRatePerSecond
+currentCreditRate = 1.0 + creditRatePerSecond
+secondsElapsed = currentTime - lastProtocolFeeCollectionTime
+debitIncome  = totalDebitBalance  * (currentDebitRate  ^ secondsElapsed - 1.0)
+creditIncome = totalCreditBalance * (currentCreditRate ^ secondsElapsed - 1.0)
+protocolFeeIncome = max(0, debitIncome - creditIncome)
+
+insuranceFeeAmount = protocolFeeIncome * insuranceRate / (insuranceRate + stabilityFeeRate)
+stabilityFeeAmount = protocolFeeIncome - insuranceFeeAmount
+
+accumulatedInsuranceFeeIncome  += insuranceFeeAmount
+accumulatedStabilityFeeIncome  += stabilityFeeAmount
+lastProtocolFeeCollectionTime   = currentTime
+```
+
+`protocolFeeIncome` is the spread between what borrowers pay and what lenders earn. At any utilization level, this is a positive number as long as `protocolFeeRate > 0`. At zero utilization (no borrowers) or zero protocol fee rate, `protocolFeeIncome = 0`.
+
+The two accumulators are read and reset by `_withdrawInsurance` and `_withdrawStability` respectively.
+
+### When Fees Are Settled
+
+`accumulateProtocolFees()` is triggered on every mutation that could change the fee calculation:
+- `increaseCreditBalance` / `decreaseCreditBalance`
+- `increaseDebitBalance` / `decreaseDebitBalance`
+- `setInterestCurve`
+- `setInsuranceRate`
+- `setStabilityFeeRate`
+
+This means changing any rate always settles all accrued fees at the **old** rate first, then applies the new rate going forward.
+
 ## Insurance Collection Mechanism
 
 ### Overview
 
-The insurance mechanism collects a percentage of interest income over time, swaps it from the underlying token to MOET, and deposits it into a **permanent, non-withdrawable** protocol insurance fund. This fund accumulates over time and can be used to cover protocol losses or other insurance-related purposes.
+The insurance mechanism collects a share of protocol spread income over time, swaps it from the underlying token to MOET, and deposits it into a **permanent, non-withdrawable** protocol insurance fund. This fund accumulates over time and can be used to cover protocol losses or other insurance-related purposes.
 
 ### Insurance Rate
 
-Each token has a configurable `insuranceRate` (default: 0.0) that represents the fraction of accrued interest income that should be collected as insurance when fees are settled.
+Each token has a configurable `insuranceRate` (default: 0.0) that represents the fraction of protocol spread income allocated to insurance when fees are settled.
 
 ### Collection Process
 
-Insurance is collected through the `collectInsurance()` function on `TokenState`, which:
+Insurance is collected through `collectInsurance()` function on `Pool` in `FlowALPv0`, which:
 
-1. **Calculates Accrued Insurance**:
+1. **Reads the Accumulated Insurance**:
    ```
-   timeElapsed = currentTime - lastInsuranceCollectionTime
-   debitIncome = totalDebitBalance * (currentDebitRate ^ timeElapsed - 1.0)
-   insuranceAmount = debitIncome * insuranceRate
+   insuranceAmount = tokenState.accumulatedInsuranceFeeIncome
+   (reset to 0 after reading)
    ```
+   The accumulation itself happens in `accumulateProtocolFees()` (see above).
 
 2. **Withdraws from Reserves**:
    - Withdraws the calculated insurance amount from the token's reserve vault
-   - If reserves are insufficient, collects only what's available
+   - If reserves are insufficient, no collection occurs and the accumulated amount remains for the next attempt
 
 3. **Swaps to MOET**:
    - Uses the token's configured `insuranceSwapper` to swap from the underlying token to MOET
@@ -258,28 +294,6 @@ Insurance is collected through the `collectInsurance()` function on `TokenState`
    - The collected MOET is deposited into the protocol's insurance fund
    - This fund grows as insurance is collected and is never withdrawable
 
-### Integration with Rate Updates
-
-Insurance collection is integrated with interest rate updates through `updateInterestRatesAndCollectInsurance()`:
-
-```cadence
-access(self) fun updateInterestRatesAndCollectInsurance(tokenType: Type) {
-    // 1. Update interest rates
-    tokenState.updateInterestRates()
-    
-    // 2. Collect insurance
-    if let collectedMOET <- tokenState.collectInsurance(reserveVault: reserveRef) {
-        // 3. Deposit into insurance fund
-        insuranceFund.deposit(from: <-collectedMOET)
-    }
-}
-```
-
-This ensures that:
-- Interest rates are recalculated based on current pool state
-- Insurance is collected proportionally to time elapsed
-- Collected MOET is automatically deposited into the insurance fund
-
 ### Configuration Requirements
 
 Before setting a non-zero insurance rate, an insurance swapper must be configured:
@@ -312,26 +326,26 @@ The Pool maintains a single `insuranceFund` vault that stores all collected MOET
 
 ### Overview
 
-The stability fee mechanism collects a percentage of interest income over time and holds it in **native token vaults** that are **withdrawable by governance**. These funds are intended to be used for ensuring the stability of MOET.
+The stability fee mechanism collects a share of protocol spread income over time and holds it in **native token vaults** that are **withdrawable by governance**. These funds are intended to be used for ensuring the stability of MOET.
 
 ### Stability Fee Rate
 
-Each token has a configurable `stabilityFeeRate` (default: 0.05 or 5%) that represents the fraction of accrued interest income that should be collected as stability fees when they are settled.
+Each token has a configurable `stabilityFeeRate` (default: 0.05 or 5%) that represents the fraction of protocol spread income allocated to stability fees when they are settled.
 
 ### Collection Process
 
-Stability fees are collected through the `collectStability()` function on `TokenState`, which:
+Stability fees are collected through `_withdrawStability()` in `FlowALPv0`, which:
 
-1. **Calculates Accrued Stability Fee**:
+1. **Reads the Accumulated Stability Fee**:
    ```
-   timeElapsed = currentTime - lastStabilityFeeCollectionTime
-   interestIncome = totalDebitBalance * (currentDebitRate ^ timeElapsed - 1.0)
-   stabilityAmount = interestIncome * stabilityFeeRate
+   stabilityAmount = tokenState.accumulatedStabilityFeeIncome
+   (reset to 0 after reading)
    ```
+   The accumulation itself happens in `accumulateProtocolFees()` (see above).
 
 2. **Withdraws from Reserves**:
    - Withdraws the calculated stability amount from the token's reserve vault
-   - If reserves are insufficient, collects only what's available
+   - If reserves are insufficient, no collection occurs and the accumulated amount remains for the next attempt
 
 3. **Deposits to Stability Fund**:
    - The collected tokens are deposited into the token-specific stability fund vault
@@ -362,26 +376,38 @@ This emits a `StabilityFundWithdrawn` event for transparency and accountability.
 
 ## Example Flow
 
-### Scenario: Protocol with Active Lending
+### Scenario: Protocol with Active Lending (KinkCurve)
 
 1. **Initial State**:
    - Total credit balance (lender deposits): 10,000 FLOW
-   - Total debit balance (borrower debt): 8,000 FLOW
-   - Debit rate: 10% nominal yearly rate
-   - Insurance rate: 0.1% (of interest income)
-   - Stability fee rate: 5% (of interest income)
-
-2. **After 1 Year**:
-   - Current debit rate = 0.10 / 31_557_600 + 1.0 = 1.00000000316880...
-   - Debit income: 8,000 × (1.00000000316880^31_557_600 - 1.0) = 841.37 FLOW
-   - Insurance collection: 841.37 × 0.001 = 0.841 FLOW → converted to MOET
-   - Stability collection: 841.37 × 0.05 = 42.07 FLOW → kept as FLOW
-   - Net to lenders: 841.37 - 0.841 - 42.07 = 798.46 FLOW
-   - Effective lender yield over the year: 798.46 / 10,000 = 7.98%
-
-3. **Fund Accumulation**:
-   - Insurance fund: +0.841 FLOW worth of MOET (permanent, for bad debt coverage)
-   - Stability fund (FLOW): +42.07 FLOW (available for MOET stability operations)
+   - Total debit balance (borrower debt): 1,000 FLOW  → utilization U = 0.1
+   - KinkCurve parameters (Aave v3 "Volatile One" profile): `optimalUtilization = 0.45`, `baseRate = 0.0`, `slope1 = 0.04`, `slope2 = 3.0`
+   - Insurance rate: 0.1% (`0.001`)
+   - Stability fee rate: 5% (`0.05`)
+   - `protocolFeeRate = 0.001 + 0.05 = 0.051`
+
+2. **KinkCurve Rate Computation**:
+   - Since `u = 0.10 ≤ u* = 0.45`:
+   - `debitRate = baseRate + slope1 × (u / u*) = 0.0 + 0.04 × (0.10 / 0.45) ≈ 0.00889` (≈ 0.889% nominal yearly rate)
+
+3. **Per-Second Rates**:
+   - `debitRatePerSec = 0.00889 / 31_557_600 ≈ 2.817e-10`
+   - `creditRatePerSec = 2.817e-10 × (1 - 0.051) × 0.1 ≈ 2.673e-11`
+
+4. **After 1 Year**:
+   - perSecondDebitRate = 1.0 + debitRatePerSec
+   - perSecondCreditRate = 1.0 + creditRatePerSec
+   - `debitIncome  = 1,000 × (perSecondDebitRate ^ 31_557_600 − 1) ≈ 8.9294 FLOW`
+   - `creditIncome = 10,000 × (perSecondCreditRate ^ 31_557_600 − 1) ≈ 8.4389 FLOW`
+   - `protocolFeeIncome = 8.9294 − 8.4389 = 0.4905 FLOW`
+   - `insuranceFee = 0.4905 × 0.001 / 0.051 ≈ 0.0096 FLOW` → converted to MOET
+   - `stabilityFee = protocolFeeIncome - insuranceFee ≈ 0.4809 FLOW` → kept as FLOW
+   - Net lender return = creditIncome = 8.4389 FLOW
+   - Effective lender yield over the year: 8.4389 / 10,000 ≈ 0.084%
+
+5. **Fund Accumulation**:
+   - Insurance fund: +0.0096 FLOW worth of MOET (permanent, for bad debt coverage)
+   - Stability fund (FLOW): +0.4809 FLOW (available for MOET stability operations)
 
 ## Key Design Decisions
 
@@ -397,11 +423,13 @@ This emits a `StabilityFundWithdrawn` event for transparency and accountability.
 
 6. **Stability Flexibility**: Keeping stability funds withdrawable in native tokens gives governance flexibility to defend MOET's peg through various strategies.
 
-7. **Time-Based Collection**: Both insurance and stability fees are collected based on time elapsed, ensuring consistent accumulation regardless of transaction frequency.
+7. **Spread-Based Fee Formula**: Fees are taken from `debitIncome - creditIncome` (the spread), not from gross debit income. This ensures that at zero utilization or zero protocol fee rate no fees are collected, and that the fee split between insurance and stability is always exact regardless of curve type.
+
+8. **Single `accumulateProtocolFees()` Accumulator**: A single shared accumulator and timestamp for both fees ensures they always use the same elapsed-time window and that a rate change for one fee type does not inadvertently double-count or skip the other.
 
-8. **Token-Specific Swappers**: Each token can have its own insurance swapper, allowing flexibility in how different tokens are converted to MOET.
+9. **Token-Specific Swappers**: Each token can have its own insurance swapper, allowing flexibility in how different tokens are converted to MOET.
 
-9. **Unified Insurance Fund**: All collected MOET goes into a single fund, providing a centralized insurance reserve for the protocol.
+10. **Unified Insurance Fund**: All collected MOET goes into a single fund, providing a centralized insurance reserve for the protocol.
 
 ## Security Considerations
 
@@ -409,7 +437,7 @@ This emits a `StabilityFundWithdrawn` event for transparency and accountability.
 - **Swapper Validation**: Insurance swappers are validated when set to ensure they output MOET
 - **Bidirectional Constraints**: Cannot set non-zero insurance rate without swapper; cannot remove swapper with non-zero rate
 - **Reserve Checks**: Both collection mechanisms check that sufficient reserves exist before withdrawing
-- **Timestamp Tracking**: Separate timestamps (`lastInsuranceCollectionTime`, `lastStabilityFeeCollectionTime`) prevent double-counting
+- **Timestamp Tracking**: A single `lastProtocolFeeCollectionTime` shared by both fees prevents double-counting across the insurance/stability split
 - **Precision**: Uses UFix128 for internal calculations to maintain precision during compounding
 - **Access Control**: Only governance (EGovernance entitlement) can modify rates or withdraw stability funds
 - **Insurance Lock**: No withdrawal function exists for insurance fund
@@ -420,7 +448,7 @@ This emits a `StabilityFundWithdrawn` event for transparency and accountability.
 
 | Parameter | Description | Default |
 |-----------|-------------|---------|
-| `insuranceRate` | Percentage of interest income collected for insurance | 0.0 |
+| `insuranceRate` | Fraction of protocol spread income allocated to insurance | 0.0 |
 | `insuranceSwapper` | Swapper to convert tokens to MOET (required before enabling) | nil |
 
 These parameters allow the protocol to adjust insurance collection based on risk assessment and market conditions.
@@ -429,7 +457,7 @@ These parameters allow the protocol to adjust insurance collection based on risk
 
 | Parameter | Description | Default |
 |-----------|-------------|---------|
-| `stabilityFeeRate` | Percentage of interest income collected for stability | 0.05 (5%) |
+| `stabilityFeeRate` | Fraction of protocol spread income allocated to stability fees | 0.05 (5%) |
 
 ### Governance Functions