# Week 2+ Implementation Plan - Functional Specification V2.0
## Strategic Roadmap to 100% Completion

**Date:** January 9, 2025  
**Current Status:** 75% Complete  
**Target:** 100% Complete  
**Estimated Timeline:** 8-10 weeks

---

## 📊 Current State Analysis

### ✅ Completed Systems (100%)
1. **Core Infrastructure** - Multi-tenant, authentication, permissions
2. **Patient Safety System** - Safety flags, crisis protocols, allergies
3. **MDT Collaboration** - Full workflow with dual-senior approval
4. **Appointment Management** - State machine, room conflicts, scheduling
5. **Documentation Tracking** - Delay monitoring, senior alerts
6. **Security & Safety** - Audit trails, role-based access
7. **Financial Systems** - ZATCA compliant invoicing
8. **Package Management** - Session ordering, auto-scheduling service
9. **Consent Management** - Expiry tracking, digital signatures
10. **Referral System** - Cross-clinic referrals with notifications

### ⚠️ Remaining Critical Gaps (25%)

| System | Current | Target | Priority |
|--------|---------|--------|----------|
| **Clinical Forms** | 40% | 100% | 🔴 CRITICAL |
| **Therapist Reports** | 10% | 100% | 🔴 CRITICAL |
| **Visual Progress Tracking** | 10% | 100% | 🔴 CRITICAL |
| **Therapist Dashboard** | 30% | 100% | 🟡 HIGH |

---

## 🎯 Strategic Implementation Phases

### Phase 1: Clinical Forms Expansion (Weeks 2-5)
**Goal:** Complete all clinic-specific forms  
**Current:** 40% → **Target:** 100%  
**Effort:** 4 weeks

#### Week 2: ABA Forms
- [ ] Create ABA app structure
- [ ] ABA Consultation Form (ABA-F-1)
- [ ] ABA Intervention Form (ABA-F-2)
- [ ] ABA Progress Report (ABA-F-3)
- [ ] Admin integration
- [ ] Form validation

#### Week 3: SLP Forms
- [ ] Create SLP app structure (already exists, needs completion)
- [ ] SLP Consultation Form (SLP-F-1)
- [ ] SLP Assessment/Reassessment Report (SLP-F-2)
- [ ] SLP Intervention Form (SLP-F-3)
- [ ] SLP Progress Report (SLP-F-4)
- [ ] Admin integration

#### Week 4: Medical & Nursing Forms
- [ ] Create Medical app structure
- [ ] Medical Consultation Form (MD-F-1)
- [ ] Medical Follow-up Form (MD-F-2)
- [ ] Create Nursing app structure
- [ ] Nursing Assessment Form (MD-N-F-1)
- [ ] Admin integration

#### Week 5: Psychology Forms & OT Completion
- [ ] Create Psychology app structure
- [ ] Psychology Consultation Form
- [ ] Psychology Assessment Form
- [ ] Complete OT forms (OT-F-2, OT-F-3)
- [ ] Cross-clinic form testing

**Deliverables:**
- 5 clinic apps fully functional
- 15+ clinical forms implemented
- All forms with validation and admin
- Form versioning system
- Auto-save functionality

---

### Phase 2: Therapist Reports & Assessments (Weeks 6-7)
**Goal:** Complete report generation system  
**Current:** 10% → **Target:** 100%  
**Effort:** 2 weeks

#### Week 6: Report Models & Templates
- [ ] Create Report model (4 types: Initial, Progress, Re-Assessment, Discharge)
- [ ] Create ReportTemplate model for each clinic
- [ ] Report generation service
- [ ] Session data aggregation service
- [ ] Report versioning system

#### Week 7: Report Generation & Export
- [ ] Auto-populate report fields from sessions
- [ ] Clinic-specific report templates
- [ ] Visual summaries (tables)
- [ ] PDF export for reports
- [ ] Bilingual report support (Arabic/English)
- [ ] Report approval workflow

**Deliverables:**
- Report model with 4 types
- 5 clinic-specific templates
- Report generation service
- PDF export functionality
- Session data aggregation
- Bilingual support

---

### Phase 3: Visual Progress Tracking (Weeks 8-9)
**Goal:** Implement comprehensive progress visualization  
**Current:** 10% → **Target:** 100%  
**Effort:** 2 weeks

