policyengine-us 1.450.0__py3-none-any.whl → 1.504.0__py3-none-any.whl

policyengine_us/variables/gov/states/az/tax/income/credits/property_tax_credit/az_property_tax_credit_agi.py

@@ -0,0 +1,53 @@
+from policyengine_us.model_api import *
+
+
+class az_property_tax_credit_agi(Variable):
+    value_type = float
+    entity = TaxUnit
+    label = "Arizona adjusted gross income for property tax credit"
+    unit = USD
+    definition_period = YEAR
+    documentation = (
+        "Adjusted gross income as defined for Arizona property tax credit purposes. "
+        "Per ARS 43-1072(H)(6) and ITR 12-1, this starts with Federal AGI and only "
+        "excludes items specifically listed in ARS 43-1072(I): Social Security, "
+        "railroad retirement, workers compensation, Arizona unemployment, veterans "
+        "disability pensions, welfare, and gifts. Unlike regular Arizona income tax, "
+        "this does NOT exclude pension income, capital gains, or Arizona exemptions."
+    )
+    reference = [
+        "https://www.azleg.gov/ars/43/01072.htm",  # ARS 43-1072
+        "https://azdor.gov/sites/default/files/2023-03/RULINGS_INDV_2012_itr12-1.pdf",  # ITR 12-1
+    ]
+    defined_for = StateCode.AZ
+
+    def formula(tax_unit, period, parameters):
+        # Start with Federal AGI
+        # Per ITR 12-1, income includes wages, interest, business/farm income,
+        # rent/royalty, S-corp/partnership income, alimony, capital gains,
+        # pension/annuity income, and other non-excluded income.
+        federal_agi = tax_unit("adjusted_gross_income", period)
+
+        # Per ARS 43-1072(I) and ITR 12-1 "Items Excluded from Income",
+        # we ONLY exclude Social Security benefits (and other items like
+        # railroad retirement, workers comp, AZ unemployment, veterans
+        # disability pensions, welfare, and gifts - but these are typically
+        # not in Federal AGI anyway).
+        #
+        # Federal AGI only includes the TAXABLE portion of Social Security,
+        # but for property tax credit, ALL Social Security should be excluded.
+        # So we subtract the taxable portion that's in Federal AGI.
+        taxable_social_security = tax_unit(
+            "tax_unit_taxable_social_security", period
+        )
+
+        # NOTE: We do NOT subtract Arizona's regular subtractions here because:
+        # - Pension exclusions (az_public_pension_exclusion,
+        #   az_military_retirement_subtraction) should be INCLUDED per
+        #   ITR 12-1 item (9)
+        # - Capital gains subtraction (az_long_term_capital_gains_subtraction)
+        #   should be INCLUDED per ITR 12-1 item (7)
+        # - US Government interest should be INCLUDED per ITR 12-1 item (2)
+        # - Arizona exemptions (aged, blind) should NOT be subtracted
+
+        return max_(0, federal_agi - taxable_social_security)

policyengine_us/variables/gov/states/ca/chhs/is_ca_medicaid_immigration_status_eligible.py

@@ -4,15 +4,57 @@ from policyengine_us.model_api import *
 class is_ca_medicaid_immigration_status_eligible(Variable):
     value_type = bool
     entity = Person
-    label = "Eligible for California state-funded Medicaid regardless of immigration status"
+    label = "Eligible for California Medi-Cal without satisfactory immigration status"
     definition_period = YEAR
-    reference = [
+    reference = (
         "https://california.public.law/codes/welfare_and_institutions_code_section_14007.8",
-    ]
+    )
+    documentation = """
+    California Welfare and Institutions Code Section 14007.8 provides
+    state-funded Medi-Cal to individuals without satisfactory immigration
+    status based on age brackets. Starting January 1, 2026, new enrollments
+    for adults 19+ are frozen for certain statuses (undocumented), but:
+    - Existing enrollees retain coverage (continuous coverage)
+    - DACA/TPS holders are NOT affected by the freeze
+    - After October 2026, refugees/asylees losing federal coverage are
+      picked up by CA state-funded coverage
+    """
     defined_for = StateCode.CA
 
     def formula(person, period, parameters):
         p = parameters(period).gov.states.ca.chhs
