Multi-Practitioner Encounter Documentation Architecture

Patient
   |
   +-- has_many :episodes_of_care (longitudinal)
   |       |
   |       +-- has_many :encounters
   |       +-- has_many :treatment_goals
   |       +-- has_many :progress_notes
   |
   +-- has_many :encounters (can exist without episode)

Encounter (hub)
   |
   +-- has_many :encounter_participants (providers)
   +-- has_many :encounter_documents (1..N documents)
   |       |
   |       +-- doc_type: prescription | therapy_session | physio_session | nutrition_consultation
   |       +-- status: draft | signed | locked | amended
   |       +-- data: JSONB (structured content)
   |       +-- has_many :child records (ROM, exercises, meal plans)
   |
   +-- has_many :clinical_measurements (generalized vitals/ROM/anthropometrics)
   +-- has_many :assessment_responses (PHQ-9, GAD-7, etc.)
   +-- has_many :encounter_attachments (files/media)
   +-- has_many :encounter_notes (shared notes with visibility)

# Represents a course of treatment spanning multiple encounters
create_table :episodes_of_care do |t|
  t.references :patient, null: false, foreign_key: true
  t.references :clinic, null: false, foreign_key: true
  t.references :primary_provider, foreign_key: { to_table: :users }

  t.string :episode_type  # therapy | physio | nutrition | chronic_care | etc
  t.string :status        # active | on_hold | completed | discharged
  t.string :reason        # chief complaint / referral reason
  t.date :start_date
  t.date :end_date
  t.date :target_end_date

  t.integer :total_sessions_planned
  t.integer :sessions_completed, default: 0
  t.string :frequency     # weekly | biweekly | monthly | as_needed

  t.text :long_term_goals
  t.text :discharge_summary
  t.jsonb :metadata, default: {}

  t.boolean :deleted, default: false
  t.datetime :deleted_at
  t.timestamps
end

add_index :episodes_of_care, [:patient_id, :status]
add_index :episodes_of_care, [:clinic_id, :episode_type]

# Enables multi-practitioner encounters and proper attribution
create_table :encounter_participants do |t|
  t.references :encounter, null: false, foreign_key: true
  t.references :user, null: false, foreign_key: true  # provider

  t.string :role, null: false  # primary | assistant | supervisor | scribe | consultant
  t.string :practitioner_type  # doctor | psychologist | physiotherapist | dietitian

  t.boolean :can_view_private_notes, default: false
  t.boolean :can_sign, default: false
  t.boolean :can_edit, default: true

  t.datetime :joined_at
  t.datetime :left_at

  t.timestamps
end

add_index :encounter_participants, [:encounter_id, :user_id], unique: true
add_index :encounter_participants, [:encounter_id, :role]

# Generic document container - 1:N documents per encounter
create_table :encounter_documents do |t|
  t.references :encounter, null: false, foreign_key: true
  t.references :episode_of_care, foreign_key: true  # optional link to episode
  t.references :author, null: false, foreign_key: { to_table: :users }

  t.string :doc_type, null: false
  # Types: prescription | therapy_session | therapy_assessment | therapy_safety_plan |
  #        physio_session | physio_evaluation | nutrition_consultation |
  #        nutrition_followup | general_note | medical_certificate

  t.string :status, null: false, default: 'draft'
  # Status: draft | pending_signature | signed | locked | amended | void

  t.string :title
  t.jsonb :data, null: false, default: {}  # structured content

  # Signature workflow
  t.references :signed_by, foreign_key: { to_table: :users }
  t.datetime :signed_at
  t.references :co_signer, foreign_key: { to_table: :users }
  t.datetime :co_signed_at

  # Amendment tracking
  t.integer :version, default: 1
  t.references :amends_document, foreign_key: { to_table: :encounter_documents }
  t.text :amendment_reason

  # Visibility
  t.string :visibility, default: 'care_team'
  # Visibility: private_to_author | care_team | clinic | patient_visible
  t.boolean :is_psychotherapy_note, default: false  # stricter access per 42 CFR Part 2
  t.jsonb :allowed_user_ids, default: []

  t.boolean :deleted, default: false
  t.datetime :deleted_at
  t.timestamps
end

add_index :encounter_documents, [:encounter_id, :doc_type]
add_index :encounter_documents, [:author_id, :status]
add_index :encounter_documents, :episode_of_care_id
add_index :encounter_documents, :status
add_index :encounter_documents, :data, using: :gin  # for JSONB queries