#### Week 8: Progress Metrics & Data Collection
- [ ] Create PatientProgressMetric model
- [ ] Define metrics for each clinic type
- [ ] Data collection from session notes
- [ ] Progress calculation algorithms
- [ ] Historical progress tracking

#### Week 9: Visualization & Charts
- [ ] Integrate Chart.js library
- [ ] Create progress dashboard
- [ ] Line charts for progress over time
- [ ] Bar charts for goal achievement
- [ ] Color-coded improvement indicators
- [ ] Export visual reports to PDF
- [ ] Clinic-specific progress views

**Deliverables:**
- PatientProgressMetric model
- Chart.js integration
- Progress dashboard with 5+ chart types
- Color-coded indicators
- PDF export with charts
- Clinic-specific metrics

---

### Phase 4: Therapist Dashboard (Week 10)
**Goal:** Create centralized therapist workspace  
**Current:** 30% → **Target:** 100%  
**Effort:** 1 week

#### Dashboard Components
- [ ] Today's appointments widget
- [ ] Pending documentation widget
- [ ] Patient priority flags widget
- [ ] Progress snapshot (latest 3 sessions)
- [ ] Assigned tasks panel
- [ ] Package sessions remaining widget
- [ ] Overdue documentation alerts
- [ ] Quick actions toolbar

#### Filtering & Search
- [ ] Filter by date range
- [ ] Filter by clinic
- [ ] Filter by patient
- [ ] Search functionality
- [ ] Saved filter presets

**Deliverables:**
- Complete therapist dashboard
- 8+ dashboard widgets
- Advanced filtering
- Quick actions
- Mobile-responsive design

---

## 📋 Detailed Implementation Tasks

### 1. Clinical Forms Implementation

#### ABA Forms Structure
```python
# aba/models.py
class ABAConsultation(ClinicallySignableMixin):
    """ABA Consultation Form (ABA-F-1)"""
    # Patient & Session Info
    patient = FK(Patient)
    appointment = FK(Appointment)
    consultation_date = DateField()
    
    # Referral Information
    referral_source = CharField()
    referral_reason = TextField()
    
    # Developmental History
    birth_history = TextField()
    developmental_milestones = TextField()
    medical_history = TextField()
    
    # Current Functioning
    communication_skills = TextField()
    social_skills = TextField()
    adaptive_behavior = TextField()
    problem_behaviors = TextField()
    
    # Assessment Results
    assessment_tools_used = TextField()
    assessment_findings = TextField()
    
    # Treatment Plan
    target_behaviors = TextField()
    intervention_strategies = TextField()
    goals = ManyToMany(TherapyGoal)
    
    # Recommendations
    recommendations = TextField()
    frequency_duration = CharField()

class ABAIntervention(ClinicallySignableMixin):
    """ABA Intervention Form (ABA-F-2)"""
    patient = FK(Patient)
    appointment = FK(Appointment)
    session_date = DateField()
    
    # Session Details
    target_behavior = FK(TherapyGoal)
    intervention_used = TextField()
    data_collected = JSONField()  # Trial-by-trial data
    
    # Progress
    correct_responses = IntegerField()
    incorrect_responses = IntegerField()
    prompted_responses = IntegerField()
    accuracy_percentage = DecimalField()
    
    # Behavior Notes
    behavior_observations = TextField()
    antecedents = TextField()
    consequences = TextField()
    
    # Next Session Plan
    next_session_plan = TextField()

class ABAProgressReport(ClinicallySignableMixin):
    """ABA Progress Report (ABA-F-3)"""
    patient = FK(Patient)
    report_period_start = DateField()
    report_period_end = DateField()
    
    # Goals Progress
    goals_progress = JSONField()  # {goal_id: {baseline, current, progress_percentage}}
    
    # Behavior Analysis
    behavior_trends = TextField()
    mastered_skills = TextField()
    emerging_skills = TextField()
    
    # Recommendations
    continue_goals = ManyToMany(TherapyGoal, related_name='continue')
    modify_goals = ManyToMany(TherapyGoal, related_name='modify')
    new_goals = ManyToMany(TherapyGoal, related_name='new')
    
    # Parent Training
    parent_training_provided = TextField()
    home_program_recommendations = TextField()
```

