From b0f008de119e93966d644c2f294b8124b18b6ab5 Mon Sep 17 00:00:00 2001 From: Ziming Date: Mon, 2 Nov 2026 18:30:05 -0500 Subject: [PATCH 1/4] Apply each state's rule for a Medicaid applicant whose spouse is not aged, blind or disabled Co-Authored-By: Claude Opus 5.5 --- ...id-couple-limit-ineligible-spouse.fixed.md | 1 + .../limit/income/budgets_couple_together.yaml | 140 +++++++++ .../income/couple_limit_without_deeming.yaml | 114 ++++++++ .../income/budgets_couple_together.yaml | 156 ++++++++++ .../income/couple_limit_without_deeming.yaml | 114 ++++++++ ...nior_or_disabled_uses_couple_standard.yaml | 272 ++++++++++++++++++ .../is_medically_needy_for_medicaid.yaml | 108 +++++++ ..._medically_needy_uses_couple_standard.yaml | 113 ++++++++ ..._recipient_income_eligible_for_medicaid.py | 17 +- ...onal_senior_or_disabled_income_eligible.py | 6 +- ...ptional_senior_or_disabled_income_limit.py | 4 +- ...senior_or_disabled_uses_couple_standard.py | 37 +++ .../is_medically_needy_for_medicaid.py | 26 +- ...caid_medically_needy_income_from_spouse.py | 45 +++ .../medicaid_medically_needy_income_limit.py | 2 +- ...id_medically_needy_uses_couple_standard.py | 36 +++ .../hhs/medicaid/income/_couple_standard.py | 35 +++ ...ed_income_deemed_from_ineligible_spouse.py | 25 +- source_conflicts/candidates.yaml | 117 ++++++++ 19 files changed, 1353 insertions(+), 15 deletions(-) create mode 100644 changelog.d/medicaid-couple-limit-ineligible-spouse.fixed.md create mode 100644 policyengine_us/parameters/gov/hhs/medicaid/eligibility/categories/medically_needy/limit/income/budgets_couple_together.yaml create mode 100644 policyengine_us/parameters/gov/hhs/medicaid/eligibility/categories/medically_needy/limit/income/couple_limit_without_deeming.yaml create mode 100644 policyengine_us/parameters/gov/hhs/medicaid/eligibility/categories/senior_or_disabled/income/budgets_couple_together.yaml create mode 100644 policyengine_us/parameters/gov/hhs/medicaid/eligibility/categories/senior_or_disabled/income/couple_limit_without_deeming.yaml create mode 100644 policyengine_us/tests/policy/baseline/gov/hhs/medicaid/eligibility/categories/medicaid_optional_senior_or_disabled_uses_couple_standard.yaml create mode 100644 policyengine_us/tests/policy/baseline/gov/hhs/medicaid/eligibility/categories/medically_needy/medicaid_medically_needy_uses_couple_standard.yaml create mode 100644 policyengine_us/variables/gov/hhs/medicaid/eligibility/categories/medicaid_optional_senior_or_disabled_uses_couple_standard.py create mode 100644 policyengine_us/variables/gov/hhs/medicaid/eligibility/categories/medically_needy/medicaid_medically_needy_income_from_spouse.py create mode 100644 policyengine_us/variables/gov/hhs/medicaid/eligibility/categories/medically_needy/medicaid_medically_needy_uses_couple_standard.py create mode 100644 policyengine_us/variables/gov/hhs/medicaid/income/_couple_standard.py diff --git a/changelog.d/medicaid-couple-limit-ineligible-spouse.fixed.md b/changelog.d/medicaid-couple-limit-ineligible-spouse.fixed.md new file mode 100644 index 00000000000..635d0df6d20 --- /dev/null +++ b/changelog.d/medicaid-couple-limit-ineligible-spouse.fixed.md @@ -0,0 +1 @@ +Apply each state's own rule for a Medicaid applicant whose spouse is not aged, blind or disabled, in the aged, blind and disabled pathway, the 209(b) route and medically needy: SSI's deeming rule by default, or budgeting the couple together, or keeping the couple limit without deeming. Test spouses split by a facility separately. diff --git a/policyengine_us/parameters/gov/hhs/medicaid/eligibility/categories/medically_needy/limit/income/budgets_couple_together.yaml b/policyengine_us/parameters/gov/hhs/medicaid/eligibility/categories/medically_needy/limit/income/budgets_couple_together.yaml new file mode 100644 index 00000000000..7c535369b74 --- /dev/null +++ b/policyengine_us/parameters/gov/hhs/medicaid/eligibility/categories/medically_needy/limit/income/budgets_couple_together.yaml @@ -0,0 +1,140 @@ +description: States count a spouse's income and test a married couple living together against the couple limit, whether or not SSI deeming would apply, under the Medicaid medically needy program, if this is true. +metadata: + unit: bool + period: year + label: Medicaid medically needy couple budgeted together + breakdown: + - state_code + reference: + - title: 42 CFR 435.601 - Application of financial eligibility methodologies + href: https://www.law.cornell.edu/cfr/text/42/435.601 + - title: "Arkansas Medical Services Policy Manual O-531 #page 424-425" + href: https://humanservices.arkansas.gov/wp-content/uploads/MS-Policy-9.26-New.pdf#page=424 + - title: 22 CCR 50373 (California) + href: https://www.law.cornell.edu/regulations/california/22-CCR-50373 + - title: Connecticut Uniform Policy Manual 5020.75 + href: https://portal.ct.gov/-/media/Departments-and-Agencies/DSS/UPMs/UPM5---Treatment-of-Income-Income-Eligibility/5020_75.doc + - title: Illinois Policy Manual PM 15-06-02-c + href: https://www.dhs.state.il.us/page.aspx?item=16512 + - title: Kansas MKEESM 4312 + href: https://khap.kdhe.ks.gov/KEESM/July_2026_Output/4000/4310-Assistance-Planning.htm + - title: 130 CMR 520.002(A)(1) (Massachusetts) + href: https://web.archive.org/web/20260711022327id_/https://www.mass.gov/doc/130-cmr-520000-masshealth-financial-eligibility-0/download#page=2 + - title: "Maryland Medical Assistance Manual Section 600 #page 7-8" + href: https://health.maryland.gov/mmcp/Medicaid%20Manual/Section%20600-%20The%20Assistance%20Unit.pdf#page=7 + - title: Michigan BEM 211 - Fiscal and asset group for SSI-related groups + href: https://dhhs.michigan.gov/olmweb/ex/BP/Public/BEM/211.pdf#page=8 + - title: Minnesota Eligibility Policy Manual 2.3.3.3.2.1.1 - Income deeming + href: https://hcopub.dhs.state.mn.us/epm/2_3_3_3_2_1_1.htm + - title: N.D. Admin. Code 75-02-02.1-34 (North Dakota) + href: https://ndlegis.gov/information/acdata/pdf/75-02-02.1.pdf#page=70 + - title: 477 NAC 25-002 (Nebraska) + href: https://www.law.cornell.edu/regulations/nebraska/477-Neb-Admin-Code-ch-25-SS-002 + - title: N.H. Code Admin. R. He-W 858.04 + href: https://www.law.cornell.edu/regulations/new-hampshire/N-H-Admin-Code-SS-He-W-858.04 + - title: "Vermont Health Benefits Eligibility and Enrollment Rule, Part 5, 29.04 and 29.14 #page 14,52" + href: https://humanservices.vermont.gov/sites/ahsnew/files/documents/HBEE-Part-5-Financial-Methodologies.pdf#page=14 + - title: Wisconsin Medicaid Eligibility Handbook 15.1 + href: https://www.emhandbooks.wisconsin.gov/meh-ebd/policy_files/15/15.1.htm +AK: + 2015-01-01: false +AL: + 2015-01-01: false +AR: + 2015-01-01: true +AZ: + 2015-01-01: false +CA: + 2015-01-01: true +CO: + 2015-01-01: false +CT: + 2015-01-01: true +DC: + 2015-01-01: false +DE: + 2015-01-01: false +FL: + 2015-01-01: false +GA: + 2015-01-01: false +HI: + 2015-01-01: false +IA: + 2015-01-01: false +ID: + 2015-01-01: false +IL: + 2015-01-01: true +IN: + 2015-01-01: false +KS: + 2015-01-01: true +KY: + 2015-01-01: false +LA: + 2015-01-01: false +MA: + 2015-01-01: true +MD: + 2015-01-01: true +ME: + 2015-01-01: false +MI: + 2015-01-01: true +MN: + 2015-01-01: true +MO: + 2015-01-01: false +MS: + 2015-01-01: false +MT: + 2015-01-01: false +NC: + 2015-01-01: false +ND: + 2015-01-01: true +NE: + 2015-01-01: true +NH: + 2015-01-01: true +NJ: + 2015-01-01: false +NM: + 2015-01-01: false +NV: + 2015-01-01: false +NY: + 2015-01-01: false +OH: + 2015-01-01: false +OK: + 2015-01-01: false +OR: + 2015-01-01: false +PA: + 2015-01-01: false +RI: + 2015-01-01: false +SC: + 2015-01-01: false +SD: + 2015-01-01: false +TN: + 2015-01-01: false +TX: + 2015-01-01: false +UT: + 2015-01-01: false +VA: + 2015-01-01: false +VT: + 2015-01-01: true +WA: + 2015-01-01: false +WI: + 2015-01-01: true +WV: + 2015-01-01: false +WY: + 2015-01-01: false diff --git a/policyengine_us/parameters/gov/hhs/medicaid/eligibility/categories/medically_needy/limit/income/couple_limit_without_deeming.yaml b/policyengine_us/parameters/gov/hhs/medicaid/eligibility/categories/medically_needy/limit/income/couple_limit_without_deeming.yaml new file mode 100644 index 00000000000..7841fa817bf --- /dev/null +++ b/policyengine_us/parameters/gov/hhs/medicaid/eligibility/categories/medically_needy/limit/income/couple_limit_without_deeming.yaml @@ -0,0 +1,114 @@ +description: States test an applicant against the couple limit even when no income is deemed from a spouse who is not aged, blind, or disabled, under the Medicaid medically needy program, if this is true. +metadata: + unit: bool + period: year + label: Medicaid medically needy couple limit applies without deeming + breakdown: + - state_code + reference: + - title: N.J.A.C. 10:70-3.5(c)2 + href: https://www.law.cornell.edu/regulations/new-jersey/N-J-A-C-10-70-3-5 + - title: 210-RICR-40-05-2 (Rhode Island) + href: https://rules.sos.ri.gov/regulations/part/210-40-05-2 +AK: + 2015-01-01: false +AL: + 2015-01-01: false +AR: + 2015-01-01: false +AZ: + 2015-01-01: false +CA: + 2015-01-01: false +CO: + 2015-01-01: false +CT: + 2015-01-01: false +DC: + 2015-01-01: false +DE: + 2015-01-01: false +FL: + 2015-01-01: false +GA: + 2015-01-01: false +HI: + 2015-01-01: false +IA: + 2015-01-01: false +ID: + 2015-01-01: false +IL: + 2015-01-01: false +IN: + 2015-01-01: false +KS: + 2015-01-01: false +KY: + 2015-01-01: false +LA: + 2015-01-01: false +MA: + 2015-01-01: false +MD: + 2015-01-01: false +ME: + 2015-01-01: false +MI: + 2015-01-01: false +MN: + 2015-01-01: false +MO: + 2015-01-01: false +MS: + 2015-01-01: false +MT: + 2015-01-01: false +NC: + 2015-01-01: false +ND: + 2015-01-01: false +NE: + 2015-01-01: false +NH: + 2015-01-01: false +NJ: + 2015-01-01: true +NM: + 2015-01-01: false +NV: + 2015-01-01: false +NY: + 2015-01-01: false +OH: + 2015-01-01: false +OK: + 2015-01-01: false +OR: + 2015-01-01: false +PA: + 2015-01-01: false +RI: + 2015-01-01: true +SC: + 2015-01-01: false +SD: + 2015-01-01: false +TN: + 2015-01-01: false +TX: + 2015-01-01: false +UT: + 2015-01-01: false +VA: + 2015-01-01: false +VT: + 2015-01-01: false +WA: + 2015-01-01: false +WI: + 2015-01-01: false +WV: + 2015-01-01: false +WY: + 2015-01-01: false diff --git a/policyengine_us/parameters/gov/hhs/medicaid/eligibility/categories/senior_or_disabled/income/budgets_couple_together.yaml b/policyengine_us/parameters/gov/hhs/medicaid/eligibility/categories/senior_or_disabled/income/budgets_couple_together.yaml new file mode 100644 index 00000000000..9e59399366b --- /dev/null +++ b/policyengine_us/parameters/gov/hhs/medicaid/eligibility/categories/senior_or_disabled/income/budgets_couple_together.yaml @@ -0,0 +1,156 @@ +description: States count a spouse's income and test a married couple living together against the couple standard, whether or not SSI deeming would apply, under the Medicaid pathway for aged, blind, or disabled people, if this is true. +metadata: + unit: bool + period: year + label: Medicaid senior or disabled couple budgeted together + breakdown: + - state_code + reference: + - title: 42 CFR 435.601 - Application of financial eligibility methodologies + href: https://www.law.cornell.edu/cfr/text/42/435.601 + - title: 42 USC 1396a(r)(2) - Less restrictive income and resource methodologies + href: https://www.law.cornell.edu/uscode/text/42/1396a#r_2 + - title: 20 CFR 416.1163 - How we deem income to you from your ineligible spouse + href: https://www.law.cornell.edu/cfr/text/20/416.1163 + - title: 7 AAC 40.240 - Income and resources of spouses (Alaska) + href: https://www.law.cornell.edu/regulations/alaska/7-AAC-40.240 + - title: AHCCCS Eligibility Policy Manual MA611 A - How to calculate income eligibility for SSI-MAO (Arizona) + href: https://epm.azahcccs.gov/epmplus/Policy/Chapter_600_Income_Eligibility/611_How_to_Calculate_Income_Eligibility_for_SSIMAO/611A.htm + - title: 10 CCR 2505-10 8.100.5 and 8.100.7.C.2 (Colorado) + href: https://www.law.cornell.edu/regulations/colorado/10-CCR-2505-10-8.100_v2 + - title: Connecticut Uniform Policy Manual 5020.75 + href: https://portal.ct.gov/-/media/Departments-and-Agencies/DSS/UPMs/UPM5---Treatment-of-Income-Income-Eligibility/5020_75.doc + - title: Connecticut Uniform Policy Manual 5515.05 + href: https://portal.ct.gov/-/media/Departments-and-Agencies/DSS/UPMs/UPM5---Treatment-of-Income-Income-Eligibility/5515_05.doc + - title: Illinois Policy Manual PM 15-06-02-c + href: https://www.dhs.state.il.us/page.aspx?item=16512 + - title: 405 IAC 2-3-4 (Indiana) + href: https://www.law.cornell.edu/regulations/indiana/405-IAC-2-3-4 + - title: 130 CMR 520.002(A)(1) (Massachusetts) + href: https://web.archive.org/web/20260711022327id_/https://www.mass.gov/doc/130-cmr-520000-masshealth-financial-eligibility-0/download#page=2 + - title: 130 CMR 519.005(A)(1) (Massachusetts) + href: https://www.law.cornell.edu/regulations/massachusetts/130-CMR-519-005 + - title: Michigan BEM 211 - Fiscal and asset group for SSI-related groups + href: https://dhhs.michigan.gov/olmweb/ex/BP/Public/BEM/211.pdf#page=8 + - title: Minnesota Eligibility Policy Manual 2.3.3.3.2.1.1 - Income deeming + href: https://hcopub.dhs.state.mn.us/epm/2_3_3_3_2_1_1.htm + - title: Missouri MHABD Manual 0805.015.05 - Persons whose income and needs are considered + href: https://dssmanuals.mo.gov/medical-assistance-for-the-aged-blind-and-disabled/0805-015-05/ + - title: N.D. Admin. Code 75-02-02.1-34 (North Dakota) + href: https://ndlegis.gov/information/acdata/pdf/75-02-02.1.pdf#page=70 + - title: 477 NAC 24-001 (Nebraska) + href: https://www.law.cornell.edu/regulations/nebraska/477-Neb-Admin-Code-ch-24-SS-001 + - title: N.H. Code Admin. R. He-W 854.02 + href: https://www.law.cornell.edu/regulations/new-hampshire/N-H-Admin-Code-SS-He-W-854.02 + - title: N.H. Code Admin. R. He-W 858.03 + href: https://www.law.cornell.edu/regulations/new-hampshire/N-H-Admin-Code-SS-He-W-858.03 + - title: OAC 317:35-7-40 - Qualified Medicare Beneficiary Plus (Oklahoma) + href: https://aem-prod.oklahoma.gov/ohca/policies-and-rules/xpolicy/medical-assistance-for-adults-and-children-eligibility/medical-services/determination-of-eligibility-for-medical-services/eligibility-as-qualified-medicare-beneficiary-plus.html + - title: South Carolina MPPM 303.06.01 + href: https://img1.scdhhs.gov/mppm/SCMPPM/Section_300.docx + - title: "Vermont Health Benefits Eligibility and Enrollment Rule, Part 5, 29.04 and 29.14 #page 14,52" + href: https://humanservices.vermont.gov/sites/ahsnew/files/documents/HBEE-Part-5-Financial-Methodologies.pdf#page=14 + - title: Wisconsin Medicaid Eligibility Handbook 15.1 + href: https://www.emhandbooks.wisconsin.gov/meh-ebd/policy_files/15/15.1.htm +AK: + 2015-01-01: true +AL: + 2015-01-01: false +AR: + 2015-01-01: false +AZ: + 2015-01-01: true +CA: + 2015-01-01: false +CO: + 2015-01-01: true +CT: + 2015-01-01: true +DC: + 2015-01-01: false +DE: + 2015-01-01: false +FL: + 2015-01-01: false +GA: + 2015-01-01: false +HI: + 2015-01-01: false +IA: + 2015-01-01: false +ID: + 2015-01-01: false +IL: + 2015-01-01: true +IN: + 2015-01-01: true +KS: + 2015-01-01: false +KY: + 2015-01-01: false +LA: + 2015-01-01: false +MA: + 2015-01-01: true +MD: + 2015-01-01: false +ME: + 2015-01-01: false +MI: + 2015-01-01: true +MN: + 2015-01-01: true +MO: + 2015-01-01: true +MS: + 2015-01-01: false +MT: + 2015-01-01: false +NC: + 2015-01-01: false +ND: + 2015-01-01: true +NE: + 2015-01-01: true +NH: + 2015-01-01: true +NJ: + 2015-01-01: false +NM: + 2015-01-01: false +NV: + 2015-01-01: false +NY: + 2015-01-01: false +OH: + 2015-01-01: false +OK: + 2015-01-01: true +OR: + 2015-01-01: false +PA: + 2015-01-01: false +RI: + 2015-01-01: false +SC: + 2015-01-01: true +SD: + 2015-01-01: false +TN: + 2015-01-01: false +TX: + 2015-01-01: false +UT: + 2015-01-01: false +VA: + 2015-01-01: false +VT: + 2015-01-01: true +WA: + 2015-01-01: false +WI: + 2015-01-01: true +WV: + 2015-01-01: false +WY: + 2015-01-01: false diff --git a/policyengine_us/parameters/gov/hhs/medicaid/eligibility/categories/senior_or_disabled/income/couple_limit_without_deeming.yaml b/policyengine_us/parameters/gov/hhs/medicaid/eligibility/categories/senior_or_disabled/income/couple_limit_without_deeming.yaml new file mode 100644 index 00000000000..a08671a81ea --- /dev/null +++ b/policyengine_us/parameters/gov/hhs/medicaid/eligibility/categories/senior_or_disabled/income/couple_limit_without_deeming.yaml @@ -0,0 +1,114 @@ +description: States test an applicant against the couple standard even when no income is deemed from a spouse who is not aged, blind, or disabled, under the Medicaid pathway for aged, blind, or disabled people, if this is true. +metadata: + unit: bool + period: year + label: Medicaid senior or disabled couple limit applies without deeming + breakdown: + - state_code + reference: + - title: 10-144 C.M.R. ch. 332, Part 7, Section 4.3 (Maine) + href: https://www.law.cornell.edu/regulations/maine/10-144-C-M-R-ch-332-SS-7-4 + - title: 210-RICR-40-05-1, 1.11.2 and 1.11.5 (Rhode Island) + href: https://rules.sos.ri.gov/regulations/part/210-40-05-1 +AK: + 2015-01-01: false +AL: + 2015-01-01: false +AR: + 2015-01-01: false +AZ: + 2015-01-01: false +CA: + 2015-01-01: false +CO: + 2015-01-01: false +CT: + 2015-01-01: false +DC: + 2015-01-01: false +DE: + 2015-01-01: false +FL: + 2015-01-01: false +GA: + 2015-01-01: false +HI: + 2015-01-01: false +IA: + 2015-01-01: false +ID: + 2015-01-01: false +IL: + 2015-01-01: false +IN: + 2015-01-01: false +KS: + 2015-01-01: false +KY: + 2015-01-01: false +LA: + 2015-01-01: false +MA: + 2015-01-01: false +MD: + 2015-01-01: false +ME: + 2015-01-01: true +MI: + 2015-01-01: false +MN: + 2015-01-01: false +MO: + 2015-01-01: false +MS: + 2015-01-01: false +MT: + 2015-01-01: false +NC: + 2015-01-01: false +ND: + 2015-01-01: false +NE: + 2015-01-01: false +NH: + 2015-01-01: false +NJ: + 2015-01-01: false +NM: + 2015-01-01: false +NV: + 2015-01-01: false +NY: + 2015-01-01: false +OH: + 2015-01-01: false +OK: + 2015-01-01: false +OR: + 2015-01-01: false +PA: + 2015-01-01: false +RI: + 2015-01-01: true +SC: + 2015-01-01: false +SD: + 2015-01-01: false +TN: + 2015-01-01: false +TX: + 2015-01-01: false +UT: + 2015-01-01: false +VA: + 2015-01-01: false +VT: + 2015-01-01: false +WA: + 2015-01-01: false +WI: + 2015-01-01: false +WV: + 2015-01-01: false +WY: + 2015-01-01: false diff --git a/policyengine_us/tests/policy/baseline/gov/hhs/medicaid/eligibility/categories/medicaid_optional_senior_or_disabled_uses_couple_standard.yaml b/policyengine_us/tests/policy/baseline/gov/hhs/medicaid/eligibility/categories/medicaid_optional_senior_or_disabled_uses_couple_standard.yaml new file mode 100644 index 00000000000..b2a6aa6b33c --- /dev/null +++ b/policyengine_us/tests/policy/baseline/gov/hhs/medicaid/eligibility/categories/medicaid_optional_senior_or_disabled_uses_couple_standard.yaml @@ -0,0 +1,272 @@ +- name: Case 1, both spouses aged use the couple standard. + period: 2026 + input: + people: + person1: + is_tax_unit_head: true + age: 70 + social_security_retirement: 12000 + person2: + is_tax_unit_spouse: true + age: 68 + social_security_retirement: 6000 + marital_units: + marital_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: PA + output: + medicaid_optional_senior_or_disabled_uses_couple_standard: [true, true] + medicaid_optional_senior_or_disabled_income_limit: [21_640, 21_640] + +# 20 CFR 416.1163(d)(1): with nothing to deem, the applicant is tested alone. West +# Virginia's limit is the SSI rate: 12 x 994 = 11,928 rather than 12 x 1,491 = 17,892. +# Countable income is 14,640 - 240 = 14,400. +- name: Case 2, spouse with no income leaves the applicant tested alone. + period: 2026 + input: + people: + person1: + is_tax_unit_head: true + age: 70 + social_security_retirement: 14640 + person2: + is_tax_unit_spouse: true + age: 50 + marital_units: + marital_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: WV + output: + medicaid_optional_senior_or_disabled_uses_couple_standard: [false, true] + medicaid_optional_senior_or_disabled_income_limit: [11_928, 17_892] + is_optional_senior_or_disabled_income_eligible: [false, true] + +# 416.1163(d)(1): income "not more than" the rate difference, 12 x 497 = 5,964. +- name: Case 3, spouse income at the deeming threshold leaves the applicant tested alone. + period: 2026 + input: + people: + person1: + is_tax_unit_head: true + age: 70 + social_security_retirement: 6000 + person2: + is_tax_unit_spouse: true + age: 50 + taxable_interest_income: 5964 + marital_units: + marital_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: WV + output: + is_ssi_spousal_deeming_applies: [false, false] + medicaid_optional_senior_or_disabled_uses_couple_standard: [false, true] + +# 416.1163(d)(2): income above 5,964 means the two are treated as an eligible couple. +- name: Case 4, spouse income above the deeming threshold uses the couple standard. + period: 2026 + input: + people: + person1: + is_tax_unit_head: true + age: 70 + social_security_retirement: 6000 + person2: + is_tax_unit_spouse: true + age: 50 + taxable_interest_income: 5965 + marital_units: + marital_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: WV + output: + is_ssi_spousal_deeming_applies: [true, false] + medicaid_optional_senior_or_disabled_uses_couple_standard: [true, true] + medicaid_optional_senior_or_disabled_income_limit: [17_892, 17_892] + +- name: Case 5, a poverty-level state uses the one-person guideline when nothing is deemed. + period: 2026 + input: + people: + person1: + is_tax_unit_head: true + age: 70 + social_security_retirement: 6000 + person2: + is_tax_unit_spouse: true + age: 50 + marital_units: + marital_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: PA + output: + medicaid_optional_senior_or_disabled_uses_couple_standard: [false, true] + medicaid_optional_senior_or_disabled_income_limit: [15_960, 21_640] + +# DSS Manual 0805.015.05 has no deeming threshold, so Missouri keeps the couple standard. +- name: Case 6, Missouri budgets a couple together whatever the spouse earns. + period: 2026 + input: + people: + person1: + is_tax_unit_head: true + age: 70 + social_security_retirement: 6000 + person2: + is_tax_unit_spouse: true + age: 50 + marital_units: + marital_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: MO + output: + medicaid_optional_senior_or_disabled_uses_couple_standard: [true, true] + medicaid_optional_senior_or_disabled_income_limit: [18_396, 18_396] + +# 20 CFR 416.414(b)(3): SSI computes each spouse separately. Countable income is +# 14,400 - 240 = 14,160 each, within the one-person guideline of 15,960, and the +# 28,320 together would fail the two-person guideline of 21,640. +- name: Case 7, spouses split by a facility are tested alone on their own income. + period: 2026 + input: + people: + person1: + is_tax_unit_head: true + age: 72 + social_security_retirement: 14400 + ssi_lives_in_medical_treatment_facility: true + ssi_medicaid_pays_majority_of_care: true + person2: + is_tax_unit_spouse: true + age: 70 + social_security_retirement: 14400 + marital_units: + marital_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: NJ + output: + medicaid_optional_senior_or_disabled_uses_couple_standard: [false, false] + medicaid_optional_senior_or_disabled_income_limit: [15_960, 15_960] + is_optional_senior_or_disabled_income_eligible: [true, true] + +# AHCCCS MA611 tests a 70-year-old with a 50-year-old spouse against the couple +# limit: 12 x 1,580 - 240 = 18,720 is within 21,640 and above the one-person 15,960. +- name: Case 8, Arizona budgets a couple together when the spouse has no income. + period: 2026 + input: + people: + person1: + is_tax_unit_head: true + age: 70 + social_security_retirement: 18960 + person2: + is_tax_unit_spouse: true + age: 50 + marital_units: + marital_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: AZ + output: + medicaid_optional_senior_or_disabled_uses_couple_standard: [true, true] + medicaid_optional_senior_or_disabled_income_limit: [21_640, 21_640] + is_optional_senior_or_disabled_income_eligible: [true, true] + + +# 16,800 + 5,400 - 240 = 21,960 is above 21,640. SSI's threshold is 12 x 497 = 5,964. +- name: Case 9, Arizona counts spouse income below SSI's deeming threshold. + period: 2026 + input: + people: + person1: + is_tax_unit_head: true + age: 70 + social_security_retirement: 16800 + person2: + is_tax_unit_spouse: true + age: 50 + taxable_interest_income: 5400 + marital_units: + marital_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: AZ + output: + is_ssi_spousal_deeming_applies: [false, false] + is_optional_senior_or_disabled_income_eligible: [false, false] + + +# 210-RICR-40-05-1 1.11.2: a group of two whether or not the spouse applies. +# 18,000 - 240 = 17,760 is within 21,640 and above the one-person 15,960. +- name: Case 10, Rhode Island keeps the couple limit when nothing is deemed. + period: 2026 + input: + people: + person1: + is_tax_unit_head: true + age: 70 + social_security_retirement: 18000 + person2: + is_tax_unit_spouse: true + age: 50 + marital_units: + marital_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: RI + output: + medicaid_optional_senior_or_disabled_uses_couple_standard: [true, true] + is_optional_senior_or_disabled_income_eligible: [true, true] + + +- name: Case 11, a state that budgets together still splits spouses in a facility. + period: 2026 + input: + people: + person1: + is_tax_unit_head: true + age: 72 + social_security_retirement: 14400 + ssi_lives_in_medical_treatment_facility: true + ssi_medicaid_pays_majority_of_care: true + person2: + is_tax_unit_spouse: true + age: 70 + social_security_retirement: 14400 + marital_units: + marital_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: MI + output: + medicaid_optional_senior_or_disabled_uses_couple_standard: [false, false] + diff --git a/policyengine_us/tests/policy/baseline/gov/hhs/medicaid/eligibility/categories/medically_needy/is_medically_needy_for_medicaid.yaml b/policyengine_us/tests/policy/baseline/gov/hhs/medicaid/eligibility/categories/medically_needy/is_medically_needy_for_medicaid.yaml index a3934f084f7..6f639c6232d 100644 --- a/policyengine_us/tests/policy/baseline/gov/hhs/medicaid/eligibility/categories/medically_needy/is_medically_needy_for_medicaid.yaml +++ b/policyengine_us/tests/policy/baseline/gov/hhs/medicaid/eligibility/categories/medically_needy/is_medically_needy_for_medicaid.yaml @@ -940,3 +940,111 @@ # 2027 still reads the 195,000 couple limit; 31,000 first applies in 2028. is_in_medicaid_medically_needy_category: [true, true] is_medically_needy_for_medicaid: [true, true] + +# New York's limit is $1,836 for one person and $2,489 for two. Countable income is +# 28,000 - 240 = 27,760. After 5,000 of expenses, 22,760 is above 12 x 1,836 = 22,032 +# and within 12 x 2,489 = 29,868. +- name: Case 37, applicant with an ineligible spouse and nothing deemed uses the individual limit. + period: 2026 + input: + people: + person1: + is_tax_unit_head: true + age: 70 + social_security_retirement: 28000 + other_medical_expenses: 5000 + takes_up_medicare_if_eligible: false + person2: + is_tax_unit_spouse: true + age: 50 + marital_units: + marital_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: NY + output: + medicaid_medically_needy_income_limit: [22_032, 29_868] + is_medically_needy_for_medicaid: [false, false] + + +# 42 CFR 435.831(d) deducts the expenses of a financially responsible relative: +# 27,760 - 5,000 - 1,000 = 21,760, within 22,032. +- name: Case 38, the expenses of a spouse whose income is not counted still reduce income. + period: 2026 + input: + people: + person1: + is_tax_unit_head: true + age: 70 + social_security_retirement: 28000 + other_medical_expenses: 5000 + takes_up_medicare_if_eligible: false + person2: + is_tax_unit_spouse: true + age: 50 + other_medical_expenses: 1000 + marital_units: + marital_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: NY + output: + is_medically_needy_for_medicaid: [true, false] + +# 130 CMR 520.002(A)(1). Applicant: 20,000 - 240 = 19,760. Spouse: (4,800 - 780) / 2 = 2,010. +# 21,770 - 14,000 = 7,770 is within 12 x 650 = 7,800. +- name: Case 39, Massachusetts counts spouse wages below SSI's deeming threshold. + period: 2026 + input: + people: + person1: + is_tax_unit_head: true + age: 70 + social_security_retirement: 20000 + other_medical_expenses: 14000 + takes_up_medicare_if_eligible: false + person2: + is_tax_unit_spouse: true + age: 50 + employment_income: 4800 + marital_units: + marital_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: MA + output: + is_ssi_spousal_deeming_applies: [false, false] + medicaid_medically_needy_income_from_spouse: [2_010, 0] + is_medically_needy_for_medicaid: [true, false] + + +# 21,770 - 13,000 = 8,770 is above 7,800. +- name: Case 40, Massachusetts applicant stays above the couple limit with less in expenses. + period: 2026 + input: + people: + person1: + is_tax_unit_head: true + age: 70 + social_security_retirement: 20000 + other_medical_expenses: 13000 + takes_up_medicare_if_eligible: false + person2: + is_tax_unit_spouse: true + age: 50 + employment_income: 4800 + marital_units: + marital_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: MA + output: + is_medically_needy_for_medicaid: [false, false] diff --git a/policyengine_us/tests/policy/baseline/gov/hhs/medicaid/eligibility/categories/medically_needy/medicaid_medically_needy_uses_couple_standard.yaml b/policyengine_us/tests/policy/baseline/gov/hhs/medicaid/eligibility/categories/medically_needy/medicaid_medically_needy_uses_couple_standard.yaml new file mode 100644 index 00000000000..e64129ac087 --- /dev/null +++ b/policyengine_us/tests/policy/baseline/gov/hhs/medicaid/eligibility/categories/medically_needy/medicaid_medically_needy_uses_couple_standard.yaml @@ -0,0 +1,113 @@ +# 12 x 1,836 = 22,032 for one and 12 x 2,489 = 29,868 for two. +- name: Case 1, New York follows SSI's rule, so a spouse with no income leaves the applicant alone. + period: 2026 + input: + people: + person1: + is_tax_unit_head: true + age: 70 + person2: + is_tax_unit_spouse: true + age: 50 + marital_units: + marital_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: NY + output: + medicaid_medically_needy_uses_couple_standard: [false, true] + medicaid_medically_needy_income_limit: [22_032, 29_868] + + +# 12 x 650 = 7,800 for two. +- name: Case 2, Massachusetts budgets a couple together. + period: 2026 + input: + people: + person1: + is_tax_unit_head: true + age: 70 + person2: + is_tax_unit_spouse: true + age: 50 + marital_units: + marital_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: MA + output: + medicaid_medically_needy_uses_couple_standard: [true, true] + medicaid_medically_needy_income_limit: [7_800, 7_800] + + +# 12 x 1,242 = 14,904 for two. +- name: Case 3, Rhode Island keeps the couple limit when nothing is deemed. + period: 2026 + input: + people: + person1: + is_tax_unit_head: true + age: 70 + person2: + is_tax_unit_spouse: true + age: 50 + marital_units: + marital_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: RI + output: + medicaid_medically_needy_uses_couple_standard: [true, true] + medicaid_medically_needy_income_limit: [14_904, 14_904] + + +# N.J.A.C. 10:70-3.5(c)2: 12 x 434 = 5,208 for two. +- name: Case 4, New Jersey keeps the couple limit when nothing is deemed. + period: 2026 + input: + people: + person1: + is_tax_unit_head: true + age: 70 + person2: + is_tax_unit_spouse: true + age: 50 + marital_units: + marital_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: NJ + output: + medicaid_medically_needy_uses_couple_standard: [true, true] + medicaid_medically_needy_income_limit: [5_208, 5_208] + + +- name: Case 5, both spouses aged use the couple limit under SSI's rule. + period: 2026 + input: + people: + person1: + is_tax_unit_head: true + age: 70 + person2: + is_tax_unit_spouse: true + age: 68 + marital_units: + marital_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: NY + output: + medicaid_medically_needy_uses_couple_standard: [true, true] + medicaid_medically_needy_income_limit: [29_868, 29_868] + diff --git a/policyengine_us/variables/gov/hhs/medicaid/eligibility/categories/is_209b_ssi_recipient_income_eligible_for_medicaid.py b/policyengine_us/variables/gov/hhs/medicaid/eligibility/categories/is_209b_ssi_recipient_income_eligible_for_medicaid.py index da396f055d4..f1ef862c72c 100644 --- a/policyengine_us/variables/gov/hhs/medicaid/eligibility/categories/is_209b_ssi_recipient_income_eligible_for_medicaid.py +++ b/policyengine_us/variables/gov/hhs/medicaid/eligibility/categories/is_209b_ssi_recipient_income_eligible_for_medicaid.py @@ -1,4 +1,7 @@ from policyengine_us.model_api import * +from policyengine_us.variables.gov.hhs.medicaid.income._couple_standard import ( + spouses_split_by_facility, +) class is_209b_ssi_recipient_income_eligible_for_medicaid(Variable): @@ -28,9 +31,19 @@ def formula(person, period, parameters): medical_expenses = person("medicaid_medically_needy_medical_expenses", period) # SSI financial responsibility rules (42 CFR 435.602): the unit is # the individual or the married couple, not the tax filing unit. - income_after_spenddown = person.marital_unit.sum( - personal_income - medical_expenses + # 42 CFR 435.831(d) also deducts a spouse's expenses when the spouse's + # income is not counted. + income = where( + person("medicaid_optional_senior_or_disabled_uses_couple_standard", period), + person.marital_unit.sum(personal_income), + personal_income, ) + expenses = where( + spouses_split_by_facility(person, period), + medical_expenses, + person.marital_unit.sum(medical_expenses), + ) + income_after_spenddown = income - expenses # The limit is per person (Missouri's blind standard can differ # within a couple) while the income is the couple's combined total. diff --git a/policyengine_us/variables/gov/hhs/medicaid/eligibility/categories/is_optional_senior_or_disabled_income_eligible.py b/policyengine_us/variables/gov/hhs/medicaid/eligibility/categories/is_optional_senior_or_disabled_income_eligible.py index ba67aa1fcef..6a1f346579f 100644 --- a/policyengine_us/variables/gov/hhs/medicaid/eligibility/categories/is_optional_senior_or_disabled_income_eligible.py +++ b/policyengine_us/variables/gov/hhs/medicaid/eligibility/categories/is_optional_senior_or_disabled_income_eligible.py @@ -30,7 +30,11 @@ def formula(person, period, parameters): ) # SSI financial responsibility rules (42 CFR 435.602): the unit is # the individual or the married couple, not the tax filing unit. - income = person.marital_unit.sum(personal_income) + income = where( + person("medicaid_optional_senior_or_disabled_uses_couple_standard", period), + person.marital_unit.sum(personal_income), + personal_income, + ) income_limit = person( "medicaid_optional_senior_or_disabled_income_limit", period ) diff --git a/policyengine_us/variables/gov/hhs/medicaid/eligibility/categories/medicaid_optional_senior_or_disabled_income_limit.py b/policyengine_us/variables/gov/hhs/medicaid/eligibility/categories/medicaid_optional_senior_or_disabled_income_limit.py index 00e6a33ef0a..409195fda4d 100644 --- a/policyengine_us/variables/gov/hhs/medicaid/eligibility/categories/medicaid_optional_senior_or_disabled_income_limit.py +++ b/policyengine_us/variables/gov/hhs/medicaid/eligibility/categories/medicaid_optional_senior_or_disabled_income_limit.py @@ -31,7 +31,9 @@ def formula(person, period, parameters): # Non-MAGI Medicaid follows the SSI financial responsibility rules # (42 CFR 435.602): the unit is the individual, or the married # couple living together, whatever their filing status. - is_couple = person.marital_unit.nb_persons() == 2 + is_couple = person( + "medicaid_optional_senior_or_disabled_uses_couple_standard", period + ) state = person.household("state_code_str", period) p = parameters( period diff --git a/policyengine_us/variables/gov/hhs/medicaid/eligibility/categories/medicaid_optional_senior_or_disabled_uses_couple_standard.py b/policyengine_us/variables/gov/hhs/medicaid/eligibility/categories/medicaid_optional_senior_or_disabled_uses_couple_standard.py new file mode 100644 index 00000000000..8cb841f8628 --- /dev/null +++ b/policyengine_us/variables/gov/hhs/medicaid/eligibility/categories/medicaid_optional_senior_or_disabled_uses_couple_standard.py @@ -0,0 +1,37 @@ +from policyengine_us.model_api import * +from policyengine_us.variables.gov.hhs.medicaid.income._couple_standard import ( + uses_couple_standard, +) + + +class medicaid_optional_senior_or_disabled_uses_couple_standard(Variable): + value_type = bool + entity = Person + label = "Uses the couple standard in Medicaid's aged, blind and disabled pathway" + documentation = ( + "Whether a married person is tested as a couple, on combined income " + "against the couple standard. SSI's rule applies by default (42 CFR " + "435.601(b)): an applicant with an ineligible spouse is tested alone " + "unless the spouse's income is deemed (20 CFR 416.1163(d)). The state " + "parameters budgets_couple_together and couple_limit_without_deeming " + "record the states whose own rules differ." + ) + definition_period = YEAR + reference = ( + "https://www.law.cornell.edu/cfr/text/42/435.601", + "https://www.law.cornell.edu/cfr/text/42/435.602", + "https://www.law.cornell.edu/cfr/text/20/416.1163", + "https://www.law.cornell.edu/cfr/text/20/416.414", + ) + + def formula(person, period, parameters): + state = person.household("state_code_str", period) + p = parameters( + period + ).gov.hhs.medicaid.eligibility.categories.senior_or_disabled.income + return uses_couple_standard( + person, + period, + p.budgets_couple_together[state].astype(bool), + p.couple_limit_without_deeming[state].astype(bool), + ) diff --git a/policyengine_us/variables/gov/hhs/medicaid/eligibility/categories/medically_needy/is_medically_needy_for_medicaid.py b/policyengine_us/variables/gov/hhs/medicaid/eligibility/categories/medically_needy/is_medically_needy_for_medicaid.py index 633c16213f9..f7a0e8035fc 100644 --- a/policyengine_us/variables/gov/hhs/medicaid/eligibility/categories/medically_needy/is_medically_needy_for_medicaid.py +++ b/policyengine_us/variables/gov/hhs/medicaid/eligibility/categories/medically_needy/is_medically_needy_for_medicaid.py @@ -1,4 +1,7 @@ from policyengine_us.model_api import * +from policyengine_us.variables.gov.hhs.medicaid.income._couple_standard import ( + spouses_split_by_facility, +) class is_medically_needy_for_medicaid(Variable): @@ -54,8 +57,27 @@ def formula(person, period, parameters): parental_expense_share = where( eligible_child, parental_expenses / max_(eligible_children, 1), 0 ) - income = marital_unit.sum( - personal_income - medical_expenses - parental_expense_share + uses_couple_standard = person( + "medicaid_medically_needy_uses_couple_standard", period + ) + # 42 CFR 435.831(d) also deducts a spouse's expenses when the spouse's + # income is not counted, unless a facility splits the couple. + expenses = where( + spouses_split_by_facility(person, period), + medical_expenses, + marital_unit.sum(medical_expenses), + ) + unit_income = personal_income + person( + "medicaid_medically_needy_income_from_spouse", period + ) + income = ( + where(uses_couple_standard, marital_unit.sum(unit_income), unit_income) + - expenses + - where( + uses_couple_standard, + marital_unit.sum(parental_expense_share), + parental_expense_share, + ) ) assets = marital_unit.sum(personal_assets) ma = parameters(period).gov.hhs.medicaid diff --git a/policyengine_us/variables/gov/hhs/medicaid/eligibility/categories/medically_needy/medicaid_medically_needy_income_from_spouse.py b/policyengine_us/variables/gov/hhs/medicaid/eligibility/categories/medically_needy/medicaid_medically_needy_income_from_spouse.py new file mode 100644 index 00000000000..6cae65f02d4 --- /dev/null +++ b/policyengine_us/variables/gov/hhs/medicaid/eligibility/categories/medically_needy/medicaid_medically_needy_income_from_spouse.py @@ -0,0 +1,45 @@ +from policyengine_us.model_api import * +from policyengine_us.variables.gov.ssa.ssi.eligibility.income._apply_ssi_exclusions import ( + _apply_ssi_exclusions, +) + + +class medicaid_medically_needy_income_from_spouse(Variable): + value_type = float + entity = Person + label = "Spouse income counted by a state that budgets a couple together" + unit = USD + documentation = ( + "Countable income added for an ineligible spouse in a state that budgets " + "a couple together, when SSI deeming has not already counted it." + ) + definition_period = YEAR + reference = "https://www.law.cornell.edu/cfr/text/42/435.602" + + def formula(person, period, parameters): + state = person.household("state_code_str", period) + p = parameters( + period + ).gov.hhs.medicaid.eligibility.categories.medically_needy.limit.income + budgets_together = p.budgets_couple_together[state].astype(bool) + marital_unit = person.marital_unit + ineligible_spouse = person("is_ssi_ineligible_spouse", period) + earned = person("ssi_earned_income", period) + unearned = person("ssi_unearned_income", period) + spouse_earned = ( + marital_unit.sum(ineligible_spouse * earned) - ineligible_spouse * earned + ) + spouse_unearned = ( + marital_unit.sum(ineligible_spouse * unearned) + - ineligible_spouse * unearned + ) + alone = _apply_ssi_exclusions(earned, unearned, parameters, period) + combined = _apply_ssi_exclusions( + earned + spouse_earned, unearned + spouse_unearned, parameters, period + ) + applies = ( + budgets_together + & person("is_ssi_aged_blind_disabled", period) + & ~person("is_ssi_spousal_deeming_applies", period) + ) + return where(applies, max_(combined - alone, 0), 0) diff --git a/policyengine_us/variables/gov/hhs/medicaid/eligibility/categories/medically_needy/medicaid_medically_needy_income_limit.py b/policyengine_us/variables/gov/hhs/medicaid/eligibility/categories/medically_needy/medicaid_medically_needy_income_limit.py index dd644e12c12..cf77db702d5 100644 --- a/policyengine_us/variables/gov/hhs/medicaid/eligibility/categories/medically_needy/medicaid_medically_needy_income_limit.py +++ b/policyengine_us/variables/gov/hhs/medicaid/eligibility/categories/medically_needy/medicaid_medically_needy_income_limit.py @@ -20,7 +20,7 @@ def formula(person, period, parameters): state = person.household("state_code_str", period) # SSI financial responsibility rules (42 CFR 435.602): the unit is # the individual or the married couple, not the tax filing unit. - is_couple = person.marital_unit.nb_persons() == 2 + is_couple = person("medicaid_medically_needy_uses_couple_standard", period) # Some states apply the one-person limit to a couple. same_limit = p.couple_uses_individual_limit[state].astype(bool) uses_couple_limit = is_couple & ~same_limit diff --git a/policyengine_us/variables/gov/hhs/medicaid/eligibility/categories/medically_needy/medicaid_medically_needy_uses_couple_standard.py b/policyengine_us/variables/gov/hhs/medicaid/eligibility/categories/medically_needy/medicaid_medically_needy_uses_couple_standard.py new file mode 100644 index 00000000000..e0e3798c63b --- /dev/null +++ b/policyengine_us/variables/gov/hhs/medicaid/eligibility/categories/medically_needy/medicaid_medically_needy_uses_couple_standard.py @@ -0,0 +1,36 @@ +from policyengine_us.model_api import * +from policyengine_us.variables.gov.hhs.medicaid.income._couple_standard import ( + uses_couple_standard, +) + + +class medicaid_medically_needy_uses_couple_standard(Variable): + value_type = bool + entity = Person + label = "Uses the couple limit in Medicaid's medically needy program" + documentation = ( + "Whether a married person is tested as a couple, on combined income " + "against the couple limit. SSI's rule applies by default (42 CFR " + "435.601(b)): an applicant with an ineligible spouse is tested alone " + "unless the spouse's income is deemed (20 CFR 416.1163(d)). The state " + "parameters budgets_couple_together and couple_limit_without_deeming " + "record the states whose own rules differ." + ) + definition_period = YEAR + reference = ( + "https://www.law.cornell.edu/cfr/text/42/435.601", + "https://www.law.cornell.edu/cfr/text/42/435.602", + "https://www.law.cornell.edu/cfr/text/20/416.1163", + ) + + def formula(person, period, parameters): + state = person.household("state_code_str", period) + p = parameters( + period + ).gov.hhs.medicaid.eligibility.categories.medically_needy.limit.income + return uses_couple_standard( + person, + period, + p.budgets_couple_together[state].astype(bool), + p.couple_limit_without_deeming[state].astype(bool), + ) diff --git a/policyengine_us/variables/gov/hhs/medicaid/income/_couple_standard.py b/policyengine_us/variables/gov/hhs/medicaid/income/_couple_standard.py new file mode 100644 index 00000000000..e192225be47 --- /dev/null +++ b/policyengine_us/variables/gov/hhs/medicaid/income/_couple_standard.py @@ -0,0 +1,35 @@ +from policyengine_us.model_api import * + + +def spouses_split_by_facility(person: Population, period: Period) -> ArrayLike: + # 20 CFR 416.414(b)(3): SSI computes each spouse separately when a facility + # splits a couple who are both aged, blind or disabled. + return person("ssi_claim_is_joint", period) & ~person( + "ssi_couple_computation_applies", period.first_month + ) + + +def uses_couple_standard( + person: Population, + period: Period, + budgets_together: ArrayLike, + couple_limit_without_deeming: ArrayLike, +) -> ArrayLike: + # Under SSI's rule an applicant with an ineligible spouse is tested alone + # unless the spouse's income is deemed (20 CFR 416.1163(d)). States may + # instead budget the couple together, or keep the couple standard without + # deeming. A person with no aged, blind or disabled status has no test of + # their own, so stays with the couple. + marital_unit = person.marital_unit + is_married = marital_unit.nb_persons() == 2 + aged_blind_disabled = person("is_ssi_aged_blind_disabled", period) + has_ineligible_spouse = ( + aged_blind_disabled & is_married & (marital_unit.sum(aged_blind_disabled) == 1) + ) + nothing_deemed = ~person("is_ssi_spousal_deeming_applies", period) + tested_alone = has_ineligible_spouse & nothing_deemed + return ( + is_married + & ~spouses_split_by_facility(person, period) + & (budgets_together | couple_limit_without_deeming | ~tested_alone) + ) diff --git a/policyengine_us/variables/gov/hhs/medicaid/income/deemed/from_ineligible_spouse/medicaid_optional_senior_or_disabled_income_deemed_from_ineligible_spouse.py b/policyengine_us/variables/gov/hhs/medicaid/income/deemed/from_ineligible_spouse/medicaid_optional_senior_or_disabled_income_deemed_from_ineligible_spouse.py index b2230f74783..34fb9634b26 100644 --- a/policyengine_us/variables/gov/hhs/medicaid/income/deemed/from_ineligible_spouse/medicaid_optional_senior_or_disabled_income_deemed_from_ineligible_spouse.py +++ b/policyengine_us/variables/gov/hhs/medicaid/income/deemed/from_ineligible_spouse/medicaid_optional_senior_or_disabled_income_deemed_from_ineligible_spouse.py @@ -34,11 +34,18 @@ def formula(person, period, parameters): ).gov.hhs.medicaid.eligibility.categories.senior_or_disabled.income.disregard state = person.household("state_code_str", period) - # Missouri MHABD considers the gross income of a married couple - # living together (DSS Manual § 0805.015.05) rather than the SSI - # deeming methodology: the spouse's income counts without the - # FBR-differential threshold or ineligible-child allocations. - is_mo = state == "MO" + # Some states budget a married couple living together rather than + # following the SSI deeming methodology. Missouri MHABD considers the + # couple's gross income (DSS Manual § 0805.015.05): the spouse's income + # counts without the FBR-differential threshold or ineligible-child + # allocations. + budgets_together = ( + parameters(period) + .gov.hhs.medicaid.eligibility.categories.senior_or_disabled.income.budgets_couple_together[ + state + ] + .astype(bool) + ) marital_unit = person.marital_unit ineligible_spouse = person("is_ssi_ineligible_spouse", period) spouse_gross_earned = ( @@ -49,10 +56,12 @@ def formula(person, period, parameters): marital_unit.sum(ineligible_spouse * individual_unearned) - ineligible_spouse * individual_unearned ) - spouse_earned = where(is_mo, spouse_gross_earned, spouse_earned) - spouse_unearned = where(is_mo, spouse_gross_unearned, spouse_unearned) + spouse_earned = where(budgets_together, spouse_gross_earned, spouse_earned) + spouse_unearned = where( + budgets_together, spouse_gross_unearned, spouse_unearned + ) has_ineligible_spouse = marital_unit.sum(ineligible_spouse) > 0 - deeming_applies = deeming_applies | (is_mo & has_ineligible_spouse) + deeming_applies = deeming_applies | (budgets_together & has_ineligible_spouse) alone_countable = _apply_medicaid_optional_senior_or_disabled_exclusions( individual_earned, diff --git a/source_conflicts/candidates.yaml b/source_conflicts/candidates.yaml index 025bb5dd42b..050862d07c5 100644 --- a/source_conflicts/candidates.yaml +++ b/source_conflicts/candidates.yaml @@ -1459,6 +1459,24 @@ candidates: note: 'PE-US follows the statute: the 2026 allowance is $1,153.31, from a $3,252.14 couple standard, twice the $1,626.07 individual rate (allowance/out_of_home_care.yaml), and the file''s comment lists the sources on each side. Verify the per-recipient calculation and document the inconsistent 2026 summary tables.' +- id: us-co:abd-spouse-income-ssi-defined-group + program: medicaid + years: + from: 2026 + to: 2026 + type: program + note: program year as the program defines it + question: "Does Colorado's SSI-related group count a non-applying spouse's income in every case, as its income rule says, or follow SSI's deeming threshold, because the group is defined by SSI eligibility?" + sources: + - kind: regulation + citation: 10 CCR 2505-10 8.100.7.C.2 + url: https://www.law.cornell.edu/regulations/colorado/10-CCR-2505-10-8.100_v2 + pe_us: + follows: statute + code: + - policyengine_us/variables/gov/hhs/medicaid/income/_couple_standard.py + state: ruled + note: "Counts both spouses' income under the express rule. Ruled by the project lead, 2026-11-02." - id: us-co:claim-of-right-subtraction-practice program: income-tax years: @@ -1656,6 +1674,27 @@ candidates: state: ruled note: 'Ruled in October 2026 to follow the statute; verify the applicable regulation version. Code not yet on main: co premium assistance formula, aca_ptc_slcsp.' +- id: us-ct:abd-spouse-income-hearing-decision + program: medicaid + years: + from: 2026 + to: 2026 + type: program + note: program year as the program defines it + question: "Does Connecticut count a spouse's income as its Uniform Policy Manual says, or apply SSI's rule, as a 2023 hearing decision on a Medicare Savings Program case did?" + sources: + - kind: manual + citation: UPM 5020.75 and 5515.05 + url: https://portal.ct.gov/-/media/Departments-and-Agencies/DSS/UPMs/UPM5---Treatment-of-Income-Income-Eligibility/5020_75.doc + - kind: agency-practice + citation: DSS hearing decision, Request 203652 + url: https://portal.ct.gov/-/media/departments-and-agencies/dss/fair-hearings/other-medicaid-eligibility/other-medicaid-eligibility-2023/omel_2023_203652.pdf#page=6 + pe_us: + follows: gap-fill + code: + - policyengine_us/variables/gov/hhs/medicaid/income/_couple_standard.py + state: ruled + note: "Follows the manual: Connecticut is a 209(b) state. Ruled by the project lead, 2026-11-02." - id: us-dc:eitc-no-tin-child-schedule-before-2023 program: income-tax years: @@ -3513,6 +3552,24 @@ candidates: prs: [] state: unreviewed note: PE-US follows the regulation from October 1, 2023; verify contemporaneous source versions. +- id: us-ma:abd-couple-income-standard + program: medicaid + years: + from: 2026 + to: 2026 + type: program + note: program year as the program defines it + question: "Does Massachusetts test a couple's income against the couple standard? 130 CMR 520.002(A)(1) says 'an income standard', and only 520.003(A)(2) names the couple limit, for assets." + sources: + - kind: regulation + citation: 130 CMR 520.002(A)(1), 520.003(A)(2), 519.005(A)(1) + url: https://www.law.cornell.edu/regulations/massachusetts/130-CMR-519-005 + pe_us: + follows: gap-fill + code: + - policyengine_us/variables/gov/hhs/medicaid/income/_couple_standard.py + state: ruled + note: "Uses the couple standard for income. Ruled by the project lead, 2026-11-02." - id: us-ma:circuit-breaker-snap-income program: income-tax years: @@ -4017,6 +4074,27 @@ candidates: note: 'PE-US follows COMAR: strike_benefits count, assumed not employee-funded, and the documentation records that manual Attachment B excludes funds without employee contributions (income/sources/unearned.yaml, md_meap_countable_income.py). Verify the conflicting manual provision and applicable versions.' +- id: us-md:medically-needy-non-abd-spouse-unit + program: medicaid + years: + from: 2026 + to: 2026 + type: program + note: program year as the program defines it + question: "Is a Maryland medically needy applicant with a spouse who is not aged, blind or disabled a unit of two, as the manual says, when COMAR 10.09.24.06 names only an aged, blind or disabled spouse as a unit member?" + sources: + - kind: regulation + citation: COMAR 10.09.24.06 + url: https://www.law.cornell.edu/regulations/maryland/COMAR-10-09-24-06 + - kind: manual + citation: Medical Assistance Manual Section 600 + url: https://health.maryland.gov/mmcp/Medicaid%20Manual/Section%20600-%20The%20Assistance%20Unit.pdf#page=8 + pe_us: + follows: gap-fill + code: + - policyengine_us/variables/gov/hhs/medicaid/income/_couple_standard.py + state: ruled + note: "Uses a unit of two: COMAR counts the income and does not name the standard. Ruled by the project lead, 2026-11-02." - id: us-md:pension-exclusion-maximum program: income-tax years: @@ -5086,6 +5164,27 @@ candidates: state: unreviewed note: PE-US follows the manual from October 1, 2025; verify the checklist's meaning and the manual's administrative-code status. +- id: us-mt:abd-spouse-deeming-threshold + program: medicaid + years: + from: 2026 + to: 2026 + type: program + note: program year as the program defines it + question: "Does Montana apply SSI's deeming threshold, as ARM 37.82.903(2) and 37.82.1107(1)(b) adopt, or consider both spouses' income, as manual CMA 603-1 says?" + sources: + - kind: regulation + citation: ARM 37.82.903(2) + url: https://www.law.cornell.edu/regulations/montana/Mont-Admin-r-37.82.903 + - kind: manual + citation: CMA 603-1 + url: https://dphhs.mt.gov/assets/hcsd/fmamanual/cma603.1.pdf#page=2 + pe_us: + follows: statute + code: + - policyengine_us/variables/gov/hhs/medicaid/income/_couple_standard.py + state: ruled + note: "Follows the regulation. Ruled by the project lead, 2026-11-02." - id: us-mt:elderly-credit-homestead-costs program: income-tax years: @@ -5825,6 +5924,24 @@ candidates: prs: [] state: unreviewed note: Verify whether the still-listed ruling applies during these years despite its obsolete tax base. +- id: us-ne:medically-needy-unit-size + program: medicaid + years: + from: 2026 + to: 2026 + type: program + note: program year as the program defines it + question: "Does Nebraska's medically needy program size the unit under 477 NAC 24, counting both spouses, or follow the general SSI methodology clause in 477 NAC 25-002.03(B)?" + sources: + - kind: regulation + citation: 477 NAC 25-002 + url: https://www.law.cornell.edu/regulations/nebraska/477-Neb-Admin-Code-ch-25-SS-002 + pe_us: + follows: gap-fill + code: + - policyengine_us/variables/gov/hhs/medicaid/income/_couple_standard.py + state: ruled + note: "Follows the specific unit-size rule. Ruled by the project lead, 2026-11-02." - id: us-nh:fanf-resource-limit-equality program: tanf years: From d76697c0fcf300e1729082dc41fb02b4c00346e4 Mon Sep 17 00:00:00 2001 From: Ziming Date: Mon, 2 Nov 2026 18:30:12 -0500 Subject: [PATCH 2/4] Cite the project lead's rulings in the source-conflict candidates Co-Authored-By: Claude Opus 5.5 --- source_conflicts/candidates.yaml | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/source_conflicts/candidates.yaml b/source_conflicts/candidates.yaml index c71b49489fb..46e0fd7d7ee 100644 --- a/source_conflicts/candidates.yaml +++ b/source_conflicts/candidates.yaml @@ -1476,7 +1476,7 @@ candidates: code: - policyengine_us/variables/gov/hhs/medicaid/income/_couple_standard.py state: ruled - note: "Counts both spouses' income under the express rule. Ruled by the project lead, 2026-11-02." + note: "Counts both spouses' income under the express rule. Ruled by the project lead, 2026-11-02: https://github.com/PolicyEngine/policyengine-us/pull/10640#issuecomment-6591157776" - id: us-co:claim-of-right-subtraction-practice program: income-tax years: @@ -1694,7 +1694,7 @@ candidates: code: - policyengine_us/variables/gov/hhs/medicaid/income/_couple_standard.py state: ruled - note: "Follows the manual: Connecticut is a 209(b) state. Ruled by the project lead, 2026-11-02." + note: "Follows the manual: Connecticut is a 209(b) state. Ruled by the project lead, 2026-11-02: https://github.com/PolicyEngine/policyengine-us/pull/10640#issuecomment-6591157776" - id: us-dc:eitc-no-tin-child-schedule-before-2023 program: income-tax years: @@ -3569,7 +3569,7 @@ candidates: code: - policyengine_us/variables/gov/hhs/medicaid/income/_couple_standard.py state: ruled - note: "Uses the couple standard for income. Ruled by the project lead, 2026-11-02." + note: "Uses the couple standard for income. Ruled by the project lead, 2026-11-02: https://github.com/PolicyEngine/policyengine-us/pull/10640#issuecomment-6591157776" - id: us-ma:circuit-breaker-snap-income program: income-tax years: @@ -4094,7 +4094,7 @@ candidates: code: - policyengine_us/variables/gov/hhs/medicaid/income/_couple_standard.py state: ruled - note: "Uses a unit of two: COMAR counts the income and does not name the standard. Ruled by the project lead, 2026-11-02." + note: "Uses a unit of two: COMAR counts the income and does not name the standard. Ruled by the project lead, 2026-11-02: https://github.com/PolicyEngine/policyengine-us/pull/10640#issuecomment-6591157776" - id: us-md:pension-exclusion-maximum program: income-tax years: @@ -5184,7 +5184,7 @@ candidates: code: - policyengine_us/variables/gov/hhs/medicaid/income/_couple_standard.py state: ruled - note: "Follows the regulation. Ruled by the project lead, 2026-11-02." + note: "Follows the regulation. Ruled by the project lead, 2026-11-02: https://github.com/PolicyEngine/policyengine-us/pull/10640#issuecomment-6591157776" - id: us-mt:elderly-credit-homestead-costs program: income-tax years: @@ -5941,7 +5941,7 @@ candidates: code: - policyengine_us/variables/gov/hhs/medicaid/income/_couple_standard.py state: ruled - note: "Follows the specific unit-size rule. Ruled by the project lead, 2026-11-02." + note: "Follows the specific unit-size rule. Ruled by the project lead, 2026-11-02: https://github.com/PolicyEngine/policyengine-us/pull/10640#issuecomment-6591157776" - id: us-nh:fanf-resource-limit-equality program: tanf years: From ca5bd31d4b0af5dc5ab0782d4658f185167f8073 Mon Sep 17 00:00:00 2001 From: Ziming Date: Mon, 2 Nov 2026 22:18:35 -0500 Subject: [PATCH 3/4] Fix facility splits and budget-together income in the couple standard Give CO, MA and NE candidates a second source, which clears the failing CI check. A couple split by a facility counts no spouse income (42 USC 1396r-5), read at the same instant as the income it gates. Medically needy budget-together uses one method at every income. Hawaii budgets a couple together. Co-Authored-By: Claude Opus 5.5 --- ...id-couple-limit-ineligible-spouse.fixed.md | 2 +- .../limit/income/budgets_couple_together.yaml | 4 +- .../income/budgets_couple_together.yaml | 6 +- ...ecipient_income_eligible_for_medicaid.yaml | 93 +++++ .../categories/medicaid_category.yaml | 71 ++++ ...nior_or_disabled_uses_couple_standard.yaml | 175 ++++++++- .../is_medically_needy_for_medicaid.yaml | 351 +++++++++++++++++- ..._income_deemed_from_ineligible_spouse.yaml | 32 ++ ..._recipient_income_eligible_for_medicaid.py | 5 +- ...senior_or_disabled_uses_couple_standard.py | 4 +- ...caid_medically_needy_income_from_spouse.py | 36 +- ...id_medically_needy_uses_couple_standard.py | 5 +- .../hhs/medicaid/income/_couple_standard.py | 23 +- ...ed_income_deemed_from_ineligible_spouse.py | 10 +- source_conflicts/candidates.yaml | 36 +- 15 files changed, 802 insertions(+), 51 deletions(-) diff --git a/changelog.d/medicaid-couple-limit-ineligible-spouse.fixed.md b/changelog.d/medicaid-couple-limit-ineligible-spouse.fixed.md index 635d0df6d20..2136eb78be9 100644 --- a/changelog.d/medicaid-couple-limit-ineligible-spouse.fixed.md +++ b/changelog.d/medicaid-couple-limit-ineligible-spouse.fixed.md @@ -1 +1 @@ -Apply each state's own rule for a Medicaid applicant whose spouse is not aged, blind or disabled, in the aged, blind and disabled pathway, the 209(b) route and medically needy: SSI's deeming rule by default, or budgeting the couple together, or keeping the couple limit without deeming. Test spouses split by a facility separately. +Apply each state's own rule for a Medicaid applicant whose spouse is not aged, blind or disabled, in the aged, blind and disabled pathway, the 209(b) route and medically needy: SSI's deeming rule by default, or budgeting the couple together, or keeping the couple limit without deeming. Test spouses split by a facility separately, with no spouse income counted. diff --git a/policyengine_us/parameters/gov/hhs/medicaid/eligibility/categories/medically_needy/limit/income/budgets_couple_together.yaml b/policyengine_us/parameters/gov/hhs/medicaid/eligibility/categories/medically_needy/limit/income/budgets_couple_together.yaml index 7c535369b74..5425acacc54 100644 --- a/policyengine_us/parameters/gov/hhs/medicaid/eligibility/categories/medically_needy/limit/income/budgets_couple_together.yaml +++ b/policyengine_us/parameters/gov/hhs/medicaid/eligibility/categories/medically_needy/limit/income/budgets_couple_together.yaml @@ -14,6 +14,8 @@ metadata: href: https://www.law.cornell.edu/regulations/california/22-CCR-50373 - title: Connecticut Uniform Policy Manual 5020.75 href: https://portal.ct.gov/-/media/Departments-and-Agencies/DSS/UPMs/UPM5---Treatment-of-Income-Income-Eligibility/5020_75.doc + - title: HAR 17-1724.1-16(1) (Hawaii) + href: https://humanservices.hawaii.gov/wp-content/uploads/2016/12/HAR-17-1724.1-INCOME-FOR-MAGI-EXCEPTED-Final-10-31-16-1.pdf#page=5 - title: Illinois Policy Manual PM 15-06-02-c href: https://www.dhs.state.il.us/page.aspx?item=16512 - title: Kansas MKEESM 4312 @@ -59,7 +61,7 @@ FL: GA: 2015-01-01: false HI: - 2015-01-01: false + 2015-01-01: true IA: 2015-01-01: false ID: diff --git a/policyengine_us/parameters/gov/hhs/medicaid/eligibility/categories/senior_or_disabled/income/budgets_couple_together.yaml b/policyengine_us/parameters/gov/hhs/medicaid/eligibility/categories/senior_or_disabled/income/budgets_couple_together.yaml index 9e59399366b..8ef35c603c2 100644 --- a/policyengine_us/parameters/gov/hhs/medicaid/eligibility/categories/senior_or_disabled/income/budgets_couple_together.yaml +++ b/policyengine_us/parameters/gov/hhs/medicaid/eligibility/categories/senior_or_disabled/income/budgets_couple_together.yaml @@ -22,6 +22,8 @@ metadata: href: https://portal.ct.gov/-/media/Departments-and-Agencies/DSS/UPMs/UPM5---Treatment-of-Income-Income-Eligibility/5020_75.doc - title: Connecticut Uniform Policy Manual 5515.05 href: https://portal.ct.gov/-/media/Departments-and-Agencies/DSS/UPMs/UPM5---Treatment-of-Income-Income-Eligibility/5515_05.doc + - title: HAR 17-1724.1-16(1) (Hawaii) + href: https://humanservices.hawaii.gov/wp-content/uploads/2016/12/HAR-17-1724.1-INCOME-FOR-MAGI-EXCEPTED-Final-10-31-16-1.pdf#page=5 - title: Illinois Policy Manual PM 15-06-02-c href: https://www.dhs.state.il.us/page.aspx?item=16512 - title: 405 IAC 2-3-4 (Indiana) @@ -75,9 +77,11 @@ FL: GA: 2015-01-01: false HI: - 2015-01-01: false + 2015-01-01: true IA: 2015-01-01: false +# IDAPA 16.03.05 sections 761-766 allow a community property method in some cases; +# the model has no input for separate or community income. ID: 2015-01-01: false IL: diff --git a/policyengine_us/tests/policy/baseline/gov/hhs/medicaid/eligibility/categories/is_209b_ssi_recipient_income_eligible_for_medicaid.yaml b/policyengine_us/tests/policy/baseline/gov/hhs/medicaid/eligibility/categories/is_209b_ssi_recipient_income_eligible_for_medicaid.yaml index 82e395efa81..ff0049f0d52 100644 --- a/policyengine_us/tests/policy/baseline/gov/hhs/medicaid/eligibility/categories/is_209b_ssi_recipient_income_eligible_for_medicaid.yaml +++ b/policyengine_us/tests/policy/baseline/gov/hhs/medicaid/eligibility/categories/is_209b_ssi_recipient_income_eligible_for_medicaid.yaml @@ -195,3 +195,96 @@ # (1,491 + 1) x 12 = 17,904; combined income 17,040. medicaid_optional_senior_or_disabled_income_limit: [17_904, 17_904] is_209b_ssi_recipient_income_eligible_for_medicaid: [true, true] + +# 20 CFR 416.1163(d)(1): with nothing to deem, the applicant is tested alone. Virginia's +# limit is 80% of the one-person guideline: 0.8 x 15,960 = 12,768, and 9,600 - 240 = +# 9,360 is within it. 9,360 is also below 12 x 994 = 11,928, so the applicant receives SSI. +- name: Case 11, Virginia SSI recipient with a spouse who has no income is tested alone. + period: 2026 + absolute_error_margin: 0.01 + input: + people: + person1: + is_tax_unit_head: true + age: 70 + social_security_retirement: 9_600 + person2: + is_tax_unit_spouse: true + age: 50 + marital_units: + marital_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: VA + output: + medicaid_optional_senior_or_disabled_uses_couple_standard: [false, true] + medicaid_optional_senior_or_disabled_income_limit: [12_768, 17_312] + is_209b_ssi_recipient_income_eligible_for_medicaid: [true, true] + is_209b_ssi_recipient_for_medicaid: [true, false] + medicaid_category: [SSI_RECIPIENT, ADULT] + +# N.D. Admin. Code 75-02-02.1-34 budgets the couple together: 10,000 + 5,000 - 240 = +# 14,760 against 12 x 1,491 = 17,892. SSI tests the applicant alone, since 5,000 is +# within its 5,964 threshold: 10,000 - 240 = 9,760 is below 11,928, so SSI pays. +- name: Case 12, North Dakota SSI recipient is budgeted together with a spouse below SSI's threshold. + period: 2026 + absolute_error_margin: 0.01 + input: + people: + person1: + is_tax_unit_head: true + age: 70 + social_security_retirement: 10_000 + person2: + is_tax_unit_spouse: true + age: 50 + taxable_interest_income: 5_000 + marital_units: + marital_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: ND + output: + medicaid_optional_senior_or_disabled_uses_couple_standard: [true, true] + medicaid_optional_senior_or_disabled_income_limit: [17_892, 17_892] + medicaid_optional_senior_or_disabled_income_deemed_from_ineligible_spouse: [5_000, 0] + medicaid_optional_senior_or_disabled_countable_income: [14_760, 0] + is_209b_ssi_recipient_income_eligible_for_medicaid: [true, true] + is_209b_ssi_recipient_for_medicaid: [true, false] + medicaid_category: [SSI_RECIPIENT, ADULT] + +# 20 CFR 416.414(b)(3): SSI computes each spouse on their own income. Hawaii's limit is +# then the one-person 18,360, not the two-person 24,890. person1 has no income, and +# person2's 9,600 - 240 = 9,360 is within the limit and below 11,928, so both receive SSI. +- name: Case 13, Hawaii SSI recipients split by a facility are each tested alone. + period: 2026 + absolute_error_margin: 0.01 + input: + people: + person1: + is_tax_unit_head: true + age: 72 + ssi_lives_in_medical_treatment_facility: true + ssi_medicaid_pays_majority_of_care: true + person2: + is_tax_unit_spouse: true + age: 70 + social_security_retirement: 9_600 + marital_units: + marital_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: HI + output: + medicaid_optional_senior_or_disabled_uses_couple_standard: [false, false] + medicaid_optional_senior_or_disabled_income_limit: [18_360, 18_360] + medicaid_optional_senior_or_disabled_countable_income: [0, 9_360] + is_209b_ssi_recipient_income_eligible_for_medicaid: [true, true] + is_209b_ssi_recipient_for_medicaid: [true, true] + medicaid_category: [SSI_RECIPIENT, SSI_RECIPIENT] diff --git a/policyengine_us/tests/policy/baseline/gov/hhs/medicaid/eligibility/categories/medicaid_category.yaml b/policyengine_us/tests/policy/baseline/gov/hhs/medicaid/eligibility/categories/medicaid_category.yaml index 23338548149..02e95d276b7 100644 --- a/policyengine_us/tests/policy/baseline/gov/hhs/medicaid/eligibility/categories/medicaid_category.yaml +++ b/policyengine_us/tests/policy/baseline/gov/hhs/medicaid/eligibility/categories/medicaid_category.yaml @@ -193,3 +193,74 @@ is_medically_needy_for_medicaid: true medicaid_category: MEDICALLY_NEEDY is_medicaid_eligible: true + +# 20 CFR 416.1163(d)(1): with nothing to deem, the applicant is tested alone. +# 17,040 - 240 = 16,800 is above West Virginia's 12 x 994 = 11,928. +- name: Case 15, West Virginia senior with a spouse who has no income is above the one-person limit. + period: 2026 + input: + people: + person1: + is_tax_unit_head: true + age: 70 + social_security_retirement: 17_040 + person2: + is_tax_unit_spouse: true + age: 50 + marital_units: + marital_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: WV + output: + medicaid_category: [NONE, ADULT] + is_medicaid_eligible: [false, true] + +# AHCCCS MA611 tests the couple: 16,800 is within 21,640 and above the one-person 15,960. +- name: Case 16, Arizona senior with a spouse who has no income is within the couple limit. + period: 2026 + input: + people: + person1: + is_tax_unit_head: true + age: 70 + social_security_retirement: 17_040 + person2: + is_tax_unit_spouse: true + age: 50 + marital_units: + marital_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: AZ + output: + medicaid_category: [SENIOR_OR_DISABLED, ADULT] + is_medicaid_eligible: [true, true] + +# 210-RICR-40-05-1 1.11.2: a group of two whether or not the spouse applies. +# 16,800 is within 21,640 and above the one-person 15,960. +- name: Case 17, Rhode Island senior with a spouse who has no income is within the couple limit. + period: 2026 + input: + people: + person1: + is_tax_unit_head: true + age: 70 + social_security_retirement: 17_040 + person2: + is_tax_unit_spouse: true + age: 50 + marital_units: + marital_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: RI + output: + medicaid_category: [SENIOR_OR_DISABLED, ADULT] + is_medicaid_eligible: [true, true] diff --git a/policyengine_us/tests/policy/baseline/gov/hhs/medicaid/eligibility/categories/medicaid_optional_senior_or_disabled_uses_couple_standard.yaml b/policyengine_us/tests/policy/baseline/gov/hhs/medicaid/eligibility/categories/medicaid_optional_senior_or_disabled_uses_couple_standard.yaml index b2a6aa6b33c..18288f6bf2b 100644 --- a/policyengine_us/tests/policy/baseline/gov/hhs/medicaid/eligibility/categories/medicaid_optional_senior_or_disabled_uses_couple_standard.yaml +++ b/policyengine_us/tests/policy/baseline/gov/hhs/medicaid/eligibility/categories/medicaid_optional_senior_or_disabled_uses_couple_standard.yaml @@ -5,11 +5,11 @@ person1: is_tax_unit_head: true age: 70 - social_security_retirement: 12000 + social_security_retirement: 12_000 person2: is_tax_unit_spouse: true age: 68 - social_security_retirement: 6000 + social_security_retirement: 6_000 marital_units: marital_unit: members: [person1, person2] @@ -31,7 +31,7 @@ person1: is_tax_unit_head: true age: 70 - social_security_retirement: 14640 + social_security_retirement: 14_640 person2: is_tax_unit_spouse: true age: 50 @@ -55,11 +55,11 @@ person1: is_tax_unit_head: true age: 70 - social_security_retirement: 6000 + social_security_retirement: 6_000 person2: is_tax_unit_spouse: true age: 50 - taxable_interest_income: 5964 + taxable_interest_income: 5_964 marital_units: marital_unit: members: [person1, person2] @@ -79,11 +79,11 @@ person1: is_tax_unit_head: true age: 70 - social_security_retirement: 6000 + social_security_retirement: 6_000 person2: is_tax_unit_spouse: true age: 50 - taxable_interest_income: 5965 + taxable_interest_income: 5_965 marital_units: marital_unit: members: [person1, person2] @@ -103,7 +103,7 @@ person1: is_tax_unit_head: true age: 70 - social_security_retirement: 6000 + social_security_retirement: 6_000 person2: is_tax_unit_spouse: true age: 50 @@ -126,7 +126,7 @@ person1: is_tax_unit_head: true age: 70 - social_security_retirement: 6000 + social_security_retirement: 6_000 person2: is_tax_unit_spouse: true age: 50 @@ -151,13 +151,13 @@ person1: is_tax_unit_head: true age: 72 - social_security_retirement: 14400 + social_security_retirement: 14_400 ssi_lives_in_medical_treatment_facility: true ssi_medicaid_pays_majority_of_care: true person2: is_tax_unit_spouse: true age: 70 - social_security_retirement: 14400 + social_security_retirement: 14_400 marital_units: marital_unit: members: [person1, person2] @@ -179,7 +179,7 @@ person1: is_tax_unit_head: true age: 70 - social_security_retirement: 18960 + social_security_retirement: 18_960 person2: is_tax_unit_spouse: true age: 50 @@ -204,11 +204,11 @@ person1: is_tax_unit_head: true age: 70 - social_security_retirement: 16800 + social_security_retirement: 16_800 person2: is_tax_unit_spouse: true age: 50 - taxable_interest_income: 5400 + taxable_interest_income: 5_400 marital_units: marital_unit: members: [person1, person2] @@ -230,7 +230,7 @@ person1: is_tax_unit_head: true age: 70 - social_security_retirement: 18000 + social_security_retirement: 18_000 person2: is_tax_unit_spouse: true age: 50 @@ -253,13 +253,13 @@ person1: is_tax_unit_head: true age: 72 - social_security_retirement: 14400 + social_security_retirement: 14_400 ssi_lives_in_medical_treatment_facility: true ssi_medicaid_pays_majority_of_care: true person2: is_tax_unit_spouse: true age: 70 - social_security_retirement: 14400 + social_security_retirement: 14_400 marital_units: marital_unit: members: [person1, person2] @@ -270,3 +270,144 @@ output: medicaid_optional_senior_or_disabled_uses_couple_standard: [false, false] +# A year reads this month-defined status in December, when the couple is home, so +# income and limit agree: 8,000 + 22,000 - 240 = 29,760, or 14,880 each, is above +# 21,640. Tested alone for the stay (20 CFR 416.414(b)(3)), person2's 21,760 is also +# above 15,960, so person2 is not eligible in any month. +- name: Case 12, a facility stay that ends within the year tests the couple on its December status. + period: 2026 + absolute_error_margin: 0.01 + input: + people: + person1: + is_tax_unit_head: true + age: 72 + social_security_retirement: 8_000 + ssi_lives_in_medical_treatment_facility: + 2026-01: true + 2026-02: true + 2026-03: true + 2026-04: true + 2026-05: true + 2026-06: true + 2026-07: false + 2026-08: false + 2026-09: false + 2026-10: false + 2026-11: false + 2026-12: false + ssi_medicaid_pays_majority_of_care: true + person2: + is_tax_unit_spouse: true + age: 70 + social_security_retirement: 22_000 + marital_units: + marital_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: NJ + output: + ssi_couple_computation_applies: + 2026-01: [false, false] + 2026-12: [true, true] + medicaid_optional_senior_or_disabled_uses_couple_standard: [true, true] + medicaid_optional_senior_or_disabled_income_limit: [21_640, 21_640] + medicaid_optional_senior_or_disabled_countable_income: [14_880, 14_880] + is_optional_senior_or_disabled_income_eligible: [false, false] + is_medicaid_eligible: [false, false] + medicaid_category: [NONE, NONE] + +# 42 USC 1396r-5(b)(1): "no income of the community spouse shall be deemed available +# to the institutionalized spouse". 15,000 - 240 = 14,760, without the spouse's 5,400, +# against the one-person 15,960. +- name: Case 13, a facility resident with a spouse who is not aged, blind or disabled is tested alone. + period: 2026 + absolute_error_margin: 0.01 + input: + people: + person1: + is_tax_unit_head: true + age: 72 + social_security_retirement: 15_000 + ssi_lives_in_medical_treatment_facility: true + ssi_medicaid_pays_majority_of_care: true + person2: + is_tax_unit_spouse: true + age: 60 + taxable_interest_income: 5_400 + marital_units: + marital_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: AZ + output: + medicaid_optional_senior_or_disabled_uses_couple_standard: [false, false] + medicaid_optional_senior_or_disabled_income_limit: [15_960, 15_960] + medicaid_optional_senior_or_disabled_income_deemed_from_ineligible_spouse: [0, 0] + medicaid_optional_senior_or_disabled_countable_income: [14_760, 0] + is_optional_senior_or_disabled_income_eligible: [true, true] + medicaid_category: [SENIOR_OR_DISABLED, ADULT] + +# HAR 17-1724.1-16(1) makes the income of spouses in the same residence available to +# each other, and HAR 17-1719-11.1(a)(3) sets the limit at the poverty level for a +# household of the applicable size. 21,000 - 240 = 20,760 is within 24,890 for two and +# above 18,360 for one. +- name: Case 14, Hawaii budgets a couple together when the spouse has no income. + period: 2026 + absolute_error_margin: 0.01 + input: + people: + person1: + is_tax_unit_head: true + age: 70 + social_security_retirement: 21_000 + person2: + is_tax_unit_spouse: true + age: 50 + marital_units: + marital_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: HI + output: + medicaid_optional_senior_or_disabled_uses_couple_standard: [true, true] + medicaid_optional_senior_or_disabled_income_limit: [24_890, 24_890] + medicaid_optional_senior_or_disabled_countable_income: [20_760, 0] + is_optional_senior_or_disabled_income_eligible: [true, true] + medicaid_category: [SENIOR_OR_DISABLED, ADULT] + +# HAR 17-1724.1-16(1) has no deeming threshold, so interest below SSI's 12 x 497 = +# 5,964 still counts: 12,000 + 5,000 - 240 = 16,760. SSI tests the applicant alone: +# 12,000 - 240 = 11,760 is below 12 x 994 = 11,928, so the applicant receives SSI. +- name: Case 15, Hawaii counts spouse income below SSI's deeming threshold. + period: 2026 + absolute_error_margin: 0.01 + input: + people: + person1: + is_tax_unit_head: true + age: 70 + social_security_retirement: 12_000 + person2: + is_tax_unit_spouse: true + age: 50 + taxable_interest_income: 5_000 + marital_units: + marital_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: HI + output: + is_ssi_spousal_deeming_applies: [false, false] + medicaid_optional_senior_or_disabled_income_deemed_from_ineligible_spouse: [5_000, 0] + medicaid_optional_senior_or_disabled_countable_income: [16_760, 0] + is_optional_senior_or_disabled_income_eligible: [true, true] + medicaid_category: [SSI_RECIPIENT, ADULT] diff --git a/policyengine_us/tests/policy/baseline/gov/hhs/medicaid/eligibility/categories/medically_needy/is_medically_needy_for_medicaid.yaml b/policyengine_us/tests/policy/baseline/gov/hhs/medicaid/eligibility/categories/medically_needy/is_medically_needy_for_medicaid.yaml index 6f639c6232d..ba7df9047b4 100644 --- a/policyengine_us/tests/policy/baseline/gov/hhs/medicaid/eligibility/categories/medically_needy/is_medically_needy_for_medicaid.yaml +++ b/policyengine_us/tests/policy/baseline/gov/hhs/medicaid/eligibility/categories/medically_needy/is_medically_needy_for_medicaid.yaml @@ -951,8 +951,8 @@ person1: is_tax_unit_head: true age: 70 - social_security_retirement: 28000 - other_medical_expenses: 5000 + social_security_retirement: 28_000 + other_medical_expenses: 5_000 takes_up_medicare_if_eligible: false person2: is_tax_unit_spouse: true @@ -978,13 +978,13 @@ person1: is_tax_unit_head: true age: 70 - social_security_retirement: 28000 - other_medical_expenses: 5000 + social_security_retirement: 28_000 + other_medical_expenses: 5_000 takes_up_medicare_if_eligible: false person2: is_tax_unit_spouse: true age: 50 - other_medical_expenses: 1000 + other_medical_expenses: 1_000 marital_units: marital_unit: members: [person1, person2] @@ -1004,13 +1004,13 @@ person1: is_tax_unit_head: true age: 70 - social_security_retirement: 20000 - other_medical_expenses: 14000 + social_security_retirement: 20_000 + other_medical_expenses: 14_000 takes_up_medicare_if_eligible: false person2: is_tax_unit_spouse: true age: 50 - employment_income: 4800 + employment_income: 4_800 marital_units: marital_unit: members: [person1, person2] @@ -1032,13 +1032,13 @@ person1: is_tax_unit_head: true age: 70 - social_security_retirement: 20000 - other_medical_expenses: 13000 + social_security_retirement: 20_000 + other_medical_expenses: 13_000 takes_up_medicare_if_eligible: false person2: is_tax_unit_spouse: true age: 50 - employment_income: 4800 + employment_income: 4_800 marital_units: marital_unit: members: [person1, person2] @@ -1048,3 +1048,332 @@ state_code: MA output: is_medically_needy_for_medicaid: [false, false] + +# A year reads this month-defined status in December, when the couple is home: +# 8,000 + 34,000 - 240 = 41,760, or 20,880 each, is above 12 x 2,489 = 29,868. Tested +# alone for the stay, person2's 33,760 is also above 12 x 1,836 = 22,032. +- name: Case 41, a facility stay that ends within the year tests the couple on its December status. + period: 2026 + absolute_error_margin: 0.01 + input: + people: + person1: + is_tax_unit_head: true + age: 72 + social_security_retirement: 8_000 + takes_up_medicare_if_eligible: false + ssi_lives_in_medical_treatment_facility: + 2026-01: true + 2026-02: true + 2026-03: true + 2026-04: true + 2026-05: true + 2026-06: true + 2026-07: false + 2026-08: false + 2026-09: false + 2026-10: false + 2026-11: false + 2026-12: false + ssi_medicaid_pays_majority_of_care: true + person2: + is_tax_unit_spouse: true + age: 70 + social_security_retirement: 34_000 + takes_up_medicare_if_eligible: false + marital_units: + marital_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: NY + output: + ssi_couple_computation_applies: + 2026-01: [false, false] + 2026-12: [true, true] + medicaid_medically_needy_uses_couple_standard: [true, true] + medicaid_medically_needy_income_limit: [29_868, 29_868] + ssi_countable_income: [20_880, 20_880] + is_medically_needy_for_medicaid: [false, false] + medicaid_category: [NONE, NONE] + +# 130 CMR 520.002(A)(1) compares the spouses' total countable income to the standard. +# SSI allocates 12 x 497 = 5,964 to the child, and 11,900 - 5,964 = 5,936 is within +# SSI's 5,964 threshold, so nothing is deemed. The spouse counts (11,900 - 780) / 2 = +# 5,560: 40,000 - 240 + 5,560 - 35,000 = 10,320, above 12 x 650 = 7,800. +- name: Case 42, Massachusetts counts spouse wages with no child allocation below SSI's threshold. + period: 2026 + absolute_error_margin: 0.01 + input: + people: + person1: + is_tax_unit_head: true + age: 70 + social_security_retirement: 40_000 + other_medical_expenses: 35_000 + takes_up_medicare_if_eligible: false + person2: + is_tax_unit_spouse: true + age: 50 + employment_income_before_lsr: 11_900 + takes_up_medicare_if_eligible: false + person3: + is_tax_unit_dependent: true + age: 10 + marital_units: + marital_unit: + members: [person1, person2] + child_marital_unit: + members: [person3] + households: + household: + members: [person1, person2, person3] + state_code: MA + output: + is_ssi_spousal_deeming_applies: [false, false, false] + ssi_countable_income: [39_760, 0, 0] + medicaid_medically_needy_income_from_spouse: [5_560, 0, 0] + medicaid_medically_needy_income_limit: [7_800, 7_800, 6_264] + is_medically_needy_for_medicaid: [false, false, false] + medicaid_category: [NONE, NONE, NONE] + +# 12,100 - 5,964 = 6,136 is above 5,964, so SSI deems (6,136 - 780) / 2 = 2,678 and +# countable income is 39,760 + 2,678 = 42,438. Budgeted together the spouse counts +# (12,100 - 780) / 2 = 5,660, so the adjustment is 5,660 - 2,678 = 2,982: +# 42,438 + 2,982 - 35,000 = 10,420, above 7,800. Counted income does not fall when +# wages cross SSI's threshold. +- name: Case 43, Massachusetts counts spouse wages with no child allocation above SSI's threshold. + period: 2026 + absolute_error_margin: 0.01 + input: + people: + person1: + is_tax_unit_head: true + age: 70 + social_security_retirement: 40_000 + other_medical_expenses: 35_000 + takes_up_medicare_if_eligible: false + person2: + is_tax_unit_spouse: true + age: 50 + employment_income_before_lsr: 12_100 + takes_up_medicare_if_eligible: false + person3: + is_tax_unit_dependent: true + age: 10 + marital_units: + marital_unit: + members: [person1, person2] + child_marital_unit: + members: [person3] + households: + household: + members: [person1, person2, person3] + state_code: MA + output: + is_ssi_spousal_deeming_applies: [true, false, false] + ssi_countable_income: [42_438, 0, 0] + medicaid_medically_needy_income_from_spouse: [2_982, 0, 0] + medicaid_medically_needy_income_limit: [7_800, 7_800, 6_264] + is_medically_needy_for_medicaid: [false, false, false] + medicaid_category: [NONE, NONE, NONE] + +# MKEESM 4312 considers the total income of both spouses living together. SSI allocates +# 2 x 5,964 = 11,928 to the children, and 17,000 - 11,928 = 5,072 is within 5,964, so +# nothing is deemed. The spouse counts (17,000 - 780) / 2 = 8,110: +# 20,000 - 240 + 8,110 - 6,000 = 21,870, above 12 x 1,491 = 17,892. +- name: Case 44, Kansas counts spouse wages with no child allocation below SSI's threshold. + period: 2026 + absolute_error_margin: 0.01 + input: + people: + person1: + is_tax_unit_head: true + age: 45 + is_blind: true + social_security_disability: 20_000 + other_medical_expenses: 6_000 + takes_up_medicare_if_eligible: false + person2: + is_tax_unit_spouse: true + age: 44 + employment_income_before_lsr: 17_000 + takes_up_medicare_if_eligible: false + person3: + is_tax_unit_dependent: true + age: 8 + person4: + is_tax_unit_dependent: true + age: 10 + marital_units: + marital_unit: + members: [person1, person2] + child1_marital_unit: + members: [person3] + child2_marital_unit: + members: [person4] + households: + household: + members: [person1, person2, person3, person4] + state_code: KS + output: + is_ssi_spousal_deeming_applies: [false, false, false, false] + ssi_countable_income: [19_760, 0, 0, 0] + medicaid_medically_needy_income_from_spouse: [8_110, 0, 0, 0] + medicaid_medically_needy_income_limit: [17_892, 17_892, 11_928, 11_928] + is_medically_needy_for_medicaid: [false, false, false, false] + medicaid_category: [NONE, NONE, OLDER_CHILD, OLDER_CHILD] + +# 18,000 - 11,928 = 6,072 is above 5,964, so SSI deems (6,072 - 780) / 2 = 2,646 and +# countable income is 19,760 + 2,646 = 22,406. Budgeted together the spouse counts +# (18,000 - 780) / 2 = 8,610, so the adjustment is 8,610 - 2,646 = 5,964: +# 22,406 + 5,964 - 6,000 = 22,370, above 17,892. +- name: Case 45, Kansas counts spouse wages with no child allocation above SSI's threshold. + period: 2026 + absolute_error_margin: 0.01 + input: + people: + person1: + is_tax_unit_head: true + age: 45 + is_blind: true + social_security_disability: 20_000 + other_medical_expenses: 6_000 + takes_up_medicare_if_eligible: false + person2: + is_tax_unit_spouse: true + age: 44 + employment_income_before_lsr: 18_000 + takes_up_medicare_if_eligible: false + person3: + is_tax_unit_dependent: true + age: 8 + person4: + is_tax_unit_dependent: true + age: 10 + marital_units: + marital_unit: + members: [person1, person2] + child1_marital_unit: + members: [person3] + child2_marital_unit: + members: [person4] + households: + household: + members: [person1, person2, person3, person4] + state_code: KS + output: + is_ssi_spousal_deeming_applies: [true, false, false, false] + ssi_countable_income: [22_406, 0, 0, 0] + medicaid_medically_needy_income_from_spouse: [5_964, 0, 0, 0] + medicaid_medically_needy_income_limit: [17_892, 17_892, 11_928, 11_928] + is_medically_needy_for_medicaid: [false, false, false, false] + medicaid_category: [NONE, NONE, OLDER_CHILD, OLDER_CHILD] + +# 130 CMR 520.002(B)(2)(a): "the community spouse's income is not counted in the +# determination of eligibility for the institutionalized spouse". The spouse's 5,900 +# is below SSI's 5,964 and stays out: 20,000 - 240 - 14,000 = 5,760, within the +# one-person 12 x 522 = 6,264. +- name: Case 46, a facility resident with a spouse who is not aged, blind or disabled is tested alone. + period: 2026 + absolute_error_margin: 0.01 + input: + people: + person1: + is_tax_unit_head: true + age: 72 + social_security_retirement: 20_000 + other_medical_expenses: 14_000 + takes_up_medicare_if_eligible: false + ssi_lives_in_medical_treatment_facility: true + ssi_medicaid_pays_majority_of_care: true + person2: + is_tax_unit_spouse: true + age: 50 + employment_income_before_lsr: 5_900 + takes_up_medicare_if_eligible: false + marital_units: + marital_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: MA + output: + is_ssi_spousal_deeming_applies: [false, false] + medicaid_medically_needy_uses_couple_standard: [false, false] + medicaid_medically_needy_income_limit: [6_264, 6_264] + medicaid_medically_needy_income_from_spouse: [0, 0] + is_medically_needy_for_medicaid: [true, false] + medicaid_category: [MEDICALLY_NEEDY, ADULT] + +# SSI deems (20,000 - 780) / 2 = 9,610 and the adjustment removes it, so the result +# matches Case 46: 19,760 + 9,610 - 9,610 - 14,000 = 5,760, within 6,264. +- name: Case 47, a facility resident has no spouse income counted above SSI's threshold. + period: 2026 + absolute_error_margin: 0.01 + input: + people: + person1: + is_tax_unit_head: true + age: 72 + social_security_retirement: 20_000 + other_medical_expenses: 14_000 + takes_up_medicare_if_eligible: false + ssi_lives_in_medical_treatment_facility: true + ssi_medicaid_pays_majority_of_care: true + person2: + is_tax_unit_spouse: true + age: 50 + employment_income_before_lsr: 20_000 + takes_up_medicare_if_eligible: false + marital_units: + marital_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: MA + output: + is_ssi_spousal_deeming_applies: [true, false] + medicaid_medically_needy_uses_couple_standard: [false, false] + medicaid_medically_needy_income_limit: [6_264, 6_264] + medicaid_medically_needy_income_from_spouse: [-9_610, 0] + is_medically_needy_for_medicaid: [true, false] + medicaid_category: [MEDICALLY_NEEDY, NONE] + +# Each spouse deducts only their own expenses. person1: 23,000 - 240 - 100 = 22,660 is +# above 12 x 1,836 = 22,032, though the spouse's 8,000 would bring it within. +# person2: 30,000 - 240 - 8,000 = 21,760 is within 22,032. +- name: Case 48, spouses split by a facility each deduct only their own medical expenses. + period: 2026 + absolute_error_margin: 0.01 + input: + people: + person1: + is_tax_unit_head: true + age: 72 + social_security_retirement: 23_000 + other_medical_expenses: 100 + takes_up_medicare_if_eligible: false + ssi_lives_in_medical_treatment_facility: true + ssi_medicaid_pays_majority_of_care: true + person2: + is_tax_unit_spouse: true + age: 70 + social_security_retirement: 30_000 + other_medical_expenses: 8_000 + takes_up_medicare_if_eligible: false + marital_units: + marital_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: NY + output: + medicaid_medically_needy_uses_couple_standard: [false, false] + medicaid_medically_needy_income_limit: [22_032, 22_032] + is_medically_needy_for_medicaid: [false, true] + medicaid_category: [NONE, MEDICALLY_NEEDY] diff --git a/policyengine_us/tests/policy/baseline/gov/hhs/medicaid/income/deemed/from_ineligible_spouse/medicaid_optional_senior_or_disabled_income_deemed_from_ineligible_spouse.yaml b/policyengine_us/tests/policy/baseline/gov/hhs/medicaid/income/deemed/from_ineligible_spouse/medicaid_optional_senior_or_disabled_income_deemed_from_ineligible_spouse.yaml index 42218c4dfd6..c1528f9f0e1 100644 --- a/policyengine_us/tests/policy/baseline/gov/hhs/medicaid/income/deemed/from_ineligible_spouse/medicaid_optional_senior_or_disabled_income_deemed_from_ineligible_spouse.yaml +++ b/policyengine_us/tests/policy/baseline/gov/hhs/medicaid/income/deemed/from_ineligible_spouse/medicaid_optional_senior_or_disabled_income_deemed_from_ineligible_spouse.yaml @@ -153,3 +153,35 @@ # Couple: (500 - 20) x 12 + (40,000 - 65 x 12) / 2 = 25,370. # Alone: (500 - 20) x 12 = 5,760. Deemed: 25,370 - 5,760 = 19,610. medicaid_optional_senior_or_disabled_income_deemed_from_ineligible_spouse: [19_610, 0] + +# 42 USC 1396r-5(b)(1): "no income of the community spouse shall be deemed available to +# the institutionalized spouse". The spouse's 8,000 is above SSI's 12 x 497 = 5,964 and +# stays out: 15,000 - 240 = 14,760, against the one-person 15,960. +- name: Case 6, a facility resident has no spouse income deemed above SSI's threshold. + period: 2026 + absolute_error_margin: 0.01 + input: + people: + person1: + is_tax_unit_head: true + age: 72 + social_security_retirement: 15_000 + ssi_lives_in_medical_treatment_facility: true + ssi_medicaid_pays_majority_of_care: true + person2: + is_tax_unit_spouse: true + age: 60 + taxable_interest_income: 8_000 + marital_units: + marital_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: AZ + output: + is_ssi_spousal_deeming_applies: [true, false] + medicaid_optional_senior_or_disabled_income_deemed_from_ineligible_spouse: [0, 0] + medicaid_optional_senior_or_disabled_countable_income: [14_760, 0] + medicaid_optional_senior_or_disabled_income_limit: [15_960, 15_960] + medicaid_category: [SENIOR_OR_DISABLED, ADULT] diff --git a/policyengine_us/variables/gov/hhs/medicaid/eligibility/categories/is_209b_ssi_recipient_income_eligible_for_medicaid.py b/policyengine_us/variables/gov/hhs/medicaid/eligibility/categories/is_209b_ssi_recipient_income_eligible_for_medicaid.py index f1ef862c72c..1fe2fccb7fb 100644 --- a/policyengine_us/variables/gov/hhs/medicaid/eligibility/categories/is_209b_ssi_recipient_income_eligible_for_medicaid.py +++ b/policyengine_us/variables/gov/hhs/medicaid/eligibility/categories/is_209b_ssi_recipient_income_eligible_for_medicaid.py @@ -32,7 +32,7 @@ def formula(person, period, parameters): # SSI financial responsibility rules (42 CFR 435.602): the unit is # the individual or the married couple, not the tax filing unit. # 42 CFR 435.831(d) also deducts a spouse's expenses when the spouse's - # income is not counted. + # income is not counted, unless a facility splits the couple. income = where( person("medicaid_optional_senior_or_disabled_uses_couple_standard", period), person.marital_unit.sum(personal_income), @@ -46,7 +46,8 @@ def formula(person, period, parameters): income_after_spenddown = income - expenses # The limit is per person (Missouri's blind standard can differ - # within a couple) while the income is the couple's combined total. + # within a couple). The income is the couple's combined total only + # under the couple standard. income_limit = person( "medicaid_optional_senior_or_disabled_income_limit", period ) diff --git a/policyengine_us/variables/gov/hhs/medicaid/eligibility/categories/medicaid_optional_senior_or_disabled_uses_couple_standard.py b/policyengine_us/variables/gov/hhs/medicaid/eligibility/categories/medicaid_optional_senior_or_disabled_uses_couple_standard.py index 8cb841f8628..5d84c69ce41 100644 --- a/policyengine_us/variables/gov/hhs/medicaid/eligibility/categories/medicaid_optional_senior_or_disabled_uses_couple_standard.py +++ b/policyengine_us/variables/gov/hhs/medicaid/eligibility/categories/medicaid_optional_senior_or_disabled_uses_couple_standard.py @@ -14,7 +14,8 @@ class medicaid_optional_senior_or_disabled_uses_couple_standard(Variable): "435.601(b)): an applicant with an ineligible spouse is tested alone " "unless the spouse's income is deemed (20 CFR 416.1163(d)). The state " "parameters budgets_couple_together and couple_limit_without_deeming " - "record the states whose own rules differ." + "record the states whose own rules differ. Spouses split by a facility " + "are each tested alone." ) definition_period = YEAR reference = ( @@ -22,6 +23,7 @@ class medicaid_optional_senior_or_disabled_uses_couple_standard(Variable): "https://www.law.cornell.edu/cfr/text/42/435.602", "https://www.law.cornell.edu/cfr/text/20/416.1163", "https://www.law.cornell.edu/cfr/text/20/416.414", + "https://www.law.cornell.edu/uscode/text/42/1396r-5", ) def formula(person, period, parameters): diff --git a/policyengine_us/variables/gov/hhs/medicaid/eligibility/categories/medically_needy/medicaid_medically_needy_income_from_spouse.py b/policyengine_us/variables/gov/hhs/medicaid/eligibility/categories/medically_needy/medicaid_medically_needy_income_from_spouse.py index 6cae65f02d4..fde8d6e3612 100644 --- a/policyengine_us/variables/gov/hhs/medicaid/eligibility/categories/medically_needy/medicaid_medically_needy_income_from_spouse.py +++ b/policyengine_us/variables/gov/hhs/medicaid/eligibility/categories/medically_needy/medicaid_medically_needy_income_from_spouse.py @@ -1,4 +1,7 @@ from policyengine_us.model_api import * +from policyengine_us.variables.gov.hhs.medicaid.income._couple_standard import ( + spouses_split_by_facility, +) from policyengine_us.variables.gov.ssa.ssi.eligibility.income._apply_ssi_exclusions import ( _apply_ssi_exclusions, ) @@ -7,14 +10,25 @@ class medicaid_medically_needy_income_from_spouse(Variable): value_type = float entity = Person - label = "Spouse income counted by a state that budgets a couple together" + label = ( + "Adjustment to SSI countable income for a spouse's income in Medicaid's " + "medically needy program" + ) unit = USD documentation = ( - "Countable income added for an ineligible spouse in a state that budgets " - "a couple together, when SSI deeming has not already counted it." + "Amount added to ssi_countable_income so that the medically needy test " + "counts a spouse's income by the state's method. A state that budgets a " + "couple together counts the spouse's income with no deeming threshold or " + "ineligible-child allocation, in place of SSI's deemed amount. A couple " + "split by a facility counts no spouse income, so the amount removes SSI's " + "deemed amount and can be negative. It is zero otherwise." ) definition_period = YEAR - reference = "https://www.law.cornell.edu/cfr/text/42/435.602" + reference = ( + "https://www.law.cornell.edu/cfr/text/42/435.602", + "https://www.law.cornell.edu/cfr/text/20/416.1163", + "https://www.law.cornell.edu/uscode/text/42/1396r-5", + ) def formula(person, period, parameters): state = person.household("state_code_str", period) @@ -37,9 +51,13 @@ def formula(person, period, parameters): combined = _apply_ssi_exclusions( earned + spouse_earned, unearned + spouse_unearned, parameters, period ) - applies = ( - budgets_together - & person("is_ssi_aged_blind_disabled", period) - & ~person("is_ssi_spousal_deeming_applies", period) + split = spouses_split_by_facility(person, period) + budgeted_together = budgets_together & person( + "is_ssi_aged_blind_disabled", period ) - return where(applies, max_(combined - alone, 0), 0) + counted = where(budgeted_together & ~split, max_(combined - alone, 0), 0) + # ssi_countable_income already holds SSI's deemed amount, which starts at + # SSI's threshold and is net of child allocations. Subtracting it leaves one + # method at every income, with no jump at that threshold. + deemed = person("ssi_income_deemed_from_ineligible_spouse", period) + return where(budgeted_together | split, counted - deemed, 0) diff --git a/policyengine_us/variables/gov/hhs/medicaid/eligibility/categories/medically_needy/medicaid_medically_needy_uses_couple_standard.py b/policyengine_us/variables/gov/hhs/medicaid/eligibility/categories/medically_needy/medicaid_medically_needy_uses_couple_standard.py index e0e3798c63b..1801d805939 100644 --- a/policyengine_us/variables/gov/hhs/medicaid/eligibility/categories/medically_needy/medicaid_medically_needy_uses_couple_standard.py +++ b/policyengine_us/variables/gov/hhs/medicaid/eligibility/categories/medically_needy/medicaid_medically_needy_uses_couple_standard.py @@ -14,13 +14,16 @@ class medicaid_medically_needy_uses_couple_standard(Variable): "435.601(b)): an applicant with an ineligible spouse is tested alone " "unless the spouse's income is deemed (20 CFR 416.1163(d)). The state " "parameters budgets_couple_together and couple_limit_without_deeming " - "record the states whose own rules differ." + "record the states whose own rules differ. Spouses split by a facility " + "are each tested alone." ) definition_period = YEAR reference = ( "https://www.law.cornell.edu/cfr/text/42/435.601", "https://www.law.cornell.edu/cfr/text/42/435.602", "https://www.law.cornell.edu/cfr/text/20/416.1163", + "https://www.law.cornell.edu/cfr/text/20/416.414", + "https://www.law.cornell.edu/uscode/text/42/1396r-5", ) def formula(person, period, parameters): diff --git a/policyengine_us/variables/gov/hhs/medicaid/income/_couple_standard.py b/policyengine_us/variables/gov/hhs/medicaid/income/_couple_standard.py index e192225be47..f82d5e55814 100644 --- a/policyengine_us/variables/gov/hhs/medicaid/income/_couple_standard.py +++ b/policyengine_us/variables/gov/hhs/medicaid/income/_couple_standard.py @@ -1,12 +1,24 @@ from policyengine_us.model_api import * +from policyengine_us.variables.gov.ssa.ssi.eligibility.status.ssi_federal_living_arrangement import ( + SSIFederalLivingArrangement, +) def spouses_split_by_facility(person: Population, period: Period) -> ArrayLike: - # 20 CFR 416.414(b)(3): SSI computes each spouse separately when a facility - # splits a couple who are both aged, blind or disabled. - return person("ssi_claim_is_joint", period) & ~person( - "ssi_couple_computation_applies", period.first_month + # Exactly one member of a married couple is in a Medicaid-paid facility. SSI + # computes each member of an eligible couple separately (20 CFR 416.414(b)(3)). + # For any institutionalized spouse (42 USC 1396r-5(h)(1)), "no income of the + # community spouse shall be deemed available to the institutionalized spouse" + # (42 USC 1396r-5(b)(1)), and that section supersedes any inconsistent Medicaid + # provision ((a)(1)). Core reads this month-defined stock at a year's last month, + # as income reads ssi_couple_computation_applies, so both agree on a part-year + # stay. + marital_unit = person.marital_unit + in_facility = ( + person("ssi_federal_living_arrangement", period) + == SSIFederalLivingArrangement.MEDICAL_TREATMENT_FACILITY ) + return (marital_unit.nb_persons() == 2) & (marital_unit.sum(in_facility) == 1) def uses_couple_standard( @@ -19,7 +31,8 @@ def uses_couple_standard( # unless the spouse's income is deemed (20 CFR 416.1163(d)). States may # instead budget the couple together, or keep the couple standard without # deeming. A person with no aged, blind or disabled status has no test of - # their own, so stays with the couple. + # their own, so stays with the couple. A couple split by a facility is never + # tested together. marital_unit = person.marital_unit is_married = marital_unit.nb_persons() == 2 aged_blind_disabled = person("is_ssi_aged_blind_disabled", period) diff --git a/policyengine_us/variables/gov/hhs/medicaid/income/deemed/from_ineligible_spouse/medicaid_optional_senior_or_disabled_income_deemed_from_ineligible_spouse.py b/policyengine_us/variables/gov/hhs/medicaid/income/deemed/from_ineligible_spouse/medicaid_optional_senior_or_disabled_income_deemed_from_ineligible_spouse.py index 34fb9634b26..2e18e626d7f 100644 --- a/policyengine_us/variables/gov/hhs/medicaid/income/deemed/from_ineligible_spouse/medicaid_optional_senior_or_disabled_income_deemed_from_ineligible_spouse.py +++ b/policyengine_us/variables/gov/hhs/medicaid/income/deemed/from_ineligible_spouse/medicaid_optional_senior_or_disabled_income_deemed_from_ineligible_spouse.py @@ -2,6 +2,9 @@ from policyengine_us.variables.gov.hhs.medicaid.income._apply_medicaid_optional_senior_or_disabled_exclusions import ( _apply_medicaid_optional_senior_or_disabled_exclusions, ) +from policyengine_us.variables.gov.hhs.medicaid.income._couple_standard import ( + spouses_split_by_facility, +) class medicaid_optional_senior_or_disabled_income_deemed_from_ineligible_spouse( @@ -14,6 +17,7 @@ class medicaid_optional_senior_or_disabled_income_deemed_from_ineligible_spouse( reference = ( "https://www.law.cornell.edu/cfr/text/20/416.1163", "https://dssmanuals.mo.gov/mo-healthnet-for-the-aged-blind-and-disabled/0805-000-00/0805-015-00/0805-015-05/", + "https://www.law.cornell.edu/uscode/text/42/1396r-5", ) defined_for = "is_ssi_aged_blind_disabled" unit = USD @@ -61,7 +65,11 @@ def formula(person, period, parameters): budgets_together, spouse_gross_unearned, spouse_unearned ) has_ineligible_spouse = marital_unit.sum(ineligible_spouse) > 0 - deeming_applies = deeming_applies | (budgets_together & has_ineligible_spouse) + # A couple split by a facility counts no spouse income under either method + # (42 USC 1396r-5(b)(1)). + deeming_applies = ( + deeming_applies | (budgets_together & has_ineligible_spouse) + ) & ~spouses_split_by_facility(person, period) alone_countable = _apply_medicaid_optional_senior_or_disabled_exclusions( individual_earned, diff --git a/source_conflicts/candidates.yaml b/source_conflicts/candidates.yaml index 46e0fd7d7ee..c41d2c4d151 100644 --- a/source_conflicts/candidates.yaml +++ b/source_conflicts/candidates.yaml @@ -1471,6 +1471,9 @@ candidates: - kind: regulation citation: 10 CCR 2505-10 8.100.7.C.2 url: https://www.law.cornell.edu/regulations/colorado/10-CCR-2505-10-8.100_v2 + - kind: regulation + citation: 10 CCR 2505-10 8.100.6.C.1.b + url: https://www.law.cornell.edu/regulations/colorado/10-CCR-2505-10-8.100_v2 pe_us: follows: statute code: @@ -2301,6 +2304,28 @@ candidates: rent shows through a heating bill or a direct electric bill, and the comment records that FY2026 plan item 2.3 answers No to differing policies for subsidized renters (ga_liheap_eligible.py, eligibility/_ga_liheap_housing.py). Verify that the plan addresses the same circumstances.' +- id: us-hi:abd-spouse-income-household-size + program: medicaid + years: + from: 2026 + to: 2026 + type: program + note: program year as the program defines it + question: "Does Hawaii test a married couple living together on combined income against the two-person standard, because HAR 17-1724.1-16(1) makes spouses' income available to each other, or apply SSI's deeming threshold, because HAR 17-1719-11.1(a)(3) says only 'a household of applicable size'?" + sources: + - kind: regulation + citation: HAR 17-1724.1-16(1) + url: https://humanservices.hawaii.gov/wp-content/uploads/2016/12/HAR-17-1724.1-INCOME-FOR-MAGI-EXCEPTED-Final-10-31-16-1.pdf#page=5 + - kind: regulation + citation: HAR 17-1719-11.1(a)(3) + url: https://www.law.cornell.edu/regulations/hawaii/Haw-Code-R-SS-17-1719-11-1 + pe_us: + follows: gap-fill + code: + - policyengine_us/parameters/gov/hhs/medicaid/eligibility/categories/senior_or_disabled/income/budgets_couple_together.yaml + - policyengine_us/parameters/gov/hhs/medicaid/eligibility/categories/medically_needy/limit/income/budgets_couple_together.yaml + state: ruled + note: "Budgets the couple together, in the aged, blind and disabled pathway and in medically needy. Ruled by the project lead, 2026-11-02: https://github.com/PolicyEngine/policyengine-us/pull/10640" - id: us-hi:claim-of-right-credit-agi-addback program: income-tax years: @@ -3562,7 +3587,13 @@ candidates: question: "Does Massachusetts test a couple's income against the couple standard? 130 CMR 520.002(A)(1) says 'an income standard', and only 520.003(A)(2) names the couple limit, for assets." sources: - kind: regulation - citation: 130 CMR 520.002(A)(1), 520.003(A)(2), 519.005(A)(1) + citation: 130 CMR 520.002(A)(1) + url: https://web.archive.org/web/20260711022327id_/https://www.mass.gov/doc/130-cmr-520000-masshealth-financial-eligibility-0/download#page=2 + - kind: regulation + citation: 130 CMR 520.003(A)(2) + url: https://web.archive.org/web/20260711022327id_/https://www.mass.gov/doc/130-cmr-520000-masshealth-financial-eligibility-0/download#page=3 + - kind: regulation + citation: 130 CMR 519.005(A)(1) url: https://www.law.cornell.edu/regulations/massachusetts/130-CMR-519-005 pe_us: follows: gap-fill @@ -5933,6 +5964,9 @@ candidates: note: program year as the program defines it question: "Does Nebraska's medically needy program size the unit under 477 NAC 24, counting both spouses, or follow the general SSI methodology clause in 477 NAC 25-002.03(B)?" sources: + - kind: regulation + citation: 477 NAC 24-001.02B1 + url: https://www.law.cornell.edu/regulations/nebraska/477-Neb-Admin-Code-ch-24-SS-001 - kind: regulation citation: 477 NAC 25-002 url: https://www.law.cornell.edu/regulations/nebraska/477-Neb-Admin-Code-ch-25-SS-002 From 37d23c83c670773862067ce1ec27c24160db0bb4 Mon Sep 17 00:00:00 2001 From: Ziming Date: Mon, 2 Nov 2026 22:32:34 -0500 Subject: [PATCH 4/4] Test Hawaii's medically needy couple setting Co-Authored-By: Claude Opus 5.5 --- .../is_medically_needy_for_medicaid.yaml | 30 +++++++++++++++++++ 1 file changed, 30 insertions(+) diff --git a/policyengine_us/tests/policy/baseline/gov/hhs/medicaid/eligibility/categories/medically_needy/is_medically_needy_for_medicaid.yaml b/policyengine_us/tests/policy/baseline/gov/hhs/medicaid/eligibility/categories/medically_needy/is_medically_needy_for_medicaid.yaml index ba7df9047b4..1d89f8abcfa 100644 --- a/policyengine_us/tests/policy/baseline/gov/hhs/medicaid/eligibility/categories/medically_needy/is_medically_needy_for_medicaid.yaml +++ b/policyengine_us/tests/policy/baseline/gov/hhs/medicaid/eligibility/categories/medically_needy/is_medically_needy_for_medicaid.yaml @@ -1377,3 +1377,33 @@ medicaid_medically_needy_income_limit: [22_032, 22_032] is_medically_needy_for_medicaid: [false, true] medicaid_category: [NONE, MEDICALLY_NEEDY] + +# HAR 17-1724.1-16(1) counts the spouse's income with no threshold: 3,000 is below +# SSI's 5,964. 20,000 - 240 + 3,000 - 13,000 = 9,760 against the couple limit, 12 x 632. +- name: Case 50, Hawaii's medically needy test counts a low-income spouse's income against the couple limit. + period: 2026 + absolute_error_margin: 0.01 + input: + people: + person1: + is_tax_unit_head: true + age: 70 + social_security_retirement: 20_000 + other_medical_expenses: 13_000 + takes_up_medicare_if_eligible: false + person2: + is_tax_unit_spouse: true + age: 50 + taxable_interest_income: 3_000 + takes_up_medicare_if_eligible: false + marital_units: + marital_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: HI + output: + medicaid_medically_needy_uses_couple_standard: [true, true] + medicaid_medically_needy_income_limit: [7_584, 7_584] + medicaid_medically_needy_income_from_spouse: [3_000, 0]