+        immigration_status = person("immigration_status", period)
+        immigration_status_str = immigration_status.decode_to_str()
+
+        # Check if person has a CA state-funded eligible immigration status
+        is_ca_state_funded_status = np.isin(
+            immigration_status_str, p.ca_state_funded_immigration_statuses
+        )
+
         age = person("age", period)
         pregnant = person("is_pregnant", period)
-        return p.eligible_regardless_of_immigration_status.calc(age) | pregnant
+        # Standard eligibility based on age or pregnancy
+        standard_eligible = (
+            p.eligible_regardless_of_immigration_status.calc(age) | pregnant
+        )
+
+        # Enrollment freeze logic (effective January 1, 2026)
+        if p.medi_cal_enrollment_freeze.in_effect:
+            # Check if person's status is affected by the freeze
+            is_freeze_affected = np.isin(
+                immigration_status_str,
+                p.medi_cal_enrollment_freeze.affected_statuses,
+            )
+            receives_medicaid = person("receives_medicaid", period)
+
+            # Freeze-affected (UNDOCUMENTED): standard age eligibility OR
+            #   continuous coverage (already enrolled)
+            # Not freeze-affected (DACA/TPS/others): always eligible
+            #   (Health4All covered all ages by 2024, freeze doesn't apply)
+            return is_ca_state_funded_status & where(
+                is_freeze_affected,
+                standard_eligible | receives_medicaid,
+                True,
+            )
+
+        return is_ca_state_funded_status & standard_eligible

policyengine_us/variables/gov/states/co/hcpf/omnisalud/co_omnisalud.py

@@ -0,0 +1,23 @@
+from policyengine_us.model_api import *
+
+
+class co_omnisalud(Variable):
+    value_type = float
+    entity = TaxUnit
+    label = "Colorado OmniSalud premium subsidy"
+    unit = USD
+    definition_period = YEAR
+    defined_for = "co_omnisalud_tax_unit_eligible"
+    adds = ["slcsp"]
+    reference = [
+        "https://connectforhealthco.com/get-started/omnisalud/",
+        "https://coloradoimmigrant.org/wp-content/uploads/2024/03/Eng.-OmniSalud-Guide-2024.pdf",
+    ]
+    documentation = """
+    Colorado OmniSalud provides a premium subsidy (SilverEnhanced Savings)
+    that covers the full cost of health insurance premiums for eligible
+    individuals, resulting in $0 monthly premium.
+
+    The benefit value is equal to the second lowest cost silver plan (SLCSP)
+    premium, similar to the federal ACA premium tax credit.
+    """

policyengine_us/variables/gov/states/co/hcpf/omnisalud/eligibility/co_omnisalud_eligible.py

@@ -0,0 +1,37 @@
+from policyengine_us.model_api import *
+
+
+class co_omnisalud_eligible(Variable):
+    value_type = bool
+    entity = Person
+    label = "Eligible for Colorado OmniSalud"
+    definition_period = YEAR
+    defined_for = StateCode.CO
+    reference = [
+        "https://connectforhealthco.com/get-started/omnisalud/",
+        "https://coloradoimmigrant.org/wp-content/uploads/2024/03/Eng.-OmniSalud-Guide-2024.pdf",
+    ]
+    documentation = """
+    Colorado OmniSalud provides marketplace coverage with premium subsidies
+    to individuals who are ineligible for Health First Colorado (Medicaid),
+    CHP+, or federal ACA subsidies due to their immigration status.
+    """
+
+    def formula(person, period, parameters):
+        p = parameters(period).gov.states.co.hcpf.omnisalud.eligibility
+
+        # Program must be in effect
+        in_effect = p.in_effect
+
+        # Must have eligible immigration status (undocumented, DACA before 2025)
+        immigration_eligible = person(
+            "co_omnisalud_immigration_status_eligible", period
+        )
+
+        # Must meet income requirements for financial assistance
+        income_eligible = person("co_omnisalud_income_eligible", period)
+
+        # Must not be eligible for other coverage
+        # (Medicaid/CHP+ eligibility already checked via immigration status)
+
+        return in_effect & immigration_eligible & income_eligible

policyengine_us/variables/gov/states/co/hcpf/omnisalud/eligibility/co_omnisalud_immigration_status_eligible.py

