policyengine-us 1.458.0__py3-none-any.whl → 1.465.0__py3-none-any.whl

policyengine_us/tests/policy/baseline/gov/states/wv/tax/income/credits/heptc/wv_homestead_excess_property_tax_credit.yaml

@@ -41,3 +41,34 @@
     # heptc_amount = property_tax - wv_sctc - p.ghi_percentage * wv_ghi = 20000-10000-800 = 8200
   output:
     wv_homestead_excess_property_tax_credit: 0
+
+- name: WV no HEPTC credit with negative income and zero property taxes
+  absolute_error_margin: 2
+  period: 2024
+  input:
+    people:
+      person1:
+        is_tax_unit_head: true
+        age: 40
+        short_term_capital_gains: -896_056.95
+        partnership_s_corp_income: -727_887.75
+        taxable_interest_income: 0.012324943
+      person2:
+        is_tax_unit_spouse: true
+        age: 40
+        short_term_capital_gains: -896_056.95
+        partnership_s_corp_income: -727_887.75
+        taxable_interest_income: 0.012324943
+    tax_units:
+      tax_unit:
+        members: [person1, person2]
+    spm_units:
+      spm_unit:
+        members: [person1, person2]
+    households:
+      household:
+        members: [person1, person2]
+        state_fips: 54
+  output:
+    adjusted_gross_income: -3_000
+    wv_homestead_excess_property_tax_credit: 0

policyengine_us/tests/policy/contrib/aca/ptc_700_fpl_cliff.yaml

