M6-T03: add pricing profile framework + strategy registry

- app/integrations/pricing: profiles.py (pydantic ManualProfile/TibberProfile,
  load_profile/list_profiles/validate_values), manual.yaml + tibber.yaml
  (structure-only, no price values), strategies.py (register/get_strategy,
  manual dual-tariff + tibber strategies, all Decimal).
- tibber strategy matches nearest tibber_price with starts_at <= t0.
- tests for profiles + strategies (hand-checked dual-tariff & tibber math).

app/integrations/pricing/__init__.py

@@ -0,0 +1,11 @@
+"""Pricing profile framework and strategy registry.
+
+This package provides:
+
+- ``profiles``: Pydantic models describing the structure of pricing profiles
+  (``ManualProfile`` / ``TibberProfile``), YAML loaders, and contract-values
+  validation (``load_profile`` / ``list_profiles`` / ``validate_values``).
+- ``strategies``: A lightweight registry of price-calculation strategies
+  (``register_strategy`` / ``get_strategy``), with built-in implementations for
+  the ``manual`` (fixed dual-tariff) and ``tibber`` (dynamic API) kinds.
+"""

app/integrations/pricing/profiles.py

@@ -0,0 +1,393 @@
+"""Pricing profile loader, validator, and contract-values checker.
+
+A *pricing profile* is a YAML file that describes the **structure** of an energy
+contract — which fields exist, their units, and which have defaults.  Actual
+pricing values (the numbers the user fills in via the UI) are stored in the DB
+as ``EnergyContractVersion.values`` (a JSON blob) and must conform to the
+corresponding profile's structure.
+
+Profiles live in ``app/integrations/pricing/profiles/<kind>.yaml`` and are
+located at runtime relative to *this file* (not CWD), matching the pattern
+established by the Modbus profile loader.
+
+Design notes
+------------
+- **Purely data + functions** — no abstract base classes or inheritance.
+- Two Pydantic models — ``ManualProfile`` and ``TibberProfile`` — capture the
+  different structures of the two supported kinds.  A thin union dispatcher in
+  ``load_profile`` picks the right one.
+- ``validate_values(kind, values)`` fills in fields that carry a ``default`` and
+  raises ``ProfileValidationError`` for missing required fields or wrong types.
+- All errors are subclasses of built-ins so callers need not import this module
+  just to catch them.
+"""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+from typing import Any, Optional
+
+import yaml
+from pydantic import BaseModel, ValidationError, model_validator
+
+logger = logging.getLogger(__name__)
+
+# Directory containing the YAML profiles, located relative to *this* file.
+_PROFILES_DIR = Path(__file__).parent / "profiles"
+
+
+# ---------------------------------------------------------------------------
+# Custom exceptions
+# ---------------------------------------------------------------------------
+
+
+class ProfileNotFoundError(FileNotFoundError):
+    """Raised when the requested profile YAML file does not exist."""
+
+
+class ProfileValidationError(ValueError):
+    """Raised when a profile YAML fails Pydantic validation or when contract
+    values do not conform to the profile structure."""
+
+
+# ---------------------------------------------------------------------------
+# Leaf-node models (a single pricing field: unit + optional default)
+# ---------------------------------------------------------------------------
+
+
+class FieldSpec(BaseModel):
+    """Specification for a single numeric pricing field."""
+
+    unit: str
+    """Physical / monetary unit string (e.g. ``"EUR/kWh"``, ``"EUR/month"``)."""
+
+    default: Optional[float] = None
+    """Default value used when the field is absent from contract values.
+    ``None`` means the field is required (no default)."""
+
+
+# ---------------------------------------------------------------------------
+# ManualProfile — fixed / variable dual-tariff contract structure
+# ---------------------------------------------------------------------------
+
+
+class ManualBuySpec(BaseModel):
+    normal: FieldSpec  # high-tariff buy price (delivered_2 registers)
+    dal: FieldSpec  # low-tariff buy price (delivered_1 registers)
+
+
+class ManualSellSpec(BaseModel):
+    normal: FieldSpec  # high-tariff sell / return price
+    dal: FieldSpec  # low-tariff sell / return price
+
+
+class ManualEnergySpec(BaseModel):
+    dual_tariff: bool  # always True for manual profiles
+    buy: ManualBuySpec
+    sell: ManualSellSpec
+    energy_tax: FieldSpec  # added to buy price; includes VAT
+    ode: FieldSpec  # currently merged into energy_tax; default 0
+
+
+class ManualStandingSpec(BaseModel):
+    network_fee: FieldSpec  # EUR/month
+    management_fee: FieldSpec  # EUR/month
+
+
+class ManualCreditsSpec(BaseModel):
+    heffingskorting: FieldSpec  # EUR/year — energy-tax credit deducted at summary
+
+
+class ManualProfile(BaseModel):
+    """Complete structure description for a ``manual`` pricing contract."""
+
+    kind: str
+    label: str
+    energy: ManualEnergySpec
+    standing: ManualStandingSpec
+    credits: ManualCreditsSpec
+
+    @model_validator(mode="after")
+    def _check_kind(self) -> "ManualProfile":
+        if self.kind != "manual":
+            raise ValueError(f"ManualProfile requires kind='manual', got {self.kind!r}")
+        return self
+
+
+# ---------------------------------------------------------------------------
+# TibberProfile — dynamic Tibber API contract structure
+# ---------------------------------------------------------------------------
+
+
+class TibberEnergySpec(BaseModel):
+    source: str  # must be "tibber_api"
+    energy_tax: FieldSpec  # subtracted from total to derive sell price
+    sell_adjust: FieldSpec  # additional sell-price adjustment; default 0
+
+
+class TibberStandingSpec(BaseModel):
+    management_fee: FieldSpec  # EUR/month; has a default
+    network_fee: FieldSpec  # EUR/month
+
+
+class TibberCreditsSpec(BaseModel):
+    heffingskorting: FieldSpec  # EUR/year
+
+
+class TibberProfile(BaseModel):
+    """Complete structure description for a ``tibber`` pricing contract."""
+
+    kind: str
+    label: str
+    energy: TibberEnergySpec
+    standing: TibberStandingSpec
+    credits: TibberCreditsSpec
+
+    @model_validator(mode="after")
+    def _check_kind(self) -> "TibberProfile":
+        if self.kind != "tibber":
+            raise ValueError(f"TibberProfile requires kind='tibber', got {self.kind!r}")
+        return self
+
+
+# A union type for type hints where either profile is acceptable.
+AnyProfile = ManualProfile | TibberProfile
+
+# Map kind → Pydantic model class used for validation.
+_PROFILE_MODELS: dict[str, type[ManualProfile] | type[TibberProfile]] = {
+    "manual": ManualProfile,
+    "tibber": TibberProfile,
+}
+
+
+# ---------------------------------------------------------------------------
+# Public API
+# ---------------------------------------------------------------------------
+
+
+def load_profile(kind: str) -> AnyProfile:
+    """Load and validate a pricing profile by kind name.
+
+    The profile file is expected at
+    ``app/integrations/pricing/profiles/<kind>.yaml``.
+
+    Parameters
+    ----------
+    kind:
+        Profile kind without extension (``"manual"`` or ``"tibber"``).
+
+    Returns
+    -------
+    ManualProfile | TibberProfile
+        Validated profile model.
+
+    Raises
+    ------
+    ProfileNotFoundError
+        If ``profiles/<kind>.yaml`` does not exist.
+    ProfileValidationError
+        If the YAML is syntactically valid but fails schema validation.
+    """
+    path = _PROFILES_DIR / f"{kind}.yaml"
+    if not path.exists():
+        raise ProfileNotFoundError(
+            f"Pricing profile '{kind}' not found (looked for {path})"
+        )
+
+    with path.open("r", encoding="utf-8") as fh:
+        raw = yaml.safe_load(fh)
+
+    if not isinstance(raw, dict):
+        raise ProfileValidationError(
+            f"Profile '{kind}': expected a YAML mapping, got {type(raw).__name__}"
+        )
+
+    # Choose the right Pydantic model based on the ``kind`` field in the YAML.
+    yaml_kind = raw.get("kind", kind)
+    model_cls = _PROFILE_MODELS.get(yaml_kind)
+    if model_cls is None:
+        raise ProfileValidationError(
+            f"Profile '{kind}' has unknown kind={yaml_kind!r}; "
+            f"supported: {list(_PROFILE_MODELS)}"
+        )
+
+    try:
+        return model_cls.model_validate(raw)
+    except ValidationError as exc:
+        raise ProfileValidationError(
+            f"Profile '{kind}' failed validation: {exc}"
+        ) from exc
+
+
+def list_profiles() -> list[dict[str, Any]]:
+    """Return structural data for all available pricing profiles.
+
+    Scans ``app/integrations/pricing/profiles/*.yaml``, loads each, and returns
+    a list of dicts (Pydantic model dumps).  Profiles that fail to load are
+    skipped with a warning.
+
+    Returns
+    -------
+    list[dict[str, Any]]
+        One entry per valid profile, suitable for JSON serialisation and
+        front-end form rendering.
+    """
+    results: list[dict[str, Any]] = []
+    if not _PROFILES_DIR.exists():
+        return results
+
+    for path in sorted(_PROFILES_DIR.glob("*.yaml")):
+        kind = path.stem
+        try:
+            profile = load_profile(kind)
+            results.append(profile.model_dump())
+        except (ProfileNotFoundError, ProfileValidationError, Exception) as exc:
+            logger.warning("Skipping malformed pricing profile '%s': %s", kind, exc)
+
+    return results
+
+
+# ---------------------------------------------------------------------------
+# Contract-values validation
+# ---------------------------------------------------------------------------
+
+
+def _fill_defaults_manual(values: dict[str, Any], profile: ManualProfile) -> dict[str, Any]:
+    """Return a copy of *values* with any ``ode`` default applied if missing."""
+    filled = dict(values)
+
+    energy = dict(filled.get("energy", {}))
+
+    # Apply default for ode (default=0) if absent.
+    if "ode" not in energy and profile.energy.ode.default is not None:
+        energy["ode"] = profile.energy.ode.default
+
+    filled["energy"] = energy
+    return filled
+
+
+def _fill_defaults_tibber(values: dict[str, Any], profile: TibberProfile) -> dict[str, Any]:
+    """Return a copy of *values* with sell_adjust and management_fee defaults applied."""
+    filled = dict(values)
+
+    energy = dict(filled.get("energy", {}))
+    # Apply default for sell_adjust (default=0) if absent.
+    if "sell_adjust" not in energy and profile.energy.sell_adjust.default is not None:
+        energy["sell_adjust"] = profile.energy.sell_adjust.default
+    filled["energy"] = energy
+
+    standing = dict(filled.get("standing", {}))
+    # Apply default for management_fee if absent.
+    if (
+        "management_fee" not in standing
+        and profile.standing.management_fee.default is not None
+    ):
+        standing["management_fee"] = profile.standing.management_fee.default
+    filled["standing"] = standing
+
+    return filled
+
+
+def _require_numeric(section: str, key: str, container: dict[str, Any]) -> None:
+    """Assert that *container[key]* exists and is a number; raise ProfileValidationError."""
+    if key not in container:
+        raise ProfileValidationError(
+            f"Contract values missing required field '{section}.{key}'"
+        )
+    val = container[key]
+    if not isinstance(val, (int, float)):
+        raise ProfileValidationError(
+            f"Contract values field '{section}.{key}' must be a number, "
+            f"got {type(val).__name__!r}"
+        )
+
+
+def _validate_manual_values(values: dict[str, Any], profile: ManualProfile) -> dict[str, Any]:
+    """Validate and fill-defaults for manual contract values.
+
+    Returns the filled values dict on success.  Raises ProfileValidationError
+    on missing required fields or wrong types.
+    """
+    filled = _fill_defaults_manual(values, profile)
+    energy = filled.get("energy", {})
+    buy = energy.get("buy", {})
+    sell = energy.get("sell", {})
+    standing = filled.get("standing", {})
+    credits = filled.get("credits", {})
+
+    # Required energy.buy fields.
+    _require_numeric("energy.buy", "normal", buy)
+    _require_numeric("energy.buy", "dal", buy)
+    # Required energy.sell fields.
+    _require_numeric("energy.sell", "normal", sell)
+    _require_numeric("energy.sell", "dal", sell)
+    # Required energy fields.
+    _require_numeric("energy", "energy_tax", energy)
+    _require_numeric("energy", "ode", energy)
+    # Required standing fields.
+    _require_numeric("standing", "network_fee", standing)
+    _require_numeric("standing", "management_fee", standing)
+    # Required credits fields.
+    _require_numeric("credits", "heffingskorting", credits)
+
+    return filled
+
+
+def _validate_tibber_values(values: dict[str, Any], profile: TibberProfile) -> dict[str, Any]:
+    """Validate and fill-defaults for tibber contract values.
+
+    Returns the filled values dict on success.  Raises ProfileValidationError
+    on missing required fields or wrong types.
+    """
+    filled = _fill_defaults_tibber(values, profile)
+    energy = filled.get("energy", {})
+    standing = filled.get("standing", {})
+    credits = filled.get("credits", {})
+
+    # Required energy fields.
+    _require_numeric("energy", "energy_tax", energy)
+    _require_numeric("energy", "sell_adjust", energy)
+    # Required standing fields.
+    _require_numeric("standing", "management_fee", standing)
+    _require_numeric("standing", "network_fee", standing)
+    # Required credits fields.
+    _require_numeric("credits", "heffingskorting", credits)
+
+    return filled
+
+
+def validate_values(kind: str, values: dict[str, Any]) -> dict[str, Any]:
+    """Validate a contract-values dict against the named profile structure.
+
+    Fields that carry a ``default`` in the profile (e.g. ``ode``,
+    ``sell_adjust``, tibber ``management_fee``) are silently filled in when
+    absent from *values*.  Fields with no default that are absent, or fields
+    whose value is not a number, cause a ``ProfileValidationError``.
+
+    Parameters
+    ----------
+    kind:
+        Profile kind (``"manual"`` or ``"tibber"``).
+    values:
+        Contract values dict as stored in ``EnergyContractVersion.values``.
+
+    Returns
+    -------
+    dict[str, Any]
+        A (possibly mutated) copy of *values* with defaults applied.
+
+    Raises
+    ------
+    ProfileNotFoundError
+        If the profile YAML for *kind* does not exist.
+    ProfileValidationError
+        If required fields are missing or have wrong types.
+    """
+    profile = load_profile(kind)
+    if isinstance(profile, ManualProfile):
+        return _validate_manual_values(values, profile)
+    if isinstance(profile, TibberProfile):
+        return _validate_tibber_values(values, profile)
+    # Unreachable with current kinds, but guard for future extensions.
+    raise ProfileValidationError(f"No validator implemented for kind={kind!r}")

