From ab15b469cc05ab478cfe8c74943edd60dfbdd005 Mon Sep 17 00:00:00 2001
From: Mae Beale <maebeale@gmail.com>
Date: Tue, 3 Nov 2026 08:34:47 -0500
Subject: [PATCH 1/4] Certificates unlock on their own; roster shows Available,
 slider makes it available now

- Marking the event's own certificate issued now unlocks it (it only fed readiness before)
- Marking a CE certificate issued now unlocks the CE certificate too
- Roster certificate cells show "Available" once a certificate unlocks on its own;
  otherwise a slider that makes it available now
- Toggling CE also refreshes the event certificate cell (issued CE unlocks it)
- CE edit page switch relabeled "CE certificate availability"

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 .../continuing_education_registration.rb      |  3 ++
 app/models/event_registration.rb              | 17 ++++++---
 .../_details_section.html.erb                 |  5 +--
 .../_certificate_issued_toggle.html.erb       | 35 ++++++++++++-------
 ...gle_ce_certificate_issued.turbo_stream.erb |  6 +++-
 .../continuing_education_registration_spec.rb |  8 +++++
 spec/models/event_registration_spec.rb        | 29 +++++++++++++++
 ...continuing_education_registrations_spec.rb |  2 +-
 spec/requests/event_registrations_spec.rb     | 25 +++++++++++++
 9 files changed, 109 insertions(+), 21 deletions(-)

diff --git a/app/models/continuing_education_registration.rb b/app/models/continuing_education_registration.rb
index 9f129418f8..47ea6759e7 100644
--- a/app/models/continuing_education_registration.rb
+++ b/app/models/continuing_education_registration.rb
@@ -146,7 +146,10 @@ def origin_ce_registration
   # attendance was tracked) the logged time approximately covers the hours.
   # Everything is judged at this record's own event/registration — after a transfer
   # the hours ride on the destination reg's own record, so there's nothing to walk.
+  # An admin marking the certificate issued is the override: it unlocks regardless.
   def certificate_available?
+    return true if certificate_sent?
+
     event = event_registration&.event
     return false unless event&.ce_eligible? && approved?
     return false unless event.end_date&.past? && event_registration.attended? && paid_in_full?
diff --git a/app/models/event_registration.rb b/app/models/event_registration.rb
index f8bd72217a..14f757d1a7 100644
--- a/app/models/event_registration.rb
+++ b/app/models/event_registration.rb
@@ -816,12 +816,13 @@ def clear_post_survey_completed!
   end
 
   # The certificate of completion unlocks once the training has happened, the
-  # registrant attended, and any scholarship tasks are complete. Issuing a CE
-  # certificate (an admin marking the credit sent) is itself an affirmation that
-  # the registrant completed the training, so it unlocks the certificate too —
-  # even when attendance was never tracked.
+  # registrant attended, and any scholarship tasks are complete. Issuing a
+  # certificate (an admin marking it sent on the roster — the registration's own
+  # or the CE one) is itself an affirmation that the registrant completed the
+  # training, so it unlocks the certificate too — even when attendance was never
+  # tracked.
   def certificate_available?
-    return true if ce_certificate_issued?
+    return true if certificate_sent? || ce_certificate_issued?
 
     event.end_date.present? && event.end_date.past? && attended? && scholarship_tasks_met?
   end
@@ -1008,6 +1009,12 @@ def ce_certificate_issued?
     continuing_education_registrations.all? { |c| c.certificate_sent_at.present? }
   end
 
+  # Every CE registration's certificate is available (on its own or because it was
+  # marked issued). Reads the preloaded CE records.
+  def ce_certificate_available?
+    continuing_education_registrations.any? && continuing_education_registrations.all?(&:certificate_available?)
+  end
+
   # Issuing keeps an existing issued date — it's printed on the certificate.
   def mark_certificate_issued!(issued)
     update!(certificate_sent_at: issued ? certificate_sent_at || Time.current : nil)
diff --git a/app/views/continuing_education_registrations/_details_section.html.erb b/app/views/continuing_education_registrations/_details_section.html.erb
index 3dd8fd1ba9..8d001617e0 100644
--- a/app/views/continuing_education_registrations/_details_section.html.erb
+++ b/app/views/continuing_education_registrations/_details_section.html.erb
@@ -112,9 +112,10 @@
                 on: ce_registration.approved?,
                 detail: ("Denied #{ce_registration.denied_at.to_date.to_fs(:long)}" if ce_registration.denied?),
                 title: "On by default. Switch off to deny: it closes the registrant's sign-in and certificate." %>
-          <%= render "continuing_education_registrations/status_switch", name: "certificate_issued", label: "CE certificate of completion",
+          <%= render "continuing_education_registrations/status_switch", name: "certificate_issued", label: "CE certificate availability",
                 on: ce_registration.certificate_sent_at.present?,
-                detail: ce_registration.certificate_sent_at ? "Issued #{ce_registration.certificate_sent_at.to_date.to_fs(:long)}" : "Not issued" %>
+                detail: ce_registration.certificate_sent_at ? "Issued #{ce_registration.certificate_sent_at.to_date.to_fs(:long)}" : "Not issued",
+                title: "Unlocks automatically once requirements are met. Switch on to make it available now." %>
         </div>
       <% end %>
     </div>
diff --git a/app/views/event_registrations/_certificate_issued_toggle.html.erb b/app/views/event_registrations/_certificate_issued_toggle.html.erb
index 2f93df4795..deadc88d81 100644
--- a/app/views/event_registrations/_certificate_issued_toggle.html.erb
+++ b/app/views/event_registrations/_certificate_issued_toggle.html.erb
@@ -1,21 +1,32 @@
-<%# Inline "certificate issued" slider toggle, targeted by id for turbo replacement.
+<%# Inline certificate availability cell, targeted by id for turbo replacement.
     Locals: registration, ce (default false) — the CE certificate instead of the event's.