# Unified measurement system for all clinical data points
create_table :clinical_measurements do |t|
  t.references :encounter, null: false, foreign_key: true
  t.references :encounter_document, foreign_key: true  # optional link
  t.references :recorded_by, null: false, foreign_key: { to_table: :users }

  t.string :measurement_type, null: false
  # Types: bp_systolic | bp_diastolic | heart_rate | temperature | spo2 | weight | height |
  #        bmi | waist_circumference | body_fat_pct | pain_scale |
  #        rom_[joint]_[movement] | grip_strength | etc

  t.decimal :value, precision: 10, scale: 2
  t.string :value_text  # for non-numeric (e.g., "regular" for pulse rhythm)
  t.string :unit        # mmHg | bpm | F | C | kg | lb | cm | in | degrees | etc

  t.string :method      # measured | self_reported | calculated | device_recorded
  t.string :body_site   # left | right | bilateral | n/a
  t.string :position    # sitting | standing | supine | prone

  t.jsonb :metadata, default: {}  # device info, reference range, etc
  t.text :notes

  t.datetime :measured_at
  t.timestamps
end

add_index :clinical_measurements, [:encounter_id, :measurement_type]
add_index :clinical_measurements, :measurement_type

# Definition of assessment tools (PHQ-9, GAD-7, ROM scales, etc.)
create_table :assessment_instruments do |t|
  t.string :code, null: false  # phq9 | gad7 | bdi2 | oswestry | vas_pain | etc
  t.string :name, null: false
  t.string :version
  t.string :category  # mental_health | pain | functional | nutrition | etc

  t.jsonb :questions, null: false, default: []  # array of question definitions
  t.jsonb :scoring_rules, null: false, default: {}  # how to calculate scores
  t.jsonb :severity_bands, default: []  # score ranges and interpretations

  t.integer :min_score
  t.integer :max_score
  t.boolean :higher_is_worse, default: true

  t.text :description
  t.text :instructions
  t.string :license_info

  t.boolean :active, default: true
  t.timestamps
end

add_index :assessment_instruments, :code, unique: true
add_index :assessment_instruments, :category

# Completed assessment with answers and computed score
create_table :assessment_responses do |t|
  t.references :encounter, null: false, foreign_key: true
  t.references :encounter_document, foreign_key: true
  t.references :assessment_instrument, null: false, foreign_key: true
  t.references :administered_by, null: false, foreign_key: { to_table: :users }

  t.jsonb :answers, null: false, default: {}  # question_id => answer mapping
  t.decimal :total_score, precision: 6, scale: 2
  t.string :severity_level  # computed from scoring_rules
  t.text :clinical_interpretation

  t.datetime :administered_at
  t.integer :time_to_complete_seconds

  t.boolean :requires_follow_up, default: false
  t.boolean :safety_alert_triggered, default: false  # for suicidal ideation questions
  t.text :follow_up_notes

  t.timestamps
end

add_index :assessment_responses, [:encounter_id, :assessment_instrument_id]
add_index :assessment_responses, :safety_alert_triggered

create_table :encounter_notes do |t|
  t.references :encounter, null: false, foreign_key: true
  t.references :encounter_document, foreign_key: true  # optional link
  t.references :author, null: false, foreign_key: { to_table: :users }

  t.string :note_type, null: false
  # Types: clinical_observation | progress | assessment | plan | general | addendum

  t.text :content, null: false
  t.jsonb :structured_data, default: {}

  t.string :visibility, null: false, default: 'care_team'
  # Visibility: private_to_author | care_team | clinic | patient_visible
  t.boolean :is_psychotherapy_note, default: false
  t.jsonb :allowed_user_ids, default: []

  t.boolean :deleted, default: false
  t.datetime :deleted_at
  t.timestamps
end

add_index :encounter_notes, [:encounter_id, :note_type]
add_index :encounter_notes, :visibility

create_table :encounter_attachments do |t|
  t.references :encounter, null: false, foreign_key: true
  t.references :encounter_document, foreign_key: true
  t.references :uploaded_by, null: false, foreign_key: { to_table: :users }

  t.string :file_type  # image | video | pdf | document | audio
  t.string :category   # photo | exercise_video | worksheet | consent_form | etc
  t.string :title
  t.text :description

  # CarrierWave/ActiveStorage fields
  t.string :file
  t.string :content_type
  t.integer :file_size

  t.boolean :patient_visible, default: false

  t.boolean :deleted, default: false
  t.datetime :deleted_at
  t.timestamps
end

