aiox-core 5.0.2 → 5.0.3

package/pro/squads/design/tasks/ds-calculate-roi.md

@@ -0,0 +1,282 @@
+# Calculate ROI and Cost Savings
+
+> Task ID: brad-calculate-roi
+> Agent: Brad (Design System Architect)
+> Version: 1.1.0
+> v4.0-compatible: true
+> **Execution Type:** `Agent`
+> **Dependencies:** depends_on: `[ds-generate-migration-strategy]` · enables: `[ds-generate-shock-report]` · workflow: `brownfield-audit`
+
+## Description
+
+Calculate real cost savings from pattern consolidation with hard numbers. Estimates monthly/annual maintenance costs before and after, projects ROI timeline, shows when investment breaks even.
+
+## Input Schema
+- **requires:** Output from `ds-generate-migration-strategy`
+- **format:** Markdown report
+- **location:** `outputs/design-system/{project}/migration/migration-strategy.md`
+
+## Output Schema
+- **produces:** `outputs/design-system/{project}/roi/roi-analysis.md`
+- **format:** Markdown report
+- **consumed_by:** ds-generate-shock-report
+
+## Prerequisites
+
+- Consolidation completed (*consolidate command run successfully)
+- .state.yaml contains pattern reduction metrics
+- Optional: Team salary data for accurate calculations
+
+## Workflow
+
+### Interactive Elicitation
+
+This task uses interactive elicitation to gather cost parameters.
+
+1. **Gather Team Context**
+   - Team size (number of developers)
+   - Average developer hourly rate (default: $150/hr)
+   - Monthly hours spent on UI maintenance (estimate if unknown)
+   - Implementation cost estimate
+
+2. **Review Pattern Metrics**
+   - Show consolidation metrics (patterns before/after)
+   - Confirm reduction percentages
+   - Identify highest-impact reductions
+
+3. **Configure Calculation**
+   - Ask for conservative vs aggressive estimates
+   - Include or exclude training costs
+   - Set ROI calculation period (1 year default)
+
+### Steps
+
+1. **Load Consolidation Metrics**
+   - Read .state.yaml for pattern reduction data
+   - Extract before/after counts for all pattern types
+   - Calculate reduction percentages
+   - Check: .state.yaml contains consolidation section with before/after pattern counts — abort with "No consolidation data: run *consolidate first"
+
+2. **Calculate Maintenance Cost (Before)**
+   - Formula: patterns × hours_per_pattern_monthly × hourly_rate × 12
+   - Default: 2 hours/month per pattern for maintenance
+   - Include debugging, updates, consistency fixes
+   - Check: monthly cost > 0 AND cost = patterns * hours_per_pattern * hourly_rate — log "Before: {patterns} patterns, ${cost}/month"
+
+3. **Calculate Maintenance Cost (After)**
+   - Same formula with consolidated pattern count
+   - Factor in design system overhead (small)
+   - Check: after_cost < before_cost — log "After: {patterns} patterns, ${cost}/month"
+
+4. **Calculate Monthly and Annual Savings**
+   - Monthly savings = cost_before - cost_after
+   - Annual savings = monthly_savings × 12
+   - Check: monthly_savings > 0 OR report contains justification for negative/zero savings — log "Savings: ${monthly}/month, ${annual}/year"
+
+5. **Estimate Implementation Cost**
+   - Developer time to create design system
+   - Migration effort (from migration strategy)
+   - Training time
+   - Default: $10,000-15,000 for medium teams
+   - Check: implementation cost > 0 AND includes developer time + migration + training — log "Implementation cost: ${cost} ({weeks} developer-weeks)"
+
+6. **Calculate ROI Metrics**
+   - ROI ratio = annual_savings / implementation_cost
+   - Breakeven point = implementation_cost / monthly_savings (in months)
+   - 3-year projection = (annual_savings × 3) - implementation_cost
+   - Check: ROI ratio calculated AND breakeven months > 0 AND 3-year projection generated — log "ROI: {ratio}x, breakeven: {months} months"
+
+7. **Calculate Velocity Impact**
+   - Estimate time saved per feature (fewer component decisions)
+   - Project velocity multiplier (3-6x typical)
+   - Convert to dollar value (time = money)
+   - Check: velocity multiplier calculated AND time savings expressed in hours/month — log "Velocity: {multiplier}x, {hours} hours/month saved"
+
+8. **Generate ROI Report**
+   - Create roi-analysis.md with executive summary
+   - Include detailed calculations with formulas
+   - Generate charts (text-based or recommend tools)
+   - Show sensitivity analysis (best/worst case)
+   - Check: `test -f roi-analysis.md` AND file contains executive summary + formulas + sensitivity analysis — abort with "ROI report generation failed"
+
+9. **Create Stakeholder Summary**
+   - One-page executive summary
+   - Key numbers only (investment, savings, breakeven)
+   - Visual comparison (before/after costs)
+   - Check: `test -f executive-summary.md` AND contains investment + savings + breakeven figures — abort with "Executive summary generation failed"
+
+10. **Update State File**
+    - Add ROI section to .state.yaml
+    - Record all cost calculations
+    - Update phase to "roi_calculated"
+    - Check: .state.yaml contains `phase: "roi_calculated"` AND roi section with all cost fields — abort with "State update failed: {missing field}"
+
+## Output
+
+- **roi-analysis.md**: Detailed ROI analysis with calculations
+- **executive-summary.md**: One-page stakeholder summary
+- **cost-breakdown.yaml**: Structured cost data
+- **.state.yaml**: Updated with ROI metrics
+
+### Output Format
+
+```yaml
+# roi section in .state.yaml
+roi:
+  calculated_at: "2025-10-27T14:00:00Z"
+
+  before:
+    patterns: 176
+    monthly_cost: $38,100
+    annual_cost: $457,200
+    hours_per_month: 352
+
+  after:
+    patterns: 32
+    monthly_cost: $6,900
+    annual_cost: $82,800
+    hours_per_month: 64
+
+  savings:
+    monthly: $31,200
+    annual: $374,400
+    hours_saved_monthly: 288
+
+  implementation:
+    estimated_cost: $12,000
+    developer_weeks: 4
+
+  roi_metrics:
+    ratio: 31.2
+    breakeven_months: 0.38
+    year_1_net: $362,400
+    year_3_cumulative: $1,111,200
+
+  velocity_impact:
+    multiplier: "4-6x"
+    time_savings: "70% reduction in UI decisions"
+```
+
+## Failure Handling
+
+- **No consolidation data available:** If .state.yaml missing consolidation section or before/after pattern counts, abort with "No consolidation data: run *consolidate first to generate pattern reduction metrics."
+- **Negative or zero monthly savings:** If calculated monthly savings <=0, abort with "ROI calculation shows negative savings: ${value}/month. Review pattern consolidation strategy or maintenance cost assumptions."
+- **Unrealistic cost inputs:** If hourly rate >$500/hr or <$50/hr, warn user "Hourly rate ${rate}/hr seems {high|low}. Industry average: $100-200/hr. Confirm before proceeding to avoid stakeholder skepticism."
+- **Implementation cost exceeds annual savings:** If implementation_cost > annual_savings AND ROI ratio <1.0, warn user "ROI ratio {ratio}x is negative. Consider phased rollout or reassess consolidation scope to improve business case."
+
+## Success Criteria
+
+- [ ] Realistic cost estimates based on team context
+- [ ] Both pre and post-consolidation costs calculated
+- [ ] ROI ratio shows positive return (>2x minimum)
+- [ ] Breakeven point calculated (typically <1 year)
+- [ ] Velocity impact quantified
+- [ ] Executive summary is stakeholder-ready
+- [ ] All calculations show formulas used
+
+## Error Handling
+
+- **No consolidation data**: Exit with message to run *consolidate first
+- **Unrealistic costs**: Warn user, suggest reviewing inputs
+- **Negative ROI**: Explain why, suggest higher-impact consolidation
+- **Missing team data**: Use industry defaults, flag estimates as rough
+
+## Security Considerations
+
+- Salary data is sensitive - only used for calculations, not logged
+- Cost reports stored securely
+- No external data transmission
+- User can review before sharing with stakeholders
+
+## Examples
+
+### Example 1: ROI Calculation
+
+```bash
+*calculate-roi
+```
+
+Output:
+```
+💰 Brad: Calculating ROI from pattern consolidation...
+
+Team Context:
+  - Developers: 8
+  - Hourly rate: $150/hr
+  - Patterns maintained: 176 → 32
+
+📊 COST ANALYSIS:
+
+BEFORE consolidation:
+  176 patterns × 2 hrs/month × $150/hr = $52,800/month
+  Annual cost: $633,600
+
+AFTER consolidation:
+  32 patterns × 2 hrs/month × $150/hr = $9,600/month
+  Annual cost: $115,200
+
+💵 SAVINGS:
+  Monthly: $43,200
+  Annual: $518,400
+  3-year total: $1,555,200
+
+🎯 ROI METRICS:
+  Implementation cost: $15,000
+  ROI ratio: 34.6x
+  Breakeven: 0.35 months (10 days!)
+  Year 1 net profit: $503,400
+
+⚡ VELOCITY IMPACT:
+  Estimated 5x faster feature development
+  288 hours/month saved = 1.8 FTE equivalent
+
+✅ Report saved: outputs/design-system/my-app/roi/roi-analysis.md
+✅ Executive summary: outputs/design-system/my-app/roi/executive-summary.md
+
+Brad says: Numbers don't lie. Show this to your boss.
+```
+
+### Example 2: Executive Summary
+
+```markdown
+# Design System ROI - Executive Summary
+
+## Investment
+**$15,000** (4 developer-weeks)
+
+## Return
+**$518,400/year** savings
+
+## ROI
+**34.6x return** on investment
+
+## Breakeven
+**10 days**
+
+## Impact
+- 81.8% pattern reduction (176 → 32)
+- 5x velocity improvement
+- 1.8 FTE equivalent time savings
+
+**Recommendation**: Immediate approval. Payback in under 2 weeks.
+```
+
+## Notes
+
+- Default 2 hours/month per pattern for maintenance (conservative)
+- Includes: debugging, updates, consistency fixes, code reviews
+- Velocity multiplier (3-6x) based on industry research
+- Implementation cost varies by team size and existing tech debt
+- ROI improves over time as system matures
+- Brad's estimates are conservative (actual savings often higher)
+- Use this report to justify design system to stakeholders
+- Recalculate ROI after Phase 2 migration to validate projections
+
+
+## Related Checklists
+
+- `squads/design/checklists/ds-component-quality-checklist.md`
+- `squads/design/checklists/ds-pattern-audit-checklist.md`
+
+## Process Guards
+- **On Fail:** Stop execution, capture evidence, and return remediation steps before proceeding.