+    A certificate unlocks on its own once its requirements are met, so then the cell
+    just says so. Otherwise it's a slider that makes it available now (marking it
+    issued); once switched on it stays a slider so it can be switched back off.
     The track is a direct sibling of the checkbox so peer-checked applies (it only
     reaches later siblings, not their descendants); the knob is the track's ::after. %>
 <% ce = local_assigns.fetch(:ce, false) %>
 <% url = ce ? toggle_ce_certificate_issued_event_registration_path(registration) : toggle_certificate_issued_event_registration_path(registration) %>
 <% issued = ce ? registration.ce_certificate_issued? : registration.certificate_sent? %>
+<% available = !issued && (ce ? registration.ce_certificate_available? : registration.certificate_available?) %>
 <span id="<%= dom_id(registration, ce ? :ce_certificate_issued : :certificate_issued) %>" class="inline-block">
-  <%= form_with url: url, method: :patch, class: "inline" do %>
-    <%= hidden_field_tag :value, "0", id: nil %>
-    <label class="relative inline-flex cursor-pointer items-center select-none" title="<%= "Transferred out — locked" if registration.editing_locked? %>">
-      <%= check_box_tag :value, "1", issued,
-            id: nil,
-            onchange: "this.form.requestSubmit()",
-            disabled: registration.editing_locked?,
-            "aria-label": ce ? "CE certificate issued" : "Certificate issued",
-            class: "peer sr-only" %>
-      <span class="relative inline-block h-5 w-9 rounded-full bg-gray-300 transition-colors peer-checked:bg-teal-600 peer-disabled:cursor-not-allowed peer-disabled:opacity-50 after:absolute after:top-0.5 after:left-0.5 after:h-4 after:w-4 after:rounded-full after:bg-white after:shadow after:transition-transform after:content-[''] peer-checked:after:translate-x-4"></span>
-    </label>
+  <% if available %>
+    <span class="inline-flex items-center gap-1.5 whitespace-nowrap text-green-700" title="Requirements met — the registrant can download it">
+      <i class="fa-solid fa-circle-check" aria-hidden="true"></i>
+      <span>Available</span>
+    </span>
+  <% else %>
+    <%= form_with url: url, method: :patch, class: "inline" do %>
+      <%= hidden_field_tag :value, "0", id: nil %>
+      <label class="relative inline-flex cursor-pointer items-center select-none" title="<%= registration.editing_locked? ? "Transferred out — locked" : "Make available now" %>">
+        <%= check_box_tag :value, "1", issued,
+              id: nil,
+              onchange: "this.form.requestSubmit()",
+              disabled: registration.editing_locked?,
+              "aria-label": ce ? "CE certificate availability" : "Certificate availability",
+              class: "peer sr-only" %>
+        <span class="relative inline-block h-5 w-9 rounded-full bg-gray-300 transition-colors peer-checked:bg-teal-600 peer-disabled:cursor-not-allowed peer-disabled:opacity-50 after:absolute after:top-0.5 after:left-0.5 after:h-4 after:w-4 after:rounded-full after:bg-white after:shadow after:transition-transform after:content-[''] peer-checked:after:translate-x-4"></span>
+      </label>
+    <% end %>
   <% end %>
 </span>
diff --git a/app/views/event_registrations/toggle_ce_certificate_issued.turbo_stream.erb b/app/views/event_registrations/toggle_ce_certificate_issued.turbo_stream.erb
index 4968e45ea5..b964bf9f71 100644
--- a/app/views/event_registrations/toggle_ce_certificate_issued.turbo_stream.erb
+++ b/app/views/event_registrations/toggle_ce_certificate_issued.turbo_stream.erb
@@ -1,7 +1,11 @@
-<%# Replace the toggled cell and the row's CE badge — avoids re-rendering the whole roster. %>
+<%# Replace the toggled cell, the event certificate cell (an issued CE certificate makes
+    it available too), and the row's CE badge — avoids re-rendering the whole roster. %>
 <%= turbo_stream.replace dom_id(@event_registration, :ce_certificate_issued) do %>
   <%= render "event_registrations/certificate_issued_toggle", registration: @event_registration, ce: true %>
 <% end %>
+<%= turbo_stream.replace dom_id(@event_registration, :certificate_issued) do %>
+  <%= render "event_registrations/certificate_issued_toggle", registration: @event_registration %>
+<% end %>
 <% if (ce_registration = @event_registration.continuing_education_registrations.first) %>
   <%= turbo_stream.replace dom_id(@event_registration, :ce_status) do %>
     <%= render "event_registrations/roster_ce_status", registration: @event_registration, ce_registration: ce_registration %>
diff --git a/spec/models/continuing_education_registration_spec.rb b/spec/models/continuing_education_registration_spec.rb
index 10e38e6652..8efae969c9 100644
--- a/spec/models/continuing_education_registration_spec.rb
+++ b/spec/models/continuing_education_registration_spec.rb
@@ -367,6 +367,14 @@ def ce_reg_for(event:, status:, cost_cents: 0)
       expect(ce_reg_for(event: event, status: "attended").certificate_available?).to be(true)
     end
 
+    it "is available once an admin marks it issued, even before the training ends and while unpaid" do
+      event = create(:event, ce_hours_offered: 6, start_date: 2.days.from_now, end_date: 3.days.from_now)
+      ce_reg = ce_reg_for(event: event, status: "registered", cost_cents: 5_000)
+      expect(ce_reg.certificate_available?).to be(false)
+      ce_reg.mark_certificate_sent!
+      expect(ce_reg.certificate_available?).to be(true)
+    end
+
     it "is unavailable when the event does not grant CE" do
       event = create(:event, ce_hours_offered: 0, start_date: 3.days.ago, end_date: 1.day.ago)
       expect(ce_reg_for(event: event, status: "attended").certificate_available?).to be(false)
