Plan: SNAP Special Household Situations — Drug Felon, Fleeing Felon, and Striker Rules

-- SPDX-License-Identifier: AGPL-3.0-or-later

CREATE TABLE snap_disqualification_screenings (
    id UUID PRIMARY KEY,
    household_id UUID NOT NULL,
    person_id UUID NOT NULL,
    application_id UUID NOT NULL,
    screening_type TEXT NOT NULL,
    -- 'drug_felony', 'fleeing_felony', 'probation_violation', 'striker'
    self_attested BOOLEAN NOT NULL,
    self_attested_date DATE,
    conviction_date DATE,           -- drug felony only
    pre_strike_income NUMERIC(10,2), -- striker only
    screening_result TEXT NOT NULL DEFAULT 'pending',
    -- 'eligible', 'disqualified', 'pending_verification', 'exempt'
    exemption_reason TEXT,           -- for drug felony: state opt-out, time served, etc.
    screened_at TIMESTAMPTZ NOT NULL DEFAULT now(),
    screened_by UUID,               -- worker who reviewed
    active BOOLEAN NOT NULL DEFAULT true,
    created_at TIMESTAMPTZ NOT NULL DEFAULT now()
);

CREATE INDEX snap_disqual_screening_household_idx
    ON snap_disqualification_screenings (household_id, person_id);
CREATE INDEX snap_disqual_screening_type_idx
    ON snap_disqualification_screenings (screening_type, screening_result)
    WHERE active = true;

[snap.disqualifications]
# Drug felony policy (7 CFR 273.11(m))
# Values: "full_prohibition", "trafficking_only", "no_prohibition", "modified"
# Georgia: partial opt-out under Georgia Code §49-4-186
drug_felony_policy = "trafficking_only"

# Whether drug treatment program completion is accepted as an exemption
# Georgia: true (confirm current policy before implementation)
drug_treatment_exemption = true

// SPDX-License-Identifier: AGPL-3.0-or-later

use chrono::NaiveDate;

/// Drug felony policy configured per jurisdiction in jurisdiction.toml.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum DrugFelonyPolicy {
    /// Federal default: all drug felonies on or after 8/22/1996 disqualify.
    FullProhibition,
    /// Only drug trafficking convictions disqualify (e.g., Georgia).
    TraffickingOnly,
    /// State has opted out entirely; no drug felony restriction.
    NoProhibition,
    /// State has a custom modification (details in jurisdiction.toml).
    Modified,
}

/// Federal cutoff date: convictions on or after this date trigger the prohibition.
const DRUG_FELONY_CUTOFF: NaiveDate =
    match NaiveDate::from_ymd_opt(1996, 8, 22) {
        Some(d) => d,
        None => unreachable!(),
    };

/// Input for drug felon screening of a single household member.
pub struct DrugFelonInput {
    pub person_id: uuid::Uuid,
    pub has_conviction: bool,
    pub conviction_date: Option<NaiveDate>,
    /// Whether the conviction is for trafficking (vs. possession or other).
    /// Determined by worker review or self-attestation detail.
    pub is_trafficking: bool,
    /// Whether the individual has completed a drug treatment program.
    pub completed_treatment: bool,
}

/// Result of the drug felon screening.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum DrugFelonResult {
    /// No disqualification applies.
    Eligible,
    /// Disqualified under drug felon prohibition.
    Disqualified,
    /// Exempt (e.g., treatment completion, conviction before cutoff).
    Exempt { reason: String },
}