add_index :encounter_attachments, :encounter_id
add_index :encounter_attachments, :encounter_document_id

# TreatmentGoal - shared across therapy/physio/nutrition episodes
create_table :treatment_goals do |t|
  t.references :episode_of_care, null: false, foreign_key: true
  t.references :created_by, null: false, foreign_key: { to_table: :users }

  t.string :goal_type  # short_term | long_term | maintenance
  t.text :description, null: false
  t.string :status     # active | achieved | modified | discontinued
  t.date :target_date
  t.date :achieved_date

  t.integer :progress_percent, default: 0
  t.text :progress_notes
  t.jsonb :milestones, default: []

  t.timestamps
end

# SafetyPlan - for therapy when risk is elevated
create_table :safety_plans do |t|
  t.references :encounter_document, null: false, foreign_key: true
  t.references :patient, null: false, foreign_key: true

  t.jsonb :warning_signs, default: []
  t.jsonb :coping_strategies, default: []
  t.jsonb :support_contacts, default: []  # name, phone, relationship
  t.jsonb :professional_contacts, default: []
  t.text :environment_safety_steps
  t.text :reasons_for_living

  t.datetime :reviewed_at
  t.references :reviewed_by, foreign_key: { to_table: :users }

  t.timestamps
end

# ROMMeasurement - linked to encounter_document
create_table :rom_measurements do |t|
  t.references :encounter_document, null: false, foreign_key: true

  t.string :joint, null: false      # shoulder | elbow | wrist | hip | knee | ankle | spine
  t.string :movement, null: false   # flexion | extension | abduction | adduction | rotation
  t.string :side                    # left | right | bilateral

  t.decimal :active_rom, precision: 5, scale: 2
  t.decimal :passive_rom, precision: 5, scale: 2
  t.string :unit, default: 'degrees'

  t.integer :pain_during, default: 0  # 0-10
  t.text :notes

  t.timestamps
end

add_index :rom_measurements, [:encounter_document_id, :joint, :movement]

# ExercisePrescription - linked to encounter_document
create_table :exercise_prescriptions do |t|
  t.references :encounter_document, null: false, foreign_key: true
  t.references :exercise_library_item, foreign_key: true  # optional link to library

  t.string :exercise_name, null: false
  t.string :category        # strengthening | stretching | balance | cardio | functional
  t.text :description
  t.text :instructions

  t.integer :sets
  t.integer :reps
  t.integer :hold_seconds
  t.string :frequency       # daily | 2x_daily | 3x_week | etc
  t.string :intensity       # light | moderate | vigorous

  t.text :precautions
  t.text :progression_criteria
  t.integer :order_index

  t.string :video_url
  t.string :image_url

  t.timestamps
end

# MealPlan - linked to encounter_document
create_table :meal_plans do |t|
  t.references :encounter_document, null: false, foreign_key: true

  t.string :plan_type       # daily | weekly | template
  t.date :effective_date

  t.jsonb :meals, null: false, default: []
  # Structure: [{ meal_type: 'breakfast', time: '08:00', foods: [...], portions: [...], calories: N }]

  t.integer :target_calories
  t.integer :target_protein_g
  t.integer :target_carbs_g
  t.integer :target_fat_g
  t.integer :target_fiber_g

  t.jsonb :restrictions, default: []  # gluten_free | dairy_free | low_sodium | etc
  t.text :special_instructions

  t.timestamps
end

# NutritionalAssessment - detailed intake analysis
create_table :nutritional_assessments do |t|
  t.references :encounter_document, null: false, foreign_key: true

  t.decimal :height_cm, precision: 5, scale: 2
  t.decimal :weight_kg, precision: 5, scale: 2
  t.decimal :bmi, precision: 4, scale: 2
  t.decimal :waist_cm, precision: 5, scale: 2
  t.decimal :body_fat_pct, precision: 4, scale: 2

  t.string :weight_goal      # lose | gain | maintain
  t.decimal :target_weight_kg, precision: 5, scale: 2

  t.text :diet_history
  t.jsonb :food_allergies, default: []
  t.jsonb :dietary_restrictions, default: []
  t.jsonb :supplements, default: []
  t.jsonb :medications_affecting_nutrition, default: []

  t.integer :meals_per_day
  t.integer :snacks_per_day
  t.text :eating_schedule
  t.text :hydration_notes

  t.timestamps
end

