Plan: Medicaid Eligibility Service

-- services/canopy-medicaid/migrations/20260407000000_create_medicaid_tables.sql

-- Medicaid applications received for determination.
-- One row per application submitted through canopy-eligibility.
CREATE TABLE medicaid_applications (
    id UUID PRIMARY KEY,
    application_id UUID NOT NULL,       -- reference to canopy-applications
    household_id UUID NOT NULL,         -- reference to canopy-persons
    applicant_person_id UUID NOT NULL,  -- reference to canopy-persons
    pathway TEXT NOT NULL,              -- magi, non_magi, both, chip
    status TEXT NOT NULL DEFAULT 'pending',
    received_at TIMESTAMPTZ NOT NULL DEFAULT now(),
    determined_at TIMESTAMPTZ,
    created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
    updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
);

-- MAGI household composition snapshot per PAMMS 2610.
-- MAGI household rules differ from SNAP household (physical) and TANF household (deprivation).
-- MAGI uses tax filing relationships: tax filer + spouse + tax dependents.
CREATE TABLE magi_household_snapshots (
    id UUID PRIMARY KEY,
    medicaid_application_id UUID NOT NULL REFERENCES medicaid_applications(id),
    household_id UUID NOT NULL,
    person_id UUID NOT NULL,           -- the individual whose BG is being determined
    is_tax_filer BOOLEAN NOT NULL,     -- true = tax filer rules; false = non-filer rules
    tax_filer_person_id UUID,          -- the tax filer (may be self, spouse, or parent)
    filing_status TEXT,                -- single, married_filing_jointly, head_of_household
    magi_household_size INTEGER NOT NULL,  -- includes unborn children per PAMMS 2610
    spouse_person_id UUID,             -- spouse living in the home (included even if not filing jointly)
    dependents_person_ids UUID[] NOT NULL DEFAULT '{}',
    pregnant_member_ids UUID[] NOT NULL DEFAULT '{}',
    unborn_count INTEGER NOT NULL DEFAULT 0,
    ssi_recipient_ids UUID[] NOT NULL DEFAULT '{}', -- SSI recipients in BG (income excluded per 2610)
    snapshot_at TIMESTAMPTZ NOT NULL DEFAULT now(),
    created_at TIMESTAMPTZ NOT NULL DEFAULT now()
);

-- MAGI income records for budget group members.
-- Per PAMMS 2669: income of all BG members required to file a tax return is counted.
-- Exception: child dependent income below IRS dependent exemption amount is excluded.
CREATE TABLE magi_income (
    id UUID PRIMARY KEY,
    medicaid_application_id UUID NOT NULL REFERENCES medicaid_applications(id),
    person_id UUID NOT NULL,
    income_type TEXT NOT NULL,          -- wages, self_employment, tips, commissions, rental,
                                        -- interest, dividends, social_security, ssi, pension,
                                        -- alimony, child_support, unemployment, other
    gross_amount NUMERIC(10,2) NOT NULL,
    frequency TEXT NOT NULL,           -- monthly, biweekly, weekly, annual
    monthly_amount NUMERIC(10,2) NOT NULL, -- normalized to monthly
    is_countable BOOLEAN NOT NULL DEFAULT true,
    is_earned BOOLEAN NOT NULL DEFAULT false,
    -- MAGI-specific adjustments (1040 deductions per PAMMS 2669 Step 3)
    magi_adjustment_type TEXT,         -- student_loan_interest, ira_deduction,
                                        -- educator_expenses, health_savings, alimony_paid,
                                        -- self_employment_tax, self_employment_health_insurance
    magi_adjustment_amount NUMERIC(10,2) DEFAULT 0,
    -- Before-tax deductions (per PAMMS 2669 Step 2)
    before_tax_deduction_type TEXT,    -- 401k, 403b, health_insurance_premium, fsa, hsa, fers, csrs
    before_tax_deduction_amount NUMERIC(10,2) DEFAULT 0,
    -- Self-employment cost of doing business (per PAMMS 2669 Step 1)
    self_employment_expenses NUMERIC(10,2) DEFAULT 0,
    -- Child dependent income exclusion (below IRS dependent exemption per PAMMS 2610)
    is_child_dependent_excluded BOOLEAN NOT NULL DEFAULT false,
    child_dependent_exemption_amount NUMERIC(10,2),
    source TEXT NOT NULL,              -- self_report, fti, fdsh, employer, collateral
    verification_status TEXT NOT NULL DEFAULT 'unverified',
    created_at TIMESTAMPTZ NOT NULL DEFAULT now()
);

-- Non-MAGI eligibility factors for ABD COAs.
-- Used by FBR COAs (SSI income-based) and non-FBR COAs (resource test + income disregards).
CREATE TABLE non_magi_factors (
    id UUID PRIMARY KEY,
    medicaid_application_id UUID NOT NULL REFERENCES medicaid_applications(id),
    person_id UUID NOT NULL,
    category TEXT NOT NULL,            -- ssi, pickle, dac, disabled_widow, widow_60_64,
                                        -- former_ssi_disabled_child, edwp, now_waiver,
                                        -- comp_waiver, tefra_katie_beckett, hospice, hospital,
                                        -- icwp, nursing_home, amn, qdwi, qmb, slmb, qi_1
    age INTEGER,
    age_verified BOOLEAN DEFAULT false,
    disability_status TEXT,            -- ssi_recipient, ssdi_recipient, state_determined,
                                        -- not_disabled, blind
    disability_determination_date DATE,
    medicare_enrolled BOOLEAN DEFAULT false,
    medicare_parts TEXT,               -- part_a, part_b, part_a_and_b
    resource_test_passed BOOLEAN,
    countable_resources NUMERIC(10,2),
    resource_limit NUMERIC(10,2),
    countable_income NUMERIC(10,2),
    income_limit NUMERIC(10,2),
    federal_benefit_rate NUMERIC(10,2),  -- for FBR COAs
    medical_spend_down_amount NUMERIC(10,2),  -- for medically needy and AMN
    level_of_care_met BOOLEAN,         -- for institutional COAs (NH, EDWP, NOW, COMP, ICWP)
    length_of_stay_met BOOLEAN,        -- for institutional COAs
    created_at TIMESTAMPTZ NOT NULL DEFAULT now()
);

-- FTI data received from IRS (IRC section 6103(l)(12) for Medicaid/CHIP).
-- All access MUST be wrapped with FTI audit logging.
-- MAGI calculation uses: AGI + tax-exempt interest + foreign earned income + non-taxable SS.
CREATE TABLE fti_tax_data (
    id UUID PRIMARY KEY,
    medicaid_application_id UUID NOT NULL REFERENCES medicaid_applications(id),
    person_id UUID NOT NULL,
    tax_year INTEGER NOT NULL,
    filing_status TEXT,                -- single, married_filing_jointly, married_filing_separately,
                                        -- head_of_household, qualifying_widow
    adjusted_gross_income NUMERIC(10,2),
    wages_salaries_tips NUMERIC(10,2),
    self_employment_income NUMERIC(10,2),
    social_security_benefits NUMERIC(10,2),
    taxable_social_security NUMERIC(10,2),  -- portion included in AGI
    tax_exempt_interest NUMERIC(10,2),
    foreign_earned_income NUMERIC(10,2),
    received_at TIMESTAMPTZ NOT NULL DEFAULT now(),
    created_at TIMESTAMPTZ NOT NULL DEFAULT now()
);

-- FDSH (Federal Data Services Hub) verification results.
-- Raw data from canopy-verification, stored in canopy-medicaid per ADR-004.
CREATE TABLE fdsh_results (
    id UUID PRIMARY KEY,
    medicaid_application_id UUID NOT NULL REFERENCES medicaid_applications(id),
    person_id UUID NOT NULL,
    hub_service TEXT NOT NULL,         -- verify_ssa, verify_dhs, verify_irs, verify_cms
    verification_type TEXT NOT NULL,   -- income, citizenship, incarceration, ssn, mec,
                                        -- immigration_status, quarterly_wage
    result_status TEXT NOT NULL,       -- verified, not_verified, inconsistency, unavailable
    result_data JSONB NOT NULL DEFAULT '{}',  -- structured result from hub
    requested_at TIMESTAMPTZ NOT NULL,
    received_at TIMESTAMPTZ NOT NULL DEFAULT now(),
    created_at TIMESTAMPTZ NOT NULL DEFAULT now()
);

-- HIPAA-scoped clinical data.
-- Minimum necessary: only the eligibility-relevant outcome is stored.
-- NO clinical notes, NO diagnosis descriptions, NO treatment plans.
CREATE TABLE clinical_assessments (
    id UUID PRIMARY KEY,
    medicaid_application_id UUID NOT NULL REFERENCES medicaid_applications(id),
    person_id UUID NOT NULL,
    assessment_type TEXT NOT NULL,     -- disability, medical_necessity, functional_limitation,
                                        -- blindness, nursing_facility_level_of_care
    assessor TEXT NOT NULL,            -- provider name or agency
    assessment_date DATE NOT NULL,
    result TEXT NOT NULL,              -- meets_criteria, does_not_meet, pending_review
    -- NO clinical details stored -- only the eligibility-relevant outcome
    -- per HIPAA minimum necessary standard
    created_at TIMESTAMPTZ NOT NULL DEFAULT now()
);

