owlplanner 2025.12.5__py3-none-any.whl → 2026.1.26__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,19 +29,33 @@ 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
 from . import timelists
 from . import socialsecurity as socsec
+from . import debts as debts
+from . import fixedassets as fxasst
 from . import mylogging as log
 from . import progress
 from .plotting.factory import PlotFactory
 
 
+# Default values
+BIGM_XOR = 5e7     # 100 times large withdrawals or conversions
+BIGM_IRMAA = 5e7   # 100 times large MAGI
+GAP = 1e-4
+MILP_GAP = 10 * GAP
+MAX_ITERATIONS = 29
+ABS_TOL = 20
+REL_TOL = 1e-6
+TIME_LIMIT = 900
+
+
 def _genGamma_n(tau):
     """
     Utility function to generate a cumulative inflation multiplier
@@ -83,7 +104,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
 
@@ -125,20 +146,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)
 
@@ -162,7 +181,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)
 
@@ -179,11 +198,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)
 
@@ -202,28 +221,43 @@ 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
 
 
-class Plan(object):
+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
 
-    def __init__(self, inames, yobs, mobs, expectancy, name, *, verbose=False, logstreams=None):
+    @classmethod
+    def get_current_id(cls):
+        return cls._id_counter
+
+    def __init__(self, inames, dobs, expectancy, name, *, verbose=False, logstreams=None):
         """
         Constructor requires three lists: the first
         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)
 
@@ -232,8 +266,8 @@ class Plan(object):
         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"
@@ -249,13 +283,9 @@ class Plan(object):
         # self.setPlotBackend("matplotlib")
         self.setPlotBackend("plotly")
 
-        self.N_i = len(yobs)
+        self.N_i = len(dobs)
         if not (0 <= self.N_i <= 2):
             raise ValueError(f"Cannot support {self.N_i} individuals.")
-        if len(mobs) != len(yobs):
-            raise ValueError("Months and years arrays should have same length.")
-        if min(mobs) < 1 or max(mobs) > 12:
-            raise ValueError("Months must be between 1 and 12.")
         if self.N_i != len(expectancy):
             raise ValueError(f"Expectancy must have {self.N_i} entries.")
         if self.N_i != len(inames):
@@ -268,16 +298,19 @@ class Plan(object):
         # Default year OBBBA speculated to be expired and replaced by pre-TCJA rates.
         self.yOBBBA = 2032
         self.inames = inames
-        self.yobs = np.array(yobs, dtype=np.int32)
-        self.mobs = np.array(mobs, dtype=np.int32)
+        self.yobs, self.mobs, self.tobs = u.parseDobs(dobs)
+        self.dobs = dobs
         self.expectancy = np.array(expectancy, dtype=np.int32)
 
         # Reference time is starting date in the current year and all passings are assumed at the end.
         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.
@@ -292,9 +325,11 @@ class Plan(object):
 
         # 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
@@ -316,9 +351,23 @@ class Plan(object):
         self.myRothX_in = np.zeros((self.N_i, self.N_n + 5))
         self.kappa_ijn = np.zeros((self.N_i, self.N_j, self.N_n + 5))
 
+        # Debt payments array (length N_n)
+        self.debt_payments_n = np.zeros(self.N_n)
+
+        # Fixed assets arrays (length N_n)
+        self.fixed_assets_tax_free_n = np.zeros(self.N_n)
+        self.fixed_assets_ordinary_income_n = np.zeros(self.N_n)
+        self.fixed_assets_capital_gains_n = np.zeros(self.N_n)
+        # Fixed assets bequest value (assets with yod past plan end)
+        self.fixed_assets_bequest_value = 0.0
+
+        # Remaining debt balance at end of plan
+        self.remaining_debt_balance = 0.0
+
         # 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
@@ -329,21 +378,26 @@ class Plan(object):
 
         # 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
         self.timeListsFileName = "None"
         self.timeLists = {}
+        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.ARCoord = None
         self.objective = "unknown"