@@ -0,0 +1,65 @@
+from policyengine_us.model_api import *
+
+
+class co_omnisalud_immigration_status_eligible(Variable):
+    value_type = bool
+    entity = Person
+    label = "Has eligible immigration status for Colorado OmniSalud"
+    definition_period = YEAR
+    defined_for = StateCode.CO
+    reference = [
+        "https://connectforhealthco.com/get-started/omnisalud/",
+        "https://coloradoimmigrant.org/wp-content/uploads/2024/03/Eng.-OmniSalud-Guide-2024.pdf",
+    ]
+    documentation = """
+    Colorado OmniSalud covers immigrants who are NOT eligible for federal
+    ACA subsidies due to their immigration status. This includes:
+    - Undocumented immigrants (adults only starting 2025)
+    - DACA recipients (before 2025 - they move to regular ACA in 2025)
+
+    Starting 2025, undocumented children and pregnant individuals move to
+    Health First Colorado (Medicaid).
+    """
+
+    def formula(person, period, parameters):
+        p = parameters(period).gov.states.co.hcpf.omnisalud.eligibility
+        immigration_status = person("immigration_status", period)
+        age = person("age", period)
+        is_pregnant = person("is_pregnant", period)
+
+        # Check if undocumented
+        undocumented = (
+            immigration_status
+            == immigration_status.possible_values.UNDOCUMENTED
+        )
+
+        # Check if DACA (covered before 2025)
+        daca = immigration_status == immigration_status.possible_values.DACA
+        daca_tps = (
+            immigration_status == immigration_status.possible_values.DACA_TPS
+        )
+        is_daca = daca | daca_tps
+
+        # Children and pregnant individuals move to Health First Colorado in 2025
+        is_child = age <= p.child_max_age
+
+        # Determine if person's status is covered by OmniSalud
+        # Undocumented adults are always covered
+        # Undocumented children covered before 2025 (parameter controls this)
+        # Undocumented pregnant covered before 2025
+        # DACA covered before 2025 (parameter controls this)
+        undocumented_child_covered = (
+            undocumented & is_child & p.covers_undocumented_children
+        )
+        undocumented_pregnant_covered = (
+            undocumented & is_pregnant & p.covers_undocumented_children
+        )
+        undocumented_adult_covered = undocumented & ~is_child & ~is_pregnant
+        daca_covered = is_daca & p.covers_daca
+
+        return (
+            undocumented_adult_covered
+            | undocumented_child_covered
+            | undocumented_pregnant_covered
+            | daca_covered
+        )

policyengine_us/variables/gov/states/co/hcpf/omnisalud/eligibility/co_omnisalud_income_eligible.py

@@ -0,0 +1,25 @@
+from policyengine_us.model_api import *
+
+
+class co_omnisalud_income_eligible(Variable):
+    value_type = bool
+    entity = Person
+    label = "Meets Colorado OmniSalud income eligibility"
+    definition_period = YEAR
+    defined_for = StateCode.CO
+    reference = [
+        "https://connectforhealthco.com/get-started/omnisalud/",
+        "https://coloradoimmigrant.org/wp-content/uploads/2024/03/Eng.-OmniSalud-Guide-2024.pdf",
+    ]
+    documentation = """
+    Colorado OmniSalud provides financial assistance (SilverEnhanced Savings)
+    to individuals with income below 150% of the Federal Poverty Level.
+    Those with higher income can still enroll but pay full premium.
+    """
+
+    def formula(person, period, parameters):
+        p = parameters(period).gov.states.co.hcpf.omnisalud.eligibility
+        # Use ACA MAGI as the income measure
+        income_level = person("medicaid_income_level", period)
+
+        return income_level < p.income_limit

policyengine_us/variables/gov/states/co/hcpf/omnisalud/eligibility/co_omnisalud_tax_unit_eligible.py

@@ -0,0 +1,19 @@
+from policyengine_us.model_api import *
+
+
+class co_omnisalud_tax_unit_eligible(Variable):
+    value_type = bool
+    entity = TaxUnit
+    label = "Tax unit eligible for Colorado OmniSalud"
+    definition_period = YEAR
+    defined_for = StateCode.CO
+    reference = [
+        "https://connectforhealthco.com/get-started/omnisalud/",
+        "https://coloradoimmigrant.org/wp-content/uploads/2024/03/Eng.-OmniSalud-Guide-2024.pdf",
+    ]
+    documentation = """
+    A tax unit is eligible for Colorado OmniSalud if any member is eligible.
+    """
+
+    def formula(tax_unit, period, parameters):
+        return tax_unit.any(tax_unit.members("co_omnisalud_eligible", period))