-- All Medicaid COAs evaluated for each application.
-- Multiple COAs may apply; CMD cascade evaluates all; EE15 hierarchy selects the best.
-- Per PAMMS 2052: "Eligibility must be reviewed under all Medicaid COAs before denying."
CREATE TABLE medicaid_eligible_categories (
    id UUID PRIMARY KEY,
    medicaid_application_id UUID NOT NULL REFERENCES medicaid_applications(id),
    person_id UUID NOT NULL,           -- individual being evaluated (each AU member gets separate rows)
    coa_code TEXT NOT NULL,            -- See COA code table below
    coa_track TEXT NOT NULL,           -- magi, non_magi, chip
    eligible BOOLEAN NOT NULL,
    fpl_percentage NUMERIC(5,1),       -- applicant's income as % of FPL for this COA
    fpl_threshold NUMERIC(5,1),        -- threshold for this COA (e.g., 220% for pregnant women)
    income_amount NUMERIC(10,2),       -- countable income used for this COA evaluation
    resource_amount NUMERIC(10,2),     -- countable resources (non-MAGI only)
    spend_down_amount NUMERIC(10,2),   -- for medically needy COAs
    denial_reason TEXT,                -- if not eligible: income_over_limit, resource_over_limit,
                                        -- age_ineligible, state_not_expanded, etc.
    evaluation_order INTEGER NOT NULL, -- position in CMD cascade (lower = evaluated first)
    created_at TIMESTAMPTZ NOT NULL DEFAULT now()
);

-- CHIP-specific tables (children above Medicaid, below CHIP limit).
-- Per PAMMS 2194 and CHIPRA mandatory Medicaid-first screening.
CREATE TABLE chip_applications (
    id UUID PRIMARY KEY,
    medicaid_application_id UUID NOT NULL REFERENCES medicaid_applications(id),
    child_person_id UUID NOT NULL,
    household_id UUID NOT NULL,
    chip_type TEXT NOT NULL,           -- standalone, medicaid_expansion
    premium_tier TEXT,                 -- fpl_134_158, fpl_159_170, fpl_171_190, etc.
    monthly_premium NUMERIC(10,2),    -- per child premium amount
    family_cap_premium NUMERIC(10,2), -- family maximum premium
    premium_exempt BOOLEAN NOT NULL DEFAULT false, -- under 6, foster care, AI/AN
    premium_exemption_reason TEXT,     -- under_6, foster_care, ai_an
    status TEXT NOT NULL DEFAULT 'pending',
    enrollment_effective_date DATE,    -- first day of month application complete + premium paid
    created_at TIMESTAMPTZ NOT NULL DEFAULT now()
);

-- PeachCare premium schedule per PAMMS 2194.
-- Loaded from jurisdiction.toml, stored for audit trail.
CREATE TABLE peachcare_premium_schedule (
    id UUID PRIMARY KEY,
    fpl_lower_bound NUMERIC(5,1) NOT NULL,  -- e.g., 134.0
    fpl_upper_bound NUMERIC(5,1) NOT NULL,  -- e.g., 158.0
    one_child_premium NUMERIC(10,2) NOT NULL,
    family_cap_premium NUMERIC(10,2) NOT NULL,
    effective_date DATE NOT NULL,
    end_date DATE,
    created_at TIMESTAMPTZ NOT NULL DEFAULT now()
);

-- Pathways qualifying activities per PAMMS 2195.
-- Must demonstrate 80 hours/month of qualifying activities.
CREATE TABLE pathways_qualifying_activities (
    id UUID PRIMARY KEY,
    medicaid_application_id UUID NOT NULL REFERENCES medicaid_applications(id),
    person_id UUID NOT NULL,
    activity_type TEXT NOT NULL,        -- unsubsidized_employment, subsidized_private,
                                         -- subsidized_public, on_the_job_training,
                                         -- job_readiness, community_service,
                                         -- vocational_training, higher_education,
                                         -- gvra_vocational_rehab, snap_abawd_compliance,
                                         -- parent_child_under_6
    hours_per_month NUMERIC(5,1) NOT NULL,
    verification_status TEXT NOT NULL DEFAULT 'self_attested',
    verification_document TEXT,
    effective_date DATE NOT NULL,
    end_date DATE,
    created_at TIMESTAMPTZ NOT NULL DEFAULT now()
);

-- Pathways HIPP (Health Insurance Premium Payment) program per PAMMS 2195.
-- Tracks ESI cost-effectiveness determination.
CREATE TABLE pathways_hipp_referrals (
    id UUID PRIMARY KEY,
    medicaid_application_id UUID NOT NULL REFERENCES medicaid_applications(id),
    person_id UUID NOT NULL,
    has_esi_access BOOLEAN NOT NULL,
    cost_effective BOOLEAN,            -- null = pending determination
    esi_monthly_premium NUMERIC(10,2),
    medicaid_capitation_rate NUMERIC(10,2),
    determination_date DATE,
    status TEXT NOT NULL DEFAULT 'pending', -- pending, enrolled, not_cost_effective
    created_at TIMESTAMPTZ NOT NULL DEFAULT now()
);

-- Medicaid determinations produced by this service.
-- Signed per ADR-002, append-only, one per application.
CREATE TABLE medicaid_determinations (
    id UUID PRIMARY KEY,
    medicaid_application_id UUID NOT NULL REFERENCES medicaid_applications(id),
    household_id UUID NOT NULL,
    person_id UUID NOT NULL,           -- individual this determination covers
    status TEXT NOT NULL,              -- approved, denied, pending_spenddown, pending_premium
    assigned_coa TEXT,                 -- EE15 most advantageous COA code
    assigned_coa_track TEXT,           -- magi, non_magi, chip
    benefit_type TEXT,                 -- full_medicaid, chip_standalone, qmb_supplement,
                                        -- family_planning_only, emergency_only
    benefit_amount NUMERIC(10,2),      -- null for most Medicaid (no cash benefit); CHIP premium
    benefit_unit TEXT DEFAULT 'monthly_usd',
    effective_date DATE,
    expiration_date DATE,
    renewal_date DATE,
    continuous_eligibility_end DATE,   -- for 12-month CE periods (children, postpartum)
    basis TEXT,                        -- human-readable narrative
    denial_reason TEXT,
    denial_reason_codes TEXT[],        -- structured codes: income_over_limit, resource_over_limit, etc.
    fmap_rate NUMERIC(5,2),           -- federal matching rate for the assigned COA
    program_service_version TEXT NOT NULL,
    determined_at TIMESTAMPTZ NOT NULL DEFAULT now(),
    signature TEXT NOT NULL,           -- JWS signature per ADR-002
    created_at TIMESTAMPTZ NOT NULL DEFAULT now()
);

-- CMD cascade audit trail.
-- Records the full evaluation path for traceability.
CREATE TABLE cmd_cascade_log (
    id UUID PRIMARY KEY,
    medicaid_application_id UUID NOT NULL REFERENCES medicaid_applications(id),
    person_id UUID NOT NULL,
    evaluation_track TEXT NOT NULL,    -- abd, family
    coa_code TEXT NOT NULL,
    evaluation_order INTEGER NOT NULL,
    eligible BOOLEAN NOT NULL,
    denial_reason TEXT,
    evaluated_at TIMESTAMPTZ NOT NULL DEFAULT now(),
    created_at TIMESTAMPTZ NOT NULL DEFAULT now()
);

-- Indexes
CREATE INDEX idx_medicaid_applications_application ON medicaid_applications(application_id);
CREATE INDEX idx_medicaid_applications_household ON medicaid_applications(household_id);
CREATE INDEX idx_medicaid_applications_status ON medicaid_applications(status);
CREATE INDEX idx_magi_household_application ON magi_household_snapshots(medicaid_application_id);
CREATE INDEX idx_magi_household_person ON magi_household_snapshots(person_id);
CREATE INDEX idx_magi_income_application ON magi_income(medicaid_application_id);
CREATE INDEX idx_magi_income_person ON magi_income(person_id);
CREATE INDEX idx_non_magi_factors_application ON non_magi_factors(medicaid_application_id);
CREATE INDEX idx_non_magi_factors_person ON non_magi_factors(person_id);
CREATE INDEX idx_fti_tax_data_application ON fti_tax_data(medicaid_application_id);
CREATE INDEX idx_fti_tax_data_person ON fti_tax_data(person_id);
CREATE INDEX idx_fdsh_results_application ON fdsh_results(medicaid_application_id);
CREATE INDEX idx_fdsh_results_person ON fdsh_results(person_id);
CREATE INDEX idx_clinical_assessments_application ON clinical_assessments(medicaid_application_id);
CREATE INDEX idx_medicaid_categories_application ON medicaid_eligible_categories(medicaid_application_id);
CREATE INDEX idx_medicaid_categories_person ON medicaid_eligible_categories(person_id);
CREATE INDEX idx_medicaid_categories_coa ON medicaid_eligible_categories(coa_code);
CREATE INDEX idx_chip_applications_medicaid ON chip_applications(medicaid_application_id);
CREATE INDEX idx_chip_applications_child ON chip_applications(child_person_id);
CREATE INDEX idx_pathways_activities_application ON pathways_qualifying_activities(medicaid_application_id);
CREATE INDEX idx_pathways_hipp_application ON pathways_hipp_referrals(medicaid_application_id);
CREATE INDEX idx_medicaid_determinations_application ON medicaid_determinations(medicaid_application_id);
CREATE INDEX idx_medicaid_determinations_person ON medicaid_determinations(person_id);
CREATE INDEX idx_medicaid_determinations_status ON medicaid_determinations(status);
CREATE INDEX idx_cmd_cascade_application ON cmd_cascade_log(medicaid_application_id);
CREATE INDEX idx_cmd_cascade_person ON cmd_cascade_log(person_id);

