SugarWOD import: narrow scope to catalog + single-modality, fix barbell-lift rep-scheme bug via set_details

[Yanchek99]

SugarWOD Import: Scope Narrowing + Barbell-Lift Rep-Scheme Fix

Context

The original 11-task SugarWOD CSV import feature (implemented and reviewed on branch
worktree-sugarwod-import) was validated end-to-end against a real 1869-row SugarWOD export.
That run surfaced findings serious enough to change the feature's scope before merge:

1. 96.1% of rows have zero delimiters between exercises in the raw CSV (no bullets, no
   newlines — exercises are literally concatenated, e.g.
   "5 Rounds for Time10 Benchpress 15520 GHD30 cal Ski"). This is a genuine SugarWOD export
   characteristic, not something preprocessing can fix.
2. The general multi-exercise heuristic parser only resolves 5 of 442 currently-"imported"
   rows (93 are catalog matches via NameMatcher, 344 are barbell-lift rows). It does not
   carry its weight relative to the complexity it would take to extend (a tokenizer for
   undelimited text was explored and shelved — see "Out of scope" below).
3. The LLM fallback (WorkoutExtraction::LlmParser) silently drops data. Tested directly
   against a real ambiguous row: it correctly resolved the exercise/rep-count structure but
   dropped a 155 lb Bench Press load entirely — no error, no low-confidence signal, just an
   incomplete Log that looks clean.
4. A confirmed, separate correctness bug in already-reviewed code: BarbellLiftHeader's
   DEFAULT_REPS fallback (hardcoded to 1) produces actively wrong PRs for any
   pyramid/varying rep scheme it doesn't otherwise recognize — 17 of 358 real barbell-lift rows
   (4.75%). E.g. "Deadlift 21-15-15-9-9-9" was recorded as a false "265 lb 1-rep-max Deadlift"
   when the real final set was 9 reps.
5. A previously-unused CSV column, set_details, contains ground-truth per-set data — a
   JSON array of {"success": bool, "load": number} per set, populated in 100% of the 358
   barbell-lift rows in the real export. Once failed attempts ("success": false) are
   excluded, best_result_raw equals max(successful set_details loads) in 358/358 rows
   (100%, verified). This eliminates the need to infer which rep count a load belongs to —
   the data says so directly.

Goal

Narrow the importer to only what can be resolved with high confidence, fix the rep-scheme bug
using set_details as ground truth, and never silently guess, drop, or corrupt data. Lower
overall row coverage vs. attempting everything is an accepted tradeoff.

Scope — what this feature imports

1. Catalog matches (benchmarks, hero WODs, the Open) — unchanged, via NameMatcher.
2. Barbell-lift rows (barbell_lift CSV column populated) — redesigned per below, using
   set_details as the primary data source.
