owlplanner 2025.12.20__py3-none-any.whl → 2026.2.2__py3-none-any.whl

owlplanner/plan.py

@@ -1,17 +1,24 @@
 """
+Core retirement planning module using linear programming optimization.
 
-Owl/plan
---------
-
-A retirement planner using linear programming optimization.
-
-See companion PDF document for an explanation of the underlying
+This module implements the main Plan class and optimization logic for retirement
+financial planning. See companion PDF document for an explanation of the underlying
 mathematical model and a description of all variables and parameters.
 
-Copyright © 2024 - Martin-D. Lacasse
+Copyright (C) 2025-2026 The Owlplanner Authors
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
 
-Disclaimers: This code is for educational purposes only and does not constitute financial advice.
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
 
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <https://www.gnu.org/licenses/>.
 """
 
 ###########################################################################
@@ -22,9 +29,10 @@ from functools import wraps
 from openpyxl import Workbook
 from openpyxl.utils.dataframe import dataframe_to_rows
 import time
+import textwrap
 
 from . import utils as u
-from . import tax2025 as tx
+from . import tax2026 as tx
 from . import abcapi as abc
 from . import rates
 from . import config
@@ -37,6 +45,29 @@ from . import progress
 from .plotting.factory import PlotFactory
 
 
+# Default values
+BIGM_AMO = 5e7     # 100 times large withdrawals or conversions
+GAP = 1e-4
+MILP_GAP = 10 * GAP
+MAX_ITERATIONS = 29
+ABS_TOL = 50
+REL_TOL = 5e-6
+TIME_LIMIT = 900
+EPSILON = 1e-9
+
+
+def _apply_rate_sequence_transform(tau_kn, reverse, roll):
+    """
+    Apply reverse and/or roll to a rate series (N_k x N_n).
+    Returns a new array; does not modify the input.
+    """
+    if reverse:
+        tau_kn = tau_kn[:, ::-1]
+    if roll != 0:
+        tau_kn = np.roll(tau_kn, int(roll), axis=1)
+    return tau_kn
+
+
 def _genGamma_n(tau):
     """
     Utility function to generate a cumulative inflation multiplier
@@ -85,7 +116,7 @@ def _genXi_n(profile, fraction, n_d, N_n, a, b, c):
             xi[n_d:] *= fraction
         xi *= neutralSum / xi.sum()
     else:
-        raise ValueError(f"Unknown profile type {profile}.")
+        raise ValueError(f"Unknown profile type '{profile}'.")
 
     return xi
 
@@ -127,20 +158,18 @@ def _q4(C, l1, l2, l3, l4, N1, N2, N3, N4):
 
 def clone(plan, newname=None, *, verbose=True, logstreams=None):
     """
-    Return an almost identical copy of plan: only the name of the plan
+    Return an almost identical copy of plan: only the name of the case
     has been modified and appended the string '(copy)',
     unless a new name is provided as an argument.
     """
     import copy
 
-    # Can't deepcopy variables containing file descriptors.
-    mylogger = plan.logger()
-    plan.setLogger(None)
+    # logger __deepcopy__ sets the logstreams of new logger to None
     newplan = copy.deepcopy(plan)
-    plan.setLogger(mylogger)
 
     if logstreams is None:
-        newplan.setLogger(mylogger)
+        original_logger = plan.logger()
+        newplan.setLogger(original_logger)
     else:
         newplan.setLogstreams(verbose, logstreams)
 
@@ -164,7 +193,7 @@ def _checkCaseStatus(func):
     @wraps(func)
     def wrapper(self, *args, **kwargs):
         if self.caseStatus != "solved":
-            self.mylog.vprint(f"Preventing to run method {func.__name__}() while case is {self.caseStatus}.")
+            self.mylog.print(f"Preventing to run method {func.__name__}() while case is {self.caseStatus}.")
             return None
         return func(self, *args, **kwargs)
 
@@ -181,11 +210,11 @@ def _checkConfiguration(func):
     def wrapper(self, *args, **kwargs):
         if self.xi_n is None:
             msg = f"You must define a spending profile before calling {func.__name__}()."
-            self.mylog.vprint(msg)
+            self.mylog.print(msg)
             raise RuntimeError(msg)
         if self.alpha_ijkn is None:
             msg = f"You must define an allocation profile before calling {func.__name__}()."
-            self.mylog.vprint(msg)
+            self.mylog.print(msg)
             raise RuntimeError(msg)
         return func(self, *args, **kwargs)
 
@@ -204,7 +233,8 @@ def _timer(func):
         result = func(self, *args, **kwargs)
         pt = time.process_time() - pt0
         rt = time.time() - rt0
-        self.mylog.vprint(f"CPU time used: {int(pt / 60)}m{pt % 60:.1f}s, Wall time: {int(rt / 60)}m{rt % 60:.1f}s.")
+        self.mylog.vprint(f"CPU time used: {int(pt / 60)}m{pt % 60:.1f}s, Wall time: {int(rt / 60)}m{rt % 60:.1f}s.",
+                          tag="INFO")
         return result
 
     return wrapper
@@ -214,6 +244,17 @@ class Plan:
     """
     This is the main class of the Owl Project.
     """
+    # Class-level counter for unique Plan IDs
+    _id_counter = 0
+
+    @classmethod
+    def get_next_id(cls):
+        cls._id_counter += 1
+        return cls._id_counter
+
+    @classmethod
+    def get_current_id(cls):
+        return cls._id_counter
 
     def __init__(self, inames, dobs, expectancy, name, *, verbose=False, logstreams=None):
         """
@@ -221,11 +262,14 @@ class Plan:
         one contains the name(s) of the individual(s),
         the second one is the year of birth of each individual,
         and the third the life expectancy. Last argument is a name for
-        the plan.
+        the case.
         """
         if name == "":
             raise ValueError("Plan must have a name")
 
+        # Generate unique ID for this Plan instance using the class method
+        self._id = Plan.get_next_id()
+
         self._name = name
         self.setLogstreams(verbose, logstreams)
 
@@ -234,8 +278,8 @@ class Plan:
         self.N_q = 6
         self.N_j = 3
         self.N_k = 4
-        # 2 binary variables.
-        self.N_zx = 2
+        # 4 binary variables for exclusions.
+        self.N_zx = 4
 
         # Default interpolation parameters for allocation ratios.
         self.interpMethod = "linear"
@@ -274,8 +318,11 @@ class Plan:
         thisyear = date.today().year
         self.horizons = self.yobs + self.expectancy - thisyear + 1
         self.N_n = np.max(self.horizons)
+        if self.N_n <= 2:
+            raise ValueError(f"Plan needs more than {self.N_n} years.")
+
         self.year_n = np.linspace(thisyear, thisyear + self.N_n - 1, self.N_n, dtype=np.int32)
-        # Year index in the plan (if any) where individuals turn 59. For 10% withdrawal penalty.
+        # Year index in the case (if any) where individuals turn 59. For 10% withdrawal penalty.
         self.n59 = 59 - thisyear + self.yobs
         self.n59[self.n59 < 0] = 0
         # Handle passing of one spouse before the other.
@@ -290,9 +337,11 @@ class Plan:
 
         # Default parameters:
         self.psi_n = np.zeros(self.N_n)  # Long-term income tax rate on capital gains (decimal)
-        self.chi = 0.6   # Survivor fraction
-        self.mu = 0.018  # Dividend rate (decimal)
-        self.nu = 0.30   # Heirs tax rate (decimal)
+        # Fraction of social security benefits that is taxed (fixed at 85% for now).
+        self.Psi_n = np.ones(self.N_n) * 0.85
+        self.chi = 0.60   # Survivor fraction
+        self.mu = 0.0172  # Dividend rate (decimal)
+        self.nu = 0.300   # Heirs tax rate (decimal)
         self.eta = (self.N_i - 1) / 2  # Spousal deposit ratio (0 or .5)
         self.phi_j = np.array([1, 1, 1])  # Fractions left to other spouse at death
         self.smileDip = 15  # Percent to reduce smile profile
@@ -330,6 +379,7 @@ class Plan:
         # Previous 2 years of MAGI needed for Medicare.
         self.prevMAGI = np.zeros((2))
         self.MAGI_n = np.zeros(self.N_n)
+        self.solverOptions = {}
 
         # Init current balances to none.
         self.beta_ij = None
@@ -340,13 +390,13 @@ class Plan:
 
         # Scenario starts at the beginning of this year and ends at the end of the last year.
         s = ("", "s")[self.N_i - 1]
-        self.mylog.vprint(f"Preparing scenario of {self.N_n} years for {self.N_i} individual{s}.")
+        self.mylog.vprint(f"Preparing scenario '{self._id}' of {self.N_n} years for {self.N_i} individual{s}.")
         for i in range(self.N_i):
             endyear = thisyear + self.horizons[i] - 1
             self.mylog.vprint(f"{self.inames[i]:>14}: life horizon from {thisyear} -> {endyear}.")
 
         # Prepare RMD time series.
-        self.rho_in = tx.rho_in(self.yobs, self.N_n)
+        self.rho_in = tx.rho_in(self.yobs, self.expectancy, self.N_n)
 
         # Initialize guardrails to ensure proper configuration.
         self._adjustedParameters = False
@@ -355,7 +405,13 @@ class Plan:
         self.houseLists = {}
         self.zeroContributions()
         self.caseStatus = "unsolved"
+        # "monotonic", "oscillatory", "max iteration", or "undefined" - how solution was obtained
+        self.convergenceType = "undefined"
         self.rateMethod = None
+        self.reproducibleRates = False
+        self.rateSeed = None
+        self.rateReverse = False
+        self.rateRoll = 0
 
         self.ARCoord = None
         self.objective = "unknown"
@@ -371,7 +427,7 @@ class Plan:
 
     def setLogstreams(self, verbose, logstreams):
         self.mylog = log.Logger(verbose, logstreams)
-        # self.mylog.vprint(f"Setting logstreams to {logstreams}.")
+        self.mylog.vprint(f"Setting logger with logstreams {logstreams}.")
 
     def logger(self):
         return self.mylog
@@ -386,7 +442,7 @@ class Plan:
 
     def _setStartingDate(self, mydate):
         """
-        Set the date when the plan starts in the current year.
+        Set the date when the case starts in the current year.
         This is mostly for reproducibility purposes and back projecting known balances to Jan 1st.
         String format of mydate is 'MM/DD', 'MM-DD', 'YYYY-MM-DD', or 'YYYY/MM/DD'. Year is ignored.
         """
@@ -432,16 +488,16 @@ class Plan:
 
     def rename(self, newname):
         """
-        Override name of the plan. Plan name is used
+        Override name of the case. Case name is used
         to distinguish graph outputs and as base name for
         saving configurations and workbooks.
         """
-        self.mylog.vprint(f"Renaming plan {self._name} -> {newname}.")
+        self.mylog.vprint(f"Renaming case '{self._name}' -> '{newname}'.")
         self._name = newname
 
     def setDescription(self, description):
         """
-        Set a text description of the plan.
+        Set a text description of the case.
         """
         self._description = description
 
@@ -458,7 +514,7 @@ class Plan:
         if not (0 <= eta <= 1):
             raise ValueError("Fraction must be between 0 and 1.")
         if self.N_i != 2:
-            self.mylog.vprint("Deposit fraction can only be 0 for single individuals.")
+            self.mylog.print("Deposit fraction can only be 0 for single individuals.")
             eta = 0
         else:
             self.mylog.vprint(f"Setting spousal surplus deposit fraction to {eta:.1f}.")
@@ -471,7 +527,7 @@ class Plan:
         """
 
         self.defaultPlots = self._checkValueType(value)
-        self.mylog.vprint(f"Setting plots default value to {value}.")
+        self.mylog.vprint(f"Setting plots default value to '{value}'.")
 
     def setPlotBackend(self, backend: str):
         """
@@ -479,12 +535,12 @@ class Plan:
         """
 
         if backend not in ("matplotlib", "plotly"):
-            raise ValueError(f"Backend {backend} not a valid option.")
+            raise ValueError(f"Backend '{backend}' not a valid option.")
 
         if backend != self._plotterName:
             self._plotter = PlotFactory.createBackend(backend)
             self._plotterName = backend
-            self.mylog.vprint(f"Setting plotting backend to {backend}.")
+            self.mylog.vprint(f"Setting plotting backend to '{backend}'.")
 
     def setDividendRate(self, mu):
         """
@@ -522,8 +578,8 @@ class Plan:
         self.caseStatus = "modified"
 
         if np.any(self.phi_j != 1):
-            self.mylog.vprint("Consider changing spousal deposit fraction for better convergence.")
-            self.mylog.vprint(f"\tRecommended: setSpousalDepositFraction({self.i_d}.)")
+            self.mylog.print("Consider changing spousal deposit fraction for better convergence.")
+            self.mylog.print(f"\tRecommended: setSpousalDepositFraction({self.i_d}.)")
 
     def setHeirsTaxRate(self, nu):
         """
@@ -558,9 +614,9 @@ class Plan:
         for i in range(self.N_i):
             if amounts[i] != 0:
                 # Check if claim age added to birth month falls next year.
-                realage = ages[i] + (self.mobs[i] - 1)/12
-                iage = int(realage)
-                fraction = 1 - (realage % 1.)
+                yearage = ages[i] + (self.mobs[i] - 1)/12
+                iage = int(yearage)
+                fraction = 1 - (yearage % 1.)
                 realns = iage - thisyear + self.yobs[i]
                 ns = max(0, realns)
                 nd = self.horizons[i]
@@ -581,6 +637,9 @@ class Plan:
     def setSocialSecurity(self, pias, ages):
         """
         Set value of social security for each individual and claiming age.
+
+        Note: Social Security benefits are paid in arrears (one month after eligibility).
+        The zeta_in array represents when checks actually arrive, not when eligibility starts.
         """
         if len(pias) != self.N_i:
             raise ValueError(f"Principal Insurance Amount must have {self.N_i} entries.")
@@ -594,51 +653,52 @@ class Plan:
         fras = socsec.getFRAs(self.yobs)
         spousalBenefits = socsec.getSpousalBenefits(pias)
 