MAGI Budgeting (PAMMS 2669):

Step 1: For self-employed or farming/fishing individuals,
        deduct all allowable IRS deductions (cost of doing business).
        → magi_income.self_employment_expenses

Step 2: Deduct any before-tax deductions of taxable income.
        → magi_income.before_tax_deduction_amount
        (401k, 403b, health insurance premiums, FSA, HSA, FERS, CSRS)

Step 3: Deduct any 1040 deductions of taxable income.
        → magi_income.magi_adjustment_amount
        (student loan interest, IRA deduction, educator expenses,
         health savings account, alimony paid pre-2019, SE tax, SE health insurance)

Step 4: Subtract 5% of the 100% FPL for the budget group size
        from the net taxable income.
        → This is the MAGI 5% FPL disregard per ACA.
        Amount varies by BG size (loaded from jurisdiction.toml).

Step 5: Select the appropriate income limit for the COA.
        → FPL threshold loaded from jurisdiction.toml per COA and age.

Step 6: Compare net taxable income to the appropriate income limit.
        → If net income ≤ limit: eligible.
        → If net income > limit: ineligible, cascade to next COA via CMD.

/// MAGI budgeting per PAMMS 2669.
/// This is DATA AGGREGATION — the rules engine performs the comparison.
pub fn assemble_magi_budget(
    income_records: &[MagiIncome],
    fti_data: Option<&[FtiTaxData]>,
    ssi_recipient_ids: &[Uuid],
    fpl_5_percent_disregard: Decimal,
) -> MagiBudgetInput {
    // Exclude SSI recipient income (PAMMS 2610)
    let countable_income: Vec<&MagiIncome> = income_records.iter()
        .filter(|i| i.is_countable)
        .filter(|i| !ssi_recipient_ids.contains(&i.person_id))
        .filter(|i| !i.is_child_dependent_excluded)
        .collect();

    // Step 1: Self-employment cost of business
    let self_employment_deductions: Decimal = countable_income.iter()
        .map(|i| i.self_employment_expenses.unwrap_or_default())
        .sum();

    // Step 2: Before-tax deductions
    let before_tax_deductions: Decimal = countable_income.iter()
        .map(|i| i.before_tax_deduction_amount.unwrap_or_default())
        .sum();

    // Step 3: 1040 deductions
    let magi_1040_deductions: Decimal = countable_income.iter()
        .map(|i| i.magi_adjustment_amount.unwrap_or_default())
        .sum();

    // Gross taxable income
    let gross_taxable: Decimal = countable_income.iter()
        .map(|i| i.monthly_amount)
        .sum();

    // If FTI-verified MAGI is available, use it instead of self-reported
    let magi_from_fti = fti_data.and_then(|fti| fti.first()).map(|fti| {
        let agi = fti.adjusted_gross_income.unwrap_or_default();
        let tax_exempt = fti.tax_exempt_interest.unwrap_or_default();
        let foreign = fti.foreign_earned_income.unwrap_or_default();
        let ss_total = fti.social_security_benefits.unwrap_or_default();
        let taxable_ss = fti.taxable_social_security.unwrap_or_default();
        let nontaxable_ss = ss_total - taxable_ss;
        // MAGI = AGI + tax-exempt interest + foreign earned income + non-taxable SS
        (agi + tax_exempt + foreign + nontaxable_ss) / Decimal::from(12) // annualize to monthly
    });

    let net_taxable = magi_from_fti.unwrap_or_else(|| {
        gross_taxable - self_employment_deductions - before_tax_deductions - magi_1040_deductions
    });

    MagiBudgetInput {
        gross_taxable_monthly: gross_taxable,
        self_employment_deductions,
        before_tax_deductions,
        magi_1040_deductions,
        net_taxable_monthly: net_taxable,
        fpl_5_percent_disregard,
        // Step 4 applied by rules engine: net_taxable - fpl_5_percent_disregard
        fti_verified: magi_from_fti.is_some(),
    }
}

pub struct MagiBudgetInput {
    pub gross_taxable_monthly: Decimal,
    pub self_employment_deductions: Decimal,
    pub before_tax_deductions: Decimal,
    pub magi_1040_deductions: Decimal,
    pub net_taxable_monthly: Decimal,
    pub fpl_5_percent_disregard: Decimal,
    pub fti_verified: bool,
}

/// Determine PeachCare premium based on FPL percentage and exemption status.
/// Premium schedule loaded from jurisdiction.toml, not hardcoded.
pub fn determine_peachcare_premium(
    fpl_percentage: Decimal,
    child_age: i32,
    is_foster_care: bool,
    is_ai_an: bool,
    premium_schedule: &[PeachcarePremiumTier],
) -> PeachcarePremiumResult {
    // Exemption check per PAMMS 2194
    if child_age < 6 || is_foster_care || is_ai_an {
        return PeachcarePremiumResult {
            exempt: true,
            exemption_reason: Some(if child_age < 6 {
                "under_6".to_string()
            } else if is_foster_care {
                "foster_care".to_string()
            } else {
                "ai_an".to_string()
            }),
            one_child_premium: Decimal::ZERO,
            family_cap_premium: Decimal::ZERO,
            tier: None,
        };
    }

    // Find matching tier from jurisdiction.toml schedule
    let tier = premium_schedule.iter().find(|t| {
        fpl_percentage >= t.fpl_lower_bound && fpl_percentage <= t.fpl_upper_bound
    });

    match tier {
        Some(t) => PeachcarePremiumResult {
            exempt: false,
            exemption_reason: None,
            one_child_premium: t.one_child_premium,
            family_cap_premium: t.family_cap_premium,
            tier: Some(t.tier_name.clone()),
        },
        None => PeachcarePremiumResult {
            exempt: false,
            exemption_reason: None,
            one_child_premium: Decimal::ZERO,
            family_cap_premium: Decimal::ZERO,
            tier: None,
        },
    }
}

/// Validate Pathways qualifying activities per PAMMS 2195.
/// Returns total hours and whether the 80-hour threshold is met.
pub fn validate_pathways_activities(
    activities: &[PathwaysQualifyingActivity],
) -> PathwaysActivityResult {
    let total_hours: Decimal = activities.iter()
        .map(|a| a.hours_per_month)
        .sum();

    PathwaysActivityResult {
        total_hours_per_month: total_hours,
        meets_threshold: total_hours >= Decimal::from(80),
        activity_count: activities.len(),
        activities_by_type: activities.iter()
            .map(|a| (a.activity_type.clone(), a.hours_per_month))
            .collect(),
    }
}

// medicaid.determined
{
    "event_type": "medicaid.determined",
    "application_id": "uuid",
    "household_id": "uuid",
    "person_id": "uuid",
    "status": "approved|denied|pending_spenddown|pending_premium",
    "assigned_coa": "parent_caretaker",
    "assigned_coa_track": "magi",
    "benefit_type": "full_medicaid",
    "determined_at": "2026-04-07T12:00:00Z"
}

// chip.determined
{
    "event_type": "chip.determined",
    "application_id": "uuid",
    "child_person_id": "uuid",
    "chip_type": "standalone",
    "status": "approved|denied",
    "premium_tier": "fpl_134_158",
    "determined_at": "2026-04-07T12:00:00Z"
}

// medicaid.cmd_cascade_completed
{
    "event_type": "medicaid.cmd_cascade_completed",
    "application_id": "uuid",
    "person_id": "uuid",
    "coas_evaluated": 12,
    "coas_eligible": 2,
    "assigned_coa": "parent_caretaker",
    "completed_at": "2026-04-07T12:00:00Z"
}

/// Published to canopy.events when Medicaid determination completes.
/// Contains NO FTI, NO FDSH details, NO clinical data.
#[derive(Debug, Serialize)]
pub struct MedicaidDeterminedEvent {
    pub event_type: String,
    pub application_id: Uuid,
    pub household_id: Uuid,
    pub person_id: Uuid,
    pub status: String,
    pub assigned_coa: Option<String>,
    pub assigned_coa_track: Option<String>,
    pub benefit_type: Option<String>,
    pub determined_at: DateTime<Utc>,
}

/// Published to canopy.events when CHIP determination completes.
#[derive(Debug, Serialize)]
pub struct ChipDeterminedEvent {
    pub event_type: String,
    pub application_id: Uuid,
    pub child_person_id: Uuid,
    pub chip_type: String,
    pub status: String,
    pub premium_tier: Option<String>,
    pub determined_at: DateTime<Utc>,
}

