Enforce 2-3 sets/exercise, superset // format, regenerate button, per-week copy

Sets:
- Every exercise gets exactly 2 or 3 sets (never 1, never 4+)
- Simplified selection engine: explicit set counts per exercise type
- Fixed leg extension getting 0 sets (was a math bug in set splitting)

Supersets:
- Display format changed to "Exercise 1 // Exercise 2" with combined
  prescription (3x4-6 / 2x8-10 @3 RIR)
- Applied in web UI, CSV export, and clipboard copy

Regenerate:
- "Regenerate Exercises" button swaps each exercise with a random
  substitute from the same muscle region (same tags + primary muscle)
- Non-substitutable exercises (Leg Extension, Ab Curl Machine, etc.)
  stay locked — only exercises with valid alternatives get swapped
- Substitution groups built from 97-exercise database with region tags

Per-week copy:
- Each week tab now has its own "Copy Week N for Sheets" button
- Copies only that week's data to clipboard (not all weeks)

https://claude.ai/code/session_01Lo7Z7GoRzG6hZkKwrxnXVk

Author: claude

ironforge/engine/__pycache__/selection.cpython-311.pyc

@@ -0,0 +1,61 @@
+"""Exercise substitution groups — exercises that target the same region of the same muscle.
+
+Used by the regenerate feature to swap exercises without changing the program's
+muscle targeting. If a group has only 1 exercise, it's not substitutable.
+"""
+
+from ironforge.data.exercises import ExerciseDefinition, ALL_EXERCISES
+from collections import defaultdict
+
+
+def _region_tags(ex: ExerciseDefinition) -> tuple[str, ...]:
+    """Extract region-identifying tags from an exercise."""
+    REGION_TAGS = {
+        'upper_chest', 'flat_chest', 'press', 'fly',
+        'side_delt', 'rear_delt', 'overhead', 'long_head', 'pushdown',
+        'proximal', 'distal', 'stretch', 'general', 'brachialis',
+        'vertical_pull', 'lat', 'row', 'mid_back', 'lat_emphasis',
+        'squat', 'quad', 'quad_isolator', 'rf',
+        'hamstring', 'curl', 'hinge', 'bflh',
+        'glute', 'calf', 'gastrocnemius',
+    }
+    return tuple(sorted(t for t in ex.tags if t in REGION_TAGS))
+
+
+def _build_groups() -> dict[str, list[ExerciseDefinition]]:
+    """Build substitution groups keyed by (primary_muscle, region_tags)."""
+    groups: dict[tuple, list[ExerciseDefinition]] = defaultdict(list)
+    seen_names: set[str] = set()
+    for ex in ALL_EXERCISES:
+        if ex.name in seen_names:
+            continue
+        seen_names.add(ex.name)
+        key = (ex.primary.name, _region_tags(ex))
+        groups[key].append(ex)
+    # Convert to string keys for JSON-friendliness
+    return {
+        f"{muscle}|{'_'.join(tags) if tags else 'base'}": exercises
+        for (muscle, tags), exercises in groups.items()
+    }
+
+
+SUBSTITUTION_GROUPS = _build_groups()
+
+# Reverse lookup: exercise name → group key
+EXERCISE_TO_GROUP: dict[str, str] = {}
+for group_key, exercises in SUBSTITUTION_GROUPS.items():
+    for ex in exercises:
+        EXERCISE_TO_GROUP[ex.name] = group_key
+
+
+def get_substitutes(exercise_name: str) -> list[ExerciseDefinition]:
+    """Return all exercises that can substitute for the given one (same region)."""
+    group_key = EXERCISE_TO_GROUP.get(exercise_name)
+    if not group_key:
+        return []
+    return [ex for ex in SUBSTITUTION_GROUPS[group_key] if ex.name != exercise_name]
+
+
+def is_substitutable(exercise_name: str) -> bool:
+    """True if the exercise has at least one valid substitute."""
+    return len(get_substitutes(exercise_name)) > 0

ironforge/engine/selection.py

@@ -11,7 +11,36 @@
     build_mesocycle_overview, build_progression_instructions,
     build_deload_instructions,
 )
-from ironforge.program.models import Program, ProgramWeek, ProgramSession
+from ironforge.engine.substitutions import get_substitutes, is_substitutable
+from ironforge.program.models import Program, ProgramWeek, ProgramSession, ProgrammedExercise
+
+import random
+
+
+def _swap_exercises(program: Program, equip: set) -> Program:
+    """Swap each substitutable exercise with a random substitute from the same group."""
+    # Build a swap map: old_name → new ExerciseDefinition (consistent across weeks)
+    swap_map: dict[str, any] = {}
+    for s in program.weeks[0].sessions:
+        for ex in s.exercises:
+            name = ex.exercise.name
+            if name in swap_map:
+                continue
+            if is_substitutable(name):
+                subs = [sub for sub in get_substitutes(name)
+                        if any(eq in equip for eq in sub.equipment)]
+                if subs:
+                    swap_map[name] = random.choice(subs)
+
+    # Apply swaps across all weeks
+    for week in program.weeks:
+        for s in week.sessions:
+            for ex in s.exercises:
+                if ex.exercise.name in swap_map:
+                    new_ex_def = swap_map[ex.exercise.name]
+                    ex.exercise = new_ex_def
+                    ex.notes = new_ex_def.notes or ""
+    return program
 
 
 def build_program(profile: UserProfile) -> Program:
@@ -65,3 +94,9 @@ def build_program(profile: UserProfile) -> Program:
         deload_instructions=deload,
         mesocycle_overview=meso_overview,
     )
+
+
+def build_program_randomized(profile: UserProfile) -> Program:
+    """Build a program then swap exercises for substitutes from the same muscle region."""
+    program = build_program(profile)
+    return _swap_exercises(program, profile.available_equipment)