-        self.mylog.vprint(
-            "Social security monthly benefits set to", [u.d(pias[i]) for i in range(self.N_i)],
-            "at FRAs(s)", [fras[i] for i in range(self.N_i)],
-        )
-        self.mylog.vprint(
-            "Benefits requested to start at age(s)", [ages[i] for i in range(self.N_i)],
-        )
+        self.mylog.vprint("SS monthly PIAs set to", [u.d(pias[i]) for i in range(self.N_i)])
+        self.mylog.vprint("SS FRAs(s)", [fras[i] for i in range(self.N_i)])
+        self.mylog.vprint("SS benefits claimed at age(s)", [ages[i] for i in range(self.N_i)])
 
         thisyear = date.today().year
         self.zeta_in = np.zeros((self.N_i, self.N_n))
         for i in range(self.N_i):
             # Check if age is in bound.
             bornOnFirstDays = (self.tobs[i] <= 2)
-            bornOnFirst = (self.tobs[i] == 1)
 
             eligible = 62 if bornOnFirstDays else 62 + 1/12
             if ages[i] < eligible:
-                self.mylog.vprint(f"Resetting starting age of {self.inames[i]} to {eligible}.")
+                self.mylog.print(f"Resetting SS claiming age of {self.inames[i]} to {eligible}.")
                 ages[i] = eligible
 
             # Check if claim age added to birth month falls next year.
-            # janage is age with reference to Jan 1 of yob.
+            # janage is age with reference to Jan 1 of yob when eligibility starts.
             janage = ages[i] + (self.mobs[i] - 1)/12
-            iage = int(janage)
-            realns = self.yobs[i] + iage - thisyear
-            ns = max(0, realns)
+
+            # Social Security benefits are paid in arrears (one month after eligibility).
+            # Calculate when payments actually start (checks arrive).
+            paymentJanage = janage + 1/12
+            paymentIage = int(paymentJanage)
+            paymentRealns = self.yobs[i] + paymentIage - thisyear
+            ns = max(0, paymentRealns)
             nd = self.horizons[i]
             self.zeta_in[i, ns:nd] = pias[i]
-            # Reduce starting year due to month offset. If realns < 0, this has happened already.
-            if realns >= 0:
-                self.zeta_in[i, ns] *= 1 - (janage % 1.)
+            # Reduce starting year due to month offset. If paymentRealns < 0, this has happened already.
+            if paymentRealns >= 0:
+                self.zeta_in[i, ns] *= 1 - (paymentJanage % 1.)
 
             # Increase/decrease PIA due to claiming age.
-            self.zeta_in[i, :] *= socsec.getSelfFactor(fras[i], ages[i], bornOnFirst)
+            self.zeta_in[i, :] *= socsec.getSelfFactor(fras[i], ages[i], bornOnFirstDays)
 
             # Add spousal benefits if applicable.
             if self.N_i == 2 and spousalBenefits[i] > 0:
-                # The latest of the two spouses to claim.
+                # The latest of the two spouses to claim (eligibility start).
                 claimYear = max(self.yobs + (self.mobs - 1)/12 + ages)
                 claimAge = claimYear - self.yobs[i] - (self.mobs[i] - 1)/12
-                ns2 = max(0, int(claimYear) - thisyear)
-                spousalFactor = socsec.getSpousalFactor(fras[i], claimAge, bornOnFirst)
+                # Spousal benefits are also paid in arrears (one month after eligibility).
+                paymentClaimYear = claimYear + 1/12
+                ns2 = max(0, int(paymentClaimYear) - thisyear)
+                spousalFactor = socsec.getSpousalFactor(fras[i], claimAge, bornOnFirstDays)
                 self.zeta_in[i, ns2:nd] += spousalBenefits[i] * spousalFactor
                 # Reduce first year of benefit by month offset.
-                self.zeta_in[i, ns2] -= spousalBenefits[i] * spousalFactor * (claimYear % 1.)
+                self.zeta_in[i, ns2] -= spousalBenefits[i] * spousalFactor * (paymentClaimYear % 1.)
 
         # Switch survivor to spousal survivor benefits.
         # Assumes both deceased and survivor already have claimed last year before passing (at n_d - 1).
@@ -682,7 +742,37 @@ class Plan:
         self.smileDelay = delay
         self.caseStatus = "modified"
 
-    def setRates(self, method, frm=None, to=None, values=None, stdev=None, corr=None):
+    def setReproducible(self, reproducible, seed=None):
+        """
+        Set whether rates should be reproducible for stochastic methods.
+        This should be called before setting rates. It only sets configuration
+        and does not regenerate existing rates.
+
+        Args:
+            reproducible: Boolean indicating if rates should be reproducible.
+            seed: Optional seed value. If None and reproducible is True,
+                  generates a new seed from current time. If None and
+                  reproducible is False, generates a seed but won't reuse it.
+        """
+        self.reproducibleRates = bool(reproducible)
+        if reproducible:
+            if seed is None:
+                if self.rateSeed is not None:
+                    # Reuse existing seed if available
+                    seed = self.rateSeed
+                else:
+                    # Generate new seed from current time
+                    seed = int(time.time() * 1000000)  # Use microseconds
+            else:
+                seed = int(seed)
+            self.rateSeed = seed
+        else:
+            # For non-reproducible rates, clear the seed
+            # setRates() will generate a new seed each time it's called
+            self.rateSeed = None
+
+    def setRates(self, method, frm=None, to=None, values=None, stdev=None, corr=None,
+                 override_reproducible=False, reverse=False, roll=0):
         """
         Generate rates for return and inflation based on the method and
         years selected. Note that last bound is included.
@@ -697,28 +787,85 @@ class Plan:
           must be provided, and optionally an ending year.
 
         Valid year range is from 1928 to last year.
+
+        Note: For stochastic methods, setReproducible() should be called before
+        setRates() to set the reproducibility flag and seed. If not called,
+        defaults to non-reproducible behavior.
+
+        Args:
+            override_reproducible: If True, override reproducibility setting and always generate new rates.
+                                 Used by Monte-Carlo runs to ensure different rates each time.
+            reverse: If True, reverse the rate sequence along the time axis (default False).
+            roll: Number of years to roll the sequence; positive rolls toward the end (default 0).
         """
         if frm is not None and to is None:
             to = frm + self.N_n - 1  # 'to' is inclusive.
 
-        dr = rates.Rates(self.mylog)
+        # Handle seed for stochastic methods
+        if method in ["stochastic", "histochastic"]:
+            if self.reproducibleRates and not override_reproducible:
+                if self.rateSeed is None:
+                    raise RuntimeError("Config error: reproducibleRates is True but rateSeed is None.")
+
+                seed = self.rateSeed
+            else:
+                # For non-reproducible rates or when overriding reproducibility, generate a new seed from time.
+                # This ensures we always have a seed stored in config, but it won't be reused.
+                seed = int(time.time() * 1000000)
+                if not override_reproducible:
+                    self.rateSeed = seed
+        else:
+            # For non-stochastic methods, seed is not used but we preserve it
+            # so that if user switches back to stochastic, their reproducibility settings are maintained.
+            seed = None
+
+        dr = rates.Rates(self.mylog, seed=seed)
         self.rateValues, self.rateStdev, self.rateCorr = dr.setMethod(method, frm, to, values, stdev, corr)
         self.rateMethod = method
         self.rateFrm = frm
         self.rateTo = to
+        self.rateReverse = bool(reverse)
+        self.rateRoll = int(roll)
         self.tau_kn = dr.genSeries(self.N_n).transpose()
-        self.mylog.vprint(f"Generating rate series of {len(self.tau_kn[0])} years using {method} method.")
+        # Reverse and roll are no-ops for constant (fixed) rate methods; ignore with a warning.
+        if method in rates.CONSTANT_RATE_METHODS and (reverse or roll != 0):
+            self.mylog.print("Warning: reverse and roll are ignored for constant (fixed) rate methods.")
+        else:
+            self.tau_kn = _apply_rate_sequence_transform(
+                self.tau_kn, self.rateReverse, self.rateRoll)
+        self.mylog.vprint(f"Generating rate series of {len(self.tau_kn[0])} years using '{method}' method.")
+        if method in ["stochastic", "histochastic"]:
+            repro_status = "reproducible" if self.reproducibleRates else "non-reproducible"
+            self.mylog.print(f"Using seed {seed} for {repro_status} rates.")
 
         # Once rates are selected, (re)build cumulative inflation multipliers.
         self.gamma_n = _genGamma_n(self.tau_kn)
         self._adjustedParameters = False
         self.caseStatus = "modified"
 
-    def regenRates(self):
+    def regenRates(self, override_reproducible=False):
         """
         Regenerate the rates using the arguments specified during last setRates() call.
         This method is used to regenerate stochastic time series.
+        Only stochastic and histochastic methods need regeneration.
+        All fixed rate methods (default, optimistic, conservative, user, historical average,
+        historical) don't need regeneration as they produce the same values.
+
+        Args:
+            override_reproducible: If True, override reproducibility setting and always generate new rates.
+                                 Used by Monte-Carlo runs to ensure each run gets different rates.
         """
+        # Fixed rate methods don't need regeneration - they produce the same values
+        if self.rateMethod in rates.RATE_METHODS_NO_REGEN:
+            return
+
+        # Only stochastic methods reach here
+        # If reproducibility is enabled and we're not overriding it, don't regenerate
+        # (rates should stay the same for reproducibility)
+        if self.reproducibleRates and not override_reproducible:
+            return
+
+        # Regenerate with new random values
         self.setRates(
             self.rateMethod,
             frm=self.rateFrm,
@@ -726,6 +873,9 @@ class Plan:
             values=100 * self.rateValues,
             stdev=100 * self.rateStdev,
             corr=self.rateCorr,
+            override_reproducible=override_reproducible,
+            reverse=self.rateReverse,
+            roll=self.rateRoll,
         )
 
     def setAccountBalances(self, *, taxable, taxDeferred, taxFree, startDate=None, units="k"):
@@ -786,12 +936,12 @@ class Plan:
             self.interpCenter = center
             self.interpWidth = width
         else:
-            raise ValueError(f"Method {method} not supported.")
+            raise ValueError(f"Method '{method}' not supported.")
 
         self.interpMethod = method
         self.caseStatus = "modified"
 
-        self.mylog.vprint(f"Asset allocation interpolation method set to {method}.")
+        self.mylog.vprint(f"Asset allocation interpolation method set to '{method}'.")
 
     def setAllocationRatios(self, allocType, taxable=None, taxDeferred=None, taxFree=None, generic=None):
         """
@@ -815,6 +965,11 @@ class Plan:
         generic = [[ko00, ko01, ko02, ko03], [kf00, kf01, kf02, kf02]]
         as assets are coordinated between accounts and spouses.
         """
+        # Validate allocType parameter
+        validTypes = ["account", "individual", "spouses"]
+        if allocType not in validTypes:
+            raise ValueError(f"allocType must be one of {validTypes}, got '{allocType}'.")
+
         self.boundsAR = {}
         self.alpha_ijkn = np.zeros((self.N_i, self.N_j, self.N_k, self.N_n + 1))
         if allocType == "account":
@@ -833,7 +988,7 @@ class Plan:
                             raise ValueError("Sum of percentages must add to 100.")
 
             for i in range(self.N_i):
-                self.mylog.vprint(f"{self.inames[i]}: Setting gliding allocation ratios (%) to {allocType}.")
+                self.mylog.vprint(f"{self.inames[i]}: Setting gliding allocation ratios (%) to '{allocType}'.")
                 self.mylog.vprint(f"      taxable: {taxable[i][0]} -> {taxable[i][1]}")
                 self.mylog.vprint(f"  taxDeferred: {taxDeferred[i][0]} -> {taxDeferred[i][1]}")
                 self.mylog.vprint(f"      taxFree: {taxFree[i][0]} -> {taxFree[i][1]}")
@@ -870,7 +1025,7 @@ class Plan:
                         raise ValueError("Sum of percentages must add to 100.")
 
             for i in range(self.N_i):
-                self.mylog.vprint(f"{self.inames[i]}: Setting gliding allocation ratios (%) to {allocType}.")
+                self.mylog.vprint(f"{self.inames[i]}: Setting gliding allocation ratios (%) to '{allocType}'.")
                 self.mylog.vprint(f"\t{generic[i][0]} -> {generic[i][1]}")
 
             for i in range(self.N_i):
@@ -905,9 +1060,9 @@ class Plan:
         self.ARCoord = allocType
         self.caseStatus = "modified"
 
-        self.mylog.vprint(f"Interpolating assets allocation ratios using {self.interpMethod} method.")
+        self.mylog.vprint(f"Interpolating assets allocation ratios using '{self.interpMethod}' method.")
 
-    def readContributions(self, filename):
+    def readContributions(self, filename, filename_for_logging=None):
         """
         Provide the name of the file containing the financial events
         over the anticipated life span determined by the
@@ -927,13 +1082,24 @@ class Plan:
 
         in any order. A template is provided as an example.
         Missing rows (years) are populated with zero values.
+
+        Parameters
+        ----------
+        filename : file-like object, str, or dict
+            Input file or dictionary of DataFrames
+        filename_for_logging : str, optional
+            Explicit filename for logging purposes. If provided, this will be used
+            in log messages instead of trying to extract it from filename.
         """
         try:
-            filename, self.timeLists, self.houseLists = timelists.read(filename, self.inames, self.horizons, self.mylog)
+            returned_filename, self.timeLists, self.houseLists = timelists.read(
+                filename, self.inames, self.horizons, self.mylog, filename=filename_for_logging
+            )
         except Exception as e:
             raise Exception(f"Unsuccessful read of Household Financial Profile: {e}") from e
 
-        self.timeListsFileName = filename
+        # Use filename_for_logging if provided, otherwise use returned filename
+        self.timeListsFileName = filename_for_logging if filename_for_logging is not None else returned_filename
         self.setContributions()
 
         return True
@@ -954,12 +1120,20 @@ class Plan:
 
             # Values for last 5 years of Roth conversion and contributions stored at the end
             # of array and accessed with negative index.
