merge: competitor-benchmark — proactive notifications, clickability, 5-phase remediation

Author: cortexark

apps/HeartCoach/Package.swift

@@ -47,7 +47,17 @@ let package = Package(
                 // SIGSEGV in testFullComparisonSummary (String(format: "%s") crash)
                 "AlgorithmComparisonTests.swift",
                 // EngineTimeSeries has its own target (ThumpTimeSeriesTests)
-                "EngineTimeSeries"
+                "EngineTimeSeries",
+                // Firebase integration tests (need Firestore SDK, not in SPM target)
+                "BugReportFirestoreTests.swift",
+                "FeedbackFirestoreTests.swift",
+                "FirestoreTelemetryIntegrationTests.swift",
+                // Super Reviewer (needs Claude CLI + judge infrastructure)
+                "SuperReviewer",
+                // Proactive notifications (needs UNUserNotificationCenter, iOS-only)
+                "ProactiveNotificationTests.swift",
+                // Advice presenter copy fit (needs iOS Views)
+                "AdvicePresenterCopyFitTests.swift"
             ]
         ),
         // TEST-3: Engine time-series validation suite (280 checkpoints).

apps/HeartCoach/README.md

@@ -11,14 +11,33 @@ This folder contains a cross-target scaffold for iPhone and Apple Watch:
 - For production, add Xcode targets and wire HealthKit/WatchConnectivity entitlements.
 - `project.yml` is included for `xcodegen`-based project generation.
 
-## Run Core Tests
+## Run Tests
+
+### Core unit tests (no Xcode required)
 ```bash
-cd /Users/t/workspace/Apple-watch/apps/Thump
+cd apps/HeartCoach
 swift test
 ```
 
-## Generate Xcode Project (optional)
+### Engine time-series validation (280 checkpoints)
 ```bash
-cd /Users/t/workspace/Apple-watch/apps/Thump
-xcodegen generate
+swift test --filter ThumpTimeSeriesTests
+```
+
+### Full integration tests (requires Xcode + Simulator)
+```bash
+xcodebuild test -project Thump.xcodeproj -scheme Thump \
+  -destination "platform=iOS Simulator,name=iPhone 17 Pro"
+```
+
+### UI tests with granular gate control
+```bash
+# Full bypass (legacy)
+xcodebuild test ... -- -UITestMode
+
+# Granular: test onboarding flow only
+xcodebuild test ... -- -UITest_SignedIn -UITest_LegalAccepted
+
+# Granular: test legal gate only
+xcodebuild test ... -- -UITest_SignedIn
 ```

apps/HeartCoach/Shared/Services/ProactiveNotificationStore.swift

@@ -0,0 +1,67 @@
+// ProactiveNotificationStore.swift
+// ThumpCore
+//
+// LocalStore extension for persisting proactive notification history.
+// Tracks when each notification type was last scheduled so the
+// ProactiveNotificationService can enforce budgets and cooldowns.
+//
+// Uses UserDefaults with a pruning strategy to prevent unbounded growth
+// (GPT-5.4 review fix #5: stale data persistence).
+//
+// Platforms: iOS 17+, watchOS 10+
+
+import Foundation
+
+// MARK: - LocalStore Extension
+
+extension LocalStore {
+
+    // MARK: - Keys
+
+    private static let proactiveHistoryKey = "thump_proactive_notification_history"
+    private static let maxHistoryDays = 14
+
+    // MARK: - Read
+
+    /// Returns all stored dates for a given notification type.
+    func proactiveNotificationDates(for type: ProactiveNotificationType) -> [Date] {
+        let all = loadProactiveHistory()
+        return all[type.rawValue] ?? []
+    }
+
+    // MARK: - Write
+
+    /// Records that a notification of the given type was scheduled at the given date.
+    /// Automatically prunes entries older than 14 days to prevent unbounded growth.
+    func logProactiveNotification(type: ProactiveNotificationType, at date: Date) {
+        var all = loadProactiveHistory()
+        var dates = all[type.rawValue] ?? []
+        dates.append(date)
+
+        // Prune entries older than 14 days
+        let cutoff = Calendar.current.date(
+            byAdding: .day,
+            value: -Self.maxHistoryDays,
+            to: date
+        ) ?? date
+        dates = dates.filter { $0 > cutoff }
+
+        all[type.rawValue] = dates
+        saveProactiveHistory(all)
+    }
+
+    // MARK: - Private Persistence
+
+    private func loadProactiveHistory() -> [String: [Date]] {
+        guard let data = UserDefaults.standard.data(forKey: Self.proactiveHistoryKey),
+              let decoded = try? JSONDecoder().decode([String: [Date]].self, from: data) else {
+            return [:]
+        }
+        return decoded
+    }
+
+    private func saveProactiveHistory(_ history: [String: [Date]]) {
+        guard let data = try? JSONEncoder().encode(history) else { return }
+        UserDefaults.standard.set(data, forKey: Self.proactiveHistoryKey)
+    }
+}

apps/HeartCoach/Shared/Views/ThumpBuddy.swift

@@ -22,6 +22,9 @@
 // Platforms: iOS 17+, watchOS 10+
 
 import SwiftUI
+#if canImport(UIKit)
+import UIKit
+#endif
 
 // MARK: - Buddy Mood
 
@@ -42,15 +45,38 @@ enum BuddyMood: String, Equatable, Sendable {
 
     static func from(
         assessment: HeartAssessment,
+        readinessScore: Int? = nil,
         nudgeCompleted: Bool = false,
         feedbackType: DailyFeedback? = nil,
         activityInProgress: Bool = false
     ) -> BuddyMood {
         if nudgeCompleted { return .conquering }
         if feedbackType == .positive { return .conquering }
         if activityInProgress { return .active }
+
+        // Use readiness score as primary signal (coherent with Thump Check card).
+        // Only show .tired when BOTH anomaly status AND readiness agree the user
+        // should rest — prevents "Rest Up" contradicting "Good to go" (BUG-1).
+        if let score = readinessScore {
+            if score >= 80 { return .thriving }
+            if score >= 60 {
+                // Moderate-to-good readiness: show content unless stress is high
+                return assessment.stressFlag ? .stressed : .content
+            }
+            if score >= 40 {
+                // Below average: nudging toward recovery
+                return assessment.stressFlag ? .stressed : .nudging
+            }
+            // Low readiness (< 40): genuinely tired — BUT only show sleeping
+            // mood in evening hours. During daytime, show nudging instead.
+            let hour = Calendar.current.component(.hour, from: Date())
+            let isEvening = hour >= 20 || hour < 6
+            return isEvening ? .tired : .nudging
+        }
+
+        // Fallback for nil readiness (first run, no data)
         if assessment.stressFlag { return .stressed }
-        if assessment.status == .needsAttention { return .tired }
+        if assessment.status == .needsAttention { return .nudging }
         if assessment.status == .improving {
             if let cardio = assessment.cardioScore, cardio >= 70 { return .thriving }
             return .content
@@ -300,7 +326,7 @@ struct ThumpBuddy: View {
         // Haptic
         #if os(watchOS)
         WKInterfaceDevice.current().play(.click)
-        #else
+        #elseif canImport(UIKit)
         UIImpactFeedbackGenerator(style: .medium).impactOccurred()
         #endif
 
@@ -345,7 +371,7 @@ struct ThumpBuddy: View {
         // Haptic — soft
         #if os(watchOS)
         WKInterfaceDevice.current().play(.success)
-        #else
+        #elseif canImport(UIKit)
         UIImpactFeedbackGenerator(style: .soft).impactOccurred()
         #endif