policyengine_us/variables/gov/states/ct/dss/tfa/ct_tfa.py

@@ -0,0 +1,34 @@
+from policyengine_us.model_api import *
+
+
+class ct_tfa(Variable):
+    value_type = float
+    entity = SPMUnit
+    label = "Connecticut Temporary Family Assistance (TFA) benefit amount"
+    unit = USD
+    definition_period = MONTH
+    reference = "https://portal.ct.gov/dss/-/media/departments-and-agencies/dss/state-plans-and-federal-reports/tanf-state-plan/ct-tanf-state-plan-2024---2026---41524-amendment.pdf#page=10"
+    defined_for = "ct_tfa_eligible"
+
+    def formula(spm_unit, period, parameters):
+        p = parameters(period).gov.states.ct.dss.tfa.payment.high_earnings
+        # Unearned income are counted dollar for dollar against TFA benefit amount
+        # https://portal.ct.gov/dss/knowledge-base/articles/cash-assistance/temporary-family-assistance?language=en_US
+        payment_standard = spm_unit("ct_tfa_payment_standard", period)
+        countable_unearned_income = spm_unit(
+            "ct_tfa_countable_unearned_income", period
+        )
+        benefit_amount = max_(payment_standard - countable_unearned_income, 0)
+        # When gross earnings are >= 171% of FPG, reduce the benefit by 20%
+        gross_earnings = add(spm_unit, period, ["tanf_gross_earned_income"])
+        fpg = spm_unit("tanf_fpg", period)
+        high_income_threshold = p.rate * fpg
+        high_income = gross_earnings >= high_income_threshold
+
+        reduction_multiplier = 1 - p.reduction_rate
+
+        return where(
+            high_income,
+            benefit_amount * reduction_multiplier,
+            benefit_amount,
+        )

policyengine_us/variables/gov/states/ct/dss/tfa/eligibility/ct_tfa_eligible.py

@@ -0,0 +1,24 @@
+from policyengine_us.model_api import *
+
+
+class ct_tfa_eligible(Variable):
+    value_type = bool
+    entity = SPMUnit
+    label = "Eligible for Connecticut Temporary Family Assistance (TFA)"
+    definition_period = MONTH
+    reference = "https://portal.ct.gov/dss/-/media/departments-and-agencies/dss/state-plans-and-federal-reports/tanf-state-plan/ct-tanf-state-plan-2024---2026---41524-amendment.pdf#page=10"
+    defined_for = StateCode.CT
+
+    def formula(spm_unit, period, parameters):
+        demographic_eligible = spm_unit("is_demographic_tanf_eligible", period)
+        immigration_status_eligible = (
+            add(spm_unit, period, ["is_citizen_or_legal_immigrant"]) > 0
+        )
+        resources_eligible = spm_unit("ct_tfa_resources_eligible", period)
+        income_eligible = spm_unit("ct_tfa_income_eligible", period)
+        return (
+            demographic_eligible
+            & immigration_status_eligible
+            & resources_eligible
+            & income_eligible
+        )

policyengine_us/variables/gov/states/ct/dss/tfa/eligibility/ct_tfa_income_eligible.py

@@ -0,0 +1,35 @@
+from policyengine_us.model_api import *
+
+
+class ct_tfa_income_eligible(Variable):
+    value_type = bool
+    entity = SPMUnit
+    label = "Eligible for Connecticut Temporary Family Assistance (TFA) due to income"
+    definition_period = MONTH
+    reference = "https://portal.ct.gov/dss/-/media/departments-and-agencies/dss/state-plans-and-federal-reports/tanf-state-plan/ct-tanf-state-plan-2024---2026---41524-amendment.pdf#page=10"
+    defined_for = StateCode.CT
+
+    def formula(spm_unit, period, parameters):
+        p = parameters(period).gov.states.ct.dss.tfa.income.recipient
+        is_tanf_enrolled = spm_unit("is_tanf_enrolled", period)
+        # New applicant income check
+        countable_income_at_application = spm_unit(
+            "ct_tfa_countable_income_at_application", period
+        )
+        need_standard = spm_unit("ct_tfa_need_standard", period)
+        income_eligible_at_application = (
+            countable_income_at_application <= need_standard
+        )
+        # Existing recipient income check
+        # Pre 2024, gross earning <= 100% fpg
+        # Starting 2024, gross earning <= 230% FPL
+        gross_earnings = add(spm_unit, period, ["tanf_gross_earned_income"])
+        fpg = spm_unit("tanf_fpg", period)
+
+        fpg_limit = p.income_limit_rate * fpg
+        income_eligible_at_grant_calculation = gross_earnings <= fpg_limit
+        return where(
+            is_tanf_enrolled,
+            income_eligible_at_grant_calculation,
+            income_eligible_at_application,
+        )

