TARIFF-17: a price component that varies by hour has somewhere to live

`price.py` modelled the whole non-energy part of a Belgian bill as ONE flat
scalar. This adds `price_taxes_profile`, which carries the TAXES component as
a period table, and makes `assemble()` evaluate it at each point's own instant.

⚠️ THE FLAT SCALAR WAS NOT A WRONG NUMBER, AND THIS IS NOT A CORRECTION OF ONE.
The optimiser reads exactly two quantities off a series - the spread
`max - min` over the firm points, and which hour is cheapest - and an additive
constant identical in every hour cancels out of the first and leaves the second
where it was. It is provably inert. Measured, and printed by test_price.py 16b
on every run: with a flat taxes figure of 0.00, 0.0739, 0.1198, 0.1327 or 1.00
EUR/kWh the same 24-hour feed is cheapest at 13:00 in all five cases and its
spread is 0.1500 EUR/kWh in all five cases. What was missing is anywhere for an
HOUR-VARYING non-energy component to live. This is a missing capability, not a
bad constant.

Belgium has one. Fluvius distribution is a single rate - its tariff-card row
reads `Normaal | Uitsl. nacht`, where exclusive night is a separate physical
circuit and not a night register - so nothing changes for the reference site in
Flanders. The Walloon DSOs and Sibelga are on the same card with four columns,
`Enkelvoudig | Dag | Nacht | Uitsl. nacht`, and the gap is real money (c/kWh):
ORES 13,27 / 7,39; AIESH 15,17 / 8,21; Tecteo RESA 12,20 / 7,01; Sibelga
9,39 / 7,10; ORES IMPACT 2026 16,578 / 5,090.

⚠️ AND THE BANDS ARE ANTI-CORRELATED WITH WHAT THE BATTERY WANTS TO DO. The
cheap network hours are the cheap spot hours, so flattening them does not shift
the curve - it UNDERSTATES the spread and declines cycles that would have paid.
Same feed, same markup, the only difference being the taxes argument:

    flat 0.0000 / 0.0739 / 0.1198 / 0.1327 / 1.0000
                                       -> cheapest hour 13, spread 0.1500
    ORES dag 0.1327 / nacht 0.0739     -> cheapest hour 03, spread 0.1788

The regression check grades WHICH HOUR IS CHEAPEST, not the spread: an
implementation that reads the table once and adds one number to every point is
the LEVEL bucket wearing a period table - right magnitude, wrong shape - and a
spread assertion passes on it. Measured: hoisting the lookup out of
`assemble()`'s loop (+17 B) is red on six named checks in test_price.py and
GREEN in the other 28 files.

ONE GRAMMAR, NOT TWO. `static_tariff.py` already shipped the periods, the day
selectors, the tiling rule and the DST handling, so `parse_taxes_profile()` is
the same parser with the option name and the "what this number means" clause as
arguments. A second tiling rule would be a second set of 23- and 25-hour-day
bugs. test_static_tariff.py section 10 pins that two ways: by parsing every
module under `app/` and asserting the grammar is defined in exactly one of
them, and by deriving each of thirteen refusal sentences for the new option
from the old option's own sentence rather than transcribing them.

`Component.TAXES` semantics, `code_leaks()` and the double-counting guarantee
are untouched. The new key joins FRAMEWORK_KEYS, BANNED_IN_PLUGIN_CODE is
derived from that set, and a plugin that names it is refused at `register()`.
It reaches both plugins that take taxes - `custom_formula` ({ENERGY, MARKUP})
and `generic_dayahead` ({ENERGY}) - and not `manual_csv`, which is all-in: the
table is routed through `capabilities().adds`, exactly as the scalar is.

⚠️ A MALFORMED TABLE IS REFUSED AT STARTUP, NOT AT THE NEXT FETCH. It is read
on the ~30 s planning path, and a table that first fails at 03:00 is a site
that stops pricing at 03:00, which §11.4 turns into a quiet fallback
indistinguishable from a healthy fixed-tariff day. validate.py refuses three
things: a table that does not tile the day; a table set beside a NON-DEFAULT
`price_taxes_eur_kwh`, because the table wins and the scalar would then be a
number the operator typed that decides nothing; and a whole card typed in
CENTS, which is how these figures are printed. That last rung is not a
restatement of the parser's +-10 EUR/kWh bound - ORES's 13,27 trips the parser,
but Sibelga's entire card, 9,39 and 7,10, is under it and would otherwise have
started as a 9.39 EUR/kWh levy. Both rungs are graded by the REASON each gives,
and mutating them together (TEST-16) moves three rows.

NOTHING CHANGES FOR A SITE THAT DOES NOT SET IT. The option ships "", and the
scalar path is unchanged arithmetically rather than merely in intent:
test_price.py 16f reproduces the pre-TARIFF-17 expression and compares 12
capability/scalar combinations point for point with `==`.

13 mutations, every one red on a named check, ledger in test_price.py below
section 16k with byte deltas and the one equivalent mutant named. 29/29 green.

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

goodwe_controller/CHANGELOG.md

@@ -23,6 +23,8 @@ if it has, it needs 0.10.0. Whoever deploys decides.
 | _this branch_ | TARIFF-07 - three plugins that never fetched a price are withdrawn, and a site configured on one is told so **⚠️ BACKWARD-INCOMPATIBLE** |
 | _this branch_ | TARIFF-15 - `custom_formula`: your own tariff card's two coefficients, graded against the card's own printed price |
 | _this branch_ | TARIFF-13 - the capacity-tariff row's "quarter(s) banked" stops resetting to 0 at every restart, and a tied peak's quarter stops moving |
+| _this branch_ | TARIFF-11 - the add-on's account of the tariff plan stops flattering it, and the status page is graded as a surface |
+| _this branch_ | TARIFF-17 - a price component that varies by hour has somewhere to live, so a Walloon day/night network tariff can change which hour is cheapest |
 
 ⚠️ **A CONFIG THAT STARTS ON THE CURRENT VERSION CAN BE REFUSED ON THE NEXT
 ONE.** TARIFF-07 withdraws `engie_dynamic`, `totalenergies_dynamic` and
@@ -58,6 +60,77 @@ separate card. *(Annotated 2026-09-13: that card is **TARIFF-15**, below, and it
 shipped on this branch as `custom_formula`. It is still not an alias — the
 operator types their own coefficients; nothing is invented on their behalf.)*
 
+### TARIFF-17 - a price component that varies by hour has somewhere to live
+
+**`price_taxes_profile`: the taxes component as a period table, alongside the
+flat `price_taxes_eur_kwh`.** ⚠️ **The flat scalar was not a wrong number, and
+this is not a correction of one.** The optimiser reads exactly two things off a
+series — the spread `max − min` over the firm points, and which hour is
+cheapest — and an additive constant identical in every hour cancels out of the
+first and leaves the second where it was. It is *provably* inert. What was
+missing was anywhere for an **hour-varying** non-energy component to live.
+
+Belgium has one. Fluvius distribution is a single rate, and its row on the
+tariff card reads `Normaal | Uitsl. nacht` — *exclusive night* being a separate
+physical circuit, not a night register — so for the reference site in Flanders
+nothing here changes. The Walloon DSOs and Sibelga are on the same card with
+four columns, `Enkelvoudig | Dag | Nacht | Uitsl. nacht`, and the gap is real
+money (c€/kWh): ORES `13,27 / 7,39`, AIESH `15,17 / 8,21`, Tecteo RESA
+`12,20 / 7,01`, Sibelga `9,39 / 7,10`, ORES IMPACT 2026 `16,578 / 5,090`.
+
+⚠️ **AND THE BANDS ARE ANTI-CORRELATED WITH WHAT THE BATTERY WANTS TO DO.** The
+cheap network hours *are* the cheap spot hours, so flattening them does not
+shift the curve — it **understates the spread** and declines cycles that would
+have paid. Measured on one ordinary Belgian winter weekday, same feed, same
+markup, the only difference being the taxes argument:
+
+```
+flat 0.0000 / 0.0739 / 0.1198 / 0.1327 / 1.0000  -> cheapest hour 13, spread 0.1500
+ORES dag 0.1327 / nacht 0.0739                   -> cheapest hour 03, spread 0.1788
+```
+
+Five different flat figures spanning and exceeding the table's own range give
+**the same hour and the same spread to the last digit**; the table moves the
+hour a battery would buy in from 13:00 to 03:00. That is the regression
+`test_price.py` section 16 grades, and it grades **the hour**, not the spread:
+an implementation that reads the table once and adds one number to every point
+produces the right magnitude and the wrong shape, and a spread assertion passes
+on it. `DOCS.md` now names the three buckets — LEVEL, SPREAD, ORDER — so the
+next person adding a component knows which one it is in.
+
+**The change is contained.** `static_tariff.py` already shipped the grammar —
+periods tiling the day, gaps and overlaps refused, day types, DST — so it is
+**the same parser**, taking the option name and the "what this number means"
+clause as arguments. There is no second tiling rule, because a second one would
+be a second set of 23- and 25-hour-day bugs; `test_static_tariff.py` section 10
+pins that by parsing every module under `app/` and asserting the grammar is
+defined in exactly one of them, and by deriving each of thirteen refusal
+sentences for the new option from the old option's own sentence.
+`Component.TAXES` semantics, `code_leaks()` and the double-counting guarantee
+are untouched: the new key joins `FRAMEWORK_KEYS`, `BANNED_IN_PLUGIN_CODE` is
+derived from that set, and a plugin naming it is refused at `register()`.
+
+⚠️ **A MALFORMED TABLE IS REFUSED AT STARTUP, NOT AT THE NEXT FETCH.** It is
+read on the ~30 s planning path through `assemble()`, and a table that first
+fails at 03:00 is a site that stops pricing at 03:00 — which §11.4 turns into a
+quiet fallback indistinguishable from a healthy fixed-tariff day. `validate.py`
+parses it at startup, and refuses three things: a table that does not tile the
+day (the same sentence `static_profile` gives, naming this key); a table set
+*beside* a non-default `price_taxes_eur_kwh`, because the table wins and the
+scalar would then be a number the operator typed that decides nothing; and a
+whole card typed **in cents**, which is how these figures are printed. That
+last rung is not a restatement of the parser's ±10 EUR/kWh bound — ORES's
+`13,27` trips the parser, but Sibelga's entire card, `9,39` and `7,10`, is
+under it, and would otherwise have started as a 9.39 EUR/kWh levy.
+
+**Nothing changes for a site that does not set it.** The option ships `""`, the
+scalar path is unchanged arithmetically — `test_price.py` 16f reproduces the
+pre-TARIFF-17 expression and compares 12 capability/scalar combinations point
+for point with `==` — and the reference site is in Flanders, where the flat
+figure is correct. This is a product concern rather than a site one: the add-on
+is sold to clients, and a Walloon or Brussels client could not express their
+own tariff.
+
 ### TARIFF-13 - the coverage figure beside the peak, and which quarter gets it
 
 **The capacity-tariff status row's `N quarter(s) banked` is read from the
@@ -108,6 +181,94 @@ noise in the one row an operator reads when the guard engages.
 Reasoning in `DECISIONS/TARIFF-13-the-coverage-of-a-peak.md`; parts 11 and 12
 of `test_tariff.py` drive a real restart — a second `Controller` against the
 same file — and pin both decisions.
+### TARIFF-11 - the plan's own account of itself, corrected and put on the page
+
+**Four defects, one shape: every one of them made the add-on look better than
+it was.** They shipped together because nothing in this repository graded the
+strings a human is shown — every tariff check inspects the `TariffPlan`
+*object*, and all four were in the *sentences* built out of it.
+
+**1. `TariffPlan.words` counted points and called them hours.** The live
+add-on logged `dynamic_dayahead from generic_dayahead, 132 h` for **132
+quarter-hourly points = 33 hours**. Belgium moved to a 15-minute MTU on
+2025-10-01, so on the real feed this was wrong every time it was printed, and
+⚠️ **not by a constant factor**: measured across a 40-hour soak the
+overstatement ranged **1.79× to 5.33×**, because §8.3's carried points are
+hourly while the firm ones are quarter-hourly and the ratio moves with the mix
+through the day. It now reads
+
+```
+dynamic_dayahead from generic_dayahead, 132 points over 33 h,
+132 firm / 0 carried, 900 s spacing
+```
+
+— the same plan, with each number in its own unit. On the weekday morning that
+plan is partly carried and reads `60 points over 33 h, 36 firm / 24 carried,
+900+3600 s spacing, provisional` instead, which is the state the soak found an
+operator could learn nothing about. The `N points over H h` wording is
+FCST-04's *Price history* wording on purpose, so the two rows describing the
+same feed can be compared rather than being two conventions on one page.
+
+**2. The §8.3 and flat-tariff refusals did the same, and they reach an
+operator.** `§8.3: only 1 of 96 hours carry a published price` is 96 points,
+which is 24 hours; the flat rung counted the same points and called them `firm
+hours`. ⚠️ **This is exactly the point≠hour conflation TARIFF-14 removed from
+`at()`, left standing in the prose that describes it** — and it is not confined
+to a log line, because `self.arb.explain()` puts it on the status page. Both
+now print the two quantities separately: `only 1 of 96 points carry a published
+price - 1 of 24 hours`. The same conflation in `price_forecast.py`'s §8.3
+carry-forward log line — `%d of %d hours` with a carried-HOUR count over a
+POINT count — is corrected in the same commit.
+
+**3. The plan reached no HTTP surface at all.** `origin`, `product`, the
+firm/carried split and the spacing appeared in **no** status row. `rows["Tariff"]`
+was `static_status()`'s sentence, computed on the 30 s I/O-free tick from its
+own static plan, and it **never saw the provider plan** — it read `'no static
+profile'` at all **802** soak samples on a site whose feed was answering. So an
+operator could not tell a working dynamic tariff from no tariff machinery at
+all, and could not learn that the plan was `provisional` for 76 % of the soak
+or mixed 900/3600 s for 70 %. The *Tariff* row now carries the plan.
+
+⚠️ **The two halves of that row are not computed at the same moment and the row
+says so.** `static_status()` runs on the 30 s tick; the provider plan comes off
+the 1800 s background refresh and is served for up to `TARIFF_MAX_AGE_S`
+(5400 s since TARIFF-12). So the plan half is stamped with **its own age**,
+measured from `tariff_at` — which TARIFF-12 deliberately does not move on a
+kept plan. A provider site with no usable plan says that too, rather than
+falling silently back to the static sentence.
+
+**4. `main.py`'s "if and only if" was false, and the row named an option that
+was on.** TARIFF-10's comment asserted that `self.arb is None` **iff**
+`arbitrage.enabled(self.o)` was False. `cycle()` returns at the input hold —
+inputs missing, `bad_for < stale_input_s`, 15 s by default — **before** it
+reaches `self.arb = None`. Driven: `arbitrage_enabled: true` plus a sensor
+answering `None` gives `arbitrage.enabled(opts) = True`, `self.arb = None` and
+a row reading `off (arbitrage_enabled)`. Past the first completed cycle the
+same early return leaves the **previous** decision standing, which the row
+rendered as a current one, up to ~15 s stale. The row now distinguishes three
+facts with three remedies — trading is off; trading is on and this cycle
+reached no decision; a decision, with its age — and it reads the **option**
+rather than inferring it from a missing decision. The comment states what is
+true.
+
+⚠️ **THE DELIVERABLE IS THE CHECK, NOT THE FIXES.** All four survived 29 green
+suites because no check in this repository had ever read a rendered row.
+`test_price.py` section 12 renders through the shipped `Controller.status_payload()`,
+parses each number out of the row **by its own slot**, and compares it against
+a figure computed from the fixture's own construction parameters — never from
+the property the row was built out of (MUTATION.md habit 4). It is deliberately
+**not** a substring test over a sentence the same file wrote: `"132 points" in
+row` is satisfied by the number appearing in the *other* number's slot, which
+habit 14 shows is a zero-byte edit away. The fixtures are a **set** of four
+plan shapes, and the check computes and prints the table of field pairs no
+fixture separates — `none` — so a pair that became degenerate would go red
+rather than quietly vacuous. The *Arbitrage* row's three states are driven
+through real cycles with a sensor answering `None`, and graded by
+**inequality**: two facts that must not render identically.
+
+**Nothing about what the battery decides changes.** No threshold, no refusal
+rung, no claim, no setpoint. Every edit is to a sentence, to a derived counter
+behind one, or to where a sentence is rendered.
 
 ### TARIFF-15 - your own tariff card, as two coefficients
 