package/pro/squads/design/tasks/ds-compose-molecule.md

@@ -0,0 +1,106 @@
+# Compose Molecule from Atoms
+
+> Task ID: atlas-compose-molecule
+> Agent: Merovingian (Design System Builder)
+> Version: 1.1.0
+> v4.0-compatible: true
+> **Execution Type:** `Agent`
+> **Dependencies:** depends_on: `[ds-build-component]` · enables: `[]` · workflow: `greenfield`
+
+## Description
+
+Build molecule component by composing existing atoms following Atomic Design methodology. Examples: FormField (Label + Input), Card (Heading + Text + Button), SearchBar (Input + Button).
+
+## Input Schema
+- **requires:** Output from `ds-build-component`
+- **format:** TypeScript source (atom components)
+- **location:** `outputs/design-system/{project}/components/{Atom}/`
+
+## Prerequisites
+
+- Setup completed
+- Atom components exist (dependencies)
+- Tokens loaded
+
+## Workflow
+
+### Steps
+
+1. **Validate Atom Dependencies** - Check required atoms exist
+2. **Generate Molecule Component** - Compose atoms with molecule logic
+3. **Generate Molecule Styles** - Molecule-specific layout and spacing
+4. **Generate Tests** - Test molecule composition and interactions
+5. **Generate Stories** - Show molecule with different atom combinations
+6. **Generate Documentation** - Document composed structure
+7. **Update Index** - Export molecule
+8. **Update State** - Track molecule built
+
+## Output
+
+- Molecule component (TypeScript)
+- Molecule styles (CSS Modules)
+- Tests (>80% coverage)
+- Stories (optional)
+- Documentation
+
+## Failure Handling
+
+- **Missing atom dependency:** If required atom component file does not exist in design-system directory, abort with "Atom {AtomName} not found. Run *build {AtomName} first to generate required dependency."
+- **Atom API incompatibility:** If atom props interface does not accept required props for molecule composition, abort with "{AtomName} API incompatible: missing props {list}. Extend atom or use different atom."
+- **Molecule reimplements atom logic:** If molecule code duplicates atom styling or behavior (e.g., duplicate button styles), warn user "Molecule should compose atoms, not reimplement. Remove duplicate logic and use {AtomName} props instead."
+- **Atom interaction tests missing:** If test suite does not include tests for interactions between composed atoms (e.g., Label clicking focuses Input), abort with "Tests incomplete: add tests for atom interactions ({missing scenarios})."
+
+## Success Criteria
+
+- [ ] All atom dependencies imported correctly
+- [ ] Molecule composes atoms (not reimplements)
+- [ ] Molecule-specific logic isolated
+- [ ] Tests cover atom interactions
+- [ ] Accessible (WCAG AA)
+
+## Example
+
+```typescript
+// FormField.tsx (molecule)
+import { Label } from '../atoms/Label';
+import { Input, InputProps } from '../atoms/Input';
+import { HelperText } from '../atoms/HelperText';
+
+export interface FormFieldProps extends InputProps {
+  label: string;
+  helperText?: string;
+  error?: string;
+}
+
+export const FormField: React.FC<FormFieldProps> = ({
+  label,
+  helperText,
+  error,
+  ...inputProps
+}) => {
+  return (
+    <div className={styles.formField}>
+      <Label htmlFor={inputProps.id}>{label}</Label>
+      <Input {...inputProps} error={!!error} />
+      {error && <HelperText variant="error">{error}</HelperText>}
+      {!error && helperText && <HelperText>{helperText}</HelperText>}
+    </div>
+  );
+};
+```
+
+## Notes
+
+- Molecules compose atoms, don't reimplement
+- Molecule adds composition logic only
+- Atoms remain independent and reusable
+- Test atom interactions in molecule context
+
+
+## Related Checklists
+
+- `squads/design/checklists/ds-component-quality-checklist.md`
+- `squads/design/checklists/ds-pattern-audit-checklist.md`
+
+## Process Guards
+- **On Fail:** Stop execution, capture evidence, and return remediation steps before proceeding.