policyengine_us/variables/gov/states/ct/dss/tfa/eligibility/ct_tfa_resources_eligible.py

@@ -0,0 +1,15 @@
+from policyengine_us.model_api import *
+
+
+class ct_tfa_resources_eligible(Variable):
+    value_type = bool
+    entity = SPMUnit
+    label = "Eligible for Connecticut Temporary Family Assistance (TFA) due to resources"
+    definition_period = MONTH
+    reference = "https://portal.ct.gov/dss/-/media/departments-and-agencies/dss/state-plans-and-federal-reports/tanf-state-plan/ct-tanf-state-plan-2024---2026---41524-amendment.pdf#page=10"
+    defined_for = StateCode.CT
+
+    def formula(spm_unit, period, parameters):
+        p = parameters(period).gov.states.ct.dss.tfa.resource
+        assets = spm_unit("spm_unit_assets", period.this_year)
+        return assets <= p.limit

policyengine_us/variables/gov/states/ct/dss/tfa/income/ct_tfa_countable_unearned_income.py

@@ -0,0 +1,22 @@
+from policyengine_us.model_api import *
+
+
+class ct_tfa_countable_unearned_income(Variable):
+    value_type = float
+    entity = SPMUnit
+    label = "Connecticut Temporary Family Assistance (TFA) countable unearned income"
+    unit = USD
+    definition_period = MONTH
+    reference = "https://portal.ct.gov/dss/-/media/departments-and-agencies/dss/state-plans-and-federal-reports/tanf-state-plan/ct-tanf-state-plan-2024---2026---41524-amendment.pdf#page=10"
+    defined_for = StateCode.CT
+
+    def formula(spm_unit, period, parameters):
+        p = parameters(period).gov.states.ct.dss.tfa.income.deduction
+        total_unearned_income = add(
+            spm_unit, period, ["tanf_gross_unearned_income"]
+        )
+        # Get child support - PolicyEngine handles period conversion automatically
+        child_support = add(spm_unit, period, ["child_support_received"])
+        child_support_deduction = min_(child_support, p.child_support)
+
+        return max_(0, total_unearned_income - child_support_deduction)

policyengine_us/variables/gov/states/ct/dss/tfa/income/new_applicant/ct_tfa_countable_earned_income_at_application.py

@@ -0,0 +1,19 @@
+from policyengine_us.model_api import *
+
+
+class ct_tfa_countable_earned_income_at_application(Variable):
+    value_type = float
+    entity = Person
+    label = "Connecticut Temporary Family Assistance (TFA) countable earned income at application per person"
+    unit = USD
+    definition_period = MONTH
+    reference = "https://portal.ct.gov/dss/-/media/departments-and-agencies/dss/state-plans-and-federal-reports/tanf-state-plan/ct-tanf-state-plan-2024---2026---41524-amendment.pdf#page=10"
+    defined_for = StateCode.CT
+
+    def formula(person, period, parameters):
+        p = parameters(
+            period
+        ).gov.states.ct.dss.tfa.income.deduction.new_applicant
+        gross_earned_income = person("tanf_gross_earned_income", period)
+
+        return max_(gross_earned_income - p.amount, 0)

policyengine_us/variables/gov/states/ct/dss/tfa/income/new_applicant/ct_tfa_countable_income_at_application.py

