iOS Skills System Implementation

┌─────────────────────────────────────────────────────────────────┐
│                        SkillsViewModel                          │
│                    (@MainActor, @Observable)                    │
│         UI State | Loading States | Error Handling              │
└────────────────────────────┬────────────────────────────────────┘
                             │
                             ▼
┌─────────────────────────────────────────────────────────────────┐
│                      SkillGraphService                          │
│                    (Actor - Thread Safe)                        │
│     Unified facade coordinating all skill operations            │
└────────────────────────────┬────────────────────────────────────┘
                             │
       ┌─────────────────────┼─────────────────────┐
       │                     │                     │
       ▼                     ▼                     ▼
┌──────────────┐    ┌───────────────┐    ┌──────────────────┐
│SkillDecay    │    │SkillRelation  │    │SkillPractice     │
│Service       │    │shipService    │    │Service           │
├──────────────┤    ├───────────────┤    ├──────────────────┤
│• Decay calc  │    │• Prerequisites│    │• Log practice    │
│• Alerts      │    │• Synergies    │    │• Streaks         │
│• Recovery    │    │• Graph build  │    │• Statistics      │
└──────────────┘    └───────────────┘    └──────────────────┘
       │                     │                     │
       ▼                     ▼                     ▼
┌──────────────────────────────────────────────────────────────┐
│                       SwiftData Layer                         │
│  SkillDecayConfigEntity | SkillRelationshipEntity | etc.     │
└──────────────────────────────────────────────────────────────┘

TrajectoryOS/
├── Models/
│   └── Data/
│       ├── SkillDecayConfigEntity.swift      # Decay configuration
│       ├── SkillRelationshipEntity.swift     # Skill graph edges
│       ├── SkillTargetEntity.swift           # Learning goals
│       ├── LearningPathEntity.swift          # Active learning paths
│       ├── SkillPracticeLogEntity.swift      # Practice history
│       ├── SkillAssessmentEntity.swift       # Assessments & evidence
│       └── SkillDecayAlertEntity.swift       # Decay notifications
│
├── Services/
│   └── Skills/
│       ├── SkillDecayService.swift           # Decay calculations
│       ├── SkillRelationshipService.swift    # Graph operations
│       ├── LearningPathService.swift         # Target/path management
│       ├── SkillPracticeService.swift        # Practice logging
│       ├── SkillAssessmentService.swift      # Assessments
│       └── SkillGraphService.swift           # Unified coordinator
│
└── ViewModels/
    └── SkillsViewModel.swift                 # UI state management

// Formula: C(t) = C_0 × 0.5^(t/T_half)
let decayFactor = pow(0.5, Double(daysSincePractice) / Double(halfLifeDays))
let adjustedConfidence = rawConfidence * decayFactor

@MainActor
class MyView: View {
    @State private var viewModel = SkillsViewModel()

    var body: some View {
        VStack {
            if let summary = viewModel.dashboardSummary {
                Text("Skills: \(summary.totalSkills)")
                Text("Health: \(summary.healthLevel.displayName)")
            }
        }
        .task {
            viewModel.configure(with: modelContainer)
            await viewModel.loadDashboard()
        }
    }
}

Task {
    try await viewModel.logPractice(
        skillId: skill.id,
        activityType: .projectWork,
        durationMinutes: 45,
        intensity: 0.8,
        notes: "Worked on new feature"
    )
}

Task {
    let path = try await viewModel.startLearningPath(
        targetId: seniorIOSDeveloperTargetId,
        targetDate: Calendar.current.date(byAdding: .month, value: 6, to: Date())
    )
}

actor SkillDecayService {
    private let modelContainer: ModelContainer

    func calculateDecay(...) async throws -> SkillDecayInfo {
        // Safe concurrent access
    }
}

@MainActor
@Observable
final class SkillsViewModel {
    // All state mutations happen on main thread
}