3. New: monostructural distance/time trials — single monostructural movement (row/run/bike/
   ski), fixed-distance-for-time or fixed-time-for-max-distance/calories (e.g. "2k row," "5k
   run"). Narrow shape only — no intervals, no multi-piece pieces.
4. New: bodyweight max-rep tests — single gymnastics/bodyweight movement, unbounded
   max-reps scoring (e.g. "max unbroken pull-ups").
5. Everything else → skipped with a reason. No general multi-exercise heuristic parsing, no
   LLM fallback.

Out of scope (explicitly deferred)

• General multi-exercise custom WOD parsing. A movement-name-anchored tokenizer for
  undelimited text was explored in depth (character-class-transition boundaries + Movement
  catalog anchoring + plausible-value-range disambiguation) and looks technically viable for a
  meaningful chunk of cases, but is shelved given it would only lift the general-heuristic path
  from 5 rows to some larger-but-still-partial number, at real implementation and maintenance
  cost. Revisit only if this feature's real-world coverage proves insufficient.
• CrossFit Games workouts. Not currently seeded in the catalog (unlike benchmarks/hero/Open).
  Adding Games-workout matching would require building db/seeds/games_workouts.rb first — a
  separate, standalone data-entry effort.
• A general cross-cutting "completeness gate" (movement-taxonomy-aware validation applied
  uniformly across every parse path) was considered as a response to the LLM's silent-data-loss
  finding, but since the LLM path is cut entirely in this scope, that motivating case no longer
  applies. Each new/fixed path validates its own completeness inline instead (see below).

Design: barbell-lift rows, redesigned around set_details

Data model split

• Workout = the reusable prescription/template (e.g., "Front Squat, 7 sets: 3-1-3-1-3-1-12
  reps"). Shared/deduped across users doing the same rep-scheme, exactly like today's
  WorkoutFingerprint/absorb_duplicate! mechanism.
• Log + MovementLog = this session's actual performance — the real weights this user
  hit, one MovementLog per set.

Algorithm

1. Parse set_details (JSON array of {success, load}). If missing, blank, or fails to parse,
   fall through past the barbell-lift path (same as today's behavior for a blank barbell_lift
   column) — do not guess.
2. Extract the per-set rep-count scheme from the title/description. This needs to be more
   robust than a simple dash-number regex — real examples include dash-joined numbers
   ("21-15-15-9-9-9"), explicit set breakdowns ("#1: 5 reps #2: 5 reps..."), and
   percentage-based prescriptions ("Set 1: 10 Reps @ 60% 1RM..."). Whatever the extraction
   method, it must produce a rep-count array whose length is validated against
   set_details.length before use.
3. If the extracted scheme's length doesn't match set_details.length, skip the row with a
   clear reason (e.g. "could not align rep scheme with recorded sets") — never guess at
   alignment. (Real testing showed this mismatch is common with ad-hoc extraction — many
   apparent mismatches turned out to be extraction bugs in a throwaway analysis script, not
   genuine data problems, which is exactly why this needs a real validation gate rather than a
   best-effort regex.)
4. Exclude failed attempts ("success": false) from being recorded at all, or at minimum
   from PR/max consideration — a missed lift is not a performance data point. (23 of 358 real
   rows contain at least one failed attempt; naively including them would risk crediting a missed
   lift as a PR.)
5. Build the Workout: one segment containing N separate Exercise records (one per
   successful set), same movement, each with its own prescribed reps from the aligned scheme —
   reusing the existing multi-exercise-line architecture (build_exercise_lines), not the
   single-exercise FIND_MAX/DEFAULT_REPS shortcut.
6. Build the Log: one MovementLog per successful set, each with its own reps (matching
   its Exercise) and load (from set_details, positionally aligned). best_result_raw is
   redundant with max(successful loads) (100% verified) and is not needed as a separate input
   once set_details is available — but should still gate this whole path (blank
   best_result_raw still means "no score recorded," per the existing blank-score guard.

Decision: failed sets are dropped entirely

A failed attempt ("success": false) does not become an Exercise/MovementLog at all — only
successful sets are recorded. Simpler, and zero risk of a missed lift ever being mistaken for a
PR.

New detectors

Both are conservative by construction: if a row doesn't cleanly match the narrow shape, it falls
through to skip — never to a guess, never to the LLM.

• Monostructural: single monostructural movement + a distance or calorie/time target →
  distance/duration-scored exercise, no load.
• Bodyweight max-rep: single gymnastics movement + max-effort language ("max unbroken," "max
  reps") → rep-scored exercise, no load.

Each validates its own completeness inline (monostructural requires distance/duration; bodyweight
requires reps) rather than a shared cross-cutting gate.

Testing

Real CSV examples already gathered anchor the test suite directly:

• The 17 pyramid-scheme rows for the rep-scheme fix ("Deadlift 21-15-15-9-9-9",
  "Back Squat 10-8-6-4-2", etc.)
• The set_details-driven multi-MovementLog behavior ("Front Squat 3-1-3-1-3-1-12" with its
  7-entry set_details array)
• Failed-attempt exclusion ("Power Clean" with a failed 225 lb attempt after a successful 215)
• Length-mismatch skip behavior (a scheme/set_details misalignment case)
• "2K ROW" for the monostructural detector
• Real skip-worthy multi-exercise rows, confirming they're correctly rejected rather than guessed
  at

[Yanchek99]

SugarWOD Import: Scope Narrowing + Barbell-Lift Rep-Scheme Fix Implementation Plan

For agentic workers: REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (- [ ]) syntax for tracking.

Goal: Fix a confirmed rep-count bug in barbell-lift PR imports by using the previously-unused set_details CSV column as ground truth, and narrow the importer's scope to only catalog matches, barbell lifts, and two new single-modality detectors — dropping the general multi-exercise heuristic parser and the LLM fallback for this feature.

Architecture: A new SugarwodImport::SetSchemeExtractor turns set_details + the row's title/description into a validated, per-set {reps:, load:} array (successful sets only, never guessing at alignment). A new SugarwodImport::BarbellLiftBuilder uses that to construct a Workout directly (bypassing text-synthesis-then-reparse entirely) — one segment with N Exercise records, matching the app's existing variable_set_based_lifting_structure? shape. RowImporter is rewired to build one MovementLog per successful set (reusing the existing Log#build_movement_logs), gains two new narrow single-modality detector stages, and loses its general-heuristic/LLM fallback stage entirely.

Tech Stack: Ruby on Rails 8.1, PostgreSQL, Minitest with fixtures — same as the rest of the app.

Global Constraints

• SugarwodImport is a model class (class SugarwodImport < ApplicationRecord). Every SugarwodImport::* service is class SugarwodImport; class Foo; ...; end; end (reopening the class as a namespace) — never module SugarwodImport.
• CfWod::WorkoutFormatClassifier and CfWod::WorkoutParser are not exclusive to this feature — app/jobs/scrape_cf_wod_job.rb also calls CfWod::WorkoutParser.call. None of Task 2's prior classifier additions (FIND_MAX, EMOM_SHORT, ON_THE_CLOCK_ROUNDS, PLAIN_ROUNDS) or the final-review's regex fixes to them get touched or removed by this plan — they remain live, correct, shared infrastructure for that other job, even though this feature's own cascade will no longer reach them.
• LoadEquivalence.to_lb(value, unit) is the only correct way to canonicalize a load into pounds — never reimplement kg/pood conversion.
• No RuboCop Exclude additions for production code — restructure instead.
• RVM/Bundler environment note for every Ruby command in this worktree:

  export PATH="$HOME/.rvm/rubies/ruby-4.0.5/bin:$HOME/.rvm/gems/ruby-4.0.5@wod-tracker/bin:$PATH"
  export GEM_HOME="$HOME/.rvm/gems/ruby-4.0.5@wod-tracker"
  export GEM_PATH="$HOME/.rvm/gems/ruby-4.0.5@wod-tracker:$HOME/.rvm/gems/ruby-4.0.5@global"

• Working directory: /Users/matthewyanchek/Repositories/GitHub/wod-tracker/.claude/worktrees/sugarwod-import, branch worktree-sugarwod-import. Not merged/pushed anywhere — safe to revise directly.

---

File Structure

File	Responsibility
app/services/sugarwod_import/set_scheme_extractor.rb (new)	Pure data transformation: set_details JSON + title/description → validated per-set {reps:, load:} array, successful sets only, or nil if unresolvable. No Rails models.
app/services/sugarwod_import/barbell_lift_builder.rb (new)	Uses SetSchemeExtractor + MovementLookup to build (unsaved) a Workout with one segment and N Exercise records. Replaces BarbellLiftHeader.
app/services/sugarwod_import/barbell_lift_header.rb (delete)	Superseded by BarbellLiftBuilder — text-synthesis-then-reparse is no longer how barbell-lift rows are built.
app/services/sugarwod_import/monostructural_detector.rb (new)	Single monostructural movement + fixed-distance-for-time or fixed-time-for-max-distance/calories → builds a Workout with one Exercise.
app/services/sugarwod_import/bodyweight_max_rep_detector.rb (new)	Single gymnastics movement + max-effort language → builds a Workout with one Exercise, rep-scored, no load.
app/services/sugarwod_import/row_importer.rb (modify)	Cascade becomes NameMatcher → BarbellLiftBuilder → MonostructuralDetector → BodyweightMaxRepDetector → skip. create_log builds one MovementLog per successful set via Log#build_movement_logs, not the old single-MovementLog guard.
test/services/sugarwod_import/set_scheme_extractor_test.rb (new)
test/services/sugarwod_import/barbell_lift_builder_test.rb (new)
test/services/sugarwod_import/barbell_lift_header_test.rb (delete)
test/services/sugarwod_import/monostructural_detector_test.rb (new)
test/services/sugarwod_import/bodyweight_max_rep_detector_test.rb (new)
test/services/sugarwod_import/row_importer_test.rb (modify)

---

Task 1: SugarwodImport::SetSchemeExtractor

Files:

• Create: app/services/sugarwod_import/set_scheme_extractor.rb
• Test: test/services/sugarwod_import/set_scheme_extractor_test.rb
• Modify: test/services/sugarwod_import/csv_parser_test.rb (regression guard, no production code change — see Step 0)

Interfaces:

• Produces: SugarwodImport::SetSchemeExtractor.call(row) # => [{ reps: Integer, load: Integer }, ...] | nil

  • row is a symbol-keyed hash with :title, :description, :set_details (a JSON string).
  • Returns nil when set_details is missing/blank/unparseable, when every set failed, when a numeric dash-scheme's length doesn't match set_details's length, or when no scheme can be determined for more than one set.
  • Never includes an entry for a failed ("success": false) set.

• Step 0: Add a regression test confirming set_details already passes through CsvParser

SugarwodImport::CsvParser#parse calls CSV.parse(..., headers: true) and table.map(&:to_h), which exposes every column present in the file — not just REQUIRED_HEADERS. set_details is already in the real CSV's header row and will already flow through with no code change, but this has never been asserted directly. Add the assertion now so a future change to CsvParser (e.g. switching to an explicit column allowlist) can't silently drop it without a test noticing:

# test/services/sugarwod_import/csv_parser_test.rb -- add this test to the existing file
    test 'exposes the set_details column for barbell-lift rows' do
      csv = "date,title,description,best_result_raw,best_result_display,score_type,barbell_lift,set_details,notes\n" \
            "01/02/2018,Deadlift,,315,315,Load,Deadlift,\"[{\"\"success\"\":true,\"\"load\"\":315}]\",\n"

      rows = CsvParser.call(csv)

      assert_equal '[{"success":true,"load":315}]', rows.first['set_details']
    end

Run bin/rails test test/services/sugarwod_import/csv_parser_test.rb — expect it to PASS immediately (no production code change needed). Commit this alongside Task 1's other changes.

• Step 1: Write the failing tests

# test/services/sugarwod_import/set_scheme_extractor_test.rb
require 'test_helper'

class SugarwodImport
  class SetSchemeExtractorTest < ActiveSupport::TestCase
    test 'extracts a varying pyramid scheme, matching each rep count to its set position' do
      row = { title: 'Front Squat 3-1-3-1-3-1-12', description: '',
              set_details: '[{"success":true,"load":155},{"success":true,"load":165},{"success":true,"load":155},' \
                            '{"success":true,"load":175},{"success":true,"load":155},{"success":true,"load":185},' \
                            '{"success":true,"load":125}]' }

      result = SetSchemeExtractor.call(row)

      assert_equal [{ reps: 3, load: 155 }, { reps: 1, load: 165 }, { reps: 3, load: 155 }, { reps: 1, load: 175 },
                    { reps: 3, load: 155 }, { reps: 1, load: 185 }, { reps: 12, load: 125 }], result
    end

    test 'drops failed sets and keeps positional alignment with the successful ones' do
      row = { title: 'Power Clean 1-1-1-1-1', description: '',
              set_details: '[{"success":true,"load":175},{"success":true,"load":185},{"success":true,"load":205},' \
                            '{"success":true,"load":215},{"success":false,"load":225}]' }

      result = SetSchemeExtractor.call(row)

      assert_equal [{ reps: 1, load: 175 }, { reps: 1, load: 185 }, { reps: 1, load: 205 }, { reps: 1, load: 215 }],
                   result
    end

    test 'applies a uniform "AxB" title scheme to every set when the set count matches A' do
      row = { title: 'Back Squat 3x5', description: 'Back Squat for load: #1: 5 reps #2: 5 reps #3: 5 reps',
              set_details: '[{"success":true,"load":200},{"success":true,"load":205},{"success":true,"load":205}]' }

      result = SetSchemeExtractor.call(row)

      assert_equal [{ reps: 5, load: 200 }, { reps: 5, load: 205 }, { reps: 5, load: 205 }], result
    end

    test 'applies a uniform "Set of N" description scheme to every successful set' do
      row = { title: 'Bench Press', description: 'Build to Heavy Set of 3',
              set_details: '[{"success":true,"load":150},{"success":true,"load":165}]' }

      result = SetSchemeExtractor.call(row)

      assert_equal [{ reps: 3, load: 150 }, { reps: 3, load: 165 }], result
    end

    test 'defaults to 1 rep only when there is exactly one successful set and no scheme text' do
      row = { title: 'Deadlift', description: 'Build to a heavy deadlift for the day',
              set_details: '[{"success":true,"load":315}]' }

      result = SetSchemeExtractor.call(row)

      assert_equal [{ reps: 1, load: 315 }], result
    end

    test 'returns nil rather than defaulting to 1 rep for multiple sets with no recognizable scheme' do
      row = { title: 'Deadlift', description: 'Build to a heavy deadlift for the day',
              set_details: '[{"success":true,"load":275},{"success":true,"load":315}]' }

      assert_nil SetSchemeExtractor.call(row)
    end

    test 'returns nil when the dash-scheme length does not match set_details length' do
      row = { title: 'Bench Press 4-2-4-2-4', description: '',
              set_details: '[{"success":true,"load":155},{"success":true,"load":185},{"success":true,"load":155},' \
                            '{"success":true,"load":195},{"success":true,"load":155},{"success":true,"load":205}]' }

      assert_nil SetSchemeExtractor.call(row)
    end

    test 'returns nil when set_details is blank' do
      assert_nil SetSchemeExtractor.call({ title: 'Deadlift', description: '', set_details: '' })
      assert_nil SetSchemeExtractor.call({ title: 'Deadlift', description: '', set_details: nil })
    end

    test 'returns nil when set_details fails to parse as JSON' do
      assert_nil SetSchemeExtractor.call({ title: 'Deadlift', description: '', set_details: 'not json' })
    end

    test 'returns nil when every set failed' do
      row = { title: 'Deadlift', description: '', set_details: '[{"success":false,"load":315}]' }

      assert_nil SetSchemeExtractor.call(row)
    end

    test 'does not mistake a non-numeric dash phrase in a movement name for a rep scheme' do
      row = { title: '3-Position Power Snatch', description: 'Build to a heavy single',
              set_details: '[{"success":true,"load":135}]' }

      result = SetSchemeExtractor.call(row)

      assert_equal [{ reps: 1, load: 135 }], result
    end
  end
end

• Step 2: Run tests to verify they fail

Run: bin/rails test test/services/sugarwod_import/set_scheme_extractor_test.rb
Expected: FAIL with NameError: uninitialized constant SugarwodImport::SetSchemeExtractor

• Step 3: Implement

# app/services/sugarwod_import/set_scheme_extractor.rb
require 'json'

class SugarwodImport
  class SetSchemeExtractor
    DASH_SCHEME = /\b(\d+(?:-\d+){2,})\b/
    AXB_SCHEME = /(\d+)\s*x\s*(\d+)\z/i
    SET_OF_N = /set of (\d+)/i
    SINGLE = /single\b/i

    def self.call(row) = new(row).extract

    def initialize(row)
      @row = row
    end

    def extract
      return nil if successful_details.blank?

      scheme = rep_scheme
      return nil unless scheme && scheme.size == details.size

      scheme.zip(details).filter_map do |reps, detail|
        next if detail['success'] == false

        { reps: reps, load: detail['load'].to_s.to_i }
      end
    end

    private

    attr_reader :row

    def details
      @details ||= begin
        JSON.parse(row[:set_details].to_s)
      rescue JSON::ParserError
        []
      end
    end

    def successful_details
      details.reject { |detail| detail['success'] == false }
    end

    def rep_scheme
      dash_scheme || axb_scheme || set_of_n_scheme || single_scheme || default_single_set_scheme
    end

    def dash_scheme
      match = scheme_source.match(DASH_SCHEME)
      match && match[1].split('-').map(&:to_i)
    end

    def axb_scheme
      match = row[:title].to_s.strip.match(AXB_SCHEME)
      return nil unless match

      sets, reps = match.captures.map(&:to_i)
      Array.new(sets, reps) if sets == details.size
    end

    def set_of_n_scheme
      match = row[:description].to_s.match(SET_OF_N)
      Array.new(details.size, match[1].to_i) if match
    end

    def single_scheme
      Array.new(details.size, 1) if row[:description].to_s.match?(SINGLE)
    end

    def default_single_set_scheme
      [1] if details.size == 1
    end

    def scheme_source
      "#{row[:title]} #{row[:description]}"
    end
  end
end

• Step 4: Run tests to verify they pass

Run: bin/rails test test/services/sugarwod_import/set_scheme_extractor_test.rb
Expected: PASS (11 examples)

• Step 5: Run RuboCop

Run: bin/rubocop app/services/sugarwod_import/set_scheme_extractor.rb test/services/sugarwod_import/set_scheme_extractor_test.rb --parallel
Expected: no offenses

• Step 6: Commit

git add app/services/sugarwod_import/set_scheme_extractor.rb test/services/sugarwod_import/set_scheme_extractor_test.rb \
  test/services/sugarwod_import/csv_parser_test.rb
git commit -m "Add SugarwodImport::SetSchemeExtractor to derive per-set reps/load from set_details"

---

Task 2: SugarwodImport::BarbellLiftBuilder

Files:

• Create: app/services/sugarwod_import/barbell_lift_builder.rb
• Delete: app/services/sugarwod_import/barbell_lift_header.rb
• Delete: test/services/sugarwod_import/barbell_lift_header_test.rb
• Test: test/services/sugarwod_import/barbell_lift_builder_test.rb

Interfaces:

• Consumes: SugarwodImport::SetSchemeExtractor.call(row) (Task 1), CfWod::MovementLookup.call(name) (existing, returns a Movement or nil).

• Produces: SugarwodImport::BarbellLiftBuilder.call(row) # => Workout | nil

  • Returns nil when row[:barbell_lift] is blank, the movement isn't in the catalog, or SetSchemeExtractor returns nil.
  • The returned Workout is unsaved, score_type: :weight, with one segment (no rounds/time_seconds/interval_scheme) containing one Exercise per entry from SetSchemeExtractor, each with movement:, position:, reps: set and load: nil (load lives on the MovementLog, not the prescription — see Task 3).

• Step 1: Write the failing tests

# test/services/sugarwod_import/barbell_lift_builder_test.rb
require 'test_helper'

class SugarwodImport
  class BarbellLiftBuilderTest < ActiveSupport::TestCase
    test 'builds one segment with N exercises for a varying pyramid scheme' do
      row = { title: 'Front Squat 3-1-3-1-3-1-12', description: '', barbell_lift: 'Front Squat',
              set_details: '[{"success":true,"load":155},{"success":true,"load":165},{"success":true,"load":155},' \
                            '{"success":true,"load":175},{"success":true,"load":155},{"success":true,"load":185},' \
                            '{"success":true,"load":125}]' }

      workout = BarbellLiftBuilder.call(row)

      assert_equal 'weight', workout.score_type
      segment = workout.segments.sole
      assert_nil segment.rounds
      assert_nil segment.time_seconds
      exercises = segment.exercises
      assert_equal 7, exercises.size
      assert_equal [3, 1, 3, 1, 3, 1, 12], exercises.map(&:reps)
      assert exercises.all? { |exercise| exercise.movement == movements(:front_squat) }
      assert exercises.all? { |exercise| exercise.load.nil? }
    end

    test 'builds a single exercise for a simple heavy-single lift' do
      row = { title: 'Deadlift', description: 'Build to a heavy deadlift for the day', barbell_lift: 'Deadlift',
              set_details: '[{"success":true,"load":315}]' }

      workout = BarbellLiftBuilder.call(row)

      exercise = workout.segments.sole.exercises.sole
      assert_equal 1, exercise.reps
      assert_equal movements(:deadlift), exercise.movement
    end

    test 'returns nil when barbell_lift is blank' do
      row = { title: 'Deadlift', description: '', barbell_lift: '', set_details: '[{"success":true,"load":315}]' }

      assert_nil BarbellLiftBuilder.call(row)
    end

    test 'returns nil when the barbell_lift name is not in the movement catalog' do
      row = { title: 'Nonexistent Lift', description: '', barbell_lift: 'Nonexistent Lift',
              set_details: '[{"success":true,"load":100}]' }

      assert_nil BarbellLiftBuilder.call(row)
    end

    test 'returns nil when SetSchemeExtractor cannot resolve the row' do
      row = { title: 'Deadlift', description: 'Build to a heavy deadlift for the day', barbell_lift: 'Deadlift',
              set_details: '[{"success":true,"load":275},{"success":true,"load":315}]' }

      assert_nil BarbellLiftBuilder.call(row)
    end
  end
end

• Step 2: Run tests to verify they fail

Run: bin/rails test test/services/sugarwod_import/barbell_lift_builder_test.rb
Expected: FAIL with NameError: uninitialized constant SugarwodImport::BarbellLiftBuilder

• Step 3: Delete the superseded files

git rm app/services/sugarwod_import/barbell_lift_header.rb test/services/sugarwod_import/barbell_lift_header_test.rb

• Step 4: Implement

# app/services/sugarwod_import/barbell_lift_builder.rb
class SugarwodImport
  class BarbellLiftBuilder
    def self.call(row) = new(row).build

    def initialize(row)
      @row = row
    end

    def build
      return nil if row[:barbell_lift].blank?

      movement = CfWod::MovementLookup.call(row[:barbell_lift])
      return nil unless movement

      sets = SetSchemeExtractor.call(row)
      return nil unless sets

      build_workout(movement, sets)
    end

    private

    attr_reader :row

    def build_workout(movement, sets)
      name = "#{movement.name} #{sets.map { |set| set[:reps] }.join('-')}"
      workout = Workout.new(score_type: :weight, name: name)
      segment = workout.segments.build(position: 1)
      sets.each_with_index do |set, index|
        segment.exercises.build(movement: movement, position: index + 1, reps: set[:reps])
      end
      workout
    end
  end
end

• Step 5: Run tests to verify they pass

Run: bin/rails test test/services/sugarwod_import/barbell_lift_builder_test.rb
Expected: PASS (5 examples)

• Step 6: Run RuboCop

Run: bin/rubocop app/services/sugarwod_import/barbell_lift_builder.rb test/services/sugarwod_import/barbell_lift_builder_test.rb --parallel
Expected: no offenses

• Step 7: Commit

git add -A app/services/sugarwod_import/barbell_lift_builder.rb app/services/sugarwod_import/barbell_lift_header.rb \
  test/services/sugarwod_import/barbell_lift_builder_test.rb test/services/sugarwod_import/barbell_lift_header_test.rb
git commit -m "Replace BarbellLiftHeader with BarbellLiftBuilder, building exercises directly from set_details"

---

Task 3: Rewire RowImporter — barbell-lift path, per-set MovementLogs, drop the general/LLM fallback

Files:

• Modify: app/services/sugarwod_import/row_importer.rb
• Test: test/services/sugarwod_import/row_importer_test.rb

Interfaces:

• Consumes: SugarwodImport::BarbellLiftBuilder.call(row) (Task 2), Log#build_movement_logs (existing — builds one MovementLog per workout.exercises_for_log_recording entry, in order, with default/blank performance values).

• Produces: unchanged public interface — SugarwodImport::RowImporter.call(row, user:) # => Result(status:, reason:).

• Step 1: Write the failing/updated tests

Replace the file's contents. Two existing tests change behavior (barbell-lift now records every set, and the unrecognized-lift-name row now skips instead of falling through to a heuristic parse that no longer exists); the general-heuristic and LLM tests are removed since that stage is gone.

# test/services/sugarwod_import/row_importer_test.rb
require 'test_helper'

class SugarwodImport
  class RowImporterTest < ActiveSupport::TestCase
    setup { @user = users(:mathew) }

    test 'matches an existing catalog workout by name and creates a Log' do
      row = { date: Date.new(2018, 1, 2), title: 'Fran', description: '21-15-9 reps for time of:• Thruster 95/65#• Pull-ups',
              best_result_raw: '378', best_result_display: '6:18', score_type: '', barbell_lift: nil, notes: 'felt strong' }

      result = RowImporter.call(row, user: @user)

      assert_equal :imported, result.status
      log = @user.logs.find_by!(workout: workouts(:fran))
      assert_equal 378, log.score_value
      assert_equal 'felt strong', log.notes
      assert_equal Date.new(2018, 1, 2), log.created_at.to_date
    end

    test 'builds a single-exercise workout and one PR-tracking MovementLog for a simple barbell-lift row' do
      row = { date: Date.new(2020, 2, 10), title: 'Back Squat', description: 'Build to Heavy Single',
              best_result_raw: '205', best_result_display: '205', score_type: 'Load', barbell_lift: 'Back Squat',
              set_details: '[{"success":true,"load":205}]', notes: nil }

      result = RowImporter.call(row, user: @user)

      assert_equal :imported, result.status
      log = @user.logs.last
      assert_equal 205, log.score_value
      exercise = log.workout.exercises_for_log_recording.sole
      assert_equal 1, exercise.reps
      assert_equal movements(:back_squat), exercise.movement
      movement_log = log.movement_logs.sole
      assert_equal movements(:back_squat), movement_log.movement
      assert_equal 205, movement_log.load
    end

    test 'builds one MovementLog per successful set for a varying pyramid scheme' do
      row = { date: Date.new(2020, 2, 11), title: 'Front Squat 3-1-3-1-3-1-12', description: '',
              best_result_raw: '185', best_result_display: '185', score_type: 'Load', barbell_lift: 'Front Squat',
              set_details: '[{"success":true,"load":155},{"success":true,"load":165},{"success":true,"load":155},' \
                            '{"success":true,"load":175},{"success":true,"load":155},{"success":true,"load":185},' \
                            '{"success":true,"load":125}]', notes: nil }

      result = RowImporter.call(row, user: @user)

      assert_equal :imported, result.status
      log = @user.logs.last
      assert_equal 185, log.score_value
      assert_equal 7, log.movement_logs.size
      assert_equal [3, 1, 3, 1, 3, 1, 12], log.movement_logs.map(&:reps)
      assert_equal [155, 165, 155, 175, 155, 185, 125], log.movement_logs.map(&:load)
    end

    test 'excludes a failed attempt from the recorded MovementLogs' do
      row = { date: Date.new(2020, 2, 12), title: 'Power Clean 1-1-1-1-1', description: '',
              best_result_raw: '215', best_result_display: '215', score_type: 'Load', barbell_lift: 'Power Clean',
              set_details: '[{"success":true,"load":175},{"success":true,"load":185},{"success":true,"load":205},' \
                            '{"success":true,"load":215},{"success":false,"load":225}]', notes: nil }

      result = RowImporter.call(row, user: @user)

      assert_equal :imported, result.status
      log = @user.logs.last
      assert_equal 215, log.score_value
      assert_equal 4, log.movement_logs.size
      assert_not_includes log.movement_logs.map(&:load), 225
    end

    test 'skips a barbell-lift row when the rep scheme cannot be aligned with set_details' do
      row = { date: Date.new(2020, 2, 13), title: 'Bench Press 4-2-4-2-4', description: '',
              best_result_raw: '205', best_result_display: '205', score_type: 'Load', barbell_lift: 'Bench Press',
              set_details: '[{"success":true,"load":155},{"success":true,"load":185},{"success":true,"load":155},' \
                            '{"success":true,"load":195},{"success":true,"load":155},{"success":true,"load":205}]',
              notes: nil }

      result = RowImporter.call(row, user: @user)

      assert_equal :skipped, result.status
    end

    test 'skips the PR-tracking MovementLogs for a weight-scored workout that totals more than one exercise' do
      row = { date: Date.new(2020, 4, 1), title: 'Total Test', description: 'For load:•Back Squat•Deadlift',
              best_result_raw: '500', best_result_display: '500', score_type: 'Load', barbell_lift: nil, notes: nil }

      result = RowImporter.call(row, user: @user)

      assert_equal :skipped, result.status
    end

    test 'skips a row with an unrecognized barbell_lift movement name' do
      row = { date: Date.new(2020, 5, 2), title: 'Some Lift', description: '', barbell_lift: 'Nonexistent Lift',
              best_result_raw: '600', score_type: 'Load', set_details: '[{"success":true,"load":600}]' }

      result = RowImporter.call(row, user: @user)

      assert_equal :skipped, result.status
    end

    test 'skips a row with a disregarded score_type without attempting to parse it' do
      row = { date: Date.new(2020, 1, 1), title: 'Daily Check-in', description: 'Did you stretch today?',
              best_result_raw: '1', best_result_display: 'Yes', score_type: 'Checkbox', barbell_lift: nil, notes: nil }

      result = RowImporter.call(row, user: @user)

      assert_equal :skipped, result.status
      assert_equal 'not a workout score type', result.reason
    end

    test 'skips a row with a blank best_result_raw without creating a Log' do
      row = { date: Date.new(2020, 6, 1), title: 'Fran', best_result_raw: '' }
      result = RowImporter.call(row, user: @user)

      assert_equal :skipped, result.status
      assert_equal 'no score recorded', result.reason
      assert_not @user.logs.exists?(workout: workouts(:fran))
    end

    test 'skips a row that matches no catalog workout, barbell lift, or single-modality shape' do
      row = { date: Date.new(2020, 3, 1), title: 'Row Burpee Chipper', description: 'For time:•50 Calorie Row•50 Push-ups',
              best_result_raw: '600', best_result_display: '10:00', score_type: '', barbell_lift: nil, notes: nil }

      result = RowImporter.call(row, user: @user)

      assert_equal :skipped, result.status
    end

    test 'is idempotent: re-importing the same user/workout/date does not create a duplicate Log' do
      row = { date: Date.new(2018, 1, 2), title: 'Fran', description: '21-15-9 reps for time of:• Thruster 95/65#• Pull-ups',
              best_result_raw: '378', best_result_display: '6:18', score_type: '', barbell_lift: nil, notes: nil }

      RowImporter.call(row, user: @user)
      result = RowImporter.call(row, user: @user)

      assert_equal :already_imported, result.status
      assert_equal 1, @user.logs.where(workout: workouts(:fran)).count
    end
  end
end

• Step 2: Run tests to verify the new/changed ones fail

Run: bin/rails test test/services/sugarwod_import/row_importer_test.rb
Expected: FAIL — build_movement_log/single_weight_exercise? still exist and don't build multiple MovementLogs; build_from_heuristic_or_llm is still reachable so the "matches no catalog workout..." test won't skip yet.

• Step 3: Implement

# app/services/sugarwod_import/row_importer.rb
class SugarwodImport
  class RowImporter
    DISREGARD_SCORE_TYPES = ['Checkbox', 'Points', 'Emoji Selection', 'Other / Text'].freeze

    Result = Struct.new(:status, :reason, keyword_init: true)

    def self.call(row, user:) = new(row, user: user).import

    def initialize(row, user:)
      @row = row
      @user = user
    end

    def import
      return Result.new(status: :skipped, reason: 'not a workout score type') if disregard?
      return Result.new(status: :skipped, reason: 'no score recorded') if row[:best_result_raw].blank?

      workout = resolve_workout
      return Result.new(status: :skipped, reason: 'not a benchmark, barbell-lift, or single-modality workout') unless workout

      ActiveRecord::Base.transaction { create_log(workout) }
    rescue ActiveRecord::ActiveRecordError => e
      Result.new(status: :skipped, reason: e.message)
    end

    private

    attr_reader :row, :user

    def disregard?
      DISREGARD_SCORE_TYPES.include?(row[:score_type].to_s.strip)
    end

    def resolve_workout
      NameMatcher.call(row[:title]) || build_from_barbell_lift || build_from_monostructural || build_from_bodyweight_max_rep
    end

    def build_from_barbell_lift
      persist(BarbellLiftBuilder.call(row))
    end

    def build_from_monostructural
      persist(MonostructuralDetector.call(row))
    end

    def build_from_bodyweight_max_rep
      persist(BodyweightMaxRepDetector.call(row))
    end

    def persist(workout)
      return nil unless workout
      return workout if workout.persisted?

      workout.save!
      workout.absorb_duplicate!
    end

    def create_log(workout)
      return Result.new(status: :already_imported) if existing_log?(workout)

      log = workout.logs.build(ScoreMapper.call(workout, row, user: user).merge(user: user))
      log.created_at = row[:date]
      build_movement_logs(workout, log)
      log.save!
      Result.new(status: :imported)
    end

    def existing_log?(workout)
      user.logs.where(workout: workout).exists?(created_at: row[:date].all_day)
    end

    # Weight-scored workouts that total more than one DISTINCT movement (e.g. "CrossFit Total" =
    # back squat + shoulder press + deadlift, summed) represent a combined total. Building
    # MovementLogs from a single row's data would misattribute that total to the wrong movement,
    # so those are skipped. A single-movement workout, whether one exercise (a simple heavy
    # single) or many (a pyramid scheme, all the same movement), is safe to build per-set.
    def build_movement_logs(workout, log)
      exercises = workout.exercises_for_log_recording
      return unless workout.score_weight? && exercises.present? && exercises.map(&:movement).uniq.one?

      log.build_movement_logs
      assign_set_loads(log)
    end

    def assign_set_loads(log)
      sets = SetSchemeExtractor.call(row)
      return unless sets

      log.movement_logs.zip(sets).each do |movement_log, set|
        movement_log.load = LoadEquivalence.to_lb(set[:load], user.load_display_unit.to_s)
      end
    end
  end
end

Why exercises.map(&:movement).uniq.one? and not exercises.one?: a simple heavy-single lift has exactly one exercise, so both checks agree. A pyramid scheme has N exercises but they all share one movement (by construction — BarbellLiftBuilder never builds mixed-movement workouts) — exercises.one? would wrongly be false and skip building any MovementLogs for it, while exercises.map(&:movement).uniq.one? correctly stays true. A multi-movement catalog total (e.g. the existing "Total Test" fixture: Back Squat + Deadlift) has 2+ distinct movements, so uniq.one? is correctly false there, matching the original guard's intent for that case.

• Step 4: Run tests to verify they still fail on the missing detectors

Run: bin/rails test test/services/sugarwod_import/row_importer_test.rb
Expected: FAIL with NameError: uninitialized constant SugarwodImport::MonostructuralDetector (and BodyweightMaxRepDetector) — expected, since Tasks 4–5 haven't landed yet. Confirm every other test (catalog match, simple barbell-lift, pyramid, failed-set exclusion, length-mismatch skip, multi-exercise skip, unrecognized-lift skip, disregard, blank-score, idempotent) passes on its own by temporarily stubbing the two missing detector calls to return nil:

# Temporary, for this step only -- delete once Tasks 4-5 land
class SugarwodImport
  class MonostructuralDetector
    def self.call(_row) = nil
  end

  class BodyweightMaxRepDetector
    def self.call(_row) = nil
  end
end

Add that block temporarily to the top of row_importer_test.rb, run the suite, confirm every test except any depending on the two new detectors passes, then remove the temporary stub before committing (Task 3 doesn't ship the real detectors — Tasks 4–5 do).

• Step 5: Verify exercises_for_log_recording really returns all N pyramid exercises

Before trusting Step 3, confirm directly against the app's own logic (app/models/concerns/workout_scoring.rb's variable_set_based_lifting_structure?, which requires: a governing_segment that is not schemed? and has rounds blank, exercises.many?, and every exercise sharing the same movement with a positive reps). BarbellLiftBuilder's segment has no rounds/time_seconds/interval_scheme and every exercise shares one movement with positive reps — so this should already hold. Confirm with a focused check:

bin/rails runner -e test '
w = Workout.new(score_type: :weight, name: 'Runner Check')
seg = w.segments.build(position: 1)
m = Movement.first
[3,1,3,1,3,1,12].each_with_index { |r, i| seg.exercises.build(movement: m, position: i+1, reps: r) }
w.save!
puts w.exercises_for_log_recording.size
'

Expected output: 7. If it prints 1 instead, variable_set_based_lifting_structure?'s conditions aren't being met — stop and re-examine governing_segment/schemed? before proceeding (do not silently work around it).

• Step 6: Remove the temporary detector stub, run the full file once more

Confirm it now fails only on the two NameErrors from the real (not-yet-built) detectors, then proceed to Tasks 4–5 which resolve those.

• Step 7: Run RuboCop on the changed file

Run: bin/rubocop app/services/sugarwod_import/row_importer.rb test/services/sugarwod_import/row_importer_test.rb --parallel
Expected: no offenses

• Step 8: Commit

git add app/services/sugarwod_import/row_importer.rb test/services/sugarwod_import/row_importer_test.rb
git commit -m "Rewire RowImporter: per-set MovementLogs via set_details, drop the general heuristic/LLM stage"

---

Task 4: SugarwodImport::MonostructuralDetector

Files:

• Create: app/services/sugarwod_import/monostructural_detector.rb
• Test: test/services/sugarwod_import/monostructural_detector_test.rb

Interfaces:

• Consumes: CfWod::MovementLookup.call(name) (existing).

• Produces: SugarwodImport::MonostructuralDetector.call(row) # => Workout | nil

  • Recognizes exactly two narrow shapes in row[:description] (after the movement name is identified via row[:title] or a single monostructural movement name found in the description): a fixed distance for time (e.g. "2000 Meter Row", "5k Run"), or a fixed time for max distance/calories (e.g. "12 Minute Max Calorie Row"). Anything else returns nil.
  • The movement must resolve to a Movement with family_monostructural?. Multiple distinct movements mentioned anywhere in the row → nil (never guess which one is intended).

• Step 1: Write the failing tests

# test/services/sugarwod_import/monostructural_detector_test.rb
require 'test_helper'

class SugarwodImport
  class MonostructuralDetectorTest < ActiveSupport::TestCase
    test 'builds a fixed-distance-for-time workout from a meter distance' do
      row = { title: '2K ROW', description: 'For Time: 2,000 Meter Row', barbell_lift: nil }

      workout = MonostructuralDetector.call(row)

      assert_equal 'time', workout.score_type
      exercise = workout.segments.sole.exercises.sole
      assert_equal movements(:row), exercise.movement
      assert_equal 2000, exercise.distance
      assert_equal 'meter', exercise.distance_unit
    end

    test 'builds a fixed-distance-for-time workout from a "5k" shorthand' do
      row = { title: '5K Run', description: 'For Time: 5k Run', barbell_lift: nil }

      workout = MonostructuralDetector.call(row)

      exercise = workout.segments.sole.exercises.sole
      assert_equal movements(:run), exercise.movement
      assert_equal 5000, exercise.distance
      assert_equal 'meter', exercise.distance_unit
    end

    test 'builds a fixed-time-for-max-calories workout' do
      row = { title: 'Max Cal Row', description: '12 Minute Max Calorie Row', barbell_lift: nil }

      workout = MonostructuralDetector.call(row)

      assert_equal 'calorie', workout.score_type
      exercise = workout.segments.sole.exercises.sole
      assert_equal movements(:row), exercise.movement
      assert_equal 720, exercise.duration_seconds
    end

    test 'returns nil when more than one movement is mentioned' do
      row = { title: 'Row Run', description: 'For Time: 500 Meter Row then 400 Meter Run', barbell_lift: nil }

      assert_nil MonostructuralDetector.call(row)
    end

    test 'returns nil when the movement is not monostructural' do
      row = { title: 'Squats for time', description: 'For Time: 50 Air Squats', barbell_lift: nil }

      assert_nil MonostructuralDetector.call(row)
    end

    test 'returns nil for a description that does not match either narrow shape' do
      row = { title: 'Intervals', description: '5 rounds: 250 Meter Row, rest 2:00 between rounds', barbell_lift: nil }

      assert_nil MonostructuralDetector.call(row)
    end
  end
end

• Step 2: Run tests to verify they fail

Run: bin/rails test test/services/sugarwod_import/monostructural_detector_test.rb
Expected: FAIL with NameError: uninitialized constant SugarwodImport::MonostructuralDetector

• Step 3: Implement

# app/services/sugarwod_import/monostructural_detector.rb
class SugarwodImport
  class MonostructuralDetector
    DISTANCE_METERS = /\A(?:for time:?\s*)?([\d,]+)\s*meter\b/i
    DISTANCE_K = /\A(?:for time:?\s*)?(\d+)\s*k\b/i
    MAX_CALORIES = /\A(\d+)\s*minute\s*max\s*calorie\b/i
    MOVEMENT_WORD_BOUNDARY = /\b(\w[\w\s-]*?)\b(?=\s*(?:row|run|bike|ski)\b)/i

    def self.call(row) = new(row).build

    def initialize(row)
      @row = row
    end

    def build
      return nil if row[:barbell_lift].present?

      description = row[:description].to_s.strip
      build_distance_for_time(description) || build_max_calories(description)
    end

    private

    attr_reader :row

    def build_distance_for_time(description)
      meters = description[DISTANCE_METERS, 1]&.delete(',')&.to_i
      meters ||= (description[DISTANCE_K, 1].to_i * 1000 if description.match?(DISTANCE_K))
      return nil unless meters&.positive?

      movement = single_monostructural_movement(description)
      return nil unless movement

      build_workout(movement, score_type: :time, name: "#{movement.name} #{meters}m") do |exercise|
        exercise.distance = meters
        exercise.distance_unit = 'meter'
      end
    end

    def build_max_calories(description)
      match = description.match(MAX_CALORIES)
      return nil unless match

      movement = single_monostructural_movement(description)
      return nil unless movement

      build_workout(movement, score_type: :calorie, name: "#{match[1]} Minute Max Calorie #{movement.name}") do |exercise|
        exercise.duration_seconds = match[1].to_i * 60
      end
    end

    def single_monostructural_movement(description)
      names = %w[row run bike ski].select { |name| description.match?(/\b#{name}\b/i) }
      return nil unless names.one?

      movement = CfWod::MovementLookup.call(names.first)
      movement if movement&.family_monostructural?
    end

    def build_workout(movement, score_type:, name:)
      workout = Workout.new(score_type: score_type, name: name)
      segment = workout.segments.build(position: 1)
      exercise = segment.exercises.build(movement: movement, position: 1)
      yield exercise
      workout
    end
  end
end

• Step 4: Run tests to verify they pass

Run: bin/rails test test/services/sugarwod_import/monostructural_detector_test.rb
Expected: PASS (6 examples)

• Step 5: Run RuboCop

Run: bin/rubocop app/services/sugarwod_import/monostructural_detector.rb test/services/sugarwod_import/monostructural_detector_test.rb --parallel
Expected: no offenses

• Step 6: Commit

git add app/services/sugarwod_import/monostructural_detector.rb test/services/sugarwod_import/monostructural_detector_test.rb
git commit -m "Add SugarwodImport::MonostructuralDetector for single-movement distance/calorie tests"

---

Task 5: SugarwodImport::BodyweightMaxRepDetector

Files:

• Create: app/services/sugarwod_import/bodyweight_max_rep_detector.rb
• Test: test/services/sugarwod_import/bodyweight_max_rep_detector_test.rb

Interfaces:

• Consumes: CfWod::MovementLookup.call(name) (existing).

• Produces: SugarwodImport::BodyweightMaxRepDetector.call(row) # => Workout | nil

  • Recognizes "Max <movement>", "Max Unbroken <movement>", or "<movement> (max reps)" style single-movement descriptions. The movement must resolve to a Movement with family_gymnastics?. Multiple distinct movements → nil.

• Step 1: Write the failing tests

# test/services/sugarwod_import/bodyweight_max_rep_detector_test.rb
require 'test_helper'

class SugarwodImport
  class BodyweightMaxRepDetectorTest < ActiveSupport::TestCase
    test 'builds a rep-scored workout from "Max Unbroken <movement>"' do
      row = { title: 'Max Pull-ups', description: 'Max Unbroken Pull Up', barbell_lift: nil }

      workout = BodyweightMaxRepDetector.call(row)

      assert_equal 'rep', workout.score_type
      exercise = workout.segments.sole.exercises.sole
      assert_equal movements(:pullup), exercise.movement
    end

    test 'builds a rep-scored workout from "Max <movement>"' do
      row = { title: 'Max Push-ups', description: 'Max Push Up', barbell_lift: nil }

      workout = BodyweightMaxRepDetector.call(row)

      exercise = workout.segments.sole.exercises.sole
      assert_equal movements(:pushup), exercise.movement
    end

    test 'builds a rep-scored workout from "<movement> (max reps)"' do
      row = { title: 'Max HSPU', description: 'Handstand Push Up (max reps)', barbell_lift: nil }

      workout = BodyweightMaxRepDetector.call(row)

      exercise = workout.segments.sole.exercises.sole
      assert_equal movements(:hspu), exercise.movement
    end

    test 'returns nil when more than one movement is mentioned' do
      row = { title: 'Max Combo', description: 'Max Pull Up then Max Push Up', barbell_lift: nil }

      assert_nil BodyweightMaxRepDetector.call(row)
    end

    test 'returns nil when the movement is not gymnastics' do
      row = { title: 'Max Row', description: 'Max Calorie Row', barbell_lift: nil }

      assert_nil BodyweightMaxRepDetector.call(row)
    end

    test 'returns nil for a description with no max-effort language' do
      row = { title: 'Pull-up practice', description: '5 sets of 5 Pull Up', barbell_lift: nil }

      assert_nil BodyweightMaxRepDetector.call(row)
    end
  end
end

• Step 2: Run tests to verify they fail

Run: bin/rails test test/services/sugarwod_import/bodyweight_max_rep_detector_test.rb
Expected: FAIL with NameError: uninitialized constant SugarwodImport::BodyweightMaxRepDetector

• Step 3: Implement

# app/services/sugarwod_import/bodyweight_max_rep_detector.rb
class SugarwodImport
  class BodyweightMaxRepDetector
    MAX_PREFIX = /\Amax (?:unbroken )?(.+)\z/i
    MAX_SUFFIX = /\A(.+?)\s*\(max reps\)\z/i

    def self.call(row) = new(row).build

    def initialize(row)
      @row = row
    end

    def build
      return nil if row[:barbell_lift].present?

      description = row[:description].to_s.strip
      name = description[MAX_PREFIX, 1] || description[MAX_SUFFIX, 1]
      return nil unless name

      movement = CfWod::MovementLookup.call(name)
      return nil unless movement&.family_gymnastics?

      build_workout(movement)
    end

    private

    attr_reader :row

    def build_workout(movement)
      workout = Workout.new(score_type: :rep, name: "Max #{movement.name}")
      segment = workout.segments.build(position: 1)
      segment.exercises.build(movement: movement, position: 1, reps: 0)
      workout
    end
  end
end

Note on the "returns nil when more than one movement is mentioned" test: MAX_PREFIX/MAX_SUFFIX only ever capture one phrase, and CfWod::MovementLookup.call('Pull Up then Max Push Up') will fail to resolve to any single catalog Movement (it isn't a recognized name), so movement is nil and the method correctly returns nil without needing separate multi-movement detection logic — simpler than MonostructuralDetector's explicit check, since there's no equivalent of %w[row run bike ski] name-fragment matching here.

• Step 4: Run tests to verify they pass

Run: bin/rails test test/services/sugarwod_import/bodyweight_max_rep_detector_test.rb
Expected: PASS (6 examples)

• Step 5: Run RuboCop

Run: bin/rubocop app/services/sugarwod_import/bodyweight_max_rep_detector.rb test/services/sugarwod_import/bodyweight_max_rep_detector_test.rb --parallel
Expected: no offenses

• Step 6: Commit

git add app/services/sugarwod_import/bodyweight_max_rep_detector.rb test/services/sugarwod_import/bodyweight_max_rep_detector_test.rb
git commit -m "Add SugarwodImport::BodyweightMaxRepDetector for single-movement max-rep tests"

---

Task 6: Remove the temporary detector stub, wire everything together, full verification

Files:

• Modify: test/services/sugarwod_import/row_importer_test.rb (remove the Task 3 Step 4 temporary stub, if still present)

• No other production files — this task verifies the whole feature end-to-end.

• Step 1: Confirm the temporary stub from Task 3 Step 4 is gone

grep -n "Temporary, for this step only" test/services/sugarwod_import/row_importer_test.rb

Expected: no output. If present, delete that block — Tasks 4–5 now provide the real classes.

• Step 2: Run the full feature test suite

bin/rails test test/models/sugarwod_import_test.rb test/services/sugarwod_import/ \
  test/jobs/import_sugarwod_csv_job_test.rb test/controllers/sugarwod_imports_controller_test.rb

Expected: PASS, 0 failures/errors.

• Step 3: Run RuboCop on every touched file

bin/rubocop app/services/sugarwod_import/ test/services/sugarwod_import/ --parallel

Expected: no offenses.

• Step 4: Confirm CfWod::WorkoutFormatClassifier/WorkoutParser and ScrapeCfWodJob are untouched

git diff --stat 20abfde..HEAD -- app/services/cf_wod/ app/jobs/scrape_cf_wod_job.rb

Expected: no output (this plan never modifies those files — they remain shared, unaffected infrastructure per the Global Constraints note).

• Step 5: Manually verify against the real 1869-row export

Using the same workaround as the original feature's Task 11 (this sandbox's Solid Queue worker segfaults on pg connect — temporarily set config.active_job.queue_adapter = :inline in config/environments/development.rb for this verification only, then revert): upload tmp/workouts.csv through the real controller flow for a test user, and confirm:

• The 93 catalog-match rows and count of barbell-lift rows still import correctly.

• At least one real pyramid-scheme row (e.g. search the uploaded results for a title matching /\d+-\d+-\d+/) produced multiple MovementLogs with varying reps.

• No row that previously relied on the general heuristic/LLM path silently produces wrong data — it should now appear in the skipped list instead.

• Revert the queue_adapter change (git diff config/environments/development.rb should be empty) before finishing.

• Step 6: Update the design issue with final results

gh issue comment 1843 --body "Implemented per this issue's design. Full touched-suite green, RuboCop clean. Real-data verification: [paste imported/skipped counts from Step 5]."

[Yanchek99]

Implemented per this issue's design. All 6 tasks complete, full touched-suite green (70/154, RuboCop clean), CfWod::WorkoutFormatClassifier/WorkoutParser/ScrapeCfWodJob confirmed untouched.

Real-data verification against the actual 1869-row export:

• 300 imported (93 catalog matches + barbell-lift + monostructural), 1569 skipped — lower than the prior branch's 442, as expected: the general heuristic/LLM path (which only contributed 5 rows) and the previously-wrong DEFAULT_REPS-based barbell-lift imports are both gone.
• 691 real per-set MovementLogs captured (avg ~2.3 per imported log), including a genuine 12-set "working up" Squat Snatch session (85→155 lb, each set its own reps+load) — this was the core goal of the redesign.
• Zero fake zero-value scores.
• Monostructural detector: 16 real hits (Row/Run at various distances).
• Bodyweight-max-rep detector: 0 hits in this dataset — not a bug, just real coverage; the narrow phrasing it looks for didn't appear in this particular export.

Two additional real bugs were found and fixed during implementation (both documented in the SDD ledger): BarbellLiftBuilder wasn't setting Workout#name (presence-validated, so every barbell-lift row would fail to save), and ImportSugarwodCsvJob#symbolize_row was dropping set_details entirely before it ever reached RowImporter — a pre-existing gap in code outside this plan's file list that would have silently broken the whole barbell-lift path in production despite all unit tests passing.