How about this:

```ruby
class Participant < ActiveRecord::Base
  def ineligible!
    self.class.transaction do
      participant_person_links.destroy_all
      events.update_all(:participant_id => nil)
      # other actions as necessary
    end
  end
end

class ResponseSetObserver < ActiveRecord::Observer
  include EligibilityExamination

  def after_save(rs)
    action(rs)
  end
end

module EligibilityExamination
  def action(rs)
    person = rs.person

    if !person.eligible? && rs.survey.title =~ /PBSamplingScreen/
      person.participant.ineligible!
    end
  end
end
```

The above proposal is an improvement in a few ways:

1. it sticks to Rails conventions
2. it is clear about _what_ becomes ineligible (AFAICT, it's a Participant)
3. it avoids explicit runtime modification of classes (which can be slow, and interferes with JITs)
4. it avoids awkward names like `ineligibilifier`
5. it works for all ResponseSet modifications, not just those occurring in an HTTP request

The names of modules in my proposal do need work and the logic is suspect (in particular, eligibility examination looks wrong to me), but I don't understand why you need to introduce a new architecture.  DCI has its merits, but mixing it with existing code that doesn't follow that pattern requires that it offer a very large payoff and I am not sure what that payoff is.