-            self.kappa_ijn[i, 0, :h+5] = np.roll(self.timeLists[iname]["taxable ctrb"], -5)
-            self.kappa_ijn[i, 1, :h+5] = np.roll(self.timeLists[iname]["401k ctrb"], -5)
-            self.kappa_ijn[i, 1, :h+5] += np.roll(self.timeLists[iname]["IRA ctrb"], -5)
-            self.kappa_ijn[i, 2, :h+5] = np.roll(self.timeLists[iname]["Roth 401k ctrb"], -5)
-            self.kappa_ijn[i, 2, :h+5] += np.roll(self.timeLists[iname]["Roth IRA ctrb"], -5)
-            self.myRothX_in[i, :h+5] = np.roll(self.timeLists[iname]["Roth conv"], -5)
+            self.kappa_ijn[i, 0, :h] = self.timeLists[iname]["taxable ctrb"][5:h+5]
+            self.kappa_ijn[i, 1, :h] = self.timeLists[iname]["401k ctrb"][5:h+5]
+            self.kappa_ijn[i, 1, :h] += self.timeLists[iname]["IRA ctrb"][5:h+5]
+            self.kappa_ijn[i, 2, :h] = self.timeLists[iname]["Roth 401k ctrb"][5:h+5]
+            self.kappa_ijn[i, 2, :h] += self.timeLists[iname]["Roth IRA ctrb"][5:h+5]
+            self.myRothX_in[i, :h] = self.timeLists[iname]["Roth conv"][5:h+5]
+
+            # Last 5 years are at the end of the N_n array.
+            self.kappa_ijn[i, 0, -5:] = self.timeLists[iname]["taxable ctrb"][:5]
+            self.kappa_ijn[i, 1, -5:] = self.timeLists[iname]["401k ctrb"][:5]
+            self.kappa_ijn[i, 1, -5:] += self.timeLists[iname]["IRA ctrb"][:5]
+            self.kappa_ijn[i, 2, -5:] = self.timeLists[iname]["Roth 401k ctrb"][:5]
+            self.kappa_ijn[i, 2, -5:] += self.timeLists[iname]["Roth IRA ctrb"][:5]
+            self.myRothX_in[i, -5:] = self.timeLists[iname]["Roth conv"][:5]
 
         self.caseStatus = "modified"
 
@@ -1062,7 +1236,7 @@ class Plan:
         else:
             # Create empty Debts sheet with proper columns
             ws = wb.create_sheet("Debts")
-            df = pd.DataFrame(columns=["name", "type", "year", "term", "amount", "rate"])
+            df = pd.DataFrame(columns=timelists._debtItems)
             for row in dataframe_to_rows(df, index=False, header=True):
                 ws.append(row)
             _formatDebtsSheet(ws)
@@ -1077,7 +1251,7 @@ class Plan:
         else:
             # Create empty Fixed Assets sheet with proper columns
             ws = wb.create_sheet("Fixed Assets")
-            df = pd.DataFrame(columns=["name", "type", "basis", "value", "rate", "yod", "commission"])
+            df = pd.DataFrame(columns=timelists._fixedAssetItems)
             for row in dataframe_to_rows(df, index=False, header=True):
                 ws.append(row)
             _formatFixedAssetsSheet(ws)
@@ -1169,7 +1343,7 @@ class Plan:
                 if self.pensionIsIndexed[i]:
                     self.piBar_in[i] *= gamma_n[:-1]
 
-            self.nm, self.L_nq, self.C_nq = tx.mediVals(self.yobs, self.horizons, gamma_n, self.N_n, self.N_q)
+            self.nm, self.Lbar_nq, self.Cbar_nq = tx.mediVals(self.yobs, self.horizons, gamma_n, self.N_n, self.N_q)
 
             self._adjustedParameters = True
 