@@ -0,0 +1,16 @@
+from policyengine_us.model_api import *
+
+
+class ct_tfa_countable_income_at_application(Variable):
+    value_type = float
+    entity = SPMUnit
+    label = "Connecticut Temporary Family Assistance (TFA) countable income at application"
+    unit = USD
+    definition_period = MONTH
+    defined_for = StateCode.CT
+    reference = "https://portal.ct.gov/dss/-/media/departments-and-agencies/dss/state-plans-and-federal-reports/tanf-state-plan/ct-tanf-state-plan-2024---2026---41524-amendment.pdf#page=10"
+
+    adds = [
+        "ct_tfa_countable_earned_income_at_application",
+        "ct_tfa_countable_unearned_income",
+    ]

policyengine_us/variables/gov/states/ct/dss/tfa/payment/ct_tfa_need_standard.py

@@ -0,0 +1,17 @@
+from policyengine_us.model_api import *
+
+
+class ct_tfa_need_standard(Variable):
+    value_type = float
+    entity = SPMUnit
+    label = "Connecticut Temporary Family Assistance (TFA) standard of need"
+    unit = USD
+    definition_period = MONTH
+    reference = "https://portal.ct.gov/dss/-/media/departments-and-agencies/dss/state-plans-and-federal-reports/tanf-state-plan/ct-tanf-state-plan-2024---2026---41524-amendment.pdf#page=10"
+    defined_for = StateCode.CT
+
+    def formula(spm_unit, period, parameters):
+        p = parameters(period).gov.states.ct.dss.tfa.payment
+        fpg = spm_unit("tanf_fpg", period)
+
+        return p.need_standard_rate * fpg

policyengine_us/variables/gov/states/ct/dss/tfa/payment/ct_tfa_payment_standard.py

@@ -0,0 +1,18 @@
+from policyengine_us.model_api import *
+
+
+class ct_tfa_payment_standard(Variable):
+    value_type = float
+    entity = SPMUnit
+    label = "Connecticut Temporary Family Assistance (TFA) payment standard"
+    unit = USD
+    definition_period = MONTH
+    reference = "https://portal.ct.gov/dss/-/media/departments-and-agencies/dss/state-plans-and-federal-reports/tanf-state-plan/ct-tanf-state-plan-2024---2026---41524-amendment.pdf#page=53"
+    defined_for = StateCode.CT
+
+    def formula(spm_unit, period, parameters):
+        p = parameters(period).gov.states.ct.dss.tfa.payment
+        size = spm_unit("spm_unit_size", period.this_year)
+        capped_unit_size = min_(size, p.max_unit_size)
+
+        return p.amount[capped_unit_size]

policyengine_us/variables/gov/states/dc/tax/income/credits/dc_ptc.py

@@ -18,15 +18,19 @@ class dc_ptc(Variable):
         retax = add(tax_unit, period, ["real_estate_taxes"])
         p_dc = parameters(period).gov.states.dc.tax.income.credits
         ptax = retax + rent * p_dc.ptc.rent_ratio
+
         elderly_age = p_dc.ptc.min_elderly_age
         head_age = tax_unit("age_head", period)
         spouse_age = tax_unit("age_spouse", period)
         is_elderly = (head_age >= elderly_age) | (spouse_age >= elderly_age)
+
+        # Only positive AGI creates an offset (negative AGI should not reduce offset)
         us_agi = tax_unit("adjusted_gross_income", period)