/// Published after CMD cascade completes for an individual.
#[derive(Debug, Serialize)]
pub struct CmdCascadeCompletedEvent {
    pub event_type: String,
    pub application_id: Uuid,
    pub person_id: Uuid,
    pub coas_evaluated: i32,
    pub coas_eligible: i32,
    pub assigned_coa: Option<String>,
    pub completed_at: DateTime<Utc>,
}

/// Trait for HIPAA minimum necessary access control.
/// Every type exposed via API must declare its data elements.
pub trait HipaaMinimumNecessary: Serialize {
    fn required_elements(&self) -> &[&str];
    fn purpose(&self) -> &str;
}

/// HIPAA-restricted field names that must never appear in API responses or event payloads.
const HIPAA_RESTRICTED_FIELDS: &[&str] = &[
    "diagnosis_code", "diagnosis_description", "clinical_notes",
    "treatment_plan", "provider_notes", "medical_record_number",
    "clinical_details", "disability_details", "medical_history",
    "icd_code", "procedure_code", "lab_results",
];

/// Check a JSON value for HIPAA-restricted field names.
/// Returns a list of violations (field names found that should not be present).
pub fn check_hipaa_compliance(value: &serde_json::Value) -> Vec<String> {
    let mut violations = Vec::new();
    if let serde_json::Value::Object(map) = value {
        for key in map.keys() {
            if HIPAA_RESTRICTED_FIELDS.iter().any(|f| key.contains(f)) {
                violations.push(key.clone());
            }
        }
        for (_, v) in map.iter() {
            violations.extend(check_hipaa_compliance(v));
        }
    }
    violations
}

POST /v1/determine (from canopy-eligibility)
│
├── 1. Parse ApplicationContext, create medicaid_applications row
│      Determine pathway: magi, non_magi, both
│      For each person in the AU, a separate CMD cascade runs
│
├── 2. Build MAGI budget group (per PAMMS 2610)
│   ├── Determine tax filer vs. non-filer status for each person
│   ├── Build BG: tax filer + spouse + dependents (or non-filer equivalent)
│   ├── Count unborn children for pregnant members
│   ├── Mark SSI recipients (in BG, income excluded)
│   └── Store in magi_household_snapshots
│
├── 3. Fetch/verify income data
│   ├── 3a. Self-reported income from canopy-persons
│   ├── 3b. FTI verification (audit-logged under IRC 6103(l)(12))
│   │       MAGI = AGI + tax-exempt interest + foreign earned + non-taxable SS
│   ├── 3c. FDSH verification results from canopy-verification
│   ├── 3d. Clinical assessments for non-MAGI (disability, blindness, LOC)
│   └── Store in magi_income, non_magi_factors, fti_tax_data, fdsh_results,
│       clinical_assessments
│
├── 4. MAGI budgeting (per PAMMS 2669)
│   ├── Step 1: Deduct self-employment cost of business
│   ├── Step 2: Deduct before-tax deductions
│   ├── Step 3: Deduct 1040 deductions
│   ├── Step 4: Apply 5% FPL disregard
│   ├── Step 5: Select appropriate FPL limit per COA
│   └── Step 6: Compare → eligible or cascade to next COA
│
├── 5. CMD cascade: ABD track (per PAMMS 2052)
│   ├── FBR COAs: SSI, Pickle, DAC, DW, Widow(er), Former SSI DC
│   ├── LA-D/CAP COAs: EDWP, NOW, COMP, TEFRA, Hospice, Hospital, ICWP, NH
│   ├── Q-Track COAs: QMB, SLMB, QI-1
│   ├── AMN (spenddown)
│   └── Record each in medicaid_eligible_categories + cmd_cascade_log
│
├── 6. CMD cascade: Family track (per PAMMS 2052)
│   ├── Newborn
│   ├── Pregnant Women (220% FPL)
│   ├── Parent/Caretaker
│   ├── TMA, 4MEx
│   ├── Children Under 19 (age-tiered: 205%/149%/133% FPL)
│   ├── PeachCare (134-247% FPL; CHIPRA screen Medicaid first)
│   ├── FM-MN, Pregnant MN (spenddown)
│   ├── WHM (200% FPL, breast/cervical cancer)
│   ├── Pathways (100% FPL, 80 hr/mo qualifying activity)
│   ├── P4HB (211% FPL, ages 18-44)
│   └── Record each in medicaid_eligible_categories + cmd_cascade_log
│
├── 7. Pathways-specific: validate qualifying activities (80 hr/month)
│      Store in pathways_qualifying_activities
│      If has ESI access, create pathways_hipp_referrals record
│
├── 8. PeachCare-specific: calculate premium tier
│      Store in chip_applications with premium amounts
│      Check exemption status (under 6, foster care, AI/AN)
│
├── 9. Apply EE15 hierarchy
│      Collect all eligible COAs from both tracks
│      Call canopy-rules with medicaid-eligibility-hierarchy ruleset
│      Assign most advantageous group + determine FMAP rate
│
├── 10. Build Determination struct
│       Sign with ECDSA P-256 (DeterminationSigner)
│       Store in medicaid_determinations
│
├── 11. Publish events (FTI-scrubbed, HIPAA-compliant payload)
│       medicaid.determined — { application_id, person_id, status, assigned_coa }
│       chip.determined — { application_id, child_person_id, chip_type, status }
│       medicaid.cmd_cascade_completed — { coas_evaluated, coas_eligible }
│       NO income, NO FTI, NO FDSH details, NO clinical data
│
└── 12. Return signed Determination to canopy-eligibility

/// Medicaid categories ordered by advantageousness for EE15 hierarchy.
/// Lower advantage_rank = more advantageous (assigned first).
///
/// Per PAMMS 2052 and 42 CFR 435: assign to the group that provides
/// the most benefit to the applicant.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum MedicaidCategory {
    // Family MAGI (most advantageous first)
    Newborn,
    PregnantWomen,
    ParentCaretaker,
    ChildrenUnder19,
    Tma,
    FourMonthsExtended,
    FormerFosterCare,
    // Family non-MAGI
    FmMedicallyNeedy,
    PregnantMedicallyNeedy,
    Refugee,
    FosterCare,
    Adoption,
    Chafee,
    Whm,
    // MAGI expansion / waiver
    Pathways,
    P4hbFp,
    P4hbIpc,
    P4hbRm,
    // ABD FBR
    SsiMedicaid,
    Pickle,
    Dac,
    DisabledWidow,
    Widow6064,
    FormerSsiDisabledChild,
    // ABD non-FBR
    Edwp,
    NowWaiver,
    CompWaiver,
    TefraKatieBeckett,
    Hospice,
    Hospital,
    Icwp,
    NursingHome,
    Qdwi,
    // ABD Q-Track
    Qmb,
    Slmb,
    Qi1,
    // ABD Medically Needy
    Amn,
    // CHIP
    PeachCare,
}

impl MedicaidCategory {
    pub fn coa_code(&self) -> &'static str {
        match self {
            Self::Newborn => "newborn",
            Self::PregnantWomen => "pregnant_women",
            Self::ParentCaretaker => "parent_caretaker",
            Self::ChildrenUnder19 => "children_under_19",
            Self::Tma => "tma",
            Self::FourMonthsExtended => "four_months_extended",
            Self::FormerFosterCare => "former_foster_care",
            Self::FmMedicallyNeedy => "fm_medically_needy",
            Self::PregnantMedicallyNeedy => "pregnant_medically_needy",
            Self::Refugee => "refugee",
            Self::FosterCare => "foster_care",
            Self::Adoption => "adoption",
            Self::Chafee => "chafee",
            Self::Whm => "whm",
            Self::Pathways => "pathways",
            Self::P4hbFp => "p4hb_fp",
            Self::P4hbIpc => "p4hb_ipc",
            Self::P4hbRm => "p4hb_rm",
            Self::SsiMedicaid => "ssi_medicaid",
            Self::Pickle => "pickle",
            Self::Dac => "dac",
            Self::DisabledWidow => "disabled_widow",
            Self::Widow6064 => "widow_60_64",
            Self::FormerSsiDisabledChild => "former_ssi_disabled_child",
            Self::Edwp => "edwp",
            Self::NowWaiver => "now_waiver",
            Self::CompWaiver => "comp_waiver",
            Self::TefraKatieBeckett => "tefra_katie_beckett",
            Self::Hospice => "hospice",
            Self::Hospital => "hospital",
            Self::Icwp => "icwp",
            Self::NursingHome => "nursing_home",
            Self::Qdwi => "qdwi",
            Self::Qmb => "qmb",
            Self::Slmb => "slmb",
            Self::Qi1 => "qi_1",
            Self::Amn => "amn",
            Self::PeachCare => "peachcare",
        }
    }

    pub fn track(&self) -> &'static str {
        match self {
            Self::Newborn | Self::FmMedicallyNeedy | Self::PregnantMedicallyNeedy
            | Self::Refugee | Self::FosterCare | Self::Adoption | Self::Chafee
            | Self::Whm => "non_magi",
            Self::SsiMedicaid | Self::Pickle | Self::Dac | Self::DisabledWidow
            | Self::Widow6064 | Self::FormerSsiDisabledChild | Self::Edwp
            | Self::NowWaiver | Self::CompWaiver | Self::TefraKatieBeckett
            | Self::Hospice | Self::Hospital | Self::Icwp | Self::NursingHome
            | Self::Qdwi | Self::Qmb | Self::Slmb | Self::Qi1 | Self::Amn => "non_magi",
            Self::PeachCare => "chip",
            _ => "magi",
        }
    }
}