@@ -1182,6 +1356,7 @@ class Plan:
         All binary variables must be lumped at the end of the vector.
         """
         medi = options.get("withMedicare", "loop") == "optimize"
+        Nmed = self.N_n - self.nm
 
         # Stack all variables in a single block vector with all binary variables at the end.
         C = {}
@@ -1190,14 +1365,20 @@ class Plan:
         C["e"] = _qC(C["d"], self.N_i, self.N_n)
         C["f"] = _qC(C["e"], self.N_n)
         C["g"] = _qC(C["f"], self.N_t, self.N_n)
-        C["m"] = _qC(C["g"], self.N_n)
+        if medi:
+            C["h"] = _qC(C["g"], self.N_n)
+            C["m"] = _qC(C["h"], Nmed, self.N_q)
+        else:
+            C["m"] = _qC(C["g"], self.N_n)
         C["s"] = _qC(C["m"], self.N_n)
         C["w"] = _qC(C["s"], self.N_n)
         C["x"] = _qC(C["w"], self.N_i, self.N_j, self.N_n)
         C["zx"] = _qC(C["x"], self.N_i, self.N_n)
-        C["zm"] = _qC(C["zx"], self.N_i, self.N_n, self.N_zx)
-        self.nvars = _qC(C["zm"], self.N_n - self.nm, self.N_q - 1) if medi else C["zm"]
+        C["zm"] = _qC(C["zx"], self.N_n, self.N_zx)
+        self.nvars = _qC(C["zm"], Nmed, self.N_q) if medi else C["zm"]
         self.nbins = self.nvars - C["zx"]
+        self.nconts = C["zx"]
+        self.nbals = C["d"]
 
         self.C = C
         self.mylog.vprint(
@@ -1224,7 +1405,7 @@ class Plan:
         self._add_conversion_limits()
         self._add_objective_constraints(objective, options)
         self._add_initial_balances()
-        self._add_surplus_deposit_linking()
+        self._add_surplus_deposit_linking(options)
         self._add_account_balance_carryover()
         self._add_net_cash_flow()
         self._add_income_profile()
@@ -1232,7 +1413,7 @@ class Plan:
         self._configure_Medicare_binary_variables(options)
         self._add_Medicare_costs(options)
         self._configure_exclusion_binary_variables(options)
-        self._build_objective_vector(objective)
+        self._build_objective_vector(objective, options)
 
     def _add_rmd_inequalities(self):
         for i in range(self.N_i):
@@ -1300,42 +1481,70 @@ class Plan:
                 self.A.addRow(row, rhs, np.inf)
 
     def _add_roth_conversion_constraints(self, options):
+        # Values in file supercedes everything.
         if "maxRothConversion" in options and options["maxRothConversion"] == "file":
             for i in range(self.N_i):
                 for n in range(self.horizons[i]):
                     rhs = self.myRothX_in[i][n]
                     self.B.setRange(_q2(self.C["x"], i, n, self.N_i, self.N_n), rhs, rhs)
         else:
+            # Don't exclude anyone by default.
+            i_xcluded = -1
+            if "noRothConversions" in options and options["noRothConversions"] != "None":
+                rhsopt = options["noRothConversions"]
+                try:
+                    i_xcluded = self.inames.index(rhsopt)
+                except ValueError as e:
+                    raise ValueError(f"Unknown individual '{rhsopt}' for noRothConversions:") from e
+                for n in range(self.horizons[i_xcluded]):
+                    self.B.setRange(_q2(self.C["x"], i_xcluded, n, self.N_i, self.N_n), 0, 0)
+
             if "maxRothConversion" in options:
-                rhsopt = options["maxRothConversion"]
-                if not isinstance(rhsopt, (int, float)):
-                    raise ValueError(f"Specified maxRothConversion {rhsopt} is not a number.")
+                rhsopt = u.get_numeric_option(options, "maxRothConversion", 0)
 
                 if rhsopt >= 0:
                     rhsopt *= self.optionsUnits
                     for i in range(self.N_i):
+                        if i == i_xcluded:
+                            continue
                         for n in range(self.horizons[i]):
-                            self.B.setRange(_q2(self.C["x"], i, n, self.N_i, self.N_n), 0, rhsopt + 0.01)
+                            # Apply the cap per individual (legacy behavior).
+                            self.B.setRange(_q2(self.C["x"], i, n, self.N_i, self.N_n), 0, rhsopt)
 
             if "startRothConversions" in options:
-                rhsopt = options["startRothConversions"]
-                if not isinstance(rhsopt, (int, float)):
-                    raise ValueError(f"Specified startRothConversions {rhsopt} is not a number.")
+                rhsopt = int(u.get_numeric_option(options, "startRothConversions", 0))
                 thisyear = date.today().year
                 yearn = max(rhsopt - thisyear, 0)
                 for i in range(self.N_i):
+                    if i == i_xcluded:
+                        continue
                     nstart = min(yearn, self.horizons[i])
                     for n in range(0, nstart):
                         self.B.setRange(_q2(self.C["x"], i, n, self.N_i, self.N_n), 0, 0)
 
-            if "noRothConversions" in options and options["noRothConversions"] != "None":
-                rhsopt = options["noRothConversions"]
-                try:
-                    i_x = self.inames.index(rhsopt)
-                except ValueError as e:
-                    raise ValueError(f"Unknown individual {rhsopt} for noRothConversions:") from e
-                for n in range(self.N_n):
-                    self.B.setRange(_q2(self.C["x"], i_x, n, self.N_i, self.N_n), 0, 0)
+            if "swapRothConverters" in options and i_xcluded == -1:
+                rhsopt = int(u.get_numeric_option(options, "swapRothConverters", 0))
+                if self.N_i == 2 and rhsopt != 0:
+                    thisyear = date.today().year
+                    absrhsopt = abs(rhsopt)
+                    yearn = max(absrhsopt - thisyear, 0)
+                    i_x = 0 if rhsopt > 0 else 1
+                    i_y = (i_x + 1) % 2
+
+                    transy = min(yearn, self.horizons[i_y])
+                    for n in range(0, transy):
+                        self.B.setRange(_q2(self.C["x"], i_y, n, self.N_i, self.N_n), 0, 0)
+
+                    transx = min(yearn, self.horizons[i_x])
+                    for n in range(transx, self.horizons[i_x]):
+                        self.B.setRange(_q2(self.C["x"], i_x, n, self.N_i, self.N_n), 0, 0)
+
+            # Disallow Roth conversions in last two years alive. Plan has at least 2 years.
+            for i in range(self.N_i):
+                if i == i_xcluded:
+                    continue
+                self.B.setRange(_q2(self.C["x"], i, self.horizons[i] - 2, self.N_i, self.N_n), 0, 0)
+                self.B.setRange(_q2(self.C["x"], i, self.horizons[i] - 1, self.N_i, self.N_n), 0, 0)
 
     def _add_withdrawal_limits(self):
         for i in range(self.N_i):
@@ -1358,9 +1567,7 @@ class Plan:
     def _add_objective_constraints(self, objective, options):
         if objective == "maxSpending":
             if "bequest" in options:
-                bequest = options["bequest"]
-                if not isinstance(bequest, (int, float)):
-                    raise ValueError(f"Desired bequest {bequest} is not a number.")
+                bequest = u.get_numeric_option(options, "bequest", 1)
                 bequest *= self.optionsUnits * self.gamma_n[-1]
             else:
                 bequest = 1
@@ -1379,9 +1586,7 @@ class Plan:
                 row.addElem(_q3(self.C["b"], i, 2, self.N_n, self.N_i, self.N_j, self.N_n + 1), 1)
             self.A.addRow(row, total_bequest_value, total_bequest_value)
         elif objective == "maxBequest":
-            spending = options["netSpending"]
-            if not isinstance(spending, (int, float)):
-                raise ValueError(f"Desired spending provided {spending} is not a number.")
+            spending = u.get_numeric_option(options, "netSpending", 1)
             spending *= self.optionsUnits
             self.B.setRange(_q1(self.C["g"], 0, self.N_n), spending, spending)
 
@@ -1395,7 +1600,7 @@ class Plan:
                 rhs = self.beta_ij[i, j] / backTau
                 self.B.setRange(_q3(self.C["b"], i, j, 0, self.N_i, self.N_j, self.N_n + 1), rhs, rhs)
 
-    def _add_surplus_deposit_linking(self):
+    def _add_surplus_deposit_linking(self, options):
         for i in range(self.N_i):
             fac1 = u.krond(i, 0) * (1 - self.eta) + u.krond(i, 1) * self.eta
             for n in range(self.n_d):
@@ -1405,8 +1610,12 @@ class Plan:
             for n in range(self.n_d, self.N_n):
                 rowDic = {_q2(self.C["d"], i, n, self.N_i, self.N_n): 1, _q1(self.C["s"], n, self.N_n): -fac2}
                 self.A.addNewRow(rowDic, 0, 0)
-        # Prevent surplus on last year.
-        self.B.setRange(_q1(self.C["s"], self.N_n - 1, self.N_n), 0, 0)
+
+        # Prevent surplus on two last year as they have little tax and/or growth consequence.
+        disallow = options.get("noLateSurplus", False)
+        if disallow:
+            self.B.setRange(_q1(self.C["s"], self.N_n - 2, self.N_n), 0, 0)
+            self.B.setRange(_q1(self.C["s"], self.N_n - 1, self.N_n), 0, 0)
 
     def _add_account_balance_carryover(self):
         tau_ijn = np.zeros((self.N_i, self.N_j, self.N_n))
@@ -1459,8 +1668,10 @@ class Plan:
         tau_0prev[tau_0prev < 0] = 0
         for n in range(self.N_n):
             rhs = -self.M_n[n] - self.J_n[n]
-            # Add fixed assets tax-free money (positive cash flow)
-            rhs += self.fixed_assets_tax_free_n[n]
+            # Add fixed assets proceeds (positive cash flow)
+            rhs += (self.fixed_assets_tax_free_n[n]
+                    + self.fixed_assets_ordinary_income_n[n]
+                    + self.fixed_assets_capital_gains_n[n])
             # Subtract debt payments (negative cash flow)
             rhs -= self.debt_payments_n[n]
             row = self.A.newRow({_q1(self.C["g"], n, self.N_n): 1})
@@ -1505,10 +1716,11 @@ class Plan:
             row = self.A.newRow()
             row.addElem(_q1(self.C["e"], n, self.N_n), 1)
             for i in range(self.N_i):
-                rhs += self.omega_in[i, n] + 0.85 * self.zetaBar_in[i, n] + self.piBar_in[i, n]
+                rhs += self.omega_in[i, n] + self.Psi_n[n] * self.zetaBar_in[i, n] + self.piBar_in[i, n]
                 row.addElem(_q3(self.C["w"], i, 1, n, self.N_i, self.N_j, self.N_n), -1)
                 row.addElem(_q2(self.C["x"], i, n, self.N_i, self.N_n), -1)
-                fak = np.sum(self.tau_kn[1:self.N_k, n] * self.alpha_ijkn[i, 0, 1:self.N_k, n], axis=0)
+                # Only positive returns are taxable (interest/dividends); losses don't reduce income.
+                fak = np.sum(np.maximum(0, self.tau_kn[1:self.N_k, n]) * self.alpha_ijkn[i, 0, 1:self.N_k, n], axis=0)
                 rhs += 0.5 * fak * self.kappa_ijn[i, 0, n]
                 row.addElem(_q3(self.C["b"], i, 0, n, self.N_i, self.N_j, self.N_n + 1), -fak)
                 row.addElem(_q3(self.C["w"], i, 0, n, self.N_i, self.N_j, self.N_n), fak)
@@ -1518,109 +1730,159 @@ class Plan:
             self.A.addRow(row, rhs, rhs)
 
     def _configure_exclusion_binary_variables(self, options):
-        if not options.get("xorConstraints", True):
+        if not options.get("amoConstraints", True):
             return
 
-        bigM = options.get("bigM", 5e6)
-        if not isinstance(bigM, (int, float)):
-            raise ValueError(f"bigM {bigM} is not a number.")
+        bigM = u.get_numeric_option(options, "bigMamo", BIGM_AMO, min_value=0)
+
+        if options.get("amoSurplus", True):
+            for n in range(self.N_n):
+                # Make z_0 and z_1 exclusive binary variables.
+                dic0 = {_q2(self.C["zx"], n, 0, self.N_n, self.N_zx): bigM*self.gamma_n[n],
+                        _q3(self.C["w"], 0, 0, n, self.N_i, self.N_j, self.N_n): -1,
+                        _q3(self.C["w"], 0, 2, n, self.N_i, self.N_j, self.N_n): -1}
+                if self.N_i == 2:
+                    dic1 = {_q3(self.C["w"], 1, 0, n, self.N_i, self.N_j, self.N_n): -1,
+                            _q3(self.C["w"], 1, 2, n, self.N_i, self.N_j, self.N_n): -1}
+                    dic0.update(dic1)
+
+                self.A.addNewRow(dic0, 0, np.inf)
 
-        for i in range(self.N_i):
-            for n in range(self.horizons[i]):
                 self.A.addNewRow(
-                    {_q3(self.C["zx"], i, n, 0, self.N_i, self.N_n, self.N_zx): bigM,
+                    {_q2(self.C["zx"], n, 1, self.N_n, self.N_zx): bigM*self.gamma_n[n],
                      _q1(self.C["s"], n, self.N_n): -1},
-                    0,
-                    bigM,
-                )
-                self.A.addNewRow(
-                    {
-                        _q3(self.C["zx"], i, n, 0, self.N_i, self.N_n, self.N_zx): bigM,
-                        _q3(self.C["w"], i, 0, n, self.N_i, self.N_j, self.N_n): 1,
-                        _q3(self.C["w"], i, 2, n, self.N_i, self.N_j, self.N_n): 1,
-                    },
-                    0,
-                    bigM,
-                )
-                self.A.addNewRow(
-                    {_q3(self.C["zx"], i, n, 1, self.N_i, self.N_n, self.N_zx): bigM,
-                     _q2(self.C["x"], i, n, self.N_i, self.N_n): -1},
-                    0,
-                    bigM,
-                )
+                    0, np.inf)
+
+                # As both can be zero, bound as z_0 + z_1 <= 1
                 self.A.addNewRow(
-                    {_q3(self.C["zx"], i, n, 1, self.N_i, self.N_n, self.N_zx): bigM,
-                     _q3(self.C["w"], i, 2, n, self.N_i, self.N_j, self.N_n): 1},
-                    0,
-                    bigM,
+                    {_q2(self.C["zx"], n, 0, self.N_n, self.N_zx): +1,
+                     _q2(self.C["zx"], n, 1, self.N_n, self.N_zx): +1},
+                    0, 1
                 )
-            for n in range(self.horizons[i], self.N_n):
-                self.B.setRange(_q3(self.C["zx"], i, n, 0, self.N_i, self.N_n, self.N_zx), 0, 0)
-                self.B.setRange(_q3(self.C["zx"], i, n, 1, self.N_i, self.N_n, self.N_zx), 0, 0)
 
-    def _configure_Medicare_binary_variables(self, options):
-        if options.get("withMedicare", "loop") != "optimize":
-            return
+        if "maxRothConversion" in options:
+            rhsopt = options.get("maxRothConversion")
+            if rhsopt != "file":
+                rhsopt = u.get_numeric_option(options, "maxRothConversion", 0)
+                if rhsopt < -1:
+                    return
 
-        bigM = options.get("bigM", 5e6)
-        if not isinstance(bigM, (int, float)):
-            raise ValueError(f"bigM {bigM} is not a number.")
+        # Turning off this constraint for maxRothConversions = 0 makes solution infeasible.
+        if options.get("amoRoth", True):
+            for n in range(self.N_n):
+                # Make z_2 and z_3 exclusive binary variables.
+                dic0 = {_q2(self.C["zx"], n, 2, self.N_n, self.N_zx): bigM*self.gamma_n[n],
+                        _q2(self.C["x"], 0, n, self.N_i, self.N_n): -1}
+                if self.N_i == 2:
+                    dic1 = {_q2(self.C["x"], 1, n, self.N_i, self.N_n): -1}
+                    dic0.update(dic1)
 
-        Nmed = self.N_n - self.nm
-        offset = 0
-        if self.nm < 2:
-            offset = 2 - self.nm
-            for nn in range(offset):
-                n = self.nm + nn
-                for q in range(self.N_q - 1):
-                    self.A.addNewRow({_q2(self.C["zm"], nn, q, Nmed, self.N_q - 1): bigM},
-                                     -np.inf, bigM - self.L_nq[nn, q] + self.prevMAGI[n])
-                    self.A.addNewRow({_q2(self.C["zm"], nn, q, Nmed, self.N_q - 1): -bigM},
-                                     -np.inf, self.L_nq[nn, q] - self.prevMAGI[n])
-
-        for nn in range(offset, Nmed):
-            n2 = self.nm + nn - 2  # n - 2
-            for q in range(self.N_q - 1):
-                rhs1 = bigM - self.L_nq[nn, q]
-                rhs2 = self.L_nq[nn, q]
-                row1 = self.A.newRow()
-                row2 = self.A.newRow()
-
-                row1.addElem(_q2(self.C["zm"], nn, q, Nmed, self.N_q - 1), +bigM)
-                row2.addElem(_q2(self.C["zm"], nn, q, Nmed, self.N_q - 1), -bigM)
-                for i in range(self.N_i):
-                    row1.addElem(_q3(self.C["w"], i, 1, n2, self.N_i, self.N_j, self.N_n), -1)
-                    row2.addElem(_q3(self.C["w"], i, 1, n2, self.N_i, self.N_j, self.N_n), +1)
+                self.A.addNewRow(dic0, 0, np.inf)
 
-                    row1.addElem(_q2(self.C["x"], i, n2, self.N_i, self.N_n), -1)
-                    row2.addElem(_q2(self.C["x"], i, n2, self.N_i, self.N_n), +1)
+                dic0 = {_q2(self.C["zx"], n, 3, self.N_n, self.N_zx): bigM*self.gamma_n[n],
+                        _q3(self.C["w"], 0, 2, n, self.N_i, self.N_j, self.N_n): -1}
+                if self.N_i == 2:
+                    dic1 = {_q3(self.C["w"], 1, 2, n, self.N_i, self.N_j, self.N_n): -1}
+                    dic0.update(dic1)
 
-                    # Dividends and interest gains for year n2.
-                    afac = (self.mu*self.alpha_ijkn[i, 0, 0, n2]
-                            + np.sum(self.alpha_ijkn[i, 0, 1:, n2]*self.tau_kn[1:, n2]))
+                self.A.addNewRow(dic0, 0, np.inf)
 
-                    row1.addElem(_q3(self.C["b"], i, 0, n2, self.N_i, self.N_j, self.N_n + 1), -afac)
-                    row2.addElem(_q3(self.C["b"], i, 0, n2, self.N_i, self.N_j, self.N_n + 1), +afac)
+                self.A.addNewRow(
+                    {_q2(self.C["zx"], n, 2, self.N_n, self.N_zx): +1,
+                     _q2(self.C["zx"], n, 3, self.N_n, self.N_zx): +1},
+                    0, 1
+                )
 
-                    row1.addElem(_q2(self.C["d"], i, n2, self.N_i, self.N_n), -afac)
-                    row2.addElem(_q2(self.C["d"], i, n2, self.N_i, self.N_n), +afac)
+    def _configure_Medicare_binary_variables(self, options):
+        if options.get("withMedicare", "loop") != "optimize":
+            return
 
-                    # Capital gains on stocks sold from taxable account accrued in year n2 - 1.
-                    bfac = self.alpha_ijkn[i, 0, 0, n2] * max(0, self.tau_kn[0, max(0, n2-1)])
+        bigM = u.get_numeric_option(options, "bigMamo", BIGM_AMO, min_value=0)
+        Nmed = self.N_n - self.nm
+        # Select exactly one IRMAA bracket per year (SOS1 behavior).
+        for nn in range(Nmed):
+            row = self.A.newRow()
+            for q in range(self.N_q):
+                row.addElem(_q2(self.C["zm"], nn, q, Nmed, self.N_q), 1)
+            self.A.addRow(row, 1, 1)
 
-                    row1.addElem(_q3(self.C["w"], i, 0, n2, self.N_i, self.N_j, self.N_n), +afac - bfac)
-                    row2.addElem(_q3(self.C["w"], i, 0, n2, self.N_i, self.N_j, self.N_n), -afac + bfac)
+        # MAGI decomposition into bracket portions: sum_q h_{q} = MAGI.
+        for nn in range(Nmed):
+            n = self.nm + nn
+            row = self.A.newRow()
+            for q in range(self.N_q):
+                row.addElem(_q2(self.C["h"], nn, q, Nmed, self.N_q), 1)
+
+            if n < 2:
+                self.A.addRow(row, self.prevMAGI[n], self.prevMAGI[n])
+                # Fix bracket selection for known previous MAGI.
+                magi = self.prevMAGI[n]
+                qsel = 0
+                for q in range(1, self.N_q):
+                    if magi > self.Lbar_nq[nn, q - 1]:
+                        qsel = q
+                for q in range(self.N_q):
+                    idx = _q2(self.C["zm"], nn, q, Nmed, self.N_q)
+                    val = 1 if q == qsel else 0
+                    self.B.setRange(idx, val, val)
+                continue
+
+            n2 = n - 2
+            rhs = (self.fixed_assets_ordinary_income_n[n2]
+                   + self.fixed_assets_capital_gains_n[n2])
+
+            row.addElem(_q1(self.C["e"], n2, self.N_n), -1)
+            for i in range(self.N_i):
+                row.addElem(_q3(self.C["w"], i, 1, n2, self.N_i, self.N_j, self.N_n), -1)
+                row.addElem(_q2(self.C["x"], i, n2, self.N_i, self.N_n), -1)
+
+                # Dividends and interest gains for year n2. Only positive returns are taxable.
+                afac = (self.mu * self.alpha_ijkn[i, 0, 0, n2]
+                        + np.sum(self.alpha_ijkn[i, 0, 1:, n2] * np.maximum(0, self.tau_kn[1:, n2])))
+
+                row.addElem(_q3(self.C["b"], i, 0, n2, self.N_i, self.N_j, self.N_n + 1), -afac)
+                row.addElem(_q2(self.C["d"], i, n2, self.N_i, self.N_n), -afac)
+
+                # Capital gains on stocks sold from taxable account accrued in year n2 - 1.
+                # Capital gains = price appreciation only (total return - dividend rate)
+                #  to avoid double taxation of dividends.
+                tau_prev = self.tau_kn[0, max(0, n2 - 1)]
+                bfac = self.alpha_ijkn[i, 0, 0, n2] * max(0, tau_prev - self.mu)
+                row.addElem(_q3(self.C["w"], i, 0, n2, self.N_i, self.N_j, self.N_n), afac - bfac)
+
+                # MAGI includes total Social Security (taxable + non-taxable) for IRMAA.
+                sumoni = (self.omega_in[i, n2]
+                          + self.zetaBar_in[i, n2]
+                          + self.piBar_in[i, n2]
+                          + 0.5 * self.kappa_ijn[i, 0, n2] * afac)
+                rhs += sumoni
 
-                    sumoni = (self.omega_in[i, n2] + self.psi_n[n2] * self.zetaBar_in[i, n2] + self.piBar_in[i, n2]
-                              + 0.5 * self.kappa_ijn[i, 0, n2] * afac)
-                    rhs1 += sumoni
-                    rhs2 -= sumoni
+            self.A.addRow(row, rhs, rhs)
 
-                self.A.addRow(row1, -np.inf, rhs1)
-                self.A.addRow(row2, -np.inf, rhs2)
+        # Bracket bounds: L_{q-1} z_q <= mg_q <= L_q z_q.
+        for nn in range(Nmed):
+            for q in range(self.N_q):
+                mg_idx = _q2(self.C["h"], nn, q, Nmed, self.N_q)
+                zm_idx = _q2(self.C["zm"], nn, q, Nmed, self.N_q)
+
+                lower = 0 if q == 0 else self.Lbar_nq[nn, q - 1]
+                if lower > 0:
+                    self.A.addNewRow({mg_idx: 1, zm_idx: -lower}, 0, np.inf)
+
+                if q < self.N_q - 1:
+                    upper = self.Lbar_nq[nn, q]
+                    self.A.addNewRow({mg_idx: 1, zm_idx: -upper}, -np.inf, 0)
+                else:
+                    # Upper bound for last bracket so h_qn = 0 when z_q = 0.
+                    upper = bigM * self.gamma_n[self.nm + nn]
+                    self.A.addNewRow({mg_idx: 1, zm_idx: -upper}, -np.inf, 0)
 
     def _add_Medicare_costs(self, options):
         if options.get("withMedicare", "loop") != "optimize":
+            # In loop mode, Medicare costs are computed outside the solver (M_n).
+            # Ensure the in-model Medicare variable (m_n) stays at zero.
+            for n in range(self.N_n):
+                self.B.setRange(_q1(self.C["m"], n, self.N_n), 0, 0)
             return
 
         for n in range(self.nm):
@@ -1631,33 +1893,57 @@ class Plan:
             n = self.nm + nn
             row = self.A.newRow()
             row.addElem(_q1(self.C["m"], n, self.N_n), 1)
-            for q in range(self.N_q - 1):
-                row.addElem(_q2(self.C["zm"], nn, q, Nmed, self.N_q - 1), -self.C_nq[nn, q+1])
-            self.A.addRow(row, self.C_nq[nn, 0], self.C_nq[nn, 0])
+            for q in range(self.N_q):
+                row.addElem(_q2(self.C["zm"], nn, q, Nmed, self.N_q), -self.Cbar_nq[nn, q])
+            self.A.addRow(row, 0, 0)
 
-    def _build_objective_vector(self, objective):
-        c = abc.Objective(self.nvars)
+    def _build_objective_vector(self, objective, options):
+        c_arr = np.zeros(self.nvars)
         if objective == "maxSpending":
             for n in range(self.N_n):
-                c.setElem(_q1(self.C["g"], n, self.N_n), -1/self.gamma_n[n])
+                c_arr[_q1(self.C["g"], n, self.N_n)] = -1/self.gamma_n[n]
         elif objective == "maxBequest":
             for i in range(self.N_i):
-                c.setElem(_q3(self.C["b"], i, 0, self.N_n, self.N_i, self.N_j, self.N_n + 1), -1)
-                c.setElem(_q3(self.C["b"], i, 1, self.N_n, self.N_i, self.N_j, self.N_n + 1), -(1 - self.nu))
-                c.setElem(_q3(self.C["b"], i, 2, self.N_n, self.N_i, self.N_j, self.N_n + 1), -1)
+                c_arr[_q3(self.C["b"], i, 0, self.N_n, self.N_i, self.N_j, self.N_n + 1)] = -1
+                c_arr[_q3(self.C["b"], i, 1, self.N_n, self.N_i, self.N_j, self.N_n + 1)] = -(1 - self.nu)
+                c_arr[_q3(self.C["b"], i, 2, self.N_n, self.N_i, self.N_j, self.N_n + 1)] = -1
         else:
             raise RuntimeError("Internal error in objective function.")
+
+        # Turn on epsilon by default when optimizing Medicare.
+        withMedicare = options.get("withMedicare", "loop")
+        default_epsilon = EPSILON if withMedicare == "optimize" else 0
+        epsilon = u.get_numeric_option(options, "epsilon", default_epsilon, min_value=0)
+        if epsilon > 0:
+            # Penalize Roth conversions to reduce churn.
+            for i in range(self.N_i):
+                for n in range(self.N_n):
+                    c_arr[_q2(self.C["x"], i, n, self.N_i, self.N_n)] += epsilon
+
+            if self.N_i == 2:
+                # Favor withdrawals from spouse 0 by penalizing spouse 1 withdrawals.
+                for j in range(self.N_j):
+                    for n in range(self.N_n):
+                        c_arr[_q3(self.C["w"], 1, j, n, self.N_i, self.N_j, self.N_n)] += epsilon
+
+        c = abc.Objective(self.nvars)
+        for idx in np.flatnonzero(c_arr):
+            c.setElem(idx, c_arr[idx])
         self.c = c
 
     @_timer
-    def runHistoricalRange(self, objective, options, ystart, yend, *, verbose=False, figure=False, progcall=None):
+    def runHistoricalRange(self, objective, options, ystart, yend, *, verbose=False, figure=False,
+                           progcall=None, reverse=False, roll=0):
         """
         Run historical scenarios on plan over a range of years.