-        ptax_offset = us_agi * where(
+        positive_agi = max_(0, us_agi)
+        ptax_offset = positive_agi * where(
             is_elderly,
-            p_dc.ptc.fraction_elderly.calc(us_agi, right=True),
-            p_dc.ptc.fraction_nonelderly.calc(us_agi, right=True),
+            p_dc.ptc.fraction_elderly.calc(positive_agi, right=True),
+            p_dc.ptc.fraction_nonelderly.calc(positive_agi, right=True),
         )
         uncapped_ptc = max_(0, ptax - ptax_offset)
         return min_(p_dc.ptc.max, uncapped_ptc)

policyengine_us/variables/gov/states/de/dhss/tanf/de_tanf.py

@@ -0,0 +1,30 @@
+from policyengine_us.model_api import *
+
+
+class de_tanf(Variable):
+    value_type = float
+    entity = SPMUnit
+    label = "Delaware TANF"
+    unit = USD
+    definition_period = MONTH
+    reference = "https://www.law.cornell.edu/regulations/delaware/16-Del-Admin-Code-SS-4000-4008"
+    defined_for = "de_tanf_eligible"
+
+    def formula(spm_unit, period, parameters):
+        # Per DSSM 4008 / State Plan Exhibit 1 Step 3 (Benefit Calculation):
+        # Net income = countable earned ($90 + $30 + 1/3 + childcare) + unearned
+        p = parameters(period).gov.states.de.dhss.tanf
+
+        countable_income = spm_unit("de_tanf_countable_income", period)
+
+        # Deficit = Standard of Need - Net Income
+        standard_of_need = spm_unit("de_tanf_standard_of_need", period)
+        deficit = max_(standard_of_need - countable_income, 0)
+
+        # Remainder = Deficit * 50%
+        remainder = deficit * p.benefit.deficit_rate
+
+        # Grant = min(Remainder, Payment Standard)
+        payment_standard = spm_unit("de_tanf_payment_standard", period)
+
+        return min_(remainder, payment_standard)

policyengine_us/variables/gov/states/de/dhss/tanf/de_tanf_payment_standard.py

@@ -0,0 +1,24 @@
+from policyengine_us.model_api import *
+
+
+class de_tanf_payment_standard(Variable):
+    value_type = float
+    entity = SPMUnit
+    label = "Delaware TANF payment standard"
+    unit = USD
+    definition_period = MONTH
+    reference = (
+        "https://www.law.cornell.edu/regulations/delaware/16-Del-Admin-Code-SS-4000-4008",
+        "https://dhss.delaware.gov/dss/tanf/",
+    )
+    defined_for = StateCode.DE
+
+    def formula(spm_unit, period, parameters):
+        p = parameters(period).gov.states.de.dhss.tanf.payment_standard
+        unit_size = spm_unit("spm_unit_size", period)
+        capped_unit_size = min_(unit_size, p.max_unit_size)
+        base_amount = p.amount[capped_unit_size]
+        # For each additional person beyond max_unit_size, add $69
+        additional_persons = max_(unit_size - p.max_unit_size, 0)
+        additional_amount = additional_persons * p.additional_person
+        return base_amount + additional_amount

policyengine_us/variables/gov/states/de/dhss/tanf/de_tanf_standard_of_need.py

@@ -0,0 +1,20 @@
+from policyengine_us.model_api import *
+
+
+class de_tanf_standard_of_need(Variable):
+    value_type = float
+    entity = SPMUnit
+    label = "Delaware TANF standard of need"
+    unit = USD
+    definition_period = MONTH
+    reference = (
+        "https://www.law.cornell.edu/regulations/delaware/16-Del-Admin-Code-SS-4000-4008",
+        "https://dhss.delaware.gov/dss/tanf/",
+    )
+    defined_for = StateCode.DE
+
+    def formula(spm_unit, period, parameters):
+        # Standard of Need = 75% of Federal Poverty Level (monthly)
+        fpg = spm_unit("spm_unit_fpg", period)
+        p = parameters(period).gov.states.de.dhss.tanf.income
+        return fpg * p.standard_of_need

policyengine_us/variables/gov/states/de/dhss/tanf/eligibility/de_tanf_eligible.py

@@ -0,0 +1,35 @@
+from policyengine_us.model_api import *
+
+
+class de_tanf_eligible(Variable):
+    value_type = bool
+    entity = SPMUnit
+    label = "Eligible for Delaware TANF"
+    definition_period = MONTH
+    reference = (
+        "https://www.law.cornell.edu/regulations/delaware/16-Del-Admin-Code-SS-4000-4008",
+        "https://dhss.delaware.gov/dss/tanf/",
+    )
+    defined_for = StateCode.DE
+
+    def formula(spm_unit, period, parameters):
+        # Use federal demographic eligibility (minor child or pregnant)
+        demographic_eligible = spm_unit("is_demographic_tanf_eligible", period)
+        # Delaware follows federal immigration rules
+        immigration_eligible = (
+            add(spm_unit, period, ["is_citizen_or_legal_immigrant"]) > 0
+        )
+        # State-specific eligibility tests
+        gross_income_eligible = spm_unit(
+            "de_tanf_gross_income_eligible", period
+        )
+        net_income_eligible = spm_unit("de_tanf_net_income_eligible", period)
+        resources_eligible = spm_unit("de_tanf_resources_eligible", period)
+
+        return (
+            demographic_eligible
+            & immigration_eligible
+            & gross_income_eligible
+            & net_income_eligible
+            & resources_eligible
+        )