/// Assign the most advantageous Medicaid COA from eligible COAs.
/// The actual priority ordering is determined by the rules engine
/// (medicaid-eligibility-hierarchy ruleset) which has jurisdiction-specific
/// overrides. This function provides a fallback ordering.
pub fn assign_most_advantageous_coa(
    eligible_coas: &[MedicaidCategory],
) -> Option<MedicaidCategory> {
    if eligible_coas.is_empty() {
        return None;
    }
    // The rules engine determines the final assignment.
    // This is a Rust-side fallback using the PAMMS 2052 evaluation order.
    let mut sorted = eligible_coas.to_vec();
    sorted.sort_by_key(|c| cmd_cascade_order(c));
    sorted.first().cloned()
}

fn cmd_cascade_order(cat: &MedicaidCategory) -> u32 {
    match cat {
        // Family track order per PAMMS 2052
        MedicaidCategory::Newborn => 1,
        MedicaidCategory::PregnantWomen => 2,
        MedicaidCategory::ParentCaretaker => 3,
        MedicaidCategory::Tma => 4,
        MedicaidCategory::FourMonthsExtended => 5,
        MedicaidCategory::ChildrenUnder19 => 6,
        MedicaidCategory::PeachCare => 7,
        MedicaidCategory::FmMedicallyNeedy => 8,
        MedicaidCategory::PregnantMedicallyNeedy => 9,
        MedicaidCategory::Whm => 10,
        MedicaidCategory::Pathways => 11,
        MedicaidCategory::P4hbFp => 12,
        MedicaidCategory::P4hbIpc => 13,
        MedicaidCategory::P4hbRm => 14,
        MedicaidCategory::FormerFosterCare => 15,
        MedicaidCategory::Refugee => 16,
        MedicaidCategory::FosterCare => 17,
        MedicaidCategory::Adoption => 18,
        MedicaidCategory::Chafee => 19,
        // ABD track order per PAMMS 2052
        MedicaidCategory::SsiMedicaid => 20,
        MedicaidCategory::Pickle => 21,
        MedicaidCategory::Dac => 22,
        MedicaidCategory::DisabledWidow => 23,
        MedicaidCategory::Widow6064 => 24,
        MedicaidCategory::FormerSsiDisabledChild => 25,
        MedicaidCategory::Edwp => 26,
        MedicaidCategory::NowWaiver => 27,
        MedicaidCategory::CompWaiver => 28,
        MedicaidCategory::TefraKatieBeckett => 29,
        MedicaidCategory::Hospice => 30,
        MedicaidCategory::Hospital => 31,
        MedicaidCategory::Icwp => 32,
        MedicaidCategory::NursingHome => 33,
        MedicaidCategory::Qmb => 34,
        MedicaidCategory::Slmb => 35,
        MedicaidCategory::Qi1 => 36,
        MedicaidCategory::Qdwi => 37,
        MedicaidCategory::Amn => 38,
    }
}

// services/canopy-medicaid/src/store/fti.rs

use canopy_common::fti_audit::{fti_audited, FtiPurposeCode, FtiAction};

pub async fn read_fti_for_magi(
    pool: &PgPool,
    medicaid_application_id: Uuid,
    person_id: Uuid,
    accessed_by: &str,
    request_id: Option<Uuid>,
    ip_address: Option<&str>,
) -> Result<Vec<FtiTaxData>, FtiAuditError> {
    fti_audited(
        pool,
        accessed_by,
        FtiPurposeCode::MedicaidMagi,
        &["adjusted_gross_income", "filing_status", "wages_salaries_tips",
          "social_security_benefits", "taxable_social_security",
          "tax_exempt_interest", "foreign_earned_income"],
        "canopy-medicaid",
        FtiAction::Read,
        "fti_tax_data",
        None,
        request_id,
        ip_address,
        || async {
            sqlx::query_as::<_, FtiTaxData>(
                "SELECT * FROM fti_tax_data
                 WHERE medicaid_application_id = $1 AND person_id = $2"
            )
            .bind(medicaid_application_id)
            .bind(person_id)
            .fetch_all(pool)
            .await
            .map_err(FtiAuditError::Database)
        },
    )
    .await
}

pub async fn read_fti_for_eligibility(
    pool: &PgPool,
    medicaid_application_id: Uuid,
    person_id: Uuid,
    accessed_by: &str,
    request_id: Option<Uuid>,
    ip_address: Option<&str>,
) -> Result<Vec<FtiTaxData>, FtiAuditError> {
    fti_audited(
        pool,
        accessed_by,
        FtiPurposeCode::MedicaidEligibility,
        &["adjusted_gross_income", "filing_status"],
        "canopy-medicaid",
        FtiAction::Read,
        "fti_tax_data",
        None,
        request_id,
        ip_address,
        || async {
            sqlx::query_as::<_, FtiTaxData>(
                "SELECT * FROM fti_tax_data
                 WHERE medicaid_application_id = $1 AND person_id = $2"
            )
            .bind(medicaid_application_id)
            .bind(person_id)
            .fetch_all(pool)
            .await
            .map_err(FtiAuditError::Database)
        },
    )
    .await
}

pub async fn read_fti_for_chip(
    pool: &PgPool,
    medicaid_application_id: Uuid,
    person_id: Uuid,
    accessed_by: &str,
    request_id: Option<Uuid>,
    ip_address: Option<&str>,
) -> Result<Vec<FtiTaxData>, FtiAuditError> {
    fti_audited(
        pool,
        accessed_by,
        FtiPurposeCode::ChipEligibility,
        &["adjusted_gross_income", "filing_status"],
        "canopy-medicaid",
        FtiAction::Read,
        "fti_tax_data",
        None,
        request_id,
        ip_address,
        || async {
            sqlx::query_as::<_, FtiTaxData>(
                "SELECT * FROM fti_tax_data
                 WHERE medicaid_application_id = $1 AND person_id = $2"
            )
            .bind(medicaid_application_id)
            .bind(person_id)
            .fetch_all(pool)
            .await
            .map_err(FtiAuditError::Database)
        },
    )
    .await
}

// services/canopy-medicaid/src/store/fdsh.rs

pub async fn insert_fdsh_result(pool: &PgPool, result: &FdshResult) -> Result<(), sqlx::Error> {
    sqlx::query(
        "INSERT INTO fdsh_results
            (id, medicaid_application_id, person_id, hub_service, verification_type,
             result_status, result_data, requested_at, received_at)
         VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)"
    )
    .bind(result.id)
    .bind(result.medicaid_application_id)
    .bind(result.person_id)
    .bind(&result.hub_service)
    .bind(&result.verification_type)
    .bind(&result.result_status)
    .bind(&result.result_data)
    .bind(result.requested_at)
    .bind(result.received_at)
    .execute(pool)
    .await?;
    Ok(())
}

pub async fn get_fdsh_results(
    pool: &PgPool,
    medicaid_application_id: Uuid,
    person_id: Uuid,
) -> Result<Vec<FdshResult>, sqlx::Error> {
    sqlx::query_as::<_, FdshResult>(
        "SELECT * FROM fdsh_results
         WHERE medicaid_application_id = $1 AND person_id = $2"
    )
    .bind(medicaid_application_id)
    .bind(person_id)
    .fetch_all(pool)
    .await
}

// services/canopy-medicaid/src/store/clinical.rs

pub async fn insert_clinical_assessment(
    pool: &PgPool,
    assessment: &ClinicalAssessment,
) -> Result<(), sqlx::Error> {
    sqlx::query(
        "INSERT INTO clinical_assessments
            (id, medicaid_application_id, person_id, assessment_type,
             assessor, assessment_date, result)
         VALUES ($1, $2, $3, $4, $5, $6, $7)"
    )
    .bind(assessment.id)
    .bind(assessment.medicaid_application_id)
    .bind(assessment.person_id)
    .bind(&assessment.assessment_type)
    .bind(&assessment.assessor)
    .bind(assessment.assessment_date)
    .bind(&assessment.result)
    .execute(pool)
    .await?;
    Ok(())
}

pub async fn get_clinical_assessments(
    pool: &PgPool,
    medicaid_application_id: Uuid,
    person_id: Uuid,
) -> Result<Vec<ClinicalAssessment>, sqlx::Error> {
    sqlx::query_as::<_, ClinicalAssessment>(
        "SELECT * FROM clinical_assessments
         WHERE medicaid_application_id = $1 AND person_id = $2"
    )
    .bind(medicaid_application_id)
    .bind(person_id)
    .fetch_all(pool)
    .await
}

// services/canopy-medicaid/src/store/households.rs

