iOS: results log + CSV export, full benchmark detail, swipe-to-change-day

Addresses three pieces of feedback:
- Results LOG (local, SwiftData): log a metcon or benchmark result from the
  session/benchmark screens; history list with swipe-to-delete; export the whole
  log to a CSV via the share sheet (Save to Files). No backend, all on-device.
- Benchmarks are now tappable -> detail sheet showing ALL 7 levels (not just Rx),
  color-coded, with bodyweight multipliers and a "Log a test" action.
- Program: native swipe left/right to change day (plus the week strip + arrows).
- Tab bar reworked to 5: Today, Program, Log, Calculator, Standard
  (Benchmarks + Levels combined under a segmented control).

Builds clean (xcodebuild); 0 em dashes; logging verified end-to-end in the
simulator (persist + render + export button).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: OneMuppet

ios/OpenProgression/App/OpenProgressionApp.swift

@@ -1,4 +1,5 @@
 import SwiftUI
+import SwiftData
 
 @main
 struct OpenProgressionApp: App {
@@ -10,5 +11,6 @@ struct OpenProgressionApp: App {
                 .preferredColorScheme(.dark)
                 .tint(Theme.primary)
         }
+        .modelContainer(for: LogEntry.self)
     }
 }

ios/OpenProgression/App/RootView.swift