@@ -359,7 +413,7 @@ class Plan(object):
 
     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
@@ -374,7 +428,7 @@ class Plan(object):
 
     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.
         """
@@ -420,16 +474,16 @@ class Plan(object):
 
     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
 
@@ -446,7 +500,7 @@ class Plan(object):
         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}.")
@@ -459,7 +513,7 @@ class Plan(object):
         """
 
         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):
         """
@@ -467,12 +521,12 @@ class Plan(object):
         """
 
         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):
         """
@@ -510,8 +564,8 @@ class Plan(object):
         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):
         """
@@ -569,6 +623,9 @@ class Plan(object):
     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.")
@@ -582,40 +639,52 @@ class Plan(object):
         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)
+
+            eligible = 62 if bornOnFirstDays else 62 + 1/12
+            if ages[i] < 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.
-            realage = ages[i] + (self.mobs[i] - 1)/12
-            iage = int(realage)
-            realns = iage - thisyear + self.yobs[i]
-            ns = max(0, realns)
+            # janage is age with reference to Jan 1 of yob when eligibility starts.
+            janage = ages[i] + (self.mobs[i] - 1)/12
+
+            # 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 - (realage % 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])
+            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)
+                # 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).
@@ -659,7 +728,36 @@ class Plan(object):
         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):
         """
         Generate rates for return and inflation based on the method and
         years selected. Note that last bound is included.
@@ -674,28 +772,77 @@ class Plan(object):
           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.
         """
         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.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.")
+        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
+        fixed_methods = ["default", "optimistic", "conservative", "user",
+                         "historical average", "historical"]
+        if self.rateMethod in fixed_methods:
+            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,
@@ -703,6 +850,7 @@ class Plan(object):
             values=100 * self.rateValues,
             stdev=100 * self.rateStdev,
             corr=self.rateCorr,
+            override_reproducible=override_reproducible,
         )
 
     def setAccountBalances(self, *, taxable, taxDeferred, taxFree, startDate=None, units="k"):
@@ -763,12 +911,12 @@ class Plan(object):
             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):
         """
@@ -792,6 +940,11 @@ class Plan(object):
         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":
@@ -810,7 +963,7 @@ class Plan(object):
                             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]}")
@@ -847,7 +1000,7 @@ class Plan(object):
                         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):
@@ -882,9 +1035,9 @@ class Plan(object):
         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
@@ -904,13 +1057,24 @@ class Plan(object):
 
         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 = 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 Wages and Contributions: {e}") from 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
@@ -931,20 +1095,91 @@ class Plan(object):
 
             # 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"
 
         return self.timeLists
 
+    def processDebtsAndFixedAssets(self):
+        """
+        Process debts and fixed assets from houseLists and populate arrays.
+        Should be called after setContributions() and before solve().
+        """
+        thisyear = date.today().year
+
+        # Process debts
+        if "Debts" in self.houseLists and not self.houseLists["Debts"].empty:
+            self.debt_payments_n = debts.get_debt_payments_array(
+                self.houseLists["Debts"], self.N_n, thisyear
+            )
+            self.remaining_debt_balance = debts.get_remaining_debt_balance(
+                self.houseLists["Debts"], self.N_n, thisyear
+            )
+        else:
+            self.debt_payments_n = np.zeros(self.N_n)
+            self.remaining_debt_balance = 0.0
+
+        # Process fixed assets
+        if "Fixed Assets" in self.houseLists and not self.houseLists["Fixed Assets"].empty:
+            filing_status = "married" if self.N_i == 2 else "single"
+            (self.fixed_assets_tax_free_n,
+             self.fixed_assets_ordinary_income_n,
+             self.fixed_assets_capital_gains_n) = fxasst.get_fixed_assets_arrays(
+                self.houseLists["Fixed Assets"], self.N_n, thisyear, filing_status
+            )
+            # Calculate bequest value for assets with yod past plan end
+            self.fixed_assets_bequest_value = fxasst.get_fixed_assets_bequest_value(
+                self.houseLists["Fixed Assets"], self.N_n, thisyear
+            )
+        else:
+            self.fixed_assets_tax_free_n = np.zeros(self.N_n)
+            self.fixed_assets_ordinary_income_n = np.zeros(self.N_n)
+            self.fixed_assets_capital_gains_n = np.zeros(self.N_n)
+            self.fixed_assets_bequest_value = 0.0
+
+    def getFixedAssetsBequestValueInTodaysDollars(self):
+        """
+        Return the fixed assets bequest value in today's dollars.
+        This requires rates to be set to calculate gamma_n (inflation factor).
+
+        Returns:
+        --------
+        float
+            Fixed assets bequest value in today's dollars.
+            Returns 0.0 if rates not set, gamma_n not calculated, or no fixed assets.
+        """
+        if self.fixed_assets_bequest_value == 0.0:
+            return 0.0
+
+        # Check if we can calculate gamma_n
+        if self.rateMethod is None or not hasattr(self, 'tau_kn'):
+            # Rates not set yet - return 0
+            return 0.0
+
+        # Calculate gamma_n if not already calculated
+        if not hasattr(self, 'gamma_n') or self.gamma_n is None:
+            self.gamma_n = _genGamma_n(self.tau_kn)
+
+        # Convert: today's dollars = nominal dollars / inflation_factor
+        return self.fixed_assets_bequest_value / self.gamma_n[-1]
+
     def saveContributions(self):
         """