diff --git a/spec/models/event_registration_spec.rb b/spec/models/event_registration_spec.rb
index 9e23655113..0ecbfbc719 100644
--- a/spec/models/event_registration_spec.rb
+++ b/spec/models/event_registration_spec.rb
@@ -1299,6 +1299,26 @@ def pay(cents)
     end
   end
 
+  describe "#certificate_available?" do
+    let(:ended_event) { create(:event, start_date: 3.days.ago, end_date: 2.days.ago) }
+
+    it "is false before attendance is recorded" do
+      reg = create(:event_registration, event: ended_event, status: "registered")
+      expect(reg.certificate_available?).to be false
+    end
+
+    it "is true once an ended training is attended with no scholarship" do
+      reg = create(:event_registration, event: ended_event, status: "attended")
+      expect(reg.certificate_available?).to be true
+    end
+
+    it "is true once an admin marks the certificate issued, even without attendance" do
+      reg = create(:event_registration, event: create(:event, start_date: 2.days.from_now, end_date: 3.days.from_now), status: "registered")
+      reg.mark_certificate_issued!(true)
+      expect(reg.reload.certificate_available?).to be true
+    end
+  end
+
   describe "#remaining_cost_without" do
     let(:event) { create(:event, cost_cents: 10_000) }
     let(:reg) { create(:event_registration, event: event) }
@@ -1725,6 +1745,15 @@ def add_ce(number: "LIC-123", hours: 4, cost_cents: 15_000)
       end
     end
 
+    describe "#ce_certificate_available?" do
+      it "is true once every CE registration's certificate is available" do
+        cer = add_ce
+        expect(reg.reload).not_to be_ce_certificate_available
+        cer.mark_certificate_sent!
+        expect(reg.reload).to be_ce_certificate_available
+      end
+    end
+
     describe "#ce_certificate_issued?" do
       it "is true only once every CE registration's certificate is sent" do
         cer = add_ce
diff --git a/spec/requests/continuing_education_registrations_spec.rb b/spec/requests/continuing_education_registrations_spec.rb
index b45811a605..47bbef485e 100644
--- a/spec/requests/continuing_education_registrations_spec.rb
+++ b/spec/requests/continuing_education_registrations_spec.rb
@@ -318,7 +318,7 @@
       page = Capybara.string(response.body)
       expect(page).to have_field("continuing_education_registration[approved]", type: "checkbox", visible: :all)
       expect(page).to have_field("continuing_education_registration[certificate_issued]", type: "checkbox", visible: :all)
-      expect(page).to have_text("CE certificate of completion")
+      expect(page).to have_text("CE certificate availability")
     end
 
     it "renders the new page for a registration" do
diff --git a/spec/requests/event_registrations_spec.rb b/spec/requests/event_registrations_spec.rb
index 777b229a4a..f56278e109 100644
--- a/spec/requests/event_registrations_spec.rb
+++ b/spec/requests/event_registrations_spec.rb
@@ -354,6 +354,23 @@ def toggle_certificate(value)
         expect(registration.reload).not_to be_certificate_sent
       end
 
+      it "shows Available instead of the slider once the certificate unlocks on its own" do
+        event.update!(start_date: 3.days.ago, end_date: 2.days.ago)
+        registration.update!(status: "attended")
+
+        toggle_certificate("0")
+
+        expect(response.body).to include("Available")
+        expect(response.body).not_to include('type="checkbox"')
+      end
+
+      it "keeps the slider (switched on) once marked available, so it can be switched off" do
+        toggle_certificate("1")
+
+        expect(response.body).to match(/type="checkbox"[^>]*checked="checked"/)
+        expect(response.body).not_to include("Available")
+      end
+
       it "leaves a CE registrant's CE certificate alone" do
         ce = create(:continuing_education_registration, event_registration: registration)
 
@@ -391,6 +408,14 @@ def toggle_ce_certificate(value)
         expect(stream).to have_css("turbo-stream[action='replace'][target='#{ActionView::RecordIdentifier.dom_id(registration, :ce_status)}']")
         expect(response.body).to include("Issued")
       end
+
+      it "refreshes the event certificate cell, which an issued CE certificate makes available" do
+        toggle_ce_certificate("1")
+
+        stream = Capybara.string(response.body)
+        expect(stream).to have_css("turbo-stream[action='replace'][target='#{ActionView::RecordIdentifier.dom_id(registration, :certificate_issued)}']")
+        expect(response.body).to include("Available")
+      end
     end
 
     describe "POST /event_registrations" do

From 39f10d995beeab01ebc821672ce7943bcbd42b50 Mon Sep 17 00:00:00 2001
From: Mae Beale <maebeale@gmail.com>
Date: Tue, 3 Nov 2026 08:36:49 -0500
Subject: [PATCH 2/4] Spell out certificate unlock requirements in the
 availability tooltips

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 app/models/continuing_education_registration.rb            | 4 ++++
 app/models/event_registration.rb                           | 3 +++
 .../_details_section.html.erb                              | 2 +-
 .../_certificate_issued_toggle.html.erb                    | 5 +++--
 spec/requests/event_registrations_spec.rb                  | 7 +++++++
 5 files changed, 18 insertions(+), 3 deletions(-)

diff --git a/app/models/continuing_education_registration.rb b/app/models/continuing_education_registration.rb
index 47ea6759e7..32a4a8db37 100644
--- a/app/models/continuing_education_registration.rb
+++ b/app/models/continuing_education_registration.rb
@@ -118,6 +118,10 @@ def self.parse_iso_date(value)
   # sign-ins/early sign-outs. You can't certify hours the sign-in sheet doesn't support.
   ATTENDANCE_COVERAGE_THRESHOLD = 0.9
 