goodwe_controller/DOCS.md

@@ -1765,12 +1765,50 @@ hour the feed did not print at all.
 
 **What you can actually see on the status page.** *Price history* (below) says
 what is held. *Arbitrage* carries the strategy's own sentence, which names the
-firm/provisional split whenever that split is what refused a trade. *Tariff*
-does **not** report the fill: it is the static-profile or Home Assistant
-price-entity sentence, regenerated on the 30 s tick. The provider plan's own
-line — `dynamic_dayahead from generic_dayahead, 48 h, provisional` — goes to the
-**add-on log** at every refresh, alongside `§8.3: 33 of 48 hours carried forward
-from yesterday's profile and flagged provisional; 15 published`.
+firm/provisional split whenever that split is what refused a trade. And
+**Tariff** on the status page reads `provisional` through the morning, because
+since TARIFF-11 that row carries the provider plan itself:
+
+```
+Tariff: no static profile (recomputed this tick); provider plan fetched 412 s
+        ago for a 48 h horizon: dynamic_dayahead from generic_dayahead,
+        60 points over 33 h, 36 firm / 24 carried, 900+3600 s spacing,
+        provisional
+```
+
+⚠️ **The two halves of that row are not computed at the same moment, and the
+row says so.** Everything before the semicolon is the static-profile or Home
+Assistant price-entity sentence, regenerated on the **30 s tick** from options
+alone — no network. Everything after it is the **background refresh's**
+resolution, which runs every 1800 s and is served for up to 5400 s before it is
+retired; `fetched N s ago` is the age of the fetch that produced it and is the
+only figure in the row that tells you whether the feed is still answering. On a
+site with a provider configured and no usable plan the row says that too,
+rather than falling silently back to the static half.
+
+Read the plan half as five separate facts: which *product* the feed publishes
+and which *plugin* read it, how many **points** it carries and how many **whole
+hours** those points cover, how many of the points are **firm** (published for
+their own interval) against **carried** (filled from yesterday under §8.3), the
+**spacing** of the points in seconds — `900+3600` is the normal mixed steady
+state, quarter-hourly firm points beside hourly carried ones — and `provisional`
+whenever any point is carried.
+
+⚠️ **Points and hours are two different numbers and this row used to print one
+of them under the other's name.** `words` was `f"… {len(points)} h"`, so a
+33-hour plan of quarter-hourly points logged `dynamic_dayahead from
+generic_dayahead, 132 h`. It is the same conflation the *Price history* row
+carried before FCST-04 and the same one `at()` carried before TARIFF-14, and it
+is **not a constant factor**: measured over a 40-hour soak the overstatement
+ranged **1.79× to 5.33×**, because the carried points are hourly while the firm
+ones are quarter-hourly, so the ratio moves with the mix as the day goes on.
+The same sentence is in the **add-on log** at every refresh, alongside `§8.3:
+33 of 48 hours carried forward from yesterday's profile and flagged
+provisional; the feed published 60 points over the other 15 hours`.
+
+The §8.3 refusal an operator reads when a trade is declined counts in the same
+two units — `§8.3: only 1 of 96 points carry a published price - 1 of 24 hours`
+— where it used to say `only 1 of 96 hours` about a 24-hour day.
 
 The plan is also now cut to the horizon you asked for, which means **hours that
 have already elapsed are no longer in it**. That is a real change to arbitrage:
@@ -1832,6 +1870,129 @@ uses the result as a cheap-window hint for the maintenance charge. They are
 — 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.
 
+### The three buckets — which price components can move a decision (TARIFF-17)
+
+**Read this before adding a price component of any kind.** The optimiser reads
+exactly two quantities off a price series, and nothing else:
+
+- the **spread**, `max − min` over the *firm* points, weighed against
+  `cycle_cost_threshold_eur`; and
+- **which hour is cheapest**, `min(firm, key=…)` — the hour a battery would
+  buy in.
+
+Every component of a Belgian bill reaches those two through one of three
+buckets, and which bucket it is in is a property of its *shape*, not of its
+size:
+
+| bucket | what it looks like | reaches the decision? |
+|---|---|---|
+| **LEVEL** | additive, **identical every hour** | **No — provably.** An additive constant cancels exactly in `max − min`, and adding it to every point leaves the argmin where it was |
+| **SPREAD** | **multiplicative** on the spot index | **Yes.** It scales the spread against a fixed `cycle_cost_threshold_eur` |
+| **ORDER** | **varies** by hour, block or day-type | **Yes, and worst.** It changes *which hour is cheapest* |
+
+Measured on the real arithmetic (`test_price.py` section 16b, printed on every
+run): with a flat taxes figure of 0.00, 0.0739, 0.1198, 0.1327 or 1.00 EUR/kWh,
+the same 24-hour feed is cheapest at **13:00 in all five cases** and its spread
+is **0.1500 EUR/kWh in all five cases**. That is the LEVEL bucket doing
+nothing, and it is not a rounding artefact — it is arithmetic.
+
+Three consequences worth having in mind:
+
+1. **`price_taxes_eur_kwh` is not a wrong number and never was.** It sits in
+   the LEVEL bucket and *cannot* distort either quantity. What it also cannot
+   do is express a component that varies by hour — which is why
+   `price_taxes_profile` exists. The defect TARIFF-17 closed was a **missing
+   capability**, not a bad constant.
+2. **`custom_formula`'s `factor` is a SPREAD component, and its `offset` is
+   LEVEL.** The contract price is `(factor × index + offset) × (1 + VAT)`, so
+   the spread over a feed is `factor × (1 + VAT) × (max index − min index)` —
+   the offset drops out entirely, and the spread is *proportional* to `factor`.
+   Moving `factor` from 0.100 to 0.10812 therefore moves the spread by exactly
+   **+8.1 %** on any feed whatever. A coefficient typed one digit wrong is not
+   a small pricing error; it is a different trading threshold. The VAT rate is
+   multiplicative on the whole expression, so it is SPREAD too.
+3. **A check that grades the spread is grading the wrong bucket.** An
+   implementation that reads an hour-varying table *once* and adds the same
+   number to every point produces a series of the right magnitude and the wrong
+   shape — the LEVEL bucket wearing a period table. The spread would look
+   plausible; the buy hour would be wrong. So the regression check for an
+   ORDER-bucket component asserts **which hour is cheapest**, not how big the
+   spread is (`test_price.py` 16c and 16d).
+
+⚠️ **Where the buckets are today.** `price_markup_eur_kwh`,
+`price_taxes_eur_kwh` and `custom_formula`'s `offset` are LEVEL.
+`custom_formula`'s `factor` and its VAT rate are SPREAD. `price_taxes_profile`
+is the only ORDER component the add-on has. Anything added next belongs in one
+of the three, and saying which is part of adding it.
+
+### Levies and VAT by time of day (`price_taxes_profile`)
+
+**Leave this empty unless your network tariff really does have a day and a
+night rate**, which in Flanders it does not. Fluvius distribution is a single
+rate: its row on the tariff card reads `Normaal | Uitsl. nacht`, and
+*exclusive night* is a **separate physical circuit** (a night-storage heater on
+its own meter), not the night register of a dual-rate meter. For a Flemish site
+the flat `price_taxes_eur_kwh` is correct, and this option changes nothing.
+
+**Wallonia and Brussels are different, and the same card proves it.** The
+Walloon DSOs and Sibelga get four columns — `Enkelvoudig | Dag | Nacht |
+Uitsl. nacht` — and the day/night gap is real money (c€/kWh):
+
+| DSO | enkelvoudig | dag | nacht | gap |
+|---|---|---|---|---|
+| ORES | 11,98 | 13,27 | 7,39 | **5,88** |
+| AIESH | 13,64 | 15,17 | 8,21 | **6,96** |
+| Tecteo RESA | 11,06 | 12,20 | 7,01 | 5,19 |
+| Sibelga (Brussels) | 9,39 | 9,39 | 7,10 | 2,29 |
+| ORES IMPACT (2026) | — | 16,578 | 5,090 | **11,49** |
+
+⚠️ **The bands are anti-correlated with what the battery wants to do.** The
+cheap network hours are the cheap spot hours. So flattening them does not
+merely shift the curve — it **systematically understates the true spread**, and
+the add-on declines cycles that are genuinely profitable. On ORES's bands over
+one ordinary winter weekday the measured effect is: cheapest hour **13:00 →
+03:00**, spread **0.1500 → 0.1788 EUR/kWh**.
+
+It is written in **exactly the same grammar as `static_profile`** — the same
+periods, the same day selectors, the same rule that every day type is covered
+once with no gap and no overlap, the same DST handling. It is literally the
+same parser; there is no second tiling rule, because a second one would be a
+second set of 23- and 25-hour-day bugs.
+
+```json
+{"periods": [
+  {"name":"dag",  "from":"07:00","to":"22:00","days":"mon-fri","eur_per_kwh":0.1327},
+  {"name":"nacht","from":"22:00","to":"07:00","days":"mon-fri","eur_per_kwh":0.0739},
+  {"name":"nacht","from":"00:00","to":"24:00","days":"sat,sun", "eur_per_kwh":0.0739}]}
+```
+
+- ⚠️ **`eur_per_kwh` here is the LEVIES ALONE, not an all-in price.** It is the
+  non-energy part of the bill for that band, and the add-on adds it to whatever
+  your price source publishes — exactly as it adds the flat figure. This is the
+  one place the two options differ in meaning while sharing a grammar, and the
+  refusal you get for leaving the number out says which one is wanted.
+- ⚠️ **The card prints cents. This option takes EUR.** ORES prints `13,27`;
+  type `0.1327`. A whole card typed in cents is refused at startup, naming both
+  bands and the factor — including the cards (Sibelga's 9,39 / 7,10) whose
+  figures are small enough to slip past the ±10 EUR/kWh bound the parser holds
+  every price to.
+- ⚠️ **Set this *or* `price_taxes_eur_kwh`, not both.** The table wins when it
+  is set, so a scalar left at a non-default value beside it would be a number
+  you typed that decides nothing. That is refused at startup rather than
+  silently resolved; leave `price_taxes_eur_kwh` at its shipped `0.06` when you
+  fill this in.
+- A **malformed table is refused at startup**, not at the next fetch. It is
+  read on the ~30 s planning path, and a table that first fails at 03:00 is a
+  site that stops pricing at 03:00 — which §11.4 turns into a quiet fallback
+  that looks exactly like a healthy fixed-tariff day.
+- It applies to the components the framework **adds**: `generic_dayahead`
+  (which declares `{ENERGY}`) and `custom_formula` (which declares
+  `{ENERGY, MARKUP}`) both get it. `manual_csv` publishes an all-in figure and
+  is untouched — the table is routed through the same `capabilities().adds`
+  rule as the scalar, not bolted on.
+- It does **not** apply to `static_profile`, whose prices are already all-in,
+  nor to `export_price_eur_kwh`.
+
 ### Static day/night and fully-fixed tariffs (`static_profile`)
 
 Most Belgian households are **not** on a dynamic contract, and an EMS that only
@@ -1951,6 +2112,33 @@ only thing that decides whether a request leaves the machine is
 `price_provider`: with it `off`, the refresh resolves the static profile in
 memory and opens no connection.
 
+**The *Arbitrage* status row says which of three things is true** — trading is
+off, trading is on and this cycle reached no decision, or a decision was
+reached — and it stamps every decision with its age. Until TARIFF-11 it said
+one of two, because the first two rendered identically. They have three
+different remedies:
+
+| the row opens with | what is true | what to do |
+|---|---|---|
+| **off** — *"arbitrage_enabled is false, so nothing trades"* | Trading is not armed. Nothing will happen, and nothing is wrong | Arm it, if you meant to |
+| **ON (arbitrage_enabled), but NO DECISION has been reached yet** | Trading **is** armed, and no cycle has run as far as the arbitrage step. The row then names the control loop's own reason, usually *inputs missing* | Fix the input the loop names |
+| **decided N s ago:** … | The strategy answered this cycle, and `N` is how old that answer is | Read the sentence that follows — it is the strategy's own |
+| **no decision this cycle (reason); the last one was taken N s ago:** … | Trading is armed, a decision stands from an earlier cycle, and **this** cycle stopped before reaching the step | As row 2 — the standing decision is history, not a verdict on now |
+
+A fifth rendering — *"…no decision this cycle …, and none stands from an
+earlier one"* — covers the case where trading was armed after a cycle had
+already run without it.
+
+⚠️ **The second row used to render exactly like the first one**, naming
+`arbitrage_enabled` on a site where `arbitrage_enabled` is `true`. A cycle with
+a missing input returns after roughly `stale_input_s` (15 s by default) without
+reaching the arbitrage step at all, so on an armed site the row reported *off*
+at startup and, once one decision had been taken, went on showing that decision
+for up to 15 s after the site stopped deciding anything. The age on the third
+row is printed **always**, including when it is zero: a row that reports
+staleness only once it is stale cannot be told from one that never reports
+it.
+
 ### Site
 
 | option | meaning |

goodwe_controller/app/main.py

@@ -218,6 +218,106 @@ def pack_energy_of(inv):
                                 inv.capacity_kwh, inv.max_w)
 
 
