Add a sectors-style age-range editor to the person form

AGENTS.md

@@ -300,6 +300,7 @@ end
 - `paginated_fields` — Client-side pagination of nested fields
 - `password_toggle` — Show/hide password fields
 - `prefetch_lazy` — Prefetch lazy-loaded content
+- `primary_tag` — Shared single-primary star for the sector and age-range cocoon chip editors (clears other stars, highlights via configurable classes, no reorder)
 - `print_options` — Print options toggle for analytics
 - `reminder_preview` — Live-preview a custom message in the reminder email as the admin types it on the bulk-reminder page
 - `remote_select` — AJAX-powered select dropdown

app/controllers/concerns/tag_assignable.rb

@@ -7,7 +7,19 @@ def assign_associations(record, param_key: nil)
     key = param_key || record.model_name.param_key
 
     selected_category_ids = Array(params[key][:category_ids]).reject(&:blank?).map(&:to_i)
-    record.categories = Category.where(id: selected_category_ids)
+    selected = Category.where(id: selected_category_ids).to_a
+
+    if params[key].key?(:managed_category_type_ids)
+      # The form only edits certain category types (e.g. age ranges + workshop
+      # settings). Preserve taggings of every other type the form never shows so
+      # saving can't silently drop them — and assign the union so the join rows
+      # for preserved categories stay intact (is_primary/legacy_id untouched).
+      managed_type_ids = Array(params[key][:managed_category_type_ids]).reject(&:blank?).map(&:to_i)
+      preserved = record.categories.reject { |category| managed_type_ids.include?(category.category_type_id) }
+      record.categories = (preserved + selected).uniq
+    else
+      record.categories = selected
+    end
 
     if params[key].key?(:sector_ids)
       selected_sector_ids = Array(params[key][:sector_ids]).reject(&:blank?).map(&:to_i)

app/controllers/people_controller.rb

@@ -293,6 +293,21 @@ def set_form_variables
       .group_by(&:category_type)
       .select { |type, _| type&.profile_specific? }
       .sort_by { |type, _| type&.name.to_s.downcase }
+
+    # Age ranges edit as their own sectors-style cocoon chip picker (AgeRange
+    # isn't a profile_specific type, so it never appears in
+    # @person_categories_grouped). Tagged via age_range_categorizable_items nested
+    # attributes, not category_ids.
+    @age_range_type = CategoryType.find_by(name: AgeGroupTaggable::AGE_RANGE_CATEGORY_TYPE)
+    age_ranges = @age_range_type ? @age_range_type.categories.published.order(:position, :name) : Category.none
+    @age_ranges_collection = age_ranges.pluck(:name, :id)
+    @current_age_range_category_ids = @person.age_range_categorizable_items.map(&:category_id)
+
+    # The category types this form edits via category_ids — the profile-specific
+    # types shown below (workshop settings). assign_associations preserves taggings
+    # of any other type (age ranges included, handled by nested attributes), so
+    # saving the form can't drop a person's other category connections.
+    @managed_category_type_ids = @person_categories_grouped.map { |type, _| type.id }
   end
 
   def find_duplicate_people(first_name, last_name, email, legal_first_name: nil, email_2: nil)
@@ -465,8 +480,8 @@ def person_params
       :youtube_url,
       :twitter_url,
       :created_by_id, :updated_by_id,
-      category_ids: [],
       sectorable_items_attributes: [ :id, :sector_id, :is_leader, :is_primary, :_destroy ],