-        """
 
+        For each year in [ystart, yend], rates are set to the historical sequence
+        starting at that year. Optional reverse and roll apply to each sequence
+        (same semantics as setRates).
+        """
         if yend + self.N_n > self.year_n[0]:
             yend = self.year_n[0] - self.N_n - 1
-            self.mylog.vprint(f"Warning: Upper bound for year range re-adjusted to {yend}.")
+            self.mylog.print(f"Warning: Upper bound for year range re-adjusted to {yend}.")
 
         if yend < ystart:
             raise ValueError(f"Starting year is too large to support a lifespan of {self.N_n} years.")
@@ -1672,8 +1958,8 @@ class Plan:
         elif objective == "maxBequest":
             columns = ["partial", "final"]
         else:
-            self.mylog.print(f"Invalid objective {objective}.")
-            raise ValueError(f"Invalid objective {objective}.")
+            self.mylog.print(f"Invalid objective '{objective}'.")
+            raise ValueError(f"Invalid objective '{objective}'.")
 
         df = pd.DataFrame(columns=columns)
 
@@ -1684,7 +1970,7 @@ class Plan:
             progcall.start()
 
         for year in range(ystart, yend + 1):
-            self.setRates("historical", year)
+            self.setRates("historical", year, reverse=reverse, roll=roll)
             self.solve(objective, options)
             if not verbose:
                 progcall.show((year - ystart + 1) / N)
@@ -1725,7 +2011,7 @@ class Plan:
         elif objective == "maxBequest":
             columns = ["partial", "final"]
         else:
-            self.mylog.print(f"Invalid objective {objective}.")
+            self.mylog.print(f"Invalid objective '{objective}'.")
             return None
 
         df = pd.DataFrame(columns=columns)
@@ -1737,7 +2023,7 @@ class Plan:
             progcall.start()
 
         for n in range(N):
-            self.regenRates()
+            self.regenRates(override_reproducible=True)
             self.solve(objective, myoptions)
             if not verbose:
                 progcall.show((n + 1) / N)
@@ -1786,52 +2072,68 @@ class Plan:
 
         Refer to companion document for implementation details.
         """
+
         if self.rateMethod is None:
             raise RuntimeError("Rate method must be selected before solving.")
 
         # Assume unsuccessful until problem solved.
         self.caseStatus = "unsuccessful"
+        self.convergenceType = "undefined"
 
         # Check objective and required options.
         knownObjectives = ["maxBequest", "maxSpending"]
         knownSolvers = ["HiGHS", "PuLP/CBC", "PuLP/HiGHS", "MOSEK"]
 
         knownOptions = [
+            "absTol",
+            "amoConstraints",
+            "amoRoth",
+            "amoSurplus",
             "bequest",
-            "bigM",
+            "bigMamo",    # Big-M value for AMO constraints (default: 5e7)
+            "epsilon",
+            "gap",
+            "maxIter",
             "maxRothConversion",
             "netSpending",
+            "noLateSurplus",
             "noRothConversions",
             "oppCostX",
-            "withMedicare",
             "previousMAGIs",
+            "relTol",
             "solver",
             "spendingSlack",
             "startRothConversions",
+            "swapRothConverters",
+            "maxTime",
             "units",
-            "xorConstraints",
+            "verbose",
+            "withMedicare",
             "withSCLoop",
         ]
-        # We might modify options if required.
         options = {} if options is None else options
+
+        # We might modify options if required.
         myoptions = dict(options)
 
-        for opt in myoptions:
+        for opt in list(myoptions.keys()):
             if opt not in knownOptions:
-                raise ValueError(f"Option {opt} is not one of {knownOptions}.")
+                # raise ValueError(f"Option '{opt}' is not one of {knownOptions}.")
+                self.mylog.print(f"Ignoring unknown solver option '{opt}'.")
+                myoptions.pop(opt)
 
         if objective not in knownObjectives:
-            raise ValueError(f"Objective {objective} is not one of {knownObjectives}.")
+            raise ValueError(f"Objective '{objective}' is not one of {knownObjectives}.")
 
         if objective == "maxBequest" and "netSpending" not in myoptions:
-            raise RuntimeError(f"Objective {objective} needs netSpending option.")
+            raise RuntimeError(f"Objective '{objective}' needs netSpending option.")
 
         if objective == "maxBequest" and "bequest" in myoptions:
-            self.mylog.vprint("Ignoring bequest option provided.")
+            self.mylog.print("Ignoring bequest option provided.")
             myoptions.pop("bequest")
 
         if objective == "maxSpending" and "netSpending" in myoptions:
-            self.mylog.vprint("Ignoring netSpending option provided.")
+            self.mylog.print("Ignoring netSpending option provided.")
             myoptions.pop("netSpending")
 
         if objective == "maxSpending" and "bequest" not in myoptions:
@@ -1839,9 +2141,24 @@ class Plan:
 
         self.optionsUnits = u.getUnits(myoptions.get("units", "k"))
 
-        oppCostX = options.get("oppCostX", 0.)
+        oppCostX = myoptions.get("oppCostX", 0.)
         self.xnet = 1 - oppCostX / 100.
 
+        if "swapRothConverters" in myoptions and "noRothConversions" in myoptions:
+            self.mylog.print("Ignoring 'noRothConversions' as 'swapRothConverters' option present.")
+            myoptions.pop("noRothConversions")
+
+        # Go easy on MILP - auto gap somehow.
+        if "gap" not in myoptions and myoptions.get("withMedicare", "loop") == "optimize":
+            fac = 1
+            maxRoth = myoptions.get("maxRothConversion", 100)
+            if maxRoth != "file" and maxRoth <= 15:
+                fac = 10
+            # Loosen default MIP gap when Medicare is optimized. Even more if rothX == 0
+            gap = fac * MILP_GAP
+            myoptions["gap"] = gap
+            self.mylog.vprint(f"Using restricted gap of {gap:.1e}.")
+
         self.prevMAGI = np.zeros(2)
         if "previousMAGIs" in myoptions:
             magi = myoptions["previousMAGIs"]
@@ -1852,7 +2169,7 @@ class Plan:
 
         lambdha = myoptions.get("spendingSlack", 0)
         if not (0 <= lambdha <= 50):
-            raise ValueError(f"Slack value out of range {lambdha}.")
+            raise ValueError(f"Slack value {lambdha} out of range.")
         self.lambdha = lambdha / 100
 
         # Reset long-term capital gain tax rate and MAGI to zero.
@@ -1862,14 +2179,14 @@ class Plan:
         self.M_n = np.zeros(self.N_n)
 
         self._adjustParameters(self.gamma_n, self.MAGI_n)
-        self._buildOffsetMap(options)
+        self._buildOffsetMap(myoptions)
 
         # Process debts and fixed assets
         self.processDebtsAndFixedAssets()
 
         solver = myoptions.get("solver", self.defaultSolver)
         if solver not in knownSolvers:
-            raise ValueError(f"Unknown solver {solver}.")
+            raise ValueError(f"Unknown solver '{solver}'.")
 
         if solver == "HiGHS":
             solverMethod = self._milpSolve
@@ -1880,7 +2197,10 @@ class Plan:
         else:
             raise RuntimeError("Internal error in defining solverMethod.")
 
-        self._scSolve(objective, options, solverMethod)
+        self.mylog.vprint(f"Using '{solver}' solver.")
+        myoptions_txt = textwrap.fill(f"{myoptions}", initial_indent="\t", subsequent_indent="\t", width=100)
+        self.mylog.vprint(f"Solver options:\n{myoptions_txt}.")
+        self._scSolve(objective, myoptions, solverMethod)
 
         self.objective = objective
         self.solverOptions = myoptions
@@ -1894,6 +2214,20 @@ class Plan:
         includeMedicare = options.get("withMedicare", "loop") == "loop"
         withSCLoop = options.get("withSCLoop", True)
 
+        # Convergence uses a relative tolerance tied to MILP gap,
+        # with an absolute floor to avoid zero/near-zero objectives.
+        gap = u.get_numeric_option(options, "gap", GAP, min_value=0)
+        abs_tol = u.get_numeric_option(options, "absTol", ABS_TOL, min_value=0)
+        rel_tol = options.get("relTol")
+        if rel_tol is None:
+            # Keep rel_tol aligned with solver gap to avoid SC loop chasing noise.
+            rel_tol = max(REL_TOL, gap / 300)
+        # rel_tol = u.get_numeric_option({"relTol": rel_tol}, "relTol", REL_TOL, min_value=0)
+        self.mylog.print(f"Using relTol={rel_tol:.1e}, absTol={abs_tol:.1e}, and gap={gap:.1e}.")
+
+        max_iterations = int(u.get_numeric_option(options, "maxIter", MAX_ITERATIONS, min_value=1))
+        self.mylog.print(f"Using maxIter={max_iterations}.")
+
         if objective == "maxSpending":
             objFac = -1 / self.xi_n[0]
         else:
@@ -1902,38 +2236,91 @@ class Plan:
         it = 0
         old_x = np.zeros(self.nvars)
         old_objfns = [np.inf]
+        scaled_obj_history = []  # Track scaled objective values for oscillation detection
+        sol_history = []  # Track solutions aligned with scaled_obj_history
+        obj_history = []  # Track raw objective values aligned with scaled_obj_history
         self._computeNLstuff(None, includeMedicare)
         while True:
-            objfn, xx, solverSuccess, solverMsg = solverMethod(objective, options)
+            objfn, xx, solverSuccess, solverMsg, solgap = solverMethod(objective, options)
 
             if not solverSuccess or objfn is None:
-                self.mylog.vprint("Solver failed:", solverMsg, solverSuccess)
+                self.mylog.print("Solver failed:", solverMsg, solverSuccess)
                 break
 
             if not withSCLoop:
+                # When Medicare is in loop mode, M_n was zero in the constraint for this
+                # single solve. Update M_n (and J_n) from solution for reporting.
+                if includeMedicare:
+                    self._computeNLstuff(xx, includeMedicare)
+                    self.mylog.print(
+                        "Warning: Self-consistent loop is off; Medicare premiums are "
+                        "computed for display but were not in the budget constraint."
+                    )
                 break
 
             self._computeNLstuff(xx, includeMedicare)
 
             delta = xx - old_x
-            absSolDiff = np.sum(np.abs(delta), axis=0)/100
-            absObjDiff = abs(objFac*(objfn + old_objfns[-1]))/100
-            self.mylog.vprint(f"Iteration: {it} objective: {u.d(objfn * objFac, f=2)},"
-                              f" |dX|: {absSolDiff:.2f}, |df|: {u.d(absObjDiff, f=2)}")
-
-            # 50 cents accuracy.
-            if absSolDiff < .5 and absObjDiff < .5:
-                self.mylog.vprint("Converged on full solution.")
+            # Only consider account balances in dX.
+            absSolDiff = np.sum(np.abs(delta[:self.nbals]), axis=0)/self.nbals
+            absObjDiff = abs(objFac*(objfn + old_objfns[-1]))
+            scaled_obj = objfn * objFac
+            scaled_obj_history.append(scaled_obj)
+            sol_history.append(xx)
+            obj_history.append(objfn)
+            self.mylog.vprint(f"Iter: {it:02}; f: {u.d(scaled_obj, f=0)}; gap: {solgap:.1e};"
+                              f" |dX|: {absSolDiff:.0f}; |df|: {u.d(absObjDiff, f=0)}")
+
+            # Solution difference is calculated and reported but not used for convergence
+            # since it scales with problem size and can prevent convergence for large cases.
+            prev_scaled_obj = scaled_obj
+            if np.isfinite(old_objfns[-1]):
+                prev_scaled_obj = (-old_objfns[-1]) * objFac
+            scale = max(1.0, abs(scaled_obj), abs(prev_scaled_obj))
+            tol = max(abs_tol, rel_tol * scale)
+            # With Medicare in loop mode, the first solve uses M_n=0; require at least
+            # one re-solve so the accepted solution had Medicare in the budget.
+            if absObjDiff <= tol and (not includeMedicare or it >= 1):
+                # Check if convergence was monotonic or oscillatory
+                # old_objfns stores -objfn values, so we need to scale them to match displayed values
+                # For monotonic convergence, the scaled objective (objfn * objFac) should be non-increasing
+                # Include current iteration's scaled objfn value
+                scaled_objfns = [(-val) * objFac for val in old_objfns[1:]] + [scaled_obj]
+                # Check if scaled objective function is non-increasing (monotonic convergence)
+                is_monotonic = all(scaled_objfns[i] <= scaled_objfns[i-1] + tol
+                                   for i in range(1, len(scaled_objfns)))
+                if is_monotonic:
+                    self.convergenceType = "monotonic"
+                else:
+                    self.convergenceType = "oscillatory"
+                self.mylog.print(f"Converged on full solution with {self.convergenceType} behavior.")
                 break
 
-            # Avoid oscillatory solutions. Look only at most recent solutions. Within $10.
-            isclosenough = abs(-objfn - min(old_objfns[int(it / 2) :])) < 10 * self.xi_n[0]
-            if isclosenough:
-                self.mylog.vprint("Converged through selecting minimum oscillating objective.")
-                break
+            # Check for oscillation (need at least 4 iterations to detect a 2-cycle)
+            if it >= 3:
+                cycle_len = self._detectOscillation(scaled_obj_history, tol)
+                if cycle_len is not None:
+                    # Find the best (maximum) objective in the cycle
+                    cycle_values = scaled_obj_history[-cycle_len:]
+                    best_idx = np.argmax(cycle_values)
+                    best_obj = cycle_values[best_idx]
+                    self.convergenceType = f"oscillatory (cycle length {cycle_len})"
+                    self.mylog.print(f"Oscillation detected: {cycle_len}-cycle pattern identified.")
+                    self.mylog.print(f"Best objective in cycle: {u.d(best_obj, f=2)}")
+
+                    # Select the solution corresponding to the best objective in the detected cycle.
+                    cycle_solutions = sol_history[-cycle_len:]
+                    cycle_objfns = obj_history[-cycle_len:]
+                    xx = cycle_solutions[best_idx]
+                    objfn = cycle_objfns[best_idx]
+                    self.mylog.print("Using best solution from detected cycle.")
+
+                    self.mylog.print("Accepting solution from cycle and terminating.")
+                    break
 
-            if it > 59:
-                self.mylog.vprint("WARNING: Exiting loop on maximum iterations.")
+            if it >= max_iterations:
+                self.convergenceType = "max iteration"
+                self.mylog.print("Warning: Exiting loop on maximum iterations.")
                 break
 
             it += 1
@@ -1941,15 +2328,15 @@ class Plan:
             old_x = xx
 
         if solverSuccess:
-            self.mylog.vprint(f"Self-consistent loop returned after {it+1} iterations.")
-            self.mylog.vprint(solverMsg)
-            self.mylog.vprint(f"Objective: {u.d(objfn * objFac)}")
+            self.mylog.print(f"Self-consistent loop returned after {it+1} iterations.")
+            self.mylog.print(solverMsg)
+            self.mylog.print(f"Objective: {u.d(objfn * objFac)}")
             # self.mylog.vprint('Upper bound:', u.d(-solution.mip_dual_bound))
             self._aggregateResults(xx)
             self._timestamp = datetime.now().strftime("%Y-%m-%d at %H:%M:%S")
             self.caseStatus = "solved"
         else:
-            self.mylog.vprint("WARNING: Optimization failed:", solverMsg, solverSuccess)
+            self.mylog.print("Warning: Optimization failed:", solverMsg, solverSuccess)
             self.caseStatus = "unsuccessful"
 
         return None
@@ -1960,12 +2347,17 @@ class Plan:
         """
         from scipy import optimize
 