+def tariff_plan_row(plan, tick_words: str, *, age_s, horizon_h: float,
+                    provider: bool, max_age_s: float) -> str:
+    """The *Tariff* status row: the 30 s tick's sentence AND the provider plan.
+
+    THE DEFECT THIS PREVENTS (TARIFF-11). `origin`, `product`, the horizon,
+    the firm/carried split and the spacing appeared in NO status row. The row
+    was `static_status()`'s sentence alone, computed on the 30 s I/O-free tick
+    from its own static plan, and it NEVER SAW the provider plan - it read
+    `'no static profile'` at all 802 samples of a 40-hour soak on a site whose
+    feed was answering. The only external evidence a plan existed at all was
+    one `_LOG.info` line, and that line carried the point<->hour mislabel
+    `TariffPlan.words` is fixed for.
+
+    ⚠️ TWO SOURCES, TWO CLOCKS, AND THE ROW SAYS SO IN WORDS. These sentences
+    are NOT computed at the same moment and presenting them as though they
+    were would be a new version of the defect being fixed:
+
+        `tick_words`  static_status() / the Home Assistant price entities,
+                      regenerated on THIS tick, every 30 s, I/O-free;
+        `plan`        the background refresh's resolution, up to
+                      TARIFF_REFRESH_S old before it is retried and up to
+                      TARIFF_MAX_AGE_S (5400 s since TARIFF-12) old before
+                      `fresh_tariff_plan()` retires it.
+
+    So the plan half is stamped with its OWN age in seconds, measured from
+    `tariff_at` - the moment of the fetch that produced it, which TARIFF-12
+    deliberately does not move on a kept plan.
+
+    ⚠️ AND `age_s` IS THE CALLER'S MEASUREMENT, NOT THIS FUNCTION'S. A clock
+    read in here would be a second clock disagreeing with the one that decided
+    the plan was fresh enough to pass at all.
+
+    ⚠️ "NO PLAN" IS SAID OUT LOUD ON A SITE THAT CONFIGURED A PROVIDER. A
+    dynamic site whose refresh has never completed, or whose plan has aged
+    past `max_age_s`, is the exact state the soak measured; rendering it as
+    the bare static sentence is how it stayed invisible for 802 samples.
+    """
+    if plan is None:
+        if not provider:
+            return tick_words
+        return (f"{tick_words} (recomputed this tick); NO provider plan - "
+                f"none has been resolved yet, or the last one is older than "
+                f"{max_age_s:.0f} s")
+    return (f"{tick_words} (recomputed this tick); provider plan fetched "
+            f"{age_s:.0f} s ago for a {horizon_h:.0f} h horizon: {plan.words}")
+
+
+def arbitrage_row(*, on: bool, decision, decided_at, cycle_at, now,
+                  why: str) -> str:
+    """The *Arbitrage* status row: THREE states, which used to render as two.
+
+    THE DEFECT THIS PREVENTS (TARIFF-11). The row was
+    `"off (arbitrage_enabled)" if self.arb is None else self.arb.explain()`,
+    under a comment asserting that `self.arb is None` if and only if
+    `arbitrage.enabled(self.o)` was False. IT IS NOT: `cycle()` returns at the
+    input hold - inputs missing, `bad_for < stale_input_s`, default 15 s -
+    BEFORE it reaches `self.arb = None`. Driven: `arbitrage_enabled: true`
+    plus a sensor answering `None` gives `arbitrage.enabled(opts) = True`,
+    `self.arb = None` (its `__init__` value, untouched) and a row reading
+    `off (arbitrage_enabled)` - NAMING AN OPTION THAT IS ON. Past the first
+    completed cycle the same early return leaves the PREVIOUS decision
+    standing instead, which the row then rendered as a current one.
+
+    THE THREE FACTS, and they are three because they have three remedies:
+
+        trading is off          the operator has not armed it. Nothing is
+                                wrong and nothing will happen.
+        no decision this cycle  it is armed, and the cycle did not get as far
+                                as the arbitrage step. `why` is the control
+                                loop's own reason - usually "inputs missing".
+        a decision              the strategy's own sentence, with the age of
+                                the cycle that produced it.
+
+    ⚠️ `on` IS READ FROM THE OPTIONS, NOT INFERRED FROM `decision is None`.
+    Inferring it is the whole defect: the option is the only thing that
+    answers "is trading armed", and it is available on every render.
+
+    ⚠️ THE AGE IS ALWAYS PRINTED, INCLUDING WHEN IT IS ZERO. A row that
+    reports staleness only once it is stale cannot be told, on any single
+    render, from one that never reports it - and the bound TARIFF-10's
+    comment claimed did not exist is ~15 s of it.
+    """
+    if not on:
+        return "off - `arbitrage_enabled` is false, so nothing trades"
+    if decided_at is None:
+        return (f"ON (`arbitrage_enabled`), but NO DECISION has been reached "
+                f"yet - no cycle has run as far as the arbitrage step. The "
+                f"loop's own reason: {why or 'none recorded'}")
+    age = (now - decided_at).total_seconds()
+    stale = cycle_at is not None and decided_at < cycle_at
+    head = (f"no decision this cycle ({why or 'no reason recorded'}); the "
+            f"last one was taken {age:.0f} s ago: " if stale else
+            f"decided {age:.0f} s ago: ")
+    if decision is None:
+        return (f"ON (`arbitrage_enabled`), no decision this cycle "
+                f"({why or 'no reason recorded'}), and none stands from an "
+                f"earlier one")
+    return head + decision.explain()
+
+
 class Controller:
     def __init__(self, opts: dict, hass: HomeAssistant, store, mqtt_pub, *, stop,
                  peak_db_path: str = "/data/tariff.db",
@@ -796,6 +896,19 @@ class Controller:
         self.tariff_plan = None
         self.tariff_at = None
         self.arb = None
+        # TARIFF-11. WHEN the standing arbitrage decision was taken, or None if
+        # this controller has never reached the arbitrage step. ⚠️ `self.arb is
+        # None` DOES NOT MEAN "TRADING IS OFF" AND NEVER DID - see
+        # `arbitrage_row()`. It also means "cycle() returned before the step
+        # ran", and at that point `self.arb` is either this attribute's initial
+        # None (startup) or the PREVIOUS cycle's decision (an input hold), and
+        # the status row rendered all three identically.
+        self.arb_at = None
+        # TARIFF-11. When the most recent cycle() STARTED. `arb_at < cycle_at`
+        # is the exact, derived statement of "the latest cycle did not get as
+        # far as the arbitrage step", which is the fact the *Arbitrage* row
+        # used to render identically to "trading is switched off".
+        self.cycle_at = None
         self._arb_action = None
         self.inputs_bad_since = None
         # SAFETY-03. What the loop's OWN bounds did last cycle - a
@@ -1565,6 +1678,24 @@ class Controller:
             self.cheap, self.tariff_words = static_status(
                 o, datetime.now(timezone.utc))
 
+        # ⚠️ TARIFF-11. THE PROVIDER PLAN REACHES THE *Tariff* ROW HERE, AND
+        # THIS IS THE ONLY PLACE THE TWO SOURCES MEET. Everything above is the
+        # 30 s I/O-free tick; `fresh_tariff_plan()` is an attribute read and an
+        # age comparison against TARIFF_MAX_AGE_S - still no fetch on this path,
+        # which is the rule the whole branch above exists to keep. What the row
+        # gains is the plan's SHAPE (origin, product, horizon, the firm/carried
+        # split, the spacing) and what it must never gain is the suggestion
+        # that the two halves were computed at the same instant, so the plan
+        # half carries its own age in seconds. See `tariff_plan_row()`.
+        _tick = datetime.now(timezone.utc)
+        _standing = self.fresh_tariff_plan(_tick)
+        self.tariff_words = tariff_plan_row(
+            _standing, self.tariff_words,
+            age_s=(None if _standing is None
+                   else (_tick - self.tariff_at).total_seconds()),
+            horizon_h=float(price_option(o, "price_horizon_h")),
+            provider=provider_configured(o), max_age_s=TARIFF_MAX_AGE_S)
+
         if self.inputs_ok:
             if self.inputs_bad_since is not None:
                 self.log_event("inputs recovered")
@@ -1918,6 +2049,11 @@ class Controller:
         method's only job is to state honestly what each strategy wants.
         """
         now = datetime.now(timezone.utc)
+        # ⚠️ BEFORE THE FIRST `return` OF THIS METHOD, ON PURPOSE (TARIFF-11).
+        # It stamps that a cycle RAN, which is a different fact from any of the
+        # decisions the cycle may or may not reach, and the status row needs
+        # the two separately.
+        self.cycle_at = now
 
         # ⚠️ EACH PACK ON ITS OWN READING, NOT "the SoC". §12's recalibration
         # drains and refills ONE pack and grades ONE coulomb counter, so each
@@ -2577,7 +2713,13 @@ class Controller:
         # `frozenset()` would be main.py asserting a forecast is healthy when
         # there is not one, which is exactly what static_tariff's `uncertainty`
         # argument has no default in order to prevent.
-        self.arb = None
+        # ⚠️ TARIFF-11: BOTH ATTRIBUTES, AND `arb_at` IS WHAT MAKES THE ROW
+        # HONEST. Reaching this line is the only proof that this cycle got as
+        # far as the arbitrage step; the early return at the input hold above
+        # leaves BOTH standing at whatever the last completed cycle left, and
+        # `arb_at` is then the age the status row reports rather than a
+        # decision presented as current.
+        self.arb, self.arb_at = None, now
         if arbitrage.enabled(self.o):
             floor_pct, ceiling_pct = arbitrage.soc_bounds(self.o)
             charge_w, discharge_w = self.trade_power_w(floor_pct, ceiling_pct)
@@ -4481,15 +4623,23 @@ class Controller:
             # every refusal it can make already carries a reason a human can
             # act on, and "Arbitrage: no" would throw all of them away.
             #
-            # ⚠️ TARIFF-10 RE-READ THIS STRING AND LEFT IT ALONE, which is worth
-            # saying because that card is about the two switches being
-            # different. `self.arb` is None if and only if
-            # `arbitrage.enabled(self.o)` was False, so `off (arbitrage_enabled)`
-            # still names the option that is actually off - and on a site with a
-            # provider configured it is now the row that says the prices
-            # arriving on the *Price history* row above are moving nothing.
-            ("Arbitrage", "off (arbitrage_enabled)" if self.arb is None
-             else self.arb.explain()),
+            # ⚠️ TARIFF-10 RE-READ THIS STRING AND LEFT IT ALONE UNDER A
+            # COMMENT THAT WAS FALSE, AND TARIFF-11 IS THAT CORRECTION. The
+            # claim was that `self.arb is None` **if and only if**
+            # `arbitrage.enabled(self.o)` was False. Only the forward direction
+            # holds: `cycle()` returns at the input hold (`bad_for <
+            # stale_input_s`, default 15 s) BEFORE it reaches `self.arb = None`
+            # at all, so on an armed site `self.arb` is `__init__`'s None at
+            # startup and the PREVIOUS cycle's decision during a later hold -
+            # and the row rendered `off (arbitrage_enabled)` on a site whose
+            # `arbitrage_enabled` is `true`. `arbitrage_row()` reads the option
+            # instead of inferring it, and separates "trading is off" from "no
+            # decision was reached this cycle"; `cycle_at` and `arb_at` are what
+            # make the second one an observation rather than a guess.
+            ("Arbitrage", arbitrage_row(
+                on=arbitrage.enabled(self.o), decision=self.arb,
+                decided_at=self.arb_at, cycle_at=self.cycle_at,
+                now=datetime.now(timezone.utc), why=self.reason)),
         ]
         return {
             "banner": banner, "level": level, "rows": rows, "checks": checks,

goodwe_controller/app/price.py

@@ -851,6 +851,18 @@ PRICE_OPTION_DEFAULTS = {
     # test_price.py section 1. A second defaults dict in the new module would be
     # a fourth place option defaults live, which is exactly the open ticket.
     "static_profile": "",
+    # TARIFF-17. A JSON object in `static_profile`'s OWN period grammar whose
+    # per-period `eur_per_kwh` is the TAXES COMPONENT for that band, not an
+    # all-in price; "" is unset and the scalar above decides. Parsed and
+    # validated by app/static_tariff.py (`parse_taxes_profile`), refused at
+    # startup by validate.py - the `static_profile` precedent exactly, and here
+    # for the same CFG-03 reason: this dict is the ONE in-code mirror of
+    # config.yaml.
+    #
+    # ⚠️ IT IS IN FRAMEWORK_KEYS. A plugin that could read this could add the
+    # taxes a second time, per hour, which is the double-counting defect trap 1
+    # exists to refuse - wearing a period table instead of a scalar.
+    "price_taxes_profile": "",
     # TARIFF-15. A JSON object carrying ONE contract's two coefficients, the
     # units they are printed in, its VAT rate and the card figures the add-on
     # grades them against; "" is unset. Parsed and validated by
@@ -884,6 +896,12 @@ PRICE_OPTION_DEFAULTS = {
 # that can double-count, so `PluginOptions` refuses them by name. Trap 1.
 FRAMEWORK_KEYS = frozenset({
     "price_markup_eur_kwh", "price_taxes_eur_kwh", "export_price_eur_kwh",
+    # TARIFF-17. The hour-varying spelling of `price_taxes_eur_kwh`, and it
+    # belongs here for the same reason the scalar does: it is a component the
+    # FRAMEWORK adds exactly once, by `caps.adds`. `BANNED_IN_PLUGIN_CODE` is
+    # derived from this set, so `code_leaks()` refuses a plugin that names it
+    # without anything else being edited.
+    "price_taxes_profile",
 })
 
 
@@ -1019,6 +1037,27 @@ def export_price_eur_kwh(opts: dict) -> float:
     return float(price_option(opts, "export_price_eur_kwh"))
 
 
+def taxes_profile(opts: dict):
+    """The configured `price_taxes_profile` as a period table, or None.
+
+    TARIFF-17. Raises `static_tariff.ProfileInvalid` on a malformed table - and
+    ⚠️ THAT EXCEPTION IS NOT MEANT TO REACH A RUNNING SITE. validate.py parses
+    the same option at STARTUP and refuses to start on it, for the reason
+    `static_profile` is refused there: a table that only fails when a fetch
+    happens is a site that stops pricing at 03:00, and §11.4 turns that into a
+    quiet fallback nothing on the status page distinguishes from a healthy
+    fixed-tariff day. `load_prices()` still handles it, loudly, because a guard
+    whose only proof is "the other guard ran first" is not a guard.
+
+    ⚠️ THE IMPORT IS LAZY AND THE CYCLE IS THE REASON. `static_tariff.py`
+    imports this module at module scope; importing it back at module scope here
+    would make which file is imported first decide whether the add-on starts.
+    `sys.modules` makes the repeat cost a dict lookup.
+    """
+    from .static_tariff import parse_taxes_profile
+    return parse_taxes_profile(price_option(opts, "price_taxes_profile"))
+
+
 # --------------------------------------------------------------------------- #
 # The plugin interface
 # --------------------------------------------------------------------------- #
@@ -1286,23 +1325,68 @@ def _validate_raw(points, caps):
         seen = u
 
 
+def taxes_at(taxes, instant: datetime) -> float:
+    """The TAXES component at ONE instant. A scalar, or a period table.
+
+    TARIFF-17. THE DEFECT THIS EXISTS TO CLOSE, and it is a MISSING CAPABILITY
+    rather than a wrong constant: `price_taxes_eur_kwh` is additive and
+    identical every hour, so it cancels exactly out of `max - min` and cannot
+    move `min(firm, key=...)`. It is not a distortion - it is provably inert on
+    both quantities the optimiser reads. What was missing is anywhere for an
+    HOUR-VARYING non-energy component to live, and the Walloon and Brussels
+    DSOs bill one: ORES `dag 13,27 / nacht 7,39` c EUR/kWh, a 5,88 c gap whose
+    cheap band coincides with the cheap spot hours. Flattening it does not
+    shift the curve, it UNDERSTATES the spread and declines profitable cycles.
+    See DOCS.md "The three buckets".
+
+    ⚠️ DUCK-TYPED ON `price_at`, NOT ON `isinstance`. price.py must not import
+    static_tariff.py - static_tariff.py imports THIS module, and a module-level
+    cycle would make the import order load-bearing. `taxes_profile()` below is
+    the one place the real parser is reached, and it imports it lazily.
+
+    ⚠️ THE LOOKUP IS ON THE ~30 s PLANNING PATH through `assemble()`, so it
+    stays a linear scan over the two-to-four periods a Belgian tariff has
+    (`StaticProfile.at()`), with no parsing, no allocation and no I/O. A
+    malformed table never reaches here: validate.py refuses it at STARTUP.
+    """
+    at = getattr(taxes, "price_at", None)
+    if at is None:
+        return float(taxes)
+    return float(at(instant))
+
+
 def assemble(caps: ProviderCapabilities, raw, markup: float,
-             taxes: float) -> list:
+             taxes) -> list:
     """RawPoints -> canonical all-in PricePoints. THE ONLY PLACE MARKUP IS ADDED.
 
     Adds exactly `caps.adds` - the complement of what the plugin declared its
     source already contains. A plugin that publishes an all-in figure gets
     nothing added; a raw EPEX figure gets both.
+
+    ⚠️ `taxes` IS A SCALAR *OR* A PERIOD TABLE (TARIFF-17), AND IT IS EVALUATED
+    AT EACH POINT'S OWN INSTANT. Hoisting the lookup out of the loop - reading
+    it once and adding the same number to every point - is the mutation that
+    collapses the whole feature back into the LEVEL bucket: the assembled
+    series would still differ from the untaxed one by the right MAGNITUDE, and
+    the cheapest hour would be wrong. `test_price.py` section 24 is the check
+    that goes red for it, and it grades WHICH HOUR IS CHEAPEST rather than the
+    spread, because a spread-magnitude assertion passes on the hoisted version.
+
+    ⚠️ THE SCALAR PATH IS UNCHANGED, ARITHMETICALLY AND NOT ONLY IN INTENT.
+    `taxes_at()` on a float returns that float at every instant, and
+    `0.0 + markup` is exactly `markup` in IEEE 754 for every finite markup, so
+    a site on a scalar gets the identical bytes it got before this landed.
     """
-    add = 0.0
-    if Component.MARKUP in caps.adds:
-        add += float(markup)
-    if Component.TAXES in caps.adds:
-        add += float(taxes)
-    return [PricePoint(start=brussels(p.start),
-                       eur_per_kwh=round(p.eur_per_kwh + add, 6),
-                       provisional=bool(p.provisional))
-            for p in raw]
+    add_markup = float(markup) if Component.MARKUP in caps.adds else 0.0
+    wants_taxes = Component.TAXES in caps.adds
+    out = []
+    for p in raw:
+        local = brussels(p.start)
+        add = add_markup + (taxes_at(taxes, local) if wants_taxes else 0.0)
+        out.append(PricePoint(start=local,
+                              eur_per_kwh=round(p.eur_per_kwh + add, 6),
+                              provisional=bool(p.provisional)))
+    return out
 
 
 # --------------------------------------------------------------------------- #
@@ -1902,13 +1986,38 @@ async def load_prices(opts: dict, since: datetime, until: datetime,
 
     caps = cls.capabilities()
     markup = float(price_option(opts, "price_markup_eur_kwh"))
-    taxes = float(price_option(opts, "price_taxes_eur_kwh"))
+
+    # ⚠️ TARIFF-17: THE TABLE WINS OVER THE SCALAR, AND validate.py REFUSES THE
+    # CASE WHERE BOTH SAY SOMETHING. Two writers of one quantity, one of which
+    # silently loses, is the shape validate.py exists to refuse - so the
+    # precedence here is only ever exercised on a configuration that has
+    # already been accepted, and it is spelled out rather than left implicit.
+    taxes_key = "price_taxes_eur_kwh"
+    try:
+        table = taxes_profile(opts)
+    except Exception as e:                                    # noqa: BLE001
+        # Not silent, and not a traceback into the 30 s tick. validate.py
+        # should have refused this at startup; if the add-on is running with it
+        # anyway, the operator is told which key and what is wrong with it.
+        _LOG.error("price_taxes_profile cannot be used (%s: %s), so this fetch "
+                   "has NO tax component to add - it is not falling back to "
+                   "price_taxes_eur_kwh, because a silently different tax "
+                   "basis is the defect this option exists to remove. Fix the "
+                   "table or clear it; validate.py refuses it at startup",
+                   type(e).__name__, e)
+        return PriceRead.no_data(
+            f"price_taxes_profile cannot be used: {e}")
+    if table is not None:
+        taxes = table
+        taxes_key = "price_taxes_profile"
+    else:
+        taxes = float(price_option(opts, "price_taxes_eur_kwh"))
 
     # ⚠️ Not a refusal, but not silent either. A plugin whose feed is already
     # all-in ignores these two numbers, and an operator who typed them has every
     # reason to believe they took effect.
     ignored = [n for c, n, v in ((Component.MARKUP, "price_markup_eur_kwh", markup),
-                                 (Component.TAXES, "price_taxes_eur_kwh", taxes))
+                                 (Component.TAXES, taxes_key, taxes))
                if c not in caps.adds and v]
     if ignored:
         _LOG.warning("%s publishes a figure that already contains %s, so the "

goodwe_controller/app/price_forecast.py

@@ -422,9 +422,19 @@ def fill_from_yesterday(read: PriceRead, *, yesterday: PriceRead,
     _audit(out, published)
     carried = sum(1 for p in out if _utc_hour(p.start) not in published)
     if carried:
+        # ⚠️ THREE QUANTITIES, THREE NAMES (TARIFF-11). This line read
+        # "%d of %d hours ... ; %d published" with `carried` (a count of
+        # carried HOURS - the fill emits exactly one point per unpublished
+        # hour) over `len(out)` (a count of POINTS, four per hour wherever the
+        # feed printed) and `len(out) - carried` (POINTS again) under the same
+        # noun. On the Belgian quarter-hourly feed that reads "33 of 141
+        # hours" about a 48-hour horizon. The fill's unit is the HOUR and the
+        # feed's is the POINT; nothing derived from one answers for the other.
+        total_h = len({_utc_hour(p.start) for p in out})
         _LOG.info("§8.3: %d of %d hours carried forward from yesterday's "
-                  "profile and flagged provisional; %d published",
-                  carried, len(out), len(out) - carried)
+                  "profile and flagged provisional; the feed published %d "
+                  "points over the other %d hours",
+                  carried, total_h, len(out) - carried, total_h - carried)
 
     product = read.match(series=lambda r: r.product,
                          no_data=lambda _r: yesterday.product)

goodwe_controller/app/static_tariff.py

@@ -222,6 +222,12 @@ _DAY_ALIASES = {
 
 MINUTES_PER_DAY = 1440
 
+# TARIFF-17. The option key whose value is a period table of the TAXES
+# component. One spelling, here, because price.py, validate.py and config.yaml
+# all name it and `provider_id()`'s note says what three spellings of one
+# decision cost.
+TAXES_PROFILE_OPTION = "price_taxes_profile"
+
 # 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
@@ -320,13 +326,37 @@ def _days(value, field: str) -> frozenset:
     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."""
+# What a period's `eur_per_kwh` MEANS, per option. The grammar is one grammar
+# (TARIFF-17); the quantity it carries is not, so the "you left this out"
+# sentence is the one thing the two tables do not share.
+_PERIOD_MEANS = {
+    "static_profile":
+        "an all-in eur_per_kwh (energy + supplier markup + taxes, §9.3) - the "
+        "same basis the dynamic providers are assembled onto, so the two are "
+        "comparable",
+}
+_TAXES_MEANS = (
+    "the TAXES component alone in eur_per_kwh - the non-energy part of the "
+    "bill for that band (distribution, levies, VAT), NOT an all-in price. The "
+    "framework adds it to what the feed publishes, exactly as the scalar "
+    "price_taxes_eur_kwh is added"
+)
+_PERIOD_MEANS[TAXES_PROFILE_OPTION] = _TAXES_MEANS
+
+
+def _price(value, field: str, means: str = None) -> float:
+    """One period's EUR/kWh, bounded exactly as price.py bounds a feed.
+
+    `means` names the quantity for the error sentence only. TARIFF-17: the same
+    grammar carries an ALL-IN price under `static_profile` and a TAXES-ONLY
+    component under `price_taxes_profile`, and an operator who confuses the two
+    is out by an energy price - so the refusal says which one is wanted.
+    """
+    if means is None:
+        means = _PERIOD_MEANS["static_profile"]
     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.")
+            f"{field} is missing. Every period needs {means}.")
     if isinstance(value, bool) or not isinstance(value, (int, float, str)):
         raise ProfileInvalid(f"{field} is {value!r}, which is not a number")
     try:
@@ -383,14 +413,19 @@ class Period:
 class StaticProfile:
     """A validated two-or-more-period tariff. Immutable, pure, I/O-free."""
 
-    def __init__(self, periods):
+    def __init__(self, periods, *, option: str = "static_profile"):
         self.periods = tuple(periods)
+        # ⚠️ TARIFF-17: the OPTION NAME travels with the profile so that every
+        # refusal names the key the operator actually typed. It is a default
+        # argument on purpose - every pre-existing call site and every
+        # pre-existing sentence is byte-identical without it.
+        self.option = option
         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)
+                f"{option} has no periods. A profile with no periods is "
+                f"not a fixed tariff, it is an absent one - leave the option "
+                f"empty to say that on purpose (§11.4 then applies).")
+        _check_tiling(self.periods, option=option)
 
     # -- what kind of tariff this is, DERIVED --------------------------------
     @property
@@ -477,7 +512,7 @@ class StaticProfile:
             u += timedelta(hours=1)
         if not out:
             raise ProfileInvalid(
-                f"static_profile.series({since.isoformat()}, "
+                f"{self.option}.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
@@ -489,7 +524,7 @@ class StaticProfile:
         return f"{kind}: " + "; ".join(p.words for p in self.periods)
 
 
-def _check_tiling(periods) -> None:
+def _check_tiling(periods, *, option: str = "static_profile") -> 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
@@ -506,22 +541,22 @@ def _check_tiling(periods) -> None:
             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)
+                _raise_gap(weekday, gap_from, minute, option)
             if n <= 1 and over_from is not None:
-                _raise_overlap(weekday, over_from, minute, periods)
+                _raise_overlap(weekday, over_from, minute, periods, option)
         if gap_from is not None:
-            _raise_gap(weekday, gap_from, MINUTES_PER_DAY)
+            _raise_gap(weekday, gap_from, MINUTES_PER_DAY, option)
         if over_from is not None:
-            _raise_overlap(weekday, over_from, MINUTES_PER_DAY, periods)
+            _raise_overlap(weekday, over_from, MINUTES_PER_DAY, periods, option)
 
 
 def _hhmm(m):
     return f"{m // 60:02d}:{m % 60:02d}"
 
 
-def _raise_gap(weekday, start, end):
+def _raise_gap(weekday, start, end, option="static_profile"):
     raise ProfileInvalid(
-        f"static_profile leaves {DAY_NAMES[weekday]} "
+        f"{option} 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 "
@@ -529,19 +564,28 @@ def _raise_gap(weekday, start, end):
         f"\"22:00-07:00 mon-fri\" does NOT cover Saturday morning.")
 
 
-def _raise_overlap(weekday, over, end, periods):
+def _raise_overlap(weekday, over, end, periods, option="static_profile"):
     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"{option} 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):
+def parse_static_profile(value, *, option: str = "static_profile",
+                         means: str = None):
     """`static_profile` -> a `StaticProfile`, or None when unset.
 
+    ⚠️ TARIFF-17 MADE `option`/`means` PARAMETERS RATHER THAN FORKING THIS
+    FUNCTION, and that is the whole of the reuse. A second period parser would
+    be a second tiling rule, a second day-type rule and a second set of DST
+    bugs, diverging first on the 23- and 25-hour days where nobody looks. The
+    two arguments move only the OPTION NAME and the "what this number is"
+    clause through the refusals; the grammar, the tiling check and the wrapping
+    rule are one implementation with one set of checks over it.
+
     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
@@ -555,6 +599,8 @@ def parse_static_profile(value):
     """
     if value is None:
         return None
+    if means is None:
+        means = _PERIOD_MEANS.get(option, _PERIOD_MEANS["static_profile"])
     if isinstance(value, str):
         text = value.strip()
         if not text or text.lower() in ("null", "none", "off"):
@@ -563,7 +609,7 @@ def parse_static_profile(value):
             value = json.loads(text)
         except ValueError as e:
             raise ProfileInvalid(
-                f"static_profile is not valid JSON ({e}). It is a JSON object "
+                f"{option} 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'
@@ -573,7 +619,7 @@ def parse_static_profile(value):
         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"{option}.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 "
@@ -581,24 +627,24 @@ def parse_static_profile(value):
         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.")
+                f"{option} has no \"periods\" list. Even a fully-fixed "
+                f"tariff is written as one period covering 00:00-24:00 all days "
+                f"- one shape for both products, so nothing downstream branches "
+                f"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")
+            f"{option}.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"{option}.periods[{i}] is {type(row).__name__}, not an "
                 f"object with from/to/days/eur_per_kwh")
-        where = f"static_profile.periods[{i}]"
+        where = f"{option}.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")
@@ -617,8 +663,47 @@ def parse_static_profile(value):
                               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)
+                                                 f"{where}.eur_per_kwh",
+                                                 means)))
+    return StaticProfile(periods, option=option)
+
+
+def parse_taxes_profile(value):
+    """`price_taxes_profile` -> a `StaticProfile` of TAX values, or None.
+
+    TARIFF-17. THE DEFECT THIS EXISTS TO CLOSE: `price.py` modelled the whole
+    non-energy part of a Belgian bill as ONE scalar. In Flanders that is
+    correct - Fluvius distribution is a single rate and its tariff card offers
+    only `Normaal | Uitsl. nacht`, where *exclusive night* is a separate
+    physical circuit rather than a night register. The Walloon and Brussels
+    DSOs are on the same card with four columns - `Enkelvoudig | Dag | Nacht |
+    Uitsl. nacht` - and the day/night gap is real money:
+
+        ORES          dag 13,27  nacht  7,39  ->  5,88 c EUR/kWh
+        AIESH         dag 15,17  nacht  8,21  ->  6,96
+        Tecteo RESA   dag 12,20  nacht  7,01  ->  5,19
+        Sibelga (BXL) dag  9,39  nacht  7,10  ->  2,29
+        ORES IMPACT   dag 16,578 nacht  5,090 -> 11,49   (2026)
+
+    ⚠️ AND THE BANDS ARE ANTI-CORRELATED WITH WHAT THE BATTERY WANTS TO DO.
+    The cheap network hours are the cheap spot hours, so flattening them does
+    not merely shift the curve - it SYSTEMATICALLY UNDERSTATES the true spread
+    and makes the add-on decline cycles that are genuinely profitable. See
+    DOCS.md "The three buckets" for why the flat scalar could never have done
+    this: an additive constant, identical every hour, cancels exactly in
+    `max - min` and cannot move `min(firm, key=...)` either.
+
+    ⚠️ THE VALUE IS THE TAXES COMPONENT, NOT AN ALL-IN PRICE. `static_profile`
+    uses the same grammar for an all-in figure; the two are one parser and two
+    meanings, and `_price()`'s refusal names which one it wanted.
+
+    ⚠️ NOT PARSED ON THE FETCH PATH. validate.py refuses a malformed table at
+    STARTUP, by the rule `price.py` trap 3 states for `static_profile`: a table
+    that cannot be parsed at 03:00 is a site that stops pricing at 03:00, and
+    §11.4 makes that quiet.
+    """
+    return parse_static_profile(value, option=TAXES_PROFILE_OPTION,
+                                means=_TAXES_MEANS)
 
 
 # --------------------------------------------------------------------------- #
@@ -771,6 +856,63 @@ class TariffPlan:
             series=lambda r: any(p.provisional for p in r.points),
             no_data=lambda _r: True)
 
+    # -- the plan's SHAPE, in the two units it actually has (TARIFF-11) ------
+    # ⚠️ POINTS AND HOURS ARE TWO NUMBERS AND THIS PLAN HAD ONLY EVER
+    # REPORTED ONE OF THEM, UNDER THE OTHER'S NAME. `words` read
+    # `f"... {len(self.read.points)} h"`, which counts POINTS: on the
+    # quarter-hourly Belgian feed (15-minute MTU, 2025-10-01) a 33-hour plan
+    # logged `dynamic_dayahead from generic_dayahead, 132 h`. It is the same
+    # conflation TARIFF-14 removed from `at()` and FCST-04 removed from the
+    # *Price history* row, left standing in the prose. ⚠️ AND THE ERROR IS
+    # NOT A FLAT 4x: a 40 h soak measured 1.79x .. 5.33x, because §8.3's
+    # carried points are HOURLY while the firm ones are quarter-hourly, so
+    # the ratio moves with the firm/carried mix as the day goes on. Nothing
+    # derived from ONE of these numbers can answer for the other.
+
+    @property
+    def n_points(self) -> int:
+        """How many points the series carries. A `no_data` read carries none."""
+        return self.read.match(series=lambda r: len(r.points),
+                               no_data=lambda _r: 0)
+
+    @property
+    def hours(self) -> int:
+        """How many distinct WHOLE CLOCK HOURS those points touch.
+
+        Same rule as `price_history._held()`, deliberately - the *Tariff* and
+        *Price history* rows describe the same feed and an operator reading
+        `132 points over 33 h` beside `96 points over 24 h` must be able to
+        compare them. A point is attributed to the UTC hour its own start
+        falls in; hours the feed never printed are simply not in the set, so
+        this counts what is PRICED rather than what was asked for.
+        """
+        return self.read.match(series=lambda r: _whole_hours(r.points),
+                               no_data=lambda _r: 0)
+
+    @property
+    def n_firm(self) -> int:
+        """Points carrying a published price for their own interval (§8.3)."""
+        return len(self.firm_points())
+
+    @property
+    def n_carried(self) -> int:
+        """Points filled from yesterday's profile, or from §11.4's fallback."""
+        return self.n_points - self.n_firm
+
+    @property
+    def spacings_s(self) -> tuple:
+        """The distinct gaps between consecutive points, ascending, in seconds.
+
+        ⚠️ MIXED IS THE NORMAL STEADY STATE, NOT AN EDGE CASE. FCST-04's
+        carry-forward emits HOURLY carried points beside QUARTER-HOURLY firm
+        ones and the soak measured `[900, 3600]` in 70 % of samples - so a
+        surface reporting one global spacing would be wrong about the usual
+        case. `price._cover_table()` is where that rule is enforced; this
+        only reports it.
+        """
+        return self.read.match(
+            series=lambda r: _spacings(r.points), no_data=lambda _r: ())
+
     def price_at(self, instant: datetime) -> float:
         """EUR/kWh now. Raises `Absence` when there is no price - never 0.0."""
         return self.read.match(
@@ -926,20 +1068,30 @@ class TariffPlan:
         pts = self.read.points
         firm = tuple(p for p in pts if not p.provisional)
         if len(firm) < 2:
+            # ⚠️ POINTS, AND THE HOUR FIGURE BESIDE IT RATHER THAN INSTEAD OF
+            # IT (TARIFF-11). This sentence read "only 1 of 96 hours carry a
+            # published price" about 96 quarter-hourly points, which are 24
+            # hours - the point<->hour conflation TARIFF-14 removed from
+            # `at()`, still standing here, and this one reaches an OPERATOR
+            # through main.py's *Arbitrage* row and not only the log.
             return Arbitrage.refuse(
-                f"§8.3: only {len(firm)} of {len(pts)} hours carry a published "
-                f"price - the rest are provisional (origin {self.origin!r}), "
-                f"and no irreversible action may be taken on a provisional "
-                f"price. A buy hour and a sell hour must BOTH be firm before a "
-                f"cycle can be committed. Load shifting, self-consumption and "
-                f"peak shaving continue")
+                f"§8.3: only {len(firm)} of {len(pts)} points carry a "
+                f"published price - {_whole_hours(firm)} of "
+                f"{_whole_hours(pts)} hours - and the rest are provisional "
+                f"(origin {self.origin!r}), so no irreversible action may be "
+                f"taken on them. A buy interval and a sell interval must BOTH "
+                f"be firm before a cycle can be committed. Load shifting, "
+                f"self-consumption and peak shaving continue")
 
         spread = round(max(p.eur_per_kwh for p in firm)
                        - min(p.eur_per_kwh for p in firm), 6)
         if spread == 0.0:
+            # ⚠️ POINTS AND HOURS, SEPARATELY, for the §8.3 rung's reason -
+            # this sentence counted points and called them "firm hours" too.
             return Arbitrage.refuse(
-                f"the tariff is flat - every one of the {len(firm)} firm hours "
-                f"costs {firm[0].eur_per_kwh:.4f} EUR/kWh, so buying low and "
+                f"the tariff is flat - every one of the {len(firm)} firm "
+                f"points, spanning {_whole_hours(firm)} hours, costs "
+                f"{firm[0].eur_per_kwh:.4f} EUR/kWh, so buying low and "
                 f"selling high is arithmetically impossible. §9.2: a fully "
                 f"fixed product is self-consumption only")
 
@@ -969,15 +1121,77 @@ class TariffPlan:
 
     @property
     def words(self) -> str:
+        """The plan's whole shape in one sentence - LOG *AND* STATUS PAGE.
+
+        ⚠️ THIS STRING IS OPERATOR-FACING SINCE TARIFF-11, which is a reason
+        for its wording to matter MORE rather than less. It used to reach only
+        `_LOG.info("tariff refreshed: %s")`; main.py's *Tariff* row now carries
+        it, age-stamped, so every number in it is read by somebody who cannot
+        see the object.
+
+        ⚠️ EVERY QUANTITY IS NAMED IN ITS OWN UNIT. `{n} points over {h} h` is
+        FCST-04's *Price history* wording on purpose - the two rows describe
+        the same feed and have to be comparable - and the firm/carried split
+        and the spacing are here because they were the two facts the soak
+        found an operator could not learn at all: the plan was `provisional`
+        for 76 % of a 40-hour soak and mixed 900/3600 s for 70 %, and no HTTP
+        surface said either.
+        """
         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"
+        gaps = self.spacings_s
+        return (f"{self.product.value} from {tag}, "
+                f"{self.n_points} points over {self.hours} h, "
+                f"{self.n_firm} firm / {self.n_carried} carried"
+                + (f", {'+'.join(str(g) for g in gaps)} s spacing"
+                   if gaps else "")
                 + (", provisional" if self.provisional else ""))
 
 