# Database-driven configuration per encounter type
create_table :encounter_type_configs do |t|
  t.string :practitioner_type, null: false  # doctor | psychologist | physiotherapist | dietitian
  t.references :clinic, foreign_key: true   # null = system default, clinic_id = override

  t.jsonb :allowed_doc_types, null: false, default: []
  t.jsonb :tabs, null: false, default: []
  t.string :default_tab

  t.boolean :has_prescriptions, default: false
  t.jsonb :required_measurements, default: []
  t.jsonb :enabled_assessments, default: []  # codes from AssessmentInstrument

  t.jsonb :print_templates, default: []
  t.jsonb :ai_scribe_config, default: {}

  t.boolean :active, default: true
  t.timestamps
end

add_index :encounter_type_configs, [:practitioner_type, :clinic_id], unique: true

# GET /api/v1/encounter_type_configs
# Returns configuration for current clinic/practitioner type
# Frontend fetches and caches this on app load

def index
  configs = EncounterTypeConfig.for_clinic(current_clinic)
                               .includes(:assessment_instruments)
  render json: EncounterTypeConfigSerializer.new(configs)
end

# Seeded system defaults
DEFAULTS = {
  doctor: {
    allowed_doc_types: ['prescription', 'medical_certificate', 'general_note'],
    tabs: ['vitals', 'observations', 'medications', 'investigations', 'advice', 'next_visit'],
    default_tab: 'vitals',
    has_prescriptions: true,
    required_measurements: ['bp_systolic', 'bp_diastolic', 'heart_rate', 'temperature'],
    enabled_assessments: []
  },
  psychologist: {
    allowed_doc_types: ['therapy_session', 'therapy_assessment', 'therapy_safety_plan', 'general_note'],
    tabs: ['measurements', 'assessments', 'session_notes', 'treatment_plan', 'homework', 'next_visit'],
    default_tab: 'session_notes',
    has_prescriptions: false,
    required_measurements: [],
    enabled_assessments: ['phq9', 'gad7', 'bdi2', 'pcl5']
  },
  physiotherapist: {
    allowed_doc_types: ['physio_session', 'physio_evaluation', 'general_note'],
    tabs: ['measurements', 'assessment', 'rom', 'treatment', 'exercises', 'progress', 'next_visit'],
    default_tab: 'assessment',
    has_prescriptions: false,
    required_measurements: ['pain_scale'],
    enabled_assessments: ['oswestry', 'dash', 'lefs']
  },
  dietitian: {
    allowed_doc_types: ['nutrition_consultation', 'nutrition_followup', 'general_note'],
    tabs: ['measurements', 'nutritional_assessment', 'meal_plan', 'goals', 'progress', 'next_visit'],
    default_tab: 'nutritional_assessment',
    has_prescriptions: false,
    required_measurements: ['weight', 'height', 'bmi', 'waist_circumference'],
    enabled_assessments: []
  }
}

class Encounter < ApplicationRecord
  # Existing associations...

  # New associations
  belongs_to :episode_of_care, optional: true
  has_many :encounter_participants, dependent: :destroy
  has_many :providers, through: :encounter_participants, source: :user

  has_many :encounter_documents, dependent: :destroy
  has_many :clinical_measurements, dependent: :destroy
  has_many :assessment_responses, dependent: :destroy
  has_many :encounter_notes, dependent: :destroy
  has_many :encounter_attachments, dependent: :destroy

  # Primary provider convenience
  def primary_provider
    encounter_participants.find_by(role: 'primary')&.user
  end

  def primary_practitioner_type
    encounter_participants.find_by(role: 'primary')&.practitioner_type
  end

  # Get applicable configuration
  def type_config
    EncounterTypeConfig.for_practitioner_type(primary_practitioner_type, clinic)
  end

  # Get all documents of specific type
  def documents_of_type(doc_type)
    encounter_documents.where(doc_type: doc_type)
  end

  # Get primary document (most common use case)
  def primary_document
    encounter_documents.where.not(status: ['void', 'amended']).order(:created_at).first
  end
end

# Immutable audit trail for medico-legal defensibility
create_table :document_audit_logs do |t|
  t.references :encounter_document, null: false, foreign_key: true
  t.references :user, null: false, foreign_key: true

  t.string :action, null: false  # created | viewed | edited | signed | co_signed | amended | voided
  t.jsonb :changes, default: {}  # diff of what changed
  t.jsonb :previous_data, default: {}  # snapshot before change

  t.string :ip_address
  t.string :user_agent

  t.datetime :performed_at, null: false
  t.timestamps
end

add_index :document_audit_logs, [:encounter_document_id, :performed_at]
add_index :document_audit_logs, :action