/// Screen a household member for drug felon disqualification.
///
/// Applies the jurisdiction-specific policy from jurisdiction.toml.
pub fn screen_drug_felon(
    input: &DrugFelonInput,
    policy: &DrugFelonyPolicy,
    treatment_exemption_enabled: bool,
) -> DrugFelonResult {
    if !input.has_conviction {
        return DrugFelonResult::Eligible;
    }

    // Conviction before federal cutoff date: not subject to prohibition
    if let Some(date) = input.conviction_date {
        if date < DRUG_FELONY_CUTOFF {
            return DrugFelonResult::Exempt {
                reason: "Conviction predates 8/22/1996 federal cutoff".to_string(),
            };
        }
    }

    match policy {
        DrugFelonyPolicy::NoProhibition => DrugFelonResult::Eligible,

        DrugFelonyPolicy::TraffickingOnly => {
            if !input.is_trafficking {
                return DrugFelonResult::Eligible;
            }
            if treatment_exemption_enabled && input.completed_treatment {
                return DrugFelonResult::Exempt {
                    reason: "Completed drug treatment program".to_string(),
                };
            }
            DrugFelonResult::Disqualified
        }

        DrugFelonyPolicy::FullProhibition => {
            if treatment_exemption_enabled && input.completed_treatment {
                return DrugFelonResult::Exempt {
                    reason: "Completed drug treatment program".to_string(),
                };
            }
            DrugFelonResult::Disqualified
        }

        DrugFelonyPolicy::Modified => {
            // Modified policies require jurisdiction-specific JDM ruleset
            // evaluation; this branch delegates to zen-engine.
            // For the Rust reference implementation, treat as full prohibition
            // with treatment exemption check.
            if treatment_exemption_enabled && input.completed_treatment {
                return DrugFelonResult::Exempt {
                    reason: "Completed drug treatment program".to_string(),
                };
            }
            DrugFelonResult::Disqualified
        }
    }
}

// SPDX-License-Identifier: AGPL-3.0-or-later

/// Input for fleeing felon / probation violator screening.
pub struct FleeingFelonInput {
    pub person_id: uuid::Uuid,
    pub fleeing_felony_prosecution: bool,
    pub probation_parole_violation: bool,
}

/// Screen a household member for fleeing felon / probation violator
/// disqualification.
///
/// 7 CFR 273.11(n): categorical prohibition, no state opt-out.
pub fn screen_fleeing_felon(input: &FleeingFelonInput) -> ScreeningResult {
    if input.fleeing_felony_prosecution {
        return ScreeningResult::Disqualified {
            reason: "Fleeing prosecution, custody, or confinement for a felony".to_string(),
        };
    }
    if input.probation_parole_violation {
        return ScreeningResult::Disqualified {
            reason: "Violating a condition of probation or parole".to_string(),
        };
    }
    ScreeningResult::Eligible
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ScreeningResult {
    Eligible,
    Disqualified { reason: String },
}

// SPDX-License-Identifier: AGPL-3.0-or-later

use rust_decimal::Decimal;

/// Input for striker household screening.
pub struct StrikerInput {
    pub person_id: uuid::Uuid,
    pub is_striker: bool,
    /// Monthly income the striker earned before the strike began.
    pub pre_strike_income: Option<Decimal>,
    /// Current monthly income for the striker (during the strike).
    pub current_income: Decimal,
}

/// Result of the striker pre-strike income comparison.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum StrikerResult {
    /// Not a striker; no special screening required.
    NotApplicable,
    /// Pre-strike income makes household eligible (would have qualified
    /// even before the strike).
    Eligible,
    /// Pre-strike income makes household ineligible (household only qualifies
    /// because strike reduced income).
    Denied,
    /// Missing pre-strike income data; cannot complete comparison.
    PendingVerification,
}

/// Evaluate the striker pre-strike income comparison test.
///
/// 7 CFR 273.11(e): Replace the striker's current income with their
/// pre-strike income, then re-evaluate eligibility. If the household
/// would NOT have been eligible with pre-strike income, deny.
///
/// `gross_income_limit` is the 130% FPL gross income limit for the
/// household size.
pub fn screen_striker(
    input: &StrikerInput,
    household_gross_income_excluding_striker: Decimal,
    gross_income_limit: Decimal,
) -> StrikerResult {
    if !input.is_striker {
        return StrikerResult::NotApplicable;
    }

    let pre_strike = match input.pre_strike_income {
        Some(income) => income,
        None => return StrikerResult::PendingVerification,
    };

    // Household gross income with pre-strike income substituted
    let hypothetical_gross = household_gross_income_excluding_striker + pre_strike;

    if hypothetical_gross <= gross_income_limit {
        StrikerResult::Eligible
    } else {
        StrikerResult::Denied
    }
}

{
  "event": "disqualification.screening_completed",
  "screening_id": "uuid",
  "household_id": "uuid",
  "person_id": "uuid",
  "screening_type": "drug_felony",
  "result": "disqualified"
}