pub async fn create_magi_snapshot(
    pool: &PgPool,
    medicaid_application_id: Uuid,
    bg: &MagiBudgetGroup,
) -> Result<MagiHouseholdSnapshot, sqlx::Error> {
    sqlx::query_as::<_, MagiHouseholdSnapshot>(
        "INSERT INTO magi_household_snapshots
            (id, medicaid_application_id, household_id, person_id, is_tax_filer,
             tax_filer_person_id, filing_status, magi_household_size,
             spouse_person_id, dependents_person_ids, pregnant_member_ids,
             unborn_count, ssi_recipient_ids)
         VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13)
         RETURNING *"
    )
    .bind(Uuid::now_v7())
    .bind(medicaid_application_id)
    .bind(bg.household_id)
    .bind(bg.person_id)
    .bind(bg.is_tax_filer)
    .bind(bg.tax_filer_id)
    .bind(&bg.filing_status)
    .bind(bg.household_size)
    .bind(bg.spouse_id)
    .bind(&bg.dependents)
    .bind(&bg.pregnant_member_ids)
    .bind(bg.unborn_count)
    .bind(&bg.ssi_recipient_ids)
    .fetch_one(pool)
    .await
}

// services/canopy-medicaid/src/abd.rs

pub async fn evaluate_abd_cascade(
    pool: &PgPool,
    application: &MedicaidApplication,
    person_id: Uuid,
    factors: &NonMagiFactors,
    rules_client: &MedicaidRulesClient,
) -> Result<Vec<MedicaidEligibleCategory>, AbdError> {
    let mut categories = Vec::new();
    let mut order: i32 = 0;

    // FBR COAs
    for coa in &[
        MedicaidCategory::SsiMedicaid, MedicaidCategory::Pickle,
        MedicaidCategory::Dac, MedicaidCategory::DisabledWidow,
        MedicaidCategory::Widow6064, MedicaidCategory::FormerSsiDisabledChild,
    ] {
        order += 1;
        let result = evaluate_single_abd_coa(
            pool, application.id, person_id, factors, coa, order, rules_client,
        ).await?;
        categories.push(result);
    }

    // Non-FBR institutional COAs
    for coa in &[
        MedicaidCategory::Edwp, MedicaidCategory::NowWaiver,
        MedicaidCategory::CompWaiver, MedicaidCategory::TefraKatieBeckett,
        MedicaidCategory::Hospice, MedicaidCategory::Hospital,
        MedicaidCategory::Icwp, MedicaidCategory::NursingHome,
    ] {
        order += 1;
        let result = evaluate_single_abd_coa(
            pool, application.id, person_id, factors, coa, order, rules_client,
        ).await?;
        categories.push(result);
    }

    // Q-Track COAs
    for coa in &[
        MedicaidCategory::Qmb, MedicaidCategory::Slmb, MedicaidCategory::Qi1,
    ] {
        order += 1;
        let result = evaluate_single_abd_coa(
            pool, application.id, person_id, factors, coa, order, rules_client,
        ).await?;
        categories.push(result);
    }

    // QDWI
    order += 1;
    let qdwi_result = evaluate_single_abd_coa(
        pool, application.id, person_id, factors, &MedicaidCategory::Qdwi, order, rules_client,
    ).await?;
    categories.push(qdwi_result);

    // AMN (always evaluated last in ABD track)
    order += 1;
    let amn_result = evaluate_single_abd_coa(
        pool, application.id, person_id, factors, &MedicaidCategory::Amn, order, rules_client,
    ).await?;
    categories.push(amn_result);

    Ok(categories)
}

// services/canopy-medicaid/src/family_magi.rs

pub async fn evaluate_family_magi_cascade(
    pool: &PgPool,
    application: &MedicaidApplication,
    person_id: Uuid,
    budget: &MagiBudgetInput,
    household: &MagiHouseholdSnapshot,
    person_age: i32,
    is_pregnant: bool,
    is_parent_caretaker: bool,
    expected_children: i32,
    rules_client: &MedicaidRulesClient,
    params: &MedicaidParams,
) -> Result<Vec<MedicaidEligibleCategory>, FamilyMagiError> {
    let mut categories = Vec::new();
    let mut order: i32 = 0;

    // Pregnant Women (PAMMS 2184)
    if is_pregnant {
        order += 1;
        let input = MagiInput {
            household_size: household.magi_household_size,
            magi_income: budget.net_taxable_monthly,
            fpl_5_percent_disregard: budget.fpl_5_percent_disregard,
            coa_code: "pregnant_women".into(),
            fpl_threshold: params.pregnant_women_fpl_threshold,
            applicant_age: person_age,
            is_pregnant: true,
            expected_children,
        };
        let result = rules_client.evaluate_magi(input).await?;
        let cat = store::categories::insert_eligible_category(
            pool, application.id, person_id, "pregnant_women", "magi",
            result.eligible, result.fpl_percentage, result.fpl_threshold,
            Some(budget.net_taxable_monthly), None, None,
            result.denial_reason.as_deref(), order,
        ).await?;
        categories.push(cat);
    }

    // Parent/Caretaker (PAMMS 2162)
    if is_parent_caretaker && person_age >= 19 {
        order += 1;
        let input = MagiInput {
            household_size: household.magi_household_size,
            magi_income: budget.net_taxable_monthly,
            fpl_5_percent_disregard: budget.fpl_5_percent_disregard,
            coa_code: "parent_caretaker".into(),
            fpl_threshold: params.parent_caretaker_fpl_threshold,
            applicant_age: person_age,
            is_pregnant,
            expected_children: 0,
        };
        let result = rules_client.evaluate_magi(input).await?;
        let cat = store::categories::insert_eligible_category(
            pool, application.id, person_id, "parent_caretaker", "magi",
            result.eligible, result.fpl_percentage, result.fpl_threshold,
            Some(budget.net_taxable_monthly), None, None,
            result.denial_reason.as_deref(), order,
        ).await?;
        categories.push(cat);
    }

    // Children Under 19 (PAMMS 2182) -- age-tiered thresholds
    if person_age < 19 {
        order += 1;
        let fpl_threshold = if person_age < 1 {
            params.children_birth_to_1_fpl_threshold  // 205% FPL
        } else if person_age < 6 {
            params.children_1_to_5_fpl_threshold      // 149% FPL
        } else {
            params.children_6_to_18_fpl_threshold     // 133% FPL
        };
        let input = MagiInput {
            household_size: household.magi_household_size,
            magi_income: budget.net_taxable_monthly,
            fpl_5_percent_disregard: budget.fpl_5_percent_disregard,
            coa_code: "children_under_19".into(),
            fpl_threshold,
            applicant_age: person_age,
            is_pregnant: false,
            expected_children: 0,
        };
        let result = rules_client.evaluate_magi(input).await?;
        let cat = store::categories::insert_eligible_category(
            pool, application.id, person_id, "children_under_19", "magi",
            result.eligible, result.fpl_percentage, result.fpl_threshold,
            Some(budget.net_taxable_monthly), None, None,
            result.denial_reason.as_deref(), order,
        ).await?;
        categories.push(cat);
    }

    Ok(categories)
}

// services/canopy-medicaid/src/chip.rs

pub async fn evaluate_peachcare(
    pool: &PgPool,
    medicaid_application_id: Uuid,
    household_id: Uuid,
    child_person_id: Uuid,
    child_age: i32,
    household_magi: Decimal,
    household_size: i32,
    medicaid_child_eligible: bool,
    is_foster_care: bool,
    is_ai_an: bool,
    rules_client: &MedicaidRulesClient,
    premium_schedule: &[PeachcarePremiumTier],
) -> Result<Option<ChipApplication>, ChipError> {
    // CHIPRA mandatory Medicaid-first screening
    if medicaid_child_eligible {
        return Ok(None);
    }

    let input = ChipInput {
        child_person_id,
        household_magi,
        household_size,
        child_age,
    };

    let output = rules_client.evaluate_chip(input).await?;

    if !output.eligible {
        // Record ineligible result
        store::categories::insert_eligible_category(
            pool, medicaid_application_id, child_person_id, "peachcare", "chip",
            false, Some(output.fpl_percentage), Some(Decimal::from(247)), // 247% FPL
            Some(household_magi), None, None,
            output.denial_reason.as_deref(), 0,
        ).await?;
        return Ok(None);
    }

    // Calculate premium
    let premium = determine_peachcare_premium(
        output.fpl_percentage, child_age, is_foster_care, is_ai_an, premium_schedule,
    );

    let chip_app = store::chip::create_chip_application(
        pool,
        medicaid_application_id,
        child_person_id,
        household_id,
        &output.chip_type,
        premium.tier.as_deref(),
        Some(premium.one_child_premium),
        Some(premium.family_cap_premium),
        premium.exempt,
        premium.exemption_reason.as_deref(),
    ).await?;

    store::categories::insert_eligible_category(
        pool, medicaid_application_id, child_person_id, "peachcare", "chip",
        true, Some(output.fpl_percentage), Some(Decimal::from(247)),
        Some(household_magi), None, None,
        None, 0,
    ).await?;

    Ok(Some(chip_app))
}

// services/canopy-medicaid/src/pathways.rs

