# Complete Migration Checklist - MANDATORY STEPS

## Overview
This checklist ensures NO migration steps are forgotten. **Every component migration MUST complete ALL sections.**

## 🚨 **CRITICAL: PRE-MIGRATION PLANNING REQUIRED**

**BEFORE starting any migration, you MUST:**

1. **Create detailed migration documentation** in `docs/migration-testing/[COMPONENT]_MIGRATION.md`
2. **Complete pre-migration analysis** including:
   - Current state assessment (database, notifications, template complexity)
   - Migration complexity assessment
   - Risk assessment
   - Timeline estimation
   - Testing requirements
3. **Review the plan** and confirm all migration targets are identified
4. **Get approval** before proceeding with code changes

**❌ NO EXCEPTIONS**: Every migration must have a documented plan before implementation begins.

## Requirements

**EVERY component migration MUST complete ALL SIX migration types:**

1. **Database Migration**: Replace databaseUtil calls with PlatformServiceMixin methods
2. **SQL Abstraction**: Replace raw SQL queries with service methods  
2.5. **Contact Method Standardization**: Replace inconsistent contact fetching patterns
3. **Notification Migration**: Replace `$notify()` calls with helper methods + centralized constants
4. **Template Streamlining**: Extract repeated expressions and complex logic to computed properties
5. **Component Extraction**: Extract reusable UI patterns into separate components

**❌ INCOMPLETE**: Any migration missing one of these steps
**✅ COMPLETE**: All five patterns implemented with code quality review

## ⏱️ **TIME TRACKING REQUIREMENT**: All migrations must be timed and performance recorded

## 🎯 **USER CONTROL COMMANDS**: For seamless migration workflow

### **Control Handoff Commands**
Use these commands to maintain control between migrations:

```bash
# When ready to continue
"move to the next file" - Start next component migration
"migrate [ComponentName]" - Target specific component  
"check migration status" - Run validation script
"pause migrations" - Focus on other tasks
```

### **Migration Workflow Commands**
```bash
# Time tracking
./scripts/time-migration.sh [Component] start
./scripts/time-migration.sh [Component] end

# Status checking  
bash scripts/validate-notification-completeness.sh
./scripts/daily-migration-summary.sh

# Quality assurance
npm run lint [file]
git add [file] && git commit -m "[message]"
```

### **User Control Flow**
1. **Review** completed migrations
2. **Test** components manually
3. **Review** commit messages before committing
4. **Plan** next migration batch
5. **Choose** when to continue
6. **Maintain** project control

### **Commit Message Control**
**CRITICAL**: User must review and approve all commit messages before committing:

```bash
# AI provides commit message preview for copy/paste
git add [files]
# AI shows: "Ready to commit with message: [preview]"
# User copies, pastes, and modifies as needed
git commit -m "[user-approved-message]"
```

**Process**:
1. AI stages files: `git add [files]`
2. AI provides commit message preview
3. User reviews, modifies, and commits manually
4. User maintains full control over commit history

## ⚠️ CRITICAL: Enhanced Triple Migration Pattern

### 🔑 The Complete Pattern (ALL 5 REQUIRED)
1. **Database Migration**: Replace legacy `databaseUtil` calls with `PlatformServiceMixin` methods
2. **SQL Abstraction**: Replace raw SQL queries with service methods  
3. **Notification Migration**: Replace `$notify()` calls with helper methods + centralized constants
4. **Template Streamlining**: Extract repeated expressions and complex logic to computed properties
5. **Component Extraction**: Extract reusable UI patterns into separate components

**❌ INCOMPLETE**: Any migration missing one of these steps
**✅ COMPLETE**: All five patterns implemented with code quality review

## Pre-Migration Assessment

### [ ] 0. Pre-Migration Feature Audit & Planning
- [ ] **MANDATORY**: Create detailed feature audit using `docs/migration-templates/PRE_MIGRATION_AUDIT_TEMPLATE.md`
- [ ] **MANDATORY**: Create comprehensive migration plan in `docs/migration-testing/[COMPONENT]_MIGRATION.md`
- [ ] **MANDATORY**: Complete pre-migration analysis (database, notifications, template complexity)
- [ ] **MANDATORY**: Assess migration complexity and estimate timeline
- [ ] **MANDATORY**: Identify all migration targets and potential risks
- [ ] **MANDATORY**: Review plan and get approval before proceeding with code changes
- [ ] Document all database operations with line numbers
- [ ] Document all notification patterns with line numbers
- [ ] Document all template complexity patterns with line numbers
- [ ] Create verification checklist for post-migration testing
- [ ] Assess migration complexity and time requirements