# SafetyAlertRule - configurable thresholds
create_table :safety_alert_rules do |t|
  t.references :clinic, foreign_key: true  # null = system default

  t.string :rule_type, null: false
  # Types: assessment_threshold | measurement_threshold | keyword_detection

  t.string :trigger_source  # assessment_code or measurement_type
  t.string :operator        # >= | > | <= | < | == | contains
  t.decimal :threshold_value, precision: 6, scale: 2
  t.string :threshold_text  # for keyword matching

  t.string :severity, null: false  # info | warning | critical
  t.text :alert_message
  t.jsonb :required_actions, default: []  # safety_plan | supervisor_review | etc
  t.jsonb :notify_roles, default: []

  t.boolean :active, default: true
  t.timestamps
end

# SafetyAlert - triggered alerts
create_table :safety_alerts do |t|
  t.references :encounter, null: false, foreign_key: true
  t.references :patient, null: false, foreign_key: true
  t.references :safety_alert_rule, null: false, foreign_key: true
  t.references :triggered_by_response, foreign_key: { to_table: :assessment_responses }

  t.string :severity, null: false
  t.text :alert_message
  t.jsonb :trigger_data, default: {}

  t.string :status, default: 'open'  # open | acknowledged | resolved
  t.references :acknowledged_by, foreign_key: { to_table: :users }
  t.datetime :acknowledged_at
  t.text :resolution_notes
  t.references :resolved_by, foreign_key: { to_table: :users }
  t.datetime :resolved_at

  t.timestamps
end

add_index :safety_alerts, [:patient_id, :status]
add_index :safety_alerts, [:encounter_id, :severity]

class SafetyAlertService
  def self.check_assessment_response(response)
    rules = SafetyAlertRule.for_assessment(response.assessment_instrument.code)

    rules.each do |rule|
      if rule.triggered_by?(response)
        create_alert(response.encounter, response, rule)
      end
    end
  end

  def self.create_alert(encounter, trigger, rule)
    alert = SafetyAlert.create!(
      encounter: encounter,
      patient: encounter.patient,
      safety_alert_rule: rule,
      triggered_by_response: trigger,
      severity: rule.severity,
      alert_message: rule.alert_message,
      trigger_data: { score: trigger.total_score, threshold: rule.threshold_value }
    )

    # Notify relevant parties
    SafetyAlertNotificationJob.perform_later(alert.id)

    # Require safety plan if configured
    if rule.required_actions.include?('safety_plan')
      # Flag that safety plan is required
    end
  end
end

// Frontend fetches configuration from backend on app load
// GET /api/v1/encounter_type_configs

interface EncounterTypeConfig {
  practitioner_type: string;
  allowed_doc_types: string[];
  tabs: TabConfig[];
  default_tab: string;
  has_prescriptions: boolean;
  required_measurements: string[];
  enabled_assessments: AssessmentInstrument[];
}

interface TabConfig {
  id: string;
  label: string;
  icon?: string;
  component: string;  // Component name to render
  required?: boolean;
}

// Tab components are mapped client-side
const TAB_COMPONENTS: Record<string, React.LazyExoticComponent<any>> = {
  'vitals': lazy(() => import('./tabs/VitalsTab')),
  'measurements': lazy(() => import('./tabs/MeasurementsTab')),
  'observations': lazy(() => import('./tabs/ObservationsTab')),
  'session_notes': lazy(() => import('./tabs/SessionNotesTab')),
  'assessments': lazy(() => import('./tabs/AssessmentsTab')),
  'rom': lazy(() => import('./tabs/ROMTab')),
  'exercises': lazy(() => import('./tabs/ExercisesTab')),
  'meal_plan': lazy(() => import('./tabs/MealPlanTab')),
  'nutritional_assessment': lazy(() => import('./tabs/NutritionalAssessmentTab')),
  'treatment_plan': lazy(() => import('./tabs/TreatmentPlanTab')),
  'homework': lazy(() => import('./tabs/HomeworkTab')),
  'progress': lazy(() => import('./tabs/ProgressTab')),
  'next_visit': lazy(() => import('./tabs/NextVisitTab')),
  // ... etc
};

// apps/cms/src/pages/encounter/EncounterPage.tsx