app/integrations/pricing/profiles/manual.yaml

@@ -0,0 +1,20 @@
+kind: manual
+label: 固定 / 可变费率（NL，双费率）
+
+energy:
+  dual_tariff: true              # use delivered_1/2, returned_1/2 for low/high tariffs
+  buy:
+    normal: { unit: EUR/kWh }   # high-tariff buy price (delivered_2 register)
+    dal:    { unit: EUR/kWh }   # low-tariff buy price (delivered_1 register)
+  sell:
+    normal: { unit: EUR/kWh }   # high-tariff sell / return price
+    dal:    { unit: EUR/kWh }   # low-tariff sell / return price (currently equal to normal)
+  energy_tax: { unit: EUR/kWh } # energy tax added to buy price (incl. VAT)
+  ode:        { unit: EUR/kWh, default: 0 }  # currently merged into energy_tax
+
+standing:                        # fixed charges; UI fills per month, engine prorates to days
+  network_fee:    { unit: EUR/month }
+  management_fee: { unit: EUR/month }
+
+credits:
+  heffingskorting: { unit: EUR/year }  # energy-tax credit; deducted at summary layer

app/integrations/pricing/profiles/tibber.yaml

@@ -0,0 +1,14 @@
+kind: tibber
+label: Tibber 动态电价（15 分钟）
+
+energy:
+  source: tibber_api              # buy = total (from API); sell = total − energy_tax − sell_adjust
+  energy_tax:  { unit: EUR/kWh }  # subtracted from total to derive sell price (incl. VAT)
+  sell_adjust: { unit: EUR/kWh, default: 0 }  # additional sell-price adjustment (residual spread)
+
+standing:                         # fixed charges; UI fills per month, engine prorates to days
+  management_fee: { unit: EUR/month, default: 5.99 }
+  network_fee:    { unit: EUR/month }
+
+credits:
+  heffingskorting: { unit: EUR/year }  # energy-tax credit; deducted at summary layer