package/pro/squads/design/tasks/ds-consolidate-patterns.md

@@ -0,0 +1,253 @@
+# Consolidate Patterns Using Intelligent Clustering
+
+> Task ID: brad-consolidate-patterns
+> Agent: Brad (Design System Architect)
+> Version: 1.1.0
+> v4.0-compatible: true
+> **Execution Type:** `Agent`
+> **Dependencies:** depends_on: `[ds-audit-codebase]` · enables: `[ds-extract-tokens]` · workflow: `brownfield-audit`
+> **On Fail:** If reduction <50% → review clustering thresholds (default 5% HSL may be too strict). If pattern-inventory.json missing/corrupt → re-run `*audit`. If consolidation produces 0 clusters → input data likely empty, return to audit phase. Do NOT proceed to tokenize with unconsolidated patterns.
+
+## Description
+
+Reduce UI pattern redundancy by clustering similar patterns using intelligent algorithms (HSL color clustering at 5% threshold, semantic button grouping). Target: >80% reduction. **v4.0: Reference data/ds-reference-architectures.md for cross-system consolidation patterns (Material 3, Fluent 2, Carbon, Spectrum).**
+
+## Input Schema
+- **requires:** Output from `ds-audit-codebase`
+- **format:** JSON data
+- **location:** `outputs/design-system/{project}/audit/pattern-inventory.json`
+
+## Output Schema
+- **produces:** `outputs/design-system/{project}/consolidation/`
+- **format:** Text data (color-clusters.txt, spacing-consolidation.txt, button-consolidation.txt)
+- **consumed_by:** ds-extract-tokens
+
+## Prerequisites
+
+- Audit completed (*audit command run successfully)
+- .state.yaml exists with inventory results
+- pattern-inventory.json available
+
+## Workflow
+
+### Interactive Elicitation
+
+This task uses interactive elicitation to review consolidation decisions.
+
+1. **Load Audit Results**
+   - Read pattern-inventory.json for full data, .state.yaml for metadata
+   - Display current redundancy metrics
+   - Confirm user wants to proceed with consolidation
+
+2. **Review Clustering Parameters**
+   - HSL threshold for colors (default: 5%)
+   - Ask if user has manual overrides (patterns that shouldn't merge)
+   - Confirm output directory
+
+3. **Present Consolidation Recommendations**
+   - Show before/after for each pattern type
+   - Ask for approval or adjustments
+   - Allow manual overrides before finalizing
+
+### Steps
+
+1. **Load Audit Data**
+   - Read pattern-inventory.json for full inventory data
+   - Read .state.yaml for scan metadata (path, timestamp)
+   - If pattern-inventory.json not found, check .state.yaml for inventory_file path
+   - Validate audit phase completed
+   - Extract pattern counts and scan path
+   - Check: pattern-inventory.json OR .state.yaml contains inventory data with pattern count > 0 — abort with "No audit data found: run *audit first"
+
+2. **Cluster Colors by HSL Similarity**
+   - Extract all unique colors from codebase
+   - Convert hex to HSL color space
+   - Group colors within 5% HSL threshold
+   - Select most-used color in each cluster as primary
+   - Identify semantic relationships (primary-dark as hover state)
+   - Check: cluster count > 0 AND each cluster has primary color + usage count — log "{N} color clusters from {total} unique colors"
+
+3. **Cluster Button Patterns by Semantic Purpose**
+   - Extract button class names and patterns
+   - Analyze naming for semantic meaning (primary, secondary, danger, etc)
+   - Group functionally equivalent buttons
+   - Recommend minimal variant set (primary, secondary, destructive)
+   - Check: button variant count <= 5 AND each variant has semantic name + mapped classes — log "{before} button patterns consolidated to {after} variants"
+
+4. **Consolidate Spacing Values**
+   - Extract all padding and margin values
+   - Identify base unit (4px or 8px)
+   - Propose spacing scale (xs, sm, md, lg, xl, 2xl, 3xl)
+   - Map existing values to scale
+   - Check: spacing scale has base unit (4px or 8px) AND scale count between 5-10 values — log "Spacing: {before} values consolidated to {after}-step scale (base: {unit})"
+
+5. **Consolidate Typography**
+   - Extract font sizes, weights, families
+   - Propose type scale (modular scale or fixed intervals)
+   - Consolidate similar weights (merge 500 and 600 if both exist)
+   - Recommend minimal font family set
+   - Check: type scale has sizes + weights + families defined AND count < original — log "Typography: {before} values consolidated to {after} tokens"
+
+6. **Generate Consolidation Report**
+   - Create consolidation-report.md with before/after metrics
+   - Include reduction percentages for each pattern type
+   - Generate detailed cluster files (color-clusters.txt, button-consolidation.txt)
+   - Calculate overall reduction percentage
+   - Check: overall reduction >= 80% OR report contains explicit justification for lower reduction — log "Overall reduction: {pct}% ({before} -> {after} patterns)"
+
+7. **Create Pattern Mapping**
+   - Generate old-to-new mapping for each pattern type
+   - Document which old patterns map to which new tokens
+   - Create migration guide snippets
+   - Check: mapping entries cover all consolidated pattern types (colors, buttons, spacing, typography) — abort with "Incomplete mapping: {type} missing"
+
+8. **Update State File**
+   - Add consolidation section to .state.yaml
+   - Record before/after counts for all pattern types
+   - Update phase to "consolidation_complete"
+   - Log Brad's consolidation decisions
+   - Check: .state.yaml contains `phase: "consolidation_complete"` AND before/after counts for all pattern types — abort with "State update failed: {missing field}"
+
+## Output
+
+- **consolidation-report.md**: Executive summary with reduction metrics
+- **color-clusters.txt**: Detailed color groupings with usage counts
+- **button-consolidation.txt**: Button semantic analysis and recommendations
+- **spacing-consolidation.txt**: Spacing scale proposal
+- **typography-consolidation.txt**: Typography scale proposal
+- **pattern-mapping.json**: Old pattern → new token mappings
+- **.state.yaml**: Updated with consolidation decisions
+
+### Output Format
+
+```yaml
+# .state.yaml consolidation section
+consolidation:
+  completed_at: "2025-10-27T12:30:00Z"
+  patterns_consolidated:
+    colors:
+      before: 89
+      after: 12
+      reduction: "86.5%"
+      clusters: 8
+    buttons:
+      before: 47
+      after: 3
+      reduction: "93.6%"
+      variants: ["primary", "secondary", "destructive"]
+    spacing:
+      before: 19
+      after: 7
+      reduction: "63.2%"
+      scale: ["xs", "sm", "md", "lg", "xl", "2xl", "3xl"]
+    typography:
+      before: 21
+      after: 10
+      reduction: "52.4%"
+  overall_reduction: "81.8%"
+  target_met: true
+```
+
+## Failure Handling
+
+- **Pattern reduction <60%:** Review clustering thresholds — HSL tolerance may be too tight. Widen from 10% to 15% and re-run
+- **Inventory file not found:** Check .state.yaml for inventory_file path. Re-run *audit if missing
+- **Conflicting patterns detected:** Present conflicts to user for manual resolution before proceeding
+- **Consolidation takes >10 min:** Split by pattern type (colors first, then spacing, then components)
+
+## Success Criteria
+
+- [ ] >80% overall pattern reduction achieved
+- [ ] Color clustering uses HSL similarity (not just hex distance)
+- [ ] Button variants identified by semantic purpose
+- [ ] Spacing scale based on consistent base unit
+- [ ] Most-used patterns preserved as primary tokens
+- [ ] All consolidation decisions documented with rationale
+- [ ] User can review and override before finalizing
+
+## Quality Gate
+
+> **GATE: Consolidation Review** — Human checkpoint before proceeding to tokenization
+
+| Metric | Threshold | Action if FAIL |
+|--------|-----------|----------------|
+| Pattern reduction | >= 60% | Widen HSL clustering tolerance from 10% to 15%, re-run consolidation |
+| Color clusters | <= 20 unique groups | Merge near-duplicates manually, re-cluster with looser threshold |
+| Spacing scale | Based on consistent base unit | If no base unit detected, propose 4px/8px grid and re-align |
+| User approval | Required | Present consolidation summary, get explicit "proceed" before tokenization |
+
+**Rework rule:** If reduction < 40% after 2 iterations, escalate to user — codebase may have genuinely diverse patterns that shouldn't be consolidated.
+
+## Error Handling
+
+- **No audit data found**: Exit with message to run *audit first
+- **Insufficient patterns to consolidate**: Report that codebase is already clean
+- **Cannot achieve 80% reduction**: Explain why and show actual reduction achieved
+- **Invalid state file**: Attempt to recover from backup or prompt re-audit
+
+## Security Considerations
+
+- Read-only analysis of patterns (no code modification)
+- Validate user overrides to prevent injection
+- Handle malformed color values safely
+- Backup state file before overwriting
+
+## Examples
+
+### Example 1: Successful Consolidation
+
+```bash
+*consolidate
+```
+
+Output:
+```
+🎨 CONSOLIDATING COLORS...
+Found 89 unique colors
+Clustering with 5% HSL threshold...
+
+CLUSTER 1 - Primary Blues (4 → 1):
+  #0066CC (234 uses) <- KEEP
+  #0065CB, #0067CD, #0064CA (merge)
+
+CLUSTER 2 - Error Reds (3 → 1):
+  #DC2626 (89 uses) <- KEEP
+  #DB2525, #DD2727 (merge)
+
+📊 CONSOLIDATION SUMMARY:
+| Pattern    | Before | After | Reduction |
+|------------|--------|-------|-----------|
+| Colors     | 89     | 12    | 86.5%     |
+| Buttons    | 47     | 3     | 93.6%     |
+| Spacing    | 19     | 7     | 63.2%     |
+| Typography | 21     | 10    | 52.4%     |
+| TOTAL      | 176    | 32    | 81.8%     |
+
+✅ TARGET MET: >80% reduction achieved
+✅ Report saved: outputs/design-system/my-app/consolidation/consolidation-report.md
+```
+
+### Example 2: User Override
+
+```bash
+*consolidate
+
+Brad: "Merge #0066CC and #0052A3?"
+User: "No, #0052A3 is intentional hover state"
+Brad: "Override recorded. Keeping both."
+```
+
+## Notes
+
+- HSL color space provides perceptual similarity (better than RGB/hex distance)
+- Most-used pattern in each cluster becomes the canonical token
+- Semantic button analysis looks for keywords: primary, main, secondary, default, danger, delete, destructive
+- Spacing scale should use consistent base unit (4px or 8px)
+- Manual overrides are respected and documented
+- Run this after every audit to prevent pattern regression
+- Brad says: "Numbers don't lie. 82% reduction = real savings."
+## Related Checklists
+
+- `squads/design/checklists/ds-component-quality-checklist.md`
+- `squads/design/checklists/ds-pattern-audit-checklist.md`
+