@@ -0,0 +1,136 @@
+- name: Single filer at 0% FPL - zero contribution
+  period: 2026
+  reforms: policyengine_us.reforms.aca.aca_ptc_700_fpl_cliff.aca_ptc_700_fpl_cliff
+  absolute_error_margin: 0.00001
+  input:
+    gov.contrib.aca.ptc_700_fpl_cliff.in_effect: true
+    aca_magi_fraction: 0.0
+  output:
+    aca_required_contribution_percentage: 0.0
+
+- name: Single filer at 150% FPL - zero contribution
+  period: 2026
+  reforms: policyengine_us.reforms.aca.aca_ptc_700_fpl_cliff.aca_ptc_700_fpl_cliff
+  absolute_error_margin: 0.00001
+  input:
+    gov.contrib.aca.ptc_700_fpl_cliff.in_effect: true
+    aca_magi_fraction: 1.5
+  output:
+    aca_required_contribution_percentage: 0.0
+
+- name: Single filer at 200% FPL - 2% contribution
+  period: 2026
+  reforms: policyengine_us.reforms.aca.aca_ptc_700_fpl_cliff.aca_ptc_700_fpl_cliff
+  absolute_error_margin: 0.00001
+  input:
+    gov.contrib.aca.ptc_700_fpl_cliff.in_effect: true
+    aca_magi_fraction: 2.0
+  output:
+    aca_required_contribution_percentage: 0.02
+
+- name: Single filer at 250% FPL - 4% contribution
+  period: 2026
+  reforms: policyengine_us.reforms.aca.aca_ptc_700_fpl_cliff.aca_ptc_700_fpl_cliff
+  absolute_error_margin: 0.00001
+  input:
+    gov.contrib.aca.ptc_700_fpl_cliff.in_effect: true
+    aca_magi_fraction: 2.5
+  output:
+    aca_required_contribution_percentage: 0.04
+
+- name: Single filer at 300% FPL - 6% contribution
+  period: 2026
+  reforms: policyengine_us.reforms.aca.aca_ptc_700_fpl_cliff.aca_ptc_700_fpl_cliff
+  absolute_error_margin: 0.00001
+  input:
+    gov.contrib.aca.ptc_700_fpl_cliff.in_effect: true
+    aca_magi_fraction: 3.0
+  output:
+    aca_required_contribution_percentage: 0.06
+
+- name: Single filer at 400% FPL - 8.5% contribution (old cliff point)
+  period: 2026
+  reforms: policyengine_us.reforms.aca.aca_ptc_700_fpl_cliff.aca_ptc_700_fpl_cliff
+  absolute_error_margin: 0.00001
+  input:
+    gov.contrib.aca.ptc_700_fpl_cliff.in_effect: true
+    aca_magi_fraction: 4.0
+  output:
+    aca_required_contribution_percentage: 0.085
+
+- name: Single filer at 500% FPL - 8.5% contribution (flat rate)
+  period: 2026
+  reforms: policyengine_us.reforms.aca.aca_ptc_700_fpl_cliff.aca_ptc_700_fpl_cliff
+  absolute_error_margin: 0.00001
+  input:
+    gov.contrib.aca.ptc_700_fpl_cliff.in_effect: true
+    aca_magi_fraction: 5.0
+  output:
+    aca_required_contribution_percentage: 0.085
+
+- name: Single filer at 600% FPL - 8.5% contribution (flat rate continues)
+  period: 2026
+  reforms: policyengine_us.reforms.aca.aca_ptc_700_fpl_cliff.aca_ptc_700_fpl_cliff
+  absolute_error_margin: 0.00001
+  input:
+    gov.contrib.aca.ptc_700_fpl_cliff.in_effect: true
+    aca_magi_fraction: 6.0
+  output:
+    aca_required_contribution_percentage: 0.085
+
+- name: Single filer at 700% FPL - 9.25% contribution (new cliff point)
+  period: 2026
+  reforms: policyengine_us.reforms.aca.aca_ptc_700_fpl_cliff.aca_ptc_700_fpl_cliff
+  absolute_error_margin: 0.00001
+  input:
+    gov.contrib.aca.ptc_700_fpl_cliff.in_effect: true
+    aca_magi_fraction: 7.0
+  output:
+    aca_required_contribution_percentage: 0.0925
+
+- name: Single filer at 175% FPL - interpolated 1% contribution
+  period: 2026
+  reforms: policyengine_us.reforms.aca.aca_ptc_700_fpl_cliff.aca_ptc_700_fpl_cliff
+  absolute_error_margin: 0.00001
+  input:
+    gov.contrib.aca.ptc_700_fpl_cliff.in_effect: true
+    aca_magi_fraction: 1.75
+  output:
+    aca_required_contribution_percentage: 0.01
+
+- name: Single filer at 350% FPL - interpolated 7.25% contribution
+  period: 2026
+  reforms: policyengine_us.reforms.aca.aca_ptc_700_fpl_cliff.aca_ptc_700_fpl_cliff
+  absolute_error_margin: 0.00001
+  input:
+    gov.contrib.aca.ptc_700_fpl_cliff.in_effect: true
+    aca_magi_fraction: 3.5
+  output:
+    aca_required_contribution_percentage: 0.0725
+
+- name: Single filer at 650% FPL - interpolated 8.875% contribution
+  period: 2026
+  reforms: policyengine_us.reforms.aca.aca_ptc_700_fpl_cliff.aca_ptc_700_fpl_cliff
+  absolute_error_margin: 0.00001
+  input:
+    gov.contrib.aca.ptc_700_fpl_cliff.in_effect: true
+    aca_magi_fraction: 6.5
+  output:
+    # 8.5% + (9.25% - 8.5%) * 0.5 = 8.5% + 0.375% = 8.875%
+    aca_required_contribution_percentage: 0.08875
+
+- name: Baseline comparison at 400% FPL - shows elimination of cliff
+  period: 2026
+  absolute_error_margin: 0.00001
+  input:
+    aca_magi_fraction: 4.0
+  output:
+    aca_required_contribution_percentage: 0.0996
+
+- name: Baseline comparison at 500% FPL - shows new eligibility
+  period: 2026
+  absolute_error_margin: 0.00001
+  input:
+    aca_magi_fraction: 5.0
+  output:
+    aca_required_contribution_percentage: 0.0996

policyengine_us/tests/test_batched.py

@@ -21,37 +21,33 @@ def count_yaml_files(directory: Path) -> int:
     return len(list(directory.rglob("*.yaml")))
 
 