app/integrations/pricing/strategies.py

@@ -0,0 +1,288 @@
+"""Price-calculation strategy registry and built-in implementations.
+
+A *strategy* is a plain function registered under a ``kind`` string.  Given
+per-register kWh deltas, the period start time, the active contract-version
+values, and a DB session, it returns a result dict with:
+
+    {
+        "import_cost":    Decimal,   # total cost of electricity drawn from grid
+        "export_revenue": Decimal,   # total revenue from electricity fed to grid
+        "net_cost":       Decimal,   # import_cost − export_revenue
+        "pricing":        dict,      # snapshot of the price inputs used (for auditing)
+    }
+
+**Import and export are kept separate throughout** — net_cost is only derived
+at the end.  This supports the Dutch no-netting rule (saldering afgebouwd).
+
+**All monetary arithmetic uses Decimal** converted via ``Decimal(str(x))`` to
+avoid float binary rounding errors.
+
+Design notes
+------------
+- **Purely data + functions**: no ABC, no class hierarchy.  A ``dict``-based
+  registry is the simplest structure that supports the two current kinds and
+  leaves the door open for future additions (e.g. ``octopus``, ``frank``).
+- ``deltas`` is a plain dataclass ``PeriodDeltas`` — typed, but no ORM.
+- Tibber strategy queries ``TibberPrice`` directly from the session; it does not
+  call the Tibber API (that is T05's job).
+"""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+from datetime import datetime
+from decimal import Decimal
+from typing import Any, Callable
+
+from sqlalchemy.orm import Session
+
+logger = logging.getLogger(__name__)
+
+
+# ---------------------------------------------------------------------------
+# Shared data types
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class PeriodDeltas:
+    """Per-register kWh deltas for one 15-minute billing period.
+
+    All values are ``Decimal`` and represent ``end_reading − start_reading``
+    for the corresponding cumulative energy register.
+
+    Attributes
+    ----------
+    d1: Decimal
+        Delivered (consumed) kWh on the low/dal tariff register (delivered_1).
+    d2: Decimal
+        Delivered (consumed) kWh on the normal/high tariff register (delivered_2).
+    r1: Decimal
+        Returned (fed-to-grid) kWh on the low/dal tariff register (returned_1).
+    r2: Decimal
+        Returned (fed-to-grid) kWh on the normal/high tariff register (returned_2).
+    """
+
+    d1: Decimal  # delivered low-tariff
+    d2: Decimal  # delivered high-tariff
+    r1: Decimal  # returned low-tariff
+    r2: Decimal  # returned high-tariff
+
+
+# Strategy callable signature.
+StrategyFn = Callable[
+    [PeriodDeltas, datetime, dict[str, Any], Session],
+    dict[str, Any],
+]
+
+
+# ---------------------------------------------------------------------------
+# Registry
+# ---------------------------------------------------------------------------
+
+_REGISTRY: dict[str, StrategyFn] = {}
+
+
+def register_strategy(kind: str, fn: StrategyFn) -> None:
+    """Register *fn* as the price-calculation strategy for *kind*.
+
+    Overwrites any previously registered strategy for the same kind (allows
+    monkey-patching in tests).
+    """
+    _REGISTRY[kind] = fn
+
+
+def get_strategy(kind: str) -> StrategyFn:
+    """Return the registered strategy for *kind*.
+
+    Raises
+    ------
+    KeyError
+        If no strategy is registered for *kind*.
+    """
+    if kind not in _REGISTRY:
+        raise KeyError(
+            f"No price strategy registered for kind={kind!r}. "
+            f"Available: {sorted(_REGISTRY)}"
+        )
+    return _REGISTRY[kind]
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+
+def _to_decimal(value: Any) -> Decimal:
+    """Convert *value* to Decimal via str() to avoid float binary rounding."""
+    return Decimal(str(value))
+
+
+# ---------------------------------------------------------------------------
+# Manual strategy — fixed dual-tariff
+# ---------------------------------------------------------------------------
+
+
+def _manual_strategy(
+    deltas: PeriodDeltas,
+    t0: datetime,
+    values: dict[str, Any],
+    session: Session,
+) -> dict[str, Any]:
+    """Calculate billing costs for one period using fixed dual-tariff rates.
+
+    Formula (§3.4):
+    - ``buy_dal    = energy.buy.dal    + energy.energy_tax + energy.ode``
+    - ``buy_normal = energy.buy.normal + energy.energy_tax + energy.ode``
+    - ``import_cost   = Δd1 × buy_dal + Δd2 × buy_normal``
+    - ``sell_dal    = energy.sell.dal``    (no tax on return price)
+    - ``sell_normal = energy.sell.normal``
+    - ``export_revenue = Δr1 × sell_dal + Δr2 × sell_normal``
+    - ``net_cost = import_cost − export_revenue``
+
+    The ``pricing`` snapshot contains all per-unit prices used so that the
+    result is fully auditable without re-querying the contract version.
+    """
+    energy = values.get("energy", {})
+    buy = energy.get("buy", {})
+    sell = energy.get("sell", {})
+
+    energy_tax = _to_decimal(energy.get("energy_tax", 0))
+    ode = _to_decimal(energy.get("ode", 0))
+
+    buy_dal_base = _to_decimal(buy.get("dal", 0))
+    buy_normal_base = _to_decimal(buy.get("normal", 0))
+    sell_dal = _to_decimal(sell.get("dal", 0))
+    sell_normal = _to_decimal(sell.get("normal", 0))
+
+    # Effective buy prices including all taxes.
+    buy_dal = buy_dal_base + energy_tax + ode
+    buy_normal = buy_normal_base + energy_tax + ode
+
+    import_cost = deltas.d1 * buy_dal + deltas.d2 * buy_normal
+    export_revenue = deltas.r1 * sell_dal + deltas.r2 * sell_normal
+    net_cost = import_cost - export_revenue
+
+    pricing_snapshot = {
+        "kind": "manual",
+        "buy_dal": str(buy_dal),
+        "buy_normal": str(buy_normal),
+        "sell_dal": str(sell_dal),
+        "sell_normal": str(sell_normal),
+        "energy_tax": str(energy_tax),
+        "ode": str(ode),
+    }
+
+    return {
+        "import_cost": import_cost,
+        "export_revenue": export_revenue,
+        "net_cost": net_cost,
+        "pricing": pricing_snapshot,
+    }
+
+
+# ---------------------------------------------------------------------------
+# Tibber strategy — dynamic 15-minute spot price
+# ---------------------------------------------------------------------------
+
+
+class TibberPriceNotFoundError(LookupError):
+    """Raised when no TibberPrice row covers the requested period start.
+
+    The billing engine (T07) catches this to mark the period as ``degraded``
+    or skip it until a price becomes available.
+    """
+
+
+def _tibber_strategy(
+    deltas: PeriodDeltas,
+    t0: datetime,
+    values: dict[str, Any],
+    session: Session,
+) -> dict[str, Any]:
+    """Calculate billing costs for one period using Tibber dynamic pricing.
+
+    Price lookup:
+        Takes the most recent ``TibberPrice`` row where ``starts_at ≤ t0``
+        (i.e. the slot that was in effect at *t0*).  This is a DESC LIMIT 1
+        query on ``starts_at``.
+
+    Formula (§3.4):
+    - ``buy  = total`` (Tibber's all-inclusive price, already includes tax)
+    - ``sell = total − energy_tax − sell_adjust``
+    - ``import_cost   = (Δd1 + Δd2) × buy``
+    - ``export_revenue = (Δr1 + Δr2) × sell``
+    - ``net_cost = import_cost − export_revenue``
+
+    Tibber does not differentiate tariff slots (dal vs normal) — the 15-minute
+    API price applies to the full delivered/returned volume.
+
+    Negative ``total`` (extreme negative spot prices):
+        When ``total`` is negative the ``sell`` price will also be negative,
+        meaning ``export_revenue`` becomes negative (feeding to grid *costs*
+        money).  This is the mathematically correct outcome and is left as-is.
+
+    Raises
+    ------
+    TibberPriceNotFoundError
+        If no ``TibberPrice`` row exists with ``starts_at ≤ t0``.  The caller
+        (T07 billing engine) should catch this and mark the period as
+        ``degraded`` or skip it for later recomputation.
+    """
+    from app.models.energy import TibberPrice  # local import to avoid circular
+    from sqlalchemy import desc
+
+    price_row: TibberPrice | None = (
+        session.query(TibberPrice)
+        .filter(TibberPrice.starts_at <= t0)
+        .order_by(desc(TibberPrice.starts_at))
+        .first()
+    )
+
+    if price_row is None:
+        raise TibberPriceNotFoundError(
+            f"No TibberPrice found covering t0={t0.isoformat()!r}; "
+            "period cannot be billed until price data is available."
+        )
+
+    energy = values.get("energy", {})
+    energy_tax = _to_decimal(energy.get("energy_tax", 0))
+    sell_adjust = _to_decimal(energy.get("sell_adjust", 0))
+
+    total = _to_decimal(price_row.total)
+    buy = total
+    sell = total - energy_tax - sell_adjust
+
+    total_delivered = deltas.d1 + deltas.d2
+    total_returned = deltas.r1 + deltas.r2
+
+    import_cost = total_delivered * buy
+    export_revenue = total_returned * sell
+    net_cost = import_cost - export_revenue
+
+    pricing_snapshot = {
+        "kind": "tibber",
+        "tibber_price_starts_at": price_row.starts_at.isoformat(),
+        "tibber_price_id": price_row.id,
+        "total": str(total),
+        "buy": str(buy),
+        "sell": str(sell),
+        "energy_tax": str(energy_tax),
+        "sell_adjust": str(sell_adjust),
+    }
+
+    return {
+        "import_cost": import_cost,
+        "export_revenue": export_revenue,
+        "net_cost": net_cost,
+        "pricing": pricing_snapshot,
+    }
+
+
+# ---------------------------------------------------------------------------
+# Register built-in strategies at module import time
+# ---------------------------------------------------------------------------
+
+register_strategy("manual", _manual_strategy)
+register_strategy("tibber", _tibber_strategy)