#### SLP Forms Structure
```python
# slp/models.py
class SLPConsultation(ClinicallySignableMixin):
    """SLP Consultation Form (SLP-F-1)"""
    patient = FK(Patient)
    appointment = FK(Appointment)
    
    # Case History
    chief_complaint = TextField()
    onset_duration = TextField()
    medical_history = TextField()
    developmental_history = TextField()
    
    # Communication Assessment
    receptive_language = TextField()
    expressive_language = TextField()
    articulation_phonology = TextField()
    voice_quality = TextField()
    fluency = TextField()
    pragmatics = TextField()
    
    # Oral Motor Examination
    oral_structures = TextField()
    oral_motor_function = TextField()
    feeding_swallowing = TextField()
    
    # Assessment Results
    standardized_tests = TextField()
    informal_assessment = TextField()
    
    # Diagnosis & Plan
    diagnosis = TextField()
    treatment_goals = ManyToMany(TherapyGoal)
    recommendations = TextField()

class SLPAssessment(ClinicallySignableMixin):
    """SLP Assessment/Reassessment Report (SLP-F-2)"""
    patient = FK(Patient)
    assessment_type = CharField(choices=['Initial', 'Reassessment'])
    assessment_date = DateField()
    
    # Test Results
    test_results = JSONField()  # {test_name: {scores, percentiles}}
    
    # Language Skills
    receptive_language_score = IntegerField()
    expressive_language_score = IntegerField()
    articulation_score = IntegerField()
    
    # Analysis
    strengths = TextField()
    weaknesses = TextField()
    clinical_impressions = TextField()
    
    # Recommendations
    treatment_recommendations = TextField()
    frequency_duration = CharField()

class SLPIntervention(ClinicallySignableMixin):
    """SLP Intervention Form (SLP-F-3)"""
    patient = FK(Patient)
    appointment = FK(Appointment)
    session_date = DateField()
    
    # Session Goals
    target_goals = ManyToMany(TherapyGoal)
    
    # Activities
    activities_used = TextField()
    materials_used = TextField()
    
    # Performance
    goal_performance = JSONField()  # {goal_id: accuracy_percentage}
    cues_required = TextField()
    
    # Observations
    patient_engagement = CharField(choices=['Excellent', 'Good', 'Fair', 'Poor'])
    behavior_notes = TextField()
    
    # Home Program
    home_practice_activities = TextField()

class SLPProgressReport(ClinicallySignableMixin):
    """SLP Progress Report (SLP-F-4)"""
    patient = FK(Patient)
    report_period_start = DateField()
    report_period_end = DateField()
    
    # Progress Summary
    goals_progress = JSONField()
    sessions_attended = IntegerField()
    
    # Skill Development
    receptive_language_progress = TextField()
    expressive_language_progress = TextField()
    articulation_progress = TextField()
    
    # Recommendations
    continue_treatment = BooleanField()
    modify_goals = TextField()
    discharge_recommendations = TextField()
```

#### Medical & Nursing Forms
```python
# medical/models.py
class MedicalConsultation(ClinicallySignableMixin):
    """Medical Consultation Form (MD-F-1)"""
    patient = FK(Patient)
    appointment = FK(Appointment)
    
    # Chief Complaint
    chief_complaint = TextField()
    history_present_illness = TextField()
    
    # Medical History
    past_medical_history = TextField()
    medications = TextField()
    allergies = TextField()
    family_history = TextField()
    
    # Physical Examination
    vital_signs = JSONField()  # {bp, hr, temp, rr, weight, height}
    general_appearance = TextField()
    system_review = TextField()
    
    # Assessment & Plan
    diagnosis = TextField()
    treatment_plan = TextField()
    medications_prescribed = TextField()
    follow_up = TextField()

class MedicalFollowUp(ClinicallySignableMixin):
    """Medical Follow-up Form (MD-F-2)"""
    patient = FK(Patient)
    appointment = FK(Appointment)
    previous_consultation = FK(MedicalConsultation)
    
    # Follow-up Details
    interval_history = TextField()
    compliance = CharField(choices=['Good', 'Fair', 'Poor'])
    
    # Current Status
    current_symptoms = TextField()
    vital_signs = JSONField()
    
    # Assessment
    progress_assessment = TextField()
    plan_modifications = TextField()

# nursing/models.py
class NursingAssessment(ClinicallySignableMixin):
    """Nursing Assessment Form (MD-N-F-1)"""
    patient = FK(Patient)
    appointment = FK(Appointment)
    
    # Vital Signs
    vital_signs = JSONField()
    pain_assessment = CharField()
    
    # Physical Assessment
    general_condition = TextField()
    skin_integrity = TextField()
    mobility = TextField()
    
    # Nursing Diagnosis
    nursing_diagnoses = TextField()
    
    # Care Plan
    interventions = TextField()
    patient_education = TextField()
```