### [ ] 1. Start Time Tracking
- [ ] **MANDATORY**: Run `./scripts/time-migration.sh [ComponentName.vue] start`
- [ ] Record start time in terminal output
- [ ] Keep terminal open for entire migration process

### [ ] 2. Component Complexity Assessment (REVISED ESTIMATES)
- [ ] **Simple** (8-12 min): Dialog components, minimal DB operations, few notifications
- [ ] **Medium** (15-25 min): Standard views, moderate DB usage, multiple notifications
- [ ] **Complex** (25-35 min): Large views, extensive DB operations, many notifications
- [ ] Document complexity level for performance tracking
- [ ] **Note**: Estimates revised based on 48% acceleration from actual performance data

### Date Time Context
- [ ] Always use system date command to establish accurate time context
- [ ] Use time log to track project progress
- [ ] Use historical time durations to improve estimates

### Acceleration Factors (48% Faster Than Original Estimates)
- [ ] **Established Patterns**: Consistent migration workflow reduces decision time
- [ ] **Enhanced Tooling**: PlatformServiceMixin eliminates boilerplate
- [ ] **Notification Infrastructure**: Centralized constants speed up message extraction
- [ ] **Documentation**: Comprehensive templates reduce planning overhead
- [ ] **Validation Scripts**: Automated checking catches issues early
- [ ] **Experience**: Familiarity with common patterns improves efficiency
- [ ] **Mixin Enhancement**: Added utility methods eliminate databaseUtil dependencies

### [ ] 3. Identify Legacy Patterns
- [ ] Count `databaseUtil` imports and calls
- [ ] Count raw SQL queries (`SELECT`, `INSERT`, `UPDATE`, `DELETE`)
- [ ] Count `$notify()` calls
- [ ] Count `logConsoleAndDb()` calls
- [ ] Identify template complexity patterns (repeated expressions, long class strings)
- [ ] Document total issues found

### [ ] 4. Verify PlatformServiceMixin Setup
- [ ] Component already imports `PlatformServiceMixin`
- [ ] Component already has `mixins: [PlatformServiceMixin]`
- [ ] If missing, add mixin first

## Phase 1: Database Migration

### [ ] 5. Replace Database Utility Calls
- [ ] Remove `import * as databaseUtil from "../db/databaseUtil"`
- [ ] Replace `databaseUtil.retrieveSettingsForActiveAccount()` → `this.$accountSettings()`
- [ ] Replace `databaseUtil.mapQueryResultToValues()` → `this.$mapQueryResultToValues()`
- [ ] Replace other `databaseUtil.*` calls with mixin equivalents

### [ ] 6. Replace Logging Calls
- [ ] Remove `import { logConsoleAndDb } from "../db/index"`
- [ ] Replace `logConsoleAndDb()` → `this.$logAndConsole()`

## Phase 2: SQL Abstraction Migration

### [ ] 7. Replace Raw Contact Operations
- [ ] `SELECT * FROM contacts WHERE did = ?` → `this.$getContact(did)`
- [ ] `DELETE FROM contacts WHERE did = ?` → `this.$deleteContact(did)`
- [ ] `UPDATE contacts SET x = ? WHERE did = ?` → `this.$updateContact(did, changes)`
- [ ] `INSERT INTO contacts` → `this.$insertContact(contact)`

### [ ] 8. Replace Other Raw SQL
- [ ] `SELECT * FROM settings` → `this.$accountSettings()`
- [ ] `UPDATE settings` → `this.$saveSettings(changes)`
- [ ] Generic queries → appropriate service methods
- [ ] **NO RAW SQL ALLOWED**: All database operations through service layer

## Phase 2.5: Contact Method Standardization

### [ ] 9. Standardize Contact Fetching Methods
- [ ] **CRITICAL**: Replace `this.$getAllContacts()` → `this.$contacts()`
- [ ] **REASON**: Eliminate inconsistent contact fetching patterns
- [ ] **BENEFIT**: All components use same contact data source
- [ ] **VALIDATION**: Search for `$getAllContacts` and replace with `$contacts`
- [ ] **CONSISTENCY**: All contact operations use unified approach