docs/design/m6-tibber-dynamic-energy.md

@@ -315,7 +315,7 @@ Phase D（API + 前端）
 - **Reviewer checklist**: secret 不回显/不进 OpenAPI 示例；`_settings_payload` 无遗漏；默认 off。
 
 ### M6-T03 — pricing profile 框架 + strategy 注册表
-- **Status**: `todo` · **Depends**: none
+- **Status**: `done` · **Depends**: none
 - **Context**: 仓库内 `manual.yaml`/`tibber.yaml` 定结构（pydantic 校验），加 price strategy 注册表（manual/tibber 出价）。纯模块，单测。
 - **Files**: `create app/integrations/pricing/__init__.py`、`pricing/profiles.py`（pydantic 模型 + `load_profile`/`list_profiles`/`validate_values`）、`pricing/profiles/manual.yaml`、`pricing/profiles/tibber.yaml`、`pricing/strategies.py`（`register_strategy`/`get_strategy`、`manual`/`tibber` 实现）；`create tests/test_pricing_profiles.py`、`tests/test_pricing_strategies.py`
 - **Steps**:

tests/test_pricing_profiles.py

@@ -0,0 +1,415 @@
+"""Tests for app/integrations/pricing/profiles.py.
+
+Acceptance criteria covered
+----------------------------
+1. ``load_profile("manual")`` succeeds and returns a valid ``ManualProfile``.
+2. ``load_profile("tibber")`` succeeds and returns a valid ``TibberProfile``.
+3. Missing profile file raises ``ProfileNotFoundError``.
+4. Malformed YAML (missing required fields) raises ``ProfileValidationError``.
+5. Wrong kind in YAML raises ``ProfileValidationError``.
+6. ``validate_values`` accepts conforming values for both kinds.
+7. ``validate_values`` fills in default values (``ode``, ``sell_adjust``,
+   tibber ``management_fee``) when absent.
+8. ``validate_values`` raises ``ProfileValidationError`` for missing required
+   fields (no default).
+9. ``validate_values`` raises ``ProfileValidationError`` for wrong-typed fields.
+10. ``list_profiles()`` returns both profiles in a list of dicts.
+"""
+
+from __future__ import annotations
+
+import textwrap
+from pathlib import Path
+from unittest.mock import patch
+
+import pytest
+import yaml
+
+from app.integrations.pricing.profiles import (
+    ManualProfile,
+    ProfileNotFoundError,
+    ProfileValidationError,
+    TibberProfile,
+    list_profiles,
+    load_profile,
+    validate_values,
+)
+
+
+# ---------------------------------------------------------------------------
+# 1-2: load_profile happy path
+# ---------------------------------------------------------------------------
+
+
+class TestLoadProfileManual:
+    """Validate that the shipped manual.yaml loads and validates correctly."""
+
+    def test_returns_manual_profile_instance(self) -> None:
+        profile = load_profile("manual")
+        assert isinstance(profile, ManualProfile)
+
+    def test_kind_is_manual(self) -> None:
+        profile = load_profile("manual")
+        assert profile.kind == "manual"
+
+    def test_has_label(self) -> None:
+        profile = load_profile("manual")
+        assert isinstance(profile.label, str) and profile.label
+
+    def test_dual_tariff_is_true(self) -> None:
+        profile = load_profile("manual")
+        assert profile.energy.dual_tariff is True
+
+    def test_energy_buy_has_normal_and_dal(self) -> None:
+        profile = load_profile("manual")
+        assert profile.energy.buy.normal.unit == "EUR/kWh"
+        assert profile.energy.buy.dal.unit == "EUR/kWh"
+
+    def test_energy_sell_has_normal_and_dal(self) -> None:
+        profile = load_profile("manual")
+        assert profile.energy.sell.normal.unit == "EUR/kWh"
+        assert profile.energy.sell.dal.unit == "EUR/kWh"
+
+    def test_energy_tax_unit(self) -> None:
+        profile = load_profile("manual")
+        assert profile.energy.energy_tax.unit == "EUR/kWh"
+        assert profile.energy.energy_tax.default is None  # required field, no default
+
+    def test_ode_has_default_zero(self) -> None:
+        profile = load_profile("manual")
+        assert profile.energy.ode.default == 0
+
+    def test_standing_fields(self) -> None:
+        profile = load_profile("manual")
+        assert profile.standing.network_fee.unit == "EUR/month"
+        assert profile.standing.management_fee.unit == "EUR/month"
+
+    def test_credits_heffingskorting(self) -> None:
+        profile = load_profile("manual")
+        assert profile.credits.heffingskorting.unit == "EUR/year"
+
+    def test_no_concrete_values_in_profile(self) -> None:
+        """Profile YAML must not contain any concrete price numbers."""
+        profile_path = (
+            Path(__file__).parent.parent
+            / "app/integrations/pricing/profiles/manual.yaml"
+        )
+        with profile_path.open() as fh:
+            raw = yaml.safe_load(fh)
+        # Leaf nodes should only have 'unit' and optionally 'default: 0',
+        # not actual price values like 0.133 or 0.127.
+        energy = raw.get("energy", {})
+        buy = energy.get("buy", {})
+        # Leaf buy nodes: only 'unit' key, no numeric value key.
+        assert set(buy["normal"].keys()) == {"unit"}, (
+            "buy.normal leaf must only have 'unit'"
+        )
+        assert set(buy["dal"].keys()) == {"unit"}, (
+            "buy.dal leaf must only have 'unit'"
+        )
+
+
+class TestLoadProfileTibber:
+    """Validate that the shipped tibber.yaml loads and validates correctly."""
+
+    def test_returns_tibber_profile_instance(self) -> None:
+        profile = load_profile("tibber")
+        assert isinstance(profile, TibberProfile)
+
+    def test_kind_is_tibber(self) -> None:
+        profile = load_profile("tibber")
+        assert profile.kind == "tibber"
+
+    def test_has_label(self) -> None:
+        profile = load_profile("tibber")
+        assert isinstance(profile.label, str) and profile.label
+
+    def test_energy_source_is_tibber_api(self) -> None:
+        profile = load_profile("tibber")
+        assert profile.energy.source == "tibber_api"
+
+    def test_energy_tax_unit(self) -> None:
+        profile = load_profile("tibber")
+        assert profile.energy.energy_tax.unit == "EUR/kWh"
+        assert profile.energy.energy_tax.default is None  # required
+
+    def test_sell_adjust_has_default_zero(self) -> None:
+        profile = load_profile("tibber")
+        assert profile.energy.sell_adjust.default == 0
+
+    def test_management_fee_has_default(self) -> None:
+        profile = load_profile("tibber")
+        assert profile.standing.management_fee.default is not None
+        assert isinstance(profile.standing.management_fee.default, float)
+
+    def test_network_fee_unit(self) -> None:
+        profile = load_profile("tibber")
+        assert profile.standing.network_fee.unit == "EUR/month"
+
+    def test_credits_heffingskorting(self) -> None:
+        profile = load_profile("tibber")
+        assert profile.credits.heffingskorting.unit == "EUR/year"
+
+
+# ---------------------------------------------------------------------------
+# 3-5: load_profile error cases
+# ---------------------------------------------------------------------------
+
+
+class TestLoadProfileErrors:
+    def test_missing_profile_raises_not_found(self) -> None:
+        with pytest.raises(ProfileNotFoundError, match="nonexistent"):
+            load_profile("nonexistent")
+
+    def test_missing_required_fields_raises_validation_error(
+        self, tmp_path: Path
+    ) -> None:
+        """A YAML missing required fields raises ProfileValidationError."""
+        bad_yaml = textwrap.dedent(
+            """\
+            kind: manual
+            label: Bad manual profile
+            # missing energy / standing / credits sections entirely
+            """
+        )
+        bad_path = tmp_path / "manual.yaml"
+        bad_path.write_text(bad_yaml)
+
+        with patch("app.integrations.pricing.profiles._PROFILES_DIR", tmp_path):
+            with pytest.raises(ProfileValidationError, match="manual"):
+                load_profile("manual")
+
+    def test_wrong_type_raises_validation_error(self, tmp_path: Path) -> None:
+        """A YAML with a wrong type (string where dict is expected) raises ProfileValidationError."""
+        bad_yaml = textwrap.dedent(
+            """\
+            kind: tibber
+            label: Wrong type profile
+            energy: "should be a mapping not a string"
+            standing:
+              management_fee: { unit: EUR/month, default: 5.99 }
+              network_fee: { unit: EUR/month }
+            credits:
+              heffingskorting: { unit: EUR/year }
+            """
+        )
+        bad_path = tmp_path / "tibber.yaml"
+        bad_path.write_text(bad_yaml)
+
+        with patch("app.integrations.pricing.profiles._PROFILES_DIR", tmp_path):
+            with pytest.raises(ProfileValidationError, match="tibber"):
+                load_profile("tibber")
+
+    def test_unknown_kind_raises_validation_error(self, tmp_path: Path) -> None:
+        """A YAML with an unknown kind raises ProfileValidationError."""
+        bad_yaml = textwrap.dedent(
+            """\
+            kind: unknown_kind
+            label: Unknown kind profile
+            """
+        )
+        bad_path = tmp_path / "unknown_kind.yaml"
+        bad_path.write_text(bad_yaml)
+
+        with patch("app.integrations.pricing.profiles._PROFILES_DIR", tmp_path):
+            with pytest.raises(ProfileValidationError, match="unknown_kind"):
+                load_profile("unknown_kind")
+
+
+# ---------------------------------------------------------------------------
+# 6-9: validate_values
+# ---------------------------------------------------------------------------
+
+# A complete, conforming set of manual contract values.
+_VALID_MANUAL_VALUES = {
+    "energy": {
+        "buy": {"normal": 0.133, "dal": 0.127},
+        "sell": {"normal": 0.05, "dal": 0.05},
+        "energy_tax": 0.1108,
+        "ode": 0.0,
+    },
+    "standing": {
+        "network_fee": 9.87,
+        "management_fee": 9.87,
+    },
+    "credits": {
+        "heffingskorting": 600.0,
+    },
+}
+
+# A complete, conforming set of tibber contract values.
+_VALID_TIBBER_VALUES = {
+    "energy": {
+        "energy_tax": 0.1108,
+        "sell_adjust": 0.0,
+    },
+    "standing": {
+        "management_fee": 5.99,
+        "network_fee": 9.87,
+    },
+    "credits": {
+        "heffingskorting": 600.0,
+    },
+}
+
+
+class TestValidateValuesManual:
+    def test_valid_values_accepted(self) -> None:
+        filled = validate_values("manual", dict(_VALID_MANUAL_VALUES))
+        # Should not raise and should return a dict.
+        assert isinstance(filled, dict)
+
+    def test_ode_default_applied_when_absent(self) -> None:
+        """When 'ode' is not in values, the default (0) should be inserted."""
+        values = {
+            "energy": {
+                "buy": {"normal": 0.133, "dal": 0.127},
+                "sell": {"normal": 0.05, "dal": 0.05},
+                "energy_tax": 0.1108,
+                # ode is absent
+            },
+            "standing": {
+                "network_fee": 9.87,
+                "management_fee": 9.87,
+            },
+            "credits": {"heffingskorting": 600.0},
+        }
+        filled = validate_values("manual", values)
+        assert filled["energy"]["ode"] == 0
+
+    def test_missing_energy_tax_raises(self) -> None:
+        values = {
+            "energy": {
+                "buy": {"normal": 0.133, "dal": 0.127},
+                "sell": {"normal": 0.05, "dal": 0.05},
+                # energy_tax absent — no default
+            },
+            "standing": {"network_fee": 9.87, "management_fee": 9.87},
+            "credits": {"heffingskorting": 600.0},
+        }
+        with pytest.raises(ProfileValidationError, match="energy_tax"):
+            validate_values("manual", values)
+
+    def test_missing_buy_normal_raises(self) -> None:
+        values = {
+            "energy": {
+                "buy": {"dal": 0.127},  # normal absent
+                "sell": {"normal": 0.05, "dal": 0.05},
+                "energy_tax": 0.1108,
+                "ode": 0.0,
+            },
+            "standing": {"network_fee": 9.87, "management_fee": 9.87},
+            "credits": {"heffingskorting": 600.0},
+        }
+        with pytest.raises(ProfileValidationError, match="normal"):
+            validate_values("manual", values)
+
+    def test_wrong_type_for_energy_tax_raises(self) -> None:
+        values = {
+            "energy": {
+                "buy": {"normal": 0.133, "dal": 0.127},
+                "sell": {"normal": 0.05, "dal": 0.05},
+                "energy_tax": "not_a_number",  # wrong type
+                "ode": 0.0,
+            },
+            "standing": {"network_fee": 9.87, "management_fee": 9.87},
+            "credits": {"heffingskorting": 600.0},
+        }
+        with pytest.raises(ProfileValidationError, match="energy_tax"):
+            validate_values("manual", values)
+
+    def test_missing_heffingskorting_raises(self) -> None:
+        values = {
+            "energy": {
+                "buy": {"normal": 0.133, "dal": 0.127},
+                "sell": {"normal": 0.05, "dal": 0.05},
+                "energy_tax": 0.1108,
+                "ode": 0.0,
+            },
+            "standing": {"network_fee": 9.87, "management_fee": 9.87},
+            "credits": {},  # heffingskorting absent — no default
+        }
+        with pytest.raises(ProfileValidationError, match="heffingskorting"):
+            validate_values("manual", values)
+
+
+class TestValidateValuesTibber:
+    def test_valid_values_accepted(self) -> None:
+        filled = validate_values("tibber", dict(_VALID_TIBBER_VALUES))
+        assert isinstance(filled, dict)
+
+    def test_sell_adjust_default_applied_when_absent(self) -> None:
+        values = {
+            "energy": {
+                "energy_tax": 0.1108,
+                # sell_adjust absent — has default 0
+            },
+            "standing": {"management_fee": 5.99, "network_fee": 9.87},
+            "credits": {"heffingskorting": 600.0},
+        }
+        filled = validate_values("tibber", values)
+        assert filled["energy"]["sell_adjust"] == 0
+
+    def test_management_fee_default_applied_when_absent(self) -> None:
+        values = {
+            "energy": {"energy_tax": 0.1108, "sell_adjust": 0.0},
+            "standing": {
+                "network_fee": 9.87,
+                # management_fee absent — has a default
+            },
+            "credits": {"heffingskorting": 600.0},
+        }
+        filled = validate_values("tibber", values)
+        assert "management_fee" in filled["standing"]
+        assert isinstance(filled["standing"]["management_fee"], float)
+
+    def test_missing_energy_tax_raises(self) -> None:
+        values = {
+            "energy": {"sell_adjust": 0.0},  # energy_tax absent — no default
+            "standing": {"management_fee": 5.99, "network_fee": 9.87},
+            "credits": {"heffingskorting": 600.0},
+        }
+        with pytest.raises(ProfileValidationError, match="energy_tax"):
+            validate_values("tibber", values)
+
+    def test_missing_network_fee_raises(self) -> None:
+        values = {
+            "energy": {"energy_tax": 0.1108, "sell_adjust": 0.0},
+            "standing": {"management_fee": 5.99},  # network_fee absent — no default
+            "credits": {"heffingskorting": 600.0},
+        }
+        with pytest.raises(ProfileValidationError, match="network_fee"):
+            validate_values("tibber", values)
+
+    def test_wrong_type_for_sell_adjust_raises(self) -> None:
+        values = {
+            "energy": {"energy_tax": 0.1108, "sell_adjust": "zero"},  # wrong type
+            "standing": {"management_fee": 5.99, "network_fee": 9.87},
+            "credits": {"heffingskorting": 600.0},
+        }
+        with pytest.raises(ProfileValidationError, match="sell_adjust"):
+            validate_values("tibber", values)
+
+
+# ---------------------------------------------------------------------------
+# 10: list_profiles
+# ---------------------------------------------------------------------------
+
+
+class TestListProfiles:
+    def test_returns_list_of_dicts(self) -> None:
+        profiles = list_profiles()
+        assert isinstance(profiles, list)
+        for item in profiles:
+            assert isinstance(item, dict)
+
+    def test_contains_manual_and_tibber(self) -> None:
+        profiles = list_profiles()
+        kinds = {p["kind"] for p in profiles}
+        assert "manual" in kinds
+        assert "tibber" in kinds
+
+    def test_each_entry_has_label(self) -> None:
+        profiles = list_profiles()
+        for p in profiles:
+            assert "label" in p and isinstance(p["label"], str)