+        time_limit = u.get_numeric_option(options, "maxTime", TIME_LIMIT, min_value=0)  # seconds
+        mygap = u.get_numeric_option(options, "gap", GAP, min_value=0)
+        verbose = options.get("verbose", False)
+
         # Optimize solver parameters
         milpOptions = {
-            "disp": False,
-            "mip_rel_gap": 1e-7,
+            "disp": bool(verbose),
+            "mip_rel_gap": mygap,    # Internal default in milp is 1e-4
             "presolve": True,
-            "node_limit": 1000000  # Limit search nodes for faster solutions
+            "time_limit": time_limit,
+            "node_limit": 1000000    # Limit search nodes for faster solutions
         }
 
         self._buildConstraints(objective, options)
@@ -1984,7 +2376,7 @@ class Plan:
             options=milpOptions,
         )
 
-        return solution.fun, solution.x, solution.success, solution.message
+        return solution.fun, solution.x, solution.success, solution.message, solution.mip_gap
 
     def _pulpSolve(self, objective, options):
         """
@@ -2049,7 +2441,7 @@ class Plan:
         solution = np.dot(c, xx)
         success = (pulp.LpStatus[prob.status] == "Optimal")
 
-        return solution, xx, success, pulp.LpStatus[prob.status]
+        return solution, xx, success, pulp.LpStatus[prob.status], -1
 
     def _mosekSolve(self, objective, options):
         """
@@ -2068,6 +2460,7 @@ class Plan:
         solverMsg = str()
 
         def _streamPrinter(text, msg=solverMsg):
+            self.mylog.vprint(text.strip())
             msg += text
 
         self._buildConstraints(objective, options)
@@ -2078,10 +2471,24 @@ class Plan:
         vkeys = self.B.keys()
         cind, cval = self.c.lists()
 
+        time_limit = u.get_numeric_option(options, "maxTime", TIME_LIMIT, min_value=0)
+        mygap = u.get_numeric_option(options, "gap", GAP, min_value=0)
+
+        verbose = options.get("verbose", False)
+
         task = mosek.Task()
-        # task.putdouparam(mosek.dparam.mio_rel_gap_const, 1e-6)
-        # task.putdouparam(mosek.dparam.mio_tol_abs_relax_int, 1e-4)
-        # task.set_Stream(mosek.streamtype.msg, _streamPrinter)
+        task.putdouparam(mosek.dparam.mio_max_time, time_limit)        # Default -1
+        # task.putdouparam(mosek.dparam.mio_rel_gap_const, 1e-6)       # Default 1e-10
+        task.putdouparam(mosek.dparam.mio_tol_rel_gap, mygap)          # Default 1e-4
+        # task.putdouparam(mosek.dparam.mio_tol_abs_relax_int, 2e-5)   # Default 1e-5
+        # task.putdouparam(mosek.iparam.mio_heuristic_level, 3)        # Default -1
+
+        # task.set_Stream(mosek.streamtype.wrn, _streamPrinter)
+        task.set_Stream(mosek.streamtype.err, _streamPrinter)
+        if verbose:
+            # task.set_Stream(mosek.streamtype.log, _streamPrinter)
+            task.set_Stream(mosek.streamtype.msg, _streamPrinter)
+
         task.appendcons(self.A.ncons)
         task.appendvars(self.A.nvars)
 
@@ -2104,14 +2511,67 @@ class Plan:
         # Problem MUST contain binary variables to make these calls.
         solsta = task.getsolsta(mosek.soltype.itg)
         solverSuccess = (solsta == mosek.solsta.integer_optimal)
+        rel_gap = task.getdouinf(mosek.dinfitem.mio_obj_rel_gap) if solverSuccess else -1
 
         xx = np.array(task.getxx(mosek.soltype.itg))
         solution = task.getprimalobj(mosek.soltype.itg)
-        task.set_Stream(mosek.streamtype.wrn, _streamPrinter)
         task.solutionsummary(mosek.streamtype.msg)
         # task.writedata(self._name+'.ptf')
 
