Pre-push review: T-1890/time-of-use-pricing

diff --git a/CHANGELOG.md b/CHANGELOG.mdindex fefbeb6..0d97e2e 100644--- a/CHANGELOG.md+++ b/CHANGELOG.md@@ -6,8 +6,44 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).  ## [Unreleased] +### Changed++- **Time-of-use pricing — app** (T-1890, T-1891). Fourth implementation phase of the band-based pricing spec, and the first with user-visible change. Settings ▸ Pricing now edits band-based plans, and costs are computed from them.+  - Settings ▸ Pricing lists plans rather than periods. Each row shows its date range and the bands its rates apply over — "Free 10:00–15:00 · $0.2800 01:00–06:00 · $0.3500 default" — with feed-in on its own line. A closed plan reads "2026-01-01 until 2026-08-01" rather than a dash range, because the end date is exclusive and that day belongs to the successor.+  - The plan editor replaces the three rate fields with a default rate, a feed-in rate, a savings reference rate (shown only once a free window exists), and a Windows section: per row a start and end picker, a Free toggle, and a rate field when the window isn't free. Times outside every window take the default rate, so a plan cannot be entered with a gap. Client-side validation mirrors the server's band rules, so a plan the editor accepts is not rejected for something it could have caught.+  - The succession affordance now says what it does: it ends the open-ended plan **on** the new plan's start date and starts the successor that same day, rather than the day before. Both rows carry the same literal date.+  - Day costs resolve in three tiers, matching the backend figure for figure: the stored per-band split when its geometry matches the plan and the free band's import is resolvable; otherwise the pre-band single-rate formula, which is what keeps every historical day's cost unchanged; otherwise all import at the plan's highest rate with no savings. Both cost helpers are pinned to the same cross-language vectors the Go implementation is tested against. The cost card and History totals keep their existing layout.+  - Day Detail chart shading takes the free window from the plan pricing that day instead of a hardcoded 11:00–14:00, so it moves on the switch date. A day with no plan, or whose plan has no free band, gets no shading rather than a misleading band — and the widgets no longer substitute the legacy window when the API reports none.+  - `/day` and `/history` now also report the window and integration provenance of the off-peak row each day's off-peak import came from. Without it the app could not tell a split captured under the current free window from a stale one, and every day priced by the new plan would have fallen back to the highest-rate estimate. The History cache stores it too, so an offline day prices identically to an online one.++### Internal++- **Time-of-use pricing — poller and operator tools** (T-1890, T-1891). Third implementation phase of the band-based pricing spec. The poller now takes its off-peak window from the plan pricing each day, captures the durable per-band split, and the operator tools follow suit.+  - New `PlanSource` gives the poller a read-through view of the pricing table with a last-good cache. A failed read is served from the cache with a warning and is never resolved as "no plan" — that would silently strip a day of its free window and its band split. A cold start with an unreachable table retries with backoff before giving up.+  - The off-peak scheduler's daily cycle is re-anchored to local midnight: it wakes, refreshes the plans, resolves that day's free window, and sleeps to its start. Plans only change behaviour at midnight, so one refresh per day is exactly enough and a plan switch changes the window with no reconfiguration. A day whose plan has no free band sleeps through to the next midnight; an unreadable pricing table retries within the day rather than writing the day off.+  - Window-end finalisation no longer requires a pending row or a start snapshot. The five deltas have come from integrating readings since T-1341 — the snapshot is diagnostics only — so a plan-read failure at window start now costs forensics rather than the whole day, and a restart or a late plan load still closes the window. Finalised rows record the window geometry they were integrated under, so a later plan edit is detectable instead of silently repricing the day.+  - The summarisation pass replaces its single unresolved-window early return with per-outcome gating. A plan read failure writes nothing and is retried; a plan with a free band runs every block; a plan without one runs the window-independent blocks with the whole day rated; a day no plan prices still gets its lowest-SoC figure, with the band sentinel left unset so a backfill can capture the split later. The `skipped-ssm-unresolved` metric dimension is gone.+  - The pass gains the rated-band capture: `bandImports` and `peakGridImportKwh` now come from one integration over the plan's rated segments, so the two can no longer disagree. Segment boundaries come from wall-clock time, which also retires the latent hour-off bug the peak block carried on DST days.+  - `cmd/backfill-grid` and `cmd/backfill-solar` resolve each day's window from the pricing table instead of `--offpeak-start`/`--offpeak-end`. A backfill spanning a plan switch needs a different window on either side; static flags would have silently misattributed every day on the wrong side. `backfill-grid` additionally rewrites the day's rated `bandImports` and the off-peak row's window geometry. The two writes go to different tables in separate calls — non-atomic, but idempotent and re-runnable.+  - New `cmd/migrate-pricing` converts the legacy three-rate rows to the band shape once. It prices every retained day under the pre-migration rules using an independently written copy of the three-rate formula, transforms the rows, prices every day again under the band model, and aborts before a single write if any day differs. Dry-run by default; `--apply` writes full items preserving row ids and leaving the sentinel alone; rows already in the band shape are skipped, so re-running is a no-op.+  - `OFFPEAK_START`/`OFFPEAK_END` and the `OffPeakWindowStart`/`OffPeakWindowEnd` CloudFormation parameters are gone from both containers. The poller container gains `TABLE_PRICING` and read-only access (`Scan`/`GetItem`/`Query`) to the pricing table; the Lambda keeps sole write access. Deploying this version leaves `/flux/offpeak-start` and `/flux/offpeak-end` behind as orphaned SSM parameters that nothing reads.++- **Time-of-use pricing — Lambda API** (T-1890, T-1891). Second implementation phase of the band-based pricing spec; the API now speaks the band shape and derives the off-peak window from plans.+  - `/pricing` CRUD and `replace-open-ended` take and return the band shape (`defaultRate` + `windows` + `savingsReferenceRate`), with the exclusive end date stored exactly as sent. Validation reports the violated band rule (`band_window_invalid`, `band_overlap`, `multiple_free_bands`, `savings_rate_missing`, `no_rated_band`) alongside the existing rate and date rules, and date-range overlaps now name the conflicting plan. A pre-migration three-rate payload is rejected with `legacy_shape`, detected on the raw JSON keys because `encoding/json` silently drops unknown fields and would otherwise decode it as a zero-rate band plan.+  - `/status`, `/day`, and `/history` resolve the off-peak window from the plan pricing the day in question instead of the `OFFPEAK_START`/`OFFPEAK_END` environment variables, which are gone from the Lambda. Cutoff suppression and charge projection take the window from the plan pricing the day the *next* window falls on, so on the eve of a plan switch they follow the successor's window rather than the outgoing one.+  - `/status.offpeak` is now nullable: a day whose plan has no free band — or that no plan prices — serialises `null` rather than emitting a window, so clients render "no window" instead of substituting a default. Off-peak and peak values on such a day are absent, never zero. A pricing read failure fails the request rather than resolving as "no plan".+  - `/day` and `/history` gain a nullable `bandImports` array (rated bands only; the free band's import stays in `offpeakGridImportKwh`). Past days serve the split captured at day close; today's is integrated live from readings through a single shared helper both endpoints call, so the two screens cannot disagree. A band the clock has not reached reads zero, but a started band that cannot be integrated makes the whole split unavailable. `/status` does not carry the split.++- **Time-of-use pricing — Go plan domain and data layer** (T-1890, T-1891). First implementation phase of the band-based pricing spec; no user-visible change yet.+  - New leaf package `internal/plan` holding the plan domain: a default rate plus exception windows, the derived full-day segmentation, per-date plan selection, free-window resolution, and DST-correct wall-clock segment bounds. Band boundaries use a new parser that accepts `24:00` as end-of-day — `derivedstats.ParseOffpeakWindow` rejects hours above 23 and would reject every plan. Validation covers the band rules (invalid window, overlap, multiple free bands, missing savings rate, no rated band) alongside the existing rate bounds and precision rules.+  - Plan end dates are now **exclusive**: a plan ending on the date its successor starts hands that whole day to the successor, with no ±1 arithmetic in validation, succession, or display. `ReplaceOpenEnded` writes the same literal switch date to both rows and refuses a succession whose closing row is still the pre-migration shape.+  - Three-tier day-cost resolution in Go (stored band split → the pre-band single-rate formula verbatim → highest-rate fallback), pinned together with the segmentation to shared cross-language vectors in `internal/api/testdata/` that the FluxCore implementation will be held to. The single-rate tier is what keeps every historical day's cost identical after migration.+  - Storage moves to the band shape: `flux-pricing` rows store `defaultRate` + `windows` + `savingsReferenceRate`, `flux-daily-energy` gains a sentinel-gated `bandImports` group for the durable per-band split, and `flux-offpeak` rows snapshot the free-window geometry they were integrated under. Pre-migration rows are detected on the raw attribute map and converted on read, so band-aware services can deploy ahead of the migration run.+  - Property-based tests assert the segments always tile 00:00–24:00, that abutting same-rate segments stay separate, that at most one plan prices any date, and that per-segment grid-import integrals sum to the whole-day integral on 23-, 24-, and 25-hour Sydney days.+ ### Documentation +- **Time-of-use pricing spec** (T-1890, T-1891; `specs/time-of-use-pricing/`). Full spec for reworking pricing plans into daily time bands — a default rate plus exception windows (the incoming plan: free 10:00–15:00, cheaper 01:00–06:00, standard rate otherwise) — with same-day plan succession via exclusive end dates, and the active plan replacing the SSM off-peak window as the source of truth across the poller and API. Covers durable per-band import capture at day close (so banded costs outlive the 30-day readings TTL), a three-tier FluxCore cost resolution that keeps all historical costs identical, a one-time `cmd/migrate-pricing` CLI with golden-value verification, requirements, design, decision log (6 ADRs, 36 quick decisions), a 39-task TDD implementation plan in three parallel streams, and manual cutover prerequisites. Planning artifacts only — no code changes. - **Architecture diagrams** (`docs/architecture-diagrams.md`). A reference document with eight Mermaid diagrams covering the system overview, build and deploy pipeline, AWS infrastructure, the poller's polling engine, the DynamoDB data model (11 tables), the Lambda API surface, the dashboard refresh sequence, and the SoC-alert push flow. Each diagram is drawn from the source of truth (`infrastructure/template.yaml`, the Go services, and the apps) and validated against the Mermaid parser. Intended both as documentation and as source material for a write-up about Flux. - Corrected the DynamoDB table list in `CLAUDE.md` to enumerate all 11 tables with their retention policy (it previously listed only the original 5). 

diff --git a/CLAUDE.md b/CLAUDE.mdindex 02d615e..ab3208b 100644--- a/CLAUDE.md+++ b/CLAUDE.md@@ -22,7 +22,8 @@ iOS App --> Lambda Function URL (Go, ARM64) -------------+ - **Poller** polls AlphaESS on multiple schedules (10s for live data, hourly/6h/24h for summaries) and writes to DynamoDB - **Lambda API** reads from DynamoDB and computes derived stats (rolling averages, cutoff estimates, off-peak deltas, peak usage periods) - **DynamoDB tables** (11, all PAY_PER_REQUEST): `flux-readings` (TTL 30d), `flux-daily-power`, `flux-daily-energy`, `flux-system`, `flux-offpeak`, `flux-notes` (PITR), `flux-devices` (PITR), `flux-soc-rules` (PITR), `flux-soc-fire-state` (TTL 7d), `flux-pricing` (PITR), `flux-simulation-presets` (PITR)-- Off-peak energy is computed by integrating `flux-readings` over the SSM-configured window (11:00-14:00) in the poller's `handleEnd`; the `getOneDateEnergy` snapshots captured at window start/end are retained for diagnostics only (post-T-1341, `specs/offpeak-from-readings`)+- Off-peak energy is computed by integrating `flux-readings` over the free window in the poller's `handleEnd`; the `getOneDateEnergy` snapshots captured at window start/end are retained for diagnostics only (post-T-1341, `specs/offpeak-from-readings`)+- The free (off-peak) window is a property of the pricing plan covering each day, not configuration: every consumer resolves it from the free band of the plan pricing the day in question, so it changes with the plan rather than with a stack update (`specs/time-of-use-pricing`, Decision 2). The `OffPeakWindowStart`/`OffPeakWindowEnd` SSM parameters are gone  Visual reference for the full flow (AWS infrastructure, polling engine, data model, API surface, dashboard and push sequences): `docs/architecture-diagrams.md`. 

diff --git a/cmd/api/main_test.go b/cmd/api/main_test.goindex dfa0413..0d425f2 100644--- a/cmd/api/main_test.go+++ b/cmd/api/main_test.go@@ -9,18 +9,13 @@ import ( )  func TestLoadConfigMissingEnv(t *testing.T) {-	// Set all env vars except TABLE_READINGS to verify validation catches it.+	// Set every required env var except TABLE_READINGS to verify validation+	// catches it. Driven off requiredEnvVars so the list cannot drift out of+	// step with what loadConfig actually demands.+	for _, key := range requiredEnvVars {+		t.Setenv(key, "placeholder")+	} 	t.Setenv("TABLE_READINGS", "")-	t.Setenv("TABLE_DAILY_ENERGY", "flux-daily-energy")-	t.Setenv("TABLE_DAILY_POWER", "flux-daily-power")-	t.Setenv("TABLE_SYSTEM", "flux-system")-	t.Setenv("TABLE_OFFPEAK", "flux-offpeak")-	t.Setenv("TABLE_NOTES", "flux-notes")-	t.Setenv("TABLE_PRICING", "flux-pricing")-	t.Setenv("OFFPEAK_START", "11:00")-	t.Setenv("OFFPEAK_END", "14:00")-	t.Setenv("API_TOKEN_PARAM", "/flux/api-token")-	t.Setenv("SYSTEM_SERIAL_PARAM", "/flux/system-serial")  	_, err := loadConfig(context.Background()) 	require.Error(t, err)

diff --git a/cmd/api/main.go b/cmd/api/main.goindex 99e074c..d246bae 100644--- a/cmd/api/main.go+++ b/cmd/api/main.go@@ -20,17 +20,15 @@ import (  // config holds all resolved configuration for the Lambda. type config struct {-	reader       dynamo.Reader-	notes        api.NoteWriter-	devices      api.DeviceStore-	rules        api.SocRuleStore-	fireState    api.FireStateCleaner-	pricing      api.PricingStore-	presets      api.SimulationPresetStore-	apiToken     string-	serial       string-	offpeakStart string-	offpeakEnd   string+	reader    dynamo.Reader+	notes     api.NoteWriter+	devices   api.DeviceStore+	rules     api.SocRuleStore+	fireState api.FireStateCleaner+	pricing   api.PricingStore+	presets   api.SimulationPresetStore+	apiToken  string+	serial    string }  // requiredEnvVars lists environment variables that must be set.@@ -46,8 +44,6 @@ var requiredEnvVars = []string{ 	"TABLE_SOC_FIRESTATE", 	"TABLE_PRICING", 	"TABLE_SIMULATION_PRESETS",-	"OFFPEAK_START",-	"OFFPEAK_END", 	"API_TOKEN_PARAM", 	"SYSTEM_SERIAL_PARAM", }@@ -62,7 +58,7 @@ func main() { 		os.Exit(1) 	} -	handler := api.NewHandler(cfg.reader, cfg.notes, cfg.serial, cfg.apiToken, cfg.offpeakStart, cfg.offpeakEnd)+	handler := api.NewHandler(cfg.reader, cfg.notes, cfg.serial, cfg.apiToken) 	handler.SetDeviceStore(cfg.devices) 	handler.SetSocRuleStore(cfg.rules) 	handler.SetFireStateCleaner(cfg.fireState)@@ -125,17 +121,15 @@ func loadConfig(ctx context.Context) (*config, error) { 	presets := dynamo.NewDynamoSimulationPresetStore(ddbClient, os.Getenv("TABLE_SIMULATION_PRESETS"))  	return &config{-		reader:       reader,-		notes:        notes,-		devices:      devices,-		rules:        socRuleStoreAdapter{reader: ruleReader, writer: ruleWriter},-		fireState:    fireStateCleanerAdapter{store: fireState},-		pricing:      pricingStoreAdapter{store: pricing},-		presets:      presets,-		apiToken:     apiToken,-		serial:       serial,-		offpeakStart: os.Getenv("OFFPEAK_START"),-		offpeakEnd:   os.Getenv("OFFPEAK_END"),+		reader:    reader,+		notes:     notes,+		devices:   devices,+		rules:     socRuleStoreAdapter{reader: ruleReader, writer: ruleWriter},+		fireState: fireStateCleanerAdapter{store: fireState},+		pricing:   pricingStoreAdapter{store: pricing},+		presets:   presets,+		apiToken:  apiToken,+		serial:    serial, 	}, nil } 

diff --git a/cmd/backfill-grid/main_test.go b/cmd/backfill-grid/main_test.goindex 6ee7867..7b8285b 100644--- a/cmd/backfill-grid/main_test.go+++ b/cmd/backfill-grid/main_test.go@@ -26,6 +26,7 @@ const ( 	testOffpeakTable     = "flux-offpeak-test" 	testReadingsTable    = "flux-readings-test" 	testDailyEnergyTable = "flux-daily-energy-test"+	testPricingTable     = "flux-pricing-test" )  // fakeDynamo is a lightweight in-memory stand-in for the DynamoDB client.@@ -36,12 +37,51 @@ type fakeDynamo struct { 	offpeakRows       map[string][]dynamo.OffpeakItem   // keyed by "*" 	readingsByDate    map[string][]dynamo.ReadingItem   // keyed by Sydney YYYY-MM-DD 	dailyEnergyByDate map[string]dynamo.DailyEnergyItem // keyed by Sydney YYYY-MM-DD; absent = no row+	pricingRows       []dynamo.PricingItem              // nil ⇒ the default 11:00–14:00 open-ended plan 	location          *time.Location 	queries           []*dynamodb.QueryInput 	puts              []*dynamodb.PutItemInput 	updates           []*dynamodb.UpdateItemInput // records UpdateDailyEnergyDerived calls 	queryErrForTable  map[string]error 	putErr            error+	scanErr           error+}++// Scan serves the pricing read. A fixture that sets no pricingRows gets the+// pre-feature plan — free 11:00–14:00, one flat rate — which is the shape+// every date in these tests was originally priced under.+func (f *fakeDynamo) Scan(_ context.Context, _ *dynamodb.ScanInput, _ ...func(*dynamodb.Options)) (*dynamodb.ScanOutput, error) {+	if f.scanErr != nil {+		return nil, f.scanErr+	}+	rows := f.pricingRows+	if rows == nil {+		rows = []dynamo.PricingItem{testPricingRow("legacy-equivalent", "2000-01-01", "", "11:00", "14:00")}+	}+	avs := make([]map[string]types.AttributeValue, 0, len(rows))+	for i := range rows {+		av, err := attributevalue.MarshalMap(rows[i])+		if err != nil {+			return nil, err+		}+		avs = append(avs, av)+	}+	return &dynamodb.ScanOutput{Items: avs}, nil+}++// testPricingRow builds a band-shape plan whose free window is the given+// range and whose remainder carries a single flat rate.+func testPricingRow(id, startDate, endDate, freeStart, freeEnd string) dynamo.PricingItem {+	savings := 0.35+	item := dynamo.PricingItem{+		PricingID: id, StartDate: startDate, DefaultRate: 0.35, FeedInRate: 0.05,+		Windows:              []dynamo.PricingWindow{{Start: freeStart, End: freeEnd, Free: true}},+		SavingsReferenceRate: &savings,+	}+	if endDate != "" {+		item.EndDate = &endDate+	}+	return item }  func (f *fakeDynamo) Query(_ context.Context, params *dynamodb.QueryInput, _ ...func(*dynamodb.Options)) (*dynamodb.QueryOutput, error) {@@ -248,10 +288,9 @@ func backfillOptsForTest(loc *time.Location, dates ...string) backfillOpts { 		tableOffpeak:     testOffpeakTable, 		tableReadings:    testReadingsTable, 		tableDailyEnergy: testDailyEnergyTable,+		tablePricing:     testPricingTable, 		from:             from, 		to:               to,-		offpeakStart:     "11:00",-		offpeakEnd:       "14:00", 		location:         loc, 		now:              func() time.Time { return now }, 	}@@ -747,13 +786,16 @@ func TestValidateOpts_RejectsReversedDateRange(t *testing.T) { 	assert.Contains(t, err.Error(), "after") } -func TestValidateOpts_RejectsMissingWindow(t *testing.T) {+// The window flags are gone — the plan supplies each day's window — so the+// pricing table takes their place as a required option.+func TestValidateOpts_RejectsMissingPricingTable(t *testing.T) { 	loc := sydney(t) 	opts := backfillOptsForTest(loc, "2026-05-18")-	opts.offpeakStart = ""+	opts.tablePricing = ""  	err := validateOpts(opts) 	require.Error(t, err)+	assert.Contains(t, err.Error(), "table-pricing") }  func decodeOffpeakItem(t *testing.T, av map[string]types.AttributeValue) dynamo.OffpeakItem {

diff --git a/cmd/backfill-grid/main.go b/cmd/backfill-grid/main.goindex 7173163..5c432a5 100644--- a/cmd/backfill-grid/main.go+++ b/cmd/backfill-grid/main.go@@ -1,24 +1,34 @@-// Package main is the standalone backfill CLI for the two readings-derived-// grid-import channels: off-peak (off-peak from readings, T-1341) and peak-// (peak from readings; Decision 7 renamed this tool from backfill-offpeak).+// Package main is the standalone backfill CLI for the readings-derived+// grid-import channels: off-peak (off-peak from readings, T-1341), peak, and+// the per-band split (time-of-use pricing).+//+// Each day's free window comes from the plan pricing that day, read from the+// pricing table — not from flags. A backfill spanning a plan switch needs a+// different window on either side of it, and a static flag pair would silently+// misattribute every day on the wrong side (Q24). // // For each non-today date in a range it does two things: //-//  1. Off-peak (unchanged): recomputes the five flux-offpeak energy deltas-//     (gridUsageKwh, solarKwh, batteryChargeKwh, batteryDischargeKwh,-//     gridExportKwh) by integrating the power channels from flux-readings over-//     the SSM off-peak window, writing via WriteOffpeakIfComplete so a row-//     mid-poll (pending or absent) is never overwritten (AC 7.8).+//  1. Off-peak: recomputes the five flux-offpeak energy deltas (gridUsageKwh,+//     solarKwh, batteryChargeKwh, batteryDischargeKwh, gridExportKwh) by+//     integrating the power channels from flux-readings over the day's free+//     window, writing via WriteOffpeakIfComplete so a row mid-poll (pending or+//     absent) is never overwritten (AC 7.8). The row also re-records the+//     window geometry it was integrated under, so a later plan edit shows up+//     as a mismatch instead of silently repricing the day (Q23/Q31). //-//  2. Peak: computes peakGridImportKwh by integrating max(pgrid,0) over the-//     two windows bracketing off-peak ([dayStart, offpeakStart) and-//     [offpeakEnd, dayEnd)) and writes it plus the peakComputedAt sentinel to-//     the corresponding flux-daily-energy row via UpdateDailyEnergyDerived-//     (peak group only — the derived-stats group is left untouched). The+//  2. Peak and bands: integrates max(pgrid,0) over each rated segment of the+//     day's plan and writes both the per-band split (bandImports) and their+//     total (peakGridImportKwh) to the flux-daily-energy row via+//     UpdateDailyEnergyDerived — the derived-stats group is left untouched.+//     Both values come from one integration so they cannot disagree. The //     daily-energy row is fetched first; if it is absent the date is skipped-//     for peak (no phantom-row creation, Decision 7). If the integration's-//     usability gate fails for either sub-window the date keeps the iOS-//     fallback (Decision 4).+//     (no phantom-row creation, Decision 7). If any rated segment fails the+//     usability gate the date keeps the client-side fallback (Decision 4).+//+// The two steps write to different tables in separate calls, so a run+// interrupted between them leaves one repaired and the other not. Both writes+// are idempotent, so the fix is to re-run the same command. // // Today's row is always skipped on both sides — the poller is the single // authoritative writer for today (AC 7.2 / Decision 4).@@ -28,10 +38,10 @@ //	go run ./cmd/backfill-grid \ //	    --serial=AB1234 \ //	    --from=2026-04-19 --to=2026-05-18 \-//	    --offpeak-start=11:00 --offpeak-end=14:00 \ //	    --table-offpeak=flux-offpeak \ //	    --table-readings=flux-readings \ //	    --table-daily-energy=flux-daily-energy \+//	    --table-pricing=flux-pricing \ //	    [--dry-run] // // Defaults: from = today - 30d, to = yesterday (the practical readings TTL@@ -48,6 +58,7 @@ import ( 	"math" 	"os" 	"strconv"+	"strings" 	"time"  	_ "time/tzdata"@@ -59,6 +70,7 @@ import (  	"github.com/ArjenSchwarz/flux/internal/derivedstats" 	"github.com/ArjenSchwarz/flux/internal/dynamo"+	"github.com/ArjenSchwarz/flux/internal/plan" )  // dynamoAPI is the subset of the DynamoDB client this CLI uses. It mirrors@@ -72,6 +84,9 @@ type dynamoAPI interface { 	GetItem(ctx context.Context, params *dynamodb.GetItemInput, optFns ...func(*dynamodb.Options)) (*dynamodb.GetItemOutput, error) 	UpdateItem(ctx context.Context, params *dynamodb.UpdateItemInput, optFns ...func(*dynamodb.Options)) (*dynamodb.UpdateItemOutput, error) 	BatchWriteItem(ctx context.Context, params *dynamodb.BatchWriteItemInput, optFns ...func(*dynamodb.Options)) (*dynamodb.BatchWriteItemOutput, error)+	// Scan serves the pricing read (ListPricingRows). The CLI never writes+	// pricing rows — the Lambda keeps sole write access to that table.+	Scan(ctx context.Context, params *dynamodb.ScanInput, optFns ...func(*dynamodb.Options)) (*dynamodb.ScanOutput, error) }  type backfillOpts struct {@@ -79,10 +94,9 @@ type backfillOpts struct { 	tableOffpeak     string 	tableReadings    string 	tableDailyEnergy string+	tablePricing     string 	from             string 	to               string-	offpeakStart     string-	offpeakEnd       string 	location         *time.Location 	dryRun           bool 	now              func() time.Time@@ -95,13 +109,16 @@ type backfillResult struct { 	RowsDryRun          int 	RowsSparseSkipped   int // <2 usable readings in window per AC 7.4 	RowsConditionFailed int // WriteOffpeakIfComplete condition rejected--	// Peak accounting (Decision 7). Independent of the off-peak counters-	// above: a date can have its off-peak row written and its peak skipped, or-	// vice versa.-	PeakWritten       int // peakGridImportKwh written (or would be, in dry-run)+	RowsNoPlan          int // no plan prices the date — window unknowable+	RowsNoFreeBand      int // the date's plan has no free window to recompute++	// Peak/band accounting (Decision 7). Independent of the off-peak counters+	// above: a date can have its off-peak row written and its bands skipped, or+	// vice versa. Peak and bands share these counters because they come from+	// one integration and are written together.+	PeakWritten       int // peakGridImportKwh + bandImports written (or would be, in dry-run) 	PeakSkippedAbsent int // flux-daily-energy row absent — skipped (no phantom row)-	PeakSkippedSparse int // peak integration usability gate failed for a sub-window+	PeakSkippedSparse int // a rated segment failed the integrator's usability gate  	Summary []string }@@ -123,10 +140,9 @@ func main() { 	flag.StringVar(&opts.tableOffpeak, "table-offpeak", os.Getenv("TABLE_OFFPEAK"), "flux-offpeak table name (or env TABLE_OFFPEAK)") 	flag.StringVar(&opts.tableReadings, "table-readings", os.Getenv("TABLE_READINGS"), "flux-readings table name (or env TABLE_READINGS)") 	flag.StringVar(&opts.tableDailyEnergy, "table-daily-energy", os.Getenv("TABLE_DAILY_ENERGY"), "flux-daily-energy table name (or env TABLE_DAILY_ENERGY)")+	flag.StringVar(&opts.tablePricing, "table-pricing", os.Getenv("TABLE_PRICING"), "flux-pricing table name (or env TABLE_PRICING)") 	flag.StringVar(&opts.from, "from", defaultFrom, "start date inclusive (YYYY-MM-DD, Sydney TZ)") 	flag.StringVar(&opts.to, "to", defaultTo, "end date inclusive (YYYY-MM-DD, Sydney TZ)")-	flag.StringVar(&opts.offpeakStart, "offpeak-start", os.Getenv("OFFPEAK_START"), "off-peak window start HH:MM (or env OFFPEAK_START)")-	flag.StringVar(&opts.offpeakEnd, "offpeak-end", os.Getenv("OFFPEAK_END"), "off-peak window end HH:MM (or env OFFPEAK_END)") 	flag.BoolVar(&opts.dryRun, "dry-run", false, "log intended writes without invoking PutItem") 	flag.Parse() @@ -158,9 +174,11 @@ func main() { 		"todaySkipped", res.RowsSkipped, 		"sparseSkipped", res.RowsSparseSkipped, 		"conditionFailed", res.RowsConditionFailed,-		"peakWritten", res.PeakWritten,-		"peakSkippedAbsentRow", res.PeakSkippedAbsent,-		"peakSkippedSparse", res.PeakSkippedSparse,+		"noPlan", res.RowsNoPlan,+		"noFreeBand", res.RowsNoFreeBand,+		"bandsWritten", res.PeakWritten,+		"bandsSkippedAbsentRow", res.PeakSkippedAbsent,+		"bandsSkippedSparse", res.PeakSkippedSparse, 	) } @@ -177,8 +195,8 @@ func validateOpts(o backfillOpts) error { 	if o.tableDailyEnergy == "" { 		return fmt.Errorf("--table-daily-energy is required") 	}-	if o.offpeakStart == "" || o.offpeakEnd == "" {-		return fmt.Errorf("--offpeak-start and --offpeak-end are required")+	if o.tablePricing == "" {+		return fmt.Errorf("--table-pricing is required") 	} 	from, err := time.ParseInLocation("2006-01-02", o.from, o.location) 	if err != nil {@@ -191,9 +209,6 @@ func validateOpts(o backfillOpts) error { 	if from.After(to) { 		return fmt.Errorf("--from %s is after --to %s", o.from, o.to) 	}-	if _, _, ok := derivedstats.ParseOffpeakWindow(o.offpeakStart, o.offpeakEnd); !ok {-		return fmt.Errorf("invalid --offpeak-start %q / --offpeak-end %q", o.offpeakStart, o.offpeakEnd)-	} 	return nil } @@ -205,15 +220,24 @@ func validateOpts(o backfillOpts) error { // fewer than two usable readings in the window emit a SKIPPED summary line // and are left unchanged (AC 7.4). //-// For each non-today date it also backfills peakGridImportKwh on the-// corresponding flux-daily-energy row (Decision 7): it queries the full-// Sydney-local day's readings, integrates max(pgrid,0) over the two windows-// bracketing off-peak, and — only when the daily-energy row already exists —-// writes the peak group via UpdateDailyEnergyDerived. An absent row is skipped-// for peak (no phantom-row creation); a failed usability gate leaves the date-// on the iOS fallback (Decision 4). The off-peak recompute above is unchanged.+// For each non-today date it also backfills peakGridImportKwh and bandImports+// on the corresponding flux-daily-energy row: it queries the full Sydney-local+// day's readings, integrates max(pgrid,0) over each rated segment of the day's+// plan, and — only when the daily-energy row already exists — writes the peak+// and band groups via UpdateDailyEnergyDerived. An absent row is skipped (no+// phantom-row creation); a failed usability gate leaves the date on the+// client-side fallback (Decision 4).+//+// Every window comes from the plan pricing that particular date, so a range+// spanning a plan switch repairs each side under its own window (Q24). func runBackfill(ctx context.Context, client dynamoAPI, opts backfillOpts) (*backfillResult, error) { 	res := &backfillResult{}+	plans, err := dynamo.ListPricingRows(ctx, client, opts.tablePricing)+	if err != nil {+		return nil, fmt.Errorf("list pricing (%s): %w", opts.tablePricing, err)+	}+	domainPlans := dynamo.PlansFromItems(plans)+ 	rows, err := queryOffpeakRange(ctx, client, opts.tableOffpeak, opts.serial, opts.from, opts.to) 	if err != nil { 		return nil, fmt.Errorf("query offpeak (%s): %w", opts.tableOffpeak, err)@@ -240,28 +264,36 @@ func runBackfill(ctx context.Context, client dynamoAPI, opts backfillOpts) (*bac 			slog.Warn("skip: invalid row date", "date", row.Date, "error", err) 			continue 		}-		windowStart, windowEnd, ok := offpeakBoundaries(day, opts.location, opts.offpeakStart, opts.offpeakEnd)-		if !ok {-			res.RowsSkipped++-			slog.Warn("skip: invalid offpeak window", "date", row.Date)++		datePlan, hasPlan := plan.PlanFor(domainPlans, row.Date)+		if !hasPlan {+			// Without a plan there is no window to integrate over and no+			// segmentation to capture — repairing the day would mean inventing+			// its geometry.+			res.RowsNoPlan+++			slog.Warn("skip: no plan prices this date", "date", row.Date) 			continue 		} -		// Off-peak recompute (unchanged behaviour). Its own query, its own-		// usability gate, its own conditional write — none of which gate the-		// peak side below (Decision 7).-		if err := backfillOffpeak(ctx, store, client, opts, row, windowStart, windowEnd, res); err != nil {-			return res, err+		// Off-peak recompute. Its own query, its own usability gate, its own+		// conditional write — none of which gate the band side below+		// (Decision 7). A plan with no free band has no off-peak row to+		// repair, but its rated bands still cover the whole day.+		if win, ok := freeWindowOn(datePlan, day, opts.location); ok {+			if err := backfillOffpeak(ctx, store, client, opts, row, win, res); err != nil {+				return res, err+			}+		} else {+			res.RowsNoFreeBand+++			slog.Info("skip off-peak recompute: the date's plan has no free band", "date", row.Date) 		} -		// Peak backfill. Independent of the off-peak outcome above: a sparse or-		// condition-rejected off-peak row does not stop peak from being written-		// (and vice versa). dayStart is Sydney-local midnight, dayEnd the next-		// local midnight (DST-correct via AddDate).+		// Peak and band backfill. Independent of the off-peak outcome above: a+		// sparse or condition-rejected off-peak row does not stop the bands+		// from being written (and vice versa). dayStart is Sydney-local+		// midnight (DST-correct via time.Date). 		dayStart := time.Date(day.Year(), day.Month(), day.Day(), 0, 0, 0, 0, opts.location)-		dayEnd := dayStart.AddDate(0, 0, 1)-		if err := backfillPeak(ctx, store, client, opts, row.Date,-			dayStart, windowStart, windowEnd, dayEnd, res); err != nil {+		if err := backfillBands(ctx, store, client, opts, row.Date, datePlan, dayStart, res); err != nil { 			return res, err 		} 	}@@ -269,22 +301,50 @@ func runBackfill(ctx context.Context, client dynamoAPI, opts backfillOpts) (*bac 	return res, nil } +// offpeakWindow is one day's free window resolved to absolute local bounds,+// alongside the HH:MM geometry re-recorded on the repaired row.+type offpeakWindow struct {+	Start, End time.Time+	StartHHMM  string+	EndHHMM    string+}++// freeWindowOn resolves the plan's free band onto the given local day. ok is+// false when the plan has no free band.+func freeWindowOn(p plan.Plan, day time.Time, loc *time.Location) (offpeakWindow, bool) {+	startMin, endMin, ok := p.FreeWindowMinutes()+	if !ok {+		return offpeakWindow{}, false+	}+	midnight := time.Date(day.Year(), day.Month(), day.Day(), 0, 0, 0, 0, loc)+	at := func(minutes int) time.Time {+		// time.Date normalises out-of-range fields in the location, so a+		// "24:00" boundary lands on the next local midnight DST-correctly.+		return time.Date(midnight.Year(), midnight.Month(), midnight.Day(), minutes/60, minutes%60, 0, 0, loc)+	}+	return offpeakWindow{+		Start:     at(startMin),+		End:       at(endMin),+		StartHHMM: plan.FormatBandTime(startMin),+		EndHHMM:   plan.FormatBandTime(endMin),+	}, true+}+ // backfillOffpeak recomputes the five off-peak deltas for one date and writes-// the patched flux-offpeak row via WriteOffpeakIfComplete. Behaviour is-// unchanged from the original backfill-offpeak CLI: sparse readings and+// the patched flux-offpeak row via WriteOffpeakIfComplete. Sparse readings and // conditional-write rejections are recorded on res and skipped (not fatal); // only a readings-query error is fatal. func backfillOffpeak(ctx context.Context, store *dynamo.DynamoStore, client dynamoAPI,-	opts backfillOpts, row dynamo.OffpeakItem, windowStart, windowEnd time.Time, res *backfillResult,+	opts backfillOpts, row dynamo.OffpeakItem, win offpeakWindow, res *backfillResult, ) error { 	readings, err := queryReadingsRange(ctx, client, opts.tableReadings, opts.serial,-		windowStart.Unix(), windowEnd.Unix())+		win.Start.Unix(), win.End.Unix()) 	if err != nil { 		return fmt.Errorf("query readings (date=%s): %w", row.Date, err) 	}  	deltas, ok := derivedstats.IntegrateOffpeakDeltas(-		toDerivedReadings(readings), windowStart.Unix(), windowEnd.Unix())+		toDerivedReadings(readings), win.Start.Unix(), win.End.Unix()) 	if !ok { 		res.RowsSparseSkipped++ 		line := fmt.Sprintf("%s  SKIPPED (sparse readings; <2 usable samples in window)", row.Date)@@ -293,7 +353,7 @@ func backfillOffpeak(ctx context.Context, store *dynamo.DynamoStore, client dyna 		return nil 	} -	patched := patchOffpeakRow(row, deltas, opts.now().UTC())+	patched := patchOffpeakRow(row, deltas, opts.now().UTC(), win) 	summary := summaryLine(row.Date, row, patched) 	res.Summary = append(res.Summary, summary) @@ -323,87 +383,90 @@ func backfillOffpeak(ctx context.Context, store *dynamo.DynamoStore, client dyna 	return nil } -// backfillPeak computes peakGridImportKwh over the two windows bracketing-// off-peak ([dayStart, offpeakStart) and [offpeakEnd, dayEnd)) and writes it,-// plus the peakComputedAt sentinel, to the flux-daily-energy row for date — but+// backfillBands integrates max(pgrid,0) over each rated segment of the date's+// plan and writes both the split (bandImports) and its total+// (peakGridImportKwh), plus their sentinels, to the flux-daily-energy row — but // only when that row already exists (GET first; an absent row is skipped, never-// created, per Decision 7). When the integration's usability gate fails for-// either sub-window the date is skipped for peak and keeps the iOS fallback-// (Decision 4). Only the peak group is written (DerivedStatsComputedAt left-// empty), so the derived-stats group is untouched. Honours --dry-run.-func backfillPeak(ctx context.Context, store *dynamo.DynamoStore, client dynamoAPI,-	opts backfillOpts, date string, dayStart, offpeakStart, offpeakEnd, dayEnd time.Time, res *backfillResult,+// created, per Decision 7).+//+// The two values come from one integration on purpose: peak import is by+// definition the import outside the free window, which is the sum of the rated+// bands. Computing them separately would let the number on a cost card differ+// from the number on a stats card.+//+// When any rated segment fails the usability gate the date is skipped and keeps+// the client-side fallback (Decision 4). Only the peak and band groups are+// written, so the derived-stats group is untouched. Honours --dry-run.+func backfillBands(ctx context.Context, store *dynamo.DynamoStore, client dynamoAPI,+	opts backfillOpts, date string, datePlan plan.Plan, dayStart time.Time, res *backfillResult, ) error {+	// GET the daily-energy row first: the backfill must never create a phantom+	// row (Decision 7). An absent row is skipped and keeps the fallback — and+	// skipping before the readings query means a date with no row costs nothing+	// to reject.+	existing, err := store.GetDailyEnergy(ctx, opts.serial, date)+	if err != nil {+		return fmt.Errorf("get daily energy for bands (date=%s): %w", date, err)+	}+	if existing == nil {+		res.PeakSkippedAbsent+++		slog.Info("skip bands: flux-daily-energy row absent (no phantom-row creation)", "date", date)+		return nil+	}+ 	// Separate full-day readings query, kept independent of backfillOffpeak's-	// off-peak-window query on purpose: peak integrates the two windows-	// bracketing off-peak, so it needs the whole day. Off-peak recompute stays-	// byte-for-byte the original tool's behaviour (its own query, own write).+	// free-window query on purpose: the rated segments span the rest of the+	// day, so this needs all of it. The off-peak recompute keeps its own query+	// and its own write.+	dayEnd := dayStart.AddDate(0, 0, 1) 	readings, err := queryReadingsRange(ctx, client, opts.tableReadings, opts.serial, 		dayStart.Unix(), dayEnd.Unix()) 	if err != nil {-		return fmt.Errorf("query readings for peak (date=%s): %w", date, err)+		return fmt.Errorf("query readings for bands (date=%s): %w", date, err) 	} -	kwh, sampleCount, skippedPairs, ok := derivedstats.IntegratePeakGridImportKwh(-		toDerivedReadings(readings), dayStart.Unix(), offpeakStart.Unix(), offpeakEnd.Unix(), dayEnd.Unix())+	bands, totalKwh, ok := dynamo.IntegrateRatedBands(+		toDerivedReadings(readings), datePlan, dayStart, opts.location) 	if !ok { 		res.PeakSkippedSparse++-		slog.Info("skip peak: sparse readings in a bracketing window", "date", date, "readings", len(readings))+		slog.Info("skip bands: a rated segment failed the usability gate",+			"date", date, "readings", len(readings)) 		return nil 	} -	// GET the daily-energy row first: peak must never create a phantom row-	// (Decision 7). An absent row is skipped and keeps the iOS fallback.-	existing, err := store.GetDailyEnergy(ctx, opts.serial, date)-	if err != nil {-		return fmt.Errorf("get daily energy for peak (date=%s): %w", date, err)-	}-	if existing == nil {-		res.PeakSkippedAbsent++-		slog.Info("skip peak: flux-daily-energy row absent (no phantom-row creation)", "date", date)-		return nil-	}--	peakKwh := derivedstats.RoundEnergy(kwh)-	res.Summary = append(res.Summary, peakSummaryLine(date, existing.PeakGridImportKwh, peakKwh, sampleCount, skippedPairs))+	res.Summary = append(res.Summary, bandSummaryLine(date, existing.PeakGridImportKwh, totalKwh, bands))  	if opts.dryRun { 		res.PeakWritten++-		slog.Info("dry-run peak", "date", date, "peakGridImportKwh", peakKwh,-			"sampleCount", sampleCount, "skippedPairs", skippedPairs)+		slog.Info("dry-run bands", "date", date, "peakGridImportKwh", totalKwh, "bands", len(bands)) 		return nil 	} +	now := opts.now().UTC().Format(time.RFC3339) 	stats := dynamo.DerivedStats{-		PeakGridImportKwh: &peakKwh,-		PeakComputedAt:    opts.now().UTC().Format(time.RFC3339),+		PeakGridImportKwh: &totalKwh,+		PeakComputedAt:    now,+		BandImports:       bands,+		BandsComputedAt:   now, 	} 	if err := store.UpdateDailyEnergyDerived(ctx, opts.serial, date, stats); err != nil {-		return fmt.Errorf("write peak (date=%s): %w", date, err)+		return fmt.Errorf("write bands (date=%s): %w", date, err) 	} 	res.PeakWritten++-	slog.Info("wrote peak grid import", "date", date, "peakGridImportKwh", peakKwh,-		"sampleCount", sampleCount, "skippedPairs", skippedPairs)+	slog.Info("wrote band split and peak grid import",+		"date", date, "peakGridImportKwh", totalKwh, "bands", len(bands)) 	return nil } -// offpeakBoundaries returns the absolute Sydney-local times of the off-peak-// window on the given day. False indicates an unparseable window.-func offpeakBoundaries(day time.Time, loc *time.Location, start, end string) (time.Time, time.Time, bool) {-	startMin, endMin, ok := derivedstats.ParseOffpeakWindow(start, end)-	if !ok {-		return time.Time{}, time.Time{}, false-	}-	midnight := time.Date(day.Year(), day.Month(), day.Day(), 0, 0, 0, 0, loc)-	return midnight.Add(time.Duration(startMin) * time.Minute),-		midnight.Add(time.Duration(endMin) * time.Minute), true-}- // patchOffpeakRow returns a copy of stored with the five integration-sourced-// deltas, the three provenance fields, and status=complete. Every other-// field — the diagnostic startE*/endE* snapshots, socStart/socEnd,-// batteryDeltaPercent — is preserved verbatim per Decision 2.-func patchOffpeakRow(stored dynamo.OffpeakItem, deltas derivedstats.OffpeakDeltas, integratedAt time.Time) dynamo.OffpeakItem {+// deltas, the three provenance fields, the window geometry, and+// status=complete. Every other field — the diagnostic startE*/endE* snapshots,+// socStart/socEnd, batteryDeltaPercent — is preserved verbatim per Decision 2.+//+// Re-recording the geometry matters because the repair may run under a+// different window than the row was originally written with; leaving the old+// snapshot would mark a correctly-repaired row as stale (Q23).+func patchOffpeakRow(stored dynamo.OffpeakItem, deltas derivedstats.OffpeakDeltas, integratedAt time.Time, win offpeakWindow) dynamo.OffpeakItem { 	out := stored 	out.Status = dynamo.OffpeakStatusComplete 	out.GridUsageKwh = derivedstats.RoundEnergy(deltas.GridImportKwh)@@ -414,6 +477,8 @@ func patchOffpeakRow(stored dynamo.OffpeakItem, deltas derivedstats.OffpeakDelta 	out.IntegrationSampleCount = deltas.SampleCount 	out.IntegrationSkippedPairs = deltas.SkippedPairs 	out.IntegratedAt = integratedAt.Format(time.RFC3339)+	out.WindowStart = win.StartHHMM+	out.WindowEnd = win.EndHHMM 	return out } @@ -440,20 +505,22 @@ func summaryLine(date string, prev, next dynamo.OffpeakItem) string { 	) } -// peakSummaryLine formats a per-day peak line: the prior stored-// peakGridImportKwh (or "none" when the row had no peak yet), the newly-// integrated value, and the combined provenance counts across the two-// bracketing windows. Mirrors summaryLine's prev→new shape so the operator-// can scan peak alongside the off-peak deltas.-func peakSummaryLine(date string, prev *float64, next float64, sampleCount, skippedPairs int) string {-	prevStr := "none"+// bandSummaryLine formats a per-day band line: the prior stored+// peakGridImportKwh (or "none" when the row had none yet), the newly+// integrated total, and each rated band's geometry and energy. Mirrors+// summaryLine's prev→new shape so the operator can scan the rated side+// alongside the off-peak deltas and see which band moved.+func bandSummaryLine(date string, prev *float64, next float64, bands []dynamo.BandImportAttr) string {+	parts := make([]string, 0, len(bands))+	for _, b := range bands {+		parts = append(parts, fmt.Sprintf("%s-%s=%.2f", b.Start, b.End, b.Kwh))+	}+	detail := strings.Join(parts, " ") 	if prev != nil {-		prevStr = fmt.Sprintf("%.2f", *prev)-		return fmt.Sprintf("%s  peak %s→%.2f |Δ|=%.2f  samples=%d skipped=%d",-			date, prevStr, next, math.Abs(next-*prev), sampleCount, skippedPairs)+		return fmt.Sprintf("%s  peak %.2f→%.2f |Δ|=%.2f  bands %s",+			date, *prev, next, math.Abs(next-*prev), detail) 	}-	return fmt.Sprintf("%s  peak %s→%.2f  samples=%d skipped=%d",-		date, prevStr, next, sampleCount, skippedPairs)+	return fmt.Sprintf("%s  peak none→%.2f  bands %s", date, next, detail) }  // queryOffpeakRange paginates flux-offpeak for one serial and a closed date

diff --git a/cmd/backfill-grid/plan_test.go b/cmd/backfill-grid/plan_test.gonew file mode 100644index 0000000..ae4a4c2--- /dev/null+++ b/cmd/backfill-grid/plan_test.go@@ -0,0 +1,310 @@+package main++import (+	"context"+	"errors"+	"testing"+	"time"++	"github.com/aws/aws-sdk-go-v2/feature/dynamodb/attributevalue"+	"github.com/stretchr/testify/assert"+	"github.com/stretchr/testify/require"++	"github.com/ArjenSchwarz/flux/internal/dynamo"+)++// These tests cover the switch from --offpeak-start/end flags to per-day plan+// resolution (Q24). A backfill spanning a plan switch needs a different window+// on either side of it; static flags would silently misattribute every day on+// the wrong side, which is the failure this replacement exists to prevent.++// gridReadingsForDay builds dense (10 s) readings across the whole Sydney-local+// day at a constant grid import, closing on the next local midnight so every+// band has a right bracket.+func gridReadingsForDay(t *testing.T, date string, loc *time.Location, watts float64) []dynamo.ReadingItem {+	t.Helper()+	day, err := time.ParseInLocation("2006-01-02", date, loc)+	require.NoError(t, err)+	end := day.AddDate(0, 0, 1)+	out := make([]dynamo.ReadingItem, 0, 24*60*60/10+1)+	for ts := day.Unix(); ts <= end.Unix(); ts += 10 {+		out = append(out, dynamo.ReadingItem{+			SysSn: testSerial, Timestamp: ts, Pgrid: watts, Soc: 50,+		})+	}+	return out+}++// decodeUpdatedBands pulls the bandImports payload back out of the captured+// UpdateItem so assertions run against what would actually be persisted.+func decodeUpdatedBands(t *testing.T, f *fakeDynamo) []dynamo.BandImportAttr {+	t.Helper()+	require.Len(t, f.updates, 1)+	av, ok := f.updates[0].ExpressionAttributeValues[":bi"]+	require.True(t, ok, "the band group must set :bi")+	var bands []dynamo.BandImportAttr+	require.NoError(t, attributevalue.Unmarshal(av, &bands))+	return bands+}++// A range spanning the switch date must repair each day under its own plan's+// window — the whole reason the flags were removed.+func TestBackfill_ResolvesWindowPerDayAcrossAPlanSwitch(t *testing.T) {+	loc := sydney(t)+	const before, after = "2026-07-31", "2026-08-01"+	f := &fakeDynamo{+		location: loc,+		offpeakRows: map[string][]dynamo.OffpeakItem{"*": {+			existingCompleteRow(before), existingCompleteRow(after),+		}},+		readingsByDate: map[string][]dynamo.ReadingItem{+			before: gridReadingsForDay(t, before, loc, 1000),+			after:  gridReadingsForDay(t, after, loc, 1000),+		},+		dailyEnergyByDate: map[string]dynamo.DailyEnergyItem{+			before: existingDailyEnergyRow(before),+			after:  existingDailyEnergyRow(after),+		},+		pricingRows: []dynamo.PricingItem{+			testPricingRow("old", "2000-01-01", after, "11:00", "14:00"),+			testPricingRow("new", after, "", "10:00", "15:00"),+		},+	}+	opts := backfillOptsForTest(loc, before, after)++	res, err := runBackfill(context.Background(), f, opts)+	require.NoError(t, err)+	require.Equal(t, 2, res.RowsWritten)++	geometry := map[string][2]string{}+	for _, put := range f.puts {+		row := decodeOffpeakItem(t, put.Item)+		geometry[row.Date] = [2]string{row.WindowStart, row.WindowEnd}+	}+	assert.Equal(t, [2]string{"11:00", "14:00"}, geometry[before],+		"switch eve is still priced by the predecessor")+	assert.Equal(t, [2]string{"10:00", "15:00"}, geometry[after],+		"the switch day belongs to the successor")+}++// The repaired row re-records the window it was integrated under, so a later+// plan edit shows up as a mismatch instead of silently repricing the day (Q23).+func TestBackfill_RewritesOffpeakWindowGeometry(t *testing.T) {+	loc := sydney(t)+	const date = "2026-08-03"+	// The stored row still carries the pre-switch geometry.+	stale := existingCompleteRow(date)+	stale.WindowStart = "11:00"+	stale.WindowEnd = "14:00"++	f := &fakeDynamo{+		location:    loc,+		offpeakRows: map[string][]dynamo.OffpeakItem{"*": {stale}},+		readingsByDate: map[string][]dynamo.ReadingItem{+			date: gridReadingsForDay(t, date, loc, 1000),+		},+		dailyEnergyByDate: map[string]dynamo.DailyEnergyItem{date: existingDailyEnergyRow(date)},+		pricingRows: []dynamo.PricingItem{+			testPricingRow("new", "2026-08-01", "", "10:00", "15:00"),+		},+	}+	opts := backfillOptsForTest(loc, date)++	_, err := runBackfill(context.Background(), f, opts)+	require.NoError(t, err)+	require.Len(t, f.puts, 1)++	row := decodeOffpeakItem(t, f.puts[0].Item)+	assert.Equal(t, "10:00", row.WindowStart)+	assert.Equal(t, "15:00", row.WindowEnd)+	// 1 kW across the 5-hour free window.+	assert.InDelta(t, 5.0, row.GridUsageKwh, 0.05)+}++// The band split and its total land in the same write, and the total equals+// the sum of the bands — the two describe one physical quantity, so a screen+// showing either must show the same number.+func TestBackfill_WritesBandImportsWithPeakTotal(t *testing.T) {+	loc := sydney(t)+	const date = "2026-08-03"+	rate := 0.28+	savings := 0.35+	tou := dynamo.PricingItem{+		PricingID: "tou", StartDate: "2026-08-01", DefaultRate: 0.35, FeedInRate: 0.05,+		Windows: []dynamo.PricingWindow{+			{Start: "10:00", End: "15:00", Free: true},+			{Start: "01:00", End: "06:00", Rate: &rate},+		},+		SavingsReferenceRate: &savings,+	}+	f := &fakeDynamo{+		location:    loc,+		offpeakRows: map[string][]dynamo.OffpeakItem{"*": {existingCompleteRow(date)}},+		readingsByDate: map[string][]dynamo.ReadingItem{+			date: gridReadingsForDay(t, date, loc, 1000),+		},+		dailyEnergyByDate: map[string]dynamo.DailyEnergyItem{date: existingDailyEnergyRow(date)},+		pricingRows:       []dynamo.PricingItem{tou},+	}+	opts := backfillOptsForTest(loc, date)++	res, err := runBackfill(context.Background(), f, opts)+	require.NoError(t, err)+	assert.Equal(t, 1, res.PeakWritten)++	expr := *f.updates[0].UpdateExpression+	assert.Contains(t, expr, "bandImports")+	assert.Contains(t, expr, "bandsComputedAt")+	assert.Contains(t, expr, "peakGridImportKwh")+	assert.NotContains(t, expr, "derivedStatsComputedAt", "the derived-stats group stays untouched")++	assert.Equal(t, []dynamo.BandImportAttr{+		{Start: "00:00", End: "01:00", Kwh: 1.0},+		{Start: "01:00", End: "06:00", Kwh: 5.0},+		{Start: "06:00", End: "10:00", Kwh: 4.0},+		{Start: "15:00", End: "24:00", Kwh: 9.0},+	}, decodeUpdatedBands(t, f))++	var peak float64+	require.NoError(t, attributevalue.Unmarshal(f.updates[0].ExpressionAttributeValues[":pk"], &peak))+	assert.InDelta(t, 19.0, peak, 0.05, "24 h at 1 kW less the 5 h free window")+}++// Without a plan there is no window to integrate over and no segmentation to+// capture, so repairing the day would mean inventing its geometry.+func TestBackfill_NoPlanForDate_SkipsRowEntirely(t *testing.T) {+	loc := sydney(t)+	const date = "2026-05-18"+	f := &fakeDynamo{+		location:    loc,+		offpeakRows: map[string][]dynamo.OffpeakItem{"*": {existingCompleteRow(date)}},+		readingsByDate: map[string][]dynamo.ReadingItem{+			date: gridReadingsForDay(t, date, loc, 1000),+		},+		dailyEnergyByDate: map[string]dynamo.DailyEnergyItem{date: existingDailyEnergyRow(date)},+		// The only plan starts well after the date being repaired.+		pricingRows: []dynamo.PricingItem{testPricingRow("later", "2026-08-01", "", "10:00", "15:00")},+	}+	opts := backfillOptsForTest(loc, date)++	res, err := runBackfill(context.Background(), f, opts)+	require.NoError(t, err)++	assert.Equal(t, 1, res.RowsNoPlan)+	assert.Zero(t, res.RowsWritten)+	assert.Empty(t, f.puts, "no off-peak write without a window")+	assert.Empty(t, f.updates, "no band write without a segmentation")+}++// A plan with no free band has no off-peak window to recompute, but its rated+// bands still cover the whole day — so the band side must still run.+func TestBackfill_NoFreeBand_SkipsOffpeakButStillWritesBands(t *testing.T) {+	loc := sydney(t)+	const date = "2026-08-03"+	f := &fakeDynamo{+		location:    loc,+		offpeakRows: map[string][]dynamo.OffpeakItem{"*": {existingCompleteRow(date)}},+		readingsByDate: map[string][]dynamo.ReadingItem{+			date: gridReadingsForDay(t, date, loc, 1000),+		},+		dailyEnergyByDate: map[string]dynamo.DailyEnergyItem{date: existingDailyEnergyRow(date)},+		pricingRows: []dynamo.PricingItem{{+			PricingID: "flat", StartDate: "2026-08-01", DefaultRate: 0.35, FeedInRate: 0.05,+		}},+	}+	opts := backfillOptsForTest(loc, date)++	res, err := runBackfill(context.Background(), f, opts)+	require.NoError(t, err)++	assert.Equal(t, 1, res.RowsNoFreeBand)+	assert.Zero(t, res.RowsWritten)+	assert.Empty(t, f.puts, "no free window means no off-peak row to repair")++	assert.Equal(t, 1, res.PeakWritten)+	bands := decodeUpdatedBands(t, f)+	require.Len(t, bands, 1)+	assert.Equal(t, "00:00", bands[0].Start)+	assert.Equal(t, "24:00", bands[0].End)+	assert.InDelta(t, 24.0, bands[0].Kwh, 0.05)+}++// An unreadable pricing table is fatal rather than a per-row skip: continuing+// would repair every day in the range under no window at all.+func TestBackfill_PricingReadError_PropagatedAsFatal(t *testing.T) {+	loc := sydney(t)+	f := &fakeDynamo{+		location: loc,+		scanErr:  errors.New("pricing table unreachable"),+	}+	opts := backfillOptsForTest(loc, "2026-05-18")++	_, err := runBackfill(context.Background(), f, opts)++	require.Error(t, err)+	assert.Contains(t, err.Error(), "list pricing")+}++// AC 3.8: on a DST day the bands keep their wall-clock boundaries while the+// energies follow real elapsed time. Deriving boundaries by adding elapsed+// minutes to midnight would shift every band after the transition by an hour.+func TestBackfill_DSTDayBandsFollowWallClock(t *testing.T) {+	loc := sydney(t)+	const date = "2026-10-04" // DST start: 02:00 → 03:00, a 23-hour day+	f := &fakeDynamo{+		location:    loc,+		offpeakRows: map[string][]dynamo.OffpeakItem{"*": {existingCompleteRow(date)}},+		readingsByDate: map[string][]dynamo.ReadingItem{+			date: gridReadingsForDay(t, date, loc, 1000),+		},+		dailyEnergyByDate: map[string]dynamo.DailyEnergyItem{date: existingDailyEnergyRow(date)},+		pricingRows: []dynamo.PricingItem{+			testPricingRow("new", "2026-01-01", "", "10:00", "15:00"),+		},+	}+	opts := backfillOptsForTest(loc, date)+	opts.now = func() time.Time { return time.Date(2026, 10, 6, 12, 0, 0, 0, loc) }++	_, err := runBackfill(context.Background(), f, opts)+	require.NoError(t, err)++	bands := decodeUpdatedBands(t, f)+	require.Len(t, bands, 2)+	assert.Equal(t, "00:00", bands[0].Start)+	assert.Equal(t, "10:00", bands[0].End)+	// 00:00–10:00 local spans only nine real hours on this day.+	assert.InDelta(t, 9.0, bands[0].Kwh, 0.05)+	assert.InDelta(t, 9.0, bands[1].Kwh, 0.05, "15:00–24:00 is unaffected by the transition")+}++// The off-peak and band writes go to different tables in separate calls, so a+// re-run after an interruption must converge rather than double-apply.+func TestBackfill_RerunIsIdempotentAcrossBothWrites(t *testing.T) {+	loc := sydney(t)+	const date = "2026-08-03"+	newFake := func() *fakeDynamo {+		return &fakeDynamo{+			location:    loc,+			offpeakRows: map[string][]dynamo.OffpeakItem{"*": {existingCompleteRow(date)}},+			readingsByDate: map[string][]dynamo.ReadingItem{+				date: gridReadingsForDay(t, date, loc, 1000),+			},+			dailyEnergyByDate: map[string]dynamo.DailyEnergyItem{date: existingDailyEnergyRow(date)},+			pricingRows: []dynamo.PricingItem{+				testPricingRow("new", "2026-08-01", "", "10:00", "15:00"),+			},+		}+	}+	opts := backfillOptsForTest(loc, date)++	first := newFake()+	_, err := runBackfill(context.Background(), first, opts)+	require.NoError(t, err)++	second := newFake()+	_, err = runBackfill(context.Background(), second, opts)+	require.NoError(t, err)++	assert.Equal(t, decodeOffpeakItem(t, first.puts[0].Item), decodeOffpeakItem(t, second.puts[0].Item))+	assert.Equal(t, decodeUpdatedBands(t, first), decodeUpdatedBands(t, second))+}

diff --git a/cmd/backfill-solar/main_test.go b/cmd/backfill-solar/main_test.goindex c7736e1..7993514 100644--- a/cmd/backfill-solar/main_test.go+++ b/cmd/backfill-solar/main_test.go@@ -21,6 +21,7 @@ const ( 	testSerial       = "TEST123" 	testEnergyTable  = "flux-daily-energy-test" 	testReadingTable = "flux-readings-test"+	testPricingTable = "flux-pricing-test" )  // fakeDynamo is a lightweight in-memory stand-in for the DynamoDB client.@@ -29,11 +30,50 @@ const ( type fakeDynamo struct { 	dailyEnergyRows  map[string][]dynamo.DailyEnergyItem // keyed by date or "*" for all 	readingsByDate   map[string][]dynamo.ReadingItem     // keyed by date "YYYY-MM-DD" Sydney+	pricingRows      []dynamo.PricingItem                // nil ⇒ the default 11:00–14:00 open-ended plan 	location         *time.Location 	queries          []*dynamodb.QueryInput 	updates          []*dynamodb.UpdateItemInput 	queryErrForTable map[string]error 	updateErr        error+	scanErr          error+}++// Scan serves the pricing read. A fixture that sets no pricingRows gets the+// pre-feature plan — free 11:00–14:00, one flat rate — which is the window+// every date in these tests was originally computed under.+func (f *fakeDynamo) Scan(_ context.Context, _ *dynamodb.ScanInput, _ ...func(*dynamodb.Options)) (*dynamodb.ScanOutput, error) {+	if f.scanErr != nil {+		return nil, f.scanErr+	}+	rows := f.pricingRows+	if rows == nil {+		rows = []dynamo.PricingItem{testPricingRow("legacy-equivalent", "2000-01-01", "", "11:00", "14:00")}+	}+	avs := make([]map[string]types.AttributeValue, 0, len(rows))+	for i := range rows {+		av, err := attributevalue.MarshalMap(rows[i])+		if err != nil {+			return nil, err+		}+		avs = append(avs, av)+	}+	return &dynamodb.ScanOutput{Items: avs}, nil+}++// testPricingRow builds a band-shape plan whose free window is the given+// range and whose remainder carries a single flat rate.+func testPricingRow(id, startDate, endDate, freeStart, freeEnd string) dynamo.PricingItem {+	savings := 0.35+	item := dynamo.PricingItem{+		PricingID: id, StartDate: startDate, DefaultRate: 0.35, FeedInRate: 0.05,+		Windows:              []dynamo.PricingWindow{{Start: freeStart, End: freeEnd, Free: true}},+		SavingsReferenceRate: &savings,+	}+	if endDate != "" {+		item.EndDate = &endDate+	}+	return item }  func (f *fakeDynamo) Query(_ context.Context, params *dynamodb.QueryInput, _ ...func(*dynamodb.Options)) (*dynamodb.QueryOutput, error) {@@ -190,10 +230,9 @@ func backfillOptsForTest(loc *time.Location) backfillOpts { 		serial:           testSerial, 		tableDailyEnergy: testEnergyTable, 		tableReadings:    testReadingTable,+		tablePricing:     testPricingTable, 		from:             "2026-04-14", 		to:               "2026-04-14",-		offpeakStart:     "11:00",-		offpeakEnd:       "14:00", 		location:         loc, 		now:              func() time.Time { return now }, 	}

diff --git a/cmd/backfill-solar/main.go b/cmd/backfill-solar/main.goindex 6cf5223..fc4541b 100644--- a/cmd/backfill-solar/main.go+++ b/cmd/backfill-solar/main.go@@ -7,14 +7,19 @@ // (totalKwh, start, end, boundarySource, percentOfDay, status, // averageKwhPerHour) is preserved byte-for-byte (Decision 7). //+// Each day's block layout is partitioned around the free window of the plan+// pricing that day, read from the pricing table rather than passed as flags: a+// range spanning a plan switch needs a different window on either side of it,+// and a static flag pair would recompute one side under the wrong layout (Q24).+// // Usage (with operator AWS credentials): // //	go run ./cmd/backfill-solar \ //	    --serial=AB1234 \ //	    --from=2026-04-09 --to=2026-05-08 \-//	    --offpeak-start=11:00 --offpeak-end=14:00 \ //	    --table-daily-energy=flux-daily-energy \ //	    --table-readings=flux-readings \+//	    --table-pricing=flux-pricing \ //	    [--dry-run] // // Defaults: from = today - 30d, to = yesterday (the practical readings TTL@@ -39,22 +44,25 @@ import (  	"github.com/ArjenSchwarz/flux/internal/derivedstats" 	"github.com/ArjenSchwarz/flux/internal/dynamo"+	"github.com/ArjenSchwarz/flux/internal/plan" )  // dynamoAPI is the subset of the DynamoDB client this CLI uses. type dynamoAPI interface { 	Query(ctx context.Context, params *dynamodb.QueryInput, optFns ...func(*dynamodb.Options)) (*dynamodb.QueryOutput, error) 	UpdateItem(ctx context.Context, params *dynamodb.UpdateItemInput, optFns ...func(*dynamodb.Options)) (*dynamodb.UpdateItemOutput, error)+	// Scan serves the pricing read (ListPricingRows). The CLI never writes+	// pricing rows — the Lambda keeps sole write access to that table.+	Scan(ctx context.Context, params *dynamodb.ScanInput, optFns ...func(*dynamodb.Options)) (*dynamodb.ScanOutput, error) }  type backfillOpts struct { 	serial           string 	tableDailyEnergy string 	tableReadings    string+	tablePricing     string 	from             string 	to               string-	offpeakStart     string-	offpeakEnd       string 	location         *time.Location 	dryRun           bool 	now              func() time.Time@@ -65,6 +73,7 @@ type backfillResult struct { 	RowsSkipped int 	RowsWritten int 	RowsDryRun  int+	RowsNoPlan  int // no plan prices the date — block layout unknowable 	IntentLog   []string } @@ -84,10 +93,9 @@ func main() { 	flag.StringVar(&opts.serial, "serial", os.Getenv("SYSTEM_SERIAL"), "AlphaESS system serial number (or env SYSTEM_SERIAL)") 	flag.StringVar(&opts.tableDailyEnergy, "table-daily-energy", os.Getenv("TABLE_DAILY_ENERGY"), "flux-daily-energy table name (or env TABLE_DAILY_ENERGY)") 	flag.StringVar(&opts.tableReadings, "table-readings", os.Getenv("TABLE_READINGS"), "flux-readings table name (or env TABLE_READINGS)")+	flag.StringVar(&opts.tablePricing, "table-pricing", os.Getenv("TABLE_PRICING"), "flux-pricing table name (or env TABLE_PRICING)") 	flag.StringVar(&opts.from, "from", defaultFrom, "start date inclusive (YYYY-MM-DD, Sydney TZ)") 	flag.StringVar(&opts.to, "to", defaultTo, "end date inclusive (YYYY-MM-DD, Sydney TZ)")-	flag.StringVar(&opts.offpeakStart, "offpeak-start", os.Getenv("OFFPEAK_START"), "off-peak window start HH:MM (or env OFFPEAK_START)")-	flag.StringVar(&opts.offpeakEnd, "offpeak-end", os.Getenv("OFFPEAK_END"), "off-peak window end HH:MM (or env OFFPEAK_END)") 	flag.BoolVar(&opts.dryRun, "dry-run", false, "log intended writes without invoking UpdateItem") 	flag.Parse() @@ -112,6 +120,7 @@ func main() { 	slog.Info("backfill complete", 		"scanned", res.RowsScanned, 		"skipped", res.RowsSkipped,+		"noPlan", res.RowsNoPlan, 		"written", res.RowsWritten, 		"dryRun", res.RowsDryRun, 	)@@ -127,8 +136,8 @@ func validateOpts(o backfillOpts) error { 	if o.tableReadings == "" { 		return fmt.Errorf("--table-readings is required") 	}-	if o.offpeakStart == "" || o.offpeakEnd == "" {-		return fmt.Errorf("--offpeak-start and --offpeak-end are required")+	if o.tablePricing == "" {+		return fmt.Errorf("--table-pricing is required") 	} 	from, err := time.ParseInLocation("2006-01-02", o.from, o.location) 	if err != nil {@@ -151,6 +160,12 @@ func validateOpts(o backfillOpts) error { // calling UpdateItem. func runBackfill(ctx context.Context, client dynamoAPI, opts backfillOpts) (*backfillResult, error) { 	res := &backfillResult{}+	pricingRows, err := dynamo.ListPricingRows(ctx, client, opts.tablePricing)+	if err != nil {+		return nil, fmt.Errorf("list pricing (%s): %w", opts.tablePricing, err)+	}+	plans := dynamo.PlansFromItems(pricingRows)+ 	rows, err := queryDailyEnergyRange(ctx, client, opts.tableDailyEnergy, opts.serial, opts.from, opts.to) 	if err != nil { 		return nil, fmt.Errorf("query daily energy (%s): %w", opts.tableDailyEnergy, err)@@ -169,6 +184,20 @@ func runBackfill(ctx context.Context, client dynamoAPI, opts backfillOpts) (*bac 			continue 		} +		// The block layout is partitioned around the day's free window, so+		// recomputing without knowing it would produce a different set of+		// blocks than the stored row has and the per-kind patch would land on+		// the wrong ones. A plan with no free band yields empty bounds, which+		// derivedstats.Blocks already reads as "no off-peak window" and which+		// is the layout that row was stored under anyway.+		datePlan, hasPlan := plan.PlanFor(plans, row.Date)+		if !hasPlan {+			res.RowsNoPlan+++			slog.Warn("skip: no plan prices this date", "date", row.Date)+			continue+		}+		offpeakStart, offpeakEnd := freeWindowHHMM(datePlan)+ 		dayStart, err := time.ParseInLocation("2006-01-02", row.Date, opts.location) 		if err != nil { 			res.RowsSkipped++@@ -191,8 +220,8 @@ func runBackfill(ctx context.Context, client dynamoAPI, opts backfillOpts) (*bac  		recomputed := derivedstats.Blocks( 			toDerivedReadings(readings),-			opts.offpeakStart,-			opts.offpeakEnd,+			offpeakStart,+			offpeakEnd, 			row.Date, 			row.Date, 			opts.now().In(opts.location),@@ -238,6 +267,18 @@ func runBackfill(ctx context.Context, client dynamoAPI, opts backfillOpts) (*bac 	return res, nil } +// freeWindowHHMM renders the plan's free band for the derivedstats helpers.+// A plan with no free band yields two empty strings, which those helpers+// already treat as "no off-peak window" and degrade accordingly — never a+// substituted default, which would invent a block boundary (AC 4.4).+func freeWindowHHMM(p plan.Plan) (start, end string) {+	startMin, endMin, ok := p.FreeWindowMinutes()+	if !ok {+		return "", ""+	}+	return plan.FormatBandTime(startMin), plan.FormatBandTime(endMin)+}+ // countDaylightPopulated reports how many daylight blocks (morning peak, // off-peak, afternoon peak) carry a non-nil SolarKwh, and the total number // of daylight blocks present on the row. Used to surface partial-backfill

diff --git a/cmd/backfill-solar/plan_test.go b/cmd/backfill-solar/plan_test.gonew file mode 100644index 0000000..cf72f48--- /dev/null+++ b/cmd/backfill-solar/plan_test.go@@ -0,0 +1,140 @@+package main++import (+	"context"+	"errors"+	"testing"+	"time"++	"github.com/stretchr/testify/assert"+	"github.com/stretchr/testify/require"++	"github.com/ArjenSchwarz/flux/internal/derivedstats"+	"github.com/ArjenSchwarz/flux/internal/dynamo"+)++// These tests cover the switch from --offpeak-start/end flags to per-day plan+// resolution (Q24). The block layout is partitioned around the day's free+// window, so recomputing a day under the wrong window produces a different set+// of blocks than the stored row has and the per-kind patch lands nowhere.++// A range spanning a plan switch must recompute each day under its own+// window — the whole reason the flags were removed.+func TestBackfill_ResolvesWindowPerDayAcrossAPlanSwitch(t *testing.T) {+	loc := sydney(t)+	const before, after = "2026-07-31", "2026-08-01"+	f := &fakeDynamo{+		location: loc,+		dailyEnergyRows: map[string][]dynamo.DailyEnergyItem{"*": {+			storedRowAllDaylightMissingSolar(before),+			storedRowAllDaylightMissingSolar(after),+		}},+		readingsByDate: map[string][]dynamo.ReadingItem{+			before: minuteReadingsWithSolar(t, before, loc),+			after:  minuteReadingsWithSolar(t, after, loc),+		},+		pricingRows: []dynamo.PricingItem{+			testPricingRow("old", "2000-01-01", after, "11:00", "14:00"),+			testPricingRow("new", after, "", "10:00", "15:00"),+		},+	}+	opts := backfillOptsForTest(loc)+	opts.from, opts.to = before, after+	// Both fixture dates must be in the past for the in-progress clamp in+	// derivedstats.Blocks to stay inert.+	opts.now = func() time.Time { return time.Date(2026, 8, 5, 12, 0, 0, 0, loc) }++	res, err := runBackfill(context.Background(), f, opts)+	require.NoError(t, err)+	require.Equal(t, 2, res.RowsWritten)+	require.Len(t, f.updates, 2)++	// The patched row keeps the stored block boundaries verbatim (Decision 7),+	// so the window each day was recomputed under shows up in the energy: the+	// off-peak block's solar is the integral over that day's free window, at a+	// constant 1.5 kW of generation.+	offpeakSolar := func(up int) float64 {+		patched := decodeDailyUsageFromUpdate(t, f.updates[up])+		require.NotNil(t, patched)+		for _, b := range patched.Blocks {+			if b.Kind == derivedstats.DailyUsageKindOffPeak {+				require.NotNil(t, b.SolarKwh)+				return *b.SolarKwh+			}+		}+		t.Fatalf("update %d has no off-peak block", up)+		return 0+	}++	assert.InDelta(t, 4.5, offpeakSolar(0), 0.05,+		"switch eve is still priced by the predecessor's 3-hour window")+	assert.InDelta(t, 7.5, offpeakSolar(1), 0.05,+		"the switch day belongs to the successor's 5-hour window")+}++// Without a plan the day's block boundaries are unknowable, and recomputing+// under a guessed window would patch the wrong blocks.+func TestBackfill_NoPlanForDate_SkipsRow(t *testing.T) {+	loc := sydney(t)+	f := &fakeDynamo{+		location:        loc,+		dailyEnergyRows: map[string][]dynamo.DailyEnergyItem{"*": {storedRowAllDaylightMissingSolar("2026-04-14")}},+		readingsByDate:  map[string][]dynamo.ReadingItem{"2026-04-14": minuteReadingsWithSolar(t, "2026-04-14", loc)},+		// The only plan starts well after the date being repaired.+		pricingRows: []dynamo.PricingItem{testPricingRow("later", "2026-08-01", "", "10:00", "15:00")},+	}+	opts := backfillOptsForTest(loc)++	res, err := runBackfill(context.Background(), f, opts)+	require.NoError(t, err)++	assert.Equal(t, 1, res.RowsNoPlan)+	assert.Zero(t, res.RowsWritten)+	assert.Empty(t, f.updates)+}++// An unreadable pricing table is fatal rather than a per-row skip: continuing+// would recompute every day in the range under no window at all.+func TestBackfill_PricingReadError_PropagatedAsFatal(t *testing.T) {+	loc := sydney(t)+	f := &fakeDynamo{location: loc, scanErr: errors.New("pricing table unreachable")}++	_, err := runBackfill(context.Background(), f, backfillOptsForTest(loc))++	require.Error(t, err)+	assert.Contains(t, err.Error(), "list pricing")+}++// A plan with no free band carves out no off-peak block, which is the layout+// such a day's row was stored under — so the recompute must use empty bounds+// rather than substituting a window that isn't in the plan (AC 4.4).+func TestFreeWindowHHMM_NoFreeBandYieldsEmptyBounds(t *testing.T) {+	t.Parallel()+	flat := dynamo.PricingItem{+		PricingID: "flat", StartDate: "2026-08-01", DefaultRate: 0.35, FeedInRate: 0.05,+	}++	start, end := freeWindowHHMM(flat.Plan())++	assert.Empty(t, start)+	assert.Empty(t, end)+}++func TestFreeWindowHHMM_RendersThePlansFreeBand(t *testing.T) {+	t.Parallel()++	start, end := freeWindowHHMM(testPricingRow("p", "2026-08-01", "", "10:00", "15:00").Plan())++	assert.Equal(t, "10:00", start)+	assert.Equal(t, "15:00", end)+}++func TestValidateOpts_RejectsMissingPricingTable(t *testing.T) {+	loc := sydney(t)+	opts := backfillOptsForTest(loc)+	opts.tablePricing = ""++	err := validateOpts(opts)+	require.Error(t, err)+	assert.Contains(t, err.Error(), "table-pricing")+}

diff --git a/cmd/migrate-pricing/golden.go b/cmd/migrate-pricing/golden.gonew file mode 100644index 0000000..94bb9a5--- /dev/null+++ b/cmd/migrate-pricing/golden.go@@ -0,0 +1,176 @@+package main++import (+	"context"+	"fmt"++	"github.com/aws/aws-sdk-go-v2/feature/dynamodb/attributevalue"+	"github.com/aws/aws-sdk-go-v2/service/dynamodb"+	"github.com/aws/aws-sdk-go-v2/service/dynamodb/types"++	"github.com/ArjenSchwarz/flux/internal/dynamo"+	"github.com/ArjenSchwarz/flux/internal/plan"+)++// dayEnergy is one retained day's stored energy, joined from the daily-energy+// row and its off-peak row. Pointer fields keep "never recorded" distinct from+// a measured zero — the distinction the legacy formula's table turns on.+type dayEnergy struct {+	Date              string+	EInput            *float64+	EOutput           *float64+	PeakGridImportKwh *float64+	Offpeak           *dynamo.OffpeakItem+	BandImports       []dynamo.BandImportAttr+}++// toDayEnergy converts to the domain cost input, band split included.+func (d dayEnergy) toDayEnergy() plan.DayEnergy {+	out := plan.DayEnergy{+		EInput:            d.EInput,+		EOutput:           d.EOutput,+		PeakGridImportKwh: d.PeakGridImportKwh,+	}+	if d.Offpeak != nil {+		row := d.Offpeak.PlanRow()+		out.Offpeak = &row+	}+	for _, b := range d.BandImports {+		out.BandImports = append(out.BandImports, plan.BandImport{Start: b.Start, End: b.End, Kwh: b.Kwh})+	}+	return out+}++// toTierTwoEnergy is toDayEnergy with the band split withheld, forcing the+// single-rate path.+//+// This is what the legacy formula is compared against, and the asymmetry is+// deliberate: the three-rate model has no notion of a per-band split, so+// including one would compare two different questions and flag the known ~1.5%+// gap between the stored peak figure and the summed bands (Q30) as a migration+// defect. The split's own accuracy is the poller's contract; what this check+// owns is whether the row conversion reprices a day.+func (d dayEnergy) toTierTwoEnergy() plan.DayEnergy {+	out := d.toDayEnergy()+	out.BandImports = nil+	return out+}++// legacyDayCosts is the pre-migration three-rate formula, written out in full+// rather than delegated: a golden check that calls the code under test proves+// nothing.+//+// It reproduces the behaviour exactly, including the two parts that a+// simplification would quietly drop — the preference for the server-computed+// peak figure over the eInput − off-peak residual (the two differ by ~1.5% by+// design, Q30), and the zero clamp on that residual.+func legacyDayCosts(row dynamo.LegacyPricingItem, day dayEnergy) plan.Costs {+	total := deref(day.EInput)+	rate := row.PeakRate++	var importCost, savings float64+	switch {+	case day.Offpeak != nil:+		off := day.Offpeak.GridUsageKwh+		peak := max(0, total-off)+		if day.PeakGridImportKwh != nil {+			peak = *day.PeakGridImportKwh+		}+		importCost = peak * rate+		savings = off * row.OffPeakSavingsRate+	case day.PeakGridImportKwh != nil:+		importCost = *day.PeakGridImportKwh * rate+	default:+		importCost = total * rate+	}++	feedIn := deref(day.EOutput) * row.FeedInRate+	return plan.Costs{+		ImportCost:   importCost,+		FeedInIncome: feedIn,+		Net:          importCost - feedIn,+		Savings:      savings,+	}+}++func deref(v *float64) float64 {+	if v == nil {+		return 0+	}+	return *v+}++// loadDays reads every retained daily-energy row for the serial and joins its+// off-peak row. Both tables are queried in full: the migration has to prove+// nothing changed for every day still on record, not a sampled range.+func loadDays(ctx context.Context, client dynamoAPI, opts migrateOpts) ([]dayEnergy, error) {+	energyRows, err := queryAll[dynamo.DailyEnergyItem](ctx, client, opts.tableDailyEnergy, opts.serial)+	if err != nil {+		return nil, fmt.Errorf("query daily energy (%s): %w", opts.tableDailyEnergy, err)+	}+	offpeakRows, err := queryAll[dynamo.OffpeakItem](ctx, client, opts.tableOffpeak, opts.serial)+	if err != nil {+		return nil, fmt.Errorf("query offpeak (%s): %w", opts.tableOffpeak, err)+	}++	byDate := make(map[string]dynamo.OffpeakItem, len(offpeakRows))+	for _, row := range offpeakRows {+		// A pending row carries no finalised deltas, so it cannot price a free+		// window — treat it as absent, exactly as the read endpoints do.+		if row.Status != dynamo.OffpeakStatusComplete {+			continue+		}+		byDate[row.Date] = row+	}++	out := make([]dayEnergy, 0, len(energyRows))+	for _, row := range energyRows {+		day := dayEnergy{+			Date:              row.Date,+			EInput:            ptr(row.EInput),+			EOutput:           ptr(row.EOutput),+			PeakGridImportKwh: row.PeakGridImportKwh,+			BandImports:       row.BandImports,+		}+		if op, ok := byDate[row.Date]; ok {+			day.Offpeak = &op+		}+		out = append(out, day)+	}+	return out, nil+}++func ptr(v float64) *float64 { return &v }++// queryAll pages one table for every row belonging to the serial.+func queryAll[T any](ctx context.Context, client dynamoAPI, table, serial string) ([]T, error) {+	keyCondition := "sysSn = :serial"+	forward := true+	input := &dynamodb.QueryInput{+		TableName:              &table,+		KeyConditionExpression: &keyCondition,+		ExpressionAttributeValues: map[string]types.AttributeValue{+			":serial": &types.AttributeValueMemberS{Value: serial},+		},+		ScanIndexForward: &forward,+	}+	var out []T+	for {+		page, err := client.Query(ctx, input)+		if err != nil {+			return nil, err+		}+		decoded := make([]T, len(page.Items))+		for i, av := range page.Items {+			if err := attributevalue.UnmarshalMap(av, &decoded[i]); err != nil {+				return nil, fmt.Errorf("unmarshal %s row: %w", table, err)+			}+		}+		out = append(out, decoded...)+		if page.LastEvaluatedKey == nil {+			break+		}+		input.ExclusiveStartKey = page.LastEvaluatedKey+	}+	return out, nil+}

diff --git a/cmd/migrate-pricing/main_test.go b/cmd/migrate-pricing/main_test.gonew file mode 100644index 0000000..e2180a1--- /dev/null+++ b/cmd/migrate-pricing/main_test.go@@ -0,0 +1,499 @@+package main++import (+	"context"+	"errors"+	"testing"++	"github.com/aws/aws-sdk-go-v2/feature/dynamodb/attributevalue"+	"github.com/aws/aws-sdk-go-v2/service/dynamodb"+	"github.com/aws/aws-sdk-go-v2/service/dynamodb/types"+	"github.com/stretchr/testify/assert"+	"github.com/stretchr/testify/require"++	"github.com/ArjenSchwarz/flux/internal/dynamo"+)++const (+	testSerial       = "TEST123"+	testPricingTable = "flux-pricing-test"+	testEnergyTable  = "flux-daily-energy-test"+	testOffpeakTable = "flux-offpeak-test"+)++// fakeDynamo serves the three tables the migration reads and records every+// PutItem so tests can assert on what would be persisted.+type fakeDynamo struct {+	pricingItems []map[string]types.AttributeValue+	energyRows   []dynamo.DailyEnergyItem+	offpeakRows  []dynamo.OffpeakItem+	puts         []*dynamodb.PutItemInput+	scanErr      error+	queryErr     error+	putErr       error+}++func (f *fakeDynamo) Scan(_ context.Context, _ *dynamodb.ScanInput, _ ...func(*dynamodb.Options)) (*dynamodb.ScanOutput, error) {+	if f.scanErr != nil {+		return nil, f.scanErr+	}+	return &dynamodb.ScanOutput{Items: f.pricingItems}, nil+}++func (f *fakeDynamo) Query(_ context.Context, params *dynamodb.QueryInput, _ ...func(*dynamodb.Options)) (*dynamodb.QueryOutput, error) {+	if f.queryErr != nil {+		return nil, f.queryErr+	}+	switch *params.TableName {+	case testEnergyTable:+		return marshalItems(f.energyRows)+	case testOffpeakTable:+		return marshalItems(f.offpeakRows)+	}+	return &dynamodb.QueryOutput{}, nil+}++func (f *fakeDynamo) PutItem(_ context.Context, params *dynamodb.PutItemInput, _ ...func(*dynamodb.Options)) (*dynamodb.PutItemOutput, error) {+	f.puts = append(f.puts, params)+	if f.putErr != nil {+		return nil, f.putErr+	}+	return &dynamodb.PutItemOutput{}, nil+}++func marshalItems[T any](items []T) (*dynamodb.QueryOutput, error) {+	avs := make([]map[string]types.AttributeValue, 0, len(items))+	for i := range items {+		av, err := attributevalue.MarshalMap(items[i])+		if err != nil {+			return nil, err+		}+		avs = append(avs, av)+	}+	return &dynamodb.QueryOutput{Items: avs}, nil+}++func testOpts() migrateOpts {+	return migrateOpts{+		serial:           testSerial,+		tablePricing:     testPricingTable,+		tableDailyEnergy: testEnergyTable,+		tableOffpeak:     testOffpeakTable,+	}+}++// legacyRowAV marshals a legacy three-rate row the way the live table holds+// it — peakRate present, endDate inclusive.+func legacyRowAV(t *testing.T, id, start, end string, peak, feedIn, savings float64) map[string]types.AttributeValue {+	t.Helper()+	item := dynamo.LegacyPricingItem{+		PricingID: id, StartDate: start,+		PeakRate: peak, FeedInRate: feedIn, OffPeakSavingsRate: savings,+		CreatedAt: "2025-01-01T00:00:00Z", UpdatedAt: "2025-01-01T00:00:00Z",+	}+	if end != "" {+		item.EndDate = &end+	}+	av, err := attributevalue.MarshalMap(item)+	require.NoError(t, err)+	return av+}++// bandRowAV marshals an already-migrated band row.+func bandRowAV(t *testing.T, id, start, end string) map[string]types.AttributeValue {+	t.Helper()+	savings := 0.35+	item := dynamo.PricingItem{+		PricingID: id, StartDate: start, DefaultRate: 0.35, FeedInRate: 0.05,+		Windows:              []dynamo.PricingWindow{{Start: "11:00", End: "14:00", Free: true}},+		SavingsReferenceRate: &savings,+		CreatedAt:            "2026-01-01T00:00:00Z", UpdatedAt: "2026-01-01T00:00:00Z",+	}+	if end != "" {+		item.EndDate = &end+	}+	av, err := attributevalue.MarshalMap(item)+	require.NoError(t, err)+	return av+}++func sentinelAV(t *testing.T, openEndedID string) map[string]types.AttributeValue {+	t.Helper()+	av, err := attributevalue.MarshalMap(dynamo.PricingSentinel{+		PricingID: "__open_ended", OpenEndedID: &openEndedID, UpdatedAt: "2026-01-01T00:00:00Z",+	})+	require.NoError(t, err)+	return av+}++func energyRow(date string, eInput, eOutput float64, peak *float64) dynamo.DailyEnergyItem {+	return dynamo.DailyEnergyItem{+		SysSn: testSerial, Date: date, EInput: eInput, EOutput: eOutput,+		PeakGridImportKwh: peak,+	}+}++func offpeakRow(date string, gridUsage float64) dynamo.OffpeakItem {+	return dynamo.OffpeakItem{+		SysSn: testSerial, Date: date, Status: dynamo.OffpeakStatusComplete,+		GridUsageKwh: gridUsage,+		IntegratedAt: "2026-05-01T04:00:00Z", IntegrationSampleCount: 900,+		WindowStart: "11:00", WindowEnd: "14:00",+	}+}++func ptrF(v float64) *float64 { return &v }+func ptrS(v string) *string   { return &v }++// --- The golden check ---++// AC 5.2 across all four tier-2 input combinations: the day's cost must be+// bit-identical before and after the row conversion.+func TestMigration_CostsUnchangedForEveryTierTwoCombination(t *testing.T) {+	f := &fakeDynamo{+		pricingItems: []map[string]types.AttributeValue{+			legacyRowAV(t, "p1", "2026-01-01", "", 0.35, 0.05, 0.32),+		},+		energyRows: []dynamo.DailyEnergyItem{+			energyRow("2026-05-01", 20, 8, ptrF(16.5)), // off-peak present, server peak present+			energyRow("2026-05-02", 20, 8, nil),        // off-peak present, server peak absent+			energyRow("2026-05-03", 20, 8, ptrF(16.5)), // off-peak absent, server peak present+			energyRow("2026-05-04", 20, 8, nil),        // both absent+		},+		offpeakRows: []dynamo.OffpeakItem{+			offpeakRow("2026-05-01", 3.5),+			offpeakRow("2026-05-02", 3.5),+		},+	}++	res, err := runMigration(context.Background(), f, testOpts())++	require.NoError(t, err)+	assert.Empty(t, res.Mismatches)+	assert.Equal(t, 4, res.DaysChecked)+	assert.Equal(t, 1, res.LegacyRows)+}++// The zero clamp on the eInput − off-peak residual: a day whose off-peak+// import exceeds its total must price at $0, not a negative amount.+func TestMigration_ZeroClampSurvivesTheTransform(t *testing.T) {+	f := &fakeDynamo{+		pricingItems: []map[string]types.AttributeValue{+			legacyRowAV(t, "p1", "2026-01-01", "", 0.35, 0.05, 0.32),+		},+		energyRows:  []dynamo.DailyEnergyItem{energyRow("2026-05-01", 2, 0, nil)},+		offpeakRows: []dynamo.OffpeakItem{offpeakRow("2026-05-01", 5.0)},+	}++	res, err := runMigration(context.Background(), f, testOpts())++	require.NoError(t, err)+	assert.Empty(t, res.Mismatches)+	assert.Equal(t, 1, res.DaysChecked)+}++// The inclusive→exclusive end-date shift must gain and lose no day (AC 5.2):+// the predecessor's last priced day stays with the predecessor, and the+// successor's first day stays with the successor. Different rates on the two+// rows make a misattributed day show up as a cost mismatch.+func TestMigration_EndDateShiftPreservesDayOwnership(t *testing.T) {+	f := &fakeDynamo{+		pricingItems: []map[string]types.AttributeValue{+			legacyRowAV(t, "old", "2026-01-01", "2026-05-31", 0.30, 0.05, 0.28),+			legacyRowAV(t, "new", "2026-06-01", "", 0.40, 0.06, 0.38),+		},+		energyRows: []dynamo.DailyEnergyItem{+			energyRow("2026-05-30", 20, 8, ptrF(16.5)),+			energyRow("2026-05-31", 20, 8, ptrF(16.5)), // predecessor's last day+			energyRow("2026-06-01", 20, 8, ptrF(16.5)), // successor's first day+		},+		offpeakRows: []dynamo.OffpeakItem{+			offpeakRow("2026-05-30", 3.5), offpeakRow("2026-05-31", 3.5), offpeakRow("2026-06-01", 3.5),+		},+	}++	res, err := runMigration(context.Background(), f, testOpts())++	require.NoError(t, err)+	assert.Empty(t, res.Mismatches)+	assert.Equal(t, 3, res.DaysChecked)++	// The closed row's exclusive end is the day after its inclusive one.+	var migrated dynamo.PricingItem+	require.NoError(t, attributevalue.UnmarshalMap(mustPut(t, f, "old").Item, &migrated))+	require.NotNil(t, migrated.EndDate)+	assert.Equal(t, "2026-06-01", *migrated.EndDate)+}++// A repriced day must be detected. There is no fixture that makes the real+// transform reprice a day — that is the property the tool exists to guarantee —+// so the detector is exercised directly against a post-migration plan set that+// prices the day at a different rate, which is what a broken transform would+// produce.+func TestCheckDay_RecordsAMismatchWhenTheDayReprices(t *testing.T) {+	legacy := []dynamo.LegacyPricingItem{{+		PricingID: "p1", StartDate: "2026-01-01",+		PeakRate: 0.30, FeedInRate: 0.05, OffPeakSavingsRate: 0.28,+	}}+	op := offpeakRow("2026-05-01", 3.5)+	day := dayEnergy{+		Date: "2026-05-01", EInput: ptrF(20), EOutput: ptrF(8),+		PeakGridImportKwh: ptrF(16.5), Offpeak: &op,+	}+	// The migrated row should carry rate 0.30; this one carries 0.40.+	wrong := dynamo.PlansFromItems([]dynamo.PricingItem{+		{+			PricingID: "p1", StartDate: "2026-01-01", DefaultRate: 0.40, FeedInRate: 0.05,+			Windows:              []dynamo.PricingWindow{{Start: "11:00", End: "14:00", Free: true}},+			SavingsReferenceRate: ptrF(0.28),+		},+	})++	res := &migrateResult{}+	checkDay(day, legacy, nil, wrong, res)++	assert.Equal(t, 1, res.DaysChecked)+	require.Len(t, res.Mismatches, 1)+	assert.Equal(t, "2026-05-01", res.Mismatches[0].Date)+	assert.NotEqual(t, res.Mismatches[0].Before.Net, res.Mismatches[0].After.Net)+}++// A day that loses its plan across the transform prices at zero, which the+// comparison reports rather than silently accepting — the shape a wrong+// end-date shift would take.+func TestCheckDay_DayLosingItsPlanIsAMismatch(t *testing.T) {+	legacy := []dynamo.LegacyPricingItem{{+		PricingID: "p1", StartDate: "2026-01-01", EndDate: ptrS("2026-05-31"),+		PeakRate: 0.30, FeedInRate: 0.05, OffPeakSavingsRate: 0.28,+	}}+	day := dayEnergy{Date: "2026-05-31", EInput: ptrF(20), EOutput: ptrF(8), PeakGridImportKwh: ptrF(16.5)}++	res := &migrateResult{}+	checkDay(day, legacy, nil, nil, res) // no post-migration plan covers the day++	require.Len(t, res.Mismatches, 1)+	assert.Zero(t, res.Mismatches[0].After.Net)+	assert.NotZero(t, res.Mismatches[0].Before.Net)+}++// The write gate: a failed check must abort before a single row is written,+// regardless of --apply.+func TestApplyMigration_MismatchAbortsBeforeAnyWrite(t *testing.T) {+	f := &fakeDynamo{}+	opts := testOpts()+	opts.apply = true+	res := &migrateResult{+		DaysChecked: 3,+		Mismatches:  []dayMismatch{{Date: "2026-05-01"}},+	}++	err := applyMigration(context.Background(), f, opts,+		[]dynamo.PricingItem{{PricingID: "p1", StartDate: "2026-01-01"}}, res)++	require.Error(t, err)+	assert.ErrorIs(t, err, ErrGoldenMismatch)+	assert.Empty(t, f.puts, "a failed check must write nothing")+	assert.Zero(t, res.RowsWritten)+	assert.Contains(t, res.Report[0], "MISMATCH 2026-05-01")+}++// --- Write behaviour ---++func TestMigration_DryRunIsTheDefaultAndWritesNothing(t *testing.T) {+	f := &fakeDynamo{+		pricingItems: []map[string]types.AttributeValue{+			legacyRowAV(t, "p1", "2026-01-01", "", 0.35, 0.05, 0.32),+		},+		energyRows:  []dynamo.DailyEnergyItem{energyRow("2026-05-01", 20, 8, ptrF(16.5))},+		offpeakRows: []dynamo.OffpeakItem{offpeakRow("2026-05-01", 3.5)},+	}++	res, err := runMigration(context.Background(), f, testOpts())++	require.NoError(t, err)+	assert.Empty(t, f.puts)+	assert.Zero(t, res.RowsWritten)+	assert.NotEmpty(t, res.Report, "a dry run still reports what it would do")+}++// AC 5.1: the migrated row carries the free window its historical data was+// computed under, the former flat rate as the default, and the former off-peak+// savings rate — with its id preserved so the sentinel keeps pointing at it.+func TestMigration_ApplyWritesTheBandShapePreservingIDs(t *testing.T) {+	f := &fakeDynamo{+		pricingItems: []map[string]types.AttributeValue{+			legacyRowAV(t, "p1", "2026-01-01", "", 0.35, 0.05, 0.32),+			sentinelAV(t, "p1"),+		},+		energyRows:  []dynamo.DailyEnergyItem{energyRow("2026-05-01", 20, 8, ptrF(16.5))},+		offpeakRows: []dynamo.OffpeakItem{offpeakRow("2026-05-01", 3.5)},+	}+	opts := testOpts()+	opts.apply = true++	res, err := runMigration(context.Background(), f, opts)++	require.NoError(t, err)+	assert.Equal(t, 1, res.RowsWritten)+	require.Len(t, f.puts, 1, "the sentinel row must not be rewritten")++	var got dynamo.PricingItem+	require.NoError(t, attributevalue.UnmarshalMap(f.puts[0].Item, &got))+	assert.Equal(t, "p1", got.PricingID)+	assert.Equal(t, 0.35, got.DefaultRate)+	assert.Equal(t, 0.05, got.FeedInRate)+	require.NotNil(t, got.SavingsReferenceRate)+	assert.Equal(t, 0.32, *got.SavingsReferenceRate)+	assert.Equal(t, []dynamo.PricingWindow{{Start: "11:00", End: "14:00", Free: true}}, got.Windows)+	assert.Nil(t, got.EndDate, "an open-ended row stays open-ended")+	assert.Equal(t, "2025-01-01T00:00:00Z", got.CreatedAt, "createdAt is carried across")++	// The written item must not carry the legacy marker, or a re-run would+	// treat it as unmigrated.+	assert.NotContains(t, f.puts[0].Item, "peakRate")+}++// --- Idempotence ---++func TestMigration_AlreadyMigratedTableIsANoOp(t *testing.T) {+	f := &fakeDynamo{+		pricingItems: []map[string]types.AttributeValue{+			bandRowAV(t, "p1", "2026-01-01", ""),+			sentinelAV(t, "p1"),+		},+		energyRows:  []dynamo.DailyEnergyItem{energyRow("2026-05-01", 20, 8, ptrF(16.5))},+		offpeakRows: []dynamo.OffpeakItem{offpeakRow("2026-05-01", 3.5)},+	}+	opts := testOpts()+	opts.apply = true++	res, err := runMigration(context.Background(), f, opts)++	require.NoError(t, err)+	assert.Zero(t, res.LegacyRows)+	assert.Equal(t, 1, res.AlreadyBandRows)+	assert.Empty(t, f.puts)+	assert.Contains(t, res.Report[0], "already migrated")+}++// A table part-way through migration converts only what is left, and the days+// priced by the untouched band rows are verified band-vs-band and reported.+func TestMigration_MixedTableConvertsOnlyLegacyRows(t *testing.T) {+	f := &fakeDynamo{+		pricingItems: []map[string]types.AttributeValue{+			legacyRowAV(t, "old", "2026-01-01", "2026-05-31", 0.30, 0.05, 0.28),+			bandRowAV(t, "new", "2026-06-01", ""),+		},+		energyRows: []dynamo.DailyEnergyItem{+			energyRow("2026-05-15", 20, 8, ptrF(16.5)),+			energyRow("2026-06-15", 20, 8, ptrF(16.5)),+		},+		offpeakRows: []dynamo.OffpeakItem{+			offpeakRow("2026-05-15", 3.5), offpeakRow("2026-06-15", 3.5),+		},+	}+	opts := testOpts()+	opts.apply = true++	res, err := runMigration(context.Background(), f, opts)++	require.NoError(t, err)+	assert.Equal(t, 1, res.LegacyRows)+	assert.Equal(t, 1, res.AlreadyBandRows)+	assert.Equal(t, 1, res.DaysChecked, "one day is priced by the legacy row")+	assert.Equal(t, 1, res.DaysBandChecked, "one day is priced by the already-band row")+	require.Len(t, f.puts, 1)++	var got dynamo.PricingItem+	require.NoError(t, attributevalue.UnmarshalMap(f.puts[0].Item, &got))+	assert.Equal(t, "old", got.PricingID)+}++// Days no row prices are counted, not compared: they showed no costs before+// the migration and must show none after (AC 2.7).+func TestMigration_UnpricedDaysAreReportedNotChecked(t *testing.T) {+	f := &fakeDynamo{+		pricingItems: []map[string]types.AttributeValue{+			legacyRowAV(t, "p1", "2026-05-01", "", 0.35, 0.05, 0.32),+		},+		energyRows: []dynamo.DailyEnergyItem{+			energyRow("2026-04-01", 20, 8, ptrF(16.5)), // before any plan+			energyRow("2026-05-01", 20, 8, ptrF(16.5)),+		},+		offpeakRows: []dynamo.OffpeakItem{offpeakRow("2026-05-01", 3.5)},+	}++	res, err := runMigration(context.Background(), f, testOpts())++	require.NoError(t, err)+	assert.Equal(t, 1, res.DaysUnpriced)+	assert.Equal(t, 1, res.DaysChecked)+}++// --- Read failures ---++func TestMigration_PricingScanError_IsFatal(t *testing.T) {+	f := &fakeDynamo{scanErr: errors.New("pricing table unreachable")}++	_, err := runMigration(context.Background(), f, testOpts())++	require.Error(t, err)+	assert.Contains(t, err.Error(), "scan pricing")+}++func TestMigration_DailyEnergyQueryError_IsFatal(t *testing.T) {+	f := &fakeDynamo{+		pricingItems: []map[string]types.AttributeValue{+			legacyRowAV(t, "p1", "2026-01-01", "", 0.35, 0.05, 0.32),+		},+		queryErr: errors.New("throttled"),+	}++	_, err := runMigration(context.Background(), f, testOpts())++	require.Error(t, err)+	assert.Contains(t, err.Error(), "query daily energy")+}++// --- Options ---++func TestValidateOpts(t *testing.T) {+	t.Parallel()+	tests := map[string]func(*migrateOpts){+		"serial":       func(o *migrateOpts) { o.serial = "" },+		"pricing":      func(o *migrateOpts) { o.tablePricing = "" },+		"daily energy": func(o *migrateOpts) { o.tableDailyEnergy = "" },+		"offpeak":      func(o *migrateOpts) { o.tableOffpeak = "" },+	}+	for name, mutate := range tests {+		t.Run(name, func(t *testing.T) {+			t.Parallel()+			opts := testOpts()+			mutate(&opts)+			require.Error(t, validateOpts(opts))+		})+	}+	require.NoError(t, validateOpts(testOpts()))+}++// mustPut returns the PutItem whose row carries the given pricingId.+func mustPut(t *testing.T, f *fakeDynamo, id string) *dynamodb.PutItemInput {+	t.Helper()+	for _, p := range f.puts {+		if v, ok := p.Item["pricingId"].(*types.AttributeValueMemberS); ok && v.Value == id {+			return p+		}+	}+	// Dry-run fixtures have no puts; re-run with apply to inspect the payload.+	opts := testOpts()+	opts.apply = true+	_, err := runMigration(context.Background(), f, opts)+	require.NoError(t, err)+	for _, p := range f.puts {+		if v, ok := p.Item["pricingId"].(*types.AttributeValueMemberS); ok && v.Value == id {+			return p+		}+	}+	t.Fatalf("no PutItem for pricingId %q", id)+	return nil+}

diff --git a/cmd/migrate-pricing/main.go b/cmd/migrate-pricing/main.gonew file mode 100644index 0000000..8fbe9f6--- /dev/null+++ b/cmd/migrate-pricing/main.go@@ -0,0 +1,416 @@+// Package main is the one-shot migration CLI that converts the legacy+// three-rate pricing rows into the band model (Decision 3).+//+// The conversion itself is a handful of field moves, shared with the dynamo+// read path so the two can never disagree about what a migrated row looks+// like. The work here is the verification around it: AC 5.2 requires that+// every historical day's costs are identical before and after, and AC 5.3+// requires that to be checked against recorded pre-migration values before the+// legacy shape goes away.+//+// So the run is: read every pricing row and every retained daily-energy day,+// price each day under the pre-migration rules (inclusive end dates, the+// three-rate formula), transform the rows, price every day again under the+// band model, and diff. Any mismatch aborts before a single write — the tool+// is safe to run repeatedly, and refuses to be the thing that silently+// reprices history.+//+// The check is deliberately not "apply the same shared function twice": the+// golden side implements the legacy formula independently, including its+// server-peak preference and zero clamp (Q30), because a check that reuses the+// code under test proves nothing.+//+// Idempotent: a row with no peakRate attribute is already migrated and is+// skipped, so a second run is a no-op.+//+// Usage (with operator AWS credentials):+//+//	go run ./cmd/migrate-pricing \+//	    --serial=AB1234 \+//	    --table-pricing=flux-pricing \+//	    --table-daily-energy=flux-daily-energy \+//	    --table-offpeak=flux-offpeak \+//	    [--apply]+//+// Without --apply the tool reports what it would do and writes nothing.+package main++import (+	"context"+	"errors"+	"flag"+	"fmt"+	"log/slog"+	"math"+	"os"+	"sort"++	_ "time/tzdata"++	awsconfig "github.com/aws/aws-sdk-go-v2/config"+	"github.com/aws/aws-sdk-go-v2/feature/dynamodb/attributevalue"+	"github.com/aws/aws-sdk-go-v2/service/dynamodb"+	"github.com/aws/aws-sdk-go-v2/service/dynamodb/types"++	"github.com/ArjenSchwarz/flux/internal/dynamo"+	"github.com/ArjenSchwarz/flux/internal/plan"+)++// dynamoAPI is the subset of the DynamoDB client this CLI uses.+type dynamoAPI interface {+	Scan(ctx context.Context, params *dynamodb.ScanInput, optFns ...func(*dynamodb.Options)) (*dynamodb.ScanOutput, error)+	Query(ctx context.Context, params *dynamodb.QueryInput, optFns ...func(*dynamodb.Options)) (*dynamodb.QueryOutput, error)+	PutItem(ctx context.Context, params *dynamodb.PutItemInput, optFns ...func(*dynamodb.Options)) (*dynamodb.PutItemOutput, error)+}++// ErrGoldenMismatch is returned when at least one day prices differently+// before and after the transform. It is fatal by design: a migration that+// changes historical costs violates AC 5.2, and no partial write is preferable+// to a wrong one.+var ErrGoldenMismatch = errors.New("golden cost check failed: migration would change historical costs")++// costEpsilon is the tolerance for the before/after comparison. The two sides+// perform the same multiplications on the same inputs, so a real match is+// exact; the epsilon only absorbs float64 association differences.+const costEpsilon = 1e-9++type migrateOpts struct {+	serial           string+	tablePricing     string+	tableDailyEnergy string+	tableOffpeak     string+	apply            bool+}++// dayMismatch is one day whose costs changed across the transform.+type dayMismatch struct {+	Date          string+	Before, After plan.Costs+}++type migrateResult struct {+	LegacyRows      int // rows carrying peakRate — the ones to transform+	AlreadyBandRows int // rows already in the band shape — left alone+	DaysChecked     int // days priced by a legacy row, verified legacy-vs-band+	DaysBandChecked int // days priced by an already-band row, verified band-vs-band+	DaysUnpriced    int // days no row covers, before or after+	RowsWritten     int+	Mismatches      []dayMismatch+	Report          []string+}++func main() {+	slog.SetDefault(slog.New(slog.NewTextHandler(os.Stderr, nil)))++	var opts migrateOpts+	flag.StringVar(&opts.serial, "serial", os.Getenv("SYSTEM_SERIAL"), "AlphaESS system serial number (or env SYSTEM_SERIAL)")+	flag.StringVar(&opts.tablePricing, "table-pricing", os.Getenv("TABLE_PRICING"), "flux-pricing table name (or env TABLE_PRICING)")+	flag.StringVar(&opts.tableDailyEnergy, "table-daily-energy", os.Getenv("TABLE_DAILY_ENERGY"), "flux-daily-energy table name (or env TABLE_DAILY_ENERGY)")+	flag.StringVar(&opts.tableOffpeak, "table-offpeak", os.Getenv("TABLE_OFFPEAK"), "flux-offpeak table name (or env TABLE_OFFPEAK)")+	flag.BoolVar(&opts.apply, "apply", false, "write the migrated rows (default: report only)")+	flag.Parse()++	if err := validateOpts(opts); err != nil {+		slog.Error("invalid options", "error", err)+		os.Exit(2)+	}++	ctx := context.Background()+	awsCfg, err := awsconfig.LoadDefaultConfig(ctx)+	if err != nil {+		slog.Error("load AWS config", "error", err)+		os.Exit(1)+	}++	res, err := runMigration(ctx, dynamodb.NewFromConfig(awsCfg), opts)+	if res != nil {+		for _, line := range res.Report {+			fmt.Println(line)+		}+	}+	if err != nil {+		slog.Error("migration aborted", "error", err)+		os.Exit(1)+	}+	slog.Info("migration complete",+		"legacyRows", res.LegacyRows,+		"alreadyBandRows", res.AlreadyBandRows,+		"daysChecked", res.DaysChecked,+		"daysBandChecked", res.DaysBandChecked,+		"daysUnpriced", res.DaysUnpriced,+		"rowsWritten", res.RowsWritten,+		"applied", opts.apply,+	)+	if !opts.apply {+		fmt.Println("\nDry run: nothing was written. Re-run with --apply to migrate.")+	}+}++func validateOpts(o migrateOpts) error {+	if o.serial == "" {+		return fmt.Errorf("--serial is required")+	}+	if o.tablePricing == "" {+		return fmt.Errorf("--table-pricing is required")+	}+	if o.tableDailyEnergy == "" {+		return fmt.Errorf("--table-daily-energy is required")+	}+	if o.tableOffpeak == "" {+		return fmt.Errorf("--table-offpeak is required")+	}+	return nil+}++// runMigration is the testable core. It never writes unless opts.apply is set+// and every day's costs survived the check.+func runMigration(ctx context.Context, client dynamoAPI, opts migrateOpts) (*migrateResult, error) {+	res := &migrateResult{}++	rows, err := scanPricingRaw(ctx, client, opts.tablePricing)+	if err != nil {+		return res, err+	}+	legacy, band, err := partitionRows(rows)+	if err != nil {+		return res, err+	}+	res.LegacyRows = len(legacy)+	res.AlreadyBandRows = len(band)++	if len(legacy) == 0 {+		res.Report = append(res.Report, "No legacy pricing rows found — already migrated.")+		return res, nil+	}++	// Transform first so the check can price each day both ways in one pass.+	// Nothing is written until the check has passed in full.+	migrated := make([]dynamo.PricingItem, 0, len(legacy))+	for _, row := range legacy {+		item, err := dynamo.TransformLegacyPricing(row)+		if err != nil {+			return res, fmt.Errorf("transform legacy row (pricingId=%s): %w", row.PricingID, err)+		}+		migrated = append(migrated, item)+		res.Report = append(res.Report, transformLine(row, item))+	}++	days, err := loadDays(ctx, client, opts)+	if err != nil {+		return res, err+	}++	// Post-migration plan set: the transformed rows plus the ones that were+	// already in the band shape and are not being touched.+	afterPlans := dynamo.PlansFromItems(append(append([]dynamo.PricingItem{}, migrated...), band...))++	for _, day := range days {+		checkDay(day, legacy, band, afterPlans, res)+	}++	return res, applyMigration(ctx, client, opts, migrated, res)+}++// applyMigration is the write gate. It is a separate step so the ordering+// invariant — no row is written until every day has been verified — is one+// readable guard rather than a property of where a loop happens to sit.+func applyMigration(ctx context.Context, client dynamoAPI, opts migrateOpts,+	migrated []dynamo.PricingItem, res *migrateResult,+) error {+	if err := res.goldenErr(); err != nil {+		for _, m := range res.Mismatches {+			res.Report = append(res.Report, mismatchLine(m))+		}+		return err+	}+	if !opts.apply {+		return nil+	}+	for _, item := range migrated {+		if err := putPricingRow(ctx, client, opts.tablePricing, item); err != nil {+			return err+		}+		res.RowsWritten+++	}+	return nil+}++// goldenErr returns the abort error when any day priced differently across the+// transform, and nil when every one matched.+func (r *migrateResult) goldenErr() error {+	if len(r.Mismatches) == 0 {+		return nil+	}+	return fmt.Errorf("%w: %d of %d days differ", ErrGoldenMismatch, len(r.Mismatches), r.DaysChecked)+}++// checkDay prices one day before and after the transform and records a+// mismatch if the two disagree.+//+// The two sides are deliberately asymmetric for a legacy-priced day: the+// "before" is the independent three-rate formula under inclusive end dates,+// the "after" is the band model under exclusive ones. That asymmetry is the+// point — it is what catches a wrong end-date shift or a mis-mapped rate,+// which comparing the shared transform against itself never would.+func checkDay(day dayEnergy, legacy []dynamo.LegacyPricingItem, band []dynamo.PricingItem,+	afterPlans []plan.Plan, res *migrateResult,+) {+	if row, ok := legacyRowFor(legacy, day.Date); ok {+		before := legacyDayCosts(row, day)+		after, _ := plan.DayCosts(planFor(afterPlans, day.Date), day.toTierTwoEnergy())+		res.DaysChecked+++		if !costsEqual(before, after) {+			res.Mismatches = append(res.Mismatches, dayMismatch{Date: day.Date, Before: before, After: after})+		}+		return+	}+	if item, ok := bandRowFor(band, day.Date); ok {+		// The row is not touched by the migration, so its days are verified+		// band-formula-vs-band-formula and reported for the operator's record+		// rather than treated as at-risk.+		costs, tier := plan.DayCosts(item.Plan(), day.toDayEnergy())+		res.DaysBandChecked+++		res.Report = append(res.Report,+			fmt.Sprintf("%s  already band-shape (plan=%s tier=%d) net=%.4f — unchanged by migration",+				day.Date, item.PricingID, tier, costs.Net))+		return+	}+	res.DaysUnpriced+++}++// costsEqual compares the four figures every screen shows.+func costsEqual(a, b plan.Costs) bool {+	return math.Abs(a.ImportCost-b.ImportCost) < costEpsilon &&+		math.Abs(a.FeedInIncome-b.FeedInIncome) < costEpsilon &&+		math.Abs(a.Net-b.Net) < costEpsilon &&+		math.Abs(a.Savings-b.Savings) < costEpsilon+}++// planFor returns the plan pricing date, or the zero plan when none does. A+// day that loses its plan across the transform produces zero costs here, which+// the comparison reports as a mismatch — exactly the off-by-one the exclusive+// end date could introduce.+func planFor(plans []plan.Plan, date string) plan.Plan {+	p, _ := plan.PlanFor(plans, date)+	return p+}++// legacyRowFor finds the legacy row pricing date under the pre-migration+// inclusive end-date rule.+func legacyRowFor(rows []dynamo.LegacyPricingItem, date string) (dynamo.LegacyPricingItem, bool) {+	for _, r := range rows {+		if date < r.StartDate {+			continue+		}+		if r.EndDate == nil || date <= *r.EndDate {+			return r, true+		}+	}+	return dynamo.LegacyPricingItem{}, false+}++// bandRowFor finds the already-band row pricing date under the exclusive+// end-date rule.+func bandRowFor(rows []dynamo.PricingItem, date string) (dynamo.PricingItem, bool) {+	for _, r := range rows {+		if r.Plan().Covers(date) {+			return r, true+		}+	}+	return dynamo.PricingItem{}, false+}++// transformLine reports one row's conversion so the operator can eyeball the+// end-date shift before applying it.+func transformLine(old dynamo.LegacyPricingItem, next dynamo.PricingItem) string {+	end := func(v *string) string {+		if v == nil {+			return "open"+		}+		return *v+	}+	return fmt.Sprintf("row %s  %s..%s (inclusive) → %s..%s (exclusive)  rate=%.4f feedIn=%.4f savings=%.4f  free 11:00-14:00",+		old.PricingID, old.StartDate, end(old.EndDate), next.StartDate, end(next.EndDate),+		next.DefaultRate, next.FeedInRate, deref(next.SavingsReferenceRate))+}++func mismatchLine(m dayMismatch) string {+	return fmt.Sprintf("MISMATCH %s  import %.4f→%.4f  feedIn %.4f→%.4f  net %.4f→%.4f  savings %.4f→%.4f",+		m.Date,+		m.Before.ImportCost, m.After.ImportCost,+		m.Before.FeedInIncome, m.After.FeedInIncome,+		m.Before.Net, m.After.Net,+		m.Before.Savings, m.After.Savings)+}++// putPricingRow writes the migrated row as a full item, preserving its+// pricingId. The sentinel row is never touched: it points at the open-ended+// row by id, and the transform does not change any id.+func putPricingRow(ctx context.Context, client dynamoAPI, table string, item dynamo.PricingItem) error {+	av, err := attributevalue.MarshalMap(item)+	if err != nil {+		return fmt.Errorf("marshal migrated row (pricingId=%s): %w", item.PricingID, err)+	}+	if _, err := client.PutItem(ctx, &dynamodb.PutItemInput{TableName: &table, Item: av}); err != nil {+		return fmt.Errorf("put migrated row (table=%s, pricingId=%s): %w", table, item.PricingID, err)+	}+	return nil+}++// scanPricingRaw pages the pricing table and returns the raw attribute maps,+// sentinel excluded. The raw form is required: attributevalue silently drops+// unknown attributes, so a legacy row decoded straight into PricingItem looks+// like a zero-rate band plan rather than anything recognisably legacy.+func scanPricingRaw(ctx context.Context, client dynamoAPI, table string) ([]map[string]types.AttributeValue, error) {+	var out []map[string]types.AttributeValue+	input := &dynamodb.ScanInput{TableName: &table}+	for {+		page, err := client.Scan(ctx, input)+		if err != nil {+			return nil, fmt.Errorf("scan pricing (table=%s): %w", table, err)+		}+		for _, av := range page.Items {+			if id, ok := av["pricingId"].(*types.AttributeValueMemberS); ok && id.Value == dynamo.PricingSentinelID {+				continue+			}+			out = append(out, av)+		}+		if page.LastEvaluatedKey == nil {+			break+		}+		input.ExclusiveStartKey = page.LastEvaluatedKey+	}+	return out, nil+}++// partitionRows splits the raw rows into the ones still carrying peakRate and+// the ones already in the band shape.+//+// An undecodable row aborts the run rather than being skipped. Skipping one+// would leave it untransformed AND drop every day it prices out of the golden+// check (those days fall through to "unpriced"), so --apply would migrate the+// remaining rows, report success, and leave a half-migrated table behind — the+// exact silent repricing this tool exists to prevent. dynamo.ListPricingRows+// errors on the same failure.+func partitionRows(rows []map[string]types.AttributeValue) ([]dynamo.LegacyPricingItem, []dynamo.PricingItem, error) {+	var legacy []dynamo.LegacyPricingItem+	var band []dynamo.PricingItem+	for _, av := range rows {+		if dynamo.IsLegacyPricingRow(av) {+			var item dynamo.LegacyPricingItem+			if err := attributevalue.UnmarshalMap(av, &item); err != nil {+				return nil, nil, fmt.Errorf("undecodable legacy pricing row: %w", err)+			}+			legacy = append(legacy, item)+			continue+		}+		var item dynamo.PricingItem+		if err := attributevalue.UnmarshalMap(av, &item); err != nil {+			return nil, nil, fmt.Errorf("undecodable pricing row: %w", err)+		}+		band = append(band, item)+	}+	sort.SliceStable(legacy, func(i, j int) bool { return legacy[i].StartDate < legacy[j].StartDate })+	sort.SliceStable(band, func(i, j int) bool { return band[i].StartDate < band[j].StartDate })+	return legacy, band, nil+}

diff --git a/cmd/poller/logging_test.go b/cmd/poller/logging_test.goindex a9afc95..8eb9240 100644--- a/cmd/poller/logging_test.go+++ b/cmd/poller/logging_test.go@@ -31,12 +31,10 @@ func TestLogPollerStartupDoesNotLogAppSecret(t *testing.T) { 	var output bytes.Buffer 	logger := slog.New(slog.NewJSONHandler(&output, nil)) 	cfg := &config.Config{-		Serial:       "SYS-001",-		AppSecret:    "super-secret-value",-		OffpeakStart: 11 * time.Hour,-		OffpeakEnd:   14 * time.Hour,-		Location:     time.UTC,-		DryRun:       true,+		Serial:    "SYS-001",+		AppSecret: "super-secret-value",+		Location:  time.UTC,+		DryRun:    true, 	}  	logPollerStartup(cfg, logger)

diff --git a/cmd/poller/logging.go b/cmd/poller/logging.goindex f4b406e..e442599 100644--- a/cmd/poller/logging.go+++ b/cmd/poller/logging.go@@ -35,9 +35,11 @@ func newJSONLogger(output io.Writer) *slog.Logger { // logPollerStartup logs selected non-secret configuration fields. Never logs // the full config to avoid leaking AppSecret. func logPollerStartup(cfg *config.Config, logger *slog.Logger) {+	// The off-peak window is no longer configuration, so it is no longer a+	// startup fact: each day's window is resolved from the plan pricing that+	// day and logged by the scheduler as it processes the day. 	logger.Info("poller starting", 		"serial", cfg.Serial,-		"offpeak", config.FormatHHMM(cfg.OffpeakStart)+"-"+config.FormatHHMM(cfg.OffpeakEnd), 		"tz", cfg.Location.String(), 		"dry_run", cfg.DryRun, 	)

diff --git a/cmd/poller/main.go b/cmd/poller/main.goindex 0236cb5..8e19b05 100644--- a/cmd/poller/main.go+++ b/cmd/poller/main.go@@ -39,8 +39,9 @@ func main() { 	// Create AlphaESS client. 	client := alphaess.NewClient(cfg.AppID, cfg.AppSecret, cfg.HTTPTimeout) -	// Create store (DynamoDB or dry-run logger).-	store, err := createStore(cfg)+	// Create store (DynamoDB or dry-run logger) and the read-only pricing+	// source the window-dependent jobs resolve their day's free band from.+	store, plans, err := createStore(cfg) 	if err != nil { 		slog.Error("create store failed", "error", err) 		os.Exit(1)@@ -53,7 +54,7 @@ func main() { 	defer cancel()  	// Run poller (blocks until ctx is cancelled).-	p := poller.New(client, store, cfg)+	p := poller.New(client, store, plans, cfg)  	// CloudWatch metrics for the daily-derived-stats summarisation pass. 	// Dry-run keeps the no-op variant set by poller.New.@@ -83,26 +84,37 @@ func main() { 	slog.Info("poller stopped") } -// createStore builds the appropriate Store implementation based on config.-func createStore(cfg *config.Config) (dynamo.Store, error) {+// createStore builds the Store and the read-only pricing source from config.+// Both come from the same DynamoDB client, so the pricing reader is created+// here rather than making the caller rebuild the AWS config.+func createStore(cfg *config.Config) (dynamo.Store, poller.PlanLister, error) { 	if cfg.DryRun {-		slog.Info("dry-run mode active, DynamoDB writes disabled")-		return dynamo.NewLogStore(slog.Default()), nil+		slog.Info("dry-run mode active, DynamoDB writes disabled; no pricing plans, so window-dependent jobs stay idle")+		return dynamo.NewLogStore(slog.Default()), noPlans{}, nil 	}  	awsCfg, err := awsconfig.LoadDefaultConfig(context.Background(), 		awsconfig.WithRegion(cfg.AWSRegion), 	) 	if err != nil {-		return nil, fmt.Errorf("load AWS config: %w", err)+		return nil, nil, fmt.Errorf("load AWS config: %w", err) 	}  	client := dynamodb.NewFromConfig(awsCfg)-	return dynamo.NewDynamoStore(client, dynamo.TableNames{+	store := dynamo.NewDynamoStore(client, dynamo.TableNames{ 		Readings:    cfg.TableReadings, 		DailyEnergy: cfg.TableDailyEnergy, 		DailyPower:  cfg.TableDailyPower, 		System:      cfg.TableSystem, 		Offpeak:     cfg.TableOffpeak,-	}), nil+	})+	return store, dynamo.NewDynamoPricingStore(client, cfg.TablePricing), nil }++// noPlans is the dry-run pricing source. Dry-run has no DynamoDB credentials+// or table names, so it reports an empty plan set — which the scheduler and+// the summarisation pass both treat as "no plan prices this day" and skip,+// exactly the no-write behaviour dry-run is for.+type noPlans struct{}++func (noPlans) ListPricing(context.Context) ([]dynamo.PricingItem, error) { return nil, nil }

diff --git a/docs/agent-notes/api-layer.md b/docs/agent-notes/api-layer.mdindex 8023140..ebc5cab 100644--- a/docs/agent-notes/api-layer.md+++ b/docs/agent-notes/api-layer.md@@ -23,7 +23,8 @@  ## Handler -- `Handler` struct holds: `reader` (dynamo.Reader), `notes` (api.NoteWriter), `serial`, `apiToken`, `offpeakStart`, `offpeakEnd`, `nowFunc`.+- `Handler` struct holds: `reader` (dynamo.Reader), `notes` (api.NoteWriter), `serial`, `apiToken`, `nowFunc`, plus a pricing store injected via `SetPricingStore`.+- There are no `offpeakStart`/`offpeakEnd` fields and no `OFFPEAK_START`/`OFFPEAK_END` env vars: the free window is resolved per day from the plan pricing that day (`specs/time-of-use-pricing`, Decision 2). `/status`, `/day`, and `/history` each fetch plans once, inside their existing errgroup. A pricing read failure is a 500 — never a fabricated "no plan" (Q14). - `api.NoteWriter` is a small interface defined in the api package mirroring the dynamo-side `PutNote`/`DeleteNote` methods so handler tests can mock without importing dynamo internals (the parameter type is still `dynamo.NoteItem`). - `nowFunc` defaults to `time.Now`, overridable in tests for deterministic time. - `Handle` is the Lambda entry point — logs method, path, status, duration via slog. Never logs the token.@@ -39,7 +40,7 @@ - Phase 2: in-memory computation — extract latest reading, filter to 60s/15min subsets, compute pgridSustained, rolling averages, cutoff estimates, MinSOC for `low24h` (filtered to readings since 00:00 Sydney local on `now`'s date via `startOfDaySydney`; field name preserved for wire compatibility — see `specs/low-since-offpeak/decision_log.md` Decision 4). No off-peak dependency on this path. - `liveFresh` gate (T-1274): `resp.Live`, `battery.EstimatedCutoff`, and `rolling15min.EstimatedCutoff` are populated only when the most recent reading is within `liveDataStalenessThreshold` (90 s). Past that, the dashboard's existing "Awaiting live data" UI surfaces instead of presenting an aged reading as current. `low24h` and the rolling averages themselves still derive from their own time-windowed subsets, which already produce correct results when the latest reading is stale. - `filterReadings(readings, from, to)` — returns subset by timestamp range.-- `buildOffpeak(item, today, windowStart, windowEnd)` — always includes window times. Deltas come from a complete record's final values, or are projected from today's running `DailyEnergyItem` against the pending record's start snapshot. Pending without a daily-energy item leaves deltas null. The response carries a `status` field (`"pending"` or `"complete"`) so clients can mark in-progress data; `batteryDeltaPercent` is unavailable mid-window because no current SOC is computed in this slice.+- `buildOffpeak(item, readings, now, window)` — returns `nil` when the day has no free window (its plan has no free band, or no plan prices it), which serialises `/status.offpeak` as `null`; clients render that as "no window" and never substitute a default (Q35). Otherwise it includes the window times. Deltas come from a complete record's final values, or are live-integrated from readings while pending. Pending without usable readings leaves deltas null. The response carries a `status` field (`"pending"` or `"complete"`) so clients can mark in-progress data; `batteryDeltaPercent` is unavailable mid-window because no current SOC is computed in this slice. - `floatPtr(v)` — helper for nullable float64 fields. - Battery capacity: fallback 13.34 when system missing or cobat == 0. - Rolling 15min: requires >= 2 readings in window, otherwise null.@@ -70,7 +71,8 @@  - Package-level `sydneyTZ` var loaded once via init function — avoids repeated `time.LoadLocation` calls and silently discarded errors. Panics on load failure (fail-fast). - `computeCutoffTime(soc, pbat, capacityKwh, cutoffPercent, now)` — Linear extrapolation. Returns nil for charging/idle/SOC≤cutoff.-- `nextOffpeakStart(now, offpeakStart, offpeakEnd)` — Absolute Sydney-local time of the next off-peak window start (today's start if `now < todayEnd`, tomorrow's start otherwise). Returns `(_, false)` for invalid off-peak config. Used by `/status` to suppress cutoff predictions that land at or after the next scheduled charging window (see T-827).+- `nextOffpeakStart(now, plans)` — Absolute Sydney-local time of the next off-peak window start (today's start if `now < todayEnd`, tomorrow's start otherwise). The window comes from the plan pricing **the day the window falls on**, so on the eve of a plan switch it follows the successor's window rather than the outgoing one (AC 4.2/Q11). Returns `(_, false)` when that day has no free window. Used by `/status` to suppress cutoff predictions that land at or after the next scheduled charging window (see T-827).+- `offpeakWindow.bounds(local)` — resolves a window to absolute instants via `plan.SegmentBounds`, i.e. wall-clock `time.Date`, **not** midnight-plus-elapsed-minutes. The additive form is an hour off on Sydney's two DST-transition days and would put the free-window edge an hour away from the band edges served in the same payload. Pinned by `dst_window_test.go`. - `computeRollingAverages(readings)` — Mean of pload and pbat. Returns (0,0) for empty. - `computePgridSustained(readings)` — Iterates backwards from end, counts consecutive pgrid>500 within 30s gaps. Needs 3+ consecutive. Expects ascending order input. - `downsample(readings, date)` — 288 five-minute buckets, averages per bucket, omits empty. Uses `sydneyTZ`. Output is already in chronological order (buckets iterated 0..287).

diff --git a/docs/agent-notes/infrastructure.md b/docs/agent-notes/infrastructure.mdindex 1ca182a..93527cc 100644--- a/docs/agent-notes/infrastructure.md+++ b/docs/agent-notes/infrastructure.md@@ -8,10 +8,17 @@ ## Template Structure  The template is a skeleton with:-- 6 Parameters: ContainerImageUri, AlphaESSAppId, SystemSerialNumber, OffPeakWindowStart, OffPeakWindowEnd, SSMPathPrefix+- 4 Parameters: ContainerImageUri, AlphaESSAppId, SystemSerialNumber, SSMPathPrefix - 3 Outputs: FunctionUrl (from ApiFunctionUrl), EcsClusterName (from EcsCluster), EcsServiceName (from PollerService) - Resources section is empty — will be populated by subsequent tasks +`OffPeakWindowStart` / `OffPeakWindowEnd` were removed with the time-of-use+pricing feature: the free window is a property of the plan pricing each day+(that spec's Decision 2), so it switches with the plan rather than with a stack+update. Deploying that version leaves `/flux/offpeak-start` and+`/flux/offpeak-end` behind as orphaned SSM parameters — nothing reads them, and+CloudFormation no longer manages them.+ ## Linting  `cfn-lint` is available on this machine and should be used to validate template changes. Expected warnings for unused parameters and unresolved resource references are normal during incremental development.@@ -21,7 +28,7 @@ The template is a skeleton with: - **VPC/Networking**: Vpc, SubnetA/B, IGW, RouteTable, DynamoDB/S3 endpoints, SecurityGroup - **IAM**: TaskExecutionRole, TaskRole, LambdaExecutionRole - **CloudWatch**: PollerLogGroup, ApiLogGroup-- **SSM Parameters**: AppIdParameter, SerialParameter, OffpeakStartParameter, OffpeakEndParameter+- **SSM Parameters**: AppIdParameter, SerialParameter - **DynamoDB**: ReadingsTable, DailyEnergyTable, DailyPowerTable, SystemTable, OffpeakTable, NotesTable - **Lambda**: ApiFunction, ApiFunctionUrl, ApiFunctionUrlPermission - **ECS**: EcsCluster, TaskDefinition, PollerService

diff --git a/docs/architecture-diagrams.md b/docs/architecture-diagrams.mdindex 47de9c5..ffa2f27 100644--- a/docs/architecture-diagrams.md+++ b/docs/architecture-diagrams.md@@ -149,7 +149,9 @@ the Internet Gateway. The VPC template also defines an S3 gateway endpoint, but the poller has no runtime S3 path — it is not drawn here to avoid implying one.  IAM is least-privilege per role: the poller's `TaskRole` reads SoC rules/devices-and writes readings, summaries, off-peak, and fire-state; the+and pricing (read-only — `Scan`/`GetItem`/`Query`, so it can resolve each day's+free window without gaining a write path) and writes readings, summaries,+off-peak, and fire-state; the `LambdaExecutionRole` is read-only on the energy tables and write-scoped to the user-authored tables (notes, devices, rules, pricing, presets) only. @@ -169,7 +171,7 @@ flowchart LR         g2["pollDailyPower<br/>every 1h · today + yesterday"]         g3["pollDailyEnergy<br/>every 1h · today + yesterday"]         g4["pollSystemInfo<br/>every 24h"]-        g5["offpeak scheduler<br/>at window start + end"]+        g5["offpeak scheduler<br/>wakes at local midnight<br/>resolves the day's free window"]         g6["pollDailySummary<br/>every 1h · derives, no API call"]         g7["midnightFinalizer<br/>~00:15 local"]     end@@ -211,13 +213,21 @@ Notes that matter for correctness: - **Today and yesterday both polled hourly** — yesterday is re-fetched so the   final pre-midnight snapshots land before the day rolls over. - **Off-peak energy is integrated from live readings** (post-T-1341) —-  `handleEnd` runs a strongly-consistent query of `flux-readings` over the-  configured window (e.g. 11:00–14:00) and sums the per-reading power deltas via+  `handleEnd` runs a strongly-consistent query of `flux-readings` over the free+  window and sums the per-reading power deltas via   `derivedstats.IntegrateOffpeakDeltas`, then writes the result to `flux-offpeak`.   The `getOneDateEnergy` snapshots captured at window start/end are retained for   diagnostics and drift logging only — they are not the basis of the computed   value. This is why `g5` reads from `flux-readings` rather than following the   `e3 → flux-daily-energy` path the other goroutines use.+- **The free window comes from the pricing plan, not configuration**+  (`specs/time-of-use-pricing`, Decision 2) — `g5` wakes at local midnight,+  refreshes its plan cache, and resolves that day's free band before sleeping to+  its start, so a plan switch moves the window with no stack update. A day whose+  plan has no free band sleeps through to the next midnight. Plan reads that+  fail are served from the last-good cache and never resolved as "no plan"+  (Q14). `g6` additionally captures the day's rated-band import split+  (`bandImports`) so banded costs outlive the 30-day readings TTL. - **`pollLiveData` also feeds SoC alerts** — the same 10s tick evaluates rules and   writes `flux-soc-fire-state`, so the poller touches more than the five tables   shown here. See diagram 8 for the full fire path.@@ -238,12 +248,12 @@ historical date. | `flux-daily-power` | `sysSn` / `uploadTime` | retained | Poller (hourly) | Lambda (Day Detail fallback) | | `flux-daily-energy` | `sysSn` / `date` | retained | Poller (hourly + summary + finalizer) | Lambda | | `flux-system` | `sysSn` | retained | Poller (24h) | Lambda |-| `flux-offpeak` | `sysSn` / `date` | retained | Poller (window diff) | Lambda |+| `flux-offpeak` | `sysSn` / `date` | retained | Poller (window integration, snapshots the window geometry) | Lambda | | `flux-notes` | `sysSn` / `date` | PITR | Lambda (`PUT /note`) | Lambda | | `flux-devices` | `deviceId` | PITR | Lambda + Poller (GC) | Poller (eval) | | `flux-soc-rules` | `deviceId` / `ruleId` | PITR | Lambda | Poller (eval) | | `flux-soc-fire-state` | `deviceRule` / `windowStartDate` | TTL 7d | Poller (idempotent) | Poller |-| `flux-pricing` | `pricingId` | PITR | Lambda | Lambda |+| `flux-pricing` | `pricingId` | PITR | Lambda | Lambda + Poller (read-only, for each day's free window) | | `flux-simulation-presets` | `presetId` | PITR | Lambda | Lambda |  Write ownership is deliberately split — the poller and the Lambda never share a@@ -270,6 +280,7 @@ flowchart LR      devices --> poller     rules --> poller+    pricing -->|free window per day| poller     poller -.->|GC delete| devices     poller -.->|GC delete| rules 

diff --git a/docs/flux-v1.md b/docs/flux-v1.mdindex 4e7fa6f..1f87d52 100644--- a/docs/flux-v1.md+++ b/docs/flux-v1.md@@ -99,6 +99,13 @@ The server rejects requests where the timestamp drifts more than 300 seconds fro  ### Off-Peak Calculation +> **Superseded twice.** The snapshot-diff basis was replaced by integration over+> `flux-readings` in T-1341 (`specs/offpeak-from-readings`); the snapshots are+> now retained for diagnostics only. The SSM-configured window was replaced by+> the free band of the pricing plan covering each day in T-1890/T-1891+> (`specs/time-of-use-pricing`, Decision 2). The description below is the+> original V1 plan, kept for context.+ The container is configured with the off-peak window (11:00 AM – 2:00 PM) via SSM Parameter Store. It calls `getOneDateEnergyBySn` at the start and end of the off-peak window and stores both snapshots. The diff between the two gives exact off-peak values for every energy metric:  - Off-peak grid usage = `eInput(end) - eInput(start)`@@ -390,6 +397,12 @@ The system serial number and off-peak window are configured server-side in SSM P  ### Off-Peak Window +> **Superseded by `specs/time-of-use-pricing` (Decision 2).** The window is now+> the free band of the pricing plan covering each day, so it changes with the+> plan rather than with a stack update, and the SSM parameters are gone.+> `/status.offpeak` is nullable — a day with no free band serialises `null`, and+> clients must render that as "no window" rather than substituting a default.+ Configured server-side in SSM Parameter Store (currently 11:00 AM – 2:00 PM). The container uses this to schedule energy snapshot calls and compute off-peak deltas. The app reads the window times from the `/status` response for display purposes only.  ### Load Alert Threshold

diff --git a/Flux/Flux/Charts/Expansion/ExpandedDayHost.swift b/Flux/Flux/Charts/Expansion/ExpandedDayHost.swiftindex 83595a5..6cbd317 100644--- a/Flux/Flux/Charts/Expansion/ExpandedDayHost.swift+++ b/Flux/Flux/Charts/Expansion/ExpandedDayHost.swift@@ -5,11 +5,20 @@ struct ExpandedDayHostSnapshot {     var date: String     var readings: [ParsedReading]     var summary: DaySummary?+    /// The day's free window, from the plan pricing it, so the expanded chart+    /// shades the same band the inline one does.+    var offpeakWindow: PlanSegment? -    init(date: String = "", readings: [ParsedReading] = [], summary: DaySummary? = nil) {+    init(+        date: String = "",+        readings: [ParsedReading] = [],+        summary: DaySummary? = nil,+        offpeakWindow: PlanSegment? = nil+    ) {         self.date = date         self.readings = readings         self.summary = summary+        self.offpeakWindow = offpeakWindow     } } @@ -79,6 +88,7 @@ struct ExpandedDayHost: View {                 PowerChartView(                     date: controller.displayed.date,                     readings: controller.displayed.readings,+                    offpeakWindow: controller.displayed.offpeakWindow,                     selectedDate: $selectedDate                 )             case .dayBatteryCombined:@@ -86,6 +96,7 @@ struct ExpandedDayHost: View {                     date: controller.displayed.date,                     readings: controller.displayed.readings,                     summary: controller.displayed.summary,+                    offpeakWindow: controller.displayed.offpeakWindow,                     selectedDate: $selectedDate                 )             case .historySolar, .historyGridUsage, .historyDailyUsage:

diff --git a/Flux/Flux/DayDetail/BatteryCombinedChartView.swift b/Flux/Flux/DayDetail/BatteryCombinedChartView.swiftindex 3da4952..7fb76ca 100644--- a/Flux/Flux/DayDetail/BatteryCombinedChartView.swift+++ b/Flux/Flux/DayDetail/BatteryCombinedChartView.swift@@ -12,6 +12,8 @@ struct BatteryCombinedChartView: View {     let date: String     let readings: [ParsedReading]     let summary: DaySummary?+    /// The day's free window, from the plan pricing it; nil means no shading.+    let offpeakWindow: PlanSegment?     @Binding var selectedDate: Date?      var expansionScope: ChartScope {@@ -34,7 +36,7 @@ struct BatteryCombinedChartView: View {     @ViewBuilder     private var chartBody: some View {         Chart {-            if let offpeak = DayChartDomain.offpeakRange(for: date) {+            if let offpeak = DayChartDomain.offpeakRange(for: date, window: offpeakWindow) {                 RectangleMark(                     xStart: .value("Start", offpeak.start),                     xEnd: .value("End", offpeak.end)@@ -204,7 +206,13 @@ struct BatteryCombinedChartView: View {         guard let date = DateFormatting.parseTimestamp(reading.timestamp) else { return nil }         return ParsedReading(id: reading.id, date: date, point: reading)     }-    BatteryCombinedChartView(date: day.date, readings: parsed, summary: day.summary, selectedDate: .constant(nil))+    BatteryCombinedChartView(+        date: day.date,+        readings: parsed,+        summary: day.summary,+        offpeakWindow: PlanSegment(start: "11:00", end: "14:00", free: true, rate: 0),+        selectedDate: .constant(nil)+    )         .padding() } #endif

diff --git a/Flux/Flux/DayDetail/BatteryPowerChartView.swift b/Flux/Flux/DayDetail/BatteryPowerChartView.swiftindex 61b1f2c..1822823 100644--- a/Flux/Flux/DayDetail/BatteryPowerChartView.swift+++ b/Flux/Flux/DayDetail/BatteryPowerChartView.swift@@ -5,6 +5,8 @@ import SwiftUI struct BatteryPowerChartView: View {     let date: String     let readings: [ParsedReading]+    /// The day's free window, from the plan pricing it; nil means no shading.+    let offpeakWindow: PlanSegment?      @State private var selectedDate: Date? @@ -25,7 +27,7 @@ struct BatteryPowerChartView: View {             }              Chart {-                if let offpeak = DayChartDomain.offpeakRange(for: date) {+                if let offpeak = DayChartDomain.offpeakRange(for: date, window: offpeakWindow) {                     RectangleMark(                         xStart: .value("Start", offpeak.start),                         xEnd: .value("End", offpeak.end)@@ -97,7 +99,11 @@ struct BatteryPowerChartView: View {         guard let date = DateFormatting.parseTimestamp(reading.timestamp) else { return nil }         return ParsedReading(id: reading.id, date: date, point: reading)     }-    BatteryPowerChartView(date: day.date, readings: parsed)-        .padding()+    BatteryPowerChartView(+        date: day.date,+        readings: parsed,+        offpeakWindow: PlanSegment(start: "11:00", end: "14:00", free: true, rate: 0)+    )+    .padding() } #endif

diff --git a/Flux/Flux/DayDetail/DayChartDomain.swift b/Flux/Flux/DayDetail/DayChartDomain.swiftindex cc28756..1a5901a 100644--- a/Flux/Flux/DayDetail/DayChartDomain.swift+++ b/Flux/Flux/DayDetail/DayChartDomain.swift@@ -13,14 +13,28 @@ enum DayChartDomain {         return startOfDay ... endOfDay     } -    static func offpeakRange(for dateString: String) -> (start: Date, end: Date)? {-        guard let startOfDay = DateFormatting.parseDayDate(dateString) else { return nil }-        let calendar = DateFormatting.sydneyCalendar+    /// The free-window shading band for a day's charts. The window comes from+    /// the free band of the plan pricing that day (AC 4.1) rather than a fixed+    /// 11:00–14:00, so it moves with the plan on the switch date. A day with no+    /// plan, or whose plan has no free band, gets no shading (AC 4.4).+    static func offpeakRange(for dateString: String, window: PlanSegment?) -> (start: Date, end: Date)? {+        guard let window,+              let startOfDay = DateFormatting.parseDayDate(dateString),+              let startMinutes = PlanWindow.parseBandTime(window.start),+              let endMinutes = PlanWindow.parseBandTime(window.end)+        else { return nil } -        guard let offpeakStart = calendar.date(byAdding: .hour, value: 11, to: startOfDay),-              let offpeakEnd = calendar.date(byAdding: .hour, value: 14, to: startOfDay)+        let calendar = DateFormatting.sydneyCalendar+        guard let offpeakStart = calendar.date(byAdding: .minute, value: startMinutes, to: startOfDay),+              let offpeakEnd = calendar.date(byAdding: .minute, value: endMinutes, to: startOfDay)         else { return nil }          return (offpeakStart, offpeakEnd)     }++    /// Convenience for the call sites that hold the plan list rather than an+    /// already-resolved window.+    static func offpeakRange(for dateString: String, plans: [PricingPlan]) -> (start: Date, end: Date)? {+        offpeakRange(for: dateString, window: PricingPlan.freeWindow(for: dateString, in: plans))+    } }

diff --git a/Flux/Flux/DayDetail/DayDetailView.swift b/Flux/Flux/DayDetail/DayDetailView.swiftindex 34f6e1a..5b7f5ec 100644--- a/Flux/Flux/DayDetail/DayDetailView.swift+++ b/Flux/Flux/DayDetail/DayDetailView.swift@@ -224,10 +224,12 @@ struct DayDetailView: View {                 if viewModel.hasPowerData {                     DayDetailPanels.power(date: viewModel.date,                                           readings: viewModel.parsedReadings,+                                          offpeakWindow: viewModel.offpeakWindow,                                           selectedDate: $powerSelected)                     DayDetailPanels.battery(date: viewModel.date,                                             readings: viewModel.parsedReadings,                                             summary: viewModel.summary,+                                            offpeakWindow: viewModel.offpeakWindow,                                             selectedDate: $batterySelected)                 } else {                     DayDetailMessagePanel(title: "Power charts unavailable",@@ -235,6 +237,7 @@ struct DayDetailView: View {                     DayDetailPanels.battery(date: viewModel.date,                                             readings: viewModel.parsedReadings,                                             summary: viewModel.summary,+                                            offpeakWindow: viewModel.offpeakWindow,                                             selectedDate: $batterySelected)                 }             } else if let error = viewModel.error {@@ -319,10 +322,12 @@ struct DayDetailView: View {             if viewModel.hasPowerData {                 DayDetailPanels.power(date: viewModel.date,                                       readings: viewModel.parsedReadings,+                                      offpeakWindow: viewModel.offpeakWindow,                                       selectedDate: $powerSelected)                 DayDetailPanels.battery(date: viewModel.date,                                         readings: viewModel.parsedReadings,                                         summary: viewModel.summary,+                                        offpeakWindow: viewModel.offpeakWindow,                                         selectedDate: $batterySelected)             } else {                 DayDetailMessagePanel(title: "Power charts unavailable",@@ -330,6 +335,7 @@ struct DayDetailView: View {                 DayDetailPanels.battery(date: viewModel.date,                                         readings: viewModel.parsedReadings,                                         summary: viewModel.summary,+                                        offpeakWindow: viewModel.offpeakWindow,                                         selectedDate: $batterySelected)             }         } else if let error = viewModel.error {

diff --git a/Flux/Flux/DayDetail/DayDetailViewModel.swift b/Flux/Flux/DayDetail/DayDetailViewModel.swiftindex 7d83997..726d9ca 100644--- a/Flux/Flux/DayDetail/DayDetailViewModel.swift+++ b/Flux/Flux/DayDetail/DayDetailViewModel.swift@@ -105,11 +105,19 @@ final class DayDetailViewModel {         await loadDay()     } -    /// Costs for the viewed day. Returns nil when no pricing period covers-    /// the day or the daily summary is missing (AC 4.6).+    /// Costs for the viewed day. Returns nil when no plan covers the day or+    /// the daily summary is missing (AC 2.7).     var costs: DayCosts? {         guard let summary else { return nil }-        return summary.costs(forDate: date, in: pricingService.periods)+        return summary.costs(forDate: date, in: pricingService.plans)+    }++    /// The free window of the plan pricing the viewed day, used for chart+    /// shading and the off-peak reading stats. Nil on a day with no plan or no+    /// free band — those get no window rather than a substituted default+    /// (AC 4.4).+    var offpeakWindow: PlanSegment? {+        PricingPlan.freeWindow(for: date, in: pricingService.plans)     }      /// AC 2.7 requires a refetch on every Day Detail open. Called from the@@ -133,7 +141,11 @@ final class DayDetailViewModel {             peakPeriods = response.peakPeriods ?? []             dailyUsage = response.dailyUsage             note = response.note-            offpeakStats = OffpeakReadingStats.compute(date: date, readings: parsedReadings)+            offpeakStats = OffpeakReadingStats.compute(+                date: date,+                readings: parsedReadings,+                offpeakWindow: offpeakWindow+            )             error = nil         } catch {             readings = []

diff --git a/Flux/Flux/DayDetail/DayDetailViewSupport.swift b/Flux/Flux/DayDetail/DayDetailViewSupport.swiftindex e70fc83..f71589a 100644--- a/Flux/Flux/DayDetail/DayDetailViewSupport.swift+++ b/Flux/Flux/DayDetail/DayDetailViewSupport.swift@@ -5,12 +5,18 @@ enum DayDetailPanels {     static func power(         date: String,         readings: [ParsedReading],+        offpeakWindow: PlanSegment?,         selectedDate: Binding<Date?>     ) -> some View {         FluxPanel {             VStack(alignment: .leading, spacing: 0) {                 FluxPanelHeader(label: "Power", right: "kW")-                PowerChartView(date: date, readings: readings, selectedDate: selectedDate)+                PowerChartView(+                    date: date,+                    readings: readings,+                    offpeakWindow: offpeakWindow,+                    selectedDate: selectedDate+                )                 HStack(spacing: 14) {                     legendChip(color: FluxTheme.Palette.amber, text: "Solar")                     legendChip(color: FluxTheme.Palette.load, text: "House")@@ -27,12 +33,19 @@ enum DayDetailPanels {         date: String,         readings: [ParsedReading],         summary: DaySummary?,+        offpeakWindow: PlanSegment?,         selectedDate: Binding<Date?>     ) -> some View {         FluxPanel {             VStack(alignment: .leading, spacing: 0) {                 FluxPanelHeader(label: "Battery", right: "% · ± kW")-                BatteryCombinedChartView(date: date, readings: readings, summary: summary, selectedDate: selectedDate)+                BatteryCombinedChartView(+                    date: date,+                    readings: readings,+                    summary: summary,+                    offpeakWindow: offpeakWindow,+                    selectedDate: selectedDate+                )             }         }     }

diff --git a/Flux/Flux/DayDetail/PowerChartView.swift b/Flux/Flux/DayDetail/PowerChartView.swiftindex 710b29b..0613c80 100644--- a/Flux/Flux/DayDetail/PowerChartView.swift+++ b/Flux/Flux/DayDetail/PowerChartView.swift@@ -7,6 +7,8 @@ struct PowerChartView: View {      let date: String     let readings: [ParsedReading]+    /// The day's free window, from the plan pricing it; nil means no shading.+    let offpeakWindow: PlanSegment?     @Binding var selectedDate: Date?      var expansionScope: ChartScope {@@ -40,7 +42,7 @@ struct PowerChartView: View {     @ViewBuilder     private var chartBody: some View {         Chart {-            if let offpeak = DayChartDomain.offpeakRange(for: date) {+            if let offpeak = DayChartDomain.offpeakRange(for: date, window: offpeakWindow) {                 RectangleMark(                     xStart: .value("Start", offpeak.start),                     xEnd: .value("End", offpeak.end)@@ -125,7 +127,12 @@ struct PowerChartView: View {         guard let date = DateFormatting.parseTimestamp(reading.timestamp) else { return nil }         return ParsedReading(id: reading.id, date: date, point: reading)     }-    PowerChartView(date: day.date, readings: parsed, selectedDate: .constant(nil))+    PowerChartView(+        date: day.date,+        readings: parsed,+        offpeakWindow: PlanSegment(start: "11:00", end: "14:00", free: true, rate: 0),+        selectedDate: .constant(nil)+    )         .padding() } #endif

diff --git a/Flux/Flux/DayDetail/SOCChartView.swift b/Flux/Flux/DayDetail/SOCChartView.swiftindex 6548ea6..2d9f301 100644--- a/Flux/Flux/DayDetail/SOCChartView.swift+++ b/Flux/Flux/DayDetail/SOCChartView.swift@@ -6,6 +6,8 @@ struct SOCChartView: View {     let date: String     let readings: [ParsedReading]     let summary: DaySummary?+    /// The day's free window, from the plan pricing it; nil means no shading.+    let offpeakWindow: PlanSegment?      @State private var selectedDate: Date? @@ -18,7 +20,7 @@ struct SOCChartView: View {             }              Chart {-                if let offpeak = DayChartDomain.offpeakRange(for: date) {+                if let offpeak = DayChartDomain.offpeakRange(for: date, window: offpeakWindow) {                     RectangleMark(                         xStart: .value("Start", offpeak.start),                         xEnd: .value("End", offpeak.end)@@ -98,7 +100,12 @@ struct SOCChartView: View {         guard let date = DateFormatting.parseTimestamp(reading.timestamp) else { return nil }         return ParsedReading(id: reading.id, date: date, point: reading)     }-    SOCChartView(date: day.date, readings: parsed, summary: day.summary)+    SOCChartView(+        date: day.date,+        readings: parsed,+        summary: day.summary,+        offpeakWindow: PlanSegment(start: "11:00", end: "14:00", free: true, rate: 0)+    )         .padding() } #endif

diff --git a/Flux/Flux/Helpers/OffpeakReadingStats.swift b/Flux/Flux/Helpers/OffpeakReadingStats.swiftindex bec0aad..790eb4f 100644--- a/Flux/Flux/Helpers/OffpeakReadingStats.swift+++ b/Flux/Flux/Helpers/OffpeakReadingStats.swift@@ -23,12 +23,16 @@ struct OffpeakReadingStats: Equatable {     /// window-specific stats. The API's `OffpeakData.gridUsageKwh` is the     /// source of truth when available; the integrated value here is a     /// fallback for the Day Detail summary split.-    static func compute(date: String, readings: [ParsedReading]) -> OffpeakReadingStats {+    static func compute(+        date: String,+        readings: [ParsedReading],+        offpeakWindow: PlanSegment?+    ) -> OffpeakReadingStats {         guard !readings.isEmpty else { return .empty }          let lowest = readings.min { $0.point.soc < $1.point.soc } -        guard let range = DayChartDomain.offpeakRange(for: date) else {+        guard let range = DayChartDomain.offpeakRange(for: date, window: offpeakWindow) else {             return OffpeakReadingStats(                 lowestSOC: lowest?.point.soc,                 lowestSOCTimestamp: lowest?.date,

diff --git a/Flux/Flux/History/HistoryViewModel.swift b/Flux/Flux/History/HistoryViewModel.swiftindex dd8f4ef..a5a67d2 100644--- a/Flux/Flux/History/HistoryViewModel.swift+++ b/Flux/Flux/History/HistoryViewModel.swift@@ -73,10 +73,11 @@ final class HistoryViewModel {     }      /// Costs for the currently-loaded range. Computed lazily — recomputes-    /// whenever the underlying `days` or `pricingService.periods` change,-    /// thanks to `@Observable` tracking on both.+    /// whenever the underlying `days` or `pricingService.plans` change, thanks+    /// to `@Observable` tracking on both. Each day is priced by the plan+    /// covering it, so a range spanning a switch date sums both sides.     var periodCosts: PeriodCosts? {-        PeriodCosts.compute(days: days, pricing: pricingService.periods)+        PeriodCosts.compute(days: days, pricing: pricingService.plans)     }      /// AC 2.7 requires a refetch on every History range change. Called from@@ -279,6 +280,11 @@ final class HistoryViewModel {                 cached.offpeakGridImportKwh = day.offpeakGridImportKwh                 cached.offpeakGridExportKwh = day.offpeakGridExportKwh                 cached.peakGridImportKwh = day.peakGridImportKwh+                cached.bandImports = day.bandImports+                cached.offpeakWindowStart = day.offpeakWindowStart+                cached.offpeakWindowEnd = day.offpeakWindowEnd+                cached.offpeakIntegratedAt = day.offpeakIntegratedAt+                cached.offpeakSampleCount = day.offpeakSampleCount                 cached.note = day.note                 warnIfClearing(cached: cached, day: day)                 cached.dailyUsage = day.dailyUsage

diff --git a/Flux/Flux/Models/CachedDayEnergy.swift b/Flux/Flux/Models/CachedDayEnergy.swiftindex f3572ba..f093b99 100644--- a/Flux/Flux/Models/CachedDayEnergy.swift+++ b/Flux/Flux/Models/CachedDayEnergy.swift@@ -14,6 +14,17 @@ final class CachedDayEnergy {     var peakGridImportKwh: Double?     var note: String? +    // The rated-band split and the off-peak row's geometry and provenance.+    // Cached alongside the energy values because History serves cached days+    // when a fetch fails: without them the same day would reprice at the+    // fallback tier offline and at the banded tier online, and the two screens+    // would disagree (Data Consistency).+    var bandImports: [BandImport]?+    var offpeakWindowStart: String?+    var offpeakWindowEnd: String?+    var offpeakIntegratedAt: String?+    var offpeakSampleCount: Int?+     // Derived stats persisted as optional Codable values (per     // daily-derived-stats AC 5.4). SwiftData stores Codable structs as     // transformable blobs without needing an extra @Relationship — keeping@@ -34,6 +45,11 @@ final class CachedDayEnergy {         offpeakGridImportKwh = dayEnergy.offpeakGridImportKwh         offpeakGridExportKwh = dayEnergy.offpeakGridExportKwh         peakGridImportKwh = dayEnergy.peakGridImportKwh+        bandImports = dayEnergy.bandImports+        offpeakWindowStart = dayEnergy.offpeakWindowStart+        offpeakWindowEnd = dayEnergy.offpeakWindowEnd+        offpeakIntegratedAt = dayEnergy.offpeakIntegratedAt+        offpeakSampleCount = dayEnergy.offpeakSampleCount         note = dayEnergy.note         dailyUsage = dayEnergy.dailyUsage         socLow = dayEnergy.socLow@@ -52,6 +68,11 @@ final class CachedDayEnergy {             offpeakGridImportKwh: offpeakGridImportKwh,             offpeakGridExportKwh: offpeakGridExportKwh,             peakGridImportKwh: peakGridImportKwh,+            bandImports: bandImports,+            offpeakWindowStart: offpeakWindowStart,+            offpeakWindowEnd: offpeakWindowEnd,+            offpeakIntegratedAt: offpeakIntegratedAt,+            offpeakSampleCount: offpeakSampleCount,             note: note,             dailyUsage: dailyUsage,             socLow: socLow,

diff --git a/Flux/Flux/Settings/Pricing/PricingEditor.swift b/Flux/Flux/Settings/Pricing/PricingEditor.swiftindex 7a69cba..546fe87 100644--- a/Flux/Flux/Settings/Pricing/PricingEditor.swift+++ b/Flux/Flux/Settings/Pricing/PricingEditor.swift@@ -1,10 +1,13 @@ import FluxCore import SwiftUI -/// Sheet for creating or editing a single pricing period. Rate inputs accept-/// up to four decimal places (AC 3.4). Validation errors from the backend-/// surface inline against the offending field when possible, otherwise as a-/// banner. The destructive delete sits behind a confirmation dialog (AC 3.7).+/// Sheet for creating or editing a single pricing plan. A plan is entered as a+/// default rate plus the exception windows that deviate from it (Decision 4);+/// the contiguous full-day segmentation is derived, so gaps and partial+/// coverage are unrepresentable. Rate inputs accept up to four decimal places.+/// Validation errors from the backend surface inline against the offending+/// field when possible, otherwise as a banner. The destructive delete sits+/// behind a confirmation dialog. @MainActor struct PricingEditor: View {     @Bindable var viewModel: PricingViewModel@@ -15,36 +18,9 @@ struct PricingEditor: View {     var body: some View {         NavigationStack {             Form {-                Section("Dates") {-                    DatePicker(-                        "Start",-                        selection: Binding(-                            get: { PricingEditor.parseDate(viewModel.draft.startDate) ?? Date() },-                            set: { viewModel.draft.startDate = PricingEditor.formatDate($0) }-                        ),-                        displayedComponents: .date-                    )-                    Toggle("Open-ended (no end date)", isOn: openEndedBinding)-                    if viewModel.draft.endDate != nil {-                        DatePicker(-                            "End",-                            selection: Binding(-                                get: {-                                    PricingEditor.parseDate(-                                        viewModel.draft.endDate ?? viewModel.draft.startDate-                                    ) ?? Date()-                                },-                                set: { viewModel.draft.endDate = PricingEditor.formatDate($0) }-                            ),-                            displayedComponents: .date-                        )-                    }-                }-                Section("Rates (AUD per kWh)") {-                    rateField(label: "Peak", value: $viewModel.draft.peakRate)-                    rateField(label: "Solar feed-in", value: $viewModel.draft.feedInRate)-                    rateField(label: "Off-peak savings", value: $viewModel.draft.offPeakSavingsRate)-                }+                datesSection+                ratesSection+                windowsSection                 if let inlineMessage = inlineValidationMessage {                     Section {                         Text(inlineMessage)@@ -52,41 +28,8 @@ struct PricingEditor: View {                             .foregroundStyle(.red)                     }                 }-                if viewModel.overlapRemediationTargetId != nil {-                    Section {-                        Button {-                            Task {-                                do {-                                    try await viewModel.remediateOverlap()-                                    dismiss()-                                } catch {-                                    // surfaces via lastValidationError-                                }-                            }-                        } label: {-                            Label("Close existing open-ended period and create",-                                  systemImage: "arrow.triangle.swap")-                        }-                        .buttonStyle(.borderedProminent)-                    } footer: {-                        Text(-                            "This closes the existing open-ended period at the day before this start date, " +-                            "then creates the new period — all in one transaction."-                        )-                        .font(.footnote)-                        .foregroundStyle(.secondary)-                    }-                }-                if case .edit = viewModel.editorMode {-                    Section {-                        Button(role: .destructive) {-                            showingDeleteConfirmation = true-                        } label: {-                            Label("Delete pricing period", systemImage: "trash")-                                .foregroundStyle(.red)-                        }-                    }-                }+                remediationSection+                deleteSection             }             .navigationTitle(navigationTitle)             #if os(iOS)@@ -114,14 +57,14 @@ struct PricingEditor: View {                 }             }             .confirmationDialog(-                "Delete this pricing period?",+                "Delete this pricing plan?",                 isPresented: $showingDeleteConfirmation,                 titleVisibility: .visible             ) {                 Button("Delete", role: .destructive) {                     Task {-                        if case .edit(let period) = viewModel.editorMode {-                            try? await viewModel.delete(period)+                        if case .edit(let plan) = viewModel.editorMode {+                            try? await viewModel.delete(plan)                             dismiss()                         }                     }@@ -131,11 +74,126 @@ struct PricingEditor: View {         }     } +    // MARK: - Sections++    private var datesSection: some View {+        Section {+            DatePicker(+                "Start",+                selection: Binding(+                    get: { PricingEditor.parseDate(viewModel.draft.startDate) ?? Date() },+                    set: { viewModel.draft.startDate = PricingEditor.formatDate($0) }+                ),+                displayedComponents: .date+            )+            Toggle("Open-ended (no end date)", isOn: openEndedBinding)+            if viewModel.draft.endDate != nil {+                DatePicker(+                    "Ends",+                    selection: Binding(+                        get: {+                            PricingEditor.parseDate(+                                viewModel.draft.endDate ?? viewModel.draft.startDate+                            ) ?? Date()+                        },+                        set: { viewModel.draft.endDate = PricingEditor.formatDate($0) }+                    ),+                    displayedComponents: .date+                )+            }+        } header: {+            Text("Dates")+        } footer: {+            if viewModel.draft.endDate != nil {+                // The end date is exclusive (Decision 5) — spelling that out+                // here is what stops someone entering an off-by-one date.+                Text("The plan's last priced day is the day before this date; a successor starting on it takes over.")+            }+        }+    }++    private var ratesSection: some View {+        Section {+            rateField(label: "Default", value: $viewModel.draft.defaultRate)+            rateField(label: "Solar feed-in", value: $viewModel.draft.feedInRate)+            if hasFreeWindow {+                rateField(label: "Savings reference", value: savingsReferenceBinding)+            }+        } header: {+            Text("Rates (AUD per kWh)")+        } footer: {+            Text("The default rate applies whenever no window below covers the time of day.")+        }+    }++    private var windowsSection: some View {+        Section {+            ForEach(Array(viewModel.draft.windows.indices), id: \.self) { index in+                PricingWindowRow(viewModel: viewModel, index: index)+            }+            Button {+                viewModel.addWindow()+            } label: {+                Label("Add window", systemImage: "plus")+            }+        } header: {+            Text("Windows")+        } footer: {+            Text("Times outside every window are charged at the default rate. A plan can have one free window.")+        }+    }++    @ViewBuilder+    private var remediationSection: some View {+        if viewModel.overlapRemediationTargetId != nil {+            Section {+                Button {+                    Task {+                        do {+                            try await viewModel.remediateOverlap()+                            dismiss()+                        } catch {+                            // surfaces via lastValidationError+                        }+                    }+                } label: {+                    Label("Close existing open-ended plan and create",+                          systemImage: "arrow.triangle.swap")+                }+                .buttonStyle(.borderedProminent)+            } footer: {+                Text(PricingViewModel.remediationFooter(startDate: viewModel.draft.startDate))+                    .font(.footnote)+                    .foregroundStyle(.secondary)+            }+        }+    }++    @ViewBuilder+    private var deleteSection: some View {+        if case .edit = viewModel.editorMode {+            Section {+                Button(role: .destructive) {+                    showingDeleteConfirmation = true+                } label: {+                    Label("Delete pricing plan", systemImage: "trash")+                        .foregroundStyle(.red)+                }+            }+        }+    }++    // MARK: - Derived state+     private var navigationTitle: String {         if case .edit = viewModel.editorMode { return "Edit pricing" }         return "New pricing"     } +    private var hasFreeWindow: Bool {+        viewModel.draft.windows.contains(where: \.free)+    }+     private var openEndedBinding: Binding<Bool> {         Binding(             get: { viewModel.draft.endDate == nil },@@ -149,6 +207,16 @@ struct PricingEditor: View {         )     } +    /// The savings reference rate is absent on a plan with no free window. The+    /// field only shows when a free window exists, and writing to it always+    /// produces a value.+    private var savingsReferenceBinding: Binding<Double> {+        Binding(+            get: { viewModel.draft.savingsReferenceRate ?? 0 },+            set: { viewModel.draft.savingsReferenceRate = $0 }+        )+    }+     private var inlineValidationMessage: String? {         if let reason = viewModel.lastValidationError {             switch reason {@@ -165,6 +233,8 @@ struct PricingEditor: View {         return nil     } +    // MARK: - Field builders+     private func rateField(label: String, value: Binding<Double>) -> some View {         HStack {             Text(label)@@ -188,14 +258,24 @@ struct PricingEditor: View { // MARK: - Static helpers (exposed for tests)  extension PricingEditor {-    static func localValidationMessage(for error: PricingPeriodDraft.ValidationError) -> String {+    static func localValidationMessage(for error: PricingPlanDraft.ValidationError) -> String {         switch error {         case .invalidStartDate:             return "Enter a valid start date (YYYY-MM-DD)."         case .invalidEndDate:             return "Enter a valid end date (YYYY-MM-DD)."         case .invertedDates:-            return "End date must not be before the start date."+            return "The end date must be after the start date."+        case .bandWindowInvalid:+            return "Each window needs a start before its end, between 00:00 and 24:00."+        case .bandOverlap:+            return "Windows must not overlap each other."+        case .multipleFreeBands:+            return "A plan can have at most one free window."+        case .noRatedBand:+            return "A free window covering the whole day leaves nothing to price."+        case .savingsRateMissing:+            return "A plan with a free window needs a savings reference rate."         case .rateOutOfRange:             return "Each rate must be between $0.00 and $10.00 per kWh."         case .ratePrecision:@@ -212,11 +292,47 @@ extension PricingEditor {         isoDateFormatter.string(from: date)     } +    /// Band boundaries are times of day, so they are edited on an arbitrary+    /// reference date the formatter then discards.+    static let bandTimeReference: Date = {+        var components = DateComponents()+        components.year = 2000+        components.month = 1+        components.day = 1+        return bandCalendar.date(from: components) ?? Date(timeIntervalSince1970: 0)+    }()++    /// Converts a stored "HH:MM" boundary to a pickable time. "24:00" has no+    /// clock representation, so it is held as 23:59 and mapped back by+    /// `formatBandTime` — without that, a plan whose last window ends at+    /// midnight could not be opened in the editor.+    static func parseBandTime(_ value: String) -> Date? {+        guard let minutes = PlanWindow.parseBandTime(value) else { return nil }+        let clamped = min(minutes, PlanWindow.minutesPerDay - 1)+        return bandCalendar.date(byAdding: .minute, value: clamped, to: bandTimeReference)+    }++    static func formatBandTime(_ date: Date) -> String {+        let components = bandCalendar.dateComponents([.hour, .minute], from: date)+        let minutes = (components.hour ?? 0) * 60 + (components.minute ?? 0)+        // 23:59 is the picker's stand-in for end-of-day; see parseBandTime.+        if minutes == PlanWindow.minutesPerDay - 1 {+            return PlanWindow.formatBandTime(PlanWindow.minutesPerDay)+        }+        return PlanWindow.formatBandTime(minutes)+    }++    private static let bandCalendar: Calendar = {+        var calendar = Calendar(identifier: .iso8601)+        calendar.timeZone = DateFormatting.sydneyTimeZone+        return calendar+    }()+     private static let isoDateFormatter: DateFormatter = {         let formatter = DateFormatter()         formatter.calendar = Calendar(identifier: .iso8601)         formatter.dateFormat = "yyyy-MM-dd"-        formatter.timeZone = TimeZone(identifier: "Australia/Melbourne") ?? .current+        formatter.timeZone = DateFormatting.sydneyTimeZone         return formatter     }() }

diff --git a/Flux/Flux/Settings/Pricing/PricingPeriodsView.swift b/Flux/Flux/Settings/Pricing/PricingPeriodsView.swiftindex 40f2f1f..ab3e30e 100644--- a/Flux/Flux/Settings/Pricing/PricingPeriodsView.swift+++ b/Flux/Flux/Settings/Pricing/PricingPeriodsView.swift@@ -1,8 +1,9 @@ import FluxCore import SwiftUI -/// Shown from Settings → "Pricing". Lists configured pricing periods sorted-/// by start date ascending and offers add/edit/delete (Requirement 3).+/// Shown from Settings → "Pricing". Lists configured pricing plans sorted by+/// start date ascending and offers add/edit/delete. Each row shows the plan's+/// date range and the bands its rates apply over (AC 6.1). @MainActor struct PricingPeriodsView: View {     @State private var viewModel: PricingViewModel@@ -40,21 +41,21 @@ struct PricingPeriodsView: View {                 }             }             Section {-                if viewModel.periods.isEmpty {+                if viewModel.plans.isEmpty {                     emptyStateRow                 } else {-                    ForEach(viewModel.periods) { period in-                        periodRow(period)+                    ForEach(viewModel.plans) { plan in+                        planRow(plan)                     }                 }             } header: {-                Text("Periods")+                Text("Plans")             }             Section {                 Button {                     viewModel.beginCreate()                 } label: {-                    Label("Add pricing period", systemImage: "plus")+                    Label("Add pricing plan", systemImage: "plus")                 }             }         }@@ -67,14 +68,14 @@ struct PricingPeriodsView: View {                 if viewModel.showsErrorBanner {                     errorBanner                 }-                LiquidGlassSection(title: "Periods") {+                LiquidGlassSection(title: "Plans") {                     VStack(alignment: .leading, spacing: 8) {-                        if viewModel.periods.isEmpty {+                        if viewModel.plans.isEmpty {                             emptyStateRow                         } else {-                            ForEach(viewModel.periods) { period in-                                periodRow(period)-                                if period.id != viewModel.periods.last?.id {+                            ForEach(viewModel.plans) { plan in+                                planRow(plan)+                                if plan.id != viewModel.plans.last?.id {                                     Divider()                                 }                             }@@ -83,7 +84,7 @@ struct PricingPeriodsView: View {                         Button {                             viewModel.beginCreate()                         } label: {-                            Label("Add pricing period", systemImage: "plus")+                            Label("Add pricing plan", systemImage: "plus")                         }                     }                     .padding(8)@@ -115,21 +116,24 @@ struct PricingPeriodsView: View {         VStack(alignment: .leading, spacing: 4) {             Text("No pricing yet")                 .font(.body.weight(.semibold))-            Text("Add a pricing period to see daily costs on Day Detail and totals on History.")+            Text("Add a pricing plan to see daily costs on Day Detail and totals on History.")                 .font(.footnote)                 .foregroundStyle(.secondary)         }     }      @ViewBuilder-    private func periodRow(_ period: PricingPeriod) -> some View {+    private func planRow(_ plan: PricingPlan) -> some View {         Button {-            viewModel.beginEdit(period)+            viewModel.beginEdit(plan)         } label: {             VStack(alignment: .leading, spacing: 4) {-                Text(PricingPeriodsView.dateRangeText(for: period))+                Text(PricingPeriodsView.dateRangeText(for: plan))                     .font(.body.weight(.semibold))-                Text(PricingPeriodsView.rateSummary(for: period))+                Text(PricingPeriodsView.bandSummary(for: plan))+                    .font(.caption)+                    .foregroundStyle(.secondary)+                Text(PricingPeriodsView.feedInSummary(for: plan))                     .font(.caption)                     .foregroundStyle(.secondary)             }@@ -141,7 +145,7 @@ struct PricingPeriodsView: View {             Button(role: .destructive) {                 Task {                     do {-                        try await viewModel.delete(period)+                        try await viewModel.delete(plan)                     } catch {                         // PricingService.delete already recorded the error on                         // service.lastError before re-throwing; the@@ -161,27 +165,44 @@ struct PricingPeriodsView: View { // MARK: - Static formatters (exposed for unit tests)  extension PricingPeriodsView {-    static func dateRangeText(for period: PricingPeriod) -> String {-        if let end = period.endDate {-            return "\(period.startDate) – \(end)"+    /// The end date is exclusive (Decision 5): the plan's last priced day is+    /// the day before it. "until" says that; an inclusive-looking dash range+    /// would not.+    static func dateRangeText(for plan: PricingPlan) -> String {+        if let end = plan.endDate {+            return "\(plan.startDate) until \(end)"+        }+        return "from \(plan.startDate)"+    }++    /// The plan's bands as entered: the free window first (it is the one that+    /// changes behaviour elsewhere), then each rated exception, then the+    /// default rate that fills the rest of the day.+    static func bandSummary(for plan: PricingPlan) -> String {+        var parts: [String] = []+        if let free = plan.freeWindow {+            parts.append("Free \(free.start)–\(free.end)")+        }+        for window in plan.windows where !window.free {+            parts.append("\(formatRate(window.rate ?? 0)) \(window.start)–\(window.end)")         }-        return "from \(period.startDate)"+        parts.append("\(formatRate(plan.defaultRate)) default")+        return parts.joined(separator: " · ")     } -    static func rateSummary(for period: PricingPeriod) -> String {-        let peak = formatRate(period.peakRate)-        let feedIn = formatRate(period.feedInRate)-        let savings = formatRate(period.offPeakSavingsRate)-        return "Peak \(peak)/kWh · Feed-in \(feedIn)/kWh · Off-peak \(savings)/kWh"+    /// Feed-in is a single flat rate per plan, so it sits on its own line+    /// rather than competing with the import bands.+    static func feedInSummary(for plan: PricingPlan) -> String {+        "Feed-in \(formatRate(plan.feedInRate))/kWh"     }      static func formatRate(_ rate: Double) -> String {-        // 4dp rate display per AC 3.2 / Decision 10. Use a fixed format so+        // 4dp rate display (daily-costs Decision 10). Use a fixed format so         // the output is stable across locales.         String(format: "$%.4f", rate)     }      static let emptyStateTitle = "No pricing yet"-    static let emptyStateDetail = "Add a pricing period to see daily costs on Day Detail and totals on History."-    static let addButtonLabel = "Add pricing period"+    static let emptyStateDetail = "Add a pricing plan to see daily costs on Day Detail and totals on History."+    static let addButtonLabel = "Add pricing plan" }

diff --git a/Flux/Flux/Settings/Pricing/PricingViewModel.swift b/Flux/Flux/Settings/Pricing/PricingViewModel.swiftindex 5281bdc..9806d70 100644--- a/Flux/Flux/Settings/Pricing/PricingViewModel.swift+++ b/Flux/Flux/Settings/Pricing/PricingViewModel.swift@@ -9,10 +9,10 @@ import Foundation final class PricingViewModel {     enum EditorMode: Equatable {         case create-        case edit(PricingPeriod)+        case edit(PricingPlan)     } -    var draft: PricingPeriodDraft = PricingPeriodDraft()+    var draft: PricingPlanDraft = PricingPlanDraft()     private(set) var editorMode: EditorMode?      /// The last `PricingValidationReason` surfaced by a failed save. The@@ -20,8 +20,8 @@ final class PricingViewModel {     /// banner. Cleared on the next successful save.     private(set) var lastValidationError: PricingValidationReason? -    /// When the last create error was an overlap with the open-ended period,-    /// the editor offers a one-tap remediation button (AC 3.6).+    /// When the last create error was an overlap with the open-ended plan,+    /// the editor offers a one-tap remediation button (AC 6.5).     private(set) var overlapRemediationTargetId: String?      let service: PricingService@@ -30,7 +30,7 @@ final class PricingViewModel {         self.service = service     } -    var periods: [PricingPeriod] { service.periods }+    var plans: [PricingPlan] { service.plans }      var lastErrorMessage: String? {         guard let err = service.lastError else { return nil }@@ -64,27 +64,54 @@ final class PricingViewModel {     }      func beginCreate() {-        draft = PricingPeriodDraft()+        draft = PricingPlanDraft()         editorMode = .create         lastValidationError = nil         overlapRemediationTargetId = nil     } -    func beginEdit(_ period: PricingPeriod) {-        draft = PricingPeriodDraft(period: period)-        editorMode = .edit(period)+    func beginEdit(_ plan: PricingPlan) {+        draft = PricingPlanDraft(plan: plan)+        editorMode = .edit(plan)         lastValidationError = nil         overlapRemediationTargetId = nil     } +    // MARK: - Window editing++    /// Appends a rated window seeded from the plan's default rate — the+    /// starting point for "this stretch costs something other than the norm".+    /// A free window is one toggle away.+    func addWindow() {+        draft.windows.append(+            PlanWindow(start: "00:00", end: "01:00", free: false, rate: draft.defaultRate)+        )+    }++    func removeWindow(at index: Int) {+        guard draft.windows.indices.contains(index) else { return }+        draft.windows.remove(at: index)+    }++    /// Toggles a window between free and rated. A free window carries no rate+    /// by contract, so the rate is dropped on the way in and re-seeded from the+    /// default rate on the way out rather than resurrecting a stale value.+    func setWindowFree(_ free: Bool, at index: Int) {+        guard draft.windows.indices.contains(index) else { return }+        draft.windows[index].free = free+        draft.windows[index].rate = free ? nil : draft.defaultRate+    }++    // MARK: - Persistence+     func save() async throws {         guard let mode = editorMode else { return }         do {             switch mode {             case .create:-                _ = try await service.create(normalisedDraft())+                _ = try await service.create(draft.normalised())             case .edit(let existing):-                _ = try await service.update(id: existing.id, normalisedDraft())+                _ = try await service.update(id: existing.id, draft.normalised())             }             editorMode = nil             lastValidationError = nil@@ -100,17 +127,18 @@ final class PricingViewModel {         }     } -    func delete(_ period: PricingPeriod) async throws {-        try await service.delete(id: period.id)+    func delete(_ plan: PricingPlan) async throws {+        try await service.delete(id: plan.id)     } -    /// One-tap remediation for the AC 3.6 flow. Closes the open-ended period-    /// at `draft.startDate − 1 day` and creates the new period in a single-    /// transactional request.+    /// One-tap remediation for the AC 6.5 flow. Ends the open-ended plan ON the+    /// new plan's start date and creates the successor, in a single+    /// transactional request. Under exclusive end dates both rows carry the+    /// same literal date and the switch day belongs to the successor (AC 2.2).     func remediateOverlap() async throws {         guard let closingId = overlapRemediationTargetId else { return }         do {-            _ = try await service.replaceOpenEnded(closingId: closingId, with: normalisedDraft())+            _ = try await service.replaceOpenEnded(closingId: closingId, with: draft.normalised())             editorMode = nil             lastValidationError = nil             overlapRemediationTargetId = nil@@ -127,15 +155,11 @@ final class PricingViewModel {         service.clearError()     } -    private func normalisedDraft() -> PricingPeriodDraft {-        // Persist rates at exactly four decimals so the wire payload matches-        // backend storage precision (Decision 10/20).-        PricingPeriodDraft(-            startDate: draft.startDate,-            endDate: draft.endDate,-            peakRate: PricingPeriodDraft.roundedToFourDP(draft.peakRate),-            feedInRate: PricingPeriodDraft.roundedToFourDP(draft.feedInRate),-            offPeakSavingsRate: PricingPeriodDraft.roundedToFourDP(draft.offPeakSavingsRate)-        )+    /// Explanatory copy under the remediation button. Phrased around the switch+    /// day rather than "the day before this start date": the predecessor now+    /// ends ON this date and the successor prices it (AC 6.5).+    static func remediationFooter(startDate: String) -> String {+        "This ends the existing open-ended plan on \(startDate) and starts the new one that same day — "+            + "all in one transaction."     } }

diff --git a/Flux/Flux/Settings/Pricing/PricingWindowRow.swift b/Flux/Flux/Settings/Pricing/PricingWindowRow.swiftnew file mode 100644index 0000000..cdc9a13--- /dev/null+++ b/Flux/Flux/Settings/Pricing/PricingWindowRow.swift@@ -0,0 +1,91 @@+import FluxCore+import SwiftUI++/// One exception window in the pricing editor: its boundaries, whether it is+/// free, and — when it isn't — the rate it carries. Extracted from+/// `PricingEditor` so the sheet stays readable as the number of sections grew.+@MainActor+struct PricingWindowRow: View {+    @Bindable var viewModel: PricingViewModel+    let index: Int++    var body: some View {+        VStack(spacing: 8) {+            HStack {+                bandTimePicker(label: "From", isStart: true)+                Spacer(minLength: 12)+                bandTimePicker(label: "To", isStart: false)+            }+            Toggle("Free", isOn: Binding(+                get: { window?.free ?? false },+                set: { viewModel.setWindowFree($0, at: index) }+            ))+            if window?.free == false {+                rateField+            }+            Button(role: .destructive) {+                viewModel.removeWindow(at: index)+            } label: {+                Label("Remove window", systemImage: "minus.circle")+                    .font(.footnote)+            }+            .frame(maxWidth: .infinity, alignment: .leading)+        }+        .padding(.vertical, 4)+    }++    /// Nil while SwiftUI is still rendering a row whose window has just been+    /// removed — reading the array directly would trap on the stale index.+    private var window: PlanWindow? {+        viewModel.draft.windows.indices.contains(index) ? viewModel.draft.windows[index] : nil+    }++    private var rateField: some View {+        HStack {+            Text("Rate")+            Spacer()+            TextField(+                "0.0000",+                value: Binding(+                    get: { window?.rate ?? 0 },+                    set: { newValue in+                        guard viewModel.draft.windows.indices.contains(index) else { return }+                        viewModel.draft.windows[index].rate = newValue+                    }+                ),+                format: .number.precision(.fractionLength(4))+            )+            #if os(iOS)+            .keyboardType(.decimalPad)+            #endif+            .multilineTextAlignment(.trailing)+            .frame(maxWidth: 120)+            Text("/ kWh")+                .foregroundStyle(.secondary)+        }+    }++    private func bandTimePicker(label: String, isStart: Bool) -> some View {+        DatePicker(+            label,+            selection: Binding(+                get: {+                    let value = isStart ? window?.start : window?.end+                    return value.flatMap(PricingEditor.parseBandTime) ?? PricingEditor.bandTimeReference+                },+                set: { newValue in+                    guard viewModel.draft.windows.indices.contains(index) else { return }+                    let formatted = PricingEditor.formatBandTime(newValue)+                    if isStart {+                        viewModel.draft.windows[index].start = formatted+                    } else {+                        viewModel.draft.windows[index].end = formatted+                    }+                }+            ),+            displayedComponents: .hourAndMinute+        )+        .labelsHidden()+        .accessibilityLabel("\(label) time")+    }+}

diff --git a/Flux/FluxTests/Charts/DayChartExpansionTests.swift b/Flux/FluxTests/Charts/DayChartExpansionTests.swiftindex a7f7c40..b782998 100644--- a/Flux/FluxTests/Charts/DayChartExpansionTests.swift+++ b/Flux/FluxTests/Charts/DayChartExpansionTests.swift@@ -23,7 +23,7 @@ struct DayChartExpansionTests {             Issue.record("Failed to parse fixture date string")             return         }-        let view = PowerChartView(date: dateString, readings: [], selectedDate: .constant(nil))+        let view = PowerChartView(date: dateString, readings: [], offpeakWindow: nil, selectedDate: .constant(nil))         #expect(view.expansionScope == .daySpecific(date: expected))     } @@ -38,6 +38,7 @@ struct DayChartExpansionTests {             date: dateString,             readings: [],             summary: nil,+            offpeakWindow: nil,             selectedDate: .constant(nil)         )         #expect(view.expansionScope == .daySpecific(date: expected))@@ -45,8 +46,8 @@ struct DayChartExpansionTests {      @Test("Different date strings produce distinct expansion scopes")     func differentDatesProduceDistinctScopes() {-        let first = PowerChartView(date: "2026-05-01", readings: [], selectedDate: .constant(nil))-        let second = PowerChartView(date: "2026-05-02", readings: [], selectedDate: .constant(nil))+        let first = PowerChartView(date: "2026-05-01", readings: [], offpeakWindow: nil, selectedDate: .constant(nil))+        let second = PowerChartView(date: "2026-05-02", readings: [], offpeakWindow: nil, selectedDate: .constant(nil))         #expect(first.expansionScope != second.expansionScope)     } }

diff --git a/Flux/FluxTests/PricingCostWiringTests.swift b/Flux/FluxTests/PricingCostWiringTests.swiftnew file mode 100644index 0000000..fc72a26--- /dev/null+++ b/Flux/FluxTests/PricingCostWiringTests.swift@@ -0,0 +1,318 @@+import FluxCore+import Foundation+import SwiftData+import Testing+@testable import Flux++/// The view models are the join point between the wire payloads and the cost+/// helper: they must hand over the band split, the off-peak row's geometry and+/// provenance, and the plan pricing the day. Anything dropped here silently+/// degrades a banded day to the fallback tier, so these tests assert on the+/// resolved tier, not just the numbers.+@MainActor @Suite(.serialized)+struct PricingCostWiringTests {+    // MARK: - Day Detail++    @Test+    func dayDetailPricesABandedDayFromTheStoredSplit() async throws {+        let apiClient = MockCostWiringAPIClient()+        apiClient.dayResponse = DayDetailResponse(+            date: "2026-08-15",+            readings: [],+            summary: bandedSummary(),+            peakPeriods: nil,+            dailyUsage: nil+        )+        let (viewModel, service) = try await makeDayDetail(date: "2026-08-15", apiClient: apiClient)+        await viewModel.loadDay()+        _ = service++        let costs = try #require(viewModel.costs)+        #expect(costs.tier == .banded, "the split, the off-peak row and the plan must all reach the helper")+        #expect(abs(costs.peakImportsCost - (1 * 0.35 + 4 * 0.28 + 2 * 0.35 + 8 * 0.35)) < 1e-9)+        #expect(abs(costs.offPeakSavings - 3 * 0.35) < 1e-9)+    }++    @Test+    func dayDetailFallsBackWhenTheSplitWasCapturedUnderAnotherWindow() async throws {+        let apiClient = MockCostWiringAPIClient()+        var summary = bandedSummary()+        // The off-peak row still carries the previous free window, so its+        // import cannot price this plan's free band (Q16).+        summary = DaySummary(+            epv: nil, eInput: 23, eOutput: 15,+            eCharge: nil, eDischarge: nil, socLow: nil, socLowTime: nil,+            offpeakGridImportKwh: 3,+            bandImports: summary.bandImports,+            offpeakWindowStart: "11:00",+            offpeakWindowEnd: "14:00",+            offpeakIntegratedAt: "2026-08-16T05:00:00Z",+            offpeakSampleCount: 1500+        )+        apiClient.dayResponse = DayDetailResponse(+            date: "2026-08-15", readings: [], summary: summary, peakPeriods: nil, dailyUsage: nil+        )+        let (viewModel, _) = try await makeDayDetail(date: "2026-08-15", apiClient: apiClient)+        await viewModel.loadDay()++        let costs = try #require(viewModel.costs)+        #expect(costs.tier == .fallback)+    }++    @Test+    func dayDetailHasNoCostsForAnUnpricedDay() async throws {+        let apiClient = MockCostWiringAPIClient()+        apiClient.dayResponse = DayDetailResponse(+            date: "2020-01-01", readings: [], summary: bandedSummary(), peakPeriods: nil, dailyUsage: nil+        )+        let (viewModel, _) = try await makeDayDetail(date: "2020-01-01", apiClient: apiClient)+        await viewModel.loadDay()+        #expect(viewModel.costs == nil, "days no plan covers show no cost data (AC 2.7)")+    }++    @Test+    func dayDetailTakesItsFreeWindowFromThePlanPricingThatDay() async throws {+        let apiClient = MockCostWiringAPIClient()+        let (switchDay, _) = try await makeDayDetail(date: "2026-08-01", apiClient: apiClient)+        #expect(switchDay.offpeakWindow?.start == "10:00")+        #expect(switchDay.offpeakWindow?.end == "15:00")++        let (switchEve, _) = try await makeDayDetail(date: "2026-07-31", apiClient: apiClient)+        #expect(switchEve.offpeakWindow?.start == "11:00")+        #expect(switchEve.offpeakWindow?.end == "14:00")+    }++    @Test+    func anUnpricedDayGetsNoWindowRatherThanADefault() async throws {+        let apiClient = MockCostWiringAPIClient()+        let (viewModel, _) = try await makeDayDetail(date: "2020-01-01", apiClient: apiClient)+        #expect(viewModel.offpeakWindow == nil, "no plan means no window, never a substituted default")+    }++    // MARK: - History++    @Test+    func historyPricesEachDayUnderItsOwnPlanAcrossASwitchDate() async throws {+        let apiClient = MockCostWiringAPIClient()+        apiClient.historyResponse = HistoryResponse(days: [+            day(date: "2026-07-31", eInput: 10),+            day(date: "2026-08-01", eInput: 10)+        ])+        let (viewModel, _) = try await makeHistory(apiClient: apiClient)+        await viewModel.loadHistory(range: .days(7))++        let costs = try #require(viewModel.periodCosts)+        #expect(costs.pricedDayCount == 2)+        // Predecessor rate 0.2873 on the 31st, successor's highest rate 0.35+        // (fallback: multi-rate plan with no split) on the switch day.+        #expect(abs(costs.peakImportsCost - (10 * 0.2873 + 10 * 0.35)) < 1e-9)+    }++    @Test+    func historyRetainsThePartialCoverageCount() async throws {+        let apiClient = MockCostWiringAPIClient()+        apiClient.historyResponse = HistoryResponse(days: [+            day(date: "2026-08-01", eInput: 10),+            day(date: "2020-01-01", eInput: 10),+            day(date: "2020-01-02", eInput: 10)+        ])+        let (viewModel, _) = try await makeHistory(apiClient: apiClient)+        await viewModel.loadHistory(range: .days(7))++        let costs = try #require(viewModel.periodCosts)+        #expect(costs.pricedDayCount == 1)+        #expect(costs.totalDayCount == 3)+        #expect(costs.hasPartialCoverage, "AC 3.7's N of M days priced caption must survive")+    }++    @Test+    func historyPricesABandedDayFromTheStoredSplit() async throws {+        let apiClient = MockCostWiringAPIClient()+        apiClient.historyResponse = HistoryResponse(days: [bandedDay()])+        let (viewModel, _) = try await makeHistory(apiClient: apiClient)+        await viewModel.loadHistory(range: .days(7))++        let costs = try #require(viewModel.periodCosts)+        #expect(abs(costs.peakImportsCost - (1 * 0.35 + 4 * 0.28 + 2 * 0.35 + 8 * 0.35)) < 1e-9)+        #expect(abs(costs.offPeakSavings - 3 * 0.35) < 1e-9)+    }++    // MARK: - Data consistency++    @Test+    func dayDetailAndHistoryReportTheSameCostForTheSameDay() async throws {+        let dayClient = MockCostWiringAPIClient()+        dayClient.dayResponse = DayDetailResponse(+            date: "2026-08-15", readings: [], summary: bandedSummary(), peakPeriods: nil, dailyUsage: nil+        )+        let (dayViewModel, _) = try await makeDayDetail(date: "2026-08-15", apiClient: dayClient)+        await dayViewModel.loadDay()++        let historyClient = MockCostWiringAPIClient()+        historyClient.historyResponse = HistoryResponse(days: [bandedDay()])+        let (historyViewModel, _) = try await makeHistory(apiClient: historyClient)+        await historyViewModel.loadHistory(range: .days(7))++        let dayCosts = try #require(dayViewModel.costs)+        let periodCosts = try #require(historyViewModel.periodCosts)+        #expect(abs(dayCosts.peakImportsCost - periodCosts.peakImportsCost) < 1e-9)+        #expect(abs(dayCosts.solarFeedInIncome - periodCosts.solarFeedInIncome) < 1e-9)+        #expect(abs(dayCosts.net - periodCosts.net) < 1e-9)+        #expect(abs(dayCosts.offPeakSavings - periodCosts.offPeakSavings) < 1e-9)+    }++    @Test+    func aCachedDayKeepsItsBandSplitSoOfflineCostsMatchTheLiveOnes() throws {+        // History falls back to the SwiftData cache when a fetch fails. If the+        // cache drops the split or the off-peak row's geometry, the same day+        // silently reprices at the fallback tier the moment the network blips.+        let live = bandedDay()+        let restored = CachedDayEnergy(from: live).asDayEnergy++        #expect(restored.bandImports == live.bandImports)+        #expect(restored.offpeakWindowStart == live.offpeakWindowStart)+        #expect(restored.offpeakWindowEnd == live.offpeakWindowEnd)+        #expect(restored.offpeakIntegratedAt == live.offpeakIntegratedAt)+        #expect(restored.offpeakSampleCount == live.offpeakSampleCount)++        let liveCosts = try #require(live.costs(in: Self.plans))+        let offlineCosts = try #require(restored.costs(in: Self.plans))+        #expect(liveCosts == offlineCosts)+        #expect(offlineCosts.tier == .banded)+    }++    // MARK: - Fixtures++    /// The plans either side of the switch date: the migrated single-rate plan+    /// until 2026-08-01, the time-of-use plan from it.+    private static let plans: [PricingPlan] = [+        PricingPlan(+            id: "old", startDate: "2026-01-01", endDate: "2026-08-01",+            defaultRate: 0.2873,+            windows: [PlanWindow(start: "11:00", end: "14:00", free: true, rate: nil)],+            feedInRate: 0.05, savingsReferenceRate: 0.2873,+            createdAt: Date(timeIntervalSince1970: 1), updatedAt: Date(timeIntervalSince1970: 1)+        ),+        PricingPlan(+            id: "new", startDate: "2026-08-01", endDate: nil,+            defaultRate: 0.35,+            windows: [+                PlanWindow(start: "10:00", end: "15:00", free: true, rate: nil),+                PlanWindow(start: "01:00", end: "06:00", free: false, rate: 0.28)+            ],+            feedInRate: 0.05, savingsReferenceRate: 0.35,+            createdAt: Date(timeIntervalSince1970: 1), updatedAt: Date(timeIntervalSince1970: 1)+        )+    ]++    private static let split = [+        BandImport(start: "00:00", end: "01:00", kwh: 1),+        BandImport(start: "01:00", end: "06:00", kwh: 4),+        BandImport(start: "06:00", end: "10:00", kwh: 2),+        BandImport(start: "15:00", end: "24:00", kwh: 8)+    ]++    private func bandedSummary() -> DaySummary {+        DaySummary(+            epv: nil, eInput: 23, eOutput: 15,+            eCharge: nil, eDischarge: nil, socLow: nil, socLowTime: nil,+            offpeakGridImportKwh: 3,+            bandImports: Self.split,+            offpeakWindowStart: "10:00",+            offpeakWindowEnd: "15:00",+            offpeakIntegratedAt: "2026-08-16T05:00:00Z",+            offpeakSampleCount: 1500+        )+    }++    private func bandedDay() -> DayEnergy {+        DayEnergy(+            date: "2026-08-15",+            epv: 0, eInput: 23, eOutput: 15, eCharge: 0, eDischarge: 0,+            offpeakGridImportKwh: 3,+            bandImports: Self.split,+            offpeakWindowStart: "10:00",+            offpeakWindowEnd: "15:00",+            offpeakIntegratedAt: "2026-08-16T05:00:00Z",+            offpeakSampleCount: 1500,+            note: nil+        )+    }++    private func day(date: String, eInput: Double) -> DayEnergy {+        DayEnergy(+            date: date,+            epv: 0, eInput: eInput, eOutput: 0, eCharge: 0, eDischarge: 0,+            note: nil+        )+    }++    private func makePricingService(apiClient: MockCostWiringAPIClient) async -> PricingService {+        let service = PricingService()+        service.bind(apiClient: apiClient)+        try? await service.refresh()+        return service+    }++    private func makeDayDetail(+        date: String,+        apiClient: MockCostWiringAPIClient+    ) async throws -> (DayDetailViewModel, PricingService) {+        apiClient.plansToReturn = Self.plans+        let service = await makePricingService(apiClient: apiClient)+        return (DayDetailViewModel(date: date, apiClient: apiClient, pricingService: service), service)+    }++    private func makeHistory(+        apiClient: MockCostWiringAPIClient+    ) async throws -> (HistoryViewModel, PricingService) {+        apiClient.plansToReturn = Self.plans+        let service = await makePricingService(apiClient: apiClient)+        let configuration = ModelConfiguration(isStoredInMemoryOnly: true)+        let container = try ModelContainer(for: CachedDayEnergy.self, configurations: configuration)+        let context = ModelContext(container)+        let viewModel = HistoryViewModel(+            apiClient: apiClient,+            modelContext: context,+            pricingService: service+        )+        return (viewModel, service)+    }+}++// MARK: - test double++private final class MockCostWiringAPIClient: FluxAPIClient, @unchecked Sendable {+    var plansToReturn: [PricingPlan] = []+    var dayResponse: DayDetailResponse?+    var historyResponse: HistoryResponse?++    func fetchStatus() async throws -> StatusResponse {+        StatusResponse(live: nil, battery: nil, rolling15min: nil, offpeak: nil, todayEnergy: nil, note: nil)+    }++    func fetchHistory(days _: Int) async throws -> HistoryResponse {+        guard let historyResponse else { throw FluxAPIError.notConfigured }+        return historyResponse+    }++    func fetchHistory(query _: HistoryQuery) async throws -> HistoryResponse {+        guard let historyResponse else { throw FluxAPIError.notConfigured }+        return historyResponse+    }++    func fetchDay(date: String) async throws -> DayDetailResponse {+        guard let dayResponse else {+            return DayDetailResponse(+                date: date, readings: [], summary: nil, peakPeriods: nil, dailyUsage: nil+            )+        }+        return dayResponse+    }++    func saveNote(date: String, text _: String) async throws -> NoteResponse {+        NoteResponse(date: date, text: "", updatedAt: nil)+    }++    func fetchPricing() async throws -> [PricingPlan] { plansToReturn }+}

diff --git a/Flux/FluxTests/Settings/PricingEditorTests.swift b/Flux/FluxTests/Settings/PricingEditorTests.swiftindex 88b9650..990f79f 100644--- a/Flux/FluxTests/Settings/PricingEditorTests.swift+++ b/Flux/FluxTests/Settings/PricingEditorTests.swift@@ -10,18 +10,36 @@ import Testing struct PricingEditorTests {     @Test     func localValidationMessagesNameTheOffendingField() throws {-        #expect(PricingEditor.localValidationMessage(for: .invertedDates).contains("End date"))+        #expect(PricingEditor.localValidationMessage(for: .invertedDates).contains("end date"))         #expect(PricingEditor.localValidationMessage(for: .ratePrecision).contains("four decimal"))         #expect(PricingEditor.localValidationMessage(for: .rateOutOfRange).contains("$0.00"))         #expect(PricingEditor.localValidationMessage(for: .invalidStartDate).contains("YYYY-MM-DD"))     } +    @Test+    func everyLocalValidationErrorHasAMessage() {+        let errors: [PricingPlanDraft.ValidationError] = [+            .invalidStartDate, .invalidEndDate, .invertedDates,+            .bandWindowInvalid, .bandOverlap, .multipleFreeBands,+            .noRatedBand, .savingsRateMissing, .rateOutOfRange, .ratePrecision+        ]+        for error in errors {+            #expect(!PricingEditor.localValidationMessage(for: error).isEmpty, "\(error)")+        }+    }++    @Test+    func bandValidationMessagesDescribeTheBandRule() {+        #expect(PricingEditor.localValidationMessage(for: .bandOverlap).lowercased().contains("overlap"))+        #expect(PricingEditor.localValidationMessage(for: .multipleFreeBands).lowercased().contains("free"))+        #expect(PricingEditor.localValidationMessage(for: .savingsRateMissing).lowercased().contains("savings"))+    }+     @Test     func dateRoundTripFormatsAsISO() throws {         let date = PricingEditor.parseDate("2026-04-15")         let unwrapped = try #require(date)-        let formatted = PricingEditor.formatDate(unwrapped)-        #expect(formatted == "2026-04-15")+        #expect(PricingEditor.formatDate(unwrapped) == "2026-04-15")     }      @Test@@ -29,41 +47,55 @@ struct PricingEditorTests {         #expect(PricingEditor.parseDate("") == nil)     } -    // MARK: - Editor mode via ViewModel+    // MARK: - Band time pickers++    @Test+    func bandTimeRoundTripsThroughTheTimePicker() throws {+        let date = try #require(PricingEditor.parseBandTime("10:30"))+        #expect(PricingEditor.formatBandTime(date) == "10:30")+    }++    @Test+    func endOfDayRoundTripsAsTwentyFourHundred() throws {+        // 24:00 has no clock representation, so the picker holds it as 23:59+        // and the formatter maps that one minute back to end-of-day. Without+        // this a plan whose last window ends at midnight could not be edited.+        let date = try #require(PricingEditor.parseBandTime("24:00"))+        #expect(PricingEditor.formatBandTime(date) == "24:00")+    }++    @Test+    func parseBandTimeRejectsMalformedInput() {+        #expect(PricingEditor.parseBandTime("nonsense") == nil)+        #expect(PricingEditor.parseBandTime("") == nil)+    }++    // MARK: - Draft validation through the editor      @Test     func draftValidatesOnTypicalCreateInputs() throws {-        let draft = PricingPeriodDraft(+        let draft = PricingPlanDraft(             startDate: "2026-08-01",             endDate: nil,-            peakRate: 0.2873,+            defaultRate: 0.2873,+            windows: [PlanWindow(start: "10:00", end: "15:00", free: true, rate: nil)],             feedInRate: 0.05,-            offPeakSavingsRate: 0.12+            savingsReferenceRate: 0.12         )         #expect(draft.validate() == nil)     }      @Test     func draftRejectsRatePrecisionGreaterThan4DP() throws {-        let draft = PricingPeriodDraft(-            startDate: "2026-08-01",-            endDate: nil,-            peakRate: 0.123456,-            feedInRate: 0.05,-            offPeakSavingsRate: 0.12-        )+        var draft = makeDraft()+        draft.defaultRate = 0.123456         #expect(draft.validate() == .ratePrecision)     }      @Test     func draftRejectsRateOutOfRange() throws {-        let draft = PricingPeriodDraft(-            startDate: "2026-08-01",-            endDate: nil,-            peakRate: 11.0,-            feedInRate: 0.05,-            offPeakSavingsRate: 0.12-        )+        var draft = makeDraft()+        draft.defaultRate = 11.0         #expect(draft.validate() == .rateOutOfRange)     } @@ -75,15 +107,20 @@ struct PricingEditorTests {         service.bind(apiClient: apiClient)         let viewModel = PricingViewModel(service: service)         viewModel.beginCreate()-        viewModel.draft = PricingPeriodDraft(+        viewModel.draft = makeDraft()+        try? await viewModel.save()+        #expect(viewModel.overlapRemediationTargetId == "pp-open")+        #expect(viewModel.lastValidationError == .overlap(openEndedId: "pp-open"))+    }++    private func makeDraft() -> PricingPlanDraft {+        PricingPlanDraft(             startDate: "2026-08-01",             endDate: nil,-            peakRate: 0.30,+            defaultRate: 0.30,+            windows: [PlanWindow(start: "10:00", end: "15:00", free: true, rate: nil)],             feedInRate: 0.06,-            offPeakSavingsRate: 0.12+            savingsReferenceRate: 0.12         )-        try? await viewModel.save()-        #expect(viewModel.overlapRemediationTargetId == "pp-open")-        #expect(viewModel.lastValidationError == .overlap(openEndedId: "pp-open"))     } }

diff --git a/Flux/FluxTests/Settings/PricingPeriodsViewTests.swift b/Flux/FluxTests/Settings/PricingPeriodsViewTests.swiftindex 65b5902..53b212a 100644--- a/Flux/FluxTests/Settings/PricingPeriodsViewTests.swift+++ b/Flux/FluxTests/Settings/PricingPeriodsViewTests.swift@@ -4,43 +4,76 @@ import Testing @testable import Flux  /// Lightweight view-state tests for PricingPeriodsView. The project has no-/// snapshot-test framework wired up (per the task brief), so these tests-/// assert on the static helpers that drive the view's text content rather-/// than rendering view trees.+/// snapshot-test framework wired up, so these tests assert on the static+/// helpers that drive the view's text content rather than rendering view trees. @MainActor @Suite struct PricingPeriodsViewTests {     @Test-    func closedPeriodFormatsAsStartEnd() {-        let period = makePeriod(start: "2026-01-01", end: "2026-06-30")-        #expect(PricingPeriodsView.dateRangeText(for: period) == "2026-01-01 – 2026-06-30")+    func closedPlanFormatsAsStartUntilEnd() {+        // The end date is exclusive (Decision 5), so the range reads as+        // "until" rather than an inclusive dash range that would look like+        // the plan prices the switch day.+        let plan = makePlan(start: "2026-01-01", end: "2026-08-01")+        #expect(PricingPeriodsView.dateRangeText(for: plan) == "2026-01-01 until 2026-08-01")     }      @Test-    func openEndedPeriodFormatsAsFromStart() {-        let period = makePeriod(start: "2026-07-01", end: nil)-        #expect(PricingPeriodsView.dateRangeText(for: period) == "from 2026-07-01")+    func openEndedPlanFormatsAsFromStart() {+        let plan = makePlan(start: "2026-07-01", end: nil)+        #expect(PricingPeriodsView.dateRangeText(for: plan) == "from 2026-07-01")+    }++    // MARK: - Band summary (AC 6.1)++    @Test+    func bandSummaryListsTheFreeWindowThenExceptionsThenTheDefault() {+        let plan = makePlan(+            start: "2026-08-01",+            end: nil,+            defaultRate: 0.35,+            windows: [+                PlanWindow(start: "10:00", end: "15:00", free: true, rate: nil),+                PlanWindow(start: "01:00", end: "06:00", free: false, rate: 0.28)+            ],+            savings: 0.35+        )+        let summary = PricingPeriodsView.bandSummary(for: plan)+        #expect(summary == "Free 10:00–15:00 · $0.2800 01:00–06:00 · $0.3500 default")+    }++    @Test+    func bandSummaryOfAFlatPlanIsJustTheDefaultRate() {+        let plan = makePlan(start: "2026-01-01", end: nil, defaultRate: 0.35, windows: [], savings: nil)+        #expect(PricingPeriodsView.bandSummary(for: plan) == "$0.3500 default")     }      @Test-    func rateSummaryUsesFourDecimalPlaces() {-        let period = makePeriod(start: "2026-01-01", end: nil, peak: 0.2873, feedIn: 0.05, offPeak: 0.1234)-        let summary = PricingPeriodsView.rateSummary(for: period)-        #expect(summary.contains("$0.2873"))-        #expect(summary.contains("$0.0500"))-        #expect(summary.contains("$0.1234"))+    func bandSummaryOfAMigratedPlanNamesItsFreeWindow() {+        let plan = makePlan(+            start: "2026-01-01",+            end: nil,+            defaultRate: 0.2873,+            windows: [PlanWindow(start: "11:00", end: "14:00", free: true, rate: nil)],+            savings: 0.2873+        )+        #expect(PricingPeriodsView.bandSummary(for: plan) == "Free 11:00–14:00 · $0.2873 default")     }      @Test     func formatRateAlwaysShowsFourDecimalPlaces() {         #expect(PricingPeriodsView.formatRate(0.05) == "$0.0500")-        #expect(PricingPeriodsView.formatRate(0.123456) == "$0.1235",-                "rounds to 4 decimal places")+        #expect(PricingPeriodsView.formatRate(0.123456) == "$0.1235", "rounds to 4 decimal places")         #expect(PricingPeriodsView.formatRate(0) == "$0.0000")     } +    @Test+    func feedInSummaryIsShownSeparatelyFromTheImportBands() {+        let plan = makePlan(start: "2026-01-01", end: nil, defaultRate: 0.35, windows: [], savings: nil)+        #expect(PricingPeriodsView.feedInSummary(for: plan).contains("$0.0500"))+    }+     @Test     func emptyStateCopyNamesUnlockedFeatures() {-        // AC 3.8 — empty state names what the feature unlocks.         let detail = PricingPeriodsView.emptyStateDetail         #expect(detail.contains("Day Detail"))         #expect(detail.contains("History"))@@ -49,36 +82,37 @@ struct PricingPeriodsViewTests {     // MARK: - sorted state via ViewModel      @Test-    func viewModelExposesPeriodsSortedAscending() async {+    func viewModelExposesPlansSortedAscending() async {         let apiClient = TestPricingAPIClient()-        apiClient.periodsToReturn = [-            makePeriod(id: "newer", start: "2026-07-01", end: nil),-            makePeriod(id: "older", start: "2026-01-01", end: "2026-06-30")+        apiClient.plansToReturn = [+            makePlan(id: "newer", start: "2026-07-01", end: nil),+            makePlan(id: "older", start: "2026-01-01", end: "2026-07-01")         ]         let service = PricingService()         service.bind(apiClient: apiClient)         let viewModel = PricingViewModel(service: service)         await viewModel.refresh()-        #expect(viewModel.periods.map(\.id) == ["older", "newer"])+        #expect(viewModel.plans.map(\.id) == ["older", "newer"])     }      // MARK: - helpers -    private func makePeriod(+    private func makePlan(         id: String = "p",         start: String,         end: String?,-        peak: Double = 0.30,-        feedIn: Double = 0.05,-        offPeak: Double = 0.12-    ) -> PricingPeriod {-        PricingPeriod(+        defaultRate: Double = 0.30,+        windows: [PlanWindow] = [PlanWindow(start: "11:00", end: "14:00", free: true, rate: nil)],+        savings: Double? = 0.12+    ) -> PricingPlan {+        PricingPlan(             id: id,             startDate: start,             endDate: end,-            peakRate: peak,-            feedInRate: feedIn,-            offPeakSavingsRate: offPeak,+            defaultRate: defaultRate,+            windows: windows,+            feedInRate: 0.05,+            savingsReferenceRate: savings,             createdAt: Date(timeIntervalSince1970: 1),             updatedAt: Date(timeIntervalSince1970: 1)         )

diff --git a/Flux/FluxTests/Settings/PricingViewModelTests.swift b/Flux/FluxTests/Settings/PricingViewModelTests.swiftindex 4f52d27..b32fbc4 100644--- a/Flux/FluxTests/Settings/PricingViewModelTests.swift+++ b/Flux/FluxTests/Settings/PricingViewModelTests.swift@@ -3,39 +3,44 @@ import Foundation import Testing @testable import Flux +// swiftlint:disable file_length type_body_length @MainActor @Suite(.serialized) struct PricingViewModelTests {     @Test-    func refreshLoadsPeriodsFromService() async throws {+    func refreshLoadsPlansFromService() async throws {         let (viewModel, apiClient) = makeViewModelAndAPI()-        apiClient.periodsToReturn = [makePeriod(id: "p1", start: "2026-01-01", end: "2026-06-30")]+        apiClient.plansToReturn = [makePlan(id: "p1", start: "2026-01-01", end: "2026-07-01")]         await viewModel.refresh()-        #expect(viewModel.periods.count == 1)-        #expect(viewModel.periods.first?.id == "p1")+        #expect(viewModel.plans.count == 1)+        #expect(viewModel.plans.first?.id == "p1")     }      @Test-    func beginCreateSeedsBlankDraft() {+    func beginCreateSeedsADraftWithTheCurrentFreeWindow() {         let (viewModel, _) = makeViewModelAndAPI()         viewModel.beginCreate()         #expect(viewModel.isEditorPresented)         #expect(viewModel.editorMode == .create)         #expect(viewModel.draft.startDate == "")+        #expect(viewModel.draft.windows.isEmpty)     }      @Test-    func beginEditSeedsDraftFromPeriod() {+    func beginEditSeedsDraftFromPlanIncludingWindows() {         let (viewModel, _) = makeViewModelAndAPI()-        let period = makePeriod(id: "p1", start: "2026-01-01", end: "2026-06-30", peak: 0.30)-        viewModel.beginEdit(period)+        let plan = makeTouPlan(id: "p1", start: "2026-08-01", end: nil)+        viewModel.beginEdit(plan)         #expect(viewModel.isEditorPresented)         if case .edit(let target) = viewModel.editorMode {             #expect(target.id == "p1")         } else {             Issue.record("expected edit mode")         }-        #expect(viewModel.draft.peakRate == 0.30)-        #expect(viewModel.draft.startDate == "2026-01-01")+        #expect(viewModel.draft.defaultRate == 0.35)+        #expect(viewModel.draft.startDate == "2026-08-01")+        #expect(viewModel.draft.windows.count == 2)+        #expect(viewModel.draft.windows[0].free)+        #expect(viewModel.draft.windows[1].rate == 0.28)     }      @Test@@ -47,59 +52,131 @@ struct PricingViewModelTests {         #expect(!viewModel.isEditorPresented)     } +    // MARK: - Window editing+     @Test-    func saveCreateAppendsRow() async throws {+    func addWindowAppendsARatedWindowAtTheDefaultRate() {         let (viewModel, _) = makeViewModelAndAPI()         viewModel.beginCreate()-        viewModel.draft = PricingPeriodDraft(-            startDate: "2026-08-01",-            endDate: nil,-            peakRate: 0.30,-            feedInRate: 0.06,-            offPeakSavingsRate: 0.12-        )+        viewModel.draft.defaultRate = 0.35+        viewModel.addWindow()+        #expect(viewModel.draft.windows.count == 1)+        #expect(!viewModel.draft.windows[0].free)+        #expect(viewModel.draft.windows[0].rate == 0.35)+    }++    @Test+    func removeWindowDropsTheRowAtTheGivenIndex() {+        let (viewModel, _) = makeViewModelAndAPI()+        viewModel.beginEdit(makeTouPlan(id: "p1", start: "2026-08-01", end: nil))+        viewModel.removeWindow(at: 0)+        #expect(viewModel.draft.windows.count == 1)+        #expect(viewModel.draft.windows[0].start == "01:00")+    }++    @Test+    func markingAWindowFreeDropsItsRate() {+        let (viewModel, _) = makeViewModelAndAPI()+        viewModel.beginCreate()+        viewModel.draft.defaultRate = 0.35+        viewModel.addWindow()+        viewModel.setWindowFree(true, at: 0)+        #expect(viewModel.draft.windows[0].free)+        #expect(viewModel.draft.windows[0].rate == nil)+    }++    @Test+    func markingAWindowRatedSeedsItFromTheDefaultRate() {+        let (viewModel, _) = makeViewModelAndAPI()+        viewModel.beginEdit(makeTouPlan(id: "p1", start: "2026-08-01", end: nil))+        viewModel.setWindowFree(false, at: 0)+        #expect(!viewModel.draft.windows[0].free)+        #expect(viewModel.draft.windows[0].rate == 0.35)+    }++    @Test+    func canSaveMirrorsDraftValidation() {+        let (viewModel, _) = makeViewModelAndAPI()+        viewModel.beginCreate()+        #expect(!viewModel.canSave, "a blank draft has no valid start date")++        viewModel.draft = makeDraft()+        #expect(viewModel.canSave)++        // A free window with no savings reference rate is rejected locally,+        // mirroring the server (AC 6.4).+        viewModel.draft.savingsReferenceRate = nil+        #expect(!viewModel.canSave)+    }++    // MARK: - Save++    @Test+    func saveCreateAppendsPlan() async throws {+        let (viewModel, _) = makeViewModelAndAPI()+        viewModel.beginCreate()+        viewModel.draft = makeDraft()         try await viewModel.save()-        #expect(viewModel.periods.contains(where: { $0.startDate == "2026-08-01" }))-        #expect(!viewModel.isEditorPresented, "editor must dismiss after alpha successful save")+        #expect(viewModel.plans.contains(where: { $0.startDate == "2026-08-01" }))+        #expect(!viewModel.isEditorPresented, "editor must dismiss after a successful save")     }      @Test-    func saveEditUpdatesRow() async throws {+    func saveNormalisesEveryRateToFourDecimalPlaces() async throws {         let (viewModel, apiClient) = makeViewModelAndAPI()-        let period = makePeriod(id: "p1", start: "2026-01-01", end: "2026-06-30", peak: 0.28)-        apiClient.periodsToReturn = [period]+        viewModel.beginCreate()+        var draft = makeDraft()+        draft.defaultRate = 0.354321+        draft.feedInRate = 0.056789+        draft.savingsReferenceRate = 0.351111+        draft.windows = [+            PlanWindow(start: "10:00", end: "15:00", free: true, rate: nil),+            PlanWindow(start: "01:00", end: "06:00", free: false, rate: 0.284567)+        ]+        viewModel.draft = draft+        try await viewModel.save()++        let sent = try #require(apiClient.lastCreatedDraft)+        #expect(sent.defaultRate == 0.3543)+        #expect(sent.feedInRate == 0.0568)+        #expect(sent.savingsReferenceRate == 0.3511)+        #expect(sent.windows[1].rate == 0.2846)+        // A free window carries no rate by contract.+        #expect(sent.windows[0].rate == nil)+    }++    @Test+    func saveEditUpdatesPlan() async throws {+        let (viewModel, apiClient) = makeViewModelAndAPI()+        let plan = makePlan(id: "p1", start: "2026-01-01", end: "2026-07-01", defaultRate: 0.28)+        apiClient.plansToReturn = [plan]         await viewModel.refresh()-        viewModel.beginEdit(period)-        viewModel.draft.peakRate = 0.32+        viewModel.beginEdit(plan)+        viewModel.draft.defaultRate = 0.32         try await viewModel.save()         // foldReplace runs synchronously inside service.update, so-        // viewModel.periods reflects the new rate as soon as save() returns-        // — no need to wait for the fire-and-forget refetch here.-        #expect(viewModel.periods.first?.peakRate == 0.32)+        // viewModel.plans reflects the new rate as soon as save() returns.+        #expect(viewModel.plans.first?.defaultRate == 0.32)     }      @Test-    func deleteRemovesPeriod() async throws {+    func deleteRemovesPlan() async throws {         let (viewModel, apiClient) = makeViewModelAndAPI()-        let period = makePeriod(id: "p1", start: "2026-01-01", end: "2026-06-30")-        apiClient.periodsToReturn = [period]+        let plan = makePlan(id: "p1", start: "2026-01-01", end: "2026-07-01")+        apiClient.plansToReturn = [plan]         await viewModel.refresh()-        try await viewModel.delete(period)-        #expect(viewModel.periods.isEmpty)+        try await viewModel.delete(plan)+        #expect(viewModel.plans.isEmpty)     } +    // MARK: - Validation errors+     @Test     func saveSurfacesOverlapErrorAsBanner() async throws {         let (viewModel, apiClient) = makeViewModelAndAPI()         apiClient.nextCreateError = .pricingValidation(.overlap(openEndedId: "open-id"))         viewModel.beginCreate()-        viewModel.draft = PricingPeriodDraft(-            startDate: "2026-08-01",-            endDate: nil,-            peakRate: 0.30,-            feedInRate: 0.06,-            offPeakSavingsRate: 0.12-        )+        viewModel.draft = makeDraft()         do {             try await viewModel.save()             Issue.record("expected save to throw")@@ -112,66 +189,101 @@ struct PricingViewModelTests {     }      @Test-    func saveSurfacesInvertedDatesAsValidationError() async throws {+    func anOverlapWithANonOpenEndedPlanOffersNoRemediation() async throws {         let (viewModel, apiClient) = makeViewModelAndAPI()-        apiClient.nextCreateError = .pricingValidation(.invertedDates)+        apiClient.nextCreateError = .pricingValidation(.overlap(openEndedId: nil))         viewModel.beginCreate()-        viewModel.draft = PricingPeriodDraft(-            startDate: "2026-08-01",-            endDate: "2026-07-31",-            peakRate: 0.30,-            feedInRate: 0.05,-            offPeakSavingsRate: 0.12-        )-        do {-            try await viewModel.save()-            Issue.record("expected throw")-        } catch {}-        #expect(viewModel.lastValidationError == .invertedDates)+        viewModel.draft = makeDraft()+        try? await viewModel.save()+        #expect(viewModel.lastValidationError == .overlap(openEndedId: nil))+        #expect(viewModel.overlapRemediationTargetId == nil)+    }++    @Test+    func saveSurfacesBandValidationErrors() async throws {+        let cases: [PricingValidationReason] = [+            .invertedDates, .bandWindowInvalid, .bandOverlap,+            .multipleFreeBands, .savingsRateMissing, .noRatedBand, .legacyShape+        ]+        for reason in cases {+            let (viewModel, apiClient) = makeViewModelAndAPI()+            apiClient.nextCreateError = .pricingValidation(reason)+            viewModel.beginCreate()+            viewModel.draft = makeDraft()+            try? await viewModel.save()+            #expect(viewModel.lastValidationError == reason, "\(reason)")+        }     } +    // MARK: - Succession (AC 6.3 / 6.5)+     @Test-    func remediateClosesOpenEndedAndCreatesNew() async throws {+    func remediationEndsTheCurrentPlanOnTheSuccessorsStartDate() async throws {         let (viewModel, apiClient) = makeViewModelAndAPI()-        let open = makePeriod(id: "pp-open", start: "2026-01-01", end: nil)-        apiClient.periodsToReturn = [open]+        let open = makePlan(id: "pp-open", start: "2026-01-01", end: nil)+        apiClient.plansToReturn = [open]         await viewModel.refresh()-        let closing = makePeriod(id: "pp-open", start: "2026-01-01", end: "2026-07-31")-        let newOpen = makePeriod(id: "pp-new", start: "2026-08-01", end: nil)-        apiClient.replaceOpenEndedResult = ReplaceOpenEndedResult(closing: closing, newPeriod: newOpen)-        apiClient.nextCreateError = nil+        // The closing row's exclusive end date IS the successor's start date —+        // no ±1 arithmetic anywhere (AC 2.2).+        let closing = makePlan(id: "pp-open", start: "2026-01-01", end: "2026-08-01")+        let newOpen = makeTouPlan(id: "pp-new", start: "2026-08-01", end: nil)+        apiClient.replaceOpenEndedResult = ReplaceOpenEndedResult(closing: closing, newPlan: newOpen)          viewModel.beginCreate()-        viewModel.draft = PricingPeriodDraft(-            startDate: "2026-08-01",-            endDate: nil,-            peakRate: 0.30,-            feedInRate: 0.06,-            offPeakSavingsRate: 0.12-        )-        // Simulate the overlap error setting the remediation target.+        viewModel.draft = makeDraft()         apiClient.nextCreateError = .pricingValidation(.overlap(openEndedId: "pp-open"))         try? await viewModel.save()         #expect(viewModel.overlapRemediationTargetId == "pp-open")          apiClient.nextCreateError = nil         try await viewModel.remediateOverlap()-        // After remediation, editor dismisses and remediation target clears.++        let sentClosingId = try #require(apiClient.lastReplaceClosingId)+        #expect(sentClosingId == "pp-open")+        let sentDraft = try #require(apiClient.lastReplaceDraft)+        #expect(sentDraft.startDate == "2026-08-01")         #expect(viewModel.overlapRemediationTargetId == nil)         #expect(!viewModel.isEditorPresented)+        #expect(viewModel.plans.first(where: { $0.id == "pp-open" })?.endDate == "2026-08-01")+    }++    @Test+    func remediationCopyUsesSwitchDayPhrasing() {+        // AC 6.5: the predecessor now ends ON the switch date, not the day+        // before it, so the affordance must not say "the day before".+        let copy = PricingViewModel.remediationFooter(startDate: "2026-08-01")+        #expect(copy.contains("2026-08-01"))+        #expect(!copy.lowercased().contains("day before"))+    }++    @Test+    func remediationSurfacesLegacyShapeRejection() async throws {+        let (viewModel, apiClient) = makeViewModelAndAPI()+        let open = makePlan(id: "pp-open", start: "2026-01-01", end: nil)+        apiClient.plansToReturn = [open]+        await viewModel.refresh()++        viewModel.beginCreate()+        viewModel.draft = makeDraft()+        apiClient.nextCreateError = .pricingValidation(.overlap(openEndedId: "pp-open"))+        try? await viewModel.save()++        apiClient.nextReplaceError = .pricingValidation(.legacyShape)+        try? await viewModel.remediateOverlap()+        #expect(viewModel.lastValidationError == .legacyShape)+        #expect(viewModel.isEditorPresented, "a failed remediation keeps the editor open")     }      @Test     func clearErrorDismissesBanner() {         let (viewModel, _) = makeViewModelAndAPI()         viewModel.beginCreate()-        // Manually push an error into the service.         viewModel.service.bind(apiClient: TestPricingAPIClient())         viewModel.clearError()         #expect(viewModel.lastValidationError == nil)     } -    // MARK: - helpers+    // MARK: - Helpers      private func makeViewModelAndAPI() -> (PricingViewModel, TestPricingAPIClient) {         let apiClient = TestPricingAPIClient()@@ -180,19 +292,51 @@ struct PricingViewModelTests {         return (PricingViewModel(service: service), apiClient)     } -    private func makePeriod(+    private func makeDraft() -> PricingPlanDraft {+        PricingPlanDraft(+            startDate: "2026-08-01",+            endDate: nil,+            defaultRate: 0.35,+            windows: [+                PlanWindow(start: "10:00", end: "15:00", free: true, rate: nil),+                PlanWindow(start: "01:00", end: "06:00", free: false, rate: 0.28)+            ],+            feedInRate: 0.06,+            savingsReferenceRate: 0.35+        )+    }++    private func makePlan(         id: String,         start: String,         end: String?,-        peak: Double = 0.30-    ) -> PricingPeriod {-        PricingPeriod(+        defaultRate: Double = 0.30+    ) -> PricingPlan {+        PricingPlan(             id: id,             startDate: start,             endDate: end,-            peakRate: peak,+            defaultRate: defaultRate,+            windows: [PlanWindow(start: "11:00", end: "14:00", free: true, rate: nil)],             feedInRate: 0.05,-            offPeakSavingsRate: 0.12,+            savingsReferenceRate: 0.12,+            createdAt: Date(timeIntervalSince1970: 1),+            updatedAt: Date(timeIntervalSince1970: 1)+        )+    }++    private func makeTouPlan(id: String, start: String, end: String?) -> PricingPlan {+        PricingPlan(+            id: id,+            startDate: start,+            endDate: end,+            defaultRate: 0.35,+            windows: [+                PlanWindow(start: "10:00", end: "15:00", free: true, rate: nil),+                PlanWindow(start: "01:00", end: "06:00", free: false, rate: 0.28)+            ],+            feedInRate: 0.05,+            savingsReferenceRate: 0.35,             createdAt: Date(timeIntervalSince1970: 1),             updatedAt: Date(timeIntervalSince1970: 1)         )@@ -203,9 +347,13 @@ struct PricingViewModelTests {  @MainActor final class TestPricingAPIClient: FluxAPIClient, @unchecked Sendable {-    var periodsToReturn: [PricingPeriod] = []+    var plansToReturn: [PricingPlan] = []     var nextCreateError: FluxAPIError?+    var nextReplaceError: FluxAPIError?     var replaceOpenEndedResult: ReplaceOpenEndedResult?+    private(set) var lastCreatedDraft: PricingPlanDraft?+    private(set) var lastReplaceClosingId: String?+    private(set) var lastReplaceDraft: PricingPlanDraft?      nonisolated func fetchStatus() async throws -> StatusResponse {         StatusResponse(live: nil, battery: nil, rolling15min: nil, offpeak: nil, todayEnergy: nil, note: nil)@@ -218,55 +366,65 @@ final class TestPricingAPIClient: FluxAPIClient, @unchecked Sendable {         NoteResponse(date: date, text: "", updatedAt: nil)     } -    func fetchPricing() async throws -> [PricingPeriod] { periodsToReturn }+    func fetchPricing() async throws -> [PricingPlan] { plansToReturn } -    func createPricing(_ draft: PricingPeriodDraft) async throws -> PricingPeriod {+    func createPricing(_ draft: PricingPlanDraft) async throws -> PricingPlan {+        lastCreatedDraft = draft         if let err = nextCreateError {             nextCreateError = nil             throw err         }         let now = Date()-        let period = PricingPeriod(+        let plan = PricingPlan(             id: "new-\(UUID().uuidString)",             startDate: draft.startDate,             endDate: draft.endDate,-            peakRate: draft.peakRate,+            defaultRate: draft.defaultRate,+            windows: draft.windows,             feedInRate: draft.feedInRate,-            offPeakSavingsRate: draft.offPeakSavingsRate,+            savingsReferenceRate: draft.savingsReferenceRate,             createdAt: now, updatedAt: now         )-        periodsToReturn.append(period)-        return period+        plansToReturn.append(plan)+        return plan     } -    func updatePricing(id: String, _ draft: PricingPeriodDraft) async throws -> PricingPeriod {-        guard let idx = periodsToReturn.firstIndex(where: { $0.id == id }) else {+    func updatePricing(id: String, _ draft: PricingPlanDraft) async throws -> PricingPlan {+        guard let idx = plansToReturn.firstIndex(where: { $0.id == id }) else {             throw FluxAPIError.notFound         }         let now = Date()-        let period = PricingPeriod(+        let plan = PricingPlan(             id: id,             startDate: draft.startDate,             endDate: draft.endDate,-            peakRate: draft.peakRate,+            defaultRate: draft.defaultRate,+            windows: draft.windows,             feedInRate: draft.feedInRate,-            offPeakSavingsRate: draft.offPeakSavingsRate,-            createdAt: periodsToReturn[idx].createdAt,+            savingsReferenceRate: draft.savingsReferenceRate,+            createdAt: plansToReturn[idx].createdAt,             updatedAt: now         )-        periodsToReturn[idx] = period-        return period+        plansToReturn[idx] = plan+        return plan     }      func deletePricing(id: String) async throws {-        periodsToReturn.removeAll { $0.id == id }+        plansToReturn.removeAll { $0.id == id }     }      func replaceOpenEndedPricing(-        closingId _: String,-        with _: PricingPeriodDraft+        closingId: String,+        with draft: PricingPlanDraft     ) async throws -> ReplaceOpenEndedResult {-        if let result = replaceOpenEndedResult { return result }-        throw FluxAPIError.serverError+        lastReplaceClosingId = closingId+        lastReplaceDraft = draft+        if let err = nextReplaceError {+            nextReplaceError = nil+            throw err+        }+        guard let result = replaceOpenEndedResult else { throw FluxAPIError.serverError }+        return result     } }+// swiftlint:enable file_length type_body_length

diff --git a/Flux/FluxWidgets/Views/PowerTrioColumns.swift b/Flux/FluxWidgets/Views/PowerTrioColumns.swiftindex e6d7e1c..5d53105 100644--- a/Flux/FluxWidgets/Views/PowerTrioColumns.swift+++ b/Flux/FluxWidgets/Views/PowerTrioColumns.swift@@ -7,12 +7,14 @@ struct PowerTrioColumns: View {     var spacing: CGFloat = 4     var tight: Bool = false -    private var offpeakStart: String {-        entry.offpeak?.windowStart ?? OffpeakData.defaultWindowStart+    /// A day with no free window has none — never substitute a default, which+    /// would falsely render the legacy 11:00–14:00 band (Q35).+    private var offpeakStart: String? {+        entry.offpeak?.windowStart     } -    private var offpeakEnd: String {-        entry.offpeak?.windowEnd ?? OffpeakData.defaultWindowEnd+    private var offpeakEnd: String? {+        entry.offpeak?.windowEnd     }      var body: some View {

diff --git a/Flux/FluxWidgets/Views/Shared/StatusEntry+WidgetColors.swift b/Flux/FluxWidgets/Views/Shared/StatusEntry+WidgetColors.swiftindex a04465e..119c924 100644--- a/Flux/FluxWidgets/Views/Shared/StatusEntry+WidgetColors.swift+++ b/Flux/FluxWidgets/Views/Shared/StatusEntry+WidgetColors.swift@@ -14,13 +14,13 @@ extension StatusEntry {      var gridTintColor: Color {         if staleness == .offline { return .secondary }-        let windowStart = offpeak?.windowStart ?? OffpeakData.defaultWindowStart-        let windowEnd = offpeak?.windowEnd ?? OffpeakData.defaultWindowEnd+        // A day with no free window has none — never substitute a default,+        // which would falsely paint the legacy 11:00–14:00 band (Q35).         return GridColor.forGrid(             pgrid: pgrid,             pgridSustained: live?.pgridSustained ?? false,-            offpeakWindowStart: windowStart,-            offpeakWindowEnd: windowEnd,+            offpeakWindowStart: offpeak?.windowStart,+            offpeakWindowEnd: offpeak?.windowEnd,             now: date         ).color     }@@ -51,8 +51,7 @@ extension StatusEntry {         // Only escalate when the cutoff is actually close — distant predictions         // would otherwise paint the ring orange all afternoon on a normal day.         if cutoff.timeIntervalSince(date) > 6 * 60 * 60 { return nil }-        let windowStart = offpeak?.windowStart ?? OffpeakData.defaultWindowStart-        let tier = CutoffTimeColor.forCutoff(cutoff, offpeakWindowStart: windowStart, now: date)+        let tier = CutoffTimeColor.forCutoff(cutoff, offpeakWindowStart: offpeak?.windowStart, now: date)         switch tier {         case .red, .orange, .amber:             return tier.color

diff --git a/Flux/FluxWidgets/WidgetFixtures.swift b/Flux/FluxWidgets/WidgetFixtures.swiftindex 42ed5cf..37b777e 100644--- a/Flux/FluxWidgets/WidgetFixtures.swift+++ b/Flux/FluxWidgets/WidgetFixtures.swift@@ -36,8 +36,8 @@ enum WidgetFixtures {                     estimatedCutoffTime: "2026-04-20T17:12:00Z"                 ),                 offpeak: OffpeakData(-                    windowStart: OffpeakData.defaultWindowStart,-                    windowEnd: OffpeakData.defaultWindowEnd,+                    windowStart: "11:00",+                    windowEnd: "14:00",                     gridUsageKwh: 1.2,                     solarKwh: nil,                     batteryChargeKwh: nil,

diff --git a/Flux/Packages/FluxCore/Sources/FluxCore/Helpers/CutoffTimeColor.swift b/Flux/Packages/FluxCore/Sources/FluxCore/Helpers/CutoffTimeColor.swiftindex 7698dcd..b2e5241 100644--- a/Flux/Packages/FluxCore/Sources/FluxCore/Helpers/CutoffTimeColor.swift+++ b/Flux/Packages/FluxCore/Sources/FluxCore/Helpers/CutoffTimeColor.swift@@ -1,16 +1,20 @@ import Foundation  public enum CutoffTimeColor {+    /// The window start is optional because a day whose plan has no free band+    /// has no window to run out of charge before (Q35). Absent takes the same+    /// path as an unparseable window: no escalation beyond the two-hour rule.     public static func forCutoff(         _ cutoffTime: Date,-        offpeakWindowStart: String,+        offpeakWindowStart: String?,         now: Date = .now     ) -> ColorTier {         if cutoffTime.timeIntervalSince(now) < 2 * 60 * 60 {             return .red         } -        guard let offpeakStart = DateFormatting.parseWindowTime(offpeakWindowStart, on: now) else {+        guard let offpeakWindowStart,+              let offpeakStart = DateFormatting.parseWindowTime(offpeakWindowStart, on: now) else {             return .normal         } 

diff --git a/Flux/Packages/FluxCore/Sources/FluxCore/Helpers/DateFormatting.swift b/Flux/Packages/FluxCore/Sources/FluxCore/Helpers/DateFormatting.swiftindex 833afcf..e6e81c0 100644--- a/Flux/Packages/FluxCore/Sources/FluxCore/Helpers/DateFormatting.swift+++ b/Flux/Packages/FluxCore/Sources/FluxCore/Helpers/DateFormatting.swift@@ -79,16 +79,30 @@ public enum DateFormatting {         dayFormatter.string(from: date)     } +    /// Parses an `"HH:MM"` band boundary onto `date`'s Sydney calendar day.+    ///+    /// `"24:00"` resolves to the start of the following day, matching the+    /// end-of-day sentinel `plan.ParseBandTime` and `PlanWindow.parseBandTime`+    /// use. A plan's free band may legitimately run to midnight, and without+    /// this the window would fail to parse and every consumer would treat the+    /// day as having no free window at all.     public static func parseWindowTime(_ timeString: String, on date: Date = .now) -> Date? {         let parts = timeString.split(separator: ":", omittingEmptySubsequences: false)         guard parts.count == 2,               let hour = Int(parts[0]),               let minute = Int(parts[1]),-              (0 ... 23).contains(hour),-              (0 ... 59).contains(minute)+              (0 ... 24).contains(hour),+              (0 ... 59).contains(minute),+              hour < 24 || minute == 0         else {             return nil         }+        if hour == 24 {+            // Calendar arithmetic, not +86400: the day after a DST transition+            // is 23 or 25 hours long.+            let dayStart = sydneyCalendar.startOfDay(for: date)+            return sydneyCalendar.date(byAdding: .day, value: 1, to: dayStart)+        }         return sydneyCalendar.date(bySettingHour: hour, minute: minute, second: 0, of: date)     } 

diff --git a/Flux/Packages/FluxCore/Sources/FluxCore/Helpers/GridColor.swift b/Flux/Packages/FluxCore/Sources/FluxCore/Helpers/GridColor.swiftindex 2499a70..b88dac7 100644--- a/Flux/Packages/FluxCore/Sources/FluxCore/Helpers/GridColor.swift+++ b/Flux/Packages/FluxCore/Sources/FluxCore/Helpers/GridColor.swift@@ -1,20 +1,29 @@ import Foundation  public enum GridColor {+    /// The window is optional because a day whose plan has no free band — or+    /// which no plan prices — genuinely has no off-peak window (Q35). Absent+    /// is treated as "outside the window", the same as any other time of day;+    /// substituting a default would falsely excuse sustained import.     public static func forGrid(         pgrid: Double,         pgridSustained: Bool,-        offpeakWindowStart: String,-        offpeakWindowEnd: String,+        offpeakWindowStart: String?,+        offpeakWindowEnd: String?,         now: Date = .now     ) -> ColorTier {         if pgrid < 0 {             return .green         } -        if pgrid > 500 &&-            pgridSustained &&-            !DateFormatting.isInOffpeakWindow(start: offpeakWindowStart, end: offpeakWindowEnd, now: now) {+        let inOffpeak: Bool+        if let offpeakWindowStart, let offpeakWindowEnd {+            inOffpeak = DateFormatting.isInOffpeakWindow(start: offpeakWindowStart, end: offpeakWindowEnd, now: now)+        } else {+            inOffpeak = false+        }++        if pgrid > 500 && pgridSustained && !inOffpeak {             return .red         } 

diff --git a/Flux/Packages/FluxCore/Sources/FluxCore/Models/APIModels.swift b/Flux/Packages/FluxCore/Sources/FluxCore/Models/APIModels.swiftindex e0f2b41..610e1f8 100644--- a/Flux/Packages/FluxCore/Sources/FluxCore/Models/APIModels.swift+++ b/Flux/Packages/FluxCore/Sources/FluxCore/Models/APIModels.swift@@ -112,9 +112,6 @@ public struct RollingAvg: Codable, Sendable { }  public struct OffpeakData: Codable, Sendable {-    public static let defaultWindowStart = "11:00"-    public static let defaultWindowEnd = "14:00"-     /// Lifecycle of the off-peak record for the day. `pending` covers the     /// in-progress window where deltas are projected against today's     /// running totals; `complete` is the final post-window record.@@ -123,8 +120,13 @@ public struct OffpeakData: Codable, Sendable {         case complete     } -    public let windowStart: String-    public let windowEnd: String+    /// The free window of the plan pricing the day, or `nil` when that plan+    /// has no free band. Clients must render `nil` as "no window" — never+    /// substitute a fixed window, which would falsely show the legacy+    /// 11:00–14:00 on a day that has none (Q35). The whole `offpeak` object is+    /// itself nullable, for a day no plan prices at all.+    public let windowStart: String?+    public let windowEnd: String?     public let status: Status?     public let gridUsageKwh: Double?     public let solarKwh: Double?@@ -138,8 +140,8 @@ public struct OffpeakData: Codable, Sendable {     public let projectedEndSoc: Double?      public init(-        windowStart: String,-        windowEnd: String,+        windowStart: String?,+        windowEnd: String?,         status: Status? = nil,         gridUsageKwh: Double?,         solarKwh: Double?,@@ -208,6 +210,18 @@ public struct DayEnergy: Codable, Sendable, Identifiable {     /// fall back to the `eInput − offpeakGridImportKwh` residual at the call     /// site (see `HistoryDerivedState.gridEntry`).     public let peakGridImportKwh: Double?+    /// The day's rated-band import split, absent when the day is unpriced or+    /// its split is unavailable (AC 3.6). Only rated bands appear — the free+    /// band's import is `offpeakGridImportKwh`, which owns it (Q31).+    public let bandImports: [BandImport]?+    /// Geometry and provenance of the off-peak row `offpeakGridImportKwh` came+    /// from, so a later plan-window edit is detectable as a mismatch rather+    /// than silently mispricing the day. Absent on pre-feature rows, which can+    /// only have been computed under 11:00–14:00.+    public let offpeakWindowStart: String?+    public let offpeakWindowEnd: String?+    public let offpeakIntegratedAt: String?+    public let offpeakSampleCount: Int?     public let note: String?      // Derived per-day stats, populated by the daily-derived-stats backend pass@@ -233,6 +247,11 @@ public struct DayEnergy: Codable, Sendable, Identifiable {         offpeakGridImportKwh: Double? = nil,         offpeakGridExportKwh: Double? = nil,         peakGridImportKwh: Double? = nil,+        bandImports: [BandImport]? = nil,+        offpeakWindowStart: String? = nil,+        offpeakWindowEnd: String? = nil,+        offpeakIntegratedAt: String? = nil,+        offpeakSampleCount: Int? = nil,         note: String? = nil,         dailyUsage: DailyUsage? = nil,         socLow: Double? = nil,@@ -248,6 +267,11 @@ public struct DayEnergy: Codable, Sendable, Identifiable {         self.offpeakGridImportKwh = offpeakGridImportKwh         self.offpeakGridExportKwh = offpeakGridExportKwh         self.peakGridImportKwh = peakGridImportKwh+        self.bandImports = bandImports+        self.offpeakWindowStart = offpeakWindowStart+        self.offpeakWindowEnd = offpeakWindowEnd+        self.offpeakIntegratedAt = offpeakIntegratedAt+        self.offpeakSampleCount = offpeakSampleCount         self.note = note         self.dailyUsage = dailyUsage         self.socLow = socLow@@ -406,6 +430,18 @@ public struct DaySummary: Codable, Sendable {     /// Absent for today and for days the integration's usability gate failed;     /// callers fall back to the `eInput − offpeakGridImportKwh` residual.     public let peakGridImportKwh: Double?+    /// The day's rated-band import split, absent when the day is unpriced or+    /// its split is unavailable (AC 3.6). Only rated bands appear — the free+    /// band's import is `offpeakGridImportKwh`, which owns it (Q31).+    public let bandImports: [BandImport]?+    /// Geometry and provenance of the off-peak row `offpeakGridImportKwh` came+    /// from, so a later plan-window edit is detectable as a mismatch rather+    /// than silently mispricing the day. Absent on pre-feature rows, which can+    /// only have been computed under 11:00–14:00.+    public let offpeakWindowStart: String?+    public let offpeakWindowEnd: String?+    public let offpeakIntegratedAt: String?+    public let offpeakSampleCount: Int?      public init(         epv: Double?,@@ -417,7 +453,12 @@ public struct DaySummary: Codable, Sendable {         socLowTime: String?,         offpeakGridImportKwh: Double? = nil,         offpeakGridExportKwh: Double? = nil,-        peakGridImportKwh: Double? = nil+        peakGridImportKwh: Double? = nil,+        bandImports: [BandImport]? = nil,+        offpeakWindowStart: String? = nil,+        offpeakWindowEnd: String? = nil,+        offpeakIntegratedAt: String? = nil,+        offpeakSampleCount: Int? = nil     ) {         self.epv = epv         self.eInput = eInput@@ -429,6 +470,11 @@ public struct DaySummary: Codable, Sendable {         self.offpeakGridImportKwh = offpeakGridImportKwh         self.offpeakGridExportKwh = offpeakGridExportKwh         self.peakGridImportKwh = peakGridImportKwh+        self.bandImports = bandImports+        self.offpeakWindowStart = offpeakWindowStart+        self.offpeakWindowEnd = offpeakWindowEnd+        self.offpeakIntegratedAt = offpeakIntegratedAt+        self.offpeakSampleCount = offpeakSampleCount     } } 

diff --git a/Flux/Packages/FluxCore/Sources/FluxCore/Models/FluxAPIError.swift b/Flux/Packages/FluxCore/Sources/FluxCore/Models/FluxAPIError.swiftindex 2b397d4..3f3df17 100644--- a/Flux/Packages/FluxCore/Sources/FluxCore/Models/FluxAPIError.swift+++ b/Flux/Packages/FluxCore/Sources/FluxCore/Models/FluxAPIError.swift@@ -13,9 +13,9 @@ public enum FluxAPIError: Error, Sendable, Equatable {     case pricingValidation(PricingValidationReason) } -/// Validation failure codes returned by the pricing endpoints (Requirement 1-/// and AC 2.3). Mirrors the server-side error codes verbatim so the editor-/// can map each one to inline field-level feedback.+/// Validation failure codes returned by the pricing endpoints (AC 7.2).+/// Mirrors the server-side error codes verbatim so the editor can map each one+/// to inline field-level feedback. public enum PricingValidationReason: Error, Sendable, Equatable {     case invertedDates     case overlap(openEndedId: String?)@@ -25,6 +25,15 @@ public enum PricingValidationReason: Error, Sendable, Equatable {     /// Returned as HTTP 409 when a concurrent writer raced this one; the     /// editor refetches the list and retries.     case concurrentWrite+    /// Band rules (time-of-use-pricing).+    case bandWindowInvalid+    case bandOverlap+    case multipleFreeBands+    case savingsRateMissing+    case noRatedBand+    /// A pre-migration three-rate payload, or a `replace-open-ended` whose+    /// closing row is still the legacy shape (AC 7.3 / Q32).+    case legacyShape }  extension FluxAPIError {@@ -74,17 +83,29 @@ extension PricingValidationReason {     public var message: String {         switch self {         case .invertedDates:-            return "End date must not be before the start date."+            return "The end date must be after the start date."         case .overlap:-            return "This period overlaps an existing one. Close the previous period first."+            return "This plan overlaps an existing one. Close the previous plan first."         case .ratePrecision:             return "Rates must use at most four decimal places."         case .rateOutOfRange:             return "Each rate must be between $0.00 and $10.00 per kWh."         case .secondOpenEnded:-            return "Only one open-ended pricing period is allowed at a time."+            return "Only one open-ended pricing plan is allowed at a time."         case .concurrentWrite:             return "Another change was just applied. Try again."+        case .bandWindowInvalid:+            return "Each window needs a start before its end, between 00:00 and 24:00."+        case .bandOverlap:+            return "Windows must not overlap each other."+        case .multipleFreeBands:+            return "A plan can have at most one free window."+        case .savingsRateMissing:+            return "A plan with a free window needs a savings reference rate."+        case .noRatedBand:+            return "A free window covering the whole day leaves nothing to price."+        case .legacyShape:+            return "This plan is still in the old three-rate format. Run the pricing migration first."         }     } }

diff --git a/Flux/Packages/FluxCore/Sources/FluxCore/Networking/FluxAPIClient.swift b/Flux/Packages/FluxCore/Sources/FluxCore/Networking/FluxAPIClient.swiftindex 98bd0f7..bd22975 100644--- a/Flux/Packages/FluxCore/Sources/FluxCore/Networking/FluxAPIClient.swift+++ b/Flux/Packages/FluxCore/Sources/FluxCore/Networking/FluxAPIClient.swift@@ -28,13 +28,13 @@ public protocol FluxAPIClient: Sendable {     func deleteRule(deviceId: String, ruleId: String) async throws      // Pricing — daily-costs spec.-    func fetchPricing() async throws -> [PricingPeriod]-    func createPricing(_ draft: PricingPeriodDraft) async throws -> PricingPeriod-    func updatePricing(id: String, _ draft: PricingPeriodDraft) async throws -> PricingPeriod+    func fetchPricing() async throws -> [PricingPlan]+    func createPricing(_ draft: PricingPlanDraft) async throws -> PricingPlan+    func updatePricing(id: String, _ draft: PricingPlanDraft) async throws -> PricingPlan     func deletePricing(id: String) async throws     func replaceOpenEndedPricing(         closingId: String,-        with draft: PricingPeriodDraft+        with draft: PricingPlanDraft     ) async throws -> ReplaceOpenEndedResult } @@ -63,15 +63,15 @@ public extension FluxAPIClient {         throw FluxAPIError.notConfigured     } -    func fetchPricing() async throws -> [PricingPeriod] {+    func fetchPricing() async throws -> [PricingPlan] {         throw FluxAPIError.notConfigured     } -    func createPricing(_: PricingPeriodDraft) async throws -> PricingPeriod {+    func createPricing(_: PricingPlanDraft) async throws -> PricingPlan {         throw FluxAPIError.notConfigured     } -    func updatePricing(id _: String, _: PricingPeriodDraft) async throws -> PricingPeriod {+    func updatePricing(id _: String, _: PricingPlanDraft) async throws -> PricingPlan {         throw FluxAPIError.notConfigured     } @@ -81,7 +81,7 @@ public extension FluxAPIClient {      func replaceOpenEndedPricing(         closingId _: String,-        with _: PricingPeriodDraft+        with _: PricingPlanDraft     ) async throws -> ReplaceOpenEndedResult {         throw FluxAPIError.notConfigured     }

diff --git a/Flux/Packages/FluxCore/Sources/FluxCore/Networking/URLSessionAPIClient.swift b/Flux/Packages/FluxCore/Sources/FluxCore/Networking/URLSessionAPIClient.swiftindex 41ea37b..3ffd7ca 100644--- a/Flux/Packages/FluxCore/Sources/FluxCore/Networking/URLSessionAPIClient.swift+++ b/Flux/Packages/FluxCore/Sources/FluxCore/Networking/URLSessionAPIClient.swift@@ -4,7 +4,7 @@ public final class URLSessionAPIClient: FluxAPIClient, Sendable {     private let session: URLSession     private let baseURL: URL     private let tokenProvider: @Sendable () -> String?-    private let decoder: JSONDecoder+    let decoder: JSONDecoder  // internal: used by the pricing extension's own file     let encoder: JSONEncoder  // internal: used by the simulation extension's own file      private static let noCacheSession: URLSession = {@@ -305,96 +305,3 @@ public final class URLSessionAPIClient: FluxAPIClient, Sendable {     }  }--// MARK: - Pricing (daily-costs spec)--extension URLSessionAPIClient {-    public func fetchPricing() async throws -> [PricingPeriod] {-        let response: PricingListResponse = try await performRequest(path: "pricing", queryItems: [])-        return response.pricing-    }--    public func createPricing(_ draft: PricingPeriodDraft) async throws -> PricingPeriod {-        let body = try encoder.encode(draft)-        return try await performRequest(path: "pricing", queryItems: [], method: "POST", body: body)-    }--    public func updatePricing(id: String, _ draft: PricingPeriodDraft) async throws -> PricingPeriod {-        let body = try encoder.encode(draft)-        return try await performRequest(path: "pricing/\(id)", queryItems: [], method: "PUT", body: body)-    }--    public func deletePricing(id: String) async throws {-        let _: EmptyPricingResponse = try await performRequest(-            path: "pricing/\(id)",-            queryItems: [],-            method: "DELETE"-        )-    }--    public func replaceOpenEndedPricing(-        closingId: String,-        with draft: PricingPeriodDraft-    ) async throws -> ReplaceOpenEndedResult {-        let payload = ReplaceOpenEndedPayload(closingPricingId: closingId, newPeriod: draft)-        let body = try encoder.encode(payload)-        let response: PricingListResponse = try await performRequest(-            path: "pricing/replace-open-ended",-            queryItems: [],-            method: "POST",-            body: body-        )-        guard response.pricing.count == 2 else {-            throw FluxAPIError.decodingError("replace-open-ended expected 2 rows, got \(response.pricing.count)")-        }-        // Match by id rather than position so a server-side reorder-        // (e.g. start-date sort) can't swap closing and new on the wire.-        guard let closing = response.pricing.first(where: { $0.id == closingId }) else {-            throw FluxAPIError.decodingError("replace-open-ended response missing row with id \(closingId)")-        }-        guard let newPeriod = response.pricing.first(where: { $0.id != closingId }) else {-            throw FluxAPIError.decodingError("replace-open-ended response: both rows share id \(closingId)")-        }-        return ReplaceOpenEndedResult(closing: closing, newPeriod: newPeriod)-    }--    fileprivate func parsePricingValidationReason(from data: Data) -> PricingValidationReason? {-        guard let payload = try? decoder.decode(PricingErrorResponse.self, from: data) else {-            return nil-        }-        switch payload.error {-        case "inverted_dates":-            return .invertedDates-        case "overlap":-            return .overlap(openEndedId: payload.openEndedId)-        case "rate_precision":-            return .ratePrecision-        case "rate_out_of_range":-            return .rateOutOfRange-        case "second_open_ended":-            return .secondOpenEnded-        case "concurrent_open_ended_write":-            return .concurrentWrite-        default:-            return nil-        }-    }--    fileprivate struct PricingErrorResponse: Decodable {-        let error: String-        let openEndedId: String?-    }--    fileprivate struct PricingListResponse: Decodable {-        let pricing: [PricingPeriod]-    }--    fileprivate struct ReplaceOpenEndedPayload: Encodable {-        let closingPricingId: String-        let newPeriod: PricingPeriodDraft-    }--    fileprivate struct EmptyPricingResponse: Decodable {-        init(from _: Decoder) throws {}-    }-}

diff --git a/Flux/Packages/FluxCore/Sources/FluxCore/Networking/URLSessionAPIClient+Pricing.swift b/Flux/Packages/FluxCore/Sources/FluxCore/Networking/URLSessionAPIClient+Pricing.swiftnew file mode 100644index 0000000..63fa1f8--- /dev/null+++ b/Flux/Packages/FluxCore/Sources/FluxCore/Networking/URLSessionAPIClient+Pricing.swift@@ -0,0 +1,102 @@+import Foundation++// MARK: - Pricing (daily-costs, time-of-use-pricing specs)++extension URLSessionAPIClient {+    public func fetchPricing() async throws -> [PricingPlan] {+        let response: PricingListResponse = try await performRequest(path: "pricing", queryItems: [])+        return response.pricing+    }++    public func createPricing(_ draft: PricingPlanDraft) async throws -> PricingPlan {+        let body = try encoder.encode(draft)+        return try await performRequest(path: "pricing", queryItems: [], method: "POST", body: body)+    }++    public func updatePricing(id: String, _ draft: PricingPlanDraft) async throws -> PricingPlan {+        let body = try encoder.encode(draft)+        return try await performRequest(path: "pricing/\(id)", queryItems: [], method: "PUT", body: body)+    }++    public func deletePricing(id: String) async throws {+        let _: EmptyPricingResponse = try await performRequest(+            path: "pricing/\(id)",+            queryItems: [],+            method: "DELETE"+        )+    }++    public func replaceOpenEndedPricing(+        closingId: String,+        with draft: PricingPlanDraft+    ) async throws -> ReplaceOpenEndedResult {+        let payload = ReplaceOpenEndedPayload(closingPricingId: closingId, newPeriod: draft)+        let body = try encoder.encode(payload)+        let response: PricingListResponse = try await performRequest(+            path: "pricing/replace-open-ended",+            queryItems: [],+            method: "POST",+            body: body+        )+        guard response.pricing.count == 2 else {+            throw FluxAPIError.decodingError("replace-open-ended expected 2 rows, got \(response.pricing.count)")+        }+        // Match by id rather than position so a server-side reorder+        // (e.g. start-date sort) can't swap closing and new on the wire.+        guard let closing = response.pricing.first(where: { $0.id == closingId }) else {+            throw FluxAPIError.decodingError("replace-open-ended response missing row with id \(closingId)")+        }+        guard let newPlan = response.pricing.first(where: { $0.id != closingId }) else {+            throw FluxAPIError.decodingError("replace-open-ended response: both rows share id \(closingId)")+        }+        return ReplaceOpenEndedResult(closing: closing, newPlan: newPlan)+    }++    /// The server's `error` codes, mirrored one-for-one. `overlap` is the only+    /// one carrying a payload, so it is handled separately from the table.+    private static let validationReasonsByCode: [String: PricingValidationReason] = [+        "inverted_dates": .invertedDates,+        "rate_precision": .ratePrecision,+        "rate_out_of_range": .rateOutOfRange,+        "second_open_ended": .secondOpenEnded,+        "concurrent_open_ended_write": .concurrentWrite,+        "band_window_invalid": .bandWindowInvalid,+        "band_overlap": .bandOverlap,+        "multiple_free_bands": .multipleFreeBands,+        "savings_rate_missing": .savingsRateMissing,+        "no_rated_band": .noRatedBand,+        "legacy_shape": .legacyShape+    ]++    func parsePricingValidationReason(from data: Data) -> PricingValidationReason? {+        guard let payload = try? decoder.decode(PricingErrorResponse.self, from: data) else {+            return nil+        }+        if payload.error == "overlap" {+            return .overlap(openEndedId: payload.openEndedId)+        }+        return Self.validationReasonsByCode[payload.error]+    }++    struct PricingErrorResponse: Decodable {+        let error: String+        /// Populated only when the overlap offender is the unique open-ended+        /// plan — the id that powers the editor's one-tap remediation.+        let openEndedId: String?+    }++    struct PricingListResponse: Decodable {+        let pricing: [PricingPlan]+    }++    /// The request field name stays `newPeriod` — it is the server's wire+    /// contract, unchanged by the band rework.+    struct ReplaceOpenEndedPayload: Encodable {+        let closingPricingId: String+        let newPeriod: PricingPlanDraft+    }++    struct EmptyPricingResponse: Decodable {+        init(from _: Decoder) throws {}+    }+}

diff --git a/Flux/Packages/FluxCore/Sources/FluxCore/Pricing/DayCosts.swift b/Flux/Packages/FluxCore/Sources/FluxCore/Pricing/DayCosts.swiftindex 967e275..0251685 100644--- a/Flux/Packages/FluxCore/Sources/FluxCore/Pricing/DayCosts.swift+++ b/Flux/Packages/FluxCore/Sources/FluxCore/Pricing/DayCosts.swift@@ -1,86 +1,304 @@ import Foundation +/// One rated band's stored grid import for a day. Each entry snapshots the+/// geometry it was captured under (Q23), so a later plan-window edit is+/// detectable as a mismatch rather than silently mispricing the day.+///+/// Only rated bands appear: the free band's import lives on the off-peak row,+/// which owns that quantity exclusively (Q31). Mirrors `plan.BandImport`.+public struct BandImport: Codable, Sendable, Equatable, Hashable {+    public let start: String+    public let end: String+    public let kwh: Double++    public init(start: String, end: String, kwh: Double) {+        self.start = start+        self.end = end+        self.kwh = kwh+    }+}++/// The off-peak row's contribution to costing — the only source of the free+/// band's kWh. Mirrors `plan.OffpeakRow`.+public struct OffpeakImport: Sendable, Equatable {+    /// The window every pre-feature off-peak row was integrated under. Rows+    /// predating the geometry snapshot carry no window, and this is the only+    /// window they can have had.+    public static let legacyWindowStart = "11:00"+    public static let legacyWindowEnd = "14:00"++    public let gridImportKwh: Double+    /// The geometry the row was integrated under; `nil` on a pre-feature row.+    public let windowStart: String?+    public let windowEnd: String?+    /// Integration provenance. A row integrated from readings but with no+    /// samples is a zero-delta artifact, not a measured zero.+    public let integratedAt: String?+    public let sampleCount: Int++    public init(+        gridImportKwh: Double,+        windowStart: String? = nil,+        windowEnd: String? = nil,+        integratedAt: String? = nil,+        sampleCount: Int = 0+    ) {+        self.gridImportKwh = gridImportKwh+        self.windowStart = windowStart+        self.windowEnd = windowEnd+        self.integratedAt = integratedAt+        self.sampleCount = sampleCount+    }++    /// Whether the row's import is a real measurement. Rows predating the+    /// integration path (no `integratedAt`) are snapshot deltas and stay usable.+    public var isUsable: Bool {+        integratedAt == nil || sampleCount > 0+    }++    /// The window the row was integrated under, substituting the pre-feature+    /// window when the row carries no snapshot.+    public var geometry: (start: String, end: String) {+        guard let windowStart, let windowEnd, !windowStart.isEmpty, !windowEnd.isEmpty else {+            return (Self.legacyWindowStart, Self.legacyWindowEnd)+        }+        return (windowStart, windowEnd)+    }+}++/// One day's stored energy, as cost resolution sees it. Optionals distinguish+/// "never recorded" from a measured zero — the distinction the single-rate+/// formula turns on. Mirrors `plan.DayEnergy`.+public struct DayCostInputs: Sendable, Equatable {+    public let eInput: Double?+    public let eOutput: Double?+    public let peakGridImportKwh: Double?+    public let offpeak: OffpeakImport?+    public let bandImports: [BandImport]?++    public init(+        eInput: Double?,+        eOutput: Double?,+        peakGridImportKwh: Double?,+        offpeak: OffpeakImport?,+        bandImports: [BandImport]?+    ) {+        self.eInput = eInput+        self.eOutput = eOutput+        self.peakGridImportKwh = peakGridImportKwh+        self.offpeak = offpeak+        self.bandImports = bandImports+    }+}++/// Which resolution path produced a `DayCosts`. Exposed so tests can assert on+/// the path, not just the number. Mirrors `plan.Tier`.+public enum CostTier: Int, Sendable, Equatable {+    /// Each rated band priced at its own rate from the stored split.+    case banded = 1+    /// The pre-band formula, applicable whenever the plan's rated segments+    /// share one rate — which every migrated legacy plan does.+    case singleRate = 2+    /// All import at the plan's highest rate with no savings (AC 3.6).+    /// Reachable only for multi-rate plans.+    case fallback = 3+}+ /// Per-day cost breakdown rendered on the Day Detail costs card. Computed on-/// read from the stored kWh values and the current pricing list — there is-/// no persisted snapshot (Decision 8).+/// read from the stored kWh values and the current plan list — there is no+/// persisted snapshot (Decision 8). public struct DayCosts: Equatable, Sendable {     public let peakImportsCost: Double     public let solarFeedInIncome: Double     public let net: Double     public let offPeakSavings: Double+    public let tier: CostTier      public init(         peakImportsCost: Double,         solarFeedInIncome: Double,         net: Double,-        offPeakSavings: Double+        offPeakSavings: Double,+        tier: CostTier = .singleRate     ) {         self.peakImportsCost = peakImportsCost         self.solarFeedInIncome = solarFeedInIncome         self.net = net         self.offPeakSavings = offPeakSavings+        self.tier = tier     } } -public extension DaySummary {-    /// Returns the cost breakdown for `date` if a pricing period covers it.-    /// Returns `nil` when no period covers `date` (AC 4.6).-    ///-    /// Zero kWh fields produce zero cost lines and do NOT make the day-    /// unpriced (Decision 18). When `offpeakGridImportKwh` is `nil`, all of-    /// `eInput` is billed as peak (Decision 23) and off-peak savings is `0`.-    ///-    /// Peak kWh prefers the server-computed `peakGridImportKwh` when present-    /// (peak-from-readings Decision 8); otherwise it falls back to the-    /// `eInput − offpeak` residual. Off-peak savings always price the measured-    /// off-peak kWh, so with the server peak the two no longer sum to `eInput`-    /// (they differ by ~1.5%, the shared sampling artifact) — each is priced on-    /// what was actually measured for that window.-    func costs(forDate date: String, in pricing: [PricingPeriod]) -> DayCosts? {-        guard let period = pricing.first(where: { $0.covers(date: date) }) else {-            return nil+public extension DayCosts {+    /// Resolves one day's costs under the plan pricing that day. Resolution+    /// order is banded → single-rate → fallback (Decision 6); the Go side runs+    /// the identical order in `plan.DayCosts`, pinned by the shared vectors in+    /// `internal/api/testdata/pricing_costs.json`.+    static func resolve(plan: PricingPlan, day: DayCostInputs) -> DayCosts {+        let feedIn = (day.eOutput ?? 0) * plan.feedInRate+        func finish(importCost: Double, savings: Double, tier: CostTier) -> DayCosts {+            DayCosts(+                peakImportsCost: importCost,+                solarFeedInIncome: feedIn,+                net: importCost - feedIn,+                offPeakSavings: savings,+                tier: tier+            )+        }++        let rated = plan.ratedSegments++        if let banded = bandedCosts(plan: plan, rated: rated, day: day) {+            return finish(importCost: banded.importCost, savings: banded.savings, tier: .banded)+        }+        if let rate = singleRate(of: rated) {+            let resolved = singleRateCosts(plan: plan, day: day, rate: rate)+            return finish(importCost: resolved.importCost, savings: resolved.savings, tier: .singleRate)+        }+        // AC 3.6: an unresolvable split prices everything at the highest rate+        // and shows no savings — the conservative overestimate every screen+        // must agree on.+        let highest = rated.map(\.rate).max() ?? 0+        return finish(importCost: (day.eInput ?? 0) * highest, savings: 0, tier: .fallback)+    }++    /// Prices the day from the stored split. Applies only when the split's+    /// geometry exactly matches the plan's rated segments AND the free band's+    /// import is resolvable — a partially known split is unavailable (AC 3.6),+    /// not partially used.+    private static func bandedCosts(+        plan: PricingPlan,+        rated: [PlanSegment],+        day: DayCostInputs+    ) -> (importCost: Double, savings: Double)? {+        guard let bands = day.bandImports, !rated.isEmpty, bands.count == rated.count else { return nil }++        var importCost = 0.0+        for (index, segment) in rated.enumerated() {+            guard bands[index].start == segment.start, bands[index].end == segment.end else { return nil }+            importCost += bands[index].kwh * segment.rate         } -        let solarKwh = eOutput ?? 0-        let peakKwh: Double-        let offPeakKwh: Double-        if let off = offpeakGridImportKwh {-            offPeakKwh = off-            peakKwh = peakGridImportKwh ?? max(0, (eInput ?? 0) - off)-        } else {-            offPeakKwh = 0-            peakKwh = peakGridImportKwh ?? (eInput ?? 0)+        guard let free = plan.freeWindow else {+            // No free band: the rated segments are the whole day and there is+            // nothing to value as savings.+            return (importCost, 0)         }+        guard let offpeak = day.offpeak, offpeak.isUsable else { return nil }+        let geometry = offpeak.geometry+        guard geometry.start == free.start, geometry.end == free.end else { return nil }+        guard let savingsRate = plan.savingsReferenceRate else { return (importCost, 0) }+        return (importCost, offpeak.gridImportKwh * savingsRate)+    }++    /// The pre-band formula, unchanged. Peak kWh prefers the server-computed+    /// value over the `eInput − off-peak` residual: the two differ by ~1.5% by+    /// design (a shared sampling artifact), and pricing the measured value is+    /// what keeps migrated history identical (Q30).+    private static func singleRateCosts(+        plan: PricingPlan,+        day: DayCostInputs,+        rate: Double+    ) -> (importCost: Double, savings: Double) {+        let total = day.eInput ?? 0+        guard let offpeak = day.offpeak else {+            return ((day.peakGridImportKwh ?? total) * rate, 0)+        }++        let off = offpeak.gridImportKwh+        let peak = day.peakGridImportKwh ?? max(0, total - off)+        let savings = plan.savingsReferenceRate.map { off * $0 } ?? 0+        return (peak * rate, savings)+    }++    /// The rate shared by every rated segment, or `nil` when they carry more+    /// than one — the only case that can reach the fallback tier.+    private static func singleRate(of rated: [PlanSegment]) -> Double? {+        guard let first = rated.first else { return nil }+        return rated.allSatisfy { $0.rate == first.rate } ? first.rate : nil+    }+} -        let peakCost = peakKwh * period.peakRate-        let feedIn = solarKwh * period.feedInRate-        let savings = offPeakKwh * period.offPeakSavingsRate-        return DayCosts(-            peakImportsCost: peakCost,-            solarFeedInIncome: feedIn,-            net: peakCost - feedIn,-            offPeakSavings: savings+public extension OffpeakImport {+    /// Reconstructs the off-peak row from the flat fields the read payloads+    /// carry. `/day` and `/history` describe the same day and the Data+    /// Consistency rule requires it to price identically on both, so the two+    /// rules that matter live here once: a day with no off-peak import has no+    /// row at all rather than a zero row — the distinction the single-rate+    /// formula turns on — and an absent sample count reads as zero samples.+    ///+    /// The surrounding `DayCostInputs` is still built per payload type:+    /// `DayEnergy.eInput` is non-optional where `DaySummary.eInput` is+    /// optional, so a shared protocol cannot cover the energy fields.+    static func from(+        gridImportKwh: Double?,+        windowStart: String?,+        windowEnd: String?,+        integratedAt: String?,+        sampleCount: Int?+    ) -> OffpeakImport? {+        gridImportKwh.map {+            OffpeakImport(+                gridImportKwh: $0,+                windowStart: windowStart,+                windowEnd: windowEnd,+                integratedAt: integratedAt,+                sampleCount: sampleCount ?? 0+            )+        }+    }+}++public extension DaySummary {+    /// Returns the cost breakdown for `date` if a plan covers it, or `nil` when+    /// none does (AC 2.7).+    ///+    /// Zero kWh fields produce zero cost lines and do NOT make the day+    /// unpriced (Decision 18).+    func costs(forDate date: String, in pricing: [PricingPlan]) -> DayCosts? {+        guard let plan = PricingPlan.plan(for: date, in: pricing) else { return nil }+        return DayCosts.resolve(plan: plan, day: costInputs)+    }++    /// The day's energy as cost resolution sees it.+    var costInputs: DayCostInputs {+        DayCostInputs(+            eInput: eInput,+            eOutput: eOutput,+            peakGridImportKwh: peakGridImportKwh,+            offpeak: .from(+                gridImportKwh: offpeakGridImportKwh,+                windowStart: offpeakWindowStart,+                windowEnd: offpeakWindowEnd,+                integratedAt: offpeakIntegratedAt,+                sampleCount: offpeakSampleCount+            ),+            bandImports: bandImports         )     } }  public extension DayEnergy {-    /// Convenience for History per-day costing. Forwards to the-    /// `DaySummary` extension using `self.date` and a transient `DaySummary`-    /// built from the day's fields.-    func costs(in pricing: [PricingPeriod]) -> DayCosts? {-        let summary = DaySummary(-            epv: epv,+    /// Convenience for History per-day costing, using `self.date` and the same+    /// resolution the Day Detail card uses so both screens agree (AC 3.4).+    func costs(in pricing: [PricingPlan]) -> DayCosts? {+        guard let plan = PricingPlan.plan(for: date, in: pricing) else { return nil }+        return DayCosts.resolve(plan: plan, day: costInputs)+    }++    var costInputs: DayCostInputs {+        DayCostInputs(             eInput: eInput,             eOutput: eOutput,-            eCharge: eCharge,-            eDischarge: eDischarge,-            socLow: socLow,-            socLowTime: socLowTime,-            offpeakGridImportKwh: offpeakGridImportKwh,-            offpeakGridExportKwh: offpeakGridExportKwh,-            peakGridImportKwh: peakGridImportKwh+            peakGridImportKwh: peakGridImportKwh,+            offpeak: .from(+                gridImportKwh: offpeakGridImportKwh,+                windowStart: offpeakWindowStart,+                windowEnd: offpeakWindowEnd,+                integratedAt: offpeakIntegratedAt,+                sampleCount: offpeakSampleCount+            ),+            bandImports: bandImports         )-        return summary.costs(forDate: date, in: pricing)     } }

diff --git a/Flux/Packages/FluxCore/Sources/FluxCore/Pricing/PeriodCosts.swift b/Flux/Packages/FluxCore/Sources/FluxCore/Pricing/PeriodCosts.swiftindex dabedda..952ee58 100644--- a/Flux/Packages/FluxCore/Sources/FluxCore/Pricing/PeriodCosts.swift+++ b/Flux/Packages/FluxCore/Sources/FluxCore/Pricing/PeriodCosts.swift@@ -31,10 +31,13 @@ public struct PeriodCosts: Equatable, Sendable {  public extension PeriodCosts {     /// Sums costs across `days`. Returns `nil` iff no day in `days` is a-    /// priced day, matching AC 5.4. The `totalDayCount` is the full range-    /// (including unpriced days) so the caller can render the-    /// `N of M days priced` caption from AC 5.3.-    static func compute(days: [DayEnergy], pricing: [PricingPeriod]) -> PeriodCosts? {+    /// priced day (AC 2.7). The `totalDayCount` is the full range (including+    /// unpriced days) so the caller can render the `N of M days priced`+    /// caption from AC 3.7.+    ///+    /// Each day resolves its own tier under the plan pricing it, so a range+    /// spanning a switch date sums days priced by different plans.+    static func compute(days: [DayEnergy], pricing: [PricingPlan]) -> PeriodCosts? {         guard !days.isEmpty else { return nil }          var peak: Double = 0

diff --git a/Flux/Packages/FluxCore/Sources/FluxCore/Pricing/PricingPlan.swift b/Flux/Packages/FluxCore/Sources/FluxCore/Pricing/PricingPlan.swiftnew file mode 100644index 0000000..9771da2--- /dev/null+++ b/Flux/Packages/FluxCore/Sources/FluxCore/Pricing/PricingPlan.swift@@ -0,0 +1,234 @@+import Foundation++/// One exception to a plan's default rate: a half-open `[start, end)` slice of+/// the day that is either free or carries its own rate. Boundaries are "HH:MM"+/// in Sydney local time; `end` may be "24:00". `rate` is absent on a free+/// window — the domain ignores it there by contract.+///+/// Mirrors `plan.Window` on the backend.+public struct PlanWindow: Codable, Sendable, Equatable, Hashable {+    public var start: String+    public var end: String+    public var free: Bool+    public var rate: Double?++    public init(start: String, end: String, free: Bool, rate: Double?) {+        self.start = start+        self.end = end+        self.free = free+        self.rate = rate+    }+}++public extension PlanWindow {+    /// The exclusive upper bound of a band boundary. Boundaries are+    /// minute-of-day values in `0...1440`; 1440 ("24:00") is end-of-day and is+    /// only ever a window or segment end.+    static let minutesPerDay = 24 * 60++    /// Converts an "HH:MM" band boundary to minutes since midnight, accepting+    /// "24:00" as end-of-day. Returns `nil` for anything malformed or beyond+    /// the day (Q34 — the off-peak window parser rejects `h > 23` and cannot+    /// be reused for bands).+    static func parseBandTime(_ value: String) -> Int? {+        let chars = Array(value)+        guard chars.count == 5, chars[2] == ":" else { return nil }+        for index in [0, 1, 3, 4] where !chars[index].isASCII || !chars[index].isNumber {+            return nil+        }+        guard let hours = Int(String(chars[0 ..< 2])),+              let minutes = Int(String(chars[3 ..< 5])),+              minutes <= 59 else { return nil }+        let total = hours * 60 + minutes+        guard total <= minutesPerDay else { return nil }+        return total+    }++    /// The inverse of `parseBandTime`, rendering 1440 as "24:00".+    static func formatBandTime(_ minutes: Int) -> String {+        String(format: "%02d:%02d", minutes / 60, minutes % 60)+    }+}++/// A window whose boundaries have been resolved to minutes of the day. Shared+/// by segmentation and draft validation, which both need the same "is this+/// window well-formed" answer before they can do anything with it.+struct ParsedBand {+    let start: Int+    let end: Int+    let free: Bool+    let rate: Double++    /// Fails when the boundaries are unparseable or not in order — the cases+    /// `PricingPlanDraft.validate` reports as `bandWindowInvalid`.+    init?(_ window: PlanWindow) {+        guard let start = PlanWindow.parseBandTime(window.start),+              let end = PlanWindow.parseBandTime(window.end),+              start < end else { return nil }+        self.start = start+        self.end = end+        self.free = window.free+        self.rate = window.rate ?? 0+    }+}++/// One band of the derived full-day segmentation. The segments of a plan tile+/// 00:00–24:00 exactly (AC 1.1). Mirrors `plan.Segment`.+public struct PlanSegment: Sendable, Equatable, Hashable {+    public let start: String+    public let end: String+    public let free: Bool+    public let rate: Double++    public init(start: String, end: String, free: Bool, rate: Double) {+        self.start = start+        self.end = end+        self.free = free+        self.rate = rate+    }+}++/// Server-assigned pricing plan. The id and timestamps are populated by the+/// backend; the client treats them as opaque. Dates are kept as YYYY-MM-DD+/// strings to match `DayEnergy.date` and so day-membership tests can use+/// lexicographic string comparison.+///+/// The plan is stored as entered — a default rate plus the exception windows+/// that deviate from it (Decision 4) — and `endDate` is the exclusive switch+/// date (Decision 5). Mirrors `dynamo.PricingItem` / `plan.Plan`.+public struct PricingPlan: Identifiable, Codable, Sendable, Equatable, Hashable {+    public let id: String+    public let startDate: String+    /// Exclusive: the plan prices `[startDate, endDate)`, so a plan ending on+    /// the date its successor starts hands the switch day to the successor.+    /// `nil` means open-ended.+    public let endDate: String?+    public let defaultRate: Double+    public let windows: [PlanWindow]+    public let feedInRate: Double+    /// Present iff the plan has a free window; the rate free-window energy is+    /// valued at.+    public let savingsReferenceRate: Double?+    public let createdAt: Date+    public let updatedAt: Date++    public init(+        id: String,+        startDate: String,+        endDate: String?,+        defaultRate: Double,+        windows: [PlanWindow],+        feedInRate: Double,+        savingsReferenceRate: Double?,+        createdAt: Date,+        updatedAt: Date+    ) {+        self.id = id+        self.startDate = startDate+        self.endDate = endDate+        self.defaultRate = defaultRate+        self.windows = windows+        self.feedInRate = feedInRate+        self.savingsReferenceRate = savingsReferenceRate+        self.createdAt = createdAt+        self.updatedAt = updatedAt+    }++    /// Returns true iff `date` (YYYY-MM-DD) falls within `[startDate, endDate)`.+    /// The end date is exclusive (Decision 5), so the switch day belongs to the+    /// successor.+    public func covers(date: String) -> Bool {+        guard date >= startDate else { return false }+        guard let endDate else { return true }+        return date < endDate+    }+}++public extension PricingPlan {+    /// The plan's contiguous full-day band list, derived from the default rate+    /// and the exception windows. The result always starts at "00:00", ends at+    /// "24:00", and contains no gaps, overlaps, or zero-width entries.+    ///+    /// Abutting segments carrying the same rate are deliberately not merged+    /// (Q26): the stored per-band split joins to this geometry, so it has to+    /// stay stable against a merge that would depend on rate equality.+    ///+    /// Windows that fail to parse are skipped — `PricingPlanDraft.validate` is+    /// where they are reported, so this stays a total function.+    var segments: [PlanSegment] {+        let bands = windows+            .compactMap(ParsedBand.init)+            .sorted { $0.start < $1.start }++        var segments: [PlanSegment] = []+        segments.reserveCapacity(bands.count * 2 + 1)++        func appendDefault(fromMinute: Int, toMinute: Int) {+            guard fromMinute < toMinute else { return }+            segments.append(PlanSegment(+                start: PlanWindow.formatBandTime(fromMinute),+                end: PlanWindow.formatBandTime(toMinute),+                free: false,+                rate: defaultRate+            ))+        }++        var cursor = 0+        for band in bands {+            // An overlapping window is invalid (validate reports bandOverlap);+            // skipping it keeps the tiling invariant intact rather than+            // emitting an inverted segment.+            guard band.start >= cursor else { continue }+            appendDefault(fromMinute: cursor, toMinute: band.start)+            segments.append(PlanSegment(+                start: PlanWindow.formatBandTime(band.start),+                end: PlanWindow.formatBandTime(band.end),+                free: band.free,+                rate: band.free ? 0 : band.rate+            ))+            cursor = band.end+        }+        appendDefault(fromMinute: cursor, toMinute: PlanWindow.minutesPerDay)+        return segments+    }++    /// `segments` filtered to the non-free bands — the geometry stored in a+    /// day's `bandImports`. Free-window import lives on the off-peak row, which+    /// owns it exclusively (Q31).+    var ratedSegments: [PlanSegment] {+        segments.filter { !$0.free }+    }++    /// The plan's free band, or `nil` when it has none. Callers must treat+    /// `nil` as "no window" and never substitute a default window (AC 4.4).+    var freeWindow: PlanSegment? {+        segments.first { $0.free }+    }++    /// The plan pricing the given date. At most one plan covers any date+    /// (AC 2.1) — the validation rules make overlapping ranges unstorable — so+    /// the first match is the only match.+    static func plan(for date: String, in plans: [PricingPlan]) -> PricingPlan? {+        plans.first { $0.covers(date: date) }+    }++    /// The free window of the plan pricing the given date (AC 4.1). `nil` when+    /// no plan covers the date or the covering plan has no free band — the two+    /// "no window" outcomes callers treat alike.+    static func freeWindow(for date: String, in plans: [PricingPlan]) -> PlanSegment? {+        plan(for: date, in: plans)?.freeWindow+    }+}++/// Server response from POST /pricing/replace-open-ended: the closing plan+/// (its exclusive end date set to the successor's start date) and the new+/// open-ended plan.+public struct ReplaceOpenEndedResult: Sendable, Equatable {+    public let closing: PricingPlan+    public let newPlan: PricingPlan++    public init(closing: PricingPlan, newPlan: PricingPlan) {+        self.closing = closing+        self.newPlan = newPlan+    }+}

diff --git a/Flux/Packages/FluxCore/Sources/FluxCore/Pricing/PricingPlanDraft.swift b/Flux/Packages/FluxCore/Sources/FluxCore/Pricing/PricingPlanDraft.swiftnew file mode 100644index 0000000..2e16cc3--- /dev/null+++ b/Flux/Packages/FluxCore/Sources/FluxCore/Pricing/PricingPlanDraft.swift@@ -0,0 +1,181 @@+import Foundation++/// The editable shape used by the pricing editor. The backend assigns id /+/// createdAt / updatedAt on POST, so the draft only carries the writable+/// fields. Server-side validation is authoritative; local validation is for+/// early editor feedback and mirrors the server rules so a plan accepted+/// locally is not rejected for a rule the client could have checked (AC 6.4).+public struct PricingPlanDraft: Codable, Sendable, Equatable {+    public var startDate: String+    /// Exclusive switch date (Decision 5); `nil` means open-ended.+    public var endDate: String?+    public var defaultRate: Double+    public var windows: [PlanWindow]+    public var feedInRate: Double+    public var savingsReferenceRate: Double?++    public init(+        startDate: String = "",+        endDate: String? = nil,+        defaultRate: Double = 0,+        windows: [PlanWindow] = [],+        feedInRate: Double = 0,+        savingsReferenceRate: Double? = nil+    ) {+        self.startDate = startDate+        self.endDate = endDate+        self.defaultRate = defaultRate+        self.windows = windows+        self.feedInRate = feedInRate+        self.savingsReferenceRate = savingsReferenceRate+    }++    public init(plan: PricingPlan) {+        self.startDate = plan.startDate+        self.endDate = plan.endDate+        self.defaultRate = plan.defaultRate+        self.windows = plan.windows+        self.feedInRate = plan.feedInRate+        self.savingsReferenceRate = plan.savingsReferenceRate+    }++    /// Reasons a draft can fail validation. Mirrors the backend error codes in+    /// `internal/plan`; `invalidStartDate` / `invalidEndDate` are the local+    /// split of the server's single `inverted_dates` code. Cross-plan rules+    /// (date-range overlap, the single-open-ended rule) run server-side only.+    public enum ValidationError: Error, Equatable, Sendable {+        case invalidStartDate+        case invalidEndDate+        case invertedDates+        case bandWindowInvalid+        case bandOverlap+        case multipleFreeBands+        case noRatedBand+        case savingsRateMissing+        case rateOutOfRange+        case ratePrecision+    }++    /// The per-rate upper bound carried over from the flat-rate model — 10× the+    /// highest plausible AU retail tariff, which catches order-of-magnitude+    /// typos without constraining real use.+    public static let rateCap = 10.0++    /// Local pre-flight validation. The server re-validates — this is purely+    /// for early editor feedback. Returns `nil` when valid. The rule order+    /// matches the server's so the first message the editor shows is the one+    /// the server would report first.+    public func validate() -> ValidationError? {+        if let dateError = validateDates() { return dateError }+        if let bandError = validateBands() { return bandError }+        return validateRates()+    }++    /// Returns the rate rounded to exactly four decimal places. The backend+    /// stores rates at 4dp; this helper keeps the wire payload consistent.+    public static func roundedToFourDP(_ rate: Double) -> Double {+        (rate * 10_000).rounded() / 10_000+    }++    /// The draft with every rate normalised to the backend's 4dp storage+    /// precision. A free window's stale rate is dropped rather than rounded —+    /// it carries no rate by contract.+    public func normalised() -> PricingPlanDraft {+        PricingPlanDraft(+            startDate: startDate,+            endDate: endDate,+            defaultRate: Self.roundedToFourDP(defaultRate),+            windows: windows.map { window in+                PlanWindow(+                    start: window.start,+                    end: window.end,+                    free: window.free,+                    rate: window.free ? nil : Self.roundedToFourDP(window.rate ?? 0)+                )+            },+            feedInRate: Self.roundedToFourDP(feedInRate),+            savingsReferenceRate: savingsReferenceRate.map(Self.roundedToFourDP)+        )+    }++    // MARK: - Rule groups++    private func validateDates() -> ValidationError? {+        guard Self.isValidDate(startDate) else { return .invalidStartDate }+        guard let endDate else { return nil }+        guard Self.isValidDate(endDate) else { return .invalidEndDate }+        // Exclusive ends make endDate == startDate a plan that prices no days.+        guard endDate > startDate else { return .invertedDates }+        return nil+    }++    private func validateBands() -> ValidationError? {+        var parsed: [ParsedBand] = []+        for window in windows {+            guard let band = ParsedBand(window) else { return .bandWindowInvalid }+            parsed.append(band)+        }++        let sorted = parsed.sorted { $0.start < $1.start }+        for index in 1 ..< max(sorted.count, 1) where sorted[index].start < sorted[index - 1].end {+            return .bandOverlap+        }++        let free = parsed.filter(\.free)+        if free.count > 1 { return .multipleFreeBands }+        // AC 1.3: at least one rated band. The only way to have none is a free+        // window covering the whole day — a zero-width default remainder left+        // by rated windows tiling the rest is fine.+        let freeMinutes = free.reduce(0) { $0 + ($1.end - $1.start) }+        if !free.isEmpty, freeMinutes >= PlanWindow.minutesPerDay { return .noRatedBand }+        if !free.isEmpty, savingsReferenceRate == nil { return .savingsRateMissing }+        return nil+    }++    private func validateRates() -> ValidationError? {+        var rates = [defaultRate, feedInRate]+        if let savingsReferenceRate { rates.append(savingsReferenceRate) }+        // A free window's rate is skipped — it carries no rate by contract.+        rates.append(contentsOf: windows.filter { !$0.free }.map { $0.rate ?? 0 })++        for rate in rates {+            if !Self.fitsFourDecimalPlaces(rate) { return .ratePrecision }+            if rate < 0 || rate > Self.rateCap { return .rateOutOfRange }+        }+        return nil+    }++    // MARK: - Primitives++    private static func isValidDate(_ value: String) -> Bool {+        // YYYY-MM-DD — strictly 10 characters with hyphen positions at 5 and 8.+        guard value.count == 10 else { return false }+        let chars = Array(value)+        guard chars[4] == "-", chars[7] == "-" else { return false }+        guard let year = Int(String(chars[0 ..< 4])),+              let month = Int(String(chars[5 ..< 7])),+              let day = Int(String(chars[8 ..< 10])) else { return false }+        guard year >= 1970, year <= 9999 else { return false }+        guard (1 ... 12).contains(month) else { return false }+        guard (1 ... 31).contains(day) else { return false }+        // Calendar-day check so 2026-02-30 fails client-side instead of+        // round-tripping to the server and surfacing as the misleading+        // "endDate must not precede startDate" message. Go's time.Parse on the+        // wire already enforces this; this keeps the pre-flight validator in+        // agreement with the authoritative server check.+        var calendar = Calendar(identifier: .iso8601)+        calendar.timeZone = DateFormatting.sydneyTimeZone+        let components = DateComponents(year: year, month: month, day: day)+        return calendar.date(from: components).map {+            let resolved = calendar.dateComponents([.year, .month, .day], from: $0)+            return resolved.year == year && resolved.month == month && resolved.day == day+        } ?? false+    }++    private static func fitsFourDecimalPlaces(_ rate: Double) -> Bool {+        // A rate fits 4dp if rate * 10_000 is (numerically) very close to an+        // integer. Float64 noise at 4dp is well below 1e-6, so this is safe.+        let scaled = rate * 10_000+        return abs(scaled - scaled.rounded()) < 1e-6+    }+}

diff --git a/Flux/Packages/FluxCore/Sources/FluxCore/Pricing/PricingService.swift b/Flux/Packages/FluxCore/Sources/FluxCore/Pricing/PricingService.swiftindex f2d0728..a388cb8 100644--- a/Flux/Packages/FluxCore/Sources/FluxCore/Pricing/PricingService.swift+++ b/Flux/Packages/FluxCore/Sources/FluxCore/Pricing/PricingService.swift@@ -1,7 +1,7 @@ import Foundation  /// Owns the pricing cache and the mutating CRUD path. View models read-/// `periods` directly; AC 2.7 requires a fetch on every UI entry point and+/// `plans` directly; AC 2.7 requires a fetch on every UI entry point and /// immediately after any mutation. The post-mutation refetch is /// fire-and-forget so the editor sees instant local feedback while the /// authoritative list lands on the next tick.@@ -10,7 +10,7 @@ import Foundation public final class PricingService {     public static let shared = PricingService() -    public private(set) var periods: [PricingPeriod] = []+    public private(set) var plans: [PricingPlan] = []     public private(set) var lastError: Error?      private var apiClient: (any FluxAPIClient)?@@ -36,7 +36,7 @@ public final class PricingService {             // Bail if the task was cancelled mid-flight — a fresher             // refresh has already overtaken us.             try Task.checkCancellation()-            periods = remote.sorted { $0.startDate < $1.startDate }+            plans = remote.sorted { $0.startDate < $1.startDate }             lastError = nil         } catch is CancellationError {             // Cancelled refreshes are not failures; leave state alone.@@ -48,7 +48,7 @@ public final class PricingService {     }      @discardableResult-    public func create(_ draft: PricingPeriodDraft) async throws -> PricingPeriod {+    public func create(_ draft: PricingPlanDraft) async throws -> PricingPlan {         guard let apiClient else {             lastError = FluxAPIError.notConfigured             throw FluxAPIError.notConfigured@@ -66,7 +66,7 @@ public final class PricingService {     }      @discardableResult-    public func update(id: String, _ draft: PricingPeriodDraft) async throws -> PricingPeriod {+    public func update(id: String, _ draft: PricingPlanDraft) async throws -> PricingPlan {         guard let apiClient else {             lastError = FluxAPIError.notConfigured             throw FluxAPIError.notConfigured@@ -90,7 +90,7 @@ public final class PricingService {         }         do {             try await apiClient.deletePricing(id: id)-            periods.removeAll { $0.id == id }+            plans.removeAll { $0.id == id }             lastError = nil             scheduleRefetch()         } catch {@@ -102,8 +102,8 @@ public final class PricingService {     @discardableResult     public func replaceOpenEnded(         closingId: String,-        with draft: PricingPeriodDraft-    ) async throws -> PricingPeriod {+        with draft: PricingPlanDraft+    ) async throws -> PricingPlan {         guard let apiClient else {             lastError = FluxAPIError.notConfigured             throw FluxAPIError.notConfigured@@ -112,34 +112,34 @@ public final class PricingService {             let result = try await apiClient.replaceOpenEndedPricing(closingId: closingId, with: draft)             // Sort once after both folds rather than re-sorting per insert.             foldInsert(result.closing, sort: false)-            foldInsert(result.newPeriod, sort: false)-            periods.sort { $0.startDate < $1.startDate }+            foldInsert(result.newPlan, sort: false)+            plans.sort { $0.startDate < $1.startDate }             lastError = nil             scheduleRefetch()-            return result.newPeriod+            return result.newPlan         } catch {             lastError = error             throw error         }     } -    private func foldInsert(_ period: PricingPeriod, sort: Bool = true) {-        if let idx = periods.firstIndex(where: { $0.id == period.id }) {-            periods[idx] = period+    private func foldInsert(_ plan: PricingPlan, sort: Bool = true) {+        if let idx = plans.firstIndex(where: { $0.id == plan.id }) {+            plans[idx] = plan         } else {-            periods.append(period)+            plans.append(plan)         }         if sort {-            periods.sort { $0.startDate < $1.startDate }+            plans.sort { $0.startDate < $1.startDate }         }     } -    private func foldReplace(_ period: PricingPeriod) {-        if let idx = periods.firstIndex(where: { $0.id == period.id }) {-            periods[idx] = period-            periods.sort { $0.startDate < $1.startDate }+    private func foldReplace(_ plan: PricingPlan) {+        if let idx = plans.firstIndex(where: { $0.id == plan.id }) {+            plans[idx] = plan+            plans.sort { $0.startDate < $1.startDate }         } else {-            foldInsert(period)+            foldInsert(plan)         }     } 

diff --git a/Flux/Packages/FluxCore/Tests/FluxCoreTests/APIModelsBandTests.swift b/Flux/Packages/FluxCore/Tests/FluxCoreTests/APIModelsBandTests.swiftnew file mode 100644index 0000000..e474f7c--- /dev/null+++ b/Flux/Packages/FluxCore/Tests/FluxCoreTests/APIModelsBandTests.swift@@ -0,0 +1,191 @@+import Foundation+import Testing+@testable import FluxCore++/// Wire-shape coverage for the band split and the nullable off-peak window+/// (`time-of-use-pricing`).+@Suite+struct APIModelsBandTests {+    // MARK: - bandImports and off-peak provenance++    @Test+    func daySummaryDecodesBandImportsAndOffpeakGeometry() throws {+        let json = """+        {+          "epv": 12.0, "eInput": 23.0, "eOutput": 15.0,+          "eCharge": 8.0, "eDischarge": 7.0,+          "socLow": 20.0, "socLowTime": "2026-08-15T06:00:00+10:00",+          "offpeakGridImportKwh": 3.0,+          "offpeakWindowStart": "10:00",+          "offpeakWindowEnd": "15:00",+          "offpeakIntegratedAt": "2026-08-16T05:00:00Z",+          "offpeakSampleCount": 1500,+          "bandImports": [+            { "start": "00:00", "end": "01:00", "kwh": 1.0 },+            { "start": "01:00", "end": "06:00", "kwh": 4.0 },+            { "start": "06:00", "end": "10:00", "kwh": 2.0 },+            { "start": "15:00", "end": "24:00", "kwh": 8.0 }+          ]+        }+        """+        let summary = try JSONDecoder().decode(DaySummary.self, from: Data(json.utf8))+        #expect(summary.bandImports?.count == 4)+        #expect(summary.bandImports?[1] == BandImport(start: "01:00", end: "06:00", kwh: 4.0))+        #expect(summary.offpeakWindowStart == "10:00")+        #expect(summary.offpeakWindowEnd == "15:00")+        #expect(summary.offpeakIntegratedAt == "2026-08-16T05:00:00Z")+        #expect(summary.offpeakSampleCount == 1500)+    }++    @Test+    func daySummaryWithoutABandSplitDecodesToNil() throws {+        let json = """+        {+          "epv": 12.0, "eInput": 23.0, "eOutput": 15.0,+          "eCharge": 8.0, "eDischarge": 7.0,+          "socLow": null, "socLowTime": null+        }+        """+        let summary = try JSONDecoder().decode(DaySummary.self, from: Data(json.utf8))+        // Absent, not an empty array — an empty array would read as "zero+        // import in every band".+        #expect(summary.bandImports == nil)+        #expect(summary.offpeakWindowStart == nil)+        #expect(summary.offpeakSampleCount == nil)+    }++    @Test+    func dayEnergyDecodesBandImportsAndOffpeakGeometry() throws {+        let json = """+        {+          "date": "2026-08-15",+          "epv": 12.0, "eInput": 23.0, "eOutput": 15.0,+          "eCharge": 8.0, "eDischarge": 7.0,+          "offpeakGridImportKwh": 3.0,+          "offpeakWindowStart": "10:00",+          "offpeakWindowEnd": "15:00",+          "bandImports": [+            { "start": "00:00", "end": "10:00", "kwh": 6.0 },+            { "start": "15:00", "end": "24:00", "kwh": 8.0 }+          ],+          "note": null+        }+        """+        let day = try JSONDecoder().decode(DayEnergy.self, from: Data(json.utf8))+        #expect(day.bandImports?.count == 2)+        #expect(day.offpeakWindowStart == "10:00")+        #expect(day.offpeakWindowEnd == "15:00")+        #expect(day.offpeakIntegratedAt == nil)+    }++    // MARK: - Off-peak row reconstruction++    @Test+    func costInputsBuildTheOffpeakRowFromTheFlatWireFields() {+        let summary = DaySummary(+            epv: nil, eInput: 23, eOutput: 15,+            eCharge: nil, eDischarge: nil,+            socLow: nil, socLowTime: nil,+            offpeakGridImportKwh: 3,+            offpeakWindowStart: "10:00",+            offpeakWindowEnd: "15:00",+            offpeakIntegratedAt: "2026-08-16T05:00:00Z",+            offpeakSampleCount: 1500+        )+        let offpeak = summary.costInputs.offpeak+        #expect(offpeak?.gridImportKwh == 3)+        #expect(offpeak?.geometry.start == "10:00")+        #expect(offpeak?.isUsable == true)+    }++    @Test+    func aDayWithNoOffpeakImportHasNoOffpeakRowAtAll() {+        let summary = DaySummary(+            epv: nil, eInput: 23, eOutput: 15,+            eCharge: nil, eDischarge: nil,+            socLow: nil, socLowTime: nil,+            offpeakGridImportKwh: nil+        )+        #expect(summary.costInputs.offpeak == nil)+    }++    @Test+    func aRowWithoutGeometryFallsBackToTheOnlyWindowItCanHaveHad() {+        let row = OffpeakImport(gridImportKwh: 6)+        #expect(row.geometry.start == "11:00")+        #expect(row.geometry.end == "14:00")+        #expect(row.isUsable)+    }++    @Test+    func aSparseCompleteRowIsNotAMeasurement() {+        let row = OffpeakImport(+            gridImportKwh: 0,+            windowStart: "10:00",+            windowEnd: "15:00",+            integratedAt: "2026-08-16T05:00:00Z",+            sampleCount: 0+        )+        #expect(!row.isUsable)+    }++    // MARK: - Nullable off-peak window (Q35)++    @Test+    func offpeakDataDecodesWithoutWindowStrings() throws {+        let json = """+        {+          "windowStart": null,+          "windowEnd": null,+          "gridUsageKwh": 1.0,+          "solarKwh": null,+          "batteryChargeKwh": null,+          "batteryDischargeKwh": null,+          "gridExportKwh": null,+          "batteryDeltaPercent": null,+          "projectedEndSoc": null+        }+        """+        let offpeak = try JSONDecoder().decode(OffpeakData.self, from: Data(json.utf8))+        #expect(offpeak.windowStart == nil)+        #expect(offpeak.windowEnd == nil)+        #expect(offpeak.gridUsageKwh == 1.0)+    }++    @Test+    func aNoFreeBandDayServesANullOffpeakObject() throws {+        let json = """+        {+          "live": null, "battery": null, "rolling15min": null,+          "offpeak": null, "todayEnergy": null, "note": null+        }+        """+        let status = try JSONDecoder().decode(StatusResponse.self, from: Data(json.utf8))+        #expect(status.offpeak == nil)+    }++    // MARK: - No default-window substitution++    @Test+    func gridTintTreatsAnAbsentWindowAsOutsideTheWindow() {+        let now = Date(timeIntervalSince1970: 1_776_000_000)+        // Sustained import above the threshold is red when there is no free+        // window to protect it — the same outcome as being outside one.+        let tier = GridColor.forGrid(+            pgrid: 900,+            pgridSustained: true,+            offpeakWindowStart: nil,+            offpeakWindowEnd: nil,+            now: now+        )+        #expect(tier == .red)+    }++    @Test+    func cutoffTintIsNeutralWithoutAWindow() {+        let now = Date(timeIntervalSince1970: 1_776_000_000)+        // Far enough out that only the window comparison could escalate it.+        let cutoff = now.addingTimeInterval(5 * 60 * 60)+        #expect(CutoffTimeColor.forCutoff(cutoff, offpeakWindowStart: nil, now: now) == .normal)+    }+}

diff --git a/Flux/Packages/FluxCore/Tests/FluxCoreTests/DateFormattingTests.swift b/Flux/Packages/FluxCore/Tests/FluxCoreTests/DateFormattingTests.swiftindex f11df5a..a7a0240 100644--- a/Flux/Packages/FluxCore/Tests/FluxCoreTests/DateFormattingTests.swift+++ b/Flux/Packages/FluxCore/Tests/FluxCoreTests/DateFormattingTests.swift@@ -62,8 +62,37 @@ import Testing     @Test     func parseWindowTimeRejectsInvalidFormats() {         #expect(DateFormatting.parseWindowTime("invalid") == nil)-        #expect(DateFormatting.parseWindowTime("24:00") == nil)         #expect(DateFormatting.parseWindowTime("09:60") == nil)+        // 24:00 is the only valid hour-24 value: it is the end-of-day sentinel,+        // not a time of day.+        #expect(DateFormatting.parseWindowTime("24:01") == nil)+        #expect(DateFormatting.parseWindowTime("25:00") == nil)+    }++    @Test+    func parseWindowTimeResolvesEndOfDaySentinel() throws {+        // A plan's free band may run to midnight, and the band model expresses+        // that as an end of "24:00" (plan.ParseBandTime / PlanWindow accept it).+        // Rejecting it here would make every consumer treat such a day as+        // having no free window at all.+        let now = makeSydneyDate(year: 2026, month: 4, day: 15, hour: 9, minute: 5)+        let midnight = try #require(DateFormatting.parseWindowTime("24:00", on: now))+        let components = sydneyCalendar.dateComponents([.year, .month, .day, .hour, .minute], from: midnight)++        #expect(components.year == 2026)+        #expect(components.month == 4)+        #expect(components.day == 16, "end-of-day is the start of the following day")+        #expect(components.hour == 0)+        #expect(components.minute == 0)+    }++    @Test+    func isInOffpeakWindowHandlesAFreeBandRunningToMidnight() {+        let insideWindow = makeSydneyDate(year: 2026, month: 4, day: 15, hour: 23, minute: 30)+        let beforeWindow = makeSydneyDate(year: 2026, month: 4, day: 15, hour: 19, minute: 59)++        #expect(DateFormatting.isInOffpeakWindow(start: "20:00", end: "24:00", now: insideWindow))+        #expect(DateFormatting.isInOffpeakWindow(start: "20:00", end: "24:00", now: beforeWindow) == false)     }      @Test

diff --git a/Flux/Packages/FluxCore/Tests/FluxCoreTests/DayCostsTests.swift b/Flux/Packages/FluxCore/Tests/FluxCoreTests/DayCostsTests.swiftindex d15d427..f5646f6 100644--- a/Flux/Packages/FluxCore/Tests/FluxCoreTests/DayCostsTests.swift+++ b/Flux/Packages/FluxCore/Tests/FluxCoreTests/DayCostsTests.swift@@ -4,199 +4,336 @@ import Testing  @Suite struct DayCostsTests {-    // MARK: - DaySummary.costs(forDate:in:)+    // MARK: - Tier 2: the pre-band formula, verbatim (Q30)      @Test-    func costsHappyPathWithFullSplit() throws {-        let pricing = [period(start: "2026-04-01", end: nil, peak: 0.30, feedIn: 0.05, offPeak: 0.10)]+    func singleRatePlanUsesTheLegacyFormulaWithTheOffpeakResidual() throws {+        let pricing = [singleRatePlan(start: "2026-04-01", end: nil, rate: 0.30, feedIn: 0.05, savings: 0.10)]         let summary = makeSummary(eInput: 10, eOutput: 4, offpeakKwh: 3) -        let costs = summary.costs(forDate: "2026-04-15", in: pricing)-        let unwrapped = try #require(costs)+        let costs = try #require(summary.costs(forDate: "2026-04-15", in: pricing))+        #expect(costs.tier == .singleRate)         // peak imports kWh = 10 - 3 = 7-        #expect(unwrapped.peakImportsCost == 7 * 0.30)-        #expect(unwrapped.solarFeedInIncome == 4 * 0.05)-        #expect(unwrapped.offPeakSavings == 3 * 0.10)-        #expect(unwrapped.net == 7 * 0.30 - 4 * 0.05)+        #expect(costs.peakImportsCost == 7 * 0.30)+        #expect(costs.solarFeedInIncome == 4 * 0.05)+        #expect(costs.offPeakSavings == 3 * 0.10)+        #expect(costs.net == 7 * 0.30 - 4 * 0.05)     }      @Test-    func costsTreatsNilOffpeakSplitAsZeroAndBillsAllImportsAsPeak() throws {-        let pricing = [period(start: "2026-04-01", end: nil, peak: 0.30, feedIn: 0.05, offPeak: 0.10)]+    func nilOffpeakSplitBillsAllImportsAtThePlanRateWithNoSavings() throws {+        let pricing = [singleRatePlan(start: "2026-04-01", end: nil, rate: 0.30, feedIn: 0.05, savings: 0.10)]         let summary = makeSummary(eInput: 10, eOutput: 4, offpeakKwh: nil) -        let costs = summary.costs(forDate: "2026-04-15", in: pricing)-        let unwrapped = try #require(costs)-        // Decision 23: all 10 kWh peak when split is nil.-        #expect(unwrapped.peakImportsCost == 10 * 0.30)-        #expect(unwrapped.offPeakSavings == 0)+        let costs = try #require(summary.costs(forDate: "2026-04-15", in: pricing))+        #expect(costs.peakImportsCost == 10 * 0.30)+        #expect(costs.offPeakSavings == 0)     }      @Test-    func costsTreatsNilFieldsAsZero() throws {-        let pricing = [period(start: "2026-04-01", end: nil, peak: 0.30, feedIn: 0.05, offPeak: 0.10)]+    func nilEnergyFieldsAreTreatedAsZeroAndStillPriceTheDay() throws {+        let pricing = [singleRatePlan(start: "2026-04-01", end: nil, rate: 0.30, feedIn: 0.05, savings: 0.10)]         let summary = DaySummary(             epv: nil, eInput: nil, eOutput: nil,             eCharge: nil, eDischarge: nil,-            socLow: nil, socLowTime: nil,-            offpeakGridImportKwh: nil, offpeakGridExportKwh: nil+            socLow: nil, socLowTime: nil         )-        let costs = summary.costs(forDate: "2026-04-15", in: pricing)-        let unwrapped = try #require(costs)-        #expect(unwrapped.peakImportsCost == 0)-        #expect(unwrapped.solarFeedInIncome == 0)-        #expect(unwrapped.offPeakSavings == 0)-        #expect(unwrapped.net == 0)+        let costs = try #require(summary.costs(forDate: "2026-04-15", in: pricing))+        #expect(costs.peakImportsCost == 0)+        #expect(costs.solarFeedInIncome == 0)+        #expect(costs.offPeakSavings == 0)+        #expect(costs.net == 0)     }      @Test-    func costsZeroValuesProduceZeroLines() throws {-        let pricing = [period(start: "2026-04-01", end: nil, peak: 0.30, feedIn: 0.05, offPeak: 0.10)]-        let summary = makeSummary(eInput: 0, eOutput: 0, offpeakKwh: 0)+    func serverPeakIsPreferredOverTheResidual() throws {+        // Server peak (6.5) deliberately differs from the residual+        // eInput − offpeak (10 − 3 = 7), so this proves the measured value wins.+        let pricing = [singleRatePlan(start: "2026-04-01", end: nil, rate: 0.30, feedIn: 0.05, savings: 0.10)]+        let summary = makeSummary(eInput: 10, eOutput: 4, offpeakKwh: 3, peakKwh: 6.5) -        let costs = summary.costs(forDate: "2026-04-15", in: pricing)-        let unwrapped = try #require(costs)-        #expect(unwrapped.peakImportsCost == 0)-        #expect(unwrapped.solarFeedInIncome == 0)-        #expect(unwrapped.offPeakSavings == 0)-        #expect(unwrapped.net == 0)+        let costs = try #require(summary.costs(forDate: "2026-04-15", in: pricing))+        #expect(costs.peakImportsCost == 6.5 * 0.30)+        // Savings still price the measured off-peak kWh unchanged.+        #expect(costs.offPeakSavings == 3 * 0.10)+        #expect(costs.net == 6.5 * 0.30 - 4 * 0.05)     }      @Test-    func costsReturnsNilWhenDateNotCoveredByAnyPeriod() throws {-        let pricing = [period(start: "2026-04-01", end: "2026-04-30", peak: 0.30, feedIn: 0.05, offPeak: 0.10)]-        let summary = makeSummary(eInput: 10, eOutput: 4, offpeakKwh: 3)+    func peakKwhIsClampedAtZeroWhenOffpeakExceedsEInput() throws {+        let pricing = [singleRatePlan(start: "2026-04-01", end: nil, rate: 0.30, feedIn: 0.05, savings: 0.10)]+        let summary = makeSummary(eInput: 2, eOutput: 0, offpeakKwh: 5)+        let costs = try #require(summary.costs(forDate: "2026-04-15", in: pricing))+        #expect(costs.peakImportsCost == 0)+    } -        #expect(summary.costs(forDate: "2026-05-01", in: pricing) == nil)-        #expect(summary.costs(forDate: "2026-03-31", in: pricing) == nil)+    @Test+    func aSingleRatePlanNeverReachesTheFallbackTier() throws {+        // No split, no server peak, no off-peak row — tier 2 still resolves.+        let pricing = [singleRatePlan(start: "2026-04-01", end: nil, rate: 0.30, feedIn: 0.05, savings: 0.10)]+        let summary = makeSummary(eInput: 10, eOutput: 0, offpeakKwh: nil)+        let costs = try #require(summary.costs(forDate: "2026-04-15", in: pricing))+        #expect(costs.tier == .singleRate)     } +    // MARK: - Tier 1: the stored band split+     @Test-    func costsPicksTheCoveringPeriodWhenMultiplePresent() throws {-        let pricing = [-            period(id: "old", start: "2026-01-01", end: "2026-03-31", peak: 0.20, feedIn: 0.04, offPeak: 0.08),-            period(id: "new", start: "2026-04-01", end: nil, peak: 0.30, feedIn: 0.06, offPeak: 0.12)-        ]-        let summary = makeSummary(eInput: 10, eOutput: 4, offpeakKwh: 3)+    func bandedPathPricesEachRatedBandAtItsOwnRate() throws {+        let pricing = [touPlan(start: "2026-08-01", end: nil)]+        let summary = makeSummary(+            eInput: 23, eOutput: 15, offpeakKwh: 3,+            offpeakWindowStart: "10:00", offpeakWindowEnd: "15:00",+            offpeakIntegratedAt: "2026-08-02T05:00:00Z", offpeakSampleCount: 1500,+            bandImports: [+                BandImport(start: "00:00", end: "01:00", kwh: 1),+                BandImport(start: "01:00", end: "06:00", kwh: 4),+                BandImport(start: "06:00", end: "10:00", kwh: 2),+                BandImport(start: "15:00", end: "24:00", kwh: 8)+            ]+        )+        let costs = try #require(summary.costs(forDate: "2026-08-15", in: pricing))+        #expect(costs.tier == .banded)+        #expect(abs(costs.peakImportsCost - (1 * 0.35 + 4 * 0.28 + 2 * 0.35 + 8 * 0.35)) < 1e-9)+        #expect(abs(costs.offPeakSavings - 3 * 0.35) < 1e-9)+    } -        let aprilCosts = summary.costs(forDate: "2026-04-15", in: pricing)-        #expect(aprilCosts?.peakImportsCost == 7 * 0.30)+    @Test+    func aSparseCompleteOffpeakRowCannotPriceTheFreeBand() throws {+        // integratedAt set with no samples is a zero-delta artifact, not a+        // measured zero, so the free import is unresolvable.+        let pricing = [touPlan(start: "2026-08-01", end: nil)]+        let summary = makeSummary(+            eInput: 23, eOutput: 15, offpeakKwh: 0,+            offpeakWindowStart: "10:00", offpeakWindowEnd: "15:00",+            offpeakIntegratedAt: "2026-08-02T05:00:00Z", offpeakSampleCount: 0,+            bandImports: [+                BandImport(start: "00:00", end: "01:00", kwh: 1),+                BandImport(start: "01:00", end: "06:00", kwh: 4),+                BandImport(start: "06:00", end: "10:00", kwh: 2),+                BandImport(start: "15:00", end: "24:00", kwh: 8)+            ]+        )+        let costs = try #require(summary.costs(forDate: "2026-08-15", in: pricing))+        #expect(costs.tier == .fallback)+    } -        let marchCosts = summary.costs(forDate: "2026-03-15", in: pricing)-        #expect(marchCosts?.peakImportsCost == 7 * 0.20)+    @Test+    func aPartiallyKnownSplitIsUnavailableNotPartiallyUsed() throws {+        let pricing = [touPlan(start: "2026-08-01", end: nil)]+        let summary = makeSummary(+            eInput: 23, eOutput: 15, offpeakKwh: 3,+            offpeakWindowStart: "10:00", offpeakWindowEnd: "15:00",+            offpeakIntegratedAt: "2026-08-02T05:00:00Z", offpeakSampleCount: 1500,+            bandImports: [+                BandImport(start: "00:00", end: "01:00", kwh: 1),+                BandImport(start: "01:00", end: "06:00", kwh: 4)+            ]+        )+        let costs = try #require(summary.costs(forDate: "2026-08-15", in: pricing))+        #expect(costs.tier == .fallback)+        #expect(abs(costs.peakImportsCost - 23 * 0.35) < 1e-9)+        #expect(costs.offPeakSavings == 0)     }      @Test-    func netExcludesOffPeakSavings() throws {-        let pricing = [period(start: "2026-04-01", end: nil, peak: 0.30, feedIn: 0.05, offPeak: 1.00)]-        let summary = makeSummary(eInput: 10, eOutput: 4, offpeakKwh: 3)+    func anOffpeakRowWithoutGeometryIsTreatedAsTheLegacyWindow() throws {+        // Pre-feature rows carry no snapshot; 11:00–14:00 is the only window+        // they can have been computed under, so they match a migrated plan.+        let pricing = [migratedPlan(start: "2026-04-01", end: nil)]+        let summary = makeSummary(+            eInput: 20, eOutput: 15, offpeakKwh: 6,+            bandImports: [+                BandImport(start: "00:00", end: "11:00", kwh: 5),+                BandImport(start: "14:00", end: "24:00", kwh: 9)+            ]+        )         let costs = try #require(summary.costs(forDate: "2026-04-15", in: pricing))-        #expect(costs.net == 7 * 0.30 - 4 * 0.05)-        #expect(costs.offPeakSavings == 3 * 1.00)+        #expect(costs.tier == .banded)+        #expect(abs(costs.peakImportsCost - 14 * 0.35) < 1e-9)     }      @Test-    func costsPrefersServerPeakOverResidualWhenPresent() throws {-        // Server peak (6.5) deliberately differs from the residual eInput-offpeak-        // (10-3=7) so the assertion proves the server value is used, not the residual.-        let pricing = [period(start: "2026-04-01", end: nil, peak: 0.30, feedIn: 0.05, offPeak: 0.10)]-        let summary = makeSummary(eInput: 10, eOutput: 4, offpeakKwh: 3, peakKwh: 6.5)-        let costs = try #require(summary.costs(forDate: "2026-04-15", in: pricing))-        #expect(costs.peakImportsCost == 6.5 * 0.30)-        // Off-peak savings still price the measured off-peak kWh unchanged.-        #expect(costs.offPeakSavings == 3 * 0.10)-        #expect(costs.net == 6.5 * 0.30 - 4 * 0.05)+    func aPlanWithoutAFreeBandNeedsNoOffpeakRow() throws {+        let plan = PricingPlan(+            id: "p", startDate: "2026-08-01", endDate: nil,+            defaultRate: 0.35,+            windows: [PlanWindow(start: "01:00", end: "06:00", free: false, rate: 0.28)],+            feedInRate: 0.05, savingsReferenceRate: nil,+            createdAt: Date(timeIntervalSince1970: 0), updatedAt: Date(timeIntervalSince1970: 0)+        )+        let summary = makeSummary(+            eInput: 15, eOutput: 15, offpeakKwh: nil,+            bandImports: [+                BandImport(start: "00:00", end: "01:00", kwh: 1),+                BandImport(start: "01:00", end: "06:00", kwh: 4),+                BandImport(start: "06:00", end: "24:00", kwh: 10)+            ]+        )+        let costs = try #require(summary.costs(forDate: "2026-08-15", in: [plan]))+        #expect(costs.tier == .banded)+        #expect(costs.offPeakSavings == 0)     } +    // MARK: - Tier 3: the fallback (AC 3.5 / 3.6)+     @Test-    func costsFallsBackToResidualWhenServerPeakNil() throws {-        let pricing = [period(start: "2026-04-01", end: nil, peak: 0.30, feedIn: 0.05, offPeak: 0.10)]-        let summary = makeSummary(eInput: 10, eOutput: 4, offpeakKwh: 3, peakKwh: nil)-        let costs = try #require(summary.costs(forDate: "2026-04-15", in: pricing))-        #expect(costs.peakImportsCost == 7 * 0.30)+    func aMultiRatePlanWithNoSplitPricesEverythingAtTheHighestRate() throws {+        let pricing = [touPlan(start: "2026-08-01", end: nil)]+        let summary = makeSummary(eInput: 23, eOutput: 15, offpeakKwh: 3)+        let costs = try #require(summary.costs(forDate: "2026-08-15", in: pricing))+        #expect(costs.tier == .fallback)+        #expect(abs(costs.peakImportsCost - 23 * 0.35) < 1e-9)+        #expect(costs.offPeakSavings == 0)     }      @Test-    func peakImportsKwhClampedAtZeroWhenOffpeakExceedsEInput() throws {-        // Off-peak should never exceed eInput in real data, but the-        // computation must not produce a negative peak-imports value.-        let pricing = [period(start: "2026-04-01", end: nil, peak: 0.30, feedIn: 0.05, offPeak: 0.10)]-        let summary = makeSummary(eInput: 2, eOutput: 0, offpeakKwh: 5)-        let costs = try #require(summary.costs(forDate: "2026-04-15", in: pricing))-        #expect(costs.peakImportsCost == 0)+    func aSplitCapturedUnderTheOldWindowDegradesToTheFallback() throws {+        let pricing = [touPlan(start: "2026-08-01", end: nil)]+        let summary = makeSummary(+            eInput: 23, eOutput: 15, offpeakKwh: 3,+            offpeakWindowStart: "10:00", offpeakWindowEnd: "15:00",+            offpeakIntegratedAt: "2026-08-02T05:00:00Z", offpeakSampleCount: 1500,+            bandImports: [+                BandImport(start: "00:00", end: "01:00", kwh: 1),+                BandImport(start: "01:00", end: "06:00", kwh: 4),+                BandImport(start: "06:00", end: "11:00", kwh: 2.5),+                BandImport(start: "14:00", end: "24:00", kwh: 9)+            ]+        )+        let costs = try #require(summary.costs(forDate: "2026-08-15", in: pricing))+        #expect(costs.tier == .fallback)+    }++    // MARK: - Plan coverage++    @Test+    func returnsNilWhenNoPlanCoversTheDate() throws {+        let pricing = [singleRatePlan(start: "2026-04-01", end: "2026-05-01", rate: 0.30, feedIn: 0.05, savings: 0.10)]+        let summary = makeSummary(eInput: 10, eOutput: 4, offpeakKwh: 3)++        #expect(summary.costs(forDate: "2026-05-01", in: pricing) == nil)+        #expect(summary.costs(forDate: "2026-03-31", in: pricing) == nil)+        #expect(summary.costs(forDate: "2026-04-30", in: pricing) != nil)+    }++    @Test+    func switchDayIsPricedByTheSuccessor() throws {+        let pricing = [+            singleRatePlan(id: "old", start: "2026-01-01", end: "2026-08-01", rate: 0.20, feedIn: 0.04, savings: 0.08),+            singleRatePlan(id: "new", start: "2026-08-01", end: nil, rate: 0.30, feedIn: 0.06, savings: 0.12)+        ]+        let summary = makeSummary(eInput: 10, eOutput: 4, offpeakKwh: 3)++        #expect(summary.costs(forDate: "2026-07-31", in: pricing)?.peakImportsCost == 7 * 0.20)+        #expect(summary.costs(forDate: "2026-08-01", in: pricing)?.peakImportsCost == 7 * 0.30)+    }++    @Test+    func emptyPlanListReturnsNil() throws {+        let summary = makeSummary(eInput: 10, eOutput: 4, offpeakKwh: 3)+        #expect(summary.costs(forDate: "2026-04-15", in: []) == nil)     }      // MARK: - DayEnergy.costs(in:)      @Test-    func dayEnergyForwardsToDaySummaryExtension() throws {-        let pricing = [period(start: "2026-04-01", end: nil, peak: 0.30, feedIn: 0.05, offPeak: 0.10)]+    func dayEnergyForwardsEveryCostInputIntoTheHelper() throws {+        let pricing = [singleRatePlan(start: "2026-04-01", end: nil, rate: 0.30, feedIn: 0.05, savings: 0.10)]         let day = DayEnergy(             date: "2026-04-15",             epv: 0, eInput: 10, eOutput: 4,             eCharge: 0, eDischarge: 0,             offpeakGridImportKwh: 3, offpeakGridExportKwh: nil,+            peakGridImportKwh: 6.5,             note: nil         )         let costs = try #require(day.costs(in: pricing))-        #expect(costs.peakImportsCost == 7 * 0.30)+        #expect(costs.peakImportsCost == 6.5 * 0.30)         #expect(costs.solarFeedInIncome == 4 * 0.05)         #expect(costs.offPeakSavings == 3 * 0.10)     }      @Test-    func dayEnergyForwardsServerPeakIntoCosts() throws {-        let pricing = [period(start: "2026-04-01", end: nil, peak: 0.30, feedIn: 0.05, offPeak: 0.10)]+    func dayEnergyForwardsTheBandSplit() throws {+        let pricing = [touPlan(start: "2026-08-01", end: nil)]         let day = DayEnergy(-            date: "2026-04-15",-            epv: 0, eInput: 10, eOutput: 4,+            date: "2026-08-15",+            epv: 0, eInput: 23, eOutput: 15,             eCharge: 0, eDischarge: 0,             offpeakGridImportKwh: 3, offpeakGridExportKwh: nil,-            peakGridImportKwh: 6.5,+            peakGridImportKwh: nil,+            bandImports: [+                BandImport(start: "00:00", end: "01:00", kwh: 1),+                BandImport(start: "01:00", end: "06:00", kwh: 4),+                BandImport(start: "06:00", end: "10:00", kwh: 2),+                BandImport(start: "15:00", end: "24:00", kwh: 8)+            ],+            offpeakWindowStart: "10:00",+            offpeakWindowEnd: "15:00",+            offpeakIntegratedAt: "2026-08-16T05:00:00Z",+            offpeakSampleCount: 1500,             note: nil         )         let costs = try #require(day.costs(in: pricing))-        // Forwarder must carry the server peak into the transient DaySummary.-        #expect(costs.peakImportsCost == 6.5 * 0.30)+        #expect(costs.tier == .banded)     }      @Test     func dayEnergyReturnsNilWhenDateNotCovered() throws {-        let pricing = [period(start: "2026-04-01", end: "2026-04-30", peak: 0.30, feedIn: 0.05, offPeak: 0.10)]+        let pricing = [singleRatePlan(start: "2026-04-01", end: "2026-05-01", rate: 0.30, feedIn: 0.05, savings: 0.10)]         let day = DayEnergy(             date: "2026-05-15",             epv: 0, eInput: 10, eOutput: 4,             eCharge: 0, eDischarge: 0,-            offpeakGridImportKwh: 3,-            offpeakGridExportKwh: nil,+            offpeakGridImportKwh: 3, offpeakGridExportKwh: nil,             note: nil         )         #expect(day.costs(in: pricing) == nil)     } -    @Test-    func emptyPricingArrayReturnsNil() throws {-        let summary = makeSummary(eInput: 10, eOutput: 4, offpeakKwh: 3)-        #expect(summary.costs(forDate: "2026-04-15", in: []) == nil)-    }--    // MARK: - helpers+    // MARK: - Helpers -    private func period(+    private func singleRatePlan(         id: String = "p",         start: String,         end: String?,-        peak: Double,+        rate: Double,         feedIn: Double,-        offPeak: Double-    ) -> PricingPeriod {-        PricingPeriod(+        savings: Double+    ) -> PricingPlan {+        PricingPlan(             id: id,             startDate: start,             endDate: end,-            peakRate: peak,+            defaultRate: rate,+            windows: [PlanWindow(start: "11:00", end: "14:00", free: true, rate: nil)],             feedInRate: feedIn,-            offPeakSavingsRate: offPeak,+            savingsReferenceRate: savings,+            createdAt: Date(timeIntervalSince1970: 1),+            updatedAt: Date(timeIntervalSince1970: 1)+        )+    }++    /// The shape every migrated legacy period takes: free 11:00–14:00 plus one+    /// flat rate for the rest of the day (AC 5.1).+    private func migratedPlan(start: String, end: String?) -> PricingPlan {+        singleRatePlan(start: start, end: end, rate: 0.35, feedIn: 0.05, savings: 0.35)+    }++    /// The incoming time-of-use plan: free 10:00–15:00, cheaper 01:00–06:00.+    private func touPlan(start: String, end: String?) -> PricingPlan {+        PricingPlan(+            id: "tou",+            startDate: start,+            endDate: end,+            defaultRate: 0.35,+            windows: [+                PlanWindow(start: "10:00", end: "15:00", free: true, rate: nil),+                PlanWindow(start: "01:00", end: "06:00", free: false, rate: 0.28)+            ],+            feedInRate: 0.05,+            savingsReferenceRate: 0.35,             createdAt: Date(timeIntervalSince1970: 1),             updatedAt: Date(timeIntervalSince1970: 1)         )@@ -206,7 +343,12 @@ struct DayCostsTests {         eInput: Double?,         eOutput: Double?,         offpeakKwh: Double?,-        peakKwh: Double? = nil+        peakKwh: Double? = nil,+        offpeakWindowStart: String? = nil,+        offpeakWindowEnd: String? = nil,+        offpeakIntegratedAt: String? = nil,+        offpeakSampleCount: Int? = nil,+        bandImports: [BandImport]? = nil     ) -> DaySummary {         DaySummary(             epv: nil,@@ -218,7 +360,12 @@ struct DayCostsTests {             socLowTime: nil,             offpeakGridImportKwh: offpeakKwh,             offpeakGridExportKwh: nil,-            peakGridImportKwh: peakKwh+            peakGridImportKwh: peakKwh,+            bandImports: bandImports,+            offpeakWindowStart: offpeakWindowStart,+            offpeakWindowEnd: offpeakWindowEnd,+            offpeakIntegratedAt: offpeakIntegratedAt,+            offpeakSampleCount: offpeakSampleCount         )     } }