@@ -4,16 +4,16 @@ struct RootView: View {
     @State private var tab = RootView.initialTab
     static var initialTab: Int {
         switch ProcessInfo.processInfo.environment["OP_TAB"] {
-        case "program": return 1; case "calculator": return 2; case "benchmarks": return 3; case "levels": return 4; default: return 0
+        case "program": return 1; case "log": return 2; case "calculator": return 3; case "standard": return 4; default: return 0
         }
     }
     var body: some View {
         TabView(selection: $tab) {
             TodayView().tag(0).tabItem { Label("Today", systemImage: "bolt.fill") }
             ProgramView().tag(1).tabItem { Label("Program", systemImage: "calendar") }
-            CalculatorView().tag(2).tabItem { Label("Calculator", systemImage: "slider.horizontal.3") }
-            BenchmarksView().tag(3).tabItem { Label("Benchmarks", systemImage: "chart.bar.fill") }
-            LevelsView().tag(4).tabItem { Label("Levels", systemImage: "square.stack.3d.up.fill") }
+            LogView().tag(2).tabItem { Label("Log", systemImage: "checklist") }
+            CalculatorView().tag(3).tabItem { Label("Calculator", systemImage: "slider.horizontal.3") }
+            StandardView().tag(4).tabItem { Label("Standard", systemImage: "chart.bar.fill") }
         }
         .tint(Theme.primary)
     }

ios/OpenProgression/Data/LogEntry.swift

@@ -0,0 +1,41 @@
+import Foundation
+import SwiftData
+
+@Model
+final class LogEntry {
+    var date: Date
+    var type: String        // "Metcon" | "Strength" | "Benchmark"
+    var name: String
+    var code: String?
+    var level: Int
+    var gender: String
+    var result: String      // e.g. "8:32", "120 kg", "12 rounds + 5"
+    var notes: String?
+
+    init(date: Date = Date(), type: String, name: String, code: String? = nil,
+         level: Int, gender: String, result: String, notes: String? = nil) {
+        self.date = date; self.type = type; self.name = name; self.code = code
+        self.level = level; self.gender = gender; self.result = result; self.notes = notes
+    }
+}
+
+enum CSV {
+    static func escape(_ s: String) -> String {
+        if s.contains(",") || s.contains("\"") || s.contains("\n") {
+            return "\"" + s.replacingOccurrences(of: "\"", with: "\"\"") + "\""
+        }
+        return s
+    }
+    static func file(for entries: [LogEntry]) -> URL {
+        let df = DateFormatter(); df.dateFormat = "yyyy-MM-dd HH:mm"
+        var rows = ["Date,Type,Name,Code,Level,Gender,Result,Notes"]
+        let levelName = ["Beginner","Beginner+","Intermediate","Intermediate+","Advanced","Advanced+","Rx"]
+        for e in entries {
+            let lvl = (e.level >= 1 && e.level <= 7) ? levelName[e.level-1] : "\(e.level)"
+            rows.append([df.string(from: e.date), e.type, e.name, e.code ?? "", lvl, e.gender, e.result, e.notes ?? ""].map(escape).joined(separator: ","))
+        }
+        let url = FileManager.default.temporaryDirectory.appendingPathComponent("openprogression-log.csv")
+        try? rows.joined(separator: "\n").data(using: .utf8)?.write(to: url)
+        return url
+    }
+}

ios/OpenProgression/Features/Benchmarks/BenchmarkDetailView.swift

@@ -0,0 +1,78 @@
+import SwiftUI
+
+func benchmarkValueText(_ v: StandardValue?, _ unit: String) -> String {
+    guard let v else { return "-" }
+    switch v {
+    case .scalar(let d):
+        if unit == "seconds" { let s = Int(d); return String(format: "%d:%02d", s/60, s%60) }
+        return "\(Int(d)) \(unit == "kg" ? "kg" : unit == "rounds" ? "rds" : unit)"
+    case .range(let lo, let hi):
+        if hi >= 99 { return "\(lo)+ \(unit)" }
+        if lo == hi { return "\(lo) \(unit)" }
+        return "\(lo)-\(hi) \(unit)"
+    }
+}
+
+struct BenchmarkDetailView: View {
+    @Environment(DataStore.self) private var store
+    @AppStorage("op.gender") private var gender: Gender = .male
+    @AppStorage("op.level") private var userLevel: Int = 3
+    let benchmark: Benchmark
+    let categoryName: String
+    @State private var showLog = false
+
+    var body: some View {
+        ScrollView {
+            VStack(alignment: .leading, spacing: 18) {
+                VStack(alignment: .leading, spacing: 6) {
+                    SectionLabel(text: categoryName)
+                    Text(benchmark.name).font(.display(28)).foregroundStyle(Theme.text)
+                    HStack(spacing: 8) {
+                        Chip(text: testLabel, color: Theme.primary)
+                        if let d = benchmark.description { Text(d).font(.body(12)).foregroundStyle(Theme.textFaint) }
+                    }
+                }
+                Picker("", selection: $gender) { Text("Male").tag(Gender.male); Text("Female").tag(Gender.female) }.pickerStyle(.segmented)
+
+                VStack(alignment: .leading, spacing: 6) {
+                    SectionLabel(text: "Standards by level")
+                    ForEach(store.levels.reversed()) { lv in
+                        HStack(spacing: 12) {
+                            Circle().fill(Theme.levelColor(lv.number)).frame(width: 8, height: 8)
+                            Text(lv.name).font(.body(14, .medium)).foregroundStyle(Theme.text)
+                            Spacer()
+                            if let bwm = benchmark.bwMultiplier?[lv.id]?[gender.rawValue] {
+                                Text(String(format: "%.2gx BW", bwm)).font(.body(11)).foregroundStyle(Theme.textFaint)
+                            }
+                            Text(benchmarkValueText(benchmark.standards[lv.id]?[gender.rawValue], benchmark.unit))
+                                .font(.body(15, .semibold)).foregroundStyle(Theme.levelColor(lv.number))
+                        }
+                        .padding(.vertical, 8)
+                        .overlay(alignment: .bottom) { Rectangle().fill(Theme.stroke).frame(height: 1) }
+                    }
+                }.card(padding: 16)
+
+                Button { Haptics.tap(); showLog = true } label: {
+                    Label("Log a test", systemImage: "square.and.pencil")
+                        .font(.body(15, .semibold)).foregroundStyle(Color.black)
+                        .frame(maxWidth: .infinity).padding(.vertical, 14)
+                        .background(Theme.primary, in: RoundedRectangle(cornerRadius: 16, style: .continuous))
+                }.buttonStyle(.plain)
+                Spacer(minLength: 12)
+            }
+            .padding(20)
+        }
+        .background(Theme.bg.ignoresSafeArea())
+        .sheet(isPresented: $showLog) {
+            LogEntrySheet(type: "Benchmark", name: benchmark.name, code: nil, level: userLevel, gender: gender,
+                          resultPlaceholder: placeholder).presentationDetents([.medium])
+        }
+    }
+
+    private var testLabel: String {
+        switch benchmark.testType { case "1rm": return "1 Rep Max"; case "max_reps": return "Max Reps"; case "time": return "For Time"; case "amrap": return "AMRAP"; default: return benchmark.testType }
+    }
+    private var placeholder: String {
+        switch benchmark.testType { case "time": return "e.g. 7:30"; case "1rm": return "e.g. 120 kg"; default: return benchmark.unit == "reps" ? "e.g. 12 reps" : "e.g. \(benchmark.unit)" }
+    }
+}

ios/OpenProgression/Features/Benchmarks/BenchmarksView.swift

@@ -1,8 +1,14 @@
 import SwiftUI
 
+private struct SelectedBenchmark: Identifiable {
+    let benchmark: Benchmark; let category: String
+    var id: String { benchmark.movement }
+}
+
 struct BenchmarksView: View {
     @Environment(DataStore.self) private var store
-    @State private var gender: Gender = .male
+    @AppStorage("op.gender") private var gender: Gender = .male
+    @State private var selected: SelectedBenchmark?
 
     private let catOrder = ["squatting","pulling","pressing","olympic_lifting","gymnastics","monostructural","bodyweight","endurance"]
 
@@ -18,12 +24,16 @@ struct BenchmarksView: View {
                 ForEach(catOrder, id: \.self) { catId in
                     if let cat = store.categories.first(where: { $0.id == catId }),
                        let bms = store.benchmarksByCategory[catId] {
-                        VStack(alignment: .leading, spacing: 10) {
+                        VStack(alignment: .leading, spacing: 4) {
                             HStack(spacing: 8) {
                                 Text(cat.icon)
-                                Text(cat.name).font(.system(size: 16, weight: .bold)).foregroundStyle(Theme.text)
+                                Text(cat.name).font(.display(16, .bold)).foregroundStyle(Theme.text)
+                            }.padding(.bottom, 6)
+                            ForEach(bms) { b in
+                                Button { Haptics.tap(); selected = SelectedBenchmark(benchmark: b, category: cat.name) } label: {
+                                    benchmarkRow(b)
+                                }.buttonStyle(.plain)
                             }
-                            ForEach(bms) { b in benchmarkRow(b) }
                         }.frame(maxWidth: .infinity, alignment: .leading).card(padding: 16)
                     }
                 }
@@ -32,29 +42,22 @@ struct BenchmarksView: View {
             .padding(.horizontal, 18).padding(.top, 8)
         }
         .background(Theme.bg.ignoresSafeArea())
+        .sheet(item: $selected) { sel in
+            BenchmarkDetailView(benchmark: sel.benchmark, categoryName: sel.category).presentationDragIndicator(.visible)
+        }
     }
 
     private func benchmarkRow(_ b: Benchmark) -> some View {
-        let rx = b.standards["rx"]?[gender.rawValue]
-        return HStack {
-            Text(b.name).font(.system(size: 14, weight: .medium)).foregroundStyle(Theme.text)
+        HStack {
+            Text(b.name).font(.body(14, .medium)).foregroundStyle(Theme.text)
             Spacer()
             HStack(spacing: 6) {
                 Text("Rx").font(.system(size: 11, weight: .bold)).foregroundStyle(Theme.levelColor(7))
-                Text(rxText(rx, b.unit)).font(.system(size: 14, weight: .semibold)).foregroundStyle(Theme.textDim)
+                Text(benchmarkValueText(b.standards["rx"]?[gender.rawValue], b.unit)).font(.body(14, .semibold)).foregroundStyle(Theme.textDim)
+                Image(systemName: "chevron.right").font(.system(size: 10, weight: .bold)).foregroundStyle(Theme.textFaint)
             }
         }
-        .padding(.vertical, 7)
+        .padding(.vertical, 8)
         .overlay(alignment: .bottom) { Rectangle().fill(Theme.stroke).frame(height: 1) }
     }
-
-    private func rxText(_ v: StandardValue?, _ unit: String) -> String {
-        guard let v else { return "-" }
-        switch v {
-        case .scalar(let d):
-            if unit == "seconds" { let s = Int(d); return String(format: "%d:%02d", s/60, s%60) }
-            return "\(Int(d)) \(unit == "kg" ? "kg" : unit == "rounds" ? "rds" : unit)"
-        case .range(let lo, _): return "\(lo)+ \(unit)"
-        }
-    }
 }

ios/OpenProgression/Features/Log/LogEntrySheet.swift

@@ -0,0 +1,67 @@
+import SwiftUI
+import SwiftData
+
+let levelShort = ["BEG","BEG+","INT","INT+","ADV","ADV+","RX"]
+
+struct LogEntrySheet: View {
+    @Environment(\.modelContext) private var ctx
+    @Environment(\.dismiss) private var dismiss
+    let type: String
+    let name: String
+    let code: String?
+    let level: Int
+    let gender: Gender
+    let resultPlaceholder: String
+    @State private var result = ""
+    @State private var notes = ""
+
+    var body: some View {
+        NavigationStack {
+            ScrollView {
+                VStack(alignment: .leading, spacing: 18) {
+                    VStack(alignment: .leading, spacing: 6) {
+                        SectionLabel(text: "Log \(type)")
+                        Text(name).font(.display(24)).foregroundStyle(Theme.text)
+                        HStack(spacing: 8) {
+                            if let c = code { Chip(text: c, color: Theme.textDim) }
+                            if level >= 1 && level <= 7 { LevelPill(name: levelShort[level-1], number: level) }
+                            Chip(text: gender.rawValue.capitalized, color: Theme.textDim)
+                        }
+                    }
+                    field("Result", placeholder: resultPlaceholder, text: $result)
+                    field("Notes (optional)", placeholder: "How it felt, scaling used...", text: $notes)
+                    Spacer(minLength: 8)
+                }
+                .padding(20)
+            }
+            .background(Theme.bg.ignoresSafeArea())
+            .toolbar {
+                ToolbarItem(placement: .cancellationAction) { Button("Cancel") { dismiss() }.tint(Theme.textDim) }
+                ToolbarItem(placement: .confirmationAction) {
+                    Button("Save") { save() }.bold().disabled(result.trimmingCharacters(in: .whitespaces).isEmpty)
+                }
+            }
+        }
+    }
+
+    private func field(_ label: String, placeholder: String, text: Binding<String>) -> some View {
+        VStack(alignment: .leading, spacing: 8) {
+            SectionLabel(text: label)
+            TextField(placeholder, text: text, axis: label.hasPrefix("Notes") ? .vertical : .horizontal)
+                .lineLimit(label.hasPrefix("Notes") ? 4 : 1)
+                .font(.body(16, .medium)).foregroundStyle(Theme.text)
+                .padding(14)
+                .background(Theme.surface, in: RoundedRectangle(cornerRadius: 14, style: .continuous))
+                .overlay(RoundedRectangle(cornerRadius: 14, style: .continuous).strokeBorder(Theme.stroke))
+        }
+    }
+
+    private func save() {
+        Haptics.tap()
+        let trimmedNotes = notes.trimmingCharacters(in: .whitespacesAndNewlines)
+        ctx.insert(LogEntry(type: type, name: name, code: code, level: level,
+                            gender: gender.rawValue, result: result.trimmingCharacters(in: .whitespaces),
+                            notes: trimmedNotes.isEmpty ? nil : trimmedNotes))
+        dismiss()
+    }
+}

ios/OpenProgression/Features/Log/LogView.swift

@@ -0,0 +1,63 @@
+import SwiftUI
+import SwiftData
+
+struct LogView: View {
+    @Environment(\.modelContext) private var ctx
+    @Query(sort: \LogEntry.date, order: .reverse) private var entries: [LogEntry]
+
+    var body: some View {
+        NavigationStack {
+            Group {
+                if entries.isEmpty { empty } else { list }
+            }
+            .background(Theme.bg.ignoresSafeArea())
+            .navigationTitle("Log")
+            .toolbar {
+                if !entries.isEmpty {
+                    ToolbarItem(placement: .topBarTrailing) {
+                        ShareLink(item: CSV.file(for: entries)) {
+                            Image(systemName: "square.and.arrow.up")
+                        }.tint(Theme.primary)
+                    }
+                }
+            }
+        }
+    }
+
+    private var empty: some View {
+        VStack(spacing: 12) {
+            Image(systemName: "checklist").font(.system(size: 44, weight: .light)).foregroundStyle(Theme.textFaint)
+            Text("No results yet").font(.display(20)).foregroundStyle(Theme.text)
+            Text("Log a workout or a benchmark and it shows up here. Export the whole log to a CSV anytime.")
+                .font(.body(14)).foregroundStyle(Theme.textDim).multilineTextAlignment(.center).padding(.horizontal, 40)
+        }.frame(maxWidth: .infinity, maxHeight: .infinity)
+    }
+
+    private var list: some View {
+        List {
+            ForEach(entries) { e in row(e) }
+                .onDelete { idx in idx.map { entries[$0] }.forEach(ctx.delete) }
+                .listRowBackground(Theme.surface)
+                .listRowSeparatorTint(Theme.stroke)
+        }
+        .listStyle(.plain)
+        .scrollContentBackground(.hidden)
+    }
+
+    private func row(_ e: LogEntry) -> some View {
+        HStack(spacing: 12) {
+            Circle().fill(Theme.levelColor(e.level)).frame(width: 8, height: 8)
+            VStack(alignment: .leading, spacing: 2) {
+                Text(e.name).font(.body(15, .semibold)).foregroundStyle(Theme.text)
+                Text("\(e.type) · \(prettyDate(e.date))\(e.notes.map { " · \($0)" } ?? "")")
+                    .font(.body(12)).foregroundStyle(Theme.textFaint).lineLimit(1)
+            }
+            Spacer()
+            Text(e.result).font(.display(16, .bold)).foregroundStyle(Theme.primary)
+        }.padding(.vertical, 4)
+    }
+
+    private func prettyDate(_ d: Date) -> String {
+        let f = DateFormatter(); f.dateFormat = "MMM d"; return f.string(from: d)
+    }
+}

ios/OpenProgression/Features/Program/ProgramView.swift

@@ -36,6 +36,13 @@ struct ProgramView: View {
             .padding(.horizontal, 18).padding(.top, 8)
         }
         .background(Theme.bg.ignoresSafeArea())
+        .simultaneousGesture(
+            DragGesture(minimumDistance: 24).onEnded { v in
+                guard abs(v.translation.width) > 60, abs(v.translation.width) > abs(v.translation.height) * 1.4 else { return }
+                Haptics.select()
+                withAnimation(.snappy) { shift(v.translation.width < 0 ? 1 : -1) }
+            }
+        )
     }
 
     private var header: some View {