+  # What #certificate_available? checks, in words — the admin tooltips spell it out.
+  CERTIFICATE_REQUIREMENTS = "the training has ended, the registrant is marked attended, the CE is approved and paid in full, " \
+    "the CE form is complete (if there is one), and signed-in time covers the CE hours (if time was tracked)".freeze
+
   # This record was created by a transfer — carried onto a transferred-in reg from
   # a matching CE the split left on the source. Identified by that source stub
   # existing (matched by license), NOT merely by the reg being a transfer-in: a CE
diff --git a/app/models/event_registration.rb b/app/models/event_registration.rb
index 14f757d1a7..6e9b324f0b 100644
--- a/app/models/event_registration.rb
+++ b/app/models/event_registration.rb
@@ -58,6 +58,9 @@ class EventRegistration < ApplicationRecord
   # Attendance outcomes surfaced as their own participation buckets; every other
   # status falls into "other" (registered, transfers, cancellations).
   NAMED_OUTCOME_STATUSES = %w[ attended incomplete_attendance no_show ].freeze
+
+  # What #certificate_available? checks, in words — the admin tooltips spell it out.
+  CERTIFICATE_REQUIREMENTS = "the training has ended, the registrant is marked attended, and any scholarship tasks are complete".freeze
   # Sentinel filter value meaning "don't narrow on this dimension" — for a filter
   # that defaults to something specific (the attendees index defaults to attended
   # registrations on trainings, so it needs a way to say "all of them").
diff --git a/app/views/continuing_education_registrations/_details_section.html.erb b/app/views/continuing_education_registrations/_details_section.html.erb
index 8d001617e0..f5ddd83aeb 100644
--- a/app/views/continuing_education_registrations/_details_section.html.erb
+++ b/app/views/continuing_education_registrations/_details_section.html.erb
@@ -115,7 +115,7 @@
           <%= render "continuing_education_registrations/status_switch", name: "certificate_issued", label: "CE certificate availability",
                 on: ce_registration.certificate_sent_at.present?,
                 detail: ce_registration.certificate_sent_at ? "Issued #{ce_registration.certificate_sent_at.to_date.to_fs(:long)}" : "Not issued",
-                title: "Unlocks automatically once requirements are met. Switch on to make it available now." %>
+                title: "Unlocks automatically once #{ContinuingEducationRegistration::CERTIFICATE_REQUIREMENTS}. Switch on to make it available now." %>
         </div>
       <% end %>
     </div>
diff --git a/app/views/event_registrations/_certificate_issued_toggle.html.erb b/app/views/event_registrations/_certificate_issued_toggle.html.erb
index deadc88d81..3763baebd2 100644
--- a/app/views/event_registrations/_certificate_issued_toggle.html.erb
+++ b/app/views/event_registrations/_certificate_issued_toggle.html.erb
@@ -9,16 +9,17 @@
 <% url = ce ? toggle_ce_certificate_issued_event_registration_path(registration) : toggle_certificate_issued_event_registration_path(registration) %>
 <% issued = ce ? registration.ce_certificate_issued? : registration.certificate_sent? %>
 <% available = !issued && (ce ? registration.ce_certificate_available? : registration.certificate_available?) %>
+<% requirements = ce ? ContinuingEducationRegistration::CERTIFICATE_REQUIREMENTS : EventRegistration::CERTIFICATE_REQUIREMENTS %>
 <span id="<%= dom_id(registration, ce ? :ce_certificate_issued : :certificate_issued) %>" class="inline-block">
   <% if available %>
-    <span class="inline-flex items-center gap-1.5 whitespace-nowrap text-green-700" title="Requirements met — the registrant can download it">
+    <span class="inline-flex items-center gap-1.5 whitespace-nowrap text-green-700" title="Unlocked: <%= requirements %>">
       <i class="fa-solid fa-circle-check" aria-hidden="true"></i>
       <span>Available</span>
     </span>
   <% else %>
     <%= form_with url: url, method: :patch, class: "inline" do %>
       <%= hidden_field_tag :value, "0", id: nil %>
-      <label class="relative inline-flex cursor-pointer items-center select-none" title="<%= registration.editing_locked? ? "Transferred out — locked" : "Make available now" %>">
+      <label class="relative inline-flex cursor-pointer items-center select-none" title="<%= registration.editing_locked? ? "Transferred out — locked" : "Unlocks automatically once #{requirements}. Switch on to make it available now." %>">
         <%= check_box_tag :value, "1", issued,
               id: nil,
               onchange: "this.form.requestSubmit()",
diff --git a/spec/requests/event_registrations_spec.rb b/spec/requests/event_registrations_spec.rb
index f56278e109..9e2c05d7b5 100644
--- a/spec/requests/event_registrations_spec.rb
+++ b/spec/requests/event_registrations_spec.rb
@@ -361,9 +361,16 @@ def toggle_certificate(value)
         toggle_certificate("0")
 
         expect(response.body).to include("Available")
+        expect(response.body).to include("Unlocked: #{EventRegistration::CERTIFICATE_REQUIREMENTS}")
         expect(response.body).not_to include('type="checkbox"')
       end
 
+      it "spells out the unlock requirements on the slider" do
+        toggle_certificate("0")
+
+        expect(response.body).to include("Unlocks automatically once #{EventRegistration::CERTIFICATE_REQUIREMENTS}")
+      end
+
       it "keeps the slider (switched on) once marked available, so it can be switched off" do
         toggle_certificate("1")
 

From a41a177d0951c430895322dd95124b79280847df Mon Sep 17 00:00:00 2001
From: Mae Beale <maebeale@gmail.com>
Date: Tue, 3 Nov 2026 08:40:51 -0500
Subject: [PATCH 3/4] Roster readiness reads certificate availability; preload
 CE certificate reads
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Readiness "Certificate not sent" → "Certificate not available" (event + CE);
  a registrant is Completed once their certificate(s) unlock, no manual send needed
- Event#ce_callout memoized (like scholarship_callout) so RegistrantCeForm hits
  the callouts once per event