-        Return workbook on wages and contributions.
+        Return workbook on wages and contributions, including Debts and Fixed Assets.
         """
         if self.timeLists is None:
             return None
@@ -966,6 +1201,36 @@ class Plan(object):
             ws = wb.create_sheet(self.inames[1])
             fillsheet(ws, 1)
 
+        # Add Debts sheet if available
+        if "Debts" in self.houseLists and not self.houseLists["Debts"].empty:
+            ws = wb.create_sheet("Debts")
+            df = self.houseLists["Debts"]
+            for row in dataframe_to_rows(df, index=False, header=True):
+                ws.append(row)
+            _formatDebtsSheet(ws)
+        else:
+            # Create empty Debts sheet with proper columns
+            ws = wb.create_sheet("Debts")
+            df = pd.DataFrame(columns=timelists._debtItems)
+            for row in dataframe_to_rows(df, index=False, header=True):
+                ws.append(row)
+            _formatDebtsSheet(ws)
+
+        # Add Fixed Assets sheet if available
+        if "Fixed Assets" in self.houseLists and not self.houseLists["Fixed Assets"].empty:
+            ws = wb.create_sheet("Fixed Assets")
+            df = self.houseLists["Fixed Assets"]
+            for row in dataframe_to_rows(df, index=False, header=True):
+                ws.append(row)
+            _formatFixedAssetsSheet(ws)
+        else:
+            # Create empty Fixed Assets sheet with proper columns
+            ws = wb.create_sheet("Fixed Assets")
+            df = pd.DataFrame(columns=timelists._fixedAssetItems)
+            for row in dataframe_to_rows(df, index=False, header=True):
+                ws.append(row)
+            _formatFixedAssetsSheet(ws)
+
         return wb
 
     def zeroContributions(self):
@@ -1079,9 +1344,11 @@ class Plan(object):
         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)
+        C["zm"] = _qC(C["zx"], 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"]
         self.nbins = self.nvars - C["zx"]
+        self.nconts = C["zx"]
+        self.nbals = C["d"]
 
         self.C = C
         self.mylog.vprint(
@@ -1108,7 +1375,7 @@ class Plan(object):
         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()
@@ -1178,48 +1445,76 @@ class Plan(object):
                         cgains *= oldTau1
                         # Past years are stored at the end of contributions and conversions arrays.
                         # Use negative index to access tail of array.
+                        # Past years are stored at the end of arrays, accessed via negative indexing
                         rhs += (cgains - 1) * self.kappa_ijn[i, 2, nn] + cgains * self.myRothX_in[i, nn]
-                        # rhs += cgains * self.kappa_ijn[i, 2, nn] + cgains * self.myRothX_in[i, nn]
 
                 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):
@@ -1242,23 +1537,26 @@ class Plan(object):
     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
 
+            # Bequest constraint now refers only to savings accounts
+            # User specifies desired bequest from accounts (fixed assets are separate)
+            # Total bequest = accounts - debts + fixed_assets
+            # So: accounts >= desired_bequest_from_accounts + debts
+            # (fixed_assets are added separately in the total bequest calculation)
+            total_bequest_value = bequest + self.remaining_debt_balance
+
             row = self.A.newRow()
             for i in range(self.N_i):
                 row.addElem(_q3(self.C["b"], i, 0, self.N_n, self.N_i, self.N_j, self.N_n + 1), 1)
                 row.addElem(_q3(self.C["b"], i, 1, self.N_n, self.N_i, self.N_j, self.N_n + 1), 1 - self.nu)
                 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, bequest, bequest)
+            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)
 
@@ -1272,7 +1570,7 @@ class Plan(object):
                 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):
@@ -1282,8 +1580,12 @@ class Plan(object):
             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))
@@ -1336,6 +1638,12 @@ class Plan(object):
         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 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})
             row.addElem(_q1(self.C["s"], n, self.N_n), 1)
             row.addElem(_q1(self.C["m"], n, self.N_n), 1)
@@ -1373,11 +1681,12 @@ class Plan(object):
 
     def _add_taxable_income(self):
         for n in range(self.N_n):
-            rhs = 0
+            # Add fixed assets ordinary income
+            rhs = self.fixed_assets_ordinary_income_n[n]
             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)
@@ -1390,53 +1699,73 @@ class Plan(object):
             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_XOR, 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,
-                )
+                    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,
-                     _q2(self.C["x"], i, n, self.N_i, 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
                 )
+
+        if "maxRothConversion" in options:
+            rhsopt = u.get_numeric_option(options, "maxRothConversion", 0)
+            if rhsopt < -1:
+                return
+
+        # 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)
+
+                self.A.addNewRow(dic0, 0, np.inf)
+
+                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)
+
+                self.A.addNewRow(dic0, 0, np.inf)
+
                 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, 2, self.N_n, self.N_zx): +1,
+                     _q2(self.C["zx"], n, 3, 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
 
-        bigM = options.get("bigM", 5e6)
-        if not isinstance(bigM, (int, float)):
-            raise ValueError(f"bigM {bigM} is not a number.")
+        # Default: 5e7 (50 million) - bounds aggregate MAGI, typically larger than bigMamo
+        bigM = u.get_numeric_option(options, "bigMirmaa", BIGM_IRMAA, min_value=0)
 
         Nmed = self.N_n - self.nm
         offset = 0
@@ -1446,47 +1775,47 @@ class Plan(object):
                 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])
+                                     self.prevMAGI[n] - self.L_nq[nn, q], np.inf)
 
         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()
+                rhs = self.L_nq[nn, q]
+                rhs -= (self.fixed_assets_ordinary_income_n[n2]
+                        + self.fixed_assets_capital_gains_n[n2])
+                row = 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)
+                row.addElem(_q2(self.C["zm"], nn, q, Nmed, self.N_q - 1), -bigM*self.gamma_n[nn])
+                # Using e_n slows convergence like crazy.
+                # Maybe replace with full exemption at the risk of creating negative income?
+                # rhs -= self.sigmaBar_n[n2]
+                row.addElem(_q1(self.C["e"], n2, self.N_n), +1)
                 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)
-
-                    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)
+                    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.
                     afac = (self.mu*self.alpha_ijkn[i, 0, 0, n2]
                             + np.sum(self.alpha_ijkn[i, 0, 1:, n2]*self.tau_kn[1:, n2]))
-                    afac = 0
-                    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)
 
-                    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)
+                    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)
 
-                    bfac = self.alpha_ijkn[i, 0, 0, n2] * max(0, self.tau_kn[0, max(0, n2-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)
+                    # 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)
 
-                    sumoni = (self.omega_in[i, n2] + self.psi_n[n2] * self.zetaBar_in[i, n2] + self.piBar_in[i, n2]
+                    # 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)
-                    rhs1 += sumoni
-                    rhs2 -= sumoni
+                    rhs -= sumoni
 
-                self.A.addRow(row1, -np.inf, rhs1)
-                self.A.addRow(row2, -np.inf, rhs2)
+                self.A.addRow(row, -np.inf, rhs)
 
     def _add_Medicare_costs(self, options):
         if options.get("withMedicare", "loop") != "optimize":
@@ -1526,7 +1855,7 @@ class Plan(object):
 
         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.")
@@ -1541,8 +1870,8 @@ class Plan(object):
         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)
 
@@ -1594,7 +1923,7 @@ class Plan(object):
         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)
@@ -1606,7 +1935,7 @@ class Plan(object):
             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)
@@ -1655,52 +1984,68 @@ class Plan(object):
 
         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",
+            "bigMirmaa",  # Big-M value for Medicare IRMAA constraints (default: 5e7)
+            "bigMamo",    # Big-M value for XOR constraints (default: 5e7)
+            "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:
@@ -1708,9 +2053,24 @@ class Plan(object):
 
         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 <= 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"]
@@ -1721,7 +2081,7 @@ class Plan(object):
 
         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.
@@ -1731,11 +2091,14 @@ class Plan(object):
         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
@@ -1746,7 +2109,10 @@ class Plan(object):
         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
@@ -1760,6 +2126,20 @@ class Plan(object):
         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:
@@ -1768,12 +2148,15 @@ class Plan(object):
         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:
@@ -1782,24 +2165,64 @@ class Plan(object):
             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)
+            if absObjDiff <= tol:
+                # 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
@@ -1807,15 +2230,15 @@ class Plan(object):
             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
@@ -1826,12 +2249,17 @@ class Plan(object):
         """
         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)