---

### 2. Report Generation System

#### Report Models
```python
# core/models.py (or reports/models.py)
class Report(ClinicallySignableMixin):
    """Base report model for all report types"""
    
    class ReportType(models.TextChoices):
        INITIAL = 'INITIAL', 'Initial Assessment Report'
        PROGRESS = 'PROGRESS', 'Progress Report'
        REASSESSMENT = 'REASSESSMENT', 'Re-Assessment Report'
        DISCHARGE = 'DISCHARGE', 'Discharge Summary'
    
    # Basic Info
    patient = FK(Patient)
    clinic = FK(Clinic)
    report_type = CharField(choices=ReportType.choices)
    report_date = DateField()
    
    # Period Covered
    period_start = DateField()
    period_end = DateField()
    
    # Sessions Included
    sessions = ManyToMany(Appointment)
    total_sessions = IntegerField()
    
    # Report Content (JSON for flexibility)
    content = JSONField()  # Clinic-specific structured data
    
    # Generated Sections
    executive_summary = TextField()
    progress_summary = TextField()
    goals_progress = JSONField()
    recommendations = TextField()
    
    # Attachments
    charts_data = JSONField()  # Data for generating charts
    
    # Status
    is_finalized = BooleanField(default=False)
    finalized_at = DateTimeField(null=True)
    
    # Version Control
    version = IntegerField(default=1)
    previous_version = FK('self', null=True)

class ReportTemplate(models.Model):
    """Templates for different report types per clinic"""
    clinic = FK(Clinic)
    report_type = CharField(choices=Report.ReportType.choices)
    template_name = CharField()
    
    # Template Structure
    sections = JSONField()  # Ordered list of sections
    required_fields = JSONField()
    optional_fields = JSONField()
    
    # Formatting
    header_template = TextField()
    footer_template = TextField()
    css_styles = TextField()
    
    # Language Support
    language = CharField(choices=[('en', 'English'), ('ar', 'Arabic')])
    
    is_active = BooleanField(default=True)
    version = IntegerField(default=1)
```

#### Report Generation Service
```python
# reports/services.py
class ReportGenerationService:
    """Service for generating clinical reports"""
    
    def generate_report(self, patient, clinic, report_type, period_start, period_end):
        """Generate a report for a patient"""
        # 1. Gather session data
        sessions = self._get_sessions(patient, clinic, period_start, period_end)
        
        # 2. Aggregate data
        aggregated_data = self._aggregate_session_data(sessions, clinic)
        
        # 3. Calculate progress
        progress_data = self._calculate_progress(patient, clinic, aggregated_data)
        
        # 4. Generate content
        content = self._generate_content(report_type, clinic, aggregated_data, progress_data)
        
        # 5. Create report
        report = Report.objects.create(
            patient=patient,
            clinic=clinic,
            report_type=report_type,
            period_start=period_start,
            period_end=period_end,
            total_sessions=sessions.count(),
            content=content,
            executive_summary=self._generate_summary(content),
            goals_progress=progress_data,
            charts_data=self._prepare_chart_data(progress_data)
        )
        
        report.sessions.set(sessions)
        return report
    
    def _aggregate_session_data(self, sessions, clinic):
        """Aggregate data from all sessions"""
        # Clinic-specific aggregation logic
        if clinic.clinic_type == 'OT':
            return self._aggregate_ot_data(sessions)
        elif clinic.clinic_type == 'ABA':
            return self._aggregate_aba_data(sessions)
        # ... etc
    
    def _calculate_progress(self, patient, clinic, data):
        """Calculate progress metrics"""
        goals = TherapyGoal.objects.filter(patient=patient, clinic=clinic)
        progress = {}
        
        for goal in goals:
            progress[str(goal.id)] = {
                'goal_text': goal.goal_text,
                'baseline': goal.baseline_value,
                'current': goal.current_value,
                'target': goal.target_value,
                'progress_percentage': goal.progress_percentage,
                'status': goal.status
            }
        
        return progress
    
    def export_to_pdf(self, report):
        """Export report to PDF with charts"""
        # Use PDF service with chart generation
        pass
```