- Roster preloads attendance entries + form completions for CE rows only;
  RegistrantCeForm reads the preloaded completions when loaded
- Query-count spec: adding CE registrants adds no roster queries

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 app/controllers/events_controller.rb          | 12 +++++
 app/models/event.rb                           |  8 +++
 app/services/event_registration_readiness.rb  | 37 +++++---------
 app/services/registrant_ce_form.rb            | 18 +++++--
 .../events_registrants_preloading_spec.rb     | 51 +++++++++++++++++++
 .../event_registration_readiness_spec.rb      | 41 ++++++++++-----
 6 files changed, 126 insertions(+), 41 deletions(-)
 create mode 100644 spec/requests/events_registrants_preloading_spec.rb

diff --git a/app/controllers/events_controller.rb b/app/controllers/events_controller.rb
index 32539ad32b..9cdafef10f 100644
--- a/app/controllers/events_controller.rb
+++ b/app/controllers/events_controller.rb
@@ -269,6 +269,7 @@ def registrants
     @ce_eligible = @event.ce_eligible?
 
     @submitted_org_names = submitted_org_names_for(@event_registrations)
+    preload_ce_certificate_reads(@event_registrations)
     @readiness = @event_registrations.to_h do |registration|
       [ registration.id, EventRegistrationReadiness.new(registration) ]
     end
@@ -1084,6 +1085,17 @@ def selected_reminder_registrations
       .select { |r| r.registrant.preferred_email.present? }
   end
 
+  # CE certificate availability (readiness + the certificate cell) reads each CE
+  # registrant's logged attendance time and CE form completion. Preload both for
+  # the CE rows only, so the roster doesn't query them per row.
+  def preload_ce_certificate_reads(registrations)
+    ce_rows = registrations.select { |r| r.continuing_education_registrations.any? }
+    return if ce_rows.empty?
+
+    ActiveRecord::Associations::Preloader.new(records: ce_rows, associations: :event_attendance_time_entries).call
+    ActiveRecord::Associations::Preloader.new(records: ce_rows.map(&:registrant), associations: :form_completions).call
+  end
+
   # Maps registrant person_id => the organization name they typed on the
   # registration form (the organization_name answer), in one batch query. Drives
   # both the roster's Pending/None org chip and the readiness "Organization not
diff --git a/app/models/event.rb b/app/models/event.rb
index 9e7f5ec36c..43fbe458bd 100644
--- a/app/models/event.rb
+++ b/app/models/event.rb
@@ -298,6 +298,14 @@ def scholarship_callout
       registration_ticket_callouts.detect { |callout| callout.builtin_key == "scholarship" }
   end
 
+  # The CE hours callout (it carries the CE form). Memoized so the roster's per-row
+  # CE certificate checks hit the callouts once per event, not per row.
+  def ce_callout
+    return @ce_callout if defined?(@ce_callout)
+    @ce_callout =
+      registration_ticket_callouts.detect { |callout| callout.builtin_key == "ce_hours" }
+  end
+
   # The recipient's form row on the (published) scholarship callout — whatever form
   # an admin links there gates readiness, no special role needed. nil when the
   # callout carries no form or is hidden.
diff --git a/app/services/event_registration_readiness.rb b/app/services/event_registration_readiness.rb
index 7bc887c064..2b45d92537 100644
--- a/app/services/event_registration_readiness.rb
+++ b/app/services/event_registration_readiness.rb
@@ -5,8 +5,9 @@
 # on either state.
 #
 # Reads only already-loaded associations (organizations, allocations,
-# scholarships, continuing_education_registrations) so it adds no per-row queries
-# when the roster preloads them.
+# scholarships, continuing_education_registrations, and — for CE rows — attendance
+# entries and form completions) so it adds no per-row queries when the roster
+# preloads them.
 class EventRegistrationReadiness
   def initialize(registration)
     @registration = registration
@@ -27,14 +28,14 @@ def event_ready?
     event_ready_issues.empty?
   end
 
-  # All post-event work done AND the certificate(s) sent.
+  # All post-event work done AND the certificate(s) available.
   def completed?
     completion_issues.empty?
   end
 
   # All post-event work done (attended, scholarship tasks met, post-event survey in)
-  # — i.e. the only thing left is sending the certificate(s). This is the admin's
-  # "send a certificate" queue.
+  # — i.e. the only thing left is the certificate(s) unlocking (the training ending,
+  # or for CE: payment, the CE form, signed-in time).
   def certifiable?
     (completion_work_issues + survey_issues).empty?
   end
@@ -42,7 +43,7 @@ def certifiable?
   # The registration's single lifecycle state for the roster's one Status column
   # and its matching filter. Completion is the final state and wins; otherwise an
   # outstanding pre-event to-do means "not ready"; a registrant who finished the
-  # post-event work but still needs a certificate is "certificate due"; and a
+  # post-event work but whose certificate isn't available yet is "certificate due"; and a
   # clear pre-event checklist with nothing further done is "ready".
   def status
     return :completed if completed?
@@ -88,9 +89,9 @@ def status_reason
     end
   end
 
-  # Which certificate(s) still need sending, abbreviated for the badge subtext.
+  # Which certificate(s) aren't available yet, abbreviated for the badge subtext.
   def certificate_due_reason
-    reg_due = !registration_certificate_sent?
+    reg_due = !registration.certificate_available?
     ce_due = ce_certificate_pending?
     return "Reg + CE" if reg_due && ce_due
     return "CE" if ce_due
@@ -141,11 +142,11 @@ def completion_work_issues
     end
   end
 
-  # The certificate(s) that still need sending once the work above is done.
+  # The certificate(s) not yet available once the work above is done.
   def certificate_issues
     @certificate_issues ||= [].tap do |issues|
-      issues << "Certificate not sent" unless registration_certificate_sent?
-      issues << "CE certificate not sent" if ce_certificate_pending?
+      issues << "Certificate not available" unless registration.certificate_available?
+      issues << "CE certificate not available" if ce_certificate_pending?
     end
   end
 