+      age_range_categorizable_items_attributes: [ :id, :category_id, :is_primary, :_destroy ],
       addresses_attributes: [
         :id,
         :address_type,

app/frontend/javascript/controllers/index.js

@@ -159,8 +159,8 @@ application.register("searchable-select", SearchableSelectController)
 import SectionFilterController from "./section_filter_controller"
 application.register("section-filter", SectionFilterController)
 
-import PrimarySectorController from "./primary_sector_controller"
-application.register("primary-sector", PrimarySectorController)
+import PrimaryTagController from "./primary_tag_controller"
+application.register("primary-tag", PrimaryTagController)
 
 import FormSectionToggleController from "./form_section_toggle_controller"
 application.register("form-section-toggle", FormSectionToggleController)

app/frontend/javascript/controllers/primary_tag_controller.js

@@ -0,0 +1,37 @@
+import { Controller } from "@hotwired/stimulus"
+
+// Drives a chip editor with a single-select "primary" star, shared by the sector
+// and age-range pickers on the person/organization form. Lighting one star clears
+// the others; the configurable primary/default classes highlight the starred chip.
+// Chips are NOT reordered — they keep their rendered (alphabetical / position)
+// order, so starring doesn't reshuffle them. Profile/recipients/dashboard views
+// still lead with the primary on display. The sector chip's leader (crown) flag is
+// independent and CSS-only, so it needs no JS here.
+export default class extends Controller {
+  static targets = ["chip", "primary"]
+  static classes = ["primary", "default"]
+
+  connect() {
+    this.style()
+  }
+
+  selectPrimary(event) {
+    if (event.target.checked) {
+      this.primaryTargets.forEach((checkbox) => {
+        if (checkbox !== event.target) checkbox.checked = false
+      })
+    }
+    this.style()
+  }
+
+  // Reflect each chip's primary state: highlight the starred chip, reset the rest.
+  style() {
+    this.primaryTargets.forEach((checkbox) => {
+      const chip = checkbox.closest("[data-primary-tag-target='chip']")
+      if (!chip) return
+      const primary = checkbox.checked
+      this.primaryClasses.forEach((klass) => chip.classList.toggle(klass, primary))
+      this.defaultClasses.forEach((klass) => chip.classList.toggle(klass, !primary))
+    })
+  }
+}

app/models/concerns/age_group_taggable.rb

@@ -32,7 +32,7 @@ def primary_age_category_ids
   # only updates existing items rather than creating them.
   def apply_primary_age_groups!(primary_category_ids)
     primary = sanitize_age_ids(primary_category_ids).to_set
-    age_range_categorizable_items.includes(:category).find_each do |item|
+    age_range_items_relation.includes(:category).find_each do |item|
       desired = primary.include?(item.category_id)
       item.update!(is_primary: desired) if item.is_primary? != desired
     end
@@ -64,7 +64,9 @@ def age_range_item?(item)
     item.category&.category_type&.name == AGE_RANGE_CATEGORY_TYPE
   end
 
-  def age_range_categorizable_items
+  # Query relation of this record's AgeRange categorizable_items. Named to avoid
+  # colliding with Person's age_range_categorizable_items nested association.
+  def age_range_items_relation
     categorizable_items
       .joins(category: :category_type)
       .where(category_types: { name: AGE_RANGE_CATEGORY_TYPE })

app/models/concerns/sectors_taggable.rb

@@ -12,11 +12,20 @@ module SectorsTaggable
   # Sectorable items ordered for display: the primary sector first, then the
   # rest alphabetically by sector name. Sorts the in-memory association rather
   # than issuing a query, so it stays correct when a form re-renders its
-  # unsaved items after a failed save.
+  # unsaved items after a failed save. Used by profile, recipients, and dashboard
+  # views, where the primary should always lead.
   def sectorable_items_primary_first
     sectorable_items.sort_by { |item| [ item.is_primary? ? 0 : 1, item.sector&.name.to_s.downcase ] }
   end
 
+  # Sectorable items in stable order for the edit form: alphabetically by sector
+  # name (sectors have no position column, so name is the position-equivalent).
+  # Unlike sectorable_items_primary_first, the primary is NOT floated to the top,
+  # so starring a sector on the form doesn't reshuffle the chips.
+  def sectorable_items_ordered
+    sectorable_items.sort_by { |item| item.sector&.name.to_s.downcase }
+  end
+
   # Additively tag sectors as primary/additional without disturbing other
   # taggings — used by registration, where a respondent names a single primary
   # sector (the dropdown) plus any number of additional sectors (the checkboxes).

app/models/person.rb

@@ -57,6 +57,11 @@ class Person < ApplicationRecord
   CONTACT_TYPES = [ "work", "personal" ].freeze
   validates :email_type, inclusion: { in: %w[work personal] }, allow_blank: true
   validates :email_2_type, inclusion: { in: %w[work personal] }, allow_blank: true
+  # Mirrors SectorsTaggable's single-primary rule for age ranges — the chip
+  # editor's single-star JS is the first line of defense, this guards imports,
+  # the console, and bad form posts. Person-only: organizations aggregate
+  # several members' primary age groups, so they legitimately have more than one.
+  validate :at_most_one_primary_age_range
   # TODO: add validation for zip code containing only numbers
   # TODO: add validation on STATE
   # TODO: add validation on phone number type
@@ -67,6 +72,19 @@ class Person < ApplicationRecord
   accepts_nested_attributes_for :contact_methods, allow_destroy: true, reject_if: :all_blank
   accepts_nested_attributes_for :sectorable_items, allow_destroy: true,
                                 reject_if: proc { |attrs| attrs["sector_id"].blank? }
+  # Age ranges edit through cocoon nested fields like sectors. A scoped view of
+  # categorizable_items (AgeRange categories only) so the form's add/remove and
+  # primary toggle round-trip as nested attributes — the is_primary flag splits
+  # primary vs additional, no separate primary_age_category_ids param needed.
+  has_many :age_range_categorizable_items,
+           -> { joins(category: :category_type).where(category_types: { name: AgeGroupTaggable::AGE_RANGE_CATEGORY_TYPE }) },
+           class_name: "CategorizableItem", as: :categorizable, inverse_of: :categorizable
+  accepts_nested_attributes_for :age_range_categorizable_items, allow_destroy: true,
+                                reject_if: proc { |attrs| attrs["category_id"].blank? }
+  # The picker can submit the same age range twice (two new rows), which the
+  # CategorizableItem uniqueness validation can't catch — both are unsaved, so
+  # both INSERT and hit the DB unique index. Collapse duplicates before validation.
+  before_validation :dedupe_age_range_items
   accepts_nested_attributes_for :user, update_only: true
   accepts_nested_attributes_for :affiliations, allow_destroy: true,
     reject_if: proc { |attrs| attrs["organization_id"].blank? }
@@ -268,8 +286,41 @@ def other_workshop_setting_responses
     other_form_responses(OTHER_WORKSHOP_SETTING_IDENTIFIERS)
   end
 
+  # The age-range nested items in category position order for the cocoon chip
+  # editor. Reads the same association the form's nested attributes build into, so
+  # unsaved picks survive a failed save (and aren't primary-first — starring
+  # shouldn't reshuffle them). Display surfaces lead with the primary instead.
+  def age_range_items_ordered
+    age_range_categorizable_items.sort_by { |item| [ item.category&.position || 0, item.category&.name.to_s ] }
+  end
+
   private
 
+  # Count the in-memory set (not a DB query): nested attributes build the items in
+  # one transaction, so a row-level check would see none persisted yet.
+  def at_most_one_primary_age_range
+    primary_count = age_range_categorizable_items.reject(&:marked_for_destruction?).count(&:is_primary?)
+    return if primary_count <= 1
+
+    errors.add(:base, "Only one age range can be marked as primary")
+  end
+
+  # Keep one tagging per age-range category. Prefer the persisted row, fold any
+  # duplicate's primary flag onto the keeper, and drop the extras (destroy if
+  # persisted, otherwise remove from the unsaved set).
+  def dedupe_age_range_items
+    live = age_range_categorizable_items.reject(&:marked_for_destruction?)
+    live.group_by(&:category_id).each_value do |items|
+      next if items.size <= 1
+
+      keeper = items.find(&:persisted?) || items.first
+      keeper.is_primary = true if items.any?(&:is_primary?)
+      (items - [ keeper ]).each do |dup|
+        dup.persisted? ? dup.mark_for_destruction : age_range_categorizable_items.delete(dup)
+      end
+    end
+  end
+
   def other_form_responses(identifiers)
     form_submissions
       .joins(form_answers: :form_field)