-def get_test_directories(base_path: Path) -> Dict[str, int]:
-    """Get all subdirectories and their test counts."""
-    dir_counts = {}
-
-    # Check for yaml files directly in base directory
-    root_count = len(list(base_path.glob("*.yaml")))
-    if root_count > 0:
-        dir_counts["."] = root_count
-
-    # Get all subdirectories with their test counts
-    for item in base_path.iterdir():
-        if item.is_dir():
-            yaml_count = count_yaml_files(item)
-            if yaml_count > 0:
-                dir_counts[item.name] = yaml_count
-
-    return dir_counts
-
-
-def split_into_batches(base_path: Path, num_batches: int) -> List[List[str]]:
+def split_into_batches(
+    base_path: Path, num_batches: int, exclude: List[str] = None
+) -> List[List[str]]:
     """
     Split test directories into specified number of batches.
     Special handling for baseline tests to separate states.
     Special handling for contrib tests to divide by folder count.
+
+    Args:
+        base_path: Path to the test directory
+        num_batches: Number of batches to split into
+        exclude: List of directory names to exclude (for contrib tests)
     """
+    if exclude is None:
+        exclude = []
+
     # Special handling for contrib tests - each folder is its own batch
     # Only apply to policy/contrib (structural tests), not baseline/contrib
     if str(base_path).endswith("policy/contrib"):
         # Get all subdirectories and sort them alphabetically
+        # Exclude specified directories
         subdirs = sorted(
-            [item for item in base_path.iterdir() if item.is_dir()]
+            [
+                item
+                for item in base_path.iterdir()
+                if item.is_dir() and item.name not in exclude
+            ]
         )
 
         # Get root level YAML files and sort them
@@ -73,19 +69,17 @@ def split_into_batches(base_path: Path, num_batches: int) -> List[List[str]]:
     if "reform" in str(base_path):
         return [[str(base_path)]]
 
-    # Special handling for baseline tests with 2 batches
-    if "baseline" in str(base_path) and num_batches == 2:
+    # Special handling for baseline tests
+    if "baseline" in str(base_path) and str(base_path).endswith("baseline"):
         states_path = base_path / "gov" / "states"
-        if states_path.exists() and count_yaml_files(states_path) > 0:
-            # Batch 1: Only states
-            batch1 = [str(states_path)]
 
-            # Batch 2: Everything else (excluding states, household, and contrib)
-            batch2 = []
+        # If --exclude states, skip states and run everything else
+        if "states" in exclude:
+            batch = []
 
             # Add root level files if any
             for yaml_file in base_path.glob("*.yaml"):
-                batch2.append(str(yaml_file))
+                batch.append(str(yaml_file))
 
             # Add all directories except gov/states, household, and contrib
             for item in base_path.iterdir():
@@ -97,49 +91,17 @@ def split_into_batches(base_path: Path, num_batches: int) -> List[List[str]]:
                         # Add gov subdirectories except states
                         for gov_item in item.iterdir():
                             if gov_item.is_dir() and gov_item.name != "states":
-                                batch2.append(str(gov_item))
+                                batch.append(str(gov_item))
                             elif gov_item.suffix == ".yaml":
-                                batch2.append(str(gov_item))
+                                batch.append(str(gov_item))
                     else:
                         # Other non-gov directories
-                        batch2.append(str(item))
-
-            return [batch1, batch2] if batch2 else [batch1]
-
-    # Default behavior for non-baseline or different batch counts
-    dir_counts = get_test_directories(base_path)
-
-    if num_batches <= 0:
-        num_batches = 1
+                        batch.append(str(item))
 