+def _whole_hours(points) -> int:
+    """How many distinct whole CLOCK HOURS a point list touches. Never raises.
+
+    THE DEFECT THIS PREVENTS (TARIFF-11). Three sentences in this module
+    reported `len(points)` under the name "hours": `TariffPlan.words`, §8.3's
+    firm-pair refusal and the flat-tariff refusal. On the hourly series that
+    was the only resolution any fixture carried before TARIFF-08 the two
+    numbers are identical, which is why it shipped; on the Belgian
+    quarter-hourly feed (15-minute MTU, 2025-10-01) `words` read
+    `dynamic_dayahead from generic_dayahead, 132 h` for 33 hours and the
+    refusal read `only 1 of 96 hours` for 24.
+
+    ⚠️ IT IS NOT `n / 4`, AND A CONSTANT FACTOR IS THE WRONG FIX. §8.3's
+    carry-forward emits ONE HOURLY point per unpublished hour beside the
+    feed's four-per-hour firm ones, so the measured overstatement over a
+    40-hour soak ranged 1.79x .. 5.33x as the mix moved. The hour count has
+    to be COUNTED.
+
+    ⚠️ IT COUNTS PRICED HOURS, NOT THE HORIZON. FCST-04 leaves an hour out
+    of the series when neither the feed nor yesterday can price it, so this
+    is at most the horizon and is smaller whenever the plan has holes - which
+    is the honest direction for a figure an operator reads as "how far ahead
+    do I have prices".
+    """
+    return len({p.start.astimezone(timezone.utc)
+                .replace(minute=0, second=0, microsecond=0) for p in points})
+
+
+def _spacings(points) -> tuple:
+    """Distinct gaps between consecutive points, ascending, in whole seconds.
+
+    Sorted by START, not by list order: `price._cover_table()` establishes
+    that order for `at()` rather than assuming it, and a surface that reported
+    the gaps of an unsorted list would print negative spacings about a series
+    that answers correctly.
+    """
+    starts = sorted(p.start.astimezone(timezone.utc) for p in points)
+    return tuple(sorted({int((b - a).total_seconds())
+                         for a, b in zip(starts, starts[1:])}))
+
+
 def _absent(reason):
     raise Absence(
         f"this plan observed no prices ({reason}). A number invented here is "

goodwe_controller/app/validate.py

@@ -331,7 +331,9 @@ from .maintenance import MAINT_OPTION_DEFAULTS
 from .p1 import is_enabled, validate_meter_options
 from .peakguard import PEAK_OPTION_DEFAULTS
 from .price import PRICE_OPTION_DEFAULTS, PROVIDERS, RETIRED_PROVIDERS
-from .static_tariff import ProfileInvalid, parse_static_profile
+from .static_tariff import (
+    ProfileInvalid, TAXES_PROFILE_OPTION, parse_static_profile,
+    parse_taxes_profile)
 from .watchdog import SIGN_OPTION_DEFAULTS
 
 _LOG = logging.getLogger("goodwe.config")
@@ -1420,6 +1422,79 @@ def _price_problems(opts: dict) -> list[str]:
                 "for this product. Peak shaving, reserve management and the "
                 "maintenance cycle are unaffected.", profile.prices[0])
 
+    # ⚠️ TARIFF-17: THE TAXES PERIOD TABLE, PARSED AT STARTUP RATHER THAN AT
+    # 03:00, FOR `static_profile`'s REASON ONE OPTION OVER. This table is read
+    # by `price.assemble()` on the ~30 s planning path; a table that only fails
+    # when a fetch happens is a site that stops pricing mid-afternoon, and
+    # §11.4 turns that into a quiet fallback that looks exactly like a healthy
+    # fixed-tariff day. So the parse happens here, once, where a refusal is a
+    # banner naming the key.
+    raw_taxes_profile = opts.get(TAXES_PROFILE_OPTION, "")
+    taxes_table = None
+    if str(raw_taxes_profile or "").strip() \
+            or isinstance(raw_taxes_profile, (list, dict)):
+        try:
+            taxes_table = parse_taxes_profile(raw_taxes_profile)
+        except ProfileInvalid as e:
+            problems.append(f"{TAXES_PROFILE_OPTION} cannot be used: {e}")
+
+    if taxes_table is not None:
+        # ⚠️ TWO WRITERS OF ONE QUANTITY, ONE OF WHICH SILENTLY LOSES - the
+        # exact case (a) this module exists for, and the same refusal shape as
+        # the price-entity/static_profile pair above. The table decides when it
+        # is set, so a non-default scalar left beside it is a number the
+        # operator typed that changes nothing, on the quantity §11.4 makes
+        # hardest to notice. It is compared against the SHIPPED DEFAULT rather
+        # than against presence, because the Supervisor writes every schema key
+        # into the options file whether the operator touched it or not.
+        scalar = _number(opts, "price_taxes_eur_kwh",
+                         PRICE_OPTION_DEFAULTS["price_taxes_eur_kwh"])
+        shipped = PRICE_OPTION_DEFAULTS["price_taxes_eur_kwh"]
+        if scalar is not None and abs(scalar - shipped) > 1e-12:
+            problems.append(
+                f"{TAXES_PROFILE_OPTION} is set AND price_taxes_eur_kwh is "
+                f"{scalar} rather than its shipped {shipped}. THE TABLE WINS: "
+                f"the add-on reads the per-period figures and never looks at "
+                f"the scalar, so the number you typed there would decide "
+                f"nothing and nothing would say so. Set price_taxes_eur_kwh "
+                f"back to {shipped}, or clear {TAXES_PROFILE_OPTION} to keep "
+                f"the flat figure.")
+
+        # ⚠️ THE UNITS RUNG, AND IT IS A SECOND QUANTITY RATHER THAN A
+        # RESTATEMENT. Every Belgian DSO prints these bands in c EUR/kWh
+        # (ORES `13,27`), and the whole table is copied off one card - so the
+        # factor-100 error arrives on EVERY row at once and nothing internal to
+        # the table disagrees with itself. The parser's own +-10 EUR/kWh bound
+        # catches a 13,27 typed raw, but NOT ORES IMPACT's night band of 5,090,
+        # which would be a 5.09 EUR/kWh levy sailing through. Belgian
+        # non-energy components run roughly 0.05-0.25 EUR/kWh, so anything at
+        # or above 1.0 is the wrong unit and not a tariff.
+        steep = sorted({p.eur_per_kwh for p in taxes_table.periods
+                        if abs(p.eur_per_kwh) >= 1.0})
+        if steep:
+            problems.append(
+                f"{TAXES_PROFILE_OPTION} carries {steep} EUR/kWh. Belgian "
+                f"levies and distribution run about 0.05-0.25 EUR/kWh, so "
+                f"these are almost certainly the CENT figures off the tariff "
+                f"card (ORES prints `13,27`, which is 0.1327 EUR/kWh) typed "
+                f"without the conversion - a factor of 100 that would make "
+                f"every hour look like an emergency. Divide by 100, or clear "
+                f"the option.")
+        negative = sorted({p.eur_per_kwh for p in taxes_table.periods
+                           if p.eur_per_kwh < 0})
+        if negative:
+            # ⚠️ A WARNING, NOT A REFUSAL. A negative non-energy component is
+            # implausible rather than impossible - a prosumer rebate is
+            # expressible this way - and refusing a site over it would be this
+            # module asserting a fact about Belgian tariff design it cannot
+            # observe. §14's warning box governs CONTRADICTIONS, and this is
+            # not one.
+            _LOG.warning(
+                "%s carries negative levies %s EUR/kWh. That is accepted, but "
+                "a tax component below zero is usually a sign error: the "
+                "add-on will SUBTRACT it from the published price in those "
+                "hours.", TAXES_PROFILE_OPTION, negative)
+
     # ⚠️ TARIFF-15: THE FORMULA, GRADED AGAINST THE OPERATOR'S OWN CARD, AT
     # STARTUP RATHER THAN AT 03:00.
     #

goodwe_controller/config.yaml

@@ -328,6 +328,40 @@ options:
   # validate.py warns about exactly that.
   static_profile: ""
 
+  # TARIFF-17. THE TAXES COMPONENT AS A DAY/NIGHT TABLE, for the sites whose
+  # network tariff actually has one. "" means the flat price_taxes_eur_kwh
+  # above decides, which is what every install has had until now and is CORRECT
+  # IN FLANDERS: Fluvius distribution is a single rate, and its row on the
+  # tariff card offers only `Normaal | Uitsl. nacht` - exclusive night being a
+  # separate physical circuit, not the night register of a dual-rate meter.
+  #
+  # The Walloon and Brussels DSOs are on the same card with FOUR columns -
+  # `Enkelvoudig | Dag | Nacht | Uitsl. nacht` - and the gap is real money
+  # (c EUR/kWh): ORES dag 13,27 / nacht 7,39; AIESH 15,17 / 8,21; Tecteo RESA
+  # 12,20 / 7,01; Sibelga 9,39 / 7,10; ORES IMPACT 2026 16,578 / 5,090.
+  #
+  # ⚠️ WHY THIS IS NOT COSMETIC. The optimiser reads the SPREAD (max - min) and
+  # which hour is cheapest. A flat number is additive and identical every hour,
+  # so it cancels out of both - it cannot distort anything, and it also cannot
+  # express this. These bands are ANTI-CORRELATED with what the battery wants
+  # to do (cheap network hours are cheap spot hours), so flattening them
+  # UNDERSTATES the true spread and declines cycles that would have paid. See
+  # DOCS.md, "The three buckets".
+  #
+  # Same JSON grammar as static_profile above - the same tiling rule, the same
+  # day selectors, the same DST handling, because it is literally the same
+  # parser. ⚠️ THE VALUE IS THE TAXES COMPONENT ALONE, NOT AN ALL-IN PRICE:
+  #
+  #   {"periods": [
+  #      {"name":"dag",  "from":"07:00","to":"22:00","days":"mon-fri","eur_per_kwh":0.1327},
+  #      {"name":"nacht","from":"22:00","to":"07:00","days":"mon-fri","eur_per_kwh":0.0739},
+  #      {"name":"nacht","from":"00:00","to":"24:00","days":"sat,sun", "eur_per_kwh":0.0739}]}
+  #
+  # ⚠️ SET THIS *OR* price_taxes_eur_kwh, NOT BOTH. Two writers of one quantity,
+  # one of which silently wins, is refused at startup: leave the scalar at its
+  # shipped default when you fill this in.
+  price_taxes_profile: ""
+
   # TARIFF-15. YOUR OWN TARIFF CARD, as two fixed coefficients. Used only when
   # `price_provider: custom_formula`; "" is unset.
   #
@@ -847,6 +881,10 @@ schema:
   # 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?
+  # TARIFF-17. A JSON string for `static_profile`'s reason, and parsed by
+  # `static_tariff.parse_taxes_profile()` - the SAME period grammar, so a
+  # second tiling rule and a second set of DST bugs do not exist to diverge.
+  price_taxes_profile: str?
   # TARIFF-15. A JSON string for the same reason `static_profile` is one: it is
   # ONE option key, it survives config.yaml's flat options block, and
   # parse_price_formula() accepts an already-parsed dict too, so a future

goodwe_controller/test_price_forecast.py

@@ -1107,21 +1107,45 @@ _OPT04_KEYS = ["arbitrage_enabled", "cycle_cost_threshold_eur",
 # in config.yaml and nowhere else, which is the arrangement `static_profile`
 # already has for the same reason.
 _T15_KEYS = ["price_formula"]
-check(f"the in-code mirror holds exactly TARIFF-02's, TARIFF-03's, OPT-04's "
-      f"and TARIFF-15's keys - FCST-03 still added none of its own "
+# TARIFF-17 added the sixth, and comes here to say so as the comment above
+# instructs. `price_taxes_profile` is the hour-varying spelling of
+# `price_taxes_eur_kwh` - a period table of the TAXES component, for the Walloon
+# and Brussels DSOs whose distribution tariff really does have a day and a night
+# band (ORES 13,27 / 7,39 c EUR/kWh). It is an ADDITION and not a replacement:
+# the scalar is untouched, every site on it is unaffected, and validate.py
+# refuses the configuration that sets both. It lives in this dict and in
+# config.yaml and nowhere else, which is `static_profile`'s arrangement for
+# `static_profile`'s reason.
+_T17_KEYS = ["price_taxes_profile"]
+check(f"the in-code mirror holds exactly TARIFF-02's, TARIFF-03's, OPT-04's, "
+      f"TARIFF-15's and TARIFF-17's keys - FCST-03 still added none of its own "
       f"{_defaults}",
       _defaults == sorted(["price_provider", "price_markup_eur_kwh",
                            "price_taxes_eur_kwh", "export_price_eur_kwh",
                            "price_csv_path", "price_feed_url",
                            "price_horizon_h", "price_timeout_s",
-                           "static_profile"] + _OPT04_KEYS + _T15_KEYS))
+                           "static_profile"]
+                          + _OPT04_KEYS + _T15_KEYS + _T17_KEYS))
 # ...and the later keys are genuinely NEW, not a rename of something that was
 # already there, or the line above would pass while the mirror silently lost a
 # key.