tests/test_pricing_strategies.py

@@ -0,0 +1,553 @@
+"""Tests for app/integrations/pricing/strategies.py.
+
+Acceptance criteria covered
+----------------------------
+1. ``get_strategy("manual")`` / ``get_strategy("tibber")`` return registered callables.
+2. Manual strategy: dual-tariff import/export/net calculated correctly (hand-verified).
+3. Manual strategy: Decimal precision — no float binary rounding errors.
+4. Tibber strategy: queries the most recent TibberPrice with starts_at ≤ t0.
+5. Tibber strategy: buy=total, sell=total−energy_tax−sell_adjust.
+6. Tibber strategy: negative total → negative export_revenue (not clamped).
+7. Tibber strategy: raises TibberPriceNotFoundError when no matching row exists.
+8. ``register_strategy`` / ``get_strategy`` round-trip works.
+9. ``get_strategy`` raises KeyError for unknown kinds.
+"""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from decimal import Decimal
+from pathlib import Path
+
+import pytest
+from alembic import command
+from alembic.config import Config
+from sqlalchemy import create_engine
+from sqlalchemy.orm import Session
+
+from app.integrations.pricing.strategies import (
+    PeriodDeltas,
+    TibberPriceNotFoundError,
+    get_strategy,
+    register_strategy,
+)
+from app.models.energy import TibberPrice
+
+
+# ---------------------------------------------------------------------------
+# Fixtures: in-memory / temp-file SQLite with energy tables
+# ---------------------------------------------------------------------------
+
+
+def _make_app_alembic_config(database_url: str) -> Config:
+    cfg = Config("alembic_app.ini")
+    cfg.set_main_option("sqlalchemy.url", database_url)
+    return cfg
+
+
+@pytest.fixture()
+def tibber_db(tmp_path: Path):
+    """Temporary SQLite DB upgraded to head (has tibber_price table)."""
+    db_path = tmp_path / "tibber_strategy_test.db"
+    db_url = f"sqlite:///{db_path}"
+    alembic_cfg = _make_app_alembic_config(db_url)
+    command.upgrade(alembic_cfg, "head")
+    engine = create_engine(db_url, connect_args={"check_same_thread": False})
+    yield engine
+    engine.dispose()
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+_UTC = timezone.utc
+
+
+def _ts(hour: int, minute: int = 0) -> datetime:
+    """Return a UTC datetime on 2026-06-23 at the given hour:minute."""
+    return datetime(2026, 6, 23, hour, minute, 0, tzinfo=_UTC)
+
+
+def _insert_tibber_price(
+    session: Session,
+    starts_at: datetime,
+    total: float,
+    energy: float = 0.08,
+    tax: float | None = None,
+    currency: str = "EUR",
+) -> TibberPrice:
+    """Insert and flush a TibberPrice row; return the ORM instance."""
+    if tax is None:
+        tax = round(total - energy, 6)
+    row = TibberPrice(
+        starts_at=starts_at,
+        resolution="QUARTER_HOURLY",
+        energy=energy,
+        tax=tax,
+        total=total,
+        level="NORMAL",
+        currency=currency,
+        fetched_at=datetime.now(_UTC),
+    )
+    session.add(row)
+    session.flush()
+    return row
+
+
+# ---------------------------------------------------------------------------
+# 1. Registry round-trip
+# ---------------------------------------------------------------------------
+
+
+class TestRegistry:
+    def test_manual_strategy_registered(self) -> None:
+        fn = get_strategy("manual")
+        assert callable(fn)
+
+    def test_tibber_strategy_registered(self) -> None:
+        fn = get_strategy("tibber")
+        assert callable(fn)
+
+    def test_unknown_kind_raises_key_error(self) -> None:
+        with pytest.raises(KeyError, match="no_such_kind"):
+            get_strategy("no_such_kind")
+
+    def test_register_and_retrieve_custom_strategy(self) -> None:
+        def _my_fn(deltas, t0, values, session):
+            return {}
+
+        register_strategy("_test_custom", _my_fn)
+        assert get_strategy("_test_custom") is _my_fn
+        # Cleanup to avoid polluting other tests.
+        from app.integrations.pricing.strategies import _REGISTRY
+        _REGISTRY.pop("_test_custom", None)
+
+
+# ---------------------------------------------------------------------------
+# 2-3. Manual strategy
+# ---------------------------------------------------------------------------
+
+# Dummy session (manual strategy does not use the session).
+_NO_SESSION = None  # type: ignore[assignment]
+
+
+class TestManualStrategy:
+    """Verify manual dual-tariff price calculations."""
+
+    # Contract values for all manual tests.
+    _VALUES = {
+        "energy": {
+            "buy": {"normal": 0.133, "dal": 0.127},
+            "sell": {"normal": 0.05, "dal": 0.05},
+            "energy_tax": 0.11,
+            "ode": 0.0,
+        },
+        "standing": {"network_fee": 9.87, "management_fee": 9.87},
+        "credits": {"heffingskorting": 600.0},
+    }
+
+    def _call(self, deltas: PeriodDeltas) -> dict:
+        fn = get_strategy("manual")
+        return fn(deltas, _ts(10), self._VALUES, _NO_SESSION)
+
+    # --- hand-calculated expected values ---
+    # buy_dal    = 0.127 + 0.11 + 0.0 = 0.237
+    # buy_normal = 0.133 + 0.11 + 0.0 = 0.243
+    # sell_dal    = 0.05
+    # sell_normal = 0.05
+    #
+    # With Δd1=2, Δd2=3, Δr1=1, Δr2=4:
+    #   import_cost   = 2×0.237 + 3×0.243 = 0.474 + 0.729 = 1.203
+    #   export_revenue = 1×0.05 + 4×0.05 = 0.05 + 0.20 = 0.25
+    #   net_cost      = 1.203 − 0.25 = 0.953
+
+    def test_import_cost_dual_tariff(self) -> None:
+        deltas = PeriodDeltas(
+            d1=Decimal("2"), d2=Decimal("3"),
+            r1=Decimal("1"), r2=Decimal("4"),
+        )
+        result = self._call(deltas)
+        expected = Decimal("2") * Decimal("0.237") + Decimal("3") * Decimal("0.243")
+        assert result["import_cost"] == expected
+
+    def test_export_revenue_dual_tariff(self) -> None:
+        deltas = PeriodDeltas(
+            d1=Decimal("2"), d2=Decimal("3"),
+            r1=Decimal("1"), r2=Decimal("4"),
+        )
+        result = self._call(deltas)
+        expected = Decimal("1") * Decimal("0.05") + Decimal("4") * Decimal("0.05")
+        assert result["export_revenue"] == expected
+
+    def test_net_cost_equals_import_minus_export(self) -> None:
+        deltas = PeriodDeltas(
+            d1=Decimal("2"), d2=Decimal("3"),
+            r1=Decimal("1"), r2=Decimal("4"),
+        )
+        result = self._call(deltas)
+        assert result["net_cost"] == result["import_cost"] - result["export_revenue"]
+
+    def test_hand_calculated_values(self) -> None:
+        """Verify exact hand-calculated result for the reference deltas."""
+        deltas = PeriodDeltas(
+            d1=Decimal("2"), d2=Decimal("3"),
+            r1=Decimal("1"), r2=Decimal("4"),
+        )
+        result = self._call(deltas)
+        assert result["import_cost"] == Decimal("1.203")
+        assert result["export_revenue"] == Decimal("0.25")
+        assert result["net_cost"] == Decimal("0.953")
+
+    def test_zero_deltas_yields_zero_costs(self) -> None:
+        deltas = PeriodDeltas(
+            d1=Decimal("0"), d2=Decimal("0"),
+            r1=Decimal("0"), r2=Decimal("0"),
+        )
+        result = self._call(deltas)
+        assert result["import_cost"] == Decimal("0")
+        assert result["export_revenue"] == Decimal("0")
+        assert result["net_cost"] == Decimal("0")
+
+    def test_ode_included_in_buy_price(self) -> None:
+        """When ode > 0 it is added to the effective buy price."""
+        values = {
+            "energy": {
+                "buy": {"normal": 0.10, "dal": 0.10},
+                "sell": {"normal": 0.05, "dal": 0.05},
+                "energy_tax": 0.10,
+                "ode": 0.01,  # non-zero ode
+            },
+            "standing": {"network_fee": 0.0, "management_fee": 0.0},
+            "credits": {"heffingskorting": 0.0},
+        }
+        deltas = PeriodDeltas(
+            d1=Decimal("1"), d2=Decimal("0"),
+            r1=Decimal("0"), r2=Decimal("0"),
+        )
+        fn = get_strategy("manual")
+        result = fn(deltas, _ts(10), values, _NO_SESSION)
+        # buy_dal = 0.10 + 0.10 + 0.01 = 0.21; import_cost = 1 × 0.21 = 0.21
+        assert result["import_cost"] == Decimal("0.21")
+
+    def test_import_export_kept_separate(self) -> None:
+        """import_cost and export_revenue must not be netted before assignment."""
+        deltas = PeriodDeltas(
+            d1=Decimal("5"), d2=Decimal("5"),
+            r1=Decimal("3"), r2=Decimal("3"),
+        )
+        result = self._call(deltas)
+        # Both must be individually non-zero.
+        assert result["import_cost"] > 0
+        assert result["export_revenue"] > 0
+
+    def test_pricing_snapshot_present(self) -> None:
+        deltas = PeriodDeltas(
+            d1=Decimal("1"), d2=Decimal("1"),
+            r1=Decimal("0"), r2=Decimal("0"),
+        )
+        result = self._call(deltas)
+        snapshot = result["pricing"]
+        assert snapshot["kind"] == "manual"
+        assert "buy_dal" in snapshot
+        assert "buy_normal" in snapshot
+        assert "sell_dal" in snapshot
+        assert "sell_normal" in snapshot
+
+
+# ---------------------------------------------------------------------------
+# 3. Decimal precision — float-error exposure test
+# ---------------------------------------------------------------------------
+
+
+class TestManualDecimalPrecision:
+    """Use values known to produce binary float errors if float arithmetic is used."""
+
+    def test_no_float_rounding_error(self) -> None:
+        """0.1 + 0.2 in float gives 0.30000000000000004; Decimal must be exact."""
+        values = {
+            "energy": {
+                "buy": {"normal": 0.1, "dal": 0.2},
+                "sell": {"normal": 0.1, "dal": 0.1},
+                "energy_tax": 0.0,
+                "ode": 0.0,
+            },
+            "standing": {"network_fee": 0.0, "management_fee": 0.0},
+            "credits": {"heffingskorting": 0.0},
+        }
+        deltas = PeriodDeltas(
+            d1=Decimal("1"), d2=Decimal("1"),
+            r1=Decimal("0"), r2=Decimal("0"),
+        )
+        fn = get_strategy("manual")
+        result = fn(deltas, _ts(10), values, _NO_SESSION)
+        # import_cost = 1×0.2 + 1×0.1 = 0.3 exactly
+        assert result["import_cost"] == Decimal("0.3"), (
+            f"Expected Decimal('0.3'), got {result['import_cost']!r} — "
+            "float arithmetic leaking in?"
+        )
+
+    def test_result_values_are_decimal_type(self) -> None:
+        values = {
+            "energy": {
+                "buy": {"normal": 0.133, "dal": 0.127},
+                "sell": {"normal": 0.05, "dal": 0.05},
+                "energy_tax": 0.11,
+                "ode": 0.0,
+            },
+            "standing": {"network_fee": 9.87, "management_fee": 9.87},
+            "credits": {"heffingskorting": 600.0},
+        }
+        deltas = PeriodDeltas(
+            d1=Decimal("1"), d2=Decimal("1"),
+            r1=Decimal("1"), r2=Decimal("1"),
+        )
+        fn = get_strategy("manual")
+        result = fn(deltas, _ts(10), values, _NO_SESSION)
+        assert isinstance(result["import_cost"], Decimal)
+        assert isinstance(result["export_revenue"], Decimal)
+        assert isinstance(result["net_cost"], Decimal)
+
+
+# ---------------------------------------------------------------------------
+# 4-7. Tibber strategy
+# ---------------------------------------------------------------------------
+
+
+class TestTibberStrategy:
+    """Verify Tibber price-lookup and billing calculations."""
+
+    _VALUES = {
+        "energy": {
+            "energy_tax": 0.10,
+            "sell_adjust": 0.0,
+        },
+        "standing": {"management_fee": 5.99, "network_fee": 9.87},
+        "credits": {"heffingskorting": 600.0},
+    }
+
+    def _call(
+        self,
+        deltas: PeriodDeltas,
+        t0: datetime,
+        session: Session,
+        values: dict | None = None,
+    ) -> dict:
+        fn = get_strategy("tibber")
+        return fn(deltas, t0, values or self._VALUES, session)
+
+    def test_buy_equals_total(self, tibber_db) -> None:
+        t0 = _ts(10, 0)
+        with Session(tibber_db) as session:
+            _insert_tibber_price(session, starts_at=_ts(9, 45), total=0.25)
+            session.commit()
+
+        with Session(tibber_db) as session:
+            deltas = PeriodDeltas(
+                d1=Decimal("1"), d2=Decimal("1"),
+                r1=Decimal("0"), r2=Decimal("0"),
+            )
+            result = self._call(deltas, t0, session)
+        # buy = total = 0.25; import_cost = 2 × 0.25 = 0.50
+        assert result["import_cost"] == Decimal("2") * Decimal("0.25")
+
+    def test_sell_equals_total_minus_energy_tax_minus_adjust(self, tibber_db) -> None:
+        t0 = _ts(10, 0)
+        with Session(tibber_db) as session:
+            _insert_tibber_price(session, starts_at=_ts(9, 45), total=0.25)
+            session.commit()
+
+        values = {
+            "energy": {"energy_tax": 0.10, "sell_adjust": 0.02},
+            "standing": {"management_fee": 5.99, "network_fee": 9.87},
+            "credits": {"heffingskorting": 600.0},
+        }
+        with Session(tibber_db) as session:
+            deltas = PeriodDeltas(
+                d1=Decimal("0"), d2=Decimal("0"),
+                r1=Decimal("1"), r2=Decimal("1"),
+            )
+            result = self._call(deltas, t0, session, values=values)
+        # sell = 0.25 - 0.10 - 0.02 = 0.13; export_revenue = 2 × 0.13 = 0.26
+        assert result["export_revenue"] == Decimal("2") * Decimal("0.13")
+
+    def test_uses_most_recent_price_before_t0(self, tibber_db) -> None:
+        """Correct row: starts_at ≤ t0, most recent wins."""
+        t0 = _ts(10, 0)
+        with Session(tibber_db) as session:
+            # Older price (should NOT be used)
+            _insert_tibber_price(session, starts_at=_ts(9, 0), total=0.10)
+            # Closer price (starts_at ≤ t0, should be used)
+            _insert_tibber_price(session, starts_at=_ts(9, 45), total=0.30)
+            # Future price (starts_at > t0, must NOT be used)
+            _insert_tibber_price(session, starts_at=_ts(10, 15), total=0.99)
+            session.commit()
+
+        with Session(tibber_db) as session:
+            deltas = PeriodDeltas(
+                d1=Decimal("1"), d2=Decimal("0"),
+                r1=Decimal("0"), r2=Decimal("0"),
+            )
+            result = self._call(deltas, t0, session)
+        # Only the 09:45 price (total=0.30) should be used.
+        snapshot = result["pricing"]
+        assert Decimal(snapshot["total"]) == Decimal("0.30")
+
+    def test_tibber_sums_both_tariff_registers(self, tibber_db) -> None:
+        """Tibber does not split dal/normal; import_cost = (d1+d2) × buy."""
+        t0 = _ts(10, 0)
+        with Session(tibber_db) as session:
+            _insert_tibber_price(session, starts_at=_ts(9, 45), total=0.20)
+            session.commit()
+
+        with Session(tibber_db) as session:
+            deltas = PeriodDeltas(
+                d1=Decimal("3"), d2=Decimal("2"),
+                r1=Decimal("0"), r2=Decimal("0"),
+            )
+            result = self._call(deltas, t0, session)
+        # import_cost = (3+2) × 0.20 = 1.00
+        assert result["import_cost"] == Decimal("1.00")
+
+    def test_negative_total_gives_negative_export_revenue(self, tibber_db) -> None:
+        """When total is negative, selling electricity costs money (correct behaviour)."""
+        t0 = _ts(10, 0)
+        with Session(tibber_db) as session:
+            # total = -0.05; sell = -0.05 - 0.10 - 0.0 = -0.15
+            _insert_tibber_price(session, starts_at=_ts(9, 45), total=-0.05)
+            session.commit()
+
+        with Session(tibber_db) as session:
+            deltas = PeriodDeltas(
+                d1=Decimal("0"), d2=Decimal("0"),
+                r1=Decimal("2"), r2=Decimal("2"),
+            )
+            result = self._call(deltas, t0, session)
+        # sell = -0.05 - 0.10 - 0.0 = -0.15; export_revenue = 4 × (-0.15) = -0.60
+        assert result["export_revenue"] < 0
+        assert result["export_revenue"] == Decimal("4") * (
+            Decimal("-0.05") - Decimal("0.10") - Decimal("0.0")
+        )
+
+    def test_negative_total_exact_calculation(self, tibber_db) -> None:
+        """Full hand-calculation for negative-total scenario."""
+        t0 = _ts(10, 0)
+        total = Decimal("-0.05")
+        energy_tax = Decimal("0.10")
+        sell_adjust = Decimal("0.0")
+        with Session(tibber_db) as session:
+            _insert_tibber_price(session, starts_at=_ts(9, 45), total=float(total))
+            session.commit()
+
+        with Session(tibber_db) as session:
+            deltas = PeriodDeltas(
+                d1=Decimal("1"), d2=Decimal("1"),  # delivered = 2 kWh
+                r1=Decimal("1"), r2=Decimal("1"),  # returned  = 2 kWh
+            )
+            result = self._call(deltas, t0, session)
+
+        buy = total  # -0.05
+        sell = total - energy_tax - sell_adjust  # -0.15
+        expected_import = Decimal("2") * buy   # -0.10
+        expected_export = Decimal("2") * sell  # -0.30
+        expected_net = expected_import - expected_export  # 0.20
+
+        assert result["import_cost"] == expected_import
+        assert result["export_revenue"] == expected_export
+        assert result["net_cost"] == expected_net
+
+    def test_no_price_before_t0_raises(self, tibber_db) -> None:
+        """When no TibberPrice exists with starts_at ≤ t0, TibberPriceNotFoundError is raised."""
+        t0 = _ts(10, 0)
+        with Session(tibber_db) as session:
+            # Only a future price — starts_at > t0.
+            _insert_tibber_price(session, starts_at=_ts(10, 15), total=0.25)
+            session.commit()
+
+        fn = get_strategy("tibber")
+        with Session(tibber_db) as session:
+            deltas = PeriodDeltas(
+                d1=Decimal("1"), d2=Decimal("0"),
+                r1=Decimal("0"), r2=Decimal("0"),
+            )
+            with pytest.raises(TibberPriceNotFoundError):
+                fn(deltas, t0, self._VALUES, session)
+
+    def test_empty_tibber_table_raises(self, tibber_db) -> None:
+        """Empty tibber_price table raises TibberPriceNotFoundError."""
+        fn = get_strategy("tibber")
+        with Session(tibber_db) as session:
+            deltas = PeriodDeltas(
+                d1=Decimal("1"), d2=Decimal("0"),
+                r1=Decimal("0"), r2=Decimal("0"),
+            )
+            with pytest.raises(TibberPriceNotFoundError):
+                fn(deltas, _ts(10), self._VALUES, session)
+
+    def test_pricing_snapshot_contains_expected_keys(self, tibber_db) -> None:
+        t0 = _ts(10, 0)
+        with Session(tibber_db) as session:
+            _insert_tibber_price(session, starts_at=_ts(9, 45), total=0.20)
+            session.commit()
+
+        with Session(tibber_db) as session:
+            deltas = PeriodDeltas(
+                d1=Decimal("1"), d2=Decimal("0"),
+                r1=Decimal("0"), r2=Decimal("0"),
+            )
+            result = self._call(deltas, t0, session)
+        snapshot = result["pricing"]
+        assert snapshot["kind"] == "tibber"
+        assert "tibber_price_starts_at" in snapshot
+        assert "buy" in snapshot
+        assert "sell" in snapshot
+
+    def test_result_values_are_decimal_type(self, tibber_db) -> None:
+        t0 = _ts(10, 0)
+        with Session(tibber_db) as session:
+            _insert_tibber_price(session, starts_at=_ts(9, 45), total=0.20)
+            session.commit()
+
+        with Session(tibber_db) as session:
+            deltas = PeriodDeltas(
+                d1=Decimal("1"), d2=Decimal("1"),
+                r1=Decimal("1"), r2=Decimal("1"),
+            )
+            result = self._call(deltas, t0, session)
+        assert isinstance(result["import_cost"], Decimal)
+        assert isinstance(result["export_revenue"], Decimal)
+        assert isinstance(result["net_cost"], Decimal)
+
+
+# ---------------------------------------------------------------------------
+# Tibber precision test
+# ---------------------------------------------------------------------------
+
+
+class TestTibberDecimalPrecision:
+    """Ensure Tibber arithmetic is exact Decimal (no float leakage)."""
+
+    def test_no_float_rounding_for_tricky_values(self, tibber_db) -> None:
+        """total=0.1, energy_tax=0.2 — float gives 0.1+0.2 error; Decimal must be exact."""
+        t0 = _ts(10, 0)
+        with Session(tibber_db) as session:
+            _insert_tibber_price(session, starts_at=_ts(9, 45), total=0.3)
+            session.commit()
+
+        values = {
+            "energy": {"energy_tax": 0.1, "sell_adjust": 0.2},
+            "standing": {"management_fee": 5.99, "network_fee": 9.87},
+            "credits": {"heffingskorting": 600.0},
+        }
+        fn = get_strategy("tibber")
+        with Session(tibber_db) as session:
+            deltas = PeriodDeltas(
+                d1=Decimal("0"), d2=Decimal("0"),
+                r1=Decimal("1"), r2=Decimal("0"),
+            )
+            result = fn(deltas, t0, values, session)
+        # sell = 0.3 - 0.1 - 0.2 = 0.0 exactly (float gives ~2.8e-17)
+        assert result["export_revenue"] == Decimal("0"), (
+            f"Expected Decimal('0'), got {result['export_revenue']!r} — "
+            "float arithmetic leaking in?"
+        )