repwise 1.0.0__tar.gz

repwise-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Adam Żmuda
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

repwise-1.0.0/PKG-INFO

@@ -0,0 +1,197 @@
+Metadata-Version: 2.4
+Name: repwise
+Version: 1.0.0
+Summary: Advance Garmin strength workout targets using double progression
+Author-email: Adam Żmuda <adam@zmuda.pro>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/theadzik/repwise
+Project-URL: Documentation, https://github.com/theadzik/repwise/tree/main/docs
+Project-URL: Changelog, https://github.com/theadzik/repwise/blob/main/CHANGELOG.md
+Project-URL: Issues, https://github.com/theadzik/repwise/issues
+Keywords: garmin,strength-training,progressive-overload
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Utilities
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: garminconnect==0.3.7
+Requires-Dist: pyyaml==6.0.3
+Provides-Extra: dev
+Requires-Dist: commitizen==4.17.0; extra == "dev"
+Requires-Dist: mypy==2.3.0; extra == "dev"
+Requires-Dist: pre-commit==4.6.1; extra == "dev"
+Requires-Dist: pytest==9.1.1; extra == "dev"
+Requires-Dist: ruff==0.16.1; extra == "dev"
+Requires-Dist: types-PyYAML==6.0.12.20260724; extra == "dev"
+Dynamic: license-file
+
+# Garmin Double Progression
+
+Reads what you actually lifted from Garmin Connect and advances the targets in
+your Garmin workouts automatically, using double progression.
+
+Train, run one command, sync your watch. Next session's numbers are already
+waiting on it.
+
+```text
+$ repwise update
+
+Activity: Workout B (1234567890)
+Updating: Workout B -> workout 111111111
+
+* Barbell Deadlift          10 x 60 kg  ->  6 x 65 kg    (hit 10 on every set, +5 kg and reset to 6)
+* Dumbbell Lateral Raise      12 x 8 kg  ->  13 x 8 kg   (add 1 rep (12 -> 13))
+  Sit-up                       11 reps  ->  11 reps      (missed target (10/11 on worst set), repeat)
+
+Dry run: 2 step(s) would change. Re-run with --apply.
+```
+
+## Quick start
+
+You need workouts already built in Garmin Connect, and Python 3.14 or newer.
+
+```bash
+git clone https://github.com/theadzik/repwise.git
+cd repwise
+python3 -m venv .venv
+.venv/bin/pip install -e .
+
+repwise import -o workouts.yaml   # build a config from your Garmin workouts
+repwise update                    # after a session: see what would change
+repwise update --apply --push     # write it, and send it to your watch
+```
+
+The first command that reaches Garmin asks for your email, password and MFA
+code, then caches a token so later runs do not. Credentials are never stored by
+this tool.
+
+**Nothing is written to Garmin without `--apply`.** A dry run is the default.
+
+The full walkthrough is in [Getting started][getting-started].
+
+## What it does
+
+It compares what you performed against the target stored in Garmin and picks
+the next one. Every workout in your config is advanced from its own latest
+session, so training A and then B and running once brings both up to date:
+
+1. Start at the bottom of the rep range.
+2. Add a rep to every set each session.
+3. Once every set reaches the top of the range, add weight and reset to the
+   bottom.
+4. If you missed the target, repeat it unchanged.
+5. A load only counts once you can carry it for the bottom of the range.
+
+Three things it handles that a spreadsheet would not:
+
+- **It judges progress by your weakest set.** Extra reps on the easy sets do not
+  pull the target somewhere you cannot repeat.
+- **It eases you back after a stall.** Miss a target twice and the session that
+  finally beats it earns a rep on two of your four sets rather than on all of
+  them, so you are not asked again for the jump that just failed.
+- **It follows the weight you actually used.** Bump the load mid-session and the
+  new load is banked, not discarded.
+- **It won't keep a load you didn't earn.** Take the 4 kg dumbbells because the
+  3 kg pair was gone, come up short of the range, and your target stays where it
+  was rather than following you onto a weight that was too heavy.
+
+Each exercise also gets a one-line note on its Garmin step, such as
+`6-10 reps | +5 kg`, so the watch shows what you are working towards and not
+just today's target. Notes you wrote yourself are left alone.
+
+## Your config is the workout
+
+`workouts.yaml` decides what a workout **is**; Garmin keeps track of where each
+exercise has **got to**. Edit the file and the next run brings Garmin into
+line:
+
+- **Write a workout that does not exist yet.** Leave `garmin_workout_id` out
+  and it is built in Garmin, then the id is written back into your file.
+- **Reorder the exercises.** The order in the file is the order on the watch.
+  Add one and it is added; delete one and it is deleted.
+- **Set the rests and the sets.** Including the rest *between* exercises, which
+  Garmin leaves as a wait for the lap button until you ask for a time.
+
+An exercise that moves keeps everything it had, target included, because the
+step itself is moved rather than rebuilt. That is the difference between
+reordering your workout and quietly restarting your progression.
+
+Nothing reaches Garmin without `--apply`, and a dry run prints every addition,
+removal and move first.
+
+It also covers timed holds like planks, exercises the watch counts per side, and
+keeping an exercise in sync when it appears in more than one workout.
+[Progression][progression] explains every decision it can make.
+
+## Commands
+
+| Command | What it does |
+| --- | --- |
+| `repwise update` | Advance targets from the latest session, and bring every workout in line with the config. Dry run by default |
+| `repwise update --apply --push` | Write all of that to Garmin and send it to your watch |
+| `repwise list` | Show your Garmin workouts and their ids |
+| `repwise import` | Build a `workouts.yaml` from your Garmin workouts |
+| `repwise check` | Check that your config names exercises Garmin actually has, that it still names the ones your workouts hold, and that every rep range fits what its weight step is really worth |
+| `repwise fetch` | Download raw workout JSON |
+| `repwise fetch exercises` | Refresh Garmin's list of every exercise it knows, which `check` reads |
+
+Any command takes `-v` to show debug output as well. Full flags and output for
+each are in [Commands][commands].
+
+## Your routine
+
+Your routine lives in `workouts.yaml`: the exercises, their order, rep ranges,
+set counts, rests, and which Garmin workout each belongs to. Generate it with
+`repwise import`, or copy [workouts.example.yaml][workouts-example] - a
+complete working A/B full body split, annotated field by field.
+
+It is the source of truth rather than a copy of one: `update` writes what it
+says to Garmin, and the only thing ever written back into it is an id Garmin
+issues for a workout it has just created.
+
+That file is gitignored, so your routine and Garmin ids stay out of version
+control. Every field is described in [Configuration][configuration].
+
+## Documentation
+
+For users:
+
+| Page | Contents |
+| --- | --- |
+| [Getting started][getting-started] | Install to first update, step by step |
+| [Commands][commands] | Every command, flag, output marker and exit code |
+| [Configuration][configuration] | The `workouts.yaml` reference, and finding your exercise identifiers |
+| [Progression][progression] | How the next target is decided, with worked examples |
+| [Troubleshooting][troubleshooting] | Login problems, skipped exercises, known limitations |
+
+For contributors:
+
+| Page | Contents |
+| --- | --- |
+| [Architecture][architecture] | Module layout, dependency and data-flow diagrams |
+| [Garmin's API][garmin-api] | The undocumented payloads and endpoints, and their traps |
+| [Contributing][contributing] | Dev setup, tests, where to make a change |
+| [Releasing][releasing] | Commit message format, and how the version is derived from it |
+
+## Licence
+
+[MIT][license].
+
+[getting-started]: https://github.com/theadzik/repwise/blob/main/docs/getting-started.md
+[commands]: https://github.com/theadzik/repwise/blob/main/docs/commands.md
+[configuration]: https://github.com/theadzik/repwise/blob/main/docs/configuration.md
+[progression]: https://github.com/theadzik/repwise/blob/main/docs/progression.md
+[troubleshooting]: https://github.com/theadzik/repwise/blob/main/docs/troubleshooting.md
+[architecture]: https://github.com/theadzik/repwise/blob/main/docs/architecture.md
+[garmin-api]: https://github.com/theadzik/repwise/blob/main/docs/garmin-api.md
+[contributing]: https://github.com/theadzik/repwise/blob/main/docs/contributing.md
+[releasing]: https://github.com/theadzik/repwise/blob/main/docs/releasing.md
+[workouts-example]: https://github.com/theadzik/repwise/blob/main/workouts.example.yaml
+[license]: https://github.com/theadzik/repwise/blob/main/LICENSE

repwise-1.0.0/README.md

@@ -0,0 +1,163 @@
+# Garmin Double Progression
+
+Reads what you actually lifted from Garmin Connect and advances the targets in
+your Garmin workouts automatically, using double progression.
+
+Train, run one command, sync your watch. Next session's numbers are already
+waiting on it.
+
+```text
+$ repwise update
+
+Activity: Workout B (1234567890)
+Updating: Workout B -> workout 111111111
+
+* Barbell Deadlift          10 x 60 kg  ->  6 x 65 kg    (hit 10 on every set, +5 kg and reset to 6)
+* Dumbbell Lateral Raise      12 x 8 kg  ->  13 x 8 kg   (add 1 rep (12 -> 13))
+  Sit-up                       11 reps  ->  11 reps      (missed target (10/11 on worst set), repeat)
+
+Dry run: 2 step(s) would change. Re-run with --apply.
+```
+
+## Quick start
+
+You need workouts already built in Garmin Connect, and Python 3.14 or newer.
+
+```bash
+git clone https://github.com/theadzik/repwise.git
+cd repwise
+python3 -m venv .venv
+.venv/bin/pip install -e .
+
+repwise import -o workouts.yaml   # build a config from your Garmin workouts
+repwise update                    # after a session: see what would change
+repwise update --apply --push     # write it, and send it to your watch
+```
+
+The first command that reaches Garmin asks for your email, password and MFA
+code, then caches a token so later runs do not. Credentials are never stored by
+this tool.
+
+**Nothing is written to Garmin without `--apply`.** A dry run is the default.
+
+The full walkthrough is in [Getting started][getting-started].
+
+## What it does
+
+It compares what you performed against the target stored in Garmin and picks
+the next one. Every workout in your config is advanced from its own latest
+session, so training A and then B and running once brings both up to date:
+
+1. Start at the bottom of the rep range.
+2. Add a rep to every set each session.
+3. Once every set reaches the top of the range, add weight and reset to the
+   bottom.
+4. If you missed the target, repeat it unchanged.
+5. A load only counts once you can carry it for the bottom of the range.
+
+Three things it handles that a spreadsheet would not:
+
+- **It judges progress by your weakest set.** Extra reps on the easy sets do not
+  pull the target somewhere you cannot repeat.
+- **It eases you back after a stall.** Miss a target twice and the session that
+  finally beats it earns a rep on two of your four sets rather than on all of
+  them, so you are not asked again for the jump that just failed.
+- **It follows the weight you actually used.** Bump the load mid-session and the
+  new load is banked, not discarded.
+- **It won't keep a load you didn't earn.** Take the 4 kg dumbbells because the
+  3 kg pair was gone, come up short of the range, and your target stays where it
+  was rather than following you onto a weight that was too heavy.
+
+Each exercise also gets a one-line note on its Garmin step, such as
+`6-10 reps | +5 kg`, so the watch shows what you are working towards and not
+just today's target. Notes you wrote yourself are left alone.
+
+## Your config is the workout
+
+`workouts.yaml` decides what a workout **is**; Garmin keeps track of where each
+exercise has **got to**. Edit the file and the next run brings Garmin into
+line:
+
+- **Write a workout that does not exist yet.** Leave `garmin_workout_id` out
+  and it is built in Garmin, then the id is written back into your file.
+- **Reorder the exercises.** The order in the file is the order on the watch.
+  Add one and it is added; delete one and it is deleted.
+- **Set the rests and the sets.** Including the rest *between* exercises, which
+  Garmin leaves as a wait for the lap button until you ask for a time.
+
+An exercise that moves keeps everything it had, target included, because the
+step itself is moved rather than rebuilt. That is the difference between
+reordering your workout and quietly restarting your progression.
+
+Nothing reaches Garmin without `--apply`, and a dry run prints every addition,
+removal and move first.
+
+It also covers timed holds like planks, exercises the watch counts per side, and
+keeping an exercise in sync when it appears in more than one workout.
+[Progression][progression] explains every decision it can make.
+
+## Commands
+
+| Command | What it does |
+| --- | --- |
+| `repwise update` | Advance targets from the latest session, and bring every workout in line with the config. Dry run by default |
+| `repwise update --apply --push` | Write all of that to Garmin and send it to your watch |
+| `repwise list` | Show your Garmin workouts and their ids |
+| `repwise import` | Build a `workouts.yaml` from your Garmin workouts |
+| `repwise check` | Check that your config names exercises Garmin actually has, that it still names the ones your workouts hold, and that every rep range fits what its weight step is really worth |
+| `repwise fetch` | Download raw workout JSON |
+| `repwise fetch exercises` | Refresh Garmin's list of every exercise it knows, which `check` reads |
+
+Any command takes `-v` to show debug output as well. Full flags and output for
+each are in [Commands][commands].
+
+## Your routine
+
+Your routine lives in `workouts.yaml`: the exercises, their order, rep ranges,
+set counts, rests, and which Garmin workout each belongs to. Generate it with
+`repwise import`, or copy [workouts.example.yaml][workouts-example] - a
+complete working A/B full body split, annotated field by field.
+
+It is the source of truth rather than a copy of one: `update` writes what it
+says to Garmin, and the only thing ever written back into it is an id Garmin
+issues for a workout it has just created.
+
+That file is gitignored, so your routine and Garmin ids stay out of version
+control. Every field is described in [Configuration][configuration].
+
+## Documentation
+
+For users:
+
+| Page | Contents |
+| --- | --- |
+| [Getting started][getting-started] | Install to first update, step by step |
+| [Commands][commands] | Every command, flag, output marker and exit code |
+| [Configuration][configuration] | The `workouts.yaml` reference, and finding your exercise identifiers |
+| [Progression][progression] | How the next target is decided, with worked examples |
+| [Troubleshooting][troubleshooting] | Login problems, skipped exercises, known limitations |
+
+For contributors:
+
+| Page | Contents |
+| --- | --- |
+| [Architecture][architecture] | Module layout, dependency and data-flow diagrams |
+| [Garmin's API][garmin-api] | The undocumented payloads and endpoints, and their traps |
+| [Contributing][contributing] | Dev setup, tests, where to make a change |
+| [Releasing][releasing] | Commit message format, and how the version is derived from it |
+
+## Licence
+
+[MIT][license].
+
+[getting-started]: https://github.com/theadzik/repwise/blob/main/docs/getting-started.md
+[commands]: https://github.com/theadzik/repwise/blob/main/docs/commands.md
+[configuration]: https://github.com/theadzik/repwise/blob/main/docs/configuration.md
+[progression]: https://github.com/theadzik/repwise/blob/main/docs/progression.md
+[troubleshooting]: https://github.com/theadzik/repwise/blob/main/docs/troubleshooting.md
+[architecture]: https://github.com/theadzik/repwise/blob/main/docs/architecture.md
+[garmin-api]: https://github.com/theadzik/repwise/blob/main/docs/garmin-api.md
+[contributing]: https://github.com/theadzik/repwise/blob/main/docs/contributing.md
+[releasing]: https://github.com/theadzik/repwise/blob/main/docs/releasing.md
+[workouts-example]: https://github.com/theadzik/repwise/blob/main/workouts.example.yaml
+[license]: https://github.com/theadzik/repwise/blob/main/LICENSE

repwise-1.0.0/pyproject.toml

@@ -0,0 +1,138 @@
+[build-system]
+requires = ["setuptools>=83.0.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "repwise"
+version = "1.0.0"
+description = "Advance Garmin strength workout targets using double progression"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.14"
+authors = [
+    { name = "Adam Żmuda", email = "adam@zmuda.pro" },
+]
+keywords = ["garmin", "strength-training", "progressive-overload"]
+# How PyPI files and filters this. Deliberately no "License :: OSI Approved"
+# line: PEP 639 replaced those with the SPDX `license` field above, and
+# setuptools refuses to build at all when both are present.
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Environment :: Console",
+    "Intended Audience :: End Users/Desktop",
+    "Natural Language :: English",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    # One line per supported minor, and requires-python above is what actually
+    # enforces it - this only decides what the sidebar on PyPI says.
+    "Programming Language :: Python :: 3.14",
+    # Trove has no classifier for fitness, training or sport, so this is the
+    # closest honest fit.
+    "Topic :: Utilities",
+]
+# Pinned to exact versions. This is an application rather than a library, so a
+# reproducible install matters more than being co-installable, and Dependabot
+# raises a PR per release. garminconnect in particular has broken
+# authentication before, so the working version is recorded deliberately.
+dependencies = [
+    "garminconnect==0.3.7",
+    "pyyaml==6.0.3",
+]
+
+# The sidebar on the PyPI page. Absolute, because the description rendered
+# there is README.md torn out of the repository, where nothing relative
+# resolves.
+[project.urls]
+Homepage = "https://github.com/theadzik/repwise"
+Documentation = "https://github.com/theadzik/repwise/tree/main/docs"
+Changelog = "https://github.com/theadzik/repwise/blob/main/CHANGELOG.md"
+Issues = "https://github.com/theadzik/repwise/issues"
+
+[project.optional-dependencies]
+dev = [
+    "commitizen==4.17.0",
+    "mypy==2.3.0",
+    "pre-commit==4.6.1",
+    "pytest==9.1.1",
+    "ruff==0.16.1",
+    "types-PyYAML==6.0.12.20260724",
+]
+
+[project.scripts]
+repwise = "repwise.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+# Conventional commits in, version numbers out. `cz check` runs from
+# .pre-commit-config.yaml on every commit message; `cz bump` reads the commits
+# since the last tag and decides the release. See docs/releasing.md.
+[tool.commitizen]
+name = "cz_conventional_commits"
+# Read and write [project].version above, so the version is stated once.
+version_provider = "pep621"
+# Bare "0.2.0", not "v0.2.0". This is Commitizen's own default and matches the
+# hand-cut 0.1.0 tag, so it is stated only to pin it: the default has changed
+# upstream before, and a silent change would start a second tag series.
+tag_format = "$version"
+version_files = ["src/repwise/__init__.py:__version__"]
+update_changelog_on_bump = true
+# History before 0.1.0 predates conventional commits, so there is nothing to
+# generate a changelog from.
+changelog_start_rev = "0.1.0"
+# Commitizen's own Markdown template with a commit link on each entry. The path
+# is resolved against the working directory, so `cz` has to run from the
+# repository root - which is where both the hook and the workflow run it.
+template = ".cz/CHANGELOG.md.j2"
+
+# Linting and formatting. The pre-commit hook and a bare `ruff check` read this
+# same section, so they cannot disagree.
+[tool.ruff]
+line-length = 88
+target-version = "py314"
+
+[tool.ruff.lint]
+select = [
+    "E", "W",  # pycodestyle
+    "F",       # pyflakes
+    "I",       # import sorting
+    "UP",      # pyupgrade: syntax available on the minimum Python
+    "B",       # bugbear: likely bugs
+    "C4",      # comprehension rewrites
+    "SIM",     # simplifications
+    "RET",     # return-statement hygiene
+    "PIE",     # small correctness idioms
+    "Q",       # quote consistency
+    "RSE",     # raise cleanliness
+    "SLF",     # private member access
+    "BLE",     # blind except - the existing noqa comments name this rule
+    "PL",      # pylint subset
+    "RUF",     # ruff's own
+]
+ignore = [
+    # This is a CLI whose job is printing, and its errors carry the detail a
+    # user needs, so neither "no print" nor "no message in the raise" applies.
+    # T201 and EM/TRY are left unselected for the same reason.
+    #
+    # Rewriting os.path to pathlib (PTH) and rejecting relative imports (TID252)
+    # would both fight deliberate choices, so they stay unselected too.
+    "PLR2004",  # magic values: tests compare against literal reps and weights
+    "PLC0415",  # imports inside functions are deliberate here
+    "RUF022",   # __all__ is ordered by meaning, not alphabetically
+]
+
+[tool.mypy]
+files = ["src", "tests"]
+python_version = "3.14"
+
+# garminconnect ships no type information. garmin/client.py is the only module
+# that imports it, which is what keeping the adapter in one place buys.
+[[tool.mypy.overrides]]
+module = "garminconnect.*"
+ignore_missing_imports = true
+
+[tool.pytest.ini_options]
+pythonpath = ["src"]
+testpaths = ["tests"]

repwise-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

repwise-1.0.0/src/repwise/__init__.py

@@ -0,0 +1,4 @@
+"""Advance Garmin strength workout targets using double progression."""
+
+__all__ = ["__version__"]
+__version__ = "1.0.0"

repwise-1.0.0/src/repwise/__main__.py

@@ -0,0 +1,7 @@
+"""Entry point for `python -m repwise`."""
+
+import sys
+
+from .cli import main
+
+sys.exit(main())

repwise-1.0.0/src/repwise/app/__init__.py

@@ -0,0 +1,7 @@
+"""The use cases: one module per command, and the report they print.
+
+Each `run_*` function is the whole of a command apart from parsing and
+dispatch. It is handed the things it needs - a Garmin session, a config, its
+options - rather than building them, so nothing here imports argparse and
+nothing here decides what a process exits with beyond returning it.
+"""

repwise-1.0.0/src/repwise/app/checking.py

@@ -0,0 +1,109 @@
+"""Report where workouts.yaml and the Garmin workouts disagree."""
+
+import logging
+
+from ..checker import Finding, check_catalog, check_programming, check_workout
+from ..domain.models import Config, GarminSettings
+from ..errors import ExitCode, GarminError
+from ..garmin.catalog import ExerciseCatalog, ensure
+from ..garmin.client import GarminSession
+from .report import SEVERITY
+
+logger = logging.getLogger(__name__)
+
+
+def _catalog(settings: GarminSettings) -> ExerciseCatalog | None:
+    """Garmin's exercise list, downloaded on the first run that wants it.
+
+    Fetched here rather than demanded of the user, because a check that only
+    works after another command has been run is a check that goes unrun. The
+    copy is cached, so this costs one download ever.
+
+    A failure costs the name checks and nothing else, exactly as a missing
+    weigh-in costs the range checks. `check` is worth running with no network
+    at all, and the questions it can still answer are worth answering.
+    """
+    try:
+        return ensure(settings)
+    except GarminError as exc:
+        logger.warning(f"Exercise names were not checked: {exc}")
+        return None
+
+
+def _bodyweight(session: GarminSession, config: Config) -> float | None:
+    """How much of you the bodyweight-loaded exercises are carrying.
+
+    What the config states wins, since someone who wrote it down means it.
+    Otherwise Garmin is asked, which is the answer that stays current without
+    anyone editing a file. A failure here is not worth failing the command
+    over: it costs the range checks on a few exercises, and `check_programming`
+    reports each of those where it finds them.
+    """
+    if config.bodyweight is not None:
+        return config.bodyweight
+
+    if not any(
+        spec.bodyweight_factor for workout in config for spec in workout.exercises
+    ):
+        return None  # nothing would read it, so do not spend a request on it
+
+    try:
+        weight = session.bodyweight()
+    except GarminError as exc:
+        logger.debug(f"Could not read your weigh-ins: {exc}")
+        return None
+
+    if weight is not None:
+        logger.debug(f"Bodyweight {weight:g} kg, averaged from your Garmin weigh-ins.")
+    return weight
+
+
+def run_check(session: GarminSession, config: Config) -> ExitCode:
+    findings: list[Finding] = []
+    bodyweight = _bodyweight(session, config)
+    catalog = _catalog(config.garmin)
+    for workout in config:
+        workout_id = workout.garmin_workout_id
+        # First, and outside the branch below, because it is the only check
+        # that does not need Garmin to hold the workout. Reported first too: an
+        # exercise that does not exist explains whatever the checks below go on
+        # to say about it, which reads better before them than after.
+        found = check_catalog(workout, catalog) if catalog else []
+
+        if workout_id is None:
+            # Nothing in Garmin to disagree with yet. Said out loud, because
+            # silence here would read as "checked, and fine" - and the names
+            # above were checked, which is the point of doing it now.
+            logger.info(f"{workout.key} (not in Garmin yet)")
+        else:
+            logger.info(f"{workout.key} ({workout_id})")
+            try:
+                payload = session.workout(workout_id)
+            except GarminError as exc:
+                # A workout that cannot be read is itself an error-level
+                # finding, so an unreachable workout still fails the command.
+                found.append(
+                    Finding(
+                        workout.key,
+                        f"could not fetch workout {workout_id}: {exc}",
+                        "error",
+                    )
+                )
+            else:
+                found += check_workout(workout, payload)
+                found += check_programming(workout, payload, bodyweight)
+
+        if not found:
+            logger.info("  ok")
+        for finding in found:
+            marker, level = SEVERITY[finding.severity]
+            logger.log(level, f"  {marker} {finding.detail}")
+        logger.info("")
+        findings.extend(found)
+
+    # Everything reported here needs a hand, so any finding at all fails the
+    # command. That is what makes it worth putting in a cron job: it goes off
+    # when the config is wrong, not when you have edited a rest and not yet
+    # run `update`.
+    logger.info(f"{len(findings)} issue(s) across {len(config.workouts)} workout(s)")
+    return ExitCode.NOTHING_USABLE if findings else ExitCode.OK