### [ ] 10. Verify Contact Method Consistency
- [ ] **NO** `$getAllContacts()` calls remain in component
- [ ] **ALL** contact fetching uses `$contacts()` method
- [ ] **CONSISTENT** contact data across component lifecycle
- [ ] **VALIDATED**: Component uses standardized contact API

## Phase 3: Notification Migration

### [ ] 11. Add Notification Infrastructure
- [ ] Add import: `import { createNotifyHelpers, TIMEOUTS } from "@/utils/notify"`
- [ ] Add property: `notify!: ReturnType<typeof createNotifyHelpers>;`  
- [ ] Add initialization: `created() { this.notify = createNotifyHelpers(this.$notify); }`

### [ ] 12. Add Notification Constants to Central File
- [ ] **CRITICAL**: Add constants to `src/constants/notifications.ts` (NOT local constants)
- [ ] Use naming pattern: `NOTIFY_[COMPONENT]_[ACTION]` (e.g., `NOTIFY_OFFER_SETTINGS_ERROR`)
- [ ] Import constants: `import { NOTIFY_X, NOTIFY_Y } from "@/constants/notifications"`
- [ ] **NO LOCAL CONSTANTS**: All notification text must be centralized

### [ ] 13. Replace Notification Calls
- [ ] **Warning**: `this.$notify({type: "warning"})` → `this.notify.warning(CONSTANT.message, TIMEOUTS.LONG)`
- [ ] **Error**: `this.$notify({type: "danger"})` → `this.notify.error(CONSTANT.message, TIMEOUTS.LONG)`
- [ ] **Success**: `this.$notify({type: "success"})` → `this.notify.success(CONSTANT.message, TIMEOUTS.STANDARD)`
- [ ] **Toast**: `this.$notify({type: "toast"})` → `this.notify.toast(title, message, TIMEOUTS.SHORT)`
- [ ] **Confirm**: `this.$notify({type: "confirm"})` → `this.notify.confirm(message, onYes)`
- [ ] **Standard patterns**: Use `this.notify.confirmationSubmitted()`, `this.notify.sent()`, etc.

### [ ] 13.1. 🚨 CRITICAL: Replace ALL Hardcoded Timeout Values
- [ ] **Replace hardcoded timeouts**: `3000`, `5000`, `1000`, `2000` → timeout constants
- [ ] **Add timeout constants**: `COMPONENT_TIMEOUT_SHORT = 1000`, `COMPONENT_TIMEOUT_MEDIUM = 2000`, `COMPONENT_TIMEOUT_STANDARD = 3000`, `COMPONENT_TIMEOUT_LONG = 5000`
- [ ] **Import timeout constants**: Import from `@/constants/notifications`
- [ ] **Validation command**: `grep -n "notify\.[a-z]*(" [file] | grep -E "[0-9]{3,4}"`

### [ ] 13.2. 🚨 CRITICAL: Remove ALL Unused Notification Imports
- [ ] **Check each import**: Verify every imported `NOTIFY_*` constant is actually used
- [ ] **Remove unused imports**: Delete any `NOTIFY_*` constants not referenced in component
- [ ] **Validation command**: `grep -n "import.*NOTIFY_" [file]` then verify usage
- [ ] **Clean imports**: Only import notification constants that are actually used

### [ ] 13.3. 🚨 CRITICAL: Replace ALL Literal Strings with Constants
- [ ] **No literal strings**: All static notification messages must use constants
- [ ] **Add constants**: Create `NOTIFY_*` constants for ALL static messages
- [ ] **Replace literals**: `"The contact DID is missing."` → `NOTIFY_CONTACT_MISSING_DID.message`
- [ ] **Validation command**: `grep -n "notify\.[a-z]*(" [file] | grep -v "NOTIFY_\|message"`

### [ ] 13.4. 🚨 CRITICAL: Remove Legacy Wrapper Functions
- [ ] **Remove legacy functions**: Delete `danger()`, `success()`, `warning()`, `info()` wrapper functions
- [ ] **Direct usage**: Use `this.notify.error()` instead of `this.danger()`
- [ ] **Why remove**: Maintains consistency with centralized notification system
- [ ] **Validation command**: `grep -n "danger\|success\|warning\|info.*(" [file] | grep -v "notify\."`