-check("...and OPT-04's four and TARIFF-15's one are additions rather than "
-      "replacements: the nine TARIFF-02/03 keys are all still present",
+check("...and OPT-04's four, TARIFF-15's one and TARIFF-17's one are additions "
+      "rather than replacements: the nine TARIFF-02/03 keys are all still "
+      "present",
       isinstance(_defaults, list)
-      and len(set(_defaults) - set(_OPT04_KEYS) - set(_T15_KEYS)) == 9)
+      and len(set(_defaults) - set(_OPT04_KEYS) - set(_T15_KEYS)
+              - set(_T17_KEYS)) == 9)
+# ⚠️ AND THE ONE TARIFF-17 IS THE HOUR-VARYING TWIN OF IS STILL THERE, BY NAME.
+# The line above counts nine, and a rename of `price_taxes_eur_kwh` to
+# `price_taxes_profile` would also count nine. The scalar path being unchanged
+# is this card's first acceptance criterion, and a count cannot grade it.
+check("...and `price_taxes_eur_kwh` is still its own key beside the table, so "
+      "TARIFF-17 widened the framework rather than renaming the scalar",
+      isinstance(_defaults, list)
+      and "price_taxes_eur_kwh" in _defaults
+      and "price_taxes_profile" in _defaults
+      and _price.PRICE_OPTION_DEFAULTS["price_taxes_eur_kwh"] == 0.06
+      and _price.PRICE_OPTION_DEFAULTS["price_taxes_profile"] == "")
 check("...and every one of them is still in config.yaml, which stays the "
       "source of truth",
       isinstance(_cfg, str)

goodwe_controller/test_static_tariff.py

@@ -59,6 +59,7 @@ is TEST-15, and it has already turned one live mutation into a false survivor.
 Read MUTATION.md before you report a survivor.
 """
 
+import ast
 import gzip
 import json
 import sys
@@ -71,8 +72,9 @@ from app.price import (
 )
 from app.price_history import NoHistory
 from app.static_tariff import (
-    MEAN_WINDOW_DAYS, ProfileInvalid, StaticProfile, TariffPlan,
-    parse_static_profile, resolve_tariff, static_plan, static_status,
+    MEAN_WINDOW_DAYS, ProfileInvalid, StaticProfile, TAXES_PROFILE_OPTION,
+    TariffPlan, parse_static_profile, parse_taxes_profile, resolve_tariff,
+    static_plan, static_status,
 )
 from app.validate import validate_startup_config
 
@@ -87,6 +89,16 @@ def check(name, cond):
         fails.append(name)
 
 
+def _reason_of(fn):
+    """The message fn() raised, or "" - so a check can assert WHICH rule
+    refused rather than only that something did (MUTATION.md habit 6)."""
+    try:
+        fn()
+    except Exception as e:                                    # noqa: BLE001
+        return str(e)
+    return ""
+
+
 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
@@ -1130,6 +1142,189 @@ check("...and the table really does exercise both rungs and the allowing path, "
       {want for _n, _p, want in _TABLE9} == {"flat", "firm-pair", "allowed"})
 
 
+
+# --------------------------------------------------------------------------- #
+print()
+print("10. TARIFF-17 - ONE period grammar, not two. A second tiling rule is a "
+      "second set of DST bugs")
+# ⚠️ THE ACCEPTANCE CRITERION THIS GRADES, and why it needs two checks rather
+# than one. `price_taxes_profile` carries the TAXES component as a period table
+# so that a Walloon day/night distribution band can reach the optimiser. The
+# obvious way to build it is a second parser next to this one - and the two
+# would agree on every ordinary day and diverge on the 23- and 25-hour days,
+# where nobody looks and where §11.4 makes the divergence quiet.
+#
+# So the claim is an IDENTITY ("it is this grammar"), and MUTATION.md habit 10
+# says pin an identity structurally and a meaning behaviourally. Both are here:
+#   10a  the grammar family is DEFINED IN EXACTLY ONE MODULE, computed by
+#        parsing every file under app/ rather than by a list somebody typed;
+#   10b  the two options produce the SAME REFUSAL SENTENCES, derived from each
+#        other, which is what a fork would break first.
+
+print()
+print("10a. the grammar is defined in exactly one module under app/, and the "
+      "scope is COMPUTED")
+# ⚠️ A HAND-WRITTEN SCOPE IS THE SAME DEFECT AS A HAND-WRITTEN FIXTURE
+# (habit 12): it passes while the copy sits in the file nobody added to the
+# list. Every `app/*.py` is parsed; the family is taken from THIS module's own
+# top-level names, so it cannot drift from what the grammar actually is.
+#
+# ⚠️ AND THE FAMILY LIST HAS ONE DELIBERATE OMISSION, STATED HERE RATHER THAN
+# ROUNDED OFF (habit 13). `_days` is NOT in it, because `maintenance.py` has a
+# `_days` of its own - a NAMESAKE, not a copy - and the check below would go
+# red on it and be deleted by whoever hit it. The namesake is asserted to BE a
+# namesake, by signature, immediately afterwards, so the omission is graded
+# rather than assumed.
+_T17_FAMILY = ("Period", "StaticProfile", "ProfileInvalid", "_check_tiling",
+               "_raise_gap", "_raise_overlap", "_minutes", "_price",
+               "parse_static_profile", "DAY_NAMES", "MINUTES_PER_DAY",
+               "_DAY_INDEX", "_DAY_ALIASES", "SUPPORTED_TZ")
+
+
+def _t17_defs(path):
+    """Top-level names a module DEFINES - classes, functions and assignments."""
+    tree = ast.parse(path.read_text(encoding="utf-8"))
+    out = set()
+    for node in tree.body:
+        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef,
+                             ast.ClassDef)):
+            out.add(node.name)
+        elif isinstance(node, ast.Assign):
+            out |= {t.id for t in node.targets if isinstance(t, ast.Name)}
+    return out
+
+
+_T17_APP = sorted((HERE / "app").glob("*.py"))
+_T17_WHERE = {name: sorted(p.name for p in _T17_APP if name in _t17_defs(p))
+              for name in _T17_FAMILY}
+for _n, _w in sorted(_T17_WHERE.items()):
+    print(f"    {_n:<22} defined in {_w}")
+check(f"every one of the {len(_T17_FAMILY)} grammar names is defined in "
+      f"EXACTLY ONE of the {len(_T17_APP)} modules under app/ - a copy of "
+      f"`_check_tiling` in price.py would take this red",
+      all(len(w) == 1 for w in _T17_WHERE.values()))
+check("...and that module is static_tariff.py in every case, so the grammar "
+      "did not move house either",
+      {w[0] for w in _T17_WHERE.values() if w} == {"static_tariff.py"})
+check("...and the pin is not vacuous: each of those names really is a "
+      "top-level definition, so the scan found something rather than nothing",
+      all(w for w in _T17_WHERE.values()) and len(_T17_APP) > 5)
+
+
+def _t17_sig(module, name):
+    tree = ast.parse((HERE / "app" / module).read_text(encoding="utf-8"))
+    fn = next(n for n in tree.body
+              if isinstance(n, ast.FunctionDef) and n.name == name)
+    return [a.arg for a in fn.args.args]
+
+
+_T17_DAYS = (_t17_sig("static_tariff.py", "_days"),
+                            _t17_sig("maintenance.py", "_days"))
+print(f"    _days: static_tariff{_T17_DAYS[0]} vs maintenance{_T17_DAYS[1]}")
+check(f"...and the ONE name held out of the family is held out honestly: "
+      f"`maintenance._days{tuple(_T17_DAYS[1])}` renders an age in words and "
+      f"is not a second copy of the grammar's "
+      f"`_days{tuple(_T17_DAYS[0])}` day selector",
+      _T17_DAYS[0] != _T17_DAYS[1] and _T17_DAYS[0] == ["value", "field"]
+      and _T17_DAYS[1] == ["n"])
+# ⚠️ WHAT THIS PIN CANNOT SEE, WITH ITS SHAPE (habit 13). It grades WHERE the
+# grammar is defined, never WHAT it means: `_check_tiling` could be rewritten
+# in place to accept a gap and this would still pass. Section 5 and 10b are
+# what grade the meaning. It also covers `app/` only, and a second grammar
+# living under `tools/` or in a check file is outside it.
+
+_T17_BODY = ast.parse(
+    (HERE / "app" / "static_tariff.py").read_text(encoding="utf-8"))
+_T17_WRAP = next(
+    (n for n in _T17_BODY.body
+     if isinstance(n, ast.FunctionDef) and n.name == "parse_taxes_profile"),
+    None)
+_T17_CALLS = ([ast.unparse(n.func) for n in ast.walk(_T17_WRAP)
+               if isinstance(n, ast.Call)] if _T17_WRAP else [])
+check(f"...and `parse_taxes_profile` is a WRAPPER and not a fork: its whole "
+      f"body calls {_T17_CALLS}, pinned on the AST rather than on the source "
+      f"text, because `\"parse_static_profile\" in src` is true of a copy that "
+      f"merely mentions it",
+      _T17_CALLS == ["parse_static_profile"])
+
+
+print()
+print("10b. and the two options give the SAME refusals - derived from each "
+      "other, not typed twice")
+# ⚠️ EVERY EXPECTED SENTENCE HERE IS THE OTHER OPTION'S OWN SENTENCE with the
+# key substituted. Nothing is transcribed, so a fork that reworded one refusal
+# - or that quietly stopped refusing something - is red on the row it broke and
+# not on all of them.
+_T17_BAD = [
+    ("a gap", {"periods": [{"name": "d", "from": "07:00", "to": "22:00",
+                            "days": "all", "eur_per_kwh": 0.13}]}),
+    ("an overlap", {"periods": [
+        {"name": "a", "from": "00:00", "to": "24:00", "days": "all",
+         "eur_per_kwh": 0.13},
+        {"name": "b", "from": "07:00", "to": "22:00", "days": "all",
+         "eur_per_kwh": 0.07}]}),
+    ("a bad HH:MM", {"periods": [{"name": "d", "from": "7.5", "to": "22:00",
+                                  "days": "all", "eur_per_kwh": 0.13}]}),
+    ("a bad day", {"periods": [{"name": "d", "from": "00:00", "to": "24:00",
+                                "days": "funday", "eur_per_kwh": 0.13}]}),
+    ("missing days", {"periods": [{"name": "d", "from": "00:00", "to": "24:00",
+                                   "eur_per_kwh": 0.13}]}),
+    ("a zero-length window", {"periods": [
+        {"name": "d", "from": "07:00", "to": "07:00", "days": "all",
+         "eur_per_kwh": 0.13}]}),
+    ("no periods list", {"timezone": "europe/brussels"}),
+    ("an empty periods list", {"periods": []}),
+    ("a foreign timezone", {"timezone": "utc", "periods": []}),
+    ("periods that are not a list", {"periods": 3}),
+    ("a row that is not an object", {"periods": ["dag"]}),
+    ("invalid JSON", "{not json"),
+    ("a 24:00 start", {"periods": [{"name": "d", "from": "24:00", "to": "07:00",
+                                    "days": "all", "eur_per_kwh": 0.13}]}),
+]
+_T17_ROWS = []
+for _what, _bad in _T17_BAD:
+    _a = _reason_of(lambda: parse_static_profile(_bad))
+    _b = _reason_of(lambda: parse_taxes_profile(_bad))
+    _T17_ROWS.append((_what, _a, _b,
+                      _a.replace("static_profile", TAXES_PROFILE_OPTION) == _b))
+for _what, _a, _b, _same in _T17_ROWS:
+    print(f"    {'ok ' if _same else 'XX '}{_what:<28} {_b[:74]}")
+check(f"all {len(_T17_ROWS)} malformations are refused IDENTICALLY under both "
+      f"options, sentence for sentence, once the key name is substituted - "
+      f"which is what one parser means and a fork could not hold",
+      all(row[3] for row in _T17_ROWS))
+check("...and every one of them really did refuse, or 'the two agree' would be "
+      "two empty strings agreeing",
+      all(row[1] and row[2] for row in _T17_ROWS))
+check("...and the sentences are not all the same sentence, or the row above "
+      "would be one comparison repeated 13 times",
+      len({row[2] for row in _T17_ROWS}) == len(_T17_ROWS))
+
+# ⚠️ THE ONE REFUSAL THAT IS DELIBERATELY DIFFERENT, and it is different
+# because the two options carry different QUANTITIES in the same grammar. A
+# period without `eur_per_kwh` gets a sentence naming what was wanted, and an
+# operator who typed an ALL-IN price into the taxes table is out by an energy
+# price with nothing reporting it.
+_T17_NOPRICE = {"periods": [{"name": "d", "from": "00:00", "to": "24:00",
+                             "days": "all"}]}
+_T17_M_S = _reason_of(lambda: parse_static_profile(_T17_NOPRICE))
+_T17_M_T = _reason_of(lambda: parse_taxes_profile(_T17_NOPRICE))
+print(f"    static_profile : {_T17_M_S[-96:]}")
+print(f"    taxes table    : {_T17_M_T[-96:]}")
+check("the 'you left the number out' refusal is the one sentence the two do "
+      "NOT share, and each names its own quantity: an all-in price for "
+      "static_profile, the taxes component alone for the table",
+      "an all-in eur_per_kwh" in _T17_M_S
+      and "an all-in eur_per_kwh" not in _T17_M_T
+      and "TAXES component alone" in _T17_M_T
+      and "NOT an all-in price" in _T17_M_T
+      and _T17_M_S.replace("static_profile", TAXES_PROFILE_OPTION) != _T17_M_T)
+check("...and both still name the ROW the operator has to go and fix, which is "
+      "the half they do share",
+      "periods[1].eur_per_kwh is missing" in _T17_M_S
+      and "periods[1].eur_per_kwh is missing" in _T17_M_T)
+
+
 # --------------------------------------------------------------------------- #
 print()
 if fails:

goodwe_controller/test_validate.py

@@ -1366,6 +1366,134 @@ check("...and the flat single-inverter config it always refused is refused "
                                   -5000, 5000) == [])
 
 
+
+# --------------------------------------------------------------------------- #
+print()
+print("TARIFF-17 - the taxes period table is refused HERE, at startup, and not "
+      "at 03:00")
+# ⚠️ WHY IT IS REFUSED IN THIS MODULE AND NOT AT FETCH TIME. `price.assemble()`
+# reads this table on the ~30 s planning path. A table that only fails when a
+# fetch happens is a site that stops pricing mid-afternoon, and §11.4 turns
+# that into a quiet fallback indistinguishable on the status page from a
+# healthy fixed-tariff day. That is `static_profile`'s argument, one option
+# over, and this is the same rule.
+_T17_DAG, _T17_NACHT = 0.1327, 0.0739
+_T17_OK = ('{"periods":['
+           '{"name":"dag","from":"07:00","to":"22:00","days":"mon-fri",'
+           f'"eur_per_kwh":{_T17_DAG}}},'
+           '{"name":"nacht","from":"22:00","to":"07:00","days":"mon-fri",'
+           f'"eur_per_kwh":{_T17_NACHT}}},'
+           '{"name":"nacht","from":"00:00","to":"24:00","days":"sat,sun",'
+           f'"eur_per_kwh":{_T17_NACHT}}}]}}')
+
+# ⚠️ THE ACCEPTED BASELINE COMES FIRST (MUTATION.md habit 7). Every refusal
+# below varies ONE thing from this line, so a refusal on the next line has
+# nowhere else to have come from.
+check("ORES's real dag/nacht table STARTS - it is a valid configuration, and "
+      "the refusals below are one edit away from this one",
+      validate_startup_config(base(price_taxes_profile=_T17_OK),
+                              -5000, 5000) == [])
+check("...and so does the shipped \"\", which is every install that exists: "
+      "the option is an addition, not a requirement",
+      validate_startup_config(base(price_taxes_profile=""), -5000, 5000) == []
+      and validate_startup_config(base(), -5000, 5000) == [])
+
+_T17_GAP = ('{"periods":[{"name":"dag","from":"07:00","to":"22:00",'
+            f'"days":"all","eur_per_kwh":{_T17_DAG}}}]}}')
+_T17_P_GAP = validate_startup_config(base(price_taxes_profile=_T17_GAP),
+                                     -5000, 5000)
+print(f"    {(_T17_P_GAP or [''])[0][:120]}")
+check("a table that leaves 00:00-07:00 unpriced is REFUSED, by the same tiling "
+      "rule static_profile has - and the refusal names the KEY and the HOURS, "
+      "not merely that something was wrong",
+      why(_T17_P_GAP, "price_taxes_profile cannot be used:")
+      and why(_T17_P_GAP, "leaves mon 00:00-07:00 with no period"))
+check("...and it is refused for THAT reason and not as a side effect of "
+      "something else this fixture happens to break: exactly one problem",
+      len(_T17_P_GAP) == 1)
+
+# ⚠️ TWO WRITERS OF ONE QUANTITY, ONE OF WHICH SILENTLY WINS. The table decides
+# when it is set, so a scalar left at a NON-DEFAULT value beside it is a number
+# the operator typed that changes nothing - on the quantity §11.4 makes hardest
+# to notice.
+_T17_P_BOTH = validate_startup_config(
+    base(price_taxes_profile=_T17_OK, price_taxes_eur_kwh=0.1198), -5000, 5000)
+print(f"    {(_T17_P_BOTH or [''])[0][:120]}")
+check("the table AND a non-default price_taxes_eur_kwh is refused, and the "
+      "refusal says WHICH ONE WINS and what to do - not merely that the two "
+      "are incompatible",
+      why(_T17_P_BOTH, "price_taxes_profile is set AND price_taxes_eur_kwh is "
+                       "0.1198")
+      and why(_T17_P_BOTH, "THE TABLE WINS"))
+check("...and the SHIPPED scalar beside the table is NOT refused, or every "
+      "Walloon site would have to clear a key it never touched. The refusal is "
+      "about a value the operator chose, and 0.06 is the one they did not",
+      validate_startup_config(base(price_taxes_profile=_T17_OK,
+                                   price_taxes_eur_kwh=0.06),
+                              -5000, 5000) == []
+      and len(_T17_P_BOTH) == 1)
+check("...and the same non-default scalar WITHOUT the table still starts, "
+      "which is what makes the line above about the PAIR rather than about "
+      "0.1198 being disliked",
+      validate_startup_config(base(price_taxes_eur_kwh=0.1198),
+                              -5000, 5000) == [])
+
+# ⚠️ THE UNITS RUNG, A SECOND QUANTITY RATHER THAN A RESTATEMENT. Every Belgian
+# DSO prints these bands in c EUR/kWh, and the whole table is copied off ONE
+# card - so a factor-100 error lands on every row at once and nothing inside
+# the table disagrees with itself.
+#
+# ⚠️ AND THE TWO RUNGS ARE GRADED SEPARATELY, BY THE REASON EACH GIVES, because
+# the parser's own +-10 EUR/kWh bound catches SOME of these cards and not
+# others - and a check that only ever exercised the loud ones would pass with
+# this rung deleted. ORES's 13,27 is refused by the parser; SIBELGA's whole
+# card - 9,39 dag against 7,10 nacht, the Brussels DSO - is under 10 in both
+# bands and reaches this rung alone.
+_T17_ORES_C = ('{"periods":['
+               '{"name":"dag","from":"07:00","to":"22:00","days":"mon-fri",'
+               '"eur_per_kwh":13.27},'
+               '{"name":"nacht","from":"22:00","to":"07:00","days":"mon-fri",'
+               '"eur_per_kwh":7.39},'
+               '{"name":"nacht","from":"00:00","to":"24:00","days":"sat,sun",'
+               '"eur_per_kwh":7.39}]}')
+_T17_SIB_C = ('{"periods":['
+              '{"name":"dag","from":"07:00","to":"22:00","days":"mon-fri",'
+              '"eur_per_kwh":9.39},'
+              '{"name":"nacht","from":"22:00","to":"07:00","days":"mon-fri",'
+              '"eur_per_kwh":7.10},'
+              '{"name":"nacht","from":"00:00","to":"24:00","days":"sat,sun",'
+              '"eur_per_kwh":7.10}]}')
+_T17_P_ORES = validate_startup_config(base(price_taxes_profile=_T17_ORES_C),
+                                      -5000, 5000)
+_T17_P_SIB = validate_startup_config(base(price_taxes_profile=_T17_SIB_C),
+                                     -5000, 5000)
+print(f"    ORES    : {(_T17_P_ORES or [''])[0][:110]}")
+print(f"    Sibelga : {(_T17_P_SIB or [''])[0][:110]}")
+check("ORES's card typed in CENTS is refused by the PARSER's bound, and the "
+      "sentence is the parser's - `beyond +-10.0`, naming the row",
+      why(_T17_P_ORES, "price_taxes_profile cannot be used:")
+      and why(_T17_P_ORES, "beyond +-10.0"))
+check("...and SIBELGA's whole card - 9,39 and 7,10, BOTH under that bound - is "
+      "refused by THIS rung instead, naming both bands and the factor. Without "
+      "it a Brussels site would price a 9.39 EUR/kWh levy and start",
+      why(_T17_P_SIB, "price_taxes_profile carries [7.1, 9.39] EUR/kWh")
+      and why(_T17_P_SIB, "factor of 100"))
+check("...and the two refusals are DIFFERENT sentences, so the rungs cannot "
+      "mask each other: deleting the units rung leaves the Sibelga line red "
+      "while the ORES line goes on passing for the parser's reason",
+      _T17_P_ORES != _T17_P_SIB
+      and not why(_T17_P_ORES, "factor of 100")
+      and not why(_T17_P_SIB, "beyond +-10.0"))
+check("...and BOTH cards divided by 100 start, which is habit 7: the refusals "
+      "above are about the units and not about Brussels or Wallonia",
+      validate_startup_config(
+          base(price_taxes_profile=_T17_ORES_C.replace("13.27", "0.1327")
+               .replace("7.39", "0.0739")), -5000, 5000) == []
+      and validate_startup_config(
+          base(price_taxes_profile=_T17_SIB_C.replace("9.39", "0.0939")
+               .replace("7.10", "0.0710")), -5000, 5000) == [])
+
+
 # --------------------------------------------------------------------------- #
 print()
 if fails:

goodwe_controller/translations/en.yaml

@@ -156,6 +156,9 @@ configuration:
   static_profile:
     name: "Tariff · Fixed or day/night tariff (one line of JSON)"
     description: "Your fixed or day/night contract, written as a single line of JSON. RECOMMENDED EVEN ON A DYNAMIC CONTRACT: this is what the add-on falls back to when the price feed dies, and with it empty a dead feed leaves the site with no tariff at all. The periods must cover every day type exactly once, with no gap and no overlap - a gap is refused at startup rather than filled in, because an invented price is one a strategy would trade on. A fully fixed tariff is one period covering 00:00-24:00 on all days. Prices are ALL IN; the markup and levies above are not added to them. Note that a window written 22:00-07:00 for mon-fri does NOT cover Saturday morning, so a weekend row is required rather than decorative."
+  price_taxes_profile:
+    name: "Tariff · Levies and VAT by time of day (one line of JSON)"
+    description: "Leave this empty unless your network tariff really does charge a different day and night rate - in Flanders it does not, Fluvius distribution is one rate, and the flat figure above is correct. In Wallonia and Brussels it does: ORES charges 13,27 c/kWh by day against 7,39 at night, AIESH 15,17 against 8,21, Sibelga 9,39 against 7,10. Written as a single line of JSON in exactly the same shape as the fixed or day/night tariff above, with the same rule that the periods must cover every day type once with no gap and no overlap. ⚠️ THE NUMBERS HERE ARE THE LEVIES ALONE, NOT A FULL PRICE - the add-on adds them to whatever your price source publishes, exactly as it adds the flat figure. Why it matters: a flat figure is the same in every hour, so it moves every hour equally and cannot change which hour is cheapest - and a night network rate is cheap in the same hours the market is cheap, so flattening it makes the add-on think the day is flatter than it is and turn down battery cycles that would have paid for themselves. Set this or the flat figure above, not both: the add-on refuses to start if the two disagree."
   price_formula:
     name: "Tariff · Your own tariff formula (one line of JSON)"
     description: "For price source custom_formula only: your own contract's two coefficients, written as a single line of JSON. Your supplier's tariff card prints the formula as B x index + A - those two numbers exist only on your card, there is no public index of them anywhere, and you are the only person who can read them. Type what the card prints, IN THE UNITS THE CARD PRINTS: every unit conversion and the VAT step are the add-on's job, because those are the two places a human silently loses a factor of 10, 100 or 1.06. Example: {\"index\":\"epex_be\",\"resolution\":\"hourly\",\"factor\":0.102,\"offset\":1.00,\"units\":\"c_eur_per_kwh\",\"vat_pct\":6,\"card\":{\"month\":\"2026-09\",\"index_eur_per_mwh\":133.9905,\"expect_incl_vat\":15.55}}. ⚠️ THE card BLOCK IS REQUIRED AND IT IS WHAT MAKES THIS SAFE: your card also prints the reference index it assumed and the price that comes out, so the add-on recomputes that price from your numbers and REFUSES TO START if it does not come out, telling you by how much. That catches a wrong unit, VAT left out or counted twice, a transposed digit, and the expensive one - network charges folded into the offset, which the add-on would then bill you for a second time. ⚠️ AND ITS LIMIT, IN THE SAME BREATH: it checks your coefficients against your card, not your card against reality, so two numbers copied off the wrong product agree with each other and pass. Fixed numbers only - no expression of any kind is evaluated, and an unrecognised field is refused rather than ignored."

goodwe_controller/translations/nl.yaml

@@ -136,6 +136,9 @@ configuration:
   static_profile:
     name: "Tarief · Vast of dag/nacht-tarief (één regel JSON)"
     description: "Uw vaste of dag/nacht-contract, geschreven als één regel JSON. AANBEVOLEN ZELFS BIJ EEN DYNAMISCH CONTRACT: hierop valt de add-on terug wanneer de prijsfeed uitvalt, en staat dit leeg dan blijft de installatie bij een dode feed helemaal zonder tarief achter. De periodes moeten elk dagtype precies één keer bedekken, zonder gat en zonder overlap - een gat wordt bij het opstarten geweigerd in plaats van opgevuld, want een verzonnen prijs is er één waarop een strategie zou handelen. Een volledig vast tarief is één periode van 00:00 tot 24:00 op alle dagen. De prijzen zijn ALLES INBEGREPEN; de marge en heffingen hierboven worden er niet bij opgeteld. Let op: een venster van 22:00 tot 07:00 voor ma-vr dekt zaterdagochtend NIET, dus een regel voor het weekend is noodzakelijk en niet decoratief."
+  price_taxes_profile:
+    name: "Tarief · Heffingen en btw per dagdeel (één regel JSON)"
+    description: "Laat dit leeg tenzij uw netbeheerder werkelijk een ander dag- en nachttarief aanrekent - in Vlaanderen is dat niet zo, de Fluvius-distributie is één tarief, en het vaste bedrag hierboven klopt. In Wallonië en Brussel is dat wél zo: ORES rekent 13,27 c/kWh overdag tegen 7,39 's nachts, AIESH 15,17 tegen 8,21, Sibelga 9,39 tegen 7,10. Geschreven als één regel JSON in precies dezelfde vorm als het vaste of dag/nacht-tarief hierboven, met dezelfde regel dat de periodes elk dagtype één keer moeten bedekken zonder gat en zonder overlap. ⚠️ DE BEDRAGEN HIER ZIJN ALLEEN DE HEFFINGEN, GEEN VOLLEDIGE PRIJS - de add-on telt ze op bij wat uw prijsbron publiceert, net zoals bij het vaste bedrag. Waarom het uitmaakt: een vast bedrag is in elk uur hetzelfde, verschuift dus elk uur evenveel en kan niet veranderen welk uur het goedkoopste is - en een nachttarief van het net is goedkoop in dezelfde uren waarin de markt goedkoop is, dus door het plat te slaan lijkt de dag vlakker dan hij is en weigert de add-on batterijcycli die zichzelf zouden terugverdienen. Vul dit in óf het vaste bedrag hierboven, niet allebei: de add-on weigert te starten als de twee elkaar tegenspreken."
   price_formula:
     name: "Tarief · Uw eigen tariefformule (één regel JSON)"
     description: "Alleen voor prijsbron custom_formula: de twee coëfficiënten van uw eigen contract, als één regel JSON. De tariefkaart van uw leverancier drukt de formule af als B x index + A - die twee getallen staan alleen op uw kaart, er bestaat nergens een publieke lijst van, en u bent de enige die ze kan lezen. Typ wat de kaart afdrukt, IN DE EENHEID DIE DE KAART GEBRUIKT: elke eenheidsomrekening en de btw-stap zijn het werk van de add-on, want dat zijn precies de twee plaatsen waar een mens stilzwijgend een factor 10, 100 of 1,06 verliest. Voorbeeld: {\"index\":\"epex_be\",\"resolution\":\"hourly\",\"factor\":0.102,\"offset\":1.00,\"units\":\"c_eur_per_kwh\",\"vat_pct\":6,\"card\":{\"month\":\"2026-09\",\"index_eur_per_mwh\":133.9905,\"expect_incl_vat\":15.55}}. ⚠️ HET BLOK card IS VERPLICHT EN MAAKT DIT VEILIG: uw kaart vermeldt ook de referentie-index die ze veronderstelt en de prijs die eruit volgt, dus de add-on berekent die prijs opnieuw uit uw getallen en START NIET als het resultaat niet klopt - met vermelding van het verschil. Dat vangt een verkeerde eenheid, btw die ontbreekt of dubbel geteld is, een omgewisseld cijfer, en de dure fout: nettarieven die in de offset verwerkt zitten en die de add-on er dan nog een tweede keer bovenop zou rekenen. ⚠️ EN DE GRENS DAARVAN, IN DEZELFDE ZIN: ze toetst uw coëfficiënten aan uw kaart, niet uw kaart aan de werkelijkheid - twee getallen van het verkeerde product kloppen onderling en komen er dus door. Alleen vaste getallen: er wordt geen enkele expressie geëvalueerd, en een onbekend veld wordt geweigerd in plaats van genegeerd."