-    # If only 1 batch, return everything
-    if num_batches == 1:
-        return [[str(base_path)]]
-
-    # Sort directories by test count (largest first)
-    sorted_dirs = sorted(dir_counts.items(), key=lambda x: x[1], reverse=True)
-
-    # Initialize batches
-    batches = [[] for _ in range(num_batches)]
-    batch_counts = [0] * num_batches
-
-    # Distribute directories to batches (greedy algorithm - add to smallest batch)
-    for dir_name, count in sorted_dirs:
-        # Find batch with fewest tests
-        min_batch_idx = batch_counts.index(min(batch_counts))
-
-        # Add directory to that batch
-        if dir_name == ".":
-            # Root level files - add individually
-            for yaml_file in base_path.glob("*.yaml"):
-                batches[min_batch_idx].append(str(yaml_file))
-        else:
-            batches[min_batch_idx].append(str(base_path / dir_name))
-
-        batch_counts[min_batch_idx] += count
+            return [batch] if batch else []
 
-    # Filter out empty batches
-    return [batch for batch in batches if batch]
+    # Default: return the entire path as a single batch
+    return [[str(base_path)]]
 
 
 def run_batch(test_paths: List[str], batch_name: str) -> Dict:
@@ -298,8 +260,15 @@ def main():
         default=2,
         help="Number of batches to split tests into (default: 2)",
     )
+    parser.add_argument(
+        "--exclude",
+        type=str,
+        default="",
+        help="Comma-separated list of directory names to exclude (for contrib tests)",
+    )
 
     args = parser.parse_args()
+    exclude_list = [x.strip() for x in args.exclude.split(",") if x.strip()]
 
     if not os.path.exists("policyengine_us"):
         print("Error: Must run from PolicyEngine US root directory")
@@ -314,13 +283,15 @@ def main():
     print("=" * 60)
     print(f"Test path: {test_path}")
     print(f"Requested batches: {args.batches}")
+    if exclude_list:
+        print(f"Excluding: {', '.join(exclude_list)}")
 
     # Count total tests
     total_tests = count_yaml_files(test_path)
     print(f"Total test files: {total_tests}")
 
     # Split into batches