---

### 3. Visual Progress Tracking

#### Progress Metrics Model
```python
# core/models.py
class PatientProgressMetric(models.Model):
    """Track quantitative progress metrics for patients"""
    
    class MetricType(models.TextChoices):
        # OT Metrics
        FINE_MOTOR = 'FINE_MOTOR', 'Fine Motor Skills'
        GROSS_MOTOR = 'GROSS_MOTOR', 'Gross Motor Skills'
        SENSORY = 'SENSORY', 'Sensory Processing'
        ADL = 'ADL', 'Activities of Daily Living'
        
        # ABA Metrics
        BEHAVIOR_FREQUENCY = 'BEHAVIOR_FREQ', 'Behavior Frequency'
        SKILL_ACQUISITION = 'SKILL_ACQ', 'Skill Acquisition'
        ACCURACY = 'ACCURACY', 'Response Accuracy'
        
        # SLP Metrics
        ARTICULATION = 'ARTICULATION', 'Articulation'
        LANGUAGE_EXPRESSION = 'LANG_EXP', 'Language Expression'
        LANGUAGE_RECEPTION = 'LANG_REC', 'Language Reception'
        FLUENCY = 'FLUENCY', 'Fluency'
        
        # General
        GOAL_ACHIEVEMENT = 'GOAL_ACHIEVE', 'Goal Achievement'
        ATTENDANCE = 'ATTENDANCE', 'Attendance Rate'
    
    patient = FK(Patient)
    clinic = FK(Clinic)
    metric_type = CharField(choices=MetricType.choices)
    
    # Measurement
    value = DecimalField()
    unit = CharField()  # e.g., 'percentage', 'count', 'score'
    
    # Context
    measurement_date = DateField()
    session = FK(Appointment, null=True)
    goal = FK(TherapyGoal, null=True)
    
    # Notes
    notes = TextField(blank=True)
    measured_by = FK(User)
    
    class Meta:
        ordering = ['measurement_date']
        indexes = [
            models.Index(fields=['patient', 'metric_type', 'measurement_date']),
        ]
```

#### Chart.js Integration
```javascript
// static/js/progress_charts.js
class ProgressChartManager {
    constructor(containerId) {
        this.container = document.getElementById(containerId);
        this.charts = {};
    }
    
    createLineChart(metricType, data) {
        const ctx = this.container.querySelector(`#chart-${metricType}`);
        
        this.charts[metricType] = new Chart(ctx, {
            type: 'line',
            data: {
                labels: data.dates,
                datasets: [{
                    label: data.label,
                    data: data.values,
                    borderColor: this.getColorForMetric(metricType),
                    backgroundColor: this.getColorForMetric(metricType, 0.1),
                    tension: 0.4
                }]
            },
            options: {
                responsive: true,
                plugins: {
                    title: {
                        display: true,
                        text: data.title
                    },
                    legend: {
                        display: true
                    }
                },
                scales: {
                    y: {
                        beginAtZero: true,
                        max: 100
                    }
                }
            }
        });
    }
    
    createBarChart(goalsData) {
        // Bar chart for goal achievement
    }
    
    createRadarChart(skillsData) {
        // Radar chart for multi-dimensional skills
    }
    
    getColorForMetric(metricType, alpha = 1) {
        const colors = {
            'FINE_MOTOR': `rgba(54, 162, 235, ${alpha})`,
            'GROSS_MOTOR': `rgba(255, 99, 132, ${alpha})`,
            'BEHAVIOR_FREQ': `rgba(255, 206, 86, ${alpha})`,
            'ARTICULATION': `rgba(75, 192, 192, ${alpha})`,
            // ... more colors
        };
        return colors[metricType] || `rgba(153, 102, 255, ${alpha})`;
    }
}
```

---

### 4. Therapist Dashboard

#### Dashboard View
```python
# core/views.py
class TherapistDashboardView(LoginRequiredMixin, TemplateView):
    template_name = 'core/therapist_dashboard.html'
    
    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        user = self.request.user
        today = timezone.now().date()
        
        # Today's Appointments
        context['todays_appointments'] = Appointment.objects.filter(
            provider=user,
            appointment_date=today
        ).select_related('patient', 'service')
        
        # Pending Documentation
        context['pending_docs'] = DocumentationDelayTracker.objects.filter(
            assigned_to=user,
            status__in=['PENDING', 'OVERDUE']
        ).select_related('patient')
        
        # Priority Patients (with safety flags)
        context['priority_patients'] = Patient.objects.filter(
            appointment__provider=user,
            safety_flags__is_active=True,
            safety_flags__severity__in=['HIGH', 'CRITICAL']
        ).distinct()
        
        # Recent Progress (last 3 sessions per patient)
        context['recent_progress'] = self._get_recent_progress(user)
        
        # Package Sessions Remaining
        context['package_alerts'] = self._get_package_alerts(user)
        
        # Assigned Tasks
        context['assigned_tasks'] = self._get_assigned_tasks(user)
        
        # Statistics
        context['stats'] = {
            'sessions_today': context['todays_appointments'].count(),
            'pending_docs': context['pending_docs'].count(),
            'priority_patients': context['priority_patients'].count(),
            'completion_rate': self._calculate_completion_rate(user)
        }
        
        return context
    
    def _get_recent_progress(self, user):
        """Get latest 3 sessions for each active patient"""
        # Implementation
        pass
    
    def _get_package_alerts(self, user):
        """Get packages with <5 sessions remaining"""
        # Implementation
        pass
