Codex/profile readiness fixtures

.superpowers/sdd/data-task-5-report.md

@@ -0,0 +1,48 @@
+# Task 5 Report: Active-Profile Training Settings
+
+## Scope and baseline
+
+- Base commit: `1a84814990db2129ccd587955eafab7f1d929af1`
+- Branch: `codex/add-profile-tab`
+- Scope: Task 5 only. No Task 6 work or tracked design/plan documents were changed.
+
+## Implemented
+
+- Reworked `SettingsManager` into a global-plus-active-profile compatibility facade. Profile-owned setters capture the originating Ready profile, serialize section changes, reject stale/switching writes, preserve consent/VBT cascades and clamps, and never write legacy Settings.
+- Seeded the compatibility stream and every derived `StateFlow` synchronously from an already-Ready profile, avoiding transient legacy/default values for immediate consumers.
+- Narrowed the `PreferencesManager` abstraction to global writes and deprecated migration-only quick-start reads. Concrete legacy profile writers remain internal solely for migration-source tests; the production-call audit found no callers.
+- Added repository-level atomic `mutateCore`, used by both SettingsManager and health import, so a long health read changes only body weight against the latest core section without reverting concurrent unit/increment updates.
+- Added `RequiredMigrationGate`; required-migration awaiters now terminate on Ready or throw `RequiredMigrationFailedException` on Failed. Health maps migration failure and profile-context failures to `HealthBodyWeightSyncResult.Failed`.
+- Replaced the production equipment-rack binding with a lifecycle-owned active-profile repository and retained the Settings implementation only as an explicit legacy implementation.
+- Routed SafeWord effective-state gating, quick-start documents and auto-saves, DWSM VBT reads, MainViewModel LED unlocks, BLE color application, and workout start gating through the active Ready profile.
+- Preserved complete single-exercise documents, rack IDs, per-set arrays, and Just Lift conversion fidelity; the existing Just Lift runtime `Int` boundary intentionally rounds the persisted float.
+- Made `JustLiftScreen` reload defaults on Ready profile-ID changes and suppress parameter writes while Switching or while the current profile's defaults are loading.
+- Updated Koin bindings and shared Android-host/DWSM fixtures to use one Ready `FakeUserProfileRepository` per fixture.
+- Replaced the adults-only dialog's former callback sequence with the serialized composite operation and removed the now-dead callback/comments.
+
+## TDD evidence
+
+- Initial consumer RED: 57 tests executed, 6 expected failures covering legacy-setting isolation, A/B rack switching, health active-core writes, SafeWord effective gating, BLE profile color, and the Ready start gate.
+- Additional RED regressions:
+  - health profile transition surfaced an uncaught `ProfileContextUnavailableException`;
+  - immediate `SettingsManager.userPreferences` exposed the legacy initial snapshot;
+  - final review set executed 21 tests with 4 intended failures: stale health core overwrite, failed migration gate handling, migration await timeout, and one-shot Just Lift defaults loading.
+- The same final review set passed 21/21 after the fixes.
+
+## Final verification
+
+All commands used Android Studio's JBR and `-Pskip.supabase.check=true`.
+
+- Required focused consumer suite: **128 tests, 0 failures, 0 errors**.
+- Required DWSM/regression suite: **173 tests, 0 failures, 0 errors**.
+- `:shared:compileAndroidMain` plus `KoinModuleVerifyTest`: **build passed; 1 test, 0 failures, 0 errors**.
+- Unfiltered `:shared:testAndroidHostTest`: **2516 tests, 0 failures, 0 errors**.
+- `:shared:compileKotlinIosArm64`: **build passed**.
+- Independent full-diff review: **no remaining Critical or Important findings**.
+- Static boundary audit: no common-main profile-owned calls through `PreferencesManager`, no common-main legacy quick-start calls, and production DI binds `ProfileEquipmentRackRepository` only.
+- `git diff --check`: passed (Git reports only the repository's Windows line-ending notices).
+
+## Notes
+
+- Existing project compiler/deprecation warnings remain; verification introduced no build or test failures.
+- `openspec/AGENTS.md` referenced by the root instructions is absent in this checkout; the complete Task 5 brief was used as the authoritative implementation contract.

.superpowers/sdd/data-task-6-report.md

@@ -0,0 +1,41 @@
+# Data Task 6 implementation report
+
+Base: `2103af00`
+Commit subject: `feat: gate live VBT by active profile`
+
+## Delivered behavior
+
+- Preserved unconditional real biomechanics capture and extracted the existing live decision into `ActiveSessionEngine.evaluateLatestVbtResult()` with the working-rep guard inside that production seam.
+- Added one immutable `VbtRuntimeSettings(enabled, velocityLossThresholdPercent, autoEndOnVelocityLoss)` `StateFlow` in `WorkoutCoordinator`; live evaluation reads it once per completed rep.
+- Initialized and updated the complete VBT triple from `SettingsManager.userPreferences`, using `map` plus `distinctUntilChanged`, rethrowing collector cancellation, and adding no new DI binding.
+- Disabled VBT now suppresses only velocity-loss interpretation, threshold/verbal events, and auto-end. Raw rep results, set summaries, persistence, MCV/peak values, PR/progression inputs, and history remain available.
+- Re-enabling preserves the configured threshold and auto-end choice and restores the prior alert/auto-end behavior without resetting the biomechanics baseline.
+- Replaced the test-local verbal tracker with production policy `UserPreferences.verbalEncouragementEventOrNull()`. Local adult confirmation neutralizes vulgar and dominatrix routing while leaving persisted profile intent unchanged.
+- Threaded `vbtEnabled` through `WorkoutUiState`, the `ActiveWorkoutScreen` remember key and value, both `WorkoutTab` layers, `WorkoutHud`, and `StatsPage`.
+- Disabled UI keeps raw MCV and Peak visible in a neutral color while hiding Zone, velocity-loss, and estimated-reps-left interpretation. `BiomechanicsHistoryCard` remains ungated.
+
+## TDD evidence
+
+1. Baseline characterization: the original focused VBT/event/integration matrix passed (86 tests, zero failures).
+2. Behavior-neutral seam extraction: the same matrix passed again (86 tests, zero failures).
+3. Feature RED:
+   - The first production-backed disabled test failed because live threshold processing still auto-ended and reset the real `BiomechanicsEngine`; the XML failure was `latestRepResult` unexpectedly null, with logs showing `VELOCITY_THRESHOLD_REACHED` and auto-end after two threshold reps.
+   - The completed test set then failed to compile on the deliberately absent `VbtRuntimeSettings`, coherent snapshot flow, and production verbal-policy API.
+   - After runtime GREEN, the two UI source-contract tests remained RED until the full Compose chain was threaded and the interpretation branches were gated.
+4. GREEN: the final focused matrix contains 92 tests across 9 suites with zero failures or errors. `VbtUiWiringTest` contributes three tests, including a malformed-source proof that the gate-slicing assertions reject raw metrics moved inside a VBT gate or estimated reps moved outside the loss gate.
+
+Runtime tests use `DWSMTestHarness`, its Ready fake profile, the real `BiomechanicsEngine`, real `WorkoutState`, real `HapticEvent` stream, and `FakeBiomechanicsRepository`. Source contracts use `readProjectFile` and verify all required Compose hops plus the absence of a history gate.
+
+## Verification
+
+- `:shared:testAndroidHostTest --tests "*Vbt*" --tests "*VerbalEncouragementGateTest*" --tests "*WorkoutCoordinatorEventTest*" --tests "*ActiveSessionEngineIntegrationTest*"`: PASS, 92/92.
+- `:shared:compileKotlinIosArm64`: PASS.
+- Android main and Android host test compilation: PASS as part of the focused matrix.
+- `git diff --check`: PASS (Git only reports the repository's LF-to-CRLF checkout notices).
+
+The build continues to print existing project deprecation/performance warnings; this task introduced no new compilation failure or Koin graph change.
+
+## Adaptations to the real codebase
+
+- No extra harness API was required: `DWSMTestHarness` already exposed the active engine, coordinator, Ready repository, real settings facade, and fake biomechanics persistence repository needed by the production-backed tests.
+- Existing `WorkoutCoordinatorEventTest` and `ActiveSessionEngineIntegrationTest` already covered event coexistence and subordinate VBT configuration. The new runtime test adds the missing master-toggle/coherent-switch/persistence/adult-policy assertions without duplicating those fixtures.

androidApp/build.gradle.kts

@@ -98,6 +98,131 @@ abstract class VerifyReleaseCueResourcesTask : DefaultTask() {
     }
 }
 
+abstract class VerifyQaReleaseBoundaryTask : DefaultTask() {
+    @get:InputFile
+    @get:PathSensitive(PathSensitivity.RELATIVE)
+    abstract val forbiddenMarkersFile: RegularFileProperty
+
+    @get:Internal
+    abstract val releaseApkDir: DirectoryProperty
+
+    @get:Internal
+    abstract val releaseIntermediatesDir: DirectoryProperty
+
+    @get:Internal
+    abstract val projectRootDir: DirectoryProperty
+
+    @TaskAction
+    fun verifyReleaseBoundary() {
+        fun ByteArray.containsSequence(sequence: ByteArray): Boolean {
+            if (sequence.isEmpty()) return true
+            if (sequence.size > size) return false
+
+            for (startIndex in 0..size - sequence.size) {
+                var matches = true
+                for (offset in sequence.indices) {
+                    if (this[startIndex + offset] != sequence[offset]) {
+                        matches = false
+                        break
+                    }
+                }
+                if (matches) return true
+            }
+            return false
+        }
+
+        val projectRoot = projectRootDir.get().asFile
+        val markerFile = forbiddenMarkersFile.get().asFile
+        val forbiddenMarkers = markerFile.readLines()
+            .map(String::trim)
+            .filter(String::isNotEmpty)
+
+        if (forbiddenMarkers.isEmpty()) {
+            throw GradleException("QA release marker inventory is empty: ${markerFile.relativeTo(projectRoot)}")
+        }
+        if (forbiddenMarkers.distinct().size != forbiddenMarkers.size) {
+            throw GradleException("QA release marker inventory contains duplicates: ${markerFile.relativeTo(projectRoot)}")
+        }
+
+        val markerBytes = forbiddenMarkers.associateWith { it.toByteArray(Charsets.UTF_8) }
+        val releaseArtifacts = releaseApkDir.get().asFile
+            .takeIf(File::isDirectory)
+            ?.walkTopDown()
+            ?.filter { it.isFile && it.extension.equals("apk", ignoreCase = true) }
+            ?.sortedBy { it.invariantSeparatorsPath }
+            ?.toList()
+            .orEmpty()
+
+        if (releaseArtifacts.isEmpty()) {
+            throw GradleException("No Android release APK artifacts found. Run :androidApp:assembleRelease first.")
+        }
+
+        val releaseIntermediates = releaseIntermediatesDir.get().asFile
+        val releaseManifests = listOf(
+            "merged_manifest",
+            "merged_manifests",
+            "packaged_manifests",
+        ).flatMap { relativeRoot ->
+            File(releaseIntermediates, relativeRoot)
+                .takeIf(File::isDirectory)
+                ?.walkTopDown()
+                ?.filter { file ->
+                    file.isFile &&
+                        file.name == "AndroidManifest.xml" &&
+                        file.relativeTo(releaseIntermediates).invariantSeparatorsPath
+                            .contains("/release/", ignoreCase = true)
+                }
+                ?.toList()
+                .orEmpty()
+        }.distinct().sortedBy { it.invariantSeparatorsPath }
+
+        if (releaseManifests.isEmpty()) {
+            throw GradleException(
+                "No merged or packaged Android release manifests found after :androidApp:assembleRelease.",
+            )
+        }
+
+        val leaks = mutableListOf<String>()
+        releaseManifests.forEach { manifest ->
+            val content = manifest.readBytes()
+            markerBytes.forEach { (marker, bytes) ->
+                if (content.containsSequence(bytes)) {
+                    leaks += "${manifest.relativeTo(projectRoot).invariantSeparatorsPath}: $marker"
+                }
+            }
+        }
+
+        var scannedEntries = 0
+        releaseArtifacts.forEach { artifact ->
+            ZipFile(artifact).use { zip ->
+                zip.entries().asSequence()
+                    .filterNot { it.isDirectory }
+                    .forEach { entry ->
+                        scannedEntries += 1
+                        val content = zip.getInputStream(entry).use { it.readBytes() }
+                        markerBytes.forEach { (marker, bytes) ->
+                            if (content.containsSequence(bytes)) {
+                                leaks +=
+                                    "${artifact.relativeTo(projectRoot).invariantSeparatorsPath}!/${entry.name}: $marker"
+                            }
+                        }
+                    }
+            }
+        }
+
+        if (leaks.isNotEmpty()) {
+            throw GradleException(
+                "Android release outputs contain debug-only QA markers:\n${leaks.joinToString("\n") { "  - $it" }}",
+            )
+        }
+
+        println(
+            "Verified ${forbiddenMarkers.size} QA markers absent from ${releaseManifests.size} release manifests " +
+                "and $scannedEntries entries across ${releaseArtifacts.size} release APK(s).",
+        )
+    }
+}
+
 abstract class VerifySupabaseRuntimeConfigTask : DefaultTask() {
     @get:Input
     abstract val configuredSupabaseUrl: Property<String>
@@ -285,6 +410,18 @@ tasks.register<VerifyReleaseCueResourcesTask>("verifyReleaseCueResources") {
     projectRootDir.set(rootProject.layout.projectDirectory)
 }
 
+tasks.register<VerifyQaReleaseBoundaryTask>("verifyQaReleaseBoundary") {
+    group = "verification"
+    description = "Assembles and rejects Android release outputs containing debug-only Profile QA markers."
+
+    dependsOn("assembleRelease")
+
+    forbiddenMarkersFile.set(layout.projectDirectory.file("config/qa-release-forbidden-markers.txt"))
+    releaseApkDir.set(layout.buildDirectory.dir("outputs/apk/release"))
+    releaseIntermediatesDir.set(layout.buildDirectory.dir("intermediates"))
+    projectRootDir.set(rootProject.layout.projectDirectory)
+}
+
 dependencies {
     // Shared module
     implementation(project(":shared"))
@@ -332,4 +469,7 @@ dependencies {
     testImplementation(libs.truth)
     testImplementation(libs.koin.test)
     testImplementation(libs.koin.test.junit4)
+    testImplementation(libs.ktor.client.mock)
+    testImplementation(libs.multiplatform.settings)
+    testImplementation(libs.multiplatform.settings.test)
 }

androidApp/config/qa-release-forbidden-markers.txt

@@ -0,0 +1,7 @@
+ProfileQa
+QaBlockingPortalApiClient
+QA_SEED_PROFILE
+[QA] Profile
+QA fixture is local-only
+profile_qa_fixture_gate
+com.devil.phoenixproject.qa

androidApp/src/debug/AndroidManifest.xml

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools">
+
+    <application
+        android:name=".qa.ProfileQaDebugApp"
+        tools:replace="android:name">
+
+        <receiver
+            android:name=".qa.ProfileQaSeedReceiver"
+            android:exported="true">
+            <intent-filter>
+                <action android:name="com.devil.phoenixproject.QA_SEED_PROFILE" />
+            </intent-filter>
+        </receiver>
+    </application>
+
+</manifest>

androidApp/src/debug/kotlin/com/devil/phoenixproject/qa/ProfileQaDebugApp.kt

@@ -0,0 +1,47 @@
+package com.devil.phoenixproject.qa
+
+import com.devil.phoenixproject.VitruvianApp
+import com.devil.phoenixproject.data.repository.AssessmentRepository
+import com.devil.phoenixproject.data.repository.ExerciseRepository
+import com.devil.phoenixproject.data.repository.PersonalRecordRepository
+import com.devil.phoenixproject.data.repository.RepMetricRepository
+import com.devil.phoenixproject.data.repository.UserProfileRepository
+import com.devil.phoenixproject.data.repository.VelocityOneRepMaxRepository
+import com.devil.phoenixproject.data.repository.WorkoutRepository
+import com.devil.phoenixproject.data.sync.PortalApiClient
+import com.devil.phoenixproject.data.sync.PortalTokenStorage
+import com.devil.phoenixproject.data.sync.SupabaseConfig
+import com.devil.phoenixproject.database.VitruvianDatabase
+import org.koin.core.context.loadKoinModules
+import org.koin.dsl.module
+
+class ProfileQaDebugApp : VitruvianApp() {
+    override fun onCreate() {
+        super.onCreate()
+
+        loadKoinModules(
+            module {
+                single { ProfileQaFixtureGate(this@ProfileQaDebugApp) }
+                single {
+                    ProfileQaSeeder(
+                        userProfileRepository = get<UserProfileRepository>(),
+                        exerciseRepository = get<ExerciseRepository>(),
+                        workoutRepository = get<WorkoutRepository>(),
+                        repMetricRepository = get<RepMetricRepository>(),
+                        personalRecordRepository = get<PersonalRecordRepository>(),
+                        assessmentRepository = get<AssessmentRepository>(),
+                        velocityOneRepMaxRepository = get<VelocityOneRepMaxRepository>(),
+                        database = get<VitruvianDatabase>(),
+                    )
+                }
+                single<PortalApiClient> {
+                    QaBlockingPortalApiClient(
+                        supabaseConfig = get<SupabaseConfig>(),
+                        tokenStorage = get<PortalTokenStorage>(),
+                        fixtureGate = get<ProfileQaFixtureGate>(),
+                    )
+                }
+            },
+        )
+    }
+}

androidApp/src/debug/kotlin/com/devil/phoenixproject/qa/ProfileQaFixtureGate.kt

@@ -0,0 +1,20 @@
+package com.devil.phoenixproject.qa
+
+import android.content.Context
+
+class ProfileQaFixtureGate(context: Context) {
+    private val preferences = context.getSharedPreferences(PREFERENCES_FILE, Context.MODE_PRIVATE)
+
+    fun isEnabled(): Boolean = preferences.getBoolean(KEY_ENABLED, false)
+
+    fun enable() {
+        check(preferences.edit().putBoolean(KEY_ENABLED, true).commit()) {
+            "Could not persist the profile QA fixture gate"
+        }
+    }
+
+    private companion object {
+        const val PREFERENCES_FILE = "profile_qa_fixture_gate"
+        const val KEY_ENABLED = "enabled"
+    }
+}