@@ -1850,7 +2278,7 @@ class Plan(object):
             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):
         """
@@ -1881,7 +2309,7 @@ class Plan(object):
             elif vkeys[i] == "fx":
                 x += [pulp.LpVariable(f"x_{i}", cat="Continuous", lowBound=Lb[i], upBound=Ub[i])]
             else:
-                raise RuntimeError(f"Internal error: Variable with wierd bound f{vkeys[i]}.")
+                raise RuntimeError(f"Internal error: Variable with weird bound {vkeys[i]}.")
 
         x.extend([pulp.LpVariable(f"z_{i}", cat="Binary") for i in range(self.nbins)])
 
@@ -1915,7 +2343,7 @@ class Plan(object):
         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):
         """
@@ -1934,6 +2362,7 @@ class Plan(object):
         solverMsg = str()
 
         def _streamPrinter(text, msg=solverMsg):
+            self.mylog.vprint(text.strip())
             msg += text
 
         self._buildConstraints(objective, options)
@@ -1944,10 +2373,24 @@ class Plan(object):
         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)
 
@@ -1970,34 +2413,67 @@ class Plan(object):
         # 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 _computeNIIT(self, MAGI_n, I_n, Q_n):
-        """
-        Compute ACA tax on Dividends (Q) and Interests (I).
-        Pass arguments to better understand dependencies.
-        For accounting for rent and/or trust income, one can easily add a column
-        to the Wages and Contributions file and add yearly amount to Q_n + I_n below.
+    def _detectOscillation(self, obj_history, tolerance, max_cycle_length=15):
         """