@@ -207,7 +208,7 @@ def ce_license_missing?
   end
 
   def ce_certificate_pending?
-    certifiable_ce.any? && !ce_certificate_sent?
+    certifiable_ce.any? && !registration.ce_certificate_available?
   end
 
   # Post-event criteria are only met by a full "attended". "incomplete_attendance"
@@ -236,16 +237,4 @@ def certifiable_ce
   def ce_paid?
     ce_registrations.any? && ce_registrations.all?(&:paid_in_full?)
   end
-
-  # The registration's own completion certificate (certificate_sent_at, via
-  # Certifiable#certificate_sent?).
-  def registration_certificate_sent?
-    registration.certificate_sent?
-  end
-
-  # CE certificates are sent once every CE registration this reg certifies has
-  # been sent. No certifiable CE means nothing has been issued.
-  def ce_certificate_sent?
-    certifiable_ce.any? && certifiable_ce.all?(&:certificate_sent?)
-  end
 end
diff --git a/app/services/registrant_ce_form.rb b/app/services/registrant_ce_form.rb
index f23c7e052b..d9872fdab1 100644
--- a/app/services/registrant_ce_form.rb
+++ b/app/services/registrant_ce_form.rb
@@ -15,7 +15,7 @@ def initialize(event_registration)
   def link
     return @link if defined?(@link)
 
-    @link = ce_callout&.registration_ticket_callout_forms&.first
+    @link = ce_callout&.registration_ticket_callout_forms&.to_a&.first
   end
 
   # The form attached to the CE callout, or nil when none is set.
@@ -59,8 +59,7 @@ def complete?
   def completed_anonymously?
     return @completed_anonymously if defined?(@completed_anonymously)
 
-    @completed_anonymously = form.present? && registrant_saved? &&
-      FormCompletion.exists?(person: @event_registration.registrant, form:, event: @event_registration.event)
+    @completed_anonymously = form.present? && registrant_saved? && form_completion_on_file?
   end
 
   private
@@ -71,6 +70,17 @@ def registrant_saved?
     @event_registration.registrant&.persisted?
   end
 
+  # Reads the registrant's preloaded completions when the roster loaded them.
+  def form_completion_on_file?
+    registrant = @event_registration.registrant
+    event = @event_registration.event
+    if registrant.form_completions.loaded?
+      registrant.form_completions.any? { |completion| completion.form_id == form.id && completion.event_id == event.id }
+    else
+      FormCompletion.exists?(person: registrant, form:, event:)
+    end
+  end
+
   def answerable_fields
     return [] unless form
 
@@ -92,6 +102,6 @@ def answers_by_field_id
   def ce_callout
     return @ce_callout if defined?(@ce_callout)
 
-    @ce_callout = @event_registration.event.registration_ticket_callouts.find_by(builtin_key: "ce_hours")
+    @ce_callout = @event_registration.event.ce_callout
   end
 end
diff --git a/spec/requests/events_registrants_preloading_spec.rb b/spec/requests/events_registrants_preloading_spec.rb
new file mode 100644
index 0000000000..2cd3bbc6b6
--- /dev/null
+++ b/spec/requests/events_registrants_preloading_spec.rb
@@ -0,0 +1,51 @@
+require "rails_helper"
+
+# The roster reads each CE registrant's certificate availability (readiness + the
+# certificate cell), which checks the CE callout's (anonymous) form completion and logged
+# attendance time. Those re-query per row unless the controller preloads them, so
+# this guards the preload: adding CE registrants must not add queries.
+RSpec.describe "Event registrants CE certificate preloading", type: :request do
+  let(:admin) { create(:user, :admin) }
+  let(:event) { create(:event, :ended, ce_hours_offered: 6) }
+  let(:form) { create(:form, name: "CE Evaluation", anonymous: true) }
+  let!(:required_field) { create(:form_field, form:, name: "How was it?", required: true) }
+
+  before do
+    create(:registration_ticket_callout, event:, builtin_key: "ce_hours", title: "CE hours", form:)
+    sign_in admin
+  end
+
+  def add_ce_registrants(count)
+    count.times do
+      registration = create(:event_registration, event:, status: "attended")
+      create(:continuing_education_registration, event_registration: registration, cost_cents: 0,
+        professional_license: create(:professional_license, person: registration.registrant))
+      create(:event_attendance_time_entry, event_registration: registration,
+        signed_in_at: 13.days.ago, signed_out_at: 13.days.ago + 8.hours)
+      create(:form_completion, person: registration.registrant, form:, event:)
+    end
+  end
+
+  def queries_for_roster
+    count = 0
+    counter = ->(*, payload) { count += 1 unless payload[:name].to_s.match?(/SCHEMA|TRANSACTION/) }
+    ActiveSupport::Notifications.subscribed(counter, "sql.active_record") { get registrants_event_path(event) }
+    expect(response).to be_successful
+    count
+  end
+
+  it "does not issue more queries as more CE registrants are listed" do
+    add_ce_registrants(2)
+    queries_for_roster # warm up: the first request also loads the signed-in user
+    baseline = queries_for_roster
+
+    add_ce_registrants(4)
+    expect(queries_for_roster).to eq(baseline)
+  end
+
+  it "shows their CE certificates as available" do
+    add_ce_registrants(1)
+    get registrants_event_path(event)
+    expect(Capybara.string(response.body)).to have_css("##{ActionView::RecordIdentifier.dom_id(EventRegistration.last, :ce_certificate_issued)}", text: "Available")
+  end
+end
diff --git a/spec/services/event_registration_readiness_spec.rb b/spec/services/event_registration_readiness_spec.rb
index 55d03843f2..6131f5e3d0 100644
--- a/spec/services/event_registration_readiness_spec.rb
+++ b/spec/services/event_registration_readiness_spec.rb
@@ -184,30 +184,37 @@ def award_scholarship(reg, tasks_completed:, amount: 1000)
       expect(readiness.completion_issues).to include("Scholarship tasks incomplete")
     end
 
