TARIFF-03: static day/night and fully-fixed tariffs, first-class

§9.2 puts a large share of the Belgian installed base on a static profile, and
an EMS that only works under dynamic pricing is an EMS for a minority. A new
`static_profile` option describes a two-period day/night tariff - or a single
fixed price - and app/static_tariff.py turns it into the same canonical
{start, eur_per_kwh, provisional} series the fetched providers emit.

Not a sixth provider plugin, for two mechanical reasons. capabilities() is a
classmethod, so a plugin's PriceProduct is fixed when the class is written -
but §9.2 makes STATIC and FIXED two different products and which one a site is
on is a property of the operator's data; StaticProfile.product derives it from
the number of distinct prices. And the plugin framework exists to stop a
FETCHED figure being marked up twice, which a number typed as all-in cannot be.
So the profile sits where §11.4 already says it does - under the providers, as
the fallback. Configured product and feed-is-down are one generator differing
in one flag, so the degradation path cannot rot unused.

"No arbitrage" is a type. TariffPlan.arbitrage() returns a variant whose
ALLOWED arm carries the spread and the cheapest/dearest hours and whose REFUSED
arm carries a reason and nothing else - .spread_eur_kwh on a refusal raises
rather than answering 0.0, so an optimiser cannot compute a trade from one.
Four refusals, all derived: peak guard holding, no price data, plan
provisional, or the series is FLAT. The last is AC2: a fixed tariff disables
arbitrage by arithmetic, not by matching on an enum. peak_guard_active is a
required keyword argument, so §10.1's priority 2 over 3 cannot be skipped.

Time-window shifting reaches the one shiftable load that exists: main.py's
cheap-window flag falls back to the static profile, and the UI gained a Tariff
row. Cheap is STRICTLY below the seven-day mean - `<=` would call every hour of
a flat tariff cheap, and 48 h taken on a Friday is two-thirds weekend.

A profile must tile every day type exactly once, checked at startup; a gap is
refused with the range named rather than filled in. `22:00-07:00 mon-fri` does
not cover Saturday morning, and that trap is what the check catches.

validate.py rule 7's stated reason expired exactly as TARIFF-02 predicted: the
test_price.py section 12 tripwire went red naming static_tariff.py. The message
now says what is true instead, and the tripwire is re-aimed rather than removed
- consumer set pinned, expired phrase asserted gone. Rule 7 also grew a second
refusal for static_profile alongside the HA price pair, the same silent-loser
conflict and a live one.

CFG-03 is not widened: static_profile went into price.py's PRICE_OPTION_DEFAULTS
- the one in-code mirror pinned to config.yaml by a check - and the new module
carries no defaults dict of its own.

Measured on the two committed days of this house's real P1 meter. 2026-08-20
(Thursday): 15.220 kWh imported, 9.606 day / 5.614 night, EUR 4.7185 under
day/night vs EUR 4.6725 flat, shifting saves EUR 0.8069 = 9.606 kWh x the
0.0840 spread, derived twice. 2026-08-23 (Sunday): 0.728 kWh, all of it
night-priced, which is the weekend row proving itself. §17 names six Belgian
scenarios; this is the seventh, and it is two days rather than a season - the
file says so rather than implying an annual figure.

All 12 suites green. Eleven mutations of static_tariff.py were each caught by
at least one check.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_015VXjA3LWccN1rJsk3okyPC

.gitattributes

@@ -8,3 +8,11 @@
 * text=auto eol=lf
 *.png binary
 *.gz  binary
+
+# `.gitea/workflows/*.yml` steps embed shell heredocs; a `\r` on the terminator
+# line means the heredoc never closes and the job fails on a syntax error that is
+# invisible in the diff. A Windows checkout with core.autocrlf=true would
+# reintroduce it on the next edit. CI-01.
+*.yml  text eol=lf
+*.yaml text eol=lf
+Dockerfile text eol=lf

.gitea/ci/Dockerfile

@@ -0,0 +1,22 @@
+# The image the add-on's tests run in (CI-01). This repo had NO CI at all before
+# that ticket - eight runnable test files, none of them ever run by a machine.
+#
+# ⚠️ THE DEPENDENCIES ARE THE SHIPPED ONES, FROM APK, AND THAT IS THE POINT.
+# goodwe_controller/Dockerfile installs `py3-aiohttp py3-paho-mqtt` from Alpine
+# packages rather than pip, because Alpine ships musl and there are no musl
+# wheels for aiohttp - pip would compile it from source on a client's Raspberry
+# Pi. Testing against pip-installed glibc wheels would be testing a different
+# add-on from the one that ships. Same base, same package manager, same names.
+#
+# ⚠️ NOT `FROM ghcr.io/home-assistant/...-base`. The real Dockerfile takes its
+# base from the Supervisor's `BUILD_FROM` build-arg, which is per-architecture
+# and not resolvable outside a Supervisor build. `alpine:3` is what those images
+# are, minus the s6 supervision the tests do not use - and it is already cached
+# on this runner's host, so the gate does not depend on a registry pull.
+#
+# ⚠️ The runner container itself CANNOT run these tests: it is Alpine with a bare
+# python3, no aiohttp, no pip (`No module named pip`; checked on the box, not
+# assumed). An image is not gold-plating here, it is the only option that does
+# not mutate a shared long-lived runner.
+FROM alpine:3
+RUN apk add --no-cache python3 py3-aiohttp py3-paho-mqtt

.gitea/workflows/checks.yml

@@ -0,0 +1,136 @@
+# CI-01: this repository's FIRST automated check. Before this file, admin/goodwe-addon
+# had no `.gitea/workflows/` directory at all - eight runnable test files, ~100 s
+# of real coverage including a wall-clock cadence test, and not one machine ever
+# ran them. Every merge here was a human reading a diff.
+#
+# ⚠️ NO `paths:` FILTER, AND ITS ABSENCE IS LOAD-BEARING. Branch protection on
+# release/1.0 requires the context `checks / unit (pull_request)`. Gitea leaves a
+# required context it never receives PENDING forever, so the moment this workflow
+# learns to sit a PR out, that PR becomes unmergeable. Condition a STEP if you
+# must; never the workflow.
+#
+# ⚠️ THE RUNNER IS SHARED WITH THE OTHER REPO'S RIG. `goodwe-runner` on
+# 192.168.2.147 carries the labels `self-hosted` and `goodwe-rig` and is
+# registered `:host`, and it is the only runner there is - so this job wears the
+# rig label without wanting a rig. Nothing below starts, stops, or reads the
+# `goodwe-sim` compose project or takes `sim/riglock.py`; it runs one short
+# container and exits. It does occupy the runner's single slot (`capacity: 1`),
+# so it QUEUES behind a rig campaign - a delayed verdict, never a destroyed one.
+#
+# NO JS ACTIONS: the runner image has no node, so `actions/checkout` cannot run.
+# Checkout is seven lines of git below.
+name: checks
+
+on:
+  pull_request:
+    branches: [release/1.0, master]
+  workflow_dispatch:
+
+concurrency:
+  # ⚠️ PER PULL REQUEST, NOT A BARE NAME. A shared group holds one running and
+  # one pending run, so a bare name lets a second PR supersede a first PR's run
+  # before any runner has picked it up - which is exactly what happened to the
+  # other repo's run 521 (four jobs, `started_at` at the Unix epoch,
+  # `runner_id: 0`, concluded `cancelled`, and the PR merged anyway). Do not
+  # replace this with a constant.
+  group: addon-checks-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  unit:
+    runs-on: [self-hosted, goodwe-rig]
+    timeout-minutes: 70   # ~4 to run; the rest is queueing for the single slot
+    env:
+      # ⚠️ UNDER /home/homelab, NOT $GITHUB_WORKSPACE (ENV-01, and re-measured
+      # during CI-01). act's workspace is `/root/.cache/act/<id>/hostexecutor`, a
+      # path that exists only INSIDE the runner container. Hand it to the host's
+      # snap-confined dockerd and the build fails with "failed to read
+      # dockerfile", or - worse, and this is the documented case - a bind mount
+      # resolves to an EMPTY DIRECTORY with no error at all. /home/homelab is
+      # mirrored 1:1 into the runner and is under $HOME, where snap confinement
+      # accepts it. The same probe under /tmp failed and under $HOME succeeded.
+      WS: /home/homelab/ci/addon-checks-${{ github.run_number }}
+    steps:
+      # ⚠️ THE CHECKOUT IS TWO LEVELS BELOW THE MOUNT ROOT, DELIBERATELY.
+      # test_freeze.py's find_hwsim() reads `HERE.parents[1] / "goodwe" / "sim"`,
+      # looking for the infra repo as a SIBLING of this one. Check out flat -
+      # goodwe_controller directly at the mount root - and `parents[1]` does not
+      # exist, so the test dies on `IndexError: 1` before its first assertion.
+      # Measured during CI-01; the flat layout was tried first and did exactly
+      # that. $WS/goodwe-addon/goodwe_controller gives parents[1] == $WS.
+      - name: checkout into a path the host shares (git; no node for actions/checkout)
+        env:
+          URL: ${{ github.server_url }}/${{ github.repository }}.git
+          TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          set -eu
+          rm -rf "$WS" && mkdir -p "$WS/goodwe-addon" && cd "$WS/goodwe-addon"
+          git init -q .
+          git remote add origin "$(echo "$URL" | sed "s#://#://x-access-token:${TOKEN}@#")"
+          git fetch -q --depth 1 origin "$GITHUB_REF" || git fetch -q --depth 1 origin "$GITHUB_SHA"
+          git checkout -qf FETCH_HEAD
+          echo "checked out $(git log --oneline -1)"
+
+      - name: build the test image (shipped deps, from apk - see .gitea/ci/Dockerfile)
+        run: |
+          set -eu
+          docker build -q -t goodwe-addon-checks:1 "$WS/goodwe-addon/.gitea/ci" >/dev/null
+          docker run --rm goodwe-addon-checks:1 python3 -c \
+            'import aiohttp, paho.mqtt.client as m, sys; print("python", sys.version.split()[0], "aiohttp", aiohttp.__version__)'
+
+      # ⚠️ THE FILE LIST IS DERIVED FROM THE TREE, NOT TYPED HERE. A hand-written
+      # list is how a new test file joins the repo and is never run - the exact
+      # shape of failure this ticket exists to close. The step globs `test_*.py`,
+      # prints the count, and REFUSES A COUNT OF ZERO: a loop over an empty glob
+      # exits 0 and would report a green gate that examined nothing.
+      #
+      # ⚠️ test_loop.py TAKES ~93 SECONDS OF WALL CLOCK ON PURPOSE (its own
+      # docstring says so, and says why: it drives the real `run_control()`
+      # against a real wall-clock floor, and mocking the clock would leave the
+      # assertion testing the mock). It is not hung. Do not "fix" it with a
+      # shorter timeout - a 60 s limit was tried during CI-01 and reported
+      # exactly the false hang the docstring predicts.
+      #
+      # ⚠️ WHAT THIS RUN DOES NOT COVER, stated because a pass here would
+      # otherwise over-claim. test_freeze.py's third section wants the infra
+      # repo's `sim/hwsim.py` to drive a real HTTP meter through the real
+      # transport. admin/goodwe is PRIVATE (checked via the API) and this
+      # workflow's GITHUB_TOKEN is minted for THIS repository only, so hwsim is
+      # absent here and `find_hwsim()` returns None. The rest of the file runs
+      # and passes. It does so SILENTLY - the file prints nothing to say the
+      # hwsim section was skipped - so "test_freeze.py: PASS" below is a weaker
+      # claim than it looks. That belongs to whoever owns test_freeze.py next;
+      # naming it here is the least this gate can do about it.
+      - name: the add-on's own tests
+        run: |
+          set -eu
+          docker run --rm -v "$WS:/w:ro" goodwe-addon-checks:1 sh -eu -c '
+            cd /w/goodwe-addon/goodwe_controller
+            set -- test_*.py
+            if [ "$1" = "test_*.py" ]; then
+              echo "NO test_*.py FOUND - the mount is empty or the layout moved. NOTHING has been checked."
+              exit 1
+            fi
+            echo "$# test file(s) to run"
+            rc=0
+            for f in "$@"; do
+              start=$(date +%s)
+              if python3 "$f" > /tmp/out 2>&1; then
+                echo "PASS  $f  ($(( $(date +%s) - start ))s)"
+              else
+                echo "FAIL  $f  ($(( $(date +%s) - start ))s)"
+                tail -40 /tmp/out
+                rc=1
+              fi
+            done
+            exit $rc
+          '
+
+      - name: clean up
+        if: always()
+        run: |
+          rm -rf "$WS" || true
+          # Root-owned by this runner inside a directory the `homelab` user owns,
+          # and sudo on that box is interactive-only, so the user cannot clean
+          # this up and the job that made it has to.
+          ls -1dt /home/homelab/ci/addon-checks-*/ 2>/dev/null | tail -n +6 | xargs -r rm -rf || true

goodwe_controller/CHANGELOG.md

@@ -2,6 +2,327 @@
 
 ## Unreleased
 
+**Static day/night and fully-fixed tariffs, first-class (TARIFF-03).**
+§9.2 puts a large share of the Belgian installed base on a static profile, and
+an EMS that only works under dynamic pricing is an EMS for a minority. A new
+`static_profile` option describes a two-period day/night tariff — or a single
+fixed price — as JSON, and `app/static_tariff.py` turns it into the same
+canonical `{start, eur_per_kwh, provisional}` series the fetched providers emit,
+so nothing downstream learns that a tariff can be static.
+
+**It is not a sixth provider plugin, and the reason is mechanical.**
+`PriceProvider.capabilities()` is a classmethod, so a plugin's `PriceProduct` is
+fixed when the class is written — but §9.2 makes STATIC and FIXED two different
+products with two different required behaviours, and which one a site is on is a
+property of the operator's data, not of any class. `StaticProfile.product`
+derives it from the number of distinct prices instead. The second reason: the
+plugin framework exists to stop a *fetched* figure being marked up twice, and a
+number the operator typed as all-in has no publisher to disagree with.
+
+**So the profile sits where §11.4 already says it does — under the providers, as
+the fallback.** The configured-product path and the feed-is-down path are the
+same generator differing in one flag: `provisional`. A static-tariff site runs
+that path every day, so the degradation path for a dynamic site cannot rot
+unused.
+
+**"No arbitrage" is a type, not a boolean somebody has to remember to check.**
+`TariffPlan.arbitrage()` returns a variant: the *allowed* arm carries the
+spread and the cheapest and dearest hours, and the *refused* arm carries a
+reason and nothing else — `.spread_eur_kwh` on a refusal raises rather than
+answering 0.0. An optimiser cannot compute a trade from a refusal because it
+cannot get the inputs out of one. Four refusals, all derived: the peak guard is
+holding, there is no price data, the plan is provisional, or **the series is
+flat**. That last one is AC2 — a fully-fixed tariff disables arbitrage by
+arithmetic rather than by matching on an enum, and a dynamic feed that happens
+to print one price all day is refused for the same true reason.
+
+**Peak shaving outranks arbitrage, expressed so OPT-04 cannot skip it.**
+`arbitrage()` takes `peak_guard_active` as a required keyword argument, so the
+spread is not obtainable without first answering whether §10.1's priority 2 is
+holding. §9.1's capacity tariff is a network cost charged whatever the energy
+product is.
+
+**Time-window shifting reaches the one shiftable load that exists.** main.py's
+cheap-window flag — previously fed only by the `price_now_entity` /
+`price_avg_entity` pair — now falls back to the static profile, and the Web UI
+gained a **Tariff** row naming the window, the price, when it next changes and
+why it is or is not cheap. The rule is *strictly* below the seven-day mean:
+under a flat tariff `<=` would call every hour cheap and a fixed-tariff site
+would top up from the grid at any hour, which is the opposite of
+self-consumption only. Seven days rather than 48 hours because a 48 h mean taken
+on a Friday is two-thirds weekend, and the same Tuesday 09:00 would come out
+cheap or dear depending on when you asked.
+
+**A profile must tile every day type exactly once, checked at startup.** A gap
+is refused with the uncovered range named rather than filled in — an invented
+price is one an optimiser would trade on — and an overlap is refused because
+otherwise one of two prices wins silently on list order. The trap this catches
+in practice: `22:00–07:00 mon-fri` does **not** cover Saturday morning, because
+a window applies on the day the clock reads.
+
+**validate.py rule 7's stated reason expired, exactly as TARIFF-02 predicted.**
+That ticket left a tripwire in `test_price.py` section 12 asserting that nothing
+in `app/` consumed `load_prices()`, with instructions to fix the refusal's
+wording in the same commit when it went red. It went red naming
+`static_tariff.py`. The message now says what is true instead — the series *is*
+consumed, but main.py acts on the static side of it and not on a fetched one —
+and the tripwire is re-aimed rather than removed: the consumer set is pinned, so
+a second consumer (OPT-04) goes red again, and the expired phrase is asserted
+gone so a bad merge cannot restore it. Rule 7 also grew a second refusal:
+`static_profile` alongside the Home Assistant price pair is the same
+silent-loser conflict, and a live one.
+
+**No new place for an option default (CFG-03 is not widened).**
+`static_profile` was added to `app/price.py`'s `PRICE_OPTION_DEFAULTS` — the one
+in-code mirror TARIFF-02 created and pinned to `config.yaml` by a check — rather
+than to a defaults dict in the new module, which has none. main.py grew no
+`o.get("static_profile", …)` fallback. That is TARIFF-02's pattern, stated
+here so a reviewer does not have to infer it.
+
+**Measured, on the data that exists.** `test_static_tariff.py` replays the two
+committed days of this house's real P1 meter (`scenarios/p1-net-2026-08-{20,23}`)
+priced under a Belgian day/night profile. 2026-08-20 is a Thursday: 15.220 kWh
+imported, 9.606 in the day window and 5.614 in the night one, EUR 4.7185 under
+day/night against EUR 4.6725 flat, and shifting the day-window energy into the
+night window saves EUR 0.8069 — which is 9.606 kWh x the 0.0840 spread, derived
+twice and required to agree. 2026-08-23 is a Sunday: 0.728 kWh, **all** of it
+night-priced, which is the weekend row proving itself on real data. §17 names
+six Belgian scenarios and a static-profile case is not among them; this is the
+seventh, and it is two captured days rather than a season — the file says so
+rather than implying an annual figure.
+
+Also worth knowing before OPT-04: on realistic Belgian day/night numbers the
+whole-tariff spread is about 0.08 EUR/kWh, **below** the shipped
+`cycle_cost_threshold_eur` of 0.10. A correct optimiser will decline to cycle
+for the tariff alone on such a site. That is a product finding, not a defect.
+
+**Price provider plugins, and one canonical all-in price format (TARIFF-02).**
+`app/price.py` ships five providers - `generic_dayahead` (wholesale EPEX BE),
+`engie_dynamic`, `totalenergies_dynamic`, `eneco_eddy` and the offline
+`manual_csv` - all emitting exactly `{"prices": [{"start", "eur_per_kwh",
+"provisional"}]}`, tz-aware at the Brussels offset, EUR/kWh, all-in. **Nothing
+consumes it yet**: this is the seam, landed first, so that the arbitrage work
+that follows never learns a supplier's name.
+
+**Double-counting the markup is refused rather than discouraged, given a
+correct declaration.** A plugin does not return a price; it returns the figure
+its source published and declares which of {energy, markup, taxes} that figure
+contains. The framework adds the complement, once. Engie and TotalEnergies
+publish a retail figure with their margin already inside; adding the configured
+3 c/kWh on top would make every future arbitrage decision wrong by that amount
+with nothing reporting it.
+
+Two mechanisms, because one was not enough. `PluginOptions` raises on the
+framework-owned keys - and review of PR #16 then wrote a double-counting plugin
+three more ways, one of them touching nothing but `PRICE_OPTION_DEFAULTS`, a
+public dict in the module every plugin already imports. So `register()` now also
+**refuses at import any plugin whose own code mentions a framework key**
+(`code_leaks()`, docstrings stripped via `ast` so a plugin's mandated
+`SOURCES:` line does not false-positive). Honest wholesale baseline 0.188
+EUR/kWh; every attack landed 0.219.
+
+**The guarantee's precise shape**, stated because an overclaim is worse than no
+claim: the framework adds the complement exactly once *given a correct `sources`
+declaration*. A plugin that declares `{energy}` while its feed is really all-in
+still comes out one markup high while touching no framework name, and no code
+can catch that - the declaration is the plugin's unverifiable claim about
+somebody else's tariff. What is mechanised is reachability; what stays human is
+truthfulness.
+
+**The product type is declared, not inferred from the plugin's name.**
+`eneco_eddy` is a real-time/imbalance product and gets widened arbitrage
+thresholds; that reaches a consumer through `capabilities().product` and
+`volatility_regime()`, never through a name comparison. `test_price.py` asserts
+mechanically that no plugin id appears anywhere in the framework's own code,
+and drives a sixth provider defined inside the test file to the correct regime
+with `price.py` untouched.
+
+**"No price data" is a type, not an empty list.** Following the same rework
+`sim/riglock.py` took, a fetch returns `PriceRead.series(...)` or
+`PriceRead.no_data(reason)`, and only the first carries fields. An empty series
+is not constructible; `no_data` has no `.points` to iterate, no `.at()`, and
+`.get("points", [])` raises rather than returning the default. **A day of free
+electricity and a day with no prices are different instructions** - arbitrage is
+pointless under the first and forbidden under the second - and an implementation
+that returns `[]` on a failed fetch cannot tell them apart. Every site-level
+failure returns `no_data`; nothing raises into the control tick.
+
+**What is not verified, and cannot be by an offline suite:** every fixture is
+synthetic, so the five feed URLs and JSON shapes are checked against a belief
+about what those suppliers publish, not against the feeds. The parse layer is
+exercised; the contract with each supplier is not. Expect the first live fetch
+of each to need a shape fix, and note that a wrong shape degrades to
+no-price-data rather than to a wrong price.
+
+**`manual_csv` is the documented offline fallback** and needs no network, no
+supplier account and no HTTP stack. See DOCS.md for the format. Its `start`
+column must carry a UTC offset - a bare local timestamp is refused, because one
+hour every October names two moments.
+
+**Injection is priced separately** (`export_price_eur_kwh`), a scalar rather
+than a second series, and negative values are accepted. Consumption plugins
+cannot reach it.
+
+**`price_provider` may not be combined with `price_now_entity` /
+`price_avg_entity`** - the add-on refuses to start on that pair. The Home
+Assistant sensors are the existing delegation of pricing to HA and still work
+alone; with both configured they would silently keep deciding while the status
+page named a supplier that decided nothing.
+
+**No timezone database is used.** The shipped Alpine image has no `tzdata`, so
+Brussels offsets are computed from the EU rule and every instant is carried as
+UTC and rendered at the offset that applies to it. The checks drive both 2026
+transitions - the 23-hour and 25-hour days - rather than a normal day, where a
+fixed 24-slot implementation and a correct one agree.
+
+**The capacity-tariff peak is now measured, banked and survives a restart
+(TARIFF-01).** New `app/tariff.py`. The 15-minute block average itself was
+already built and unwired - `p1.QuarterAverager` computes clock-aligned 900 s
+blocks, time-weighted over irregular telegram spacing, offtake-only and
+per-phase - and `P1Ingest.blocks` was a 96-entry list a restart erased. This
+adds the SQLite behind it (`/data/tariff.db`): one row per completed quarter in
+the indefinite 15-min tier, one row per calendar month in the permanent peak
+tier, and no `DELETE` against either anywhere in the module.
+
+**Blocks, not a sliding window.** The card says "rolling"; 9.1 bills "the
+highest 15-minute average offtake", stated per QUARTER. "Rolling" here means
+continuously updated, not a trailing-15-minutes window - a trailing window
+reports a peak the meter never bills, and reports it HIGH, because a burst
+straddling :15 fills it completely while contributing to two block averages at
+partial weight.
+
+**A restart mid-block resumes it, and a restart that outlives the block banks
+it.** `QuarterAverager` grew `snapshot()`/`restore()`; the tracker checkpoints
+the open block every 15 s (worst case 1.7 % of one quarter) and clears the
+checkpoint in the same breath as a block close. The held sample keeps its
+ORIGINAL timestamp across the restart, so the outage is integrated under the
+same `max_hold_s` rule a running process would apply and uncovered seconds drag
+the closed block DOWN rather than being held forward. `quarter_start` is the
+primary key and a re-bank may only ever RAISE a figure, so a replay cannot
+double-count and a partial re-run cannot lower a quarter already measured.
+
+**An unreadable store is not a zero peak.** `peak()` answers `OBSERVED` /
+`NO_RECORD` / `NOT_OBSERVED` and carries `peak_w = None` unless observed - the
+`riglock.holder()` fix applied to something that spends money. A peak read as
+0 W hands SAFETY-07 maximum headroom and silently disarms the guard at the
+moment its own storage breaks, so there is no accessor that defaults it: a
+caller who forgets gets a `TypeError`, and the status page prints a different
+row for "no quarter yet" than for "the database did not answer".
+
+**Calendar months are LOCAL, blocks are UTC.** A quarter starting 22:15 UTC on
+31 August bills in September. Block alignment still needs no timezone.
+
+**No new option, and no second peak entity.** The soft limit is the existing
+`peak_cap_w`; `config.yaml` and `validate.py` are untouched, so CFG-03 is not
+widened. `peak_forecast_entity` stays the input to `maintenance_charge_floor()`
+- repointing that consumer changes what moves energy and belongs to SAFETY-07.
+
+**It measures and nothing else.** No claim, no clamp, no command; graded on the
+parsed syntax in `test_tariff.py`, which also proves the same grader lights up
+on `main.py`. Per SAFETY-20, the quantity is DELIVERED power - `tariff.py` only
+ever sees `P1Sample`, the meter's own reading, never a setpoint.
+
+**AC 3 is not met and the check says so.** It asks for 30 days of replay; two
+days of this house's real meter exist (2026-08-20, 2026-08-23), now committed as
+`scenarios/p1-net-*.jsonl.gz`. `test_tariff.py` part 9 replays them, reports
+the percentage under the shipped limit next to the sample size in days, and
+asserts nothing about the 95 % figure.
+
+**A computed setpoint over the rating now alarms instead of being clipped in
+silence (SAFETY-03).** The clamp was never the missing half - specs.md 10.3
+records an unclamped integrator climbing ~130 W per 4 s past 10 kW and reporting
+**14 768 W** while pinned at the 5 kW rail, and a silent clamp turns exactly that
+into a flat, legal-looking 5000 W hold. `write_setpoint()` - the one path every
+write takes, cycle, heartbeat, operator button and shutdown alike - now clamps to
+the **validated** `max_w` and reports whether the raw value differed, and
+`Controller.check_output_clamp()` raises `OUTPUT_CLAMP`: a persistent
+notification (`goodwe_output_clamp`), an `ERROR`, an event row and a red status
+banner. **Not a trip**: the clamped value is written and the loop keeps running,
+per 11.2's "clamp *and alarm*".
+
+**The bound is `max_w` and nothing is `min()`ed at runtime.** Section 14 requires
+the loop clamp and the driver's `setpoint_limit_w` to agree, validated at startup
+with a refusal on mismatch - which CFG-01 already ships. The device range is
+still applied second, as defence in depth; after a successful validation it
+cannot engage, so if it ever does, that is louder than the first stage and it
+alarms too, naming the bound. No new config key: the guard's limit is the one
+the operator already set, and its cadence is a module constant.
+
+**`Decision` grew `i_clamped` / `clamped` booleans, and that is the load-bearing
+part.** `reason` is one string that later stages overwrite - a cycle that clamps
+the integrator and is then slew limited reports `slew-limited`, and one that
+clamps while saturated reports `saturated-freeze`. Both *are* the winding case,
+so an alarm keyed on the string is silent on exactly the cycles it exists for:
+mutating main.py back onto `"clamp" in decision.reason` drops the 10.3 replay
+from 2 engagements to **0**. The flags are set where the clamp happens and are
+never overwritten. On a default install (`integrator_max_w` following `max_w`)
+the integrator bound is the one that bites and the output clamp is unreachable,
+so the integrator flag is the whole signal.
+
+**Distinct from the saturation freeze, and checked in the negative.** A clamp is
+a *software* bug signal; saturation is the *hardware* failing to follow a legal
+command, and its action is to freeze the integrator, not to alarm. They share no
+reason code, notification id, status row or counter. `test_clamp.py` drives a
+loop that saturates for 10 consecutive cycles at 1.4 % of the rating and asserts
+zero clamp notifications, zero engagements, no log row and no status row - after
+first asserting that the saturation freeze *really did* engage, so the silence is
+an observation rather than a scenario that did nothing.
+
+**The action log is coalesced per episode, and that was a real bug.**
+`log_event()` keeps 40 rows; one row per engagement flushed the entire ring
+within 40 cycles of a winding loop, and the first thing it evicted was
+SAFETY-18's own `METER FROZEN?` row - this guard silencing another guard's log.
+Caught by `test_freeze.py` going red, not by inspection. One row per episode now,
+carrying the exact engagement count read off the counter.
+
+**A non-finite setpoint is refused, and it was worse than passing one through.**
+`nan` is loss of input (11.1 rule 1: command zero, keep commanding), not an
+out-of-range value. Measured: because every comparison against `nan` is False, a
+naive `max(-limit, min(limit, nan))` keeps its *first* argument and turns a `nan`
+into a command **at the full rating**, then reports it as a clamp engagement.
+
+**Review fixes (PR #12).** Three, and the first was a behavioural regression
+this PR introduced: `clamp_to_rating()` **returned early** from the `max_w`
+stage, so the device bound - the "applied second, defence in depth" half - was
+reached only when the rating bound had NOT fired. The bigger the overshoot, the
+less the guard did. At `max_w` 5000 against a +-4000 device, +9999 emitted
+**+5000 W, outside the device range**, while a mere +4500 was correctly held to
++4000. That undid the pre-PR guarantee "never send a value the device will
+reject outright" and undercut this module's own case for clamping to `max_w`
+rather than a runtime `min()`, which rests entirely on that stage catching a
+validation that did not run. Both stages now always run, the result names both
+bounds when both bite (`max_w+device`), and the property is asserted over a
+492-point sweep rather than on witness values - the defect was invisible to any
+single-value check that happened to sit inside one stage. No reachable
+production path was found for it (two validation gates and the arbiter bound sit
+in front), but latent is not harmless.
+
+Two harness defects, both of the kind where a check cannot fail for the value it
+forbids: the hysteresis check issued `range(CLEAR_CYCLES - 1)` clean cycles,
+which at `CLEAR_CYCLES = 1` issues **zero** and passes while printing
+"0 clean cycles do NOT clear it" - green for the chatter setting the constant
+exists to prevent. And the re-assert check stimulated at `REASSERT_S + 9`, green
+for **any** value including 3600, i.e. the hour of silence the module promises
+not to produce. Both are now written in wall-clock terms that do not move when
+the constant does: **one** clean cycle must not clear the alarm, and a loop
+pinned across the 900 s capacity-tariff quarter must speak at least 5 times and
+on no more than 20 % of cycles. `CLEAR_CYCLES = 1`, `REASSERT_S = 3600` and
+`REASSERT_S = 0` each go red.
+
+**`test_clamp.py`** (new, assert-based, no framework) covers the clamp
+arithmetic and its boundaries - exactly +-`max_w` is *not* an engagement - the
+alarm's edge/re-assert/hysteresis cadence, the 10.3 runaway replayed through the
+real `Controller.cycle()` against an unclamped transcription, the saturation
+negative, and the direct-write path. Six author mutations reproduced red,
+including "clamp kept, alarm deleted" (the historical build) and "alarm keyed on
+`reason`". Two of the check's own hypotheses about how the freeze and the clamp
+interact were **refused by the sweep** and rewritten to what it measured: a
+frozen cycle *can* clamp, and does so exactly when the integrator reverses.
+
+`test_freeze.py`'s notification assertions now filter by `notification_id`
+rather than by service - the add-on raises more than one kind of notification,
+and its railing scenarios legitimately raise this one too.
+
 **Cheap-window maintenance charging was unreachable at the shipped defaults, and
 now the config that makes it unreachable is refused (MAINT-04).** `config.yaml`
 shipped `max_w: 2000` against `maintenance_charge_w: 2500`. The cheap-window

goodwe_controller/DOCS.md

@@ -474,6 +474,61 @@ today is operational: set `max_w` no higher than the loop actually needs (the
 tuning was measured at 2000 W and a 1.78 kW load step is tracked fine there), fit
 the e-stop, and watch for the alarm.
 
+### The winding-loop alarm (the output clamp)
+
+Every setpoint this add-on writes is clamped to `max_w` before it leaves the
+process, and **when that clamp actually engages, it alarms.** The clamp on its
+own is not the feature - this project already clipped, and the clipping is what
+hid the defect the guard exists for: with the inverter switched off entirely an
+unclamped integrator climbed ~130 W per 4 s past 10 kW and, pinned at the 5 kW
+rail, reported **14 768 W**. Clipped silently, that is a flat, legal-looking
+5000 W hold on every dashboard, and nothing anywhere says the loop asked for
+three times it.
+
+**What "the rating" is.** The bound is `max_w`, and only `max_w`. It is already
+validated against the setpoint device's own range at startup - the add-on
+*refuses to start* if `max_w` exceeds what the device accepts (and again once
+ESPHome is up and the real rating is known), so by the time the loop runs the two
+numbers agree. The device range is applied a second time inside the write as
+defence in depth; after a successful validation it cannot bite, and if it ever
+does, that engagement alarms too and names the bound.
+
+**Clamping is not saturation, and the two never share a channel.**
+
+| | what it means | what happens |
+|---|---|---|
+| **clamp** | the *computed* value exceeded the rating | a software bug signal - something upstream is winding. **Alarm.** |
+| **saturation** | the inverter is not following a perfectly *legal* command | a hardware condition - freeze the integrator. **No alarm.** |
+
+A loop can be legally saturated all day: a cold pack, a curtailed inverter, an
+export limit. Routing the clamp through a saturation-shaped alarm puts the bug
+signal inside the noise, which is the same silence as clipping quietly. They
+share no reason code, no notification id, no status row and no counter.
+
+**It is an alarm, not a trip.** The clamped value is written and the loop keeps
+running - this is not the sign-disagreement failsafe, which commands 0 W. You
+get a persistent notification (`goodwe_output_clamp`, replaced rather than
+stacked), an `ERROR` in the log with the reason code `OUTPUT_CLAMP`, a row in
+the event list, and a red status banner while it is engaged. Once it clears, a
+warning row keeps the engagement count so the evidence does not vanish with the
+condition. Consecutive engagements share one event row carrying the exact count,
+because the event list keeps only 40 rows and a row per cycle would flush every
+other guard's entries out of it.
+
+**There is nothing to configure**, deliberately. The bound is `max_w`, which you
+already set; giving the guard a limit of its own would be a second number that
+can disagree with the first, which is exactly the failure the startup validation
+exists to prevent. The alarm's cadence - first engagement, then re-asserted every
+30 s while it persists, cleared after 3 clean cycles - is fixed for the same
+reason `RAIL_FRAC` is: it describes the notification bus, not the plant.
+
+WARNING: **on a default install the engagement you will see is the integrator's,
+not the output's.** The control law bounds the integrator to `max_w` and *then*
+derives the command from it, so the command itself can never come out over the
+rating unless `integrator_max_w` has been deliberately raised above `max_w`.
+Both are watched. A guard that watched only the emitted value would be silent on
+every standard configuration.
+
 ### The frozen-meter alarm
 
 A meter that has died is easy — it stops answering, the sample age climbs past
@@ -526,6 +581,168 @@ unchanged is 12 W, which is inside the 15 W deadband — so the command there is
 parked at 0 W and the two halves of the rule cannot both be true. At the schema
 floor of 60 s that figure is 60 W and only the margin is left.
 
+### Energy price providers
+
+> **No *fetched* price moves energy in 0.5.x.** This release ships the
+> *plumbing*: the five provider plugins, the canonical all-in format they emit,
+> and the config that selects one. Turning a provider on fetches, validates and
+> publishes prices and changes no charging decision; the arbitrage strategy that
+> would use it is a later ticket.
+>
+> The one exception is `static_profile` below. A static day/night tariff needs
+> no network, so its cheap window is computed on every cycle and does reach the
+> maintenance cycle's grid top-up.
+
+| option | meaning |
+|---|---|
+| `price_provider` | `off` (default) or one of the five plugins below |
+| `price_markup_eur_kwh` | Your supplier's margin, EUR/kWh. **Added only when the chosen plugin's feed does not already contain it** |
+| `price_taxes_eur_kwh` | Levies and VAT, EUR/kWh. Same rule |
+| `export_price_eur_kwh` | The **injection** price. A separate scalar, not a series — see below |
+| `price_csv_path` | Where `manual_csv` reads its file |
+| `price_feed_url` | Override the plugin's default feed. Only a host the plugin itself declares is accepted |
+| `price_horizon_h` | How far ahead to ask for, hours |
+| `price_timeout_s` | Per-request timeout |
+| `static_profile` | A static day/night or fully-fixed tariff. Empty by default — see below |
+
+**Which plugin sources what.** This is the one thing to get right, because
+adding your markup to a price that already contains it makes every future
+arbitrage decision wrong by that amount, in a direction nothing reports.
+
+| plugin | product | the published figure contains | the add-on adds |
+|---|---|---|---|
+| `generic_dayahead` | day-ahead | energy only (wholesale EPEX BE) | markup **and** taxes |
+| `engie_dynamic` | day-ahead | energy + Engie's markup | taxes |
+| `totalenergies_dynamic` | day-ahead | energy + TotalEnergies' markup | taxes |
+| `eneco_eddy` | **real-time / imbalance** | everything, all-in | nothing |
+| `manual_csv` | day-ahead | everything, all-in | nothing |
+
+You cannot get this wrong by editing the markup: each plugin *declares* what its
+feed contains and the add-on adds only the rest. Set a markup under a plugin
+that already carries one and it is **ignored, with a line in the log saying so**
+— never applied twice.
+
+That holds **given a correct declaration**, and it is worth knowing where the
+line is. What the add-on enforces mechanically is that a plugin cannot obtain
+the markup or apply it: the numbers are not reachable from plugin code, and a
+plugin whose code mentions them fails to load at all. What it cannot check is
+whether a plugin described its supplier's feed truthfully — that is a claim
+about somebody else's tariff, and no code can verify it. If you write a plugin,
+the `sources` declaration is the part a reviewer has to read.
+
+`eneco_eddy` is a real-time/imbalance product rather than a day-ahead one. It is
+flagged as high-volatility, which widens arbitrage thresholds once the
+optimiser lands. That comes from the plugin's own declaration, not from its
+name.
+
+**`manual_csv` — the offline fallback.** It needs no internet, no supplier
+account and no HTTP stack at all, and it is the supported way to run this
+add-on price-aware on a site with no outbound connectivity. Write a file and
+point `price_csv_path` at it:
+
+```csv
+start,eur_per_kwh,provisional
+2026-01-15T00:00:00+01:00,0.1834,false
+2026-01-15T01:00:00+01:00,-0.0210,true
+2026-01-15T02:00:00+01:00,0.3115,false
+```
+
+- `start` **must carry its UTC offset** (`+01:00` in winter, `+02:00` in
+  summer). A bare `2026-01-15 00:00` is refused, because for one hour every
+  October a local wall clock names two different moments.
+- `eur_per_kwh` is **all-in** — energy *plus* markup *plus* taxes. This plugin
+  has no way to know what your numbers already include, so it assumes
+  everything and adds nothing.
+- Negative prices are valid and are kept. They are the best charging hours of
+  the year.
+- `provisional` is optional; omit the column and every hour is treated as
+  settled.
+
+**When there are no prices at all** — provider off, feed unreachable, CSV
+missing — the add-on does not guess. It reports *no price data*, which is a
+distinct state from "prices, all of them zero": the plan is marked provisional
+and arbitrage is disabled, per the degradation matrix. It never falls back to a
+price of zero, which would read as free electricity.
+
+**Injection is priced separately** (`export_price_eur_kwh`). In Belgium it is
+often near zero, which by itself strongly favours self-consumption over export.
+It is a single number rather than a curve because no supported supplier
+publishes a dynamic injection tariff; negative values are accepted.
+
+**The old Home Assistant price sensors.** `price_now_entity` and
+`price_avg_entity` still work and are unchanged: the add-on compares them and
+uses the result as a cheap-window hint for the maintenance charge. They are
+**not compatible with `price_provider`, and not with `static_profile` either**
+— configure two of them and the add-on refuses to start, naming the conflict,
+because the add-on reads exactly one and the loser is silent. Use one.
+
+### Static day/night and fully-fixed tariffs (`static_profile`)
+
+Most Belgian households are **not** on a dynamic contract, and an EMS that only
+works under hourly pricing is an EMS for a minority. `static_profile` is how a
+two-period day/night tariff or a single fixed price becomes a first-class
+configuration rather than "turn the price feature off and hope".
+
+It is one option, holding a JSON object, on one line:
+
+```json
+{"periods": [
+  {"name":"day",   "from":"07:00","to":"22:00","days":"mon-fri","eur_per_kwh":0.34},
+  {"name":"night", "from":"22:00","to":"07:00","days":"mon-fri","eur_per_kwh":0.26},
+  {"name":"night", "from":"00:00","to":"24:00","days":"sat,sun", "eur_per_kwh":0.26}]}
+```
+
+A **fully fixed** tariff is one period covering the whole week:
+
+```json
+{"periods": [
+  {"name":"fixed","from":"00:00","to":"24:00","days":"all","eur_per_kwh":0.31}]}
+```
+
+- `eur_per_kwh` is **all-in** — energy *plus* your supplier's markup *plus*
+  taxes — exactly like `manual_csv`. `price_markup_eur_kwh` and
+  `price_taxes_eur_kwh` are **not** added to it.
+- `days` takes `mon`…`sun`, ranges (`mon-fri`, `fri-mon`), comma lists
+  (`sat,sun`) and the words `weekday`, `weekend`, `all`.
+- Times are **local Belgian time** and windows are half-open: `07:00`–`22:00`
+  includes 07:00 and excludes 22:00. A window may cross midnight.
+- The clock changes twice a year and the add-on handles it. It generates prices
+  against absolute instants, so a spring-forward day is 23 hours and an
+  autumn-back day is 25.
+
+> ⚠️ **A window belongs to the day the clock reads, not the day it started.**
+> `22:00`–`07:00` on `mon-fri` covers Friday 23:00 but **not** Saturday 03:00 —
+> Saturday 03:00 is Saturday's. That is why the example above has a third row
+> for the weekend. Leave it out and the add-on **refuses to start**, naming the
+> uncovered hours.
+
+**Every day type must be covered exactly once.** The periods have to tile all
+seven days with no gap and no overlap, and the add-on checks that at startup. A
+gap is refused rather than filled in, because a made-up price is one the
+optimiser would trade on; an overlap is refused because otherwise one of the two
+prices silently wins on the order you typed them in.
+
+**What it changes today.** The add-on works out which window you are in and
+whether that window is *cheap* — strictly below the tariff's seven-day average.
+The Web UI shows both on a new **Tariff** row, and the maintenance cycle's
+cheap-window grid top-up uses it, which is exactly the "shift load into the
+cheap window" behaviour a day/night tariff asks for. Nothing else moves energy
+on a price yet.
+
+Under a **fully fixed** tariff every hour equals the average, so there is *no*
+cheap window by construction and the add-on runs self-consumption only — which
+is the correct behaviour for that product, not a limitation. Peak shaving, the
+capacity-tariff tracker, the reserve floor and the maintenance schedule are all
+unaffected: the capacity tariff is a network cost charged whatever your energy
+contract is.
+
+**Recommended even on a dynamic contract.** When a price feed is unreachable the
+add-on falls back to your static profile, marks the plan provisional and
+disables arbitrage. With `static_profile` empty there is nothing to fall back
+to, and the site simply has no tariff until the feed returns. It is not required
+— the add-on warns rather than refusing — but filling it in is what makes that
+fallback work.
+
 ### Site
 
 | option | meaning |

goodwe_controller/app/clamp.py

@@ -0,0 +1,284 @@
+"""SAFETY-03 - the output clamp, and the alarm that makes it audible.
+
+WHAT IT CATCHES, in one sentence: a control law that computes a setpoint the
+actuator cannot deliver, which every layer below it will happily clip to
+something legal-looking while the thing that produced it goes on winding.
+
+THE CLAMP IS NOT THE DELIVERABLE. specs.md 10.3 is explicit that this project
+already clipped, and that the clipping is what hid the defect:
+
+    with the inverter switched off entirely, an unclamped integrator climbed
+    ~130 W per 4 s to over 10 kW and, pinned at the 5 kW rail, reported
+    14 768 W
+
+A clamp alone turns that into a silent, perfectly flat 5000 W hold. Every
+dashboard reads "commanded 5000 W", which is a legal number, and nothing
+anywhere says the loop asked for three times it. 11.2's watchdog row says
+"Clamp AND ALARM - the loop is winding"; the second verb is this module.
+
+------------------------------------------------------------------------------
+WHAT "THE RATING" IS HERE, AND WHY IT IS ONE NUMBER AND NOT A MIN()
+
+The card names two bounds and warns against choosing between them:
+
+  - `DriverCapabilities.setpoint_limit_w` (3.2), the inverter's own magnitude
+    rating. In this add-on that arrives as the setpoint entity's `min`/`max`
+    from `hass.limits()` - `Controller.dev_min` / `dev_max`.
+  - `optimizer.loop.clamp_w` (14), the configured loop clamp. In this add-on
+    that is the `max_w` option, which `Tuning.max_w` and the arbiter's
+    `supervised` limit both already use.
+
+14 says these two must AGREE, validated at startup with a refusal on
+mismatch - and that gate already ships: `validate_startup_config()` refuses
+`max_w > dev_max` and `-max_w < dev_min` (validate.py, problem 1), and
+run_control() re-runs it once ESPHome is up and the real rating is known.
+
+So this guard clamps to `max_w`, THE VALIDATED VALUE, and does not `min()` it
+with the device rating at runtime. That is the card's instruction and it is also
+the only reading that keeps `max_w` meaningful: a silent runtime `min()` is
+precisely the "helper bounded to +-500 W under a loop clamped to 1500 W" failure
+the 14 warning box is about.
+
+WARNING - THE DEVICE BOUND IS STILL APPLIED, SECOND, AND IT IS NOT REDUNDANT.
+After a successful validation `+-max_w` lies inside `[dev_min, dev_max]`, so the
+second stage is arithmetically a no-op and can never engage. If it DOES engage,
+the validation did not run or no longer holds - `hass.limits()` returns
+(None, None) whenever ESPHome is not up yet, and the range checks are skipped
+rather than guessed at - and that is a louder fault than the first stage, not a
+quieter one. It therefore alarms too, through the same channel, with the bound
+named. This is NOT SAFETY-20; nothing here changes what `freeze.py` measures its
+rail against.
+
+------------------------------------------------------------------------------
+WHERE THE WIND ACTUALLY SHOWS UP - READ THIS BEFORE "SIMPLIFYING" THE CALLER
+
+`control.compute()` bounds the integrator to `integrator_max_w or max_w` and
+THEN derives the command from it, so on a default install (`integrator_max_w`
+unset, i.e. following `max_w`) the command can never exceed `max_w` and the
+actuator-side clamp below IS UNREACHABLE. control.py says so in as many words:
+
+    SAFETY-03 ... must watch for THIS, not for "clamped" below.
+
+An alarm wired only to this module's `ClampResult.engaged` would therefore be
+silent on the exact configuration the whole ticket is about. The winding is
+visible one layer up, at the integrator bound, and that is why `Decision` now
+carries `i_clamped` / `clamped` BOOLEANS and the caller ORs them in here.
+
+AND WHY BOOLEANS RATHER THAN `Decision.reason`. `reason` is a single string that
+later stages overwrite: a cycle that clamps the integrator and is then slew
+limited reports "slew-limited", and one that clamps while saturated reports
+"saturated-freeze". Both are exactly the winding-into-a-rail case, and on the
+string the clamp signal is destroyed before anything can alarm on it. The two
+flags are set where the clamp happens and are never overwritten. A check in
+test_clamp.py drives that precise combination.
+
+------------------------------------------------------------------------------
+DISTINCT FROM SATURATION - THIS IS ACCEPTANCE CRITERION 2, NOT A NICETY
+
+    clamp      the COMPUTED value exceeded the rating. A software bug signal:
+               something upstream is winding. Alarm, every engagement.
+    saturation |command - inverter AC power| > `saturation_w` for
+               `saturation_cycles`. The HARDWARE cannot follow a perfectly legal
+               command. Action is "freeze the integrator" (11.2), not an alarm.
+
+A loop can be legally saturated all day - a cold pack, a curtailed inverter, an
+export limit - so a saturation-shaped alarm is one an operator learns to ignore.
+Routing the clamp through it puts the bug signal inside the noise, which is the
+same silence 10.3 is complaining about. They share no reason code, no
+notification id, no status row and no counter.
+
+------------------------------------------------------------------------------
+ANTI-FLOOD, WITHOUT GOING SILENT
+
+A genuinely winding loop clamps on EVERY cycle for as long as it winds. One HA
+notification per cycle is how an operator learns to dismiss notifications
+unread, and this add-on already made that argument once (see the fixed
+`notification_id` note in main.check_meter_frozen).
+
+So the two surfaces are split, deliberately:
+
+  - EVERY engagement is recorded, never deduplicated, and that record is what
+    says how hard the loop is pushing. 15's action log is this add-on's
+    `Controller.events`, and it gets a row from `write_setpoint()` on every
+    engaged WRITE; `engagements` here counts every engaged CYCLE. The two layers
+    are counted separately on purpose - the heartbeat re-writes an
+    already-clamped value between cycles, so a per-write count would inflate and
+    a per-cycle log would miss an out-of-cycle write.
+  - THE NOTIFICATION fires on the rising edge and then RE-ASSERTS every
+    `REASSERT_S`, so a loop pinned on the rail for an hour does not go quiet.
+  - It DE-ASSERTS only after `CLEAR_CYCLES` consecutive clean cycles, which is
+    the 10.2 hysteresis: a command sitting exactly on the rail dithers in and
+    out of engagement by one quantisation step, and without this the alarm
+    chatters.
+
+`REASSERT_S` and `CLEAR_CYCLES` are module constants, not options, for the same
+reason `freeze.RAIL_FRAC` is: they describe the event bus, not the plant, and
+every knob 10.3 asked to keep exposed is a LOOP TUNING knob and is untouched by
+this module. No new config key is added anywhere - CFG-03 already has three
+places a default has to be kept in step and this ticket does not earn a fourth.
+
+------------------------------------------------------------------------------
+NOT A TRIP
+
+Clamping does not stop the loop and does not command 0 W. The clamped value is
+written and control continues, which is what 11.2 asks for ("Clamp and alarm")
+and what distinguishes this from SAFETY-01/02, whose action is 0 W. It follows
+that this must NOT drive the failsafe status - `publish()` keeps reporting
+"running", because the controller is.
+"""
+
+import math
+from dataclasses import dataclass
+from datetime import datetime
+
+# The reason code, distinct from any saturation-freeze code by construction:
+# nothing else in this add-on uses it. See "DISTINCT FROM SATURATION".
+REASON_CODE = "OUTPUT_CLAMP"
+
+# Re-assert the notification this often while the clamp stays engaged. 30 s is
+# the planning cadence (2.3), i.e. slow enough not to flood and fast enough
+# that a pinned loop is never quiet for a whole billing quarter.
+REASSERT_S = 30.0
+
+# Consecutive clean cycles before the alarm de-asserts (10.2 hysteresis).
+CLEAR_CYCLES = 3
+
+
+@dataclass(frozen=True)
+class ClampResult:
+    """What the guard did, with the RAW value preserved.
+
+    AC 2 turns on "the raw computed value differed from the clamped one", so the
+    raw value has to survive the call - a guard that returns only the applied
+    number cannot be asked the question the acceptance criterion asks.
+    """
+
+    requested_w: float
+    applied_w: float
+    limit_w: float
+    engaged: bool
+    bound: str = ""          # "" | "max_w" | "device" - which stage bit
+
+    def describe(self) -> str:
+        return (f"{REASON_CODE}: the computed setpoint {self.requested_w:+.0f} W "
+                f"was clamped to {self.applied_w:+.0f} W by the {self.bound} "
+                f"bound (rating {self.limit_w:.0f} W) - something upstream is "
+                f"winding")
+
+
+def is_commandable(value) -> bool:
+    """False for None, NaN and the infinities.
+
+    A non-finite setpoint is LOSS OF INPUT, not an out-of-range value, and
+    11.1 rule 1 says loss of input means command zero and keep commanding. It
+    must not reach the clamp arithmetic: `min(limit, nan)` returns nan on
+    CPython, so a nan would sail straight through a naive clamp and then report
+    `engaged` True on the `applied != requested` test - because nan != nan - i.e.
+    a transport bug filed in the winding-loop counter, with a nan on the wire.
+    """
+    if value is None:
+        return False
+    try:
+        return math.isfinite(float(value))
+    except (TypeError, ValueError):
+        return False
+
+
+def clamp_to_rating(requested_w, limit_w, dev_min=None, dev_max=None) -> ClampResult:
+    """Bound a computed setpoint to the validated rating. The ONLY clamp.
+
+    `limit_w`  the validated magnitude bound - `max_w`. Symmetric, because
+               3.2 calls `setpoint_limit_w` a MAGNITUDE clamp: it binds import
+               (+) and export (-) identically.
+    `dev_min` / `dev_max`  the device's own asymmetric range, applied second and
+               expected never to bite. See the module note.
+
+    Public, and the predicate lives here rather than in the test, for the reason
+    `freeze.looks_frozen()` gives: a safety expression transcribed into its own
+    check is one copy plus a future disagreement about what the check means.
+
+    EXACTLY +-`limit_w` IS NOT AN ENGAGEMENT. The bound is inclusive; a loop
+    resting on the rail is doing what it was told, and alarming there would fire
+    on every healthy full-power hour.
+    """
+    requested = float(requested_w)
+    limit = abs(float(limit_w))
+
+    # ⚠️ BOTH STAGES ALWAYS RUN. THIS USED TO `return` FROM THE FIRST ONE, AND
+    # THAT WAS A REGRESSION AGAINST THE CODE IT REPLACED. `write_setpoint()`
+    # previously clamped to the device range unconditionally, under the comment
+    # "never send a value the device will reject outright"; short-circuiting here
+    # meant the device bound was applied only when the rating bound had NOT
+    # fired, i.e. THE BIGGER THE OVERSHOOT THE LESS THE GUARD DID. Measured on
+    # the shipped function at max_w 5000 against a device of +-4000:
+    #
+    #     +9999 -> +5000  bound='max_w'   <- outside the device range
+    #     +4500 -> +4000  bound='device'
+    #
+    # It also undercut this module's own argument for clamping to `max_w` rather
+    # than a runtime `min()`, which rests entirely on this stage catching the
+    # case where the startup validation did not run.
+    applied = max(-limit, min(limit, requested))
+    bound = "max_w" if applied != requested else ""
+
+    # Second stage. Arithmetically dead after a successful startup validation -
+    # and therefore worth alarming on precisely BECAUSE it fired.
+    if dev_min is not None and dev_max is not None:
+        bounded = max(float(dev_min), min(float(dev_max), applied))
+        if bounded != applied:
+            bound = "device" if not bound else "max_w+device"
+            applied = bounded
+
+    return ClampResult(requested, applied, limit, applied != requested, bound)
+
+
+class ClampWatchdog:
+    """One instance per controller. Counts every engagement, alarms sparsely.
+
+    `note()` is called once per write with whether the clamp bit; the caller ORs
+    in the loop's own `i_clamped` / `clamped` flags, which is where the winding
+    is actually visible on a default install (see the module note).
+    """
+
+    def __init__(self):
+        self.active = False
+        self.engagements = 0      # every engagement, never deduplicated
+        self.episodes = 0         # rising edges
+        self.since: datetime | None = None
+        self.last_alarm: datetime | None = None
+        self.reason = ""
+        self.clean_cycles = 0
+
+    def note(self, engaged: bool, reason: str, now: datetime) -> bool:
+        """Advance one cycle. True when the caller should raise the alarm.
+
+        `now` is the caller's clock, the same discipline as
+        `SignWatchdog.evaluate()` and `FreezeWatchdog.evaluate()`.
+        """
+        if engaged:
+            self.engagements += 1
+            self.clean_cycles = 0
+            self.reason = reason
+            if not self.active:
+                self.active = True
+                self.since = now
+                self.episodes += 1
+                self.last_alarm = now
+                return True
+            # Still engaged: re-assert on the slow cadence, not every cycle.
+            if (self.last_alarm is None
+                    or (now - self.last_alarm).total_seconds() >= REASSERT_S):
+                self.last_alarm = now
+                return True
+            return False
+
+        if not self.active:
+            return False
+        self.clean_cycles += 1
+        if self.clean_cycles >= CLEAR_CYCLES:
+            self.active = False
+            self.since = None
+            self.last_alarm = None
+            self.reason = ""
+            self.clean_cycles = 0
+        return False

goodwe_controller/app/control.py

@@ -64,6 +64,23 @@ class Decision:
     # and quantisation. Carry it back in as `i_w` next cycle; that is what keeps
     # it a separate quantity from the command.
     i_w: float = 0.0
+    # SAFETY-03. Did a clamp actually engage this cycle - i.e. did the RAW
+    # computed value differ from the bounded one?
+    #
+    # ⚠️ THESE EXIST BECAUSE `reason` CANNOT ANSWER THAT QUESTION. `reason` is
+    # one string and every later stage overwrites it: a cycle that clamps the
+    # integrator and is then slew limited reports "slew-limited", and one that
+    # clamps while saturated reports "saturated-freeze". Both ARE the winding
+    # case, and on the string the clamp signal is gone before anything can alarm
+    # on it. These two are written where the clamp happens and are never
+    # overwritten, so they mean exactly what they say and nothing else.
+    #
+    # `i_clamped` is the one that fires on a default install: the integrator
+    # bound is reached first, so `clamped` is unreachable unless
+    # `integrator_max_w` is deliberately set above `max_w`. Alarm on BOTH - see
+    # the comment at the bound below, and clamp.py.
+    i_clamped: bool = False
+    clamped: bool = False
 
 
 def compute(
@@ -188,7 +205,8 @@ def compute(
     # bound is not. It is what makes the worst-case unwind time finite and
     # knowable instead of a function of how long the error happened to stand.
     bounded = max(-limit, min(limit, i_w))
-    if bounded != i_w:
+    i_clamped = bounded != i_w
+    if i_clamped:
         # ⚠️ SAFETY-03 (alarm whenever the loop winds into a rail) must watch
         # for THIS, not for "clamped" below. At the default limit == max_w the
         # integrator bound is reached first and the command derived from it can
@@ -209,7 +227,8 @@ def compute(
     # --- ORDER MATTERS: clamp -> slew -> freeze ----------------------------
     # An early draft applied a floor after the clamp and let demand escape it.
     target = max(-tuning.max_w, min(tuning.max_w, want))
-    if target != want:
+    clamped = target != want
+    if clamped:
         reason = "clamped"
 
     slewed = max(prev_w - tuning.slew_w, min(prev_w + tuning.slew_w, target))
@@ -235,7 +254,8 @@ def compute(
     step = max(1, int(tuning.step_w))
     target = round(target / step) * step
 
-    return Decision(float(target), sat_count, frozen, reason, float(i_w))
+    return Decision(float(target), sat_count, frozen, reason, float(i_w),
+                    i_clamped, clamped)
 
 
 def maintenance_charge_floor(

goodwe_controller/app/main.py

@@ -36,11 +36,17 @@ from .arbiter import (
     P_LOOP, P_MAINT_SHAPE, P_MAINTENANCE, P_SAFETY, Claim, resolve,
 )
 from .control import Tuning, compute, maintenance_charge_floor, peak_at_risk
+from .clamp import (
+    REASON_CODE as CLAMP_REASON, ClampResult, ClampWatchdog, clamp_to_rating,
+    is_commandable,
+)
 from .freeze import FreezeWatchdog, FreezeWatchdogConfig, rail_w
 from .hass import HomeAssistant
 from .maintenance import IDLE, MaintConfig, Maintenance
 from .mqtt import MqttPublisher
 from .p1 import P1Ingest, build_source, is_enabled
+from .static_tariff import static_status
+from .tariff import PeakStore, PeakTracker
 from .validate import ConfigRefused, refuse, validate_startup_config
 from .watchdog import SignWatchdog, SignWatchdogConfig, loop_is_following
 from . import web
@@ -59,7 +65,8 @@ def load_options() -> dict:
 
 
 class Controller:
-    def __init__(self, opts: dict, hass: HomeAssistant, store, mqtt_pub, *, stop):
+    def __init__(self, opts: dict, hass: HomeAssistant, store, mqtt_pub, *, stop,
+                 peak_db_path: str = "/data/tariff.db"):
         self.o = opts
         self.hass = hass
         self.store = store
@@ -140,12 +147,48 @@ class Controller:
         self.freeze_wd = FreezeWatchdog(
             FreezeWatchdogConfig(hold_s=float(opts.get("meter_freeze_s", 300))))
 
+        # SAFETY-03. The output clamp's alarm - see clamp.py for why the clamp
+        # itself is the cheap half.
+        #
+        # ⚠️ NO CONFIG OF ITS OWN, on purpose. The bound it clamps to is `max_w`,
+        # which is already an option, already validated against the device's
+        # rating at startup, and already used by Tuning and the arbiter. Giving
+        # this a second key would be a fourth place a limit has to be kept in
+        # step (CFG-03 already tracks three) and, worse, would recreate exactly
+        # the two-numbers-that-disagree failure the §14 warning box describes.
+        # The anti-flood cadence is a module constant for the same reason
+        # freeze.RAIL_FRAC is: it describes the event bus, not the plant.
+        self.clamp_wd = ClampWatchdog()
+
         # P1 ingestion (TEL-01). `meter_source: off` keeps the original
         # single-entity meter_entity path, so an existing install is unchanged
         # until it opts in.
         self.p1 = P1Ingest(phases=int(opts.get("meter_phases", 1)),
                            max_age_s=float(opts.get("meter_max_age_s", 30)))
         self.p1_enabled = is_enabled(opts)
+
+        # TARIFF-01. The capacity-tariff peak: measured from the meter, banked
+        # in SQLite, restored across a restart. It is an INSTRUMENT - it files no
+        # claim and clamps nothing. SAFETY-07 is what will read it.
+        #
+        # ⚠️ NO NEW OPTION. The soft limit is `peak_cap_w`, already shipped,
+        # already validated, already read by control.peak_at_risk(). CFG-03
+        # tracks three places option defaults live; a fourth, for a limit that
+        # already exists, is the mistake the clamp watchdog declined to make ~30
+        # lines up. config.yaml and validate.py are untouched by this ticket.
+        #
+        # ⚠️ AND NO SECOND PEAK ENTITY. `peak_forecast_entity` is the existing
+        # HA-side delegation and it stays the input to maintenance_charge_floor():
+        # repointing that consumer at this measurement CHANGES WHAT MOVES ENERGY
+        # during a maintenance charge, which belongs to SAFETY-07 with its own
+        # acceptance, not to a measurement ticket. What this adds is the MEASURED
+        # MONTH PEAK - a different quantity from a forecast entity, published
+        # nowhere as a duplicate of it.
+        self.peak_store = PeakStore(peak_db_path)
+        self.peak = PeakTracker(self.peak_store,
+                                cap_w=float(opts.get("peak_cap_w", 3500)))
+        self.peak.restore(self.p1.averager)
+        _LOG.info("capacity-tariff peak store: %s", self.peak.restore_state)
         # Set by amain() once the transport is built, so the status page can show
         # what only the transport knows (homewizard_local's unchanged_s). Stays
         # None when P1 is off, or under a transport that has no such counter.
@@ -166,11 +209,20 @@ class Controller:
         self.grid = self.soc = self.batt = None
         self.peak_fc = None
         self.cheap = False
+        # TARIFF-03. One line of prose for the status page saying WHICH tariff
+        # window we are in and why it is or is not cheap - so "Cheap window:
+        # no" is an evidenced answer rather than a bare no.
+        self.tariff_words = "no static profile"
         self.last_write = None
         self.last_write_at = None
         self.last_write_ok = None
         self.inputs_bad_since = None
         self.dev_min = self.dev_max = None
+        # SAFETY-03. What the last write's clamp did, and what the loop's own
+        # bounds did last cycle. `loop_clamped` is a (engaged, note) pair so the
+        # alarm can say WHICH bound bit without re-deriving it from a string.
+        self.clamp_last: ClampResult | None = None
+        self.loop_clamped: tuple[bool, str] = (False, "")
         self.events: list[str] = []
         self.stopping = False
 
@@ -214,9 +266,31 @@ class Controller:
             now_p = await self.hass.number(now_e)
             avg_p = await self.hass.number(avg_e)
             self.cheap = (now_p is not None and avg_p is not None and now_p <= avg_p)
+            self.tariff_words = "Home Assistant price entities"
         else:
-            # Fixed-tariff site: never force a paid grid top-up, wait for sun.
-            self.cheap = False
+            # TARIFF-03. §9.2 makes a static day/night tariff a first-class
+            # product, and its required EMS handling is TIME-WINDOW SHIFTING.
+            # The add-on has exactly one shiftable load in 0.5.x - the
+            # maintenance cycle's cheap-window grid top-up, ~15 lines below in
+            # cycle() - so this is where the window reaches something that moves
+            # energy. With `static_profile` empty this returns False and the
+            # behaviour is bit-for-bit what it has always been: "fixed-tariff
+            # site, never force a paid grid top-up, wait for sun".
+            #
+            # ⚠️ SYNCHRONOUS AND I/O-FREE, ON PURPOSE. The provider-backed
+            # resolver (static_tariff.resolve_tariff) can perform an HTTP fetch,
+            # and this coroutine is on the path that feeds the ESP32 heartbeat -
+            # a supplier's TLS timeout here would be a supplier able to push the
+            # add-on towards layer 1's 30 s veto. Generation from a static
+            # profile is pure arithmetic, so §2.3's "regenerate on the tick"
+            # applies and there is nothing to block on. Putting a fetched series
+            # on this path needs a BACKGROUND refresh and belongs with OPT-04.
+            #
+            # ⚠️ AND IT CANNOT BE BOTH. validate.py refuses static_profile
+            # alongside the two Home Assistant entities, because this `if` picks
+            # one and the loser is silent.
+            self.cheap, self.tariff_words = static_status(
+                o, datetime.now(timezone.utc))
 
         if self.inputs_ok:
             if self.inputs_bad_since is not None:
@@ -229,11 +303,37 @@ class Controller:
         entity = self.o.get("setpoint_entity", "")
         if not entity:
             return
-        # Never send a value the device will reject outright. A rejected write is
-        # silent from the controller's point of view, and the inverter then keeps
-        # doing whatever it was already doing.
-        if self.dev_min is not None and self.dev_max is not None:
-            value = max(self.dev_min, min(self.dev_max, value))
+
+        # --- SAFETY-03: THE CLAMP, AND IT IS ON THE ONLY PATH TO THE WIRE -----
+        # Every write in this add-on comes through here - the cycle, the
+        # heartbeat, the operator's stop button and shutdown() - so no optimizer,
+        # maintenance or manual path can route around it. That placement is the
+        # first acceptance criterion, and it is why the guard is not in
+        # control.py: a guard the control law owns is a guard every other claimer
+        # bypasses.
+        #
+        # ⚠️ A NON-FINITE VALUE IS LOSS OF INPUT, NOT AN OUT-OF-RANGE ONE. §11.1
+        # rule 1: command zero and keep commanding. It must not reach the clamp
+        # arithmetic - see is_commandable() for what a nan does to it - and it
+        # must not be counted as a clamp engagement, or a transport bug lands in
+        # the winding-loop counter.
+        if not is_commandable(value):
+            self.log_event(f"non-finite setpoint {value!r} - commanding 0 W")
+            _LOG.error("refusing to write a non-finite setpoint %r - commanding "
+                       "0 W and continuing to command. This is a bug upstream, "
+                       "not a limit.", value)
+            value = 0.0
+        result = clamp_to_rating(value, float(self.o.get("max_w", 2000)),
+                                 self.dev_min, self.dev_max)
+        self.clamp_last = result
+        if result.engaged:
+            # ⚠️ EVERY engagement, never deduplicated: this is the action log
+            # (§15), and it is a different surface from the notification, which
+            # IS deduplicated. The count is what says how hard the loop pushed;
+            # the notification only says that it did.
+            self.log_event(result.describe())
+        value = result.applied_w
+
         changed = (self.last_write is None or value != self.last_write)
         if not (changed or force):
             return
@@ -379,11 +479,29 @@ class Controller:
             self.sat_count = decision.sat_count
             self.i_w = decision.i_w
             self.loop_w = decision.target_w
+            # --- SAFETY-03 ---------------------------------------------------
+            # ⚠️ READ THE BOOLEANS, NOT `decision.reason`. On a default install
+            # the integrator bound is what bites and the output clamp is
+            # unreachable (control.py says so), and `reason` is then overwritten
+            # by whichever of slew-limiting or the saturation freeze ran after
+            # it - so a string test is silent on the two cases a winding loop
+            # most often presents as. These flags are set where the clamp
+            # happens and nothing downstream touches them.
+            self.loop_clamped = (
+                decision.i_clamped or decision.clamped,
+                (f"the loop asked for {decision.i_w:+.0f} W"
+                 + (" (integrator bound)" if decision.i_clamped else "")
+                 + (" (output bound)" if decision.clamped else "")),
+            )
             claims.append(Claim.set("loop", P_LOOP, decision.target_w, decision.reason))
         else:
             # Stopped or blind: no accumulation may survive the outage.
             self.i_w = 0.0
             self.loop_w = None
+            # A loop that is not running cannot be winding. Clearing this here
+            # rather than letting the last value stand is what makes the alarm
+            # de-assert when control is stopped.
+            self.loop_clamped = (False, "")
 
         resolution = resolve(claims)
         if resolution.contradiction:
@@ -406,14 +524,125 @@ class Controller:
         self.reason = resolution.explain()
         await self.write_setpoint(self.target)
 
-        # --- SAFETY-18, and it runs LAST on purpose --------------------------
-        # Both terms of the conjunction describe the state that now exists: the
-        # command that has just gone on the wire, and how long the meter that
-        # chose it has been standing still. Evaluated before write_setpoint()
-        # it would be reasoning about the PREVIOUS command against THIS cycle's
-        # meter - the one combination that is true of neither moment.
+        # --- SAFETY-03, and its boundary is the WRITE ------------------------
+        # ⚠️ NOT THE SAME BOUNDARY AS SAFETY-18's BELOW, THOUGH THE CALLS ABUT.
+        # This one reads `self.clamp_last`, which is None until write_setpoint()
+        # has actually run, so it has to follow the write. The one below grades
+        # `self.target`, which is assigned further up - see check_output_clamp()
+        # and check_meter_frozen() for each. Two guards, two orderings, adjacent
+        # lines: do not "tidy" them into one rule.
+        await self.check_output_clamp()
+
+        # --- SAFETY-18, and its boundary is the ASSIGNMENT --------------------
+        # ⚠️ THE BOUNDARY IS `self.target = resolution.target_w` ABOVE, NOT
+        # write_setpoint(). This comment used to say "the command that has just
+        # gone on the wire", which is wrong twice over and was corrected by
+        # TEST-06's reviewer: `check_meter_frozen()` grades `self.target` - the
+        # arbiter's resolved intent - and `write_setpoint()` clamps only a local
+        # `value` and can skip the write entirely, so that number may never have
+        # gone anywhere.
+        #
+        # What both terms of the conjunction must describe is the SAME moment:
+        # the command this cycle resolved, against how long the meter that chose
+        # it has been standing still. Evaluated before
+        # `self.target = resolution.target_w` it would grade the PREVIOUS
+        # cycle's command against THIS cycle's meter - the one combination that
+        # was true of neither moment. Moving it between the assignment and
+        # write_setpoint() is therefore harmless; moving it above the assignment
+        # is not, and test_freeze.py part 5 fails on exactly that.
         await self.check_meter_frozen()
 
+        # --- TARIFF-01, and it is LAST on purpose -----------------------------
+        # Banking a quarter is bookkeeping about a moment that has already
+        # happened; a slow SD card must never sit between the meter and the
+        # setpoint. Its position is unconstrained in the way SAFETY-03's and
+        # SAFETY-18's are not - it grades neither `target` nor `standing` and
+        # reads only `self.p1`, which no line in this method writes.
+        self.peak.sync(self.p1)
+
+    async def check_output_clamp(self) -> None:
+        """SAFETY-03. Alarm whenever a clamp actually engaged this cycle.
+
+        Runs AFTER write_setpoint() for the same reason SAFETY-18 does: the
+        clamp is arithmetic done inside the write, so before the write there is
+        nothing yet to report.
+
+        ⚠️ PUBLISHING IS NOT IN THE WRITE PATH. The clamp itself is synchronous
+        inside write_setpoint(); this - the awaits, the notification, anything
+        that can block on Home Assistant - is out here. A stalled supervisor must
+        never be able to delay or drop a frame.
+
+        ⚠️ THIS IS NOT A TRIP. No claim is filed, nothing is latched, 0 W is not
+        commanded and `publish()` still reports "running". §11.2's action for
+        this row is "clamp and alarm", and the clamped value is written and the
+        loop keeps running. Turning this into a trip means coming here and
+        changing that deliberately, not discovering it in the field.
+        """
+        engaged_write = bool(self.clamp_last and self.clamp_last.engaged)
+        engaged_loop, loop_note = self.loop_clamped
+        engaged = engaged_write or engaged_loop
+        if engaged:
+            where = (self.clamp_last.describe() if engaged_write
+                     else f"{CLAMP_REASON}: {loop_note}, above the "
+                          f"{float(self.o.get('max_w', 2000)):.0f} W rating, and "
+                          f"was clamped to {self.target:+.0f} W")
+            reason = (f"{where}. This is a BUG SIGNAL, not a limit being used: "
+                      f"something upstream computed a setpoint the actuator "
+                      f"cannot deliver.")
+        else:
+            reason = ""
+        fired = self.clamp_wd.note(engaged, reason, datetime.now(timezone.utc))
+
+        # --- THE ACTION LOG, AND IT IS COALESCED PER EPISODE ------------------
+        # Every engagement is recorded, but consecutive ones are recorded by
+        # UPDATING one row's count rather than inserting a row each.
+        #
+        # ⚠️ THAT IS NOT COSMETIC, AND IT WAS FOUND THE HARD WAY. `log_event()`
+        # keeps 40 rows; a winding loop clamps on every cycle, so a row per
+        # engagement flushes the whole ring within 40 cycles - and the first
+        # thing it evicted, in test_freeze.py, was SAFETY-18's "METER FROZEN?"
+        # row. A guard whose log drowns out the other guards' logs has moved the
+        # flood rather than removed it. The count here is `clamp_wd.engagements`,
+        # so nothing is lost: the row says exactly how many, and the number is
+        # read off the counter rather than off the number of rows.
+        #
+        # This lives here rather than only in write_setpoint() because on a
+        # default install the actuator-side clamp is unreachable - compute() has
+        # already bounded the integrator - so the only engagements that exist are
+        # loop-side ones. Measured: 60 cycles of the §10.3 runaway produce 0
+        # write-path engagements and 2 loop-side ones.
+        if engaged and not engaged_write:
+            tag = f"{CLAMP_REASON} episode {self.clamp_wd.episodes}"
+            row = (f"{tag}: {self.clamp_wd.engagements} engagement(s) - "
+                   f"{reason}")
+            if self.events and tag in self.events[0]:
+                stamp = self.events[0].split(" ", 1)[0]
+                self.events[0] = f"{stamp} {row}"
+            else:
+                self.log_event(row)
+        if not fired:
+            return
+        _LOG.error(
+            "SAFETY-03 - %s Silently clipping this is how a winding integrator "
+            "reached 14 768 W on this project before: the clamp makes every "
+            "dashboard read a legal number while the thing producing it goes on "
+            "climbing. The command IS clamped and the loop is STILL RUNNING - "
+            "this is an alarm, not a trip. Engagements so far: %d.",
+            self.clamp_wd.reason, self.clamp_wd.engagements)
+        # A fixed notification_id, for the reason check_meter_frozen() gives -
+        # and a DIFFERENT one from every other alarm this add-on raises, because
+        # a clamp is not a frozen meter and neither is a saturation freeze.
+        await self.hass.call("persistent_notification", "create", {
+            "notification_id": "goodwe_output_clamp",
+            "title": "GoodWe: a computed setpoint exceeded the rating",
+            "message": (
+                f"{self.clamp_wd.reason}\n\nThe command has been clamped and "
+                f"the controller is STILL RUNNING. This is NOT the inverter "
+                f"failing to follow a legal command (that is the saturation "
+                f"freeze, which is normal and does not alarm) - the value asked "
+                f"for was itself out of range."),
+        })
+
     async def check_meter_frozen(self) -> None:
         """SAFETY-18. Alarm on a meter that answers forever without changing.
 
@@ -668,6 +897,27 @@ class Controller:
                                     f"{self.freeze_wd.cfg.hold_s:.0f} s unchanged "
                                     f"while the command is over "
                                     f"{rail_w(self.o.get('max_w', 2000)):.0f} W)"})
+
+            # TARIFF-01. The month's billed peak, and - the load-bearing half -
+            # a DIFFERENT row when the store could not answer. "no peak yet" is
+            # a normal state on the 1st; "unreadable" is a broken instrument, and
+            # a status page that spelled them the same way would let a 0 W read
+            # look like a quiet month right up until SAFETY-07 shaved nothing.
+            _pk = self.peak.peak()
+            if _pk.is_unreadable:
+                out.append({"ok": False, "warn": True,
+                            "text": "capacity-tariff peak: " + _pk.explain()})
+            else:
+                # §9.1's "warning entity at 80 %", as a status row rather than
+                # a second entity - see the constructor on not doubling up.
+                _frac = self.peak.warning_frac() or 0.0
+                _ok = _frac < 0.8
+                out.append({"ok": _ok, "warn": not _ok,
+                            "text": _pk.explain()
+                                    + f" - {_frac * 100:.0f} % of the "
+                                      f"{self.peak.cap_w:.0f} W soft limit"
+                                    + f"; {self.peak.recorded} quarter(s) banked"
+                                    + f"; on start: {self.peak.restore_state}"})
         rows = [("battery SoC", self.soc, o.get("soc_entity")),
                 ("battery power", self.batt, o.get("batt_entity"))]
         if not self.p1_enabled:
@@ -694,6 +944,23 @@ class Controller:
             out.append({"ok": True, "warn": False,
                         "text": f"setpoint {sp} (range {self.dev_min:g}…{self.dev_max:g} W)"})
 
+        # SAFETY-03. Red while a clamp is engaged, and the engagement COUNT is
+        # shown even after it clears - a loop that wound once and stopped is
+        # still a bug, and a row that vanishes with the condition takes the
+        # evidence with it. Reported only when there is something to report:
+        # unlike the freeze detector this guard has no "not covered" state, it
+        # runs on every write on every transport.
+        if self.clamp_wd.active:
+            out.append({"ok": False, "warn": False,
+                        "text": "OUTPUT CLAMP ENGAGED - " + self.clamp_wd.reason
+                                + f" Engagements: {self.clamp_wd.engagements}."})
+        elif self.clamp_wd.engagements:
+            out.append({"ok": False, "warn": True,
+                        "text": f"output clamp: not engaged now, but it has "
+                                f"engaged {self.clamp_wd.engagements} time(s) in "
+                                f"{self.clamp_wd.episodes} episode(s) since "
+                                f"start - see the event log"})
+
         if self.last_write_ok is False:
             out.append({"ok": False, "warn": False,
                         "text": "last write to the inverter was REJECTED - check the log"})
@@ -758,6 +1025,7 @@ class Controller:
             ("Maintenance phase", self.maint.phase),
             ("Maintenance due", "now" if next_due is None else next_due.strftime("%Y-%m-%d")),
             ("Cheap window", "yes" if self.cheap else "no"),
+            ("Tariff", self.tariff_words),
         ]
         return {
             "banner": banner, "level": level, "rows": rows, "checks": checks,

goodwe_controller/app/p1.py

@@ -353,6 +353,54 @@ class QuarterAverager:
         self._last_pp = sample.per_phase_w
         return closed
 
+    # -- surviving a restart (TARIFF-01) ------------------------------------
+    def snapshot(self) -> dict:
+        """The open block's whole state, as JSON-safe primitives.
+
+        ⚠️ `last_t` is the HELD SAMPLE'S OWN timestamp and is stored as it is,
+        not refreshed to "now". That is what makes a restart integrate the gap
+        under exactly the `max_hold_s` rule a running process would have used:
+        a short restart is a plateau, a long one leaves uncovered seconds that
+        drag the closed block's average down. Rewriting it to the restore time
+        would silently credit the whole outage at the last value seen before it.
+        """
+        return {
+            "block": self._block,
+            "acc": self._acc,
+            "pp_acc": list(self._pp_acc),
+            "elapsed": self._elapsed,
+            "last_t": self._last_t,
+            "last_net": self._last_net,
+            "last_pp": list(self._last_pp) if self._last_pp is not None else None,
+            "phases": self.phases,
+        }
+
+    def restore(self, state: dict) -> bool:
+        """Put a `snapshot()` back. False if it does not fit this averager.
+
+        A phase-count change is a reconfiguration, not a resumption: the
+        per-phase accumulator would be reshaped mid-block and the two halves
+        would not be the same measurement. Refusing is the honest answer, and
+        the caller reports starting fresh rather than pretending it resumed.
+        """
+        try:
+            if int(state.get("phases", self.phases)) != self.phases:
+                return False
+            pp_acc = list(state.get("pp_acc") or [])
+            if len(pp_acc) != self.phases:
+                return False
+            self._block = None if state["block"] is None else int(state["block"])
+            self._acc = float(state["acc"])
+            self._pp_acc = [float(v) for v in pp_acc]
+            self._elapsed = float(state["elapsed"])
+            self._last_t = None if state["last_t"] is None else float(state["last_t"])
+            self._last_net = float(state["last_net"])
+            lp = state.get("last_pp")
+            self._last_pp = tuple(float(v) for v in lp) if lp is not None else None
+            return True
+        except (KeyError, TypeError, ValueError):
+            return False
+
 
 # --------------------------------------------------------------------------- #
 # what the rest of the add-on talks to

goodwe_controller/app/static_tariff.py

@@ -0,0 +1,924 @@
+"""TARIFF-03 - static day/night and fully-fixed tariffs, first-class.
+
+WHERE THIS LIVES, AND WHY IT IS NOT WHERE THE SPEC SAYS. specs.md §2.2 puts the
+price machinery at `ems/tariff/...`. That module layout does not exist and is
+not being built; the product owner's decision of 2026-08-30 is that everything
+ships in `goodwe_controller/app/`, next to price.py, arbiter.py and validate.py.
+The BEHAVIOUR §9.2 / §9.3 / §11.4 / §10.1 describes is unchanged and still
+authoritative - only the path moved.
+
+WHY THIS TICKET EXISTS, in §9.2's own words: "a large share of the installed
+base is on [a static profile], and an EMS that only works under dynamic pricing
+is an EMS for a minority." The §9.2 product table maps four products onto four
+EMS behaviours, and TARIFF-02 shipped the machinery for the top two only:
+
+    Dynamic day-ahead    hourly EPEX BE + markup     full arbitrage
+    Real-time/imbalance  e.g. Eneco Eddy Flex        arbitrage, wider thresholds
+    Static day/night     two-period tariff           TIME-WINDOW SHIFTING   <- here
+    Fully fixed          single price                SELF-CONSUMPTION ONLY  <- here
+
+
+THE PLACEMENT DECISION, AND THE TWO REASONS IT IS NOT A PROVIDER PLUGIN
+=======================================================================
+The obvious move is a sixth `@register`ed `PriceProvider` alongside
+`generic_dayahead` and `manual_csv`. It was considered and rejected, on two
+grounds that are mechanical rather than aesthetic:
+
+  1. A PROVIDER'S PRODUCT IS FIXED AT CLASS-DEFINITION TIME AND THIS ONE IS NOT.
+     `PriceProvider.capabilities()` is a `classmethod` taking no options, and
+     `load_prices()` reads `caps.product` to stamp the series. But §9.2 makes
+     STATIC and FIXED two DIFFERENT products with two different required EMS
+     behaviours, and which of the two a site is on is a property of the
+     OPERATOR'S DATA - one period or several - not of any class. A plugin would
+     have to declare one of them and be wrong for half its users, or the
+     framework would have to grow a per-call product override, which is a
+     change to TARIFF-02's contract for the benefit of one caller.
+     `StaticProfile.product` derives it from the periods instead (see below).
+
+  2. THE PLUGIN FRAMEWORK EXISTS TO SOLVE A PROBLEM THIS PATH DOES NOT HAVE.
+     `capabilities().sources` / `assemble()` exist because a FETCHED figure may
+     or may not already contain the supplier's markup, and adding it twice is
+     invisible (price.py, trap 1). A static profile's numbers are typed by the
+     operator as all-in; there is no publisher to disagree with, so the whole
+     `RawPoint` -> `assemble()` -> `PricePoint` pipeline would be an identity
+     function wrapped in a declaration nobody can check.
+
+  ⚠️ WHAT IS *NOT* A REASON: "it is offline". `manual_csv` is offline and is a
+  plugin, correctly. Offline-ness is not what separates these two.
+
+So the static profile sits UNDER the provider framework, as the layer §11.4
+already says it is:
+
+    §11.4  No price data -> fall back to the static profile, mark the plan
+                            provisional, no arbitrage.
+
+which makes the §9.2 product option and the §11.4 degradation row THE SAME CODE
+PATH, differing in exactly one flag. A fully-static site is one that leaves
+`price_provider: off` (already the shipped default) and fills in
+`static_profile`; a dynamic site whose feed died falls into the same generator
+with `provisional=True`. One generator, two call sites, one flag - so the
+fallback cannot rot, because it is the path a whole class of installs runs on
+every day.
+
+It emits `PricePoint`s in TARIFF-02's canonical `{start, eur_per_kwh,
+provisional}` shape (§9.3, "so the optimiser compares like with like"), so
+every downstream consumer works unchanged and none of them learns that a
+tariff can be static.
+
+
+HOW "NO ARBITRAGE" IS EXPRESSED SO A FUTURE OPTIMISER CANNOT IGNORE IT
+======================================================================
+A boolean called `arbitrage_ok` that OPT-04 is asked to remember to check is not
+a mechanism; it is a comment with a type. So the numbers an arbitrage strategy
+NEEDS - the spread, and which hours are the cheap and dear ends of it - EXIST
+ONLY ON THE PERMITTING VARIANT of `Arbitrage`. `refused` carries `.reason` and
+nothing else, and reaches for anything else raises `Absence`, the same shape
+price.py borrowed from `sim/riglock.py`. An optimiser cannot compute a trade
+from a refusal, because it cannot get the inputs out of one.
+
+And the verdict is only obtainable from `TariffPlan.arbitrage(...)`, which takes
+`peak_guard_active` as a REQUIRED KEYWORD ARGUMENT. §9.1 and §10.1 put peak
+shaving (priority 2) above price arbitrage (priority 3) - the capacity tariff is
+a network cost charged whatever the energy product is - and the way that
+ordering is made to survive OPT-04 landing is that OPT-04 cannot obtain a spread
+without first stating whether the peak guard is holding. It is not free to
+forget the question; the call does not compile without an answer.
+
+⚠️ FOUR REFUSALS, IN THIS ORDER, EACH DERIVED FROM SOMETHING MEASURED:
+
+  1. the peak guard is active           §10.1: priority 2 outranks priority 3
+  2. no price data at all               §11.4, and no static_profile to fall to
+  3. the plan is provisional            §11.4 fallback / §8.3 unknown hours
+  4. the series is FLAT                 max - min == 0, so there is nothing to
+                                        arbitrage. THIS is AC2: a fully-fixed
+                                        tariff disables arbitrage by ARITHMETIC,
+                                        not by a special case keyed on
+                                        `PriceProduct.FIXED`. A dynamic feed
+                                        that happens to print one price all day
+                                        gets refused for the same true reason.
+
+Nothing here decides a trade. The spread is handed over; OPT-04 owns
+`cycle_cost_threshold_eur` (§10.1/§14) and what to do about it. ⚠️ Worth knowing
+before that lands: on the Belgian day/night numbers in DOCS.md the whole-tariff
+spread is 0.08 EUR/kWh, which is BELOW the shipped 0.10 threshold - so a
+correct OPT-04 will decline to cycle for the tariff alone on such a site. That
+is a product finding, not a bug here.
+
+WHAT STAYS ON WHEN ARBITRAGE IS OFF (AC2, and §10.1 in full): priorities 1
+(self-consumption), 2 (peak shaving), 4 (reserve management) and 5 (load
+shifting) are untouched by any refusal above. Only priority 3 goes away. In
+0.5.x that is literally true because none of them reads a price: the grid
+following loop, the capacity-tariff peak tracker and the freeze/sign watchdogs
+all run off P1 and know nothing about this module.
+
+
+TIME-WINDOW SHIFTING, AND THE ONE SHIFTABLE LOAD THAT EXISTS TODAY
+==================================================================
+§9.2's handling for a two-period tariff is "time-window shifting", and §10.1
+priority 5 is load shifting. The add-on has exactly one shiftable load in
+0.5.x: the maintenance cycle's cheap-window grid top-up. `static_status()` is
+what main.py reads for it, and `cheap_now()` is the rule:
+
+    cheap  <=>  the price now is STRICTLY BELOW the mean over the horizon
+
+⚠️ STRICTLY BELOW, AND THE STRICTNESS IS AC2. Under a fully-fixed tariff every
+hour equals the mean, so `<=` would make EVERY hour a cheap window and a fixed
+tariff site would top the battery up from the grid at any hour of the day -
+which is the exact opposite of "self-consumption only". With `<`, a flat series
+has no cheap window at all, derived rather than special-cased. (The Home
+Assistant `price_now_entity`/`price_avg_entity` pair main.py has always used
+computes `now <= avg`; the difference is deliberate and is why this is not
+simply the same expression.)
+
+⚠️ THE MEAN IS TAKEN OVER SEVEN LOCAL DAYS, not over the 48 h forecast horizon,
+and that is not tidiness. Belgian night tariffs usually cover the whole weekend,
+so a 48 h mean computed on a Friday afternoon is weighted about 2/3 weekend and
+the SAME Tuesday 09:00 comes out cheap or dear depending on the day you asked.
+Seven days contains each weekday exactly once, so the mean is a property of the
+tariff instead of a property of the hour you called at.
+
+
+DAYLIGHT SAVING, AND WHY THERE IS NO `zoneinfo` HERE EITHER
+============================================================
+The shipped Alpine image has no `tzdata` (price.py's docstring, and the
+Dockerfile), so `ZoneInfo("Europe/Brussels")` raises there. price.py already
+carries `brussels()` / `brussels_offset()` - the EU rule, in arithmetic, checked
+in review of PR #16 against `zoneinfo` over 149,040 hourly instants with zero
+mismatches - and this module uses it rather than growing a second answer to the
+same question.
+
+Generation iterates HOURLY IN UTC and renders each instant to local, so a
+spring-forward day yields 23 points and an autumn-back day 25, BY CONSTRUCTION.
+An implementation that walked 24 local hours would emit 24 on both and misprice
+an hour twice a year; `test_static_tariff.py` drives both 2026 transitions and
+counts, rather than asserting 24.
+
+⚠️ A WINDOW BELONGS TO THE DAY THE CLOCK READS, NOT THE DAY IT STARTED. A
+`22:00-07:00 mon-fri` night window covers Friday 23:00 (Friday) but NOT
+Saturday 03:00 - Saturday 03:00 is Saturday's, and Saturday needs its own
+period. That is the only rule under which the tiling check below can be
+decidable at all, and it is why the shipped Belgian example carries an
+explicit weekend row.
+
+
+VALIDATION: NEVER INVENT A PRICE FOR AN UNCOVERED HOUR
+======================================================
+For every day type the periods must tile the 1440-minute clock exactly once -
+no gap, no overlap - and `parse_static_profile()` refuses anything else with the
+uncovered or doubled range named in local time. `validate.py` calls it at
+startup, so a malformed profile is a refusal to start, not a surprise at 02:00.
+
+The alternative - defaulting an uncovered hour to some price - is the defect
+price.py's whole `_NoData` type exists to prevent, one level down: an invented
+number that arbitrage then acts on. A missing profile is not a zero price, and
+a zero price is exactly the value that makes everything look free.
+"""
+
+import json
+import logging
+import math
+from dataclasses import dataclass
+from datetime import datetime, timedelta, timezone
+
+from .price import (
+    MAX_PLAUSIBLE_EUR_KWH, Absence, PricePoint, PriceProduct, PriceRead,
+    _Outcome, brussels, load_prices, price_option,
+)
+
+_LOG = logging.getLogger("goodwe.tariff.static")
+
+DAY_NAMES = ("mon", "tue", "wed", "thu", "fri", "sat", "sun")
+_DAY_INDEX = {n: i for i, n in enumerate(DAY_NAMES)}      # Mon=0, as weekday()
+_DAY_ALIASES = {
+    "weekday": "mon-fri", "weekdays": "mon-fri", "week": "mon-fri",
+    "weekend": "sat-sun", "weekends": "sat-sun",
+    "all": "mon-sun", "daily": "mon-sun", "every": "mon-sun", "*": "mon-sun",
+}
+
+MINUTES_PER_DAY = 1440
+
+# The mean that `cheap_now()` grades against is taken over this many local days.
+# Seven, so each weekday appears exactly once - see the module docstring. It is
+# a MODULE CONSTANT and not an option on purpose: CFG-03 already tracks three
+# places option defaults live, and this describes the Belgian week rather than
+# the site.
+MEAN_WINDOW_DAYS = 7
+
+# The only timezone a `static_profile` may name. See the docstring: there is no
+# tz database in the shipped image, so anything else cannot be honoured and is
+# refused rather than silently treated as Brussels.
+SUPPORTED_TZ = ("europe/brussels", "cet", "cest", "")
+
+
+class ProfileInvalid(Exception):
+    """A `static_profile` that cannot be turned into a tariff.
+
+    Refused at startup by validate.py. Carries a message naming the key and the
+    fix, because the operator who typed it is the only one who can repair it.
+    """
+
+
+# --------------------------------------------------------------------------- #
+# Parsing
+# --------------------------------------------------------------------------- #
+
+def _minutes(value, field: str) -> int:
+    """"HH:MM" -> minutes past local midnight. `to: "24:00"` means end-of-day."""
+    text = str(value).strip()
+    if not text:
+        raise ProfileInvalid(f"{field} is empty; write it as \"HH:MM\", e.g. "
+                             f"\"07:00\"")
+    parts = text.split(":")
+    if len(parts) != 2:
+        raise ProfileInvalid(
+            f"{field} is {value!r}; it must be \"HH:MM\" local Belgian time, "
+            f"e.g. \"22:00\". A bare hour or a decimal is refused rather than "
+            f"guessed at - 7.5 could be 07:30 or 07:50.")
+    try:
+        h, m = int(parts[0]), int(parts[1])
+    except ValueError:
+        raise ProfileInvalid(f"{field} is {value!r}; \"HH:MM\" needs two "
+                             f"integers, e.g. \"07:00\"")
+    if not (0 <= m < 60) or not (0 <= h <= 24) or (h == 24 and m != 0):
+        raise ProfileInvalid(
+            f"{field} is {value!r}, which is not a time of day. Hours run 0-23, "
+            f"minutes 0-59; \"24:00\" is accepted only as an END meaning "
+            f"midnight at the end of the day.")
+    return h * 60 + m
+
+
+def _days(value, field: str) -> frozenset:
+    """A day selector -> a frozenset of weekday() indices. Mon=0 .. Sun=6.
+
+    Accepts a list (`["mon", "tue"]`), a comma list (`"sat,sun"`), a range
+    (`"mon-fri"`), the aliases in `_DAY_ALIASES`, and any mixture.
+    """
+    if value is None:
+        raise ProfileInvalid(
+            f"{field} is missing. Name the days this period applies to - "
+            f"\"mon-fri\", \"sat,sun\" or \"all\". It is required rather than "
+            f"defaulted to every day, because a Belgian night tariff that "
+            f"silently covered the weekend too would misprice 48 h a week with "
+            f"nothing reporting it.")
+    tokens = []
+    if isinstance(value, (list, tuple)):
+        for item in value:
+            tokens.extend(str(item).strip().lower().split(","))
+    else:
+        tokens.extend(str(value).strip().lower().split(","))
+
+    out = set()
+    for token in tokens:
+        token = _DAY_ALIASES.get(token.strip(), token.strip())
+        if not token:
+            continue
+        if "-" in token:
+            a, _, b = token.partition("-")
+            a, b = a.strip(), b.strip()
+            if a not in _DAY_INDEX or b not in _DAY_INDEX:
+                raise ProfileInvalid(
+                    f"{field}: {token!r} is not a day range. Days are "
+                    f"{', '.join(DAY_NAMES)}; a range is written \"mon-fri\".")
+            i, j = _DAY_INDEX[a], _DAY_INDEX[b]
+            # A range may wrap (`fri-mon`), because a Belgian weekend tariff is
+            # often written that way.
+            out.update((i + k) % 7 for k in range((j - i) % 7 + 1))
+        else:
+            if token not in _DAY_INDEX:
+                raise ProfileInvalid(
+                    f"{field}: {token!r} is not a day. Use "
+                    f"{', '.join(DAY_NAMES)}, a range like \"mon-fri\", or one "
+                    f"of {', '.join(sorted(_DAY_ALIASES))}.")
+            out.add(_DAY_INDEX[token])
+    if not out:
+        raise ProfileInvalid(f"{field} selected no days at all")
+    return frozenset(out)
+
+
+def _price(value, field: str) -> float:
+    """The all-in EUR/kWh for a period, bounded exactly as price.py bounds a feed."""
+    if value is None:
+        raise ProfileInvalid(
+            f"{field} is missing. Every period needs an all-in eur_per_kwh "
+            f"(energy + supplier markup + taxes, §9.3) - the same basis the "
+            f"dynamic providers are assembled onto, so the two are comparable.")
+    if isinstance(value, bool) or not isinstance(value, (int, float, str)):
+        raise ProfileInvalid(f"{field} is {value!r}, which is not a number")
+    try:
+        out = float(value)
+    except (TypeError, ValueError):
+        raise ProfileInvalid(f"{field} is {value!r}, which is not a number")
+    if not math.isfinite(out):
+        raise ProfileInvalid(f"{field} is {value!r}, which is not finite")
+    if abs(out) > MAX_PLAUSIBLE_EUR_KWH:
+        raise ProfileInvalid(
+            f"{field} is {out} EUR/kWh, beyond +-{MAX_PLAUSIBLE_EUR_KWH}. The "
+            f"usual cause is a figure in cents or in EUR/MWh - 34 instead of "
+            f"0.34 - which would make every hour look like an emergency. Same "
+            f"bound the fetched feeds are held to (price.py `_validate_raw`).")
+    return out
+
+
+@dataclass(frozen=True)
+class Period:
+    """One priced window of the local week. Half-open [start, end) on the clock.
+
+    `end <= start` means the window wraps past local midnight (22:00-07:00), and
+    `days` selects the day THE CLOCK READS, not the day the window opened - see
+    the module docstring.
+    """
+
+    name: str
+    start_min: int
+    end_min: int
+    days: frozenset
+    eur_per_kwh: float
+
+    @property
+    def wraps(self) -> bool:
+        return self.end_min <= self.start_min
+
+    def covers(self, weekday: int, minute: int) -> bool:
+        if weekday not in self.days:
+            return False
+        if not self.wraps:
+            return self.start_min <= minute < self.end_min
+        return minute >= self.start_min or minute < self.end_min
+
+    @property
+    def words(self) -> str:
+        def hhmm(m):
+            return f"{m // 60:02d}:{m % 60:02d}"
+        days = ",".join(DAY_NAMES[d] for d in sorted(self.days))
+        return (f"{self.name} {hhmm(self.start_min)}-"
+                f"{hhmm(self.end_min if self.end_min else MINUTES_PER_DAY)} "
+                f"{days} @ {self.eur_per_kwh:.4f}")
+
+
+class StaticProfile:
+    """A validated two-or-more-period tariff. Immutable, pure, I/O-free."""
+
+    def __init__(self, periods):
+        self.periods = tuple(periods)
+        if not self.periods:
+            raise ProfileInvalid(
+                "static_profile has no periods. A profile with no periods is "
+                "not a fixed tariff, it is an absent one - leave the option "
+                "empty to say that on purpose (§11.4 then applies).")
+        _check_tiling(self.periods)
+
+    # -- what kind of tariff this is, DERIVED --------------------------------
+    @property
+    def prices(self) -> tuple:
+        return tuple(p.eur_per_kwh for p in self.periods)
+
+    @property
+    def product(self) -> PriceProduct:
+        """§9.2's product, derived from the DATA rather than declared.
+
+        One distinct price across every period is a fully-fixed tariff whatever
+        the operator called the rows; two or more is a static profile. Nobody
+        has to tick a "this is fixed" box and nobody can tick it wrongly.
+        """
+        return (PriceProduct.FIXED if len(set(self.prices)) == 1
+                else PriceProduct.STATIC)
+
+    # -- lookups -------------------------------------------------------------
+    def at(self, instant: datetime) -> Period:
+        """The period covering an INSTANT. Tiling makes this total."""
+        local = brussels(instant)
+        minute = local.hour * 60 + local.minute
+        for p in self.periods:
+            if p.covers(local.weekday(), minute):
+                return p
+        # Unreachable given _check_tiling, and it stays an exception rather than
+        # a default for the reason the module docstring gives.
+        raise Absence(
+            f"no period covers {local.isoformat()} - the tiling check that "
+            f"makes this impossible has been weakened")
+
+    def price_at(self, instant: datetime) -> float:
+        return self.at(instant).eur_per_kwh
+
+    def next_change(self, instant: datetime, *, limit_days: int = 8):
+        """The next instant at which the period NAME changes, or None.
+
+        Coarse 15-minute scan to bracket the change, then a 1-minute refine, so
+        this is ~800 lookups rather than ~11,500. Returns UTC.
+        """
+        u = instant.astimezone(timezone.utc).replace(second=0, microsecond=0)
+        # ⚠️ KEYED ON (name, price), NOT ON THE NAME. Two rows may legitimately
+        # share a name - a Belgian night tariff is often written as a weekday
+        # row and a weekend row both called "night" - and the tariff has not
+        # changed when the clock crosses between them. But two rows with one
+        # name and DIFFERENT prices is a change an operator must see, and a
+        # name-only comparison would report the next change as never.
+        here = self._key(u)
+        coarse = timedelta(minutes=15)
+        end = u + timedelta(days=limit_days)
+        probe = u
+        while probe < end:
+            probe += coarse
+            if self._key(probe) != here:
+                fine = probe - coarse
+                while fine < probe:
+                    fine += timedelta(minutes=1)
+                    if self._key(fine) != here:
+                        return fine
+                return probe
+        return None
+
+    def _key(self, instant):
+        p = self.at(instant)
+        return (p.name, p.eur_per_kwh)
+
+    # -- the canonical series ------------------------------------------------
+    def series(self, since: datetime, until: datetime, *,
+               provisional: bool) -> list:
+        """Hourly `PricePoint`s over [since, until), in §9.3's canonical shape.
+
+        ⚠️ ITERATES IN UTC. That is what makes a spring-forward day 23 points and
+        an autumn-back day 25 without anything here knowing the dates.
+        """
+        a = since.astimezone(timezone.utc).replace(minute=0, second=0,
+                                                   microsecond=0)
+        b = until.astimezone(timezone.utc)
+        out = []
+        u = a
+        while u < b:
+            out.append(PricePoint(start=brussels(u),
+                                  eur_per_kwh=round(self.price_at(u), 6),
+                                  provisional=bool(provisional)))
+            u += timedelta(hours=1)
+        if not out:
+            raise ProfileInvalid(
+                f"static_profile.series({since.isoformat()}, "
+                f"{until.isoformat()}) spans no whole hour. An empty series is "
+                f"not constructible downstream on purpose (price.py trap 3).")
+        return out
+
+    @property
+    def words(self) -> str:
+        kind = ("fully fixed" if self.product is PriceProduct.FIXED
+                else f"static, {len(set(self.prices))} price levels")
+        return f"{kind}: " + "; ".join(p.words for p in self.periods)
+
+
+def _check_tiling(periods) -> None:
+    """Every day type must be covered by EXACTLY ONE period, every minute.
+
+    ⚠️ REFUSES BOTH DIRECTIONS. A gap means an hour with no price, and the only
+    way to serve it is to invent one. An overlap means two prices for one hour
+    and a silent winner decided by list order - the "two writers, one of which
+    quietly wins" shape validate.py exists to refuse.
+    """
+    for weekday in range(7):
+        gap_from = over_from = None
+        for minute in range(MINUTES_PER_DAY):
+            n = sum(1 for p in periods if p.covers(weekday, minute))
+            if n == 0 and gap_from is None:
+                gap_from = minute
+            if n > 1 and over_from is None:
+                over_from = (minute, n)
+            if n != 0 and gap_from is not None:
+                _raise_gap(weekday, gap_from, minute)
+            if n <= 1 and over_from is not None:
+                _raise_overlap(weekday, over_from, minute, periods)
+        if gap_from is not None:
+            _raise_gap(weekday, gap_from, MINUTES_PER_DAY)
+        if over_from is not None:
+            _raise_overlap(weekday, over_from, MINUTES_PER_DAY, periods)
+
+
+def _hhmm(m):
+    return f"{m // 60:02d}:{m % 60:02d}"
+
+
+def _raise_gap(weekday, start, end):
+    raise ProfileInvalid(
+        f"static_profile leaves {DAY_NAMES[weekday]} "
+        f"{_hhmm(start)}-{_hhmm(end)} with no period, so those hours have no "
+        f"price. Refused rather than defaulted: an invented price is one an "
+        f"optimiser would trade on, and §11.4 already says what a missing price "
+        f"means. Add a period covering it - remember a window written "
+        f"\"22:00-07:00 mon-fri\" does NOT cover Saturday morning.")
+
+
+def _raise_overlap(weekday, over, end, periods):
+    start, n = over
+    names = [p.name for p in periods if p.covers(weekday, start)]
+    raise ProfileInvalid(
+        f"static_profile gives {DAY_NAMES[weekday]} {_hhmm(start)}-"
+        f"{_hhmm(end)} {n} prices at once ({', '.join(names)}). Two prices for "
+        f"one hour means one of them silently wins on list order. Narrow one of "
+        f"the windows or split the day selector.")
+
+
+def parse_static_profile(value):
+    """`static_profile` -> a `StaticProfile`, or None when unset.
+
+    Accepts what the option can actually arrive as:
+      * `None` / `""` / `"null"`      - unset. §14 ships `static_profile: null`.
+      * a JSON string                 - what config.yaml's flat `str?` option
+                                        carries on a Supervisor install.
+      * a dict `{"periods": [...]}`   - already-parsed, from /data/options.json
+                                        under a future nested schema, from
+                                        sim/inject.py, or from a check.
+      * a bare list of period dicts   - the same thing without the wrapper.
+
+    Raises `ProfileInvalid`; never returns a half-built profile.
+    """
+    if value is None:
+        return None
+    if isinstance(value, str):
+        text = value.strip()
+        if not text or text.lower() in ("null", "none", "off"):
+            return None
+        try:
+            value = json.loads(text)
+        except ValueError as e:
+            raise ProfileInvalid(
+                f"static_profile is not valid JSON ({e}). It is a JSON object "
+                f"with a \"periods\" list, on one line, e.g.\n"
+                f'  {{"periods": [{{"name":"day","from":"07:00","to":"22:00",'
+                f'"days":"mon-fri","eur_per_kwh":0.34}}, ...]}}\n'
+                f"Leave it empty for a dynamic-only or price-free site.")
+
+    if isinstance(value, dict):
+        tz = str(value.get("timezone", "") or "").strip().lower()
+        if tz not in SUPPORTED_TZ:
+            raise ProfileInvalid(
+                f"static_profile.timezone is {value.get('timezone')!r}. Only "
+                f"Europe/Brussels is supported: the shipped image carries no tz "
+                f"database (see app/price.py), so any other zone could not be "
+                f"honoured and would be silently treated as Brussels - which is "
+                f"wrong by an hour for part of the year.")
+        rows = value.get("periods")
+        if rows is None:
+            raise ProfileInvalid(
+                "static_profile has no \"periods\" list. Even a fully-fixed "
+                "tariff is written as one period covering 00:00-24:00 all days "
+                "- one shape for both products, so nothing downstream branches "
+                "on which kind of site this is.")
+    else:
+        rows = value
+
+    if not isinstance(rows, (list, tuple)):
+        raise ProfileInvalid(
+            f"static_profile.periods is {type(rows).__name__}, not a list")
+
+    periods = []
+    for i, row in enumerate(rows, start=1):
+        if not isinstance(row, dict):
+            raise ProfileInvalid(
+                f"static_profile.periods[{i}] is {type(row).__name__}, not an "
+                f"object with from/to/days/eur_per_kwh")
+        where = f"static_profile.periods[{i}]"
+        name = str(row.get("name", "") or f"period{i}").strip() or f"period{i}"
+        start = _minutes(row.get("from", row.get("start")), f"{where}.from")
+        end = _minutes(row.get("to", row.get("end")), f"{where}.to")
+        if end == 0:
+            end = MINUTES_PER_DAY          # "00:00" as an END is end-of-day
+        if start == end:
+            raise ProfileInvalid(
+                f"{where} runs {_hhmm(start)}-{_hhmm(end)}, which is either "
+                f"zero minutes or the whole day and there is no way to tell "
+                f"which was meant. Write a full day as 00:00-24:00.")
+        if start == MINUTES_PER_DAY:
+            raise ProfileInvalid(
+                f"{where}.from is \"24:00\"; a period cannot START at "
+                f"end-of-day. Did you mean \"00:00\"?")
+        periods.append(Period(name=name, start_min=start,
+                              end_min=end,
+                              days=_days(row.get("days"), f"{where}.days"),
+                              eur_per_kwh=_price(row.get("eur_per_kwh"),
+                                                 f"{where}.eur_per_kwh")))
+    return StaticProfile(periods)
+
+
+# --------------------------------------------------------------------------- #
+# The arbitrage verdict. A variant type, because a boolean is a suggestion.
+# --------------------------------------------------------------------------- #
+
+class Arbitrage(_Outcome):
+    """May an optimiser trade on this tariff, and with what numbers.
+
+      * `allowed` - carries `.spread_eur_kwh`, `.cheapest`, `.dearest`,
+                    `.regime`, `.product`. These are the ONLY inputs an
+                    arbitrage strategy needs, and they exist here and nowhere
+                    else.
+      * `refused` - carries `.reason`. Nothing else. `.spread_eur_kwh` on a
+                    refusal raises `Absence`.
+
+    ⚠️ NO `__bool__`, for price.py's reason: `if verdict:` must not look like a
+    guard while being none. Use `.match(allowed=..., refused=...)`, both
+    handlers required, so the refusal cannot be fallen through.
+    """
+
+    def match(self, *, allowed, refused):
+        return {"allowed": allowed, "refused": refused}[self.kind](self)
+
+    @staticmethod
+    def allow(spread, cheapest, dearest, regime, product):
+        return _Allowed(spread, cheapest, dearest, regime, product)
+
+    @staticmethod
+    def refuse(reason):
+        if not reason or not isinstance(reason, str):
+            raise ValueError(
+                "Arbitrage.refuse() takes a reason a human can act on - §10.2 "
+                "requires every plan change to carry one, and 'arbitrage did "
+                "nothing' with no reason is indistinguishable from a bug.")
+        return _Refused(reason)
+
+
+class _Allowed(Arbitrage):
+    kind = "allowed"
+
+    def __init__(self, spread, cheapest, dearest, regime, product):
+        self.spread_eur_kwh = spread
+        self.cheapest = cheapest          # the PricePoint at the low end
+        self.dearest = dearest            # the PricePoint at the high end
+        self.regime = regime              # §8.3 "wide" | "normal"
+        self.product = product
+        self.words = (f"spread {spread:.4f} EUR/kWh over "
+                      f"{product.value} ({regime} thresholds)")
+
+
+class _Refused(Arbitrage):
+    kind = "refused"
+
+    def __init__(self, reason):
+        self.reason = reason
+        self.words = f"no arbitrage - {reason}"
+
+
+# --------------------------------------------------------------------------- #
+# The plan: one tariff, whatever produced it
+# --------------------------------------------------------------------------- #
+
+class TariffPlan:
+    """What this site's tariff looks like right now, and what may be done on it.
+
+    `origin` is how the series was obtained, and it is NOT the same question as
+    `product`:
+
+        "provider"  a live feed (§9.2 rows 1-2)
+        "static"    the CONFIGURED static_profile (§9.2 rows 3-4)
+        "fallback"  the static_profile standing in for a dead feed (§11.4) -
+                    identical data, `provisional=True`, arbitrage refused
+        "none"      no feed and no profile. §6: the loop keeps regulating.
+    """
+
+    def __init__(self, read: PriceRead, profile, origin: str):
+        self.read = read
+        self.profile = profile
+        self.origin = origin
+
+    # -- derived facts -------------------------------------------------------
+    @property
+    def has_prices(self) -> bool:
+        return self.read.match(series=lambda _r: True, no_data=lambda _r: False)
+
+    @property
+    def product(self):
+        return self.read.match(series=lambda r: r.product,
+                               no_data=lambda _r: None)
+
+    @property
+    def provisional(self) -> bool:
+        """§8.3/§11.4, derived from the points rather than asserted."""
+        return self.read.match(
+            series=lambda r: any(p.provisional for p in r.points),
+            no_data=lambda _r: True)
+
+    def price_at(self, instant: datetime) -> float:
+        """EUR/kWh now. Raises `Absence` when there is no price - never 0.0."""
+        return self.read.match(
+            series=lambda r: r.at(instant).eur_per_kwh,
+            no_data=lambda r: _absent(r.reason))
+
+    def window_at(self, instant: datetime) -> str:
+        """The name of the tariff window now (`day`, `night`, ...).
+
+        Only a static profile has named windows; a day-ahead series does not,
+        and inventing one would be a label with no referent.
+        """
+        if self.profile is None:
+            raise Absence(
+                "this plan has no static_profile, so it has no named tariff "
+                "window. Time-window shifting (§9.2) is a static-profile "
+                "behaviour; a day-ahead series is shifted against prices, not "
+                "against window names.")
+        return self.profile.at(instant).name
+
+    def mean_eur_kwh(self) -> float:
+        return self.read.match(
+            series=lambda r: sum(p.eur_per_kwh for p in r.points) / len(r.points),
+            no_data=lambda r: _absent(r.reason))
+
+    def spread_eur_kwh(self) -> float:
+        return self.read.match(
+            series=lambda r: (max(p.eur_per_kwh for p in r.points)
+                              - min(p.eur_per_kwh for p in r.points)),
+            no_data=lambda r: _absent(r.reason))
+
+    # -- the two things a consumer is allowed to act on ----------------------
+    def cheap_now(self, instant: datetime) -> bool:
+        """Is now a cheap window? STRICTLY below the mean - see the docstring.
+
+        False on a provisional plan: §8.3 forbids an irreversible action on a
+        provisional price, and a grid top-up of a battery is about as
+        irreversible as this add-on gets. False when there is no price at all,
+        which is the §11.4 row and also main.py's long-standing "fixed-tariff
+        site: never force a paid grid top-up, wait for sun".
+        """
+        if not self.has_prices or self.provisional:
+            return False
+        try:
+            return self.price_at(instant) < self.mean_eur_kwh()
+        except Absence:
+            # An instant outside the series is an hour with no price (§11.4 for
+            # that hour), not a cheap one.
+            return False
+
+    def arbitrage(self, *, peak_guard_active: bool) -> Arbitrage:
+        """May OPT-04 trade, and on what numbers. See the module docstring.
+
+        ⚠️ `peak_guard_active` IS REQUIRED AND KEYWORD-ONLY. §9.1/§10.1 put peak
+        shaving above arbitrage, and this is how that ordering survives a
+        strategy that has not been written yet: the spread is not obtainable
+        without answering the question.
+        """
+        if not isinstance(peak_guard_active, bool):
+            raise TypeError(
+                f"peak_guard_active must be a bool, not {peak_guard_active!r}. "
+                f"A truthy 'unknown' is how §10.1's priority 2 gets skipped.")
+        if peak_guard_active:
+            return Arbitrage.refuse(
+                "the capacity-tariff peak guard is holding, and §10.1 puts peak "
+                "shaving (priority 2) above price arbitrage (priority 3) - the "
+                "capaciteitstarief is a network cost charged whatever the "
+                "energy product is (§9.1)")
+        if not self.has_prices:
+            return Arbitrage.refuse(
+                f"§11.4: {self.read.reason}. No series exists, so no spread "
+                f"exists; self-consumption, peak shaving and reserve management "
+                f"(§10.1 priorities 1, 2 and 4) are unaffected")
+        if self.provisional:
+            return Arbitrage.refuse(
+                f"§11.4: the plan is provisional (origin {self.origin!r}), and "
+                f"§8.3 forbids an irreversible action on a provisional price. "
+                f"Load shifting and peak shaving continue")
+        spread = self.spread_eur_kwh()
+        if spread == 0.0:
+            return Arbitrage.refuse(
+                f"the tariff is flat - every one of the "
+                f"{len(self.read.points)} hours costs "
+                f"{self.read.points[0].eur_per_kwh:.4f} EUR/kWh, so buying low "
+                f"and selling high is arithmetically impossible. §9.2: a fully "
+                f"fixed product is self-consumption only")
+        pts = self.read.points
+        return Arbitrage.allow(
+            spread=spread,
+            cheapest=min(pts, key=lambda p: p.eur_per_kwh),
+            dearest=max(pts, key=lambda p: p.eur_per_kwh),
+            regime=self.read.regime,
+            product=self.read.product)
+
+    @property
+    def words(self) -> str:
+        if not self.has_prices:
+            return f"no tariff - {self.read.reason}"
+        tag = {"provider": self.read.provider, "static": "static_profile",
+               "fallback": "static_profile (feed down)"}.get(self.origin,
+                                                             self.origin)
+        return (f"{self.product.value} from {tag}, {len(self.read.points)} h"
+                + (", provisional" if self.provisional else ""))
+
+
+def _absent(reason):
+    raise Absence(
+        f"this plan observed no prices ({reason}). A number invented here is "
+        f"the bug price.py's _NoData exists to prevent - 'no data' becoming "
+        f"'free'. Ask has_prices, or use read.match(...).")
+
+
+# --------------------------------------------------------------------------- #
+# The two entry points
+# --------------------------------------------------------------------------- #
+
+def static_plan(opts: dict, since: datetime, until: datetime, *,
+                provisional: bool = False, now=None) -> TariffPlan:
+    """The static-profile plan. PURE, I/O-FREE, no network, no tz database.
+
+    This is what main.py calls on the planning tick. It is synchronous on
+    purpose: `load_prices()` may perform an HTTP fetch, and a fetch on the tick
+    that feeds the ESP32 heartbeat is a supplier's TLS timeout able to stall the
+    heartbeat towards layer 1's 30 s veto. Generation is pure, so §2.3 says
+    regenerate every tick rather than cache, and there is nothing here that can
+    block.
+    """
+    profile = parse_static_profile(price_option(opts, "static_profile"))
+    if profile is None:
+        return TariffPlan(
+            PriceRead.no_data(
+                "no static_profile configured; §11.4: plan provisional, no "
+                "arbitrage. Self-consumption, peak shaving and reserve "
+                "management are unaffected"),
+            None, "none")
+    points = profile.series(since, until, provisional=provisional)
+    return TariffPlan(
+        PriceRead.series(points, profile.product, "static_profile",
+                         now or datetime.now(timezone.utc)),
+        profile, "fallback" if provisional else "static")
+
+
+def static_status(opts: dict, now: datetime):
+    """(cheap, words) for the status page and for main.py's cheap-window flag.
+
+    Never raises: a `static_profile` that does not parse is refused at STARTUP
+    by validate.py, so reaching this with a broken one means somebody handed the
+    controller a dict the validator never saw. That is worth a warning and a
+    "no cheap window", not a controller that stops regulating a battery (§6:
+    absent machinery must not disable the loop).
+    """
+    try:
+        plan = static_plan(opts, now, now + timedelta(days=MEAN_WINDOW_DAYS),
+                           now=now)
+    except ProfileInvalid as e:
+        _LOG.warning("static_profile is unusable (%s); no cheap window. This "
+                     "should have been refused at startup - see validate.py", e)
+        return False, f"static_profile unusable: {e}"
+    if not plan.has_prices:
+        return False, "no static profile"
+    cheap = plan.cheap_now(now)
+    window = plan.window_at(now)
+    price = plan.price_at(now)
+    when = plan.profile.next_change(now)
+    until = "" if when is None else f" until {brussels(when):%H:%M}"
+    kind = ("fixed" if plan.product is PriceProduct.FIXED else "day/night")
+    return cheap, (f"{kind}: {window}{until} at {price:.4f} EUR/kWh, "
+                   f"mean {plan.mean_eur_kwh():.4f} over "
+                   f"{MEAN_WINDOW_DAYS} d - "
+                   f"{'CHEAP window' if cheap else 'not a cheap window'}")
+
+
+async def resolve_tariff(opts: dict, since: datetime, until: datetime,
+                         transport=None, now=None) -> TariffPlan:
+    """The full §9.2 + §11.4 resolution. MAY PERFORM I/O - see `static_plan`.
+
+    ⚠️ NOT ON THE 30 s TICK, and that is a deliberate boundary rather than an
+    omission. Wiring a provider-backed plan into the control loop needs a
+    BACKGROUND refresh (a day-ahead feed publishes once a day; polling it every
+    30 s would be rude and would put a network timeout on the heartbeat path).
+    That task belongs with the first strategy that actually trades - OPT-04 -
+    and this function is the seam it consumes. Everything below it is exercised
+    by test_static_tariff.py today.
+
+      price_provider off  + profile  -> the CONFIGURED product (§9.2 rows 3-4)
+      price_provider off  + none     -> no prices at all (§11.4, nothing to
+                                        fall back to)
+      provider series                -> the feed (§9.2 rows 1-2)
+      provider no_data    + profile  -> §11.4 FALLBACK, provisional, no arbitrage
+      provider no_data    + none     -> no prices at all
+    """
+    stamp = now or datetime.now(timezone.utc)
+    pid = str(price_option(opts, "price_provider") or "off").strip()
+    if pid in ("", "off"):
+        return static_plan(opts, since, until, provisional=False, now=stamp)
+
+    read = await load_prices(opts, since, until, transport)
+    return read.match(
+        series=lambda r: TariffPlan(r, _quiet_profile(opts), "provider"),
+        no_data=lambda r: _degrade(opts, r, since, until, stamp))
+
+
+def _quiet_profile(opts):
+    """The profile, for window naming, without letting a bad one break a good feed."""
+    try:
+        return parse_static_profile(price_option(opts, "static_profile"))
+    except ProfileInvalid:
+        return None
+
+
+def _degrade(opts, read, since, until, stamp) -> TariffPlan:
+    """§11.4: fall back to the static profile, mark provisional, no arbitrage."""
+    try:
+        profile = parse_static_profile(price_option(opts, "static_profile"))
+    except ProfileInvalid as e:
+        _LOG.warning("the price feed is down AND static_profile is unusable "
+                     "(%s), so there is no tariff at all", e)
+        profile = None
+    if profile is None:
+        _LOG.warning("§11.4: %s, and no static_profile is configured to fall "
+                     "back to. The plan is provisional and arbitrage is off; "
+                     "self-consumption, peak shaving and reserve management "
+                     "continue (§6, §10.1).", read.reason)
+        return TariffPlan(read, None, "none")
+    _LOG.warning("§11.4: %s - falling back to the static profile, plan marked "
+                 "PROVISIONAL, arbitrage off.", read.reason)
+    points = profile.series(since, until, provisional=True)
+    return TariffPlan(
+        PriceRead.series(points, profile.product, "static_profile", stamp),
+        profile, "fallback")

goodwe_controller/app/tariff.py

@@ -0,0 +1,682 @@
+"""TARIFF-01 - the monthly capacity-tariff peak, and the record that outlives it.
+
+WHAT THIS IS, AND WHAT IT DELIBERATELY IS NOT. This module is an INSTRUMENT. It
+measures the number the Belgian capaciteitstarief bills on - the highest
+15-minute average offtake of the calendar month (Fluvius / Resa / Ores) - and it
+writes that number down somewhere a restart cannot reach. It makes no claim,
+applies no clamp, and commands nothing. The guard that will read it is SAFETY-07,
+and it belongs in `arbiter.py` as a `P_PEAK` claim when it is built. Keeping the
+measurement and the actuation apart is the whole reason this file is small.
+
+WHAT WAS ALREADY BUILT, AND WHY THIS CARD IS NOT 8 SP OF NEW ARITHMETIC.
+`p1.QuarterAverager` already computes AC 1 in full: clock-aligned 900 s blocks,
+time-weighted over irregular telegram spacing, offtake-only, per-phase, with a
+`max_hold_s` gap rule. It was unwired and unpersisted - `P1Ingest.blocks` is a
+96-entry list in memory that a restart erases. So this file is the persistence
+and the monthly reduction, not a second accumulator. Adding one would be adding
+a second source of truth for the exact quantity the money depends on.
+
+  BLOCKS, NOT A SLIDING WINDOW.  The Description says "rolling"; AC 1 says
+  "15-min block average". They are different numbers and the utility bills the
+  second one. §9.1 calls the billed unit the "highest 15-minute average offtake",
+  and §9.1's own worked case - "one 4998 W quarter moved a monthly peak from
+  4832 -> 5013 W" - is stated per QUARTER, an object a sliding window does not
+  have. "Rolling" here means CONTINUOUSLY UPDATED (the open block's partial
+  average is readable at every sample), not a trailing-15-minutes window. A
+  trailing window would report a peak the meter never bills, and it reports it
+  HIGHER than the real one: a load burst straddling :15 fills a trailing window
+  completely while contributing to two block averages at partial weight. Guarding
+  that would spend battery defending an interval nobody charges for.
+
+  DELIVERED POWER, NOT INTENDED POWER.  SAFETY-20 has an open question about
+  whether guards should grade `Decision.target` (pre-clamp intent) or `standing`
+  (what actually reached the wire). For a capacity tariff there is no question to
+  ask: the utility's meter integrates the current that flowed. This module never
+  sees a setpoint at all - it consumes `P1Sample`, which is the meter's own
+  reading - and that is on purpose. A peak computed from intent would be wrong in
+  the expensive direction (a clamped 9 kW request that delivered 5 kW would
+  record 9 kW, and every consumer would shave against a peak that never existed).
+
+  AN UNREADABLE STORE IS NOT A ZERO PEAK.  This is the defect this repo spent a
+  day removing from `sim/riglock.py`, where `holder()` was rewritten to answer
+  `observed / not_observed / gone` instead of a partial dict every caller
+  `.get()`s a default out of. The same trap is here and it is worse, because the
+  degenerate value is not merely wrong, it is DISARMING: a peak read as 0 W gives
+  SAFETY-07 the maximum possible headroom and silently switches the guard off at
+  the moment its own storage is broken. So `peak()` returns a `PeakReading` whose
+  `state` is one of OBSERVED / NO_RECORD / NOT_OBSERVED, `peak_w` is `None`
+  unless the state is OBSERVED, and there is no `.get(..., 0)` shaped accessor
+  anywhere on it. NO_RECORD ("this month has no completed block yet", a normal
+  state on the 1st) and NOT_OBSERVED ("the database did not answer") are
+  different types of thing and are never spelled the same way.
+
+CONFIG: NONE ADDED, ON PURPOSE.  CFG-03 is open because the option defaults
+already live in three places held apart by a tripwire in `test_validate.py`. The
+soft limit this measurement is graded against already exists as `peak_cap_w`
+(config.yaml, default 3500), already validated, already read by
+`control.peak_at_risk()`. §14 names a `tariffs.capacity_peak_limit_kw: 2.5` - in
+KILOwatts, against watts everywhere else - and adding it would have made a fourth
+defaults site AND imported the unit mismatch §14's own warning box says must be
+caught at startup. So this module takes its limit as a plain constructor
+argument in WATTS and config.yaml is untouched by this ticket.
+
+THE DATABASE. SQLite in /data, the add-on's only durable volume, alongside
+`store.py`'s state.json. Two tiers from §15, and their retention is the point:
+
+  quarter_blocks   one row per completed 900 s block   INDEFINITE
+  monthly_peak     one row per calendar month          PERMANENT
+
+Neither is ever pruned here, and no sweep in this file can prune them - there is
+no DELETE statement against either table anywhere in this module. §15's asymmetry
+is why: raw samples vanish after 7 days, so a 15-minute aggregate that was not
+written AS IT HAPPENED can never be recomputed. `monthly_peak` is maintained as a
+derived record - upserted on every block close, and `recompute_month()` re-derives
+it from `quarter_blocks` so the two can be PROVEN not to have diverged rather
+than assumed not to have.
+
+RESTART MID-BLOCK. The open block's accumulator is memory. A restart at minute 12
+that dropped it would under-read the rest of the quarter, and SAFETY-07's clamp
+would release exactly when it was most needed. So the accumulator is checkpointed
+(`QuarterAverager.snapshot()`) into a single row, at most `CHECKPOINT_S` stale,
+and restored on startup. Three cases, all of them exercised in `test_tariff.py`:
+
+  * the checkpoint's block is the block containing `now`  -> restore it verbatim,
+    including the held sample's ORIGINAL timestamp, so the first sample after the
+    restart integrates the gap under the same `max_hold_s` rule a running process
+    would have applied. A restart longer than `max_hold_s` therefore leaves
+    uncovered seconds, and a closed block is always divided by the full 900 s, so
+    the gap DRAGS THE BILLED AVERAGE DOWN instead of being averaged away;
+  * the checkpoint's block ended while we were down -> that block really happened
+    and its measured part is real, so it is closed at `acc / 900` and recorded,
+    then a fresh block is opened. Discarding it would lose measured energy;
+  * no checkpoint, or one that cannot be read -> start clean and SAY SO. The
+    return value of `restore()` names which of the three happened; it is never
+    silently the first one.
+
+Double counting is answered structurally rather than by care: `quarter_start` is
+the PRIMARY KEY, and the recorded average may only ever be RAISED by a later
+write (`ON CONFLICT ... WHERE excluded.offtake_avg_w > ...`). Replaying the same
+block twice is therefore a no-op, and a restart that reprocesses a block with
+LESS coverage than the first pass cannot lower a figure already banked.
+
+MONTH BOUNDARY. Calendar months are LOCAL (Europe/Brussels); blocks are stored in
+UTC. In August those differ by two hours, so a block starting 2026-08-31 22:15
+UTC belongs to SEPTEMBER and putting it in August would move a month's bill.
+Block alignment itself needs no timezone - every Belgian offset is a whole number
+of hours, so the 900 s UTC grid lands on :00/:15/:30/:45 local on both sides of a
+DST transition, which is the argument `QuarterAverager` already carries.
+"""
+
+import json
+import logging
+import os
+import sqlite3
+from dataclasses import dataclass
+from datetime import datetime, timedelta, timezone, tzinfo
+
+_LOG = logging.getLogger("goodwe.tariff")
+
+QUARTER_S = 900
+
+# How stale the partial-block checkpoint may be. This is the ONLY thing a crash
+# can lose from an open block, and the loss is bounded and one-directional: the
+# lost seconds were already integrated into `_acc`, so dropping them makes the
+# restored block read LOW, never high. At 15 s against a 900 s block the
+# worst-case under-read of one quarter's average is 15/900 = 1.7 % of that
+# quarter's own offtake - see test_tariff.py, which computes that bound from
+# these two constants rather than quoting it.
+CHECKPOINT_S = 15.0
+
+# -- reading states. Three, and never fewer. -------------------------------- #
+OBSERVED = "observed"          # the store answered and there is a peak
+NO_RECORD = "no_record"        # the store answered and this month has none yet
+NOT_OBSERVED = "not_observed"  # the store did not answer. NOT a zero peak.
+
+
+# --------------------------------------------------------------------------- #
+# local time, without a hard dependency on the tz database
+# --------------------------------------------------------------------------- #
+class _EUTimezone(tzinfo):
+    """Europe/Brussels by the EU harmonised rule, for hosts with no tzdata.
+
+    ⚠️ THIS IS A FALLBACK AND IT IS NOT SILENT. `zoneinfo` is tried first and is
+    what runs on the add-on's container. The fallback exists because the
+    alternative - quietly using UTC when tzdata is missing - misfiles every block
+    in the last two hours of a month into the wrong month's bill, and does it
+    without a symptom. Encoding the rule (CET, CEST from 01:00 UTC on the last
+    Sunday of March to 01:00 UTC on the last Sunday of October) is 20 lines and
+    is checked against zoneinfo, date by date, wherever zoneinfo is available.
+    """
+
+    # The rule, in both frames. `fromutc` is overridden rather than inherited
+    # because the base implementation calls back into `utcoffset` with a
+    # datetime whose tzinfo is self - and the first version of this class
+    # answered that by calling `astimezone`, which calls `utcoffset`, which
+    # recursed until the stack ran out. A tzinfo must answer from the value it
+    # is handed, never by converting it.
+    @staticmethod
+    def _last_sunday(year: int, month: int, hour: int) -> datetime:
+        d = datetime(year, month + 1, 1) - timedelta(days=1)
+        return (d - timedelta(days=(d.weekday() + 1) % 7)).replace(hour=hour)
+
+    def _dst_local(self, naive: datetime) -> bool:
+        """From a LOCAL wall clock: 02:00 CET last Sunday March -> 03:00 CEST
+        last Sunday October. The one ambiguous hour each autumn resolves to
+        standard time, which cannot move a month boundary."""
+        y = naive.year
+        return self._last_sunday(y, 3, 2) <= naive < self._last_sunday(y, 10, 3)
+
+    def _dst_utc(self, naive_utc: datetime) -> bool:
+        """From UTC: both EU transitions happen at 01:00 UTC, everywhere."""
+        y = naive_utc.year
+        return self._last_sunday(y, 3, 1) <= naive_utc < self._last_sunday(y, 10, 1)
+
+    def fromutc(self, dt: datetime) -> datetime:
+        return dt + timedelta(hours=2 if self._dst_utc(dt.replace(tzinfo=None)) else 1)
+
+    def utcoffset(self, dt):
+        if dt is None:
+            return timedelta(hours=1)
+        return timedelta(hours=2 if self._dst_local(dt.replace(tzinfo=None)) else 1)
+
+    def dst(self, dt):
+        if dt is None:
+            return timedelta(0)
+        return timedelta(hours=1 if self._dst_local(dt.replace(tzinfo=None)) else 0)
+
+    def tzname(self, dt):
+        return "CEST" if dt is not None and self._dst_local(dt.replace(tzinfo=None)) else "CET"
+
+
+def _billing_tz():
+    try:
+        from zoneinfo import ZoneInfo
+        tz = ZoneInfo("Europe/Brussels")
+        # Prove it resolves before trusting it: a ZoneInfo built from an empty
+        # tzdata answers, and answering wrongly is the failure being avoided.
+        if datetime(2026, 7, 1, tzinfo=timezone.utc).astimezone(tz).hour == 2:
+            return tz
+        _LOG.warning("zoneinfo Europe/Brussels resolved but gave the wrong "
+                     "summer offset - falling back to the encoded EU rule")
+    except Exception as err:                      # noqa: BLE001 - any failure
+        _LOG.info("no usable tz database (%s) - using the encoded EU rule", err)
+    return _EUTimezone()
+
+
+BILLING_TZ = _billing_tz()
+
+
+def month_key(when: datetime) -> str:
+    """The calendar month a UTC instant is billed in, as 'YYYY-MM' LOCAL time."""
+    if when.tzinfo is None:
+        when = when.replace(tzinfo=timezone.utc)
+    local = when.astimezone(BILLING_TZ)
+    return f"{local.year:04d}-{local.month:02d}"
+
+
+# --------------------------------------------------------------------------- #
+# the per-phase reduction policy - one function, deliberately
+# --------------------------------------------------------------------------- #
+# §9.1 requires the average be computed per-phase-aware, but does NOT say whether
+# the BILLED figure on a three-phase connection is the sum of the phases or the
+# worst single phase. §5.2 requires the per-phase data; nothing states the
+# reduction. So it is one function with one argument, and correcting it later is
+# a one-line change plus a test parameter rather than a change to the
+# accumulator. §17's "Three-phase unbalanced load" scenario is the case that
+# tells the three apart - on a balanced load all three agree, which is exactly
+# why a balanced fixture must not be what this is tested on.
+POLICY_NET = "net"   # default: the connection's net offtake, what the meter bills
+POLICY_SUM = "sum"   # sum of the per-phase offtakes (differs when a phase exports)
+POLICY_MAX = "max"   # the worst single phase
+
+
+def billed_w(block, policy: str = POLICY_NET) -> float:
+    """Reduce one closed block to the single figure the month is billed on."""
+    pp = getattr(block, "per_phase_offtake_avg_w", None)
+    if policy == POLICY_NET or not pp:
+        return float(block.offtake_avg_w)
+    if policy == POLICY_SUM:
+        return float(sum(pp))
+    if policy == POLICY_MAX:
+        return float(max(pp))
+    raise ValueError(f"unknown per-phase reduction policy: {policy!r}")
+
+
+# --------------------------------------------------------------------------- #
+# what a read of the store answers
+# --------------------------------------------------------------------------- #
+@dataclass(frozen=True)
+class PeakReading:
+    """An answer about a month's peak, or an honest refusal to give one.
+
+    ⚠️ There is no `peak_w_or(default)` and there must never be one. Every
+    accessor that lets a caller turn "the database did not answer" into a number
+    re-creates the defect this type exists to remove. Callers ask `is_observed`
+    first, and a caller that forgets gets `None` and a TypeError, which is loud.
+    """
+
+    state: str
+    month: str
+    peak_w: float | None = None
+    quarter_start: datetime | None = None
+    per_phase_w: tuple | None = None
+    detail: str = ""
+
+    @property
+    def is_observed(self) -> bool:
+        return self.state == OBSERVED
+
+    @property
+    def is_unreadable(self) -> bool:
+        return self.state == NOT_OBSERVED
+
+    def explain(self) -> str:
+        if self.state == OBSERVED:
+            at = self.quarter_start.isoformat() if self.quarter_start else "?"
+            return f"{self.month}: peak {self.peak_w:.0f} W, set by the quarter at {at}"
+        if self.state == NO_RECORD:
+            return f"{self.month}: no completed quarter recorded yet"
+        return (f"{self.month}: PEAK UNREADABLE ({self.detail}) - this is NOT a "
+                f"zero peak and must not be used as headroom")
+
+
+# --------------------------------------------------------------------------- #
+# the store
+# --------------------------------------------------------------------------- #
+_SCHEMA = """
+CREATE TABLE IF NOT EXISTS quarter_blocks (
+    quarter_start   TEXT PRIMARY KEY,   -- ISO-8601 UTC, aligned to 900 s
+    month           TEXT NOT NULL,      -- 'YYYY-MM', LOCAL calendar month
+    offtake_avg_w   REAL NOT NULL,
+    per_phase_json  TEXT
+);
+CREATE INDEX IF NOT EXISTS ix_quarter_month ON quarter_blocks(month);
+CREATE TABLE IF NOT EXISTS monthly_peak (
+    month           TEXT PRIMARY KEY,
+    peak_w          REAL NOT NULL,
+    quarter_start   TEXT NOT NULL,
+    per_phase_json  TEXT
+);
+CREATE TABLE IF NOT EXISTS partial_block (
+    id              INTEGER PRIMARY KEY CHECK (id = 1),
+    state_json      TEXT NOT NULL
+);
+"""
+
+
+class PeakStore:
+    """SQLite behind /data. Every read answers with a state, never with a default."""
+
+    def __init__(self, path: str = "/data/tariff.db"):
+        self.path = path
+        self.ok = False
+        self.last_error: str | None = None
+        self._db: sqlite3.Connection | None = None
+        self._open()
+
+    def _open(self) -> None:
+        parent = os.path.dirname(self.path)
+        # ⚠️ THE DIRECTORY IS NOT CREATED. /data is mounted by the Supervisor and
+        # always exists on a real install, so `makedirs` here could only ever
+        # succeed where the durable volume is MISSING - manufacturing a database
+        # on the container's ephemeral layer that looks durable, reads fine, and
+        # is thrown away on the next restart. That is a peak store that silently
+        # forgets, which is worse than one that says it cannot answer.
+        if parent and not os.path.isdir(parent):
+            self.last_error = f"no durable volume at {parent}"
+            # INFO, not ERROR: on a dev host or in a test container there is no
+            # /data and nothing is wrong. A store that OPENED and then broke is
+            # the error case, and it is logged as one below.
+            _LOG.info("no peak store: %s - the monthly peak will read "
+                      "NOT_OBSERVED", self.last_error)
+            return
+        try:
+            self._db = sqlite3.connect(self.path, timeout=5.0,
+                                       check_same_thread=False)
+            # WAL: a power cut mid-write must not leave a torn database that
+            # reads as "no peak this month" - the exact shape of the defect.
+            self._db.execute("PRAGMA journal_mode=WAL")
+            self._db.executescript(_SCHEMA)
+            self._db.commit()
+            self.ok = True
+            self.last_error = None
+        except sqlite3.Error as err:
+            self._db = None
+            self.ok = False
+            self.last_error = str(err)
+            # ⚠️ Deliberately NOT raised. §6's fail-open rule: an aggregation
+            # fault must not stop a controller that is regulating a battery. The
+            # cost of continuing is a peak that reads NOT_OBSERVED, and every
+            # reader is built to treat that as "do not use me", not as 0 W.
+            _LOG.error("peak store unusable at %s (%s) - the monthly peak will "
+                       "read NOT_OBSERVED, which is not a zero peak", self.path, err)
+
+    def close(self) -> None:
+        if self._db is not None:
+            try:
+                self._db.close()
+            finally:
+                self._db = None
+                self.ok = False
+
+    # -- writing ------------------------------------------------------------
+    def record_block(self, block, policy: str = POLICY_NET) -> bool:
+        """Persist one completed block and fold it into its month's peak.
+
+        Both tables move in ONE transaction. A crash between them would leave a
+        banked quarter that the monthly peak does not know about, and the peak is
+        the record the money is read off.
+        """
+        if self._db is None:
+            return False
+        w = billed_w(block, policy)
+        start = block.start.astimezone(timezone.utc).isoformat()
+        month = month_key(block.start)
+        pp = getattr(block, "per_phase_offtake_avg_w", None)
+        pp_json = json.dumps(list(pp)) if pp else None
+        try:
+            with self._db:
+                # A block may only ever be RAISED. A restart that reprocesses a
+                # quarter it had already banked will have LESS coverage than the
+                # first pass (its first seconds are gone), so an unconditional
+                # REPLACE would silently lower a recorded figure.
+                self._db.execute(
+                    "INSERT INTO quarter_blocks(quarter_start, month, offtake_avg_w, per_phase_json)"
+                    " VALUES(?,?,?,?)"
+                    " ON CONFLICT(quarter_start) DO UPDATE SET"
+                    "   offtake_avg_w=excluded.offtake_avg_w,"
+                    "   per_phase_json=excluded.per_phase_json"
+                    " WHERE excluded.offtake_avg_w > quarter_blocks.offtake_avg_w",
+                    (start, month, w, pp_json))
+                self._db.execute(
+                    "INSERT INTO monthly_peak(month, peak_w, quarter_start, per_phase_json)"
+                    " VALUES(?,?,?,?)"
+                    " ON CONFLICT(month) DO UPDATE SET"
+                    "   peak_w=excluded.peak_w,"
+                    "   quarter_start=excluded.quarter_start,"
+                    "   per_phase_json=excluded.per_phase_json"
+                    " WHERE excluded.peak_w > monthly_peak.peak_w",
+                    (month, w, start, pp_json))
+            return True
+        except sqlite3.Error as err:
+            self.last_error = str(err)
+            _LOG.error("could not record quarter %s (%s)", start, err)
+            return False
+
+    # -- reading ------------------------------------------------------------
+    def peak(self, when: datetime | None = None, month: str | None = None) -> PeakReading:
+        """The billed peak for a month. Three possible answers, never a default."""
+        if month is None:
+            month = month_key(when or datetime.now(timezone.utc))
+        if self._db is None:
+            return PeakReading(NOT_OBSERVED, month,
+                               detail=self.last_error or "store never opened")
+        try:
+            row = self._db.execute(
+                "SELECT peak_w, quarter_start, per_phase_json FROM monthly_peak"
+                " WHERE month=?", (month,)).fetchone()
+        except sqlite3.Error as err:
+            self.last_error = str(err)
+            return PeakReading(NOT_OBSERVED, month, detail=str(err))
+        if row is None:
+            return PeakReading(NO_RECORD, month)
+        pp = tuple(json.loads(row[2])) if row[2] else None
+        return PeakReading(OBSERVED, month, peak_w=float(row[0]),
+                           quarter_start=datetime.fromisoformat(row[1]),
+                           per_phase_w=pp)
+
+    def recompute_month(self, month: str) -> PeakReading:
+        """Re-derive the peak from `quarter_blocks` - the divergence check.
+
+        `monthly_peak` is a derived record, so it can be PROVEN equal to the
+        tier it derives from instead of trusted to be. Read-only.
+        """
+        if self._db is None:
+            return PeakReading(NOT_OBSERVED, month,
+                               detail=self.last_error or "store never opened")
+        try:
+            row = self._db.execute(
+                "SELECT offtake_avg_w, quarter_start, per_phase_json FROM quarter_blocks"
+                " WHERE month=? ORDER BY offtake_avg_w DESC, quarter_start ASC LIMIT 1",
+                (month,)).fetchone()
+        except sqlite3.Error as err:
+            self.last_error = str(err)
+            return PeakReading(NOT_OBSERVED, month, detail=str(err))
+        if row is None:
+            return PeakReading(NO_RECORD, month)
+        pp = tuple(json.loads(row[2])) if row[2] else None
+        return PeakReading(OBSERVED, month, peak_w=float(row[0]),
+                           quarter_start=datetime.fromisoformat(row[1]),
+                           per_phase_w=pp)
+
+    def blocks_in(self, month: str) -> list:
+        """(quarter_start, offtake_avg_w) for a month, oldest first. [] on error
+        is safe here ONLY because no caller reads emptiness as a peak - AC 3's
+        counter reports the sample size it actually got."""
+        if self._db is None:
+            return []
+        try:
+            return [(datetime.fromisoformat(a), float(b)) for a, b in self._db.execute(
+                "SELECT quarter_start, offtake_avg_w FROM quarter_blocks"
+                " WHERE month=? ORDER BY quarter_start", (month,))]
+        except sqlite3.Error as err:
+            self.last_error = str(err)
+            return []
+
+    # -- the open block's checkpoint ----------------------------------------
+    def save_partial(self, state: dict) -> bool:
+        if self._db is None:
+            return False
+        try:
+            with self._db:
+                self._db.execute(
+                    "INSERT INTO partial_block(id, state_json) VALUES(1,?)"
+                    " ON CONFLICT(id) DO UPDATE SET state_json=excluded.state_json",
+                    (json.dumps(state),))
+            return True
+        except (sqlite3.Error, TypeError, ValueError) as err:
+            self.last_error = str(err)
+            return False
+
+    def load_partial(self) -> dict | None:
+        if self._db is None:
+            return None
+        try:
+            row = self._db.execute(
+                "SELECT state_json FROM partial_block WHERE id=1").fetchone()
+            return json.loads(row[0]) if row else None
+        except (sqlite3.Error, ValueError) as err:
+            self.last_error = str(err)
+            return None
+
+    def clear_partial(self) -> None:
+        # The one DELETE in this module, and it is against the checkpoint - a
+        # scratch row, not a retention tier. Neither quarter_blocks nor
+        # monthly_peak is deleted from anywhere in this file.
+        if self._db is None:
+            return
+        try:
+            with self._db:
+                self._db.execute("DELETE FROM partial_block WHERE id=1")
+        except sqlite3.Error as err:
+            self.last_error = str(err)
+
+
+# --------------------------------------------------------------------------- #
+# the tracker: what main.py holds
+# --------------------------------------------------------------------------- #
+@dataclass(frozen=True)
+class Projection:
+    """The open block's end-of-quarter estimate, with the reasons to distrust it.
+
+    `elapsed_s` travels WITH the number rather than beside it, because early in a
+    quarter a projection is a 10-second extrapolation over 900 s and a consumer
+    that cannot see that will react to noise. `covered_frac` is separately useful:
+    it is below 1.0 when the meter had a gap, which is the "unreliable quarter"
+    the functional note asks be marked rather than reported low.
+    """
+
+    projected_w: float
+    elapsed_w: float
+    elapsed_s: float
+    covered_frac: float
+    complete: bool
+    block_start: datetime | None
+
+    def explain(self) -> str:
+        return (f"quarter projects {self.projected_w:.0f} W "
+                f"({self.elapsed_s:.0f} s elapsed, {self.covered_frac * 100:.0f} % covered"
+                + ("" if self.complete else ", INCOMPLETE") + ")")
+
+
+class PeakTracker:
+    """Drives the store from `P1Ingest`. Measures; never commands."""
+
+    def __init__(self, store: PeakStore, cap_w: float = 3500.0,
+                 policy: str = POLICY_NET, checkpoint_s: float = CHECKPOINT_S):
+        self.store = store
+        self.cap_w = float(cap_w)
+        self.policy = policy
+        self.checkpoint_s = float(checkpoint_s)
+        self.recorded = 0
+        self.restore_state = "not attempted"
+        self._seen: set = set()
+        self._last_ckpt = 0.0
+
+    # -- startup ------------------------------------------------------------
+    def restore(self, averager, now: datetime | None = None) -> str:
+        """Put the open block back. Returns which of the three cases happened."""
+        now = now or datetime.now(timezone.utc)
+        snap = self.store.load_partial()
+        if not snap:
+            self.restore_state = ("fresh: no checkpoint" if self.store.ok
+                                  else "fresh: store unreadable")
+            return self.restore_state
+        block = snap.get("block")
+        if block is None:
+            self.restore_state = "fresh: checkpoint had no open block"
+            return self.restore_state
+
+        current = int(now.timestamp() // QUARTER_S) * QUARTER_S
+        if block == current:
+            if not averager.restore(snap):
+                # A reshaped accumulator (meter_phases changed) is a different
+                # measurement, not a resumable one. Say so; do not half-resume.
+                self.store.clear_partial()
+                self.restore_state = "fresh: checkpoint does not fit this averager"
+                return self.restore_state
+            self.restore_state = (
+                f"resumed the open block at {snap.get('elapsed', 0.0):.0f} s "
+                f"of {QUARTER_S} s ({snap.get('acc', 0.0) / QUARTER_S:.0f} W banked)")
+            return self.restore_state
+
+        # The block ended while the add-on was down. Its measured part really
+        # happened, so bank it at acc/900 rather than discard measured energy.
+        # It reads LOW because the seconds after the shutdown were never covered,
+        # and that is the honest figure: coverage a closed block did not get.
+        closed = _ClosedBlock(
+            start=datetime.fromtimestamp(block, timezone.utc),
+            offtake_avg_w=float(snap.get("acc", 0.0)) / QUARTER_S,
+            per_phase_offtake_avg_w=(tuple(v / QUARTER_S for v in snap["pp_acc"])
+                                     if snap.get("pp_acc") and snap.get("last_pp") else None))
+        banked = self.store.record_block(closed, self.policy)
+        self.store.clear_partial()
+        self.restore_state = (
+            f"closed a stale block from {closed.start.isoformat()} at "
+            f"{closed.offtake_avg_w:.0f} W (partial coverage), "
+            + ("banked" if banked else "NOT banked - store unwritable"))
+        return self.restore_state
+
+    # -- steady state -------------------------------------------------------
+    def sync(self, ingest, now_mono: float | None = None) -> int:
+        """Bank any blocks that closed, and refresh the checkpoint. Returns the
+        number of blocks newly recorded on this call."""
+        import time as _t
+        n = 0
+        for block in getattr(ingest, "blocks", ()):
+            key = block.start.timestamp()
+            if key in self._seen:
+                continue
+            if self.store.record_block(block, self.policy):
+                self._seen.add(key)
+                self.recorded += 1
+                n += 1
+        if n:
+            # A block just closed, so the checkpoint's block is gone: clearing it
+            # in the same breath is what stops a crash here from replaying it.
+            self.store.clear_partial()
+            self._last_ckpt = 0.0
+        self.checkpoint(ingest, now_mono or _t.monotonic())
+        return n
+
+    def checkpoint(self, ingest, now_mono: float, force: bool = False) -> bool:
+        if not force and (now_mono - self._last_ckpt) < self.checkpoint_s:
+            return False
+        avg = getattr(ingest, "averager", None)
+        if avg is None:
+            return False
+        self._last_ckpt = now_mono
+        return self.store.save_partial(avg.snapshot())
+
+    # -- reading ------------------------------------------------------------
+    def peak(self, when: datetime | None = None) -> PeakReading:
+        return self.store.peak(when)
+
+    def headroom_w(self, when: datetime | None = None) -> float | None:
+        """Watts left under the soft limit, or None when it cannot be known.
+
+        ⚠️ `None`, not `self.cap_w`. An unreadable peak returning full headroom
+        is the disarming default this whole module is shaped against.
+        """
+        r = self.peak(when)
+        if r.state == NO_RECORD:
+            return self.cap_w
+        if not r.is_observed:
+            return None
+        return max(0.0, self.cap_w - r.peak_w)
+
+    def warning_frac(self, when: datetime | None = None) -> float | None:
+        """Peak as a fraction of the soft limit - §9.1's 80 % warning entity."""
+        r = self.peak(when)
+        if r.state == NO_RECORD:
+            return 0.0
+        if not r.is_observed or self.cap_w <= 0:
+            return None
+        return r.peak_w / self.cap_w
+
+    @staticmethod
+    def project(averager, now: datetime) -> Projection:
+        """End-of-quarter average if the last sample held for the rest of it.
+
+        ⚠️ The two divisors are DIFFERENT and only coincide at the end of the
+        block. `elapsed_w` divides by the seconds actually covered (what the
+        meter has shown so far); `projected_w` divides by the full 900 s and
+        credits the held value over what remains. At `elapsed_s == 900` and full
+        coverage they are equal - which is precisely why nothing may be tested
+        only at that point.
+        """
+        start = averager.block_start
+        if start is None:
+            return Projection(0.0, 0.0, 0.0, 0.0, False, None)
+        elapsed_wall = max(0.0, (now - start).total_seconds())
+        elapsed = averager.elapsed_s
+        acc = averager.partial_ws
+        remaining = max(0.0, QUARTER_S - elapsed_wall)
+        held = max(getattr(averager, "_last_net", 0.0), 0.0)
+        return Projection(
+            projected_w=(acc + held * remaining) / QUARTER_S,
+            elapsed_w=(acc / elapsed) if elapsed > 0 else 0.0,
+            elapsed_s=elapsed_wall,
+            covered_frac=(elapsed / elapsed_wall) if elapsed_wall > 0 else 0.0,
+            complete=elapsed_wall <= 0 or elapsed >= elapsed_wall - 1e-9,
+            block_start=start)
+
+
+@dataclass(frozen=True)
+class _ClosedBlock:
+    """A block reconstructed from a checkpoint. Shaped like `p1.QuarterBlock` so
+    `record_block` has one input type; kept private so nothing else makes one."""
+
+    start: datetime
+    offtake_avg_w: float
+    per_phase_offtake_avg_w: tuple | None

goodwe_controller/app/validate.py

@@ -116,6 +116,21 @@ NOT READY banner already names the problem, (b) does not apply.
      (13.8 kWh usable at 2000 W is ~6.9 h against the 720 min DRAIN_TIMEOUT).
      It is warned about below, not refused.
 
+  7. A price configuration that cannot mean what it says.  [(a)]
+     Three cases, all in `_price_problems()`: an unknown `price_provider` id
+     (refused rather than defaulted to 'off', per the §14 warning box);
+     `price_provider` set alongside `price_now_entity`/`price_avg_entity`,
+     which is TWO PRICE SOURCES ON ONE SITE where the Home Assistant pair
+     silently wins; and `manual_csv` with no `price_csv_path`, which turns the
+     documented offline fallback into a permanent no-price-data condition
+     reached by accident. Same shape as 1, 4 and 5 every time - a source the
+     operator chose, overridden by a layer they cannot see.
+
+     ⚠️ `price_provider: "off"` IS NOT REFUSED AND MUST NOT BECOME SO. §11.4
+     makes no-price-data a supported state, and §9.2 says a large share of the
+     installed base is on a fixed or static tariff. Refusing to start without a
+     price feed would lock those sites out of the add-on entirely.
+
 WHAT IS DELIBERATELY *NOT* REFUSED, because it is untidy rather than unsafe:
 
   - `integrator_max_w` above `max_w`. DOCS.md is right that the only thing the
@@ -141,6 +156,8 @@ WHAT IS DELIBERATELY *NOT* REFUSED, because it is untidy rather than unsafe:
 import logging
 
 from .p1 import is_enabled, validate_meter_options
+from .price import PROVIDERS
+from .static_tariff import ProfileInvalid, parse_static_profile
 
 _LOG = logging.getLogger("goodwe.config")
 
@@ -349,6 +366,9 @@ def validate_startup_config(opts: dict, dev_min=None, dev_max=None) -> list[str]
             f"two numbers. Lower maintenance_charge_w to {max_w:.0f} W or less, "
             f"or raise max_w to at least {charge_w:.0f} W.")
 
+    # --- 7. two price sources on one site ------------------------------------
+    problems.extend(_price_problems(opts))
+
     # --- warnings: real, but not worth refusing over -------------------------
     integ = opts.get("integrator_max_w")
     integ_w = None if not integ else _number(opts, "integrator_max_w", None)
@@ -382,6 +402,144 @@ def validate_startup_config(opts: dict, dev_min=None, dev_max=None) -> list[str]
     return problems
 
 
+def _price_problems(opts: dict) -> list[str]:
+    """Rule 7 (TARIFF-02): the price configuration, refused where it is untrue.
+
+    ⚠️ NOTE WHAT IS *NOT* HERE. `price_provider: "off"` is not refused and never
+    will be: §11.4 makes no-price-data a first-class supported state (static
+    profile, provisional plan, no arbitrage), and an add-on that will not start
+    without a price feed is an add-on that a Belgian fixed-tariff site - a large
+    share of the installed base, per §9.2 - cannot run at all.
+
+    Four refusals and two log lines (TARIFF-03 added one refusal, one parse and
+    two notices), and every refusal is still case (a) from this module's
+    docstring: a source the operator SET being overridden by a layer they cannot
+    see. The additions are `static_profile` alongside the Home Assistant price
+    pair - the same silent-loser shape as provider-plus-pair, and a LIVE one -
+    and a `static_profile` that does not tile the day, which would leave hours
+    with no price at all.
+    """
+    problems: list[str] = []
+    pid = str(opts.get("price_provider", "") or "off").strip() or "off"
+
+    if pid != "off" and pid not in PROVIDERS:
+        problems.append(
+            f"price_provider is {pid!r}, which is not a shipped plugin. The "
+            f"ids that exist are: off, {', '.join(sorted(PROVIDERS))}. "
+            "Refused rather than defaulted, per the §14 warning box - a "
+            "silent fall back to 'off' would look exactly like a working "
+            "provider that happens never to find a cheap hour.")
+        return problems          # nothing below can be judged against an unknown id
+
+    # ⚠️ THE HA-SIDE OVERLAP THE PM TOLD US TO DECIDE ABOUT, DECIDED HERE.
+    # price_now_entity/price_avg_entity are the original delegation of pricing
+    # to Home Assistant: main.py reduces them to ONE BOOLEAN, `cheap`, read by
+    # the maintenance cheap-window charge floor. They are KEPT - retiring them
+    # would take a live install's only price signal away - but they may not run
+    # alongside another price source, because main.py reads exactly one and the
+    # loser is silent. That is (a), and it is the "silently double up" the PM
+    # named on 2026-08-30.
+    #
+    # ⚠️ THE REASON THIS REFUSAL GIVES WAS REWRITTEN BY TARIFF-03, AND THE OLD
+    # WORDING IS WHY. Until TARIFF-03 this message said the configured provider
+    # "would decide nothing", which was true only because nothing consumed the
+    # series; test_price.py section 12 carried a tripwire that went red the
+    # moment a consumer landed, with instructions to fix the wording here in the
+    # same commit. It landed, it went red, and this is that fix. What is true
+    # NOW, stated exactly and no wider:
+    #
+    #   * app/static_tariff.py consumes load_prices(). resolve_tariff() turns a
+    #     provider series into a TariffPlan, a cheap-window flag and an
+    #     arbitrage verdict, so the seam is no longer inert.
+    #   * main.py reads the STATIC side of that module every cycle
+    #     (static_status()), which makes static_profile a real writer of `cheap`.
+    #   * main.py does NOT yet call resolve_tariff() on the control tick, and
+    #     that is deliberate: a provider fetch is network I/O and the tick is
+    #     what feeds the ESP32 heartbeat. So a configured PROVIDER still shapes
+    #     no energy decision on its own; a configured STATIC PROFILE does.
+    #
+    # Hence two refusals below rather than one, and neither claims more than
+    # that list. When OPT-04 puts resolve_tariff() on a background refresh, the
+    # first message's middle clause is what changes - not the rule.
+    ha_price = [k for k in ("price_now_entity", "price_avg_entity")
+                if str(opts.get(k, "") or "").strip()]
+    if pid != "off" and ha_price:
+        problems.append(
+            f"price_provider is {pid!r} AND {' and '.join(ha_price)} "
+            f"{'is' if len(ha_price) == 1 else 'are'} set, which is two price "
+            "sources on one site. THE HOME ASSISTANT ENTITIES WIN: they are "
+            "what main.py reduces to the `cheap` flag the maintenance cycle "
+            "reads. The provider series IS consumed now - app/static_tariff.py "
+            "builds a tariff plan and an arbitrage verdict from it - but it is "
+            "not what main.py acts on, so the supplier you configured would "
+            "shape no energy decision while the status page named it. Clear "
+            "price_now_entity and price_avg_entity to use the "
+            f"{pid!r} plugin, or set price_provider to 'off' to keep the "
+            "Home Assistant sensors.")
+
+    # ⚠️ THE SAME RULE FOR THE SOURCE TARIFF-03 ADDED, AND THIS ONE IS A LIVE
+    # CONFLICT RATHER THAN A LATENT ONE. main.py's read_inputs() takes `cheap`
+    # from the Home Assistant pair when it is set and from the static profile
+    # otherwise - one flag, first writer wins, and the operator who filled in a
+    # day/night tariff has no way to see that it lost.
+    if ha_price and str(opts.get("static_profile", "") or "").strip():
+        problems.append(
+            f"static_profile is set AND {' and '.join(ha_price)} "
+            f"{'is' if len(ha_price) == 1 else 'are'} set, which is two "
+            "tariff sources feeding one cheap-window flag. THE HOME ASSISTANT "
+            "ENTITIES WIN: main.py reads them first and never looks at the "
+            "static profile, so the day/night tariff you typed would decide "
+            "nothing and nothing would say so. Clear price_now_entity and "
+            "price_avg_entity to use static_profile, or clear static_profile "
+            "to keep the Home Assistant sensors.")
+
+    # ⚠️ THE PROFILE ITSELF, PARSED AT STARTUP RATHER THAN AT 02:00. A profile
+    # that does not tile the day has hours with no price, and the only ways to
+    # serve those are to invent a number or to fail at the moment the clock
+    # reaches them. §14's warning box - refuse to start on a mismatch rather
+    # than clamp quietly - is the same instruction one level down.
+    raw_profile = opts.get("static_profile", "")
+    if str(raw_profile or "").strip() or isinstance(raw_profile, (list, dict)):
+        try:
+            profile = parse_static_profile(raw_profile)
+        except ProfileInvalid as e:
+            profile = None
+            problems.append(f"static_profile cannot be used: {e}")
+        if profile is not None and profile.product is not None \
+                and len(set(profile.prices)) == 1:
+            _LOG.info(
+                "static_profile carries one distinct price (%.4f EUR/kWh "
+                "all-in), so this site is priced as FULLY FIXED. Arbitrage is "
+                "off by arithmetic - a flat series has no spread - and the "
+                "add-on runs self-consumption only, which is §9.2's handling "
+                "for this product. Peak shaving, reserve management and the "
+                "maintenance cycle are unaffected.", profile.prices[0])
+
+    # ⚠️ A WARNING, NOT A REFUSAL, AND THE ASYMMETRY IS DELIBERATE. §11.4 says a
+    # site with no price data falls back to the static profile; a dynamic site
+    # with none configured has nothing to fall back to when its feed dies. That
+    # is a real gap worth naming - but refusing to start over it would break
+    # every install TARIFF-02 shipped, none of which could have had one.
+    if pid != "off" and not str(opts.get("static_profile", "") or "").strip():
+        _LOG.warning(
+            "price_provider is %r but static_profile is empty. §11.4's "
+            "degradation row is 'no price data -> fall back to the static "
+            "profile'; with none configured, a feed outage leaves this site "
+            "with no tariff at all rather than with a coarse one. Not refused, "
+            "but filling it in is what makes that row work.", pid)
+
+    if pid == "manual_csv" and not str(opts.get("price_csv_path", "") or "").strip():
+        problems.append(
+            "price_provider is 'manual_csv' but price_csv_path is empty, so "
+            "the offline fallback has no file to read. Every fetch would "
+            "return no-price-data with a filesystem error as its reason - "
+            "which is §11.4 behaviour arrived at by accident rather than by "
+            "configuration. Point it at the CSV, or set price_provider to "
+            "'off', which says the same thing on purpose.")
+
+    return problems
+
+
 def _number(opts: dict, key, default):
     raw = opts.get(key, default)
     if raw is None or raw == "":

goodwe_controller/config.yaml

@@ -162,9 +162,84 @@ options:
   # --- tariff / capacity tariff (all optional) ------------------------------
   peak_forecast_entity: ""
   peak_cap_w: 3500
+
+  # ⚠️ THE OLD PRICE PATH, AND IT IS NOT DEAD YET. These two entities are the
+  # add-on delegating the whole price question to Home Assistant: main.py reads
+  # both and derives ONE BOOLEAN, `cheap = now <= avg`, which is consumed by
+  # nothing except the maintenance cycle's cheap-window charge floor. That is
+  # all they have ever done. They are kept, because retiring them would take
+  # the maintenance cycle's only price signal away on a live install before
+  # anything replaces it - TARIFF-03 (static profile) and OPT-04 (arbitrage)
+  # are the cards that replace it, and neither has landed.
+  #
+  # ⚠️ They may NOT be combined with price_provider below. Two price sources on
+  # one site, one of which silently wins, is exactly the "double up" the PM
+  # named; validate.py rule 7 refuses that configuration at startup rather than
+  # letting an operator believe the provider they configured is driving
+  # something. See app/validate.py.
   price_now_entity: ""
   price_avg_entity: ""
 
+  # --- price providers (TARIFF-02, specs §9.3 / §14 `tariffs:`) --------------
+  # `off` is the shipped default and means the §11.4 no-price-data row applies:
+  # static profile, plan provisional, NO ARBITRAGE. Nothing in 0.5.x consumes
+  # the series yet - OPT-04 is the consumer - so turning this on today fetches,
+  # validates and publishes prices and changes no energy decision.
+  #
+  # ⚠️ THESE DEFAULTS ARE MIRRORED ONCE, IN app/price.py's
+  # PRICE_OPTION_DEFAULTS, and test_price.py reads THIS FILE and asserts the two
+  # agree key for key. Do not add a third copy in main.py - CFG-03 is open
+  # because that has already happened three times.
+  #
+  # markup/taxes are the §14 `tariffs.energy_price.*` figures and are added by
+  # the FRAMEWORK, only for the components the chosen plugin declares its feed
+  # does not already contain. engie_dynamic, totalenergies_dynamic, eneco_eddy
+  # and manual_csv publish a figure that already carries the markup, so setting
+  # it under those is ignored - and logged as ignored, never applied twice.
+  price_provider: "off"
+  price_markup_eur_kwh: 0.03
+  price_taxes_eur_kwh: 0.06
+  price_csv_path: "/share/goodwe_prices.csv"
+  price_feed_url: ""
+  price_horizon_h: 48
+  price_timeout_s: 10
+
+  # --- static / fully-fixed tariffs (TARIFF-03, specs §9.2 / §11.4) ----------
+  # §14's `tariffs.static_profile`, and "" is its `null`. §9.2: "a large share
+  # of the installed base is on [a static profile]" - this is what makes those
+  # sites first-class rather than "price_provider: off, good luck".
+  #
+  # A JSON object, on one line, whose periods must tile every day type exactly
+  # once - no gap and no overlap. A gap is REFUSED at startup rather than
+  # defaulted, because an invented price is one an optimiser would trade on.
+  # A fully-fixed tariff is ONE period covering 00:00-24:00, all days; the
+  # add-on derives "fixed" from there being one distinct price, so there is no
+  # box to tick and none to tick wrongly.
+  #
+  #   {"periods": [
+  #      {"name":"day",  "from":"07:00","to":"22:00","days":"mon-fri","eur_per_kwh":0.34},
+  #      {"name":"night","from":"22:00","to":"07:00","days":"mon-fri","eur_per_kwh":0.26},
+  #      {"name":"night","from":"00:00","to":"24:00","days":"sat,sun", "eur_per_kwh":0.26}]}
+  #
+  # ⚠️ A window written "22:00-07:00 mon-fri" does NOT cover Saturday morning -
+  # a period applies on the day the CLOCK reads, so the weekend row above is
+  # required, not decorative. See DOCS.md.
+  #
+  # eur_per_kwh is ALL-IN (energy + markup + taxes, §9.3), the same basis the
+  # dynamic providers are assembled onto. price_markup_eur_kwh and
+  # price_taxes_eur_kwh are NOT added to it.
+  #
+  # ⚠️ RECOMMENDED EVEN ON A DYNAMIC SITE. §11.4's degradation row is "no price
+  # data -> fall back to the static profile"; with this empty there is nothing
+  # to fall back to and a dead feed leaves the site with no tariff at all.
+  # validate.py warns about exactly that.
+  static_profile: ""
+
+  # §9.3: injection is priced SEPARATELY, and in Belgium it is often near zero -
+  # which by itself strongly favours self-consumption over export. A scalar, not
+  # a second series: no shipped supplier publishes a dynamic injection curve.
+  export_price_eur_kwh: 0.04
+
   # --- site ------------------------------------------------------------------
   estop_fitted: false
   log_level: info
@@ -239,5 +314,28 @@ schema:
   price_now_entity: str?
   price_avg_entity: str?
 
+  # ⚠️ The provider list is written out rather than left as `str`, so the
+  # Supervisor rejects a typo in the UI. validate.py ALSO refuses an unknown id
+  # against app/price.py's PROVIDERS registry, because sim/inject.py and the
+  # checks reach validate_startup_config() with a dict the Supervisor never saw.
+  # Adding a sixth plugin means adding it here and to PROVIDERS - and nowhere
+  # else, which is AC2.
+  price_provider: list(off|generic_dayahead|engie_dynamic|totalenergies_dynamic|eneco_eddy|manual_csv)
+  price_markup_eur_kwh: float(0,1)
+  price_taxes_eur_kwh: float(0,1)
+  price_csv_path: str?
+  price_feed_url: str?
+  price_horizon_h: int(1,72)
+  price_timeout_s: int(2,60)
+  # A JSON string rather than a nested schema, deliberately: it is ONE option
+  # key (§14 has one), it survives config.yaml's flat options block, and
+  # parse_static_profile() accepts an already-parsed dict too, so a future
+  # nested schema is a config.yaml change and no code change at all.
+  static_profile: str?
+  # ⚠️ The lower bound is NEGATIVE on purpose. Belgian injection tariffs have
+  # gone below zero (you pay to export at midday in summer), and a schema that
+  # bottoms out at 0 would make that site inexpressible.
+  export_price_eur_kwh: float(-1,1)
+
   estop_fitted: bool
   log_level: list(trace|debug|info|warning|error)

goodwe_controller/test_clamp.py

@@ -0,0 +1,550 @@
+"""Runnable check for SAFETY-03, the output clamp and its winding-loop alarm.
+
+    python3 test_clamp.py
+
+No framework, asserts only, same house style as test_freeze.py.
+
+Five parts, and parts 3 and 4 are the ones that carry the acceptance criteria:
+
+  1. THE CLAMP ARITHMETIC, on the shipped `clamp_to_rating()` - boundaries,
+     symmetry, the device second stage, and the non-finite cases. Table driven.
+  2. THE ALARM'S CADENCE - rising edge, re-assert, hysteresis - on the shipped
+     `ClampWatchdog`. Every engagement counted, notifications not flooded.
+  3. AC 1 + AC 3, WIRED. A computed setpoint that exceeds the rating, driven
+     through the REAL `Controller.cycle()`: nothing over the rating reaches the
+     device, and the alarm fires. Includes the historical runaway from
+     specs.md 10.3 replayed against an unclamped transcription, so the check
+     says what the clamp is actually worth in watts rather than asserting a
+     constant.
+  4. AC 2, AND IT IS THE LOAD-BEARING HALF. A loop that SATURATES WITHOUT
+     CLAMPING - the inverter refusing to follow a perfectly legal command - must
+     raise NO clamp alarm. If it does, the bug signal is inside the noise again
+     and the whole ticket has bought nothing.
+  5. NO PATH BYPASSES IT. write_setpoint() is the only route to the wire, so it
+     is called directly with an out-of-range value the way the heartbeat and the
+     operator's buttons call it.
+
+------------------------------------------------------------------------------
+WHY PART 4 ALSO ASSERTS ON `Decision`'s BOOLEANS AND NOT ON `reason`
+
+`Decision.reason` is one string and the stages after the clamp overwrite it. The
+check below drives a cycle that clamps the integrator AND is then slew limited,
+and asserts that `reason` does NOT say so while `i_clamped` does. That is not a
+style preference - an alarm keyed on the string is silent on exactly the cycles a
+winding loop produces, and this is the check that would go red if someone
+"simplified" main.py back onto it.
+
+------------------------------------------------------------------------------
+WHAT THIS CHECK DOES NOT COVER
+
+- The firmware-side magnitude clamp (the card's "two clamps, not one"). This
+  add-on's `write_setpoint()` is the add-on half; the ESP32 half is DRIVER-07's
+  and is not in this repo's Python.
+- A rig run. Nothing here needs one: the clamp is arithmetic on the write path
+  and part 3 drives the shipped `Controller.cycle()` against a stub Home
+  Assistant, which is the same surface test_freeze.py part 1-2 use. The wire-
+  level invariant the card asks for (`|emitted| <= rating` on every frame) is
+  asserted here over every value that reached `set_number()`, which is the last
+  thing this process controls; proving it at the inverter needs the witness log
+  and belongs with DRIVER-07.
+"""
+
+import asyncio
+import math
+import sys
+from datetime import datetime, timedelta, timezone
+
+from app.clamp import (
+    CLEAR_CYCLES, REASON_CODE, REASSERT_S, ClampWatchdog, clamp_to_rating,
+    is_commandable,
+)
+from app.control import Tuning, compute
+from app.main import Controller
+
+fails = []
+T0 = datetime(2026, 8, 30, 9, 0, 0, tzinfo=timezone.utc)
+
+# The live install's numbers. NOTES.md and freeze.py both say max_w: 5000 there,
+# which is also the device rating, so this is the bound the alarm is written at.
+LIVE_MAX_W = 5000.0
+CLAMP_ID = "goodwe_output_clamp"
+
+
+def check(name, cond):
+    print(f"  {'ok  ' if cond else 'FAIL'} {name}")
+    if not cond:
+        fails.append(name)
+
+
+# ==============================================================================
+print("1. the clamp arithmetic, on the shipped expression")
+
+# (requested, limit, expected applied, expected engaged, expected bound)
+TABLE = [
+    (5001.0, 5000.0, 5000.0, True, "max_w"),      # +limit+1
+    (-5001.0, 5000.0, -5000.0, True, "max_w"),    # -limit-1, the export side
+    (5000.0, 5000.0, 5000.0, False, ""),          # exactly +limit: NOT engaged
+    (-5000.0, 5000.0, -5000.0, False, ""),        # exactly -limit: NOT engaged
+    (0.0, 5000.0, 0.0, False, ""),                # the failsafe value
+    (1234.0, 5000.0, 1234.0, False, ""),
+    (14768.0, 5000.0, 5000.0, True, "max_w"),     # 10.3's reported runaway
+]
+for requested, limit, want_applied, want_engaged, want_bound in TABLE:
+    r = clamp_to_rating(requested, limit)
+    check(f"{requested:+.0f} W against a {limit:.0f} W rating -> "
+          f"{r.applied_w:+.0f} W, engaged={r.engaged}, bound={r.bound!r}",
+          r.applied_w == want_applied and r.engaged is want_engaged
+          and r.bound == want_bound)
+
+# It is a MAGNITUDE clamp (3.2), so import and export must be bound identically.
+# Derived over a sweep rather than asserted on two hand-picked values.
+asym = [m for m in range(0, 12001, 37)
+        if clamp_to_rating(m, LIVE_MAX_W).applied_w
+        != -clamp_to_rating(-m, LIVE_MAX_W).applied_w]
+check(f"symmetric over {len(range(0, 12001, 37))} magnitudes "
+      f"({len(asym)} asymmetric)", not asym)
+
+# The engagement flag has to mean "the RAW value differed", which is the words
+# AC 2 uses. Re-derived from the result's own fields, not from the table.
+mismatch = [m for m in range(0, 12001, 37)
+            for r in [clamp_to_rating(m, LIVE_MAX_W)]
+            if r.engaged != (r.requested_w != r.applied_w)]
+check("engaged is exactly 'raw differs from applied', over the same sweep",
+      not mismatch)
+
+# The device second stage. Only reachable when max_w is ABOVE the device range,
+# i.e. when validate_startup_config() did not run or no longer holds.
+r = clamp_to_rating(3000.0, 5000.0, dev_min=-2000.0, dev_max=2000.0)
+check(f"a device narrower than max_w still bites, and says which bound "
+      f"({r.applied_w:+.0f} W, {r.bound!r})",
+      r.applied_w == 2000.0 and r.engaged and r.bound == "device")
+r = clamp_to_rating(3000.0, 5000.0, dev_min=-5000.0, dev_max=5000.0)
+check("...and is a no-op once the startup validation holds",
+      r.applied_w == 3000.0 and not r.engaged)
+
+# ⚠️ REGRESSION, REVIEW-FOUND. THE FIRST STAGE USED TO `return` AND THE DEVICE
+# STAGE WAS THEN NEVER REACHED, so the harder the overshoot the less the guard
+# did: at max_w 5000 against a +-4000 device, +9999 emitted +5000 - OUTSIDE THE
+# DEVICE RANGE - while a mere +4500 was correctly held to +4000. That inverts
+# the guard and it was a regression against the pre-PR `write_setpoint()`, whose
+# comment read "never send a value the device will reject outright".
+#
+# The property is asserted over a sweep, not on the two witness values, because
+# the defect was invisible to every single-value check that happened to sit
+# inside one stage.
+DEV_LO, DEV_HI = -4000.0, 4000.0
+escapes = [(m, clamp_to_rating(m, 5000.0, DEV_LO, DEV_HI).applied_w)
+           for m in range(-15000, 15001, 61)
+           for a in [clamp_to_rating(m, 5000.0, DEV_LO, DEV_HI).applied_w]
+           if not (DEV_LO <= a <= DEV_HI)]
+big = clamp_to_rating(9999.0, 5000.0, DEV_LO, DEV_HI)
+small = clamp_to_rating(4500.0, 5000.0, DEV_LO, DEV_HI)
+print(f"    max_w 5000 vs a device of {DEV_LO:+.0f}..{DEV_HI:+.0f}: "
+      f"+9999 -> {big.applied_w:+.0f} W ({big.bound}), "
+      f"+4500 -> {small.applied_w:+.0f} W ({small.bound})")
+check(f"BOTH stages always run - {big.requested_w:+.0f} W emits "
+      f"{big.applied_w:+.0f} W, inside the device's {DEV_HI:+.0f} W, and names "
+      f"both bounds ({big.bound!r})",
+      big.applied_w == DEV_HI and big.bound == "max_w+device")
+check(f"...and it holds over the whole range, so no overshoot escapes the "
+      f"device ({len(escapes)} escapes in {len(range(-15000, 15001, 61))})",
+      not escapes)
+check("...a big overshoot is not clamped LESS than a small one",
+      abs(big.applied_w) <= abs(small.applied_w) + 0.0)
+
+print("   non-finite input is loss of input, not an out-of-range value")
+for bad in (None, float("nan"), float("inf"), float("-inf"), "abc", object()):
+    check(f"is_commandable({bad!r:.30}) is False", is_commandable(bad) is False)
+for good in (0, -5000.0, 5000, 12.5):
+    check(f"is_commandable({good!r}) is True", is_commandable(good) is True)
+
+# ⚠️ WHY THAT GUARD EXISTS, AND THE ANSWER IS WORSE THAN "it passes a nan
+# through". MEASURED HERE, not recalled: every comparison against a nan is
+# False, so `min(limit, nan)` keeps its FIRST argument and a naive clamp turns a
+# nan into a command at the FULL RATING - and then reports engaged=True, because
+# limit != nan, so the winding-loop counter gets a transport bug filed in it.
+# The number below is computed by the same expression the guard replaces.
+nan = float("nan")
+naive = max(-LIVE_MAX_W, min(LIVE_MAX_W, nan))
+check(f"a naive clamp turns a nan into {naive:+,.0f} W and calls it "
+      f"engaged={naive != nan} - hence the guard",
+      naive == LIVE_MAX_W and (naive != nan) is True)
+
+
+# ==============================================================================
+print()
+print("2. the alarm's cadence: every engagement counted, no flood")
+
+wd = ClampWatchdog()
+t = T0
+fired = [wd.note(True, "winding", t + timedelta(seconds=i)) for i in range(10)]
+check(f"the rising edge fires ({fired[0]})", fired[0] is True)
+check(f"the next 9 one-second cycles fire {sum(fired[1:])} more times "
+      f"(re-assert is {REASSERT_S:.0f} s)", sum(fired[1:]) == 0)
+check(f"but every one of them is counted: engagements={wd.engagements}",
+      wd.engagements == 10)
+check(f"and it is one episode, not ten: episodes={wd.episodes}",
+      wd.episodes == 1)
+
+# --- THE RE-ASSERT CADENCE, PINNED IN BOTH DIRECTIONS ------------------------
+# ⚠️ REVIEW-FOUND. This used to read `wd.note(True, ..., T0 + REASSERT_S + 9)`,
+# which is green for ANY value of the constant - REASSERT_S = 3600 passed, and an
+# hour of silence is precisely what the module promises not to do. A check whose
+# stimulus is written in terms of the constant it is grading cannot grade it.
+#
+# The requirements are stated in wall-clock seconds and derived from what the
+# alarm is FOR, so they do not move when the constant does:
+#
+#   floor - a loop pinned on the rail must speak at least MIN_PER_QUARTER times
+#           inside the 900 s quarter that bills the capacity tariff. That window
+#           is the same one freeze.py and DOCS.md reason about.
+#   ceiling - it must not speak on more than MAX_FRACTION of cycles, or it is
+#           the per-cycle flood the split exists to remove.
+QUARTER_S = 900.0
+MIN_PER_QUARTER = 5
+MAX_FRACTION = 0.20
+
+pinned = ClampWatchdog()
+alarms = sum(1 for i in range(int(QUARTER_S))
+             if pinned.note(True, "pinned", T0 + timedelta(seconds=i)))
+print(f"    pinned on the rail for {QUARTER_S:.0f} s at 1 s cycles: "
+      f"{pinned.engagements} engagements, {alarms} alarm(s) "
+      f"({alarms / QUARTER_S:.1%} of cycles)")
+check(f"a loop pinned for a whole billing quarter speaks at least "
+      f"{MIN_PER_QUARTER} times (it spoke {alarms})",
+      alarms >= MIN_PER_QUARTER)
+check(f"...and on no more than {MAX_FRACTION:.0%} of cycles (it was "
+      f"{alarms / QUARTER_S:.1%})", alarms <= MAX_FRACTION * QUARTER_S)
+check("...while every single cycle is still counted",
+      pinned.engagements == int(QUARTER_S))
+
+# --- THE HYSTERESIS, PINNED AGAINST THE CHATTER DIRECTION --------------------
+# ⚠️ REVIEW-FOUND. This used to issue `range(CLEAR_CYCLES - 1)` clean cycles,
+# which at CLEAR_CYCLES = 1 issues ZERO of them and passes while printing
+# "0 clean cycles do NOT clear it". Green for every value >= 1 - including 1,
+# which IS the chatter the constant exists to prevent. The stimulus is a literal
+# now: ONE clean cycle must not clear the alarm, whatever the constant says.
+wd2 = ClampWatchdog()
+wd2.note(True, "winding", T0)
+wd2.note(False, "", T0 + timedelta(seconds=1))
+check(f"ONE clean cycle does NOT clear the alarm (active={wd2.active}) - "
+      f"a command dithering across the rail must not chatter",
+      wd2.active is True)
+survived = 1
+while wd2.active and survived < 50:
+    wd2.note(False, "", T0 + timedelta(seconds=1 + survived))
+    survived += 1
+print(f"    it took {survived} consecutive clean cycles to de-assert "
+      f"(CLEAR_CYCLES = {CLEAR_CYCLES})")
+check(f"...and it does de-assert, after {survived} of them, rather than "
+      f"latching", wd2.active is False and survived == CLEAR_CYCLES)
+check("...and the engagement count survives the clear, so the evidence does",
+      wd2.engagements == 1)
+check("a clean cycle on an idle watchdog says nothing",
+      wd2.note(False, "", T0 + timedelta(seconds=300)) is False)
+
+
+# ==============================================================================
+print()
+print("3. AC 1 + AC 3, wired: over the rating both clamps AND alarms")
+
+
+class _Store:
+    data = {}
+
+    def set(self, *a):
+        pass
+
+    def get_time(self, *a):
+        return None
+
+
+class _Pub:
+    enabled = False
+
+    def publish(self, *a, **k):
+        pass
+
+    def close(self):
+        pass
+
+
+class _Hass:
+    """Stub HA. `track` False models an inverter that is switched off entirely,
+    which is the 10.3 runaway's own setup."""
+
+    def __init__(self, grid, batt=0.0, track=True):
+        self.grid = grid
+        self.batt = batt
+        self.track = track
+        self.calls = []
+        self.writes = []
+
+    async def limits(self, entity):
+        return (-LIVE_MAX_W, LIVE_MAX_W, 1.0)
+
+    async def number(self, entity, invert=False):
+        return {"sensor.grid": self.grid, "sensor.soc": 50.0,
+                "sensor.batt": self.batt}.get(entity)
+
+    async def set_number(self, entity, value):
+        self.writes.append(float(value))
+        if self.track:
+            self.batt = float(value)
+        return True
+
+    async def call(self, domain, service, data):
+        self.calls.append((domain, service, data))
+        return True
+
+
+def wired(grid, cycles=40, batt=0.0, track=True, **over):
+    async def go():
+        hass = _Hass(grid, batt=batt, track=track)
+        c = Controller(dict(
+            {"setpoint_entity": "number.sp", "meter_entity": "sensor.grid",
+             "soc_entity": "sensor.soc", "batt_entity": "sensor.batt",
+             "meter_source": "off", "max_w": LIVE_MAX_W, "gain": 0.6,
+             "slew_w": 1000, "deadband_w": 15, "target_grid_w": 0,
+             "step_w": 10, "heartbeat_s": 10, "stale_input_s": 15},
+            **over), hass, _Store(), _Pub(), stop=asyncio.Event())
+        c.auto = True
+        c.dev_min, c.dev_max = -LIVE_MAX_W, LIVE_MAX_W
+        # The red status row exists only WHILE the clamp is engaged, and the
+        # hysteresis clears it a few cycles later - so it is captured live
+        # rather than looked for after the run, when it is correctly gone.
+        c.red_snapshot = []
+        for _ in range(cycles):
+            await c.read_inputs()
+            await c.cycle()
+            if c.clamp_wd.active and not c.red_snapshot:
+                c.red_snapshot = c.checks()
+        return hass, c
+    return asyncio.run(go())
+
+
+def clamp_notes(hass):
+    return [d for dom, svc, d in hass.calls
+            if (dom, svc) == ("persistent_notification", "create")
+            and d.get("notification_id") == CLAMP_ID]
+
+
+# THE 10.3 RUNAWAY, replayed. "With the inverter switched off entirely, an
+# unclamped integrator climbed ~130 W per 4 s to over 10 kW and, pinned at the
+# 5 kW rail, reported 14 768 W." `track=False` is the inverter switched off: it
+# reports 0 W however hard it is commanded, so the error never closes.
+hass_r, ctl_r = wired(6000.0, cycles=60, track=False)
+emitted = [abs(w) for w in hass_r.writes]
+
+# What the SAME error would have done to an accumulator with no bound - the
+# transcription is deliberately the unclamped velocity form 10.3 describes, so
+# the figure below is computed here and not quoted from the spec.
+runaway, err = 0.0, 6000.0
+for _ in range(60):
+    runaway += 0.6 * err
+print(f"    unclamped, the same 60 cycles reach {runaway:,.0f} W; "
+      f"the largest value that reached the device is {max(emitted):,.0f} W")
+check(f"an unbounded accumulator really does run away here "
+      f"({runaway:,.0f} W >> {LIVE_MAX_W:.0f} W)", runaway > 3 * LIVE_MAX_W)
+check(f"AC 1: NOT ONE of the {len(emitted)} values that reached the device "
+      f"exceeds the {LIVE_MAX_W:.0f} W rating",
+      emitted and max(emitted) <= LIVE_MAX_W)
+# ⚠️ AND THE CLAMP IS NOT THE ONLY THING HOLDING THAT LINE HERE, which is worth
+# saying out loud rather than letting the number above imply otherwise. Against
+# an inverter reporting 0 W the saturation freeze engages after
+# `saturation_cycles` and pins the command well BELOW the rail - that is why the
+# largest emitted value is what it is and not 5000 W. The clamp is what makes it
+# bounded; the freeze is what makes it small. A check that read
+# `max(emitted) == max_w` would have been asserting the freeze, not the clamp.
+check(f"...and the saturation freeze is what pins it at {max(emitted):,.0f} W "
+      f"rather than the rail", ctl_r.sat_count >= ctl_r.tuning.saturation_cycles)
+
+notes_r = clamp_notes(hass_r)
+print(f"    the loop clamped on {ctl_r.clamp_wd.engagements} of {60} cycles, "
+      f"in {ctl_r.clamp_wd.episodes} episode(s), raising {len(notes_r)} "
+      f"notification(s)")
+check("AC 3: and it ALARMED - silently clipping this is the defect",
+      ctl_r.clamp_wd.engagements > 0 and len(notes_r) >= 1)
+check("...with its own notification_id, not shared with any other guard",
+      all(d["notification_id"] == CLAMP_ID for d in notes_r))
+check("...one episode, re-asserted rather than one per cycle",
+      ctl_r.clamp_wd.episodes == 1 and len(notes_r) < ctl_r.clamp_wd.engagements)
+check("...and it names itself a bug signal, not a limit in use",
+      bool(notes_r) and "out of range" in notes_r[0]["message"])
+rows_r = [e for e in ctl_r.events if REASON_CODE in e]
+check(f"the action log records every engagement, coalesced into one row per "
+      f"episode ({len(rows_r)} row(s), {ctl_r.clamp_wd.engagements} "
+      f"engagement(s))",
+      len(rows_r) == ctl_r.clamp_wd.episodes
+      and f"{ctl_r.clamp_wd.engagements} engagement(s)" in rows_r[0])
+
+# ⚠️ REGRESSION, AND IT WAS A REAL BUG BEFORE IT WAS A CHECK. `log_event()` keeps
+# 40 rows. A row per engagement flushes that ring inside 40 cycles of a winding
+# loop, and the first thing it evicted was SAFETY-18's own "METER FROZEN?" row -
+# i.e. this guard silencing another guard's log. Driven here with a plant that
+# TRACKS the command, so the saturation freeze never engages and the integrator
+# clamps on essentially every cycle.
+hass_l, ctl_l = wired(9000.0, cycles=80, track=True)
+rows_l = [e for e in ctl_l.events if REASON_CODE in e]
+other_l = [e for e in ctl_l.events if REASON_CODE not in e]
+print(f"    80 winding cycles: {ctl_l.clamp_wd.engagements} engagement(s) -> "
+      f"{len(rows_l)} log row(s), leaving room for {len(other_l)} other event(s)")
+check(f"a long winding episode does NOT flood the 40-row event log "
+      f"({len(rows_l)} rows for {ctl_l.clamp_wd.engagements} engagements)",
+      ctl_l.clamp_wd.engagements > 40 and len(rows_l) <= ctl_l.clamp_wd.episodes)
+check("...and the count in the row is the counter's, so nothing is lost",
+      f"{ctl_l.clamp_wd.engagements} engagement(s)" in rows_l[-1])
+# The RED row exists only while engaged, and the episode above is short, so it
+# is captured mid-run rather than asserted after the hysteresis has cleared it.
+check("the status page goes red WHILE it is engaged",
+      any(not c["ok"] and not c["warn"] and "OUTPUT CLAMP ENGAGED" in c["text"]
+          for c in ctl_r.red_snapshot))
+check("...and once clear, a warn row still says how many times it engaged",
+      any(c["warn"] and f"{ctl_r.clamp_wd.engagements} time(s)" in c["text"]
+          for c in ctl_r.checks()))
+
+# ⚠️ NOT A TRIP. 11.2's action is "clamp and alarm"; the loop keeps running and
+# keeps writing the clamped value. If a later cut changes that it must come here.
+check(f"it is NOT a trip - the command stands at {ctl_r.target:+.0f} W, not 0 W",
+      ctl_r.target != 0.0 and ctl_r.target == hass_r.writes[-1])
+check("...and the controller still reports itself running, not failsafe",
+      ctl_r.auto and not ctl_r.sign_wd.tripped)
+
+# The export side, because the clamp is a magnitude clamp and a sign bug in it
+# would be invisible on the import case alone.
+hass_x, ctl_x = wired(-6000.0, cycles=60, track=False)
+check(f"the export side clamps and alarms too "
+      f"({min(hass_x.writes):+,.0f} W, {len(clamp_notes(hass_x))} note(s), "
+      f"{ctl_x.clamp_wd.engagements} engagement(s))",
+      min(hass_x.writes) < 0 and abs(min(hass_x.writes)) <= LIVE_MAX_W
+      and clamp_notes(hass_x) and ctl_x.clamp_wd.engagements > 0)
+
+
+# ==============================================================================
+print()
+print("4. AC 2: saturation WITHOUT clamping must NOT raise a clamp alarm")
+
+# A legal command the inverter will not follow. The meter sits just outside the
+# deadband so the loop moves a little and then rests; `batt` is pinned far from
+# whatever is commanded, which is the saturation condition (|cmd - actual| >
+# saturation_w) and nothing else. The integrator never approaches the rating.
+hass_s, ctl_s = wired(60.0, cycles=40, batt=2500.0, track=False)
+peak = max(abs(w) for w in hass_s.writes)
+print(f"    saturated for {ctl_s.sat_count} consecutive cycles; the command "
+      f"peaked at {peak:.0f} W, {peak / LIVE_MAX_W:.1%} of the rating")
+# ⚠️ THE POSITIVE HALF FIRST. A negative check that saw nothing happen is not an
+# observation - if the saturation freeze never engaged, "no clamp alarm" is
+# vacuous and this check is worthless.
+check(f"the saturation freeze REALLY DID engage (sat_count="
+      f"{ctl_s.sat_count} >= {ctl_s.tuning.saturation_cycles})",
+      ctl_s.sat_count >= ctl_s.tuning.saturation_cycles)
+check("...and the event log says so, in the saturation's own words",
+      any("saturation freeze" in e for e in ctl_s.events))
+check(f"...while the command stayed well inside the rating "
+      f"({peak:.0f} W < {LIVE_MAX_W:.0f} W)", peak < LIVE_MAX_W)
+# Now the negative, which is only worth anything because of the three above.
+check("AC 2: NO clamp notification was raised", not clamp_notes(hass_s))
+check("AC 2: the clamp counted ZERO engagements", ctl_s.clamp_wd.engagements == 0)
+check("AC 2: no OUTPUT_CLAMP row in the action log",
+      not [e for e in ctl_s.events if REASON_CODE in e])
+check("AC 2: and no clamp row on the status page",
+      not [c for c in ctl_s.checks() if "output clamp" in c["text"].lower()])
+
+print("   ...and the two alarms do not share a notification_id")
+ids_clamp = {d["notification_id"] for d in clamp_notes(hass_r)}
+ids_other = {d.get("notification_id") for dom, svc, d in hass_r.calls
+             if svc == "create"} - ids_clamp
+check(f"clamp ids {sorted(ids_clamp)} are disjoint from every other alarm's "
+      f"{sorted(x for x in ids_other if x)}", not (ids_clamp & ids_other))
+
+print("   ...and the alarm cannot be keyed on Decision.reason")
+# A cycle that clamps the integrator AND is then slew limited. `reason` reports
+# the LAST stage, so a string-keyed alarm is silent on it; the boolean is not.
+t = Tuning(max_w=2000.0, slew_w=100.0, gain=0.6)
+d = compute(prev_w=1000.0, grid_w=6000.0, actual_w=1000.0, tuning=t, i_w=1900.0)
+print(f"    reason={d.reason!r}  i_clamped={d.i_clamped}  clamped={d.clamped}")
+check("the integrator DID clamp on that cycle", d.i_clamped is True)
+check("...but `reason` says 'slew-limited' - the clamp was overwritten "
+      "downstream, so a string-keyed alarm is SILENT here",
+      d.reason == "slew-limited" and "clamp" not in d.reason)
+# And the same for the OUTPUT clamp, on a config that lets the integrator run
+# above the rail - then both flags fire and `reason` still reports neither.
+t2 = Tuning(max_w=2000.0, integrator_max_w=3000.0, slew_w=100.0, gain=0.6)
+d2 = compute(prev_w=1000.0, grid_w=6000.0, actual_w=1000.0, tuning=t2, i_w=2900.0)
+print(f"    reason={d2.reason!r}  i_clamped={d2.i_clamped}  clamped={d2.clamped}")
+check("both clamps engaged, and `reason` reports neither",
+      d2.i_clamped and d2.clamped and "clamp" not in d2.reason)
+# ⚠️ HOW THE FREEZE AND THE CLAMP INTERACT, MEASURED RATHER THAN ASSUMED, AND
+# THE MEASUREMENT REFUSED TWO GUESSES BEFORE THIS ONE. Written first as "a
+# frozen cycle never clamps" (false), then as "only the i_w == 0 reseed
+# exception clamps" (also false - at i_w == 0 with a matching actual the cycle
+# is not saturated at all, so it is never frozen). What the sweep actually
+# shows: a frozen cycle clamps exactly when the integrator REVERSES. control.py
+# permits that on purpose - "it may fall, cross zero, or reverse outright" -
+# because the alternative deadlocks the loop, and a reversal is a full swing
+# that can clear the bound on the far side in one step.
+#
+# That matters for this ticket rather than being trivia: it is the one shape
+# where the saturation freeze and a clamp engagement coincide, so it is exactly
+# where an alarm that shared a channel with saturation would lose the clamp.
+grid_sweep = (-9000.0, -3000.0, 3000.0, 9000.0)
+grid = [(pp, g) for pp in (-1900.0, -500.0, 0.0, 500.0, 1900.0)
+        for g in grid_sweep]
+runs = {(pp, g): compute(pp, g, 0.0, t, sat_count=5, i_w=pp) for pp, g in grid}
+frozen = [k for k, d in runs.items() if d.frozen]
+frozen_clamps = [k for k in frozen if runs[k].i_clamped]
+# The property, stated independently of the control law's own branches: the
+# correction pushes AGAINST the standing integrator, and the resulting swing
+# clears the bound.
+reversals = [(pp, g) for pp, g in frozen
+             if pp * g < 0 and abs(pp + t.gain * g) > t.max_w]
+print(f"    {len(frozen)} of {len(grid)} sweep cells are frozen; "
+      f"those that also clamp: {frozen_clamps}")
+check(f"a frozen cycle CAN clamp, and only by reversing "
+      f"({len(frozen_clamps)} of {len(frozen)} frozen cells)",
+      frozen_clamps and frozen_clamps == reversals)
+check("...and a frozen cycle pushing the way it already leans never clamps - "
+      "that is the freeze doing its job",
+      not [k for k in frozen if runs[k].i_clamped and k[0] * k[1] > 0])
+check("a healthy cycle sets neither flag",
+      not any([compute(0.0, 100.0, 0.0, t).i_clamped,
+               compute(0.0, 100.0, 0.0, t).clamped]))
+
+
+# ==============================================================================
+print()
+print("5. no path reaches the wire around the clamp")
+
+
+async def _direct():
+    hass = _Hass(0.0)
+    c = Controller({"setpoint_entity": "number.sp", "max_w": 2000,
+                    "meter_source": "off"},
+                   hass, _Store(), _Pub(), stop=asyncio.Event())
+    c.dev_min, c.dev_max = -LIVE_MAX_W, LIVE_MAX_W
+    # The shape the heartbeat, shutdown() and handle_action() all use.
+    await c.write_setpoint(9999.0, force=True)
+    await c.write_setpoint(-9999.0, force=True)
+    await c.write_setpoint(float("nan"), force=True)
+    await c.write_setpoint(1500.0, force=True)
+    return hass, c
+
+
+hass_d, ctl_d = asyncio.run(_direct())
+print(f"    asked for 9999 / -9999 / nan / 1500 W; the device saw "
+      f"{hass_d.writes}")
+check("a direct out-of-range write is clamped, not passed through",
+      hass_d.writes[:2] == [2000.0, -2000.0])
+check("a nan is refused and becomes 0 W, per 11.1 rule 1",
+      hass_d.writes[2] == 0.0)
+check("...and is NOT counted as a clamp engagement - it is a transport bug",
+      sum(1 for e in ctl_d.events if REASON_CODE in e) == 2)
+check("an in-range value is untouched", hass_d.writes[3] == 1500.0)
+check("every emitted frame satisfies |emitted| <= the rating",
+      all(abs(w) <= 2000.0 for w in hass_d.writes))
+
+print()
+if fails:
+    print(f"{len(fails)} FAILED: {', '.join(fails)}")
+    sys.exit(1)
+print("all checks passed")

goodwe_controller/test_freeze.py

@@ -2,7 +2,10 @@
 
     python3 test_freeze.py
 
-Three parts, and the last two are the ones that matter:
+Six parts. Parts 2 and 3 are the acceptance argument; parts 5 and 6 exist
+because TEST-06 found three mutations that survived parts 1-4 green - the
+evaluation POSITION inside cycle(), the NOT COVERED status string, and the
+shipped `meter_freeze_s` itself:
 
   1. the predicate's boundaries and the edge-trigger, table-driven;
   2. SILENT ON REAL CONVERGED DATA. `scenarios/p1-age-2026-08-26.jsonl.gz` is
@@ -18,6 +21,14 @@ Three parts, and the last two are the ones that matter:
      repo is next to this one (or `$GOODWE_SIM`), and an equivalent local stub
      otherwise. Both are exercised; the run says which one it used.
 
+  4. THE WIRING: the real `Controller.cycle()`, asserted on the service call
+     that leaves the process;
+  5. WHERE IN `cycle()` the detector is evaluated - by consequence, not by
+     source order. It runs after `write_setpoint()`, and that is what makes two
+     compositions safe (see the section for both);
+  6. WHAT THE STATUS PAGE SAYS about an uncovered transport, and the shipped
+     threshold read back out of `config.yaml`.
+
 ⚠️ Part 3 runs in WALL CLOCK - `unchanged_s` is `time.monotonic()` and the
 transport really polls - so it drives the detector at `hold_s=10`, not the
 shipped 300. The THRESHOLD is config; the MECHANISM is what is under test, and
@@ -57,6 +68,7 @@ import asyncio
 import gzip
 import json
 import os
+import re
 import subprocess
 import sys
 import time
@@ -79,6 +91,29 @@ HERE = Path(__file__).resolve().parent
 # The live install's numbers, which are the ones the exposure is written at.
 LIVE_MAX_W = 5000.0
 
+# --------------------------------------------------------------------------- #
+# THE SHIPPED THRESHOLD, READ FROM config.yaml (TEST-06 / AC3)
+# --------------------------------------------------------------------------- #
+# ⚠️ `meter_freeze_s: 300` used to appear in this file only as the literal 300,
+# retyped six times, so `300 -> 3600` in config.yaml left every check here
+# green. Everything below is now driven off the SHIPPED value, and the value
+# itself is pinned in test_validate.py the way MAINT-04 pins the other defaults.
+#
+# Regex, not PyYAML: the add-on image installs py3-aiohttp/py3-paho-mqtt only,
+# and a check that skips on ImportError is not a check.
+_CFG_TXT = (HERE / "config.yaml").read_text(encoding="utf-8")
+
+
+def _cfg_default(key):
+    """The single `  key: <number>` default line in config.yaml's options block."""
+    found = re.findall(rf"^  {key}: (-?\d+(?:\.\d+)?)\s*$", _CFG_TXT, re.M)
+    return float(found[0]) if len(found) == 1 else None
+
+
+SHIPPED_HOLD_S = _cfg_default("meter_freeze_s")
+SHIPPED_DEADBAND_W = _cfg_default("deadband_w")
+SHIPPED_MAX_W = _cfg_default("max_w")
+
 
 def check(name, cond):
     print(f"  {'ok  ' if cond else 'FAIL'} {name}")
@@ -135,6 +170,35 @@ check("the reason names both terms",
       "unchanged over 300" in wd.reason and "command over 4750" in wd.reason)
 
 
+# --------------------------------------------------------------------------- #
+# 1b. the SHIPPED threshold, and the two properties it has to have (AC3)
+# --------------------------------------------------------------------------- #
+# ⚠️ This is the number the whole ticket is an argument about, and it was pinned
+# nowhere: `meter_freeze_s: 300 -> 3600` used to leave this file and
+# test_validate.py both green. test_validate.py pins the literal in MAINT-04's
+# manner; here it is pinned by its CONSEQUENCES, so a schema-legal value that
+# gives up the argument goes red even though it is a legal value.
+print("the shipped meter_freeze_s (AC3)")
+check(f"config.yaml's numeric defaults were read (freeze {SHIPPED_HOLD_S}, "
+      f"deadband {SHIPPED_DEADBAND_W}, max_w {SHIPPED_MAX_W})",
+      None not in (SHIPPED_HOLD_S, SHIPPED_DEADBAND_W, SHIPPED_MAX_W))
+check("the code default and the shipped default are the same number - "
+      "FreezeWatchdogConfig() is a default, config.yaml is the ship",
+      FreezeWatchdogConfig().hold_s == SHIPPED_HOLD_S)
+check("this file's `tuning()` really is config.yaml's deadband, so the "
+      "mutual-exclusion arithmetic below is about the shipped law",
+      tuning().deadband_w == SHIPPED_DEADBAND_W)
+
+# The upper bound is money: config.yaml's own comment says 300 s is "still
+# inside the 900 s quarter that bills the capacity tariff". A hold that outlives
+# the quarter notifies after the peak is already billed.
+QUARTER_S = 900.0
+check(f"the alarm still lands inside the {QUARTER_S:.0f} s billing quarter "
+      f"({SHIPPED_HOLD_S:.0f} s hold)", SHIPPED_HOLD_S < QUARTER_S)
+# The lower bound is the conjunction itself - see the derivation below, which
+# now runs off the shipped numbers rather than off two retyped literals.
+
+
 # --------------------------------------------------------------------------- #
 # 2. silent on 40 minutes of real converged behaviour
 # --------------------------------------------------------------------------- #
@@ -183,10 +247,10 @@ def replay(hold_s, max_w, cycle_floor_s=15.0):
 
 
 for mw in (2000.0, LIVE_MAX_W):
-    wd_r, peak_cmd, peak_unchanged, fired = replay(300.0, mw)
+    wd_r, peak_cmd, peak_unchanged, fired = replay(SHIPPED_HOLD_S, mw)
     print(f"    max_w {mw:.0f}: worst |command| {peak_cmd:.0f} W (rail "
           f"{rail_w(mw):.0f} W), worst unchanged {peak_unchanged:.1f} s "
-          f"(hold 300 s), episodes {wd_r.episodes}")
+          f"(hold {SHIPPED_HOLD_S:.0f} s), episodes {wd_r.episodes}")
     check(f"max_w {mw:.0f}: never alarms on the converged capture", fired is None)
     check(f"max_w {mw:.0f}: and the rail term had margin to spare",
           peak_cmd < rail_w(mw))
@@ -194,7 +258,7 @@ for mw in (2000.0, LIVE_MAX_W):
 # The margin on the OTHER term, as numbers rather than as trust. Both figures
 # are quoted in config.yaml and freeze.py, so they are re-measured every run and
 # a capture swapped underneath them cannot leave the prose saying the old thing.
-_, _, worst_unchanged, _ = replay(300.0, LIVE_MAX_W)
+_, _, worst_unchanged, _ = replay(SHIPPED_HOLD_S, LIVE_MAX_W)
 gaps, last, prev = [], rows[0]["t"], None
 for r in rows:
     if prev is None or r["pwr"] != prev:
@@ -208,7 +272,8 @@ check("worst observed unchanged_s is the 8 s the docs quote",
       7.5 < worst_unchanged < 8.5)
 check("longest distinct-reading interval is the 15.4 s the docs quote",
       15.0 < max(gaps) < 16.0)
-check("300 s is at least 15x the worst of the two", 300.0 >= 15 * max(gaps))
+check(f"the shipped {SHIPPED_HOLD_S:.0f} s is at least 15x the worst of the two",
+      SHIPPED_HOLD_S >= 15 * max(gaps))
 
 # --------------------------------------------------------------------------- #
 # 2b. TEL-05's case, reconstructed, because the capture cannot contain it
@@ -226,22 +291,26 @@ check("300 s is at least 15x the worst of the two", 300.0 >= 15 * max(gaps))
 # -14.2 W) rather than invented: one hour of a perfectly healthy converged meter
 # that happens not to move.
 print("TEL-05's low-power case - a converged meter that legitimately repeats")
-tel05 = FreezeWatchdog(FreezeWatchdogConfig(hold_s=300))
+tel05 = FreezeWatchdog(FreezeWatchdogConfig(hold_s=SHIPPED_HOLD_S))
 t5 = tuning(LIVE_MAX_W)
 tgt, iw, sc = 0.0, 0.0, 0
 bare_would_fire = False
 tel05_cmd = 0.0
-for k in range(3600):
+# Long enough that the REJECTED bare threshold has to get its chance even if
+# someone raises meter_freeze_s - the mutation must be caught by the pins above,
+# not by this case going red for an incidental reason.
+TEL05_S = max(3600, int(SHIPPED_HOLD_S) + 300)
+for k in range(TEL05_S):
     if k % 15 == 0:                       # cycle_floor_s, the only trigger left
         d = compute(prev_w=tgt, grid_w=-14.2, actual_w=tgt, tuning=t5,
                     sat_count=sc, i_w=iw)
         tgt, iw, sc = d.target_w, d.i_w, d.sat_count
     tel05_cmd = max(tel05_cmd, abs(tgt))
     # The REJECTED design, written out so the case can be shown to be real.
-    bare_would_fire = bare_would_fire or float(k) >= 300
+    bare_would_fire = bare_would_fire or float(k) >= SHIPPED_HOLD_S
     tel05.evaluate(float(k), tgt, LIVE_MAX_W, T0 + timedelta(seconds=k))
-print(f"    an hour at -14.2 W: worst |command| {tel05_cmd:.0f} W, "
-      f"unchanged_s reaches 3599 s, episodes {tel05.episodes}")
+print(f"    {TEL05_S / 60:.0f} min at -14.2 W: worst |command| {tel05_cmd:.0f} W, "
+      f"unchanged_s reaches {TEL05_S - 1} s, episodes {tel05.episodes}")
 check("the bare unchanged_s threshold TEL-05 rejected WOULD fire here",
       bare_would_fire)
 check("the conjunction does not - this is what the rail term buys",
@@ -255,8 +324,11 @@ check("...and the command stayed nowhere near the rail",
 # figure is inside the deadband, so the command there is parked at 0 W. If
 # someone lowers meter_freeze_s or narrows the deadband, this is the check that
 # should stop them.
-DEADBAND_W = 15.0
-slowest_healthy_w = 3600.0 / 300.0
+DEADBAND_W = SHIPPED_DEADBAND_W          # config.yaml's, not a retyped 15
+slowest_healthy_w = 3600.0 / SHIPPED_HOLD_S
+print(f"    at the shipped {SHIPPED_HOLD_S:.0f} s hold, the slowest healthy "
+      f"meter that still looks unchanged is {slowest_healthy_w:.1f} W, against "
+      f"a {DEADBAND_W:.0f} W deadband")
 check("a healthy meter slow enough to look unchanged is inside the deadband",
       slowest_healthy_w < DEADBAND_W)
 _park = compute(prev_w=0.0, grid_w=-slowest_healthy_w, actual_w=0.0,
@@ -277,11 +349,19 @@ check("...and the same replay DOES alarm once both terms are made reachable",
 # 3. a genuinely frozen meter, over real HTTP, through the real transport
 # --------------------------------------------------------------------------- #
 def find_hwsim():
-    """The rig's own fake meter, if the infra repo is reachable."""
+    """The rig's own fake meter, if the infra repo is reachable.
+
+    ⚠️ `HERE.parents[1]` only exists when this package sits at least two levels
+    below the filesystem root - it raised IndexError and took the WHOLE suite
+    down on a checkout at `C:/goodwe_controller`, which is a failure of the
+    lookup, not of the thing being tested. Guarded, so a shallow checkout falls
+    through to the stub like any other missing sibling repo.
+    """
     cands = []
     if os.environ.get("GOODWE_SIM"):
         cands.append(Path(os.environ["GOODWE_SIM"]) / "hwsim.py")
-    cands.append(HERE.parents[1] / "goodwe" / "sim" / "hwsim.py")
+    if len(HERE.parents) > 1:
+        cands.append(HERE.parents[1] / "goodwe" / "sim" / "hwsim.py")
     for c in cands:
         if c.exists():
             return c
@@ -379,7 +459,15 @@ def with_server(argv, port, fn):
 
 
 hw = find_hwsim()
-print(f"frozen meter over HTTP - using {'the rig hwsim at ' + str(hw) if hw else 'the local stub'}")
+# ⚠️ WHICH TRANSPORT BACKED PART 3 IS PART OF THE RESULT, and it is repeated in
+# the summary at the end of the run. The two are not equivalent: pointed at the
+# real `sim/hwsim.py` the rig path failed 1 run in 3 (a 16 s window against a
+# 10 s hold, when hwsim.serve() is slow to start), while the stub is tuned never
+# to fail. A green log that does not say which one ran is a green log that can
+# have quietly substituted the weaker stand-in - the same shape as an assertion
+# that cannot fail, from the other end.
+PART3_TRANSPORT = f"the rig hwsim at {hw}" if hw else "the local stub"
+print(f"frozen meter over HTTP - using {PART3_TRANSPORT}")
 if hw:
     def argv_for(mode):
         return [HWSIM_DRIVER, "8791" if mode == "freeze" else "8792", mode,
@@ -454,11 +542,17 @@ class _Hass:
         # runaway under test never happens - which would have made this a check
         # that passes for the wrong reason.
         self.batt = 0.0
+        # ⚠️ The dead-poll-task case (AC1's second half): every input reads
+        # None, exactly as it does when the transport task has died while the
+        # controller keeps cycling.
+        self.dead = False
 
     async def limits(self, entity):
         return (-5000.0, 5000.0, 1.0)
 
     async def number(self, entity, invert=False):
+        if self.dead:
+            return None
         return {"sensor.grid": self.grid, "sensor.soc": 50.0,
                 "sensor.batt": self.batt}.get(entity)
 
@@ -479,29 +573,113 @@ class _Source:
         self.unchanged_s = unchanged_s
 
 
+# ⚠️ meter_freeze_s is deliberately NOT in here. A controller built with the key
+# absent must land on the shipped number by itself, and that is asserted below -
+# supplying it here would test this dict instead of the shipped default.
+STALE_INPUT_S = 15.0
+
+
+def _opts(**over):
+    o = {"setpoint_entity": "number.sp", "meter_entity": "sensor.grid",
+         "soc_entity": "sensor.soc", "batt_entity": "sensor.batt",
+         "meter_source": "off", "max_w": LIVE_MAX_W, "gain": 0.6,
+         "slew_w": 1000, "deadband_w": SHIPPED_DEADBAND_W,
+         "target_grid_w": -10, "step_w": 10, "heartbeat_s": 10,
+         "stale_input_s": STALE_INPUT_S}
+    o.update(over)
+    return o
+
+
+# ⚠️ TWO SURFACES, AND EVERY ASSERTION BELOW SAYS WHICH ONE IT IS ABOUT.
+# The first cut of this helper selected by SERVICE, which measured "any guard's
+# notification" while every assertion built on it was named for THIS guard's.
+# That was true only because `check_meter_frozen()` was the sole
+# `persistent_notification.create` in `app/`; SAFETY-03 (#12) adds a second one
+# (`goodwe_output_clamp`) raised by scenarios that rail the command on purpose,
+# and eight assertions here went red against it - AC1's core check included.
+#
+# Blanket id-keying is NOT the repair. Three of those eight are claims about the
+# WHOLE notification surface, and narrowing them to this guard's id would have
+# silently shrunk a claim rather than fixed a conflation - which is the defect
+# class this card exists to close. So both surfaces are available by name, and
+# each assertion picks one deliberately.
+FREEZE_NOTE_ID = "goodwe_meter_frozen"
+
+
+def all_notes_of(hass):
+    """EVERY HA persistent notification raised this run, whoever raised it."""
+    return [d for dom, svc, d in hass.calls
+            if (dom, svc) == ("persistent_notification", "create")]
+
+
+def _is_freeze_note(d):
+    """Is this notification the freeze detector's?
+
+    ⚠️ THE ID **OR** THE TITLE, and the `or` is measured rather than tidy.
+    Keyed on the id alone, renaming the id empties every list in this file and
+    SIX assertions collapse together - so the one check whose subject IS the id
+    could no longer fail on its own, in the file about assertions that cannot
+    fail. Recognising the guard by what it says as well leaves the rename
+    exactly one red: the id's own check. Measured both ways:
+
+        selector                      vs #12's app/    id renamed
+        by service (the first cut)      8 red            1 red
+        by id alone                     3 red            6 red
+        by id or title (this)           3 red            1 red
+
+    The union cannot re-admit another guard's alarm unless that guard also
+    calls itself frozen, which would be a confusable alarm on its own account.
+    """
+    return (d.get("notification_id") == FREEZE_NOTE_ID
+            or "frozen" in str(d.get("title", "")).lower())
+
+
+def notes_of(hass):
+    """Only THIS guard's - see _is_freeze_note()."""
+    return [d for d in all_notes_of(hass) if _is_freeze_note(d)]
+
+
+def notes_by_text_of(hass):
+    """This guard's, recognised by what it SAYS and never by its id.
+
+    Exists for the two assertions whose subject IS the id: selected by the id,
+    both would be true by construction.
+    """
+    return [d for d in all_notes_of(hass)
+            if "frozen" in str(d.get("title", "")).lower()]
+
+
 def wired(unchanged_s, grid, cycles=60, **over):
+    """Returns (hass, controller, trace).
+
+    `trace` is one row per cycle - (command after the cycle, the watchdog's
+    level, notifications raised so far) - which is what AC1 needs: the
+    QUESTION IS NOT WHETHER THE ALARM HAPPENS BUT ON WHICH CYCLE.
+    """
     async def go():
         hass = _Hass(grid)
-        c = Controller(dict(
-            {"setpoint_entity": "number.sp", "meter_entity": "sensor.grid",
-             "soc_entity": "sensor.soc", "batt_entity": "sensor.batt",
-             "meter_source": "off", "max_w": LIVE_MAX_W, "gain": 0.6,
-             "slew_w": 1000, "deadband_w": 15, "target_grid_w": -10,
-             "step_w": 10, "heartbeat_s": 10, "stale_input_s": 15},
-            **over), hass, _Store(), _Pub(), stop=asyncio.Event())
+        c = Controller(_opts(**over), hass, _Store(), _Pub(),
+                       stop=asyncio.Event())
         c.auto = True
         c.dev_min, c.dev_max = -5000.0, 5000.0
         c.p1_source = _Source(unchanged_s)
+        trace = []
         for _ in range(cycles):
             await c.read_inputs()
             await c.cycle()
-        return hass, c
+            trace.append((c.target, c.freeze_wd.active, len(notes_of(hass))))
+        return hass, c, trace
     return asyncio.run(go())
 
 
-hass_f, ctl_f = wired(3600.0, 4000.0)
-notes = [d for dom, svc, d in hass_f.calls
-         if (dom, svc) == ("persistent_notification", "create")]
+# ⚠️ SAFETY-03 (#12) arrived at the same diagnosis independently and added a
+# `frozen_notes()` keyed on the id. `notes_of()` above subsumes it - same id,
+# plus the title fallback that keeps the id's own check independently
+# falsifiable, plus `all_notes_of()` for the claims that are about the whole
+# surface rather than about this guard.
+hass_f, ctl_f, trace_f = wired(3600.0, 4000.0)
+notes = notes_of(hass_f)                      # THIS guard's
+all_notes = all_notes_of(hass_f)              # the whole surface
 # The status row lives behind `p1_enabled`, which is what a homewizard_local
 # install has. Flipped here rather than plumbing a whole P1 transport in - the
 # row's own content is what is under test.
@@ -509,9 +687,28 @@ ctl_f.p1_enabled = True
 rows = [c for c in ctl_f.checks() if "METER MAY BE FROZEN" in c["text"]]
 print(f"    frozen at +4000 W: command ran to {ctl_f.target:.0f} W, "
       f"{len(notes)} notification(s), {len(rows)} red status row(s)")
-check("the shipped cycle() raises exactly one HA notification", len(notes) == 1)
+# SURFACE-WIDE, deliberately, and the second guard has now landed. SAFETY-03
+# ships `goodwe_output_clamp`, and this scenario - a runaway loop winding into
+# the rail - raises it legitimately: the loop asks for more than the rating and
+# is clamped. So the answer to "is this scenario still meant to raise exactly
+# one alarm" is NO, it raises exactly two, and BOTH ARE NAMED here rather than
+# the claim being narrowed until it went green again. A third guard has to come
+# back to this line, which is the whole point of keeping one assertion in the
+# file that accounts for the controller's entire alarm output.
+_ids = sorted(d.get("notification_id") for d in all_notes)
+print(f"    the whole notification surface this run: {_ids}")
+check("the whole notification surface carried exactly two alarms this run - "
+      "SAFETY-18's and SAFETY-03's, both named",
+      _ids == ["goodwe_meter_frozen", "goodwe_output_clamp"])
+# THIS GUARD'S, keyed on the id.
+check("...and the freeze detector is the one that raised it", len(notes) == 1)
+# ⚠️ Selected by TEXT, not by id - see notes_by_text_of(). One of the two
+# assertions whose subject IS the id (the other is the stability check in part
+# 5), so it must not be selected by the thing it is checking, and it has to be
+# able to fail while everything else stays green.
 check("...with a fixed notification_id so repeats replace, not stack",
-      notes and notes[0].get("notification_id") == "goodwe_meter_frozen")
+      [d.get("notification_id") for d in notes_by_text_of(hass_f)]
+      == [FREEZE_NOTE_ID])
 check("...and it says the controller is still running",
       bool(notes) and "STILL RUNNING" in notes[0]["message"])
 check("the status page carries a failed row saying so",
@@ -522,17 +719,293 @@ check("the event log names it", any("METER FROZEN" in e for e in ctl_f.events))
 check("and it does NOT command 0 W - this cut is an alarm only",
       abs(ctl_f.target) >= rail_w(LIVE_MAX_W))
 
-hass_n, ctl_n = wired(3600.0, -14.2)
-check("wired up, TEL-05's converged case still raises nothing",
-      not [1 for dom, svc, _ in hass_n.calls if svc == "create"])
-hass_m, ctl_m = wired(2.0, 8000.0)
-check("wired up, a real railed load against a moving meter raises nothing",
-      not [1 for dom, svc, _ in hass_m.calls if svc == "create"]
-      and abs(ctl_m.target) >= rail_w(LIVE_MAX_W))
-check("an uncovered transport (no unchanged_s) raises nothing, and says so",
-      not [1 for dom, svc, _ in wired(None, 4000.0)[0].calls if svc == "create"])
+# ⚠️ THE THREE SCENARIOS THAT SAFETY-03 FORCED A DECISION ON, decided one at a
+# time and not reflexively narrowed to green. Measured on the merged tree:
+#
+#   scenario                              surface  ids                    freeze
+#   frozen meter, railed command (above)     2      frozen + clamp          1
+#   TEL-05 converged, -14.2 W                0      -                       0
+#   moving meter, a real 8 kW load           1      clamp                   0
+#   uncovered transport, no unchanged_s      1      clamp                   0
+#
+# CONVERGED stays SURFACE-WIDE. At the operating point this controller exists to
+# hold, the correct behaviour is that the whole add-on has nothing to say - not
+# merely that the freeze guard has nothing to say. Nothing about SAFETY-03
+# weakens that claim, and it still holds, so narrowing it would give away a real
+# property for nothing.
+#
+# The other two NARROW to notes_of(), and the reason is the same in both: the
+# clamp alarm there is CORRECT and is SAFETY-03's subject, not this file's. A
+# genuine 8 kW load really does drive the loop past the rating; an uncovered
+# transport really does not stop it doing so. Asserting silence across the whole
+# surface would make this file fail whenever a different guard correctly does
+# its job - a claim about somebody else's behaviour wearing this file's name.
+# What each still owns is the load-bearing half: THE FREEZE DETECTOR SAID
+# NOTHING. The surface is printed rather than asserted, so a reader can still
+# see what else fired without this file grading it.
+hass_n, ctl_n, _ = wired(3600.0, -14.2)
+check("wired up, TEL-05's converged case leaves the WHOLE SURFACE silent - at "
+      "the operating point the add-on should have nothing at all to say",
+      not all_notes_of(hass_n))
+
+hass_m, ctl_m, _ = wired(2.0, 8000.0)
+print(f"    real 8 kW load, moving meter: surface "
+      f"{sorted(d.get('notification_id') for d in all_notes_of(hass_m))}, "
+      f"freeze {len(notes_of(hass_m))}")
+check("wired up, a real railed load against a moving meter raises nothing FROM "
+      "THIS GUARD (the clamp alarm there is SAFETY-03's and is correct)",
+      not notes_of(hass_m) and abs(ctl_m.target) >= rail_w(LIVE_MAX_W))
+
+hass_u = wired(None, 4000.0)[0]
+print(f"    uncovered transport: surface "
+      f"{sorted(d.get('notification_id') for d in all_notes_of(hass_u))}, "
+      f"freeze {len(notes_of(hass_u))}")
+check("an uncovered transport (no unchanged_s) raises nothing FROM THIS GUARD, "
+      "which is the honest report of a detector that cannot see",
+      not notes_of(hass_u))
+
+
+# --------------------------------------------------------------------------- #
+# 5. WHERE in cycle() the detector is evaluated (TEST-06 / AC1)
+# --------------------------------------------------------------------------- #
+# ⚠️ WHERE THE BOUNDARY ACTUALLY IS - AND IT IS NOT write_setpoint().
+# The first version of this comment said the detector runs "after
+# write_setpoint()" and grades "the command that has just gone on the wire".
+# TEST-06's reviewer disproved both halves by mutation:
+#
+#     N3  move check_meter_frozen() to immediately BEFORE write_setpoint()
+#         -> green, and CORRECTLY green
+#
+# because `self.target = resolution.target_w` is assigned two lines above the
+# write, `write_setpoint()` clamps only a local `value`, and it can skip the
+# write entirely (`if not (changed or force): return`). So what the detector
+# grades is `self.target` - the arbiter's resolved intent, PRE device clamp and
+# possibly never emitted - and the invariant these checks pin is:
+#
+#     check_meter_frozen() runs AFTER `self.target = resolution.target_w`
+#
+# That distinction is not pedantry. A check more robust than its own
+# explanation is how the next person moves the call ABOVE the assignment
+# believing they had preserved the stated rule.
+#
+# Both properties below are asserted by an OBSERVABLE CONSEQUENCE rather than by
+# source order, so semantic-preserving refactors stay green (measured by the
+# reviewer: renaming the method, and calling it from a helper that itself runs
+# last, both survive - the suite drives `await c.cycle()` and never names the
+# method):
+#
+#   (a) BOTH TERMS MUST DESCRIBE THE SAME MOMENT. The command it grades has to
+#       be the one THIS cycle resolved, judged against how long the meter that
+#       chose it has stood still. Evaluated above the assignment it grades the
+#       PREVIOUS cycle's command against THIS cycle's meter - a pairing that was
+#       never true of any moment - and the alarm arrives a whole cycle late.
+#   (b) THE DEAD-POLL-TASK COMPOSITION. When the poll task dies the inputs go
+#       stale, the arbiter resolves 0 W, and the detector - evaluated after that
+#       resolution lands in self.target - correctly sees an unrailed command and
+#       CLEARS. Evaluated above the assignment it would still be looking at the
+#       railed command from before the failsafe, and would keep the alarm
+#       standing over a controller that is already commanding 0 W.
+print("WHERE the detector is evaluated in cycle() - the ordering AC1 protects")
+
+_railed = [i for i, (t, _, _) in enumerate(trace_f)
+           if abs(t) >= rail_w(LIVE_MAX_W)]
+_alarmed = [i for i, (_, _, n) in enumerate(trace_f) if n >= 1]
+_first_railed = _railed[0] if _railed else None
+_first_alarm = _alarmed[0] if _alarmed else None
+print(f"    ramp to the rail: first railed command on cycle {_first_railed}, "
+      f"first notification on cycle {_first_alarm}, over {len(trace_f)} cycles")
+# Without this the equality below could be satisfied on cycle 0, where "the same
+# cycle" and "one cycle later" are indistinguishable.
+check("the command takes several cycles to reach the rail, so 'same cycle' and "
+      "'one cycle later' are different observations",
+      _first_railed is not None and _first_railed >= 1
+      and len(trace_f) > _first_railed + 1)
+check("the alarm lands on the SAME cycle the command reaches the rail - "
+      "evaluated after `self.target = resolution.target_w` it grades the "
+      "command THIS cycle resolved; evaluated above that assignment it grades "
+      "the previous one and arrives a cycle late",
+      _first_alarm is not None and _first_alarm == _first_railed)
+
+
+def dead_poll(after_cycles=20, dead_cycles=4, revived_cycles=20):
+    """Alarm on a railed command, then kill the poll task and keep cycling.
+
+    The real thing: the transport task dies, every input reads None, and after
+    `stale_input_s` the arbiter's P_SAFETY stop resolves 0 W. `inputs_bad_since`
+    is backdated rather than slept through - the clock is wall clock, and the
+    mechanism rather than the wait is what is under test.
+    """
+    async def go():
+        hass = _Hass(4000.0)
+        c = Controller(_opts(), hass, _Store(), _Pub(), stop=asyncio.Event())
+        c.auto = True
+        c.dev_min, c.dev_max = -5000.0, 5000.0
+        c.p1_source = _Source(3600.0)
+        for _ in range(after_cycles):
+            await c.read_inputs()
+            await c.cycle()
+        before = (c.target, c.freeze_wd.active, len(notes_of(hass)))
+        hass.dead = True
+        trace = []
+        for _ in range(dead_cycles):
+            await c.read_inputs()
+            if c.inputs_bad_since is not None:
+                c.inputs_bad_since = (datetime.now(timezone.utc)
+                                      - timedelta(seconds=STALE_INPUT_S + 1))
+            await c.cycle()
+            trace.append((c.target, c.freeze_wd.active, len(notes_of(hass))))
+        # ...and then the transport comes back, against a meter that is still
+        # frozen. The loop re-rails and this is a NEW episode - the alarm is
+        # allowed, indeed required, to speak again.
+        hass.dead = False
+        revived = []
+        for _ in range(revived_cycles):
+            await c.read_inputs()
+            await c.cycle()
+            revived.append((c.target, c.freeze_wd.active, len(notes_of(hass))))
+        # ⚠️ by TEXT: "the second episode REPLACED the first" is a claim about
+        # the id, so the list it is checked against must not be selected by the
+        # id - that would make it true by construction.
+        return before, trace, revived, notes_by_text_of(hass), c
+    return asyncio.run(go())
+
+
+_before, _dead, _revived, _freeze_notes, _ctl_d = dead_poll()
+_zeroed = [i for i, (t, _, _) in enumerate(_dead) if t == 0.0]
+print(f"    poll task killed: alarming at {_before[0]:+.0f} W "
+      f"(active={_before[1]}, {_before[2]} notification(s)) -> "
+      + ", ".join(f"cycle {i}: {t:+.0f} W active={a} notes={n}"
+                  for i, (t, a, n) in enumerate(_dead)))
+check("the episode really was standing before the poll task died - otherwise "
+      "the release below is vacuous",
+      _before[1] and _before[2] == 1 and abs(_before[0]) >= rail_w(LIVE_MAX_W))
+check("a dead poll task drives the command to 0 W",
+      bool(_zeroed) and _zeroed[0] == 0)
+check("...and on THAT SAME cycle the alarm is already clear, because the "
+      "detector ran after 0 W was resolved into self.target, not before it",
+      bool(_zeroed) and not _dead[_zeroed[0]][1])
+check("...and it stays clear for as long as the failsafe holds it there",
+      _dead and not any(a for _, a, _ in _dead))
+# ⚠️ "and it raises nothing new while parked" is NOT asserted here, and the
+# reason matters more than the deletion. It was dropped as REDUNDANT, not as
+# undecidable: TEST-06's reviewer falsified it in one line - move the
+# `hass.call` above `if not fired: return` so the detector notifies every cycle,
+# and notifications appear in exactly these parked cycles (that mutation takes
+# this file RED 9). My first note here claimed no mutation could break it, which
+# was the very inference this file exists to distrust, made about this file.
+# The deletion stands because the exact count below catches that same mutation
+# nine times over - no coverage was lost - and the honest form of the claim is
+# "I tried to break it and here is what happened", never "I could not, so it
+# cannot".
+
+# ⚠️ AND THE OTHER HALF, or "no second notification" is a claim no mutation can
+# break: when the transport comes back against a meter that is STILL frozen the
+# loop re-rails, and that is a new episode which MUST speak. What must not
+# happen is a second notification stacking up beside the first.
+_re_railed = [i for i, (t, _, _) in enumerate(_revived)
+              if abs(t) >= rail_w(LIVE_MAX_W)]
+print(f"    transport revived: command re-rails on cycle "
+      f"{_re_railed[0] if _re_railed else None}, "
+      f"{_ctl_d.freeze_wd.episodes} episode(s), {len(_freeze_notes)} "
+      f"notification(s) from this guard, "
+      f"ids {sorted({n.get('notification_id') for n in _freeze_notes})}")
+# A PRECONDITION, not a discriminating check - the same role as "the command
+# takes several cycles to reach the rail" above, and labelled the same way:
+# without it the two checks below are satisfied by a controller that never came
+# back. The crudest falsifier (never file the loop claim) takes most of this
+# file red, which is the signature of a precondition rather than a check; the
+# narrowest one measured is a stale-input stop that never releases.
+check("PRECONDITION: a revived transport against a still-frozen meter re-rails "
+      "the command",
+      bool(_re_railed))
+check("...which is a SECOND episode, and it alarms again on the cycle it rails",
+      _ctl_d.freeze_wd.episodes == 2
+      and bool(_re_railed) and _revived[_re_railed[0]][2] == _before[2] + 1)
+# ⚠️ STABILITY, not the value - the value is pinned once, above. Renaming the
+# id must fail that check and NOT this one; the two say different things and
+# each has to be able to go red on its own.
+check("...on the same notification_id, so the second REPLACES the first "
+      "instead of stacking a second one beside it",
+      len(_freeze_notes) == 2
+      and len({n.get("notification_id") for n in _freeze_notes}) == 1)
+
+
+# --------------------------------------------------------------------------- #
+# 6. what the status page SAYS about coverage (TEST-06 / AC2)
+# --------------------------------------------------------------------------- #
+# ⚠️ The check above only ever asserted that an uncovered transport is SILENT,
+# which a status page claiming `armed` on a guard that cannot run also satisfies.
+# The AC was that the detector reports uncovered transports *and says so*, so
+# the string is what gets asserted here, in both directions: the uncovered row
+# must not claim `armed`, and the covered row must still claim it - or "does not
+# say armed" would be satisfiable by deleting the armed branch outright.
+print("what the status page SAYS about coverage")
+
+
+def freeze_rows(unchanged_s, grid, **over):
+    """The freeze-detector rows of the real checks(), on a p1 install.
+
+    ⚠️ WHAT THIS DOES NOT COVER. The rows live behind `if self.p1_enabled:`, and
+    the flag is set here by hand rather than by building a real P1 transport -
+    inherited from part 4's fixture. So everything below proves "WHEN the row is
+    produced it says the right thing", and nothing below proves "the row is
+    produced on homewizard_local and not otherwise". That gate is uncovered;
+    AC2 is about the string, and widening the fixture belongs to whoever covers
+    the gate.
+    """
+    _h, ctl, _t = wired(unchanged_s, grid, cycles=3, **over)
+    # p1_enabled is what a homewizard_local install has; the row's own content
+    # is what is under test, not the transport that feeds it.
+    ctl.p1_enabled = True
+    return ctl, [r for r in ctl.checks()
+                 if r["text"].startswith("freeze detector")]
+
+
+_ctl_u, _rows_u = freeze_rows(None, 4000.0, meter_source="ha_dsmr")
+_ctl_c, _rows_c = freeze_rows(2.0, -14.2)
+print(f"    uncovered: {_rows_u[0]['text'] if _rows_u else '(no row at all)'}")
+print(f"    covered:   {_rows_c[0]['text'] if _rows_c else '(no row at all)'}")
+check("an uncovered transport gets exactly one freeze-detector row",
+      len(_rows_u) == 1)
+check("...and it says NOT COVERED",
+      bool(_rows_u) and "NOT COVERED" in _rows_u[0]["text"])
+check("...and it does NOT claim the guard is armed - that would be the status "
+      "page lying on behalf of a guard that cannot run",
+      bool(_rows_u) and "armed" not in _rows_u[0]["text"])
+check("...and it names the meter_source it is not covering, so the operator "
+      "knows which install this is",
+      bool(_rows_u) and "ha_dsmr" in _rows_u[0]["text"])
+check("...and it names homewizard_local as the transport that would be covered",
+      bool(_rows_u) and "homewizard_local" in _rows_u[0]["text"])
+check("...flagged as a warning rather than a silent ok",
+      bool(_rows_u) and not _rows_u[0]["ok"] and _rows_u[0]["warn"])
+
+check("a COVERED transport gets exactly one freeze-detector row",
+      len(_rows_c) == 1)
+check("...and that one DOES say armed - without this, 'the uncovered row does "
+      "not say armed' is satisfied by deleting the armed branch",
+      bool(_rows_c) and "armed" in _rows_c[0]["text"]
+      and "NOT COVERED" not in _rows_c[0]["text"])
+check("...and it quotes the hold and the rail it is armed at, derived from the "
+      "config the controller was actually built with",
+      bool(_rows_c)
+      and f"{_ctl_c.freeze_wd.cfg.hold_s:.0f} s unchanged" in _rows_c[0]["text"]
+      and f"{rail_w(LIVE_MAX_W):.0f} W" in _rows_c[0]["text"])
+check("...as an ok row, since a covered armed guard is not a warning",
+      bool(_rows_c) and _rows_c[0]["ok"] and not _rows_c[0]["warn"])
+
+# AC3's other half, through the built object rather than through a literal: the
+# opts dict does NOT carry meter_freeze_s, so this is the number an install that
+# leaves the key at its config.yaml default actually lands on.
+print(f"    a Controller built with meter_freeze_s ABSENT holds "
+      f"{_ctl_c.freeze_wd.cfg.hold_s:.0f} s (config.yaml ships "
+      f"{SHIPPED_HOLD_S:.0f} s)")
+check("a Controller built with the key absent lands on the SHIPPED hold, so "
+      "config.yaml and main.py's fallback cannot drift apart unnoticed",
+      _ctl_c.freeze_wd.cfg.hold_s == SHIPPED_HOLD_S)
 
 print()
+print(f"part 3 (the live HTTP transport) ran against: {PART3_TRANSPORT}")
 if fails:
     print(f"{len(fails)} FAILED: {', '.join(fails)}")
     sys.exit(1)

goodwe_controller/test_static_tariff.py

@@ -0,0 +1,861 @@
+"""Runnable check for static day/night and fully-fixed tariffs.  `python3 test_static_tariff.py`
+
+WHAT THIS FILE IS DEFENDING, in the order the ticket's acceptance criteria name
+it:
+
+  AC1  `static_profile` (§14) drives TIME-WINDOW SHIFTING for a two-period
+       tariff - the right window at the right local instant, on both sides of
+       both 2026 DST transitions, and reaching the one shiftable load the add-on
+       actually has.
+  AC2  Fully-fixed pricing DISABLES ARBITRAGE and leaves self-consumption only.
+  AC3  The Belgian scenario suite carries a static-profile regression case.
+
+THREE RULES THIS FILE HOLDS ITSELF TO, because the reviewer will:
+
+  * EVERY VERDICT IS DERIVED. No `check("the split is right", True)`. Where a
+    check needs an expected number it is computed HERE, by different arithmetic
+    than app/static_tariff.py uses - the window split is re-derived by summing
+    over samples with an independent local-hour test, the profile mean by a
+    second pass, the saving by two routes that must agree.
+
+  * NO STIMULUS IS EVALUATED WHERE THE QUANTITY IT GRADES IS DEGENERATE. A
+    two-period tariff has this trap BUILT IN and it is the main hazard here:
+
+      - THE PERIOD BOUNDARY IS THE DEGENERACY. At 07:00 and at 22:00 the "which
+        window" question and the "is it cheap" question agree under almost any
+        bug, and a probe at 12:00 cannot tell a correct wrap-around from one
+        that treats 22:00-07:00 as 22:00-24:00. So probes sit at 06:59 / 07:00 /
+        07:01 and 21:59 / 22:00 / 22:01, and a Saturday 03:00 probe exists
+        specifically because the mon-fri night window MUST NOT cover it.
+      - MEAN-CHEAP AND MINIMUM-CHEAP AGREE ON A TWO-LEVEL TARIFF. Under two
+        prices "below the mean" and "is the cheapest price" are the same set, so
+        a two-period profile cannot tell `cheap_now` from `price == min`.
+        Section 3 therefore runs a THREE-level profile where those two answers
+        differ, and asserts they differ before grading anything with it.
+      - DAY AND NIGHT MUST HAVE DIFFERENT PRICES AND NEITHER MAY BE ZERO, or the
+        whole shifting question collapses. Asserted as checks in their own
+        right, first, rather than assumed.
+      - THE DST CHECKS RUN ON THE 23-HOUR AND 25-HOUR DAYS, not on a normal day
+        where a 24-slot implementation and a correct one agree exactly.
+      - THE REPLAY DAY MUST CARRY IMPORT IN BOTH WINDOWS. A day whose whole
+        import fell in one window grades no split at all; section 6 asserts that
+        before it reports a saving.
+
+  * A FAILED READ IS NOT AN OBSERVATION. A missing static_profile is not a zero
+    price, and zero is exactly the value that makes everything look free. So
+    `static_plan` with no profile is checked to produce a read with NO
+    `.points`, and `price_at` on it must RAISE rather than answer 0.0.
+"""
+
+import gzip
+import json
+import sys
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+
+from app.price import (
+    Absence, PricePoint, PriceProduct, PriceRead, arbitrage_allowed, brussels,
+    plan_is_provisional,
+)
+from app.static_tariff import (
+    MEAN_WINDOW_DAYS, ProfileInvalid, StaticProfile, TariffPlan,
+    parse_static_profile, resolve_tariff, static_plan, static_status,
+)
+from app.validate import validate_startup_config
+
+HERE = Path(__file__).resolve().parent
+UTC = timezone.utc
+fails = []
+
+
+def check(name, cond):
+    print(f"  {'ok  ' if cond else 'FAIL'} {name}")
+    if not cond:
+        fails.append(name)
+
+
+def raises(fn, exc):
+    """True only if fn() raises EXACTLY `exc`. A different exception is False -
+    'it was refused' and 'it broke on the way to being refused' must not grade
+    the same."""
+    try:
+        fn()
+    except exc:
+        return True
+    except Exception:
+        return False
+    return False
+
+
+def reason(fn):
+    try:
+        fn()
+    except Exception as e:                                    # noqa: BLE001
+        return str(e)
+    return ""
+
+
+class _Raised:
+    def __init__(self, e):
+        self.e = e
+
+    def __eq__(self, other):
+        return False
+
+    def __hash__(self):
+        return id(self)
+
+    def __bool__(self):
+        return False
+
+    def __repr__(self):
+        return f"<raised {type(self.e).__name__}: {self.e}>"
+
+
+def derived(fn):
+    """A value a check grades. An exception becomes `_Raised`, which equals
+    nothing and is falsy - NOT a default. See test_price.py for why."""
+    try:
+        return fn()
+    except Exception as e:                                    # noqa: BLE001
+        return _Raised(e)
+
+
+def near(a, b, tol=1e-9):
+    try:
+        return abs(float(a) - float(b)) <= tol
+    except (TypeError, ValueError):
+        return False
+
+
+# --------------------------------------------------------------------------- #
+# The fixtures. Belgian day/night numbers, and their degeneracies asserted.
+# --------------------------------------------------------------------------- #
+
+DAY_P = 0.3410           # all-in EUR/kWh, day
+NIGHT_P = 0.2570         # all-in EUR/kWh, night
+FIXED_P = 0.3070         # all-in EUR/kWh, single-tariff site
+
+TWO_PERIOD = {"periods": [
+    {"name": "day", "from": "07:00", "to": "22:00", "days": "mon-fri",
+     "eur_per_kwh": DAY_P},
+    {"name": "night", "from": "22:00", "to": "07:00", "days": "mon-fri",
+     "eur_per_kwh": NIGHT_P},
+    {"name": "night", "from": "00:00", "to": "24:00", "days": "sat,sun",
+     "eur_per_kwh": NIGHT_P},
+]}
+
+FULLY_FIXED = {"periods": [
+    {"name": "fixed", "from": "00:00", "to": "24:00", "days": "all",
+     "eur_per_kwh": FIXED_P},
+]}
+
+# ⚠️ THREE LEVELS, AND SECTION 3 EXISTS BECAUSE OF IT. Under two prices "cheaper
+# than the mean" and "is the minimum price" are the same set of hours, so a
+# two-period profile cannot distinguish `cheap_now`'s rule from `price == min`.
+# Here the middle level sits BELOW the mean without being the minimum (the four
+# expensive evening hours pull the mean up past it), so those two rules give
+# DIFFERENT answers at 12:00 - and section 3 proves they differ before grading
+# anything with it.
+THREE_LEVEL = {"periods": [
+    {"name": "peak", "from": "17:00", "to": "21:00", "days": "all",
+     "eur_per_kwh": 0.4800},
+    {"name": "day", "from": "07:00", "to": "17:00", "days": "all",
+     "eur_per_kwh": 0.2900},
+    {"name": "evening", "from": "21:00", "to": "24:00", "days": "all",
+     "eur_per_kwh": 0.2900},
+    {"name": "night", "from": "00:00", "to": "07:00", "days": "all",
+     "eur_per_kwh": 0.1900},
+]}
+
+
+def opts(profile=None, **over):
+    o = {"price_provider": "off",
+         "static_profile": "" if profile is None else json.dumps(profile)}
+    o.update(over)
+    return o
+
+
+# --------------------------------------------------------------------------- #
+print("0. the arithmetic this file grades with must not be degenerate")
+# ⚠️ These ARE the guard against a section that passes for the wrong reason. If
+# any goes red, every shifting assertion below is measuring nothing.
+check("day and night prices differ, so 'used the wrong window' is visible",
+      DAY_P != NIGHT_P)
+check("...and neither is zero, so 'dropped the price entirely' is visible",
+      DAY_P != 0 and NIGHT_P != 0)
+check("...and the fixed price is neither of them, so a fixed-tariff result "
+      "cannot be a day/night result in disguise",
+      FIXED_P not in (DAY_P, NIGHT_P))
+check("...and the day/night spread is not the fixed price, so 'reported the "
+      "spread where the price was wanted' is visible",
+      not near(DAY_P - NIGHT_P, FIXED_P))
+_lv = sorted({p["eur_per_kwh"] for p in THREE_LEVEL["periods"]})
+check(f"the three-level fixture really has three levels {_lv}", len(_lv) == 3)
+
+
+# --------------------------------------------------------------------------- #
+print()
+print("1. AC1 - the two-period profile puts the right window on the right hour")
+
+TWO = parse_static_profile(json.dumps(TWO_PERIOD))
+check("a JSON string parses (what config.yaml's flat `str?` option carries)",
+      isinstance(TWO, StaticProfile))
+check("...and so does an already-parsed dict (what /data/options.json would "
+      "carry under a nested schema, and what sim/inject.py hands over)",
+      isinstance(parse_static_profile(TWO_PERIOD), StaticProfile))
+check("...and a bare list of periods, without the wrapper",
+      isinstance(parse_static_profile(TWO_PERIOD["periods"]), StaticProfile))
+
+# ⚠️ THE PRODUCT IS DERIVED FROM THE DATA. Nobody ticks a box saying 'static'.
+check("the product is derived from the number of distinct prices, not declared: "
+      "two levels -> STATIC", TWO.product is PriceProduct.STATIC)
+check("...and one level -> FIXED, from the same code, with no flag anywhere",
+      parse_static_profile(FULLY_FIXED).product is PriceProduct.FIXED)
+# ...and it is really the PRICES, not the row count: three rows, one price.
+_three_rows_one_price = parse_static_profile({"periods": [
+    dict(p, eur_per_kwh=FIXED_P) for p in TWO_PERIOD["periods"]]})
+check("...and THREE rows carrying ONE price is still FIXED, so the derivation "
+      "is on the prices and not on len(periods)",
+      _three_rows_one_price.product is PriceProduct.FIXED
+      and len(_three_rows_one_price.periods) == 3)
+
+# ⚠️ PROBES AT THE BOUNDARY, NOT IN THE MIDDLE OF A WINDOW. 2026-01-15 is a
+# Thursday and Belgium is on CET (+01:00) then, so local == UTC + 1 h.
+THU = datetime(2026, 1, 15, tzinfo=UTC)
+
+
+def at_local(day, hh, mm=0):
+    """A UTC instant whose BRUSSELS wall clock reads hh:mm on `day`.
+
+    Built by search rather than by adding an offset, so this helper cannot
+    inherit the same offset bug it is meant to detect.
+    """
+    for minutes in range(-180, 24 * 60 + 180):
+        u = day + timedelta(minutes=minutes)
+        loc = brussels(u)
+        if loc.hour == hh and loc.minute == mm and loc.date() == \
+                brussels(day + timedelta(hours=12)).date():
+            return u
+    raise AssertionError(f"no instant reads {hh:02d}:{mm:02d} local on {day}")
+
+
+_probes = [(6, 59, "night"), (7, 0, "day"), (7, 1, "day"),
+           (21, 59, "day"), (22, 0, "night"), (22, 1, "night"),
+           (12, 0, "day"), (3, 0, "night")]
+_got = [(hh, mm, TWO.at(at_local(THU, hh, mm)).name) for hh, mm, _ in _probes]
+check(f"the half-open boundaries land exactly - 06:59 night, 07:00 day, "
+      f"21:59 day, 22:00 night {_got}",
+      all(name == want for (hh, mm, want), (_, __, name)
+          in zip(_probes, _got)))
+check("...and the 22:00-07:00 window really wraps midnight: Thursday 03:00 is "
+      "night, which a [22:00,24:00) reading would call uncovered",
+      TWO.at(at_local(THU, 3)).name == "night")
+
+# ⚠️ THE DAY-TYPE TRAP. A `mon-fri` night window must NOT bleed into Saturday
+# morning - a period applies on the day the CLOCK reads. The weekend row is what
+# covers Saturday 03:00, and it is a DIFFERENT Period object.
+SAT = datetime(2026, 1, 17, tzinfo=UTC)          # a Saturday
+_sat3 = TWO.at(at_local(SAT, 3))
+_thu3 = TWO.at(at_local(THU, 3))
+check("Saturday 03:00 is served by the WEEKEND row, not by Friday's night "
+      "window bleeding over - same name and price, different period",
+      _sat3.name == _thu3.name and _sat3 is not _thu3
+      and 5 in _sat3.days and 5 not in _thu3.days)
+check("...and Saturday 12:00 is night-priced, because a Belgian weekend tariff "
+      "runs all day - a weekday-shaped lookup would call it day",
+      near(TWO.price_at(at_local(SAT, 12)), NIGHT_P))
+check("...while Thursday 12:00 is day-priced, so the two are really different "
+      "answers and not one answer twice",
+      near(TWO.price_at(at_local(THU, 12)), DAY_P))
+
+# next_change: the shifting primitive - "how long until the cheap window".
+_nc = TWO.next_change(at_local(THU, 12))
+check(f"next_change from Thursday 12:00 is the 22:00 flip "
+      f"{None if _nc is None else brussels(_nc).isoformat()}",
+      _nc is not None and brussels(_nc).hour == 22 and brussels(_nc).minute == 0)
+_nc2 = TWO.next_change(at_local(SAT, 12))
+check("...and from Saturday noon it is Monday 07:00, because the whole weekend "
+      "is one window - a scan that stopped at midnight would say 24 h",
+      _nc2 is not None and brussels(_nc2).hour == 7
+      and brussels(_nc2).weekday() == 0)
+
+
+# --------------------------------------------------------------------------- #
+print()
+print("2. AC2 - a fully-fixed tariff disables arbitrage, by arithmetic")
+
+FIX = parse_static_profile(FULLY_FIXED)
+# ⚠️ The window OPENS A DAY EARLY. `at_local(THU, 0)` is 23:00 UTC on the 14th -
+# Belgium is an hour ahead - so a plan starting at THU would not cover midnight
+# local, and `price_at` would correctly raise for it. That raise is the right
+# behaviour (an hour outside the series is an hour with no price) but it is not
+# what these sections are grading.
+SPAN_A, SPAN_B = THU - timedelta(days=1), THU + timedelta(days=2)
+p_fixed = static_plan(opts(FULLY_FIXED), SPAN_A, SPAN_B)
+p_two = static_plan(opts(TWO_PERIOD), SPAN_A, SPAN_B)
+
+check("the fixed plan really produced a series (so the refusal below is about "
+      "the tariff, not about a failed read)",
+      p_fixed.has_prices and len(p_fixed.read.points) == 72)
+_spread_fixed = derived(p_fixed.spread_eur_kwh)
+_spread_two = derived(p_two.spread_eur_kwh)
+check(f"...and its spread is exactly zero {_spread_fixed}",
+      near(_spread_fixed, 0.0))
+check(f"...while the two-period spread is the day/night difference "
+      f"{_spread_two}, re-derived here as {DAY_P - NIGHT_P:.4f}",
+      near(_spread_two, DAY_P - NIGHT_P, 1e-9))
+
+_v_fixed = p_fixed.arbitrage(peak_guard_active=False)
+_v_two = p_two.arbitrage(peak_guard_active=False)
+check("a fully-fixed tariff REFUSES arbitrage", _v_fixed.kind == "refused")
+check("...for the true reason - the series is flat, so there is nothing to buy "
+      "low and sell high, not because a FIXED enum was matched on",
+      "flat" in _v_fixed.reason and "self-consumption only" in _v_fixed.reason)
+check("...and a two-period tariff, on the same code path, ALLOWS it - so the "
+      "refusal is discriminating rather than universal",
+      _v_two.kind == "allowed")
+
+# ⚠️ NOT KEYED ON THE PRODUCT ENUM. A DAY-AHEAD series that happens to print one
+# price all day must be refused for the same reason, or the rule is a label
+# check wearing arithmetic's clothes.
+_flat_dayahead = TariffPlan(
+    PriceRead.series(
+        [PricePoint(start=brussels(THU + timedelta(hours=i)),
+                    eur_per_kwh=0.2222, provisional=False) for i in range(24)],
+        PriceProduct.DAY_AHEAD, "generic_dayahead", THU),
+    None, "provider")
+check("a DAY_AHEAD series that happens to be flat is refused too, so the rule "
+      "is arithmetic and not a product label",
+      _flat_dayahead.arbitrage(peak_guard_active=False).kind == "refused")
+
+# The numbers an optimiser needs exist ONLY on the permitting variant.
+check("the allowed verdict carries the spread, the cheapest hour and the "
+      "dearest hour - the whole input set for a trade",
+      near(_v_two.spread_eur_kwh, DAY_P - NIGHT_P)
+      and near(_v_two.cheapest.eur_per_kwh, NIGHT_P)
+      and near(_v_two.dearest.eur_per_kwh, DAY_P))
+check("...and a REFUSED verdict carries none of them: .spread_eur_kwh raises "
+      "Absence rather than answering 0.0, which is the number that would make "
+      "every hour look equally good",
+      raises(lambda: _v_fixed.spread_eur_kwh, Absence)
+      and raises(lambda: _v_fixed.cheapest, Absence))
+check("...and it is not iterable and has no .get(), the other two routes from "
+      "a refusal to an empty, harmless-looking loop",
+      raises(lambda: list(_v_fixed), Absence)
+      and raises(lambda: _v_fixed.get("spread_eur_kwh", 0.0), Absence))
+check("...and match() demands BOTH arms, so the refusal cannot be fallen "
+      "through", raises(lambda: _v_fixed.match(allowed=lambda v: 1), TypeError))
+check("...and there is no falsy variant, so `if verdict:` cannot look like a "
+      "guard while being none", bool(_v_fixed) is True and bool(_v_two) is True)
+
+# §10.1 priority 2 over priority 3, expressed so OPT-04 cannot skip it.
+check("peak shaving outranks arbitrage: the SAME allowed plan is refused when "
+      "the peak guard is holding",
+      p_two.arbitrage(peak_guard_active=True).kind == "refused")
+check("...and the reason names the ordering rather than the tariff",
+      "priority 2" in p_two.arbitrage(peak_guard_active=True).reason)
+check("...and the question cannot be skipped: peak_guard_active is required "
+      "and keyword-only, so a spread is not obtainable without answering it",
+      raises(lambda: p_two.arbitrage(), TypeError)
+      and raises(lambda: p_two.arbitrage(False), TypeError))
+check("...nor answered with a truthy 'unknown'",
+      raises(lambda: p_two.arbitrage(peak_guard_active=None), TypeError)
+      and raises(lambda: p_two.arbitrage(peak_guard_active="no"), TypeError))
+
+
+# --------------------------------------------------------------------------- #
+print()
+print("3. the cheap-window rule, on a tariff where it is not degenerate")
+# ⚠️ WHY THREE LEVELS. Under two prices, "below the mean" and "equal to the
+# minimum" select the SAME hours, so a two-period profile cannot tell
+# cheap_now()'s actual rule from `price == min(prices)`. This fixture's `day`
+# level sits between the two, and the check below PROVES the two rules disagree
+# before anything is graded with it.
+
+THREE = parse_static_profile(THREE_LEVEL)
+p3 = static_plan(opts(THREE_LEVEL), SPAN_A,
+                 SPAN_A + timedelta(days=MEAN_WINDOW_DAYS))
+_mean3 = p3.mean_eur_kwh()
+_min3 = min(p.eur_per_kwh for p in p3.read.points)
+_day3 = 0.2900
+check(f"the three-level fixture is non-degenerate: the minimum {_min3:.4f} is "
+      f"strictly below the middle level {_day3:.4f}, which is strictly below "
+      f"the mean {_mean3:.4f} - so 'below the mean' and 'is the minimum' select "
+      f"DIFFERENT sets of hours and this fixture can tell them apart",
+      _min3 < _day3 < _mean3)
+check("...so cheap_now() calls the 07:00-17:00 MIDDLE level cheap - it is under "
+      "the mean without being the cheapest price of the day, which a "
+      "`price == min(prices)` rule would get wrong and a `price < mean` rule "
+      "gets right", p3.cheap_now(at_local(THU, 12)) is True)
+check("...and the middle level really is not the minimum, so that check graded "
+      "the difference rather than restating it",
+      not near(p3.price_at(at_local(THU, 12)), _min3))
+check("...and calls the 00:00-07:00 minimum cheap",
+      p3.cheap_now(at_local(THU, 3)) is True)
+check("...and the 17:00-21:00 peak not cheap",
+      p3.cheap_now(at_local(THU, 18)) is False)
+
+# ⚠️ STRICTLY BELOW, AND THAT IS AC2 IN THE SHIFTING HALF. On a flat series
+# `<=` would make EVERY hour a cheap window and a fixed-tariff site would top
+# the battery up from the grid at any hour - the opposite of self-consumption
+# only.
+_fixed_hours = [at_local(THU, h) for h in range(0, 24, 3)]
+check(f"a fully-fixed tariff has NO cheap window at any hour of the day "
+      f"{[h for h in range(0, 24, 3) if p_fixed.cheap_now(at_local(THU, h))]} - "
+      f"which is what `<` buys and `<=` would destroy",
+      not any(p_fixed.cheap_now(t) for t in _fixed_hours))
+check("...and the price really is defined at every one of those hours, so the "
+      "'no cheap window' answer is a priced no and not a missing read",
+      all(near(p_fixed.price_at(t), FIXED_P) for t in _fixed_hours))
+# ...and on the two-period tariff the cheap hours are exactly the night ones.
+_cheap_h = {h for h in range(24) if p_two.cheap_now(at_local(THU, h))}
+_night_h = {h for h in range(24) if TWO.at(at_local(THU, h)).name == "night"}
+check(f"on the day/night tariff the cheap hours ARE the night hours, derived "
+      f"two ways {sorted(_cheap_h)}",
+      _cheap_h == _night_h and 0 < len(_cheap_h) < 24)
+
+# ⚠️ THE MEAN IS OVER SEVEN DAYS, NOT OVER THE HOUR YOU ASKED AT. A 48 h mean on
+# a Friday afternoon is ~2/3 weekend, so the same Tuesday 09:00 would come out
+# cheap or dear depending on when the question was put.
+FRI = datetime(2026, 1, 16, tzinfo=UTC)
+_from_thu = static_status(opts(TWO_PERIOD), at_local(THU, 12))
+_from_fri = static_status(opts(TWO_PERIOD), at_local(FRI, 15))
+_mean_thu = static_plan(opts(TWO_PERIOD), at_local(THU, 12),
+                        at_local(THU, 12) + timedelta(days=MEAN_WINDOW_DAYS)
+                        ).mean_eur_kwh()
+_mean_fri = static_plan(opts(TWO_PERIOD), at_local(FRI, 15),
+                        at_local(FRI, 15) + timedelta(days=MEAN_WINDOW_DAYS)
+                        ).mean_eur_kwh()
+check(f"the 7-day mean is stable across the day it is asked on "
+      f"({_mean_thu:.4f} vs {_mean_fri:.4f}), so a window's cheapness is a "
+      f"property of the tariff and not of the clock",
+      near(_mean_thu, _mean_fri, 5e-4))
+_mean48_thu = static_plan(opts(TWO_PERIOD), at_local(THU, 12),
+                          at_local(THU, 12) + timedelta(days=2)).mean_eur_kwh()
+_mean48_fri = static_plan(opts(TWO_PERIOD), at_local(FRI, 15),
+                          at_local(FRI, 15) + timedelta(days=2)).mean_eur_kwh()
+check(f"...and the 48 h mean this replaces is NOT stable ({_mean48_thu:.4f} vs "
+      f"{_mean48_fri:.4f}), so the seven days are buying something real",
+      not near(_mean48_thu, _mean48_fri, 5e-4))
+
+
+# --------------------------------------------------------------------------- #
+print()
+print("4. DST - 23 and 25 hour days, where a 24-slot implementation is wrong")
+# ⚠️ 2026: CEST from 01:00 UTC Sunday 29 March, CET from 01:00 UTC Sunday
+# 25 October (price.py's brussels_offset, checked in PR #16 against zoneinfo
+# over 149,040 instants). Both are SUNDAYS, so the weekend row prices them -
+# which is itself worth knowing, because the wrap-around weekday row is not what
+# is under test here.
+SPRING = datetime(2026, 3, 29, tzinfo=UTC)
+AUTUMN = datetime(2026, 10, 25, tzinfo=UTC)
+
+
+def local_day_points(profile, day_utc):
+    """Hourly points whose BRUSSELS date is that of `day_utc` + 12 h."""
+    target = brussels(day_utc + timedelta(hours=12)).date()
+    pts = profile.series(day_utc - timedelta(hours=6),
+                         day_utc + timedelta(hours=30), provisional=False)
+    return [p for p in pts if p.start.date() == target]
+
+
+_spring = derived(lambda: local_day_points(TWO, SPRING))
+_autumn = derived(lambda: local_day_points(TWO, AUTUMN))
+check(f"the spring-forward local day emits 23 points, not 24 "
+      f"({len(_spring) if not isinstance(_spring, _Raised) else _spring})",
+      not isinstance(_spring, _Raised) and len(_spring) == 23)
+check(f"the autumn-back local day emits 25 points, not 24 "
+      f"({len(_autumn) if not isinstance(_autumn, _Raised) else _autumn})",
+      not isinstance(_autumn, _Raised) and len(_autumn) == 25)
+check("...and the two 02:00 points in October are DIFFERENT instants at "
+      "DIFFERENT offsets, which a naive local-hour key would collide",
+      len({p.start.utcoffset() for p in _autumn if p.start.hour == 2}) == 2)
+check("...and every emitted start is strictly increasing in UTC, which is what "
+      "price.py's boundary check demands of a fetched feed too",
+      all(a.start.astimezone(UTC) < b.start.astimezone(UTC)
+          for a, b in zip(_autumn, _autumn[1:])))
+# A weekday profile across a transition, so the wrap-around path sees one too.
+_wrapdays = local_day_points(TWO, datetime(2026, 3, 30, tzinfo=UTC))
+check("a normal Monday still emits 24, so the 23/25 above are the transitions "
+      "and not a systematic miscount", len(_wrapdays) == 24)
+
+
+# --------------------------------------------------------------------------- #
+print()
+print("5. a failed read is not an observation, and a gap is not a price")
+
+_none = static_plan(opts(None), THU, THU + timedelta(days=1))
+check("no static_profile produces a NO-DATA read, not an empty series and not "
+      "a zero one", not _none.has_prices)
+check("...and reading a price off it RAISES rather than answering 0.0 - the "
+      "value that would make every hour look free",
+      raises(lambda: _none.price_at(THU), Absence)
+      and raises(_none.mean_eur_kwh, Absence)
+      and raises(_none.spread_eur_kwh, Absence))
+check("...and its underlying read has no .points at all, so `min(read.points)` "
+      "cannot run against it",
+      raises(lambda: _none.read.points, Absence))
+check("...and arbitrage is refused, per §11.4",
+      _none.arbitrage(peak_guard_active=False).kind == "refused"
+      and arbitrage_allowed(_none.read) is False)
+check("...and static_status() says so in words rather than reporting a price",
+      static_status(opts(None), THU) == (False, "no static profile"))
+
+# ⚠️ THE TILING REFUSAL. An uncovered hour has no price and the only ways to
+# serve it are to invent one or to fail when the clock reaches it.
+_gap = {"periods": [
+    {"name": "day", "from": "07:00", "to": "22:00", "days": "all",
+     "eur_per_kwh": DAY_P},
+    {"name": "night", "from": "23:00", "to": "07:00", "days": "all",
+     "eur_per_kwh": NIGHT_P}]}
+check("a profile with a 22:00-23:00 gap is REFUSED, not defaulted",
+      raises(lambda: parse_static_profile(_gap), ProfileInvalid))
+check("...and names the uncovered range so the operator can fix it",
+      "22:00-23:00" in reason(lambda: parse_static_profile(_gap)))
+_overlap = {"periods": [
+    {"name": "day", "from": "07:00", "to": "22:00", "days": "all",
+     "eur_per_kwh": DAY_P},
+    {"name": "night", "from": "21:00", "to": "07:00", "days": "all",
+     "eur_per_kwh": NIGHT_P}]}
+check("...and an overlap is refused too - two prices for one hour means one "
+      "wins on list order",
+      raises(lambda: parse_static_profile(_overlap), ProfileInvalid)
+      and "2 prices" in reason(lambda: parse_static_profile(_overlap)))
+# THE CLASSIC MISTAKE the docstring warns about: no weekend row.
+_noweekend = {"periods": [
+    {"name": "day", "from": "07:00", "to": "22:00", "days": "mon-fri",
+     "eur_per_kwh": DAY_P},
+    {"name": "night", "from": "22:00", "to": "07:00", "days": "mon-fri",
+     "eur_per_kwh": NIGHT_P}]}
+check("a weekday-only profile is refused because Saturday and Sunday have no "
+      "price - the mistake a wrap-around window invites",
+      raises(lambda: parse_static_profile(_noweekend), ProfileInvalid)
+      and "sat" in reason(lambda: parse_static_profile(_noweekend)))
+# ...and the shipped shape is accepted, so the rule is not simply "refuse all".
+check("...while the three-row Belgian shape IS accepted, so the tiling rule "
+      "discriminates rather than refusing everything",
+      isinstance(parse_static_profile(TWO_PERIOD), StaticProfile))
+
+_bad = [
+    ("not JSON at all", "day 07:00-22:00 0.34"),
+    ("a price in cents", {"periods": [dict(FULLY_FIXED["periods"][0],
+                                           eur_per_kwh=30.7)]}),
+    ("a non-numeric price", {"periods": [dict(FULLY_FIXED["periods"][0],
+                                              eur_per_kwh="cheap")]}),
+    ("a missing days selector", {"periods": [
+        {"name": "x", "from": "00:00", "to": "24:00", "eur_per_kwh": 0.3}]}),
+    ("an unknown day name", {"periods": [dict(FULLY_FIXED["periods"][0],
+                                              days="mon-frd")]}),
+    ("a decimal hour", {"periods": [dict(FULLY_FIXED["periods"][0],
+                                         **{"from": "7.5"})]}),
+    ("an unsupported timezone", dict(FULLY_FIXED, timezone="Europe/Madrid")),
+    ("an empty periods list", {"periods": []}),
+]
+for label, value in _bad:
+    payload = value if isinstance(value, str) else json.dumps(value)
+    check(f"refused: {label}",
+          raises(lambda p=payload: parse_static_profile(p), ProfileInvalid))
+check("...and every one of those refusals says something an operator can act "
+      "on, rather than just failing",
+      all(len(reason(lambda p=(v if isinstance(v, str) else json.dumps(v)):
+                     parse_static_profile(p))) > 40 for _, v in _bad))
+for label, value in (("empty", ""), ("null", "null"), ("absent", None),
+                     ("whitespace", "   ")):
+    check(f"...while {label!r} means 'no profile' rather than an error",
+          parse_static_profile(value) is None)
+
+
+# --------------------------------------------------------------------------- #
+print()
+print("6. AC3 - the static-profile regression case, on the Belgian data that exists")
+# ⚠️ WHAT THE "BELGIAN SCENARIO SUITE" ACTUALLY IS IN THIS REPO. specs §17 names
+# six scenarios; none of them is a static-profile case, which is why AC3 asks
+# for a seventh. What exists as DATA is two days of this house's real P1 net
+# power, captured from the live meter and committed as
+# `scenarios/p1-net-2026-08-{20,23}.jsonl.gz` - the same fixtures test_tariff.py
+# part 9 replays for the capacity tariff. Nothing longer was ever captured.
+#
+# So this case is measured against REAL BELGIAN HOUSEHOLD LOAD, and the two days
+# happen to be one weekday and one weekend day, which is exactly the pair a
+# day/night tariff needs to be graded on. It is NOT a 30-day replay and this
+# section does not claim to be one; the numbers it prints are the numbers those
+# two days actually produce.
+
+REPLAY = sorted((HERE / "scenarios").glob("p1-net-*.jsonl.gz"))
+print(f"    replay fixtures found: {len(REPLAY)} "
+      f"({', '.join(p.name for p in REPLAY) or 'none'})")
+check("the committed replay fixtures are present - a regression fixture CI "
+      "cannot see is not a regression fixture", len(REPLAY) >= 2)
+
+MAX_GAP_S = 60.0        # a longer hole in the capture is not counted as energy
+
+
+def replay_import(path):
+    """(kWh imported per local tariff window, total kWh, span hours, weekday).
+
+    ⚠️ THE WINDOW IS DECIDED HERE BY AN INDEPENDENT ROUTE - the Brussels-local
+    hour of the sample, tested against the fixture's own 07:00/22:00 boundaries
+    - rather than by asking the module under test. The two must agree; that
+    agreement is the check.
+    """
+    per_window = {}
+    total = 0.0
+    first = last = None
+    prev = None
+    days = set()
+    with gzip.open(path, "rt", encoding="utf-8") as fh:
+        for line in fh:
+            row = json.loads(line)
+            t = datetime.fromisoformat(row["t"])
+            w = float(row["w"])
+            if first is None:
+                first = t
+            last = t
+            if prev is not None:
+                dt = (t - prev[0]).total_seconds()
+                if 0 < dt <= MAX_GAP_S and prev[1] > 0:
+                    kwh = prev[1] * dt / 3_600_000.0
+                    loc = brussels(prev[0])
+                    days.add(loc.weekday())
+                    window = ("day" if loc.weekday() < 5
+                              and 7 <= loc.hour < 22 else "night")
+                    per_window[window] = per_window.get(window, 0.0) + kwh
+                    total += kwh
+            prev = (t, w)
+    span = (last - first).total_seconds() / 3600.0 if first else 0.0
+    return per_window, total, span, days
+
+
+def cost_under(path, profile):
+    """EUR the imported energy cost, priced sample by sample by the MODULE."""
+    total = 0.0
+    prev = None
+    with gzip.open(path, "rt", encoding="utf-8") as fh:
+        for line in fh:
+            row = json.loads(line)
+            t = datetime.fromisoformat(row["t"])
+            w = float(row["w"])
+            if prev is not None:
+                dt = (t - prev[0]).total_seconds()
+                if 0 < dt <= MAX_GAP_S and prev[1] > 0:
+                    total += (prev[1] * dt / 3_600_000.0) * profile.price_at(prev[0])
+            prev = (t, w)
+    return total
+
+
+replay_days = 0.0
+graded = 0
+for path in REPLAY:
+    windows, total_kwh, span_h, weekdays = replay_import(path)
+    replay_days += span_h / 24.0
+    day_kwh = windows.get("day", 0.0)
+    night_kwh = windows.get("night", 0.0)
+    kind = "weekday" if weekdays and min(weekdays) < 5 else "weekend"
+    print(f"    {path.name}: {span_h:.1f} h, {kind} "
+          f"(weekday indices {sorted(weekdays)}), {total_kwh:.3f} kWh imported "
+          f"= {day_kwh:.3f} day + {night_kwh:.3f} night")
+
+    check(f"{path.name}: the two routes to the total agree",
+          near(day_kwh + night_kwh, total_kwh, 1e-9))
+
+    # The module's own pricing must reproduce the independently-split volumes.
+    c_two = cost_under(path, TWO)
+    c_expect = day_kwh * DAY_P + night_kwh * NIGHT_P
+    check(f"{path.name}: the module prices the real day at "
+          f"EUR {c_two:.4f}, which equals the independently-split "
+          f"{day_kwh:.3f} kWh x {DAY_P} + {night_kwh:.3f} kWh x {NIGHT_P} = "
+          f"EUR {c_expect:.4f}", near(c_two, c_expect, 1e-9))
+
+    c_fix = cost_under(path, FIX)
+    check(f"{path.name}: under a FULLY FIXED tariff the same energy costs "
+          f"EUR {c_fix:.4f} = {total_kwh:.3f} kWh x {FIXED_P}, one price for "
+          f"every hour", near(c_fix, total_kwh * FIXED_P, 1e-9))
+
+    # ⚠️ THE SHIFTING FIGURE, AND THE DEGENERACY GUARD IN FRONT OF IT. A day
+    # whose entire import landed in one window grades nothing: the saving would
+    # be 0 under a correct implementation AND under one that ignored the clock.
+    if day_kwh > 0 and night_kwh > 0:
+        graded += 1
+        saving = c_two - total_kwh * NIGHT_P
+        check(f"{path.name}: this day DOES import in both windows "
+              f"({day_kwh:.3f} / {night_kwh:.3f} kWh), so the split grades "
+              f"something", True)
+        check(f"{path.name}: shifting every day-window kWh into the night "
+              f"window saves EUR {saving:.4f}, which is exactly "
+              f"{day_kwh:.3f} kWh x the {DAY_P - NIGHT_P:.4f} spread - two "
+              f"routes to one number",
+              near(saving, day_kwh * (DAY_P - NIGHT_P), 1e-9) and saving > 0)
+        # AC2 on the same real data: under a fixed tariff there is nothing to
+        # shift, and that is arithmetic rather than a special case.
+        check(f"{path.name}: under the FIXED tariff the identical shift saves "
+              f"exactly nothing, so self-consumption-only is the right "
+              f"behaviour for that product",
+              near(c_fix - total_kwh * FIXED_P, 0.0, 1e-12))
+    else:
+        print(f"    {path.name}: import fell in ONE window only "
+              f"({day_kwh:.3f} day / {night_kwh:.3f} night) - this day is a "
+              f"day-typing witness, not a shifting one, and no saving is "
+              f"claimed from it")
+
+print()
+print(f"    AC3 MEASURED: {replay_days:.1f} DAYS of real Belgian household "
+      f"P1 data, {graded} of {len(REPLAY)} days carrying import in BOTH tariff "
+      f"windows and therefore grading the split.")
+print(f"    AC3 ASKS FOR A REGRESSION CASE IN THE BELGIAN SUITE, AND THIS IS "
+      f"ONE - but the suite holds two captured days, not a season, so nothing "
+      f"here is a claim about annual savings. §17's six named scenarios do not "
+      f"include a static-profile case; this is the seventh, and TEST-01 should "
+      f"say so.")
+check("the replay produced a measurable split over a stated sample size, "
+      "rather than a criterion quietly redefined to fit the data",
+      graded >= 1 and replay_days < 30)
+check("...and BOTH day types are present in the fixtures, which is what makes "
+      "the weekend row testable on real data at all",
+      len({("weekday" if min(replay_import(p)[3]) < 5 else "weekend")
+           for p in REPLAY}) == 2)
+
+
+# --------------------------------------------------------------------------- #
+print()
+print("7. §11.4 - the profile is the fallback, and the fallback is provisional")
+
+
+async def _dead(url, timeout_s):
+    raise OSError("the supplier's feed is down")
+
+
+def run(coro):
+    import asyncio
+    return asyncio.run(coro)
+
+
+_cfg = opts(TWO_PERIOD, price_provider="generic_dayahead",
+            price_feed_url="https://api.energy-charts.info/price?bzn=BE",
+            price_timeout_s=1, price_markup_eur_kwh=0.03,
+            price_taxes_eur_kwh=0.06)
+_fb = run(resolve_tariff(_cfg, THU, THU + timedelta(days=1), transport=_dead))
+check("a dead feed falls back to the static profile rather than to nothing",
+      _fb.origin == "fallback" and _fb.has_prices)
+check("...with the SAME prices the configured-product path produces, because "
+      "it is one generator and not a second implementation",
+      [p.eur_per_kwh for p in _fb.read.points]
+      == [p.eur_per_kwh for p in static_plan(
+          opts(TWO_PERIOD), THU, THU + timedelta(days=1)).read.points])
+check("...marked PROVISIONAL, which is the one flag that differs",
+      _fb.provisional and plan_is_provisional(_fb.read))
+check("...and arbitrage is refused on it, per §11.4, even though a full series "
+      "exists and has a real spread",
+      _fb.arbitrage(peak_guard_active=False).kind == "refused"
+      and near(_fb.spread_eur_kwh(), DAY_P - NIGHT_P))
+check("...while the SAME profile as the configured product allows it - so the "
+      "refusal is about provisionality and not about the profile",
+      static_plan(opts(TWO_PERIOD), THU, THU + timedelta(days=1)
+                  ).arbitrage(peak_guard_active=False).kind == "allowed")
+check("...and the provisional plan has no cheap window either: §8.3 forbids an "
+      "irreversible action on a provisional price, and a grid top-up is one",
+      not any(_fb.cheap_now(at_local(THU, h)) for h in range(24)))
+_fb_none = run(resolve_tariff(opts(None, price_provider="generic_dayahead",
+                                   price_timeout_s=1),
+                              THU, THU + timedelta(days=1), transport=_dead))
+check("a dead feed with NO static_profile has nothing to fall back to, and "
+      "says that rather than inventing a tariff",
+      _fb_none.origin == "none" and not _fb_none.has_prices)
+
+# A live feed still wins over the profile.
+_body = json.dumps({"data": [
+    {"start": (THU + timedelta(hours=i)).isoformat(), "price_eur_mwh": 40 + i}
+    for i in range(24)]}).encode()
+
+
+async def _live(url, timeout_s):
+    return _body
+
+
+_live_plan = run(resolve_tariff(_cfg, THU, THU + timedelta(days=1),
+                                transport=_live))
+check("a live feed is used in preference to the static profile",
+      _live_plan.origin == "provider"
+      and _live_plan.product is PriceProduct.DAY_AHEAD)
+check("...and arbitrage is allowed on it, with the spread derived from the "
+      "feed rather than from the profile",
+      _live_plan.arbitrage(peak_guard_active=False).kind == "allowed"
+      and near(_live_plan.arbitrage(peak_guard_active=False).spread_eur_kwh,
+               0.023, 1e-9))
+
+
+# --------------------------------------------------------------------------- #
+print()
+print("8. the startup gate, and CFG-03")
+
+
+def vbase(**over):
+    o = {"setpoint_entity": "number.goodwe_setpoint", "max_w": 2000,
+         "soc_entity": "sensor.soc", "batt_entity": "sensor.batt",
+         "meter_source": "off",
+         "maintenance_charge_w": 2000, "maintenance_discharge_w": 2000}
+    o.update(over)
+    return o
+
+
+def why(problems, needle):
+    return any(needle in p for p in problems)
+
+
+check("a good static_profile starts",
+      validate_startup_config(
+          vbase(static_profile=json.dumps(TWO_PERIOD)), -5000, 5000) == [])
+check("a gapped one is REFUSED at startup, not at 22:00 on the day it bites",
+      why(validate_startup_config(vbase(static_profile=json.dumps(_gap)),
+                                  -5000, 5000),
+          "static_profile cannot be used"))
+check("...and the refusal names the uncovered range",
+      why(validate_startup_config(vbase(static_profile=json.dumps(_gap)),
+                                  -5000, 5000), "22:00-23:00"))
+check("static_profile alongside the Home Assistant price entities is refused - "
+      "main.py reads one of them and the loser is silent",
+      why(validate_startup_config(
+          vbase(static_profile=json.dumps(TWO_PERIOD),
+                price_now_entity="sensor.now", price_avg_entity="sensor.avg"),
+          -5000, 5000), "HOME ASSISTANT"))
+check("...and the Home Assistant pair ALONE still starts, so nothing is taken "
+      "away from a live install",
+      validate_startup_config(vbase(price_now_entity="sensor.now",
+                                    price_avg_entity="sensor.avg"),
+                              -5000, 5000) == [])
+check("...and an empty static_profile is never refused: §9.2 puts a large share "
+      "of the installed base on a fixed tariff, and §11.4 makes no-price-data a "
+      "supported state",
+      validate_startup_config(vbase(static_profile=""), -5000, 5000) == []
+      and validate_startup_config(vbase(), -5000, 5000) == [])
+check("...and a fully-fixed profile starts, since a one-price site is a "
+      "supported product and not a misconfiguration",
+      validate_startup_config(vbase(static_profile=json.dumps(FULLY_FIXED)),
+                              -5000, 5000) == [])
+
+# ⚠️ CFG-03 IS NOT WIDENED BY THIS TICKET. `static_profile` was added to
+# app/price.py's PRICE_OPTION_DEFAULTS - the ONE in-code mirror TARIFF-02
+# created and pinned to config.yaml - rather than to a second defaults dict in
+# the new module. That mirror is enforced by test_price.py section 1, which
+# reads config.yaml; this check is the other half of the claim: the new module
+# must carry NO defaults dict of its own.
+_SRC = (HERE / "app" / "static_tariff.py").read_text(encoding="utf-8")
+check("the new module holds no option-defaults dict of its own, so this ticket "
+      "added ZERO new places an option default lives (CFG-03)",
+      "OPTION_DEFAULTS" not in _SRC.replace("PRICE_OPTION_DEFAULTS", ""))
+check("...and it reads the option through price.price_option(), the framework's "
+      "single read path, rather than through opts.get(key, <a number>)",
+      "price_option(opts" in _SRC and 'opts.get("static_profile"' not in _SRC)
+_MAIN = (HERE / "app" / "main.py").read_text(encoding="utf-8")
+check("...and main.py grew no `o.get(\"static_profile\", <a default>)` fallback "
+      "either - it calls static_status(o, now), and the option is read once, "
+      "inside the framework",
+      'get("static_profile"' not in _MAIN and "static_status(" in _MAIN)
+
+
+# --------------------------------------------------------------------------- #
+print()
+if fails:
+    print(f"{len(fails)} FAILED: " + "; ".join(fails))
+    sys.exit(1)
+print("all checks passed")

goodwe_controller/test_tariff.py

@@ -0,0 +1,910 @@
+"""Runnable check for TARIFF-01, the capacity-tariff measurement.
+
+    python3 test_tariff.py
+
+Ten parts. What each is for, and - where it matters - what it is deliberately
+NOT allowed to be tested at:
+
+  1. THE BLOCK ARITHMETIC, against a worked example written out segment by
+     segment. The fixture is chosen to be non-degenerate on three axes at once:
+     irregular sample spacing, a sample that STRADDLES the :15 boundary, and a
+     gap longer than `max_hold_s` so the block's coverage is short of 900 s.
+  2. THE 900 s DEGENERACY, named and then avoided. `acc/elapsed`, `acc/900` and
+     the end-of-quarter projection are THREE DIFFERENT FORMULAS that all agree
+     at exactly full coverage of a complete block. A check run only there proves
+     nothing about any of them, so part 2 first shows them agreeing at that
+     point (so the trap is documented rather than asserted around), then shows
+     part 1's fixture separating all three - and every later part uses fixtures
+     that are away from it.
+  3. RESTART MID-BLOCK, through the real `QuarterAverager.snapshot()`/`restore()`
+     and a real SQLite file: a restarted run must land on the same closed block
+     as an uninterrupted one, and a run that DOES NOT restore must land lower.
+     Without that second half, "restore works" is satisfied by a fixture where
+     restoring changes nothing.
+  4. MONTH ROLLOVER, in LOCAL time, including a restart that straddles it.
+  5. AN UNREADABLE STORE IS NOT A ZERO PEAK - the acceptance argument. Three
+     states, three different answers, and no accessor that turns "the database
+     did not answer" into a number.
+  6. THE TIMEZONE FALLBACK, graded against `zoneinfo` day by day.
+  7. THE PER-PHASE REDUCTION on an UNBALANCED load. §17's three-phase case. On a
+     balanced load net/sum/max all coincide, which is why a balanced fixture is
+     worth nothing here.
+  8. `monthly_peak` vs a recompute from `quarter_blocks` - the derived record
+     proven equal to the tier it derives from, and proven never to be lowered.
+  9. AC 3, ON THE REPLAY DATA THAT ACTUALLY EXISTS. See the honesty note below.
+ 10. THE WIRING, through the real `Controller` and its real status page.
+
+------------------------------------------------------------------------------
+⚠️ AC 3 IS NOT MET, AND PART 9 DOES NOT PRETEND OTHERWISE.
+
+AC 3 asks for "the monthly peak held under the soft limit in >= 95 % of
+intervals over a 30-day simulation replay". THERE IS NO 30-DAY DATASET. The
+infra repo's `sim/scenarios/` holds exactly two days of this house's real meter
+- 2026-08-20 (the Illusmart failure day) and 2026-08-23 (the healthy reference)
+- exported on 2026-08-25 because they were about to age out of HA's recorder,
+and nothing longer was ever captured. `sim/scenarios/README.md` lists the whole
+inventory; the rest is RS485 bus frames, OTA witness logs and a 578-row rollback
+poll, none of which carries grid power over calendar time.
+
+So part 9 replays the two days that exist, reports the percentage over them, and
+states the sample size in days next to it. It is a MEASUREMENT, not a verdict:
+nothing in it exits non-zero on the 95 % figure, because a 2-day run cannot pass
+or fail a 30-day criterion and a check that claimed it could would be the more
+expensive of the two mistakes. Both days are also *uncontrolled* - the add-on
+was not shaving peaks on either - so the figure they give is the BASELINE the
+guard has to improve on, which is the useful thing a 2-day replay can say.
+
+The two days are committed here as `scenarios/p1-net-<date>.jsonl.gz`
+(`{"t": iso8601, "w": signed_watts}` per line, derived from the HA recorder
+export) for the reason `scenarios/p1-age-2026-08-26.jsonl.gz` already is: the
+infra repo is private, CI's token is minted for this repository only, and a
+regression fixture that CI cannot see is not a regression fixture.
+
+Closing AC 3 needs 30 days of capture. That is TEST-01's replay harness, and it
+cannot start before somebody starts recording.
+"""
+
+import asyncio
+import gzip
+import json
+import shutil
+import sys
+import tempfile
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+
+from app.main import Controller
+from app.p1 import P1Ingest, QuarterAverager, QUARTER_S, make_sample, split_signed
+from app.tariff import (
+    BILLING_TZ, CHECKPOINT_S, NO_RECORD, NOT_OBSERVED, POLICY_MAX,
+    POLICY_NET, POLICY_SUM, PeakStore, PeakTracker, _EUTimezone, billed_w,
+    month_key,
+)
+
+fails = []
+HERE = Path(__file__).resolve().parent
+TMP = Path(tempfile.mkdtemp(prefix="goodwe-tariff-"))
+
+# The live install's numbers: NOTES.md and freeze.py both record max_w 5000
+# there. `peak_cap_w` ships at 3500 in config.yaml and is the SOFT LIMIT AC 3
+# grades against - read out of the shipped file in part 10 rather than typed.
+LIVE_MAX_W = 5000.0
+
+
+def check(name, cond):
+    print(f"  {'ok  ' if cond else 'FAIL'} {name}")
+    if not cond:
+        fails.append(name)
+
+
+def near(a, b, tol=1e-6):
+    return a is not None and b is not None and abs(a - b) <= tol
+
+
+def sample(t: datetime, net_w: float, phases=1, phase_net=None):
+    """One P1 telegram, through the SHIPPED derivation.
+
+    `split_signed` and `make_sample` are what the real transports call, so the
+    sign convention under test is the one that ships rather than a local
+    re-derivation of it.
+    """
+    imp, exp = split_signed(net_w)
+    pi = pe = None
+    if phase_net is not None:
+        pairs = [split_signed(v) for v in phase_net]
+        pi = [a for a, _ in pairs]
+        pe = [b for _, b in pairs]
+    return make_sample("ha_signed", imp, exp, phases=phases,
+                       phase_import_w=pi, phase_export_w=pe,
+                       ingest_ts=t, ingest_mono=t.timestamp())
+
+
+def fresh_store(name: str) -> PeakStore:
+    return PeakStore(str(TMP / f"{name}.db"))
+
+
+# B is a clock-aligned quarter boundary: proved, not assumed, because every
+# other number in part 1 rests on it.
+B = datetime(2026, 8, 30, 9, 0, 0, tzinfo=timezone.utc)
+
+
+# ==============================================================================
+print("1. the block arithmetic, on a worked example")
+
+check(f"the fixture's start {B.isoformat()} really is 900 s aligned",
+      int(B.timestamp()) % QUARTER_S == 0)
+
+# (t seconds after B, net W). Deliberately irregular, with an export, a gap
+# longer than max_hold_s, and a last sample that straddles the boundary.
+MAX_HOLD_S = 30.0
+FIXTURE = [(0, 1000.0), (20, 2000.0), (30, -500.0), (50, 3000.0),
+           (250, 4000.0), (880, 1200.0), (1000, 900.0)]
+
+# The worked example, written as the segments a person would compute by hand:
+# each HELD value and how many seconds of the FIRST block it is evidence for.
+# Two rules do all the work: a sample is held forward until the next one, capped
+# at MAX_HOLD_S; and export is 0 W of offtake, never a negative contribution.
+SEGMENTS = [
+    (1000.0, 20),    # 0 -> 20, a normal telegram interval, held in full
+    (2000.0, 10),    # 20 -> 30, likewise
+    (0.0, 20),       # 30 -> 50: -500 W is EXPORT, so 0 W of offtake for 20 s
+    (3000.0, 30),    # 50 -> 250 is a 200 s GAP; only the first 30 s is evidence
+    (4000.0, 30),    # 250 -> 880 is a 630 s gap; again only 30 s is evidence
+    (1200.0, 20),    # 880 -> 900: the STRADDLE's first half, up to the boundary
+]
+# The straddle's second half: the same held 1200 W, from the boundary until its
+# hold expires at 880 + 30. It must be credited to the NEXT block, not to this
+# one and not to neither.
+SPLIT_TAIL_W, SPLIT_TAIL_S = 1200.0, 10
+EXP_WS = sum(w * s for w, s in SEGMENTS)
+EXP_COVERED_S = sum(s for _, s in SEGMENTS)
+EXP_BLOCK_AVG = EXP_WS / QUARTER_S              # what the utility bills
+EXP_ELAPSED_AVG = EXP_WS / EXP_COVERED_S        # what a /elapsed divisor gives
+NAIVE_MEAN = sum(max(w, 0.0) for _, w in FIXTURE[:-1]) / (len(FIXTURE) - 1)
+
+avg = QuarterAverager(phases=1, max_hold_s=MAX_HOLD_S)
+closed = []
+for dt_s, w in FIXTURE:
+    closed += avg.add(sample(B + timedelta(seconds=dt_s), w))
+
+print(f"    {len(SEGMENTS)} held segments -> {EXP_WS:,.0f} Ws over "
+      f"{EXP_COVERED_S:.0f} s of the {QUARTER_S} s block")
+check(f"exactly one block closed", len(closed) == 1)
+check(f"...starting at the fixture's own boundary {B.isoformat()}",
+      bool(closed) and closed[0].start == B)
+check(f"...averaging {EXP_BLOCK_AVG:.2f} W - the worked example's "
+      f"{EXP_WS:,.0f} Ws over the FULL {QUARTER_S} s",
+      bool(closed) and near(closed[0].offtake_avg_w, EXP_BLOCK_AVG, 1e-9))
+
+# The three ways of being wrong, each of which produces a plausible number.
+print(f"    the same data read three other ways: /elapsed = {EXP_ELAPSED_AVG:.2f} W, "
+      f"naive mean of samples = {NAIVE_MEAN:.2f} W, "
+      f"billed = {EXP_BLOCK_AVG:.2f} W")
+check("...and /elapsed is NOT the billed figure - a gap must drag the average "
+      "down, not be averaged away",
+      abs(EXP_ELAPSED_AVG - EXP_BLOCK_AVG) > 1.0)
+check("...and a naive mean over samples is NOT the billed figure either - it "
+      "weights a burst of fast telegrams like a slow one",
+      abs(NAIVE_MEAN - EXP_BLOCK_AVG) > 1.0)
+
+# The straddle: the 4000 W sample at t=400 is held ACROSS 900. Its evidence
+# expires at 430, so the second block gets none of it - and the second block
+# must still have been OPENED at 900, not at 1000.
+check(f"the block after the straddle opens at the boundary, not at the sample",
+      avg.block_start == B + timedelta(seconds=QUARTER_S))
+print(f"    the straddling sample is SPLIT at the boundary: "
+      f"{SEGMENTS[-1][0]:.0f} W x {SEGMENTS[-1][1]} s into the first block, "
+      f"x {SPLIT_TAIL_S} s into the second")
+check(f"...and the second block is credited the tail "
+      f"({SPLIT_TAIL_W * SPLIT_TAIL_S:,.0f} Ws), so a sample spanning :15 is "
+      f"attributed to BOTH blocks in proportion and wholly to neither",
+      near(avg.partial_ws, SPLIT_TAIL_W * SPLIT_TAIL_S, 1e-9))
+
+
+# ==============================================================================
+print()
+print("2. the 900 s degeneracy - where three different formulas agree")
+
+# A complete block at a constant power, fully covered. Here acc/elapsed,
+# acc/900 and the projection are ALL the same number. Anything checked only
+# here is checked against nothing.
+HELD_W = 2400.0
+deg = QuarterAverager(phases=1, max_hold_s=MAX_HOLD_S)
+deg_closed = []
+for i in range(0, QUARTER_S + 1, 5):
+    deg_closed += deg.add(sample(B + timedelta(seconds=i), HELD_W))
+d_block = deg_closed[0].offtake_avg_w
+deg2 = QuarterAverager(phases=1, max_hold_s=MAX_HOLD_S)
+LAST_S = QUARTER_S - 5
+for i in range(0, LAST_S + 1, 5):
+    deg2.add(sample(B + timedelta(seconds=i), HELD_W))
+d_partial = deg2.offtake_avg_w
+# Graded AT the last sample: full coverage behind it, a held value in front.
+d_proj = PeakTracker.project(deg2, B + timedelta(seconds=LAST_S)).projected_w
+print(f"    at full coverage of a whole block: acc/900 = {d_block:.2f} W, "
+      f"acc/elapsed = {d_partial:.2f} W, projection = {d_proj:.2f} W")
+check("all three formulas coincide at exactly 900 s of full coverage - so a "
+      "check placed only there distinguishes none of them",
+      near(d_block, HELD_W, 1e-6) and near(d_partial, HELD_W, 1e-6)
+      and near(d_proj, HELD_W, 1e-6))
+
+# Away from it, on part 1's fixture at a point mid-block, they must separate.
+mid = QuarterAverager(phases=1, max_hold_s=MAX_HOLD_S)
+for dt_s, w in FIXTURE[:-1]:
+    mid.add(sample(B + timedelta(seconds=dt_s), w))
+NOW = B + timedelta(seconds=500)
+p = PeakTracker.project(mid, NOW)
+print(f"    at t=500 s on part 1's fixture: acc/elapsed = {p.elapsed_w:.2f} W, "
+      f"projection = {p.projected_w:.2f} W, coverage = {p.covered_frac * 100:.1f} %")
+check("mid-block, with a gap in it, the elapsed average and the projection are "
+      "DIFFERENT numbers", abs(p.elapsed_w - p.projected_w) > 1.0)
+check("...and the projection carries elapsed_s, so a consumer can see it is an "
+      f"extrapolation over {QUARTER_S - p.elapsed_s:.0f} s it has not seen",
+      near(p.elapsed_s, 500.0, 1e-6))
+check("...and a gap shows up as coverage below 1.0 rather than as a confident "
+      "low number", p.covered_frac < 1.0 and not p.complete)
+
+
+# ==============================================================================
+print()
+print("3. restart mid-block: the same block, or a lower one, never a lost one")
+
+RUN_W = 2000.0
+STEP_S = 1
+RESTART_AT_S = 600      # minute 10 of the quarter - the functional note's case
+
+
+def feed(avg, t0_s, t1_s, w=RUN_W):
+    out = []
+    for i in range(t0_s, t1_s + 1, STEP_S):
+        out += avg.add(sample(B + timedelta(seconds=i), w))
+    return out
+
+
+# (a) the control: no restart at all.
+ctrl = QuarterAverager(phases=1, max_hold_s=MAX_HOLD_S)
+ctrl_closed = feed(ctrl, 0, QUARTER_S)
+CTRL_W = ctrl_closed[0].offtake_avg_w
+
+# (b) restarted at minute 10, checkpoint restored through a real SQLite file.
+st = fresh_store("restart")
+tr = PeakTracker(st, cap_w=LIVE_MAX_W)
+a1 = QuarterAverager(phases=1, max_hold_s=MAX_HOLD_S)
+feed(a1, 0, RESTART_AT_S)
+check("the checkpoint round-trips through SQLite", st.save_partial(a1.snapshot()))
+a2 = QuarterAverager(phases=1, max_hold_s=MAX_HOLD_S)   # a brand-new process
+restored = tr.restore(a2, B + timedelta(seconds=RESTART_AT_S + 1))
+print(f"    restore() said: {restored}")
+check("...and restore() reports RESUMING rather than starting fresh",
+      restored.startswith("resumed"))
+r_closed = feed(a2, RESTART_AT_S + STEP_S, QUARTER_S)
+RESTART_W = r_closed[0].offtake_avg_w if r_closed else None
+
+# (c) the mutation guard: the SAME restart with no restore.
+a3 = QuarterAverager(phases=1, max_hold_s=MAX_HOLD_S)
+n_closed = feed(a3, RESTART_AT_S + STEP_S, QUARTER_S)
+NORESTORE_W = n_closed[0].offtake_avg_w if n_closed else None
+
+print(f"    uninterrupted {CTRL_W:.2f} W | restored {RESTART_W:.2f} W | "
+      f"restart with no restore {NORESTORE_W:.2f} W")
+check(f"a restart at {RESTART_AT_S} s lands on the SAME billed block as an "
+      f"uninterrupted run", near(RESTART_W, CTRL_W, 1e-6))
+check("...and without the restore it lands LOWER - so 'the restore works' is "
+      "not satisfied by a fixture where restoring changes nothing",
+      NORESTORE_W is not None and NORESTORE_W < CTRL_W - 1.0)
+# Derived, not asserted against a literal: the lost part is exactly the seconds
+# before the restart, at the power that was flowing.
+DROPPED_S = RESTART_AT_S + STEP_S     # the resumed feed starts one step later
+check(f"...and it is lower by exactly the {DROPPED_S} s it dropped "
+      f"({RUN_W * DROPPED_S / QUARTER_S:.2f} W)",
+      near(CTRL_W - NORESTORE_W, RUN_W * DROPPED_S / QUARTER_S, 1e-6))
+
+# (d) a LONG outage: restored, but the meter was away past max_hold_s. The
+# uncovered seconds must drag the block DOWN, not be held forward.
+OUTAGE_S = 200
+a4 = QuarterAverager(phases=1, max_hold_s=MAX_HOLD_S)
+st4 = fresh_store("outage")
+st4.save_partial(a1.snapshot())
+PeakTracker(st4, cap_w=LIVE_MAX_W).restore(a4, B + timedelta(seconds=RESTART_AT_S + OUTAGE_S))
+o_closed = feed(a4, RESTART_AT_S + OUTAGE_S, QUARTER_S)
+OUTAGE_UNCOVERED_S = OUTAGE_S - MAX_HOLD_S
+print(f"    a {OUTAGE_S} s outage inside the quarter, of which "
+      f"{OUTAGE_UNCOVERED_S:.0f} s is past the {MAX_HOLD_S:.0f} s hold: "
+      f"{o_closed[0].offtake_avg_w:.2f} W")
+check(f"...reads lower than the uninterrupted block by exactly the uncovered "
+      f"seconds ({RUN_W * OUTAGE_UNCOVERED_S / QUARTER_S:.2f} W) - a gap is "
+      f"never held forward across the whole outage",
+      near(CTRL_W - o_closed[0].offtake_avg_w,
+           RUN_W * OUTAGE_UNCOVERED_S / QUARTER_S, 1e-6))
+
+# (e) double counting is answered by the primary key, not by care.
+st5 = fresh_store("dedupe")
+st5.record_block(ctrl_closed[0])
+st5.record_block(ctrl_closed[0])
+st5.record_block(ctrl_closed[0])
+rows = st5.blocks_in(month_key(B))
+check("banking the same quarter three times leaves ONE row - quarter_start is "
+      "the primary key, so a replay or a restart cannot double-count",
+      len(rows) == 1 and near(rows[0][1], CTRL_W, 1e-9))
+
+# ...and a later pass with LESS coverage may not lower a banked figure.
+from app.tariff import _ClosedBlock as _CB
+st5.record_block(_CB(start=B, offtake_avg_w=CTRL_W / 2, per_phase_offtake_avg_w=None))
+after = st5.blocks_in(month_key(B))
+check(f"...and re-banking the same quarter at half the figure leaves it at "
+      f"{CTRL_W:.0f} W - a restart's partial re-run must never lower a "
+      f"quarter that was already measured in full",
+      len(after) == 1 and near(after[0][1], CTRL_W, 1e-9))
+
+# (f) the checkpoint's own staleness bound, derived from the constant.
+print(f"    CHECKPOINT_S = {CHECKPOINT_S:.0f} s, so a crash can lose at most "
+      f"{CHECKPOINT_S / QUARTER_S * 100:.1f} % of one quarter's average")
+check("the checkpoint bound is small enough that its worst case is under 2 % "
+      "of a quarter", CHECKPOINT_S / QUARTER_S < 0.02)
+
+
+# ==============================================================================
+print()
+print("4. month rollover, in LOCAL time, and across a restart that straddles it")
+
+# CEST is UTC+2, so the last two hours of 31 August UTC are already September.
+AUG_LATE = datetime(2026, 8, 31, 21, 45, tzinfo=timezone.utc)
+SEP_EARLY = datetime(2026, 8, 31, 22, 15, tzinfo=timezone.utc)
+print(f"    {AUG_LATE.isoformat()} is local "
+      f"{AUG_LATE.astimezone(BILLING_TZ).isoformat()} -> {month_key(AUG_LATE)}")
+print(f"    {SEP_EARLY.isoformat()} is local "
+      f"{SEP_EARLY.astimezone(BILLING_TZ).isoformat()} -> {month_key(SEP_EARLY)}")
+check("a quarter starting 21:45 UTC on 31 Aug bills in AUGUST",
+      month_key(AUG_LATE) == "2026-08")
+check("a quarter starting 22:15 UTC on 31 Aug bills in SEPTEMBER - filing it "
+      "under August would move a whole month's bill",
+      month_key(SEP_EARLY) == "2026-09")
+check("...and the two are genuinely on opposite sides of the boundary, not "
+      "the same answer twice", month_key(AUG_LATE) != month_key(SEP_EARLY))
+# Winter, where the offset is +1 and the boundary sits an hour later.
+JAN_LATE = datetime(2026, 1, 31, 22, 45, tzinfo=timezone.utc)
+check("in WINTER the same trap is an hour later: 22:45 UTC on 31 Jan is still "
+      "January, and 23:15 UTC is February",
+      month_key(JAN_LATE) == "2026-01"
+      and month_key(JAN_LATE + timedelta(minutes=30)) == "2026-02")
+
+st6 = fresh_store("months")
+AUG_PEAK_W, SEP_PEAK_W = 4998.0, 900.0
+st6.record_block(_CB(AUG_LATE, AUG_PEAK_W, None))
+st6.record_block(_CB(SEP_EARLY, SEP_PEAK_W, None))
+r_aug, r_sep = st6.peak(month="2026-08"), st6.peak(month="2026-09")
+print(f"    {r_aug.explain()}")
+print(f"    {r_sep.explain()}")
+check(f"August's peak is the {AUG_PEAK_W:.0f} W quarter (specs.md:583's own "
+      f"measured case) and September's is not",
+      r_aug.is_observed and near(r_aug.peak_w, AUG_PEAK_W)
+      and r_sep.is_observed and near(r_sep.peak_w, SEP_PEAK_W))
+check("...so a new month starts from its OWN quarters, not from the previous "
+      "month's peak", r_sep.peak_w < r_aug.peak_w)
+
+# The restart that straddles the boundary: a checkpoint whose open block is in
+# August, restored when `now` is already September.
+st7 = fresh_store("straddle")
+tr7 = PeakTracker(st7, cap_w=LIVE_MAX_W)
+straddler = QuarterAverager(phases=1, max_hold_s=MAX_HOLD_S)
+for i in range(0, 400, STEP_S):
+    straddler.add(sample(AUG_LATE + timedelta(seconds=i), RUN_W))
+st7.save_partial(straddler.snapshot())
+after_boot = QuarterAverager(phases=1, max_hold_s=MAX_HOLD_S)
+said = tr7.restore(after_boot, SEP_EARLY + timedelta(minutes=3))
+print(f"    restore() across the boundary said: {said}")
+aug7, sep7 = st7.peak(month="2026-08"), st7.peak(month="2026-09")
+check("a restart that straddles the month boundary BANKS the dead August "
+      "quarter rather than dropping measured energy",
+      said.startswith("closed a stale block") and aug7.is_observed)
+check(f"...at its partial-coverage figure ({aug7.peak_w:.2f} W = "
+      f"{RUN_W * 399 / QUARTER_S:.2f} W, the seconds it actually covered)",
+      near(aug7.peak_w, RUN_W * 399 / QUARTER_S, 1e-6))
+check("...and September reads NO_RECORD, which is a different answer from "
+      "August's peak AND from a zero",
+      sep7.state == NO_RECORD and sep7.peak_w is None)
+check("...and the checkpoint is cleared, so a second boot cannot re-bank it",
+      st7.load_partial() is None)
+
+
+# ==============================================================================
+print()
+print("5. AN UNREADABLE STORE IS NOT A ZERO PEAK  (the acceptance argument)")
+
+# Three stores, three states, and the three must not answer alike.
+good = fresh_store("states")
+good_tr = PeakTracker(good, cap_w=LIVE_MAX_W)
+empty_r = good_tr.peak(B)
+
+gone = fresh_store("gone")
+gone_tr = PeakTracker(gone, cap_w=LIVE_MAX_W)
+gone.record_block(_CB(B, 3000.0, None))
+gone.close()                       # the database goes away under a live reader
+gone_r = gone_tr.peak(B)
+
+never = PeakStore(str(TMP / "no-such-dir" / "x.db"))
+never_tr = PeakTracker(never, cap_w=LIVE_MAX_W)
+never_r = never_tr.peak(B)
+
+# A store that is OPEN and whose query FAILS is a third code path - a closed
+# handle short-circuits before the SQL ever runs, so without this the
+# `except sqlite3.Error` arm of peak() is never executed by anything.
+broken = fresh_store("broken-table")
+broken.record_block(_CB(B, 3000.0, None))
+broken._db.execute("DROP TABLE monthly_peak")
+broken._db.commit()
+broken_r = PeakTracker(broken, cap_w=LIVE_MAX_W).peak(B)
+
+for label, r in (("fresh store, no quarter yet", empty_r),
+                 ("store that broke under a live reader", gone_r),
+                 ("store that never opened", never_r),
+                 ("store open, query failed", broken_r)):
+    print(f"    {label:38s} -> {r.state:13s} {r.explain()}")
+
+check("a fresh store with no quarter yet says NO_RECORD - a normal state on "
+      "the 1st of the month", empty_r.state == NO_RECORD)
+check("a store that broke says NOT_OBSERVED", gone_r.state == NOT_OBSERVED)
+check("a store that never opened says NOT_OBSERVED", never_r.state == NOT_OBSERVED)
+check("a store whose QUERY fails says NOT_OBSERVED too - a different code path "
+      "from a closed handle, and the one a half-corrupt database takes",
+      broken_r.state == NOT_OBSERVED and broken_r.peak_w is None)
+# ...and losing the DERIVED record does not lose the peak, which is the whole
+# argument for keeping monthly_peak recomputable from the 15-min tier.
+_rec = broken.recompute_month(month_key(B))
+print(f"    ...but with the 15-min tier intact, recompute_month() still "
+      f"answers: {_rec.explain()}")
+check("...while recompute_month() STILL answers from the surviving 15-min "
+      "tier - the permanent record is derived, so losing it is recoverable",
+      _rec.is_observed and near(_rec.peak_w, 3000.0))
+broken._db.execute("DROP TABLE quarter_blocks")
+broken._db.commit()
+check("...and once BOTH tiers are gone it says NOT_OBSERVED rather than "
+      "raising into the control loop",
+      broken.recompute_month(month_key(B)).state == NOT_OBSERVED)
+check("...and NO_RECORD and NOT_OBSERVED are DIFFERENT states, not two "
+      "spellings of the same one", empty_r.state != gone_r.state)
+check("...and they read differently to a human, too",
+      empty_r.explain() != gone_r.explain()
+      and "NOT" in gone_r.explain() and "zero peak" in gone_r.explain())
+
+check("an unreadable peak is None, not 0.0 - there is no number to mistake",
+      gone_r.peak_w is None and never_r.peak_w is None)
+check("...and NO_RECORD carries no number either", empty_r.peak_w is None)
+_typed = False
+try:
+    float(gone_r.peak_w)
+except TypeError:
+    _typed = True
+check("...and a caller who forgets to ask gets a TypeError rather than a "
+      "silently disarming zero", _typed)
+check("PeakReading exposes no accessor that defaults a missing peak to a "
+      "number - no .get(), no _or() ",
+      not [a for a in dir(gone_r)
+           if a.startswith(("get", "value")) or a.endswith("_or")])
+
+# The consequence, which is the reason any of this matters.
+print(f"    headroom under a {LIVE_MAX_W:.0f} W limit: "
+      f"no quarter yet -> {good_tr.headroom_w(B)}, "
+      f"unreadable -> {gone_tr.headroom_w(B)}")
+check("an unreadable store yields NO headroom figure - the disarming default "
+      "(full headroom, guard silently off) is unreachable",
+      gone_tr.headroom_w(B) is None and never_tr.headroom_w(B) is None)
+check(f"...where a genuinely empty month yields the full {LIVE_MAX_W:.0f} W, "
+      f"which is correct and is a different answer",
+      near(good_tr.headroom_w(B), LIVE_MAX_W))
+check("the 80 % warning fraction is likewise None when nothing was observed",
+      gone_tr.warning_frac(B) is None and good_tr.warning_frac(B) == 0.0)
+
+# And a real peak reduces headroom, so "always None" does not pass this part.
+good.record_block(_CB(B, LIVE_MAX_W * 0.9, None))
+print(f"    after one {LIVE_MAX_W * 0.9:.0f} W quarter: "
+      f"headroom {good_tr.headroom_w(B):.0f} W, "
+      f"warning {good_tr.warning_frac(B) * 100:.0f} % of the limit")
+check("a real observed peak gives a real headroom, so this part is not passed "
+      "by a store that answers None to everything",
+      near(good_tr.headroom_w(B), LIVE_MAX_W * 0.1, 1e-6))
+check(f"...and it is over §9.1's 80 % warning threshold",
+      good_tr.warning_frac(B) > 0.8)
+
+# A CORRUPT database file is the third way a store fails, and it must land in
+# NOT_OBSERVED too rather than raising into the control loop.
+corrupt_path = TMP / "corrupt.db"
+corrupt_path.write_bytes(b"this is not a database" * 64)
+corrupt = PeakStore(str(corrupt_path))
+c_r = PeakTracker(corrupt, cap_w=LIVE_MAX_W).peak(B)
+print(f"    a corrupt database file -> {c_r.state}")
+check("a corrupt database reads NOT_OBSERVED and does not raise into the "
+      "control loop (§6 fail-open)", c_r.state == NOT_OBSERVED)
+
+
+# ==============================================================================
+print()
+print("6. the timezone fallback, graded against zoneinfo")
+
+_zi = None
+try:
+    from zoneinfo import ZoneInfo
+    _zi = ZoneInfo("Europe/Brussels")
+except Exception as err:                      # noqa: BLE001
+    print(f"    zoneinfo unavailable here ({err}) - the fallback IS the tz")
+
+if _zi is None:
+    check("zoneinfo is absent, so the encoded rule cannot be graded here - "
+          "reported, not silently passed", True)
+else:
+    fb = _EUTimezone()
+    # ⚠️ HOURLY, NOT 3-HOURLY, ACROSS THE TRANSITION DAYS. Both EU transitions
+    # happen at 01:00 UTC, so a rule that is wrong BY AN HOUR differs from the
+    # right one only between 01:00 and 02:00 UTC. A 3-hourly sweep steps over
+    # that window entirely and grades nothing - measured: a mutation moving the
+    # UTC threshold from 01:00 to 02:00 survived the whole file at 3-hourly.
+    probes = [datetime(2026, 1, 1, 12, tzinfo=timezone.utc)]
+    probes += [datetime(2026, m, d, h, mi, tzinfo=timezone.utc)
+               for m in (3, 10) for d in (28, 29, 30, 31)
+               for h in range(24) for mi in (0, 30)]
+    probes += [datetime(2026, m, 1, 0, 30, tzinfo=timezone.utc) for m in range(1, 13)]
+    # ⚠️ COMPARE THE CONVERTED WALL CLOCK, NOT ITS utcoffset(). `astimezone`
+    # goes through `fromutc`, but the RESULT carries local wall values, so
+    # asking it for `.utcoffset()` routes straight back into the LOCAL arm and
+    # never grades `fromutc` at all. Measured: a mutation moving the UTC
+    # threshold by an hour survived 397 offset-comparing probes and dies
+    # immediately on the wall clock they produce.
+    def _wallclock(t, tz):
+        return t.astimezone(tz).replace(tzinfo=None)
+
+    bad = [t for t in probes if _wallclock(t, fb) != _wallclock(t, _zi)]
+    print(f"    {len(probes)} probes across both DST transitions and every "
+          f"month boundary: {len(bad)} disagreement(s) in the LOCAL WALL CLOCK "
+          f"each one converts to")
+    check("the encoded EU rule converts every probe to the same local wall "
+          "clock as zoneinfo, including the two transition weekends", not bad)
+    # ...and the probes are not all the same offset, or the check is vacuous.
+    offsets = {t.astimezone(_zi).utcoffset() for t in probes}
+    check(f"...and the probe set spans BOTH offsets ({sorted(str(o) for o in offsets)}), "
+          f"so agreeing is not free", len(offsets) == 2)
+    check(f"BILLING_TZ resolved to zoneinfo on this host, not the fallback",
+          not isinstance(BILLING_TZ, _EUTimezone))
+
+    # ⚠️ THE PROBES ABOVE ONLY EXERCISE `fromutc()`. `astimezone` on a UTC
+    # instant never calls `utcoffset()` with a local wall time, so the local
+    # arm of the rule was ungraded - a mutation that moved it by an hour
+    # survived the whole file. These probes drive it directly. Noon is used
+    # because it is unambiguous on every day of the year, including the two
+    # transition days where 02:00-03:00 local is missing or repeated.
+    #
+    # ⚠️ AND THE LOCAL PROBES MUST INCLUDE 03:00-03:59 ON THE OCTOBER SUNDAY.
+    # That hour is where a local rule that ends DST an hour late still claims
+    # CEST while zoneinfo has already returned to CET; at noon both answers
+    # agree and the probe is worth nothing. Measured: at noon-only, a mutation
+    # moving the local thresholds from 02:00/03:00 to 03:00/04:00 survived.
+    #
+    # The MARCH gap (02:00-02:59 local, which does not exist) is deliberately
+    # NOT probed: Python hands a nonexistent local time to `utcoffset` as an
+    # ordinary value and any answer is defensible, so grading it would pin an
+    # arbitrary choice. It cannot move a month boundary - it is the last Sunday
+    # of March, never the 1st of a month - which is the only thing this tz is
+    # used for.
+    wall = [datetime(2026, m, d, 12) for m, d in
+            [(3, 27), (3, 28), (3, 29), (3, 30), (10, 24), (10, 25),
+             (10, 26), (10, 27)]]
+    wall += [datetime(2026, 10, 25, h, mi) for h in range(0, 6) for mi in (0, 30)
+             if h != 2]                       # 02:00 local is the ambiguous fold
+    wall += [datetime(2026, 3, 29, h, mi) for h in (0, 1, 3, 4, 5) for mi in (0, 30)]
+    wall += [datetime(2026, m, 1, 12) for m in range(1, 13)]
+    bad_w = [w for w in wall
+             if w.replace(tzinfo=fb).utcoffset() != w.replace(tzinfo=_zi).utcoffset()]
+    w_offsets = {w.replace(tzinfo=_zi).utcoffset() for w in wall}
+    print(f"    {len(wall)} LOCAL-wall probes through utcoffset(): "
+          f"{len(bad_w)} disagreement(s), spanning "
+          f"{sorted(str(o) for o in w_offsets)}")
+    check("utcoffset() on local wall time matches zoneinfo across both "
+          "transition weekends - the arm astimezone() never reaches", not bad_w)
+    check("...and those probes span both offsets too", len(w_offsets) == 2)
+    bad_n = [w for w in wall
+             if w.replace(tzinfo=fb).tzname() != w.replace(tzinfo=_zi).tzname()]
+    check("...and tzname() agrees with zoneinfo at every one of them (CET/CEST)",
+          not bad_n)
+
+
+# ==============================================================================
+print()
+print("7. the per-phase reduction, on an UNBALANCED three-phase load (§17)")
+
+# One phase exporting is what separates the three policies. On a balanced load
+# they all give the same number, which is why this fixture is not balanced.
+PH = (3000.0, 500.0, -200.0)
+NET = sum(PH)
+u = QuarterAverager(phases=3, max_hold_s=MAX_HOLD_S)
+u_closed = []
+for i in range(0, QUARTER_S + 1, 5):
+    u_closed += u.add(sample(B + timedelta(seconds=i), NET, phases=3, phase_net=PH))
+blk = u_closed[0]
+vals = {p: billed_w(blk, p) for p in (POLICY_NET, POLICY_SUM, POLICY_MAX)}
+print(f"    phases {PH} (net {NET:+.0f} W) -> "
+      + ", ".join(f"{k}={v:.0f} W" for k, v in vals.items()))
+check(f"the NET policy bills the connection's net offtake ({NET:.0f} W)",
+      near(vals[POLICY_NET], NET, 1e-6))
+check(f"the SUM policy clips each phase first, so the exporting phase does not "
+      f"net off ({sum(max(v, 0.0) for v in PH):.0f} W)",
+      near(vals[POLICY_SUM], sum(max(v, 0.0) for v in PH), 1e-6))
+check(f"the MAX policy bills the worst single phase ({max(PH):.0f} W)",
+      near(vals[POLICY_MAX], max(PH), 1e-6))
+check("...and on THIS fixture all three are different numbers - which is the "
+      "whole reason the reduction is a named policy and not an assumption",
+      len({round(v, 6) for v in vals.values()}) == 3)
+check("the shipped default is NET, the meter's own billed register",
+      billed_w(blk) == vals[POLICY_NET])
+
+bal = QuarterAverager(phases=3, max_hold_s=MAX_HOLD_S)
+b_closed = []
+for i in range(0, QUARTER_S + 1, 5):
+    b_closed += bal.add(sample(B + timedelta(seconds=i), 3000.0, phases=3,
+                               phase_net=(1000.0, 1000.0, 1000.0)))
+b_vals = {p: billed_w(b_closed[0], p) for p in (POLICY_NET, POLICY_SUM, POLICY_MAX)}
+check(f"...and on a BALANCED load NET and SUM coincide ({b_vals[POLICY_NET]:.0f} W), "
+      f"so a balanced fixture could not have told them apart",
+      near(b_vals[POLICY_NET], b_vals[POLICY_SUM], 1e-6))
+
+
+# ==============================================================================
+print()
+print("8. monthly_peak is DERIVED, and provably has not diverged")
+
+st8 = fresh_store("derive")
+QUARTERS = [(0, 1200.0), (1, 4998.0), (2, 3357.0), (3, 800.0), (4, 4832.0)]
+for q, w in QUARTERS:
+    st8.record_block(_CB(B + timedelta(seconds=q * QUARTER_S), w, None))
+MAXQ = max(w for _, w in QUARTERS)
+stored = st8.peak(month=month_key(B))
+derived = st8.recompute_month(month_key(B))
+print(f"    {len(QUARTERS)} quarters banked; stored peak {stored.peak_w:.0f} W, "
+      f"recomputed from quarter_blocks {derived.peak_w:.0f} W")
+check(f"the stored monthly peak is the largest quarter ({MAXQ:.0f} W - "
+      f"specs.md:583's own figure)",
+      stored.is_observed and near(stored.peak_w, MAXQ))
+check("...and re-deriving it from the 15-min tier gives the same number and "
+      "the same quarter, so the two records are proven equal rather than "
+      "assumed to be",
+      derived.is_observed and near(derived.peak_w, stored.peak_w)
+      and derived.quarter_start == stored.quarter_start)
+check("...and the two measured regressions from §9.1 land on DIFFERENT peaks - "
+      f"the sustained {MAXQ:.0f} W quarter, not the oscillating 3357 W one",
+      not near(stored.peak_w, 3357.0))
+# A quarter arriving LATER and lower must not lower the month.
+st8.record_block(_CB(B + timedelta(seconds=9 * QUARTER_S), 100.0, None))
+check("a later, smaller quarter does not lower the month's peak",
+      near(st8.peak(month=month_key(B)).peak_w, MAXQ))
+check("...and the recompute agrees with it after that write, too",
+      near(st8.recompute_month(month_key(B)).peak_w, MAXQ))
+# No pruning: §15 says these two tiers are indefinite / permanent.
+src = (HERE / "app" / "tariff.py").read_text(encoding="utf-8")
+check("§15's retention is structural: no DELETE against quarter_blocks or "
+      "monthly_peak exists anywhere in tariff.py",
+      "DELETE FROM quarter_blocks" not in src
+      and "DELETE FROM monthly_peak" not in src
+      and "DROP TABLE" not in src)
+
+
+# ==============================================================================
+print()
+print("9. AC 3, on the replay data that actually exists")
+
+REPLAY = sorted((HERE / "scenarios").glob("p1-net-*.jsonl.gz"))
+print(f"    replay fixtures found: {len(REPLAY)} "
+      f"({', '.join(p.name for p in REPLAY) or 'none'})")
+check("the committed replay fixtures are present - a regression fixture CI "
+      "cannot see is not a regression fixture", len(REPLAY) >= 2)
+
+# ⚠️ `peak_cap_w:` appears TWICE in config.yaml - once under `options:` with the
+# default, once under `schema:` with `int(500,15000)`. Taking the last match
+# would blow up on the schema line, and taking any match that parses would be
+# luck; the FIRST is the options block, which is the number an install lands on.
+SHIPPED_CAP_W = None
+for line in (HERE / "config.yaml").read_text(encoding="utf-8").splitlines():
+    if line.strip().startswith("peak_cap_w:"):
+        try:
+            SHIPPED_CAP_W = float(line.split(":", 1)[1].strip())
+        except ValueError:
+            continue
+        break
+check("config.yaml's shipped peak_cap_w was read out of the file rather than "
+      "typed here", SHIPPED_CAP_W is not None)
+
+replay_days = 0
+total_q = 0
+under = 0
+for path in REPLAY:
+    st9 = fresh_store("replay-" + path.stem)
+    ing = P1Ingest(phases=1, max_age_s=MAX_HOLD_S)
+    tr9 = PeakTracker(st9, cap_w=SHIPPED_CAP_W or LIVE_MAX_W)
+    first = last = None
+    with gzip.open(path, "rt", encoding="utf-8") as fh:
+        for line in fh:
+            row = json.loads(line)
+            t = datetime.fromisoformat(row["t"])
+            first = first or t
+            last = t
+            ing.submit(sample(t, float(row["w"])))
+    tr9.sync(ing)
+    months = {month_key(b.start) for b in ing.blocks}
+    span_h = (last - first).total_seconds() / 3600.0
+    qs = [w for _, w in st9.blocks_in(sorted(months)[0])] if months else []
+    peak = max(qs) if qs else 0.0
+    ok_q = sum(1 for w in qs if w <= (SHIPPED_CAP_W or LIVE_MAX_W))
+    total_q += len(qs)
+    under += ok_q
+    replay_days += span_h / 24.0
+    print(f"    {path.name}: {span_h:.1f} h, {len(qs)} closed quarters, "
+          f"month peak {peak:.0f} W, "
+          f"{ok_q}/{len(qs)} = {100.0 * ok_q / max(len(qs), 1):.1f} % under the "
+          f"{SHIPPED_CAP_W:.0f} W soft limit")
+    check(f"{path.name}: the month's peak equals its own largest quarter",
+          near(st9.peak(month=sorted(months)[0]).peak_w, peak, 1e-9))
+    check(f"{path.name}: a full day of real telegrams produces ~96 quarters, "
+          f"got {len(qs)}", 90 <= len(qs) <= 96)
+
+PCT = 100.0 * under / max(total_q, 1)
+print()
+print(f"    AC 3 MEASURED: {under}/{total_q} quarters = {PCT:.1f} % under the "
+      f"{SHIPPED_CAP_W:.0f} W soft limit, over {replay_days:.1f} DAYS of "
+      f"replay, UNCONTROLLED (no peak shaving was running on either day).")
+print(f"    AC 3 ASKS FOR 30 DAYS. {replay_days:.1f} days exist. "
+      f"AC 3 IS NOT MET and this run does not claim it is - see the module "
+      f"docstring. The figure above is the BASELINE SAFETY-07 has to improve.")
+check("the replay produced a measurable number over a stated sample size, "
+      "rather than a criterion quietly redefined to fit the data",
+      total_q > 100 and replay_days < 30)
+
+
+# ==============================================================================
+print()
+print("10. the wiring: the real Controller, and what its status page says")
+
+
+class _Store:
+    data = {}
+
+    def set(self, *a):
+        pass
+
+    def get_time(self, *a):
+        return None
+
+
+class _Pub:
+    enabled = False
+
+    def publish(self, *a, **k):
+        pass
+
+    def close(self):
+        pass
+
+
+class _Hass:
+    async def limits(self, entity):
+        return (-LIVE_MAX_W, LIVE_MAX_W, 1.0)
+
+    async def number(self, entity, invert=False):
+        return None
+
+    async def set_number(self, entity, value):
+        return True
+
+    async def call(self, domain, service, data):
+        return True
+
+
+def built(db_path, opts=None):
+    return Controller(dict(
+        {"setpoint_entity": "number.sp", "meter_source": "ha_signed",
+         "p1_net_entity": "sensor.net", "meter_phases": 1,
+         "max_w": LIVE_MAX_W, "gain": 0.6, "slew_w": 1000, "deadband_w": 15,
+         "target_grid_w": 0, "step_w": 10, "heartbeat_s": 10,
+         "stale_input_s": 15}, **(opts or {})),
+        _Hass(), _Store(), _Pub(), stop=asyncio.Event(),
+        peak_db_path=str(db_path))
+
+
+c = built(TMP / "wired.db")
+check(f"a Controller built with peak_cap_w ABSENT takes the SHIPPED "
+      f"{SHIPPED_CAP_W:.0f} W, so config.yaml and main.py's fallback cannot "
+      f"drift apart unnoticed", c.peak.cap_w == SHIPPED_CAP_W)
+
+# Drive one real quarter through the real ingest, then the real cycle's sync.
+for i in range(0, QUARTER_S + 1, 5):
+    c.p1.submit(sample(B + timedelta(seconds=i), 4998.0))
+n = c.peak.sync(c.p1)
+wr = c.peak.peak(B)
+print(f"    after one 4998 W quarter through the real ingest: "
+      f"{n} banked, {wr.explain()}")
+check("the closed quarter reached SQLite through the tracker the cycle calls",
+      n == 1 and wr.is_observed and near(wr.peak_w, 4998.0, 1e-6))
+
+# ⚠️ `cycle()` calls sync() ONCE A SECOND against a `blocks` list that keeps a
+# closed quarter for a DAY. Without a dedupe that is ~86 000 re-banks of the
+# same row per block, and `recorded` - the number the status page prints as
+# "quarters banked" - would be a count of loop iterations rather than of
+# quarters. The database stays correct either way, which is exactly why this
+# needs its own check instead of being caught by the peak.
+again = c.peak.sync(c.p1)
+third = c.peak.sync(c.p1)
+print(f"    sync() called three times over the same closed quarter: "
+      f"{n}, {again}, {third} newly banked; tracker reports "
+      f"{c.peak.recorded} quarter(s)")
+check("...and syncing the same quarter again banks nothing new, so the count "
+      "the status page shows is quarters and not cycles",
+      again == 0 and third == 0 and c.peak.recorded == 1)
+check("...and the peak is unchanged by the repeat",
+      near(c.peak.peak(B).peak_w, 4998.0, 1e-6))
+
+rows = [r for r in c.checks() if "capacity-tariff" in r["text"] or "peak" in r["text"]]
+peak_rows = [r for r in rows if "peak" in r["text"] and "quarter(s) banked" in r["text"]]
+print("    status row: " + (peak_rows[0]["text"] if peak_rows else "(none)"))
+check("the status page carries exactly one capacity-tariff peak row",
+      len(peak_rows) == 1)
+check("...naming the peak, the soft limit and the quarters banked, all derived "
+      "from the controller that was actually built",
+      bool(peak_rows) and "4998 W" in peak_rows[0]["text"]
+      and f"{SHIPPED_CAP_W:.0f} W soft limit" in peak_rows[0]["text"]
+      and "1 quarter(s) banked" in peak_rows[0]["text"])
+check("...and it is FLAGGED, because 4998 W is over §9.1's 80 % warning point "
+      f"on a {SHIPPED_CAP_W:.0f} W limit",
+      bool(peak_rows) and not peak_rows[0]["ok"] and peak_rows[0]["warn"])
+
+# The half that matters: the same page with a store that cannot answer.
+c2 = built(TMP / "no-such-dir" / "nope.db")
+u_rows = [r for r in c2.checks() if "capacity-tariff peak" in r["text"]]
+print("    status row (unreadable store): "
+      + (u_rows[0]["text"] if u_rows else "(none)"))
+check("an unreadable store gets its OWN row, saying UNREADABLE", len(u_rows) == 1)
+check("...and it does NOT read as a quiet month at 0 W - without this, a broken "
+      "instrument looks exactly like a month with no peak",
+      bool(u_rows) and "UNREADABLE" in u_rows[0]["text"]
+      and "0 %" not in u_rows[0]["text"] and u_rows[0]["warn"])
+check("...and the healthy row and the unreadable row are different text",
+      bool(u_rows) and bool(peak_rows)
+      and u_rows[0]["text"] != peak_rows[0]["text"])
+
+# THE MEASUREMENT IS OF DELIVERED POWER (SAFETY-20). Graded on the parsed
+# SYNTAX, not on the text: the module docstring argues this at length and names
+# every forbidden word while doing so, so a grep over the source would be
+# satisfied by deleting the explanation and would fail on writing one. What must
+# be true is that no NAME the code evaluates refers to a command.
+import ast as _ast
+
+_tree = _ast.parse(src)
+_names = {n.id for n in _ast.walk(_tree) if isinstance(n, _ast.Name)}
+_names |= {n.attr for n in _ast.walk(_tree) if isinstance(n, _ast.Attribute)}
+_names |= {n.name for n in _ast.walk(_tree)
+           if isinstance(n, (_ast.FunctionDef, _ast.ClassDef))}
+_FORBIDDEN = {"setpoint", "write_setpoint", "target", "Decision", "i_clamped",
+              "clamped", "Claim", "resolve", "P_PEAK", "arbiter"}
+_found = sorted(_names & _FORBIDDEN)
+_imports = sorted(m.module or "" for m in _ast.walk(_tree)
+                  if isinstance(m, _ast.ImportFrom))
+print(f"    tariff.py evaluates {len(_names)} distinct names and imports "
+      f"from {_imports or ['(stdlib only)']}")
+check(f"none of them is a command-side name {sorted(_FORBIDDEN)} - the utility "
+      f"bills what FLOWED, so this reads the meter and nothing else"
+      + (f"; found {_found}" if _found else ""), not _found)
+check("...and it imports nothing from arbiter, clamp or control: it files no "
+      "claim, applies no clamp, and commands nothing - SAFETY-07's job",
+      not [m for m in _imports if m in ("arbiter", "clamp", "control",
+                                        ".arbiter", ".clamp", ".control")])
+# ...and the guard is not vacuous: the same grader run over main.py, which DOES
+# command, must light up.
+_main = {n.attr for n in _ast.walk(
+    _ast.parse((HERE / "app" / "main.py").read_text(encoding="utf-8")))
+    if isinstance(n, _ast.Attribute)}
+check(f"the same grader over main.py finds {sorted(_main & _FORBIDDEN)}, so it "
+      f"is capable of failing", bool(_main & _FORBIDDEN))
+
+
+# ==============================================================================
+print()
+shutil.rmtree(TMP, ignore_errors=True)
+if fails:
+    print(f"{len(fails)} FAILED: {', '.join(fails)}")
+    sys.exit(1)
+print("all checks passed")

goodwe_controller/test_validate.py

@@ -253,6 +253,91 @@ check("...and the shipped charge rate is at or under the shipped ceiling",
 check("...and the shipped discharge rate too, so it warns about nothing",
       _shipped["maintenance_discharge_w"] <= _shipped["max_w"])
 
+# --------------------------------------------------------------------------- #
+print("the shipped meter_freeze_s, pinned (TEST-06 / AC3)")
+# ⚠️ WHY A NUMBER GETS ITS OWN CHECK. `meter_freeze_s: 300` is the threshold
+# SAFETY-18's entire argument is about, and before this it was pinned NOWHERE:
+# 300 -> 3600 left test_freeze.py AND this file green, because the schema
+# accepts int(60,3600) and no check ever read the shipped value. The schema
+# bounds what is CONFIGURABLE; this pins what is SHIPPED, which is a different
+# question and the one the docs answer.
+#
+# Read by regex like _shipped above, for the same reason: no PyYAML in the
+# image, and a check that skips on ImportError is not a check.
+_freeze_s = [float(v) for v in re.findall(
+    r"^  meter_freeze_s: (\d+(?:\.\d+)?)\s*$", _txt, re.M)]
+_freeze_schema = re.findall(r"^  meter_freeze_s: int\((\d+),(\d+)\)\s*$",
+                            _txt, re.M)
+check(f"config.yaml carries exactly one meter_freeze_s default {_freeze_s}",
+      len(_freeze_s) == 1)
+check("...and exactly one schema range for it", len(_freeze_schema) == 1)
+_hold_s = _freeze_s[0] if _freeze_s else None
+_lo, _hi = ((float(_freeze_schema[0][0]), float(_freeze_schema[0][1]))
+            if _freeze_schema else (None, None))
+check("the shipped meter_freeze_s is still the measured 300 s that freeze.py, "
+      "config.yaml's own comment and test_freeze.py are all written at",
+      _hold_s == 300.0)
+check(f"...and it is inside its own schema range ({_lo}-{_hi} s)",
+      None not in (_lo, _hi, _hold_s) and _lo <= _hold_s <= _hi)
+
+# The two properties the number has to have, DERIVED rather than restated - so
+# they go red on a value that is merely schema-legal. Both come straight from
+# config.yaml's own comment on the key.
+#
+#   upper: the alert must land inside the 900 s quarter that bills the capacity
+#          tariff, or the notification arrives after the money is spent;
+#   lower: the slowest a HEALTHY meter can tick a 1 Wh register and still look
+#          unchanged for hold_s is 3600/hold_s W, and that must stay inside the
+#          deadband or the conjunction's two terms stop being mutually
+#          exclusive (freeze.py, "WHERE hold_s COMES FROM").
+_QUARTER_S = 900.0
+_shipped_deadband = [float(v) for v in re.findall(
+    r"^  deadband_w: (\d+(?:\.\d+)?)\s*$", _txt, re.M)]
+check(f"config.yaml carries exactly one deadband_w default {_shipped_deadband}",
+      len(_shipped_deadband) == 1)
+_db = _shipped_deadband[0] if _shipped_deadband else None
+_slowest_healthy_w = 3600.0 / _hold_s if _hold_s else None
+print(f"    shipped meter_freeze_s {_hold_s} s: alert inside the "
+      f"{_QUARTER_S:.0f} s billing quarter, and a healthy meter slow enough to "
+      f"look unchanged for it is {_slowest_healthy_w} W against a "
+      f"{_db} W deadband")
+check(f"...the alarm still lands inside the {_QUARTER_S:.0f} s billing quarter",
+      _hold_s is not None and _hold_s < _QUARTER_S)
+check("...and a healthy meter that looks unchanged for it is still inside the "
+      "deadband, so the two terms stay mutually exclusive",
+      _slowest_healthy_w is not None and _db is not None
+      and _slowest_healthy_w < _db)
+
+# ⚠️ AND THE RANGE'S OWN BOUNDS. "300 sits inside the range" is worth nothing
+# while the range itself is unpinned: widened to `int(1,86400)` an operator can
+# configure `meter_freeze_s: 86400` and the guard is dead for a day at a time,
+# with every check in this repo still green. That mutation survived the first
+# cut of this PR and is what this block closes. Both numbers are argued for in
+# config.yaml's own comment and in freeze.py, and each is re-derived here:
+#
+#   60 s   the floor freeze.py calls NOT A RECOMMENDATION - there a healthy
+#          meter can look unchanged at 60 W, four times the shipped deadband, so
+#          the conjunction's two terms stop being mutually exclusive and only
+#          the margin is left;
+#   3600 s the ceiling - already four times the billing quarter, so the top of
+#          the range has given up detecting a freeze inside the quarter that
+#          bills it. It is the last bound between a supported configuration and
+#          a disabled guard, and moving it is a decision rather than a tidy-up.
+print(f"    schema range {_lo}-{_hi} s: at the floor a healthy meter that looks "
+      f"unchanged is "
+      + (f"{3600.0 / _lo:.0f} W" if _lo else "?")
+      + f" against a {_db} W deadband; the ceiling is "
+      + (f"{_hi / _QUARTER_S:.1f}x" if _hi else "?")
+      + " the billing quarter")
+check(f"the schema range itself is still the argued 60-3600 s (found "
+      f"{_lo}-{_hi})", (_lo, _hi) == (60.0, 3600.0))
+check("...a floor that gives up the mutual exclusion and keeps only the "
+      "margin, which is why config.yaml calls it not a recommendation",
+      None not in (_lo, _db) and 3600.0 / _lo > _db)
+check("...and a ceiling already past the billing quarter, so no value the "
+      "schema still accepts can alarm inside the quarter that bills it",
+      _hi is not None and _hi > _QUARTER_S)
+
 # --------------------------------------------------------------------------- #
 print("the KNOWN cross-file default divergence, pinned rather than commented")
 # ⚠️ WHAT THIS GUARDS, AND WHY IT ASSERTS THE BUG RATHER THAN THE FIX.

goodwe_controller/test_watchdog.py

@@ -274,6 +274,16 @@ from app.main import Controller  # noqa: E402
 class _Hass:
     def __init__(self):
         self.writes = []
+        self.calls = []
+
+    # ⚠️ ADDED FOR SAFETY-03, AND THE REASON IS WORTH READING. The e2e below
+    # runs a DELIBERATELY INVERTED loop (gain -0.6) into a steady 2000 W import,
+    # which is a loop that winds straight into the rail - so the output-clamp
+    # alarm fires here, and the stub not having `call` is how that was
+    # discovered. This scenario is now a second, independent witness that the
+    # clamp alarm sees a real winding loop; test_clamp.py asserts it explicitly.
+    async def call(self, domain, service, data):
+        self.calls.append((domain, service, data))
 
     async def limits(self, entity):
         return (-5000.0, 5000.0, 1.0)