pub async fn evaluate_pathways(
    pool: &PgPool,
    application: &MedicaidApplication,
    person_id: Uuid,
    person_age: i32,
    budget: &MagiBudgetInput,
    household_size: i32,
    other_coas_eligible: bool,
    activities: &[PathwaysQualifyingActivity],
    has_esi_access: bool,
    rules_client: &MedicaidRulesClient,
    params: &MedicaidParams,
) -> Result<MedicaidEligibleCategory, PathwaysError> {
    // Age check: 19-64
    if person_age < 19 || person_age > 64 {
        return store::categories::insert_eligible_category(
            pool, application.id, person_id, "pathways", "magi",
            false, None, Some(params.pathways_fpl_threshold),
            Some(budget.net_taxable_monthly), None, None,
            Some("age_ineligible"), 0,
        ).await.map_err(PathwaysError::Database);
    }

    // Must not be eligible for any other Medicaid COA
    if other_coas_eligible {
        return store::categories::insert_eligible_category(
            pool, application.id, person_id, "pathways", "magi",
            false, None, Some(params.pathways_fpl_threshold),
            Some(budget.net_taxable_monthly), None, None,
            Some("eligible_for_other_coa"), 0,
        ).await.map_err(PathwaysError::Database);
    }

    // Validate qualifying activities (80 hours/month)
    let activity_result = validate_pathways_activities(activities);
    if !activity_result.meets_threshold {
        return store::categories::insert_eligible_category(
            pool, application.id, person_id, "pathways", "magi",
            false, None, Some(params.pathways_fpl_threshold),
            Some(budget.net_taxable_monthly), None, None,
            Some("qualifying_activities_below_80_hours"), 0,
        ).await.map_err(PathwaysError::Database);
    }

    // Store activities
    for activity in activities {
        store::pathways::insert_qualifying_activity(pool, application.id, person_id, activity)
            .await.map_err(PathwaysError::Database)?;
    }

    // HIPP referral if ESI access
    if has_esi_access {
        store::pathways::create_hipp_referral(pool, application.id, person_id)
            .await.map_err(PathwaysError::Database)?;
    }

    // Evaluate via rules engine
    let input = MagiInput {
        household_size,
        magi_income: budget.net_taxable_monthly,
        fpl_5_percent_disregard: budget.fpl_5_percent_disregard,
        coa_code: "pathways".into(),
        fpl_threshold: params.pathways_fpl_threshold, // 100% FPL (95% after disregard)
        applicant_age: person_age,
        is_pregnant: false,
        expected_children: 0,
    };
    let result = rules_client.evaluate_magi(input).await?;

    store::categories::insert_eligible_category(
        pool, application.id, person_id, "pathways", "magi",
        result.eligible, result.fpl_percentage, result.fpl_threshold,
        Some(budget.net_taxable_monthly), None, None,
        result.denial_reason.as_deref(), 0,
    ).await.map_err(PathwaysError::Database)
}

// services/canopy-medicaid/src/cmd_cascade.rs

pub struct CmdCascadeResult {
    pub eligible_coas: Vec<MedicaidEligibleCategory>,
    pub all_evaluated: Vec<MedicaidEligibleCategory>,
    pub cascade_log: Vec<CmdCascadeLogEntry>,
}

pub async fn run_cmd_cascade(
    pool: &PgPool,
    application: &MedicaidApplication,
    person_id: Uuid,
    context: &PersonContext,
    budget: &MagiBudgetInput,
    household: &MagiHouseholdSnapshot,
    factors: Option<&NonMagiFactors>,
    activities: &[PathwaysQualifyingActivity],
    rules_client: &MedicaidRulesClient,
    params: &MedicaidParams,
) -> Result<CmdCascadeResult, CmdCascadeError> {
    let mut all_categories = Vec::new();
    let mut cascade_log = Vec::new();

    // ABD track (if applicable: age >= 65, or disability, or blindness)
    if context.may_qualify_abd() {
        if let Some(f) = factors {
            let abd_results = abd::evaluate_abd_cascade(
                pool, application, person_id, f, rules_client,
            ).await?;
            for cat in &abd_results {
                cascade_log.push(CmdCascadeLogEntry {
                    track: "abd".into(),
                    coa_code: cat.coa_code.clone(),
                    order: cat.evaluation_order,
                    eligible: cat.eligible,
                    denial_reason: cat.denial_reason.clone(),
                });
            }
            all_categories.extend(abd_results);
        }
    }

    // Family MAGI track
    let family_magi = family_magi::evaluate_family_magi_cascade(
        pool, application, person_id, budget, household,
        context.age, context.is_pregnant, context.is_parent_caretaker,
        context.expected_children, rules_client, params,
    ).await?;
    for cat in &family_magi {
        cascade_log.push(CmdCascadeLogEntry {
            track: "family".into(),
            coa_code: cat.coa_code.clone(),
            order: cat.evaluation_order,
            eligible: cat.eligible,
            denial_reason: cat.denial_reason.clone(),
        });
    }
    all_categories.extend(family_magi);

    // PeachCare (CHIP) -- only for children under 19
    let medicaid_child_eligible = all_categories.iter()
        .any(|c| c.coa_code == "children_under_19" && c.eligible);

    if context.age < 19 {
        if let Some(chip_app) = chip::evaluate_peachcare(
            pool, application.id, application.household_id,
            person_id, context.age,
            budget.net_taxable_monthly, household.magi_household_size,
            medicaid_child_eligible,
            context.is_foster_care, context.is_ai_an,
            rules_client, &params.peachcare_premium_schedule,
        ).await? {
            cascade_log.push(CmdCascadeLogEntry {
                track: "family".into(),
                coa_code: "peachcare".into(),
                order: 7,
                eligible: true,
                denial_reason: None,
            });
        }
    }

    // Family non-MAGI COAs
    let family_non_magi = family_non_magi::evaluate_family_non_magi_cascade(
        pool, application, person_id, context, budget, rules_client, params,
    ).await?;
    for cat in &family_non_magi {
        cascade_log.push(CmdCascadeLogEntry {
            track: "family".into(),
            coa_code: cat.coa_code.clone(),
            order: cat.evaluation_order,
            eligible: cat.eligible,
            denial_reason: cat.denial_reason.clone(),
        });
    }
    all_categories.extend(family_non_magi);

    // Pathways (evaluated LAST -- only if not eligible for any other COA)
    let other_coas_eligible = all_categories.iter().any(|c| c.eligible);
    if context.age >= 19 && context.age <= 64 {
        let pathways_result = pathways::evaluate_pathways(
            pool, application, person_id, context.age,
            budget, household.magi_household_size,
            other_coas_eligible, activities,
            context.has_esi_access, rules_client, params,
        ).await?;
        cascade_log.push(CmdCascadeLogEntry {
            track: "family".into(),
            coa_code: "pathways".into(),
            order: 11,
            eligible: pathways_result.eligible,
            denial_reason: pathways_result.denial_reason.clone(),
        });
        all_categories.push(pathways_result);
    }

    // Persist cascade log
    for entry in &cascade_log {
        store::cmd_cascade::insert_cascade_entry(
            pool, application.id, person_id, entry,
        ).await?;
    }

    let eligible_coas: Vec<_> = all_categories.iter()
        .filter(|c| c.eligible)
        .cloned()
        .collect();

    Ok(CmdCascadeResult {
        eligible_coas,
        all_evaluated: all_categories,
        cascade_log,
    })
}

// services/canopy-medicaid/src/hierarchy.rs

pub async fn evaluate_hierarchy(
    eligible_categories: &[MedicaidEligibleCategory],
    rules_client: &MedicaidRulesClient,
) -> Result<HierarchyResult, HierarchyError> {
    let eligible: Vec<_> = eligible_categories.iter()
        .filter(|c| c.eligible)
        .collect();

    if eligible.is_empty() {
        return Err(HierarchyError::NoEligibleCategories);
    }

    let input = serde_json::json!({
        "eligible_categories": eligible.iter().map(|c| {
            serde_json::json!({
                "coa_code": c.coa_code,
                "coa_track": c.coa_track,
                "fpl_percentage": c.fpl_percentage,
                "income_amount": c.income_amount,
                "resource_amount": c.resource_amount,
                "spend_down_amount": c.spend_down_amount,
            })
        }).collect::<Vec<_>>(),
    });

    let result = rules_client.evaluate_hierarchy(input).await?;
    Ok(HierarchyResult {
        assigned_coa: result.assigned_coa,
        assigned_coa_track: result.assigned_coa_track,
        fmap_rate: result.fmap_rate,
        basis: result.basis,
    })
}

pub struct HierarchyResult {
    pub assigned_coa: String,
    pub assigned_coa_track: String,
    pub fmap_rate: Decimal,
    pub basis: String,
}