-    it "flags the registration certificate as unsent until certificate_sent_at is set" do
+    it "flags the registration certificate as unavailable before the training has ended" do
       registration.update!(status: "attended")
 
-      expect(readiness.completion_issues).to include("Certificate not sent")
+      expect(readiness.completion_issues).to include("Certificate not available")
     end
 
-    it "clears the registration certificate issue once it has been sent" do
+    it "clears the registration certificate issue once an admin marks it available" do
       registration.update!(status: "attended", certificate_sent_at: Time.current)
 
-      expect(readiness.completion_issues).not_to include("Certificate not sent")
+      expect(readiness.completion_issues).not_to include("Certificate not available")
     end
 
-    it "flags the CE certificate as unsent when CE credit was requested" do
+    it "clears the registration certificate issue once the training has ended and they attended" do
+      event.update!(start_date: 3.days.ago, end_date: 2.days.ago)
+      registration.update!(status: "attended")
+
+      expect(readiness.completion_issues).not_to include("Certificate not available")
+    end
+
+    it "flags the CE certificate as unavailable when CE credit was requested" do
       registration.update!(status: "attended")
       create(:continuing_education_registration, event_registration: registration,
         professional_license: create(:professional_license, person: registration.registrant, number: "LIC123"))
 
-      expect(readiness.completion_issues).to include("CE certificate not sent")
+      expect(readiness.completion_issues).to include("CE certificate not available")
     end
 
     it "does not flag a CE certificate when CE credit was not requested" do
       registration.update!(status: "attended")
 
-      expect(readiness.completion_issues).not_to include("CE certificate not sent")
+      expect(readiness.completion_issues).not_to include("CE certificate not available")
     end
   end
 
@@ -223,16 +230,16 @@ def award_scholarship(reg, tasks_completed:, amount: 1000)
     end
 
     it "flags the destination reg's roster with its own CE certificate still pending" do
-      expect(described_class.new(destination).completion_issues).to include("CE certificate not sent")
+      expect(described_class.new(destination).completion_issues).to include("CE certificate not available")
     end
 
-    it "clears once the destination reg's CE has been issued" do
+    it "clears once the destination reg's CE has been marked available" do
       ce.mark_certificate_sent!
-      expect(described_class.new(destination).completion_issues).not_to include("CE certificate not sent")
+      expect(described_class.new(destination).completion_issues).not_to include("CE certificate not available")
     end
 
     it "does not flag CE on the source reg, which holds no CE record of its own here" do
-      expect(described_class.new(source).certificate_issues).not_to include("CE certificate not sent")
+      expect(described_class.new(source).certificate_issues).not_to include("CE certificate not available")
     end
   end
 
@@ -252,7 +259,7 @@ def award_scholarship(reg, tasks_completed:, amount: 1000)
       expect(readiness.status_label).to eq("Ready")
     end
 
-    it "is :certificate_due once the post-event work is done but the certificate is unsent" do
+    it "is :certificate_due once the post-event work is done but the certificate isn't available yet" do
       pay(registration, 1000)
       link_org(registration)
       registration.update!(status: "attended")
@@ -261,7 +268,7 @@ def award_scholarship(reg, tasks_completed:, amount: 1000)
       expect(readiness.status_label).to eq("Certificate pending")
     end
 
-    it "is :completed once attended and the certificate has been sent" do
+    it "is :completed once attended and an admin marked the certificate available" do
       pay(registration, 1000)
       registration.update!(status: "attended", certificate_sent_at: Time.current)
 
@@ -269,6 +276,14 @@ def award_scholarship(reg, tasks_completed:, amount: 1000)
       expect(readiness.status_label).to eq("Completed")
     end
 
+    it "is :completed once the training has ended and they attended" do
+      pay(registration, 1000)
+      event.update!(start_date: 3.days.ago, end_date: 2.days.ago)
+      registration.update!(status: "attended")
+
+      expect(readiness.status).to eq(:completed)
+    end
+
     it "prefers :completed over the pre-event checklist when completion is reached" do
       allow(readiness).to receive(:completed?).and_return(true)
 

From 5afdc92c3ac362c8ec53648f34f6a62463c8f702 Mon Sep 17 00:00:00 2001
From: Mae Beale <maebeale@gmail.com>
Date: Tue, 3 Nov 2026 08:45:44 -0500
Subject: [PATCH 4/4] Denied CE no longer holds roster readiness back; noted on
 the badge instead