-        return solution, xx, solverSuccess, solverMsg
+        return solution, xx, solverSuccess, solverMsg, rel_gap
+
+    def _detectOscillation(self, obj_history, tolerance, max_cycle_length=15):
+        """
+        Detect if the objective function is oscillating in a repeating cycle.
+
+        This function checks for repeating patterns of any length (2, 3, 4, etc.)
+        in the recent objective function history. It handles numerical precision
+        by using a tolerance for "close enough" matching.
+
+        Parameters
+        ----------
+        obj_history : list
+            List of recent objective function values (most recent last)
+        tolerance : float
+            Tolerance for considering two values "equal" (same as convergence tolerance)
+        max_cycle_length : int
+            Maximum cycle length to check for (default 15)
+
+        Returns
+        -------
+        int or None
+            Cycle length if oscillation detected, None otherwise
+        """
+        if len(obj_history) < 4:  # Need at least 4 values to detect a 2-cycle
+            return None
+
+        # Check for cycles of length 2, 3, 4, ... up to max_cycle_length
+        # We need at least 2*cycle_length values to confirm a cycle
+        for cycle_len in range(2, min(max_cycle_length + 1, len(obj_history) // 2 + 1)):
+            # Check if the last cycle_len values match the previous cycle_len values
+            if len(obj_history) < 2 * cycle_len:
+                continue
+
+            recent = obj_history[-cycle_len:]
+            previous = obj_history[-2*cycle_len:-cycle_len]
+
+            # Check if all pairs match within tolerance
+            matches = all(abs(recent[i] - previous[i]) <= tolerance
+                          for i in range(cycle_len))
+
+            if matches:
+                # Verify it's a true cycle by checking one more period back if available
+                if len(obj_history) >= 3 * cycle_len:
+                    earlier = obj_history[-3*cycle_len:-2*cycle_len]
+                    if all(abs(recent[i] - earlier[i]) <= tolerance
+                           for i in range(cycle_len)):
+                        return cycle_len
+                else:
+                    # If we don't have enough history, still report the cycle
+                    # but it's less certain
+                    return cycle_len
+
+        return None
 
     def _computeNLstuff(self, x, includeMedicare):
         """
@@ -2128,7 +2588,13 @@ class Plan:
         self._aggregateResults(x, short=True)
 
         self.J_n = tx.computeNIIT(self.N_i, self.MAGI_n, self.I_n, self.Q_n, self.n_d, self.N_n)
-        self.psi_n = tx.capitalGainTaxRate(self.N_i, self.MAGI_n, self.gamma_n[:-1], self.n_d, self.N_n)
+        ltcg_n = np.maximum(self.Q_n, 0)
+        tx_income_n = self.e_n + ltcg_n
+        cg_tax_n = tx.capitalGainTax(self.N_i, tx_income_n, ltcg_n, self.gamma_n[:-1], self.n_d, self.N_n)
+        self.psi_n = np.zeros(self.N_n)
+        has_ltcg = ltcg_n > 0
+        self.psi_n[has_ltcg] = cg_tax_n[has_ltcg] / ltcg_n[has_ltcg]
+        self.U_n = cg_tax_n
         # Compute Medicare through self-consistent loop.
         if includeMedicare:
             self.M_n = tx.mediCosts(self.yobs, self.horizons, self.MAGI_n, self.prevMAGI, self.gamma_n[:-1], self.N_n)
@@ -2154,6 +2620,7 @@ class Plan:
         Ce = self.C["e"]
         Cf = self.C["f"]
         Cg = self.C["g"]
+        Ch = self.C.get("h", self.C["m"])
         Cm = self.C["m"]
         Cs = self.C["s"]
         Cw = self.C["w"]
@@ -2177,7 +2644,11 @@ class Plan:
         self.f_tn = np.array(x[Cf:Cg])
         self.f_tn = self.f_tn.reshape((Nt, Nn))
 
-        self.g_n = np.array(x[Cg:Cm])
+        self.g_n = np.array(x[Cg:Ch])
+
+        if "h" in self.C:
+            self.h_qn = np.array(x[Ch:Cm])
+            self.h_qn = self.h_qn.reshape((self.N_n - self.nm, self.N_q))
 
         self.m_n = np.array(x[Cm:Cs])
 
@@ -2196,27 +2667,33 @@ class Plan:
         self.G_n = np.sum(self.f_tn, axis=0)
 
         tau_0 = np.array(self.tau_kn[0, :])
-        tau_0[tau_0 < 0] = 0
         # Last year's rates.
         tau_0prev = np.roll(tau_0, 1)
+        # Capital gains = price appreciation only (total return - dividend rate)
+        # to avoid double taxation of dividends. No tax harvesting here.
+        capital_gains_rate = np.maximum(0, tau_0prev - self.mu)
         self.Q_n = np.sum(
             (
                 self.mu
                 * (self.b_ijn[:, 0, :Nn] - self.w_ijn[:, 0, :] + self.d_in[:, :] + 0.5 * self.kappa_ijn[:, 0, :Nn])
-                + tau_0prev * self.w_ijn[:, 0, :]
+                + capital_gains_rate * self.w_ijn[:, 0, :]
             )
             * self.alpha_ijkn[:, 0, 0, :Nn],
             axis=0,
         )
-        # Add fixed assets capital gains
+        # Add fixed assets capital gains.
         self.Q_n += self.fixed_assets_capital_gains_n
         self.U_n = self.psi_n * self.Q_n
 
-        self.MAGI_n = self.G_n + self.e_n + self.Q_n
+        # Also add back non-taxable part of SS.
+        self.MAGI_n = (self.G_n + self.e_n + self.Q_n
+                       + np.sum((1 - self.Psi_n) * self.zetaBar_in, axis=0))
 
+        # Only positive returns count as interest/dividend income (matches _add_taxable_income).
         I_in = ((self.b_ijn[:, 0, :-1] + self.d_in - self.w_ijn[:, 0, :])
-                * np.sum(self.alpha_ijkn[:, 0, 1:, :Nn] * self.tau_kn[1:, :], axis=1))
-        self.I_n = np.sum(I_in, axis=0)
+                * np.sum(self.alpha_ijkn[:, 0, 1:, :Nn] * np.maximum(0, self.tau_kn[1:, :]), axis=1))
+        # Sum over individuals to share losses across spouses; clamp to non-negative.
+        self.I_n = np.maximum(0, np.sum(I_in, axis=0))
 
         # Stop after building minimum required for self-consistent loop.
         if short:
@@ -2282,33 +2759,12 @@ class Plan:
         sources["tax-free wdrwl"] = self.w_ijn[:, 2, :]
         sources["BTI"] = self.Lambda_in
         # Debts and fixed assets (debts are negative as expenses)
-        # Reshape 1D arrays to match shape of other sources (N_i x N_n)
-        if self.N_i == 1:
-            sources["debt payments"] = -self.debt_payments_n.reshape(1, -1)
-            sources["fixed assets tax-free"] = self.fixed_assets_tax_free_n.reshape(1, -1)
-            sources["fixed assets ordinary"] = self.fixed_assets_ordinary_income_n.reshape(1, -1)
-            sources["fixed assets capital gains"] = self.fixed_assets_capital_gains_n.reshape(1, -1)
-        else:
-            # For married couples, split using eta between individuals.
-            debt_array = np.zeros((self.N_i, self.N_n))
-            debt_array[0, :] = -self.debt_payments_n * (1 - self.eta)
-            debt_array[1, :] = -self.debt_payments_n * self.eta
-            sources["debt payments"] = debt_array
-
-            fa_tax_free = np.zeros((self.N_i, self.N_n))
-            fa_tax_free[0, :] = self.fixed_assets_tax_free_n * (1 - self.eta)
-            fa_tax_free[1, :] = self.fixed_assets_tax_free_n * self.eta
-            sources["fixed assets tax-free"] = fa_tax_free
-
-            fa_ordinary = np.zeros((self.N_i, self.N_n))
-            fa_ordinary[0, :] = self.fixed_assets_ordinary_income_n * (1 - self.eta)
-            fa_ordinary[1, :] = self.fixed_assets_ordinary_income_n * self.eta
-            sources["fixed assets ordinary"] = fa_ordinary
-
-            fa_capital = np.zeros((self.N_i, self.N_n))
-            fa_capital[0, :] = self.fixed_assets_capital_gains_n * (1 - self.eta)
-            fa_capital[1, :] = self.fixed_assets_capital_gains_n * self.eta
-            sources["fixed assets capital gains"] = fa_capital
+        # Show as household totals, not split between individuals
+        # Reshape to (1, N_n) to indicate household-level source
+        sources["FA ord inc"] = self.fixed_assets_ordinary_income_n.reshape(1, -1)
+        sources["FA cap gains"] = self.fixed_assets_capital_gains_n.reshape(1, -1)
+        sources["FA tax-free"] = self.fixed_assets_tax_free_n.reshape(1, -1)
+        sources["debt pmts"] = -self.debt_payments_n.reshape(1, -1)
 
         savings = {}
         savings["taxable"] = self.b_ijn[:, 0, :]
@@ -2340,75 +2796,80 @@ class Plan:
         return None
 
     @_checkCaseStatus
-    def summary(self):
+    def summary(self, N=None):
         """
         Print summary in logs.
         """
         self.mylog.print("SUMMARY ================================================================")
-        dic = self.summaryDic()
+        dic = self.summaryDic(N)
         for key, value in dic.items():
             self.mylog.print(f"{key}: {value}")
         self.mylog.print("------------------------------------------------------------------------")
 
         return None
 
-    def summaryList(self):
+    def summaryList(self, N=None):
         """
         Return summary as a list.
         """
         mylist = []
-        dic = self.summaryDic()
+        dic = self.summaryDic(N)
         for key, value in dic.items():
             mylist.append(f"{key}: {value}")
 
         return mylist
 
-    def summaryDf(self):
+    def summaryDf(self, N=None):
         """
         Return summary as a dataframe.
         """
-        return pd.DataFrame(self.summaryDic(), index=[self._name])
+        return pd.DataFrame(self.summaryDic(N), index=[self._name])
 
-    def summaryString(self):
+    def summaryString(self, N=None):
         """
         Return summary as a string.
         """
         string = "Synopsis\n"
-        dic = self.summaryDic()
+        dic = self.summaryDic(N)
         for key, value in dic.items():
-            string += f"{key:>70}: {value}\n"
+            string += f"{key:>77}: {value}\n"
 
         return string
 
-    def summaryDic(self):
+    def summaryDic(self, N=None):
         """
         Return dictionary containing summary of values.
         """
+        if N is None:
+            N = self.N_n
+        if not (0 < N <= self.N_n):
+            raise ValueError(f"Value N={N} is out of reange")
+
         now = self.year_n[0]
         dic = {}
         # Results
-        dic["Plan name"] = self._name
+        dic["Case name"] = self._name
         dic["Net yearly spending basis" + 26*" ."] = u.d(self.g_n[0] / self.xi_n[0])
         dic[f"Net spending for year {now}"] = u.d(self.g_n[0])
         dic[f"Net spending remaining in year {now}"] = u.d(self.g_n[0] * self.yearFracLeft)
 
-        totSpending = np.sum(self.g_n, axis=0)
-        totSpendingNow = np.sum(self.g_n / self.gamma_n[:-1], axis=0)
+        totSpending = np.sum(self.g_n[:N], axis=0)
+        totSpendingNow = np.sum(self.g_n[:N] / self.gamma_n[:N], axis=0)
         dic[" Total net spending"] = f"{u.d(totSpendingNow)}"
         dic["[Total net spending]"] = f"{u.d(totSpending)}"
 
-        totRoth = np.sum(self.x_in, axis=(0, 1))
-        totRothNow = np.sum(np.sum(self.x_in, axis=0) / self.gamma_n[:-1], axis=0)
+        totRoth = np.sum(self.x_in[:, :N], axis=(0, 1))
+        totRothNow = np.sum(np.sum(self.x_in[:, :N], axis=0) / self.gamma_n[:N], axis=0)
         dic[" Total Roth conversions"] = f"{u.d(totRothNow)}"
         dic["[Total Roth conversions]"] = f"{u.d(totRoth)}"
 
-        taxPaid = np.sum(self.T_n, axis=0)
-        taxPaidNow = np.sum(self.T_n / self.gamma_n[:-1], axis=0)
+        taxPaid = np.sum(self.T_n[:N], axis=0)
+        taxPaidNow = np.sum(self.T_n[:N] / self.gamma_n[:N], axis=0)
         dic[" Total tax paid on ordinary income"] = f"{u.d(taxPaidNow)}"
         dic["[Total tax paid on ordinary income]"] = f"{u.d(taxPaid)}"
         for t in range(self.N_t):
-            taxPaid = np.sum(self.T_tn[t], axis=0)
-            taxPaidNow = np.sum(self.T_tn[t] / self.gamma_n[:-1], axis=0)
+            taxPaid = np.sum(self.T_tn[t, :N], axis=0)
+            taxPaidNow = np.sum(self.T_tn[t, :N] / self.gamma_n[:N], axis=0)
             if t >= len(tx.taxBracketNames):
                 tname = f"Bracket {t}"
             else:
@@ -2416,33 +2877,33 @@ class Plan:
             dic[f"»  Subtotal in tax bracket {tname}"] = f"{u.d(taxPaidNow)}"
             dic[f"» [Subtotal in tax bracket {tname}]"] = f"{u.d(taxPaid)}"
 
-        penaltyPaid = np.sum(self.P_n, axis=0)
-        penaltyPaidNow = np.sum(self.P_n / self.gamma_n[:-1], axis=0)
+        penaltyPaid = np.sum(self.P_n[:N], axis=0)
+        penaltyPaidNow = np.sum(self.P_n[:N] / self.gamma_n[:N], axis=0)
         dic["»  Subtotal in early withdrawal penalty"] = f"{u.d(penaltyPaidNow)}"
         dic["» [Subtotal in early withdrawal penalty]"] = f"{u.d(penaltyPaid)}"
 
-        taxPaid = np.sum(self.U_n, axis=0)
-        taxPaidNow = np.sum(self.U_n / self.gamma_n[:-1], axis=0)
+        taxPaid = np.sum(self.U_n[:N], axis=0)
+        taxPaidNow = np.sum(self.U_n[:N] / self.gamma_n[:N], axis=0)
         dic[" Total tax paid on gains and dividends"] = f"{u.d(taxPaidNow)}"
         dic["[Total tax paid on gains and dividends]"] = f"{u.d(taxPaid)}"
 
-        taxPaid = np.sum(self.J_n, axis=0)
-        taxPaidNow = np.sum(self.J_n / self.gamma_n[:-1], axis=0)
+        taxPaid = np.sum(self.J_n[:N], axis=0)
+        taxPaidNow = np.sum(self.J_n[:N] / self.gamma_n[:N], axis=0)
         dic[" Total net investment income tax paid"] = f"{u.d(taxPaidNow)}"
         dic["[Total net investment income tax paid]"] = f"{u.d(taxPaid)}"
 
-        taxPaid = np.sum(self.m_n + self.M_n, axis=0)
-        taxPaidNow = np.sum((self.m_n + self.M_n) / self.gamma_n[:-1], axis=0)
+        taxPaid = np.sum(self.m_n[:N] + self.M_n[:N], axis=0)
+        taxPaidNow = np.sum((self.m_n[:N] + self.M_n[:N]) / self.gamma_n[:N], axis=0)
         dic[" Total Medicare premiums paid"] = f"{u.d(taxPaidNow)}"
         dic["[Total Medicare premiums paid]"] = f"{u.d(taxPaid)}"
 
-        totDebtPayments = np.sum(self.debt_payments_n, axis=0)
+        totDebtPayments = np.sum(self.debt_payments_n[:N], axis=0)
         if totDebtPayments > 0:
-            totDebtPaymentsNow = np.sum(self.debt_payments_n / self.gamma_n[:-1], axis=0)
+            totDebtPaymentsNow = np.sum(self.debt_payments_n[:N] / self.gamma_n[:N], axis=0)
             dic[" Total debt payments"] = f"{u.d(totDebtPaymentsNow)}"
             dic["[Total debt payments]"] = f"{u.d(totDebtPayments)}"
 
-        if self.N_i == 2 and self.n_d < self.N_n:
+        if self.N_i == 2 and self.n_d < self.N_n and N == self.N_n:
             p_j = self.partialEstate_j * (1 - self.phi_j)
             p_j[1] *= 1 - self.nu
             nx = self.n_d - 1
@@ -2453,58 +2914,66 @@ class Plan:
             totSpousal = np.sum(q_j)
             iname_s = self.inames[self.i_s]
             iname_d = self.inames[self.i_d]
-            dic["Year of partial bequest"] = (f"{ynx}")
-            dic[f" Sum of spousal transfer to {iname_s}"] = (f"{u.d(ynxNow*totSpousal)}")
-            dic[f"[Sum of spousal transfer to {iname_s}]"] = (f"{u.d(totSpousal)}")
-            dic[f"»  Spousal transfer to {iname_s} - taxable"] = (f"{u.d(ynxNow*q_j[0])}")
-            dic[f"» [Spousal transfer to {iname_s} - taxable]"] = (f"{u.d(q_j[0])}")
-            dic[f"»  Spousal transfer to {iname_s} - tax-def"] = (f"{u.d(ynxNow*q_j[1])}")
-            dic[f"» [Spousal transfer to {iname_s} - tax-def]"] = (f"{u.d(q_j[1])}")
-            dic[f"»  Spousal transfer to {iname_s} - tax-free"] = (f"{u.d(ynxNow*q_j[2])}")
-            dic[f"» [Spousal transfer to {iname_s} - tax-free]"] = (f"{u.d(q_j[2])}")
-
-            dic[f" Sum of post-tax non-spousal bequest from {iname_d}"] = (f"{u.d(ynxNow*totOthers)}")
-            dic[f"[Sum of post-tax non-spousal bequest from {iname_d}]"] = (f"{u.d(totOthers)}")
-            dic[f"»  Post-tax non-spousal bequest from {iname_d} - taxable"] = (f"{u.d(ynxNow*p_j[0])}")
-            dic[f"» [Post-tax non-spousal bequest from {iname_d} - taxable]"] = (f"{u.d(p_j[0])}")
-            dic[f"»  Post-tax non-spousal bequest from {iname_d} - tax-def"] = (f"{u.d(ynxNow*p_j[1])}")
-            dic[f"» [Post-tax non-spousal bequest from {iname_d} - tax-def]"] = (f"{u.d(p_j[1])}")
-            dic[f"»  Post-tax non-spousal bequest from {iname_d} - tax-free"] = (f"{u.d(ynxNow*p_j[2])}")
-            dic[f"» [Post-tax non-spousal bequest from {iname_d} - tax-free]"] = (f"{u.d(p_j[2])}")
-
-        estate = np.sum(self.b_ijn[:, :, self.N_n], axis=0)
-        estate[1] *= 1 - self.nu
-        endyear = self.year_n[-1]
-        lyNow = 1./self.gamma_n[-1]
-        debts = self.remaining_debt_balance
-        # Add fixed assets bequest value (assets with yod past plan end)
-        totEstate = np.sum(estate) - debts + self.fixed_assets_bequest_value
-        dic["Year of final bequest"] = (f"{endyear}")
-        dic[" Total value of final bequest"] = (f"{u.d(lyNow*totEstate)}")
-        if debts > 0:
-            dic[" After paying remaining debts of"] = (f"{u.d(lyNow*debts)}")
-        if self.fixed_assets_bequest_value > 0:
-            dic[" Fixed assets liquidated at end of plan"] = (f"{u.d(lyNow*self.fixed_assets_bequest_value)}")
-            dic["[Fixed assets liquidated at end of plan]"] = (f"{u.d(self.fixed_assets_bequest_value)}")
-        dic["[Total value of final bequest]"] = (f"{u.d(totEstate)}")
-        dic["»  Post-tax final bequest account value - taxable"] = (f"{u.d(lyNow*estate[0])}")
-        dic["» [Post-tax final bequest account value - taxable]"] = (f"{u.d(estate[0])}")
-        dic["»  Post-tax final bequest account value - tax-def"] = (f"{u.d(lyNow*estate[1])}")
-        dic["» [Post-tax final bequest account value - tax-def]"] = (f"{u.d(estate[1])}")
-        dic["»  Post-tax final bequest account value - tax-free"] = (f"{u.d(lyNow*estate[2])}")
-        dic["» [Post-tax final bequest account value - tax-free]"] = (f"{u.d(estate[2])}")
-        if debts > 0:
-            dic["» [Remaining debt balance]"] = (f"{u.d(debts)}")
-
-        dic["Plan starting date"] = str(self.startDate)
-        dic["Cumulative inflation factor at end of final year"] = (f"{self.gamma_n[-1]:.2f}")
+            dic["Year of partial bequest"] = f"{ynx}"
+            dic[f" Sum of spousal transfer to {iname_s}"] = f"{u.d(ynxNow*totSpousal)}"
+            dic[f"[Sum of spousal transfer to {iname_s}]"] = f"{u.d(totSpousal)}"
+            dic[f"»  Spousal transfer to {iname_s} - taxable"] = f"{u.d(ynxNow*q_j[0])}"
+            dic[f"» [Spousal transfer to {iname_s} - taxable]"] = f"{u.d(q_j[0])}"
+            dic[f"»  Spousal transfer to {iname_s} - tax-def"] = f"{u.d(ynxNow*q_j[1])}"
+            dic[f"» [Spousal transfer to {iname_s} - tax-def]"] = f"{u.d(q_j[1])}"
+            dic[f"»  Spousal transfer to {iname_s} - tax-free"] = f"{u.d(ynxNow*q_j[2])}"
+            dic[f"» [Spousal transfer to {iname_s} - tax-free]"] = f"{u.d(q_j[2])}"
+
+            dic[f" Sum of post-tax non-spousal bequest from {iname_d}"] = f"{u.d(ynxNow*totOthers)}"
+            dic[f"[Sum of post-tax non-spousal bequest from {iname_d}]"] = f"{u.d(totOthers)}"
+            dic[f"»  Post-tax non-spousal bequest from {iname_d} - taxable"] = f"{u.d(ynxNow*p_j[0])}"
+            dic[f"» [Post-tax non-spousal bequest from {iname_d} - taxable]"] = f"{u.d(p_j[0])}"
+            dic[f"»  Post-tax non-spousal bequest from {iname_d} - tax-def"] = f"{u.d(ynxNow*p_j[1])}"
+            dic[f"» [Post-tax non-spousal bequest from {iname_d} - tax-def]"] = f"{u.d(p_j[1])}"
+            dic[f"»  Post-tax non-spousal bequest from {iname_d} - tax-free"] = f"{u.d(ynxNow*p_j[2])}"
+            dic[f"» [Post-tax non-spousal bequest from {iname_d} - tax-free]"] = f"{u.d(p_j[2])}"
+
+        if N == self.N_n:
+            estate = np.sum(self.b_ijn[:, :, self.N_n], axis=0)
+            heirsTaxLiability = estate[1] * self.nu
+            estate[1] *= 1 - self.nu
+            endyear = self.year_n[-1]
+            lyNow = 1./self.gamma_n[-1]
+            # Add fixed assets bequest value (assets with yod past plan end)
+            debts = self.remaining_debt_balance
+            savingsEstate = np.sum(estate)
+            totEstate = savingsEstate - debts + self.fixed_assets_bequest_value
+
+            dic["Year of final bequest"] = f"{endyear}"
+            dic[" Total after-tax value of final bequest"] = f"{u.d(lyNow*totEstate)}"
+            dic["» After-tax value of savings assets"] = f"{u.d(lyNow*savingsEstate)}"
+            dic["» Fixed assets liquidated at end of plan"] = f"{u.d(lyNow*self.fixed_assets_bequest_value)}"
+            dic["» With heirs assuming tax liability of"] = f"{u.d(lyNow*heirsTaxLiability)}"
+            dic["» After paying remaining debts of"] = f"{u.d(lyNow*debts)}"
+
+            dic["[Total after-tax value of final bequest]"] = f"{u.d(totEstate)}"
+            dic["[» After-tax value of savings assets]"] = f"{u.d(savingsEstate)}"
+            dic["[» Fixed assets liquidated at end of plan]"] = f"{u.d(self.fixed_assets_bequest_value)}"
+            dic["[» With heirs assuming tax liability of"] = f"{u.d(heirsTaxLiability)}"
+            dic["[» After paying remaining debts of]"] = f"{u.d(debts)}"
+
+            dic["»  Post-tax final bequest account value - taxable"] = f"{u.d(lyNow*estate[0])}"
+            dic["» [Post-tax final bequest account value - taxable]"] = f"{u.d(estate[0])}"
+            dic["»  Post-tax final bequest account value - tax-def"] = f"{u.d(lyNow*estate[1])}"
+            dic["» [Post-tax final bequest account value - tax-def]"] = f"{u.d(estate[1])}"
+            dic["»  Post-tax final bequest account value - tax-free"] = f"{u.d(lyNow*estate[2])}"
+            dic["» [Post-tax final bequest account value - tax-free]"] = f"{u.d(estate[2])}"
+
+        dic["Case starting date"] = str(self.startDate)
+        dic["Cumulative inflation factor at end of final year"] = f"{self.gamma_n[N]:.2f}"
         for i in range(self.N_i):
-            dic[f"{self.inames[i]:>14}'s life horizon"] = (f"{now} -> {now + self.horizons[i] - 1}")
-            dic[f"{self.inames[i]:>14}'s years planned"] = (f"{self.horizons[i]}")
+            dic[f"{self.inames[i]:>14}'s life horizon"] = f"{now} -> {now + self.horizons[i] - 1}"
+            dic[f"{self.inames[i]:>14}'s years planned"] = f"{self.horizons[i]}"
 
-        dic["Plan name"] = self._name
+        dic["Case name"] = self._name
         dic["Number of decision variables"] = str(self.A.nvars)
         dic["Number of constraints"] = str(self.A.ncons)
+        dic["Convergence"] = self.convergenceType
         dic["Case executed on"] = str(self._timestamp)
 
         return dic
@@ -2516,9 +2985,26 @@ class Plan:
         A tag string can be set to add information to the title of the plot.
         """
         if self.rateMethod in [None, "user", "historical average", "conservative"]:
-            self.mylog.vprint(f"Warning: Cannot plot correlations for {self.rateMethod} rate method.")
+            self.mylog.print(f"Warning: Cannot plot correlations for {self.rateMethod} rate method.")
             return None
 
+        # Check if rates are constant (all values are the same for each rate type)
+        # This can happen with fixed rates
+        if self.tau_kn is not None:
+            # Check if all rates are constant (no variation)
+            rates_are_constant = True
+            for k in range(self.N_k):
+                # Check if all values in this rate series are (approximately) the same
+                rate_std = np.std(self.tau_kn[k])
+                # Use a small threshold to account for floating point precision
+                if rate_std > 1e-10:  # If standard deviation is non-zero, rates vary
+                    rates_are_constant = False
+                    break
+
+            if rates_are_constant:
+                self.mylog.print("Warning: Cannot plot correlations for constant rates (no variation in rate values).")
+                return None
+
         fig = self._plotter.plot_rates_correlations(self._name, self.tau_kn, self.N_n, self.rateMethod,
                                                     self.rateFrm, self.rateTo, tag, shareRange)
 
@@ -2547,7 +3033,7 @@ class Plan:
         A tag string can be set to add information to the title of the plot.
         """
         if self.rateMethod is None:
-            self.mylog.vprint("Warning: Rate method must be selected before plotting.")
+            self.mylog.print("Warning: Rate method must be selected before plotting.")
             return None
 
         fig = self._plotter.plot_rates(self._name, self.tau_kn, self.year_n,
@@ -2566,7 +3052,7 @@ class Plan:
         A tag string can be set to add information to the title of the plot.
         """
         if self.xi_n is None:
-            self.mylog.vprint("Warning: Profile must be selected before plotting.")
+            self.mylog.print("Warning: Profile must be selected before plotting.")
             return None
         title = self._name + "\nSpending Profile"
         if tag:
@@ -2736,7 +3222,7 @@ class Plan:
         self._plotter.jupyter_renderer(fig)
         return None
 
-    def saveWorkbook(self, overwrite=False, *, basename=None, saveToFile=True):
+    def saveWorkbook(self, overwrite=False, *, basename=None, saveToFile=True, with_config="no"):
         """
         Save instance in an Excel spreadsheet.
         The first worksheet will contain income in the following
@@ -2745,10 +3231,10 @@ class Plan:
         - taxable ordinary income
         - taxable dividends
         - tax bills (federal only, including IRMAA)
-        for all the years for the time span of the plan.
+        for all the years for the time span of the case.
 
         The second worksheet contains the rates
-        used for the plan as follows:
+        used for the case as follows:
         - S&P 500
         - Corporate Baa bonds
         - Treasury notes (10y)
@@ -2770,7 +3256,30 @@ class Plan:
         - tax-free account.
 
         Last worksheet contains summary.
+
+        with_config controls whether to insert the current case configuration
+        as a TOML sheet. Valid values are:
+        - "no": do not include config
+        - "first": insert config as the first sheet
+        - "last": insert config as the last sheet
         """
+        def add_config_sheet(position):
+            if with_config == "no":
+                return
+            if with_config not in {"no", "first", "last"}:
+                raise ValueError(f"Invalid with_config option '{with_config}'.")
+            if position != with_config:
+                return
+
+            from io import StringIO
+
+            config_buffer = StringIO()
+            config.saveConfig(self, config_buffer, self.mylog)
+            config_buffer.seek(0)
+
+            ws_config = wb.create_sheet(title="Config (.toml)", index=0 if position == "first" else None)
+            for row_idx, line in enumerate(config_buffer.getvalue().splitlines(), start=1):
+                ws_config.cell(row=row_idx, column=1, value=line)
 
         def fillsheet(sheet, dic, datatype, op=lambda x: x):
             rawData = {}
@@ -2790,6 +3299,7 @@ class Plan:
             _formatSpreadsheet(ws, datatype)
 
         wb = Workbook()
+        add_config_sheet("first")
 
         # Income.
         ws = wb.active
@@ -2811,6 +3321,10 @@ class Plan:
             "all pensions": np.sum(self.piBar_in, axis=0),
             "all soc sec": np.sum(self.zetaBar_in, axis=0),
             "all BTI's": np.sum(self.Lambda_in, axis=0),
+            "FA ord inc": self.fixed_assets_ordinary_income_n,
+            "FA cap gains": self.fixed_assets_capital_gains_n,
+            "FA tax-free": self.fixed_assets_tax_free_n,
+            "debt pmts": -self.debt_payments_n,
             "all wdrwls": np.sum(self.w_ijn, axis=(0, 1)),
             "all deposits": -np.sum(self.d_in, axis=0),
             "ord taxes": -self.T_n - self.J_n,
@@ -2839,6 +3353,16 @@ class Plan:
             ws = wb.create_sheet(sname)
             fillsheet(ws, srcDic, "currency", op=lambda x: x[i])   # noqa: B023
 
+        # Household sources (debts and fixed assets)
+        householdSrcDic = {
+            "FA ord inc": self.sources_in["FA ord inc"],
+            "FA cap gains": self.sources_in["FA cap gains"],
+            "FA tax-free": self.sources_in["FA tax-free"],
+            "debt pmts": self.sources_in["debt pmts"],
+        }
+        ws = wb.create_sheet("Household Sources")
+        fillsheet(ws, householdSrcDic, "currency", op=lambda x: x[0])
+
         # Account balances except final year.
         accDic = {
             "taxable bal": self.b_ijn[:, 0, :-1],
@@ -2933,6 +3457,7 @@ class Plan:
             ws.append(row)
 
         _formatSpreadsheet(ws, "summary")
+        add_config_sheet("last")
 
         if saveToFile:
             if basename is None:
@@ -2952,11 +3477,29 @@ class Plan:
 
         planData = {}
         planData["year"] = self.year_n
+
+        # Income data
         planData["net spending"] = self.g_n
         planData["taxable ord. income"] = self.G_n
         planData["taxable gains/divs"] = self.Q_n
-        planData["tax bill"] = self.T_n
-
+        planData["Tax bills + Med."] = self.T_n + self.U_n + self.m_n + self.M_n + self.J_n
+
+        # Cash flow data (matching Cash Flow worksheet)
+        planData["all wages"] = np.sum(self.omega_in, axis=0)
+        planData["all pensions"] = np.sum(self.piBar_in, axis=0)
+        planData["all soc sec"] = np.sum(self.zetaBar_in, axis=0)
+        planData["all BTI's"] = np.sum(self.Lambda_in, axis=0)
+        planData["FA ord inc"] = self.fixed_assets_ordinary_income_n
+        planData["FA cap gains"] = self.fixed_assets_capital_gains_n
+        planData["FA tax-free"] = self.fixed_assets_tax_free_n
+        planData["debt pmts"] = -self.debt_payments_n
+        planData["all wdrwls"] = np.sum(self.w_ijn, axis=(0, 1))
+        planData["all deposits"] = -np.sum(self.d_in, axis=0)
+        planData["ord taxes"] = -self.T_n - self.J_n
+        planData["div taxes"] = -self.U_n
+        planData["Medicare"] = -self.m_n - self.M_n
+
+        # Individual account data
         for i in range(self.N_i):
             planData[self.inames[i] + " txbl bal"] = self.b_ijn[i, 0, :-1]
             planData[self.inames[i] + " txbl dep"] = self.d_in[i, :]
@@ -2971,6 +3514,7 @@ class Plan:
             planData[self.inames[i] + " tax-free wdrwl"] = self.w_ijn[i, 2, :]
             planData[self.inames[i] + " big-ticket items"] = self.Lambda_in[i, :]
 
+        # Rates
         ratesDic = {"S&P 500": 0, "Corporate Baa": 1, "T Bonds": 2, "inflation": 3}
         for key in ratesDic:
             planData[key] = self.tau_kn[ratesDic[key]]
@@ -3020,7 +3564,7 @@ def _saveWorkbook(wb, basename, overwrite, mylog):
         mylog.print(f'File "{fname}" already exists.')
         key = input("Overwrite? [Ny] ")
         if key != "y":
-            mylog.vprint("Skipping save and returning.")
+            mylog.print("Skipping save and returning.")
             return None
 
     for _ in range(3):
@@ -3067,7 +3611,11 @@ def _formatSpreadsheet(ws, ftype):
         # col[0].style = 'Title'
         width = max(len(str(col[0].value)) + 4, 10)
         ws.column_dimensions[column].width = width
-        if column != "A":
+        if column == "A":
+            # Format year column as integer without commas
+            for cell in col:
+                cell.number_format = "0"
+        else:
             for cell in col:
                 cell.number_format = fstring
 
@@ -3098,8 +3646,8 @@ def _formatDebtsSheet(ws):
     # Apply formatting based on column name
     for col_letter, col_name in col_map.items():
         if col_name in ["year", "term"]:
-            # Integer format
-            fstring = "#,##0"
+            # Integer format without commas
+            fstring = "0"
         elif col_name in ["rate"]:
             # Number format (2 decimal places for percentages stored as numbers)
             fstring = "#,##0.00"
@@ -3143,8 +3691,8 @@ def _formatFixedAssetsSheet(ws):
     # Apply formatting based on column name
     for col_letter, col_name in col_map.items():
         if col_name in ["yod"]:
-            # Integer format
-            fstring = "#,##0"
+            # Integer format without commas
+            fstring = "0"
         elif col_name in ["rate", "commission"]:
             # Number format (1 decimal place for percentages stored as numbers)
             fstring = "#,##0.00"