Move the framework pin to v0.18.0 (TOKEN_FOR_GITEA_* token names)

Merge pull request 'MIL-008: smarter purchase rule' (#49 ) from mil-008-smarter-rule into main
Resolve pending commit links for MIL-008
2026-10-29 00:32:35 +08:00 · 2026-10-28 16:43:41 +01:00 · 2026-10-28 23:43:04 +08:00 · 2026-10-28 23:43:01 +08:00 · 2026-10-28 23:19:42 +08:00 · 2026-10-28 23:17:17 +08:00
21 changed files with 673 additions and 130 deletions
@@ -102,6 +102,7 @@ The bot plays for 5 minutes, then prints one line on standard output, for exampl
 | `--duration SECONDS` | How long to play | 300 |
 | `--interval SECONDS` | Time between upgrade checks (greater than 0) | 5 |
 | `--buy-all` | Buy every affordable upgrade, most expensive first, instead of one | off |
+| `--best-value` | Buy the affordable upgrade with the lowest price per cookie per second (not together with `--buy-all`) | off |
 | `--headless` | Run Chromium without a window | off (on in Docker) |
 | `--screenshot PATH` | Save a screenshot when the run ends | none |
 | `--screenshot-start PATH` | Save a screenshot before the first click | none |
@@ -14,9 +14,9 @@ document of a type. `Primary File` may contain a glob (e.g.
 | BC | Business Case | docs/business-case.md | 002 |
 | SA | Stakeholder Analysis | docs/stakeholder-analysis.md | 002 |
 | PP | Project Plan | docs/project-plan.md | 002 |
-| MIL | Milestone / Gateway | docs/milestones/*.md | 008 |
+| 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 | 019 |
+| RC | SQA Review Record | docs/sqa/reviews/rc-*.md | 021 |
 | TM | Traceability Matrix | docs/sqa/traceability-matrix.md | 002 |
 | DICT | Domain Dictionary (PO and IT terms) | docs/dictionary.md | 002 |

@@ -0,0 +1,76 @@
+# MIL-008 Smarter purchase rule
+
+## Metadata
+| Key | Value |
+| --- | --- |
+| ID | MIL-008 |
+| CrossReference | [BC-001] |
+| Language | en |
+| Domain | it |
+
+## Version History
+| Date | Status | Author | Reviewer | Change | Commit |
+| --- | --- | --- | --- | --- | --- |
+| 2026-10-28 | Accepted | Jens Tirsvad Nielsen | AI as stand-in for S02 | Initial version | [9a6796f] |
+
+---
+
+## Purpose
+
+Decide whether a purchase rule that looks at what an upgrade earns, not only at its price, beats the assignment's rule ("most expensive affordable", 18.9 cookies/second alone on the computer) in a measured container run.
+
+## Deliverable
+
+A "best value" strategy next to buy-one and buy-all (the lowest price per cookie per second among the affordable upgrades), selectable from the command line, unit tested, with a recorded comparison and a wiki note for each language. The defaults stay the assignment's behaviour.
+
+## Go / No-Go Criteria
+
+| # | Criterion (objectively checkable) | Go | No-Go |
+| --- | --- | --- | --- |
+| 1 | The new strategy is selectable from the command line and the defaults are unchanged (5 seconds, buy one) | Defaults unchanged | Defaults changed |
+| 2 | The rule is a pure function in `domain/` with no Selenium import, and unit tests cover it | 0 failures, coverage of the logic modules at 80% or more | A test fails or coverage drops |
+| 3 | Baseline and new strategy are each run at least twice in the same container conditions and the table is recorded | Table with 4 or more rows | Fewer rows |
+| 4 | The result is stated as measured, also when the new rule is not better | Result named | Claim without a measurement |
+| 5 | The wiki records the result in English, Danish and Bahasa Malaysia | 3 languages | A language missing |
+| 6 | The code review against `qc-programming-python.md` is `Go` | `RC-*` is `Go` | `No-Go` |
+
+## Dependencies
+
+| Depends on | Reason |
+| --- | --- |
+| MIL-006 | Extends the strategy options and the comparison method |
+
+## Traceability
+
+| Business Case objective / KPI / user story | Reference |
+| --- | --- |
+| O4 | [BC-001] |
+| CN-003 | [SA-001] |
+
+## Ownership
+
+| Role | Stakeholder ID (SA) |
+| --- | --- |
+| Owner | S01 |
+| Approving reviewer | S02 (AI as stand-in, autonomous mode, not independent) |
+
+## Target Date
+
+2026-11-06 — after the planned window of [PP-001]; the Business Case sets no deadline.
+
+## Tasks
+
+| # | Task | Summary | Needs its own Use Case/User Story? | Reference |
+| --- | --- | --- | --- | --- |
+| 1 | Read the production of each upgrade | Add to the game port a read of how many cookies per second one unit of each visible upgrade makes (from the game's own data), and add it to `Upgrade`. Unit tested with a fake game. | No | O4 |
+| 2 | Add the best value rule | Add a pure function that picks the affordable upgrade with the lowest price per cookie per second, and a `BEST_VALUE` strategy. Unit tested, including ties and unknown production. | No | O4 |
+| 3 | Select the strategy from the command line | Add the option, keep buy-one as the default, and update the README option table. | No | O4 |
+| 4 | Compare with container runs | Run baseline and best value at least twice each in Docker under the same conditions, record cookies per second and name the better rule. | No | O4 |
+| 5 | Record the result in the wiki | Add the result and what was gained to Step 5 in English, Danish and Bahasa Malaysia. | No | O4 |
+
+---
+
+[BC-001]: ../business-case.md
+[PP-001]: ../project-plan.md
+[SA-001]: ../stakeholder-analysis.md
+[9a6796f]: https://git.tirsystem.com/Tirsvad-Udemy-100-days-of-code/048-the-coockie-factory-new/commit/9a6796f775680effe37a54f2609c3915140c8c0e
@@ -12,12 +12,13 @@
 | Date | Status | Author | Reviewer | Change | Commit |
 | --- | --- | --- | --- | --- | --- |
 | 2026-10-28 | Accepted | Jens Tirsvad Nielsen | S01 | Initial version: seven gateways; accepted by S01 in chat | [cadc5ef] |
+| 2026-10-28 | Accepted | Jens Tirsvad Nielsen | S01 | Add MIL-008 (smarter purchase rule); accepted by S01 in chat | [9a6796f] |

 ---

 ## Purpose

-This plan schedules seven gateways (`MIL-001` to `MIL-007`) that take the Cookie Clicker bot from an accepted baseline to a documented, tested and published repository. The Business Case sets no deadline, so the window 2026-10-28 to 2026-11-04 is a planning assumption of this plan. Each gateway ends in a decision and a deliverable and is delivered by one pull request on its own branch.
+This plan schedules eight gateways (`MIL-001` to `MIL-008`) that take the Cookie Clicker bot from an accepted baseline to a documented, tested and published repository. The Business Case sets no deadline, so the window 2026-10-28 to 2026-11-04 is a planning assumption of this plan. Each gateway ends in a decision and a deliverable and is delivered by one pull request on its own branch.

 ## Planning Assumptions

@@ -38,6 +39,7 @@ This plan schedules seven gateways (`MIL-001` to `MIL-007`) that take the Cookie
 | Lecture step 4 | [MIL-005] | 2026-10-31 to 2026-11-01 | 2026-11-01 | S01 | none (technical tasks) | 5 minute run, cookies per second, screenshot 4 | [Milestone 5] |
 | Lecture step 5 | [MIL-006] | 2026-11-01 to 2026-11-02 | 2026-11-02 | S01 | none (technical tasks) | Strategy options, comparison, screenshot 5 | [Milestone 6] |
 | Documentation, wiki and release | [MIL-007] | 2026-11-02 to 2026-11-04 | 2026-11-04 | S01 | none (documentation) | README, Doxygen, wiki in en, da and ms, final checks | [Milestone 7] |
+| Smarter purchase rule | [MIL-008] | 2026-11-05 to 2026-11-06 | 2026-11-06 | S01 | none (technical tasks) | Best value strategy, measured comparison, wiki note in en, da and ms | [Milestone 8] |

 ```plantuml
@startgantt
@@ -103,6 +105,7 @@ A No-Go on a gateway stops all later gateways until it is fixed and re-reviewed.
 [MIL-005]: ./milestones/mil-005-timed-run.md
 [MIL-006]: ./milestones/mil-006-strategy.md
 [MIL-007]: ./milestones/mil-007-documentation.md
+[MIL-008]: ./milestones/mil-008-smarter-rule.md
 [cadc5ef]: https://git.tirsystem.com/Tirsvad-Udemy-100-days-of-code/048-the-coockie-factory-new/commit/cadc5eff21d9afc09799d4bc2e3f6ac17ab2612a
 [Milestone 1]: https://git.tirsystem.com/Tirsvad-Udemy-100-days-of-code/048-the-coockie-factory-new/milestone/290
 [Milestone 2]: https://git.tirsystem.com/Tirsvad-Udemy-100-days-of-code/048-the-coockie-factory-new/milestone/291
@@ -111,3 +114,5 @@ A No-Go on a gateway stops all later gateways until it is fixed and re-reviewed.
 [Milestone 5]: https://git.tirsystem.com/Tirsvad-Udemy-100-days-of-code/048-the-coockie-factory-new/milestone/294
 [Milestone 6]: https://git.tirsystem.com/Tirsvad-Udemy-100-days-of-code/048-the-coockie-factory-new/milestone/295
 [Milestone 7]: https://git.tirsystem.com/Tirsvad-Udemy-100-days-of-code/048-the-coockie-factory-new/milestone/296
+[Milestone 8]: https://git.tirsystem.com/Tirsvad-Udemy-100-days-of-code/048-the-coockie-factory-new/milestone/308
+[9a6796f]: https://git.tirsystem.com/Tirsvad-Udemy-100-days-of-code/048-the-coockie-factory-new/commit/9a6796f775680effe37a54f2609c3915140c8c0e
@@ -0,0 +1,65 @@
+# SQA Review Record
+
+## Metadata
+| Key | Value |
+| --- | --- |
+| ID | RC-019 |
+| CrossReference | [MIL-008], [QC-MIL-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 | [9a6796f] |
+
+---
+
+## Artifact Under Review
+
+- Instance reviewed: [MIL-008]
+- Checklist used: [QC-MIL-001] (`QC-MIL-001`)
+- Scope: full review
+- Language and domain: en / it
+- Language reviewer: none
+- Mode: autonomous, not independent (the reviewer is `AI as stand-in for S02`)
+
+## Checklist Results
+
+| # | Criterion | Status | Evidence/Notes |
+| --- | --- | --- | --- |
+| 1 | A concrete deliverable is defined for every gate | Pass | Deliverable names the strategy, the comparison and the wiki note. |
+| 2 | Explicit Go/No-Go criteria are stated for each gate | Pass | Go/No-Go table has objectively checkable criteria with Go and No-Go columns. |
+| 3 | Dependencies on other milestones are explicitly mapped | Pass | Dependencies table names the preceding gateway. |
+| 4 | Each milestone is traceable to a Business Case objective or KPI | Pass | Traceability maps to Business Case objectives and success criteria. |
+| 5 | Milestone owner and approving reviewer are identified | Pass | Ownership: owner S01, approving reviewer S02 (AI stand-in). |
+| 6 | Milestone has a defined target date consistent with project constraints | Pass | Target Date lies after the plan window in PP-001 (the plan is extended in this change); the Business Case sets no deadline. |
+
+## Language and Domain Results
+
+| # | Criterion | Status | Evidence/Notes |
+| --- | --- | --- | --- |
+| 1 | The Metadata table has a `Language` row and a `Domain` row, and neither is a placeholder | Pass | Metadata has `Language` = en and `Domain` = it. |
+| 2 | `Language` is a BCP 47 code and `Domain` is a value from the registry's domain list | Pass | `en` is BCP 47; `it` is in the registry domain list. |
+| 3 | The content (prose and table cells) is written in the stated language | Pass | All prose and table cells are English. |
+| 4 | The register matches the one the registry gives for the artifact type | Pass | Register of the type is IT Executive English (registry, Languages). |
+| 5 | Domain terms are the PO terms of the domain's dictionary, with no synonyms | Pass | Terms follow DICT-001: bot, cookie, cookies per second, lecture step, upgrade. |
+| 6 | Metadata keys, section headings, IDs and statuses are in English | Pass | Keys, headings, IDs and statuses are English. |
+| 7 | No translated twin (`<name>.<language>.md`) exists beside the document | Pass | No translated twin exists in `docs/`. |
+| 8 | A change of language or domain since the previous accepted version has a Version History row and was reviewed again | N-A | First version; no language change. |
+| 9 | A reviewer competent in the domain, and in the language, has confirmed that the domain terms are used correctly | Pass | The stand-in reviewer reads English and checked the IT terms in context. |
+| 10 | Abbreviations are spelled out on first use, in the stated language | Pass | Abbreviations (ADR, QC, ISO/IEC, S-IDs) are spelled out or defined where first used, or are the framework's own IDs. |
+
+## Overall Verdict
+
+Go — MIL-008 meets every Mandatory criterion. No blocking finding. The review is not independent: the AI authored and reviewed it as stand-in for S02, and S01 can challenge it in the end-of-run summary.
+
+## Action Items
+
+| Action | Owner | Due |
+| --- | --- | --- |
+| None | S01 | - |
+
+---
+
+[MIL-008]: ../../milestones/mil-008-smarter-rule.md
+[QC-MIL-001]: ../../../framework/qc/artifacts/qc-milestones-gateways.md
+[9a6796f]: https://git.tirsystem.com/Tirsvad-Udemy-100-days-of-code/048-the-coockie-factory-new/commit/9a6796f775680effe37a54f2609c3915140c8c0e
@@ -0,0 +1,62 @@
+# SQA Review Record
+
+## Metadata
+| Key | Value |
+| --- | --- |
+| ID | RC-020 |
+| CrossReference | [MIL-008], [QC-PY-001] |
+
+## Version History
+| Date | Status | Author | Reviewer | Change | Commit |
+| --- | --- | --- | --- | --- | --- |
+| 2026-10-28 | Accepted | Jens Tirsvad Nielsen | AI as stand-in for S02 | Code review record | [2f1c7ff] |
+
+---
+
+## Artifact Under Review
+
+- Instance reviewed: [MIL-008]
+- Checklist used: [QC-PY-001] (`QC-PY-001`)
+- Scope: full review of the source and tests added by MIL-008: the best value rule `choose_best_value`, the `BEST_VALUE` strategy, the production read in the Selenium adapter, the `--best-value` option and 19 new tests; four 300 s container runs produced the comparison
+- 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 | ruff (N rules) passes; names follow PEP 8 casing. |
+| 2 | Names state purpose in the domain's language; no unexplained abbreviations, no single-letter names outside tiny scopes | Pass | Names use the terms of DICT-001 (cookie, upgrade, bot); 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` and `ruff check` pass with the rules in `pyproject.toml`; no suppressions. |
+| 4 | Every function and method signature is type-annotated, including `-> None` | Pass | `mypy --strict` passes; every signature is annotated. |
+| 5 | No bare `except:`, no swallowed exceptions; specific exceptions are raised and the cause is kept (`raise ... from`) | Pass | No bare `except`; ruff B and S rules pass. |
+| 6 | No mutable default arguments and no shadowed builtins | Pass | No mutable defaults; ruff B006 and A rules pass. |
+| 7 | Files, locks and connections are managed with context managers | Pass | The browser is closed in a `finally` block in `main`. |
+| 8 | Public modules, classes and functions have docstrings that say what, not how | Pass | Public modules, classes and functions have Doxygen docstrings with `@brief`. |
+| 9 | Logging uses `logging`, not `print`; no secrets or personal data in log output | Pass | Diagnostics use `logging`; the required result line `cookies/second: N` is the program's output, not a log; no secrets are read or logged. |
+| 10 | Classes and operations trace to the Design Class Diagram they implement; deviations are recorded | N-A | No Design Class Diagram exists (ADR-0001 skips use case design); ADR-0002 records the layout instead. |
+| 11 | Tests exist for new behaviour, are named for the behaviour, and do not depend on order or the network | Pass | 135 tests pass with fakes; 100% coverage of the logic modules; tests cover the new rule, the production read and its failure paths. |
+| 12 | Type checker runs in strict mode without errors; `Any` is justified in a comment | Pass | `mypy --strict` passes; no `Any`. |
+| 13 | Dependencies are declared and pinned in the project's dependency file, none unused | Pass | `pyproject.toml` lists Selenium as the only runtime dependency; dev extras are test and lint tools. |
+| 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 | Constants live only in `constants.py`; rules are defined once. |
+| 15 | Imports point inward: business-rule modules import no framework, database, UI or delivery-mechanism code, and there are no import cycles | Pass | `domain` imports no Selenium; `application` depends on a port; no import cycles. |
+| 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 | Modules have one reason to change; the game is behind a narrow port. |
+| 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 | Layers `domain`, `application`, `infrastructure` under `src/`, `unit` and `integration` under `tests/`; no `presentation` package by 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 | English names, snake_case files, no spaces. |
+
+## Overall Verdict
+
+Go — the code of MIL-008 meets every Mandatory criterion; `ruff`, `mypy --strict` and `pytest` were run and pass. 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 |
+| --- | --- | --- |
+| None | S01 | - |
+
+---
+
+[MIL-008]: ../../milestones/mil-008-smarter-rule.md
+[QC-PY-001]: ../../../framework/qc/code/qc-programming-python.md
+[2f1c7ff]: https://git.tirsystem.com/Tirsvad-Udemy-100-days-of-code/048-the-coockie-factory-new/commit/2f1c7ff00a80bdcfa4ed4ff087227a3e4d4d591c
@@ -9,7 +9,8 @@
 ## Version History
 | Date | Status | Author | Reviewer | Change | Commit |
 | --- | --- | --- | --- | --- | --- |
-| 2026-10-28 | Accepted | Jens Tirsvad Nielsen | AI as stand-in for S02 | Initial version: baseline artifacts | [cadc5ef] |
+| 2026-10-28 | Accepted | Jens Tirsvad Nielsen | AI as stand-in for S02 | Add MIL-008 and RC-019 | [9a6796f] |
+| 2026-10-28 | Accepted | Jens Tirsvad Nielsen | AI as stand-in for S02 | Add RC-020, the code review of MIL-008 | [2f1c7ff] |

 ---

@@ -29,7 +30,7 @@ Tracks backward and forward links between artifact instances so that the Busines
 | --- | --- | --- | --- | --- | --- | --- |
 | [BC-001] | Business Case | en | it | - | [SA-001], [PP-001] | RC-001 |
 | [SA-001] | Stakeholder Analysis | en | it | [BC-001] | [PP-001] | RC-002 |
-| [PP-001] | Project Plan | en | it | [BC-001], [SA-001] | [MIL-001] to [MIL-007] | - (accepted by S01 in chat; no checklist) |
+| [PP-001] | Project Plan | en | it | [BC-001], [SA-001] | [MIL-001] to [MIL-008] | - (accepted by S01 in chat; no checklist) |
 | [DICT-001] | Domain Dictionary | en | it | [BC-001], [SA-001] | - | RC-003 |
 | [ADR-0001] | ADR | - | - | [BC-001] | [PP-001] | RC-004 |
 | [ADR-0002] | ADR | - | - | [BC-001], [SA-001] | code in MIL-002 onward | RC-005 |
@@ -40,12 +41,14 @@ Tracks backward and forward links between artifact instances so that the Busines
 | [MIL-004] | Milestone | en | it | [BC-001], [PP-001] | [MIL-005] | RC-010 |
 | [MIL-005] | Milestone | en | it | [BC-001], [PP-001] | [MIL-006] | RC-011 |
 | [MIL-006] | Milestone | en | it | [BC-001], [PP-001] | [MIL-007] | RC-012 |
-| [MIL-007] | Milestone | en | it | [BC-001], [PP-001] | - | RC-013 |
+| [MIL-007] | Milestone | en | it | [BC-001], [PP-001] | [MIL-008] | RC-013 |
+| [MIL-008] | Milestone | en | it | [BC-001], [PP-001] | - | RC-019 |
 | Source and tests of [MIL-002] | Python source code | - | - | [MIL-002], [ADR-0002] | - | RC-014 |
 | Source and tests of [MIL-003] | Python source code | - | - | [MIL-003], [ADR-0002] | - | RC-015 |
 | Source and tests of [MIL-004] | Python source code | - | - | [MIL-004], [ADR-0002] | - | RC-016 |
 | Source and tests of [MIL-005] | Python source code | - | - | [MIL-005], [ADR-0002] | - | RC-017 |
 | Source and tests of [MIL-006] | Python source code | - | - | [MIL-006], [ADR-0002] | - | RC-018 |
+| Source and tests of [MIL-008] | Python source code | - | - | [MIL-008], [ADR-0002] | - | RC-020 |

 ## Concern Coverage

@@ -53,7 +56,7 @@ Tracks backward and forward links between artifact instances so that the Busines
 | --- | --- | --- | --- | --- |
 | CN-001 | [BC-001], [MIL-003], [MIL-004], [MIL-005] | [ADR-0002] | Unit tests per gateway | Covered |
 | CN-002 | [PP-001], [MIL-001] | [ADR-0001] | Review records | Covered |
-| CN-003 | [MIL-006] | - | Unit tests per gateway | Covered |
+| CN-003 | [MIL-006], [MIL-008] | - | Unit tests per gateway | Covered |
 | CN-004 | [MIL-002], [MIL-003] | [ADR-0002] | Code review | Covered |
 | CN-005 | [MIL-002], [MIL-007] | - | Clean clone walk-through | Covered |
 | CN-006 | [MIL-007] | - | Wiki check | Covered |
@@ -89,4 +92,7 @@ Tracks backward and forward links between artifact instances so that the Busines
 [MIL-005]: ../milestones/mil-005-timed-run.md
 [MIL-006]: ../milestones/mil-006-strategy.md
 [MIL-007]: ../milestones/mil-007-documentation.md
+[MIL-008]: ../milestones/mil-008-smarter-rule.md
 [cadc5ef]: https://git.tirsystem.com/Tirsvad-Udemy-100-days-of-code/048-the-coockie-factory-new/commit/cadc5eff21d9afc09799d4bc2e3f6ac17ab2612a
+[9a6796f]: https://git.tirsystem.com/Tirsvad-Udemy-100-days-of-code/048-the-coockie-factory-new/commit/9a6796f775680effe37a54f2609c3915140c8c0e
+[2f1c7ff]: https://git.tirsystem.com/Tirsvad-Udemy-100-days-of-code/048-the-coockie-factory-new/commit/2f1c7ff00a80bdcfa4ed4ff087227a3e4d4d591c
@@ -36,9 +36,29 @@ Det bedste resultat er intervallet på 10 sekunder med køb én. Hvorfor:
 - At tjekke oftere er ikke bedre. Hvert tjek læser siden og tager tid fra klikningen, og det dyreste produkt, der er råd til, er som regel kun lidt bedre end det billigere, man kunne have købt et øjeblik før.
 - Køb alle gør ingen forskel tidligt i spillet: der er kun råd til Cursor og Grandma, og det køber botten alligevel. Det ville få betydning senere, når antallet af cookies rummer flere produkter på én gang.

+## En smartere regel: bedste værdi
+
+`--best-value` ser ikke kun på prisen. Spillet fortæller, hvor mange cookies pr. sekund én enhed af hvert produkt giver, og botten køber det produkt, der er råd til, med den laveste pris pr. cookie pr. sekund (`choose_best_value`). Cursor koster 15 og giver 0,1 (150 cookies for hver cookie pr. sekund), Grandma koster 100 og giver 1 (100 for hver), så Grandma er det bedste køb, selv om den koster mere.
+
+```bash
+cookie-clicker-bot --best-value
+```
+
+Hver række er en fuld kørsel på 300 sekunder alene i en Docker-container, den ene efter den anden, tjek hvert 5. sekund:
+
+| Kørsel | Strategi | cookies/sekund | Købt |
+| --- | --- | --- | --- |
+| 1 | dyreste, der er råd til | 18 | 30 Cursor, 15 Grandma |
+| 2 | bedste værdi | 17.9 | 29 Cursor, 15 Grandma |
+| 3 | dyreste, der er råd til | 18.8 | 28 Cursor, 16 Grandma |
+| 4 | bedste værdi | 18.8 | 28 Cursor, 16 Grandma |
+
+Den smartere regel er **ikke bedre**: de to regler adskiller sig mindre end to kørsler af den samme regel (18 og 18,8). Årsagen er den samme som for køb alle. På 5 sekunder klikker botten omkring 125 cookies, så der er kun råd til Cursor og Grandma, og begge regler køber næsten det samme. En regel, der ser på værdi, ville få betydning, når der er råd til flere produkter på én gang, for eksempel med et længere tjekinterval.
+
 ## Hvad vi fik ud af dette trin

 - **Små, rene regler er nemme at sammenligne.** Fordi valget af opgradering ikke rører Selenium, er en ny strategi en ny funktion plus en test.
 - **Mål, gæt ikke.** Det resultat, vi forventede (flere tjek, flere cookies), var det modsatte af, hvad kørslerne viste.
 - **En anden rigtig fejl.** Det første hold styrtede ned i én container: spillet omskriver tælleren i hvert billede, og en computer under belastning fik vores ene genforsøg til at fejle. Læsningen forsøger nu fem gange med en kort pause. En test med en falsk driver, der bliver forældet fire gange, viser det.
 - **Retfærdige sammenligninger kræver de samme forhold.** Vi kørte rækkerne samtidig og rapporterer to hold, fordi en enkelt kørsel kan være heldig.
+- **En bedre idé skal stadig måles.** Reglen om bedste værdi er rigtig på papiret og gjorde ingen forskel i kørslerne, fordi botten aldrig har cookies nok til at vælge mellem mere end to produkter.
@@ -36,9 +36,29 @@ Keputusan terbaik ialah selang 10 saat dengan beli satu. Sebabnya:
 - Menyemak lebih kerap tidak lebih baik. Setiap semakan membaca halaman dan mengambil masa daripada mengklik, dan produk termahal yang mampu dibeli biasanya hanya sedikit lebih baik daripada yang lebih murah yang boleh anda beli seketika sebelumnya.
 - Beli semua tidak membuat perbezaan pada awal permainan: hanya Cursor dan Grandma yang mampu dibeli, dan bot membelinya juga. Ia akan penting kemudian, apabila bilangan kuki cukup untuk beberapa produk sekali gus.

+## Peraturan yang lebih bijak: nilai terbaik
+
+`--best-value` tidak melihat harga sahaja. Permainan memberitahu berapa kuki sesaat yang dihasilkan oleh satu unit setiap produk, dan bot membeli produk yang mampu dibeli dengan harga terendah bagi setiap kuki sesaat (`choose_best_value`). Cursor berharga 15 dan menghasilkan 0.1 (150 kuki bagi setiap kuki sesaat), Grandma berharga 100 dan menghasilkan 1 (100 bagi setiap satu), jadi Grandma ialah belian yang lebih baik walaupun lebih mahal.
+
+```bash
+cookie-clicker-bot --best-value
+```
+
+Setiap baris ialah larian penuh 300 saat bersendirian dalam bekas Docker, satu demi satu, semak setiap 5 saat:
+
+| Larian | Strategi | kuki/saat | Dibeli |
+| --- | --- | --- | --- |
+| 1 | termahal yang mampu dibeli | 18 | 30 Cursor, 15 Grandma |
+| 2 | nilai terbaik | 17.9 | 29 Cursor, 15 Grandma |
+| 3 | termahal yang mampu dibeli | 18.8 | 28 Cursor, 16 Grandma |
+| 4 | nilai terbaik | 18.8 | 28 Cursor, 16 Grandma |
+
+Peraturan yang lebih bijak ini **tidak lebih baik**: perbezaan antara kedua-dua peraturan lebih kecil daripada perbezaan antara dua larian peraturan yang sama (18 dan 18.8). Sebabnya sama seperti beli semua. Dalam 5 saat bot mengklik kira-kira 125 kuki, jadi hanya Cursor dan Grandma yang mampu dibeli, dan kedua-dua peraturan membeli hampir perkara yang sama. Peraturan yang melihat nilai akan penting apabila beberapa produk mampu dibeli sekali gus, misalnya dengan selang semakan yang lebih panjang.
+
 ## Apa yang kita peroleh dalam langkah ini

 - **Peraturan kecil yang tulen mudah dibandingkan.** Oleh kerana pemilihan naik taraf tidak menyentuh Selenium, strategi baharu hanyalah fungsi baharu serta satu ujian.
 - **Ukur, jangan meneka.** Keputusan yang kami jangkakan (lebih banyak semakan, lebih banyak kuki) bertentangan dengan apa yang ditunjukkan oleh larian.
 - **Pepijat sebenar kedua.** Kelompok pertama ranap dalam satu bekas: permainan menulis semula pembilang pada setiap bingkai, dan komputer yang terbeban menyebabkan satu percubaan semula kami gagal. Bacaan kini mencuba semula lima kali dengan jeda singkat. Ujian dengan pemacu palsu yang menjadi basi empat kali menunjukkannya.
 - **Perbandingan yang adil memerlukan keadaan yang sama.** Kami menjalankan baris-baris itu serentak dan melaporkan dua kelompok, kerana satu larian boleh bernasib baik.
+- **Idea yang lebih baik masih perlu diukur.** Peraturan nilai terbaik betul di atas kertas dan tidak membuat perbezaan dalam larian, kerana bot tidak pernah mempunyai kuki yang cukup untuk memilih antara lebih daripada dua produk.
@@ -36,9 +36,29 @@ The best result is the 10 second interval with buy one. Why:
 - Checking more often is not better. Every check reads the page and takes time away from clicking, and the most expensive affordable product is usually only a little better than the cheaper one you could have bought a moment before.
 - Buy all makes no difference early in the game: only Cursor and Grandma are affordable, and the bot buys them anyway. It would matter later, when the cookie count holds several products at once.

+## A smarter rule: best value
+
+`--best-value` does not look at the price alone. The game tells how many cookies per second one unit of each product makes, and the bot buys the affordable product with the lowest price per cookie per second (`choose_best_value`). Cursor costs 15 and makes 0.1 (150 cookies for each cookie per second), Grandma costs 100 and makes 1 (100 for each), so Grandma is the better deal even though it costs more.
+
+```bash
+cookie-clicker-bot --best-value
+```
+
+Each row is a full 300 second run alone in a Docker container, one after the other, check every 5 seconds:
+
+| Run | Strategy | cookies/second | Bought |
+| --- | --- | --- | --- |
+| 1 | most expensive affordable | 18 | 30 Cursor, 15 Grandma |
+| 2 | best value | 17.9 | 29 Cursor, 15 Grandma |
+| 3 | most expensive affordable | 18.8 | 28 Cursor, 16 Grandma |
+| 4 | best value | 18.8 | 28 Cursor, 16 Grandma |
+
+The smarter rule is **not better**: the two rules differ by less than the difference between two runs of the same rule (18 and 18.8). The reason is the same as for buy all. In 5 seconds the bot clicks about 125 cookies, so only Cursor and Grandma are ever affordable, and both rules buy nearly the same. A rule that looks at value would matter once several products are affordable at once, for example with a longer check interval or after the first minutes of luck.
+
 ## What we gained in this step

 - **Small, pure rules are easy to compare.** Because the choice of upgrade does not touch Selenium, a new strategy is a new function plus a test.
 - **Measure, do not guess.** The result we expected (more checks, more cookies) was the opposite of what the runs showed.
 - **A second real bug.** The first batch crashed in one container: the game rewrites the counter every frame, and a computer under load made our single retry fail. The read now retries five times with a short pause. A test with a fake driver that goes stale four times shows it.
 - **Fair comparisons need the same conditions.** We ran the rows at the same time and report two batches, because one run can be lucky.
+- **A better idea still has to be measured.** The best value rule is correct on paper and made no difference in the runs, because the bot never has enough cookies to choose between more than two products.
@@ -11,6 +11,7 @@ from cookie_clicker_bot.domain.buy_strategy import BuyStrategy
 from cookie_clicker_bot.domain.upgrades import (
    Upgrade,
    choose_affordable_upgrades,
+    choose_best_value,
    choose_most_expensive_affordable,
 )

@@ -48,16 +49,35 @@ def buy_most_expensive_upgrade(game: GamePort) -> Upgrade | None:
    return None


+def buy_best_value_upgrade(game: GamePort) -> Upgrade | None:
+    """@brief Buy the affordable upgrade with the lowest price per cookie per second.
+
+    @param game The game to play.
+    @return The upgrade that was bought, or None when nothing was affordable or
+        the click did not reach the product.
+    """
+    chosen = choose_best_value(game.upgrades(), game.cookie_count())
+    if chosen is not None and game.buy(chosen):
+        return chosen
+    return None
+
+
 def buy_upgrades(game: GamePort, strategy: BuyStrategy) -> list[Upgrade]:
    """@brief Do one purchase round with the given strategy (lecture step 5).

    @param game The game to play.
    @param strategy BUY_ONE buys the most expensive affordable upgrade, BUY_ALL buys
-        every upgrade the cookies pay for.
+        every upgrade the cookies pay for, BEST_VALUE buys the one with the lowest
+        price per cookie per second.
    @return The upgrades really bought, in order; a click that missed is left out.
    """
-    if strategy is BuyStrategy.BUY_ONE:
-        bought = buy_most_expensive_upgrade(game)
+    if strategy is not BuyStrategy.BUY_ALL:
+        buy_one = (
+            buy_best_value_upgrade
+            if strategy is BuyStrategy.BEST_VALUE
+            else buy_most_expensive_upgrade
+        )
+        bought = buy_one(game)
        return [] if bought is None else [bought]
    plan = choose_affordable_upgrades(game.upgrades(), game.cookie_count())
    return [upgrade for upgrade in plan if game.buy(upgrade)]
@@ -69,7 +69,8 @@ def parse_args(argv: Sequence[str] | None = None) -> argparse.Namespace:
        default=constants.UPGRADE_CHECK_INTERVAL_SECONDS,
        help="seconds between upgrade checks, greater than 0 (default: %(default)s)",
    )
-    parser.add_argument(
+    choice = parser.add_mutually_exclusive_group()
+    choice.add_argument(
        "--buy-all",
        action="store_true",
        help=(
@@ -77,6 +78,14 @@ def parse_args(argv: Sequence[str] | None = None) -> argparse.Namespace:
            "(default: buy only the most expensive affordable one)"
        ),
    )
+    choice.add_argument(
+        "--best-value",
+        action="store_true",
+        help=(
+            "at each check buy the affordable upgrade with the lowest price per "
+            "cookie per second"
+        ),
+    )
    parser.add_argument(
        "--headless",
        action="store_true",
@@ -95,6 +104,19 @@ def parse_args(argv: Sequence[str] | None = None) -> argparse.Namespace:
    return parser.parse_args(argv)


+def choose_strategy(args: argparse.Namespace) -> BuyStrategy:
+    """@brief Turn the purchase options into a strategy.
+
+    @param args The parsed options.
+    @return BUY_ALL, BEST_VALUE or, by default, BUY_ONE.
+    """
+    if args.buy_all:
+        return BuyStrategy.BUY_ALL
+    if args.best_value:
+        return BuyStrategy.BEST_VALUE
+    return BuyStrategy.BUY_ONE
+
+
 def main(
    argv: Sequence[str] | None = None,
    game_factory: Callable[[bool], GamePort] = create_game,
@@ -113,7 +135,7 @@ def main(
        game.dismiss_language()
        if args.screenshot_start is not None:
            game.save_screenshot(args.screenshot_start)
-        strategy = BuyStrategy.BUY_ALL if args.buy_all else BuyStrategy.BUY_ONE
+        strategy = choose_strategy(args)
        logger.info(
            "checking upgrades every %s seconds, strategy %s",
            args.interval,
@@ -90,6 +90,12 @@ WINDOW_SIZE: Final[str] = "1366,900"
 ## Script that clicks an element from inside the page, past anything that covers it.
 JS_CLICK_SCRIPT: Final[str] = "arguments[0].click();"

+## Script that reads the cookies per second of one unit of each product, by index.
+JS_PRODUCTION_SCRIPT: Final[str] = "return Game.ObjectsById.map(o => o.storedCps);"
+
+## Prefix of a product element id; the rest is the index into the script's list.
+PRODUCT_ID_PREFIX: Final[str] = "product"
+
 ## Chromium arguments needed to run headless inside a container.
 HEADLESS_BROWSER_ARGUMENTS: Final[tuple[str, ...]] = (
    "--headless=new",
@@ -12,3 +12,5 @@ class BuyStrategy(Enum):
    BUY_ONE = "buy-one"
    ## Buy every upgrade the cookies pay for, most expensive first.
    BUY_ALL = "buy-all"
+    ## Buy the affordable upgrade with the lowest price per cookie per second.
+    BEST_VALUE = "best-value"
@@ -16,6 +16,8 @@ class Upgrade:
    name: str
    ## Price in cookies.
    price: int
+    ## Cookies per second one unit makes; None when the page did not tell.
+    cookies_per_second: float | None = None


 def choose_affordable_upgrades(
@@ -39,6 +41,33 @@ def choose_affordable_upgrades(
    return plan


+def choose_best_value(upgrades: Sequence[Upgrade], cookies: int) -> Upgrade | None:
+    """@brief Pick the affordable upgrade that pays for itself fastest.
+
+    The value of an upgrade is its price divided by the cookies per second it makes,
+    so the lowest ratio wins. Upgrades with unknown or zero production are skipped;
+    when none of the affordable ones has a known production the rule falls back to
+    the most expensive affordable upgrade.
+
+    @param upgrades The visible upgrades, in store order.
+    @param cookies The cookies the player has.
+    @return The chosen upgrade (the first on a tie), or None when none is affordable.
+    """
+    producing = [
+        upgrade
+        for upgrade in upgrades
+        if upgrade.price <= cookies
+        and upgrade.cookies_per_second is not None
+        and upgrade.cookies_per_second > 0
+    ]
+    if not producing:
+        return choose_most_expensive_affordable(upgrades, cookies)
+    return min(
+        producing,
+        key=lambda upgrade: upgrade.price / (upgrade.cookies_per_second or 1.0),
+    )
+
+
 def choose_most_expensive_affordable(
    upgrades: Sequence[Upgrade], cookies: int
 ) -> Upgrade | None:
@@ -9,6 +9,7 @@ from typing import Any, Protocol, TypeVar

 from selenium.common.exceptions import (
    ElementClickInterceptedException,
+    JavascriptException,
    NoSuchElementException,
    StaleElementReferenceException,
 )
@@ -149,7 +150,19 @@ class SeleniumGame:
        products = self._driver.find_elements(
            By.CSS_SELECTOR, constants.VISIBLE_PRODUCT_SELECTOR
        )
-        return [self._read_upgrade(product) for product in products]
+        production = self._read_production()
+        return [self._read_upgrade(product, production) for product in products]
+
+    def _read_production(self) -> list[float]:
+        """@brief Read the cookies per second of one unit of every product.
+
+        @return The numbers by product index; empty when the page does not tell.
+        """
+        try:
+            production = self._driver.execute_script(constants.JS_PRODUCTION_SCRIPT)
+        except JavascriptException:
+            return []
+        return production if isinstance(production, list) else []

    def _read_again_if_stale(self, read: Callable[[], T]) -> T:
        """@brief Run a read; repeat it while the page re-renders under it.
@@ -195,12 +208,26 @@ class SeleniumGame:
        self._driver.quit()

    @staticmethod
-    def _read_upgrade(product: ElementLike) -> Upgrade:
-        """@brief Read the id, name and price of one product element."""
+    def _read_upgrade(product: ElementLike, production: Sequence[float]) -> Upgrade:
+        """@brief Read the id, name, price and production of one product element."""
        name = product.find_element(By.CSS_SELECTOR, constants.PRODUCT_NAME_SELECTOR)
        price = product.find_element(By.CSS_SELECTOR, constants.PRODUCT_PRICE_SELECTOR)
        key = product.get_attribute(constants.ID_ATTRIBUTE) or ""
-        return Upgrade(key=key, name=name.text.strip(), price=parse_amount(price.text))
+        return Upgrade(
+            key=key,
+            name=name.text.strip(),
+            price=parse_amount(price.text),
+            cookies_per_second=SeleniumGame._production_of(key, production),
+        )
+
+    @staticmethod
+    def _production_of(key: str, production: Sequence[float]) -> float | None:
+        """@brief Look up the production of the product with this element id."""
+        index = key.removeprefix(constants.PRODUCT_ID_PREFIX)
+        if not index.isdigit() or int(index) >= len(production):
+            return None
+        value = production[int(index)]
+        return float(value) if isinstance(value, int | float) else None

    def _visible(self, element_id: str) -> ElementLike | None:
        """@brief Return the element with this id when it exists and is displayed."""
@@ -9,6 +9,7 @@ from typing import Any
 import pytest
 from selenium.common.exceptions import (
    ElementClickInterceptedException,
+    JavascriptException,
    NoSuchElementException,
    StaleElementReferenceException,
 )
@@ -63,8 +64,13 @@ class FakeDriver:
        self.screenshots: list[str] = []
        self.quit_called = False
        self.scripts: list[tuple[str, FakeElement]] = []
+        self.production: Any = []

-    def execute_script(self, script: str, *args: Any) -> None:  # noqa: ANN401
+    def execute_script(self, script: str, *args: Any) -> Any:  # noqa: ANN401
+        if script == constants.JS_PRODUCTION_SCRIPT:
+            if isinstance(self.production, Exception):
+                raise self.production
+            return self.production
        self.scripts.append((script, args[0]))

    def get(self, url: str) -> None:
@@ -427,3 +433,58 @@ def test_close_quits_the_driver() -> None:
    make_game(driver).close()

    assert driver.quit_called
+
+
+def _driver_with_two_products() -> FakeDriver:
+    driver = FakeDriver()
+    driver.groups[constants.VISIBLE_PRODUCT_SELECTOR] = [
+        make_product("product0", "Cursor", "15"),
+        make_product("product1", "Grandma", "100"),
+    ]
+    return driver
+
+
+def test_upgrades_reads_the_production_of_each_product() -> None:
+    driver = _driver_with_two_products()
+    driver.production = [0.1, 1]
+
+    assert make_game(driver).upgrades() == [
+        Upgrade("product0", "Cursor", 15, 0.1),
+        Upgrade("product1", "Grandma", 100, 1.0),
+    ]
+
+
+def test_upgrades_leaves_the_production_unknown_when_the_script_fails() -> None:
+    driver = _driver_with_two_products()
+    driver.production = JavascriptException("Game is not defined")
+
+    upgrades = make_game(driver).upgrades()
+
+    assert [upgrade.cookies_per_second for upgrade in upgrades] == [None, None]
+
+
+def test_upgrades_leaves_the_production_unknown_for_a_product_the_list_lacks() -> None:
+    driver = _driver_with_two_products()
+    driver.production = [0.1]
+
+    upgrades = make_game(driver).upgrades()
+
+    assert [upgrade.cookies_per_second for upgrade in upgrades] == [0.1, None]
+
+
+def test_upgrades_leaves_a_production_that_is_not_a_number_unknown() -> None:
+    driver = _driver_with_two_products()
+    driver.production = [{}, 1]
+
+    upgrades = make_game(driver).upgrades()
+
+    assert [upgrade.cookies_per_second for upgrade in upgrades] == [None, 1.0]
+
+
+def test_upgrades_leaves_the_production_unknown_for_an_unexpected_answer() -> None:
+    driver = _driver_with_two_products()
+    driver.production = None
+
+    upgrades = make_game(driver).upgrades()
+
+    assert [upgrade.cookies_per_second for upgrade in upgrades] == [None, None]
@@ -179,6 +179,31 @@ def test_parse_args_buys_one_upgrade_unless_buy_all_is_given() -> None:
    assert parse_args(["--buy-all"]).buy_all is True


+def test_parse_args_best_value_is_off_by_default() -> None:
+    assert parse_args([]).best_value is False
+    assert parse_args(["--best-value"]).best_value is True
+
+
+def test_parse_args_rejects_buy_all_together_with_best_value(
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    with pytest.raises(SystemExit) as exit_info:
+        parse_args(["--buy-all", "--best-value"])
+
+    assert exit_info.value.code == 2
+    assert "not allowed with" in capsys.readouterr().err
+
+
+def test_main_logs_the_best_value_strategy(
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    caplog.set_level("INFO")
+
+    main(["--duration", "0", "--best-value"], lambda _h: RecordingGame())
+
+    assert "strategy best-value" in caplog.text
+
+
@pytest.mark.parametrize("value", ["0", "-1", "abc", "nan"])
 def test_parse_args_rejects_an_interval_that_is_not_positive(
    value: str, capsys: pytest.CaptureFixture[str]
@@ -6,6 +6,7 @@ from pathlib import Path

 from cookie_clicker_bot.application.game_loop import (
    PlayResult,
+    buy_best_value_upgrade,
    buy_most_expensive_upgrade,
    buy_upgrades,
    click_and_buy,
@@ -14,6 +15,9 @@ from cookie_clicker_bot.application.game_loop import (
 from cookie_clicker_bot.domain.buy_strategy import BuyStrategy
 from cookie_clicker_bot.domain.upgrades import Upgrade

+VALUE_CURSOR = Upgrade("product0", "Cursor", 15, 0.1)
+VALUE_GRANDMA = Upgrade("product1", "Grandma", 100, 1.0)
+
 CURSOR = Upgrade("product0", "Cursor", 15)
 GRANDMA = Upgrade("product1", "Grandma", 100)

@@ -248,3 +252,31 @@ def test_click_and_buy_checks_every_ten_seconds_with_a_ten_second_interval() ->

    assert game.buy_times == [11.0, 21.0]
    assert result.purchases == ("Grandma", "Grandma")
+
+
+def test_buy_best_value_upgrade_buys_the_cheapest_per_cookie_per_second() -> None:
+    game = FakeGame(cookies=500, upgrades=[VALUE_CURSOR, VALUE_GRANDMA])
+
+    bought = buy_best_value_upgrade(game)
+
+    assert bought == VALUE_GRANDMA
+    assert game.bought == [VALUE_GRANDMA]
+
+
+def test_buy_best_value_upgrade_buys_nothing_when_too_poor() -> None:
+    game = FakeGame(cookies=10, upgrades=[VALUE_CURSOR, VALUE_GRANDMA])
+
+    assert buy_best_value_upgrade(game) is None
+    assert game.bought == []
+
+
+def test_buy_best_value_upgrade_leaves_out_a_click_that_missed() -> None:
+    game = FakeGame(cookies=500, upgrades=[VALUE_GRANDMA], buy_succeeds=False)
+
+    assert buy_best_value_upgrade(game) is None
+
+
+def test_buy_upgrades_with_best_value_buys_one_upgrade() -> None:
+    game = FakeGame(cookies=500, upgrades=[VALUE_CURSOR, VALUE_GRANDMA])
+
+    assert buy_upgrades(game, BuyStrategy.BEST_VALUE) == [VALUE_GRANDMA]
@@ -5,6 +5,7 @@
 from cookie_clicker_bot.domain.upgrades import (
    Upgrade,
    choose_affordable_upgrades,
+    choose_best_value,
    choose_most_expensive_affordable,
 )

@@ -68,3 +69,46 @@ def test_plan_does_not_change_the_given_list() -> None:
    choose_affordable_upgrades(upgrades, 1000)

    assert upgrades == [CURSOR, GRANDMA]
+
+
+VALUE_CURSOR = Upgrade("product0", "Cursor", 15, 0.1)
+VALUE_GRANDMA = Upgrade("product1", "Grandma", 100, 1.0)
+VALUE_FARM = Upgrade("product2", "Farm", 1100, 8.0)
+
+
+def test_best_value_picks_the_lowest_price_per_cookie_per_second() -> None:
+    upgrades = [VALUE_CURSOR, VALUE_GRANDMA, VALUE_FARM]
+
+    assert choose_best_value(upgrades, 2000) == VALUE_GRANDMA
+
+
+def test_best_value_ignores_what_the_cookies_cannot_pay() -> None:
+    upgrades = [VALUE_CURSOR, VALUE_GRANDMA, VALUE_FARM]
+
+    assert choose_best_value(upgrades, 50) == VALUE_CURSOR
+
+
+def test_best_value_returns_none_when_nothing_is_affordable() -> None:
+    assert choose_best_value([VALUE_CURSOR, VALUE_GRANDMA], 10) is None
+
+
+def test_best_value_returns_none_without_upgrades() -> None:
+    assert choose_best_value([], 1000) is None
+
+
+def test_best_value_takes_the_first_on_a_tie() -> None:
+    twin = Upgrade("product9", "Twin", 100, 1.0)
+
+    assert choose_best_value([VALUE_GRANDMA, twin], 500) == VALUE_GRANDMA
+
+
+def test_best_value_skips_an_upgrade_with_zero_production() -> None:
+    idle = Upgrade("product9", "Idle", 10, 0.0)
+
+    assert choose_best_value([idle, VALUE_GRANDMA], 500) == VALUE_GRANDMA
+
+
+def test_best_value_falls_back_to_the_most_expensive_when_production_is_unknown() -> (
+    None
+):
+    assert choose_best_value([CURSOR, GRANDMA, FARM], 1200) == FARM
Author	SHA1	Message	Date
Tirsvad	835cb54d00	Move the framework pin to v0.18.0 (TOKEN_FOR_GITEA_* token names)	2026-10-29 00:32:35 +08:00
Tirsvad	e7324ca6d6	Merge pull request 'MIL-008: smarter purchase rule' (#49 ) from mil-008-smarter-rule into main TirSystem/git-workflows: Publish wiki / publish-wiki (push) Successful in 14s Details TirSystem/git-workflows: Sync GitHub mirror metadata / sync-metadata (push) Successful in 7s Details	2026-10-28 16:43:41 +01:00
Tirsvad	086b9f1582	Resolve pending commit links for MIL-008	2026-10-28 23:43:04 +08:00
Tirsvad	2f1c7ff00a	Record the best value comparison in the wiki and review the code of MIL-008 Task: MIL-008#4 Task: MIL-008#5	2026-10-28 23:43:01 +08:00
Tirsvad	ecbe0d2671	Add the best value purchase rule and its command line option Task: MIL-008#1 Task: MIL-008#2 Task: MIL-008#3	2026-10-28 23:19:42 +08:00
Tirsvad	014d9ad3d9	Link the milestone and resolve commits for MIL-008	2026-10-28 23:17:17 +08:00
Tirsvad	9a6796f775	Plan MIL-008: smarter purchase rule	2026-10-28 23:16:46 +08:00
Tirsvad	8865608459	Merge pull request 'MIL-007: release, plan links and final checks' (#43 ) from mil-007-release into main TirSystem/git-workflows: Sync GitHub mirror metadata / sync-metadata (push) Successful in 7s Details	2026-10-28 11:11:02 +01:00