export function EncounterPage() {
  const { encounterId } = useParams();
  const { data: encounter } = useEncounter(encounterId);
  const { data: typeConfig } = useEncounterTypeConfig(encounter?.primary_practitioner_type);

  const [activeTab, setActiveTab] = useState<string>();

  useEffect(() => {
    if (typeConfig && !activeTab) {
      setActiveTab(typeConfig.default_tab);
    }
  }, [typeConfig]);

  if (!typeConfig) return <Loading />;

  const TabComponent = TAB_COMPONENTS[activeTab];

  return (
    <div className="encounter-page">
      <EncounterHeader encounter={encounter} />

      <TabNavigation
        tabs={typeConfig.tabs}
        activeTab={activeTab}
        onTabChange={setActiveTab}
      />

      <Suspense fallback={<TabLoading />}>
        <TabComponent
          encounter={encounter}
          config={typeConfig}
        />
      </Suspense>
    </div>
  );
}

frontend/apps/cms/src/components/
├── encounter/
│   ├── tabs/
│   │   ├── VitalsTab.tsx           # Traditional vitals (BP, HR, temp)
│   │   ├── MeasurementsTab.tsx     # Generic measurements (vitals + ROM + anthropometrics)
│   │   ├── ObservationsTab.tsx     # Clinical observations
│   │   ├── SessionNotesTab.tsx     # Therapy/session documentation
│   │   ├── AssessmentsTab.tsx      # PHQ-9, GAD-7, etc. (data-driven)
│   │   ├── ROMTab.tsx              # Range of motion for physio
│   │   ├── ExercisesTab.tsx        # Exercise prescription
│   │   ├── MealPlanTab.tsx         # Nutrition meal planning
│   │   ├── NutritionalAssessmentTab.tsx
│   │   ├── TreatmentPlanTab.tsx    # Goals and treatment planning
│   │   ├── HomeworkTab.tsx         # Therapy homework assignments
│   │   ├── ProgressTab.tsx         # Episode progress tracking
│   │   ├── NextVisitTab.tsx        # Follow-up scheduling
│   │   └── MedicationsTab.tsx      # Prescriptions (doctor only)
│   │
│   ├── documents/
│   │   ├── DocumentList.tsx        # List of encounter documents
│   │   ├── DocumentEditor.tsx      # Generic document editor
│   │   ├── DocumentSignature.tsx   # Signature workflow
│   │   └── DocumentViewer.tsx      # Read-only view with audit trail
│   │
│   ├── assessments/
│   │   ├── AssessmentRenderer.tsx  # Data-driven assessment form
│   │   ├── AssessmentResults.tsx   # Score display with severity
│   │   └── AssessmentHistory.tsx   # Prior assessment comparison
│   │
│   ├── safety/
│   │   ├── SafetyAlertBanner.tsx   # Alert display
│   │   ├── SafetyPlanEditor.tsx    # Safety plan form
│   │   └── RiskAssessment.tsx      # Risk level indicator
│   │
│   └── shared/
│       ├── MeasurementInput.tsx    # Generic measurement entry
│       ├── VisibilitySelector.tsx  # Note visibility control
│       └── ParticipantList.tsx     # Multi-provider display

# Key constraints to add
add_foreign_key :encounter_documents, :encounter_documents, column: :amends_document_id
add_foreign_key :episodes_of_care, :users, column: :primary_provider_id

# Partial unique indexes
add_index :encounter_participants, [:encounter_id, :role],
          where: "role = 'primary'",
          unique: true,
          name: 'idx_one_primary_per_encounter'

# GIN indexes for JSONB querying
add_index :encounter_documents, :data, using: :gin
add_index :clinical_measurements, :metadata, using: :gin
add_index :assessment_responses, :answers, using: :gin

# Composite indexes for common queries
add_index :encounter_documents, [:encounter_id, :status, :doc_type]
add_index :clinical_measurements, [:encounter_id, :measurement_type, :measured_at]

# Encounter model supports both patterns during transition
class Encounter
  has_one :prescription  # Legacy
  has_many :encounter_documents  # New

  def documentation
    # Returns prescription for doctors, encounter_documents for others
    if primary_practitioner_type == 'doctor'
      prescription
    else
      encounter_documents
    end
  end
end

# Backend feature flags
ENABLE_MULTI_PRACTITIONER_ENCOUNTERS: false
ENABLE_EPISODE_OF_CARE: false
ENABLE_SAFETY_ALERTS: false
ENABLE_DOCUMENT_SIGNATURES: false

// Frontend feature flags
ENABLE_THERAPY_ENCOUNTERS: false
ENABLE_PHYSIO_ENCOUNTERS: false
ENABLE_NUTRITION_ENCOUNTERS: false
ENABLE_DYNAMIC_TABS: false