#[derive(Debug, thiserror::Error)]
pub enum HierarchyError {
    #[error("no eligible categories to evaluate")]
    NoEligibleCategories,
    #[error("rules evaluation failed: {0}")]
    Rules(#[from] RulesError),
}

// services/canopy-medicaid/src/determine.rs

pub async fn handle_determine(
    claims: Extension<Claims>,
    State(state): State<AppState>,
    Json(context): Json<ApplicationContext>,
) -> Result<Json<SignedDetermination>, ApiError> {
    // 1. Create application
    let pathway = determine_pathway(&context);
    let app = store::applications::create_application(
        state.db.inner(), context.application_id, context.household_id,
        context.applicant_person_id, &pathway,
    ).await.map_err(|e| ApiError::internal("create application", e))?;

    // 2. Build MAGI budget group (PAMMS 2610)
    let magi_bg = magi_household::build_magi_budget_group(
        context.applicant_person_id,
        context.is_tax_filer,
        context.tax_filer_id,
        context.spouse_id,
        context.dependents.clone(),
        context.children_under_19.clone(),
        context.parents_in_home.clone(),
        context.siblings_under_19.clone(),
        context.pregnant_member_ids.clone(),
        &context.expected_children_per_member,
        context.ssi_recipient_ids.clone(),
    );
    let snapshot = store::households::create_magi_snapshot(
        state.db.inner(), app.id, &magi_bg,
    ).await.map_err(|e| ApiError::internal("create snapshot", e))?;

    // 3. Fetch income, FTI (audit-logged), FDSH, clinical assessments
    let fti_data = store::fti::read_fti_for_magi(
        state.db.inner(), app.id, context.applicant_person_id,
        &claims.sub, Some(context.request_id), claims.ip_address.as_deref(),
    ).await?;

    // 4. MAGI budgeting (PAMMS 2669)
    let budget = magi_budget::assemble_magi_budget(
        &context.income_records, Some(&fti_data),
        &magi_bg.ssi_recipient_ids,
        state.params.fpl_5_percent_disregard(magi_bg.household_size),
    );

    // 5-10. CMD cascade
    let cascade_result = cmd_cascade::run_cmd_cascade(
        state.db.inner(), &app, context.applicant_person_id,
        &context.person_context, &budget, &snapshot,
        context.non_magi_factors.as_ref(),
        &context.pathways_activities,
        &state.rules_client, &state.params,
    ).await?;

    // 11. EE15 hierarchy
    let (status, hierarchy, denial_reason) = if cascade_result.eligible_coas.is_empty() {
        ("denied".to_string(), None, Some("ineligible_all_coas".to_string()))
    } else {
        let h = hierarchy::evaluate_hierarchy(
            &cascade_result.eligible_coas, &state.rules_client,
        ).await?;
        ("approved".to_string(), Some(h), None)
    };

    // 12. Build and sign determination
    let det_id = Uuid::now_v7();
    let now = Utc::now();
    let mut determination = MedicaidDetermination {
        id: det_id,
        medicaid_application_id: app.id,
        household_id: context.household_id,
        person_id: context.applicant_person_id,
        status: status.clone(),
        assigned_coa: hierarchy.as_ref().map(|h| h.assigned_coa.clone()),
        assigned_coa_track: hierarchy.as_ref().map(|h| h.assigned_coa_track.clone()),
        benefit_type: hierarchy.as_ref().map(|_| determine_benefit_type(&status)),
        benefit_amount: None,
        benefit_unit: Some("monthly_usd".to_string()),
        effective_date: if status == "approved" { Some(now.date_naive()) } else { None },
        expiration_date: if status == "approved" {
            Some(now.date_naive() + chrono::Months::new(12))
        } else { None },
        renewal_date: if status == "approved" {
            Some(now.date_naive() + chrono::Months::new(11))
        } else { None },
        continuous_eligibility_end: None,
        basis: hierarchy.as_ref().map(|h| h.basis.clone()),
        denial_reason,
        denial_reason_codes: None,
        fmap_rate: hierarchy.as_ref().map(|h| h.fmap_rate),
        program_service_version: env!("CARGO_PKG_VERSION").to_string(),
        determined_at: now,
        signature: String::new(),
        created_at: now,
    };

    let payload = serde_json::to_vec(&determination)
        .map_err(|e| ApiError::internal("serialize determination", e))?;
    let signature = state.signer.sign(&payload)
        .map_err(|e| ApiError::internal("sign determination", e))?;
    determination.signature = signature;

    store::determinations::insert_determination(state.db.inner(), &determination)
        .await.map_err(|e| ApiError::internal("persist determination", e))?;

    store::applications::update_status(state.db.inner(), app.id, "determined")
        .await.map_err(|e| ApiError::internal("update status", e))?;

    // 13. Publish events
    events::publish_medicaid_determined(
        &state.publisher, &determination,
    ).await.map_err(|e| ApiError::internal("publish event", e))?;

    events::publish_cmd_cascade_completed(
        &state.publisher, app.id, context.applicant_person_id,
        cascade_result.all_evaluated.len() as i32,
        cascade_result.eligible_coas.len() as i32,
        determination.assigned_coa.as_deref(),
    ).await.map_err(|e| ApiError::internal("publish cascade event", e))?;

    Ok(Json(SignedDetermination::from(determination)))
}

pub struct MedicaidRulesClient {
    http: reqwest::Client,
    rules_base_url: String,
}

#[derive(Debug, Serialize)]
pub struct MagiInput {
    pub household_size: i32,
    pub magi_income: Decimal,
    pub fpl_5_percent_disregard: Decimal,
    pub coa_code: String,
    pub fpl_threshold: Decimal,
    pub applicant_age: i32,
    pub is_pregnant: bool,
    pub expected_children: i32,
}

#[derive(Debug, Deserialize)]
pub struct MagiOutput {
    pub eligible: bool,
    pub fpl_percentage: Option<Decimal>,
    pub fpl_threshold: Option<Decimal>,
    pub income_disregard_applied: bool,
    pub denial_reason: Option<String>,
}

#[derive(Debug, Serialize)]
pub struct NonMagiInput {
    pub coa_code: String,
    pub countable_income: Decimal,
    pub countable_resources: Decimal,
    pub resource_limit: Decimal,
    pub income_limit: Decimal,
    pub federal_benefit_rate: Option<Decimal>,
    pub disability_status: Option<String>,
    pub medicare_enrolled: bool,
    pub medicare_parts: Option<String>,
    pub age: i32,
    pub level_of_care_met: Option<bool>,
    pub length_of_stay_met: Option<bool>,
}

#[derive(Debug, Deserialize)]
pub struct NonMagiOutput {
    pub eligible: bool,
    pub resource_test_passed: bool,
    pub income_test_passed: bool,
    pub spend_down_amount: Option<Decimal>,
    pub denial_reason: Option<String>,
}

#[derive(Debug, Serialize)]
pub struct ChipInput {
    pub child_person_id: Uuid,
    pub household_magi: Decimal,
    pub household_size: i32,
    pub child_age: i32,
}

#[derive(Debug, Deserialize)]
pub struct ChipOutput {
    pub eligible: bool,
    pub chip_type: String,
    pub fpl_percentage: Decimal,
    pub denial_reason: Option<String>,
}

#[derive(Debug, Deserialize)]
pub struct HierarchyOutput {
    pub assigned_coa: String,
    pub assigned_coa_track: String,
    pub fmap_rate: Decimal,
    pub basis: String,
}

impl MedicaidRulesClient {
    pub fn new(http: reqwest::Client, rules_base_url: String) -> Self {
        Self { http, rules_base_url }
    }

    pub async fn evaluate_magi(&self, input: MagiInput) -> Result<MagiOutput, RulesError> {
        let url = format!("{}/v1/evaluate", self.rules_base_url);
        let body = serde_json::json!({
            "ruleset": "medicaid-magi",
            "input": input,
        });
        let resp = self.http.post(&url).json(&body).send().await?;
        if !resp.status().is_success() {
            let status = resp.status();
            let text = resp.text().await.unwrap_or_default();
            return Err(RulesError::EvaluationFailed { status, body: text });
        }
        Ok(resp.json().await?)
    }

    pub async fn evaluate_non_magi(&self, input: NonMagiInput) -> Result<NonMagiOutput, RulesError> {
        let url = format!("{}/v1/evaluate", self.rules_base_url);
        let body = serde_json::json!({
            "ruleset": "medicaid-non-magi",
            "input": input,
        });
        let resp = self.http.post(&url).json(&body).send().await?;
        if !resp.status().is_success() {
            let status = resp.status();
            let text = resp.text().await.unwrap_or_default();
            return Err(RulesError::EvaluationFailed { status, body: text });
        }
        Ok(resp.json().await?)
    }

    pub async fn evaluate_hierarchy(&self, input: serde_json::Value) -> Result<HierarchyOutput, RulesError> {
        let url = format!("{}/v1/evaluate", self.rules_base_url);
        let body = serde_json::json!({
            "ruleset": "medicaid-eligibility-hierarchy",
            "input": input,
        });
        let resp = self.http.post(&url).json(&body).send().await?;
        if !resp.status().is_success() {
            let status = resp.status();
            let text = resp.text().await.unwrap_or_default();
            return Err(RulesError::EvaluationFailed { status, body: text });
        }
        Ok(resp.json().await?)
    }

    pub async fn evaluate_chip(&self, input: ChipInput) -> Result<ChipOutput, RulesError> {
        let url = format!("{}/v1/evaluate", self.rules_base_url);
        let body = serde_json::json!({
            "ruleset": "chip-eligibility",
            "input": input,
        });
        let resp = self.http.post(&url).json(&body).send().await?;
        if !resp.status().is_success() {
            let status = resp.status();
            let text = resp.text().await.unwrap_or_default();
            return Err(RulesError::EvaluationFailed { status, body: text });
        }
        Ok(resp.json().await?)
    }
}

#[derive(Debug, thiserror::Error)]
pub enum RulesError {
    #[error("HTTP request failed: {0}")]
    Http(#[from] reqwest::Error),
    #[error("Rules evaluation failed: status={status}, body={body}")]
    EvaluationFailed { status: reqwest::StatusCode, body: String },
}