Resolve pending commit links

Add review record RC-021 for MIL-007
Add retry wrapper and resilient login, booking and bookings read (step 9)
2026-10-28 18:14:19 +08:00 · 2026-10-28 18:14:18 +08:00 · 2026-10-28 18:14:13 +08:00 · 2026-10-28 11:03:00 +01:00 · 2026-10-28 18:02:52 +08:00 · 2026-10-28 18:02:50 +08:00
41 changed files with 3722 additions and 42 deletions
@@ -16,7 +16,7 @@ document of a type. `Primary File` may contain a glob (e.g.
 | PP | Project Plan | docs/project-plan.md | 002 |
 | MIL | Milestone / Gateway | docs/milestones/*.md | 009 |
 | ADR | Architecture Decision Record | docs/adr/adr-NNNN-*.md | 0004 |
-| RC | SQA Review Record | docs/sqa/reviews/rc-*.md | 018 |
+| RC | SQA Review Record | docs/sqa/reviews/rc-*.md | 022 |
 | TM | Traceability Matrix | docs/sqa/traceability-matrix.md | 002 |
 | DICT | Domain Dictionary | docs/dictionary.md | 002 |

@@ -9,7 +9,7 @@
 ## Version History
 | Date | Status | Author | Reviewer | Change | Commit |
 | --- | --- | --- | --- | --- | --- |
-| 2026-10-28 | Accepted | Jens Tirsvad Nielsen | AI as stand-in for S02 | Review record, full review of the source and tests of MIL-003 | pending |
+| 2026-10-28 | Accepted | Jens Tirsvad Nielsen | AI as stand-in for S02 | Review record, full review of the source and tests of MIL-003 | [245dd16] |

 ---

@@ -59,3 +59,4 @@ Go-with-conditions - the code of MIL-003 meets every Mandatory criterion of QC-P

 [MIL-003]: ../../milestones/mil-003-login.md
 [QC-PY-001]: ../../../framework/qc/code/qc-programming-python.md
+[245dd16]: https://git.tirsystem.com/Tirsvad-Udemy-100-days-of-code/049-snack-and-lift/commit/245dd1689e10cc8d87c6f2a4934286cc36ca34e2
@@ -0,0 +1,62 @@
+# SQA Review Record
+
+## Metadata
+| Key | Value |
+| --- | --- |
+| ID | RC-018 |
+| CrossReference | [MIL-004], [QC-PY-001] |
+
+## Version History
+| Date | Status | Author | Reviewer | Change | Commit |
+| --- | --- | --- | --- | --- | --- |
+| 2026-10-28 | Accepted | Jens Tirsvad Nielsen | AI as stand-in for S02 | Review record, full review of the source and tests of MIL-004 | [41b0dac] |
+
+---
+
+## Artifact Under Review
+
+- Instance reviewed: [MIL-004]
+- Checklist used: [QC-PY-001] (`QC-PY-001`)
+- Scope: full review of the source and tests of MIL-004
+- Language and domain: n/a
+- Language reviewer: none
+- Mode: autonomous, not independent (the reviewer is `AI as stand-in for S02`)
+
+## Checklist Results
+
+| # | Criterion | Status | Evidence/Notes |
+| --- | --- | --- | --- |
+| 1 | Packages, modules, functions, variables, classes and constants follow PEP 8 casing (`snake_case`, `PascalCase`, `UPPER_SNAKE`) | Pass | Modules, functions and variables are `snake_case`, classes `PascalCase`, constants `UPPER_SNAKE`; `ruff check` with the N rules passes. |
+| 2 | Names state purpose in the domain's language; no unexplained abbreviations, no single-letter names outside tiny scopes | Pass | Names state purpose (for example `retry`, `login`, `book_class`, `get_my_bookings`); no single-letter names outside comprehensions. |
+| 3 | Code is produced by the project's formatter and passes its linter with no unexplained suppressions | Pass | `ruff format` leaves 0 files changed and `ruff check` reports 0 findings; there is no suppression. |
+| 4 | Every function and method signature is type-annotated, including `-> None` | Pass | Every function and method has annotations (ruff ANN rules pass), including `-> None`. |
+| 5 | No bare `except:`, no swallowed exceptions; specific exceptions are raised and the cause is kept (`raise ... from`) | Pass | No bare `except`; specific exceptions are caught, and re-raised with `raise ... from` where the cause matters. |
+| 6 | No mutable default arguments and no shadowed builtins | Pass | No mutable default arguments; no builtin is shadowed (ruff B and A-style checks pass). |
+| 7 | Files, locks and connections are managed with context managers | Pass | Files and the browser are managed with `with`/`try-finally`; no unmanaged file handle exists. |
+| 8 | Public modules, classes and functions have docstrings that say what, not how | Pass | Public modules, classes and functions have Doxygen docstrings (`@brief`, `@param`, `@return`). |
+| 9 | Logging uses `logging`, not `print`; no secrets or personal data in log output | Pass | No print calls; messages go through `logging`. |
+| 10 | Classes and operations trace to the Design Class Diagram they implement; deviations are recorded | N-A | No Design Class Diagram exists; ADR-0001 records that design artifacts are skipped. Classes follow ADR-0002. |
+| 11 | Tests exist for new behaviour, are named for the behaviour, and do not depend on order or the network | Pass | 103 unit tests (models, parsing, decisions, booking, recorder, command line) need no browser or network; 9 container tests run the adapter against local HTML fixtures; coverage of the non-infrastructure modules is 100%. |
+| 12 | Type checker runs in strict mode without errors; `Any` is justified in a comment | N-A | No strict type checker is configured; annotations are complete and checked by ruff. |
+| 13 | Dependencies are declared and pinned in the project's dependency file, none unused | Pass | `pyproject.toml` declares Selenium (runtime) and pytest, pytest-cov, ruff (dev) with lower bounds; none is unused. |
+| 14 | Each piece of knowledge (a business rule, constant, format, validation or query) is defined in one place; code is merged only where it expresses the same knowledge, not where it merely looks alike | Pass | Each rule, constant and message exists once (constants in `constants.py`, rules in `domain/`). |
+| 15 | Imports point inward: business-rule modules import no framework, database, UI or delivery-mechanism code, and there are no import cycles | Pass | `domain` and `application` import no Selenium; only `infrastructure` imports it; no import cycle exists. |
+| 16 | SOLID holds: a class or module has one reason to change; new behaviour is added by extension, not by editing a type test in several places; subclasses honour the contract of their base; protocols are narrow; high-level code depends on protocols or abstract types and receives its implementations | Pass | One reason to change per module; the adapter hides Selenium behind a port; fakes honour the port contract. |
+| 17 | Source is laid out in the layers and folders of the clean architecture folder structure (`domain`, `application`, `infrastructure`, `presentation` packages under `src/`, and `unit`, `integration` and `e2e` under `tests/`), in `snake_case`, and imports between the layers point inward | Pass | Layout follows `src/snack_and_lift/{domain,application,infrastructure}` and `tests/{unit,integration,e2e}`; there is no presentation layer for a command-line bot (ADR-0002). |
+| 18 | File and folder names are English, contain no space and no character outside letters, digits, `-`, `_` and `.`, and follow the casing of the language for files | Pass | All file and folder names are English lowercase with `_`, `-` and `.` only. |
+
+## Overall Verdict
+
+Go-with-conditions - the code of MIL-004 meets every Mandatory criterion of QC-PY-001 and there is no blocking finding, but part of the gate evidence cannot be produced by the stand-in. Gate criterion 1 (unit tests of the four button states and the parsing) is met. Criterion 2 (a container run that books or recognises the Tuesday class on the live site) is not verified, and criterion 3 is not met: `step-3.png` and `step-4.png` come from a run with an account. The framework forbids the stand-in to enter passwords or register on a third-party site, so the live run was not made; the adapter is verified against local fixtures that copy the site's element IDs, button texts and day labels. The review is not independent: the AI wrote and reviewed it as stand-in for S02, and S01 can challenge it in the end-of-run summary.
+
+## Action Items
+
+| Action | Owner | Due |
+| --- | --- | --- |
+| Run the bot with your own account and keep `docs/images/step-3.png` and `step-4.png`; report any selector that failed | S01 | when S01 has time |
+
+---
+
+[MIL-004]: ../../milestones/mil-004-book-class.md
+[QC-PY-001]: ../../../framework/qc/code/qc-programming-python.md
+[41b0dac]: https://git.tirsystem.com/Tirsvad-Udemy-100-days-of-code/049-snack-and-lift/commit/41b0dace113f17d9fc0ffece8a1133ad15d0fb21
@@ -0,0 +1,62 @@
+# SQA Review Record
+
+## Metadata
+| Key | Value |
+| --- | --- |
+| ID | RC-019 |
+| CrossReference | [MIL-005], [QC-PY-001] |
+
+## Version History
+| Date | Status | Author | Reviewer | Change | Commit |
+| --- | --- | --- | --- | --- | --- |
+| 2026-10-28 | Accepted | Jens Tirsvad Nielsen | AI as stand-in for S02 | Review record, full review of the source and tests of MIL-005 | [45e6fc7] |
+
+---
+
+## Artifact Under Review
+
+- Instance reviewed: [MIL-005]
+- Checklist used: [QC-PY-001] (`QC-PY-001`)
+- Scope: full review of the source and tests of MIL-005
+- Language and domain: n/a
+- Language reviewer: none
+- Mode: autonomous, not independent (the reviewer is `AI as stand-in for S02`)
+
+## Checklist Results
+
+| # | Criterion | Status | Evidence/Notes |
+| --- | --- | --- | --- |
+| 1 | Packages, modules, functions, variables, classes and constants follow PEP 8 casing (`snake_case`, `PascalCase`, `UPPER_SNAKE`) | Pass | Modules, functions and variables are `snake_case`, classes `PascalCase`, constants `UPPER_SNAKE`; `ruff check` with the N rules passes. |
+| 2 | Names state purpose in the domain's language; no unexplained abbreviations, no single-letter names outside tiny scopes | Pass | Names state purpose (for example `retry`, `login`, `book_class`, `get_my_bookings`); no single-letter names outside comprehensions. |
+| 3 | Code is produced by the project's formatter and passes its linter with no unexplained suppressions | Pass | `ruff format` leaves 0 files changed and `ruff check` reports 0 findings; there is no suppression. |
+| 4 | Every function and method signature is type-annotated, including `-> None` | Pass | Every function and method has annotations (ruff ANN rules pass), including `-> None`. |
+| 5 | No bare `except:`, no swallowed exceptions; specific exceptions are raised and the cause is kept (`raise ... from`) | Pass | No bare `except`; specific exceptions are caught, and re-raised with `raise ... from` where the cause matters. |
+| 6 | No mutable default arguments and no shadowed builtins | Pass | No mutable default arguments; no builtin is shadowed (ruff B and A-style checks pass). |
+| 7 | Files, locks and connections are managed with context managers | Pass | Files and the browser are managed with `with`/`try-finally`; no unmanaged file handle exists. |
+| 8 | Public modules, classes and functions have docstrings that say what, not how | Pass | Public modules, classes and functions have Doxygen docstrings (`@brief`, `@param`, `@return`). |
+| 9 | Logging uses `logging`, not `print`; no secrets or personal data in log output | Pass | No print calls; messages go through `logging`. |
+| 10 | Classes and operations trace to the Design Class Diagram they implement; deviations are recorded | N-A | No Design Class Diagram exists; ADR-0001 records that design artifacts are skipped. Classes follow ADR-0002. |
+| 11 | Tests exist for new behaviour, are named for the behaviour, and do not depend on order or the network | Pass | 122 unit tests (target lookup, counters, summary and detail text, booking of all target classes, command line) need no browser or network; 10 container tests run the adapter against local fixtures; coverage of the non-infrastructure modules is 100%. |
+| 12 | Type checker runs in strict mode without errors; `Any` is justified in a comment | N-A | No strict type checker is configured; annotations are complete and checked by ruff. |
+| 13 | Dependencies are declared and pinned in the project's dependency file, none unused | Pass | `pyproject.toml` declares Selenium (runtime) and pytest, pytest-cov, ruff (dev) with lower bounds; none is unused. |
+| 14 | Each piece of knowledge (a business rule, constant, format, validation or query) is defined in one place; code is merged only where it expresses the same knowledge, not where it merely looks alike | Pass | Each rule, constant and message exists once (constants in `constants.py`, rules in `domain/`). |
+| 15 | Imports point inward: business-rule modules import no framework, database, UI or delivery-mechanism code, and there are no import cycles | Pass | `domain` and `application` import no Selenium; only `infrastructure` imports it; no import cycle exists. |
+| 16 | SOLID holds: a class or module has one reason to change; new behaviour is added by extension, not by editing a type test in several places; subclasses honour the contract of their base; protocols are narrow; high-level code depends on protocols or abstract types and receives its implementations | Pass | One reason to change per module; the adapter hides Selenium behind a port; fakes honour the port contract. |
+| 17 | Source is laid out in the layers and folders of the clean architecture folder structure (`domain`, `application`, `infrastructure`, `presentation` packages under `src/`, and `unit`, `integration` and `e2e` under `tests/`), in `snake_case`, and imports between the layers point inward | Pass | Layout follows `src/snack_and_lift/{domain,application,infrastructure}` and `tests/{unit,integration,e2e}`; there is no presentation layer for a command-line bot (ADR-0002). |
+| 18 | File and folder names are English, contain no space and no character outside letters, digits, `-`, `_` and `.`, and follow the casing of the language for files | Pass | All file and folder names are English lowercase with `_`, `-` and `.` only. |
+
+## Overall Verdict
+
+Go-with-conditions - the code of MIL-005 meets every Mandatory criterion of QC-PY-001 and there is no blocking finding, but part of the gate evidence cannot be produced by the stand-in. Gate criterion 1 (unit tests of counters, summary and detail list) is met. Criterion 2 (a container run on the live site that processes every Tuesday and Thursday card once) is not verified, and criterion 3 is not met: `step-5.png` and `step-6.png` come from a run with an account. The framework forbids the stand-in to enter passwords or register on a third-party site; a container test against the local fixture checks that every target card is processed once. The review is not independent: the AI wrote and reviewed it as stand-in for S02, and S01 can challenge it in the end-of-run summary.
+
+## Action Items
+
+| Action | Owner | Due |
+| --- | --- | --- |
+| Run the bot with your own account and keep `docs/images/step-5.png` and `step-6.png` | S01 | when S01 has time |
+
+---
+
+[MIL-005]: ../../milestones/mil-005-counters-and-both-days.md
+[QC-PY-001]: ../../../framework/qc/code/qc-programming-python.md
+[45e6fc7]: https://git.tirsystem.com/Tirsvad-Udemy-100-days-of-code/049-snack-and-lift/commit/45e6fc72dfb39d3bb58b4129a159fe3727aa26c2
@@ -0,0 +1,62 @@
+# SQA Review Record
+
+## Metadata
+| Key | Value |
+| --- | --- |
+| ID | RC-020 |
+| CrossReference | [MIL-006], [QC-PY-001] |
+
+## Version History
+| Date | Status | Author | Reviewer | Change | Commit |
+| --- | --- | --- | --- | --- | --- |
+| 2026-10-28 | Accepted | Jens Tirsvad Nielsen | AI as stand-in for S02 | Review record, full review of the source and tests of MIL-006 | [f57040e] |
+
+---
+
+## Artifact Under Review
+
+- Instance reviewed: [MIL-006]
+- Checklist used: [QC-PY-001] (`QC-PY-001`)
+- Scope: full review of the source and tests of MIL-006
+- Language and domain: n/a
+- Language reviewer: none
+- Mode: autonomous, not independent (the reviewer is `AI as stand-in for S02`)
+
+## Checklist Results
+
+| # | Criterion | Status | Evidence/Notes |
+| --- | --- | --- | --- |
+| 1 | Packages, modules, functions, variables, classes and constants follow PEP 8 casing (`snake_case`, `PascalCase`, `UPPER_SNAKE`) | Pass | Modules, functions and variables are `snake_case`, classes `PascalCase`, constants `UPPER_SNAKE`; `ruff check` with the N rules passes. |
+| 2 | Names state purpose in the domain's language; no unexplained abbreviations, no single-letter names outside tiny scopes | Pass | Names state purpose (for example `retry`, `login`, `book_class`, `get_my_bookings`); no single-letter names outside comprehensions. |
+| 3 | Code is produced by the project's formatter and passes its linter with no unexplained suppressions | Pass | `ruff format` leaves 0 files changed and `ruff check` reports 0 findings; there is no suppression. |
+| 4 | Every function and method signature is type-annotated, including `-> None` | Pass | Every function and method has annotations (ruff ANN rules pass), including `-> None`. |
+| 5 | No bare `except:`, no swallowed exceptions; specific exceptions are raised and the cause is kept (`raise ... from`) | Pass | No bare `except`; specific exceptions are caught, and re-raised with `raise ... from` where the cause matters. |
+| 6 | No mutable default arguments and no shadowed builtins | Pass | No mutable default arguments; no builtin is shadowed (ruff B and A-style checks pass). |
+| 7 | Files, locks and connections are managed with context managers | Pass | Files and the browser are managed with `with`/`try-finally`; no unmanaged file handle exists. |
+| 8 | Public modules, classes and functions have docstrings that say what, not how | Pass | Public modules, classes and functions have Doxygen docstrings (`@brief`, `@param`, `@return`). |
+| 9 | Logging uses `logging`, not `print`; no secrets or personal data in log output | Pass | No print calls; messages go through `logging`. |
+| 10 | Classes and operations trace to the Design Class Diagram they implement; deviations are recorded | N-A | No Design Class Diagram exists; ADR-0001 records that design artifacts are skipped. Classes follow ADR-0002. |
+| 11 | Tests exist for new behaviour, are named for the behaviour, and do not depend on order or the network | Pass | 174 unit tests (booking entries, verification, date independence for all seven starting weekdays, command line) need no browser or network; 15 container tests run the adapter against local fixtures; coverage of the non-infrastructure modules is 100%. |
+| 12 | Type checker runs in strict mode without errors; `Any` is justified in a comment | N-A | No strict type checker is configured; annotations are complete and checked by ruff. |
+| 13 | Dependencies are declared and pinned in the project's dependency file, none unused | Pass | `pyproject.toml` declares Selenium (runtime) and pytest, pytest-cov, ruff (dev) with lower bounds; none is unused. |
+| 14 | Each piece of knowledge (a business rule, constant, format, validation or query) is defined in one place; code is merged only where it expresses the same knowledge, not where it merely looks alike | Pass | Each rule, constant and message exists once (constants in `constants.py`, rules in `domain/`). |
+| 15 | Imports point inward: business-rule modules import no framework, database, UI or delivery-mechanism code, and there are no import cycles | Pass | `domain` and `application` import no Selenium; only `infrastructure` imports it; no import cycle exists. |
+| 16 | SOLID holds: a class or module has one reason to change; new behaviour is added by extension, not by editing a type test in several places; subclasses honour the contract of their base; protocols are narrow; high-level code depends on protocols or abstract types and receives its implementations | Pass | One reason to change per module; the adapter hides Selenium behind a port; fakes honour the port contract. |
+| 17 | Source is laid out in the layers and folders of the clean architecture folder structure (`domain`, `application`, `infrastructure`, `presentation` packages under `src/`, and `unit`, `integration` and `e2e` under `tests/`), in `snake_case`, and imports between the layers point inward | Pass | Layout follows `src/snack_and_lift/{domain,application,infrastructure}` and `tests/{unit,integration,e2e}`; there is no presentation layer for a command-line bot (ADR-0002). |
+| 18 | File and folder names are English, contain no space and no character outside letters, digits, `-`, `_` and `.`, and follow the casing of the language for files | Pass | All file and folder names are English lowercase with `_`, `-` and `.` only. |
+
+## Overall Verdict
+
+Go-with-conditions - the code of MIL-006 meets every Mandatory criterion of QC-PY-001 and there is no blocking finding, but part of the gate evidence cannot be produced by the stand-in. Gate criterion 1 (unit tests of the comparison and the mismatch message) is met, and the date independence is tested for every starting weekday (no hardcoded date, no list-position rule). Criteria 2 and 3 (container runs on the live site, including after the admin advances 3 days) are not verified, and criterion 4 is not met: `step-7.png` and `step-8.png` come from a run with an account. The framework forbids the stand-in to enter passwords or register on a third-party site; the admin time controls also need a login. The review is not independent: the AI wrote and reviewed it as stand-in for S02, and S01 can challenge it in the end-of-run summary.
+
+## Action Items
+
+| Action | Owner | Due |
+| --- | --- | --- |
+| Run the bot with your own account (also after advancing the site 3 days as admin) and keep `docs/images/step-7.png` and `step-8.png` | S01 | when S01 has time |
+
+---
+
+[MIL-006]: ../../milestones/mil-006-verify-and-time-travel.md
+[QC-PY-001]: ../../../framework/qc/code/qc-programming-python.md
+[f57040e]: https://git.tirsystem.com/Tirsvad-Udemy-100-days-of-code/049-snack-and-lift/commit/f57040e136feac01f10d99279038f48992518f43
@@ -0,0 +1,62 @@
+# SQA Review Record
+
+## Metadata
+| Key | Value |
+| --- | --- |
+| ID | RC-021 |
+| CrossReference | [MIL-007], [QC-PY-001] |
+
+## Version History
+| Date | Status | Author | Reviewer | Change | Commit |
+| --- | --- | --- | --- | --- | --- |
+| 2026-10-28 | Accepted | Jens Tirsvad Nielsen | AI as stand-in for S02 | Review record, full review of the source and tests of MIL-007 | [5d28e68] |
+
+---
+
+## Artifact Under Review
+
+- Instance reviewed: [MIL-007]
+- Checklist used: [QC-PY-001] (`QC-PY-001`)
+- Scope: full review of the source and tests of MIL-007
+- Language and domain: n/a
+- Language reviewer: none
+- Mode: autonomous, not independent (the reviewer is `AI as stand-in for S02`)
+
+## Checklist Results
+
+| # | Criterion | Status | Evidence/Notes |
+| --- | --- | --- | --- |
+| 1 | Packages, modules, functions, variables, classes and constants follow PEP 8 casing (`snake_case`, `PascalCase`, `UPPER_SNAKE`) | Pass | Modules, functions and variables are `snake_case`, classes `PascalCase`, constants `UPPER_SNAKE`; `ruff check` with the N rules passes. |
+| 2 | Names state purpose in the domain's language; no unexplained abbreviations, no single-letter names outside tiny scopes | Pass | Names state purpose (for example `retry`, `login`, `book_class`, `get_my_bookings`); no single-letter names outside comprehensions. |
+| 3 | Code is produced by the project's formatter and passes its linter with no unexplained suppressions | Pass | `ruff format` leaves 0 files changed and `ruff check` reports 0 findings; there is no suppression. |
+| 4 | Every function and method signature is type-annotated, including `-> None` | Pass | Every function and method has annotations (ruff ANN rules pass), including `-> None`. |
+| 5 | No bare `except:`, no swallowed exceptions; specific exceptions are raised and the cause is kept (`raise ... from`) | Pass | No bare `except`; specific exceptions are caught, and re-raised with `raise ... from` where the cause matters. |
+| 6 | No mutable default arguments and no shadowed builtins | Pass | No mutable default arguments; no builtin is shadowed (ruff B and A-style checks pass). |
+| 7 | Files, locks and connections are managed with context managers | Pass | Files and the browser are managed with `with`/`try-finally`; no unmanaged file handle exists. |
+| 8 | Public modules, classes and functions have docstrings that say what, not how | Pass | Public modules, classes and functions have Doxygen docstrings (`@brief`, `@param`, `@return`). |
+| 9 | Logging uses `logging`, not `print`; no secrets or personal data in log output | Pass | No print calls; messages go through `logging`. |
+| 10 | Classes and operations trace to the Design Class Diagram they implement; deviations are recorded | N-A | No Design Class Diagram exists; ADR-0001 records that design artifacts are skipped. Classes follow ADR-0002. |
+| 11 | Tests exist for new behaviour, are named for the behaviour, and do not depend on order or the network | Pass | 237 unit tests (retry, resilient login, booking and bookings read, a seeded chaos test at 50% failure: 97 of 100 seeds complete, seeds 0 to 17 must all pass) need no browser or network; 20 container tests run the adapter against failing local fixtures; coverage of the non-infrastructure modules is 100%. |
+| 12 | Type checker runs in strict mode without errors; `Any` is justified in a comment | N-A | No strict type checker is configured; annotations are complete and checked by ruff. |
+| 13 | Dependencies are declared and pinned in the project's dependency file, none unused | Pass | `pyproject.toml` declares Selenium (runtime) and pytest, pytest-cov, ruff (dev) with lower bounds; none is unused. |
+| 14 | Each piece of knowledge (a business rule, constant, format, validation or query) is defined in one place; code is merged only where it expresses the same knowledge, not where it merely looks alike | Pass | Each rule, constant and message exists once (constants in `constants.py`, rules in `domain/`). |
+| 15 | Imports point inward: business-rule modules import no framework, database, UI or delivery-mechanism code, and there are no import cycles | Pass | `domain` and `application` import no Selenium; only `infrastructure` imports it; no import cycle exists. |
+| 16 | SOLID holds: a class or module has one reason to change; new behaviour is added by extension, not by editing a type test in several places; subclasses honour the contract of their base; protocols are narrow; high-level code depends on protocols or abstract types and receives its implementations | Pass | One reason to change per module; the adapter hides Selenium behind a port; fakes honour the port contract. |
+| 17 | Source is laid out in the layers and folders of the clean architecture folder structure (`domain`, `application`, `infrastructure`, `presentation` packages under `src/`, and `unit`, `integration` and `e2e` under `tests/`), in `snake_case`, and imports between the layers point inward | Pass | Layout follows `src/snack_and_lift/{domain,application,infrastructure}` and `tests/{unit,integration,e2e}`; there is no presentation layer for a command-line bot (ADR-0002). |
+| 18 | File and folder names are English, contain no space and no character outside letters, digits, `-`, `_` and `.`, and follow the casing of the language for files | Pass | All file and folder names are English lowercase with `_`, `-` and `.` only. |
+
+## Overall Verdict
+
+Go-with-conditions - the code of MIL-007 meets every Mandatory criterion of QC-PY-001 and there is no blocking finding, but part of the gate evidence cannot be produced by the stand-in. Gate criteria 1 (retry unit tests) and 2 (a booking only counts when the page confirms it) are met in tests. Criterion 3 (three container runs on the live site at 50% simulated failure) is not verified, and criterion 4 is not met: `step-9.png` comes from a run with an account. The framework forbids the stand-in to enter passwords or register on a third-party site, and the network simulation is an admin control behind a login. Known behaviour: a wrong password or an empty bookings page is also retried seven times (about 3 seconds) before exit code 1. The review is not independent: the AI wrote and reviewed it as stand-in for S02, and S01 can challenge it in the end-of-run summary.
+
+## Action Items
+
+| Action | Owner | Due |
+| --- | --- | --- |
+| Enable the network simulation at 50% as admin, run the bot three times with your own account and keep `docs/images/step-9.png` | S01 | when S01 has time |
+
+---
+
+[MIL-007]: ../../milestones/mil-007-resilience.md
+[QC-PY-001]: ../../../framework/qc/code/qc-programming-python.md
+[5d28e68]: https://git.tirsystem.com/Tirsvad-Udemy-100-days-of-code/049-snack-and-lift/commit/5d28e682b41e1a03b0cac1a6b2ea4977750d45b8
@@ -38,6 +38,10 @@ Tracks backward and forward links between artifact instances so that the Busines
 | [MIL-008] | Milestone | en | it | [BC-001], [PP-001] | - | RC-015 |
 | Source and tests of [MIL-002] | Python source code | - | - | [MIL-002], [ADR-0002], [ADR-0003] | - | RC-016 |
 | Source and tests of [MIL-003] | Python source code | - | - | [MIL-003], [ADR-0002], [ADR-0003] | - | RC-017 (Go-with-conditions) |
+| Source and tests of [MIL-004] | Python source code | - | - | [MIL-004], [ADR-0002] | - | RC-018 (Go-with-conditions) |
+| Source and tests of [MIL-005] | Python source code | - | - | [MIL-005], [ADR-0002] | - | RC-019 (Go-with-conditions) |
+| Source and tests of [MIL-006] | Python source code | - | - | [MIL-006], [ADR-0002] | - | RC-020 (Go-with-conditions) |
+| Source and tests of [MIL-007] | Python source code | - | - | [MIL-007], [ADR-0002] | - | RC-021 (Go-with-conditions) |

 ## Concern Coverage

@@ -0,0 +1,148 @@
+"""@file booking.py
+@brief Lecture steps 3 to 6: book the Tuesday and Thursday 6pm classes and report their state.
+"""
+
+import logging
+import time
+from collections.abc import Callable
+
+from snack_and_lift import constants
+from snack_and_lift.application.ports import GymPort
+from snack_and_lift.application.retry import Sleep, retry
+from snack_and_lift.domain.errors import GymError
+from snack_and_lift.domain.models import ButtonState, ClassCard, ClassResult
+from snack_and_lift.domain.rules import (
+    CONFIRMED_STATE,
+    OUTCOME_OF_ACTION,
+    decide_outcome_action,
+    find_next_class,
+    find_target_classes,
+    format_outcome,
+)
+
+logger = logging.getLogger(__name__)
+
+
+def book_class(gym: GymPort, card: ClassCard) -> ClassResult:
+    """@brief Book or waitlist a class, or report that it already is.
+
+    @param gym The gym site.
+    @param card The class, as read from the page.
+    @return The class and what happened.
+    @exception UnknownButtonError The button is busy, completed or unknown.
+    @exception GymError The click failed or was not confirmed by the button.
+    """
+    action = decide_outcome_action(card)
+    expected = CONFIRMED_STATE.get(action)
+    if expected is not None:
+        new_text = gym.press_class_button(card.card_id)
+        if ButtonState.from_text(new_text) is not expected:
+            raise GymError(f"click not confirmed: the button says {new_text!r}")
+    outcome = OUTCOME_OF_ACTION[action]
+    logger.info(format_outcome(outcome, card))
+    return ClassResult(card, outcome)
+
+
+def _read_current_card(gym: GymPort, card: ClassCard) -> ClassCard:
+    """@brief Read a class again from the page, to see what an earlier attempt did.
+
+    @param gym The gym site.
+    @param card The class, as it was read before.
+    @return The class with the state the page shows now.
+    @exception GymError The schedule could not be read or the class is no longer on it.
+    """
+    for current in gym.list_class_cards():
+        if current.card_id == card.card_id:
+            return current
+    raise GymError(constants.MESSAGE_CLASS_NOT_ON_SCHEDULE.format(card_id=card.card_id))
+
+
+def book_class_with_retry(
+    gym: GymPort,
+    card: ClassCard,
+    retries: int = constants.RETRY_COUNT,
+    sleep: Sleep = time.sleep,
+) -> ClassResult:
+    """@brief Book a class, repeating it when the site drops the request.
+
+    Before each repeat the class is read from the page again. When the button now shows the
+    state that the click should give, the click did go through although its confirmation
+    failed, so the class counts as newly booked or waitlisted and is not clicked again.
+
+    @param gym The gym site.
+    @param card The class, as read from the page.
+    @param retries The most attempts to make.
+    @param sleep Waits between two attempts.
+    @return The class and what happened.
+    @exception RetriesExhaustedError Every attempt failed.
+    """
+    attempts = 0
+
+    def attempt() -> ClassResult:
+        nonlocal attempts
+        attempts += 1
+        if attempts == 1:
+            return book_class(gym, card)
+        current = _read_current_card(gym, card)
+        action = decide_outcome_action(card)
+        if CONFIRMED_STATE.get(action) is current.state:
+            outcome = OUTCOME_OF_ACTION[action]
+            logger.info(format_outcome(outcome, card))
+            return ClassResult(card, outcome)
+        return book_class(gym, current)
+
+    description = constants.RETRY_DESCRIPTION_BOOK.format(name=card.name, day=card.day_label)
+    return retry(attempt, retries, description, sleep=sleep)
+
+
+def book_next_tuesday(
+    gym: GymPort, retries: int = constants.RETRY_COUNT, sleep: Sleep = time.sleep
+) -> ClassResult | None:
+    """@brief Book the next Tuesday class at the target time.
+
+    @param gym The gym site.
+    @param retries The most attempts to book the class.
+    @param sleep Waits between two attempts.
+    @return The result, or None when the schedule has no such class.
+    @exception GymError The page could not be read or the booking failed on every attempt.
+    """
+    card = find_next_class(gym.list_class_cards(), constants.NEXT_CLASS_WEEKDAY)
+    if card is None:
+        logger.warning(
+            constants.MESSAGE_NO_CLASS_FOUND.format(
+                weekday=constants.NEXT_CLASS_WEEKDAY,
+                time=constants.TARGET_TIME_TEXT,
+            )
+        )
+        return None
+    return book_class_with_retry(gym, card, retries, sleep)
+
+
+def book_target_classes(
+    gym: GymPort,
+    on_result: Callable[[ClassResult], None] | None = None,
+    retries: int = constants.RETRY_COUNT,
+    sleep: Sleep = time.sleep,
+) -> list[ClassResult]:
+    """@brief Book every Tuesday and Thursday class at the target time, in page order.
+
+    The cards are listed once; each class is found again by its id when it is pressed.
+
+    @param gym The gym site.
+    @param on_result Called after each class was handled, for example to take a screenshot.
+    @param retries The most attempts to book one class.
+    @param sleep Waits between two attempts.
+    @return What happened to each class; empty when the schedule has none.
+    @exception GymError The page could not be read or a booking failed on every attempt.
+    """
+    cards = find_target_classes(gym.list_class_cards())
+    if not cards:
+        logger.warning(constants.MESSAGE_NO_TARGET_CLASSES.format(time=constants.TARGET_TIME_TEXT))
+        return []
+    results: list[ClassResult] = []
+    for card in cards:
+        result = book_class_with_retry(gym, card, retries, sleep)
+        results.append(result)
+        if on_result is not None:
+            on_result(result)
+    return results
@@ -5,6 +5,9 @@
 from pathlib import Path
 from typing import Protocol

+from snack_and_lift.domain.booking_entry import BookingEntry
+from snack_and_lift.domain.models import ClassCard
+

 class GymPort(Protocol):
    """@brief The gym site as the use cases see it."""
@@ -26,6 +29,47 @@ class GymPort(Protocol):
        """
        ...

+    def list_class_cards(self) -> list[ClassCard]:
+        """@brief Read every class card of the schedule, in page order.
+
+        @return The classes, each with the day of its group.
+        @exception GymError The schedule could not be read.
+        """
+        ...
+
+    def press_class_button(self, card_id: str) -> str:
+        """@brief Click the button of a class and wait until the request has finished.
+
+        @param card_id The id of the card without its prefix.
+        @return The new text of the button.
+        @exception GymError The site shows an error for the class (the message is its text)
+            or nothing settled in time.
+        """
+        ...
+
+    def open_my_bookings(self) -> None:
+        """@brief Open the My Bookings page and wait until it is shown.
+
+        @exception GymError The page did not load.
+        """
+        ...
+
+    def list_my_bookings(self) -> list[BookingEntry]:
+        """@brief Read every confirmed booking and waitlist entry of the My Bookings page.
+
+        @return The entries, confirmed ones first; empty when the page shows its empty state.
+        @exception GymError The page shows an error (the message is its text) or did not settle.
+        """
+        ...
+
+    def save_text_screenshot(self, text: str, path: Path) -> None:
+        """@brief Save an image of console text.
+
+        @param text The lines to draw, in a dark monospace style.
+        @param path The PNG file to write; its folders are created.
+        """
+        ...
+
    def save_screenshot(self, path: Path) -> None:
        """@brief Save a screenshot of the current page.

@@ -0,0 +1,67 @@
+"""@file retry.py
+@brief Lecture step 9: repeat a step that failed because the site dropped a request.
+"""
+
+import logging
+import time
+from collections.abc import Callable
+
+from snack_and_lift import constants
+from snack_and_lift.domain.errors import GymError, RetriesExhaustedError
+
+logger = logging.getLogger(__name__)
+
+## Waits for a number of seconds; tests pass a recorder so that they never really sleep.
+Sleep = Callable[[float], None]
+
+
+def retry[T](
+    func: Callable[[], T],
+    retries: int = constants.RETRY_COUNT,
+    description: str | None = None,
+    *,
+    delay: float = constants.RETRY_DELAY_SECONDS,
+    sleep: Sleep = time.sleep,
+) -> T:
+    """@brief Call a function until it succeeds, at most `retries` times.
+
+    Only a `GymError` is repeated: it is what a dropped request looks like. Any other error,
+    such as missing credentials, is a defect and passes through at once.
+
+    @param func The step, called without arguments.
+    @param retries The most attempts to make, at least 1.
+    @param description What the step does, for the log (never put a secret in it).
+    @param delay Seconds to wait between two attempts.
+    @param sleep Waits for a number of seconds.
+    @return What the function returned on its first successful attempt.
+    @exception ValueError `retries` is below 1.
+    @exception RetriesExhaustedError Every attempt raised a `GymError`; the last one is the cause.
+    """
+    if retries < 1:
+        raise ValueError(constants.MESSAGE_RETRIES_INVALID.format(retries=retries))
+    name = description or constants.RETRY_DEFAULT_DESCRIPTION
+    for attempt in range(1, retries + 1):
+        try:
+            result = func()
+        except GymError as error:
+            if attempt == retries:
+                message = constants.MESSAGE_RETRIES_EXHAUSTED.format(
+                    description=name, retries=retries, error=error
+                )
+                raise RetriesExhaustedError(message) from error
+            logger.warning(
+                constants.MESSAGE_RETRY_FAILED.format(
+                    attempt=attempt,
+                    retries=retries,
+                    description=name,
+                    error=str(error).rstrip("."),
+                )
+            )
+            sleep(delay)
+        else:
+            if attempt > 1:
+                logger.info(
+                    constants.MESSAGE_RETRY_SUCCEEDED.format(description=name, attempts=attempt)
+                )
+            return result
+    raise AssertionError("unreachable: the last attempt returns or raises")  # pragma: no cover
@@ -3,9 +3,12 @@
 """

 import logging
+import time

+from snack_and_lift import constants
 from snack_and_lift.application.credentials import Credentials
 from snack_and_lift.application.ports import GymPort
+from snack_and_lift.application.retry import Sleep, retry

 logger = logging.getLogger(__name__)

@@ -19,3 +22,25 @@ def login(gym: GymPort, credentials: Credentials) -> None:
    """
    gym.log_in(credentials.email, credentials.password)
    logger.info("✓ Logged in: the class schedule is shown")
+
+
+def login_with_retry(
+    gym: GymPort,
+    credentials: Credentials,
+    retries: int = constants.RETRY_COUNT,
+    sleep: Sleep = time.sleep,
+) -> None:
+    """@brief Log in, repeating the login when the site drops the request.
+
+    @param gym The gym site.
+    @param credentials The account to log in with.
+    @param retries The most attempts to make.
+    @param sleep Waits between two attempts.
+    @exception RetriesExhaustedError Every attempt failed.
+    """
+    retry(
+        lambda: login(gym, credentials),
+        retries,
+        constants.RETRY_DESCRIPTION_LOGIN,
+        sleep=sleep,
+    )
@@ -0,0 +1,73 @@
+"""@file verification.py
+@brief Lecture steps 7 and 8: check the bookings on the My Bookings page.
+"""
+
+import logging
+import time
+from collections.abc import Sequence
+
+from snack_and_lift import constants
+from snack_and_lift.application.ports import GymPort
+from snack_and_lift.application.retry import Sleep, retry
+from snack_and_lift.domain.booking_entry import BookingEntry, is_target_entry
+from snack_and_lift.domain.errors import NoBookingsFoundError
+from snack_and_lift.domain.models import ClassResult
+from snack_and_lift.domain.verification import VerificationResult, build_verification
+
+logger = logging.getLogger(__name__)
+
+
+def get_my_bookings(gym: GymPort) -> list[BookingEntry]:
+    """@brief Open the My Bookings page and read all its entries.
+
+    @param gym The gym site.
+    @return Every confirmed booking and waitlist entry, not only the target classes.
+    @exception NoBookingsFoundError The page shows no entry at all.
+    @exception GymError The page could not be opened or read.
+    """
+    gym.open_my_bookings()
+    entries = gym.list_my_bookings()
+    if not entries:
+        raise NoBookingsFoundError(constants.MESSAGE_NO_BOOKINGS_FOUND)
+    return entries
+
+
+def get_my_bookings_with_retry(
+    gym: GymPort, retries: int = constants.RETRY_COUNT, sleep: Sleep = time.sleep
+) -> list[BookingEntry]:
+    """@brief Read the My Bookings page, repeating it when the page fails to load.
+
+    @param gym The gym site.
+    @param retries The most attempts to make.
+    @param sleep Waits between two attempts.
+    @return Every confirmed booking and waitlist entry.
+    @exception RetriesExhaustedError Every attempt failed.
+    """
+    return retry(
+        lambda: get_my_bookings(gym), retries, constants.RETRY_DESCRIPTION_BOOKINGS, sleep=sleep
+    )
+
+
+def verify_bookings(
+    gym: GymPort,
+    results: Sequence[ClassResult],
+    retries: int = constants.RETRY_COUNT,
+    sleep: Sleep = time.sleep,
+) -> VerificationResult:
+    """@brief Compare what the bot booked with the My Bookings page.
+
+    The page is not opened when the bot handled no class.
+
+    @param gym The gym site.
+    @param results What happened to each class.
+    @param retries The most attempts to read the page.
+    @param sleep Waits between two attempts.
+    @return The comparison of the expected entries with the Tuesday and Thursday 6pm entries.
+    @exception RetriesExhaustedError The page could not be read on any attempt.
+    """
+    if not results:
+        return build_verification(results, [])
+    entries = [
+        entry for entry in get_my_bookings_with_retry(gym, retries, sleep) if is_target_entry(entry)
+    ]
+    return build_verification(results, entries)
@@ -6,14 +6,23 @@ import argparse
 import logging
 import os
 import sys
+import time
 from collections.abc import Callable, Sequence
 from pathlib import Path

-from snack_and_lift.application.credentials import load_credentials
+from snack_and_lift import constants
+from snack_and_lift.application.booking import book_next_tuesday, book_target_classes
+from snack_and_lift.application.credentials import Credentials, load_credentials
 from snack_and_lift.application.ports import GymPort
-from snack_and_lift.application.session import login
-from snack_and_lift.domain.errors import LoginFailedError, MissingCredentialsError
+from snack_and_lift.application.retry import Sleep
+from snack_and_lift.application.session import login_with_retry
+from snack_and_lift.application.verification import verify_bookings
+from snack_and_lift.domain.errors import GymError, LoginFailedError, MissingCredentialsError
+from snack_and_lift.domain.models import ClassResult
+from snack_and_lift.domain.report import format_detail_list, format_summary
+from snack_and_lift.domain.verification import format_verification
 from snack_and_lift.infrastructure.browser import create_driver, default_profile_dir
+from snack_and_lift.infrastructure.console_recorder import ConsoleRecorder
 from snack_and_lift.infrastructure.selenium_gym import SeleniumGym

 ## Builds the gym site from (headless, profile folder, keep open).
@@ -33,6 +42,22 @@ def selenium_gym_factory(headless: bool, profile_dir: Path, keep_open: bool) ->
    return SeleniumGym(create_driver(headless, profile_dir, keep_open))


+def _at_least_one(text: str) -> int:
+    """@brief Read a whole number of at least 1 for an option.
+
+    @param text The text of the option.
+    @return The number.
+    @exception argparse.ArgumentTypeError The text is not a whole number of at least 1.
+    """
+    try:
+        number = int(text)
+    except ValueError:
+        number = 0
+    if number < 1:
+        raise argparse.ArgumentTypeError(f"{text!r} is not a whole number of at least 1")
+    return number
+
+
 def parse_args(argv: Sequence[str] | None = None) -> argparse.Namespace:
    """@brief Read the command line.

@@ -42,6 +67,10 @@ def parse_args(argv: Sequence[str] | None = None) -> argparse.Namespace:
    parser = argparse.ArgumentParser(
        prog="snack-and-lift",
        description="Books the Tuesday and Thursday 6pm classes at the Snack and Lift gym.",
+        epilog=(
+            "exit codes: 0 done, 1 a step failed (also when every retry failed), "
+            "2 credentials missing, 3 the My Bookings page does not match the bookings made"
+        ),
    )
    parser.add_argument(
        "--headless",
@@ -66,6 +95,21 @@ def parse_args(argv: Sequence[str] | None = None) -> argparse.Namespace:
        default=None,
        help="save a screenshot after each step into this folder",
    )
+    parser.add_argument(
+        "--first-tuesday-only",
+        action="store_true",
+        help="book only the next Tuesday 6pm class (lecture steps 3 and 4); skips the verification",
+    )
+    parser.add_argument(
+        "--retries",
+        type=_at_least_one,
+        default=constants.RETRY_COUNT,
+        metavar="N",
+        help=(
+            "attempts for the login, each booking and the My Bookings page when the site "
+            f"drops a request (default: {constants.RETRY_COUNT}, at least 1)"
+        ),
+    )
    args = parser.parse_args(argv)
    if args.keep_open is None:
        args.keep_open = not args.headless
@@ -92,17 +136,109 @@ def _save_step(gym: GymPort, screenshot_dir: Path | None, name: str) -> None:
        gym.save_screenshot(screenshot_dir / name)


+def _save_console(gym: GymPort, screenshot_dir: Path | None, text: str, name: str) -> None:
+    """@brief Save console text as an image when a folder was asked for.
+
+    @param gym The gym site.
+    @param screenshot_dir The folder, or None for no screenshots.
+    @param text The console text to draw.
+    @param name The file name.
+    """
+    if screenshot_dir is not None:
+        gym.save_text_screenshot(text, screenshot_dir / name)
+
+
+def _run(
+    gym: GymPort,
+    args: argparse.Namespace,
+    recorder: ConsoleRecorder,
+    credentials: Credentials,
+    sleep: Sleep,
+) -> bool:
+    """@brief Open the site, log in, book the classes and verify them, saving the step images.
+
+    Books every Tuesday and Thursday 6pm class, logs the summary and the detailed list and
+    verifies the bookings on the My Bookings page; with `--first-tuesday-only` it books the
+    next Tuesday class only and does not verify.
+
+    @param gym The gym site.
+    @param args The parsed options.
+    @param recorder The recorded console lines, drawn for step 4.
+    @param credentials The account to log in with.
+    @param sleep Waits between two attempts of a retried step.
+    @return False when the My Bookings page does not match the bookings made, else True.
+    @exception GymError A step failed on every attempt.
+    """
+    gym.open_site()
+    _save_step(gym, args.screenshot_dir, "step-1.png")
+    login_with_retry(gym, credentials, args.retries, sleep)
+    _save_step(gym, args.screenshot_dir, "step-2.png")
+    if args.first_tuesday_only:
+        book_next_tuesday(gym, args.retries, sleep)
+        _save_step(gym, args.screenshot_dir, constants.SCREENSHOT_STEP_3)
+        _save_console(gym, args.screenshot_dir, recorder.text, constants.SCREENSHOT_STEP_4)
+        return True
+    window_saved = False
+
+    def save_window_once(_: ClassResult) -> None:
+        nonlocal window_saved
+        if not window_saved:
+            _save_step(gym, args.screenshot_dir, constants.SCREENSHOT_STEP_3)
+            window_saved = True
+
+    results = book_target_classes(gym, save_window_once, args.retries, sleep)
+    if not window_saved:
+        _save_step(gym, args.screenshot_dir, constants.SCREENSHOT_STEP_3)
+    _save_console(gym, args.screenshot_dir, recorder.text, constants.SCREENSHOT_STEP_4)
+    summary = format_summary(results)
+    logger.info("%s", summary)
+    _save_console(gym, args.screenshot_dir, summary, constants.SCREENSHOT_STEP_5)
+    detail = format_detail_list(results)
+    logger.info("%s", detail)
+    _save_console(gym, args.screenshot_dir, f"{summary}\n{detail}", constants.SCREENSHOT_STEP_6)
+    verification = verify_bookings(gym, results, args.retries, sleep)
+    _save_step(gym, args.screenshot_dir, constants.SCREENSHOT_STEP_7)
+    verification_text = format_verification(verification)
+    logger.info("%s", verification_text)
+    _save_console(gym, args.screenshot_dir, verification_text, constants.SCREENSHOT_STEP_8)
+    _save_console(gym, args.screenshot_dir, recorder.text, constants.SCREENSHOT_STEP_9)
+    return verification.is_success
+
+
 def main(
    argv: Sequence[str] | None = None,
    gym_factory: GymFactory = selenium_gym_factory,
+    sleep: Sleep = time.sleep,
 ) -> int:
-    """@brief Start the bot: open the site and log in.
+    """@brief Start the bot: open the site, log in, book the classes and verify them.

    @param argv Arguments without the program name; None reads `sys.argv`.
    @param gym_factory Builds the gym site; tests pass a fake.
-    @return Process exit code: 0 done, 1 login failed, 2 credentials missing.
+    @param sleep Waits between two attempts of a retried step; tests pass a recorder.
+    @return Process exit code: 0 done, 1 a step failed, 2 credentials missing, 3 mismatch.
    """
    logging.basicConfig(level=logging.INFO, format="%(message)s")
+    root = logging.getLogger()
+    root.setLevel(logging.INFO)
+    recorder = ConsoleRecorder()
+    root.addHandler(recorder)
+    try:
+        return _main(argv, gym_factory, recorder, sleep)
+    finally:
+        root.removeHandler(recorder)
+
+
+def _main(
+    argv: Sequence[str] | None, gym_factory: GymFactory, recorder: ConsoleRecorder, sleep: Sleep
+) -> int:
+    """@brief The body of `main`, run while the recorder is attached.
+
+    @param argv Arguments without the program name.
+    @param gym_factory Builds the gym site.
+    @param recorder The console recorder.
+    @param sleep Waits between two attempts of a retried step.
+    @return Process exit code.
+    """
    _use_utf8_output()
    args = parse_args(argv)
    try:
@@ -112,14 +248,14 @@ def main(
        return 2
    gym = gym_factory(args.headless, args.profile_dir, args.keep_open)
    try:
-        gym.open_site()
-        _save_step(gym, args.screenshot_dir, "step-1.png")
-        login(gym, credentials)
-        _save_step(gym, args.screenshot_dir, "step-2.png")
+        verified = _run(gym, args, recorder, credentials, sleep)
    except LoginFailedError as error:
        logger.error("Login failed: %s", error)
        return 1
+    except GymError as error:
+        logger.error("Failed: %s", error)
+        return 1
    finally:
        if not args.keep_open:
            gym.close()
-    return 0
+    return 0 if verified else constants.EXIT_VERIFICATION_MISMATCH
@@ -18,6 +18,31 @@ WAIT_TIMEOUT_SECONDS: Final[int] = 10
 ## Attempts of the `retry` wrapper before it gives up (lecture step 9).
 RETRY_COUNT: Final[int] = 7

+## Seconds to wait between two attempts of the `retry` wrapper.
+RETRY_DELAY_SECONDS: Final[float] = 0.5
+
+## Name of a retried step that was given no description.
+RETRY_DEFAULT_DESCRIPTION: Final[str] = "operation"
+
+## Descriptions of the retried steps, as they appear in the log.
+RETRY_DESCRIPTION_LOGIN: Final[str] = "login"
+RETRY_DESCRIPTION_BOOK: Final[str] = "book {name} on {day}"
+RETRY_DESCRIPTION_BOOKINGS: Final[str] = "get my bookings"
+
+## Messages of the `retry` wrapper.
+MESSAGE_RETRY_FAILED: Final[str] = (
+    "⚠ Attempt {attempt}/{retries} failed: {description}: {error}. Retrying..."
+)
+MESSAGE_RETRY_SUCCEEDED: Final[str] = "✓ {description} succeeded after {attempts} attempts"
+MESSAGE_RETRIES_EXHAUSTED: Final[str] = "{description} failed after {retries} attempts: {error}"
+MESSAGE_RETRIES_INVALID: Final[str] = "retries must be at least 1, got {retries}"
+
+## Error raised when a class card is no longer on the schedule while a booking is repeated.
+MESSAGE_CLASS_NOT_ON_SCHEDULE: Final[str] = "class {card_id} not found on the schedule"
+
+## File name of the screenshot of lecture step 9 (the console with the retry warnings).
+SCREENSHOT_STEP_9: Final[str] = "step-9.png"
+
 ## Weekdays of the classes the bot books, as the site abbreviates them.
 TARGET_WEEKDAYS: Final[tuple[str, ...]] = ("Tue", "Thu")

@@ -64,3 +89,142 @@ HEADLESS_BROWSER_ARGUMENTS: Final[tuple[str, ...]] = (
    "--disable-dev-shm-usage",
    "--disable-gpu",
 )
+
+## Weekday of the class that lecture steps 3 and 4 book, as the site abbreviates it.
+NEXT_CLASS_WEEKDAY: Final[str] = "Tue"
+
+## Hour (24-hour clock) of the class the bot books.
+TARGET_HOUR: Final[int] = 18
+
+## Minute of the class the bot books.
+TARGET_MINUTE: Final[int] = 0
+
+## CSS selector of every class card on the schedule.
+CLASS_CARD_CSS: Final[str] = "div[id^='class-card-']"
+
+## Prefix of the element ids of one card; the card id (for example "123") follows it.
+CLASS_CARD_ID_PREFIX: Final[str] = "class-card-"
+CLASS_NAME_ID_PREFIX: Final[str] = "class-name-"
+CLASS_TIME_ID_PREFIX: Final[str] = "class-time-"
+BOOK_BUTTON_ID_PREFIX: Final[str] = "book-button-"
+COMPLETED_LABEL_ID_PREFIX: Final[str] = "completed-label-"
+CLASS_ERROR_ID_PREFIX: Final[str] = "class-error-"
+
+## XPath, relative to a card, of the title of the day group the card is in (the "ancestor" hint).
+DAY_TITLE_XPATH: Final[str] = (
+    "ancestor::div[starts-with(@id,'day-group-')]//h2[starts-with(@id,'day-title-')]"
+)
+
+## Texts of the button of a card.
+BUTTON_TEXT_BOOK: Final[str] = "Book Class"
+BUTTON_TEXT_JOIN_WAITLIST: Final[str] = "Join Waitlist"
+BUTTON_TEXT_BOOKED: Final[str] = "Booked"
+BUTTON_TEXT_WAITLISTED: Final[str] = "Waitlisted"
+BUTTON_TEXT_BOOKING: Final[str] = "Booking..."
+BUTTON_TEXT_JOINING: Final[str] = "Joining..."
+BUTTON_TEXT_COMPLETED: Final[str] = "Completed"
+
+## Prefix of the time text of a card ("Time: 6:00 PM").
+TIME_TEXT_PREFIX: Final[str] = "Time:"
+
+## Day labels the site wraps around the date of the next two days.
+DAY_LABEL_WRAPPERS: Final[tuple[str, ...]] = ("Today", "Tomorrow")
+
+## Console messages of the booking, with the class name and the day label as the site shows it.
+MESSAGE_BOOKED: Final[str] = "✓ Successfully booked: {name} on {day}"
+MESSAGE_WAITLISTED: Final[str] = "✓ Joined waitlist for: {name} on {day}"
+MESSAGE_ALREADY_BOOKED: Final[str] = "✓ Already booked: {name} on {day}"
+MESSAGE_ALREADY_WAITLISTED: Final[str] = "✓ Already on waitlist: {name} on {day}"
+MESSAGE_NO_CLASS_FOUND: Final[str] = "No {weekday} class at {time} found on the schedule"
+
+## Logged when the schedule has no class on a target weekday at the target time.
+MESSAGE_NO_TARGET_CLASSES: Final[str] = (
+    "No Tuesday or Thursday class at {time} found on the schedule"
+)
+
+## Time of the target classes as written in messages (24-hour clock).
+TARGET_TIME_TEXT: Final[str] = f"{TARGET_HOUR:02d}:{TARGET_MINUTE:02d}"
+
+## Lines of the booking summary (lecture step 5).
+SUMMARY_TITLE: Final[str] = "--- BOOKING SUMMARY ---"
+SUMMARY_NEW_BOOKINGS: Final[str] = "New bookings: {count}"
+SUMMARY_NEW_WAITLIST: Final[str] = "New waitlist entries: {count}"
+SUMMARY_ALREADY_DONE: Final[str] = "Already booked/waitlisted: {count}"
+SUMMARY_TOTAL: Final[str] = "Total Tuesday & Thursday 6pm classes: {count}"
+
+## Lines of the detailed class list (lecture step 6).
+DETAIL_TITLE: Final[str] = "--- DETAILED CLASS LIST ---"
+DETAIL_LINE: Final[str] = "  • [{tag}] {name} on {day}"
+DETAIL_NONE: Final[str] = "  No matching class found"
+DETAIL_TAG_NEW_BOOKING: Final[str] = "New Booking"
+DETAIL_TAG_NEW_WAITLIST: Final[str] = "New Waitlist"
+DETAIL_TAG_ALREADY_BOOKED: Final[str] = "Already Booked"
+DETAIL_TAG_ALREADY_WAITLISTED: Final[str] = "Already Waitlisted"
+
+## File names of the screenshots of lecture steps 3 to 6.
+SCREENSHOT_STEP_3: Final[str] = "step-3.png"
+SCREENSHOT_STEP_4: Final[str] = "step-4.png"
+SCREENSHOT_STEP_5: Final[str] = "step-5.png"
+SCREENSHOT_STEP_6: Final[str] = "step-6.png"
+
+## `string.Template` of the page that renders console text for a screenshot.
+CONSOLE_PAGE_TEMPLATE: Final[str] = (
+    "<!DOCTYPE html><html><head><meta charset='utf-8'></head>"
+    "<body style='margin:0;background:#1e1e1e;color:#d4d4d4'>"
+    "<pre style='margin:0;padding:16px;font:16px/1.5 monospace;white-space:pre-wrap'>"
+    "$text</pre></body></html>"
+)
+
+## Prefix of the `data:` URL that carries the console page.
+CONSOLE_PAGE_URL_PREFIX: Final[str] = "data:text/html;charset=utf-8,"
+
+## File names of the screenshots of lecture steps 7 and 8.
+SCREENSHOT_STEP_7: Final[str] = "step-7.png"
+SCREENSHOT_STEP_8: Final[str] = "step-8.png"
+
+## Process exit code when the My Bookings page does not match what the bot did.
+EXIT_VERIFICATION_MISMATCH: Final[int] = 3
+
+## Id of the navigation link that opens the My Bookings page.
+MY_BOOKINGS_LINK_ID: Final[str] = "my-bookings-link"
+
+## Id of the My Bookings page, shown after its bookings were loaded.
+MY_BOOKINGS_PAGE_ID: Final[str] = "my-bookings-page"
+
+## Id of the element shown when the account has no booking and no waitlist entry.
+EMPTY_BOOKINGS_STATE_ID: Final[str] = "empty-bookings-state"
+
+## CSS selectors of the confirmed booking cards and the waitlist cards.
+BOOKING_CARD_CSS: Final[str] = "#confirmed-bookings-section div[id^='booking-card-']"
+WAITLIST_CARD_CSS: Final[str] = "#waitlist-section div[id^='waitlist-card-']"
+
+## Prefixes of the element ids of a booking card and of a waitlist card.
+BOOKING_CARD_ID_PREFIX: Final[str] = "booking-card-"
+BOOKING_NAME_ID_PREFIX: Final[str] = "booking-class-name-"
+WAITLIST_CARD_ID_PREFIX: Final[str] = "waitlist-card-"
+WAITLIST_NAME_ID_PREFIX: Final[str] = "waitlist-class-name-"
+
+## XPath, relative to a card, of the paragraph "When: Tue, Aug 12, 6:00 PM".
+WHEN_XPATH: Final[str] = ".//p[strong[starts-with(normalize-space(), 'When:')]]"
+
+## Prefix of the date and time text of a booking card.
+WHEN_TEXT_PREFIX: Final[str] = "When:"
+
+## Suffix the My Bookings page adds to the name of a waitlist entry.
+WAITLIST_NAME_SUFFIX: Final[str] = " (Waitlist)"
+
+## Message of the error raised when the My Bookings page shows no booking at all.
+MESSAGE_NO_BOOKINGS_FOUND: Final[str] = "The My Bookings page shows no booking or waitlist entry"
+
+## Lines of the verification on the My Bookings page (lecture steps 7 and 8).
+VERIFY_TITLE: Final[str] = "--- VERIFYING ON MY BOOKINGS PAGE ---"
+VERIFY_LINE_VERIFIED: Final[str] = "  ✓ Verified: {name}"
+VERIFY_RESULT_TITLE: Final[str] = "--- VERIFICATION RESULT ---"
+VERIFY_EXPECTED: Final[str] = "Expected: {count} {noun}"
+VERIFY_FOUND: Final[str] = "Found: {count} {noun}"
+VERIFY_NOUN_SINGULAR: Final[str] = "booking"
+VERIFY_NOUN_PLURAL: Final[str] = "bookings"
+VERIFY_SUCCESS: Final[str] = "✅ SUCCESS: All bookings verified!"
+VERIFY_MISMATCH: Final[str] = "❌ MISMATCH: Missing {count} bookings"
+VERIFY_LINE_MISSING: Final[str] = "  ✗ Missing: {entry}"
+VERIFY_LINE_UNEXPECTED: Final[str] = "  ? Unexpected: {entry}"
@@ -0,0 +1,88 @@
+"""@file booking_entry.py
+@brief One entry of the My Bookings page: a confirmed booking or a waitlist entry.
+"""
+
+import re
+from dataclasses import dataclass
+
+from snack_and_lift import constants
+from snack_and_lift.domain.day_label import parse_day_label
+from snack_and_lift.domain.errors import PageFormatError
+from snack_and_lift.domain.rules import parse_time
+
+_WHEN = re.compile(r"(?P<date>[A-Z][a-z]{2}, [A-Z][a-z]{2} \d{1,2}), (?P<time>.+)")
+
+
+@dataclass(frozen=True, slots=True)
+class BookingEntry:
+    """@brief A booking or waitlist entry, as read from the My Bookings page.
+
+    `name` is the class name WITHOUT the ` (Waitlist)` suffix the page adds to a waitlist
+    entry; `waitlisted` carries that fact. `when_text` is the page text without the
+    `When:` prefix, for example `Tue, Aug 12, 6:00 PM`.
+    """
+
+    name: str
+    when_text: str
+    waitlisted: bool
+
+    @classmethod
+    def from_page(cls, heading: str, when_text: str, waitlisted: bool) -> "BookingEntry":
+        """@brief Build an entry from the texts of its card.
+
+        @param heading The class name as the page shows it, possibly with the waitlist suffix.
+        @param when_text The date and time paragraph, with or without the `When:` prefix.
+        @param waitlisted True for a card of the waitlist section.
+        @return The entry, with the suffix and the prefix removed.
+        """
+        name = heading.strip().removesuffix(constants.WAITLIST_NAME_SUFFIX.strip()).strip()
+        when = when_text.strip().removeprefix(constants.WHEN_TEXT_PREFIX).strip()
+        return cls(name, when, waitlisted)
+
+    def _split_when(self) -> tuple[str, str]:
+        """@brief Split the date text from the time text.
+
+        @return The date text (`Tue, Aug 12`) and the time text (`6:00 PM`).
+        @exception PageFormatError The text has no date and time.
+        """
+        match = _WHEN.fullmatch(self.when_text)
+        if match is None:
+            raise PageFormatError(f"Unexpected booking date and time: {self.when_text!r}")
+        return match["date"], match["time"]
+
+    @property
+    def weekday(self) -> str:
+        """@brief The weekday of the entry (`Tue`).
+
+        @exception PageFormatError The date and time text is not valid.
+        """
+        return parse_day_label(self._split_when()[0])[0]
+
+    @property
+    def date_text(self) -> str:
+        """@brief The date of the entry (`Tue, Aug 12`), comparable with a class card's date.
+
+        @exception PageFormatError The date and time text is not valid.
+        """
+        return parse_day_label(self._split_when()[0])[1]
+
+    @property
+    def time(self) -> tuple[int, int]:
+        """@brief The hour (0-23) and the minute of the entry.
+
+        @exception PageFormatError The date and time text is not valid.
+        """
+        return parse_time(self._split_when()[1])
+
+
+def is_target_entry(entry: BookingEntry) -> bool:
+    """@brief Tell whether the entry is a class the bot books: a target weekday at the target time.
+
+    @param entry The entry.
+    @return True for Tuesday or Thursday at `TARGET_HOUR`:`TARGET_MINUTE`.
+    @exception PageFormatError The date and time text is not valid.
+    """
+    return entry.weekday in constants.TARGET_WEEKDAYS and entry.time == (
+        constants.TARGET_HOUR,
+        constants.TARGET_MINUTE,
+    )
@@ -0,0 +1,29 @@
+"""@file day_label.py
+@brief Reads the title of a day group of the schedule ("Today (Tue, Aug 12)").
+
+Kept apart from `rules.py` so that `models.py` can use it without a circular import.
+"""
+
+import re
+
+from snack_and_lift import constants
+from snack_and_lift.domain.errors import PageFormatError
+
+_DATE = re.compile(r"(?P<weekday>[A-Z][a-z]{2}), [A-Z][a-z]{2} \d{1,2}")
+_WRAPPER = re.compile(rf"(?:{'|'.join(constants.DAY_LABEL_WRAPPERS)}) \((?P<inner>.+)\)")
+
+
+def parse_day_label(label: str) -> tuple[str, str]:
+    """@brief Split a day label into the weekday and the date text.
+
+    @param label `Today (Tue, Aug 12)`, `Tomorrow (Wed, Aug 13)` or `Thu, Aug 14`.
+    @return The weekday (`Tue`) and the date text (`Tue, Aug 12`).
+    @exception PageFormatError The label has none of these forms.
+    """
+    text = label.strip()
+    wrapped = _WRAPPER.fullmatch(text)
+    date_text = wrapped["inner"] if wrapped else text
+    match = _DATE.fullmatch(date_text)
+    if match is None:
+        raise PageFormatError(f"Unexpected day label: {label!r}")
+    return match["weekday"], date_text
@@ -1,15 +1,35 @@
-"""@file errors.py
-@brief The errors of the bot.
-"""
-
-
-class GymError(Exception):
-    """@brief The gym site did not behave as the bot expected (a page, element or timeout)."""
-
-
-class LoginFailedError(GymError):
-    """@brief The site refused the login; the message is the text the site shows."""
-
-
-class MissingCredentialsError(Exception):
-    """@brief The account e-mail or password is not set in the environment."""
+"""@file errors.py
+@brief The errors of the bot.
+"""
+
+
+class GymError(Exception):
+    """@brief The gym site did not behave as the bot expected (a page, element or timeout)."""
+
+
+class LoginFailedError(GymError):
+    """@brief The site refused the login; the message is the text the site shows."""
+
+
+class MissingCredentialsError(Exception):
+    """@brief The account e-mail or password is not set in the environment."""
+
+
+class UnknownButtonError(GymError):
+    """@brief A class button shows a text the bot cannot act on (busy, completed or unknown)."""
+
+
+class PageFormatError(GymError):
+    """@brief A text read from the page (a day label or a time) has an unexpected format."""
+
+
+class RetriesExhaustedError(GymError):
+    """@brief A step failed on every attempt; the cause is the error of the last attempt."""
+
+
+class NoBookingsFoundError(GymError):
+    """@brief The My Bookings page shows no booking where the bot expects some.
+
+    The project's counterpart of Selenium's `NoSuchElementException`, which the lecture asks
+    the student to raise when the bookings that should be there are missing.
+    """
@@ -0,0 +1,94 @@
+"""@file models.py
+@brief Plain data of the schedule: the button state, a class card and the result of a booking.
+"""
+
+from dataclasses import dataclass
+from enum import Enum, auto
+
+from snack_and_lift import constants
+from snack_and_lift.domain.day_label import parse_day_label
+
+
+class ButtonState(Enum):
+    """@brief What the button of a class card says."""
+
+    BOOK = auto()
+    JOIN_WAITLIST = auto()
+    BOOKED = auto()
+    WAITLISTED = auto()
+    BUSY = auto()
+    COMPLETED = auto()
+    UNKNOWN = auto()
+
+    @classmethod
+    def from_text(cls, text: str) -> "ButtonState":
+        """@brief Map the text of a button to its state.
+
+        @param text The visible text of the button (or the label of a past class).
+        @return The state; UNKNOWN for a text the bot does not know.
+        """
+        return _STATE_BY_TEXT.get(text.strip(), cls.UNKNOWN)
+
+
+_STATE_BY_TEXT: dict[str, ButtonState] = {
+    constants.BUTTON_TEXT_BOOK: ButtonState.BOOK,
+    constants.BUTTON_TEXT_JOIN_WAITLIST: ButtonState.JOIN_WAITLIST,
+    constants.BUTTON_TEXT_BOOKED: ButtonState.BOOKED,
+    constants.BUTTON_TEXT_WAITLISTED: ButtonState.WAITLISTED,
+    constants.BUTTON_TEXT_BOOKING: ButtonState.BUSY,
+    constants.BUTTON_TEXT_JOINING: ButtonState.BUSY,
+    constants.BUTTON_TEXT_COMPLETED: ButtonState.COMPLETED,
+}
+
+
+@dataclass(frozen=True, slots=True)
+class ClassCard:
+    """@brief One class of the schedule, as read from the page.
+
+    `card_id` is the id of the card without the `class-card-` prefix (for example
+    "123"); the site builds the ids of the card's other elements from the same suffix.
+    """
+
+    card_id: str
+    name: str
+    day_label: str
+    time_text: str
+    button_text: str
+
+    @property
+    def state(self) -> ButtonState:
+        """@brief The state of the button."""
+        return ButtonState.from_text(self.button_text)
+
+    @property
+    def weekday(self) -> str:
+        """@brief The weekday of the day group (`Tue`).
+
+        @exception PageFormatError The day label is not in a known form.
+        """
+        return parse_day_label(self.day_label)[0]
+
+    @property
+    def date_text(self) -> str:
+        """@brief The date of the day group (`Tue, Aug 12`).
+
+        @exception PageFormatError The day label is not in a known form.
+        """
+        return parse_day_label(self.day_label)[1]
+
+
+class Outcome(Enum):
+    """@brief What the booking did, or found, for a class."""
+
+    NEW_BOOKING = auto()
+    NEW_WAITLIST = auto()
+    ALREADY_BOOKED = auto()
+    ALREADY_WAITLISTED = auto()
+
+
+@dataclass(frozen=True, slots=True)
+class ClassResult:
+    """@brief The class that was handled and what happened to it."""
+
+    card: ClassCard
+    outcome: Outcome
@@ -0,0 +1,81 @@
+"""@file report.py
+@brief Lecture steps 5 and 6: count what the bot did and write the summary and the class list.
+"""
+
+from collections.abc import Sequence
+from dataclasses import dataclass
+
+from snack_and_lift import constants
+from snack_and_lift.domain.models import ClassResult, Outcome
+
+_TAG_OF_OUTCOME: dict[Outcome, str] = {
+    Outcome.NEW_BOOKING: constants.DETAIL_TAG_NEW_BOOKING,
+    Outcome.NEW_WAITLIST: constants.DETAIL_TAG_NEW_WAITLIST,
+    Outcome.ALREADY_BOOKED: constants.DETAIL_TAG_ALREADY_BOOKED,
+    Outcome.ALREADY_WAITLISTED: constants.DETAIL_TAG_ALREADY_WAITLISTED,
+}
+
+_ALREADY_DONE = (Outcome.ALREADY_BOOKED, Outcome.ALREADY_WAITLISTED)
+
+
+@dataclass(frozen=True, slots=True)
+class Counters:
+    """@brief How many classes ended in each way."""
+
+    new_bookings: int
+    new_waitlist: int
+    already_done: int
+
+    @property
+    def total(self) -> int:
+        """@brief The number of classes handled."""
+        return self.new_bookings + self.new_waitlist + self.already_done
+
+
+def count_results(results: Sequence[ClassResult]) -> Counters:
+    """@brief Count the results by outcome.
+
+    @param results What happened to each class.
+    @return The counters; already booked and already waitlisted count together.
+    """
+    return Counters(
+        new_bookings=sum(1 for r in results if r.outcome is Outcome.NEW_BOOKING),
+        new_waitlist=sum(1 for r in results if r.outcome is Outcome.NEW_WAITLIST),
+        already_done=sum(1 for r in results if r.outcome in _ALREADY_DONE),
+    )
+
+
+def format_summary(results: Sequence[ClassResult]) -> str:
+    """@brief Write the booking summary block.
+
+    @param results What happened to each class.
+    @return The block, starting with `--- BOOKING SUMMARY ---`, lines joined by newlines.
+    """
+    counters = count_results(results)
+    return "\n".join(
+        [
+            constants.SUMMARY_TITLE,
+            constants.SUMMARY_NEW_BOOKINGS.format(count=counters.new_bookings),
+            constants.SUMMARY_NEW_WAITLIST.format(count=counters.new_waitlist),
+            constants.SUMMARY_ALREADY_DONE.format(count=counters.already_done),
+            constants.SUMMARY_TOTAL.format(count=counters.total),
+        ]
+    )
+
+
+def format_detail_list(results: Sequence[ClassResult]) -> str:
+    """@brief Write the detailed class list, one line per class in the order handled.
+
+    @param results What happened to each class.
+    @return The block, starting with `--- DETAILED CLASS LIST ---`; says so when empty.
+    """
+    lines = [constants.DETAIL_TITLE]
+    if not results:
+        lines.append(constants.DETAIL_NONE)
+    lines.extend(
+        constants.DETAIL_LINE.format(
+            tag=_TAG_OF_OUTCOME[result.outcome], name=result.card.name, day=result.card.day_label
+        )
+        for result in results
+    )
+    return "\n".join(lines)
@@ -0,0 +1,159 @@
+"""@file rules.py
+@brief The booking rules: which class is the target, what to do for a button state, what to say.
+"""
+
+import re
+from collections.abc import Iterable
+from enum import Enum, auto
+
+from snack_and_lift import constants
+from snack_and_lift.domain.day_label import parse_day_label
+from snack_and_lift.domain.errors import PageFormatError, UnknownButtonError
+from snack_and_lift.domain.models import ButtonState, ClassCard, Outcome
+
+__all__ = [
+    "CONFIRMED_STATE",
+    "OUTCOME_OF_ACTION",
+    "Action",
+    "decide_outcome_action",
+    "find_next_class",
+    "find_target_classes",
+    "format_outcome",
+    "is_target_time",
+    "parse_day_label",
+    "parse_time",
+]
+
+_TIME = re.compile(
+    rf"(?:{re.escape(constants.TIME_TEXT_PREFIX)}\s*)?(\d{{1,2}}):(\d{{2}})\s*(AM|PM)",
+    re.IGNORECASE,
+)
+_MAX_CLOCK_HOUR = 12
+_MAX_MINUTE = 59
+
+
+class Action(Enum):
+    """@brief What the bot does for a class card."""
+
+    CLICK_BOOK = auto()
+    CLICK_WAITLIST = auto()
+    ALREADY_BOOKED = auto()
+    ALREADY_WAITLISTED = auto()
+
+
+## The outcome that follows from each action.
+OUTCOME_OF_ACTION: dict[Action, Outcome] = {
+    Action.CLICK_BOOK: Outcome.NEW_BOOKING,
+    Action.CLICK_WAITLIST: Outcome.NEW_WAITLIST,
+    Action.ALREADY_BOOKED: Outcome.ALREADY_BOOKED,
+    Action.ALREADY_WAITLISTED: Outcome.ALREADY_WAITLISTED,
+}
+
+## The button state that proves a click worked.
+CONFIRMED_STATE: dict[Action, ButtonState] = {
+    Action.CLICK_BOOK: ButtonState.BOOKED,
+    Action.CLICK_WAITLIST: ButtonState.WAITLISTED,
+}
+
+_ACTION_OF_STATE: dict[ButtonState, Action] = {
+    ButtonState.BOOK: Action.CLICK_BOOK,
+    ButtonState.JOIN_WAITLIST: Action.CLICK_WAITLIST,
+    ButtonState.BOOKED: Action.ALREADY_BOOKED,
+    ButtonState.WAITLISTED: Action.ALREADY_WAITLISTED,
+}
+
+_MESSAGE_OF_OUTCOME: dict[Outcome, str] = {
+    Outcome.NEW_BOOKING: constants.MESSAGE_BOOKED,
+    Outcome.NEW_WAITLIST: constants.MESSAGE_WAITLISTED,
+    Outcome.ALREADY_BOOKED: constants.MESSAGE_ALREADY_BOOKED,
+    Outcome.ALREADY_WAITLISTED: constants.MESSAGE_ALREADY_WAITLISTED,
+}
+
+
+def parse_time(text: str) -> tuple[int, int]:
+    """@brief Read a 12-hour time such as `6:00 PM`.
+
+    @param text The time, with or without the `Time:` prefix.
+    @return The hour (0-23) and the minute.
+    @exception PageFormatError The text is not a valid time.
+    """
+    match = _TIME.fullmatch(text.strip())
+    if match is None:
+        raise PageFormatError(f"Unexpected time text: {text!r}")
+    hour, minute = int(match[1]), int(match[2])
+    if not 1 <= hour <= _MAX_CLOCK_HOUR or minute > _MAX_MINUTE:
+        raise PageFormatError(f"Time out of range: {text!r}")
+    hour %= _MAX_CLOCK_HOUR
+    if match[3].upper() == "PM":
+        hour += _MAX_CLOCK_HOUR
+    return hour, minute
+
+
+def is_target_time(card: ClassCard) -> bool:
+    """@brief Tell whether the class starts at the time the bot books.
+
+    @param card The class.
+    @return True at `TARGET_HOUR`:`TARGET_MINUTE`.
+    @exception PageFormatError The time text is not valid.
+    """
+    return parse_time(card.time_text) == (constants.TARGET_HOUR, constants.TARGET_MINUTE)
+
+
+def find_next_class(cards: Iterable[ClassCard], weekday: str) -> ClassCard | None:
+    """@brief Find the first class of a weekday at the target time, in page order.
+
+    The weekday is read from each card's day label; the position in the list means nothing.
+    Classes already completed are skipped.
+
+    @param cards The classes in the order of the page.
+    @param weekday The weekday as the site abbreviates it (`Tue`).
+    @return The class, or None when there is none.
+    """
+    for card in cards:
+        if card.state is ButtonState.COMPLETED:
+            continue
+        if card.weekday == weekday and is_target_time(card):
+            return card
+    return None
+
+
+def find_target_classes(cards: Iterable[ClassCard]) -> list[ClassCard]:
+    """@brief Find every class on a target weekday at the target time, in page order.
+
+    The weekday is read from each card's day label; the position in the list means nothing.
+    Classes already completed are skipped.
+
+    @param cards The classes in the order of the page.
+    @return The classes to handle; empty when there is none.
+    @exception PageFormatError A day label or time text is not valid.
+    """
+    return [
+        card
+        for card in cards
+        if card.state is not ButtonState.COMPLETED
+        and card.weekday in constants.TARGET_WEEKDAYS
+        and is_target_time(card)
+    ]
+
+
+def decide_outcome_action(card: ClassCard) -> Action:
+    """@brief Decide what to do from the state of the button.
+
+    @param card The class.
+    @return The action.
+    @exception UnknownButtonError The button is busy, completed or unknown; `retry` can repeat.
+    """
+    action = _ACTION_OF_STATE.get(card.state)
+    if action is None:
+        raise UnknownButtonError(f"Cannot act on button {card.button_text!r} of {card.name}")
+    return action
+
+
+def format_outcome(outcome: Outcome, card: ClassCard) -> str:
+    """@brief Build the console message of an outcome.
+
+    @param outcome What happened.
+    @param card The class; its day label is shown as the site writes it.
+    @return For example `✓ Successfully booked: Spin Class on Tomorrow (Thu, Aug 14)`.
+    """
+    return _MESSAGE_OF_OUTCOME[outcome].format(name=card.name, day=card.day_label)
@@ -0,0 +1,108 @@
+"""@file verification.py
+@brief Lecture steps 7 and 8: compare what the bot did with the My Bookings page.
+"""
+
+from collections import Counter
+from collections.abc import Sequence
+from dataclasses import dataclass
+
+from snack_and_lift import constants
+from snack_and_lift.domain.booking_entry import BookingEntry
+from snack_and_lift.domain.models import ClassResult, Outcome
+
+_WAITLISTED_OUTCOMES = (Outcome.NEW_WAITLIST, Outcome.ALREADY_WAITLISTED)
+
+## An entry is identified by its class name, its date text and whether it is waitlisted.
+_Key = tuple[str, str, bool]
+
+
+@dataclass(frozen=True, slots=True)
+class VerificationResult:
+    """@brief What the My Bookings page shows compared with what the bot did.
+
+    `verified`, `missing` and `unexpected` hold display names, with the waitlist suffix for a
+    waitlist entry; `missing` and `unexpected` also say the day (`Spin Class on Tue, Aug 12`).
+    """
+
+    expected: int
+    found: int
+    verified: list[str]
+    missing: list[str]
+    unexpected: list[str]
+
+    @property
+    def is_success(self) -> bool:
+        """@brief True when every expected entry was found and nothing else was."""
+        return self.expected == self.found and not self.missing and not self.unexpected
+
+
+def _display_name(name: str, waitlisted: bool) -> str:
+    """@brief The name as the page shows it."""
+    return name + constants.WAITLIST_NAME_SUFFIX if waitlisted else name
+
+
+def _expected_keys(results: Sequence[ClassResult]) -> list[_Key]:
+    """@brief The entries the bot's results say must be on the page."""
+    return [(r.card.name, r.card.date_text, r.outcome in _WAITLISTED_OUTCOMES) for r in results]
+
+
+def _entry_keys(entries: Sequence[BookingEntry]) -> list[_Key]:
+    """@brief The identity of each entry found on the page."""
+    return [(e.name, e.date_text, e.waitlisted) for e in entries]
+
+
+def _describe(key: _Key) -> str:
+    """@brief Write an entry for the missing and unexpected lines."""
+    name, day, waitlisted = key
+    return f"{_display_name(name, waitlisted)} on {day}"
+
+
+def build_verification(
+    results: Sequence[ClassResult], entries: Sequence[BookingEntry]
+) -> VerificationResult:
+    """@brief Compare the results of the booking with the target entries of the page.
+
+    @param results What happened to each class; waitlisted when the outcome is a waitlist one.
+    @param entries The Tuesday and Thursday 6pm entries found on the page.
+    @return The comparison; the counts are the numbers of results and of entries.
+    @exception PageFormatError An entry or a card has no valid date.
+    """
+    expected = _expected_keys(results)
+    remaining = Counter(_entry_keys(entries))
+    verified: list[str] = []
+    missing: list[str] = []
+    for key in expected:
+        if remaining[key] > 0:
+            remaining[key] -= 1
+            verified.append(_display_name(key[0], key[2]))
+        else:
+            missing.append(_describe(key))
+    unexpected = [_describe(key) for key in remaining.elements()]
+    return VerificationResult(len(expected), len(entries), verified, missing, unexpected)
+
+
+def _count_text(template: str, count: int) -> str:
+    """@brief Write a count with `booking` in the singular for 1."""
+    noun = constants.VERIFY_NOUN_SINGULAR if count == 1 else constants.VERIFY_NOUN_PLURAL
+    return template.format(count=count, noun=noun)
+
+
+def format_verification(result: VerificationResult) -> str:
+    """@brief Write the verification block.
+
+    @param result The comparison.
+    @return The block, starting with `--- VERIFYING ON MY BOOKINGS PAGE ---`.
+    """
+    lines = [constants.VERIFY_TITLE]
+    lines.extend(constants.VERIFY_LINE_VERIFIED.format(name=name) for name in result.verified)
+    lines.append("")
+    lines.append(constants.VERIFY_RESULT_TITLE)
+    lines.append(_count_text(constants.VERIFY_EXPECTED, result.expected))
+    lines.append(_count_text(constants.VERIFY_FOUND, result.found))
+    if result.is_success:
+        lines.append(constants.VERIFY_SUCCESS)
+        return "\n".join(lines)
+    lines.append(constants.VERIFY_MISMATCH.format(count=result.expected - result.found))
+    lines.extend(constants.VERIFY_LINE_MISSING.format(entry=text) for text in result.missing)
+    lines.extend(constants.VERIFY_LINE_UNEXPECTED.format(entry=text) for text in result.unexpected)
+    return "\n".join(lines)
@@ -0,0 +1,35 @@
+"""@file console_recorder.py
+@brief Keeps the lines the bot logs, so they can be drawn as the lecture's console screenshot.
+"""
+
+import logging
+
+
+class ConsoleRecorder(logging.Handler):
+    """@brief A logging handler that stores the formatted message of every record."""
+
+    def __init__(self, level: int = logging.NOTSET) -> None:
+        """@brief Create an empty recorder.
+
+        @param level The lowest level to keep.
+        """
+        super().__init__(level)
+        self.setFormatter(logging.Formatter("%(message)s"))
+        self._lines: list[str] = []
+
+    @property
+    def lines(self) -> list[str]:
+        """@brief The recorded lines, oldest first (a copy)."""
+        return list(self._lines)
+
+    @property
+    def text(self) -> str:
+        """@brief The recorded lines joined by newlines."""
+        return "\n".join(self._lines)
+
+    def emit(self, record: logging.LogRecord) -> None:
+        """@brief Store one record.
+
+        @param record The log record.
+        """
+        self._lines.append(self.format(record))
@@ -3,10 +3,13 @@
 """

 import functools
+import html
 import logging
+import urllib.parse
 from collections.abc import Callable
 from pathlib import Path
-from typing import Concatenate
+from string import Template
+from typing import Concatenate, Literal

 from selenium.common.exceptions import (
    ElementClickInterceptedException,
@@ -16,11 +19,14 @@ from selenium.common.exceptions import (
 )
 from selenium.webdriver.common.by import By
 from selenium.webdriver.remote.webdriver import WebDriver
+from selenium.webdriver.remote.webelement import WebElement
 from selenium.webdriver.support import expected_conditions as ec
 from selenium.webdriver.support.ui import WebDriverWait

 from snack_and_lift import constants
+from snack_and_lift.domain.booking_entry import BookingEntry
 from snack_and_lift.domain.errors import GymError, LoginFailedError
+from snack_and_lift.domain.models import ButtonState, ClassCard

 logger = logging.getLogger(__name__)

@@ -82,11 +88,18 @@ class SeleniumGym:
        @exception LoginFailedError The site shows a login error.
        @exception GymError The page did not behave as expected.
        """
-        self._wait.until(ec.element_to_be_clickable((By.ID, constants.NAV_LOGIN_BUTTON_ID))).click()
-        self._wait.until(
+        # After a failed login the form is still shown, so a repeated login skips the nav button.
+        if not self._driver.find_elements(By.ID, constants.LOGIN_EMAIL_INPUT_ID):
+            self._wait.until(
+                ec.element_to_be_clickable((By.ID, constants.NAV_LOGIN_BUTTON_ID))
+            ).click()
+        email_input = self._wait.until(
            ec.presence_of_element_located((By.ID, constants.LOGIN_EMAIL_INPUT_ID))
-        ).send_keys(email)
-        self._driver.find_element(By.ID, constants.LOGIN_PASSWORD_INPUT_ID).send_keys(password)
+        )
+        password_input = self._driver.find_element(By.ID, constants.LOGIN_PASSWORD_INPUT_ID)
+        for field, value in ((email_input, email), (password_input, password)):
+            field.clear()
+            field.send_keys(value)
        self._driver.find_element(By.ID, constants.LOGIN_SUBMIT_BUTTON_ID).click()
        self._wait.until(
            ec.any_of(
@@ -98,6 +111,144 @@ class SeleniumGym:
        if errors:
            raise LoginFailedError(errors[0].text)

+    @_translate_errors
+    def list_class_cards(self) -> list[ClassCard]:
+        """@brief Read every class card; the day comes from the ancestor day group.
+
+        @return The classes in page order.
+        @exception GymError The schedule could not be read.
+        """
+        self._wait.until(
+            ec.presence_of_element_located((By.CSS_SELECTOR, constants.CLASS_CARD_CSS))
+        )
+        elements = self._driver.find_elements(By.CSS_SELECTOR, constants.CLASS_CARD_CSS)
+        return [self._read_card(element) for element in elements]
+
+    def _read_card(self, element: WebElement) -> ClassCard:
+        """@brief Turn one card element into plain data.
+
+        @param element The card.
+        @return The class.
+        """
+        card_id = (element.get_attribute("id") or "").removeprefix(constants.CLASS_CARD_ID_PREFIX)
+        buttons = element.find_elements(By.ID, constants.BOOK_BUTTON_ID_PREFIX + card_id)
+        labels = element.find_elements(By.ID, constants.COMPLETED_LABEL_ID_PREFIX + card_id)
+        control = (buttons or labels or [None])[0]
+        return ClassCard(
+            card_id=card_id,
+            name=element.find_element(By.ID, constants.CLASS_NAME_ID_PREFIX + card_id).text,
+            day_label=element.find_element(By.XPATH, constants.DAY_TITLE_XPATH).text,
+            time_text=element.find_element(By.ID, constants.CLASS_TIME_ID_PREFIX + card_id).text,
+            button_text=control.text if control is not None else "",
+        )
+
+    @_translate_errors
+    def press_class_button(self, card_id: str) -> str:
+        """@brief Scroll to the button, click it and wait for the result or the error box.
+
+        @param card_id The id of the card without its prefix.
+        @return The new text of the button.
+        @exception GymError The site shows an error for the class, or nothing settled in time.
+        """
+        button_id = constants.BOOK_BUTTON_ID_PREFIX + card_id
+        button = self._wait.until(ec.presence_of_element_located((By.ID, button_id)))
+        self._driver.execute_script("arguments[0].scrollIntoView({block: 'center'});", button)
+        before = button.text
+        self._wait.until(ec.element_to_be_clickable((By.ID, button_id))).click()
+
+        def settled(driver: WebDriver) -> tuple[str, str] | Literal[False]:
+            errors = driver.find_elements(By.ID, constants.CLASS_ERROR_ID_PREFIX + card_id)
+            text = driver.find_element(By.ID, button_id).text
+            if errors:
+                return text, errors[0].text or "class error"
+            if text != before and ButtonState.from_text(text) is not ButtonState.BUSY:
+                return text, ""
+            return False
+
+        text, error = self._wait.until(settled)
+        if error:
+            raise GymError(error)
+        return text
+
+    @_translate_errors
+    def open_my_bookings(self) -> None:
+        """@brief Click the My Bookings link and wait for the page.
+
+        @exception GymError The page did not load.
+        """
+        self._wait.until(ec.element_to_be_clickable((By.ID, constants.MY_BOOKINGS_LINK_ID))).click()
+        self._wait.until(ec.presence_of_element_located((By.ID, constants.MY_BOOKINGS_PAGE_ID)))
+
+    @_translate_errors
+    def list_my_bookings(self) -> list[BookingEntry]:
+        """@brief Wait for the bookings to load, then read the confirmed and waitlist cards.
+
+        @return The entries, confirmed ones first; empty when the page shows its empty state.
+        @exception GymError The page shows an error box, or nothing was shown in time.
+        """
+        self._wait.until(
+            ec.any_of(
+                ec.presence_of_element_located((By.CSS_SELECTOR, constants.BOOKING_CARD_CSS)),
+                ec.presence_of_element_located((By.CSS_SELECTOR, constants.WAITLIST_CARD_CSS)),
+                ec.presence_of_element_located((By.ID, constants.EMPTY_BOOKINGS_STATE_ID)),
+                ec.presence_of_element_located((By.ID, constants.ERROR_MESSAGE_ID)),
+            )
+        )
+        errors = self._driver.find_elements(By.ID, constants.ERROR_MESSAGE_ID)
+        if errors:
+            raise GymError(errors[0].text or "My Bookings error")
+        confirmed = self._driver.find_elements(By.CSS_SELECTOR, constants.BOOKING_CARD_CSS)
+        waitlist = self._driver.find_elements(By.CSS_SELECTOR, constants.WAITLIST_CARD_CSS)
+        return [
+            self._read_entry(
+                element, constants.BOOKING_CARD_ID_PREFIX, constants.BOOKING_NAME_ID_PREFIX, False
+            )
+            for element in confirmed
+        ] + [
+            self._read_entry(
+                element, constants.WAITLIST_CARD_ID_PREFIX, constants.WAITLIST_NAME_ID_PREFIX, True
+            )
+            for element in waitlist
+        ]
+
+    @staticmethod
+    def _read_entry(
+        element: WebElement, card_prefix: str, name_prefix: str, waitlisted: bool
+    ) -> BookingEntry:
+        """@brief Turn one booking or waitlist card into plain data.
+
+        @param element The card.
+        @param card_prefix The prefix of the card id.
+        @param name_prefix The prefix of the id of the card's heading.
+        @param waitlisted True for a card of the waitlist section.
+        @return The entry.
+        """
+        card_id = (element.get_attribute("id") or "").removeprefix(card_prefix)
+        return BookingEntry.from_page(
+            heading=element.find_element(By.ID, name_prefix + card_id).text,
+            when_text=element.find_element(By.XPATH, constants.WHEN_XPATH).text,
+            waitlisted=waitlisted,
+        )
+
+    @_translate_errors
+    def save_text_screenshot(self, text: str, path: Path) -> None:
+        """@brief Draw console text in a temporary tab and save a screenshot of it.
+
+        A tab is used so that the schedule page keeps its state.
+
+        @param text The lines to draw.
+        @param path The PNG file to write; its folders are created.
+        """
+        page = Template(constants.CONSOLE_PAGE_TEMPLATE).substitute(text=html.escape(text))
+        original = self._driver.current_window_handle
+        self._driver.switch_to.new_window("tab")
+        try:
+            self._driver.get(constants.CONSOLE_PAGE_URL_PREFIX + urllib.parse.quote(page))
+            self.save_screenshot(path)
+        finally:
+            self._driver.close()
+            self._driver.switch_to.window(original)
+
    def save_screenshot(self, path: Path) -> None:
        """@brief Save a screenshot of the current page.

@@ -12,8 +12,19 @@
    // Dummy account of this fixture only; it is not a real account.
    const ACCEPTED_EMAIL = "fixture@example.invalid";
    const ACCEPTED_PASSWORD = "fixture-password";
+    // Imitates the network simulation: ?fail=N drops the first N submits after a short delay.
+    let failuresLeft = parseInt(new URLSearchParams(window.location.search).get("fail") || "0", 10);
    document.getElementById("login-form").addEventListener("submit", function (event) {
      event.preventDefault();
+      document.getElementById("message-area").innerHTML = "";
+      if (failuresLeft > 0) {
+        failuresLeft -= 1;
+        setTimeout(function () {
+          document.getElementById("message-area").innerHTML =
+            '<div id="error-message">Network request failed. Please try again.</div>';
+        }, 100);
+        return;
+      }
      const email = document.getElementById("email-input").value;
      const password = document.getElementById("password-input").value;
      if (email === ACCEPTED_EMAIL && password === ACCEPTED_PASSWORD) {
@@ -0,0 +1,53 @@
+<!DOCTYPE html>
+<html lang="en">
+<head><meta charset="utf-8"><title>Fixture gym my bookings</title></head>
+<body>
+  <nav><a id="my-bookings-link" href="my_bookings.html">My Bookings</a></nav>
+  <div id="my-bookings-page" data-bookings-count="0" data-waitlist-count="0" data-loading="true">
+    <h1>My Bookings</h1>
+    <p id="loading-placeholder">Loading your bookings...</p>
+    <div id="content"></div>
+  </div>
+  <script>
+    // Imitates the site: a loading text, then the page for the state in the query
+    // (?state=empty or ?state=error; anything else shows two bookings and a waitlist entry).
+    const params = new URLSearchParams(window.location.search);
+    const state = params.get("state");
+    // ?fail=N shows the error for the first N loads of the page in this tab (the network
+    // simulation); the count lives in sessionStorage because every load starts a new page.
+    const loads = parseInt(sessionStorage.getItem("loads") || "0", 10);
+    const dropped = loads < parseInt(params.get("fail") || "0", 10);
+    sessionStorage.setItem("loads", String(loads + 1));
+    // The nav link keeps the state, so opening the page from here shows the same state again.
+    document.getElementById("my-bookings-link").href = "my_bookings.html" + window.location.search;
+    const page = document.getElementById("my-bookings-page");
+    const content = document.getElementById("content");
+    setTimeout(function () {
+      document.getElementById("loading-placeholder").remove();
+      page.dataset.loading = "false";
+      if (state === "error" || dropped) {
+        content.innerHTML = '<div id="error-message">Failed to load bookings</div>';
+      } else if (state === "empty") {
+        content.innerHTML = '<div id="empty-bookings-state">You have no bookings yet</div>';
+      } else {
+        page.dataset.bookingsCount = "2";
+        page.dataset.waitlistCount = "1";
+        content.innerHTML =
+          '<div id="confirmed-bookings-section">' +
+          '<div id="booking-card-11" data-booking-status="confirmed">' +
+          '<h3 id="booking-class-name-11">Spin Class</h3>' +
+          '<p><strong>When:</strong> Tue, Aug 12, 6:00 PM</p></div>' +
+          '<div id="booking-card-12" data-booking-status="confirmed">' +
+          '<h3 id="booking-class-name-12">Yoga Class</h3>' +
+          '<p><strong>When:</strong> Wed, Aug 13, 7:00 AM</p></div>' +
+          '</div>' +
+          '<div id="waitlist-section">' +
+          '<div id="waitlist-card-21" data-booking-status="waitlisted">' +
+          '<h3 id="waitlist-class-name-21">HIIT Class (Waitlist)</h3>' +
+          '<p><strong>When:</strong> Thu, Aug 14, 6:00 PM</p></div>' +
+          '</div>';
+      }
+    }, 200);
+  </script>
+</body>
+</html>
@@ -2,6 +2,89 @@
 <html lang="en">
 <head><meta charset="utf-8"><title>Fixture gym schedule</title></head>
 <body>
-  <div id="schedule-page">Class schedule</div>
+  <nav><a id="my-bookings-link" href="my_bookings.html">My Bookings</a></nav>
+  <div id="schedule-page">
+    <h1>Class Schedule (Today: Wed, Aug 13)</h1>
+    <select id="day-filter"><option>Next 7 Days</option></select>
+
+    <div id="day-group-wed-aug-13">
+      <h2 id="day-title-wed-aug-13">Today (Wed, Aug 13)</h2>
+      <div id="class-card-101" data-class-type="yoga" data-user-booked="false">
+        <h3 id="class-name-101">Yoga Class</h3>
+        <p id="class-time-101"><strong>Time:</strong> 6:00 AM</p>
+        <span id="completed-label-101">Completed</span>
+      </div>
+      <div id="class-card-102" data-class-type="spin" data-user-booked="false">
+        <h3 id="class-name-102">Spin Class</h3>
+        <p id="class-time-102"><strong>Time:</strong> 6:00 PM</p>
+        <button id="book-button-102">Book Class</button>
+      </div>
+    </div>
+
+    <div id="day-group-thu-aug-14">
+      <h2 id="day-title-thu-aug-14">Tomorrow (Thu, Aug 14)</h2>
+      <div id="class-card-201" data-class-type="hiit" data-user-booked="false">
+        <h3 id="class-name-201">HIIT Class</h3>
+        <p id="class-time-201"><strong>Time:</strong> 6:00 PM</p>
+        <button id="book-button-201">Join Waitlist</button>
+      </div>
+    </div>
+
+    <div id="day-group-fri-aug-15">
+      <h2 id="day-title-fri-aug-15">Fri, Aug 15</h2>
+      <div id="class-card-401" data-class-type="hiit" data-user-booked="true">
+        <h3 id="class-name-401">HIIT Class</h3>
+        <p id="class-time-401"><strong>Time:</strong> 5:00 PM</p>
+        <button id="book-button-401" disabled>Booked</button>
+      </div>
+    </div>
+
+    <div id="day-group-tue-aug-19">
+      <h2 id="day-title-tue-aug-19">Tue, Aug 19</h2>
+      <div id="class-card-301" data-class-type="yoga" data-user-booked="false">
+        <h3 id="class-name-301">Yoga Class</h3>
+        <p id="class-time-301"><strong>Time:</strong> 7:00 AM</p>
+        <button id="book-button-301">Book Class</button>
+      </div>
+      <div id="class-card-302" data-class-type="spin" data-user-booked="false" data-fail-times="1">
+        <h3 id="class-name-302">Spin Class</h3>
+        <p id="class-time-302"><strong>Time:</strong> 6:00 PM</p>
+        <button id="book-button-302">Book Class</button>
+      </div>
+    </div>
+  </div>
+  <script>
+    // Imitates the site: a busy text, then the new state; card 302 fails on its first click.
+    // ?fail=N makes every button fail on its first N clicks (the network simulation).
+    const failParam = parseInt(new URLSearchParams(window.location.search).get("fail") || "0", 10);
+    document.querySelectorAll("div[id^='class-card-']").forEach(function (card) {
+      card.dataset.failLeft = String(Math.max(failParam, parseInt(card.dataset.failTimes || "0", 10)));
+    });
+    document.querySelectorAll("button[id^='book-button-']").forEach(function (button) {
+      button.addEventListener("click", function () {
+        const id = button.id.replace("book-button-", "");
+        const card = document.getElementById("class-card-" + id);
+        const oldText = button.textContent;
+        const stale = document.getElementById("class-error-" + id);
+        if (stale) { stale.remove(); }
+        const waitlist = oldText === "Join Waitlist";
+        button.textContent = waitlist ? "Joining..." : "Booking...";
+        button.disabled = true;
+        setTimeout(function () {
+          if (parseInt(card.dataset.failLeft, 10) > 0) {
+            card.dataset.failLeft = String(parseInt(card.dataset.failLeft, 10) - 1);
+            button.textContent = oldText;
+            button.disabled = false;
+            const box = document.createElement("div");
+            box.id = "class-error-" + id;
+            box.textContent = "Network error, please try again";
+            card.appendChild(box);
+            return;
+          }
+          button.textContent = waitlist ? "Waitlisted" : "Booked";
+        }, 200);
+      });
+    });
+  </script>
 </body>
 </html>
@@ -3,12 +3,23 @@
 """

 import os
-from collections.abc import Iterator
+from collections.abc import Callable, Iterator
 from pathlib import Path

 import pytest

-from snack_and_lift.domain.errors import LoginFailedError
+from snack_and_lift.application.booking import book_class_with_retry, book_target_classes
+from snack_and_lift.application.credentials import Credentials
+from snack_and_lift.application.session import login_with_retry
+from snack_and_lift.application.verification import get_my_bookings, get_my_bookings_with_retry
+from snack_and_lift.domain.booking_entry import BookingEntry
+from snack_and_lift.domain.errors import (
+    GymError,
+    LoginFailedError,
+    NoBookingsFoundError,
+    RetriesExhaustedError,
+)
+from snack_and_lift.domain.models import Outcome
 from snack_and_lift.infrastructure.browser import create_driver
 from snack_and_lift.infrastructure.selenium_gym import SeleniumGym

@@ -55,3 +66,207 @@ def test_save_screenshot_creates_the_folder(gym: SeleniumGym, tmp_path: Path) ->
    gym.save_screenshot(target)

    assert target.stat().st_size > 0
+
+
+FIXTURE_SCHEDULE = (Path(__file__).parent / "fixtures" / "schedule.html").as_uri()
+
+
+@pytest.fixture
+def schedule_gym(tmp_path: Path) -> Iterator[SeleniumGym]:
+    driver = create_driver(headless=True, profile_dir=tmp_path / "profile", keep_open=False)
+    try:
+        driver.get(FIXTURE_SCHEDULE)
+        yield SeleniumGym(driver, base_url=FIXTURE_SCHEDULE)
+    finally:
+        driver.quit()
+
+
+def test_list_class_cards_reads_the_day_from_the_ancestor_group(schedule_gym: SeleniumGym) -> None:
+    cards = {card.card_id: card for card in schedule_gym.list_class_cards()}
+
+    assert list(cards) == ["101", "102", "201", "401", "301", "302"]
+    assert cards["102"].day_label == "Today (Wed, Aug 13)"
+    assert cards["201"].weekday == "Thu"
+    assert cards["302"].weekday == "Tue"
+    assert cards["302"].name == "Spin Class"
+    assert cards["302"].time_text == "Time: 6:00 PM"
+    assert cards["302"].button_text == "Book Class"
+    assert cards["101"].button_text == "Completed"
+    assert cards["401"].button_text == "Booked"
+
+
+def test_press_class_button_confirms_booking(schedule_gym: SeleniumGym) -> None:
+    assert schedule_gym.press_class_button("102") == "Booked"
+
+
+def test_press_class_button_confirms_waitlist(schedule_gym: SeleniumGym) -> None:
+    assert schedule_gym.press_class_button("201") == "Waitlisted"
+
+
+def test_press_class_button_raises_with_the_error_text_then_succeeds(
+    schedule_gym: SeleniumGym,
+) -> None:
+    with pytest.raises(GymError, match="Network error"):
+        schedule_gym.press_class_button("302")
+
+    assert schedule_gym.press_class_button("302") == "Booked"
+
+
+def test_save_text_screenshot_writes_a_png_and_keeps_the_page(
+    schedule_gym: SeleniumGym, tmp_path: Path
+) -> None:
+    target = tmp_path / "shots" / "step-4.png"
+
+    schedule_gym.save_text_screenshot("✓ Successfully booked: <Spin Class>", target)
+
+    assert target.read_bytes().startswith(b"\x89PNG")
+    assert schedule_gym.list_class_cards()
+
+
+def test_book_target_classes_books_every_tuesday_and_thursday_class(
+    schedule_gym: SeleniumGym,
+) -> None:
+    # Card 302 drops its first click; the booking repeats it and the page confirms the second.
+    results = book_target_classes(schedule_gym, sleep=lambda _: None)
+
+    assert [(r.card.card_id, r.outcome) for r in results] == [
+        ("201", Outcome.NEW_WAITLIST),
+        ("302", Outcome.NEW_BOOKING),
+    ]
+
+
+FIXTURE_MY_BOOKINGS = (Path(__file__).parent / "fixtures" / "my_bookings.html").as_uri()
+
+
+@pytest.fixture
+def open_my_bookings_page(tmp_path: Path) -> Iterator[Callable[[str], SeleniumGym]]:
+    """@brief Opens the My Bookings fixture in the given state (a query such as `?state=empty`)."""
+    driver = create_driver(headless=True, profile_dir=tmp_path / "profile", keep_open=False)
+
+    def open_page(query: str = "") -> SeleniumGym:
+        driver.get(FIXTURE_MY_BOOKINGS + query)
+        return SeleniumGym(driver, base_url=FIXTURE_MY_BOOKINGS)
+
+    try:
+        yield open_page
+    finally:
+        driver.quit()
+
+
+def test_open_my_bookings_follows_the_nav_link(schedule_gym: SeleniumGym) -> None:
+    schedule_gym.open_my_bookings()
+
+    assert [entry.name for entry in schedule_gym.list_my_bookings()] == [
+        "Spin Class",
+        "Yoga Class",
+        "HIIT Class",
+    ]
+
+
+def test_list_my_bookings_reads_confirmed_and_waitlist_entries(
+    open_my_bookings_page: Callable[[str], SeleniumGym],
+) -> None:
+    entries = open_my_bookings_page("").list_my_bookings()
+
+    assert entries == [
+        BookingEntry("Spin Class", "Tue, Aug 12, 6:00 PM", False),
+        BookingEntry("Yoga Class", "Wed, Aug 13, 7:00 AM", False),
+        BookingEntry("HIIT Class", "Thu, Aug 14, 6:00 PM", True),
+    ]
+
+
+def test_list_my_bookings_returns_nothing_for_the_empty_state(
+    open_my_bookings_page: Callable[[str], SeleniumGym],
+) -> None:
+    assert open_my_bookings_page("?state=empty").list_my_bookings() == []
+
+
+def test_get_my_bookings_raises_for_the_empty_state(
+    open_my_bookings_page: Callable[[str], SeleniumGym],
+) -> None:
+    with pytest.raises(NoBookingsFoundError):
+        get_my_bookings(open_my_bookings_page("?state=empty"))
+
+
+def test_list_my_bookings_raises_with_the_text_of_the_error_box(
+    open_my_bookings_page: Callable[[str], SeleniumGym],
+) -> None:
+    with pytest.raises(GymError, match="Failed to load bookings"):
+        open_my_bookings_page("?state=error").list_my_bookings()
+
+
+FIXTURE_LOGIN = (Path(__file__).parent / "fixtures" / "login.html").as_uri()
+
+
+@pytest.fixture
+def open_fixture(tmp_path: Path) -> Iterator[Callable[[str], SeleniumGym]]:
+    """@brief Opens a fixture page by its address, with the query that sets its failures."""
+    driver = create_driver(headless=True, profile_dir=tmp_path / "profile", keep_open=False)
+
+    def open_page(url: str) -> SeleniumGym:
+        driver.get(url)
+        return SeleniumGym(driver, base_url=url)
+
+    try:
+        yield open_page
+    finally:
+        driver.quit()
+
+
+def test_login_with_retry_logs_in_after_two_dropped_requests(
+    open_fixture: Callable[[str], SeleniumGym],
+) -> None:
+    gym = open_fixture(FIXTURE_LOGIN + "?fail=2")
+    sleeps: list[float] = []
+
+    login_with_retry(gym, Credentials(FIXTURE_EMAIL, FIXTURE_PASSWORD), sleep=sleeps.append)
+
+    assert len(sleeps) == 2
+
+
+def test_login_with_retry_gives_up_when_every_request_is_dropped(
+    open_fixture: Callable[[str], SeleniumGym],
+) -> None:
+    gym = open_fixture(FIXTURE_LOGIN + "?fail=5")
+
+    with pytest.raises(RetriesExhaustedError, match="Network request failed"):
+        login_with_retry(
+            gym, Credentials(FIXTURE_EMAIL, FIXTURE_PASSWORD), retries=3, sleep=lambda _: None
+        )
+
+
+def test_book_class_with_retry_books_after_two_dropped_clicks(
+    open_fixture: Callable[[str], SeleniumGym],
+) -> None:
+    gym = open_fixture(FIXTURE_SCHEDULE + "?fail=2")
+    card = next(card for card in gym.list_class_cards() if card.card_id == "302")
+
+    result = book_class_with_retry(gym, card, sleep=lambda _: None)
+
+    assert result.outcome is Outcome.NEW_BOOKING
+    assert next(c for c in gym.list_class_cards() if c.card_id == "302").button_text == "Booked"
+
+
+def test_book_target_classes_completes_when_every_class_drops_two_clicks(
+    open_fixture: Callable[[str], SeleniumGym],
+) -> None:
+    gym = open_fixture(FIXTURE_SCHEDULE + "?fail=2")
+
+    results = book_target_classes(gym, sleep=lambda _: None)
+
+    assert [(r.card.card_id, r.outcome) for r in results] == [
+        ("201", Outcome.NEW_WAITLIST),
+        ("302", Outcome.NEW_BOOKING),
+    ]
+
+
+def test_get_my_bookings_with_retry_reads_the_page_after_two_failed_loads(
+    open_fixture: Callable[[str], SeleniumGym],
+) -> None:
+    gym = open_fixture(FIXTURE_MY_BOOKINGS + "?fail=2")
+    sleeps: list[float] = []
+
+    entries = get_my_bookings_with_retry(gym, sleep=sleeps.append)
+
+    assert [entry.name for entry in entries] == ["Spin Class", "Yoga Class", "HIIT Class"]
+    assert sleeps
@@ -2,29 +2,143 @@
@brief A fake of the GymPort for the unit tests.
 """

+import random
+from dataclasses import replace
 from pathlib import Path

-from snack_and_lift.domain.errors import LoginFailedError
+from snack_and_lift import constants
+from snack_and_lift.domain.booking_entry import BookingEntry
+from snack_and_lift.domain.errors import GymError, LoginFailedError
+from snack_and_lift.domain.models import ButtonState, ClassCard
+
+_PRESS_RESULTS = {
+    constants.BUTTON_TEXT_BOOK: constants.BUTTON_TEXT_BOOKED,
+    constants.BUTTON_TEXT_JOIN_WAITLIST: constants.BUTTON_TEXT_WAITLISTED,
+}
+
+
+_WAITLISTED_BY_STATE = {
+    ButtonState.BOOK: False,
+    ButtonState.BOOKED: False,
+    ButtonState.JOIN_WAITLIST: True,
+    ButtonState.WAITLISTED: True,
+}
+
+
+def _entry_of(card: ClassCard) -> BookingEntry | None:
+    """@brief The My Bookings entry that a card ends in, or None when it is not booked."""
+    flag = _WAITLISTED_BY_STATE.get(card.state)
+    if flag is None:
+        return None
+    time_text = card.time_text.removeprefix(constants.TIME_TEXT_PREFIX).strip()
+    return BookingEntry(card.name, f"{card.date_text}, {time_text}", flag)
+
+
+NETWORK_ERROR_TEXT = "Network request failed. Please try again."


 class FakeGym:
-    """@brief Records the calls; can be told to refuse the login."""
+    """@brief Records the calls; can refuse the login, serve cards and fail a click.

-    def __init__(self, login_error: str | None = None) -> None:
+    Unless `bookings` is given, the My Bookings page shows every card that is, or by the
+    click becomes, booked or waitlisted. A successful click turns the card's button into its
+    new state, so a card read again shows what the click did.
+
+    `fail_first` is a deterministic failure schedule: it maps the name of a port method
+    (`log_in`, `press_class_button`, `open_my_bookings`, `list_my_bookings`) to the number of
+    its first calls that fail like a dropped request. With `click_goes_through`, a failing
+    `press_class_button` still turns the button (the click arrived, the answer did not).
+    """
+
+    def __init__(
+        self,
+        login_error: str | None = None,
+        cards: list[ClassCard] | None = None,
+        press_result: str | None = None,
+        press_error: str | None = None,
+        bookings: list[BookingEntry] | None = None,
+        bookings_error: str | None = None,
+        fail_first: dict[str, int] | None = None,
+        click_goes_through: bool = False,
+    ) -> None:
        self.login_error = login_error
+        self.cards = cards or []
+        self.press_result = press_result
+        self.press_error = press_error
+        self.bookings = bookings
+        self.bookings_error = bookings_error
+        self.click_goes_through = click_goes_through
+        self._failures_left = dict(fail_first or {})
        self.calls: list[str] = []
        self.logins: list[tuple[str, str]] = []
        self.screenshots: list[Path] = []
+        self.text_screenshots: list[tuple[str, Path]] = []
+        self.pressed: list[str] = []
        self.closed = False

    def open_site(self) -> None:
        self.calls.append("open_site")

+    def _should_fail(self, name: str) -> bool:
+        """@brief Whether this call is one of the scheduled failures; counts it."""
+        left = self._failures_left.get(name, 0)
+        if left > 0:
+            self._failures_left[name] = left - 1
+            return True
+        return False
+
+    def _turn_button(self, card_id: str) -> str:
+        """@brief Turn the button of a card to the state its click gives; return the new text."""
+        index = next(i for i, card in enumerate(self.cards) if card.card_id == card_id)
+        card = self.cards[index]
+        new_text = _PRESS_RESULTS[card.button_text]
+        self.cards[index] = replace(card, button_text=new_text)
+        return new_text
+
    def log_in(self, email: str, password: str) -> None:
        self.calls.append("log_in")
        self.logins.append((email, password))
        if self.login_error is not None:
            raise LoginFailedError(self.login_error)
+        if self._should_fail("log_in"):
+            raise LoginFailedError(NETWORK_ERROR_TEXT)
+
+    def list_class_cards(self) -> list[ClassCard]:
+        self.calls.append("list_class_cards")
+        return list(self.cards)
+
+    def press_class_button(self, card_id: str) -> str:
+        self.calls.append("press_class_button")
+        self.pressed.append(card_id)
+        if self.press_error is not None:
+            raise GymError(self.press_error)
+        if self.press_result is not None:
+            return self.press_result
+        if self._should_fail("press_class_button"):
+            if self.click_goes_through:
+                self._turn_button(card_id)
+            raise GymError(NETWORK_ERROR_TEXT)
+        return self._turn_button(card_id)
+
+    def open_my_bookings(self) -> None:
+        self.calls.append("open_my_bookings")
+        if self._should_fail("open_my_bookings"):
+            raise GymError(NETWORK_ERROR_TEXT)
+
+    def list_my_bookings(self) -> list[BookingEntry]:
+        self.calls.append("list_my_bookings")
+        if self._should_fail("list_my_bookings"):
+            raise GymError(NETWORK_ERROR_TEXT)
+        if self.bookings_error is not None:
+            raise GymError(self.bookings_error)
+        if self.bookings is not None:
+            return list(self.bookings)
+        entries = (_entry_of(card) for card in self.cards)
+        return [entry for entry in entries if entry is not None]
+
+    def save_text_screenshot(self, text: str, path: Path) -> None:
+        self.calls.append("save_text_screenshot")
+        self.text_screenshots.append((text, path))

    def save_screenshot(self, path: Path) -> None:
        self.calls.append("save_screenshot")
@@ -33,3 +147,30 @@ class FakeGym:
    def close(self) -> None:
        self.calls.append("close")
        self.closed = True
+
+
+class ChaosGym(FakeGym):
+    """@brief A gym whose login, click and bookings read each fail with a set probability.
+
+    The site's network simulation fails up to 50% of these requests and writes nothing when
+    one fails. The random numbers come from a seeded generator, so a run is repeatable.
+    """
+
+    _FAILING_CALLS = frozenset({"log_in", "press_class_button", "list_my_bookings"})
+
+    def __init__(
+        self,
+        rng: random.Random,
+        failure_probability: float = 0.5,
+        cards: list[ClassCard] | None = None,
+    ) -> None:
+        super().__init__(cards=cards)
+        self._rng = rng
+        self._failure_probability = failure_probability
+
+    def _should_fail(self, name: str) -> bool:
+        return name in self._FAILING_CALLS and self._rng.random() < self._failure_probability
+
+
+def no_sleep(seconds: float) -> None:
+    """@brief A `sleep` that returns at once, so a retry test never waits."""
@@ -0,0 +1,83 @@
+"""@file test_application_verification.py
+@brief Reading the My Bookings page and verifying the bookings, against a fake gym.
+"""
+
+import pytest
+from tests.unit.fakes import FakeGym, no_sleep
+from tests.unit.test_booking_entry import make_entry
+from tests.unit.test_models import make_card
+
+from snack_and_lift.application.booking import book_target_classes
+from snack_and_lift.application.verification import get_my_bookings, verify_bookings
+from snack_and_lift.domain.errors import GymError, NoBookingsFoundError, RetriesExhaustedError
+from snack_and_lift.domain.models import ClassResult, Outcome
+
+
+def test_get_my_bookings_opens_the_page_and_returns_all_entries() -> None:
+    entries = [make_entry("Wed, Aug 13, 7:00 AM"), make_entry(waitlisted=True)]
+    gym = FakeGym(bookings=entries)
+
+    assert get_my_bookings(gym) == entries
+    assert gym.calls == ["open_my_bookings", "list_my_bookings"]
+
+
+def test_get_my_bookings_raises_when_the_page_has_no_entry() -> None:
+    with pytest.raises(NoBookingsFoundError):
+        get_my_bookings(FakeGym(bookings=[]))
+
+
+def test_get_my_bookings_propagates_the_page_error() -> None:
+    with pytest.raises(GymError, match="Failed to load"):
+        get_my_bookings(FakeGym(bookings_error="Failed to load bookings"))
+
+
+def test_verify_bookings_succeeds_for_the_booked_classes() -> None:
+    gym = FakeGym(
+        cards=[
+            make_card("Tue, Aug 12", card_id="1"),
+            make_card("Thu, Aug 14", card_id="2", button_text="Join Waitlist"),
+        ]
+    )
+    results = book_target_classes(gym)
+
+    verification = verify_bookings(gym, results)
+
+    assert verification.is_success
+    assert verification.verified == ["Spin Class", "Spin Class (Waitlist)"]
+
+
+def test_verify_bookings_ignores_entries_that_are_not_target_classes() -> None:
+    gym = FakeGym(bookings=[make_entry(), make_entry("Wed, Aug 13, 6:00 PM")])
+    results = [ClassResult(make_card("Tue, Aug 12"), Outcome.NEW_BOOKING)]
+
+    assert verify_bookings(gym, results).is_success
+
+
+def test_verify_bookings_reports_a_missing_booking() -> None:
+    gym = FakeGym(bookings=[make_entry("Wed, Aug 13, 7:00 AM")])
+    results = [ClassResult(make_card("Tue, Aug 12"), Outcome.NEW_BOOKING)]
+
+    verification = verify_bookings(gym, results)
+
+    assert not verification.is_success
+    assert verification.missing == ["Spin Class on Tue, Aug 12"]
+
+
+def test_verify_bookings_raises_when_classes_were_booked_but_the_page_is_empty() -> None:
+    gym = FakeGym(bookings=[])
+    results = [ClassResult(make_card("Tue, Aug 12"), Outcome.NEW_BOOKING)]
+
+    with pytest.raises(RetriesExhaustedError) as caught:
+        verify_bookings(gym, results, sleep=no_sleep)
+
+    assert isinstance(caught.value.__cause__, NoBookingsFoundError)
+
+
+def test_verify_bookings_skips_the_page_when_nothing_is_expected() -> None:
+    gym = FakeGym()
+
+    verification = verify_bookings(gym, [])
+
+    assert verification.is_success
+    assert verification.expected == 0
+    assert gym.calls == []
@@ -0,0 +1,150 @@
+"""@file test_booking.py
+@brief Booking a class and booking the next Tuesday class, against a fake gym.
+"""
+
+import logging
+
+import pytest
+from tests.unit.fakes import FakeGym, no_sleep
+from tests.unit.test_models import make_card
+
+from snack_and_lift.application.booking import (
+    book_class,
+    book_next_tuesday,
+    book_target_classes,
+)
+from snack_and_lift.domain.errors import GymError, UnknownButtonError
+from snack_and_lift.domain.models import Outcome
+
+
+@pytest.mark.parametrize(
+    ("button_text", "outcome", "message"),
+    [
+        ("Book Class", Outcome.NEW_BOOKING, "✓ Successfully booked: Spin Class on"),
+        ("Join Waitlist", Outcome.NEW_WAITLIST, "✓ Joined waitlist for: Spin Class on"),
+    ],
+)
+def test_book_class_clicks_and_confirms(
+    button_text: str, outcome: Outcome, message: str, caplog: pytest.LogCaptureFixture
+) -> None:
+    card = make_card(button_text=button_text)
+    gym = FakeGym(cards=[card])
+
+    with caplog.at_level(logging.INFO):
+        result = book_class(gym, card)
+
+    assert result.outcome is outcome
+    assert gym.pressed == ["123"]
+    assert message in caplog.text
+
+
+@pytest.mark.parametrize(
+    ("button_text", "outcome"),
+    [("Booked", Outcome.ALREADY_BOOKED), ("Waitlisted", Outcome.ALREADY_WAITLISTED)],
+)
+def test_book_class_does_not_click_when_already_done(button_text: str, outcome: Outcome) -> None:
+    gym = FakeGym()
+
+    result = book_class(gym, make_card(button_text=button_text))
+
+    assert result.outcome is outcome
+    assert gym.pressed == []
+
+
+def test_book_class_raises_when_click_is_not_confirmed() -> None:
+    card = make_card()
+    gym = FakeGym(cards=[card], press_result="Book Class")
+
+    with pytest.raises(GymError, match="click not confirmed"):
+        book_class(gym, card)
+
+
+def test_book_class_raises_when_waitlist_click_gives_booked() -> None:
+    card = make_card(button_text="Join Waitlist")
+
+    with pytest.raises(GymError, match="click not confirmed"):
+        book_class(FakeGym(cards=[card], press_result="Booked"), card)
+
+
+def test_book_class_propagates_a_site_error() -> None:
+    with pytest.raises(GymError, match="Network down"):
+        book_class(FakeGym(cards=[make_card()], press_error="Network down"), make_card())
+
+
+def test_book_class_raises_for_a_busy_button() -> None:
+    with pytest.raises(UnknownButtonError):
+        book_class(FakeGym(), make_card(button_text="Booking..."))
+
+
+def test_book_next_tuesday_books_the_first_tuesday_class() -> None:
+    cards = [
+        make_card("Today (Wed, Aug 13)", card_id="1"),
+        make_card("Tue, Aug 19", card_id="2"),
+        make_card("Tue, Aug 26", card_id="3"),
+    ]
+    gym = FakeGym(cards=cards)
+
+    result = book_next_tuesday(gym)
+
+    assert result is not None
+    assert result.card.card_id == "2"
+    assert gym.pressed == ["2"]
+
+
+def test_book_next_tuesday_logs_when_there_is_no_class(caplog: pytest.LogCaptureFixture) -> None:
+    gym = FakeGym(cards=[make_card("Wed, Aug 13")])
+
+    with caplog.at_level(logging.INFO):
+        assert book_next_tuesday(gym) is None
+
+    assert "No Tue class at 18:00 found" in caplog.text
+    assert gym.pressed == []
+
+
+def test_book_target_classes_handles_every_target_class_in_order() -> None:
+    cards = [
+        make_card("Today (Wed, Aug 13)", card_id="1"),
+        make_card("Tomorrow (Thu, Aug 14)", card_id="2"),
+        make_card("Tue, Aug 19", card_id="3", button_text="Join Waitlist"),
+        make_card("Thu, Aug 21", card_id="4", button_text="Booked"),
+        make_card("Tue, Aug 26", card_id="5", button_text="Waitlisted"),
+    ]
+    gym = FakeGym(cards=cards)
+
+    results = book_target_classes(gym)
+
+    assert [result.outcome for result in results] == [
+        Outcome.NEW_BOOKING,
+        Outcome.NEW_WAITLIST,
+        Outcome.ALREADY_BOOKED,
+        Outcome.ALREADY_WAITLISTED,
+    ]
+    assert gym.pressed == ["2", "3"]
+    assert gym.calls.count("list_class_cards") == 1
+
+
+def test_book_target_classes_calls_back_after_each_class() -> None:
+    gym = FakeGym(
+        cards=[make_card("Thu, Aug 14", card_id="1"), make_card("Tue, Aug 19", card_id="2")]
+    )
+    seen: list[str] = []
+
+    book_target_classes(gym, lambda result: seen.append(result.card.card_id))
+
+    assert seen == ["1", "2"]
+
+
+def test_book_target_classes_logs_when_there_is_none(caplog: pytest.LogCaptureFixture) -> None:
+    gym = FakeGym(cards=[make_card("Wed, Aug 13")])
+
+    with caplog.at_level(logging.INFO):
+        assert book_target_classes(gym) == []
+
+    assert "No Tuesday or Thursday class at 18:00 found" in caplog.text
+
+
+def test_book_target_classes_propagates_a_failing_class() -> None:
+    gym = FakeGym(cards=[make_card("Thu, Aug 14")], press_error="Network down")
+
+    with pytest.raises(GymError, match="Network down"):
+        book_target_classes(gym, sleep=no_sleep)
@@ -0,0 +1,65 @@
+"""@file test_booking_entry.py
+@brief The entries of the My Bookings page: parsing and the target test.
+"""
+
+import dataclasses
+
+import pytest
+
+from snack_and_lift.domain.booking_entry import BookingEntry, is_target_entry
+from snack_and_lift.domain.errors import GymError, NoBookingsFoundError, PageFormatError
+
+
+def make_entry(
+    when_text: str = "Tue, Aug 12, 6:00 PM", name: str = "Spin Class", waitlisted: bool = False
+) -> BookingEntry:
+    return BookingEntry(name, when_text, waitlisted)
+
+
+def test_entry_derives_weekday_date_and_time() -> None:
+    entry = make_entry("Thu, Aug 14, 6:00 PM")
+
+    assert entry.weekday == "Thu"
+    assert entry.date_text == "Thu, Aug 14"
+    assert entry.time == (18, 0)
+
+
+@pytest.mark.parametrize(
+    "when_text", ["", "Someday", "Tue, Aug 12", "Tue, Aug 12, noon", "6:00 PM"]
+)
+def test_entry_with_bad_when_text_raises(when_text: str) -> None:
+    with pytest.raises(PageFormatError):
+        is_target_entry(make_entry(when_text))
+
+
+def test_from_page_removes_the_waitlist_suffix_and_the_when_prefix() -> None:
+    entry = BookingEntry.from_page("Spin Class (Waitlist)", "When: Tue, Aug 12, 6:00 PM", True)
+
+    assert entry == BookingEntry("Spin Class", "Tue, Aug 12, 6:00 PM", True)
+
+
+def test_from_page_keeps_a_plain_name() -> None:
+    assert BookingEntry.from_page("Spin Class", "Tue, Aug 12, 6:00 PM", False).name == "Spin Class"
+
+
+@pytest.mark.parametrize(
+    ("when_text", "expected"),
+    [
+        ("Tue, Aug 12, 6:00 PM", True),
+        ("Thu, Aug 14, 6:00 PM", True),
+        ("Wed, Aug 13, 6:00 PM", False),
+        ("Tue, Aug 12, 6:00 AM", False),
+        ("Thu, Aug 14, 6:30 PM", False),
+    ],
+)
+def test_is_target_entry(when_text: str, expected: bool) -> None:
+    assert is_target_entry(make_entry(when_text)) is expected
+
+
+def test_entry_is_immutable() -> None:
+    with pytest.raises(dataclasses.FrozenInstanceError):
+        make_entry().name = "Other"  # type: ignore[misc]
+
+
+def test_no_bookings_found_is_a_gym_error() -> None:
+    assert issubclass(NoBookingsFoundError, GymError)
@@ -2,10 +2,13 @@
@brief The command line accepts its options and the entry point wires the use case.
 """

+import logging
 from pathlib import Path

 import pytest
-from tests.unit.fakes import FakeGym
+from tests.unit.fakes import FakeGym, no_sleep
+from tests.unit.test_booking_entry import make_entry
+from tests.unit.test_models import make_card

 from snack_and_lift import constants
 from snack_and_lift.cli import main, parse_args
@@ -61,8 +64,192 @@ def test_main_saves_both_screenshots_on_success(tmp_path: Path) -> None:

    assert code == 0
    assert gym.logins == [(DUMMY_EMAIL, DUMMY_PASSWORD)]
-    assert gym.screenshots == [tmp_path / "step-1.png", tmp_path / "step-2.png"]
-    assert gym.calls == ["open_site", "save_screenshot", "log_in", "save_screenshot"]
+    assert gym.screenshots == [
+        tmp_path / "step-1.png",
+        tmp_path / "step-2.png",
+        tmp_path / "step-3.png",
+        tmp_path / "step-7.png",
+    ]
+    assert [path for _, path in gym.text_screenshots] == [
+        tmp_path / "step-4.png",
+        tmp_path / "step-5.png",
+        tmp_path / "step-6.png",
+        tmp_path / "step-8.png",
+        tmp_path / "step-9.png",
+    ]
+    assert gym.calls == [
+        "open_site",
+        "save_screenshot",
+        "log_in",
+        "save_screenshot",
+        "list_class_cards",
+        "save_screenshot",
+        "save_text_screenshot",
+        "save_text_screenshot",
+        "save_text_screenshot",
+        "save_screenshot",
+        "save_text_screenshot",
+        "save_text_screenshot",
+    ]
+
+
+@pytest.mark.usefixtures("credentials_env")
+def test_main_books_the_class_and_draws_the_console_text(tmp_path: Path) -> None:
+    gym = FakeGym(cards=[make_card("Tue, Aug 19")])
+
+    assert main(["--screenshot-dir", str(tmp_path)], lambda *_: gym) == 0
+
+    assert gym.pressed == ["123"]
+    text, _ = gym.text_screenshots[0]
+    assert "✓ Logged in" in text
+    assert "✓ Successfully booked: Spin Class on Tue, Aug 19" in text
+
+
+@pytest.mark.usefixtures("credentials_env")
+def test_main_books_every_target_class_and_logs_the_report(
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    gym = FakeGym(
+        cards=[
+            make_card("Tomorrow (Thu, Aug 14)", card_id="1"),
+            make_card("Fri, Aug 15", card_id="2"),
+            make_card("Tue, Aug 19", card_id="3", button_text="Join Waitlist"),
+        ]
+    )
+
+    with caplog.at_level(logging.INFO):
+        assert main([], lambda *_: gym) == 0
+
+    assert gym.pressed == ["1", "3"]
+    assert "New bookings: 1\nNew waitlist entries: 1\nAlready booked/waitlisted: 0" in caplog.text
+    assert "Total Tuesday & Thursday 6pm classes: 2" in caplog.text
+    assert "  • [New Booking] Spin Class on Tomorrow (Thu, Aug 14)" in caplog.text
+    assert "  • [New Waitlist] Spin Class on Tue, Aug 19" in caplog.text
+
+
+@pytest.mark.usefixtures("credentials_env")
+def test_main_saves_step_3_after_the_first_class_and_the_report_images(tmp_path: Path) -> None:
+    gym = FakeGym(
+        cards=[make_card("Thu, Aug 14", card_id="1"), make_card("Tue, Aug 19", card_id="2")]
+    )
+
+    assert main(["--screenshot-dir", str(tmp_path)], lambda *_: gym) == 0
+
+    assert gym.calls == [
+        "open_site",
+        "save_screenshot",
+        "log_in",
+        "save_screenshot",
+        "list_class_cards",
+        "press_class_button",
+        "save_screenshot",
+        "press_class_button",
+        "save_text_screenshot",
+        "save_text_screenshot",
+        "save_text_screenshot",
+        "open_my_bookings",
+        "list_my_bookings",
+        "save_screenshot",
+        "save_text_screenshot",
+        "save_text_screenshot",
+    ]
+    assert gym.screenshots[-2:] == [tmp_path / "step-3.png", tmp_path / "step-7.png"]
+    (_, _), (step_5, _), (step_6, _), (step_8, step_8_path), (step_9, step_9_path) = (
+        gym.text_screenshots
+    )
+    assert step_8_path == tmp_path / "step-8.png"
+    assert step_8.startswith("--- VERIFYING ON MY BOOKINGS PAGE ---")
+    assert step_8.endswith("✅ SUCCESS: All bookings verified!")
+    assert step_9_path == tmp_path / "step-9.png"
+    assert step_9.startswith("✓ Logged in")
+    assert step_9.endswith("✅ SUCCESS: All bookings verified!")
+    assert step_5.startswith("--- BOOKING SUMMARY ---\nNew bookings: 2")
+    assert "--- DETAILED CLASS LIST ---" not in step_5
+    assert step_6.startswith(step_5)
+    assert "--- DETAILED CLASS LIST ---\n  • [New Booking] Spin Class on Thu, Aug 14" in step_6
+
+
+@pytest.mark.usefixtures("credentials_env")
+def test_main_logs_the_verification_and_returns_0_on_success(
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    gym = FakeGym(cards=[make_card("Tue, Aug 19")])
+
+    with caplog.at_level(logging.INFO):
+        assert main([], lambda *_: gym) == 0
+
+    assert "--- VERIFYING ON MY BOOKINGS PAGE ---\n  ✓ Verified: Spin Class" in caplog.text
+    assert "Expected: 1 booking\nFound: 1 booking\n✅ SUCCESS" in caplog.text
+
+
+@pytest.mark.usefixtures("credentials_env")
+def test_main_returns_3_on_a_mismatch(tmp_path: Path, caplog: pytest.LogCaptureFixture) -> None:
+    gym = FakeGym(cards=[make_card("Tue, Aug 19")], bookings=[make_entry("Wed, Aug 20, 7:00 AM")])
+
+    with caplog.at_level(logging.INFO):
+        code = main(["--headless", "--screenshot-dir", str(tmp_path)], lambda *_: gym)
+
+    assert code == 3
+    assert "❌ MISMATCH: Missing 1 bookings" in caplog.text
+    assert "  ✗ Missing: Spin Class on Tue, Aug 19" in caplog.text
+    assert gym.screenshots[-1] == tmp_path / "step-7.png"
+    assert gym.text_screenshots[-2][1] == tmp_path / "step-8.png"
+    assert gym.text_screenshots[-1][1] == tmp_path / "step-9.png"
+    assert gym.closed is True
+
+
+@pytest.mark.usefixtures("credentials_env")
+def test_main_returns_1_when_the_bookings_page_is_empty() -> None:
+    gym = FakeGym(cards=[make_card("Tue, Aug 19")], bookings=[])
+
+    assert main([], lambda *_: gym, no_sleep) == 1
+
+
+@pytest.mark.usefixtures("credentials_env")
+def test_main_logs_an_empty_report_without_target_classes(
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    gym = FakeGym(cards=[make_card("Wed, Aug 13")])
+
+    with caplog.at_level(logging.INFO):
+        assert main([], lambda *_: gym) == 0
+
+    assert "Total Tuesday & Thursday 6pm classes: 0" in caplog.text
+    assert "No matching class found" in caplog.text
+
+
+@pytest.mark.usefixtures("credentials_env")
+def test_main_first_tuesday_only_books_one_class_and_no_report(
+    tmp_path: Path, caplog: pytest.LogCaptureFixture
+) -> None:
+    gym = FakeGym(
+        cards=[make_card("Thu, Aug 14", card_id="1"), make_card("Tue, Aug 19", card_id="2")]
+    )
+
+    with caplog.at_level(logging.INFO):
+        code = main(["--first-tuesday-only", "--screenshot-dir", str(tmp_path)], lambda *_: gym)
+
+    assert code == 0
+    assert gym.pressed == ["2"]
+    assert "BOOKING SUMMARY" not in caplog.text
+    assert "VERIFYING" not in caplog.text
+    assert "open_my_bookings" not in gym.calls
+    assert [path.name for path in gym.screenshots] == ["step-1.png", "step-2.png", "step-3.png"]
+    assert [path.name for _, path in gym.text_screenshots] == ["step-4.png"]
+
+
+@pytest.mark.usefixtures("credentials_env")
+def test_first_tuesday_only_flag_is_read() -> None:
+    assert parse_args(["--first-tuesday-only"]).first_tuesday_only is True
+    assert parse_args([]).first_tuesday_only is False
+
+
+@pytest.mark.usefixtures("credentials_env")
+def test_main_returns_1_when_the_booking_fails() -> None:
+    gym = FakeGym(cards=[make_card("Tue, Aug 19")], press_error="Network down")
+
+    assert main(["--headless"], lambda *_: gym, no_sleep) == 1
+    assert gym.closed is True


@pytest.mark.usefixtures("credentials_env")
@@ -91,7 +278,7 @@ def test_main_returns_2_when_credentials_are_missing(
 def test_main_returns_1_when_login_fails() -> None:
    gym = FakeGym(login_error="Invalid credentials")

-    assert main(["--headless"], lambda *_: gym) == 1
+    assert main(["--headless"], lambda *_: gym, no_sleep) == 1
    assert gym.closed is True


@@ -0,0 +1,30 @@
+"""@file test_console_recorder.py
+@brief The recorder keeps the formatted lines of the log.
+"""
+
+import logging
+
+from snack_and_lift.infrastructure.console_recorder import ConsoleRecorder
+
+
+def test_recorder_keeps_formatted_messages() -> None:
+    logger = logging.getLogger("test_console_recorder")
+    logger.setLevel(logging.INFO)
+    recorder = ConsoleRecorder()
+    logger.addHandler(recorder)
+    try:
+        logger.info("✓ Logged %s", "in")
+        logger.warning("careful")
+    finally:
+        logger.removeHandler(recorder)
+
+    assert recorder.lines == ["✓ Logged in", "careful"]
+    assert recorder.text == "✓ Logged in\ncareful"
+
+
+def test_recorder_lines_are_a_copy() -> None:
+    recorder = ConsoleRecorder()
+
+    recorder.lines.append("x")
+
+    assert recorder.lines == []
@@ -29,3 +29,7 @@ def test_retry_count_is_seven() -> None:

 def test_bot_books_tuesday_and_thursday() -> None:
    assert constants.TARGET_WEEKDAYS == ("Tue", "Thu")
+
+
+def test_retry_delay_is_half_a_second() -> None:
+    assert constants.RETRY_DELAY_SECONDS == 0.5
@@ -0,0 +1,87 @@
+"""@file test_date_independence.py
+@brief The bot picks classes by weekday and time only, whatever the first visible day is.
+"""
+
+from datetime import date, timedelta
+
+import pytest
+from tests.unit.fakes import FakeGym
+
+from snack_and_lift.application.booking import book_target_classes
+from snack_and_lift.application.verification import verify_bookings
+from snack_and_lift.domain.models import ClassCard
+from snack_and_lift.domain.rules import find_target_classes
+
+## A Monday; the schedules below start on this day plus an offset, so every weekday occurs.
+_A_MONDAY = date(2025, 8, 11)
+_DAYS_SHOWN = 8
+_TUESDAY, _THURSDAY = 1, 3
+_TIMES = (
+    ("Time: 6:00 AM", "Book Class"),
+    ("Time: 6:00 PM", "Book Class"),
+    ("Time: 7:00 PM", "Book Class"),
+)
+
+
+def _day_text(day: date) -> str:
+    return f"{day:%a}, {day:%b} {day.day}"
+
+
+def _label(index: int, day: date) -> str:
+    if index == 0:
+        return f"Today ({_day_text(day)})"
+    if index == 1:
+        return f"Tomorrow ({_day_text(day)})"
+    return _day_text(day)
+
+
+def make_schedule(start_offset: int) -> tuple[list[ClassCard], set[str]]:
+    """@brief Cards of 8 days from a start weekday, and the ids of the Tue/Thu 6pm ones."""
+    cards: list[ClassCard] = []
+    wanted: set[str] = set()
+    for index in range(_DAYS_SHOWN):
+        day = _A_MONDAY + timedelta(days=start_offset + index)
+        for slot, (time_text, button) in enumerate(_TIMES):
+            card_id = f"{index}{slot}"
+            cards.append(ClassCard(card_id, "Spin Class", _label(index, day), time_text, button))
+            if day.weekday() in (_TUESDAY, _THURSDAY) and slot == 1:
+                wanted.add(card_id)
+    return cards, wanted
+
+
+@pytest.mark.parametrize("start_offset", range(7))
+def test_find_target_classes_for_every_starting_weekday(start_offset: int) -> None:
+    cards, wanted = make_schedule(start_offset)
+
+    assert {card.card_id for card in find_target_classes(cards)} == wanted
+    assert wanted
+
+
+@pytest.mark.parametrize("start_offset", range(7))
+def test_booking_and_verification_for_every_starting_weekday(start_offset: int) -> None:
+    cards, wanted = make_schedule(start_offset)
+    gym = FakeGym(cards=cards)
+
+    results = book_target_classes(gym)
+
+    assert set(gym.pressed) == wanted
+    assert len(gym.pressed) == len(wanted)
+    assert verify_bookings(gym, results).is_success
+
+
+def test_schedule_whose_first_visible_day_is_a_thursday_includes_today() -> None:
+    cards, _ = make_schedule(3)
+    assert cards[0].day_label.startswith("Today (Thu,")
+
+    chosen = find_target_classes(cards)
+
+    assert [card.weekday for card in chosen] == ["Thu", "Tue", "Thu"]
+    assert chosen[0].card_id == "01"
+
+
+def test_card_order_does_not_change_which_classes_are_chosen() -> None:
+    cards, wanted = make_schedule(2)
+
+    chosen = find_target_classes(list(reversed(cards)))
+
+    assert {card.card_id for card in chosen} == wanted
@@ -0,0 +1,57 @@
+"""@file test_models.py
+@brief Button states and the values derived from a class card.
+"""
+
+import dataclasses
+
+import pytest
+
+from snack_and_lift.domain.errors import PageFormatError
+from snack_and_lift.domain.models import ButtonState, ClassCard
+
+
+def make_card(
+    day_label: str = "Tomorrow (Thu, Aug 14)",
+    time_text: str = "Time: 6:00 PM",
+    button_text: str = "Book Class",
+    card_id: str = "123",
+    name: str = "Spin Class",
+) -> ClassCard:
+    return ClassCard(card_id, name, day_label, time_text, button_text)
+
+
+@pytest.mark.parametrize(
+    ("text", "state"),
+    [
+        ("Book Class", ButtonState.BOOK),
+        ("Join Waitlist", ButtonState.JOIN_WAITLIST),
+        ("Booked", ButtonState.BOOKED),
+        ("Waitlisted", ButtonState.WAITLISTED),
+        ("Booking...", ButtonState.BUSY),
+        ("Joining...", ButtonState.BUSY),
+        ("Completed", ButtonState.COMPLETED),
+        (" Booked ", ButtonState.BOOKED),
+        ("", ButtonState.UNKNOWN),
+        ("Cancel", ButtonState.UNKNOWN),
+    ],
+)
+def test_button_state_is_read_from_text(text: str, state: ButtonState) -> None:
+    assert ButtonState.from_text(text) is state
+
+
+def test_card_derives_state_weekday_and_date() -> None:
+    card = make_card()
+
+    assert card.state is ButtonState.BOOK
+    assert card.weekday == "Thu"
+    assert card.date_text == "Thu, Aug 14"
+
+
+def test_card_with_bad_day_label_raises() -> None:
+    with pytest.raises(PageFormatError):
+        _ = make_card(day_label="Someday").weekday
+
+
+def test_card_is_immutable() -> None:
+    with pytest.raises(dataclasses.FrozenInstanceError):
+        make_card().name = "Other"  # type: ignore[misc]
@@ -0,0 +1,86 @@
+"""@file test_report.py
+@brief The counters, the booking summary and the detailed class list.
+"""
+
+from tests.unit.test_models import make_card
+
+from snack_and_lift.domain.models import ClassResult, Outcome
+from snack_and_lift.domain.report import (
+    Counters,
+    count_results,
+    format_detail_list,
+    format_summary,
+)
+
+
+def make_result(outcome: Outcome, day_label: str = "Tue, Aug 19") -> ClassResult:
+    return ClassResult(make_card(day_label), outcome)
+
+
+def test_count_results_groups_the_outcomes() -> None:
+    results = [
+        make_result(Outcome.NEW_BOOKING),
+        make_result(Outcome.NEW_BOOKING),
+        make_result(Outcome.NEW_WAITLIST),
+        make_result(Outcome.ALREADY_BOOKED),
+        make_result(Outcome.ALREADY_WAITLISTED),
+    ]
+
+    counters = count_results(results)
+
+    assert counters == Counters(new_bookings=2, new_waitlist=1, already_done=2)
+    assert counters.total == 5
+
+
+def test_count_results_is_zero_for_no_results() -> None:
+    assert count_results([]).total == 0
+
+
+def test_format_summary_matches_the_lecture() -> None:
+    results = [
+        make_result(Outcome.NEW_BOOKING, "Tomorrow (Thu, Aug 14)"),
+        make_result(Outcome.NEW_WAITLIST),
+    ]
+
+    assert format_summary(results) == (
+        "--- BOOKING SUMMARY ---\n"
+        "New bookings: 1\n"
+        "New waitlist entries: 1\n"
+        "Already booked/waitlisted: 0\n"
+        "Total Tuesday & Thursday 6pm classes: 2"
+    )
+
+
+def test_format_summary_for_no_results() -> None:
+    assert format_summary([]).endswith("Total Tuesday & Thursday 6pm classes: 0")
+
+
+def test_format_detail_list_matches_the_lecture() -> None:
+    results = [
+        make_result(Outcome.NEW_BOOKING, "Tomorrow (Thu, Aug 14)"),
+        make_result(Outcome.NEW_WAITLIST),
+    ]
+
+    assert format_detail_list(results) == (
+        "--- DETAILED CLASS LIST ---\n"
+        "  • [New Booking] Spin Class on Tomorrow (Thu, Aug 14)\n"
+        "  • [New Waitlist] Spin Class on Tue, Aug 19"
+    )
+
+
+def test_format_detail_list_tags_every_outcome() -> None:
+    results = [
+        make_result(Outcome.ALREADY_BOOKED),
+        make_result(Outcome.ALREADY_WAITLISTED),
+    ]
+
+    lines = format_detail_list(results).splitlines()
+
+    assert lines[1:] == [
+        "  • [Already Booked] Spin Class on Tue, Aug 19",
+        "  • [Already Waitlisted] Spin Class on Tue, Aug 19",
+    ]
+
+
+def test_format_detail_list_says_when_no_class_was_found() -> None:
+    assert format_detail_list([]) == "--- DETAILED CLASS LIST ---\n  No matching class found"
@@ -0,0 +1,316 @@
+"""@file test_resilience.py
+@brief Lecture step 9: login, booking and bookings read survive a site that drops requests.
+"""
+
+import logging
+import random
+from pathlib import Path
+
+import pytest
+from tests.unit.fakes import ChaosGym, FakeGym, no_sleep
+from tests.unit.test_booking_entry import make_entry
+from tests.unit.test_models import make_card
+
+from snack_and_lift import constants
+from snack_and_lift.application.booking import (
+    book_class_with_retry,
+    book_next_tuesday,
+    book_target_classes,
+)
+from snack_and_lift.application.credentials import Credentials
+from snack_and_lift.application.session import login_with_retry
+from snack_and_lift.application.verification import get_my_bookings_with_retry, verify_bookings
+from snack_and_lift.cli import main, parse_args
+from snack_and_lift.domain.errors import GymError, LoginFailedError, RetriesExhaustedError
+from snack_and_lift.domain.models import ButtonState, ClassResult, Outcome
+
+DUMMY_EMAIL = "dummy@example.invalid"
+DUMMY_PASSWORD = "dummy-password"
+CREDENTIALS = Credentials(DUMMY_EMAIL, DUMMY_PASSWORD)
+
+
+@pytest.fixture
+def credentials_env(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setenv(constants.ACCOUNT_EMAIL_ENV, DUMMY_EMAIL)
+    monkeypatch.setenv(constants.ACCOUNT_PASSWORD_ENV, DUMMY_PASSWORD)
+
+
+def test_login_with_retry_logs_in_after_two_dropped_requests(
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    gym = FakeGym(fail_first={"log_in": 2})
+    sleeps: list[float] = []
+
+    with caplog.at_level(logging.INFO):
+        login_with_retry(gym, CREDENTIALS, sleep=sleeps.append)
+
+    assert gym.calls == ["log_in"] * 3
+    assert sleeps == [constants.RETRY_DELAY_SECONDS] * 2
+    assert "⚠ Attempt 2/7 failed: login: Network request failed. Please try again." in caplog.text
+    assert "✓ login succeeded after 3 attempts" in caplog.text
+
+
+def test_login_with_retry_never_logs_the_password(caplog: pytest.LogCaptureFixture) -> None:
+    gym = FakeGym(fail_first={"log_in": 2})
+
+    with caplog.at_level(logging.DEBUG):
+        login_with_retry(gym, CREDENTIALS, sleep=no_sleep)
+
+    assert DUMMY_PASSWORD not in caplog.text
+    assert DUMMY_EMAIL not in caplog.text
+
+
+def test_login_with_retry_gives_up_after_the_set_attempts() -> None:
+    gym = FakeGym(fail_first={"log_in": 10})
+
+    with pytest.raises(RetriesExhaustedError, match="login failed after 3 attempts") as caught:
+        login_with_retry(gym, CREDENTIALS, retries=3, sleep=no_sleep)
+
+    assert isinstance(caught.value.__cause__, LoginFailedError)
+    assert len(gym.logins) == 3
+
+
+def test_book_class_with_retry_repeats_a_dropped_click() -> None:
+    card = make_card()
+    gym = FakeGym(cards=[card], fail_first={"press_class_button": 2})
+
+    result = book_class_with_retry(gym, card, sleep=no_sleep)
+
+    assert result.outcome is Outcome.NEW_BOOKING
+    assert gym.pressed == ["123", "123", "123"]
+    assert gym.calls.count("list_class_cards") == 2
+
+
+def test_book_class_with_retry_reads_nothing_again_when_the_first_attempt_works() -> None:
+    card = make_card()
+    gym = FakeGym(cards=[card])
+
+    book_class_with_retry(gym, card, sleep=no_sleep)
+
+    assert gym.calls == ["press_class_button"]
+
+
+@pytest.mark.parametrize(
+    ("button_text", "outcome", "final_state"),
+    [
+        ("Book Class", Outcome.NEW_BOOKING, ButtonState.BOOKED),
+        ("Join Waitlist", Outcome.NEW_WAITLIST, ButtonState.WAITLISTED),
+    ],
+)
+def test_book_class_with_retry_counts_a_click_that_went_through_as_new(
+    button_text: str,
+    outcome: Outcome,
+    final_state: ButtonState,
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    card = make_card(button_text=button_text)
+    gym = FakeGym(cards=[card], fail_first={"press_class_button": 1}, click_goes_through=True)
+
+    with caplog.at_level(logging.INFO):
+        result = book_class_with_retry(gym, card, sleep=no_sleep)
+
+    assert result.outcome is outcome
+    assert gym.pressed == ["123"]
+    assert gym.cards[0].state is final_state
+    assert "Already" not in caplog.text
+
+
+def test_book_class_with_retry_keeps_already_booked_as_it_is() -> None:
+    card = make_card(button_text="Booked")
+    gym = FakeGym(cards=[card])
+
+    result = book_class_with_retry(gym, card, sleep=no_sleep)
+
+    assert result.outcome is Outcome.ALREADY_BOOKED
+    assert gym.pressed == []
+
+
+def test_book_class_with_retry_does_not_count_a_click_without_confirmation() -> None:
+    card = make_card()
+    gym = FakeGym(cards=[card], press_result="Book Class")
+
+    with pytest.raises(RetriesExhaustedError, match="click not confirmed"):
+        book_class_with_retry(gym, card, retries=2, sleep=no_sleep)
+
+    assert gym.pressed == ["123", "123"]
+
+
+def test_book_class_with_retry_fails_when_the_class_left_the_schedule() -> None:
+    card = make_card()
+    gym = FakeGym(cards=[card], fail_first={"press_class_button": 1})
+    gym.cards.clear()
+
+    with pytest.raises(RetriesExhaustedError, match="not found on the schedule"):
+        book_class_with_retry(gym, card, retries=2, sleep=no_sleep)
+
+
+def test_book_class_with_retry_gives_up_after_the_set_attempts() -> None:
+    card = make_card()
+    gym = FakeGym(cards=[card], fail_first={"press_class_button": 9})
+
+    with pytest.raises(RetriesExhaustedError, match="book Spin Class on Tomorrow"):
+        book_class_with_retry(gym, card, retries=3, sleep=no_sleep)
+
+    assert len(gym.pressed) == 3
+
+
+def test_book_next_tuesday_repeats_a_dropped_click() -> None:
+    gym = FakeGym(cards=[make_card("Tue, Aug 19")], fail_first={"press_class_button": 1})
+
+    result = book_next_tuesday(gym, sleep=no_sleep)
+
+    assert result is not None
+    assert result.outcome is Outcome.NEW_BOOKING
+
+
+def test_book_target_classes_repeats_each_class_on_its_own() -> None:
+    gym = FakeGym(
+        cards=[make_card("Thu, Aug 14", card_id="1"), make_card("Tue, Aug 19", card_id="2")],
+        fail_first={"press_class_button": 3},
+    )
+
+    results = book_target_classes(gym, sleep=no_sleep)
+
+    assert [result.outcome for result in results] == [Outcome.NEW_BOOKING] * 2
+    assert gym.pressed == ["1", "1", "1", "1", "2"]
+
+
+def test_get_my_bookings_with_retry_opens_the_page_again_after_a_failure() -> None:
+    entries = [make_entry("Wed, Aug 13, 7:00 AM")]
+    gym = FakeGym(bookings=entries, fail_first={"open_my_bookings": 1, "list_my_bookings": 1})
+
+    assert get_my_bookings_with_retry(gym, sleep=no_sleep) == entries
+    assert gym.calls == [
+        "open_my_bookings",
+        "open_my_bookings",
+        "list_my_bookings",
+        "open_my_bookings",
+        "list_my_bookings",
+    ]
+
+
+def test_get_my_bookings_with_retry_gives_up_after_the_set_attempts() -> None:
+    gym = FakeGym(bookings_error="Failed to load bookings")
+
+    with pytest.raises(RetriesExhaustedError, match="Failed to load bookings"):
+        get_my_bookings_with_retry(gym, retries=2, sleep=no_sleep)
+
+
+def test_verify_bookings_reads_the_page_through_retry() -> None:
+    card = make_card("Tue, Aug 12")
+    gym = FakeGym(cards=[card], fail_first={"list_my_bookings": 2})
+    results = [ClassResult(card, Outcome.NEW_BOOKING)]
+
+    verification = verify_bookings(gym, results, sleep=no_sleep)
+
+    assert verification.is_success
+
+
+def test_main_completes_a_run_with_dropped_requests_and_draws_them_in_step_9(
+    credentials_env: None, tmp_path: Path, caplog: pytest.LogCaptureFixture
+) -> None:
+    gym = FakeGym(
+        cards=[make_card("Thu, Aug 14", card_id="1"), make_card("Tue, Aug 19", card_id="2")],
+        fail_first={"log_in": 1, "press_class_button": 2, "list_my_bookings": 1},
+    )
+
+    with caplog.at_level(logging.INFO):
+        code = main(["--screenshot-dir", str(tmp_path)], lambda *_: gym, no_sleep)
+
+    assert code == 0
+    step_9, step_9_path = gym.text_screenshots[-1]
+    assert step_9_path == tmp_path / "step-9.png"
+    assert "⚠ Attempt 1/7 failed: login" in step_9
+    assert "succeeded after 2 attempts" in step_9
+    assert step_9.endswith("✅ SUCCESS: All bookings verified!")
+
+
+def test_main_returns_1_when_every_retry_failed(
+    credentials_env: None, caplog: pytest.LogCaptureFixture
+) -> None:
+    gym = FakeGym(fail_first={"log_in": 5})
+
+    with caplog.at_level(logging.INFO):
+        code = main(["--retries", "2"], lambda *_: gym, no_sleep)
+
+    assert code == 1
+    assert len(gym.logins) == 2
+    assert "Failed: login failed after 2 attempts" in caplog.text
+
+
+def test_main_uses_one_attempt_when_asked() -> None:
+    assert parse_args(["--retries", "1"]).retries == 1
+
+
+def test_retries_option_defaults_to_the_constant() -> None:
+    assert parse_args([]).retries == constants.RETRY_COUNT
+
+
+@pytest.mark.parametrize("value", ["0", "-3", "many", "1.5"])
+def test_retries_option_rejects_less_than_one(value: str) -> None:
+    with pytest.raises(SystemExit):
+        parse_args(["--retries", value])
+
+
+def test_help_epilog_mentions_retries(capsys: pytest.CaptureFixture[str]) -> None:
+    with pytest.raises(SystemExit):
+        parse_args(["--help"])
+
+    out = capsys.readouterr().out
+    assert "--retries N" in out
+    assert "every retry failed" in out
+
+
+## Chance that a request fails in the chaos test: the site's maximum (50%).
+CHAOS_FAILURE_PROBABILITY = 0.5
+
+## Chaos runs, and how many must complete. With 7 attempts an operation fails for good with
+## probability 0.5**7 (about 0.8%). A run has four such operations (login, two clicks, the
+## bookings read), so about 3% of runs fail and about 97 of 100 complete; 90 leaves room for
+## the spread of the seeds without hiding a real defect. The seeds are fixed, so it is stable.
+CHAOS_RUNS = 100
+CHAOS_MIN_COMPLETED = 90
+
+## Seeds that were checked to complete fully (seed 18 is the first that runs out of attempts);
+## a change that breaks one of them is a defect.
+CHAOS_SEEDS_THAT_MUST_PASS = tuple(range(18))
+
+
+def _run_chaos(seed: int) -> tuple[int, ChaosGym]:
+    gym = ChaosGym(
+        random.Random(seed),
+        CHAOS_FAILURE_PROBABILITY,
+        cards=[make_card("Thu, Aug 14", card_id="1"), make_card("Tue, Aug 19", card_id="2")],
+    )
+    return main(["--retries", "7"], lambda *_: gym, no_sleep), gym
+
+
+def _is_consistent(gym: ChaosGym) -> bool:
+    """@brief True when every target class is booked on the page after the run."""
+    return all(card.state is ButtonState.BOOKED for card in gym.cards)
+
+
+@pytest.mark.usefixtures("credentials_env")
+def test_chaos_runs_with_half_of_the_requests_failing_mostly_complete() -> None:
+    completed = 0
+    for seed in range(CHAOS_RUNS):
+        code, gym = _run_chaos(seed)
+        assert code in (0, 1), f"seed {seed}: a verified run never ends in a mismatch"
+        if code == 0:
+            assert _is_consistent(gym), f"seed {seed}: verified but not booked"
+            completed += 1
+
+    assert completed >= CHAOS_MIN_COMPLETED
+
+
+@pytest.mark.usefixtures("credentials_env")
+@pytest.mark.parametrize("seed", CHAOS_SEEDS_THAT_MUST_PASS)
+def test_chaos_seed_completes_with_a_consistent_verified_result(seed: int) -> None:
+    code, gym = _run_chaos(seed)
+
+    assert code == 0
+    assert _is_consistent(gym)
+
+
+def test_retry_error_is_a_gym_error_for_the_exit_code() -> None:
+    assert issubclass(RetriesExhaustedError, GymError)
@@ -0,0 +1,167 @@
+"""@file test_retry.py
+@brief The retry wrapper: success, repeats, exhaustion, what it logs and what it never retries.
+"""
+
+import logging
+
+import pytest
+
+from snack_and_lift import constants
+from snack_and_lift.application.retry import retry
+from snack_and_lift.domain.errors import (
+    GymError,
+    LoginFailedError,
+    MissingCredentialsError,
+    PageFormatError,
+    RetriesExhaustedError,
+    UnknownButtonError,
+)
+
+
+class Flaky:
+    """@brief A step that raises the given errors in turn and then returns a value."""
+
+    def __init__(self, errors: list[Exception], value: str = "done") -> None:
+        self._errors = list(errors)
+        self._value = value
+        self.calls = 0
+
+    def __call__(self) -> str:
+        self.calls += 1
+        if self._errors:
+            raise self._errors.pop(0)
+        return self._value
+
+
+def test_retry_returns_the_result_on_the_first_attempt() -> None:
+    step = Flaky([])
+    sleeps: list[float] = []
+
+    assert retry(step, sleep=sleeps.append) == "done"
+    assert step.calls == 1
+    assert sleeps == []
+
+
+def test_retry_succeeds_after_some_failures(caplog: pytest.LogCaptureFixture) -> None:
+    step = Flaky([GymError("a"), GymError("b")])
+
+    with caplog.at_level(logging.INFO):
+        result = retry(step, 7, "login", sleep=lambda _: None)
+
+    assert result == "done"
+    assert step.calls == 3
+    assert "✓ login succeeded after 3 attempts" in caplog.text
+
+
+def test_retry_does_not_log_success_after_a_single_attempt(
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    with caplog.at_level(logging.INFO):
+        retry(Flaky([]), 7, "login", sleep=lambda _: None)
+
+    assert "succeeded" not in caplog.text
+
+
+def test_retry_raises_after_the_last_attempt_with_the_last_error_as_cause() -> None:
+    last = GymError("third")
+    step = Flaky([GymError("first"), GymError("second"), last])
+
+    with pytest.raises(RetriesExhaustedError, match="login failed after 3 attempts") as caught:
+        retry(step, 3, "login", sleep=lambda _: None)
+
+    assert caught.value.__cause__ is last
+    assert "third" in str(caught.value)
+    assert step.calls == 3
+
+
+def test_retries_exhausted_is_a_gym_error() -> None:
+    with pytest.raises(GymError):
+        retry(Flaky([GymError("x")]), 1, sleep=lambda _: None)
+
+
+def test_retry_with_one_attempt_does_not_repeat_or_sleep() -> None:
+    step = Flaky([GymError("x"), GymError("y")])
+    sleeps: list[float] = []
+
+    with pytest.raises(RetriesExhaustedError):
+        retry(step, 1, sleep=sleeps.append)
+
+    assert step.calls == 1
+    assert sleeps == []
+
+
+def test_retry_with_one_attempt_returns_on_success() -> None:
+    assert retry(Flaky([]), 1, sleep=lambda _: None) == "done"
+
+
+def test_retry_waits_the_delay_between_attempts_but_not_after_the_last() -> None:
+    sleeps: list[float] = []
+
+    with pytest.raises(RetriesExhaustedError):
+        retry(Flaky([GymError("x")] * 4), 4, delay=1.5, sleep=sleeps.append)
+
+    assert sleeps == [1.5, 1.5, 1.5]
+
+
+def test_retry_uses_the_default_delay_and_attempts() -> None:
+    sleeps: list[float] = []
+    step = Flaky([GymError("x")] * constants.RETRY_COUNT)
+
+    with pytest.raises(RetriesExhaustedError):
+        retry(step, sleep=sleeps.append)
+
+    assert step.calls == constants.RETRY_COUNT
+    assert sleeps == [constants.RETRY_DELAY_SECONDS] * (constants.RETRY_COUNT - 1)
+
+
+def test_retry_logs_a_warning_with_attempt_description_and_error(
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    step = Flaky([GymError("Network request failed. Please try again.")])
+
+    with caplog.at_level(logging.WARNING):
+        retry(step, 7, "login", sleep=lambda _: None)
+
+    assert (
+        "⚠ Attempt 1/7 failed: login: Network request failed. Please try again. Retrying..."
+        in caplog.text
+    )
+
+
+def test_retry_names_a_step_without_description(caplog: pytest.LogCaptureFixture) -> None:
+    with caplog.at_level(logging.WARNING):
+        retry(Flaky([GymError("x")]), sleep=lambda _: None)
+
+    assert f"failed: {constants.RETRY_DEFAULT_DESCRIPTION}: x" in caplog.text
+
+
+@pytest.mark.parametrize(
+    "error",
+    [LoginFailedError("no"), UnknownButtonError("busy"), PageFormatError("format")],
+)
+def test_retry_repeats_every_kind_of_gym_error(error: GymError) -> None:
+    step = Flaky([error])
+
+    assert retry(step, 2, sleep=lambda _: None) == "done"
+    assert step.calls == 2
+
+
+def test_retry_lets_other_errors_pass_untouched() -> None:
+    error = MissingCredentialsError("missing")
+    step = Flaky([error])
+
+    with pytest.raises(MissingCredentialsError) as caught:
+        retry(step, 7, sleep=lambda _: None)
+
+    assert caught.value is error
+    assert step.calls == 1
+
+
+@pytest.mark.parametrize("retries", [0, -1])
+def test_retry_rejects_fewer_than_one_attempt(retries: int) -> None:
+    step = Flaky([])
+
+    with pytest.raises(ValueError, match="at least 1"):
+        retry(step, retries)
+
+    assert step.calls == 0
@@ -0,0 +1,164 @@
+"""@file test_rules.py
+@brief Day and time parsing, finding the target class, the decision and the messages.
+"""
+
+import pytest
+from tests.unit.test_models import make_card
+
+from snack_and_lift.domain.errors import PageFormatError, UnknownButtonError
+from snack_and_lift.domain.models import Outcome
+from snack_and_lift.domain.rules import (
+    Action,
+    decide_outcome_action,
+    find_next_class,
+    find_target_classes,
+    format_outcome,
+    is_target_time,
+    parse_day_label,
+    parse_time,
+)
+
+
+@pytest.mark.parametrize(
+    ("label", "expected"),
+    [
+        ("Today (Tue, Aug 12)", ("Tue", "Tue, Aug 12")),
+        ("Tomorrow (Wed, Aug 13)", ("Wed", "Wed, Aug 13")),
+        ("Thu, Aug 14", ("Thu", "Thu, Aug 14")),
+        ("  Fri, Sep 5 ", ("Fri", "Fri, Sep 5")),
+    ],
+)
+def test_day_label_is_split(label: str, expected: tuple[str, str]) -> None:
+    assert parse_day_label(label) == expected
+
+
+@pytest.mark.parametrize("label", ["", "Tuesday", "Today Tue, Aug 12", "Today (Tue, Aug 12", "x"])
+def test_day_label_junk_raises(label: str) -> None:
+    with pytest.raises(PageFormatError):
+        parse_day_label(label)
+
+
+@pytest.mark.parametrize(
+    ("text", "expected"),
+    [
+        ("6:00 PM", (18, 0)),
+        ("Time: 6:00 PM", (18, 0)),
+        ("12:00 AM", (0, 0)),
+        ("12:30 AM", (0, 30)),
+        ("12:00 PM", (12, 0)),
+        ("11:59 PM", (23, 59)),
+        ("1:05 am", (1, 5)),
+    ],
+)
+def test_time_is_read(text: str, expected: tuple[int, int]) -> None:
+    assert parse_time(text) == expected
+
+
+@pytest.mark.parametrize("text", ["", "noon", "6 PM", "0:00 AM", "13:00 PM", "6:60 PM", "18:00"])
+def test_time_junk_raises(text: str) -> None:
+    with pytest.raises(PageFormatError):
+        parse_time(text)
+
+
+def test_target_time_is_six_pm() -> None:
+    assert is_target_time(make_card(time_text="Time: 6:00 PM"))
+    assert not is_target_time(make_card(time_text="Time: 6:00 AM"))
+    assert not is_target_time(make_card(time_text="Time: 6:30 PM"))
+
+
+def test_next_class_is_found_when_the_schedule_starts_on_a_wednesday() -> None:
+    cards = [
+        make_card("Today (Wed, Aug 13)", card_id="1"),
+        make_card("Thu, Aug 14", card_id="2"),
+        make_card("Tue, Aug 19", time_text="Time: 7:00 AM", card_id="3"),
+        make_card("Tue, Aug 19", card_id="4"),
+        make_card("Tue, Aug 26", card_id="5"),
+    ]
+
+    found = find_next_class(cards, "Tue")
+
+    assert found is not None
+    assert found.card_id == "4"
+
+
+def test_next_class_accepts_a_today_label() -> None:
+    cards = [make_card("Today (Tue, Aug 12)", card_id="9")]
+
+    found = find_next_class(cards, "Tue")
+
+    assert found is not None
+    assert found.card_id == "9"
+
+
+def test_next_class_skips_completed_classes() -> None:
+    cards = [
+        make_card("Today (Tue, Aug 12)", button_text="Completed", card_id="1"),
+        make_card("Tue, Aug 19", card_id="2"),
+    ]
+
+    found = find_next_class(cards, "Tue")
+
+    assert found is not None
+    assert found.card_id == "2"
+
+
+def test_next_class_is_none_without_a_match() -> None:
+    assert find_next_class([make_card("Thu, Aug 14")], "Tue") is None
+    assert find_next_class([], "Tue") is None
+
+
+@pytest.mark.parametrize(
+    ("button_text", "action"),
+    [
+        ("Book Class", Action.CLICK_BOOK),
+        ("Join Waitlist", Action.CLICK_WAITLIST),
+        ("Booked", Action.ALREADY_BOOKED),
+        ("Waitlisted", Action.ALREADY_WAITLISTED),
+    ],
+)
+def test_action_follows_the_button_state(button_text: str, action: Action) -> None:
+    assert decide_outcome_action(make_card(button_text=button_text)) is action
+
+
+@pytest.mark.parametrize("button_text", ["Booking...", "Joining...", "Completed", "???"])
+def test_action_for_busy_or_unknown_button_raises(button_text: str) -> None:
+    with pytest.raises(UnknownButtonError):
+        decide_outcome_action(make_card(button_text=button_text))
+
+
+@pytest.mark.parametrize(
+    ("outcome", "message"),
+    [
+        (Outcome.NEW_BOOKING, "✓ Successfully booked: Spin Class on Tomorrow (Thu, Aug 14)"),
+        (Outcome.NEW_WAITLIST, "✓ Joined waitlist for: Spin Class on Tomorrow (Thu, Aug 14)"),
+        (Outcome.ALREADY_BOOKED, "✓ Already booked: Spin Class on Tomorrow (Thu, Aug 14)"),
+        (Outcome.ALREADY_WAITLISTED, "✓ Already on waitlist: Spin Class on Tomorrow (Thu, Aug 14)"),
+    ],
+)
+def test_outcome_message(outcome: Outcome, message: str) -> None:
+    assert format_outcome(outcome, make_card()) == message
+
+
+def test_find_target_classes_returns_tuesdays_and_thursdays_in_page_order() -> None:
+    cards = [
+        make_card("Today (Wed, Aug 13)", card_id="1"),
+        make_card("Tomorrow (Thu, Aug 14)", card_id="2"),
+        make_card("Fri, Aug 15", card_id="3"),
+        make_card("Tue, Aug 19", card_id="4"),
+    ]
+
+    assert [card.card_id for card in find_target_classes(cards)] == ["2", "4"]
+
+
+def test_find_target_classes_ignores_other_times_and_completed_cards() -> None:
+    cards = [
+        make_card("Thu, Aug 14", time_text="Time: 7:00 AM", card_id="1"),
+        make_card("Thu, Aug 14", button_text="Completed", card_id="2"),
+        make_card("Tue, Aug 19", time_text="Time: 6:00 PM", card_id="3"),
+    ]
+
+    assert [card.card_id for card in find_target_classes(cards)] == ["3"]
+
+
+def test_find_target_classes_is_empty_when_none_match() -> None:
+    assert find_target_classes([make_card("Wed, Aug 13")]) == []
@@ -0,0 +1,106 @@
+"""@file test_verification.py
+@brief The comparison of the bot's results with the My Bookings page, and its text.
+"""
+
+from tests.unit.test_booking_entry import make_entry
+from tests.unit.test_models import make_card
+
+from snack_and_lift.domain.models import ClassResult, Outcome
+from snack_and_lift.domain.verification import build_verification, format_verification
+
+BOOKED = ClassResult(make_card("Tue, Aug 12"), Outcome.NEW_BOOKING)
+WAITLISTED = ClassResult(make_card("Thu, Aug 14", card_id="2"), Outcome.NEW_WAITLIST)
+
+
+def test_everything_found_is_a_success() -> None:
+    result = build_verification(
+        [BOOKED, WAITLISTED],
+        [make_entry("Tue, Aug 12, 6:00 PM"), make_entry("Thu, Aug 14, 6:00 PM", waitlisted=True)],
+    )
+
+    assert result.is_success
+    assert result.verified == ["Spin Class", "Spin Class (Waitlist)"]
+    assert (result.expected, result.found) == (2, 2)
+
+
+def test_success_text_is_exact() -> None:
+    result = build_verification(
+        [BOOKED, WAITLISTED],
+        [make_entry("Tue, Aug 12, 6:00 PM"), make_entry("Thu, Aug 14, 6:00 PM", waitlisted=True)],
+    )
+
+    assert format_verification(result) == (
+        "--- VERIFYING ON MY BOOKINGS PAGE ---\n"
+        "  ✓ Verified: Spin Class\n"
+        "  ✓ Verified: Spin Class (Waitlist)\n"
+        "\n"
+        "--- VERIFICATION RESULT ---\n"
+        "Expected: 2 bookings\n"
+        "Found: 2 bookings\n"
+        "✅ SUCCESS: All bookings verified!"
+    )
+
+
+def test_one_booking_is_singular() -> None:
+    text = format_verification(build_verification([BOOKED], [make_entry("Tue, Aug 12, 6:00 PM")]))
+
+    assert "Expected: 1 booking\nFound: 1 booking\n" in text
+
+
+def test_missing_entry_is_a_mismatch_with_a_line() -> None:
+    result = build_verification([BOOKED, WAITLISTED], [make_entry("Tue, Aug 12, 6:00 PM")])
+
+    text = format_verification(result)
+
+    assert not result.is_success
+    assert result.missing == ["Spin Class (Waitlist) on Thu, Aug 14"]
+    assert "Expected: 2 bookings\nFound: 1 booking\n❌ MISMATCH: Missing 1 bookings" in text
+    assert text.endswith("  ✗ Missing: Spin Class (Waitlist) on Thu, Aug 14")
+
+
+def test_unexpected_entry_gives_a_negative_missing_count() -> None:
+    result = build_verification(
+        [BOOKED], [make_entry("Tue, Aug 12, 6:00 PM"), make_entry("Thu, Aug 14, 6:00 PM")]
+    )
+
+    text = format_verification(result)
+
+    assert result.unexpected == ["Spin Class on Thu, Aug 14"]
+    assert "❌ MISMATCH: Missing -1 bookings" in text
+    assert text.endswith("  ? Unexpected: Spin Class on Thu, Aug 14")
+
+
+def test_waitlist_flag_must_match() -> None:
+    result = build_verification([BOOKED], [make_entry("Tue, Aug 12, 6:00 PM", waitlisted=True)])
+
+    assert result.missing == ["Spin Class on Tue, Aug 12"]
+    assert result.unexpected == ["Spin Class (Waitlist) on Tue, Aug 12"]
+    assert "Missing 0 bookings" in format_verification(result)
+
+
+def test_date_must_match() -> None:
+    result = build_verification([BOOKED], [make_entry("Tue, Aug 19, 6:00 PM")])
+
+    assert not result.is_success
+
+
+def test_already_waitlisted_is_expected_as_waitlist() -> None:
+    results = [ClassResult(make_card("Thu, Aug 14"), Outcome.ALREADY_WAITLISTED)]
+
+    assert build_verification(
+        results, [make_entry("Thu, Aug 14, 6:00 PM", waitlisted=True)]
+    ).is_success
+
+
+def test_nothing_expected_and_nothing_found_is_a_success() -> None:
+    result = build_verification([], [])
+
+    assert result.is_success
+    assert "Expected: 0 bookings\nFound: 0 bookings\n✅ SUCCESS" in format_verification(result)
+
+
+def test_same_class_twice_is_matched_one_to_one() -> None:
+    result = build_verification([BOOKED, BOOKED], [make_entry("Tue, Aug 12, 6:00 PM")])
+
+    assert result.verified == ["Spin Class"]
+    assert result.missing == ["Spin Class on Tue, Aug 12"]
Author	SHA1	Message	Date
Tirsvad	6871e54333	Resolve pending commit links	2026-10-28 18:14:19 +08:00
Tirsvad	5d28e682b4	Add review record RC-021 for MIL-007	2026-10-28 18:14:18 +08:00
Tirsvad	37f3cc436a	Add retry wrapper and resilient login, booking and bookings read (step 9) retry(func, retries=7, description=None), RetriesExhaustedError, resilient login, book_class and get_my_bookings that re-read the card before a repeat and count a booking only when the page confirms it, --retries option, step-9 console image, seeded chaos tests at 50 percent failure and container tests against failing local fixtures. Task: MIL-007#1 Task: MIL-007#2 Task: MIL-007#3 Task: MIL-007#4	2026-10-28 18:14:13 +08:00
Tirsvad	a830e3ae5f	Merge pull request 'MIL-006: verify bookings and time travel QA' (#45 ) from mil-006-verify-and-time-travel into main TirSystem/git-workflows: Sync GitHub mirror metadata / sync-metadata (push) Successful in 7s Details	2026-10-28 11:03:00 +01:00
Tirsvad	944ba204cf	Resolve pending commit links	2026-10-28 18:02:52 +08:00
Tirsvad	f57040e136	Add review record RC-020 for MIL-006	2026-10-28 18:02:50 +08:00
Tirsvad	8c6cc148f5	Add My Bookings verification and date-independent booking (steps 7 and 8) Booking entries parsed from the My Bookings page, comparison of expected and found bookings with the lecture's output, NoBookingsFoundError as the counterpart of NoSuchElementException, exit code 3 on a mismatch, tests for every starting weekday of the 8-day window, container tests against local fixtures. Task: MIL-006#1 Task: MIL-006#2 Task: MIL-006#3 Task: MIL-006#4	2026-10-28 18:02:44 +08:00
Tirsvad	0a665ee9ac	Merge pull request 'MIL-005: counters and every Tuesday and Thursday class' (#44 ) from mil-005-counters-and-both-days into main TirSystem/git-workflows: Sync GitHub mirror metadata / sync-metadata (push) Successful in 6s Details	2026-10-28 10:54:26 +01:00
Tirsvad	1088a88e59	Resolve pending commit links	2026-10-28 17:54:19 +08:00
Tirsvad	45e6fc72df	Add review record RC-019 for MIL-005	2026-10-28 17:54:17 +08:00
Tirsvad	2ce7e3d8dc	Add counters, summary and every Tuesday and Thursday class (steps 5 and 6) Target class lookup for Tuesday and Thursday 6pm, counters, booking summary and detailed class list, --first-tuesday-only for the earlier step, screenshot names for steps 5 and 6, unit and container tests. Task: MIL-005#1 Task: MIL-005#2 Task: MIL-005#3 Task: MIL-005#4	2026-10-28 17:54:11 +08:00
Tirsvad	e0b6abb662	Merge pull request 'MIL-004: book a class and check its state' (#43 ) from mil-004-book-class into main TirSystem/git-workflows: Sync GitHub mirror metadata / sync-metadata (push) Successful in 6s Details	2026-10-28 10:49:17 +01:00
Tirsvad	41b0dace11	Add review record RC-018 and resolve pending commit links for MIL-004	2026-10-28 17:49:10 +08:00
Tirsvad	08ba464ec9	Add class card parsing, booking and state checks (steps 3 and 4) Day label and time parsing, next Tuesday 6pm lookup without list-position tricks, decision on Book Class / Join Waitlist / Booked / Waitlisted, confirmed clicks, console recorder and text screenshots, unit tests and container tests against local fixtures. Task: MIL-004#1 Task: MIL-004#2 Task: MIL-004#3 Task: MIL-004#4	2026-10-28 17:49:06 +08:00
Tirsvad	735cb73cde	Merge pull request 'MIL-003: profile, navigation and automated login' (#42 ) from mil-003-login into main TirSystem/git-workflows: Sync GitHub mirror metadata / sync-metadata (push) Successful in 7s Details	2026-10-28 10:42:08 +01:00