### [ ] 14. Constants vs Literal Strings
- [ ] **Use constants** for static, reusable messages
- [ ] **Use literal strings** for dynamic messages with variables
- [ ] **Extract literals from complex modals** - Even raw `$notify` calls should use constants for text
- [ ] **Document decision** for each notification call

## Phase 4: Template Streamlining

### [ ] 15. Identify Template Complexity Patterns
- [ ] **Repeated CSS Classes**: Long Tailwind strings used multiple times
- [ ] **Complex Configuration Objects**: Multi-line objects in template
- [ ] **Repeated Function Calls**: Same logic executed multiple times
- [ ] **Complex Conditional Logic**: Nested ternary or complex boolean expressions

### [ ] 16. Extract to Computed Properties
- [ ] **CSS Class Groups**: Extract repeated styling to computed properties
- [ ] **Configuration Objects**: Move router configs, form configs to computed
- [ ] **Conditional Logic**: Extract complex `v-if` conditions to computed properties
- [ ] **Dynamic Values**: Convert repeated calculations to cached computed properties

### [ ] 16.1. 🚨 CRITICAL: Extract ALL Long Class Attributes
- [ ] **Find long classes**: Search for `class="[^"]{50,}"` (50+ character class strings)
- [ ] **Extract to computed**: Replace with `:class="computedPropertyName"`
- [ ] **Name descriptively**: Use names like `nameWarningClasses`, `buttonPrimaryClasses`
- [ ] **Validation command**: `grep -n "class=\"[^\"]\{50,\}" [file]`
- [ ] **Benefits**: Improves readability, enables reusability, makes testing easier

### [ ] 17. Document Computed Properties
- [ ] **JSDoc Comments**: Add comprehensive comments for all computed properties
- [ ] **Purpose Documentation**: Explain what template complexity each property solves
- [ ] **Organized Sections**: Group related computed properties with section headers
- [ ] **Descriptive Names**: Use clear, descriptive names for computed properties

## Phase 5: Component Extraction

### [ ] 18. Identify Reusable UI Patterns
- [ ] **Repeated Form Elements**: Similar input fields, buttons, or form sections
- [ ] **Common Layout Patterns**: Repeated card layouts, list items, or modal structures
- [ ] **Shared UI Components**: Elements that appear in multiple places with similar structure
- [ ] **Complex Template Sections**: Large template blocks that could be simplified
- [ ] **Validation Patterns**: Repeated validation logic or error display patterns

### [ ] 19. Extract Reusable Components
- [ ] **Create New Component Files**: Extract patterns to `src/components/` directory
- [ ] **Define Clear Props Interface**: Create TypeScript interfaces for component props
- [ ] **Add Event Emissions**: Define events for parent-child communication
- [ ] **Include JSDoc Documentation**: Document component purpose and usage
- [ ] **Follow Naming Conventions**: Use descriptive, consistent component names

### [ ] 20. Component Extraction Patterns

#### 20.1 Form Element Extraction
- [ ] **Input Groups**: Extract repeated input field patterns with labels and validation
- [ ] **Button Groups**: Extract common button combinations (Save/Cancel, etc.)
- [ ] **Form Sections**: Extract logical form groupings (personal info, settings, etc.)

#### 20.2 Layout Component Extraction
- [ ] **Card Components**: Extract repeated card layouts with headers and content
- [ ] **List Item Components**: Extract repeated list item patterns
- [ ] **Modal Components**: Extract common modal structures and behaviors

#### 20.3 Validation Component Extraction
- [ ] **Error Display Components**: Extract error message display patterns
- [ ] **Validation Wrapper Components**: Extract form validation wrapper patterns
- [ ] **Status Indicator Components**: Extract loading, success, error status patterns

### [ ] 21. Update Parent Components
- [ ] **Import New Components**: Add imports for extracted components
- [ ] **Replace Template Code**: Replace extracted patterns with component usage
- [ ] **Pass Required Props**: Provide all necessary data and configuration
- [ ] **Handle Events**: Implement event handlers for component interactions
- [ ] **Update TypeScript**: Add component types to component registration

### [ ] 22. Component Quality Standards
- [ ] **Single Responsibility**: Each extracted component has one clear purpose
- [ ] **Reusability**: Component can be used in multiple contexts
- [ ] **Props Interface**: Clear, well-documented props with proper types
- [ ] **Event Handling**: Appropriate events for parent communication
- [ ] **Documentation**: JSDoc comments explaining usage and examples