-        J_n = np.zeros(self.N_n)
-        status = len(self.yobs) - 1
+        Detect if the objective function is oscillating in a repeating cycle.
 
-        for n in range(self.N_n):
-            if status and n == self.n_d:
-                status -= 1
+        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
 
-            Gmax = tx.niitThreshold[status]
-            if MAGI_n[n] > Gmax:
-                J_n[n] = tx.niitRate * min(MAGI_n[n] - Gmax, I_n[n] + Q_n[n])
+        # 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 J_n
+        return None
 
     def _computeNLstuff(self, x, includeMedicare):
         """
@@ -2013,8 +2489,14 @@ class Plan(object):
 
         self._aggregateResults(x, short=True)
 
-        self.J_n = self._computeNIIT(self.MAGI_n, self.I_n, self.Q_n)
-        self.psi_n = tx.capitalGainTaxRate(self.N_i, self.MAGI_n, self.gamma_n[:-1], self.n_d, self.N_n)
+        self.J_n = tx.computeNIIT(self.N_i, self.MAGI_n, self.I_n, self.Q_n, 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)
@@ -2082,27 +2564,34 @@ class Plan(object):
         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.
+        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))
 
         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)
+        # Clamp interest/dividend income to non-negative. Sum over individuals to share losses across spouses.
+        self.I_n = np.maximum(0, np.sum(I_in, axis=0))
 
-        # Stop after building minimu required for self-consistent loop.
+        # Stop after building minimum required for self-consistent loop.
         if short:
             return
 
@@ -2165,6 +2654,13 @@ class Plan(object):
         sources["RothX"] = self.x_in
         sources["tax-free wdrwl"] = self.w_ijn[:, 2, :]
         sources["BTI"] = self.Lambda_in
+        # Debts and fixed assets (debts are negative as expenses)
+        # 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, :]
@@ -2176,7 +2672,9 @@ class Plan(object):
 
         estate_j = np.sum(self.b_ijn[:, :, self.N_n], axis=0)
         estate_j[1] *= 1 - self.nu
-        self.bequest = np.sum(estate_j) / self.gamma_n[-1]
+        # Subtract remaining debt balance from estate
+        total_estate = np.sum(estate_j) - self.remaining_debt_balance
+        self.bequest = max(0.0, total_estate) / self.gamma_n[-1]
 
         self.basis = self.g_n[0] / self.xi_n[0]
 
@@ -2194,100 +2692,114 @@ class Plan(object):
         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)
-            tname = tx.taxBracketNames[t]
+            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:
+                tname = tx.taxBracketNames[t]
             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)}"
 
-        if self.N_i == 2 and self.n_d < self.N_n:
+        totDebtPayments = np.sum(self.debt_payments_n[:N], axis=0)
+        if totDebtPayments > 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 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
@@ -2298,49 +2810,66 @@ class Plan(object):
             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]
-        totEstate = np.sum(estate)
-        dic["Year of final bequest"] = (f"{endyear}")
-        dic[" Total value of final bequest"] = (f"{u.d(lyNow*totEstate)}")
-        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])}")
-
-        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
@@ -2352,9 +2881,26 @@ class Plan(object):
         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)
 
@@ -2383,7 +2929,7 @@ class Plan(object):
         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,
@@ -2402,7 +2948,7 @@ class Plan(object):
         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:
@@ -2572,7 +3118,7 @@ class Plan(object):
         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
@@ -2581,10 +3127,10 @@ class Plan(object):
         - 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)
@@ -2606,7 +3152,30 @@ class Plan(object):
         - 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 = {}
@@ -2626,6 +3195,7 @@ class Plan(object):
             _formatSpreadsheet(ws, datatype)
 
         wb = Workbook()
+        add_config_sheet("first")
 
         # Income.
         ws = wb.active
@@ -2647,6 +3217,10 @@ class Plan(object):
             "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,
@@ -2675,6 +3249,16 @@ class Plan(object):
             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],
@@ -2713,6 +3297,20 @@ class Plan(object):
             ws.append(lastRow)
             _formatSpreadsheet(ws, "currency")
 
+        # Federal income tax brackets.
+        TxDic = {}
+        for t in range(self.N_t):
+            TxDic[tx.taxBracketNames[t]] = self.T_tn[t, :]
+
+        TxDic["total"] = self.T_n
+        TxDic["NIIT"] = self.J_n
+        TxDic["LTCG"] = self.U_n
+        TxDic["10% penalty"] = self.P_n
+
+        sname = "Federal Income Tax"
+        ws = wb.create_sheet(sname)
+        fillsheet(ws, TxDic, "currency")
+
         # Allocations.
         jDic = {"taxable": 0, "tax-deferred": 1, "tax-free": 2}
         kDic = {"stocks": 0, "C bonds": 1, "T notes": 2, "common": 3}
@@ -2755,6 +3353,7 @@ class Plan(object):
             ws.append(row)
 
         _formatSpreadsheet(ws, "summary")
+        add_config_sheet("last")
 
         if saveToFile:
             if basename is None:
@@ -2774,11 +3373,29 @@ class Plan(object):
 
         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, :]
@@ -2793,6 +3410,7 @@ class Plan(object):
             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]]
@@ -2842,7 +3460,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):
@@ -2889,8 +3507,102 @@ 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
 
     return None
+
+
+def _formatDebtsSheet(ws):
+    """
+    Format Debts sheet with appropriate column formatting.
+    """
+    from openpyxl.utils import get_column_letter
+
+    # Format header row
+    for cell in ws[1]:
+        cell.style = "Pandas"
+
+    # Get column mapping from header
+    header_row = ws[1]
+    col_map = {}
+    for idx, cell in enumerate(header_row, start=1):
+        col_letter = get_column_letter(idx)
+        col_name = str(cell.value).lower() if cell.value else ""
+        col_map[col_letter] = col_name
+        # Set column width
+        width = max(len(str(cell.value)) + 4, 10)
+        ws.column_dimensions[col_letter].width = width
+
+    # Apply formatting based on column name
+    for col_letter, col_name in col_map.items():
+        if col_name in ["year", "term"]:
+            # Integer format without commas
+            fstring = "0"
+        elif col_name in ["rate"]:
+            # Number format (2 decimal places for percentages stored as numbers)
+            fstring = "#,##0.00"
+        elif col_name in ["amount"]:
+            # Currency format
+            fstring = "$#,##0_);[Red]($#,##0)"
+        else:
+            # Text columns (name, type) - no number formatting
+            continue
+
+        # Apply formatting to all data rows (skip header row 1)
+        for row in ws.iter_rows(min_row=2):
+            for cell in row:
+                if cell.column_letter == col_letter:
+                    cell.number_format = fstring
+
+    return None
+
+
+def _formatFixedAssetsSheet(ws):
+    """
+    Format Fixed Assets sheet with appropriate column formatting.
+    """
+    from openpyxl.utils import get_column_letter
+
+    # Format header row
+    for cell in ws[1]:
+        cell.style = "Pandas"
+
+    # Get column mapping from header
+    header_row = ws[1]
+    col_map = {}
+    for idx, cell in enumerate(header_row, start=1):
+        col_letter = get_column_letter(idx)
+        col_name = str(cell.value).lower() if cell.value else ""
+        col_map[col_letter] = col_name
+        # Set column width
+        width = max(len(str(cell.value)) + 4, 10)
+        ws.column_dimensions[col_letter].width = width
+
+    # Apply formatting based on column name
+    for col_letter, col_name in col_map.items():
+        if col_name in ["yod"]:
+            # 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"
+        elif col_name in ["basis", "value"]:
+            # Currency format
+            fstring = "$#,##0_);[Red]($#,##0)"
+        else:
+            # Text columns (name, type) - no number formatting
+            continue
+
+        # Apply formatting to all data rows (skip header row 1)
+        for row in ws.iter_rows(min_row=2):
+            for cell in row:
+                if cell.column_letter == col_letter:
+                    cell.number_format = fstring
+
+    return None