- Readiness CE checks (unpaid, license, certificate) skip denied CE
- Status badge shows "CE denied" as a note (tooltip, and under the badge
  when there's no other reason)

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 app/services/event_registration_readiness.rb  | 25 ++++++++++++-------
 .../_readiness_badge.html.erb                 |  9 +++++--
 .../events/_registrants_results.html.erb      |  3 ++-
 .../event_registration_readiness_spec.rb      | 25 +++++++++++++++++++
 4 files changed, 50 insertions(+), 12 deletions(-)

diff --git a/app/services/event_registration_readiness.rb b/app/services/event_registration_readiness.rb
index 2b45d92537..ee44b17b27 100644
--- a/app/services/event_registration_readiness.rb
+++ b/app/services/event_registration_readiness.rb
@@ -63,6 +63,12 @@ def status_label
     STATUS_LABELS.fetch(status)
   end
 
+  # Heads-ups that don't affect the status — a denied CE is skipped by every CE
+  # check, so the badge just mentions it.
+  def notes
+    registration.continuing_education_registrations.any?(&:denied?) ? [ "CE denied" ] : []
+  end
+
   # Sort key for the roster's Status column: lifecycle order first, then the
   # reason, so same-status rows group by reason (e.g. all "Payment due" together).
   def status_sort_key
@@ -200,15 +206,15 @@ def survey_outstanding?
   end
 
   def ce_unpaid?
-    registration.ce_registered? && !ce_paid?
+    ce_registrations.any? && !ce_paid?
   end
 
   def ce_license_missing?
-    registration.ce_registered? && !registration.ce_license_provided?
+    ce_registrations.any? && !ce_registrations.all? { |c| c.professional_license&.number_known? }
   end
 
   def ce_certificate_pending?
-    certifiable_ce.any? && !registration.ce_certificate_available?
+    certifiable_ce.any? && !certifiable_ce.all?(&:certificate_available?)
   end
 
   # Post-event criteria are only met by a full "attended". "incomplete_attendance"
@@ -220,16 +226,17 @@ def attendance_issue
 
   # The admin-created CE billing records homed on this registration (preloaded on
   # the roster). Their PAYMENT + license state drives the CE money/license checks;
-  # these stay on the home reg after a transfer.
+  # these stay on the home reg after a transfer. A denied CE is out of the picture —
+  # it never gets a certificate, so it doesn't hold readiness back (see #notes).
   def ce_registrations
-    registration.continuing_education_registrations
+    registration.continuing_education_registrations.reject(&:denied?)
   end
 
-  # The CE this registration certifies — its own records. After a transfer the
-  # hours ride on the destination reg's own record, so each reg certifies exactly
-  # what it holds. (issue #1944)
+  # The CE this registration certifies — its own (undenied) records. After a
+  # transfer the hours ride on the destination reg's own record, so each reg
+  # certifies exactly what it holds. (issue #1944)
   def certifiable_ce
-    registration.continuing_education_registrations
+    ce_registrations
   end
 
   # CE is paid once every CE registration is paid in full. A requested-but-not-yet
diff --git a/app/views/event_registrations/_readiness_badge.html.erb b/app/views/event_registrations/_readiness_badge.html.erb
index f95e336578..5b0b5b9a4f 100644
--- a/app/views/event_registrations/_readiness_badge.html.erb
+++ b/app/views/event_registrations/_readiness_badge.html.erb
@@ -6,9 +6,12 @@
       status  - Symbol (:not_ready, :ready, :certificate_due, :completed)
       label   - display text for the status
       issues  - array of outstanding-condition strings (tooltip, when any)
-      subtext - optional short reason rendered under the badge %>
+      subtext - optional short reason rendered under the badge
+      notes   - optional heads-ups that don't affect the status (tooltip; under the
+                badge when there's no reason) %>
 <%
   subtext = local_assigns[:subtext]
+  notes = local_assigns.fetch(:notes, [])
   style, icon, subtext_color = case status
     when :completed then [ "bg-green-50 text-green-700 border-green-200", "fa-flag-checkered", "text-green-600" ]
     when :certificate_due then [ "bg-purple-50 text-purple-700 border-purple-200", "fa-certificate", "text-purple-600" ]
@@ -16,11 +19,13 @@
     when :ready then [ "bg-blue-50 text-blue-700 border-blue-200", "fa-circle-check", "text-blue-600" ]
     else [ "bg-amber-50 text-amber-700 border-amber-200", "fa-circle-exclamation", "text-amber-600" ]
   end
-  tooltip = issues.any? ? issues.join(" · ") : label
+  tooltip = ((issues.any? ? issues : [ label ]) + notes.map { |note| "Note: #{note}" }).join(" · ")
 %>
 <div class="inline-flex flex-col items-center gap-0.5">
   <%= render "shared/badge", label: label, classes: style, icon: "fas #{icon}", title: tooltip %>
   <% if subtext.present? %>
     <span class="text-2xs font-medium <%= subtext_color %>"><%= subtext %></span>
+  <% elsif notes.any? %>
+    <span class="text-2xs font-medium text-gray-500"><%= notes.to_sentence %></span>
   <% end %>
 </div>
diff --git a/app/views/events/_registrants_results.html.erb b/app/views/events/_registrants_results.html.erb
index c443f5babe..01e2dee134 100644
--- a/app/views/events/_registrants_results.html.erb
+++ b/app/views/events/_registrants_results.html.erb
@@ -418,7 +418,8 @@
                         status: readiness.status,
                         label: readiness.status_label,
                         issues: readiness.status_issues,
-                        subtext: readiness.status_reason %>
+                        subtext: readiness.status_reason,
+                        notes: readiness.notes %>
                 </td>
                 <% survey_roles.each do |role| %>
                   <% completion = @survey_completions.completion(registration.registrant_id, role) %>
diff --git a/spec/services/event_registration_readiness_spec.rb b/spec/services/event_registration_readiness_spec.rb
index 6131f5e3d0..1ff44bdd5c 100644
--- a/spec/services/event_registration_readiness_spec.rb
+++ b/spec/services/event_registration_readiness_spec.rb
@@ -243,6 +243,31 @@ def award_scholarship(reg, tasks_completed:, amount: 1000)
     end
   end
 
+  describe "a denied CE" do
+    let(:ce) do
+      create(:continuing_education_registration, event_registration: registration, cost_cents: 5_000,
+        professional_license: create(:professional_license, person: registration.registrant, number: nil))
+    end
+
+    before do
+      pay(registration, 1000)
+      link_org(registration)
+      event.update!(start_date: 3.days.ago, end_date: 2.days.ago)
+      registration.update!(status: "attended")
+      ce.update!(denied_at: Time.current)
+    end
+
+    it "doesn't hold readiness back" do
+      expect(readiness.event_ready_issues).to be_empty
+      expect(readiness.certificate_issues).to be_empty
+      expect(readiness.status).to eq(:completed)
+    end
+
+    it "is noted instead" do
+      expect(readiness.notes).to eq([ "CE denied" ])
+    end
+  end
+
   describe "#status" do
     it "is :not_ready when a pre-event condition is outstanding" do
       # default registrant is unpaid on a paid event