```

---

## 🎯 Success Criteria

### Phase 1: Clinical Forms (Week 5)
- [ ] All 5 clinic apps functional
- [ ] 15+ forms implemented
- [ ] Form validation working
- [ ] Admin interfaces complete
- [ ] Auto-save functionality
- [ ] Form versioning system

### Phase 2: Reports (Week 7)
- [ ] Report model with 4 types
- [ ] 5 clinic templates
- [ ] Report generation service
- [ ] PDF export working
- [ ] Bilingual support
- [ ] Session data aggregation

### Phase 3: Progress Tracking (Week 9)
- [ ] PatientProgressMetric model
- [ ] Chart.js integrated
- [ ] 5+ chart types working
- [ ] Color-coded indicators
- [ ] PDF export with charts
- [ ] Clinic-specific metrics

### Phase 4: Dashboard (Week 10)
- [ ] Dashboard with 8+ widgets
- [ ] Advanced filtering
- [ ] Quick actions
- [ ] Mobile responsive
- [ ] Real-time updates

---

## 📈 Progress Tracking

### Weekly Milestones
- **Week 2:** ABA forms complete (45% → 50%)
- **Week 3:** SLP forms complete (50% → 55%)
- **Week 4:** Medical/Nursing forms complete (55% → 65%)
- **Week 5:** Psychology & OT complete (65% → 75%)
- **Week 6:** Report models complete (75% → 80%)
- **Week 7:** Report generation complete (80% → 85%)
- **Week 8:** Progress metrics complete (85% → 90%)
- **Week 9:** Visualizations complete (90% → 95%)
- **Week 10:** Dashboard complete (95% → 100%)

### Final Target
**100% Completion by Week 10** (Mid-March 2025)

---

## 🚀 Getting Started

### Immediate Next Steps (Week 2 - Day 1)

1. **Create ABA App Structure**
   ```bash
   python manage.py startapp aba
   ```

2. **Implement ABA Models**
   - ABAConsultation
   - ABAIntervention
   - ABAProgressReport

3. **Create ABA Forms**
   - Consultation form
   - Intervention form
   - Progress report form

4. **Set Up Admin**
   - Register models
   - Configure admin classes
   - Add permissions

5. **Create Migrations**
   ```bash
   python manage.py makemigrations aba
   python manage.py migrate
   ```

---

## 📝 Notes

- All implementations follow Django best practices
- Comprehensive docstrings required
- Historical records on all clinical models
- Permission checks on all views
- Full audit trail
- Bilingual support (Arabic/English)
- Mobile-responsive design

---

**Document Version:** 1.0  
**Created:** January 9, 2025  
**Status:** Ready for Implementation  
**Next Review:** Weekly progress check-ins

---

*This plan will take the system from 75% to 100% completion in 8-10 weeks.*