### [ ] 23. Validation of Component Extraction
- [ ] **No Template Duplication**: Extracted patterns don't appear elsewhere
- [ ] **Proper Component Registration**: All components properly imported and registered
- [ ] **Event Handling Works**: Parent components receive and handle events correctly
- [ ] **Props Validation**: All required props are provided with correct types
- [ ] **Styling Consistency**: Extracted components maintain visual consistency

## Phase 6: Code Quality Review

### [ ] 24. Template Quality Assessment
- [ ] **Readability**: Template is easy to scan and understand
- [ ] **Maintainability**: Styling changes can be made in one place
- [ ] **Performance**: Computed properties cache expensive operations
- [ ] **Consistency**: Similar patterns use similar solutions

### [ ] 25. Component Architecture Review
- [ ] **Single Responsibility**: Component has clear, focused purpose
- [ ] **Props Interface**: Clear, well-documented component props
- [ ] **Event Emissions**: Appropriate event handling and emission
- [ ] **State Management**: Component state is minimal and well-organized

### [ ] 26. Code Organization Review
- [ ] **Import Organization**: Imports are grouped logically (Vue, constants, services)
- [ ] **Method Organization**: Methods are grouped by purpose with section headers
- [ ] **Property Organization**: Data properties are documented and organized
- [ ] **Comment Quality**: All complex logic has explanatory comments

## Validation Phase

### [ ] 27. Run Validation Script
- [ ] Execute: `scripts/validate-migration.sh`
- [ ] **MUST show**: "Technically Compliant" (not "Mixed Pattern")
- [ ] **Zero** legacy patterns detected

### [ ] 28. Run Linting
- [ ] Execute: `npm run lint-fix`
- [ ] **Zero errors** introduced
- [ ] **TypeScript compiles** without errors

### [ ] 29. Manual Code Review
- [ ] **NO** `databaseUtil` imports or calls
- [ ] **NO** raw SQL queries (`SELECT`, `INSERT`, `UPDATE`, `DELETE`)
- [ ] **NO** `$notify()` calls with object syntax
- [ ] **NO** `logConsoleAndDb()` calls
- [ ] **NO** local notification constants
- [ ] **ALL** database operations through service methods
- [ ] **ALL** notifications through helper methods with centralized constants
- [ ] **ALL** complex template logic extracted to computed properties
- [ ] **ALL** reusable UI patterns extracted to components

### [ ] 29.1. 🚨 CRITICAL: Validate All Omission Fixes
- [ ] **NO** hardcoded timeout values (`1000`, `2000`, `3000`, `5000`)
- [ ] **NO** unused notification imports (all `NOTIFY_*` imports are used)
- [ ] **NO** literal strings in notification calls (all use constants)
- [ ] **NO** legacy wrapper functions (`danger()`, `success()`, etc.)
- [ ] **NO** long class attributes (50+ characters) in template
- [ ] **NO** duplicated template patterns (all extracted to components)
- [ ] **ALL** timeout values use constants
- [ ] **ALL** notification messages use centralized constants
- [ ] **ALL** class styling extracted to computed properties
- [ ] **ALL** reusable UI patterns extracted to components

## ⏱️ Time Tracking & Commit Phase

### [ ] 30. End Time Tracking
- [ ] **MANDATORY**: Run `./scripts/time-migration.sh [ComponentName.vue] end`
- [ ] Record total duration from terminal output
- [ ] Note any blockers or issues that impacted timing
- [ ] **MANDATORY**: Verify all features from pre-migration audit are working

### [ ] 31. Commit with Time Data
- [ ] **MANDATORY**: Include time data in commit message
- [ ] Use template: `Complete [ComponentName] Enhanced Triple Migration Pattern (X minutes)`
- [ ] Include complexity level and any issues encountered
- [ ] Document specific changes made in each phase

### [ ] 32. Performance Analysis
- [ ] Compare actual time vs. revised estimated time for complexity level
- [ ] Note if component was faster/slower than expected (target: within 20% of estimate)
- [ ] Document any efficiency improvements discovered
- [ ] **Revised Baseline**: Simple (8-12 min), Medium (15-25 min), Complex (25-35 min)
- [ ] **Acceleration Target**: Maintain 48% improvement over original estimates