-    batches = split_into_batches(test_path, args.batches)
+    batches = split_into_batches(test_path, args.batches, exclude_list)
     if len(batches) != args.batches:
         print(
             f"Actual batches: {len(batches)} (optimized for {total_tests} files)"

policyengine_us/variables/gov/hhs/medicare/savings_programs/category/is_qi_eligible.py

@@ -0,0 +1,33 @@
+from policyengine_us.model_api import *
+
+
+class is_qi_eligible(Variable):
+    value_type = bool
+    entity = Person
+    label = "Qualifying Individual (QI) eligible"
+    definition_period = MONTH
+    reference = (
+        "https://www.law.cornell.edu/cfr/text/42/435.123",
+        "https://www.medicare.gov/basics/costs/help/medicare-savings-programs",
+    )
+
+    def formula(person, period, parameters):
+        # QI requires income above 120% FPL but at or below 135% FPL
+        p = parameters(
+            period
+        ).gov.hhs.medicare.savings_programs.eligibility.income
+
+        medicare_eligible = person("is_medicare_eligible", period.this_year)
+        asset_eligible = person("msp_asset_eligible", period)
+
+        fpg = person("msp_fpg", period)
+        countable_income = person("msp_countable_income", period)
+
+        slmb_income_limit = fpg * p.slmb.fpl_limit
+        qi_income_limit = fpg * p.qi.fpl_limit
+
+        income_above_slmb = countable_income > slmb_income_limit
+        income_at_or_below_qi = countable_income <= qi_income_limit
+        income_eligible = income_above_slmb & income_at_or_below_qi
+
+        return medicare_eligible & income_eligible & asset_eligible

policyengine_us/variables/gov/hhs/medicare/savings_programs/category/is_qmb_eligible.py

@@ -0,0 +1,28 @@
+from policyengine_us.model_api import *
+
+
+class is_qmb_eligible(Variable):
+    value_type = bool
+    entity = Person
+    label = "Qualified Medicare Beneficiary (QMB) eligible"
+    definition_period = MONTH
+    reference = (
+        "https://www.law.cornell.edu/cfr/text/42/435.121",
+        "https://www.medicare.gov/basics/costs/help/medicare-savings-programs",
+    )
+
+    def formula(person, period, parameters):
+        # QMB requires income at or below 100% FPL
+        p = parameters(
+            period
+        ).gov.hhs.medicare.savings_programs.eligibility.income
+
+        medicare_eligible = person("is_medicare_eligible", period.this_year)
+        asset_eligible = person("msp_asset_eligible", period)
+
+        fpg = person("msp_fpg", period)
+        countable_income = person("msp_countable_income", period)
+        qmb_income_limit = fpg * p.qmb.fpl_limit
+        income_eligible = countable_income <= qmb_income_limit
+
+        return medicare_eligible & income_eligible & asset_eligible

policyengine_us/variables/gov/hhs/medicare/savings_programs/category/is_slmb_eligible.py

@@ -0,0 +1,33 @@
+from policyengine_us.model_api import *
+
+
+class is_slmb_eligible(Variable):
+    value_type = bool
+    entity = Person
+    label = "Specified Low-Income Medicare Beneficiary (SLMB) eligible"
+    definition_period = MONTH
+    reference = (
+        "https://www.law.cornell.edu/cfr/text/42/435.122",
+        "https://www.medicare.gov/basics/costs/help/medicare-savings-programs",
+    )
+
+    def formula(person, period, parameters):
+        # SLMB requires income above 100% FPL but at or below 120% FPL
+        p = parameters(
+            period
+        ).gov.hhs.medicare.savings_programs.eligibility.income
+
+        medicare_eligible = person("is_medicare_eligible", period.this_year)
+        asset_eligible = person("msp_asset_eligible", period)
+
+        fpg = person("msp_fpg", period)
+        countable_income = person("msp_countable_income", period)
+
+        qmb_income_limit = fpg * p.qmb.fpl_limit
+        slmb_income_limit = fpg * p.slmb.fpl_limit
+
+        income_above_qmb = countable_income > qmb_income_limit
+        income_at_or_below_slmb = countable_income <= slmb_income_limit
+        income_eligible = income_above_qmb & income_at_or_below_slmb
+
+        return medicare_eligible & income_eligible & asset_eligible

policyengine_us/variables/gov/hhs/medicare/savings_programs/category/msp_category.py

@@ -0,0 +1,33 @@
+from policyengine_us.model_api import *
+
+
+class MSPCategory(Enum):
+    NONE = "None"
+    QMB = "Qualified Medicare Beneficiary"
+    SLMB = "Specified Low-Income Medicare Beneficiary"
+    QI = "Qualifying Individual"
+
+
+class msp_category(Variable):
+    value_type = Enum
+    possible_values = MSPCategory
+    default_value = MSPCategory.NONE
+    entity = Person
+    label = "Medicare Savings Program category"
+    definition_period = MONTH
+    reference = (
+        "https://www.medicare.gov/basics/costs/help/medicare-savings-programs",
+        "https://www.law.cornell.edu/cfr/text/42/435.121",
+    )
+
+    def formula(person, period, parameters):
+        qmb = person("is_qmb_eligible", period)
+        slmb = person("is_slmb_eligible", period)
+        qi = person("is_qi_eligible", period)
+
+        # Priority: QMB > SLMB > QI (QMB is most comprehensive)
+        return select(
+            [qmb, slmb, qi],
+            [MSPCategory.QMB, MSPCategory.SLMB, MSPCategory.QI],
+            default=MSPCategory.NONE,
+        )

policyengine_us/variables/gov/hhs/medicare/savings_programs/eligibility/msp_asset_eligible.py

@@ -0,0 +1,26 @@
+from policyengine_us.model_api import *
+
+
+class msp_asset_eligible(Variable):
+    value_type = bool
+    entity = Person
+    label = "Medicare Savings Program asset eligible"
+    definition_period = MONTH
+    reference = (
+        "https://www.medicare.gov/basics/costs/help/medicare-savings-programs",
+        "https://www.medicareinteractive.org/understanding-medicare/"
+        "cost-saving-programs/medicare-savings-programs-qmb-slmb-qi/"
+        "medicare-savings-program-income-and-asset-limits",
+    )
+
+    def formula(person, period, parameters):
+        p = parameters(period).gov.hhs.medicare.savings_programs.eligibility
+        state_code = person.household("state_code_str", period)
+        # Check if asset test applies (some states have eliminated it)
+        asset_test_applies = p.asset.applies[state_code]
+        # If asset test doesn't apply, everyone is asset-eligible
+        cash_assets = person.spm_unit("spm_unit_cash_assets", period.this_year)
+        married = person.spm_unit("spm_unit_is_married", period)
+        asset_limit = where(married, p.asset.couple, p.asset.individual)
+        meets_asset_test = cash_assets <= asset_limit
+        return where(asset_test_applies, meets_asset_test, True)

policyengine_us/variables/gov/hhs/medicare/savings_programs/eligibility/msp_eligible.py

@@ -0,0 +1,20 @@
+from policyengine_us.model_api import *
+
+
+class msp_eligible(Variable):
+    value_type = bool
+    entity = Person
+    label = "Medicare Savings Program eligible"
+    definition_period = MONTH
+    reference = (
+        "https://www.medicare.gov/basics/costs/help/medicare-savings-programs",
+        "https://www.law.cornell.edu/cfr/text/42/435.121",
+    )
+
+    def formula(person, period, parameters):
+        # Must be Medicare eligible
+        medicare_eligible = person("is_medicare_eligible", period.this_year)
+        income_eligible = person("msp_income_eligible", period)
+        asset_eligible = person("msp_asset_eligible", period)
+
+        return medicare_eligible & income_eligible & asset_eligible

policyengine_us/variables/gov/hhs/medicare/savings_programs/eligibility/msp_income_eligible.py

@@ -0,0 +1,26 @@
+from policyengine_us.model_api import *
+
+
+class msp_income_eligible(Variable):
+    value_type = bool
+    entity = Person
+    label = "Medicare Savings Program income eligible"
+    definition_period = MONTH
+    reference = (
+        "https://www.medicare.gov/basics/costs/help/medicare-savings-programs",
+        "https://www.law.cornell.edu/cfr/text/42/435.121",
+    )
+
+    def formula(person, period, parameters):
+        # Income eligible if under the QI threshold (135% FPL)
+        # which is the highest threshold for standard MSP levels
+        p = parameters(
+            period
+        ).gov.hhs.medicare.savings_programs.eligibility.income.qi
+        fpg = person("msp_fpg", period)
+        countable_income = person("msp_countable_income", period)
+
+        # Use QI threshold (135% FPL) as the outer bound
+        qi_income_limit = fpg * p.fpl_limit
+
+        return countable_income <= qi_income_limit

policyengine_us/variables/gov/hhs/medicare/savings_programs/income/msp_countable_income.py

@@ -0,0 +1,35 @@
+from policyengine_us.model_api import *
+from policyengine_us.variables.gov.ssa.ssi.eligibility.income._apply_ssi_exclusions import (
+    _apply_ssi_exclusions,
+)
+
+
+class msp_countable_income(Variable):
+    value_type = float
+    entity = Person
+    unit = USD
+    label = "Medicare Savings Program countable monthly income"
+    definition_period = MONTH
+    reference = (
+        "https://www.law.cornell.edu/uscode/text/42/1396d#p",
+        "https://secure.ssa.gov/apps10/poms.nsf/lnx/0501715010",
+        "https://www.medicare.gov/basics/costs/help/medicare-savings-programs",
+    )
+    documentation = """
+    MSP countable income uses SSI methodology per 42 U.S.C. 1396d(p)(1)(B),
+    which specifies income "determined under section 1382a" (SSI rules).
+    This applies the standard SSI exclusions:
+    1. $20 general income exclusion (from unearned first)
+    2. $65 earned income exclusion
+    3. 50% of remaining earned income excluded
+    """
+
+    def formula(person, period, parameters):
+        # MSP uses SSI income methodology per 42 U.S.C. 1396d(p)(1)(B)
+        earned = person("ssi_earned_income", period.this_year)
+        unearned = person("ssi_unearned_income", period.this_year)
+        # Apply SSI exclusions ($20 general, $65 earned, 50% remaining)
+        annual_countable = _apply_ssi_exclusions(
+            earned, unearned, parameters, period.this_year
+        )
+        return annual_countable / MONTHS_IN_YEAR

policyengine_us/variables/gov/hhs/medicare/savings_programs/income/msp_fpg.py

@@ -0,0 +1,40 @@
+from policyengine_us.model_api import *
+
+
+class msp_fpg(Variable):
+    value_type = float
+    entity = Person
+    unit = USD
+    label = "MSP Federal Poverty Guideline"
+    definition_period = YEAR
+    reference = (
+        "https://www.law.cornell.edu/uscode/text/42/1396d#p",
+        "https://www.medicare.gov/basics/costs/help/medicare-savings-programs",
+    )
+    documentation = """
+    The Federal Poverty Guideline used for MSP eligibility is based on
+    individual or couple status, not the full household/SPM unit size.
+    Per 42 U.S.C. 1396d(p), MSP income limits are based on the federal
+    poverty line for a family of the size involved.
+
+    Note: Published Medicare.gov limits are $20/month higher than raw FPL
+    because they include the $20 general income exclusion in the threshold.
+    Our implementation applies the $20 exclusion to income instead, which
+    is mathematically equivalent: (income - $20) <= FPL == income <= (FPL + $20)
+    """
+
+    def formula(person, period, parameters):
+        # MSP uses individual (1 person) or couple (2 persons) FPG,
+        # not the full SPM unit size.
+        # Note: These are raw FPL values. Published limits are $20 higher
+        # because we apply the $20 exclusion to income (msp_countable_income)
+        # rather than adding it to the threshold.
+        married = person.spm_unit("spm_unit_is_married", period)
+        state_group = person.household("state_group_str", period)
+        p = parameters(period).gov.hhs.fpg
+        p1 = p.first_person[state_group]
+        pn = p.additional_person[state_group]
+        # 1 person if single, 2 persons if married
+        individual_fpg = p1
+        couple_fpg = p1 + pn
+        return where(married, couple_fpg, individual_fpg)

policyengine_us/variables/gov/hhs/medicare/savings_programs/msp.py

@@ -0,0 +1,15 @@
+from policyengine_us.model_api import *
+
+
+class msp(Variable):
+    value_type = float
+    entity = Person
+    unit = USD
+    label = "Medicare Savings Program benefit"
+    definition_period = MONTH
+    reference = (
+        "https://www.medicare.gov/basics/costs/help/medicare-savings-programs",
+    )
+    defined_for = "msp_eligible"
+
+    adds = ["msp_benefit_value"]

policyengine_us/variables/gov/hhs/medicare/savings_programs/msp_benefit_value.py

@@ -0,0 +1,37 @@
+from policyengine_us.model_api import *
+from policyengine_us.variables.gov.hhs.medicare.savings_programs.category.msp_category import (
+    MSPCategory,
+)
+
+
+class msp_benefit_value(Variable):
+    value_type = float
+    entity = Person
+    unit = USD
+    label = "Medicare Savings Program estimated monthly benefit value"
+    definition_period = MONTH
+    reference = (
+        "https://www.medicare.gov/basics/costs/help/medicare-savings-programs",
+    )
+    defined_for = "msp_eligible"
+
+    def formula(person, period, parameters):
+        category = person("msp_category", period)
+
+        # Get premiums (automatically disaggregated from annual to monthly)
+        part_a_premium = person("base_part_a_premium", period)
+        part_b_premium = person("base_part_b_premium", period)
+
+        # Benefit depends on category:
+        # QMB: Part A + Part B premiums (plus deductibles/copays, not modeled)
+        # SLMB: Part B premium only
+        # QI: Part B premium only
+        is_qmb = category == MSPCategory.QMB
+        is_slmb = category == MSPCategory.SLMB
+        is_qi = category == MSPCategory.QI
+
+        return (
+            is_qmb * (part_a_premium + part_b_premium)
+            + is_slmb * part_b_premium
+            + is_qi * part_b_premium
+        )