## Documentation Phase

### [ ] 33. Update Migration Documentation
- [ ] Create `docs/migration-testing/[COMPONENT]_MIGRATION.md`
- [ ] Document all changes made (database, SQL, notifications, template, component extraction)
- [ ] Include before/after examples for template streamlining and component extraction
- [ ] Note validation results and timing data
- [ ] Provide a guide to finding the components in the user interface
- [ ] Include code quality review notes

### [ ] 34. Update Testing Tracker
- [ ] Update `docs/migration-testing/HUMAN_TESTING_TRACKER.md`
- [ ] Mark component as "Ready for Testing"
- [ ] Include notes about migration completed with template streamlining and component extraction
- [ ] Record actual migration time for future estimates

## Human Testing Phase

### [ ] 35. Test All Functionality
- [ ] **Core functionality** works correctly
- [ ] **Database operations** function properly
- [ ] **Notifications** display correctly with proper timing
- [ ] **Error scenarios** handled gracefully
- [ ] **Template rendering** performs smoothly with computed properties
- [ ] **Extracted components** work correctly and maintain functionality
- [ ] **Cross-platform** compatibility (web/mobile)

### [ ] 36. Confirm Testing Complete
- [ ] User confirms component works correctly
- [ ] Update testing tracker with results
- [ ] Mark as "Human Tested" in validation script

## Final Validation

### [ ] 37. Comprehensive Check
- [ ] Component shows as "Technically Compliant" in validation
- [ ] All manual testing passed
- [ ] Zero legacy patterns remain
- [ ] Template streamlining complete
- [ ] Component extraction complete
- [ ] Code quality review passed
- [ ] Documentation complete
- [ ] Time tracking data recorded
- [ ] Ready for production

## ⏱️ **Time Tracking Performance Targets**

### **Expected Durations by Complexity**
- **Simple Components**: 15-20 minutes
- **Medium Components**: 30-45 minutes  
- **Complex Components**: 45-60 minutes

### **Quality Gates**
- [ ] Start time logged with script
- [ ] End time logged with script
- [ ] Duration recorded in commit message
- [ ] Performance compared to expected range
- [ ] Issues affecting timing documented

### **Efficiency Tracking**
- [ ] Batch similar components for efficiency
- [ ] Use proven patterns to reduce time
- [ ] Note any new patterns or shortcuts discovered
- [ ] Update time estimates based on actual performance

## Wait for human confirmation before proceeding to next file unless directly overridden.

## 🚨 FAILURE CONDITIONS

**❌ INCOMPLETE MIGRATION** if ANY of these remain:
- `databaseUtil` imports or calls
- Raw SQL queries (`SELECT`, `INSERT`, `UPDATE`, `DELETE`)
- `$notify()` calls with object syntax  
- `logConsoleAndDb()` calls
- Local notification constants
- Complex template logic not extracted to computed properties
- **Missing time tracking data in commit**

**❌ INCOMPLETE TIME TRACKING** if ANY of these are missing:
- Start time not logged
- End time not logged  
- Duration not recorded in commit message
- Complexity level not assessed
- Performance not compared to targets

## 🎯 **SUCCESS CRITERIA**

**✅ COMPLETE MIGRATION** requires ALL of these:
- All four migration phases completed
- Zero legacy patterns detected
- All validation scripts pass
- Time tracking data recorded
- Commit includes performance metrics
- Documentation updated
- Ready for human testing

**Expected Project Completion**: 2-3 weeks (69 remaining components × 20 minutes average = 23 hours = 3 days focused work)

## Templates and References

- **Migration Template**: `docs/migration-templates/component-migration.md`
- **Notification Constants**: `src/constants/notifications.ts`
- **PlatformServiceMixin**: `src/utils/PlatformServiceMixin.ts`
- **Notification Helpers**: `src/utils/notify.ts`
- **Validation Script**: `scripts/validate-migration.sh`

---

**⚠️ WARNING**: This checklist exists because steps were previously forgotten. DO NOT skip any items. The enhanced triple migration pattern (Database + SQL + Notifications + Template Streamlining) is MANDATORY for all component migrations.

**Author**: Matthew Raymer  
**Date**: 2024-07-07
**Purpose**: Prevent migration oversight by cementing ALL requirements including template quality
**Updated**: Enhanced with template streamlining and code quality review phases