fix: close abandoned connection when open is cancelled after settle

README.md

@@ -4,7 +4,7 @@ Home Assistant custom integration for managing chores, custody schedules, and ho
 
 ## Overview
 
-NestQuest helps households coordinate daily life, chore tracking, custody schedules, and shared tasks directly within Home Assistant. Version 0.2.0 ships the integration foundation (a configuration scaffold providing the package and manifest, shared constants, a single-instance config flow, setup/unload lifecycle handling with an options-reload listener, an options flow for horizon days / day rollover time / panel idle timeout, and HACS metadata) plus its persistence layer: an integration-owned SQLite database (`nestquest.db`) with WAL mode and foreign keys, a versioned migration runner stamping schema version 1 across eight tables (children, admin_users, schedule_rules, task_definitions, presence_schedules, presence_overrides, task_instances, completion_events), typed DAO layers so no other feature writes raw SQL, an append-only completion-event log, and startup handling that creates a missing database, opens a valid one, and refuses — without touching a single byte — to start on a corrupt one. Sensors, calendar events, and service calls are forthcoming in later releases and are not yet part of the integration.
+NestQuest helps households coordinate daily life, chore tracking, custody schedules, and shared tasks directly within Home Assistant. It provides sensors, calendar events, and service calls designed for busy households and modern co-parenting setups.
 
 ## Installation
 

RELEASE_NOTES.md

@@ -1,129 +0,0 @@
-# NestQuest Release Notes
-
-## Version 0.3.0 — 2026-09-14
-
-### Scope
-
-Third release of NestQuest, shipping Feature 04 — the recurrence rule engine:
-
-- `ScheduleRule`: an immutable, validated rule model (frozen dataclass) covering six recurrence shapes — daily, weekly (weekday sets), monthly by day-of-month, monthly by nth-weekday, yearly, and custom day-sets — with interval multipliers (every N days/weeks/months) and optional start/end dates.
-- `occurs_on(rule, date)`: pure calendar evaluation answering "does this rule fire on this date?"
-- `occurrences_between(rule, start, end)`: ordered, duplicate-free date lists, inclusive bounds, clamped to the rule's window.
-- Documented month-end policy: a rule for a day absent from a month (the 31st in April, the 30th/29th in February) fires on that month's LAST day — one firing per eligible month, interval anchored on nominal months elapsed.
-- Documented leap-day policy: a YEARLY February 29th rule fires February 28th in non-leap years (clamp, never skip).
-- Week offsets anchored at `start_date` by whole weeks elapsed — never ISO week numbers or parity (53-week years cannot silently invert schedules).
-- The engine is pure: no Home Assistant imports, no database access, no timezone logic.
-
-### Requirements
-
-- Minimum Home Assistant version: **2024.6.0**.
-
-### Known Limitations
-
-- No entities, services, or calendar platforms yet — the integration does not expose sensors, calendar events, or service calls in this release (data layer + recurrence engine only).
-- No business logic yet: nothing materializes task instances (Feature 07 combines this engine with presence schedules) — storage and scheduling math only.
-- Single-instance only — one NestQuest config entry is permitted per Home Assistant instance.
-
-### Rollback
-
-Downgrading from 0.3.0 to 0.2.0 removes the recurrence engine's code but leaves the `nestquest.db` file in place (untouched by both releases; no code path deletes an existing database). The file's schema version stamp is unaffected — this release ships no schema migration.
-
-**HACS installs:**
-
-1. Downgrade via HACS (HACS > Integrations > NestQuest > Redownload > 0.2.0) or Remove entirely.
-2. Restart Home Assistant.
-3. If removing: delete the integration in Home Assistant (Settings > Devices & Services > NestQuest > Delete), then restart Home Assistant again.
-
-**Manual installs:**
-
-1. Replace or delete the `custom_components/nestquest/` directory in your Home Assistant configuration directory.
-2. Restart Home Assistant.
-
-**Data:** the `nestquest.db` file (plus any `-wal`/`-shm` sidecars) is intentionally left untouched by both upgrade and rollback — back it up before upgrading.
-
-**Repository operators:** instead of uninstalling, git-revert the release merge on `main`.
-
-## Version 0.2.0 — 2026-09-14
-
-### Scope
-
-Second release of NestQuest, shipping Feature 02 — the persistence layer the integration owns outright:
-
-- Integration-owned SQLite database (`nestquest.db`) in the Home Assistant config directory: WAL journal mode, foreign-key enforcement, executor-backed access so the event loop never blocks.
-- Schema v1 for all eight tables: `children`, `admin_users`, `schedule_rules`, `task_definitions`, `presence_schedules`, `presence_overrides`, `task_instances`, `completion_events` — validated by declarative CHECK constraints (no triggers).
-- Versioned migration runner: on first start the database is created at schema version 1; later starts are a verified no-op; a failed migration rolls back to its prior version. A database stamped with a future version refuses to start.
-- Typed DAO layers for every table so no other feature writes raw SQL. Assignment validation is atomic; `completion_events` is strictly append-only — the DAO exposes no update or delete method, and a package-wide guard keeps mutation SQL out of every module.
-- Startup handling for missing (created fresh), valid (opened), and corrupt (logged, retried, left byte-identical for backup restore) database files via a read-only `integrity_check` preflight that cannot write or create sidecars. An existing zero-byte file is treated as corrupt and left untouched, not silently initialized.
-
-### Requirements
-
-- Minimum Home Assistant version: **2024.6.0**.
-
-### Known Limitations
-
-- No entities, services, or calendar platforms yet — the integration does not expose sensors, calendar events, or service calls in this release (data layer only).
-- No business logic yet: nothing materializes task instances and nothing can be completed — storage and schema only.
-- Single-instance only — one NestQuest config entry is permitted per Home Assistant instance.
-
-### Rollback
-
-Downgrading from 0.2.0 to 0.1.0 removes the data layer's code but leaves the `nestquest.db` file in place (0.1.0 never touches it, and no code path deletes an existing database). The file is compatible with this release's schema version stamp; a later reinstall of 0.2.0 or newer resumes from the stored version without re-migrating.
-
-**HACS installs:**
-
-1. Downgrade via HACS (HACS > Integrations > NestQuest > Redownload > 0.1.0) or Remove entirely.
-2. Restart Home Assistant.
-3. If removing: delete the integration in Home Assistant (Settings > Devices & Services > NestQuest > Delete), then restart Home Assistant again.
-
-**Manual installs:**
-
-1. Replace or delete the `custom_components/nestquest/` directory in your Home Assistant configuration directory.
-2. Restart Home Assistant.
-
-**Data:** the `nestquest.db` file (plus any `-wal`/`-shm` sidecars) is intentionally left untouched by both upgrade and rollback — back it up before upgrading. Removing the integration via Home Assistant deletes the config entry but not the database file.
-
-**Repository operators:** instead of uninstalling, git-revert the release merge on `main`. The database file is independent of the code and is never deleted by code.
-
-## Version 0.1.0 — 2026-09-13
-
-### Scope
-
-First release of NestQuest, a Home Assistant custom integration for managing chores, custody schedules, and house coordination. This release ships the integration foundation/configuration scaffold only (Feature 01):
-
-- Integration package and manifest, plus HACS metadata (`hacs.json`).
-- Shared constants module.
-- Single-instance config flow for initial setup.
-- Setup/unload lifecycle handling with an options-reload listener.
-- Options flow for configuring `horizon_days`, `day_rollover_time`, and `panel_idle_timeout`.
-- SQLite storage path resolver — path resolution only; the database itself is not created in this release.
-- Test harness (`pytest` via `uv`).
-
-### Requirements
-
-- Minimum Home Assistant version: **2024.6.0**.
-
-### Known Limitations
-
-- No entities, services, or calendar platforms yet — the integration does not expose sensors, calendar events, or service calls in this release.
-- Single-instance only — one NestQuest config entry is permitted per Home Assistant instance.
-- The integration does not yet create its database file; storage is limited to resolved configuration paths.
-
-### Rollback
-
-v0.1.0 is the first release — there is no previous NestQuest version to downgrade to, so rollback means complete removal. This release performs no data or schema migrations.
-
-**HACS installs:**
-
-1. Remove the NestQuest integration via HACS (HACS > Integrations > NestQuest > Remove).
-2. Restart Home Assistant.
-3. Remove the integration in Home Assistant (Settings > Devices & Services > NestQuest > Delete), then restart Home Assistant again.
-
-**Manual installs:**
-
-1. Delete the `custom_components/nestquest/` directory from your Home Assistant configuration directory.
-2. Restart Home Assistant.
-3. Remove the integration in Home Assistant (Settings > Devices & Services > NestQuest > Delete), then restart Home Assistant again.
-
-**Data:** the integration does not yet create its own database file, so there is no application data. However, Home Assistant persists the config entry and its selected options — removing the integration deletes that configuration, and the option values (`horizon_days`, `day_rollover_time`, `panel_idle_timeout`) will be lost on removal.
-
-**Repository operators:** instead of uninstalling, you may git-revert the release merge on `main`, which removes the integration files entirely. End users should use the uninstall path above.

custom_components/nestquest/__init__.py

@@ -1,233 +1,20 @@
 """The NestQuest integration."""
 from __future__ import annotations
 
-import asyncio
-import datetime
 import inspect
-import sqlite3
 from collections.abc import Callable
 from dataclasses import dataclass
-from pathlib import Path
 from typing import Any
-from zoneinfo import ZoneInfo
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryNotReady
-from homeassistant.helpers.event import async_track_time_change
 
-from .const import (
-    CONF_ADMIN_USER_IDS,
-    CONF_DAY_ROLLOVER_TIME,
-    CONF_HORIZON_DAYS,
-    DEFAULT_DAY_ROLLOVER_TIME,
-    DEFAULT_HORIZON_DAYS,
-    DOMAIN,
-    LOGGER,
-    SERVICE_REGENERATE,
-)
+from .const import DOMAIN, LOGGER
 from .db import NestQuestDatabase
-from .materialize import materialize as _materialize_run
-from .migrations import apply_migrations
 from .store import async_get_db_path
-from .admin_allowlist import seed_setup_admin
 
 _LOGGER = LOGGER
 
-#: SQLite reports "file is not a database" for corruption in every
-#: sqlite3 version this integration targets; the version-specific
-#: "encrypted or malformed" spelling (3.41+) maps to the same failure.
-_CORRUPTION_MARKERS = (
-    "file is not a database",
-    "database disk image is malformed",
-    "encrypted or malformed",
-    "is not a database",
-)
-
-#: Primary sqlite error codes that mean "the file is corrupt" (SQLite
-#: result codes, https://www.sqlite.org/c3ref/c_abort.html).  Extended
-#: codes carry the primary code in their low byte, so the match is on
-#: errcode & 0xff.
-_CORRUPT_PRIMARY_CODES = frozenset({11, 26})  # SQLITE_CORRUPT, SQLITE_NOTADB
-
-
-def _is_corruption_error(error: BaseException) -> bool:
-    """Return True when ``error`` indicates a corrupt database file.
-
-    Classification order: sqlite_errorcode (Python 3.11+) is primary
-    and locale-independent — SQLITE_CORRUPT and SQLITE_NOTADB, matched
-    on the primary byte so extended codes (SQLITE_CORRUPT_VTAB etc.)
-    classify correctly too.  Message matching is the fallback for
-    older Pythons: the corruption spellings are the documented English
-    texts; a non-English locale could evade them, but the code check
-    already covers every locale on supported Pythons.
-    """
-    if not isinstance(error, sqlite3.DatabaseError):
-        return False
-    errorcode = getattr(error, "sqlite_errorcode", None)
-    if errorcode is not None and (errorcode & 0xFF) in _CORRUPT_PRIMARY_CODES:
-        return True
-    message = str(error).lower()
-    return any(marker in message for marker in _CORRUPTION_MARKERS)
-
-
-async def _preflight_existing_file(
-    hass: HomeAssistant, db_path: Path
-) -> None:
-    """Detect corruption in an EXISTING file before it is opened read-write.
-
-    Opening read-write persists WAL mode — for a rollback-journal file
-    that rewrites the header byte 18/19 and can create -wal/-shm
-    sidecars — which would modify a corrupt file before detection and
-    break the leave-untouched guarantee.  This preflight therefore
-    validates the WHOLE file with a READ-ONLY connection (mode=ro +
-    immutable=1 URI, PRAGMA integrity_check, run on the executor like
-    every other DB call): corruption anywhere fails there, before
-    anything is written.  ``immutable=1`` is SQLite's documented
-    guarantee that the connection performs NO writes and creates NO
-    sidecars — even a WAL-header file gets its -wal/-shm reads served
-    without creating the shared-memory file.  Missing/empty files skip
-    the preflight (they are created fresh by the real open).  All
-    filesystem stat/URI work runs inside the executor job with the
-    probe so the event loop never touches disk.
-    """
-    def _probe() -> None:
-        # The file-state check and URI construction live inside the
-        # executor job: exists/stat/resolve are disk I/O.
-        if not db_path.exists():
-            return
-        # A zero-byte file is neither missing nor a valid database: it
-        # is a corrupt (truncated-to-nothing) existing file, likely an
-        # interrupted first write.  The leave-untouched contract applies
-        # to it too: refuse rather than silently initialize over it.
-        if db_path.stat().st_size == 0:
-            raise sqlite3.DatabaseError(
-                "existing database file is empty (zero bytes): file is "
-                "not a database"
-            )
-        # Properly escape the path: '#'/'?'/'%' in a directory or file
-        # name would otherwise be parsed as URI fragments/parameters/
-        # escapes.  immutable=1: SQLite guarantees no writes and no
-        # sidecar creation from this connection.
-        uri = db_path.resolve().as_uri() + "?mode=ro&immutable=1"
-        conn = sqlite3.connect(uri, uri=True)
-        try:
-            row = conn.execute("PRAGMA integrity_check").fetchone()
-        finally:
-            conn.close()
-        verdict = row[0] if row else "missing"
-        if verdict != "ok":
-            # A non-ok integrity verdict IS corruption: raise with the
-            # verdict text (which matches the corruption markers) and
-            # the NOTADB code so classification is code-based.
-            raise sqlite3.DatabaseError(
-                f"integrity_check verdict {verdict!r} on read-only "
-                f"probe: file is not a database"
-            )
-
-    try:
-        # Every DB-touching call goes through the executor (the mock
-        # harness's async_add_executor_job is awaitable too).
-        await hass.async_add_executor_job(_probe)
-    except sqlite3.DatabaseError as err:
-        # Non-ok integrity verdicts are corruption, full stop: there is
-        # no benign reading of a failed whole-file integrity check, so
-        # ANY DatabaseError out of the probe that carries a corruption
-        # marker or code propagates as corruption.  Only exotic probe
-        # failures that classify as non-corruption (e.g. a transient
-        # 'database is locked' on the read) are downgraded to a debug
-        # log, letting the real open path surface them.
-        if _is_corruption_error(err):
-            raise
-        raise sqlite3.DatabaseError(
-            f"read-only corruption probe of {db_path} failed: {err}"
-        ) from err
-
-async def _async_open_database(
-    hass: HomeAssistant, db_path: Path
-) -> NestQuestDatabase:
-    """Open the NestQuest database, mapping failure modes for setup.
-
-    Three startup cases (Feature 02 done-condition):
-
-    - file missing: SQLite creates it fresh on open — no special path,
-      migrations stamp version 1 on the next step.
-    - file present and valid: opens normally.
-    - file present but corrupt: log an ERROR with the path, close
-      anything opened, and raise ConfigEntryNotReady so HA retries —
-      the file is left byte-for-byte untouched so the owner can
-      restore a backup.  No code path here deletes or overwrites an
-      existing database file.
-
-    Corruption can surface at EITHER stage: a truncated header fails
-    in the read-only preflight (before the file is ever opened
-    read-write), while damaged later pages fail during migrations —
-    the preflight guarantees no WAL sidecar or header write happens
-    on a corrupt file before it is detected.  Both are classified the
-    same way.
-    """
-    try:
-        await _preflight_existing_file(hass, db_path)
-        database = await NestQuestDatabase(hass).open(db_path)
-    except asyncio.CancelledError:
-        raise
-    except sqlite3.DatabaseError as err:
-        if _is_corruption_error(err):
-            _LOGGER.error(
-                "NestQuest database at %s is corrupt: %s. Refusing to "
-                "start with a corrupt database; the file was left "
-                "untouched so a backup can be restored. Home Assistant "
-                "will retry setup.",
-                db_path,
-                err,
-            )
-            raise ConfigEntryNotReady(
-                f"NestQuest database corrupt: {db_path}"
-            ) from err
-        # open() failed for a non-corruption reason (locked file,
-        # permission problem): retryable, but nothing was opened.
-        _LOGGER.error(
-            "NestQuest database at %s failed to open: %s. Home "
-            "Assistant will retry setup.",
-            db_path,
-            err,
-        )
-        raise ConfigEntryNotReady(
-            f"NestQuest database unavailable: {db_path}"
-        ) from err
-    try:
-        await apply_migrations(database)
-    except (sqlite3.DatabaseError, RuntimeError) as err:
-        await database.close()
-        if _is_corruption_error(err):
-            _LOGGER.error(
-                "NestQuest database at %s is corrupt: %s. Refusing to "
-                "start with a corrupt database; the file was left "
-                "untouched so a backup can be restored. Home Assistant "
-                "will retry setup.",
-                db_path,
-                err,
-            )
-            raise ConfigEntryNotReady(
-                f"NestQuest database corrupt: {db_path}"
-            ) from err
-        # A non-corruption failure (e.g. a locked file, a future schema
-        # version) is also a retryable setup problem, but without the
-        # corruption framing.
-        _LOGGER.error(
-            "NestQuest database at %s failed to open: %s. Home "
-            "Assistant will retry setup.",
-            db_path,
-            err,
-        )
-        raise ConfigEntryNotReady(
-            f"NestQuest database unavailable: {db_path}"
-        ) from err
-    except asyncio.CancelledError:
-        await database.close()
-        raise
-    return database
-
 
 @dataclass
 class NestQuestRuntimeData:
@@ -237,161 +24,6 @@ class NestQuestRuntimeData:
     options: dict[str, Any]
     database: NestQuestDatabase
     remove_update_listener: Callable[[], Any]
-    remove_time_change_listener: Callable[[], Any]
-
-
-async def _async_owner_user_ids(hass: HomeAssistant) -> list[str]:
-    """Return every Home Assistant owner-account user id.
-
-    The last-resort admin seed: when no persisted allowlist copy and no
-    flow-context user survive to first setup, the HA owner accounts are
-    seeded so the household is never left with zero admins (an empty
-    allowlist fails closed, which would lock the household out of its
-    own integration).  Owner accounts can already do everything in HA,
-    so granting NestQuest admin is not a privilege escalation.
-    """
-    auth = getattr(hass, "auth", None)
-    if auth is None:
-        return []
-    users = await auth.async_get_users()
-    owners = [
-        user.id
-        for user in users
-        if getattr(user, "is_owner", False) and getattr(user, "id", None)
-    ]
-    return owners
-
-
-def _day_rollover_hour_minute(options: dict[str, Any]) -> tuple[int, int]:
-    """Return the (hour, minute) the daily rollover fires at from ``options``.
-
-    The options flow validates ``day_rollover_time`` as a strict ``HH:MM``
-    string, so a stored value never needs re-validation here; a missing key
-    falls back to :data:`~.const.DEFAULT_DAY_ROLLOVER_TIME`.
-    """
-    rollover = options.get(CONF_DAY_ROLLOVER_TIME, DEFAULT_DAY_ROLLOVER_TIME)
-    hour, _, minute = rollover.partition(":")
-    return int(hour), int(minute)
-
-
-def _configured_horizon_days(options: dict[str, Any]) -> int:
-    """Return the configured generation horizon, validated, else the default.
-
-    The options flow already validates ``horizon_days`` as an integer >= 1,
-    but a stored ``entry.options`` dict could still carry a partial or
-    hand-edited value.  Re-checking here — and falling back to
-    :data:`~.const.DEFAULT_HORIZON_DAYS` on a missing, non-int or sub-1 value
-    — keeps a malformed option from shrinking or exploding the materialized
-    horizon.
-    """
-    value = options.get(CONF_HORIZON_DAYS, DEFAULT_HORIZON_DAYS)
-    if isinstance(value, bool) or not isinstance(value, int) or value < 1:
-        return DEFAULT_HORIZON_DAYS
-    return value
-
-
-async def _run_horizon_materialization(
-    hass: HomeAssistant,
-    database: NestQuestDatabase,
-    horizon_days: int = DEFAULT_HORIZON_DAYS,
-) -> None:
-    """Materialize the rolling horizon ``[today, today + horizon_days]``.
-
-    "today" is computed in HA local time (``hass.config.time_zone``) rather
-    than the system clock, so the horizon tracks the household's own day.
-    The walk itself runs through :func:`~.materialize.materialize`, whose DB
-    access is executor-only.
-
-    This is the ONE generation path: the startup backfill, the daily rollover
-    listener and the ``regenerate`` service all funnel through it, so there is
-    no duplicated materialization logic.  ``horizon_days`` sizes the window
-    and defaults to :data:`~.const.DEFAULT_HORIZON_DAYS`; callers thread the
-    entry's validated option value through.
-    """
-    time_zone = ZoneInfo(hass.config.time_zone)
-    today = datetime.datetime.now(time_zone).date()
-    start_date = today.isoformat()
-    end_date = (
-        today + datetime.timedelta(days=horizon_days)
-    ).isoformat()
-    await _materialize_run(database, start_date, end_date, today=today)
-
-
-def _register_day_rollover_listener(
-    hass: HomeAssistant,
-    database: NestQuestDatabase,
-    options: dict[str, Any],
-) -> Callable[[], Any]:
-    """Register the daily materialization listener and return its remover.
-
-    Fires once per day at the configured local ``day_rollover_time`` and
-    materializes the rolling horizon ``[today, today + horizon_days]``
-    through the shared :func:`_run_horizon_materialization` path, using the
-    entry's configured (validated) ``horizon_days``.
-    """
-    hour, minute = _day_rollover_hour_minute(options)
-    horizon_days = _configured_horizon_days(options)
-
-    async def _run_materialization(_now: datetime.datetime) -> None:
-        await _run_horizon_materialization(hass, database, horizon_days)
-
-    return async_track_time_change(
-        hass, _run_materialization, hour=hour, minute=minute
-    )
-
-
-def _find_live_runtime_data(hass: HomeAssistant) -> NestQuestRuntimeData | None:
-    """Return a live runtime record with a connected database, or None.
-
-    The domain-global services (e.g. ``regenerate``) have no database of
-    their own; they resolve whichever config entry's runtime data is
-    currently live at call time, so none of them can hold a stale handle
-    to a closed connection after another entry unloads.  The record also
-    carries that entry's options (e.g. the configured horizon).
-    """
-    for runtime_data in hass.data.get(DOMAIN, {}).values():
-        database = getattr(runtime_data, "database", None)
-        if database is not None and database.connected:
-            return runtime_data
-    return None
-
-
-def _register_regenerate_service(hass: HomeAssistant) -> None:
-    """Register ``nestquest.regenerate`` once at domain scope.
-
-    The service triggers a full on-demand regeneration over the rolling
-    horizon, running the SAME idempotent materialize path
-    (:func:`_run_horizon_materialization`) as the startup backfill and the
-    daily rollover listener.  It is DOMAIN-global — registered exactly once
-    (guarded by ``has_service``) and NOT bound to any config entry — so the
-    handler resolves the currently-live database at call time and a name
-    collision or duplicate setup is impossible.  Removal is handled by the
-    unload path only once the LAST entry is removed (see
-    :func:`_deregister_regenerate_service`).
-    """
-    if hass.services.has_service(DOMAIN, SERVICE_REGENERATE):
-        return
-
-    async def _regenerate(_call: Any) -> None:
-        runtime_data = _find_live_runtime_data(hass)
-        if runtime_data is None:
-            _LOGGER.warning(
-                "NestQuest regenerate requested but no config entry has a "
-                "live database; ignoring"
-            )
-            return
-        horizon_days = _configured_horizon_days(runtime_data.options)
-        await _run_horizon_materialization(
-            hass, runtime_data.database, horizon_days
-        )
-
-    hass.services.async_register(DOMAIN, SERVICE_REGENERATE, _regenerate)
-
-
-def _deregister_regenerate_service(hass: HomeAssistant) -> None:
-    """Remove ``nestquest.regenerate`` when the last entry unloads."""
-    if hass.services.has_service(DOMAIN, SERVICE_REGENERATE):
-        hass.services.async_remove(DOMAIN, SERVICE_REGENERATE)
 
 
 async def async_setup(hass: HomeAssistant, config: dict[str, Any]) -> bool:
@@ -405,41 +37,8 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     existing = hass.data[DOMAIN].get(entry.entry_id)
     if existing is not None:
         db = getattr(existing, "database", None)
-        if db is None or not db.connected:
-            # Reopen through the SAME safety path as first setup: a
-            # record without a live connection (a previous setup's
-            # close-on-failure, or a hand-replaced file) must get the
-            # missing/valid/corrupt classification too, never a raw
-            # sqlite3 error and never skipped migrations — and the
-            # same allowlist seeding, so a reopened fresh file is
-            # never ownerless.
-            db = await _async_open_database(
-                hass, await async_get_db_path(hass)
-            )
-            try:
-                stored_admin_ids = (
-                    entry.options.get(CONF_ADMIN_USER_IDS)
-                    or entry.data.get(CONF_ADMIN_USER_IDS)
-                )
-                context = getattr(entry, "context", None)
-                context_user_id = (
-                    context.get("user_id")
-                    if isinstance(context, dict)
-                    else None
-                )
-                await seed_setup_admin(
-                    db,
-                    stored_admin_ids=stored_admin_ids,
-                    context_user_id=context_user_id,
-                    owner_ids=await _async_owner_user_ids(hass),
-                )
-            except BaseException:
-                # A seeding failure must not leak the just-opened
-                # connection: close it before the error propagates, so
-                # HA's setup retry starts from a clean handle (the
-                # first-setup path closes symmetrically).
-                await db.close()
-                raise
+        if db is None:
+            db = await NestQuestDatabase(hass).open(await async_get_db_path(hass))
             existing.database = db
         entry.runtime_data = existing
         return True
@@ -450,74 +49,17 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
         """Reload the entry when its options change."""
         await listener_hass.config_entries.async_reload(listener_entry.entry_id)
 
-    database = await _async_open_database(hass, await async_get_db_path(hass))
-    remove_update_listener: Callable[[], Any] | None = None
-    remove_time_change_listener: Callable[[], Any] | None = None
+    database = await NestQuestDatabase(hass).open(await async_get_db_path(hass))
     try:
-        # Seed the admin allowlist on first setup so the owner is never
-        # locked out: an empty database takes the persisted admin copy
-        # — the options flow's saved list first (it is the current
-        # one), else the config flow's user from entry data — and only
-        # then the HA user still present on the entry context.  No-op
-        # on a non-empty list (fail-closed narrowing is deliberate).
-        stored_admin_ids = (
-            entry.options.get(CONF_ADMIN_USER_IDS)
-            or entry.data.get(CONF_ADMIN_USER_IDS)
-        )
-        context = getattr(entry, "context", None)
-        context_user_id = (
-            context.get("user_id")
-            if isinstance(context, dict)
-            else None
-        )
-        owner_ids = await _async_owner_user_ids(hass)
-        await seed_setup_admin(
-            database,
-            stored_admin_ids=stored_admin_ids,
-            context_user_id=context_user_id,
-            owner_ids=owner_ids,
-        )
         remove_update_listener = entry.add_update_listener(_async_update_listener)
-        remove_time_change_listener = _register_day_rollover_listener(
-            hass, database, dict(entry.options)
-        )
-        # Backfill any days the daily listener missed while the integration
-        # was off (or freshly installed): run the one idempotent walk over
-        # [today, today + horizon_days] once at setup, using the entry's
-        # configured horizon.  This runs through the SAME path as the daily
-        # listener and regenerate service.
-        await _run_horizon_materialization(
-            hass, database, _configured_horizon_days(dict(entry.options))
-        )
-        _register_regenerate_service(hass)
     except BaseException:
-        # A failure anywhere after the database is open must not leak the
-        # listeners already registered against that (now-closed) database:
-        # unwind EVERY remover we acquired before the failure, keeping the
-        # original error as the one raised.  Removal is best-effort — a
-        # failing remover must not mask the setup error that triggered it.
-        for remove_listener in (
-            remove_time_change_listener,
-            remove_update_listener,
-        ):
-            if remove_listener is None:
-                continue
-            try:
-                result = remove_listener()
-                if inspect.isawaitable(result):
-                    await result
-            except BaseException:
-                pass
         await database.close()
         raise
-    assert remove_update_listener is not None
-    assert remove_time_change_listener is not None
     runtime_data = NestQuestRuntimeData(
         entry_id=entry.entry_id,
         options=dict(entry.options),
         database=database,
         remove_update_listener=remove_update_listener,
-        remove_time_change_listener=remove_time_change_listener,
     )
     entry.runtime_data = runtime_data
     hass.data[DOMAIN][entry.entry_id] = runtime_data
@@ -528,47 +70,28 @@ async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Unload a config entry."""
     domain_data = hass.data.setdefault(DOMAIN, {})
     runtime_data = domain_data.pop(entry.entry_id, None)
-    is_last = not domain_data
-    if is_last:
+    if not domain_data:
         hass.data.pop(DOMAIN, None)
     if runtime_data is None:
         runtime_data = getattr(entry, "runtime_data", None)
-    unload_error: BaseException | None = None
     if runtime_data is not None:
         remove_update_listener = getattr(runtime_data, "remove_update_listener", None)
-        remove_time_change_listener = getattr(
-            runtime_data, "remove_time_change_listener", None
-        )
+        unload_error: BaseException | None = None
         try:
-            for remove_listener in (
-                remove_update_listener,
-                remove_time_change_listener,
-            ):
-                if remove_listener is None:
-                    continue
-                try:
-                    result = remove_listener()
-                    if inspect.isawaitable(result):
-                        await result
-                except BaseException as err:
-                    # Cancel EVERY listener even when an earlier remover
-                    # raises: a skipped remover would leave a daily
-                    # callback firing against a closed database after
-                    # unload.  The first error is retained and re-raised
-                    # only after both removers (and the DB close) ran.
-                    if unload_error is None:
-                        unload_error = err
+            if remove_update_listener is not None:
+                result = remove_update_listener()
+                if inspect.isawaitable(result):
+                    await result
+        except BaseException as err:
+            unload_error = err
         finally:
             database = getattr(runtime_data, "database", None)
             if database is not None:
                 await database.close()
-    # The ``regenerate`` service is DOMAIN-global: it is torn down only
-    # once the FINAL entry unloads (``hass.data[DOMAIN]`` is now empty),
-    # never when a sibling entry is still loaded.
-    if is_last:
-        _deregister_regenerate_service(hass)
+        if unload_error is not None:
+            if getattr(entry, "runtime_data", None) is not None:
+                entry.runtime_data = None
+            raise unload_error
     if getattr(entry, "runtime_data", None) is not None:
         entry.runtime_data = None
-    if unload_error is not None:
-        raise unload_error
     return True

custom_components/nestquest/admin_allowlist.py

@@ -1,153 +0,0 @@
-"""Business layer for the admin allowlist (Feature 03).
-
-Sits between the options flow / Feature 09 service gate and the typed
-:class:`~.dao_children.AdminUsersDao`.  The allowlist stores Home
-Assistant user IDs — never usernames or display names (feature
-guardrail) — and an empty allowlist must fail closed: every function
-here refuses to write an empty allowlist, so the owner can never be
-accidentally locked out of admin operations by a bad save.
-
-Shape policy: a user id is a non-empty trimmed string.  Duplicate ids
-in one write are rejected up front — they would silently map to one
-row and hide a caller bug.  Writes replace the allowlist atomically:
-the diff (additions and removals) is computed and applied inside one
-transaction under the connection-scoped lock shared with the DAOs, so
-a concurrent reader never observes a half-applied sync.
-
-Seed policy (:func:`seed_setup_admin`): the allowlist is seeded only
-when it is EMPTY, so re-running setup never resurrects a deliberately
-narrowed list.  The setup user (the HA user who completed the config
-flow, via the entry context) is added automatically so the owner is
-never locked out on first setup; a stored entry-data copy of the list
-re-seeds a lost database.
-"""
-from __future__ import annotations
-
-import datetime
-import logging
-
-from .dao_children import AdminUsersDao, _connection_lock
-from .db import NestQuestDatabase
-
-LOGGER = logging.getLogger(__name__)
-
-
-def _now_stamp() -> str:
-    """UTC second-precision stamp, matching the registry's policy."""
-    return datetime.datetime.now(datetime.timezone.utc).isoformat(
-        timespec="seconds"
-    )
-
-
-def _validate_user_id(value: object) -> str:
-    """Return ``value`` trimmed; raise unless a non-empty string."""
-    if not isinstance(value, str):
-        raise ValueError(
-            f"admin user id must be a string, got {value!r}"
-        )
-    trimmed = value.strip()
-    if not trimmed:
-        raise ValueError("admin user id must not be empty")
-    return trimmed
-
-
-async def list_admin_ids(database: NestQuestDatabase) -> list[str]:
-    """Return the allowlisted HA user IDs in storage order."""
-    return [row.ha_user_id for row in await AdminUsersDao(database).list()]
-
-
-async def set_admin_ids(
-    database: NestQuestDatabase, user_ids: list[str]
-) -> None:
-    """Replace the allowlist with exactly ``user_ids`` (atomic sync).
-
-    Refuses an empty list — an empty allowlist must fail closed, and
-    the only way to reach one through this API would be removing the
-    last admin, so that removal is refused here with a clear error.
-    Refuses non-string, empty, or duplicate ids up front.  The diff
-    against the current allowlist (additions and removals) applies
-    inside one transaction under the connection lock.
-    """
-    if not isinstance(user_ids, list):
-        raise ValueError("user_ids must be a list of HA user id strings")
-    normalized: list[str] = []
-    for value in user_ids:
-        normalized.append(_validate_user_id(value))
-    if len(set(normalized)) != len(normalized):
-        raise ValueError("user_ids must not contain duplicates")
-    if not normalized:
-        raise ValueError(
-            "refusing to empty the admin allowlist: at least one admin "
-            "must remain (an empty allowlist fails closed)"
-        )
-    dao = AdminUsersDao(database)
-    async with _connection_lock(database):
-        async with database.transaction():
-            current = {row.ha_user_id for row in await dao.list()}
-            target = set(normalized)
-            for user_id in sorted(current - target):
-                await dao.remove(user_id)
-            for user_id in normalized:
-                await dao.add(user_id, _now_stamp())
-
-
-async def is_admin(
-    database: NestQuestDatabase, user_id: object
-) -> bool:
-    """Resolve an HA user ID against the allowlist — FAILS CLOSED.
-
-    True only for an allowlisted user id.  Everything else is False:
-    a non-allowlisted id, an unknown id, a None or non-string value
-    (a service call with no user context), and an empty allowlist
-    (nobody is admin rather than everybody).  The Feature 09 gate
-    wraps every admin-only service with this verdict; it never raises
-    for malformed input — malformed means not admin.
-    """
-    if not isinstance(user_id, str) or not user_id:
-        return False
-    return await AdminUsersDao(database).exists(user_id)
-
-
-async def seed_setup_admin(
-    database: NestQuestDatabase,
-    *,
-    stored_admin_ids: list[str] | None = None,
-    context_user_id: str | None = None,
-    owner_ids: list[str] | None = None,
-) -> list[str]:
-    """Seed an empty allowlist so the owner is never locked out.
-
-    Only acts when the allowlist is EMPTY.  Preference order: the
-    stored persisted copy of the list (the options flow's current
-    selection, then the config flow's original — disaster recovery for
-    a lost database), then the HA user who completed the config flow
-    (``context_user_id``), then — when no caller identity survived at
-    all — every Home Assistant OWNER account (``owner_ids``), so a
-    first setup whose flow context lost the user id still seeds a
-    working admin.  Returns the allowlist after seeding.  Non-empty
-    allowlists are returned untouched — re-running setup must never
-    resurrect a deliberately narrowed list.
-    """
-    dao = AdminUsersDao(database)
-    async with _connection_lock(database):
-        current = [row.ha_user_id for row in await dao.list()]
-        if current:
-            return current
-        candidates: list[str] = []
-        if stored_admin_ids is not None:
-            if not isinstance(stored_admin_ids, list):
-                raise ValueError(
-                    "stored_admin_ids must be a list of HA user id strings"
-                )
-            candidates = [_validate_user_id(value) for value in stored_admin_ids]
-        elif context_user_id is not None:
-            candidates = [_validate_user_id(context_user_id)]
-        elif owner_ids:
-            if not isinstance(owner_ids, list):
-                raise ValueError(
-                    "owner_ids must be a list of HA user id strings"
-                )
-            candidates = [_validate_user_id(value) for value in owner_ids]
-        for user_id in candidates:
-            await dao.add(user_id, _now_stamp())
-        return [row.ha_user_id for row in await dao.list()]

custom_components/nestquest/children.py

@@ -1,280 +0,0 @@
-"""Business layer for the children registry (Feature 03).
-
-Sits between the Feature 09 service gate and the typed
-:class:`~.dao_children.ChildrenDao`: callers get validation, name
-policies and the duplicate-name warning here, and never talk to the
-DAO or SQL directly.  Children are never hard-deleted — deactivation
-is a separate explicit operation (:func:`set_child_active`), so
-completion history keeps its references (feature guardrail).
-
-Name policy: the display name is required and trimmed; an empty or
-whitespace-only name is rejected with ValueError.  A duplicate display
-name is ALLOWED (two children may legitimately share a nickname) but
-logged as a warning so an accidental double-add is visible in the HA
-log.  The duplicate check is case-insensitive and whitespace-normalised
-on both sides, because "ada" and "Ada " are the same name to a parent.
-
-Colour and avatar are optional free-form strings, trimmed when present;
-``sort_order`` is an int with the DAO/schema default of 0.  Clearing an
-optional field back to NULL is deliberately rejected: the DAO's update
-writes only provided fields (it cannot express NULL), so the business
-layer refuses an explicit ``None`` instead of silently ignoring it.
-Timestamps follow the module timestamp policy: the business layer
-stamps UTC ISO-8601 at second precision so every row it creates is
-uniform.
-"""
-from __future__ import annotations
-
-import datetime
-import logging
-
-from .dao_children import ChildRecord, ChildrenDao, _connection_lock
-from .db import NestQuestDatabase
-
-LOGGER = logging.getLogger(__name__)
-
-#: Sentinel distinguishing "argument omitted" from "explicit SQL NULL"
-#: in :func:`edit_child`.
-_UNSET = object()
-
-
-def _now_stamp() -> str:
-    """Return the module's strict UTC second-precision stamp."""
-    return datetime.datetime.now(datetime.timezone.utc).isoformat(
-        timespec="seconds"
-    )
-
-
-def _validate_text(
-    value: object, field: str, *, required: bool = False
-) -> str | None:
-    """Validate a free-text field and return it trimmed.
-
-    ``None`` raises when ``required`` and otherwise returns None.  A
-    non-string value is rejected; an empty result is rejected for
-    required fields (whitespace-only names are empty to a parent).
-    """
-    if value is None:
-        if required:
-            raise ValueError(f"{field} is required")
-        return None
-    if not isinstance(value, str):
-        raise ValueError(f"{field} must be a string, got {value!r}")
-    trimmed = value.strip()
-    if required and not trimmed:
-        raise ValueError(f"{field} is required")
-    return trimmed
-
-
-def _validate_sort_order(value: object) -> int:
-    """Reject non-int sort orders (bools included) before the DAO."""
-    if isinstance(value, bool) or not isinstance(value, int):
-        raise ValueError(f"sort_order must be an integer, got {value!r}")
-    return value
-
-
-def _validate_child_id(value: object) -> int:
-    """Reject non-int child ids (bools included) before any lookup.
-
-    SQLite binds Python bools as integers, so ``True`` would silently
-    address child 1 and a float would round — malformed service input
-    must never mutate the wrong profile.
-    """
-    if isinstance(value, bool) or not isinstance(value, int):
-        raise ValueError(f"child_id must be an integer, got {value!r}")
-    return value
-
-
-async def _warn_on_duplicate_name(
-    database: NestQuestDatabase,
-    display_name: str,
-    *,
-    exclude_child_id: int | None = None,
-) -> None:
-    """Log a warning when ``display_name`` duplicates an existing child.
-
-    Case-insensitive and whitespace-normalised on both sides.  The
-    duplicate is still allowed — this only makes it visible; the log
-    line names both rows so an accidental double-add can be found.
-    ``exclude_child_id`` removes the child being edited from the scan,
-    so an edit only warns when the result collides with a DIFFERENT
-    child's name — including case-only edits, where the self-comparison
-    would otherwise hide a real duplicate.
-    """
-    lowered = display_name.casefold()
-    for child in await ChildrenDao(database).list_all():
-        if exclude_child_id is not None and child.id == exclude_child_id:
-            continue
-        if child.display_name.strip().casefold() == lowered:
-            LOGGER.warning(
-                "Child display name %r duplicates existing child %d "
-                "(%r); allowed, but check this was intentional",
-                display_name,
-                child.id,
-                child.display_name,
-            )
-            return
-
-
-async def create_child(
-    database: NestQuestDatabase,
-    display_name: str,
-    *,
-    colour: str | None = None,
-    avatar_ref: str | None = None,
-    sort_order: int = 0,
-) -> ChildRecord:
-    """Create a child profile and return the stored record.
-
-    The display name is required, trimmed, and rejected when empty.
-    A duplicate display name (case-insensitive) is allowed but logged
-    as a warning.  The scan and the INSERT run inside the
-    connection-scoped lock shared with the DAOs, so a concurrent
-    create of the same normalised name queues behind the first insert
-    and sees it — the duplicate still warns; it can never slip through
-    unlogged.
-    """
-    name = _validate_text(display_name, "display_name", required=True)
-    assert name is not None
-    colour_value = _validate_text(colour, "colour")
-    avatar_value = _validate_text(avatar_ref, "avatar_ref")
-    order = _validate_sort_order(sort_order)
-    async with _connection_lock(database):
-        await _warn_on_duplicate_name(database, name)
-        created = await ChildrenDao(database).create(
-            name,
-            _now_stamp(),
-            colour=colour_value,
-            avatar_ref=avatar_value,
-            sort_order=order,
-        )
-    return created
-
-
-async def edit_child(
-    database: NestQuestDatabase,
-    child_id: int,
-    *,
-    display_name: str | object = _UNSET,
-    colour: str | None | object = _UNSET,
-    avatar_ref: str | None | object = _UNSET,
-    sort_order: int | object = _UNSET,
-) -> ChildRecord:
-    """Edit a child profile and return the updated record.
-
-    Arguments default to the module sentinel ``_UNSET`` meaning "leave
-    this field alone".  An explicitly passed ``None`` for an optional
-    field raises: the DAO's update writes only provided fields and
-    cannot express NULL, so a silent no-op would mask the caller's
-    intent (see the module docstring).  A provided display name is
-    validated like create's; the duplicate scan excludes only the child
-    being edited, so a case-only edit colliding with another child's
-    normalised name still warns.  Raises ValueError when the child does
-    not exist.
-
-    Atomicity: the existence check, the duplicate scan, the UPDATE and
-    the readback all run inside the connection-scoped lock shared with
-    the DAOs, so another edit cannot slip between this call's UPDATE
-    and its readback — the returned record is exactly the one this
-    edit produced, not a later writer's.
-    """
-    _validate_child_id(child_id)
-    async with _connection_lock(database):
-        dao = ChildrenDao(database)
-        existing = await dao.get(child_id)
-        if existing is None:
-            raise ValueError(f"child {child_id} does not exist")
-        updates: dict[str, object] = {}
-        if display_name is not _UNSET:
-            name = _validate_text(
-                display_name, "display_name", required=True
-            )
-            assert name is not None
-            await _warn_on_duplicate_name(
-                database, name, exclude_child_id=child_id
-            )
-            updates["display_name"] = name
-        if colour is not _UNSET:
-            value = _validate_text(colour, "colour")
-            if value is None:
-                raise ValueError(
-                    "clearing colour is not supported; pass a replacement "
-                    "value or omit the field"
-                )
-            updates["colour"] = value
-        if avatar_ref is not _UNSET:
-            value = _validate_text(avatar_ref, "avatar_ref")
-            if value is None:
-                raise ValueError(
-                    "clearing avatar_ref is not supported; pass a "
-                    "replacement value or omit the field"
-                )
-            updates["avatar_ref"] = value
-        if sort_order is not _UNSET:
-            updates["sort_order"] = _validate_sort_order(sort_order)
-        if updates:
-            await dao.update(child_id, **updates)
-        edited = await dao.get(child_id)
-    assert edited is not None
-    return edited
-
-
-async def set_child_active(
-    database: NestQuestDatabase, child_id: int, is_active: bool
-) -> ChildRecord:
-    """Deactivate or reactivate a child; returns the updated record.
-
-    Deactivation hides the child from the panel without deleting their
-    history (feature guardrail); this is the only removal path.
-    ``is_active`` must be a real bool: the DAO's ``int()`` would
-    otherwise silently coerce strings and numerics ("1", 0) into a
-    state the caller never asked for.  Raises ValueError when the
-    child does not exist.
-
-    Atomicity: existence check, UPDATE and readback run inside the
-    connection-scoped lock, so a concurrent opposite transition cannot
-    make this call report the other caller's value.
-    """
-    _validate_child_id(child_id)
-    async with _connection_lock(database):
-        dao = ChildrenDao(database)
-        if await dao.get(child_id) is None:
-            raise ValueError(f"child {child_id} does not exist")
-        if not isinstance(is_active, bool):
-            raise ValueError(
-                f"is_active must be a real bool, got {is_active!r}"
-            )
-        await dao.set_active(child_id, is_active)
-        updated = await dao.get(child_id)
-    assert updated is not None
-    return updated
-
-
-async def reorder_children(
-    database: NestQuestDatabase, ordered_ids: list[int]
-) -> None:
-    """Rewrite the children's panel display order in one transaction.
-
-    ``ordered_ids`` must be a complete permutation of the children
-    table — every child id exactly once.  A partial list (missing an
-    existing child), an unknown id, or a duplicate is rejected with
-    ValueError before any write, so the current order survives a
-    rejected call.  The DAO enforces this inside its own transaction
-    (check and write are     atomic under the connection lock); this
-    wrapper additionally rejects non-integer ids up front, since
-    ``bool`` and floats would silently compare against stored integer
-    ids at the SQL layer.
-    """
-    for child_id in ordered_ids:
-        _validate_child_id(child_id)
-    await ChildrenDao(database).reorder(ordered_ids)
-
-
-async def list_children(
-    database: NestQuestDatabase, *, active_only: bool = False
-) -> list[ChildRecord]:
-    """Return children in display order (sort_order, then id)."""
-    dao = ChildrenDao(database)
-    if active_only:
-        return await dao.list_active()
-    return await dao.list_all()

custom_components/nestquest/completion.py

@@ -1,200 +0,0 @@
-"""Business layer for the completion event log (Feature 08).
-
-Sits between the Feature 09 service gate and the typed
-:class:`~.dao_instances.CompletionEventsDao`: callers get actor-shape
-validation and the UTC occurred-at stamp here, and never talk to the
-DAO or SQL directly.  This module is the only Feature-08 caller of
-:meth:`~.dao_instances.CompletionEventsDao.append`.  Completing and
-un-completing an instance (no-op-if-already-done) arrive in later
-tasks.  Instance current state is derived from the latest event via
-:func:`instance_state` (``open`` / ``done``); there is no status
-column.
-
-Actor policy matches the schema CHECKs (D-008): ``actor_source`` is
-``'user'`` or ``'panel'`` only — never ``'service'``.  ``'user'``
-requires ``actor_user_id`` and forbids ``actor_child_id``; ``'panel'``
-requires ``actor_child_id`` (the tapped profile) and forbids
-``actor_user_id``.  Inverted shapes raise a field-naming ValueError
-before any write.
-
-``occurred_at`` is stamped UTC ISO-8601 at second precision with an
-explicit ``+00:00`` offset, matching the DAO's one accepted shape so
-lexicographic range queries stay exact.  ``was_on_time`` is required
-(True/False) for completed events; un-completions may pass None.  There
-is no permission check here (that is Feature 09).
-"""
-from __future__ import annotations
-
-import datetime
-
-from .dao_children import _connection_lock
-from .dao_instances import (
-    EVENT_COMPLETED,
-    EVENT_UNCOMPLETED,
-    CompletionEventRecord,
-    CompletionEventsDao,
-    QuestInstancesDao,
-)
-from .db import NestQuestDatabase
-
-#: Timestamp policy for completion_events.occurred_at: strict UTC
-#: ISO-8601 with explicit '+00:00' offset (module timestamp policy).
-_UTC_TIMESTAMP_FORMAT = "%Y-%m-%dT%H:%M:%S+00:00"
-
-
-def _now_stamp() -> str:
-    """Return the module's strict UTC second-precision stamp."""
-    return datetime.datetime.now(datetime.timezone.utc).strftime(
-        _UTC_TIMESTAMP_FORMAT
-    )
-
-
-def _stamp_occurred_at(now: datetime.datetime | None) -> str:
-    """Return a DAO-accepted UTC stamp for ``now``, or the current time."""
-    if now is None:
-        return _now_stamp()
-    if not isinstance(now, datetime.datetime):
-        raise ValueError(f"now must be a datetime, got {now!r}")
-    if now.tzinfo is None:
-        raise ValueError("now must be timezone-aware")
-    return now.astimezone(datetime.timezone.utc).strftime(
-        _UTC_TIMESTAMP_FORMAT
-    )
-
-
-def _validate_int_id(value: object, field: str) -> int:
-    """Reject non-int ids (bools included) before any lookup."""
-    if isinstance(value, bool) or not isinstance(value, int):
-        raise ValueError(f"{field} must be an integer, got {value!r}")
-    return value
-
-
-def _validate_event_type(value: object) -> str:
-    """Return a schema-legal event type, or raise naming the field."""
-    if value not in (EVENT_COMPLETED, EVENT_UNCOMPLETED):
-        raise ValueError(
-            f"event_type must be '{EVENT_COMPLETED}' or "
-            f"'{EVENT_UNCOMPLETED}', got {value!r}"
-        )
-    return value
-
-
-def _validate_actor(
-    actor_source: object,
-    actor_user_id: object,
-    actor_child_id: object,
-) -> tuple[str, str | None, int | None]:
-    """Return a schema-legal actor triple, or raise naming the field.
-
-    ``'user'`` requires a non-empty ``actor_user_id`` string and forbids
-    ``actor_child_id``.  ``'panel'`` requires an integer
-    ``actor_child_id`` and forbids ``actor_user_id``.  Any other
-    ``actor_source`` (including ``'service'``) is rejected.
-    """
-    if actor_source not in ("user", "panel"):
-        raise ValueError(
-            f"actor_source must be 'user' or 'panel', got {actor_source!r}"
-        )
-    if actor_source == "user":
-        if not isinstance(actor_user_id, str) or not actor_user_id.strip():
-            raise ValueError("actor_source 'user' requires actor_user_id")
-        if actor_child_id is not None:
-            raise ValueError(
-                "actor_source 'user' must not carry actor_child_id"
-            )
-        return "user", actor_user_id.strip(), None
-    if actor_user_id is not None:
-        raise ValueError("actor_source 'panel' must not carry actor_user_id")
-    if actor_child_id is None:
-        raise ValueError(
-            "actor_source 'panel' requires actor_child_id"
-        )
-    return (
-        "panel",
-        None,
-        _validate_int_id(actor_child_id, "actor_child_id"),
-    )
-
-
-def _validate_was_on_time(
-    event_type: str, was_on_time: object
-) -> bool | None:
-    """Return a real bool or None; completed events require True/False."""
-    if was_on_time is not None and type(was_on_time) is not bool:
-        raise ValueError(
-            f"was_on_time must be True, False or None, got {was_on_time!r}"
-        )
-    if event_type == EVENT_COMPLETED and was_on_time is None:
-        raise ValueError(
-            "a completed event requires was_on_time (True/False)"
-        )
-    return was_on_time
-
-
-async def append_event(
-    database: NestQuestDatabase,
-    instance_id: int,
-    child_id: int,
-    event_type: str,
-    *,
-    actor_source: str,
-    actor_user_id: str | None = None,
-    actor_child_id: int | None = None,
-    was_on_time: bool | None = None,
-    now: datetime.datetime | None = None,
-) -> CompletionEventRecord:
-    """Append one completion or un-completion event and return the row.
-
-    Validates actor shapes and the completed-event on-time requirement
-    before calling :meth:`CompletionEventsDao.append`.  ``occurred_at``
-    is stamped here (UTC ``+00:00``); pass ``now`` to pin the clock.
-    """
-    instance_id = _validate_int_id(instance_id, "instance_id")
-    child_id = _validate_int_id(child_id, "child_id")
-    event_type = _validate_event_type(event_type)
-    actor_source, actor_user_id, actor_child_id = _validate_actor(
-        actor_source, actor_user_id, actor_child_id
-    )
-    was_on_time = _validate_was_on_time(event_type, was_on_time)
-    occurred_at = _stamp_occurred_at(now)
-    return await CompletionEventsDao(database).append(
-        instance_id,
-        child_id,
-        event_type,
-        actor_source,
-        occurred_at,
-        was_on_time,
-        actor_user_id=actor_user_id,
-        actor_child_id=actor_child_id,
-    )
-
-
-async def instance_state(
-    database: NestQuestDatabase,
-    instance_id: int,
-) -> str:
-    """Return ``open`` or ``done`` from the instance's latest event.
-
-    No events, or a latest event of uncompleted, is ``open``.  A latest
-    event of completed is ``done``.  Unknown ``instance_id`` raises
-    ValueError naming the field.  Existence and the latest event are
-    read inside the connection lock so the answer is one snapshot.
-    """
-    instance_id = _validate_int_id(instance_id, "instance_id")
-    async with _connection_lock(database):
-        instance = await QuestInstancesDao(database).get_by_id(instance_id)
-        if instance is None:
-            raise ValueError(
-                f"instance_id: quest instance {instance_id} does not exist"
-            )
-        latest = await CompletionEventsDao(database).get_latest_for_instance(
-            instance_id
-        )
-    if latest is None or latest.event_type == EVENT_UNCOMPLETED:
-        return "open"
-    if latest.event_type == EVENT_COMPLETED:
-        return "done"
-    raise ValueError(
-        f"event_type must be '{EVENT_COMPLETED}' or "
-        f"'{EVENT_UNCOMPLETED}', got {latest.event_type!r}"
-    )

custom_components/nestquest/config_flow.py

@@ -7,7 +7,7 @@ from homeassistant import config_entries
 from homeassistant.core import callback
 from homeassistant.data_entry_flow import FlowResult
 
-from .const import CONF_ADMIN_USER_IDS, DOMAIN
+from .const import DOMAIN
 
 
 class NestQuestConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
@@ -28,14 +28,7 @@ class NestQuestConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
     async def async_step_user(
         self, user_input: dict[str, Any] | None = None
     ) -> FlowResult:
-        """Handle the user step of the config flow.
-
-        The HA user completing the flow is persisted into the entry
-        data as the initial admin allowlist copy: real HA does not
-        guarantee the flow context survives to setup, and entry data is
-        the persisted record first setup seeds from — the owner is
-        never locked out.
-        """
+        """Handle the user step of the config flow."""
         await self.async_set_unique_id(DOMAIN, raise_on_progress=False)
         if self._async_in_progress() or self._async_current_entries():
             return self.async_abort(reason="single_instance_allowed")
@@ -43,12 +36,4 @@ class NestQuestConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
         if user_input is None:
             return self.async_show_form(step_id="user")
 
-        data = dict(user_input)
-        flow_user_id = (
-            self.context.get("user_id")
-            if isinstance(self.context, dict)
-            else None
-        )
-        if flow_user_id:
-            data[CONF_ADMIN_USER_IDS] = [flow_user_id]
-        return self.async_create_entry(title="NestQuest", data=data)
+        return self.async_create_entry(title="NestQuest", data=user_input)

custom_components/nestquest/const.py

@@ -9,9 +9,6 @@ LOGGER = logging.getLogger(LOGGER_NAME)
 
 PLATFORMS: list[str] = []
 
-#: Service name for the on-demand regeneration service (``nestquest.regenerate``).
-SERVICE_REGENERATE = "regenerate"
-
 SQLITE_DB_FILENAME = "nestquest.db"
 
 # Configuration keys and default values
@@ -23,34 +20,3 @@ DEFAULT_DAY_ROLLOVER_TIME = "00:00"
 
 CONF_PANEL_IDLE_TIMEOUT = "panel_idle_timeout"
 DEFAULT_PANEL_IDLE_TIMEOUT = 300
-
-# Admin allowlist (Feature 03): HA user IDs permitted to call admin-only
-# services.  Stored as IDs, never usernames (feature guardrail).  The
-# database allowlist is authoritative; the config entry carries the same
-# list as a disaster-recovery copy so a lost database can be re-seeded.
-CONF_ADMIN_USER_IDS = "admin_user_ids"
-
-# Quest windows (D-008): a definition may declare several day windows;
-# each produces its own instance per day and groups the panel's Quest
-# Log into three columns.  The clock ranges are stored here so they stay
-# configurable later.  Boundaries: a window's end equals the next
-# window's start; classification (Feature 07 materialisation) treats a
-# due time exactly on the boundary as belonging to the LATER window, so
-# 12:00 is afternoon (not morning) and 17:00 is evening (not
-# afternoon).  Times after 21:00 belong to no window.
-WINDOW_MORNING = "morning"
-WINDOW_AFTERNOON = "afternoon"
-WINDOW_EVENING = "evening"
-
-QUEST_WINDOWS: tuple[str, ...] = (
-    WINDOW_MORNING,
-    WINDOW_AFTERNOON,
-    WINDOW_EVENING,
-)
-
-#: Inclusive "HH:MM" bounds per window, in 24-hour local time.
-WINDOW_CLOCK_RANGES: dict[str, tuple[str, str]] = {
-    WINDOW_MORNING: ("00:00", "11:59"),
-    WINDOW_AFTERNOON: ("12:00", "17:00"),
-    WINDOW_EVENING: ("17:00", "21:00"),
-}

custom_components/nestquest/dao_children.py

@@ -1,319 +0,0 @@
-"""Typed DAO layer for the children and admin_users tables.
-
-All SQL for ``children`` and ``admin_users`` lives in this module per
-the feature guardrail: callers get typed dataclasses back and never see
-raw rows or SQL.  Every method is async and runs through
-:class:`~.db.NestQuestDatabase`, so each statement executes on the HA
-executor and the event loop never blocks.
-
-Error contract: violations surface as the underlying
-:class:`sqlite3.IntegrityError` (duplicate, foreign-key, or CHECK
-failure) from the execute call; the DAO adds no wrapping exception
-type.  A get that matches nothing returns ``None``; a mutation that
-matches nothing is reported by :class:`~.db.ExecutionResult.rowcount`,
-which each method returns where the caller may need it (reorder, and
-the admin remove/set paths).
-"""
-from __future__ import annotations
-
-import asyncio
-from dataclasses import dataclass
-
-from .db import NestQuestDatabase
-
-
-@dataclass(frozen=True)
-class ChildRecord:
-    """One row of ``children``."""
-
-    id: int
-    display_name: str
-    colour: str | None
-    avatar_ref: str | None
-    sort_order: int
-    is_active: bool
-    created_at: str
-
-
-@dataclass(frozen=True)
-class AdminUserRecord:
-    """One row of ``admin_users``."""
-
-    ha_user_id: str
-    added_at: str
-
-
-def _child_from_row(row: tuple) -> ChildRecord:
-    """Build a :class:`ChildRecord` from a SELECT row."""
-    return ChildRecord(
-        id=row[0],
-        display_name=row[1],
-        colour=row[2],
-        avatar_ref=row[3],
-        sort_order=row[4],
-        is_active=bool(row[5]),
-        created_at=row[6],
-    )
-
-
-_CHILD_COLUMNS = (
-    "id, display_name, colour, avatar_ref, sort_order, is_active, created_at"
-)
-
-
-#: One asyncio.Lock per (connection wrapper, running loop), shared by
-#: every ChildrenDao instance over the same database: the wrapper
-#: rejects a second concurrent transaction with RuntimeError, so ALL
-#: transactional DAO operations on one connection must queue here, not
-#: per-instance.  Keyed like the migration runner's lock; entries are
-#: never evicted (a config entry holds one wrapper per process).
-_CONNECTION_LOCKS: dict[tuple[int, int], asyncio.Lock] = {}
-
-
-def _connection_lock(database) -> asyncio.Lock:
-    """Return the shared transaction-serializing lock for ``database``."""
-    loop = asyncio.get_running_loop()
-    key = (id(database), id(loop))
-    lock = _CONNECTION_LOCKS.get(key)
-    if lock is None:
-        lock = asyncio.Lock()
-        _CONNECTION_LOCKS[key] = lock
-    return lock
-
-
-class ChildrenDao:
-    """Typed async data access for the ``children`` table.
-
-    Deletion is deliberately absent: children are deactivated, never
-    deleted, because completion history references them (feature
-    guardrail).
-    """
-
-    def __init__(self, database) -> None:
-        self._database = database
-
-    async def create(
-        self,
-        display_name: str,
-        created_at: str,
-        *,
-        colour: str | None = None,
-        avatar_ref: str | None = None,
-        sort_order: int = 0,
-        is_active: bool = True,
-    ) -> ChildRecord:
-        """Insert one child and return the record as stored."""
-        result = await self._database.execute(
-            "INSERT INTO children (display_name, colour, avatar_ref, "
-            "sort_order, is_active, created_at) VALUES (?, ?, ?, ?, ?, ?)",
-            (
-                display_name,
-                colour,
-                avatar_ref,
-                sort_order,
-                int(is_active),
-                created_at,
-            ),
-        )
-        child = await self.get(result.lastrowid)
-        assert child is not None
-        return child
-
-    async def get(self, child_id: int) -> ChildRecord | None:
-        """Return the child with ``child_id``, or None."""
-        row = await self._database.fetch_one(
-            f"SELECT {_CHILD_COLUMNS} FROM children WHERE id = ?",
-            (child_id,),
-        )
-        return _child_from_row(row) if row is not None else None
-
-    async def list_active(self) -> list[ChildRecord]:
-        """Return active children ordered by sort_order, then id."""
-        rows = await self._database.fetch_all(
-            f"SELECT {_CHILD_COLUMNS} FROM children WHERE is_active = 1 "
-            "ORDER BY sort_order, id"
-        )
-        return [_child_from_row(row) for row in rows]
-
-    async def list_all(self) -> list[ChildRecord]:
-        """Return all children ordered by sort_order, then id."""
-        rows = await self._database.fetch_all(
-            f"SELECT {_CHILD_COLUMNS} FROM children "
-            "ORDER BY sort_order, id"
-        )
-        return [record for record in map(_child_from_row, rows)]
-
-    async def update(
-        self,
-        child_id: int,
-        *,
-        display_name: str | None = None,
-        colour: str | None = None,
-        avatar_ref: str | None = None,
-        sort_order: int | None = None,
-    ) -> int:
-        """Update the given fields; returns rows updated (0 if absent).
-
-        Only non-None arguments are written, so a caller cannot
-        accidentally blank a column by omitting it.
-        """
-        assignments: list[str] = []
-        parameters: list[object] = []
-        if display_name is not None:
-            assignments.append("display_name = ?")
-            parameters.append(display_name)
-        if colour is not None:
-            assignments.append("colour = ?")
-            parameters.append(colour)
-        if avatar_ref is not None:
-            assignments.append("avatar_ref = ?")
-            parameters.append(avatar_ref)
-        if sort_order is not None:
-            assignments.append("sort_order = ?")
-            parameters.append(sort_order)
-        if not assignments:
-            return 0
-        parameters.append(child_id)
-        result = await self._database.execute(
-            f"UPDATE children SET {', '.join(assignments)} WHERE id = ?",
-            tuple(parameters),
-        )
-        return result.rowcount
-
-    async def set_active(self, child_id: int, is_active: bool) -> int:
-        """Set the child's active flag; returns rows updated (0 if absent)."""
-        result = await self._database.execute(
-            "UPDATE children SET is_active = ? WHERE id = ?",
-            (int(is_active), child_id),
-        )
-        return result.rowcount
-
-    async def reorder(self, ordered_ids: list[int]) -> None:
-        """Persist a new sort order: ``ordered_ids[i]`` gets sort_order i.
-
-        The list must be a COMPLETE permutation of the children table:
-        every existing child id appears exactly once.  Partial lists
-        (missing an existing child) and unknown ids (naming a child
-        that does not exist) are rejected with ValueError BEFORE any
-        write, leaving the current order untouched — a silent partial
-        reorder would leave unlisted children with stale positions and
-        hide a caller bug.  Duplicate ids are rejected up front: they
-        cannot all hold distinct positions, and silently assigning the
-        last occurrence's index would hide a caller bug.
-
-        Runs inside one transaction; positions are staged at offset
-        -len (all negative, so any permutation of the same ids never
-        collides mid-reorder under the wrapper's single-connection
-        serialization), then finalized 0..n-1.
-
-        Concurrent reorder() calls on one connection are serialized by
-        a connection-scoped asyncio lock (shared across every ChildrenDao
-        over the same wrapper, however many instances): the wrapper's
-        transaction() rejects a second concurrent transaction with
-        RuntimeError, so racing callers would crash instead of
-        queueing.  The lock makes the second call wait, then run
-        against the first call's final state — which also keeps the
-        completeness check honest: the re-read of the table happens
-        inside the same lock and transaction as the writes.
-        """
-        if len(set(ordered_ids)) != len(ordered_ids):
-            raise ValueError(
-                "reorder() received duplicate child ids; every id must "
-                "appear at most once"
-            )
-        async with _connection_lock(self._database):
-            async with self._database.transaction():
-                rows = await self._database.fetch_all(
-                    f"SELECT id FROM children"
-                )
-                existing = {row[0] for row in rows}
-                listed = set(ordered_ids)
-                missing = sorted(existing - listed)
-                unknown = sorted(listed - existing)
-                if missing or unknown:
-                    details = []
-                    if missing:
-                        details.append(
-                            f"missing child ids {missing} (a partial "
-                            "reorder would leave them with stale "
-                            "positions)"
-                        )
-                    if unknown:
-                        details.append(
-                            f"unknown child ids {unknown}"
-                        )
-                    raise ValueError(
-                        "reorder() must list every child exactly once; "
-                        + "; ".join(details)
-                    )
-                offset = len(ordered_ids)
-                await self._database.execute_many(
-                    "UPDATE children SET sort_order = ? WHERE id = ?",
-                    [
-                        (-(offset + index), child_id)
-                        for index, child_id in enumerate(ordered_ids)
-                    ],
-                )
-                await self._database.execute_many(
-                    "UPDATE children SET sort_order = ? WHERE id = ?",
-                    [
-                        (index, child_id)
-                        for index, child_id in enumerate(ordered_ids)
-                    ],
-                )
-
-
-class AdminUsersDao:
-    """Typed async access to the ``admin_users`` allowlist.
-
-    The allowlist stores HA user IDs, never usernames (feature
-    guardrail); an empty allowlist means no admin, enforced by callers
-    resolving through :meth:`exists`.
-    """
-
-    def __init__(self, database) -> None:
-        self._database = database
-
-    async def add(self, ha_user_id: str, added_at: str) -> bool:
-        """Add a user to the allowlist; True if inserted, False if present.
-
-        Idempotent under concurrency: a single INSERT ... ON CONFLICT DO
-        NOTHING decides and inserts in one statement (the wrapper
-        serializes statements, not check-then-insert sequences, so a
-        SELECT/INSERT pair would let two concurrent adds both see no
-        row and the second one raise IntegrityError).  rowcount reports
-        whether the insert actually happened.
-        """
-        result = await self._database.execute(
-            "INSERT INTO admin_users (ha_user_id, added_at) VALUES (?, ?) "
-            "ON CONFLICT (ha_user_id) DO NOTHING",
-            (ha_user_id, added_at),
-        )
-        return result.rowcount > 0
-
-    async def remove(self, ha_user_id: str) -> bool:
-        """Remove a user from the allowlist; True if a row was removed."""
-        result = await self._database.execute(
-            "DELETE FROM admin_users WHERE ha_user_id = ?",
-            (ha_user_id,),
-        )
-        return result.rowcount > 0
-
-    async def list(self) -> list[AdminUserRecord]:
-        """Return every allowlisted user, oldest first."""
-        rows = await self._database.fetch_all(
-            "SELECT ha_user_id, added_at FROM admin_users "
-            "ORDER BY added_at, ha_user_id"
-        )
-        return [
-            AdminUserRecord(ha_user_id=row[0], added_at=row[1])
-            for row in rows
-        ]
-
-    async def exists(self, ha_user_id: str) -> bool:
-        """Return True if ``ha_user_id`` is allowlisted."""
-        row = await self._database.fetch_one(
-            "SELECT 1 FROM admin_users WHERE ha_user_id = ?",
-            (ha_user_id,),
-        )
-        return row is not None

custom_components/nestquest/dao_instances.py

@@ -1,795 +0,0 @@
-"""Typed DAO layer for quest_instances and the append-only completion_events.
-
-All SQL for these tables lives in this module per the feature
-guardrails: callers get typed dataclasses back and never see raw rows
-or SQL.  Every method is async and runs through
-:class:`~.db.NestQuestDatabase`, so each statement executes on the HA
-executor and the event loop never blocks.
-
-Append-only policy (Feature 08, D-005): ``completion_events`` is
-strictly append-only.  This module is where that property is enforced
-mechanically — the completion-events DAO below exposes NO update or
-delete method at all; completions append, un-completions append a
-separate reversal event, and instance state derives from the latest
-event.  A package-wide guard test (bottom of the test module) keeps
-mutation SQL for this table out of every other module.
-
-Upsert semantics: ``QuestInstancesDao.upsert`` is idempotent on
-(definition_id, child_id, due_date, window) — re-running
-materialization for a tuple whose instance already exists refreshes
-only the generation-time snapshot columns and never duplicates a row.
-The schema's UNIQUE(definition_id, child_id, due_date, window) is the
-last line of defense.  The upsert refuses a child that is not an
-assignee of the definition and a window outside ``const.QUEST_WINDOWS``
-(D-008 multi-assignee, multi-window model).
-
-``delete_future_uncompleted`` implements the Feature 06/07 rule that
-reassignment and schedule edits regenerate future instances: it
-removes only instances at or after the cutoff that have NO completion
-event, inside one transaction, so an instance completed mid-call can
-never be deleted.  Instances in the past are never touched (Feature 07
-guardrail: never delete history), and no method here deletes a single
-instance that has a completion event.
-"""
-from __future__ import annotations
-
-import datetime
-from dataclasses import dataclass
-
-from .dao_children import _connection_lock
-from .dao_rules import _validate_date, _validate_window
-from .db import NestQuestDatabase
-
-#: Timestamp policy for completion_events.occurred_at: strict UTC
-#: ISO-8601 with explicit '+00:00' offset (module timestamp policy).
-#: One accepted shape bounds lexicographic range queries correctly, so
-#: the occurred-at scope does not guess at timestamp spellings.
-_UTC_TIMESTAMP_FORMAT = "%Y-%m-%dT%H:%M:%S+00:00"
-
-
-def _today() -> datetime.date:
-    """Return the current local calendar date (the single date source).
-
-    Every "today" read in this module goes through this one function so
-    the delete clamp and the materialize walk's no-past guard read the
-    same clock, and a caller or test can pin/roll that clock
-    deterministically (e.g. a queued-across-midnight regression).  Pure
-    clock read — no business rule lives here.
-    """
-    return datetime.date.today()
-
-
-def _resolve_today(today: datetime.date | None) -> datetime.date:
-    """Return the caller-resolved "today", or the host date when absent.
-
-    The no-past guard and the delete cutoffs must compare due dates
-    against the SAME calendar date the materialization horizon was built
-    from.  Home Assistant's configured time zone can lag the host clock
-    around midnight, so when the caller has already resolved the local
-    date (``today``) that anchor is authoritative; ``None`` falls back to
-    the host clock (:func:`_today`), which is exactly the previous
-    behavior for callers with no HA-local date.
-    """
-    return _today() if today is None else today
-
-
-def _reject_past(due_date: str, today_iso: str) -> None:
-    """Raise unless ``due_date`` is on or after ``today_iso``.
-
-    The single no-past rule shared by :meth:`QuestInstancesDao.upsert`
-    and :meth:`QuestInstancesDao.upsert_if_valid`: instances are never
-    generated in the past, measured against the resolved "today".
-    """
-    if due_date < today_iso:
-        raise ValueError(
-            f"instances are never generated in the past: due_date "
-            f"{due_date!r} is before today {today_iso!r}"
-        )
-
-
-def _validate_utc_timestamp(value: str, field: str) -> None:
-    """Raise ValueError unless ``value`` is a strict UTC ISO-8601 stamp.
-
-    Same strictness policy as _validate_date: parse with the exact
-    format, then round-trip the parsed value against the input so
-    non-padded or re-ordered shapes are rejected.  The round-trip
-    strips the UTC offset (isoformat() omits it when the offset is
-    zero), so the suffix is appended before comparing.
-    """
-    try:
-        parsed = datetime.datetime.strptime(
-            value, _UTC_TIMESTAMP_FORMAT
-        )
-    except (TypeError, ValueError):
-        raise ValueError(
-            f"{field} must be a UTC ISO-8601 timestamp "
-            f"(YYYY-MM-DDTHH:MM:SS+00:00), got {value!r}"
-        ) from None
-    if parsed.isoformat() + "+00:00" != value:
-        raise ValueError(
-            f"{field} must be a strict UTC timestamp "
-            f"(YYYY-MM-DDTHH:MM:SS+00:00), got {value!r}"
-        )
-
-
-def _next_day_start(date_str: str) -> str:
-    """Return the UTC timestamp one second past ``date_str``'s last second.
-
-    Gives range queries an exact half-open upper bound without
-    fractional-second guessing.
-    """
-    day = datetime.date.fromisoformat(date_str)
-    next_day = day + datetime.timedelta(days=1)
-    return f"{next_day.isoformat()}T00:00:00+00:00"
-
-
-@dataclass(frozen=True)
-class QuestInstanceRecord:
-    """One row of ``quest_instances``."""
-
-    id: int
-    definition_id: int
-    child_id: int
-    window: str
-    due_date: str
-    due_time: str | None
-    generated_at: str
-
-
-@dataclass(frozen=True)
-class CompletionEventRecord:
-    """One row of ``completion_events`` (append-only table)."""
-
-    id: int
-    instance_id: int
-    child_id: int
-    event_type: str
-    actor_source: str
-    actor_user_id: str | None
-    actor_child_id: int | None
-    occurred_at: str
-    was_on_time: bool | None
-
-
-_INSTANCE_COLUMNS = (
-    "id, definition_id, child_id, window, due_date, due_time, generated_at"
-)
-_EVENT_COLUMNS = (
-    "id, instance_id, child_id, event_type, actor_source, actor_user_id, "
-    "actor_child_id, occurred_at, was_on_time"
-)
-
-#: The only event types the append path accepts; the schema CHECK is
-#: the backstop, this is the DAO's typed front door.
-EVENT_COMPLETED = "completed"
-EVENT_UNCOMPLETED = "uncompleted"
-
-
-def _instance_from_row(row: tuple) -> QuestInstanceRecord:
-    return QuestInstanceRecord(
-        id=row[0],
-        definition_id=row[1],
-        child_id=row[2],
-        window=row[3],
-        due_date=row[4],
-        due_time=row[5],
-        generated_at=row[6],
-    )
-
-
-def _event_from_row(row: tuple) -> CompletionEventRecord:
-    return CompletionEventRecord(
-        id=row[0],
-        instance_id=row[1],
-        child_id=row[2],
-        event_type=row[3],
-        actor_source=row[4],
-        actor_user_id=row[5],
-        actor_child_id=row[6],
-        occurred_at=row[7],
-        was_on_time=None if row[8] is None else bool(row[8]),
-    )
-
-
-class QuestInstancesDao:
-    """Typed async access to the ``quest_instances`` table."""
-
-    def __init__(self, database: NestQuestDatabase) -> None:
-        self._database = database
-
-    async def upsert(
-        self,
-        definition_id: int,
-        child_id: int,
-        due_date: str,
-        generated_at: str,
-        *,
-        window: str,
-        due_time: str | None = None,
-        today: datetime.date | None = None,
-    ) -> QuestInstanceRecord:
-        """Create the dated instance for the widened key idempotently.
-
-        The instance key is (definition_id, child_id, due_date, window)
-        (D-008): running materialization twice for the same tuple
-        yields ONE row — the ON CONFLICT path refreshes the
-        generation-time snapshot columns (due_time) and regenerates the
-        stamp, but can never create a duplicate.  The schema's
-        UNIQUE(definition_id, child_id, due_date, window) backs this
-        up, so the twice-daily case (two windows, one child, one date)
-        yields two rows and the shared case (three assignees, one
-        window) yields three.
-
-        Guardrails enforced here:
-
-        - ``due_date`` must be TODAY or later: instances are never
-          generated in the past (Feature 07).  The caller's
-          materialization horizon is future-dated by definition.
-          ``today`` optionally pins the resolved HA-local date the
-          guard compares against (falling back to the host clock when
-          omitted) so a household time zone behind the host around
-          midnight is not misread as "past".
-        - ``window`` must be one of ``const.QUEST_WINDOWS``.
-        - An existing instance WITH a completion event is IMMUTABLE:
-          the conflict path must not rewrite its snapshot columns
-          (Feature 07/08).  The upsert refuses with ValueError in that
-          case — silently no-oping would mask a materialization bug.
-        - The child must be an assignee of the definition (D-008
-          multi-assignee model).
-
-        The definition must exist (validated atomically under the
-        connection lock so a concurrent definition deactivation or
-        child deletion cannot slip between check and insert).
-        """
-        _validate_date(due_date, "due_date")
-        _validate_window(window)
-        # Fail fast on obviously-past dates BEFORE queuing on the
-        # connection lock (a nice early error); the AUTHORITATIVE
-        # check runs after the lock is acquired, because a caller can
-        # wait on the lock across midnight — a date that was "today"
-        # at call time may be "yesterday" by the time the INSERT runs.
-        # A caller-supplied ``today`` (HA-local) is used for BOTH
-        # checks and never re-read, since it is already the anchor the
-        # batch runs against.
-        today_date = _resolve_today(today)
-        _reject_past(due_date, today_date.isoformat())
-        async with _connection_lock(self._database):
-            async with self._database.transaction():
-                # Re-read "today" under the lock: this is the date the
-                # insert actually executes on, so the no-past rule
-                # holds across midnight rollovers.  A pinned HA-local
-                # anchor is exempt from the re-read (see above).
-                if today is None:
-                    today_date = _today()
-                _reject_past(due_date, today_date.isoformat())
-                definition = await self._database.fetch_one(
-                    "SELECT 1 FROM quest_definitions WHERE id = ?",
-                    (definition_id,),
-                )
-                if definition is None:
-                    raise ValueError(
-                        f"quest definition {definition_id} does not exist"
-                    )
-                assignee = await self._database.fetch_one(
-                    "SELECT 1 FROM quest_definition_assignees "
-                    "WHERE definition_id = ? AND child_id = ?",
-                    (definition_id, child_id),
-                )
-                if assignee is None:
-                    raise ValueError(
-                        f"quest definition {definition_id} is not "
-                        f"assigned to child {child_id}; instance must "
-                        "carry an assigned child"
-                    )
-                existing = await self._database.fetch_one(
-                    "SELECT 1 FROM completion_events "
-                    "WHERE instance_id = (SELECT id FROM quest_instances "
-                    "WHERE definition_id = ? AND child_id = ? "
-                    "AND due_date = ? AND window = ?)",
-                    (definition_id, child_id, due_date, window),
-                )
-                if existing is not None:
-                    raise ValueError(
-                        f"instance for (definition {definition_id}, "
-                        f"child {child_id}, due_date {due_date!r}, "
-                        f"window {window!r}) already has a completion "
-                        "event and is immutable; it cannot be regenerated"
-                    )
-                await self._database.execute(
-                    "INSERT INTO quest_instances (definition_id, child_id, "
-                    "window, due_date, due_time, generated_at) "
-                    "VALUES (?, ?, ?, ?, ?, ?) "
-                    "ON CONFLICT (definition_id, child_id, due_date, "
-                    "window) DO UPDATE SET "
-                    "due_time = excluded.due_time, "
-                    "generated_at = excluded.generated_at",
-                    (
-                        definition_id,
-                        child_id,
-                        window,
-                        due_date,
-                        due_time,
-                        generated_at,
-                    ),
-                )
-                instance = await self.get(
-                    definition_id, child_id, due_date, window
-                )
-        assert instance is not None
-        return instance
-
-    async def upsert_if_valid(
-        self,
-        definition_id: int,
-        child_id: int,
-        due_date: str,
-        generated_at: str,
-        *,
-        window: str,
-        due_time: str | None = None,
-        today: datetime.date | None = None,
-    ) -> QuestInstanceRecord | None:
-        """Insert one dated instance iff its tuple is still materializable.
-
-        This is the materialization walk's single write path.  Unlike the
-        generic :meth:`upsert`, which validates only existence and
-        assignment, this method re-validates EVERY materialization
-        precondition in the SAME connection-lock-held transaction as the
-        INSERT — closing the check-then-insert gap a concurrent config
-        write could otherwise slip through:
-
-        - the definition exists AND is active (a definition deactivated
-          after the input snapshot is skipped, never written);
-        - the child exists AND is active (a deactivated child is skipped);
-        - the (definition, child) assignment link still exists (a removed
-          assignment is skipped);
-        - the window is still declared on the definition (a removed window
-          is skipped);
-        - the window's live ``due_time`` still EQUALS the caller-supplied
-          ``due_time`` (NULL-safe: NULL == NULL counts as equal; a window
-          with no due time matches a snapshot with no due time).  A
-          window-time edit landed after the input snapshot makes the
-          caller's ``due_time`` stale, and writing it would overwrite the
-          newer due_time a concurrent regeneration already upserted — so
-          the tuple is skipped instead of written.
-
-        The due_time check closes the one check-then-insert gap this
-        method previously left open: it re-validated every OTHER
-        precondition but then wrote the snapshot's ``due_time``
-        unconditionally, so a stale materialization could clobber a
-        newer, concurrently-regenerated due_time.
-
-        Returns the stored instance, or ``None`` when a precondition
-        failed — the tuple no longer materializable, which the walk SKIPS
-        rather than raising, so the rest of the batch is unaffected.  The
-        no-past rule (instances are never generated in the past) is
-        preserved from :meth:`upsert` and still raises ValueError; ``today``
-        optionally pins the HA-local anchor it compares against.  An
-        instance that ALREADY has a completion event is also skipped
-        (returns ``None``) rather than raised: it is immutable, so the
-        walk leaves it untouched instead of failing the batch — the
-        generic :meth:`upsert` keeps its hard refusal for the
-        delete/regenerate path.
-        """
-        _validate_date(due_date, "due_date")
-        _validate_window(window)
-        # Fail fast on obviously-past dates before queuing on the lock;
-        # the authoritative check re-runs under the lock (see upsert).
-        today_date = _resolve_today(today)
-        _reject_past(due_date, today_date.isoformat())
-        async with _connection_lock(self._database):
-            async with self._database.transaction():
-                if today is None:
-                    today_date = _today()
-                _reject_past(due_date, today_date.isoformat())
-                still_valid = await self._database.fetch_one(
-                    "SELECT 1 FROM quest_definitions d "
-                    "JOIN quest_definition_assignees a "
-                    "ON a.definition_id = d.id "
-                    "JOIN children c ON c.id = a.child_id "
-                    "JOIN quest_definition_windows w "
-                    "ON w.definition_id = d.id "
-                    "WHERE d.id = ? AND a.child_id = ? AND w.window = ? "
-                    "AND d.is_active = 1 AND c.is_active = 1 "
-                    "AND w.due_time IS ? LIMIT 1",
-                    (definition_id, child_id, window, due_time),
-                )
-                if still_valid is None:
-                    # A config change invalidated the tuple since the
-                    # snapshot: skip it rather than abort the batch.
-                    return None
-                existing = await self._database.fetch_one(
-                    "SELECT 1 FROM completion_events "
-                    "WHERE instance_id = (SELECT id FROM quest_instances "
-                    "WHERE definition_id = ? AND child_id = ? "
-                    "AND due_date = ? AND window = ?)",
-                    (definition_id, child_id, due_date, window),
-                )
-                if existing is not None:
-                    # The instance is already completed and therefore
-                    # immutable: the walk SKIPS it (no-op) rather than
-                    # rewriting its snapshot columns or failing the
-                    # batch.  This is the materialization walk's skip,
-                    # distinct from the generic :meth:`upsert` refusal.
-                    return None
-                await self._database.execute(
-                    "INSERT INTO quest_instances (definition_id, child_id, "
-                    "window, due_date, due_time, generated_at) "
-                    "VALUES (?, ?, ?, ?, ?, ?) "
-                    "ON CONFLICT (definition_id, child_id, due_date, "
-                    "window) DO UPDATE SET "
-                    "due_time = excluded.due_time, "
-                    "generated_at = excluded.generated_at",
-                    (
-                        definition_id,
-                        child_id,
-                        window,
-                        due_date,
-                        due_time,
-                        generated_at,
-                    ),
-                )
-                instance = await self.get(
-                    definition_id, child_id, due_date, window
-                )
-        assert instance is not None
-        return instance
-
-    async def get(
-        self,
-        definition_id: int,
-        child_id: int,
-        due_date: str,
-        window: str,
-    ) -> QuestInstanceRecord | None:
-        """Return the instance for the widened key tuple, or None."""
-        row = await self._database.fetch_one(
-            f"SELECT {_INSTANCE_COLUMNS} FROM quest_instances "
-            "WHERE definition_id = ? AND child_id = ? AND due_date = ? "
-            "AND window = ?",
-            (definition_id, child_id, due_date, window),
-        )
-        return _instance_from_row(row) if row is not None else None
-
-    async def get_by_id(self, instance_id: int) -> QuestInstanceRecord | None:
-        """Return the instance with ``instance_id``, or None."""
-        row = await self._database.fetch_one(
-            f"SELECT {_INSTANCE_COLUMNS} FROM quest_instances WHERE id = ?",
-            (instance_id,),
-        )
-        return _instance_from_row(row) if row is not None else None
-
-    async def list_by_child_and_date(
-        self, child_id: int, due_date: str
-    ) -> list[QuestInstanceRecord]:
-        """Return the child's instances due exactly on ``due_date``."""
-        _validate_date(due_date, "due_date")
-        rows = await self._database.fetch_all(
-            f"SELECT {_INSTANCE_COLUMNS} FROM quest_instances "
-            "WHERE child_id = ? AND due_date = ? ORDER BY id",
-            (child_id, due_date),
-        )
-        return [_instance_from_row(row) for row in rows]
-
-    async def list_by_date_range(
-        self,
-        child_id: int,
-        range_start: str,
-        range_end: str,
-    ) -> list[QuestInstanceRecord]:
-        """Return the child's instances with due_date in the closed range."""
-        _validate_date(range_start, "range_start")
-        _validate_date(range_end, "range_end")
-        if range_end < range_start:
-            raise ValueError(
-                "range_end must be on or after range_start, got "
-                f"{range_end!r} < {range_start!r}"
-            )
-        rows = await self._database.fetch_all(
-            f"SELECT {_INSTANCE_COLUMNS} FROM quest_instances "
-            "WHERE child_id = ? AND due_date >= ? AND due_date <= ? "
-            "ORDER BY due_date, id",
-            (child_id, range_start, range_end),
-        )
-        return [_instance_from_row(row) for row in rows]
-
-    async def delete_future_uncompleted(
-        self, definition_id: int, cutoff_date: str, *, today: datetime.date | None = None
-    ) -> int:
-        """Delete the definition's open instances at/after cutoff.
-
-        Implements regeneration after a definition edit or reassignment
-        (Features 06/07): only instances at or after the cutoff with NO
-        completion event are removed, inside one transaction — an
-        instance that gains a completion event mid-flight cannot be
-        deleted.  The cutoff cannot be backdated below today: "future"
-        is measured against TODAY (materialization regenerates the
-        rolling horizon from now), so a caller cannot use this to
-        rewrite past open instances either — the day-rollover missed
-        sweep (Feature 11) handles past-due instances instead.  ``today``
-        optionally pins the HA-local anchor the clamp compares against
-        (falling back to the host clock when omitted).  Any instance with
-        a completion event is never touched, regardless of its date.
-        Returns the number deleted.
-        """
-        _validate_date(cutoff_date, "cutoff_date")
-        async with _connection_lock(self._database):
-            async with self._database.transaction():
-                # "today" is read under the lock: the DELETE actually
-                # executes on this date, so a caller queued across
-                # midnight cannot delete instances that became past
-                # while it waited (backdating is clamped to the
-                # execution date, not the call date).
-                today_date = _resolve_today(today)
-                effective_cutoff = max(cutoff_date, today_date.isoformat())
-                result = await self._database.execute(
-                    "DELETE FROM quest_instances WHERE definition_id = ? "
-                    "AND due_date >= ? AND NOT EXISTS ("
-                    "  SELECT 1 FROM completion_events "
-                    "  WHERE instance_id = quest_instances.id"
-                    ")",
-                    (definition_id, effective_cutoff),
-                )
-        return result.rowcount
-
-    async def delete_future_uncompleted_for_child(
-        self, child_id: int, cutoff_date: str, *, today: datetime.date | None = None
-    ) -> tuple[int, str]:
-        """Delete the child's open instances at/after cutoff, across every
-        definition, returning ``(deleted, effective_cutoff)``.
-
-        Child-scoped counterpart to :meth:`delete_future_uncompleted`,
-        used when a child's presence changes (Feature 09): only instances
-        at or after the cutoff with NO completion event are removed, inside
-        one transaction — an instance that gains a completion event
-        mid-flight cannot be deleted.  The cutoff cannot be backdated below
-        today, for the same reason as the definition-scoped method (see its
-        docstring).  ``today`` optionally pins the HA-local anchor the clamp
-        compares against (falling back to the host clock when omitted).
-        Any instance with a completion event is never touched, regardless
-        of its date.
-
-        Returns the number deleted and the effective cutoff that was
-        actually applied (``max(cutoff_date, today)``, read under the
-        lock).  The caller (:func:`~.materialize.regenerate_for_child`)
-        passes that effective cutoff back as its re-materialization anchor,
-        so the delete and the rebuild share ONE execution-day even when the
-        call is queued across midnight — instead of the caller re-reading a
-        stale "today" and materializing a window the delete already
-        superseded.
-        """
-        _validate_date(cutoff_date, "cutoff_date")
-        async with _connection_lock(self._database):
-            async with self._database.transaction():
-                # "today" is read under the lock, matching the
-                # definition-scoped method: the DELETE executes on this
-                # date, so a caller queued across midnight cannot delete
-                # instances that became past while it waited.
-                today_date = _resolve_today(today)
-                effective_cutoff = max(cutoff_date, today_date.isoformat())
-                result = await self._database.execute(
-                    "DELETE FROM quest_instances WHERE child_id = ? "
-                    "AND due_date >= ? AND NOT EXISTS ("
-                    "  SELECT 1 FROM completion_events "
-                    "  WHERE instance_id = quest_instances.id"
-                    ")",
-                    (child_id, effective_cutoff),
-                )
-        return result.rowcount, effective_cutoff
-
-
-class CompletionEventsDao:
-    """Typed append-only access to the ``completion_events`` table.
-
-    APPEND-ONLY BY CONSTRUCTION: this class exposes ``append`` and the
-    three read methods below, and NOTHING else.  There is no update,
-    no delete, no upsert — completions and un-completions both arrive
-    through :meth:`append` as new rows, and history is immutable
-    (Feature 08 done-condition: no code path updates or deletes an
-    event).  The package-wide leak-guard test additionally fails if
-    mutation SQL for this table ever appears in any module.
-    """
-
-    def __init__(self, database: NestQuestDatabase) -> None:
-        self._database = database
-
-    async def append(
-        self,
-        instance_id: int,
-        child_id: int,
-        event_type: str,
-        actor_source: str,
-        occurred_at: str,
-        was_on_time: bool | None,
-        *,
-        actor_user_id: str | None = None,
-        actor_child_id: int | None = None,
-    ) -> CompletionEventRecord:
-        """Append one completion or un-completion event.
-
-        ``actor_source`` is 'user' (an admin action: ``actor_user_id``
-        set, ``actor_child_id`` NULL) or 'panel' (a panel tap: no user
-        id, and ``actor_child_id`` carrying the tapped child profile,
-        D-008); the actor-pair CHECKs enforce this shape at the schema
-        level.  ``occurred_at`` must be the module's one strict UTC
-        shape (YYYY-MM-DDTHH:MM:SS+00:00) so lexicographic range
-        queries stay exact.  ``was_on_time`` is required (True/False)
-        for completions; for un-completions it may be None or the
-        reversed completion's flag (Feature 08 still deciding).  The
-        instance, child and — for panel events — the tapped child must
-        exist — validated atomically under the connection lock.
-        """
-        if event_type not in (EVENT_COMPLETED, EVENT_UNCOMPLETED):
-            raise ValueError(
-                f"event_type must be '{EVENT_COMPLETED}' or "
-                f"'{EVENT_UNCOMPLETED}', got {event_type!r}"
-            )
-        if actor_source not in ("user", "panel"):
-            raise ValueError(
-                f"actor_source must be 'user' or 'panel', got "
-                f"{actor_source!r}"
-            )
-        if actor_source == "user" and not actor_user_id:
-            raise ValueError(
-                "actor_source 'user' requires actor_user_id"
-            )
-        if actor_source == "panel" and actor_user_id is not None:
-            raise ValueError(
-                "actor_source 'panel' must not carry actor_user_id"
-            )
-        if actor_source == "panel" and actor_child_id is None:
-            raise ValueError(
-                "actor_source 'panel' requires actor_child_id "
-                "(the tapped child profile)"
-            )
-        if actor_source == "user" and actor_child_id is not None:
-            raise ValueError(
-                "actor_source 'user' must not carry actor_child_id"
-            )
-        if was_on_time is not None and type(was_on_time) is not bool:
-            raise ValueError(
-                f"was_on_time must be True, False or None, got "
-                f"{was_on_time!r}"
-            )
-        if event_type == EVENT_COMPLETED and was_on_time is None:
-            raise ValueError(
-                "a completed event requires was_on_time (True/False)"
-            )
-        _validate_utc_timestamp(occurred_at, "occurred_at")
-        async with _connection_lock(self._database):
-            async with self._database.transaction():
-                instance = await self._database.fetch_one(
-                    "SELECT child_id FROM quest_instances WHERE id = ?",
-                    (instance_id,),
-                )
-                if instance is None:
-                    raise ValueError(
-                        f"quest instance {instance_id} does not exist"
-                    )
-                if instance[0] != child_id:
-                    raise ValueError(
-                        f"quest instance {instance_id} belongs to child "
-                        f"{instance[0]}, not {child_id}"
-                    )
-                child = await self._database.fetch_one(
-                    "SELECT 1 FROM children WHERE id = ?", (child_id,)
-                )
-                if child is None:
-                    raise ValueError(f"child {child_id} does not exist")
-                if actor_child_id is not None:
-                    tapped = await self._database.fetch_one(
-                        "SELECT 1 FROM children WHERE id = ?",
-                        (actor_child_id,),
-                    )
-                    if tapped is None:
-                        raise ValueError(
-                            f"actor_child_id {actor_child_id} does not "
-                            "reference an existing child"
-                        )
-                result = await self._database.execute(
-                    "INSERT INTO completion_events (instance_id, child_id, "
-                    "event_type, actor_source, actor_user_id, "
-                    "actor_child_id, occurred_at, was_on_time) "
-                    "VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
-                    (
-                        instance_id,
-                        child_id,
-                        event_type,
-                        actor_source,
-                        actor_user_id,
-                        actor_child_id,
-                        occurred_at,
-                        None if was_on_time is None else int(was_on_time),
-                    ),
-                )
-                event = await self._database.fetch_one(
-                    f"SELECT {_EVENT_COLUMNS} FROM completion_events "
-                    "WHERE id = ?",
-                    (result.lastrowid,),
-                )
-        assert event is not None
-        return _event_from_row(event)
-
-    async def list_by_instance(
-        self, instance_id: int
-    ) -> list[CompletionEventRecord]:
-        """Return every event for the instance, in append order."""
-        rows = await self._database.fetch_all(
-            f"SELECT {_EVENT_COLUMNS} FROM completion_events "
-            "WHERE instance_id = ? ORDER BY id",
-            (instance_id,),
-        )
-        return [_event_from_row(row) for row in rows]
-
-    async def list_by_child_and_date_range(
-        self,
-        child_id: int,
-        range_start: str,
-        range_end: str,
-        *,
-        due_date_scope: bool = True,
-    ) -> list[CompletionEventRecord]:
-        """Return the child's events for instances due in the closed range.
-
-        Scopes by the INSTANCE's due date (the day the task was owed),
-        not the event's wall-clock timestamp: history reporting asks
-        "what happened to the tasks due that day" (Feature 13).  Set
-        ``due_date_scope=False`` to filter by ``occurred_at`` date
-        instead.  Ordered by instance, then event id.
-        """
-        _validate_date(range_start, "range_start")
-        _validate_date(range_end, "range_end")
-        if range_end < range_start:
-            raise ValueError(
-                "range_end must be on or after range_start, got "
-                f"{range_end!r} < {range_start!r}"
-            )
-        if due_date_scope:
-            predicate = (
-                "SELECT id FROM quest_instances WHERE child_id = ? "
-                "AND due_date >= ? AND due_date <= ?"
-            )
-            parameters: list[object] = [child_id, range_start, range_end]
-        else:
-            # Occurred-at scope: occurred_at is validated to the one
-            # accepted UTC shape at append time, so half-open day
-            # bounds in that same shape are exact (no spelling drift).
-            occurred_start = f"{range_start}T00:00:00+00:00"
-            occurred_end = f"{range_end}T23:59:59+00:00"
-            query = (
-                f"SELECT {_EVENT_COLUMNS} FROM completion_events "
-                "WHERE child_id = ? AND occurred_at >= ? "
-                "AND occurred_at < ? ORDER BY instance_id, id"
-            )
-            rows = await self._database.fetch_all(
-                query,
-                [
-                    child_id,
-                    occurred_start,
-                    _next_day_start(range_end),
-                ],
-            )
-            return [_event_from_row(row) for row in rows]
-        rows = await self._database.fetch_all(
-            f"SELECT {_EVENT_COLUMNS} FROM completion_events "
-            f"WHERE instance_id IN ({predicate}) "
-            "ORDER BY instance_id, id",
-            tuple(parameters),
-        )
-        return [_event_from_row(row) for row in rows]
-
-    async def get_latest_for_instance(
-        self, instance_id: int
-    ) -> CompletionEventRecord | None:
-        """Return the instance's most recent event, or None if untouched.
-
-        Instance current state derives from this event (Feature 08):
-        'completed' means done, 'uncompleted' as the latest means open
-        again, None means never completed.
-        """
-        row = await self._database.fetch_one(
-            f"SELECT {_EVENT_COLUMNS} FROM completion_events "
-            "WHERE instance_id = ? ORDER BY id DESC LIMIT 1",
-            (instance_id,),
-        )
-        return _event_from_row(row) if row is not None else None

custom_components/nestquest/dao_presence.py

@@ -1,334 +0,0 @@
-"""Typed DAO layer for the presence_schedules and presence_overrides tables.
-
-All SQL for these tables lives in this module per the feature
-guardrails: callers get typed dataclasses back and never see raw rows
-or SQL.  Every method is async and runs through
-:class:`~.db.NestQuestDatabase`, so each statement executes on the HA
-executor and the event loop never blocks.
-
-Semantics per the done-condition and Feature 05:
-
-- A child has AT MOST ONE presence schedule (schema UNIQUE); upserting
-  by child updates the existing row rather than raising.
-- A child with NO schedule row is present every day — the absence of a
-  row is meaningful state, expressed by :meth:`PresenceSchedulesDao.get_by_child`
-  returning None, never by an empty pattern row.
-- Overrides beat the pattern for their date range (that resolution is
-  the presence engine's job, Feature 05); the DAO only stores and
-  lists them.  A single-day override stores the same date as both
-  start and end (schema CHECK requires end >= start).
-
-Date arguments are validated as strict YYYY-MM-DD per the same policy
-the rules DAO applies: the schema's lexical CHECKs cannot prove
-calendar validity.
-"""
-from __future__ import annotations
-
-from dataclasses import dataclass
-
-from .dao_children import _connection_lock
-from .dao_rules import _UNSET, _validate_date
-from .db import NestQuestDatabase
-
-
-@dataclass(frozen=True)
-class PresenceScheduleRecord:
-    """One row of ``presence_schedules``."""
-
-    id: int
-    child_id: int
-    cycle_length_weeks: int
-    anchor_date: str
-    pattern: str
-
-
-@dataclass(frozen=True)
-class PresenceOverrideRecord:
-    """One row of ``presence_overrides``."""
-
-    id: int
-    child_id: int
-    start_date: str
-    end_date: str
-    is_present: bool
-    note: str | None
-
-
-_SCHEDULE_COLUMNS = (
-    "id, child_id, cycle_length_weeks, anchor_date, pattern"
-)
-_OVERRIDE_COLUMNS = (
-    "id, child_id, start_date, end_date, is_present, note"
-)
-
-
-def _schedule_from_row(row: tuple) -> PresenceScheduleRecord:
-    return PresenceScheduleRecord(
-        id=row[0],
-        child_id=row[1],
-        cycle_length_weeks=row[2],
-        anchor_date=row[3],
-        pattern=row[4],
-    )
-
-
-def _override_from_row(row: tuple) -> PresenceOverrideRecord:
-    return PresenceOverrideRecord(
-        id=row[0],
-        child_id=row[1],
-        start_date=row[2],
-        end_date=row[3],
-        is_present=bool(row[4]),
-        note=row[5],
-    )
-
-
-class PresenceSchedulesDao:
-    """Typed async access to the ``presence_schedules`` table."""
-
-    def __init__(self, database: NestQuestDatabase) -> None:
-        self._database = database
-
-    async def upsert_by_child(
-        self,
-        child_id: int,
-        cycle_length_weeks: int,
-        anchor_date: str,
-        pattern: str,
-    ) -> PresenceScheduleRecord:
-        """Set the child's presence schedule, replacing any existing one.
-
-        Upsert semantics are the done-condition: a second schedule for
-        the same child updates the existing row rather than raising.
-        Runs under the connection lock so a concurrent upsert/delete
-        for the same child serializes instead of colliding on the
-        schema's UNIQUE(child_id).  Pattern validity (segment shape,
-        segment count = cycle_length_weeks) is enforced by the schema
-        CHECKs; the child must exist (FK) — validated atomically here
-        so a deleted child cannot pass a stale check.
-        """
-        _validate_date(anchor_date, "anchor_date")
-        async with _connection_lock(self._database):
-            async with self._database.transaction():
-                child = await self._database.fetch_one(
-                    "SELECT 1 FROM children WHERE id = ?", (child_id,)
-                )
-                if child is None:
-                    raise ValueError(f"child {child_id} does not exist")
-                await self._database.execute(
-                    "INSERT INTO presence_schedules (child_id, "
-                    "cycle_length_weeks, anchor_date, pattern) "
-                    "VALUES (?, ?, ?, ?) "
-                    "ON CONFLICT (child_id) DO UPDATE SET "
-                    "cycle_length_weeks = excluded.cycle_length_weeks, "
-                    "anchor_date = excluded.anchor_date, "
-                    "pattern = excluded.pattern",
-                    (child_id, cycle_length_weeks, anchor_date, pattern),
-                )
-                schedule = await self.get_by_child(child_id)
-        assert schedule is not None
-        return schedule
-
-    async def get_by_child(
-        self, child_id: int
-    ) -> PresenceScheduleRecord | None:
-        """Return the child's schedule, or None when the child has none.
-
-        None is meaningful and UNAMBIGUOUS here: the child exists and
-        has no schedule row, i.e. the child is present every day
-        (Feature 05 guardrail).  An unknown child id raises ValueError
-        instead of returning None, because "nonexistent child" must
-        never be silently read as "present every day".
-        """
-        child = await self._database.fetch_one(
-            "SELECT 1 FROM children WHERE id = ?", (child_id,)
-        )
-        if child is None:
-            raise ValueError(f"child {child_id} does not exist")
-        row = await self._database.fetch_one(
-            f"SELECT {_SCHEDULE_COLUMNS} FROM presence_schedules "
-            "WHERE child_id = ?",
-            (child_id,),
-        )
-        return _schedule_from_row(row) if row is not None else None
-
-    async def delete(self, child_id: int) -> bool:
-        """Remove the child's schedule; True if a row was removed.
-
-        After deletion the child is present every day (no row means
-        no restriction).  Deleting a schedule the child never had
-        returns False.
-        """
-        result = await self._database.execute(
-            "DELETE FROM presence_schedules WHERE child_id = ?",
-            (child_id,),
-        )
-        return result.rowcount > 0
-
-
-class PresenceOverridesDao:
-    """Typed async access to the ``presence_overrides`` table."""
-
-    def __init__(self, database: NestQuestDatabase) -> None:
-        self._database = database
-
-    async def create(
-        self,
-        child_id: int,
-        start_date: str,
-        end_date: str,
-        is_present: bool,
-        *,
-        note: str | None = None,
-    ) -> PresenceOverrideRecord:
-        """Insert one override and return the record as stored.
-
-        The child must exist (validated atomically under the
-        connection lock).  Date shape is validated strictly, and the
-        schema CHECK rejects end < start.
-
-        Overlap policy (Feature 05): an override for a child may not
-        overlap another override of the SAME child — two different
-        present/absent answers for one date are unresolvable.  The
-        overlap check (inclusive boundaries) runs inside the same
-        transaction as the INSERT, so a racing create cannot slip a
-        conflicting override between the check and the write; a
-        conflict raises ValueError naming the conflicting override's
-        id and range.
-        """
-        _validate_date(start_date, "start_date")
-        _validate_date(end_date, "end_date")
-        async with _connection_lock(self._database):
-            async with self._database.transaction():
-                child = await self._database.fetch_one(
-                    "SELECT 1 FROM children WHERE id = ?", (child_id,)
-                )
-                if child is None:
-                    raise ValueError(f"child {child_id} does not exist")
-                # Only a well-ordered range has overlap semantics:
-                # inverted ranges fall through to the INSERT and hit
-                # the schema's end>=start CHECK, preserving the
-                # IntegrityError contract the matrix tests rely on.
-                if end_date >= start_date:
-                    conflicting = await self._database.fetch_one(
-                        f"SELECT {_OVERRIDE_COLUMNS} "
-                        "FROM presence_overrides "
-                        "WHERE child_id = ? AND end_date >= ? "
-                        "AND start_date <= ? ORDER BY id LIMIT 1",
-                        (child_id, start_date, end_date),
-                    )
-                else:
-                    conflicting = None
-                if conflicting is not None:
-                    conflict = _override_from_row(conflicting)
-                    raise ValueError(
-                        f"override for child {child_id} "
-                        f"[{start_date}, {end_date}] overlaps existing "
-                        f"override {conflict.id} "
-                        f"[{conflict.start_date}, {conflict.end_date}] "
-                        f"(is_present={conflict.is_present})"
-                    )
-                result = await self._database.execute(
-                    "INSERT INTO presence_overrides (child_id, "
-                    "start_date, end_date, is_present, note) "
-                    "VALUES (?, ?, ?, ?, ?)",
-                    (child_id, start_date, end_date, int(is_present), note),
-                )
-                override = await self._database.fetch_one(
-                    f"SELECT {_OVERRIDE_COLUMNS} FROM presence_overrides "
-                    "WHERE id = ?",
-                    (result.lastrowid,),
-                )
-        assert override is not None
-        return _override_from_row(override)
-
-    async def list_by_child_and_range(
-        self,
-        child_id: int,
-        range_start: str,
-        range_end: str,
-    ) -> list[PresenceOverrideRecord]:
-        """Return the child's overrides overlapping [range_start, range_end].
-
-        An override overlaps the range when it ends on or after the
-        range starts and starts on or before the range ends (inclusive
-        boundary dates, matching the storage model where overrides are
-        closed date ranges).  Ordered by start date.
-        """
-        _validate_date(range_start, "range_start")
-        _validate_date(range_end, "range_end")
-        if range_end < range_start:
-            raise ValueError(
-                "range_end must be on or after range_start, got "
-                f"{range_end!r} < {range_start!r}"
-            )
-        rows = await self._database.fetch_all(
-            f"SELECT {_OVERRIDE_COLUMNS} FROM presence_overrides "
-            "WHERE child_id = ? AND end_date >= ? AND start_date <= ? "
-            "ORDER BY start_date",
-            (child_id, range_start, range_end),
-        )
-        return [_override_from_row(row) for row in rows]
-
-    async def delete(self, override_id: int) -> bool:
-        """Remove one override by id; True if a row was removed."""
-        result = await self._database.execute(
-            "DELETE FROM presence_overrides WHERE id = ?",
-            (override_id,),
-        )
-        return result.rowcount > 0
-
-
-async def read_snapshot_unlocked(
-    database: NestQuestDatabase,
-    child_ids: list[int],
-    range_start: str,
-    range_end: str,
-) -> tuple[
-    dict[int, PresenceScheduleRecord],
-    dict[int, list[PresenceOverrideRecord]],
-]:
-    """Read schedules and overrides for ``child_ids`` WITHOUT locking.
-
-    MUST be called inside the connection lock and an open transaction, so
-    the schedules and overrides returned here stay coherent with every
-    other table the caller reads inside that same transaction (the
-    materialization walk's single input snapshot does exactly that).  The
-    date range comes already validated by the caller.
-
-    Returns ``(schedules, overrides)``:
-
-    - ``schedules`` maps ``child_id`` to its :class:`PresenceScheduleRecord`
-      for every child that HAS a schedule row.  A child absent from the
-      mapping has no schedule, i.e. is present every day (Feature 05).
-    - ``overrides`` maps ``child_id`` to that child's overrides overlapping
-      ``[range_start, range_end]`` (inclusive boundaries), ordered by start
-      date; a child with no matching override is absent from the mapping.
-
-    ``child_ids`` must name existing children (the caller derives them
-    from a trusted snapshot, within the same transaction).
-    """
-    children = sorted(set(child_ids))
-    if not children:
-        return {}, {}
-    placeholders = ",".join("?" for _ in children)
-    schedule_rows = await database.fetch_all(
-        f"SELECT {_SCHEDULE_COLUMNS} FROM presence_schedules "
-        f"WHERE child_id IN ({placeholders})",
-        tuple(children),
-    )
-    override_rows = await database.fetch_all(
-        f"SELECT {_OVERRIDE_COLUMNS} FROM presence_overrides "
-        f"WHERE child_id IN ({placeholders}) AND end_date >= ? "
-        "AND start_date <= ? ORDER BY start_date",
-        tuple(children) + (range_start, range_end),
-    )
-    schedules = {
-        record.child_id: record
-        for record in map(_schedule_from_row, schedule_rows)
-    }
-    overrides: dict[int, list[PresenceOverrideRecord]] = {}
-    for row in override_rows:
-        record = _override_from_row(row)
-        overrides.setdefault(record.child_id, []).append(record)
-    return schedules, overrides

custom_components/nestquest/manifest.json

@@ -1,14 +1,12 @@
 {
   "domain": "nestquest",
   "name": "NestQuest",
-  "codeowners": [
-    "@overseer"
-  ],
+  "codeowners": ["@overseer"],
   "config_flow": true,
-  "documentation": "https://github.com/talon2king/NestQuest",
+  "documentation": "https://code.cubecraftlabs.com/Maniacs_Mansion/NestQuest",
   "integration_type": "hub",
   "iot_class": "local_polling",
-  "issue_tracker": "https://github.com/talon2king/NestQuest/issues",
+  "issue_tracker": "https://code.cubecraftlabs.com/Maniacs_Mansion/NestQuest/issues",
   "requirements": [],
-  "version": "0.3.0"
+  "version": "0.1.0"
 }

custom_components/nestquest/materialize.py

@@ -1,377 +0,0 @@
-"""The materialization walk (Feature 07 core).
-
-:func:`materialize` turns the schedule rules + custody presence of the
-active quest definitions into concrete ``quest_instances`` rows over a
-date range.  It is the pure walk over definitions x dates x assignees x
-windows; HA scheduling (day-rollover triggers) is a separate later
-task and lives elsewhere.
-
-The walk is deterministic and idempotent:
-
-- All inputs — the active definitions with their rules, assignees and
-  windows, AND the assignee children's presence schedules and scoped
-  overrides — are read inside ONE locked transaction (see
-  :func:`~.dao_rules.load_materialization_input`), so the walk sees a
-  single coherent snapshot rather than a definition state from one
-  instant and a presence state from another.
-- Presence is snapshotted into an immutable
-  :class:`~.presence.PresenceEngine` from that same coherent read.
-- For each date in the range, each definition whose decoded rule
-  :func:`~.recurrence.occurs_on` on that date, each assignee who is
-  ``is_present`` on that date and each declared window, one instance is
-  written through :class:`~.dao_instances.QuestInstancesDao.upsert_if_valid`
-  with a ``generated_at`` stamp shared by the whole batch (one coherent
-  time per run).
-
-A config change that lands AFTER the snapshot is read but BEFORE a
-tuple's write (an assignment removed, a definition or child deactivated,
-a window removed) makes that tuple SKIP rather than abort the batch:
-:meth:`~.dao_instances.QuestInstancesDao.upsert_if_valid` re-validates
-every materialization precondition (active definition, active child,
-live assignment, declared window, and its CURRENT ``due_time``) inside
-the SAME transaction as the INSERT, so the check and the write cannot be
-split by a racing config edit.
-
-The upsert is idempotent on (definition_id, child_id, due_date,
-window), so re-running the materialization over the same range never
-duplicates a row; a tuple whose instance is already completed is SKIPPED
-(never rewritten, never raised) by
-:meth:`~.dao_instances.QuestInstancesDao.upsert_if_valid`.
-
-Regeneration: a config or presence change must rebuild future instances
-so they track the new state.  :func:`regenerate_for_definition` covers
-definition edits / reassignment (Features 06/07); :func:`regenerate_for_child`
-covers a single child's presence change (Feature 09).  Both delete the
-affected open instances at or after today — never a completed instance,
-never the past — and re-run the walk over the rolling horizon
-``[today, today + horizon_days]`` (``horizon_days`` defaults to
-``DEFAULT_HORIZON_DAYS``).
-
-HOOK (Feature 09 presence services): the presence business layer that
-lands in Feature 09 MUST call :func:`regenerate_for_child` after EVERY
-presence-state write so a child's future instances track its presence:
-``set_presence_pattern`` (including clearing/setting an empty pattern),
-deleting/clearing the presence schedule
-(:meth:`~.dao_presence.PresenceSchedulesDao.delete`),
-``create_presence_override``, and ``delete_presence_override``.  A
-schedule delete changes presence state too (the child becomes
-always-present), so it must regenerate just like the others.  This hook
-is documented, not yet wired: no presence business layer exists yet, and
-the presence DAO (``dao_presence.py``) must stay free of business rules
-— never call :func:`regenerate_for_child` from inside the DAO layer.
-"""
-from __future__ import annotations
-
-import datetime
-
-from .const import DEFAULT_HORIZON_DAYS
-from .dao_instances import QuestInstancesDao, _resolve_today
-from .dao_rules import (
-    _validate_date,
-    load_materialization_input,
-    schedule_rule_from_storage,
-    schedule_rule_storage_from_record,
-)
-from .db import NestQuestDatabase
-from .presence import PresenceEngine, PresenceOverride, PresenceSchedule
-from .recurrence import ScheduleRule, occurs_on
-
-
-def _now_stamp() -> str:
-    """Return the batch's shared UTC second-precision generation stamp."""
-    return datetime.datetime.now(datetime.timezone.utc).isoformat(
-        timespec="seconds"
-    )
-
-
-def _resolve_horizon_days(horizon_days: int | None) -> int:
-    """Validate a regeneration horizon and return the resolved day count.
-
-    ``None`` resolves to :data:`~.const.DEFAULT_HORIZON_DAYS`.  A bool
-    (SQLite would happily bind ``True``/``False`` onto an int), a non-int,
-    or a value below 1 raises ValueError naming the field — the validation
-    runs BEFORE any future-instance delete so a malformed horizon can never
-    delete rows it then fails to rebuild.  A negative horizon would
-    otherwise delete first and only then be rejected by
-    :func:`materialize`'s inverted-range check; ``0``/``False`` would
-    silently shrink the window to a single day.
-    """
-    if horizon_days is None:
-        return DEFAULT_HORIZON_DAYS
-    if (
-        isinstance(horizon_days, bool)
-        or not isinstance(horizon_days, int)
-        or horizon_days < 1
-    ):
-        raise ValueError(
-            f"horizon_days must be a positive integer, got {horizon_days!r}"
-        )
-    return horizon_days
-
-
-def _decode_rule(snapshot) -> ScheduleRule:
-    """Decode a snapshot's rule record back into a ScheduleRule.
-
-    The record carried by the snapshot is the one the definition
-    referenced at read time, so decoding it here (rather than re-reading
-    through ``ScheduleRulesDao``) preserves the coherence the snapshot
-    guarantees.
-    """
-    return schedule_rule_from_storage(
-        schedule_rule_storage_from_record(snapshot.rule)
-    )
-
-
-def _build_engine(
-    schedules_records,
-    overrides_records,
-) -> PresenceEngine:
-    """Convert raw presence records into an immutable PresenceEngine."""
-    schedules: dict[int, PresenceSchedule] = {}
-    for child_id, record in schedules_records.items():
-        schedules[child_id] = PresenceSchedule.decode(
-            child_id, record.anchor_date, record.pattern
-        )
-    overrides: dict[int, list[PresenceOverride]] = {}
-    for child_id, records in overrides_records.items():
-        overrides[child_id] = [
-            PresenceOverride(
-                record.child_id,
-                record.start_date,
-                record.end_date,
-                record.is_present,
-                record.note,
-            )
-            for record in records
-        ]
-    return PresenceEngine(schedules, overrides)
-
-
-async def materialize(
-    database: NestQuestDatabase,
-    start_date: str,
-    end_date: str,
-    *,
-    child_ids: list[int] | None = None,
-    today: datetime.date | None = None,
-) -> int:
-    """Generate quest instances for the closed range [start_date, end_date].
-
-    ``start_date`` and ``end_date`` must be strict ISO calendar dates
-    (YYYY-MM-DD) with ``end_date`` on or after ``start_date``; anything
-    else raises ValueError naming the offending field.  Returns the number
-    of instances upserted for the range (idempotent — a re-run refreshes
-    the same rows, never duplicates them).
-
-    ``child_ids`` optionally scopes the walk to exactly those children:
-    assignees outside the list are never written, so a caller that only
-    wants one child's instances rebuilt (e.g. :func:`regenerate_for_child`
-    after a presence change) cannot touch any unrelated child's rows.
-    When omitted (or None) the walk covers every assignee as before.
-
-    ``today`` optionally pins the resolved HA-local date the walk's
-    no-past guard compares against; it is threaded into every
-    :meth:`~.dao_instances.QuestInstancesDao.upsert_if_valid` write.  When
-    omitted the host clock (``datetime.date.today``) is used, which is the
-    historical default.  A caller that computed the horizon in Home
-    Assistant's configured time zone MUST pass that same date here so a
-    time zone behind the host around midnight is not rejected as "past".
-
-    ``start_date`` is clamped up to the resolved "today" (the same
-    ``today`` anchor threaded into the no-past guard), so a caller that
-    passes a ``start_date`` already in the past never yields a
-    past-dated instance: the walk simply begins on today and skips every
-    earlier date.  A range entirely in the past therefore produces zero
-    instances rather than an error, and the DAO's no-past guard remains
-    the authoritative backstop under the lock.
-
-    All inputs are read in ONE locked transaction; each tuple's write then
-    goes through the atomic :meth:`~.dao_instances.QuestInstancesDao.upsert_if_valid`,
-    which re-validates the tuple and its current ``due_time`` in the same
-    transaction as the INSERT, so a config change that arrives mid-batch
-    skips the affected tuples rather than aborting the batch or leaving a
-    partial result.
-    """
-    _validate_date(start_date, "start_date")
-    _validate_date(end_date, "end_date")
-    if end_date < start_date:
-        raise ValueError(
-            f"end_date must be on or after start_date, got "
-            f"{end_date!r} < {start_date!r}"
-        )
-
-    snapshots, schedules_records, overrides_records = await (
-        load_materialization_input(database, start_date, end_date)
-    )
-    engine = _build_engine(schedules_records, overrides_records)
-    child_filter = None if child_ids is None else set(child_ids)
-
-    definitions = [
-        (snapshot.definition.id, _decode_rule(snapshot),
-         snapshot.assignees, snapshot.windows)
-        for snapshot in snapshots
-    ]
-
-    generated_at = _now_stamp()
-    instances = QuestInstancesDao(database)
-
-    start = datetime.datetime.strptime(start_date, "%Y-%m-%d").date()
-    end = datetime.datetime.strptime(end_date, "%Y-%m-%d").date()
-
-    # Clamp a past start up to today (the HA-local anchor when the caller
-    # pinned one, else the host clock) so the walk can never emit a
-    # past-dated instance; the DAO's no-past guard remains the backstop.
-    # A range entirely in the past therefore yields zero instances.
-    today_date = _resolve_today(today)
-    start = max(start, today_date)
-
-    count = 0
-    cursor = start
-    while cursor <= end:
-        iso = cursor.isoformat()
-        for definition_id, rule, assignees, windows in definitions:
-            if not occurs_on(rule, cursor):
-                continue
-            for child in assignees:
-                if child_filter is not None and child.id not in child_filter:
-                    continue
-                if not engine.is_present(child.id, cursor):
-                    continue
-                for window in windows:
-                    written = await instances.upsert_if_valid(
-                        definition_id,
-                        child.id,
-                        iso,
-                        generated_at,
-                        window=window.window,
-                        due_time=window.due_time,
-                        today=today,
-                    )
-                    if written is not None:
-                        count += 1
-        cursor += datetime.timedelta(days=1)
-    return count
-
-
-async def regenerate_for_definition(
-    database: NestQuestDatabase,
-    definition_id: int,
-    *,
-    today: datetime.date | None = None,
-    horizon_days: int | None = None,
-) -> int:
-    """Regenerate a definition's future instances after a config change.
-
-    The Feature 06 edit/assignment/activation paths call this after a
-    successful write so future instances track the new state: the
-    definition's open instances at or after today are deleted (never a
-    completed instance, never the past) via
-    :meth:`~.dao_instances.QuestInstancesDao.delete_future_uncompleted`,
-    then the materialization walk re-runs over the rolling horizon
-    ``[today, today + horizon_days]`` so the (changed) rule,
-    assignee set and windows re-materialize against today's state.
-
-    "today" is computed the same way the walk computes it —
-    :func:`~.dao_instances._today` — so the delete cutoff and the
-    re-materialization range share one anchor, and the walk's
-    ``upsert_if_valid`` no-past guard never rejects the regenerated
-    range.  ``today`` optionally pins a caller-resolved HA-local date
-    (threaded into both the delete cutoff and the re-materialization)
-    so a household time zone behind the host around midnight stays
-    consistent.  ``horizon_days`` sizes the re-materialization window;
-    when omitted it falls back to :data:`~.const.DEFAULT_HORIZON_DAYS`.
-    A bool, non-int, or sub-1 value raises ValueError BEFORE any delete.
-    Returns the number of instances the re-materialization
-    upserted across the whole snapshot (idempotent — other active
-    definitions' tuples refresh in place, never duplicate).
-    """
-    horizon = _resolve_horizon_days(horizon_days)
-    today_date = _resolve_today(today)
-    start_date = today_date.isoformat()
-    end_date = (
-        today_date + datetime.timedelta(days=horizon)
-    ).isoformat()
-
-    instances = QuestInstancesDao(database)
-    await instances.delete_future_uncompleted(
-        definition_id, start_date, today=today
-    )
-    return await materialize(database, start_date, end_date, today=today)
-
-
-# HOOK (Feature 09 presence services): ``regenerate_for_child`` is the
-# child-presence counterpart to ``regenerate_for_definition``.  The
-# presence business layer that lands in Feature 09 MUST call
-# ``regenerate_for_child`` after EVERY presence-state write, so future
-# instances track a child's changed presence: set_presence_pattern
-# (including clearing/setting an empty pattern), deleting/clearing the
-# presence schedule (PresenceSchedulesDao.delete),
-# create_presence_override, and delete_presence_override.  A schedule
-# delete changes presence state too (the child becomes always-present),
-# so it must regenerate just like the others.  It is deliberately NOT
-# wired into ``dao_presence.py``: the DAO layer stays pure storage (no
-# business rules), and no presence business layer exists yet to host the
-# call — see the module docstring note above.
-async def regenerate_for_child(
-    database: NestQuestDatabase,
-    child_id: int,
-    *,
-    today: datetime.date | None = None,
-    horizon_days: int | None = None,
-) -> int:
-    """Regenerate a child's future instances after a presence change.
-
-    The Feature 09 presence services call this after every
-    presence-state write — set_presence_pattern (including clearing or
-    setting an empty pattern), deleting/clearing the presence schedule
-    (:meth:`~.dao_presence.PresenceSchedulesDao.delete`),
-    create_presence_override, and delete_presence_override — so a
-    child's future instances track its new presence: the child's open
-    instances at or after today are deleted across ALL its definitions
-    (never a completed instance, never the past) via
-    :meth:`~.dao_instances.QuestInstancesDao.delete_future_uncompleted_for_child`,
-    then the materialization walk re-runs over the rolling horizon
-    ``[today, today + horizon_days]`` scoped to that child only,
-    so the child's now-absent/present dates re-materialize against
-    today's presence WITHOUT touching any other child's rows.
-
-    ``child_id`` must be a plain int — bool and float are rejected
-    (SQLite binds a bool as 0/1 and a float would round, so a malformed
-    id must never mutate the wrong profile).
-
-    "today" is computed the same way the walk computes it —
-    :func:`~.dao_instances._today` — and the re-materialization range uses the
-    delete's returned effective cutoff (see
-    :meth:`~.dao_instances.QuestInstancesDao.delete_future_uncompleted_for_child`),
-    so the delete cutoff and the re-materialization window share ONE
-    execution-day anchor even when the call is queued across midnight.
-    ``today`` optionally pins a caller-resolved HA-local date, threaded
-    into the delete cutoff and the re-materialization for the same
-    host-vs-HA time-zone consistency.  ``horizon_days`` sizes the
-    re-materialization window; when omitted it falls back to
-    :data:`~.const.DEFAULT_HORIZON_DAYS`.  A bool, non-int, or sub-1 value
-    raises ValueError BEFORE any delete.  Returns the number of instances
-    the re-materialization upserted for the child across the whole
-    snapshot.
-    """
-    if isinstance(child_id, bool) or not isinstance(child_id, int):
-        raise ValueError(f"child_id must be an integer, got {child_id!r}")
-
-    horizon = _resolve_horizon_days(horizon_days)
-    today_date = _resolve_today(today)
-
-    instances = QuestInstancesDao(database)
-    # Use the delete's returned effective cutoff as the materialize anchor,
-    # NOT the independently-computed "today" above.  If the call is queued
-    # across midnight the delete clamps its cutoff to the execution-day;
-    # materializing from the stale "today" (now yesterday) would trip the
-    # walk's no-past guard and leave the child's future instances deleted
-    # but not rebuilt.  One anchor for both keeps them consistent.
-    _, effective_cutoff = await instances.delete_future_uncompleted_for_child(
-        child_id, today_date.isoformat(), today=today
-    )
-    start = datetime.date.fromisoformat(effective_cutoff)
-    end_date = (start + datetime.timedelta(days=horizon)).isoformat()
-    return await materialize(
-        database, start.isoformat(), end_date, child_ids=[child_id], today=today
-    )

custom_components/nestquest/migrations.py

@@ -1,584 +0,0 @@
-"""Versioned schema migration runner for the NestQuest SQLite database.
-
-The runner owns one metadata table, ``nestquest_schema_version``, holding
-a single row with the schema version the database file currently
-reflects.  Migrations are declared as an ordered list: entry ``n``
-upgrades version ``n-1`` to version ``n``.  Applying a migration means
-running its DDL inside one transaction and stamping the new version in
-that same transaction, so a database never persists a half-applied
-migration: any failure rolls the statements and the version stamp back
-together, leaving the file at its prior version.
-
-Version 0 means "the file exists but carries no NestQuest schema yet"
-— a fresh file, or a file this integration has never written.  Starting
-the runner against version 0 applies migration 1, which applies the
-full v1 DDL from :mod:`.schema` and stamps version 1.
-
-Migration 1 was rewritten pre-release (D-007): nothing was ever
-shipped, so the v1 DDL now creates the ``quest_*`` tables directly
-instead of the legacy ``task_*`` spellings, and no compatibility shim
-exists.  Dev machines that already hold a version-1 database with
-``task_*`` tables are handled by migration 2, which detects the legacy
-table names and ``ALTER TABLE ... RENAME TO``s them to their current
-names before anything else assumes the new model.  Migration 3 brings
-pre-D-008 databases to the multi-assignee model: it creates
-``quest_definition_assignees`` and, when ``quest_definitions`` still
-carries a single ``child_id`` column, rebuilds the table without it,
-copying each definition's assignee across.  Migration 4 adds the
-windows table, migration 5 rebuilds ``quest_instances`` onto the
-widened (definition_id, child_id, due_date, window) key, and migration
-6 rebuilds ``completion_events`` with the D-008 ``actor_child_id``
-column.  Each callable migration runs inside its own transaction
-together with its version stamp, so a crash mid-step rolls the
-statements and the stamp back together.
-
-Migration entries are either an ordered sequence of SQL statements or
-an async callable taking ``(database, target_version)``.  Callables
-exist for steps whose SQL depends on the database's current state (a
-legacy rename only fires when a legacy table is present; a rebuild only
-when the old column shape is present) and own their transaction so they
-can bracket it with connection pragmas the runner's uniform transaction
-cannot express.
-
-Each migration's statements and its version stamp run inside ONE
-transaction, and the stamp is written as DELETE + INSERT rather than
-UPDATE because a version-0 database has no version row to update yet.
-An UPDATE form would silently match zero rows there and leave the
-database migrated but unstamped — reporting version 0 forever, and
-re-applying migration 1 on every startup.  The DELETE+INSERT shape is
-also what makes the stamp a replace, so the row never duplicates.
-
-Idempotence across restarts: a database already at the latest version
-has no pending migrations, so the runner opens a read-only check, finds
-nothing to do, and leaves the file byte-untouched (no write transaction
-is opened, so no WAL churn).
-
-Migration list policy: entries are append-only.  Once shipped, a
-migration's SQL must never be edited — an old database applying it for
-the first time and a fresh database would then diverge.  Fix-forward
-with a new migration instead.  The version stamp lives in the same
-SQLite file as the data it describes, so restoring a backup restores
-its matching schema version with it.
-
-Corrupt or missing files are not this module's concern: startup
-handling of those cases is task d5bca74b, which decides whether to
-open fresh or raise ConfigEntryNotReady.  This runner assumes it is
-handed an open, working connection.
-"""
-from __future__ import annotations
-
-import asyncio
-import logging
-from collections.abc import Awaitable, Callable, Sequence
-from typing import Union
-
-from .db import NestQuestDatabase
-from .schema import (
-    COMPLETION_EVENTS_TABLE_SQL,
-    QUEST_DEFINITIONS_TABLE_SQL,
-    QUEST_INSTANCES_TABLE_SQL,
-    SCHEMA_V1_STATEMENTS,
-    SCHEMA_V1_QUEST_DEFINITION_ASSIGNEES_DDL,
-    SCHEMA_V1_QUEST_DEFINITION_WINDOWS_DDL,
-)
-
-LOGGER = logging.getLogger(__name__)
-
-#: One migration entry: either an ordered sequence of SQL statements or
-#: an async callable taking ``(database, target_version)`` that manages
-#: its own transaction and stamps via :func:`stamp_schema_version`.
-MigrationStep = Union[
-    Sequence[str],
-    Callable[[NestQuestDatabase, int], Awaitable[None]],
-]
-
-#: Metadata table holding the applied schema version.  Prefixed with the
-#: integration domain so a config directory shared with other tools can
-#: never collide with a foreign ``schema_version`` table.
-VERSION_TABLE = "nestquest_schema_version"
-
-#: DDL for the version metadata table.  The singleton-row invariant is
-#: enforced by the schema itself: ``id`` is fixed at 1 by CHECK, keyed
-#: PRIMARY KEY, so the table can never hold a second row, and the
-#: stamp write is an UPDATE (no DELETE+INSERT needed).  ``version`` is
-#: a positive integer: version 0 means "no row" and is never stored,
-#: so a negative or zero stored value is corruption, not a state the
-#: runner can act on.
-VERSION_TABLE_DDL = f"""
-    CREATE TABLE IF NOT EXISTS {VERSION_TABLE} (
-        id INTEGER NOT NULL PRIMARY KEY CHECK (id = 1),
-        version INTEGER NOT NULL CHECK (version >= 1)
-    )
-"""
-
-#: One-based index into :data:`MIGRATIONS`: entry ``n`` upgrades
-#: version ``n-1`` to version ``n``.
-MIGRATION_1_V1_DDL: list[str] = list(SCHEMA_V1_STATEMENTS)
-
-#: The assignees table DDL, shared with migration 1 via the schema
-#: module so a rebuilt and a freshly created table cannot drift.
-_ASSIGNEES_TABLE_DDL: str = SCHEMA_V1_QUEST_DEFINITION_ASSIGNEES_DDL[0]
-
-#: Legacy (pre-D-007) table name -> current table name.  Order matters:
-#: the parent table renames first so the child's foreign key reference
-#: is rewritten while its parent's new name is already in place.
-LEGACY_TASK_TABLE_RENAMES: tuple[tuple[str, str], ...] = (
-    ("task_definitions", "quest_definitions"),
-    ("task_instances", "quest_instances"),
-)
-
-
-async def stamp_schema_version(
-    database: NestQuestDatabase, version: int
-) -> None:
-    """Write the schema version stamp (inside the caller's transaction).
-
-    INSERT keyed on the singleton row (id = 1) with an upsert: a fresh
-    file has no row yet, so UPDATE alone would silently match zero rows
-    there and leave a migrated-but-unstamped database.
-    """
-    await database.execute(
-        f"INSERT INTO {VERSION_TABLE} (id, version) "
-        "VALUES (1, ?) "
-        "ON CONFLICT (id) DO UPDATE SET version = excluded.version",
-        (version,),
-    )
-
-
-async def _table_has_column(
-    database: NestQuestDatabase, table: str, column: str
-) -> bool:
-    """Return True when ``table`` currently carries ``column``."""
-    rows = await database.fetch_all(f"PRAGMA table_info({table})")
-    return any(row[1] == column for row in rows)
-
-
-#: Window assigned to instances migrated from the pre-window instance
-#: shape (D-008).  Pre-window rows were generated for whole-day
-#: obligations; the morning window is the documented default landing
-#: spot, and future dates are regenerated with real window declarations
-#: by materialization (delete_future_uncompleted + re-run).
-LEGACY_MIGRATED_WINDOW = "morning"
-
-
-async def _rename_legacy_task_tables(
-    database: NestQuestDatabase, target_version: int
-) -> None:
-    """Rename any surviving ``task_*`` tables to their ``quest_*`` names.
-
-    Dev-machines-only path (D-007): a database stamped version 1 by the
-    pre-rename runner holds ``task_definitions``/``task_instances``.
-    Each legacy name still present is renamed; fresh databases find
-    nothing and this step is a no-op.  Modern SQLite rewrites foreign
-    key clauses in other tables to follow the rename, so the renamed
-    schema is indistinguishable from a freshly created one apart from
-    internal autoindex names.  Runs in its own transaction together
-    with the version stamp, so a crash rolls both back.
-    """
-    async with database.transaction():
-        for legacy_name, current_name in LEGACY_TASK_TABLE_RENAMES:
-            row = await database.fetch_one(
-                "SELECT 1 FROM sqlite_master WHERE type = 'table' "
-                "AND name = ?",
-                (legacy_name,),
-            )
-            if row is not None:
-                await database.execute(
-                    f'ALTER TABLE "{legacy_name}" RENAME TO "{current_name}"'
-                )
-                LOGGER.info(
-                    "Renamed legacy table %s to %s",
-                    legacy_name,
-                    current_name,
-                )
-        await stamp_schema_version(database, target_version)
-
-
-async def _add_definition_assignees(
-    database: NestQuestDatabase, target_version: int
-) -> None:
-    """Bring definitions to the multi-assignee model (D-008).
-
-    Two shapes arrive here:
-
-    - Fresh or renamed databases whose ``quest_definitions`` already
-      matches the current canonical DDL (no ``child_id`` column): only
-      the assignees table needs creating (``IF NOT EXISTS`` is a no-op
-      when migration 1 already made it).
-    - Databases stamped at version 2 whose ``quest_definitions`` still
-      carries the single ``child_id`` column: the table is rebuilt via
-      SQLite's canonical procedure — create the new table, copy rows,
-      move each definition's assignee into
-      ``quest_definition_assignees``, drop the old table, rename — so
-      ``DROP COLUMN``'s foreign-key restriction never applies and no
-      definition or instance row is lost.
-
-    The copy runs with ``foreign_keys = OFF`` because dropping the old
-    table under enforcement would fire the implicit DELETE and violate
-    the ``quest_instances`` foreign key; ``PRAGMA foreign_key_check``
-    runs inside the same transaction before the stamp, so a corrupt
-    copy aborts the whole migration instead of persisting.  The pragma
-    is a connection-level no-op inside a transaction, hence the
-    off/transaction/on bracket.
-    """
-    legacy_child_id = await _table_has_column(
-        database, "quest_definitions", "child_id"
-    )
-    await database.execute("PRAGMA foreign_keys = OFF")
-    try:
-        async with database.transaction():
-            await database.execute(_ASSIGNEES_TABLE_DDL)
-            if legacy_child_id:
-                await database.execute(
-                    "CREATE TABLE quest_definitions_rebuilt "
-                    f"{QUEST_DEFINITIONS_TABLE_SQL}"
-                )
-                await database.execute(
-                    "INSERT INTO quest_definitions_rebuilt "
-                    "(id, title, description, icon, schedule_rule_id, "
-                    "due_time, is_active, created_at) "
-                    "SELECT id, title, description, icon, "
-                    "schedule_rule_id, due_time, is_active, created_at "
-                    "FROM quest_definitions ORDER BY id"
-                )
-                await database.execute(
-                    "INSERT OR IGNORE INTO quest_definition_assignees "
-                    "(definition_id, child_id) "
-                    "SELECT id, child_id FROM quest_definitions"
-                )
-                await database.execute("DROP TABLE quest_definitions")
-                await database.execute(
-                    "ALTER TABLE quest_definitions_rebuilt "
-                    "RENAME TO quest_definitions"
-                )
-                violations = await database.fetch_all(
-                    "PRAGMA foreign_key_check"
-                )
-                if violations:
-                    raise RuntimeError(
-                        "definition rebuild produced foreign-key "
-                        f"violations: {violations!r}"
-                    )
-            await stamp_schema_version(database, target_version)
-    finally:
-        await database.execute("PRAGMA foreign_keys = ON")
-
-
-async def _widen_instance_key(
-    database: NestQuestDatabase, target_version: int
-) -> None:
-    """Bring ``quest_instances`` to the D-008 instance key.
-
-    Databases whose instance table still carries the pre-window shape
-    (no ``window`` column, UNIQUE on (definition_id, due_date)) are
-    rebuilt via SQLite's canonical procedure into the widened shape —
-    UNIQUE (definition_id, child_id, due_date, window) — with every
-    migrated row landing in :data:`LEGACY_MIGRATED_WINDOW` so existing
-    ids (and the completion events referencing them) survive intact.
-    The old rows were unique per (definition, due_date), so pinning one
-    window cannot collide with the widened key.  Fresh databases whose
-    table already matches the canonical shape only stamp.
-
-    The rebuild runs with ``foreign_keys = OFF`` (dropping the old
-    table under enforcement would fire the implicit DELETE and violate
-    the ``completion_events`` foreign key) and verifies
-    ``PRAGMA foreign_key_check`` inside the transaction before the
-    stamp, so a corrupt copy aborts the whole migration.
-    """
-    legacy_shape = not await _table_has_column(
-        database, "quest_instances", "window"
-    )
-    await database.execute("PRAGMA foreign_keys = OFF")
-    try:
-        async with database.transaction():
-            if legacy_shape:
-                await database.execute(
-                    "CREATE TABLE quest_instances_rebuilt "
-                    f"{QUEST_INSTANCES_TABLE_SQL}"
-                )
-                await database.execute(
-                    "INSERT INTO quest_instances_rebuilt "
-                    "(id, definition_id, child_id, window, due_date, "
-                    "due_time, generated_at) "
-                    "SELECT id, definition_id, child_id, ?, due_date, "
-                    "due_time, generated_at "
-                    "FROM quest_instances ORDER BY id",
-                    (LEGACY_MIGRATED_WINDOW,),
-                )
-                await database.execute("DROP TABLE quest_instances")
-                await database.execute(
-                    "ALTER TABLE quest_instances_rebuilt "
-                    "RENAME TO quest_instances"
-                )
-                violations = await database.fetch_all(
-                    "PRAGMA foreign_key_check"
-                )
-                if violations:
-                    raise RuntimeError(
-                        "instance rebuild produced foreign-key "
-                        f"violations: {violations!r}"
-                    )
-                LOGGER.info(
-                    "Widened quest_instances key; migrated rows pinned "
-                    "to the %r window",
-                    LEGACY_MIGRATED_WINDOW,
-                )
-            await stamp_schema_version(database, target_version)
-    finally:
-        await database.execute("PRAGMA foreign_keys = ON")
-
-
-async def _add_actor_child_id(
-    database: NestQuestDatabase, target_version: int
-) -> None:
-    """Bring ``completion_events`` to the D-008 actor-child shape.
-
-    The ``actor_child_id`` column records which panel profile was
-    tapped; it cannot be added with ``ALTER TABLE ADD COLUMN`` alone
-    because the canonical shape also carries an actor-pair coherence
-    CHECK (panel events require it, user events forbid it), and CHECK
-    constraints cannot be added to an existing table.  Databases with
-    the legacy shape are therefore rebuilt via SQLite's canonical
-    procedure, backfilling each legacy panel row's ``actor_child_id``
-    to ``child_id`` — pre-D-008 panel completions were always recorded
-    against the tapped child themselves — while admin rows stay NULL.
-    Row ids are preserved so ``quest_instances`` references and the
-    append-only history stay intact.  Fresh databases already match
-    the canonical shape and only stamp.
-
-    The rebuild runs with ``foreign_keys = OFF`` and verifies
-    ``PRAGMA foreign_key_check`` inside the transaction before the
-    stamp.  The copy is an INSERT..SELECT, not an UPDATE: the
-    completion_events table keeps its append-only guarantee.
-    """
-    legacy_shape = not await _table_has_column(
-        database, "completion_events", "actor_child_id"
-    )
-    await database.execute("PRAGMA foreign_keys = OFF")
-    try:
-        async with database.transaction():
-            if legacy_shape:
-                await database.execute(
-                    "CREATE TABLE completion_events_rebuilt "
-                    f"{COMPLETION_EVENTS_TABLE_SQL}"
-                )
-                await database.execute(
-                    "INSERT INTO completion_events_rebuilt "
-                    "(id, instance_id, child_id, event_type, actor_source, "
-                    "actor_user_id, actor_child_id, occurred_at, "
-                    "was_on_time) "
-                    "SELECT id, instance_id, child_id, event_type, "
-                    "actor_source, actor_user_id, "
-                    "CASE WHEN actor_source = 'panel' THEN child_id "
-                    "ELSE NULL END, "
-                    "occurred_at, was_on_time "
-                    "FROM completion_events ORDER BY id"
-                )
-                await database.execute("DROP TABLE completion_events")
-                await database.execute(
-                    "ALTER TABLE completion_events_rebuilt "
-                    "RENAME TO completion_events"
-                )
-                violations = await database.fetch_all(
-                    "PRAGMA foreign_key_check"
-                )
-                if violations:
-                    raise RuntimeError(
-                        "completion_events rebuild produced foreign-key "
-                        f"violations: {violations!r}"
-                    )
-                LOGGER.info(
-                    "Added actor_child_id to completion_events; legacy "
-                    "panel rows backfilled to their own child_id"
-                )
-            await stamp_schema_version(database, target_version)
-    finally:
-        await database.execute("PRAGMA foreign_keys = ON")
-
-
-#: The ordered migration list.  Append-only: never edit an applied
-#: entry, add the next one instead.  (Migration 1's content was
-#: rewritten pre-release per D-007 — no version 1 database shipped.)
-MIGRATIONS: Sequence[MigrationStep] = [
-    MIGRATION_1_V1_DDL,
-    _rename_legacy_task_tables,
-    _add_definition_assignees,
-    # Migration 4 (D-008): the windows table is a plain new table — a
-    # CREATE IF NOT EXISTS suffices for both fresh databases (which
-    # already made it in migration 1) and pre-window databases.
-    list(SCHEMA_V1_QUEST_DEFINITION_WINDOWS_DDL),
-    # Migration 5 (D-008): rebuild quest_instances onto the widened
-    # (definition_id, child_id, due_date, window) key.
-    _widen_instance_key,
-    # Migration 6 (D-008): rebuild completion_events with the
-    # actor_child_id column and its actor-pair coherence CHECK,
-    # backfilling legacy panel rows to their own child_id.
-    _add_actor_child_id,
-]
-
-
-async def _create_version_table(database: NestQuestDatabase) -> None:
-    """Create the version metadata table if it does not exist.
-
-    The table is created before any version check: it is the runner's
-    own bookkeeping, and creating it is idempotent.  The DDL enforces
-    the singleton-row invariant (``id`` fixed at 1) and a positive
-    integer version at the database level.
-    """
-    await database.execute(VERSION_TABLE_DDL)
-
-
-async def read_schema_version(database: NestQuestDatabase) -> int:
-    """Return the schema version recorded in the database.
-
-    Returns 0 when the version table or its row is missing — the
-    "fresh file" case.  A stored version higher than the runner knows
-    is surfaced as-is; the caller decides how to treat a future version.
-
-    Reading is deliberately passive: a missing table raises, it is not
-    swallowed into 0, because :func:`apply_migrations` always creates
-    the table before reading and a direct reader hitting "no such
-    table" is a caller bug worth surfacing, not a fresh file.
-    """
-    row = await database.fetch_one(
-        f"SELECT version FROM {VERSION_TABLE} LIMIT 1"
-    )
-    if row is None:
-        return 0
-    version = row[0]
-    if not isinstance(version, int) or isinstance(version, bool):
-        raise RuntimeError(
-            f"Schema version metadata is not an integer: {version!r}"
-        )
-    if version < 1:
-        raise RuntimeError(
-            f"Schema version metadata is invalid (must be >= 1): {version!r}"
-        )
-    return version
-
-
-#: One asyncio.Lock per connection wrapper, created lazily and bound to
-#: the running loop, serializing whole apply_migrations runs so two
-#: concurrent callers on one connection queue instead of colliding on
-#: the wrapper's single-transaction rule.
-_MIGRATION_LOCKS: dict[int, asyncio.Lock] = {}
-
-
-def _migration_lock(database: NestQuestDatabase) -> asyncio.Lock:
-    """Return the migration lock bound to ``database``'s running loop."""
-    loop = asyncio.get_running_loop()
-    key = (id(database), id(loop))
-    lock = _MIGRATION_LOCKS.get(key)
-    if lock is None:
-        lock = asyncio.Lock()
-        _MIGRATION_LOCKS[key] = lock
-    return lock
-
-
-async def apply_migrations(
-    database: NestQuestDatabase,
-    migrations: Sequence[MigrationStep] = MIGRATIONS,
-) -> int:
-    """Bring the database schema up to the latest version.
-
-    Reads the current version, applies every pending migration in order
-    — each inside one transaction that also stamps the new version —
-    and returns the resulting version.  Applying zero pending
-    migrations (database already current) is a no-op that logs at debug
-    level and opens no write transaction.
-
-    The version is re-read inside each migration transaction before
-    deciding to apply it: the outer read is advisory only (loop bounds,
-    no-op fast path), and on one shared connection two interleaved
-    runners would otherwise both read the same version and both apply
-    a non-idempotent migration.  Under the transaction's lock the
-    second runner sees the first runner's stamp and skips.
-
-    Runners on one connection are serialized by an asyncio lock held
-    for the whole decide-and-apply span: NestQuestDatabase rejects a
-    second transaction while one is active (RuntimeError), so
-    concurrent callers must queue, and the lock makes that queueing
-    explicit.  The loser of the race re-reads the version once it
-    acquires the lock, sees the winner's stamp, and applies nothing.
-
-    Raises whatever the failing migration raised, with the database
-    rolled back to its prior version and prior rows untouched.
-    """
-    async with _migration_lock(database):
-        await _create_version_table(database)
-        current = await read_schema_version(database)
-        latest = len(migrations)
-
-        if current > latest:
-            raise RuntimeError(
-                f"Database schema version {current} is newer than this "
-                f"integration understands (latest known: {latest}); "
-                "downgrades are not supported"
-            )
-
-        if current == latest:
-            LOGGER.debug(
-                "NestQuest schema already at version %d; "
-                "no migrations to apply",
-                current,
-            )
-            return current
-
-        for target in range(current + 1, latest + 1):
-            applied = False
-            step = migrations[target - 1]
-            if callable(step):
-                # Callable migrations own their transaction: some steps
-                # (table rebuilds) must run connection pragmas such as
-                # ``foreign_keys = OFF`` BEFORE opening one, which the
-                # runner's uniform transaction cannot express, and they
-                # stamp inside their own transaction so a failure rolls
-                # the statements and the version stamp back together.
-                # The version is re-read here under the migration lock:
-                # runners on one connection are serialized by it, so
-                # the version cannot change between this read and the
-                # callable's commit.
-                in_tx_version = await read_schema_version(database)
-                if in_tx_version > latest:
-                    raise RuntimeError(
-                        f"Database schema version {in_tx_version} is newer "
-                        f"than this integration understands (latest known: "
-                        f"{latest}); downgrades are not supported"
-                    )
-                if in_tx_version < target:
-                    await step(database, target)
-                    applied = True
-            else:
-                async with database.transaction():
-                    # Re-read the version INSIDE the write transaction:
-                    # the outer read was advisory, and the wrapper
-                    # serializes individual statements, not the
-                    # read-decide-apply decision.  Under the
-                    # transaction's lock the version cannot change
-                    # between the read and the stamp, and the loser of
-                    # an interleaved race (a queued second caller
-                    # re-running apply_migrations after the winner
-                    # already migrated) re-reads here, sees the
-                    # winner's stamp, and skips instead of re-applying
-                    # a non-idempotent migration with a stale version.
-                    in_tx_version = await read_schema_version(database)
-                    if in_tx_version > latest:
-                        raise RuntimeError(
-                            f"Database schema version {in_tx_version} is "
-                            f"newer than this integration understands "
-                            f"(latest known: {latest}); downgrades are "
-                            f"not supported"
-                        )
-                    if in_tx_version < target:
-                        for sql in step:
-                            await database.execute(sql)
-                        await stamp_schema_version(database, target)
-                        applied = True
-                        applied_statements = len(step)
-            if applied:
-                LOGGER.info(
-                    "NestQuest schema migrated to version %d",
-                    target,
-                )
-
-        return latest

custom_components/nestquest/options_flow.py

@@ -7,19 +7,15 @@ from typing import Any
 import voluptuous as vol
 from homeassistant import config_entries
 from homeassistant.data_entry_flow import FlowResult
-from homeassistant.helpers import config_validation as cv
 
 from .const import (
-    CONF_ADMIN_USER_IDS,
     CONF_DAY_ROLLOVER_TIME,
     CONF_HORIZON_DAYS,
     CONF_PANEL_IDLE_TIMEOUT,
     DEFAULT_DAY_ROLLOVER_TIME,
     DEFAULT_HORIZON_DAYS,
     DEFAULT_PANEL_IDLE_TIMEOUT,
-    DOMAIN,
 )
-from .admin_allowlist import list_admin_ids, set_admin_ids
 
 MIN_HORIZON_DAYS = 1
 MIN_PANEL_IDLE_TIMEOUT = 30
@@ -59,168 +55,51 @@ def _async_validate(user_input: dict[str, Any]) -> dict[str, str]:
     return errors
 
 
-def _build_schema(
-    current: dict[str, Any],
-    *,
-    admin_choices: dict[str, str] | None = None,
-    admin_default: list[str] | None = None,
-) -> vol.Schema:
-    """Build the form schema, pre-filled with the current values.
-
-    The admin picker is a multi-select of EXISTING Home Assistant users
-    (never a free-text field — the allowlist stores user IDs); its
-    default is the current database allowlist, so an untouched submit
-    re-saves exactly who is already allowed.
-    """
-    fields: dict[Any, Any] = {
-        vol.Required(
-            CONF_HORIZON_DAYS, default=current[CONF_HORIZON_DAYS]
-        ): int,
-        vol.Required(
-            CONF_DAY_ROLLOVER_TIME, default=current[CONF_DAY_ROLLOVER_TIME]
-        ): str,
-        vol.Required(
-            CONF_PANEL_IDLE_TIMEOUT, default=current[CONF_PANEL_IDLE_TIMEOUT]
-        ): int,
-    }
-    if admin_choices is not None:
-        # HA's supported multi-select validator: the frontend can
-        # serialize the field as a real picker of the given choices.
-        fields[
-            vol.Optional(
-                CONF_ADMIN_USER_IDS, default=list(admin_default or [])
-            )
-        ] = cv.multi_select(admin_choices)
-    return vol.Schema(fields)
+def _build_schema(current: dict[str, Any]) -> vol.Schema:
+    """Build the form schema, pre-filled with the current values."""
+    return vol.Schema(
+        {
+            vol.Required(
+                CONF_HORIZON_DAYS, default=current[CONF_HORIZON_DAYS]
+            ): int,
+            vol.Required(
+                CONF_DAY_ROLLOVER_TIME, default=current[CONF_DAY_ROLLOVER_TIME]
+            ): str,
+            vol.Required(
+                CONF_PANEL_IDLE_TIMEOUT, default=current[CONF_PANEL_IDLE_TIMEOUT]
+            ): int,
+        }
+    )
 
 
 class NestQuestOptionsFlow(config_entries.OptionsFlowWithConfigEntry):
     """Handle the options flow for NestQuest."""
 
-    def _async_database(self):
-        """Return the runtime database for this entry, or None.
-
-        Real HA only opens the options flow for an existing entry, so
-        the runtime record (and its database) exists; the None branch
-        covers direct construction in tests and degraded states.
-        """
-        hass_data = getattr(self.hass, "data", None)
-        if not isinstance(hass_data, dict):
-            return None
-        record = hass_data.get(DOMAIN, {}).get(self.config_entry.entry_id)
-        database = getattr(record, "database", None)
-        return database if getattr(database, "connected", False) else None
-
-    async def _async_admin_choices(self) -> dict[str, str]:
-        """Map HA user id -> display name for the picker.
-
-        Real Home Assistant always provides ``hass.auth``; a missing
-        one (direct construction in tests, degraded harness) degrades
-        to an empty picker rather than crashing the form.
-        """
-        auth = getattr(self.hass, "auth", None)
-        if auth is None:
-            return {}
-        users = await auth.async_get_users()
-        return {
-            user.id: user.name
-            for user in users
-            if getattr(user, "id", None)
-        }
-
-    async def _async_current_admin_ids(self) -> list[str]:
-        """Return the current allowlist, or [] without a database."""
-        database = self._async_database()
-        if database is None:
-            return []
-        return await list_admin_ids(database)
-
     async def async_step_init(
         self, user_input: dict[str, Any] | None = None
     ) -> FlowResult:
         """Manage the NestQuest options."""
-        admin_choices = await self._async_admin_choices()
-        admin_default = await self._async_current_admin_ids()
         if user_input is None:
             return self.async_show_form(
-                step_id="init",
-                data_schema=_build_schema(
-                    self._current_values(),
-                    admin_choices=admin_choices,
-                    admin_default=admin_default,
-                ),
+                step_id="init", data_schema=_build_schema(self._current_values())
             )
 
         errors = _async_validate(user_input)
-        # The admin ids are validated only when the key is present:
-        # schema-validated submits always carry it (vol.Optional's
-        # default fills from the current allowlist), while raw callers
-        # omitting the key keep the field untouched.
-        admin_ids_present = CONF_ADMIN_USER_IDS in user_input
-        admin_ids = user_input.get(CONF_ADMIN_USER_IDS)
         if errors:
             return self.async_show_form(
                 step_id="init",
-                data_schema=_build_schema(
-                    self._current_values(),
-                    admin_choices=admin_choices,
-                    admin_default=admin_default,
-                ),
-                errors=errors,
-            )
-        if admin_ids_present and (
-            not isinstance(admin_ids, list)
-            or any(not isinstance(value, str) for value in admin_ids)
-        ):
-            errors[CONF_ADMIN_USER_IDS] = "invalid_admin"
-        elif admin_ids_present and not admin_ids:
-            # An empty allowlist fails closed: saving zero admins is
-            # refused, never silently applied.
-            errors[CONF_ADMIN_USER_IDS] = "no_admins"
-        elif admin_ids_present and any(
-            value not in admin_choices for value in admin_ids
-        ):
-            # The schema enforces membership for real HA submits; this
-            # backs the raw-input path up so an unknown id can never
-            # reach the allowlist.
-            errors[CONF_ADMIN_USER_IDS] = "invalid_admin"
-        elif admin_ids_present and len(set(admin_ids)) != len(admin_ids):
-            # set_admin_ids refuses duplicates with ValueError; a flow
-            # submission must surface that as a field error instead of
-            # an unhandled crash.
-            errors[CONF_ADMIN_USER_IDS] = "invalid_admin"
-        if errors:
-            return self.async_show_form(
-                step_id="init",
-                data_schema=_build_schema(
-                    self._current_values(),
-                    admin_choices=admin_choices,
-                    admin_default=admin_default,
-                ),
+                data_schema=_build_schema(self._current_values()),
                 errors=errors,
             )
 
-        # Apply the picker's selection to the allowlist when the
-        # runtime database is reachable; the selection is always
-        # stored on the entry as the disaster-recovery copy.
-        database = self._async_database()
-        if database is not None and admin_ids_present:
-            await set_admin_ids(database, admin_ids)
-        data = {
-            CONF_HORIZON_DAYS: user_input[CONF_HORIZON_DAYS],
-            CONF_DAY_ROLLOVER_TIME: user_input[CONF_DAY_ROLLOVER_TIME],
-            CONF_PANEL_IDLE_TIMEOUT: user_input[CONF_PANEL_IDLE_TIMEOUT],
-        }
-        if admin_ids_present:
-            data[CONF_ADMIN_USER_IDS] = admin_ids
-        elif admin_default:
-            # HA replaces entry.options wholesale, so an omitted picker
-            # field must carry the CURRENT allowlist forward: dropping
-            # it would leave only the stale config-flow copy in entry
-            # data, and a later database loss would resurrect admins
-            # the owner has since removed.
-            data[CONF_ADMIN_USER_IDS] = list(admin_default)
-        return self.async_create_entry(title="NestQuest", data=data)
+        return self.async_create_entry(
+            title="NestQuest",
+            data={
+                CONF_HORIZON_DAYS: user_input[CONF_HORIZON_DAYS],
+                CONF_DAY_ROLLOVER_TIME: user_input[CONF_DAY_ROLLOVER_TIME],
+                CONF_PANEL_IDLE_TIMEOUT: user_input[CONF_PANEL_IDLE_TIMEOUT],
+            },
+        )
 
     def _current_values(self) -> dict[str, Any]:
         """Resolve current values from entry options, then entry data, then defaults."""

custom_components/nestquest/presence.py

@@ -1,477 +0,0 @@
-"""The presence and custody model (Feature 05).
-
-PURE module: no Home Assistant imports, no database access, no
-timezone logic — it operates on plain calendar dates only (feature
-guardrail).  The later engine (cycle position, ``is_present``,
-overrides, previews) builds directly on this model.
-
-A :class:`PresenceSchedule` answers "on which weekdays of which cycle
-week is this child at this house?" for an N-week repeating custody
-pattern.  Two of the household's three children follow a two-week
-rotation; a child with NO schedule row is present every day (that
-default lives in the engine, not here).
-
-Pattern encoding: the model's canonical serialization is the SAME
-pipe-separated CSV the database stores (see schema.py's
-``presence_schedules.pattern``): segment ``i`` (week index ``i``) is a
-comma-separated list of present weekdays, 0 = Monday .. 6 = Sunday,
-e.g. ``'0,2,4|1,3'`` = Mon/Wed/Fri in week 0, Tue/Thu in week 1.  An
-empty segment means absent every day of that week.  Encoding sorts
-each segment's weekdays and uses the exact segment order, so
-``decode(encode(schedule))`` round-trips losslessly and two schedules
-with equal patterns produce equal strings.
-
-Anchor-date policy: ``anchor_date`` pins the cycle.  Cycle position is
-computed from anchor-date arithmetic ONLY — never ISO week numbers or
-week parity (D-004): 53-week years silently invert parity on January
-1st.  The arithmetic lives in the engine task; this module validates
-that the anchor is a strict calendar date.
-
-Validation policy: construction is total — every reject happens in
-``__init__`` so no invalid schedule can ever exist:
-- ``cycle_length_weeks`` must be an integer 1..4.  The 4 cap matches
-  the database CHECK (schema.py) and keeps anchor arithmetic and the
-  encoded pattern human-readable; revisit both together if a longer
-  cycle is ever needed.
-- ``pattern`` must cover week indices 0..cycle_length_weeks-1 exactly
-  (no gaps, no extra weeks) with sets of integers 0..6 (bools
-  rejected: True would silently mean Monday).
-- ``anchor_date`` must be a strict ISO YYYY-MM-DD calendar date (or a
-  ``datetime.date``).
-"""
-from __future__ import annotations
-
-import datetime
-from dataclasses import dataclass
-from types import MappingProxyType
-
-#: The schema's documented cap for cycle_length_weeks (schema.py keeps
-#: the pattern human-readable and the anchor arithmetic small).
-MAX_CYCLE_LENGTH_WEEKS = 4
-
-_DATE_FORMAT = "%Y-%m-%d"
-
-
-def _parse_date(value: object, field_name: str) -> datetime.date:
-    """Accept a datetime.date or a strict YYYY-MM-DD string.
-
-    ``datetime.datetime`` is rejected explicitly: it SUBCLASSES
-    datetime.date, so a bare isinstance check would store a value with
-    a time component and every later calendar-date comparison (e.g.
-    ``PresenceOverride.covers``) would raise TypeError.
-    """
-    if isinstance(value, datetime.datetime):
-        raise ValueError(
-            f"{field_name} must be a plain calendar date, not a "
-            f"datetime with a time component: {value!r}"
-        )
-    if isinstance(value, datetime.date):
-        return value
-    if not isinstance(value, str):
-        raise ValueError(
-            f"{field_name} must be a datetime.date or an ISO date string, "
-            f"got {value!r}"
-        )
-    try:
-        parsed = datetime.datetime.strptime(value, _DATE_FORMAT).date()
-    except (TypeError, ValueError):
-        raise ValueError(
-            f"{field_name} must be an ISO date (YYYY-MM-DD), got {value!r}"
-        ) from None
-    if parsed.isoformat() != value:
-        raise ValueError(
-            f"{field_name} must be a strict YYYY-MM-DD date, got {value!r}"
-        )
-    return parsed
-
-
-def _validate_week_index(week: object, cycle_length_weeks: int) -> int:
-    """Reject non-int week indices (bools included) and out-of-cycle."""
-    if isinstance(week, bool) or not isinstance(week, int):
-        raise ValueError(
-            f"pattern week index must be an integer, got {week!r}"
-        )
-    if not 0 <= week < cycle_length_weeks:
-        raise ValueError(
-            f"pattern week index must be in 0..{cycle_length_weeks - 1}, "
-            f"got {week}"
-        )
-    return week
-
-
-def _validate_weekday_set(week: int, weekdays: object) -> frozenset[int]:
-    """Validate one week's present-weekday set."""
-    if isinstance(weekdays, (str, bytes)) or weekdays is None:
-        raise ValueError(
-            f"pattern[{week}] must be an iterable of weekday ints 0..6, "
-            f"got {weekdays!r}"
-        )
-    try:
-        members = list(weekdays)
-    except TypeError:
-        raise ValueError(
-            f"pattern[{week}] must be an iterable of weekday ints 0..6, "
-            f"got {weekdays!r}"
-        ) from None
-    for member in members:
-        if isinstance(member, bool) or not isinstance(member, int):
-            raise ValueError(
-                f"pattern[{week}] weekday must be an int 0..6, got {member!r}"
-            )
-        if not 0 <= member <= 6:
-            raise ValueError(
-                f"pattern[{week}] weekday must be in 0..6 (Monday=0), "
-                f"got {member}"
-            )
-    return frozenset(members)
-
-
-def _validate_cycle_length(value: object) -> int:
-    """Reject non-int and out-of-range cycle lengths (bools included)."""
-    if isinstance(value, bool) or not isinstance(value, int):
-        raise ValueError(
-            f"cycle_length_weeks must be an integer, got {value!r}"
-        )
-    if not 1 <= value <= MAX_CYCLE_LENGTH_WEEKS:
-        raise ValueError(
-            f"cycle_length_weeks must be between 1 and "
-            f"{MAX_CYCLE_LENGTH_WEEKS}, got {value}"
-        )
-    return value
-
-
-def _validate_child_id(value: object) -> int:
-    """Reject non-int child ids (bools would silently address child 1)."""
-    if isinstance(value, bool) or not isinstance(value, int):
-        raise ValueError(f"child_id must be an integer, got {value!r}")
-    return value
-
-
-@dataclass(frozen=True, init=False)
-class PresenceSchedule:
-    """One child's N-week repeating presence pattern.
-
-    ``pattern`` maps each week index of the cycle (``0`` .. ``n-1``)
-    to the set of present weekdays (ints, Monday=0).  A week with an
-    empty set means the child is absent every day of that week — which
-    is distinct from having no schedule at all (the engine treats a
-    missing schedule as present every day).
-    """
-
-    child_id: int
-    cycle_length_weeks: int
-    anchor_date: datetime.date
-    pattern: MappingProxyType  # week index -> frozenset of weekdays
-
-    def __init__(
-        self,
-        child_id: int,
-        cycle_length_weeks: int,
-        anchor_date: object,
-        pattern: dict[int, object],
-    ) -> None:
-        object.__setattr__(self, "child_id", _validate_child_id(child_id))
-        cycle = _validate_cycle_length(cycle_length_weeks)
-        object.__setattr__(self, "cycle_length_weeks", cycle)
-        object.__setattr__(
-            self, "anchor_date", _parse_date(anchor_date, "anchor_date")
-        )
-        if not isinstance(pattern, dict):
-            raise ValueError(
-                "pattern must map week index to a set of present "
-                f"weekdays, got {pattern!r}"
-            )
-        normalised: dict[int, frozenset[int]] = {}
-        for week, weekdays in pattern.items():
-            index = _validate_week_index(week, cycle)
-            normalised[index] = _validate_weekday_set(index, weekdays)
-        missing = [
-            week for week in range(cycle) if week not in normalised
-        ]
-        if missing:
-            raise ValueError(
-                f"pattern must cover week indices 0..{cycle - 1}; "
-                f"missing {missing}"
-            )
-        # Frozen must mean frozen: a bare dict would let callers inject
-        # unvalidated weekdays (or drop required weeks) AFTER
-        # construction, bypassing total validation.  The mapping
-        # proxy exposes the validated contents read-only; the
-        # per-week sets are already frozensets.
-        object.__setattr__(self, "pattern", MappingProxyType(normalised))
-
-    def encode(self) -> str:
-        """Serialize to the database's pipe-separated CSV shape.
-
-        Segments appear in week order; each segment is the week's
-        present weekdays as a sorted comma-separated list (an empty set
-        encodes as an empty segment).  Two schedules with equal
-        patterns encode identically.
-        """
-        segments = [
-            ",".join(str(day) for day in sorted(self.pattern[week]))
-            for week in range(self.cycle_length_weeks)
-        ]
-        return "|".join(segments)
-
-    @classmethod
-    def decode(
-        cls,
-        child_id: int,
-        anchor_date: object,
-        encoded: str,
-    ) -> "PresenceSchedule":
-        """Build a schedule from its encoded pattern.
-
-        The cycle length is derived from the segment count, mirroring
-        the database's segment-count CHECK.  Decoding is strict: wrong
-        shapes, non-numeric or out-of-range weekdays are rejected —
-        the database CHECKs make such rows unrepresentable, and this
-        is the same contract on the model side.  A segment count above
-        the documented cycle cap is rejected by the ordinary
-        construction validation.
-        """
-        if not isinstance(encoded, str):
-            raise ValueError(
-                f"encoded pattern must be a string, got {encoded!r}"
-            )
-        segments = encoded.split("|")
-        pattern: dict[int, set[int]] = {}
-        for week, segment in enumerate(segments):
-            weekdays: set[int] = set()
-            if segment:
-                for part in segment.split(","):
-                    if len(part) != 1 or part not in "0123456":
-                        raise ValueError(
-                            f"encoded segment {week} carries an invalid "
-                            f"weekday {part!r} (single digits 0-6 only)"
-                        )
-                    weekdays.add(int(part))
-            pattern[week] = weekdays
-        return cls(child_id, len(segments), anchor_date, pattern)
-
-
-@dataclass(frozen=True, init=False)
-class PresenceOverride:
-    """A date-specific present/absent flag beating any pattern.
-
-    Covers a single date (``end_date == start_date``) or an inclusive
-    range.  A concrete range is the storage shape
-    (``presence_overrides.end_date`` is NOT NULL), so the model
-    requires both bounds and validates start <= end.  Construction and
-    validation live here so the engine can trust every instance.
-    """
-
-    child_id: int
-    start_date: datetime.date
-    end_date: datetime.date
-    is_present: bool
-    note: str | None
-
-    def __init__(
-        self,
-        child_id: int,
-        start_date: object,
-        end_date: object,
-        is_present: bool,
-        note: str | None = None,
-    ) -> None:
-        object.__setattr__(self, "child_id", _validate_child_id(child_id))
-        start = _parse_date(start_date, "start_date")
-        end = _parse_date(end_date, "end_date")
-        if end < start:
-            raise ValueError(
-                f"end_date must be on or after start_date, got "
-                f"{end.isoformat()} < {start.isoformat()}"
-            )
-        object.__setattr__(self, "start_date", start)
-        object.__setattr__(self, "end_date", end)
-        if not isinstance(is_present, bool):
-            raise ValueError(
-                f"is_present must be a real bool, got {is_present!r}"
-            )
-        object.__setattr__(self, "is_present", is_present)
-        if note is not None and not isinstance(note, str):
-            raise ValueError(f"note must be a string or None, got {note!r}")
-        object.__setattr__(self, "note", note)
-
-    def covers(self, date: datetime.date) -> bool:
-        """Return True when the override applies to ``date``."""
-        return self.start_date <= date <= self.end_date
-
-
-def cycle_week_index(
-    schedule: PresenceSchedule, target_date: object
-) -> int:
-    """Return the cycle week index ``target_date`` falls in.
-
-    Anchor-date arithmetic ONLY (D-004): ``((target_date -
-    anchor_date).days // 7) % cycle_length_weeks``.  Python's floor
-    division makes dates BEFORE the anchor behave correctly — they
-    walk the cycle backwards (day -1 is the last week of the cycle,
-    day -8 wraps one further) instead of inverting, which is exactly
-    what ISO week parity does wrong in 53-week years.  The modulo of
-    a negative in Python is non-negative, so the index is always a
-    valid week index.
-    """
-    target = _parse_date(target_date, "target_date")
-    days = (target - schedule.anchor_date).days
-    return (days // 7) % schedule.cycle_length_weeks
-
-
-#: Search cap for :meth:`PresenceEngine.next_present_dates`: two full
-#: years of daily checks.  A child absent every day (an all-absent
-#: pattern with a blocking override) would otherwise loop forever; the
-#: cap bounds the scan and surfaces the situation as an error instead.
-MAX_PREVIEW_SCAN_DAYS = 366 * 2
-
-
-class PresenceEngine:
-    """Answers "is this child at this house on this date?".
-
-    Pure and side-effect-free: built from an immutable snapshot of the
-    children's schedules (``child_id -> PresenceSchedule``), it never
-    touches the database — callers build a snapshot from the DAO layer
-    and pass it in.  A child with NO schedule entry is present every
-    day (the third household child's case); a child WITH a schedule is
-    present exactly when the date's weekday is in that schedule's
-    pattern for the date's cycle week index (anchor-date arithmetic —
-    :func:`cycle_week_index`, never ISO week parity).
-    """
-
-    def __init__(
-        self,
-        schedules: dict[int, PresenceSchedule],
-        overrides: dict[int, list[PresenceOverride]] | None = None,
-    ) -> None:
-        if not isinstance(schedules, dict):
-            raise ValueError(
-                f"schedules must map child_id to PresenceSchedule, got "
-                f"{schedules!r}"
-            )
-        for child_id, schedule in schedules.items():
-            # Validate the KEY as a model child id too: True and 1.0
-            # compare equal to 1, so {True: schedule(1)} would be
-            # accepted and then behave differently on lookup.
-            _validate_child_id(child_id)
-            if not isinstance(schedule, PresenceSchedule):
-                raise ValueError(
-                    f"schedules[{child_id!r}] must be a PresenceSchedule, "
-                    f"got {schedule!r}"
-                )
-            if schedule.child_id != child_id:
-                raise ValueError(
-                    f"schedules is keyed {child_id!r} but holds the "
-                    f"schedule of child {schedule.child_id}"
-                )
-        if overrides is None:
-            overrides = {}
-        if not isinstance(overrides, dict):
-            raise ValueError(
-                "overrides must map child_id to a list of "
-                f"PresenceOverride, got {overrides!r}"
-            )
-        for child_id, entries in overrides.items():
-            _validate_child_id(child_id)
-            if not isinstance(entries, list):
-                raise ValueError(
-                    f"overrides[{child_id!r}] must be a list of "
-                    f"PresenceOverride, got {entries!r}"
-                )
-            for entry in entries:
-                if not isinstance(entry, PresenceOverride):
-                    raise ValueError(
-                        f"overrides[{child_id!r}] entries must be "
-                        f"PresenceOverride, got {entry!r}"
-                    )
-                if entry.child_id != child_id:
-                    raise ValueError(
-                        f"overrides is keyed {child_id!r} but holds an "
-                        f"override of child {entry.child_id}"
-                    )
-        # Read-only snapshot: reassignment is refused and no mutator
-        # exists, so a built engine answers consistently for its
-        # lifetime.  The overrides lists are copied to immutable
-        # tuples — a shallow mapping copy alone would leave caller-
-        # owned lists reachable through _overrides, and mutating one
-        # later would change is_present results.
-        object.__setattr__(self, "_schedules", MappingProxyType(dict(schedules)))
-        object.__setattr__(
-            self,
-            "_overrides",
-            MappingProxyType(
-                {child_id: tuple(entries) for child_id, entries in overrides.items()}
-            ),
-        )
-
-    def is_present(self, child_id: object, date: object) -> bool:
-        """Return whether ``child_id`` is present on ``date``.
-
-        Overrides take precedence over the repeating pattern: when an
-        override covers the date, its flag IS the answer — including
-        for a child with no schedule at all.  The DAO layer guarantees
-        a child's overrides never overlap; if a snapshot still carries
-        two covering the same date, the one with the LATEST start date
-        wins (deterministic, and matches "the most specific swap wins").
-        """
-        if isinstance(child_id, bool) or not isinstance(child_id, int):
-            raise ValueError(f"child_id must be an integer, got {child_id!r}")
-        target = _parse_date(date, "date")
-        entries = self._overrides.get(child_id) or []
-        covering = [
-            entry for entry in entries if entry.covers(target)
-        ]
-        if covering:
-            winner = max(covering, key=lambda entry: entry.start_date)
-            return winner.is_present
-        schedule = self._schedules.get(child_id)
-        if schedule is None:
-            # No schedule at all: present every day (household default).
-            return True
-        week = cycle_week_index(schedule, target)
-        return target.weekday() in schedule.pattern[week]
-
-    def next_present_dates(
-        self,
-        child_id: object,
-        start_date: object,
-        count: int,
-    ) -> list[datetime.date]:
-        """Return the next ``count`` dates the child is present.
-
-        Walks forward from ``start_date`` (INCLUSIVE — a parent
-        previewing "starting Monday" expects Monday itself when the
-        child is present) checking :meth:`is_present` for every day,
-        so overrides and the pattern are honoured identically.  The
-        admin Schedule tab renders this preview so a parent can confirm
-        a custody pattern is right before saving it.
-
-        A child absent every scanned day raises ValueError after the
-        two-year search cap — an always-absent child would otherwise
-        loop forever.  ``count`` must be a positive integer.
-        """
-        _validate_child_id(child_id)
-        start = _parse_date(start_date, "start_date")
-        if isinstance(count, bool) or not isinstance(count, int):
-            raise ValueError(f"count must be an integer, got {count!r}")
-        if count < 1:
-            raise ValueError(f"count must be at least 1, got {count}")
-        found: list[datetime.date] = []
-        day = start
-        for _ in range(MAX_PREVIEW_SCAN_DAYS):
-            if self.is_present(child_id, day):
-                found.append(day)
-                if len(found) == count:
-                    return found
-            day += datetime.timedelta(days=1)
-        raise ValueError(
-            f"child {child_id} is not present on any of the "
-            f"{MAX_PREVIEW_SCAN_DAYS} days from {start.isoformat()}; "
-            f"{count} present day(s) cannot be previewed"
-        )
-
-    def __setattr__(self, name: object, value: object) -> None:
-        raise AttributeError(
-            "PresenceEngine is an immutable snapshot; build a new engine "
-            "instead of mutating this one"
-        )

custom_components/nestquest/quest_definitions.py

@@ -1,603 +0,0 @@
-"""Business layer for creating and editing quest definitions (Feature 06).
-
-Sits between the Feature 09 service gate and the typed
-:class:`~.dao_rules.QuestDefinitionsDao`: callers get validation and the
-all-or-nothing create/edit here, and never touch the DAO SQL directly.
-:func:`create_quest_definition` is the create path,
-:func:`edit_quest_definition` the edit path, :func:`assign_child` and
-:func:`unassign_child` the assignment paths, and
-:func:`set_quest_definition_active` the deactivate/reactivate path.
-There is no permission check here (that is Feature 09).
-
-Validation policy mirrors :mod:`.children`:
-
-- ``title`` is required and trimmed; empty or whitespace-only raises
-  ValueError.
-- ``rule`` must be an already-validated :class:`~.recurrence.ScheduleRule`
-  (its constructor is total — rule validation is NOT re-implemented
-  here).
-- ``assignee_child_ids`` must be a non-empty list (strictly a ``list``);
-  every id is a plain int (bools and floats rejected, since SQLite would
-  bind them onto a real child) and must reference an existing ACTIVE
-  child (the DAO enforces the active/exists check inside the same
-  transaction).  Duplicate ids are rejected here, before the composite
-  primary key could surface them as an :class:`sqlite3.IntegrityError`.
-- ``windows`` must be a non-empty list (strictly a ``list``); each entry
-  is a window name from :data:`~.const.QUEST_WINDOWS` — either a bare
-  name (no due time) or a ``(name, due_time)`` pair whose due time is a
-  strict 24-hour HH:MM string.  Duplicate window names are rejected
-  here, before the composite primary key could surface them as an
-  :class:`sqlite3.IntegrityError`.
-
-The rule, definition, assignees and windows are persisted in ONE
-transaction (the DAO's :meth:`~.dao_rules.QuestDefinitionsDao.create_with_rule_and_windows`),
-so a rejected or failed create persists nothing.  The definition-level
-``due_time`` column is superseded by per-window due times (D-008) and is
-never set here.  ``created_at`` is stamped UTC ISO-8601 at second
-precision, matching :mod:`.children`.
-"""
-from __future__ import annotations
-
-import datetime
-from dataclasses import dataclass
-
-from .dao_children import ChildRecord, _connection_lock
-from .dao_rules import (
-    QuestDefinitionRecord,
-    QuestDefinitionSnapshot,
-    QuestDefinitionWindowRecord,
-    QuestDefinitionsDao,
-    ScheduleRuleStorage,
-    ScheduleRulesDao,
-    _UNSET,
-    _validate_date,
-    _validate_time,
-    _validate_window,
-    schedule_rule_from_storage,
-    schedule_rule_storage_from_record,
-    schedule_rule_to_storage,
-)
-from .db import NestQuestDatabase
-from .materialize import regenerate_for_definition
-from .recurrence import ScheduleRule, occurs_on
-
-
-@dataclass(frozen=True)
-class CreatedQuestDefinition:
-    """The persisted result of a create, edit or activation change.
-
-    ``definition`` is the stored row; ``rule`` is the schedule rule
-    decoded back through the storage mapping; ``assignees`` and
-    ``windows`` are the definition's linked child records and window
-    declarations, read through the DAO.
-    """
-
-    definition: QuestDefinitionRecord
-    rule: ScheduleRule
-    assignees: list[ChildRecord]
-    windows: list[QuestDefinitionWindowRecord]
-
-
-def _now_stamp() -> str:
-    """Return the module's strict UTC second-precision stamp."""
-    return datetime.datetime.now(datetime.timezone.utc).isoformat(
-        timespec="seconds"
-    )
-
-
-def _validate_text(
-    value: object, field: str, *, required: bool = False
-) -> str | None:
-    """Validate a free-text field and return it trimmed.
-
-    ``None`` raises when ``required`` and otherwise returns None.  A
-    non-string value is rejected; an empty result is rejected for
-    required fields.
-    """
-    if value is None:
-        if required:
-            raise ValueError(f"{field} is required")
-        return None
-    if not isinstance(value, str):
-        raise ValueError(f"{field} must be a string, got {value!r}")
-    trimmed = value.strip()
-    if required and not trimmed:
-        raise ValueError(f"{field} is required")
-    return trimmed
-
-
-def _validate_assignee_ids(value: object) -> list[int]:
-    """Return the assignee ids as plain ints, or raise naming the field.
-
-    The argument must be a non-empty list — strictly a ``list``: tuples
-    and other sequences are rejected.  Each entry must be a real int
-    (bools and floats rejected) so SQLite cannot bind ``True`` onto
-    child 1 or a float onto a neighbouring profile.
-    """
-    if type(value) is not list:
-        raise ValueError(
-            f"assignee_child_ids must be a list, got {type(value).__name__}"
-        )
-    if not value:
-        raise ValueError("assignee_child_ids must not be empty")
-    ids: list[int] = []
-    for entry in value:
-        if isinstance(entry, bool) or not isinstance(entry, int):
-            raise ValueError(
-                "assignee_child_ids must contain integer child ids, "
-                f"got {entry!r}"
-            )
-        ids.append(entry)
-    if len(set(ids)) != len(ids):
-        raise ValueError(
-            "assignee_child_ids must not contain duplicate child ids"
-        )
-    return ids
-
-
-def _normalize_windows(
-    value: object,
-) -> list[tuple[str, str | None]]:
-    """Normalize the windows argument to ``(name, due_time)`` pairs.
-
-    The outer argument must be a non-empty list — strictly a ``list``:
-    tuples and other sequences are rejected, while each individual entry
-    may still be a ``(window, due_time)`` tuple.  A bare window name
-    (due time None) is also accepted.  The name must be a
-    :data:`~.const.QUEST_WINDOWS` spelling and a present due time must be
-    a strict 24-hour HH:MM, both validated up front so a malformed
-    window is rejected before any write.
-    """
-    if type(value) is not list:
-        raise ValueError(
-            f"windows must be a list, got {type(value).__name__}"
-        )
-    if not value:
-        raise ValueError("windows must not be empty")
-    normalized: list[tuple[str, str | None]] = []
-    seen: set[str] = set()
-    for index, entry in enumerate(value):
-        if isinstance(entry, str):
-            name: object = entry
-            due_time: object = None
-        elif isinstance(entry, (tuple, list)) and len(entry) == 2:
-            name, due_time = entry[0], entry[1]
-        else:
-            raise ValueError(
-                f"windows[{index}] must be a window name or a "
-                f"(name, due_time) pair, got {entry!r}"
-            )
-        _validate_window(name)
-        if due_time is not None:
-            _validate_time(due_time, "due_time")
-        if name in seen:
-            raise ValueError(
-                f"windows must not contain duplicate window {name!r}"
-            )
-        seen.add(name)
-        normalized.append((name, due_time))
-    return normalized
-
-
-def _validate_definition_id(value: object) -> int:
-    """Reject non-int definition ids (bools included) before any lookup.
-
-    SQLite binds Python bools as integers, so ``True`` would silently
-    address definition 1 and a float would round — malformed service
-    input must never mutate the wrong definition.
-    """
-    if isinstance(value, bool) or not isinstance(value, int):
-        raise ValueError(f"definition_id must be an integer, got {value!r}")
-    return value
-
-
-def _validate_child_id(value: object) -> int:
-    """Reject non-int child ids (bools included) before any lookup.
-
-    SQLite binds Python bools as integers, so ``True`` would silently
-    address child 1 and a float would round — malformed service input
-    must never mutate the wrong profile.
-    """
-    if isinstance(value, bool) or not isinstance(value, int):
-        raise ValueError(f"child_id must be an integer, got {value!r}")
-    return value
-
-
-async def create_quest_definition(
-    database: NestQuestDatabase,
-    title: str,
-    rule: ScheduleRule,
-    assignee_child_ids: list[int],
-    windows: list[str | tuple[str, str | None]],
-    *,
-    description: str | None = None,
-    icon: str | None = None,
-) -> CreatedQuestDefinition:
-    """Create a quest definition (rule + assignees + windows) atomically.
-
-    Validates the arguments up front, then persists the schedule rule,
-    the definition, its assignees and its windows in one transaction via
-    the DAO.  Returns the stored definition together with its decoded
-    rule, assignees and windows — all read back inside that same
-    transaction, so the returned bundle is a consistent creation
-    snapshot.  Raises ValueError on any rejected argument; a rejected or
-    failed create persists nothing.
-    """
-    name = _validate_text(title, "title", required=True)
-    assert name is not None
-    if not isinstance(rule, ScheduleRule):
-        raise ValueError(f"rule must be a ScheduleRule, got {rule!r}")
-    assignee_ids = _validate_assignee_ids(assignee_child_ids)
-    window_specs = _normalize_windows(windows)
-    description_value = _validate_text(description, "description")
-    icon_value = _validate_text(icon, "icon")
-
-    storage = schedule_rule_to_storage(rule)
-    dao = QuestDefinitionsDao(database)
-    try:
-        snapshot = await dao.create_with_rule_and_windows(
-            name,
-            storage,
-            _now_stamp(),
-            assignee_ids,
-            window_specs,
-            description=description_value,
-            icon=icon_value,
-        )
-    except ValueError as error:
-        # The DAO's assignee check names only the child; re-raise so the
-        # public contract names the field the caller actually passed.
-        message = str(error)
-        if message.startswith("child "):
-            raise ValueError(
-                f"assignee_child_ids: {message}"
-            ) from error
-        raise
-    decoded_rule = schedule_rule_from_storage(storage)
-    return CreatedQuestDefinition(
-        definition=snapshot.definition,
-        rule=decoded_rule,
-        assignees=snapshot.assignees,
-        windows=snapshot.windows,
-    )
-
-
-async def edit_quest_definition(
-    database: NestQuestDatabase,
-    definition_id: int,
-    *,
-    title: str | object = _UNSET,
-    description: str | None | object = _UNSET,
-    icon: str | None | object = _UNSET,
-    rule: ScheduleRule | object = _UNSET,
-    windows: list[str | tuple[str, str | None]] | object = _UNSET,
-    today: datetime.date | None = None,
-    horizon_days: int | None = None,
-) -> CreatedQuestDefinition:
-    """Edit a quest definition's metadata, rule and windows atomically.
-
-    Arguments default to the sentinel ``_UNSET`` meaning "leave this
-    field alone".  A provided ``title`` is validated like create's
-    (required and trimmed); ``description`` and ``icon`` are optional
-    and may be cleared by passing ``None`` explicitly.  A provided
-    ``rule`` must be an already-validated :class:`~.recurrence.ScheduleRule`
-    and REPLACES the definition's schedule rule IN PLACE — the existing
-    ``schedule_rules`` row is updated, never orphaned or duplicated.  A
-    provided ``windows`` list REPLACES the whole window set (each entry
-    a ``const.QUEST_WINDOWS`` name, optionally with a strict HH:MM due
-    time), matching create's non-empty contract.  Assignment is NOT
-    settable here.  Raises ValueError when the definition does not
-    exist or any argument is rejected.
-
-    Returns the updated definition together with its decoded rule,
-    assignees and windows — all read back inside the DAO's transaction,
-    so the returned bundle is a consistent edit snapshot.  Edits change
-    future instances only; no ``quest_instances`` or
-    ``completion_events`` row is touched.
-
-    ``today`` optionally pins the caller-resolved HA-local date the
-    regeneration's no-past guard and horizon are anchored to (threaded
-    into :func:`~.materialize.regenerate_for_definition`); it is a plain
-    ``datetime.date`` with no HA import here — the Feature 09 service
-    supplies the hass-derived value.  When omitted, regeneration falls
-    back to the host clock, same as before.  ``horizon_days`` sizes the
-    regeneration's re-materialization window the same way (threaded into
-    :func:`~.materialize.regenerate_for_definition`); it defaults to
-    :data:`~.const.DEFAULT_HORIZON_DAYS` when omitted.
-    """
-    _validate_definition_id(definition_id)
-
-    title_value: str | None | object = _UNSET
-    if title is not _UNSET:
-        name = _validate_text(title, "title", required=True)
-        assert name is not None
-        title_value = name
-
-    description_value: str | None | object = _UNSET
-    if description is not _UNSET:
-        description_value = _validate_text(description, "description")
-
-    icon_value: str | None | object = _UNSET
-    if icon is not _UNSET:
-        icon_value = _validate_text(icon, "icon")
-
-    rule_storage: ScheduleRuleStorage | object = _UNSET
-    if rule is not _UNSET:
-        if not isinstance(rule, ScheduleRule):
-            raise ValueError(f"rule must be a ScheduleRule, got {rule!r}")
-        rule_storage = schedule_rule_to_storage(rule)
-
-    window_specs: list[tuple[str, str | None]] | object = _UNSET
-    if windows is not _UNSET:
-        window_specs = _normalize_windows(windows)
-
-    dao = QuestDefinitionsDao(database)
-    try:
-        snapshot = await dao.edit_definition(
-            definition_id,
-            title=title_value,
-            description=description_value,
-            icon=icon_value,
-            rule=rule_storage,
-            windows=window_specs,
-        )
-    except ValueError as error:
-        # The DAO's missing-definition error names only the id; re-raise
-        # so the public contract names the field the caller passed (matching
-        # assign/unassign/deactivate).
-        message = str(error)
-        if message.startswith("quest definition "):
-            raise ValueError(f"definition_id: {message}") from error
-        raise
-
-    decoded_rule = schedule_rule_from_storage(
-        schedule_rule_storage_from_record(snapshot.rule)
-    )
-
-    await regenerate_for_definition(
-        database, definition_id, today=today, horizon_days=horizon_days
-    )
-
-    return CreatedQuestDefinition(
-        definition=snapshot.definition,
-        rule=decoded_rule,
-        assignees=snapshot.assignees,
-        windows=snapshot.windows,
-    )
-
-
-async def assign_child(
-    database: NestQuestDatabase,
-    definition_id: int,
-    child_id: int,
-    *,
-    today: datetime.date | None = None,
-    horizon_days: int | None = None,
-) -> list[ChildRecord]:
-    """Assign ``child_id`` to the definition (idempotent).
-
-    Validates that both ids are plain ints (bools and floats rejected)
-    and that the child exists and is active — the DAO enforces the
-    active/exists check inside its transaction, and also confirms the
-    definition exists.  Assigning an already-assigned child is a no-op
-    (no duplicate row).  Returns the definition's assignees read back
-    inside the DAO's same transaction, a consistent post-assignment
-    roster (a concurrent assign/unassign cannot race it after the
-    write).  Raises ValueError on any rejected argument.  Only the
-    ``quest_definition_assignees`` link is written; existing instances
-    and completion history are never touched.
-
-    ``today`` optionally pins the caller-resolved HA-local date threaded
-    into the assignment's regeneration (see :func:`edit_quest_definition`).
-    ``horizon_days`` optionally sizes the regeneration's re-materialization
-    window the same way.
-    """
-    _validate_definition_id(definition_id)
-    _validate_child_id(child_id)
-    dao = QuestDefinitionsDao(database)
-    try:
-        assignees = await dao.add_assignee(definition_id, child_id)
-    except ValueError as error:
-        # The DAO names only the child/definition; re-raise so the
-        # public contract names the field the caller actually passed.
-        message = str(error)
-        if message.startswith("child "):
-            raise ValueError(f"child_id: {message}") from error
-        if message.startswith("quest definition "):
-            raise ValueError(f"definition_id: {message}") from error
-        raise
-    await regenerate_for_definition(
-        database, definition_id, today=today, horizon_days=horizon_days
-    )
-    return assignees
-
-
-async def unassign_child(
-    database: NestQuestDatabase,
-    definition_id: int,
-    child_id: int,
-    *,
-    today: datetime.date | None = None,
-    horizon_days: int | None = None,
-) -> bool:
-    """Unassign ``child_id`` from the definition; True when removed.
-
-    Validates both ids are plain ints (bools and floats rejected) and
-    that the definition exists, then removes the (definition, child)
-    link.  Returns True when a row was removed and False when the child
-    was not currently assigned.  Raises ValueError on a rejected
-    argument.  Only the ``quest_definition_assignees`` link is written;
-    existing instances and completion history are never touched.
-
-    ``today`` optionally pins the caller-resolved HA-local date threaded
-    into the unassignment's regeneration (see :func:`edit_quest_definition`).
-    ``horizon_days`` optionally sizes the regeneration's re-materialization
-    window the same way.
-    """
-    _validate_definition_id(definition_id)
-    _validate_child_id(child_id)
-    dao = QuestDefinitionsDao(database)
-    definition = await dao.get(definition_id)
-    if definition is None:
-        raise ValueError(
-            f"definition_id: quest definition {definition_id} does not exist"
-        )
-    removed = await dao.remove_assignee(definition_id, child_id)
-    await regenerate_for_definition(
-        database, definition_id, today=today, horizon_days=horizon_days
-    )
-    return removed
-
-
-async def set_quest_definition_active(
-    database: NestQuestDatabase,
-    definition_id: int,
-    is_active: bool,
-    *,
-    today: datetime.date | None = None,
-    horizon_days: int | None = None,
-) -> CreatedQuestDefinition:
-    """Deactivate or reactivate a definition; returns the updated view.
-
-    Flipping the flag is the only removal path (Feature 06 guardrail):
-    a deactivated definition stops future instance generation but its
-    row, schedule rule, assignees and windows all survive, and existing
-    instances plus completion history are never touched.  Reactivation
-    re-enables future generation; generating or removing instances is
-    Feature 07 and does not happen here.
-
-    ``definition_id`` must be a plain int (bools and floats rejected,
-    since SQLite would bind ``True`` onto definition 1) and
-    ``is_active`` must be a real bool — the DAO's ``int()`` would
-    otherwise silently coerce strings and numerics ("1", 0) into a
-    state the caller never asked for.  Raises ValueError naming the
-    offending field when the id is malformed, ``is_active`` is not a
-    bool, or the definition does not exist.
-
-    Atomicity: the existence check, the UPDATE and the readback of the
-    definition, its rule, assignees and windows all run inside the
-    connection-scoped lock, so the returned bundle is a consistent
-    snapshot that a concurrent mutation cannot race.
-
-    ``today`` optionally pins the caller-resolved HA-local date threaded
-    into the activation change's regeneration (see
-    :func:`edit_quest_definition`).  ``horizon_days`` optionally sizes the
-    regeneration's re-materialization window the same way.
-    """
-    _validate_definition_id(definition_id)
-    if not isinstance(is_active, bool):
-        raise ValueError(f"is_active must be a real bool, got {is_active!r}")
-    async with _connection_lock(database):
-        dao = QuestDefinitionsDao(database)
-        if await dao.get(definition_id) is None:
-            raise ValueError(
-                f"definition_id: quest definition {definition_id} "
-                "does not exist"
-            )
-        await dao.set_active(definition_id, is_active)
-        updated = await dao.get(definition_id)
-        assert updated is not None
-        rule_record = await ScheduleRulesDao(database).get(
-            updated.schedule_rule_id
-        )
-        assert rule_record is not None
-        assignees = await dao.list_assignees(definition_id)
-        windows = await dao.list_windows(definition_id)
-    rule = schedule_rule_from_storage(
-        schedule_rule_storage_from_record(rule_record)
-    )
-    await regenerate_for_definition(
-        database, definition_id, today=today, horizon_days=horizon_days
-    )
-    return CreatedQuestDefinition(
-        definition=updated,
-        rule=rule,
-        assignees=assignees,
-        windows=windows,
-    )
-
-
-def _bundle_snapshot(
-    snapshot: QuestDefinitionSnapshot,
-) -> CreatedQuestDefinition:
-    """Decode a DAO snapshot into the layer's rich view.
-
-    The rule record carried by the snapshot is the one the definition
-    referenced at read time, so decoding it here (rather than re-reading
-    through :class:`~.dao_rules.ScheduleRulesDao`) preserves the
-    coherence the DAO's locked snapshot guarantees: the rule, assignees
-    and windows all come from one atomic read, never three separate ones.
-    """
-    rule = schedule_rule_from_storage(
-        schedule_rule_storage_from_record(snapshot.rule)
-    )
-    return CreatedQuestDefinition(
-        definition=snapshot.definition,
-        rule=rule,
-        assignees=snapshot.assignees,
-        windows=snapshot.windows,
-    )
-
-
-async def list_active_definitions(
-    database: NestQuestDatabase,
-) -> list[CreatedQuestDefinition]:
-    """Return every ACTIVE definition with its decoded rule and links.
-
-    Ordered by rising definition id, matching the DAO's ``list_active``
-    order, so callers get a stable, repeatable sequence.  Each entry is
-    the same rich :class:`CreatedQuestDefinition` snapshot as the rest of
-    the layer: the stored row plus its decoded
-    :class:`~.recurrence.ScheduleRule`, assignees and windows.  The
-    definitions and their links are read by the DAO inside one locked
-    transaction, so each bundle is a coherent snapshot that a concurrent
-    edit cannot interleave.
-    """
-    dao = QuestDefinitionsDao(database)
-    snapshots = await dao.list_snapshots_active()
-    return [_bundle_snapshot(snapshot) for snapshot in snapshots]
-
-
-async def list_definitions_for_child(
-    database: NestQuestDatabase,
-    child_id: int,
-) -> list[CreatedQuestDefinition]:
-    """Return the definitions assigned to ``child_id`` (rich view).
-
-    ``child_id`` must be a plain int (bools and floats rejected, since
-    SQLite would bind ``True`` onto child 1).  Results are ordered by
-    rising definition id, matching ``list_active_definitions`` and
-    ``list_definitions_firing_on``.  Each entry is a
-    :class:`CreatedQuestDefinition` snapshot bundling the definition with
-    its decoded rule, assignees and windows, read atomically by the DAO.
-    """
-    _validate_child_id(child_id)
-    dao = QuestDefinitionsDao(database)
-    snapshots = await dao.list_snapshots_by_child(child_id)
-    bundles = [_bundle_snapshot(snapshot) for snapshot in snapshots]
-    return sorted(bundles, key=lambda bundle: bundle.definition.id)
-
-
-async def list_definitions_firing_on(
-    database: NestQuestDatabase,
-    date: str,
-) -> list[CreatedQuestDefinition]:
-    """Return the ACTIVE definitions whose rule fires on ``date``.
-
-    ``date`` must be a strict ISO calendar date (YYYY-MM-DD); a malformed
-    value raises ValueError naming the field.  Each active definition's
-    stored rule is decoded through the task-1 storage mapping and handed
-    to the recurrence engine's :func:`~.recurrence.occurs_on`; only the
-    definitions whose decoded rule fires on the date are returned, in
-    rising definition-id order, each as the same rich
-    :class:`CreatedQuestDefinition` snapshot as the rest of the layer.
-    The definitions and their rules are read inside one locked
-    transaction, so a bundle can never filter on one rule while
-    presenting another state's windows.
-    """
-    _validate_date(date, "date")
-    target = datetime.datetime.strptime(date, "%Y-%m-%d").date()
-    dao = QuestDefinitionsDao(database)
-    snapshots = await dao.list_snapshots_active()
-    bundles = [_bundle_snapshot(snapshot) for snapshot in snapshots]
-    return [bundle for bundle in bundles if occurs_on(bundle.rule, target)]

custom_components/nestquest/recurrence.py

@@ -1,621 +0,0 @@
-"""The ScheduleRule model: rule types, validation, and serialization.
-
-A :class:`ScheduleRule` describes WHEN a recurring chore fires — a pure
-frozen dataclass with no Home Assistant and no database imports.  The
-evaluation engine (Feature 04) consumes it; the DAO layer (Feature 02)
-serializes its dict form into the ``schedule_rules`` table.
-
-Type model: one enum member per recurrence shape.  ``MONTHLY_DAY``
-("the 15th of every month") and ``MONTHLY_WEEKDAY`` ("the second
-Tuesday of every month") are distinct types rather than one monthly
-type with optional fields, so validation is total: a rule either
-constructs, or raises :class:`RuleValidationError` naming the offending
-field.  Every type carries ONLY the fields its shape needs; carrying
-any other shape's field is a construction error.
-
-Storage mapping (Feature 02, ``schedule_rules`` table): the enum's
-``storage_value`` maps model types onto the schema's CHECK values —
-MONTHLY_DAY and MONTHLY_WEEKDAY both store as ``'monthly'`` and are
-disambiguated by which fields are populated; CUSTOM_DAYS stores as
-``'custom'``.  ``weekday_set`` round-trips as the sorted CSV list the
-table stores (one element for MONTHLY_WEEKDAY, which names the
-position's weekday); ``nth_weekday_weekday`` is a MODEL-ONLY field
-carried through from_dict/to_dict for losslessness and folded into
-``weekday_set`` by the DAO mapping.  ``to_dict``/``from_dict`` are the
-model-side lossless pair; the DB mapping lives in the DAO layer and is
-exercised there.
-
-Validation policy (fail fast at construction — the schema's CHECK
-constraints are a second line of defense, but invalid rules must never
-reach storage):
-
-- ``interval`` >= 1 for every rule.
-- ``weekday_set`` is required for WEEKLY and CUSTOM_DAYS, forbidden
-  elsewhere; entries are 0 (Monday) .. 6 (Sunday), no booleans.
-- ``day_of_month`` 1..31 is required for MONTHLY_DAY.
-- ``nth_weekday`` 1..5 or -1 (0 is meaningless as a position and is
-  rejected) with a weekday 0..6 for MONTHLY_WEEKDAY.
-- ``month`` 1..12 is required for YEARLY.
-- ``start_date`` is a strict ISO date; ``end_date`` is optional and,
-  when present, on or after ``start_date``.
-
-Month-end policy (implemented in :func:`_occurs_monthly_day` and
-documented for Feature 04): in each interval-eligible month, a
-MONTHLY_DAY rule for a day that does not exist in that month — the
-31st in April, the 30th or 29th in February, February 29th in a
-non-leap year — fires on the LAST day of the month instead of being
-skipped.  A monthly chore still happens in every eligible month,
-pinned to the month's end when its nominal date is absent; exactly one
-day per eligible month matches the rule (nominal day when it exists,
-month end when it does not).  The interval anchors on nominal months
-elapsed from start_date's month, so clamping never shifts the cadence.
-"""
-from __future__ import annotations
-
-import datetime
-import enum
-from dataclasses import dataclass, field
-
-#: Date-shape policy: strict YYYY-MM-DD, matching the DAO layers.
-_DATE_FORMAT = "%Y-%m-%d"
-
-#: Weekday-name policy: 0 = Monday .. 6 = Sunday (ISO order).
-
-
-class RuleType(enum.Enum):
-    """The six recurrence shapes the engine supports.
-
-    ``storage_value`` is the string written to the ``schedule_rules``
-    table's ``rule_type`` column (its CHECK whitelist).  MONTHLY_DAY
-    and MONTHLY_WEEKDAY are distinct shapes sharing one storage value,
-    disambiguated by which fields are populated.
-    """
-
-    DAILY = "daily"
-    WEEKLY = "weekly"
-    MONTHLY_DAY = "monthly_day"
-    MONTHLY_WEEKDAY = "monthly_weekday"
-    YEARLY = "yearly"
-    CUSTOM_DAYS = "custom_days"
-
-    @property
-    def storage_value(self) -> str:
-        """The schema-level rule_type string this model type maps to."""
-        return {
-            RuleType.DAILY: "daily",
-            RuleType.WEEKLY: "weekly",
-            RuleType.MONTHLY_DAY: "monthly",
-            RuleType.MONTHLY_WEEKDAY: "monthly",
-            RuleType.YEARLY: "yearly",
-            RuleType.CUSTOM_DAYS: "custom",
-        }[self]
-
-
-class RuleValidationError(ValueError):
-    """Raised when a ScheduleRule field combination is invalid."""
-
-
-def _validate_date(value: str, field_name: str) -> None:
-    """Raise unless ``value`` is a strict YYYY-MM-DD calendar date."""
-    try:
-        parsed = datetime.datetime.strptime(value, _DATE_FORMAT).date()
-    except (TypeError, ValueError):
-        raise RuleValidationError(
-            f"{field_name} must be an ISO date (YYYY-MM-DD), got {value!r}"
-        ) from None
-    if parsed.isoformat() != value:
-        raise RuleValidationError(
-            f"{field_name} must be a strict YYYY-MM-DD date, got {value!r}"
-        )
-
-
-def _validate_weekday_set(weekday_set) -> frozenset[int]:
-    """Return a normalized frozenset or raise with a clear message.
-
-    Sequence entries are validated BEFORE set() coercion: a list like
-    [0, False] must not collapse the boolean into 0, and unhashable
-    entries must raise RuleValidationError, never a raw TypeError.
-    """
-    if isinstance(weekday_set, (list, tuple)):
-        for entry in weekday_set:
-            # _is_plain_int: bool and int subclasses (potentially
-            # unhashable) are rejected before set() coercion.
-            if not _is_plain_int(entry):
-                raise RuleValidationError(
-                    f"weekday_set entries must be plain integers, got "
-                    f"{entry!r}"
-                )
-        weekday_set = set(weekday_set)
-    if not isinstance(weekday_set, (set, frozenset)):
-        raise RuleValidationError(
-            f"weekday_set must be a set of weekday integers, got "
-            f"{type(weekday_set).__name__}"
-        )
-    if not weekday_set:
-        raise RuleValidationError(
-            "weekday_set must not be empty for weekly/custom rules"
-        )
-    for entry in weekday_set:
-        if not _is_plain_int(entry):
-            raise RuleValidationError(
-                f"weekday_set entries must be plain integers, got "
-                f"{entry!r}"
-            )
-        if not 0 <= entry <= 6:
-            raise RuleValidationError(
-                f"weekday_set entries must be 0 (Monday)..6 (Sunday), "
-                f"got {entry!r}"
-            )
-    return frozenset(weekday_set)
-
-
-def _is_plain_int(value) -> bool:
-    """True only for real ints: bool excluded AND int subclasses too
-    (an unhashable int subclass would break the frozen-hashable model)."""
-    return type(value) is int
-
-
-def _validate_monthly_weekday(nth_weekday, weekday) -> None:
-    """Validate the MONTHLY_WEEKDAY position fields."""
-    if nth_weekday is None or not _is_plain_int(nth_weekday):
-        raise RuleValidationError(
-            "nth_weekday must be an integer for monthly_weekday rules, "
-            f"got {nth_weekday!r}"
-        )
-    if not (-1 <= nth_weekday <= 5) or nth_weekday == 0:
-        raise RuleValidationError(
-            f"nth_weekday must be -1 (last) or 1..5, got {nth_weekday!r}"
-        )
-    if weekday is None or not _is_plain_int(weekday) or not 0 <= weekday <= 6:
-        raise RuleValidationError(
-            f"monthly_weekday rules require a weekday 0 (Monday)..6 "
-            f"(Sunday), got {weekday!r}"
-        )
-
-
-
-
-
-@dataclass(frozen=True)
-class ScheduleRule:
-    """An immutable, validated recurrence rule (see module docstring).
-
-    Construct with keyword arguments; invalid combinations raise
-    :class:`RuleValidationError` at construction time.  Fields map
-    one-to-one onto the ``schedule_rules`` table columns, with
-    ``nth_weekday_weekday`` as the model-only weekday companion to
-    ``nth_weekday`` (serialized inside ``weekday_set`` at the DAO
-    boundary).
-    """
-
-    rule_type: RuleType
-    interval: int = 1
-    weekday_set: frozenset[int] | None = None
-    day_of_month: int | None = None
-    nth_weekday: int | None = None
-    nth_weekday_weekday: int | None = None
-    month: int | None = None
-    start_date: str = "1970-01-01"
-    end_date: str | None = None
-
-    def __post_init__(self) -> None:
-        # Normalize a string rule_type into the enum; anything else
-        # that is not already a RuleType is rejected.
-        if isinstance(self.rule_type, str):
-            # EXACT model names only: no whitespace stripping, no storage
-            # aliases.  The DAO maps storage strings to model fields when
-            # reading rows; the model boundary stays unambiguous.
-            candidates = {rt.name.lower(): rt for rt in RuleType}
-            if self.rule_type in candidates:
-                object.__setattr__(
-                    self, "rule_type", candidates[self.rule_type]
-                )
-            else:
-                raise RuleValidationError(
-                    f"rule_type must be a RuleType or one of "
-                    f"{sorted(candidates)}, got {self.rule_type!r}"
-                )
-        if not isinstance(self.rule_type, RuleType):
-            raise RuleValidationError(
-                f"rule_type must be a RuleType or one of its string "
-                f"values, got {self.rule_type!r}"
-            )
-        if not _is_plain_int(self.interval):
-            raise RuleValidationError(
-                f"interval must be an integer >= 1, got {self.interval!r}"
-            )
-        if self.interval < 1:
-            raise RuleValidationError(
-                f"interval must be >= 1, got {self.interval!r}"
-            )
-
-        _validate_date(self.start_date, "start_date")
-        if self.end_date is not None:
-            _validate_date(self.end_date, "end_date")
-            if self.end_date < self.start_date:
-                raise RuleValidationError(
-                    f"end_date {self.end_date!r} must be on or after "
-                    f"start_date {self.start_date!r}"
-                )
-
-        # Type-exclusive field policy, enforced for every type: build
-        # the dict of present fields, then reject every field the shape
-        # must not carry (weekday_set present is detectable via None vs
-        # set even after normalization below).
-        shape = self.rule_type
-        if shape is RuleType.DAILY:
-            forbidden_fields = (
-                "weekday_set",
-                "day_of_month",
-                "nth_weekday",
-                "nth_weekday_weekday",
-                "month",
-            )
-        elif shape is RuleType.WEEKLY:
-            forbidden_fields = (
-                "day_of_month",
-                "nth_weekday",
-                "nth_weekday_weekday",
-                "month",
-            )
-        elif shape is RuleType.CUSTOM_DAYS:
-            forbidden_fields = (
-                "day_of_month",
-                "nth_weekday",
-                "nth_weekday_weekday",
-                "month",
-            )
-        elif shape is RuleType.MONTHLY_DAY:
-            forbidden_fields = ("weekday_set", "nth_weekday",
-                                "nth_weekday_weekday", "month")
-        elif shape is RuleType.MONTHLY_WEEKDAY:
-            forbidden_fields = ("weekday_set", "day_of_month", "month")
-        elif shape is RuleType.YEARLY:
-            forbidden_fields = (
-                "weekday_set",
-                "nth_weekday",
-                "nth_weekday_weekday",
-            )
-        present_forbidden = [
-            name
-            for name in forbidden_fields
-            if getattr(self, name) is not None
-        ]
-        if present_forbidden:
-            raise RuleValidationError(
-                f"{shape.value} rules must not set "
-                f"{', '.join(sorted(present_forbidden))}"
-            )
-
-        # Required fields per shape.
-        if shape is RuleType.WEEKLY or shape is RuleType.CUSTOM_DAYS:
-            normalized = _validate_weekday_set(self.weekday_set)
-            object.__setattr__(self, "weekday_set", normalized)
-        elif shape is RuleType.MONTHLY_DAY:
-            if self.day_of_month is None or not _is_plain_int(
-                self.day_of_month
-            ):
-                raise RuleValidationError(
-                    "monthly_day rules require day_of_month (1..31)"
-                )
-            if not 1 <= self.day_of_month <= 31:
-                raise RuleValidationError(
-                    f"day_of_month must be 1..31, got {self.day_of_month!r}"
-                )
-        elif shape is RuleType.MONTHLY_WEEKDAY:
-            _validate_monthly_weekday(
-                self.nth_weekday, self.nth_weekday_weekday
-            )
-        elif shape is RuleType.YEARLY:
-            if self.month is None or not _is_plain_int(self.month):
-                raise RuleValidationError(
-                    "yearly rules require month (1..12)"
-                )
-            if not 1 <= self.month <= 12:
-                raise RuleValidationError(
-                    f"month must be 1..12, got {self.month!r}"
-                )
-            if self.day_of_month is not None and not (
-                _is_plain_int(self.day_of_month)
-                and 1 <= self.day_of_month <= 31
-            ):
-                raise RuleValidationError(
-                    f"day_of_month must be 1..31 for yearly rules, got "
-                    f"{self.day_of_month!r}"
-                )
-
-    def to_dict(self) -> dict:
-        """Return the lossless dict form (model-side storage shape).
-
-        ``weekday_set`` serializes as a sorted list; MONTHLY_WEEKDAY's
-        weekday travels inside it (appended) plus
-        ``nth_weekday_weekday`` so the pair round-trips without
-        ambiguity at the model layer.
-        """
-        return {
-            "rule_type": self.rule_type.name.lower(),  # model name
-            "interval": self.interval,
-            "weekday_set": (
-                sorted(self.weekday_set) if self.weekday_set is not None
-                else None
-            ),
-            "day_of_month": self.day_of_month,
-            "nth_weekday": self.nth_weekday,
-            "nth_weekday_weekday": self.nth_weekday_weekday,
-            "month": self.month,
-            "start_date": self.start_date,
-            "end_date": self.end_date,
-        }
-
-    @classmethod
-    def from_dict(cls, data: dict) -> "ScheduleRule":
-        """Rebuild a rule from :meth:`to_dict` output.
-
-        Raises :class:`RuleValidationError` on unknown keys, missing
-        keys, or invalid combinations — never a raw TypeError.
-        """
-        if not isinstance(data, dict):
-            raise RuleValidationError(
-                f"rule data must be a dict, got {type(data).__name__}"
-            )
-        allowed = {
-            "rule_type",
-            "interval",
-            "weekday_set",
-            "day_of_month",
-            "nth_weekday",
-            "nth_weekday_weekday",
-            "month",
-            "start_date",
-            "end_date",
-        }
-        unknown = [key for key in data if key not in allowed]
-        if unknown:
-            raise RuleValidationError(
-                f"unknown rule fields: {sorted(unknown, key=repr)}"
-            )
-        if "rule_type" not in data:
-            raise RuleValidationError("missing required rule field: rule_type")
-        weekday_set = data.get("weekday_set")
-        if isinstance(weekday_set, (list, tuple)):
-            # Validate entries as plain ints BEFORE set() coercion, so a
-            # list like [0, False] cannot collapse False into 0 and an
-            # unhashable/int-subclass entry cannot leak a raw TypeError.
-            for entry in weekday_set:
-                if not _is_plain_int(entry):
-                    raise RuleValidationError(
-                        f"weekday_set entries must be plain integers, got "
-                        f"{entry!r}"
-                    )
-            weekday_set = set(weekday_set)
-        return cls(
-            rule_type=data["rule_type"],
-            interval=data.get("interval", 1),
-            weekday_set=weekday_set,
-            day_of_month=data.get("day_of_month"),
-            nth_weekday=data.get("nth_weekday"),
-            nth_weekday_weekday=data.get("nth_weekday_weekday"),
-            month=data.get("month"),
-            start_date=data.get("start_date", "1970-01-01"),
-            end_date=data.get("end_date"),
-        )
-
-
-# ---------------------------------------------------------------------------
-# Evaluation engine (Feature 04): pure date arithmetic on ScheduleRule
-# ---------------------------------------------------------------------------
-
-
-def _parse_date(value: str) -> datetime.date:
-    """Parse a strict ISO date already validated by the model."""
-    return datetime.datetime.strptime(value, _DATE_FORMAT).date()
-
-
-def _anchor_offset(rule: ScheduleRule, target: datetime.date) -> int:
-    """Day offset from the rule's anchor date to ``target``.
-
-    The anchor for DAILY/WEEKLY-interval arithmetic is start_date: the
-    first day the rule CAN fire.  A negative offset means the target
-    precedes the rule's window entirely.
-    """
-    return (target - _parse_date(rule.start_date)).days
-
-
-def _within_window(rule: ScheduleRule, target: datetime.date) -> bool:
-    """True when ``target`` is inside the rule's [start, end] window."""
-    if target < _parse_date(rule.start_date):
-        return False
-    if rule.end_date is not None and target > _parse_date(rule.end_date):
-        return False
-    return True
-
-
-def _month_end(year: int, month: int) -> int:
-    """The last calendar day of the given month (leap-aware)."""
-    if month == 12:
-        return 31
-    return (datetime.date(year, month + 1, 1)
-            - datetime.timedelta(days=1)).day
-
-
-def _occurs_monthly_day(rule: ScheduleRule, target: datetime.date) -> bool:
-    """MONTHLY_DAY evaluation with the documented month-end policy.
-
-    Policy: in each interval-eligible month, a rule for a day-of-month
-    that does not exist in that month (the 31st in April, the 30th in
-    February, the 29th of February in a non-leap year) fires on the
-    LAST day of that month instead of being skipped — the chore still
-    happens that month, pinned to the month's end when its nominal date
-    is absent.
-
-    The interval anchors on months ELAPSED from start_date's month: the
-    rule fires when the months between the anchor month and the target's
-    month form a multiple of the interval, keeping "every 2 months on
-    the 15th" aligned to the anchor month even when the firing lands on
-    a clamped month-end day.
-    """
-    anchor = _parse_date(rule.start_date)
-    months_elapsed = (
-        (target.year - anchor.year) * 12 + (target.month - anchor.month)
-    )
-    if months_elapsed % rule.interval != 0:
-        return False
-    month_end = _month_end(target.year, target.month)
-    return target.day == min(rule.day_of_month, month_end)
-
-
-def _nth_weekday_of_month(
-    year: int, month: int, weekday: int, nth: int
-) -> int | None:
-    """The day-of-month of the ``nth`` ``weekday``, or None when the
-    month has no such occurrence (``nth`` 5 beyond four occurrences).
-
-    Positive ``nth`` counts forward (1 = first); ``-1`` counts from the
-    end (last occurrence, whatever the total).  Pure calendar math.
-    """
-    if nth == -1:
-        last = datetime.date(year, month, _month_end(year, month))
-        back = (last.weekday() - weekday) % 7
-        return last.day - back
-    first = datetime.date(year, month, 1)
-    first_offset = (weekday - first.weekday()) % 7
-    day = 1 + first_offset + (nth - 1) * 7
-    if day > _month_end(year, month):
-        return None
-    return day
-
-
-def _occurs_monthly_weekday(
-    rule: ScheduleRule, target: datetime.date
-) -> bool:
-    """MONTHLY_WEEKDAY evaluation.
-
-    Fires when the target is the ``nth`` occurrence of
-    ``nth_weekday_weekday`` in its month (1..4 forward, -1 last).  A
-    month with fewer occurrences than ``nth`` (5 on a four-occurrence
-    month) does not fire — n 5 is accepted by the model but skips such
-    months, matching the done-condition.  The interval anchors on
-    nominal months elapsed from start_date's month.
-    """
-    anchor = _parse_date(rule.start_date)
-    months_elapsed = (
-        (target.year - anchor.year) * 12 + (target.month - anchor.month)
-    )
-    if months_elapsed % rule.interval != 0:
-        return False
-    if target.weekday() != rule.nth_weekday_weekday:
-        return False
-    nth_day = _nth_weekday_of_month(
-        target.year, target.month, rule.nth_weekday_weekday, rule.nth_weekday
-    )
-    return nth_day is not None and target.day == nth_day
-
-
-def _occurs_yearly(rule: ScheduleRule, target: datetime.date) -> bool:
-    """YEARLY evaluation with the documented leap-day clamp policy.
-
-    Policy: in each interval-eligible year, the rule fires on
-    ``day_of_month`` of ``month`` when that day exists.  A YEARLY rule
-    for February 29th fires on FEBRUARY 28TH in a non-leap year (the
-    same clamp-as-month-end policy as MONTHLY_DAY: the annual chore
-    still happens every year, pinned to February's end when its
-    nominal date is absent) rather than silently vanishing.  A YEARLY
-    rule with NO day_of_month fires on the first day of ``month``.
-    The interval anchors on years elapsed from start_date's year.
-    """
-    anchor = _parse_date(rule.start_date)
-    years_elapsed = target.year - anchor.year
-    if years_elapsed % rule.interval != 0:
-        return False
-    if target.month != rule.month:
-        return False
-    if rule.day_of_month is None:
-        # Day-less yearly rules fire on the first of the month.
-        return target.day == 1
-    month_end = _month_end(target.year, target.month)
-    return target.day == min(rule.day_of_month, month_end)
-
-
-def occurs_on(rule: ScheduleRule, target: datetime.date) -> bool:
-    """Return True when ``rule`` fires on ``target``.
-
-    Pure function: no I/O, no timezone awareness, no mutation.  Dates
-    are plain calendar dates (Feature 04 guardrail); the caller decides
-    the timezone that produced them.
-    """
-    # Dispatch FIRST: an unimplemented shape must raise loudly even for
-    # dates outside the window, never silently evaluate to False.
-    shape = rule.rule_type
-    if shape not in (
-        RuleType.DAILY, RuleType.WEEKLY, RuleType.CUSTOM_DAYS,
-        RuleType.MONTHLY_DAY, RuleType.MONTHLY_WEEKDAY, RuleType.YEARLY,
-    ):
-        raise NotImplementedError(
-            f"occurs_on for {shape} lands with its own engine task "
-            "(Features 04 task sequence)"
-        )
-    if not _within_window(rule, target):
-        return False
-    if shape is RuleType.DAILY:
-        offset = (target - _parse_date(rule.start_date)).days
-        return offset % rule.interval == 0
-    if shape is RuleType.MONTHLY_DAY:
-        return _occurs_monthly_day(rule, target)
-    if shape is RuleType.MONTHLY_WEEKDAY:
-        return _occurs_monthly_weekday(rule, target)
-    if shape is RuleType.YEARLY:
-        return _occurs_yearly(rule, target)
-    # WEEKLY / CUSTOM_DAYS: whole-week anchoring from start_date, never
-    # ISO week numbers (Feature 04/05 guardrail: 53-week years flip ISO
-    # parity on January 1st; anchor arithmetic does not).
-    anchor = _parse_date(rule.start_date)
-    if shape is RuleType.CUSTOM_DAYS:
-        interval = 1
-    else:
-        interval = rule.interval
-    week_offset = (target - anchor).days // 7
-    if week_offset % interval != 0:
-        return False
-    return target.weekday() in rule.weekday_set
-
-
-def occurrences_between(
-    rule: ScheduleRule, start: str, end: str
-) -> list[str]:
-    """Return every date string in [start, end] the rule fires on.
-
-    Inclusive on both ends.  Raises RuleValidationError on malformed or
-    inverted bounds; a window entirely outside [rule.start_date,
-    rule.end_date] yields an empty list.
-    """
-    if rule.rule_type not in (
-        RuleType.DAILY, RuleType.WEEKLY, RuleType.CUSTOM_DAYS,
-        RuleType.MONTHLY_DAY, RuleType.MONTHLY_WEEKDAY, RuleType.YEARLY,
-    ):
-        raise NotImplementedError(
-            f"occurrences_between for {rule.rule_type} lands with its own "
-            "engine task (Features 04 task sequence)"
-        )
-    _validate_date(start, "start")
-    _validate_date(end, "end")
-    start_date = _parse_date(start)
-    end_date = _parse_date(end)
-    if end_date < start_date:
-        raise RuleValidationError(
-            f"end {end!r} must be on or after start {start!r}"
-        )
-    rule_start = _parse_date(rule.start_date)
-    if end_date < rule_start:
-        return []
-    # Clamp the walk to the rule's own window and the queried range.
-    effective_start = max(start_date, rule_start)
-    effective_end = end_date
-    if rule.end_date is not None:
-        effective_end = min(effective_end, _parse_date(rule.end_date))
-    results: list[str] = []
-    cursor = effective_start
-    while cursor <= effective_end:
-        if occurs_on(rule, cursor):
-            results.append(cursor.isoformat())
-        cursor += datetime.timedelta(days=1)
-    return results

custom_components/nestquest/schema.py

@@ -1,411 +0,0 @@
-"""Declarative schema DDL for the NestQuest SQLite database.
-
-Every v1 table is declared here as plain SQL statements so later schema
-tasks can append their own DDL to :data:`SCHEMA_V1_STATEMENTS` without
-touching this module's tables.  All statements use
-``CREATE TABLE IF NOT EXISTS`` so application is idempotent; the versioned
-migration runner is a separate later concern.
-
-Timestamp policy: all timestamps are UTC ISO-8601 strings, set by the
-caller/DAO rather than a DB default, per the feature guardrails.  No
-``length(created_at) = 25`` CHECK is added: the exact string shape
-produced by callers is not fixed yet (``datetime.isoformat()`` may
-include microseconds, changing the length), so enforcing a fixed length
-here would reject valid values.  Only non-null is enforced for now.
-
-Date policy: ``start_date``/``end_date`` are ISO date strings (YYYY-MM-DD,
-no time component) compared lexically by the ``end_date >= start_date``
-CHECK; due_date/due_time string shapes are caller-validated by the rule
-engine and DAO layers, not by DDL.
-
-``weekday_set`` format: comma-separated weekday integers (CSV), 0 =
-Monday .. 6 = Sunday, e.g. ``'0,2,4'`` for Mon/Wed/Fri.  Chosen over JSON
-because it sorts, compares and parses trivially in SQL.  The format is
-enforced at the DB level: a CHECK matches ``weekday_set`` against GLOB
-patterns for element counts 1..7 of single digits 0-6 (GLOB has no
-repetition quantifier, so the element count is enumerated; more than 7
-elements is impossible for a weekday set).  ``''``, ``'x'``, ``'7'`` and
-``'0,x'`` are all rejected; NULL stays allowed for non-weekly rules.
-This keeps the schema layer storage-only — the DAO layer (tasks
-8c72300c+) does not need its own validator, it can rely on the CHECK.
-
-Type affinity: SQLite applies column affinity on insert, but CHECKs
-still observe text and fractional values ('abc' stays text, '1.5'
-becomes REAL), so every INTEGER column carrying rule semantics carries
-a ``typeof(...) = 'integer'`` guard in its CHECK.
-
-Rule-type coherence: two CHECKs enforce that ``weekly`` carries a
-non-null ``weekday_set``, ``monthly`` carries a ``day_of_month`` or an
-``nth_weekday``, ``yearly`` carries a ``month``, and ``daily``/``custom``
-carry none of the month-specific fields.  Relaxed deliberately: the DDL
-does NOT forbid ``month`` on weekly/monthly rules (an "every 2 weeks"
-rule or a monthly rule could later be pinned to a month) nor extra
-fields on weekly/monthly/yearly rules generally, so the CHECKs only
-reject what the rule engine definitively cannot express now.
-
-Presence pattern format: ``presence_schedules.pattern`` encodes the
-whole N-week repeating cycle in one TEXT column as pipe-separated
-segments, one per week of the cycle: segment ``i`` is a ``weekday_set``
-CSV (same single-digit 0-6 convention as ``schedule_rules.weekday_set``)
-for week ``i``, e.g. ``'0,2,4|1,3'`` = Mon/Wed/Fri in week 0, Tue/Thu in
-week 1.  An empty segment means the child is absent every day of that
-week; a wholly empty pattern with ``cycle_length_weeks = 1`` means
-absent every day of every week, which is distinct from having no
-schedule row at all (a child with no schedule is present every day, per
-the feature guardrails).  Chosen over JSON or per-week rows to stay
-consistent with the CSV ``weekday_set`` convention and fully checkable
-by plain CHECKs.  DB-level validation is pure CHECK, no triggers or
-custom functions: char-class GLOBs reject every character outside
-digits 0-6, comma and pipe; adjacency GLOBs reject empty elements
-(double comma, comma next to a pipe, leading/trailing comma) and
-two-digit runs; a further GLOB rejects contiguous runs of 8+ comma
-separated digits, which caps a segment at 7 elements — the GLOB cannot
-match across a ``|``, so cross-segment boundaries stay safe; and the
-segment count is pinned to ``cycle_length_weeks`` by
-``LENGTH(pattern) - LENGTH(REPLACE(pattern, '|', '')) + 1``.  Per
-weekday_set this is not full CSV-set normalisation (duplicates like
-``'0,0'`` or unsorted sets stay storable, as with ``schedule_rules``);
-the engine treats the segment as a set.  A
-one-row-per-``week_index`` normalization was considered and rejected:
-the flat single-column encoding keeps the done-condition's table shape
-and proved fully checkable with plain CHECKs.
-
-``cycle_length_weeks`` is capped at 4: 2 (alternating weeks) is the
-common case, and a small cap keeps anchor arithmetic and the encoded
-pattern human-readable.  Revisit the cap — and re-run the pattern
-validation matrix in tests — if a longer cycle is ever needed.
-``anchor_date`` is an ISO date string pinning the cycle: the week index
-of a date is (days since anchor) // 7 mod ``cycle_length_weeks``,
-computed by the presence engine (Feature 05) from anchor-date
-arithmetic, never ISO week parity.  Like other date columns it carries
-no shape CHECK, matching the established date policy.
-
-Presence overrides: ``presence_overrides.end_date`` is NOT NULL,
-unlike ``schedule_rules.end_date`` — an override is always a concrete
-date range; a single-day override stores the same date in both columns.
-``is_present`` 0/1 marks the child absent/present for the whole range;
-``note`` is optional free text.
-
-Multi-assignee definitions (D-008): ``quest_definitions`` carries no
-``child_id`` column.  Assignment lives in
-``quest_definition_assignees``, one row per (definition, child) with a
-composite primary key and foreign keys to the definition and the child,
-so "brush teeth" is one definition covering three children.  The
-migration runner rebuilds a pre-D-008 table into this shape and copies
-its single-assignee column across.  The composite primary key makes
-duplicate assignment impossible at the storage layer.
-
-Quest windows (D-008): ``quest_definition_windows`` declares which day
-windows a definition spans — one row per (definition, window), the
-composite primary key making a window idempotent per definition.
-``window`` is CHECK-constrained to the three spellings ``const`` owns;
-``due_time`` optionally pins a due time inside the window and is
-caller-validated (strict HH:MM) by the DAO layer, matching the date
-policy above.  The window clock ranges live in ``const.py``, not here:
-this layer stores what the caller declares and never interprets clocks.
-
-Quest instances: ``quest_instances`` deliberately carries NO completion
-status column.  An instance's current state derives from the latest row
-in ``completion_events`` (Feature 08), so materialization (Feature 07)
-can insert instances without knowing anything about completion and the
-append-only log stays the single source of truth.  ``definition_id``,
-``child_id``, ``due_date`` and ``window`` snapshot the
-materialization-time facts ("why this instance exists"): assignment
-edits and rule edits change future instances only and never rewrite
-these rows.  ``window`` records which declared day window produced the
-instance (D-008), CHECK-constrained to the same three spellings
-``const`` owns.  ``due_time`` snapshots the window's optional due time
-at generation for the same reason — the instance keeps its
-generation-time value even if the definition is edited later.
-``generated_at`` is a caller-set UTC ISO-8601 timestamp per the module
-timestamp policy (no DB default, so a generation batch stamps one
-coherent time).
-
-Uniqueness: the (definition_id, child_id, due_date, window) tuple is
-declared as a table-level ``UNIQUE`` constraint rather than a separate
-``CREATE UNIQUE INDEX`` statement.  SQLite materializes it as an
-implicit unique index (``sqlite_autoindex_quest_instances_1``) — the
-required "unique index prevents duplicate instances" — and the
-constraint form cannot be silently dropped the way a standalone index
-can, so the duplicate door stays shut.  Idempotent materialization keys
-on exactly this tuple: the twice-daily case (one definition, two
-windows, one child, one date) yields two rows and the shared case (one
-definition, three assignees, one window) yields three.  No secondary
-indexes beyond it are declared yet: history and board queries (Features
-08/10/13) should justify their indexes as a later migration once their
-query shapes exist.
-
-No ``ON DELETE`` clauses are declared on any foreign key in this
-module: children and definitions are deactivated, never deleted, so a
-deletion that would orphan instances or events is a bug and must fail
-loudly rather than cascade.
-
-Completion events: ``completion_events`` is strictly append-only.  That
-property is enforced at the DAO layer — the completion-events DAO
-exposes no UPDATE or DELETE path (task a9ea75fc) — and deliberately NOT
-by database triggers, matching the module's no-trigger policy: a RAISE
-trigger would be the one exception to "pure CHECK, no triggers",
-complicate the later migration runner, and still prove nothing (any
-writer can run raw SQL).  ``event_type`` is constrained to
-``completed``/``uncompleted``; a ``missed`` row is intentionally not
-representable — missed is a derived state announced on the HA event bus
-(Feature 10), never an appended event.
-
-``child_id`` is deliberately denormalized (it is also derivable via
-``quest_instances``): history reporting (Feature 13) filters and rates
-per child directly against the log, and the log should stay
-self-describing without joins.
-
-Actor policy: ``actor_source`` distinguishes an authenticated HA user
-(``'user'``, with ``actor_user_id`` holding the HA user id) from a
-panel tap with no user context (``'panel'``, with ``actor_user_id``
-NULL — the tapped child profile is ``actor_child_id``, D-008).  Two
-coherence CHECKs make both shapes non-negotiable: ``'user'`` requires
-``actor_user_id`` and forbids ``actor_child_id``; ``'panel'`` requires
-``actor_child_id`` (the tapped profile) and forbids ``actor_user_id``.
-Other actor sources are rejected; if an unattended system actor is
-ever needed, that is a schema migration, not a silent widening.
-
-On-time policy: ``was_on_time`` is required (integer 0 or 1) for
-``completed`` events — at completion time the due date is known and the
-flag is decidable.  For ``uncompleted`` events the flag is optional:
-Feature 08 decides whether a reversal carries the reversed completion's
-on-time flag or NULL, and the DDL deliberately accepts both rather than
-guessing.
-"""
-from __future__ import annotations
-
-from .db import NestQuestDatabase
-
-#: GLOB patterns matching a valid ``weekday_set`` CSV: one GLOB per
-#: possible element count 1..7 (a weekday set cannot exceed 7 elements).
-#: Each element is a single digit 0-6, separated by a literal comma.
-#: GLOB has no repetition quantifier, so the element count is enumerated.
-#: ``''`` and NULL are deliberately NOT matched: NULL is allowed for
-#: non-weekly rules via a separate ``IS NULL`` arm, and '' is invalid
-#: because weekly rules need at least one weekday.
-WEEKDAY_SET_GLOB_PATTERNS: list[str] = [
-    "[0-6]",
-    "[0-6],[0-6]",
-    "[0-6],[0-6],[0-6]",
-    "[0-6],[0-6],[0-6],[0-6]",
-    "[0-6],[0-6],[0-6],[0-6],[0-6]",
-    "[0-6],[0-6],[0-6],[0-6],[0-6],[0-6]",
-    "[0-6],[0-6],[0-6],[0-6],[0-6],[0-6],[0-6]",
-]
-
-SCHEMA_V1_CHILDREN_DDL: list[str] = [
-    """
-    CREATE TABLE IF NOT EXISTS children (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        display_name TEXT NOT NULL,
-        colour TEXT,
-        avatar_ref TEXT,
-        sort_order INTEGER NOT NULL DEFAULT 0 CHECK (typeof(sort_order) = 'integer'),
-        is_active INTEGER NOT NULL DEFAULT 1 CHECK (typeof(is_active) = 'integer' AND is_active IN (0, 1)),
-        created_at TEXT NOT NULL
-    )
-    """,
-]
-
-SCHEMA_V1_ADMIN_USERS_DDL: list[str] = [
-    """
-    CREATE TABLE IF NOT EXISTS admin_users (
-        ha_user_id TEXT PRIMARY KEY NOT NULL,
-        added_at TEXT NOT NULL
-    )
-    """,
-]
-
-_WEEKDAY_SET_CHECK = " OR ".join(
-    f"weekday_set GLOB '{pattern}'" for pattern in WEEKDAY_SET_GLOB_PATTERNS
-)
-
-SCHEMA_V1_SCHEDULE_RULES_DDL: list[str] = [
-    f"""
-    CREATE TABLE IF NOT EXISTS schedule_rules (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        rule_type TEXT NOT NULL CHECK (rule_type IN ('daily', 'weekly', 'monthly', 'yearly', 'custom')),
-        interval INTEGER NOT NULL DEFAULT 1 CHECK (typeof(interval) = 'integer' AND interval >= 1),
-        weekday_set TEXT CHECK (weekday_set IS NULL OR ({_WEEKDAY_SET_CHECK})),
-        day_of_month INTEGER CHECK (day_of_month IS NULL OR (typeof(day_of_month) = 'integer' AND day_of_month >= 1 AND day_of_month <= 31)),
-        nth_weekday INTEGER CHECK (nth_weekday IS NULL OR (typeof(nth_weekday) = 'integer' AND nth_weekday IN (-1, 1, 2, 3, 4, 5))),
-        month INTEGER CHECK (month IS NULL OR (typeof(month) = 'integer' AND month >= 1 AND month <= 12)),
-        start_date TEXT NOT NULL,
-        end_date TEXT,
-        CHECK (end_date IS NULL OR end_date >= start_date),
-        CHECK (
-            (rule_type = 'weekly' AND weekday_set IS NOT NULL)
-            OR (rule_type = 'monthly' AND (day_of_month IS NOT NULL OR nth_weekday IS NOT NULL))
-            OR (rule_type = 'yearly' AND month IS NOT NULL)
-            OR (rule_type IN ('daily', 'custom') AND day_of_month IS NULL AND nth_weekday IS NULL AND month IS NULL)
-        )
-    )
-    """,
-]
-
-#: Column body of ``quest_definitions``, shared between the v1 DDL
-#: below and the multi-assignee rebuild migration, which must recreate
-#: the table in exactly this shape (D-008: one definition, many
-#: assignees via ``quest_definition_assignees`` — no ``child_id``
-#: column on the definition itself).
-QUEST_DEFINITIONS_TABLE_SQL = """(
-    id INTEGER PRIMARY KEY AUTOINCREMENT,
-    title TEXT NOT NULL,
-    description TEXT,
-    icon TEXT,
-    schedule_rule_id INTEGER NOT NULL REFERENCES schedule_rules(id),
-    due_time TEXT,
-    is_active INTEGER NOT NULL DEFAULT 1 CHECK (typeof(is_active) = 'integer' AND is_active IN (0, 1)),
-    created_at TEXT NOT NULL
-)"""
-
-SCHEMA_V1_QUEST_DEFINITIONS_DDL: list[str] = [
-    f"""
-    CREATE TABLE IF NOT EXISTS quest_definitions {QUEST_DEFINITIONS_TABLE_SQL}
-    """,
-]
-
-SCHEMA_V1_QUEST_DEFINITION_ASSIGNEES_DDL: list[str] = [
-    """
-    CREATE TABLE IF NOT EXISTS quest_definition_assignees (
-        definition_id INTEGER NOT NULL REFERENCES quest_definitions(id),
-        child_id INTEGER NOT NULL REFERENCES children(id),
-        PRIMARY KEY (definition_id, child_id)
-    )
-    """,
-]
-
-SCHEMA_V1_QUEST_DEFINITION_WINDOWS_DDL: list[str] = [
-    """
-    CREATE TABLE IF NOT EXISTS quest_definition_windows (
-        definition_id INTEGER NOT NULL REFERENCES quest_definitions(id),
-        window TEXT NOT NULL CHECK (window IN ('morning', 'afternoon', 'evening')),
-        due_time TEXT,
-        PRIMARY KEY (definition_id, window)
-    )
-    """,
-]
-
-SCHEMA_V1_PRESENCE_SCHEDULES_DDL: list[str] = [
-    f"""
-    CREATE TABLE IF NOT EXISTS presence_schedules (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        child_id INTEGER NOT NULL UNIQUE REFERENCES children(id),
-        cycle_length_weeks INTEGER NOT NULL CHECK (typeof(cycle_length_weeks) = 'integer' AND cycle_length_weeks >= 1 AND cycle_length_weeks <= 4),
-        anchor_date TEXT NOT NULL,
-        pattern TEXT NOT NULL CHECK (
-            NOT pattern GLOB '*[^0-6,|]*'
-            AND NOT pattern GLOB '*[0-6][0-6]*'
-            AND NOT pattern GLOB '*,,*'
-            AND NOT pattern GLOB '*,|*'
-            AND NOT pattern GLOB '*|,*'
-            AND NOT pattern GLOB ',*'
-            AND NOT pattern GLOB '*,'
-            AND NOT pattern GLOB '*[0-6],[0-6],[0-6],[0-6],[0-6],[0-6],[0-6],[0-6]*'
-            AND (LENGTH(pattern) - LENGTH(REPLACE(pattern, '|', '')) + 1) = cycle_length_weeks
-        )
-    )
-    """,
-]
-
-SCHEMA_V1_PRESENCE_OVERRIDES_DDL: list[str] = [
-    """
-    CREATE TABLE IF NOT EXISTS presence_overrides (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        child_id INTEGER NOT NULL REFERENCES children(id),
-        start_date TEXT NOT NULL,
-        end_date TEXT NOT NULL,
-        is_present INTEGER NOT NULL CHECK (typeof(is_present) = 'integer' AND is_present IN (0, 1)),
-        note TEXT,
-        CHECK (end_date >= start_date)
-    )
-    """,
-]
-
-#: Column body of ``quest_instances``, shared between the v1 DDL
-#: below and the instance-key rebuild migration, which must recreate
-#: the table in exactly this shape (D-008: the instance key is
-#: (definition_id, child_id, due_date, window) — one instance per
-#: assigned child per declared window per firing date).
-QUEST_INSTANCES_TABLE_SQL = """(
-    id INTEGER PRIMARY KEY AUTOINCREMENT,
-    definition_id INTEGER NOT NULL REFERENCES quest_definitions(id),
-    child_id INTEGER NOT NULL REFERENCES children(id),
-    window TEXT NOT NULL CHECK (window IN ('morning', 'afternoon', 'evening')),
-    due_date TEXT NOT NULL,
-    due_time TEXT,
-    generated_at TEXT NOT NULL,
-    UNIQUE (definition_id, child_id, due_date, window)
-)"""
-
-SCHEMA_V1_QUEST_INSTANCES_DDL: list[str] = [
-    f"""
-    CREATE TABLE IF NOT EXISTS quest_instances {QUEST_INSTANCES_TABLE_SQL}
-    """,
-]
-
-#: Column body of ``completion_events``, shared between the v1 DDL
-#: below and the actor-child rebuild migration, which must recreate the
-#: table in exactly this shape (D-008: ``actor_child_id`` records which
-#: panel profile was tapped — set for panel events, NULL for admin
-#: ones; legacy panel rows backfill to ``child_id``, the child they
-#: always were).
-COMPLETION_EVENTS_TABLE_SQL = """(
-    id INTEGER PRIMARY KEY AUTOINCREMENT,
-    instance_id INTEGER NOT NULL REFERENCES quest_instances(id),
-    child_id INTEGER NOT NULL REFERENCES children(id),
-    event_type TEXT NOT NULL CHECK (event_type IN ('completed', 'uncompleted')),
-    actor_source TEXT NOT NULL CHECK (actor_source IN ('user', 'panel')),
-    actor_user_id TEXT,
-    actor_child_id INTEGER REFERENCES children(id),
-    occurred_at TEXT NOT NULL,
-    was_on_time INTEGER CHECK (
-        was_on_time IS NULL
-        OR (typeof(was_on_time) = 'integer' AND was_on_time IN (0, 1))
-    ),
-    CHECK (
-        (actor_source = 'user' AND actor_user_id IS NOT NULL)
-        OR (actor_source = 'panel' AND actor_user_id IS NULL)
-    ),
-    CHECK (
-        (actor_source = 'user' AND actor_child_id IS NULL)
-        OR (actor_source = 'panel' AND actor_child_id IS NOT NULL)
-    ),
-    CHECK (
-        (event_type = 'completed' AND was_on_time IS NOT NULL)
-        OR (event_type = 'uncompleted')
-    )
-)"""
-
-SCHEMA_V1_COMPLETION_EVENTS_DDL: list[str] = [
-    f"""
-    CREATE TABLE IF NOT EXISTS completion_events {COMPLETION_EVENTS_TABLE_SQL}
-    """,
-]
-
-SCHEMA_V1_STATEMENTS: list[str] = [
-    *SCHEMA_V1_CHILDREN_DDL,
-    *SCHEMA_V1_ADMIN_USERS_DDL,
-    *SCHEMA_V1_SCHEDULE_RULES_DDL,
-    *SCHEMA_V1_QUEST_DEFINITIONS_DDL,
-    *SCHEMA_V1_QUEST_DEFINITION_ASSIGNEES_DDL,
-    *SCHEMA_V1_QUEST_DEFINITION_WINDOWS_DDL,
-    *SCHEMA_V1_PRESENCE_SCHEDULES_DDL,
-    *SCHEMA_V1_PRESENCE_OVERRIDES_DDL,
-    *SCHEMA_V1_QUEST_INSTANCES_DDL,
-    *SCHEMA_V1_COMPLETION_EVENTS_DDL,
-]
-
-
-async def async_apply_ddl(
-    database: NestQuestDatabase, statements: list[str]
-) -> None:
-    """Apply each DDL statement inside one transaction on ``database``.
-
-    Idempotent: every statement is ``CREATE TABLE IF NOT EXISTS``, so
-    applying the same list twice leaves the schema and its rows intact.
-    """
-    async with database.transaction():
-        for sql in statements:
-            await database.execute(sql)

custom_components/nestquest/services.yaml

@@ -1,12 +0,0 @@
-# Service declarations for the NestQuest integration (Home Assistant
-# services.yaml metadata). Services are domain-scoped: nested under the
-# "nestquest" domain, not repeated per config entry.
-
-regenerate:
-  name: Regenerate quest instances
-  description: >-
-    Regenerate every future quest instance for the household over the rolling
-    horizon, using the same idempotent materialization as the daily rollover
-    and the startup backfill. Safe to call at any time: a re-run refreshes the
-    same rows instead of duplicating them, and completed instances are never
-    touched.

custom_components/nestquest/strings.json

@@ -22,16 +22,13 @@
         "data": {
           "horizon_days": "Generation horizon (days)",
           "day_rollover_time": "Day rollover time (HH:MM)",
-          "panel_idle_timeout": "Panel idle timeout (seconds)",
-          "admin_user_ids": "Admin users (parents)"
+          "panel_idle_timeout": "Panel idle timeout (seconds)"
         }
       }
     },
     "errors": {
       "invalid": "Invalid value.",
-      "invalid_time": "Time must use 24-hour HH:MM format.",
-      "no_admins": "Select at least one admin user; an empty allowlist would lock everyone out.",
-      "invalid_admin": "Invalid admin selection."
+      "invalid_time": "Time must use 24-hour HH:MM format."
     }
   }
-}
+}

custom_components/nestquest/translations/en.json

@@ -22,16 +22,13 @@
         "data": {
           "horizon_days": "Generation horizon (days)",
           "day_rollover_time": "Day rollover time (HH:MM)",
-          "panel_idle_timeout": "Panel idle timeout (seconds)",
-          "admin_user_ids": "Admin users (parents)"
+          "panel_idle_timeout": "Panel idle timeout (seconds)"
         }
       }
     },
     "errors": {
       "invalid": "Invalid value.",
-      "invalid_time": "Time must use 24-hour HH:MM format.",
-      "no_admins": "Select at least one admin user; an empty allowlist would lock everyone out.",
-      "invalid_admin": "Invalid admin selection."
+      "invalid_time": "Time must use 24-hour HH:MM format."
     }
   }
-}
+}

design/ADMIN-SPEC.md

@@ -1,136 +0,0 @@
-# Admin spec — parent phone card
-
-Screens `1d`–`1i`. One card, `nestquest-admin-card`, four tabs. Reference viewport
-390×844. Plain CubeCraft styling and plain domain words — no parchment, no Cinzel, no
-quest vocabulary in this surface.
-
-## 1. Shell
-
-- Page `--nq-a-page`; cards `--nq-a-surface` with 1px `--nq-a-border`.
-- **Header** white, 1px bottom border: screen title 24px/800, tracking −.02em, plus a
-  12px/600 `--nq-a-ink-secondary` sub-line. Optional trailing action (icon square 36px,
-  or a gradient `New` button).
-- **Tab bar** absolute bottom, `--nq-a-tabbar-height` 70px + 12px bottom padding, white,
-  1px top border, 4 items: `house` Today · `list-checks` Tasks · `calendar-days` Schedule ·
-  `history` History. Active icon and label `--nq-brand-blue` at 700; inactive icon
-  `--nq-a-ink-tertiary`, label `--nq-a-ink-secondary` 600.
-- **Every scroll column ends with 92px bottom padding** so content clears the tab bar.
-  This was a real defect in review — do not omit it.
-- Two densities exist. Ship **compact**; `--nq-a-density-*` carries the roomy values.
-- Everything this card mutates goes through a NestQuest service, which enforces the admin
-  allowlist server-side. The card must assume it can be rendered by a non-admin and still
-  be safe — hiding controls is not the boundary (D-003).
-
-## 2. Today (1d compact, 1h roomy)
-
-### 2.1 Header
-Title `Today`; sub `<weekday>, <Month D> · cycle day N of 14`; trailing `settings` square.
-
-### 2.2 Stat row
-Three equal cards, 8px gap, padding 12px: numeral 22px/800 (done in `--nq-brand-blue`,
-remaining in `--nq-a-ink`, overdue in `--nq-a-danger`), label 10px/600 uppercase tracking
-.08em `--nq-a-ink-secondary` — `Done`, `Remaining`, `Overdue`.
-
-### 2.3 Child rows
-One card, rows divided by `--nq-a-divider`, row padding 11px 13px:
-30px gradient avatar square (radius 7px, initial 13px/800 white) · name 14px/700 ·
-meta 11px/600 (`3 of 7 · 1 overdue`; all-done in `--nq-a-success`; away reads
-`Away · returns <Mon D>`) · 82×6px progress track with gradient fill. An away child's
-avatar is flat `#9898A8` and the row carries a lowercase `override` pill when the absence
-comes from a presence override rather than the pattern.
-
-### 2.4 Roomy variant (1h)
-Header becomes a hero: kicker 11px/700 uppercase, `8 of 12 done` 32px/800, 10px gradient
-progress bar, 13px/600 sub-line. Each child gets its own 12px-radius card with
-`0 4px 12px rgba(0,0,0,.06)`, 48px avatar, 19px/800 name, right-aligned `3/7` +
-status line, and its overdue item inlined as a `--nq-a-danger-bg` row with a
-`Mark done` action.
-
-### 2.5 Needs attention
-Section label 11px/700 uppercase, then one card of event rows: Lucide glyph 18px ·
-title `<Quest> · <Child>` 13px/700 · meta 11px/600 (`Overdue since 9:00 AM` in
-`--nq-a-danger`; `Completed 7:04 AM from panel` in `--nq-a-ink-secondary`) · trailing
-text action `Mark done` (`--nq-brand-blue`) or `Undo` (`--nq-brand-purple`).
-
-### 2.6 Permission note
-An info strip (`--nq-a-info-bg`, `info` glyph, 11.5px/600 `--nq-a-info-ink`):
-"Undo is admin-only. A panel tap can never reverse a completion." Keep this copy — it is
-the one place the security model is explained to the user.
-
-## 3. Definitions (1e)
-
-### 3.1 List
-Header `Tasks` / `7 definitions · 3 children` + gradient `New` button. Filter chips row
-(All / one per child): active `#18181D` fill white text, inactive white with border.
-Rows: glyph 17px · title 13.5px/700 · meta 11px/600 `<assignees> · <recurrence> · <windows>`
-· `chevron-right`. An inactive definition renders the whole row at
-`--nq-a-ink-tertiary` with `· inactive` in the meta — never hard-deleted (glossary).
-The row being edited takes `--nq-a-selected` with brand-blue glyph, `Editing` meta and
-`chevron-down`.
-
-### 3.2 Edit sheet
-Bottom sheet, `--nq-a-radius-sheet`, `--nq-a-sheet-shadow`, 38×4px grabber, padding
-14px 18px 24px. Title 19px/800. Fields, 11px gap, each with a 10px/700 uppercase label:
-
-| Field | Control |
-|---|---|
-| Assigned children | multi-select row → sheet; shows `Declan` or `All three` |
-| Repeats | select (Daily / Weekly / Monthly / Yearly / Custom + interval) |
-| Due time | time field per window |
-| Window | 3-up segmented, **multi-select** — a definition may own several |
-| Skip on away days | toggle, gradient when on, sub "No instance when the child is absent" |
-
-Footer: `Cancel` (flex 1, bordered) + `Save changes` (flex 2, gradient), both 13px vertical
-padding. Sheet enters over the dimmed list in `--nq-dur-modal`.
-
-### 3.3 Icon picker
-Each definition carries a Lucide glyph, shown on both surfaces. **The allowed subset is not
-yet defined** — pick 24–40 household-relevant glyphs and ship them as a grid picker.
-
-## 4. Schedule (1f)
-
-- Header `Schedule` / `2-week cycle · anchor <weekday>, <Mon D>`.
-- **Month grid** card: month label 11px/700 uppercase + chevron pair; weekday initials
-  10px/700 `--nq-a-ink-tertiary`; day cells `aspect-ratio: 1`, radius 6px —
-  rotation-home days `--nq-a-selected` with `#201F7A` numerals, away days
-  `--nq-a-page` with `--nq-a-ink-secondary`, override days `--nq-a-warning-bg` with
-  `--nq-a-warning-ink` and a 1px warning border, today filled with the brand gradient in
-  white 800. Legend row beneath, 10.5px/600, one swatch per state.
-- **Presence pattern** card: one row per child, name 13px/700 + rule 12px/600
-  (`Weeks 1 & 3 of cycle`, `Every day`).
-- **Overrides** card: `Add` text action; rows with `calendar-x` / `calendar-check`,
-  title `<Child> away · <Mon D – D>`, meta reason, trailing `trash-2`.
-- Cycle position is always computed from the anchor date. **Never** from ISO week numbers
-  or week parity (D-004).
-
-## 5. History (1g)
-
-- Header `History` / `Append-only event log · last 14 days` + bordered `CSV` button
-  (`download` glyph) that exports the filtered range.
-- Stat row: `91%` On time · `128` Completed · `7` Missed, numerals 20px/800.
-- Filter chips: `All events` / `Reversals` / `Missed`.
-- Day-grouped sections (label 11px/700 uppercase) of event rows: 7px status dot
-  (green completed, `--nq-a-reversal` un-completed, `--nq-a-danger` missed) ·
-  title `<Quest> · <Child>` 12.5px/700 · meta 10.5px/600 giving event type, actor and
-  on-time flag (`completed · panel (Declan) · on time`, `uncompleted · joshua (admin)`,
-  `missed · nightly sweep`, `completed · panel (Declan) · late 22 min`) · time 11px/600.
-- Footer strip (`--nq-a-page`, `lock` glyph): "Events are never edited or deleted. A
-  reversal is its own row." Rows are never editable in the UI (D-005).
-
-## 6. Presence override editor (1i)
-
-Pushed screen with a back chevron; title `Presence override` / sub "Beats the custody
-pattern for these dates".
-
-- Form card (roomy density, 18px padding, 16px gaps):
-  **Child** 3-up segmented, selected = gradient;
-  **Status for these dates** 2-up segmented (`Away` / `Home`), selected = `#18181D`;
-  **From** / **Through** date fields side by side, 13px padding, 14px/700 values;
-  **Reason (optional)** text field.
-- **Consequence warning** — `--nq-a-warning-bg` card with `alert-circle`:
-  headline `This removes N upcoming tasks` 13.5px/700 `--nq-a-warning-ink`, body 12px/600
-  `--nq-a-warning-ink-2` naming the child, the date range, and stating "Completed days are
-  untouched." The count must be computed live from the materialiser before saving.
-- Footer: `Cancel` (flex 1, white, bordered) + `Save override` (flex 2, gradient), 15px
-  vertical padding.
-- Saving must never delete an instance that already has a completion event.

design/DESIGN-HANDOFF.md

@@ -1,82 +0,0 @@
-# NestQuest — design handoff
-
-Approved UI design for the NestQuest Home Assistant integration, ready to implement.
-Source of truth for visuals: the mockup file `NestQuest Mockups.dc.html` (9 screens,
-option ids `1a`–`1j`). This folder is the written form of those screens.
-
-## What is in here
-
-| File | Contents |
-|---|---|
-| `PANEL-SPEC.md` | Kids' DAKOS wall panel: party board, quest log, confirm, quest complete |
-| `ADMIN-SPEC.md` | Parent phone admin: today, definitions, schedule, history, overrides |
-| `ENTITIES-AND-SERVICES.md` | Every screen mapped to the HA entities, services and events it needs |
-| `IMPLEMENTATION-ORDER.md` | Build order, with the decisions that change existing code first |
-| `tokens/nestquest-panel-tokens.css` | Panel card custom properties |
-| `tokens/nestquest-admin-tokens.css` | Admin card custom properties |
-
-## Screen index
-
-| id | Screen | Surface | Spec |
-|---|---|---|---|
-| 1a | The Party (attract) | panel 1920×1080 | PANEL §2 |
-| 1b | Quest Log | panel 1920×1080 | PANEL §3 |
-| 1j | Complete confirm | panel 1920×1080 | PANEL §4 |
-| 1c | Quest complete | panel 1920×1080 | PANEL §5 |
-| 1d | Today (compact) | phone 390×844 | ADMIN §2 |
-| 1e | Definitions + edit sheet | phone 390×844 | ADMIN §3 |
-| 1f | Schedule + custody | phone 390×844 | ADMIN §4 |
-| 1g | History + CSV | phone 390×844 | ADMIN §5 |
-| 1h | Today (roomy) | phone 390×844 | ADMIN §2.4 |
-| 1i | Presence override | phone 390×844 | ADMIN §6 |
-
-## Design decisions taken during this handoff
-
-These were open in CTXD and are now settled. Several contradict the current repo and
-docs — read `IMPLEMENTATION-ORDER.md` §1 before writing code.
-
-1. **`quest_*` naming throughout.** The domain model is renamed from `task_*` to
-   `quest_*` in DB, services, entities and UI. Migration note in IMPLEMENTATION-ORDER §1.1.
-2. **Instance key becomes `(definition_id, child_id, due_date, window)`.** Required by
-   multi-assignee definitions and by twice-daily quests. Supersedes the documented
-   `(definition_id, due_date)`.
-3. **A definition may have multiple assignees**, and materialises one instance per
-   assigned child per date per window. Each child completes their own.
-4. **A definition may declare more than one window** (morning / afternoon / evening),
-   producing one instance per window per day.
-5. **Missed quests vanish from the panel at rollover.** Kids never see a wall of failure;
-   the missed event is in the parent's history only.
-6. **Three Lovelace cards**: `nestquest-party-board-card`, `nestquest-quest-log-card`,
-   `nestquest-admin-card`. Board and log live in separate Lovelace views; a crest tap
-   navigates.
-7. **Completion needs a confirm step** (screen 1j) because children cannot undo.
-8. **The quest log owns idle return**: 40 s of no touch navigates back to the board.
-   TouchHub Auto-Return must be configured longer than 40 s so the two do not fight.
-9. **Actor on a panel completion** is `panel` plus the tapped child profile, per glossary.
-10. **Weather is a configured entity** on the party board card (`weather_entity`), not
-    NestQuest data.
-11. **Fonts are bundled** as local woff2 in the card's `www/` folder — the panel may be
-    offline. Nunito (400/600/700/800) and Cinzel + Cinzel Decorative.
-
-## Vocabulary
-
-The panel speaks tabletop; the admin speaks plainly. Both sit on the same `quest_*` model.
-
-| Model / admin | Panel display string |
-|---|---|
-| quest instance | quest |
-| child | adventurer |
-| child's task list | Quest Log |
-| household | The Party |
-| all complete | Quest complete |
-| absent | On travels |
-
-## Open questions
-
-- Empty and error states are unspecified by request (child with no quests, everyone away,
-  integration unconfigured, DB unreachable). Panel must not render a blank parchment —
-  decide before shipping the card.
-- No gamification is in scope. XP, levels, streaks and rarity were explicitly deferred,
-  but the append-only event log already supports computing them later.
-- Icon per quest definition is chosen by the parent from a Lucide subset; the subset is
-  not yet defined (`ADMIN-SPEC.md` §3.3).

design/ENTITIES-AND-SERVICES.md

@@ -1,117 +0,0 @@
-# Screens → HA entities, services and events
-
-Planned surface from CTXD CONTEXT.MD, adjusted for the design decisions in
-`DESIGN-HANDOFF.md`. Names use the `quest_*` model.
-
-## 1. Entities the cards read
-
-| Entity | Type | Used by |
-|---|---|---|
-| `sensor.nestquest_<child>_quests_due_today` | int | 1a plate progress, 1b counts, 1d stats |
-| `sensor.nestquest_<child>_quests_completed_today` | int | 1a, 1b, 1c, 1d, 1h |
-| `sensor.nestquest_<child>_quests_remaining_today` | int | 1b remaining block, 1d |
-| `sensor.nestquest_<child>_completion_pct_today` | float | progress bars |
-| `sensor.nestquest_<child>_next_quest` | str + attrs | optional panel hint |
-| `binary_sensor.nestquest_<child>_all_done` | bool | 1c trigger, 1d "all done" |
-| `binary_sensor.nestquest_<child>_present_today` | bool | 1a away plate, 1d away row |
-| `sensor.nestquest_household_quests_due_today` | int | 1b party line, 1c party stat |
-| `sensor.nestquest_household_quests_completed_today` | int | same |
-| `sensor.nestquest_cycle_day` | int | 1d sub-line, 1f header |
-| *configured* `weather.<entity>` | HA core | panel dock |
-
-Per-instance data is too granular for entity state. The cards read the day's instance list
-from an attribute payload on the per-child sensor (or a websocket command —
-implementer's call), shaped:
-
-```json
-{
-  "instances": [
-    { "id": 4821, "definition_id": 12, "child_id": 3, "title": "Fill bird feeder",
-      "icon": "bird", "window": "afternoon", "due_time": "17:00",
-      "state": "open", "overdue": true, "completed_at": null, "on_time": null }
-  ]
-}
-```
-
-`state` ∈ `open` | `completed`. Missed instances are **omitted** from panel payloads
-(decision 5) and included in admin payloads.
-
-## 2. Services the cards call
-
-| Service | Admin only | Called from |
-|---|---|---|
-| `nestquest.complete_quest` | no (panel allowed) | 1j confirm |
-| `nestquest.uncomplete_quest` | **yes** | 1d `Undo` |
-| `nestquest.create_quest_definition` | **yes** | 1e `New` |
-| `nestquest.update_quest_definition` | **yes** | 1e sheet `Save changes` |
-| `nestquest.set_quest_definition_active` | **yes** | 1e row action |
-| `nestquest.set_presence_pattern` | **yes** | 1f presence card |
-| `nestquest.create_presence_override` | **yes** | 1i `Save override` |
-| `nestquest.delete_presence_override` | **yes** | 1f override row `trash-2` |
-| `nestquest.export_history_csv` | **yes** | 1g `CSV` |
-| `nestquest.manage_child` | **yes** | settings |
-
-`complete_quest` payload from the panel:
-
-```yaml
-service: nestquest.complete_quest
-data:
-  instance_id: 4821
-  actor: panel            # kiosk user context
-  actor_child_id: 3       # the tapped profile (decision 9)
-```
-
-Every service resolves `call.context.user_id` against the admin allowlist and **fails
-closed** with no user context (D-003). The panel's kiosk user is never allowlisted, so
-`uncomplete_quest` is unreachable from the wall even though the card never renders the
-control.
-
-## 3. Events the cards listen for
-
-| Event | Effect |
-|---|---|
-| `nestquest_quest_completed` | stamp the seal, re-sort the column, refresh counts |
-| `nestquest_quest_uncompleted` | un-seal, restore the card (admin action, panel must reflect it) |
-| `nestquest_quest_missed` | remove the instance from the panel; add a history row |
-| `nestquest_child_day_complete` | show screen 1c |
-
-All four come off the `DataUpdateCoordinator`; cards should also refresh on
-`state_changed` for their sensors so they recover if an event is dropped.
-
-## 4. Card configuration
-
-```yaml
-# kids' panel, view 1
-type: custom:nestquest-party-board-card
-weather_entity: weather.home          # optional; dock falls back to date/time
-quest_log_path: /nestquest/log        # view the crest tap navigates to
-child_order: [declan, jordyn, chloe]
-
-# kids' panel, view 2
-type: custom:nestquest-quest-log-card
-board_path: /nestquest/board
-idle_return_seconds: 40               # must be shorter than TouchHub Auto-Return
-confirm_timeout_seconds: 15
-complete_screen_seconds: 12
-
-# parent phone
-type: custom:nestquest-admin-card
-density: compact                      # compact | roomy
-default_tab: today
-```
-
-The quest log reads the selected child from the view's URL/`hass` path parameter so the
-board → log hop is a plain Lovelace navigation (decision 6).
-
-## 5. Data-shape consequences of the design
-
-1. Instance key is `(definition_id, child_id, due_date, window)` — the schema's
-   `task_instances` unique index must widen.
-2. `quest_definitions` needs an **assignees** join table, replacing the single
-   `child_id` column.
-3. `quest_definitions` needs a **windows** set (morning/afternoon/evening) plus an
-   optional due time per window.
-4. The materialiser emits one instance per (assignee × window × firing date), still
-   idempotent on the widened key, still only when the child is present.
-5. `completion_events` gains `actor_child_id` so a panel completion records which
-   profile was tapped, while `actor` stays `panel`.

design/IMPLEMENTATION-ORDER.md

@@ -1,80 +0,0 @@
-# Implementation order
-
-Written for an agent working in `code.cubecraftlabs.com/Maniacs_Mansion/NestQuest`.
-Steps 1.x change existing code and must land first; the frontend is step 4 onward.
-
-## 1. Model changes (breaking, pre-release)
-
-### 1.1 Rename `task_*` → `quest_*`
-Nothing is released (main/dev are at "first commit", version 0.1.0), so rename in place
-rather than aliasing.
-
-- `schema.py`: `task_definitions` → `quest_definitions`, `task_instances` →
-  `quest_instances`. Keep `completion_events`, `children`, `admin_users`,
-  `schedule_rules`, `presence_schedules`, `presence_overrides`.
-- `db.py` / `store.py`: rename DAO methods and any SQL literals.
-- `const.py`: no table names live there today; keep it that way.
-- `tests/test_schema.py`, `tests/test_store.py`, `tests/test_db.py`: update expectations.
-- **Migration note:** the versioned migration runner has no released version to upgrade
-  from. Bump the schema version, and make migration 1 create the `quest_*` tables
-  directly. If any dev machine already holds a `nestquest.db` with `task_*` tables, the
-  runner should detect the legacy names and `ALTER TABLE ... RENAME TO` before applying
-  the widened index — a dev-only path, worth ~20 lines and a test.
-
-### 1.2 Widen the instance key
-Unique index becomes `(definition_id, child_id, due_date, window)`. Materialisation stays
-idempotent on that tuple. Add a test for the twice-daily case (one definition, two windows,
-one child, one date → two rows) and the shared case (one definition, three assignees, one
-window → three rows).
-
-### 1.3 Multi-assignee definitions
-Add `quest_definition_assignees(definition_id, child_id)`. Drop the single `child_id`
-column on the definition. The "exactly one assigned child" rule in GLOSSARY.MD no longer
-holds — CTXD has been updated.
-
-### 1.4 Windows
-Add `quest_definition_windows(definition_id, window, due_time)` with
-`window ∈ ('morning','afternoon','evening')`. Window clock ranges are fixed for now:
-morning ≤ 11:59, afternoon 12:00–17:00, evening 17:00–21:00. Store the ranges in
-`const.py` so they are configurable later.
-
-### 1.5 `actor_child_id` on completion events
-Nullable int. Set for panel completions, null for admin ones. Still append-only.
-
-## 2. Engines and materialisation
-Unchanged in intent: pure recurrence engine, pure presence engine with anchor-date
-arithmetic, daily materialiser over `horizon_days` at `day_rollover_time`. Only the
-instance fan-out changes (assignees × windows).
-
-## 3. Services, permissions, entities
-Implement the service table in `ENTITIES-AND-SERVICES.md` §2 behind the permission
-decorator, then the sensors and binary sensors in §1, then the four events in §3.
-`complete_quest` is the only service a non-admin context may call.
-
-## 4. Frontend groundwork
-1. Create `custom_components/nestquest/www/`.
-2. Bundle fonts as woff2: Nunito 400/600/700/800; Cinzel 600/700/900; Cinzel Decorative
-   700/900. Declare `@font-face` with `font-display: swap` in a shared
-   `nestquest-fonts.css`. No CDN — the panel may be offline.
-3. Copy `design/tokens/nestquest-panel-tokens.css` and
-   `design/tokens/nestquest-admin-tokens.css` in as the cards' `:host` blocks.
-4. Register the three cards with `customCards` and ship editors later; hand-written YAML
-   is fine for v1.
-
-## 5. Cards, in this order
-1. `nestquest-party-board-card` (screen 1a) — read-only, proves the entity payload.
-2. `nestquest-quest-log-card` (1b) — read-only first, no completion.
-3. Confirm dialog + `complete_quest` (1j) with optimistic seal and revert-on-failure.
-4. Quest complete screen (1c) driven by `nestquest_child_day_complete`.
-5. Idle return (40 s) and the documented TouchHub Auto-Return constraint.
-6. `nestquest-admin-card`: Today (1d) → Definitions + sheet (1e) → Schedule (1f) →
-   History + CSV (1g) → Presence override (1i).
-
-## 6. Before shipping
-- `use_x_frame_options: false` is required for TouchHub embedding — document the
-  clickjacking trade-off next to the setting, per D-006.
-- Verify no NestQuest control in the dock strip is tappable.
-- Verify the kiosk HA user is absent from the admin allowlist, and that
-  `uncomplete_quest` denies it with a logged denial.
-- Empty and error states are still unspecified (see DESIGN-HANDOFF "Open questions").
-  Do not ship a card that renders a blank parchment.

design/PANEL-SPEC.md

@@ -1,170 +0,0 @@
-# Panel spec — kids' DAKOS wall panel
-
-Screens `1a`, `1b`, `1j`, `1c` of the mockups. Two cards:
-`nestquest-party-board-card` (§2) and `nestquest-quest-log-card` (§3–5).
-
-## 1. Frame and constraints
-
-- **Canvas** 1920×1080, landscape, fixed. No scrolling — content must fit. Every screen in
-  the mockups measures exactly 1920×1080 with no overflow; keep it that way.
-- **Viewing distance** ~3 ft. **No text below 22px.** Meta lines are 22px/600 Nunito;
-  quest titles 30px/700 Cinzel; section heads 32px.
-- **Contrast** every ink token is ≥4.5:1 on parchment. Do not introduce alpha-muted text.
-- **Ground** `--nq-p-parchment` + `--nq-p-vignette`, CSS only, no image assets.
-- **Double frame** inset 26px (`--nq-p-frame-outer`, radius 14px) and inset 36px
-  (`--nq-p-frame-inner`, radius 8px), both `pointer-events: none`.
-- **Dock** bottom strip, 84px, inset 46px, radius 14px, `--nq-p-dock-bg`. Weather only.
-  **Nothing in the dock is tappable** (D-006).
-- **No login.** Every action comes from the kiosk HA user; the kiosk user is never in the
-  admin allowlist.
-
-## 2. The Party — attract state (1a)
-
-Default view on the wall. Layout top to bottom:
-
-1. **Wordmark row** at y=64. Rule · d20 hexagon · `NestQuest` (66px/900 display, brand
-   gradient via `background-clip: text`) · d20 · rule. d20 marks are 34px hexagons
-   (`clip-path: polygon(50% 0, 93% 25%, 93% 75%, 50% 100%, 7% 75%, 7% 25%)`) filled with
-   the brand gradient, numeral 15px/700 Cinzel.
-2. **Kicker** `The Party · <weekday>, <Month D>` — 21px/600 Cinzel, tracking .30em, uppercase.
-3. **Adventurer plates**, 3-up grid, 56px gap, page inset 110px, top y=262. One plate per
-   child returned by the party sensor, in configured order.
-4. **Hint line** `Tap your crest to open your Quest Log`, 27px/600 Nunito, y≈930.
-5. **Dock.**
-
-### 2.1 Adventurer plate (present)
-
-Radius 20px, `--nq-p-card-panel`, 2px `--nq-p-panel-border`, `--nq-p-panel-shadow`,
-padding 44px 28px 40px, contents centred, 26px gap. **The whole plate is the tap target**
-(≥188px wide, ≥600px tall — far above minimum).
-
-- **Crest** 188×214, shield via `clip-path: polygon(0 0, 100% 0, 100% 62%, 50% 100%, 0 62%)`,
-  `--nq-p-crest`, inset ring `inset 0 0 0 4px rgba(255,255,255,.22)`, child's initial
-  82px/700 display in white.
-- **Name** 48px/700 Cinzel, `--nq-p-ink`, tracking .02em.
-- **Presence pill** radius 9999px, `#e8f4ea` on `rgba(22,120,60,.35)`, `check-circle` 22px
-  `#157a3c`, label `Home today` 19px/600 Cinzel uppercase `#146b36`.
-- **Progress line** `N of M quests claimed` 26px/700 Cinzel `--nq-p-ink-secondary`.
-- **Progress bar** full width, 16px, radius 9999px, track `rgba(92,62,26,.18)` with 1px
-  border, fill `--nq-brand-gradient-h`.
-
-### 2.2 Adventurer plate (away)
-
-Same geometry, muted: `linear-gradient(#f2ecdd, #e6dcc6)`, **2px dashed** border, no lift
-shadow. Crest uses `--nq-p-crest-away`; initial stays **full-opacity white** (never alpha).
-Name in `--nq-p-ink-away`. Pill: `tent` icon, label `On travels`, neutral fill. Progress
-line reads `Returns <weekday>, <Mon D>`; empty progress track, no fill. **Not tappable** —
-the plate must not navigate, since the child has no instances.
-
-### 2.3 Dock
-
-`cloud-sun` 40px · temperature 38px/800 Nunito `--nq-p-dock-ink` · 1px divider ·
-condition + high/low 26px/600 `--nq-p-dock-ink-secondary` · divider · one short forecast
-phrase. All read from the configured `weather_entity`; if unset, render the dock with date
-and time only rather than removing it (the strip is part of the frame).
-
-## 3. Quest Log (1b)
-
-Reached by tapping a present crest. Header at y=56, page inset 62px:
-
-- Small crest 96×110 (initial 44px/700 display).
-- Title `<Name>'s Quest Log` 56px/700 display.
-- Sub `<weekday>, <Month D> · N of M claimed` 20px/600 Cinzel, tracking .24em, uppercase.
-- **Remaining block** right-aligned: radius 14px panel, d20 mark 44px with the remaining
-  count, `N quests left` 28px/700 Cinzel, and a party line
-  `Party progress · X of Y today` 22px/600 Nunito.
-
-### 3.1 Window columns
-
-Three equal columns, 34px gap, top y=236, one per window — **Morning** (until 11:59 AM),
-**Afternoon** (12:00–5:00 PM), **Evening** (5:00–9:00 PM). Column head: icon
-(`sunrise` / `sun` / `moon`) 34px, name 32px/700 Cinzel, sub-label 21px/600 Cinzel
-uppercase with the window's clock range, right-aligned `done/total` 26px/700 Cinzel,
-14px bottom padding, `--nq-p-rule` underline.
-
-Cards stack at `--nq-p-quest-gap` (24px). Order within a column: **incomplete first,
-sealed below**. A window with no quests renders its head and nothing else — do not
-collapse the column, the three-column rhythm is the layout.
-
-### 3.2 Quest card — open
-
-`--nq-p-quest-min-height` 116px, radius 12px, `--nq-p-card-open`, 1px
-`--nq-p-card-border`, `--nq-p-card-shadow`, padding 22px, 22px gap, row layout:
-
-1. **Icon tile** 64×64, radius 10px, `--nq-p-icon-tile`, Lucide glyph 34px white.
-2. **Text** title 30px/700 Cinzel `--nq-p-ink`; meta 22px/600 Nunito
-   `--nq-p-ink-secondary` reading `Due by <h:mm A>`. If past due:
-   `Overdue · due <h:mm A>` in 22px/700 Cinzel uppercase, tracking .10em,
-   `--nq-p-ink-late`.
-3. **Complete button** `--nq-p-button-height` 72px × min 150px, radius 10px,
-   `--nq-brand-gradient`, `check` 30px + `Complete` 24px/700 Cinzel white,
-   `box-shadow: 0 3px 0 rgba(40,20,60,.35)`.
-
-Both the card body and the button open the confirm dialog (§4). Press feedback:
-`scale(.98)`, `--nq-dur-micro`.
-
-### 3.3 Quest card — sealed
-
-`--nq-p-card-done`, `opacity: .82`, no shadow, **not tappable**. Icon tile
-`--nq-p-icon-tile-done` with the glyph in `--nq-p-ink-secondary`. Title 30px/700 Cinzel
-`--nq-p-ink-muted` with `text-decoration: line-through`. Meta reads
-`Claimed <h:mm A>` 22px/600 Nunito `--nq-p-ink-secondary`.
-
-**Wax seal** `--nq-p-seal-size` 78px circle, `--nq-p-seal`, `--nq-p-seal-shadow`,
-`check` 38px in `rgba(255,235,235,.95)`, absolutely positioned `right: 16px; top: -12px`,
-rotated a few degrees — **vary the rotation per card** (−9°, +6°, −4° in the mockup) so the
-board looks stamped by hand, not templated. Entrance: fade + `scale(1.15 → 1)`,
-`--nq-dur-base`, `--nq-ease-out`.
-
-### 3.4 Party roll-up
-
-An optional dashed panel in the afternoon column: label `Party roll-up` 18px/600 Cinzel
-uppercase, body 23px/600 Nunito `--nq-p-ink-secondary` — one or two sentences on the other
-children ("Jordyn has finished her log. Chloe is on travels until Sunday."). Read-only.
-
-### 3.5 Idle return
-
-40 s with no touch → navigate back to the party board view. Reset on any pointer or touch
-event. The card owns this; TouchHub Auto-Return must be set longer than 40 s.
-
-## 4. Complete confirm (1j)
-
-Modal over the dimmed log — scrim `rgba(30,20,10,.62)` over the live board.
-
-Dialog 1000px wide at `top: 196px; left: 460px`, radius 20px, parchment panel with 3px
-`rgba(92,62,26,.5)`, `box-shadow: 0 26px 60px rgba(20,10,0,.5)`, padding 64px 68px 56px.
-
-- Header row: 104px icon tile (radius 12px, brand gradient, glyph 56px) · window kicker
-  21px/600 Cinzel uppercase tracking .24em · quest title 58px/700 display.
-- Body 32px/600 Nunito `#3f2f1c`: `Mark this quest complete? Once the seal is set, only a
-  parent can undo it.`
-- Buttons, 24px gap, both `--nq-p-confirm-button` 108px tall:
-  **Not yet** flex 1, `rgba(92,62,26,.1)` with 2px border, `x` 34px + 30px/700 Cinzel;
-  **Complete** flex 2, brand gradient, `check` 38px + 32px/700 Cinzel white.
-- Dialog enters with fade + `scale(.96 → 1)`, `--nq-dur-modal`, `--nq-ease-out`.
-- Dismiss: **Not yet**, scrim tap, or 15 s of no input.
-
-On confirm, call the completion service optimistically, stamp the seal, and re-sort the
-column. On service failure, revert the card and surface a single-line parchment toast.
-
-## 5. Quest complete (1c)
-
-Shown when the last instance for a child's day is completed; auto-returns to the board
-after 12 s (countdown line `Returning to The Party in N seconds`, 25px/600 Nunito).
-
-- Large seal 168px at y=96 (`check` 86px), rotated −6°, `0 10px 24px rgba(60,10,20,.42)`.
-- `Quest complete` 86px/900 display, brand-gradient text fill.
-- Sub 34px/600 Nunito `--nq-p-ink-secondary`, max-width 1000px, centred, `text-wrap: pretty`:
-  names the child, the date, and how the day went.
-- **Stat blocks** 4-up at y=540, inset 200px, 26px gap: radius 16px parchment panels,
-  numeral 58px/900 Cinzel, label 17px/600 Cinzel uppercase tracking .14em —
-  `Quests claimed`, `On time`, `Late`, `The Party` (household X/Y).
-- Dock switches to the evening variant (`cloud-moon`).
-
-## 6. Accessibility and input
-
-- Minimum tap target on this surface is the quest card itself (116px) and the 72px button;
-  nothing interactive is smaller than 72px.
-- 24px between adjacent tap targets so a stray finger cannot claim the wrong quest.
-- No hover states — this is a touch-only surface. Provide `:active` feedback only.
-- No animation loops. Entrances only, per the CubeCraft motion rules.

design/tokens/nestquest-admin-tokens.css

@@ -1,76 +0,0 @@
-/* ============================================================
-   NestQuest — Parent admin card tokens
-   Surface: phone, 390x844 reference. Plain CubeCraft styling,
-   no tabletop treatment, plain domain words in the UI.
-   Scope on the card host: nestquest-admin-card.
-   Derived from the approved mockups (admin screens 1d-1i).
-   Two densities were built; COMPACT is the default. Flip
-   --nq-a-density-* to the roomy values for the alternative.
-   ============================================================ */
-
-:host {
-  /* ── Brand + neutrals (CubeCraft tokens, verbatim) ─────── */
-  --nq-brand-blue:        #3B3AB8;
-  --nq-brand-purple:      #A035CC;
-  --nq-brand-gradient:    linear-gradient(135deg, var(--nq-brand-blue), var(--nq-brand-purple));
-  --nq-brand-gradient-h:  linear-gradient(90deg,  var(--nq-brand-blue), var(--nq-brand-purple));
-
-  --nq-a-page:            #F4F4F6;
-  --nq-a-surface:         #FFFFFF;
-  --nq-a-surface-subtle:  #FAFAFA;
-  --nq-a-selected:        #EBEBF8;   /* row being edited */
-  --nq-a-border:          #E4E4EA;
-  --nq-a-divider:         #EDEDF1;
-
-  --nq-a-ink:             #18181D;
-  --nq-a-ink-secondary:   #52525E;
-  --nq-a-ink-tertiary:    #70707E;   /* inactive rows, unselected nav icons */
-
-  --nq-a-success:         #15803D;
-  --nq-a-danger:          #DC2626;
-  --nq-a-danger-strong:   #B91C1C;
-  --nq-a-danger-bg:       #FEE2E2;
-  --nq-a-warning-ink:     #92400E;
-  --nq-a-warning-ink-2:   #78350F;
-  --nq-a-warning-bg:      #FEF3C7;
-  --nq-a-warning-border:  rgba(217,119,6,.35);
-  --nq-a-info-bg:         #DBEAFE;
-  --nq-a-info-ink:        #1E3A8A;
-  --nq-a-info-icon:       #1D4ED8;
-  --nq-a-reversal:        #7D28A0;   /* un-complete events in history */
-
-  /* ── Type ─────────────────────────────────────────────── */
-  --nq-a-font:            Nunito, system-ui, sans-serif;
-  --nq-a-size-screen:     24px;  /* 800, screen title */
-  --nq-a-size-hero:       32px;  /* 800, roomy "8 of 12 done" */
-  --nq-a-size-card-title: 19px;  /* 800, roomy child card */
-  --nq-a-size-stat:       22px;  /* 800, compact stat number */
-  --nq-a-size-row:        13.5px;/* 700, list row title */
-  --nq-a-size-meta:       11px;  /* 600, row meta */
-  --nq-a-size-label:      10px;  /* 700, uppercase field label */
-  --nq-a-track-label:     .10em;
-
-  /* ── Density: COMPACT (default) ───────────────────────── */
-  --nq-a-density-page-pad:   14px 16px 92px;  /* bottom clears the 70px tab bar */
-  --nq-a-density-gap:        10px;
-  --nq-a-density-card-pad:   13px;
-  --nq-a-density-row-pad:    11px 13px;
-  --nq-a-density-radius:     8px;
-  --nq-a-density-shadow:     none;
-  /* Density: ROOMY — page-pad 18px 20px 92px; gap 16px;
-     card-pad 18px; radius 12px; shadow 0 4px 12px rgba(0,0,0,.06) */
-
-  /* ── Metrics ──────────────────────────────────────────── */
-  --nq-a-tabbar-height:   70px;   /* + 12px safe-area padding */
-  --nq-a-tap-min:         44px;   /* every row/control clears this */
-  --nq-a-radius-pill:     9999px;
-  --nq-a-radius-sheet:    20px 20px 0 0;
-  --nq-a-sheet-shadow:    0 -8px 28px rgba(9,9,11,.18);
-  --nq-a-progress-height: 6px;    /* 8px roomy, 10px hero */
-
-  /* ── Motion ───────────────────────────────────────────── */
-  --nq-ease-out:          cubic-bezier(0, 0, .2, 1);
-  --nq-dur-micro:         120ms;
-  --nq-dur-base:          200ms;
-  --nq-dur-modal:         350ms;
-}

design/tokens/nestquest-panel-tokens.css

@@ -1,94 +0,0 @@
-/* ============================================================
-   NestQuest — Kids' panel card tokens
-   Surface: DAKboard DAKOS wall panel, 1920x1080 landscape,
-   viewed from ~3 ft, no login, read/complete only.
-   Scope these on the card host: nestquest-quest-log-card,
-   nestquest-party-board-card.
-   Derived from the approved mockups (panel screens 1a, 1b, 1c, 1j).
-   ============================================================ */
-
-:host {
-  /* ── Parchment ground ─────────────────────────────────── */
-  --nq-p-parchment-top:      #f0e4c7;
-  --nq-p-parchment-bottom:   #ddcca3;
-  --nq-p-parchment: radial-gradient(ellipse at 25% 10%, rgba(255,255,255,.5), transparent 55%),
-                    radial-gradient(ellipse at 85% 90%, rgba(120,86,44,.28), transparent 60%),
-                    repeating-linear-gradient(93deg, rgba(150,115,70,.05) 0 2px, transparent 2px 6px),
-                    repeating-linear-gradient(2deg, rgba(150,115,70,.04) 0 3px, transparent 3px 7px),
-                    linear-gradient(var(--nq-p-parchment-top), var(--nq-p-parchment-bottom));
-  --nq-p-vignette:           inset 0 0 200px rgba(80,52,20,.35);
-
-  /* Card surfaces sitting on parchment */
-  --nq-p-card-open:          linear-gradient(#fdf7e6, #f2e7c9);   /* incomplete quest */
-  --nq-p-card-done:          linear-gradient(#f0e8d3, #e6dcc2);   /* sealed quest */
-  --nq-p-card-panel:         linear-gradient(#fcf6e6, #f1e6ca);   /* adventurer plate, stat block */
-  --nq-p-card-border:        rgba(120,88,48,.38);
-  --nq-p-panel-border:       rgba(92,62,26,.40);
-  --nq-p-card-shadow:        0 3px 0 rgba(120,88,48,.20), inset 0 1px 0 rgba(255,255,255,.70);
-  --nq-p-panel-shadow:       0 6px 0 rgba(92,62,26,.18), inset 0 2px 0 rgba(255,255,255,.70);
-  --nq-p-frame-outer:        2px solid rgba(92,62,26,.45);
-  --nq-p-frame-inner:        1px solid rgba(92,62,26,.28);
-  --nq-p-rule:               2px solid rgba(92,62,26,.35);
-
-  /* ── Ink (all values >= 4.5:1 on parchment) ───────────── */
-  --nq-p-ink:                #2b1f14;   /* titles, quest names */
-  --nq-p-ink-secondary:      #5c452a;   /* meta, window labels, counts */
-  --nq-p-ink-muted:          #6f6455;   /* sealed quest titles only */
-  --nq-p-ink-away:           #4d4433;   /* away adventurer name */
-  --nq-p-ink-late:           #8f1526;   /* overdue line */
-
-  /* ── Brand (CubeCraft, toned down: accents only) ──────── */
-  --nq-brand-blue:           #3B3AB8;
-  --nq-brand-purple:         #A035CC;
-  --nq-brand-gradient:       linear-gradient(135deg, var(--nq-brand-blue), var(--nq-brand-purple));
-  --nq-p-icon-tile:          var(--nq-brand-gradient);            /* open quest icon tile */
-  --nq-p-icon-tile-done:     rgba(92,62,26,.16);
-  --nq-p-crest:              var(--nq-brand-gradient);
-  --nq-p-crest-away:         linear-gradient(135deg, #6b6b7a, #7a7286);
-
-  /* ── Wax seal (completed marker) ──────────────────────── */
-  --nq-p-seal:               radial-gradient(circle at 35% 30%, #a8283a, #6d1322);
-  --nq-p-seal-shadow:        0 4px 10px rgba(60,10,20,.40), inset 0 0 0 4px rgba(255,255,255,.14);
-  --nq-p-seal-size:          78px;   /* 168px on the quest-complete screen */
-
-  /* ── Dock (bottom strip, non-interactive) ─────────────── */
-  --nq-p-dock-bg:            rgba(43,31,20,.90);
-  --nq-p-dock-ink:           #f7efdb;
-  --nq-p-dock-ink-secondary: #d8c9a6;
-  --nq-p-dock-divider:       rgba(233,220,189,.30);
-  --nq-p-dock-height:        84px;
-
-  /* ── Type ─────────────────────────────────────────────── */
-  --nq-p-font-display:       'Cinzel Decorative', Cinzel, serif;  /* NestQuest, names, Quest complete */
-  --nq-p-font-heading:       Cinzel, serif;                       /* section heads, quest titles, numerals */
-  --nq-p-font-body:          Nunito, system-ui, sans-serif;       /* meta lines, dock */
-
-  --nq-p-size-hero:          86px;   /* 900 weight, "Quest complete" */
-  --nq-p-size-wordmark:      66px;   /* 900 weight */
-  --nq-p-size-title:         56px;   /* 700, "Declan's Quest Log" */
-  --nq-p-size-name:          48px;   /* 700, adventurer name */
-  --nq-p-size-section:       32px;   /* 700, Morning / Afternoon / Evening */
-  --nq-p-size-quest:         30px;   /* 700, quest title */
-  --nq-p-size-body:          22px;   /* 600 Nunito, meta — PANEL MINIMUM */
-  --nq-p-size-label:         21px;   /* 600 Cinzel, uppercase, tracked */
-  --nq-p-track-label:        .14em;
-  --nq-p-track-kicker:       .30em;
-
-  /* ── Metrics: touch ───────────────────────────────────── */
-  --nq-p-quest-min-height:   116px;  /* whole card is the tap target */
-  --nq-p-quest-gap:          24px;   /* separation between tap targets */
-  --nq-p-button-height:      72px;   /* "Complete" button on a quest card */
-  --nq-p-button-min-width:   150px;
-  --nq-p-confirm-button:     108px;  /* confirm dialog buttons */
-  --nq-p-radius-card:        12px;
-  --nq-p-radius-panel:       20px;
-  --nq-p-radius-pill:        9999px;
-  --nq-p-page-inset:         62px;
-  --nq-p-frame-inset:        26px;
-
-  /* ── Motion (CubeCraft easing) ────────────────────────── */
-  --nq-ease-out:             cubic-bezier(0, 0, .2, 1);
-  --nq-dur-micro:            120ms;
-  --nq-dur-base:             200ms;
-  --nq-dur-modal:            350ms;
-}

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "nestquest"
-version = "0.3.0"
+version = "0.1.0"
 description = "NestQuest Home Assistant Integration"
 readme = "README.md"
 requires-python = ">=3.11"

tests/conftest.py

@@ -29,7 +29,7 @@ import tempfile
 import weakref
 from pathlib import Path
 from types import SimpleNamespace
-from unittest.mock import AsyncMock, MagicMock
+from unittest.mock import MagicMock
 
 import pytest
 
@@ -41,10 +41,6 @@ _HA_MODULES = (
     "homeassistant.core",
     "homeassistant.config_entries",
     "homeassistant.data_entry_flow",
-    "homeassistant.exceptions",
-    "homeassistant.helpers",
-    "homeassistant.helpers.config_validation",
-    "homeassistant.helpers.event",
 )
 
 def _find_spec(name: str):
@@ -81,10 +77,6 @@ for _parent, _child in (
     ("homeassistant", "config_entries"),
     ("homeassistant", "data_entry_flow"),
     ("homeassistant", "core"),
-    ("homeassistant", "exceptions"),
-    ("homeassistant", "helpers"),
-    ("homeassistant.helpers", "config_validation"),
-    ("homeassistant.helpers", "event"),
 ):
     setattr(sys.modules[_parent], _child, sys.modules[f"{_parent}.{_child}"])
 
@@ -166,7 +158,6 @@ def _callback_decorator(fn):
 _config_entries_mock = _ha_mock("homeassistant.config_entries")
 _core_mock = _ha_mock("homeassistant.core")
 _data_entry_flow_mock = _ha_mock("homeassistant.data_entry_flow")
-_exceptions_mock = _ha_mock("homeassistant.exceptions")
 
 _config_entries_mock.ConfigFlow = _ConfigFlowBase
 _config_entries_mock.OptionsFlowWithConfigEntry = _OptionsFlowWithConfigEntryBase
@@ -177,41 +168,6 @@ _data_entry_flow_mock.RESULT_TYPE_ABORT = "abort"
 _data_entry_flow_mock.FlowResult = dict
 
 
-class ConfigEntryNotReady(Exception):
-    """Stand-in mirroring homeassistant.exceptions.ConfigEntryNotReady.
-
-    HA retries setup when this is raised; the tests assert the corrupt
-    database path raises it instead of crashing with an unrelated error.
-    """
-
-
-_exceptions_mock.ConfigEntryNotReady = ConfigEntryNotReady
-
-import voluptuous as vol
-
-
-def _multi_select(choices: dict):
-    """Mirror homeassistant.helpers.config_validation.multi_select.
-
-    The options flow's admin picker uses HA's supported multi-select
-    validator (schema-serializable by HA's frontend); the mock provides
-    the same contract: a list whose members are keys of ``choices``.
-    """
-
-    def _validate(selected):
-        if not isinstance(selected, list):
-            raise vol.Invalid("Not a list")
-        for value in selected:
-            if value not in choices:
-                raise vol.Invalid(f"{value} is not a valid option")
-        return selected
-
-    return _validate
-
-
-_ha_mock("homeassistant.helpers.config_validation").multi_select = _multi_select
-
-
 # ---------------------------------------------------------------------------
 # Shared helpers for the behavior tests.
 # ---------------------------------------------------------------------------
@@ -244,129 +200,16 @@ class ListenerRegistry:
         return sum(len(listeners) for listeners in self._listeners.values())
 
 
-class TimeChangeRegistry:
-    """Models HA's time-change listener bookkeeping.
-
-    ``track`` mirrors ``homeassistant.helpers.event.async_track_time_change``:
-    each call appends a record (action + hour/minute/second) and returns
-    a remove callable that reverses the registration.  Tests inspect
-    ``registrations`` and exercise the newest action through :meth:`fire`.
-    """
-
-    def __init__(self, hass=None):
-        self._hass = hass
-        self._registrations: list[dict] = []
-
-    def track(self, action, hour=None, minute=None, second=None):
-        record = {
-            "action": action,
-            "hour": hour,
-            "minute": minute,
-            "second": second,
-        }
-
-        def _remove():
-            self._registrations.remove(record)
-
-        record["remove"] = _remove
-        self._registrations.append(record)
-        return _remove
-
-    @property
-    def registrations(self):
-        """Return a copy of the live registrations."""
-        return list(self._registrations)
-
-    @property
-    def size(self) -> int:
-        """Number of live registrations."""
-        return len(self._registrations)
-
-    async def fire(self, now=None, index: int = -1):
-        """Run a registered action as HA's scheduler would, awaiting coroutines."""
-        result = self._registrations[index]["action"](now)
-        if inspect.isawaitable(result):
-            await result
-
-
-def _async_track_time_change(hass, action, hour=None, minute=None, second=None):
-    """Mirror homeassistant.helpers.event.async_track_time_change.
-
-    Exact HA 2024.6 signature — no ``local`` keyword: the local-time
-    wrapper is already this function.  Routes to the registry attached to
-    ``hass`` (created on demand), so tests reach the registrations via
-    ``hass.time_change``.
-    """
-    registry = getattr(hass, "time_change", None)
-    if registry is None:
-        registry = TimeChangeRegistry(hass)
-        hass.time_change = registry
-    return registry.track(action, hour=hour, minute=minute, second=second)
-
-
-_ha_mock("homeassistant.helpers.event").async_track_time_change = _async_track_time_change
-
-
-class ServiceRegistry:
-    """Models HA's ``hass.services`` service registry.
-
-    ``async_register`` stores a handler under its (domain, service) key,
-    ``has_service`` reports registration, and ``async_remove`` removes it
-    — exactly the surface Home Assistant's ``ServiceRegistry`` exposes
-    (there is deliberately NO ``async_unregister`` alias here, so a caller
-    that uses the wrong method name fails instead of being silently
-    papered over).  ``call`` invokes a stored handler the way HA's service
-    bus would — awaiting a coroutine result — so tests can exercise a
-    registered service end-to-end.
-    """
-
-    def __init__(self, hass=None):
-        self._hass = hass
-        self._services: dict[tuple[str, str], object] = {}
-
-    def async_register(self, domain, service, func, schema=None, supports_response=None):
-        self._services[(domain, service)] = func
-        return None
-
-    def has_service(self, domain, service):
-        return (domain, service) in self._services
-
-    def async_remove(self, domain, service):
-        self._services.pop((domain, service), None)
-        return None
-
-    async def call(self, domain, service, data=None):
-        func = self._services.get((domain, service))
-        if func is None:
-            raise KeyError(f"service {domain}.{service} not registered")
-        call = SimpleNamespace(domain=domain, service=service, data=data or {})
-        result = func(call)
-        if inspect.isawaitable(result):
-            await result
-        return result
-
-    @property
-    def registered_services(self):
-        """The registered (domain, service) pairs."""
-        return list(self._services)
-
-
 def make_config_entry(
     entry_id: str = "test_entry",
     options: dict | None = None,
     data: dict | None = None,
-    context: dict | None = None,
 ):
-    """Create a stub config entry shaped like HA's ConfigEntry for tests.
-
-    ``context`` mirrors HA's entry context (the flow that created the
-    entry carries the acting HA user under ``context["user_id"]``).
-    """
+    """Create a stub config entry shaped like HA's ConfigEntry for tests."""
     entry = SimpleNamespace(
         entry_id=entry_id,
         options=dict(options or {}),
         data=dict(data or {}),
-        context=dict(context or {}),
     )
     entry.add_update_listener = None
     return entry
@@ -390,10 +233,6 @@ def make_hass() -> tuple:
         config=MagicMock(),
         config_entries=SimpleNamespace(async_reload=None),
     )
-    # hass.auth mirrors the real surface the integration reads: an
-    # async_get_users list the tests can repoint at will (the setup
-    # path resolves HA owner accounts as the last-resort admin seed).
-    hass.auth = SimpleNamespace(async_get_users=AsyncMock(return_value=[]))
 
     def _cleanup_config_dir():
         import shutil
@@ -412,11 +251,6 @@ def make_hass() -> tuple:
 
     hass.async_add_executor_job = _run_executor_job
     registry = ListenerRegistry(hass)
-    hass.time_change = TimeChangeRegistry(hass)
-    hass.services = ServiceRegistry(hass)
-    # A valid IANA time zone (the day-rollover listener reads it to
-    # compute "today" in HA local time).
-    hass.config.time_zone = "UTC"
 
     async def _async_reload(entry_id: str) -> None:
         registry.reloaded.append(entry_id)
@@ -454,15 +288,8 @@ async def hass():
 def make_entry():
     """Provide the config-entry factory as a fixture."""
 
-    def _factory(
-        entry_id: str = "test_entry",
-        options: dict | None = None,
-        data: dict | None = None,
-        context: dict | None = None,
-    ):
-        return make_config_entry(
-            entry_id=entry_id, options=options, data=data, context=context
-        )
+    def _factory(entry_id: str = "test_entry", options: dict | None = None, data: dict | None = None):
+        return make_config_entry(entry_id=entry_id, options=options, data=data)
 
     return _factory
 

tests/test_admin_allowlist.py

@@ -1,471 +0,0 @@
-"""Tests for admin_allowlist.py: the Feature 03 allowlist business layer."""
-from __future__ import annotations
-
-import asyncio
-from types import SimpleNamespace
-from unittest.mock import AsyncMock, MagicMock
-
-import pytest
-
-from custom_components.nestquest import async_setup_entry, async_unload_entry
-from custom_components.nestquest.admin_allowlist import (
-    list_admin_ids,
-    seed_setup_admin,
-    set_admin_ids,
-)
-from custom_components.nestquest.dao_children import AdminUsersDao
-from custom_components.nestquest.db import NestQuestDatabase
-from custom_components.nestquest.migrations import apply_migrations
-
-
-def _run(coro):
-    return asyncio.new_event_loop().run_until_complete(coro)
-
-
-def _make_hass_mock():
-    hass = MagicMock()
-    hass.async_add_executor_job = AsyncMock(side_effect=(lambda fn, *a: fn(*a)))
-    return hass
-
-
-def _with_db(tmp_path, name):
-    def _run_test(body):
-        async def _main():
-            database = NestQuestDatabase(_make_hass_mock())
-            await database.open(tmp_path / name)
-            try:
-                await apply_migrations(database)
-                return await body(database)
-            finally:
-                await database.close()
-
-        return _run(_main())
-
-    return _run_test
-
-
-# ---------------------------------------------------------------------------
-# set_admin_ids: read/write with the fail-closed guarantee
-# ---------------------------------------------------------------------------
-
-
-def test_set_admin_ids_round_trip(tmp_path) -> None:
-    async def _body(database):
-        await set_admin_ids(database, ["user-owner", "user-parent"])
-        # Membership is the contract; AdminUsersDao.list orders by id.
-        assert sorted(await list_admin_ids(database)) == [
-            "user-owner",
-            "user-parent",
-        ]
-        # Replace: the removed id is gone, the new one present.
-        await set_admin_ids(database, ["user-parent", "user-grandma"])
-        assert sorted(await list_admin_ids(database)) == [
-            "user-grandma",
-            "user-parent",
-        ]
-        return await list_admin_ids(database)
-
-    _with_db(tmp_path, "set-round-trip.db")(_body)
-
-
-def test_set_admin_ids_rejects_empty_allowlist(tmp_path) -> None:
-    """Removing the last admin (or saving an empty selection) is
-    refused with a clear error: an empty allowlist fails closed, so
-    the owner must never be able to reach one through this API."""
-    async def _body(database):
-        await set_admin_ids(database, ["user-owner"])
-        with pytest.raises(ValueError, match="at least one admin"):
-            await set_admin_ids(database, [])
-        # The refused write left the allowlist intact.
-        assert await list_admin_ids(database) == ["user-owner"]
-        return None
-
-    _with_db(tmp_path, "set-empty-refused.db")(_body)
-
-
-@pytest.mark.parametrize(
-    "bad", [None, "notalist", [42], [None], [""], ["  "], 5]
-)
-def test_set_admin_ids_rejects_malformed_input(tmp_path, bad) -> None:
-    async def _body(database):
-        with pytest.raises(ValueError):
-            await set_admin_ids(database, bad)
-        assert await list_admin_ids(database) == []
-        return None
-
-    _with_db(tmp_path, "set-malformed.db")(_body)
-
-
-def test_set_admin_ids_rejects_duplicates(tmp_path) -> None:
-    async def _body(database):
-        with pytest.raises(ValueError, match="duplicates"):
-            await set_admin_ids(database, ["user-a", "user-a"])
-        assert await list_admin_ids(database) == []
-        return None
-
-    _with_db(tmp_path, "set-duplicates.db")(_body)
-
-
-def test_set_admin_ids_trims_and_replaces_atomically(tmp_path) -> None:
-    async def _body(database):
-        await set_admin_ids(database, ["  user-a  "])
-        assert await list_admin_ids(database) == ["user-a"]
-        # Sync that both adds and removes in one write.
-        await set_admin_ids(database, ["user-b", "user-c"])
-        assert await list_admin_ids(database) == ["user-b", "user-c"]
-        return None
-
-    _with_db(tmp_path, "set-trim.db")(_body)
-
-
-# ---------------------------------------------------------------------------
-# seed_setup_admin: the owner is never locked out on first setup
-# ---------------------------------------------------------------------------
-
-
-def test_seed_adds_context_user_on_first_setup(tmp_path) -> None:
-    async def _body(database):
-        seeded = await seed_setup_admin(
-            database, stored_admin_ids=None, context_user_id="owner-1"
-        )
-        assert seeded == ["owner-1"]
-        assert await list_admin_ids(database) == ["owner-1"]
-        return seeded
-
-    _with_db(tmp_path, "seed-context.db")(_body)
-
-
-def test_seed_prefers_stored_entry_ids_over_context(tmp_path) -> None:
-    async def _body(database):
-        seeded = await seed_setup_admin(
-            database,
-            stored_admin_ids=["user-a", "user-b"],
-            context_user_id="owner-1",
-        )
-        assert seeded == ["user-a", "user-b"]
-        return seeded
-
-    _with_db(tmp_path, "seed-stored.db")(_body)
-
-
-def test_seed_leaves_nonempty_allowlist_untouched(tmp_path) -> None:
-    """Re-running setup must never resurrect a deliberately narrowed
-    list: only an EMPTY allowlist is seeded."""
-    async def _body(database):
-        await set_admin_ids(database, ["user-kept"])
-        seeded = await seed_setup_admin(
-            database,
-            stored_admin_ids=["user-a", "user-b"],
-            context_user_id="owner-1",
-        )
-        assert seeded == ["user-kept"]
-        assert await list_admin_ids(database) == ["user-kept"]
-        return seeded
-
-    _with_db(tmp_path, "seed-narrowed.db")(_body)
-
-
-def test_seed_with_nothing_available_leaves_empty(tmp_path) -> None:
-    async def _body(database):
-        seeded = await seed_setup_admin(
-            database, stored_admin_ids=None, context_user_id=None
-        )
-        assert seeded == []
-        return seeded
-
-    _with_db(tmp_path, "seed-nothing.db")(_body)
-
-
-def test_seed_rejects_malformed_candidates(tmp_path) -> None:
-    async def _body(database):
-        with pytest.raises(ValueError):
-            await seed_setup_admin(
-                database, stored_admin_ids=[42], context_user_id=None
-            )
-        with pytest.raises(ValueError):
-            await seed_setup_admin(
-                database, stored_admin_ids=None, context_user_id="  "
-            )
-        assert await list_admin_ids(database) == []
-        return None
-
-    _with_db(tmp_path, "seed-malformed.db")(_body)
-
-
-# ---------------------------------------------------------------------------
-# Setup wiring: async_setup_entry seeds automatically
-# ---------------------------------------------------------------------------
-
-
-async def _setup_entry(hass, entry, registry):
-    from tests.test_lifecycle import _wire
-
-    entry = _wire(entry, registry)
-    await async_setup_entry(hass, entry)
-    return entry
-
-
-async def test_setup_seeds_allowlist_from_entry_context(
-    hass, make_entry
-) -> None:
-    entry = await _setup_entry(
-        hass,
-        make_entry(context={"user_id": "ha-owner"}),
-        hass.registry,
-    )
-    database = entry.runtime_data.database
-    try:
-        assert await list_admin_ids(database) == ["ha-owner"]
-    finally:
-        await database.close()
-    assert await async_unload_entry(hass, entry) is True
-
-
-async def test_setup_seeds_allowlist_from_stored_entry_data(
-    hass, make_entry
-) -> None:
-    """A lost database re-seeded from the entry's stored admin copy."""
-    from custom_components.nestquest.const import CONF_ADMIN_USER_IDS
-
-    entry = await _setup_entry(
-        hass,
-        make_entry(data={CONF_ADMIN_USER_IDS: ["user-a", "user-b"]}),
-        hass.registry,
-    )
-    database = entry.runtime_data.database
-    try:
-        assert await list_admin_ids(database) == ["user-a", "user-b"]
-    finally:
-        await database.close()
-    assert await async_unload_entry(hass, entry) is True
-
-
-async def test_setup_without_context_leaves_allowlist_empty(
-    hass, make_entry
-) -> None:
-    """Fail closed: no context user and no stored copy means an empty
-    allowlist — nobody is admin until the owner configures it."""
-    entry = await _setup_entry(hass, make_entry(), hass.registry)
-    database = entry.runtime_data.database
-    try:
-        assert await list_admin_ids(database) == []
-    finally:
-        await database.close()
-    assert await async_unload_entry(hass, entry) is True
-
-
-async def test_setup_does_not_reseed_narrowed_allowlist(
-    hass, make_entry
-) -> None:
-    from custom_components.nestquest import async_unload_entry
-    from custom_components.nestquest.const import CONF_ADMIN_USER_IDS
-
-    entry = await _setup_entry(
-        hass, make_entry(context={"user_id": "ha-owner"}), hass.registry
-    )
-    database = entry.runtime_data.database
-    await set_admin_ids(database, ["user-parent"])
-    await database.close()
-    assert await async_unload_entry(hass, entry) is True
-
-    # Reload with the SAME context: the narrowed list survives.
-    entry_reloaded = await _setup_entry(
-        hass, make_entry(context={"user_id": "ha-owner"}), hass.registry
-    )
-    database_b = entry_reloaded.runtime_data.database
-    try:
-        assert await list_admin_ids(database_b) == ["user-parent"]
-    finally:
-        await database.close()
-    assert await async_unload_entry(hass, entry_reloaded) is True
-
-
-async def test_setup_seed_prefers_options_over_entry_data(
-    hass, make_entry
-) -> None:
-    """Seed precedence on a fresh database: the options flow's saved
-    list (the current one) beats the config flow's original copy."""
-    from custom_components.nestquest.const import CONF_ADMIN_USER_IDS
-
-    entry = await _setup_entry(
-        hass,
-        make_entry(
-            options={CONF_ADMIN_USER_IDS: ["user-current"]},
-            data={CONF_ADMIN_USER_IDS: ["ha-owner"]},
-            context={"user_id": "ha-owner"},
-        ),
-        hass.registry,
-    )
-    database = entry.runtime_data.database
-    try:
-        assert await list_admin_ids(database) == ["user-current"]
-    finally:
-        await database.close()
-    assert await async_unload_entry(hass, entry) is True
-
-
-async def test_setup_owner_fallback_seeds_owner_accounts(
-    hass, make_entry
-) -> None:
-    """Last-resort seed: with no persisted copy and no flow-context
-    user, HA owner accounts are seeded so first setup is never
-    ownerless (the real flow may lose the context; owners can already
-    do everything in HA)."""
-    from unittest.mock import AsyncMock
-
-    hass.auth.async_get_users = AsyncMock(
-        return_value=[
-            SimpleNamespace(id="owner-1", is_owner=True),
-            SimpleNamespace(id="member-1", is_owner=False),
-            SimpleNamespace(id="owner-2", is_owner=True),
-        ]
-    )
-    entry = await _setup_entry(hass, make_entry(), hass.registry)
-    database = entry.runtime_data.database
-    try:
-        assert sorted(await list_admin_ids(database)) == ["owner-1", "owner-2"]
-    finally:
-        await database.close()
-    assert await async_unload_entry(hass, entry) is True
-
-
-async def test_setup_owner_fallback_not_used_when_context_present(
-    hass, make_entry
-) -> None:
-    """The context user (flow caller) wins over the owner fallback:
-    a non-owner parent configuring the integration becomes the admin."""
-    from unittest.mock import AsyncMock
-
-    hass.auth.async_get_users = AsyncMock(
-        return_value=[SimpleNamespace(id="owner-1", is_owner=True)]
-    )
-    entry = await _setup_entry(
-        hass,
-        make_entry(context={"user_id": "parent-configured"}),
-        hass.registry,
-    )
-    database = entry.runtime_data.database
-    try:
-        assert await list_admin_ids(database) == ["parent-configured"]
-    finally:
-        await database.close()
-    assert await async_unload_entry(hass, entry) is True
-
-
-def test_seed_owner_ids_argument(tmp_path) -> None:
-    async def _body(database):
-        # Malformed owner lists are rejected like any other candidate —
-        # while the allowlist is still empty, so the seed proceeds far
-        # enough to validate.
-        with pytest.raises(ValueError):
-            await seed_setup_admin(
-                database,
-                stored_admin_ids=None,
-                context_user_id=None,
-                owner_ids=[7],
-            )
-        assert await list_admin_ids(database) == []
-        seeded = await seed_setup_admin(
-            database,
-            stored_admin_ids=None,
-            context_user_id=None,
-            owner_ids=["owner-1"],
-        )
-        assert seeded == ["owner-1"]
-        return seeded
-
-    _with_db(tmp_path, "seed-owner-arg.db")(_body)
-
-
-async def test_reopened_setup_failure_closes_database(
-    hass, make_entry, monkeypatch
-) -> None:
-    """A seeding failure on the reopened-record path closes the just-
-    opened connection before re-raising (no leaked handles across HA's
-    setup retries)."""
-    import pytest as pytest_module
-    from unittest.mock import AsyncMock
-
-    import custom_components.nestquest as nestquest_module
-    from custom_components.nestquest.db import NestQuestDatabase
-
-    # First: a successful setup to create the runtime record and file.
-    entry = await _setup_entry(hass, make_entry(), hass.registry)
-    await async_unload_entry(hass, entry)
-
-    # Now a re-setup whose seeding fails after the reopen.
-    async def _failing_seed(database, **kwargs):
-        raise RuntimeError("seed boom")
-
-    monkeypatch.setattr(
-        nestquest_module, "seed_setup_admin", _failing_seed, raising=True
-    )
-
-    close_calls: list[bool] = []
-    original_close = NestQuestDatabase.close
-
-    async def _spy_close(self):
-        close_calls.append(True)
-        return await original_close(self)
-
-    monkeypatch.setattr(NestQuestDatabase, "close", _spy_close)
-
-    with pytest_module.raises(RuntimeError, match="seed boom"):
-        await _setup_entry(hass, entry, hass.registry)
-    # The reopen path opened AND closed a connection; the failure is
-    # the last thing observed.
-    assert close_calls[-1] is True
-
-
-# ---------------------------------------------------------------------------
-# is_admin: the fail-closed resolver (Feature 09's verdict function)
-# ---------------------------------------------------------------------------
-
-
-def test_is_admin_verdict_matrix(tmp_path) -> None:
-    async def _body(database):
-        from custom_components.nestquest.admin_allowlist import is_admin
-
-        await set_admin_ids(database, ["user-owner"])
-        assert await is_admin(database, "user-owner") is True
-        assert await is_admin(database, "user-other") is False
-        # Unknown, malformed, and absent identities all fail closed.
-        assert await is_admin(database, "") is False
-        assert await is_admin(database, "  user-owner  ") is False, (
-            "ids are stored trimmed; an untrimmed lookup is a different "
-            "id and must not match"
-        )
-        assert await is_admin(database, None) is False
-        assert await is_admin(database, 42) is False
-        assert await is_admin(database, ["user-owner"]) is False
-        assert await is_admin(database, True) is False
-        return None
-
-    _with_db(tmp_path, "resolver-matrix.db")(_body)
-
-
-def test_is_admin_empty_allowlist_fails_closed(tmp_path) -> None:
-    """An empty allowlist returns False for EVERYONE, not True."""
-    async def _body(database):
-        from custom_components.nestquest.admin_allowlist import is_admin
-
-        for candidate in ("user-owner", "", None, 1):
-            assert await is_admin(database, candidate) is False
-        return None
-
-    _with_db(tmp_path, "resolver-empty.db")(_body)
-
-
-def test_is_admin_false_after_last_admin_removal_attempt(tmp_path) -> None:
-    """The refusal keeps the verdict sound: a refused removal leaves
-    the admin in place, so is_admin still resolves True."""
-    async def _body(database):
-        from custom_components.nestquest.admin_allowlist import is_admin
-
-        await set_admin_ids(database, ["user-owner"])
-        with pytest.raises(ValueError, match="at least one admin"):
-            await set_admin_ids(database, [])
-        assert await is_admin(database, "user-owner") is True
-        return None
-
-    _with_db(tmp_path, "resolver-refusal.db")(_body)

tests/test_children_registry.py

@@ -1,842 +0,0 @@
-"""Tests for children.py: the Feature 03 child-profile business layer."""
-from __future__ import annotations
-
-import asyncio
-import logging
-import re
-from unittest.mock import AsyncMock, MagicMock
-
-import pytest
-
-from custom_components.nestquest.children import (
-    create_child,
-    edit_child,
-    list_children,
-    reorder_children,
-    set_child_active,
-)
-from custom_components.nestquest.dao_children import ChildRecord, ChildrenDao
-from custom_components.nestquest.db import NestQuestDatabase
-from custom_components.nestquest.migrations import apply_migrations
-
-
-def _run(coro):
-    return asyncio.new_event_loop().run_until_complete(coro)
-
-
-def _make_hass_mock():
-    hass = MagicMock()
-    hass.async_add_executor_job = AsyncMock(side_effect=(lambda fn, *a: fn(*a)))
-    return hass
-
-
-def _with_db(tmp_path, name):
-    def _run_test(body):
-        async def _main():
-            database = NestQuestDatabase(_make_hass_mock())
-            await database.open(tmp_path / name)
-            try:
-                await apply_migrations(database)
-                return await body(database)
-            finally:
-                await database.close()
-
-        return _run(_main())
-
-    return _run_test
-
-
-# ---------------------------------------------------------------------------
-# create_child: required, trimmed display name
-# ---------------------------------------------------------------------------
-
-
-def test_create_child_returns_typed_record(tmp_path) -> None:
-    async def _body(database):
-        child = await create_child(
-            database,
-            "  Declan  ",
-            colour="#2E7D32",
-            avatar_ref="avatars/declan.png",
-            sort_order=2,
-        )
-        assert isinstance(child, ChildRecord)
-        # The name is trimmed before storage.
-        assert child.display_name == "Declan"
-        assert child.colour == "#2E7D32"
-        assert child.avatar_ref == "avatars/declan.png"
-        assert child.sort_order == 2
-        assert child.is_active is True
-        # The business layer stamps created_at in strict UTC shape.
-        assert re.fullmatch(
-            r"\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\+00:00", child.created_at
-        )
-        return child
-
-    _with_db(tmp_path, "create-typed.db")(_body)
-
-
-def test_create_child_defaults(tmp_path) -> None:
-    async def _body(database):
-        child = await create_child(database, "Chloe")
-        assert child.display_name == "Chloe"
-        assert child.colour is None
-        assert child.avatar_ref is None
-        assert child.sort_order == 0
-        return child
-
-    _with_db(tmp_path, "create-defaults.db")(_body)
-
-
-@pytest.mark.parametrize("bad", ["", "   ", "\t\n", None])
-def test_create_child_missing_name_rejected(tmp_path, bad) -> None:
-    async def _body(database):
-        with pytest.raises(ValueError, match="display_name is required"):
-            await create_child(database, bad)
-        assert await list_children(database) == []
-        return None
-
-    _with_db(tmp_path, "create-empty-name.db")(_body)
-
-
-@pytest.mark.parametrize("bad", [42, ["Ada"], 3.5])
-def test_create_child_non_string_name_rejected(tmp_path, bad) -> None:
-    async def _body(database):
-        with pytest.raises(ValueError, match="must be a string"):
-            await create_child(database, bad)
-        return None
-
-    _with_db(tmp_path, "create-bad-name-type.db")(_body)
-
-
-def test_create_child_optional_text_fields_validated(tmp_path) -> None:
-    async def _body(database):
-        with pytest.raises(ValueError, match="colour must be a string"):
-            await create_child(database, "Ada", colour=7)
-        with pytest.raises(ValueError, match="avatar_ref must be a string"):
-            await create_child(database, "Ada", avatar_ref=1.5)
-        return None
-
-    _with_db(tmp_path, "create-bad-optional.db")(_body)
-
-
-@pytest.mark.parametrize("bad", ["2", 1.5, True, None])
-def test_create_child_sort_order_must_be_int(tmp_path, bad) -> None:
-    async def _body(database):
-        with pytest.raises(ValueError, match="sort_order must be an integer"):
-            await create_child(database, "Ada", sort_order=bad)
-        return None
-
-    _with_db(tmp_path, "create-bad-order.db")(_body)
-
-
-# ---------------------------------------------------------------------------
-# create_child: duplicate display name allowed but warned
-# ---------------------------------------------------------------------------
-
-
-def test_create_child_duplicate_name_allowed_and_warned(
-    tmp_path, caplog
-) -> None:
-    async def _body(database):
-        first = await create_child(database, "Ada")
-        with caplog.at_level(
-            logging.WARNING, logger="custom_components.nestquest.children"
-        ):
-            second = await create_child(database, "  ADA ")
-        # Whitespace/case-normalised duplicate: allowed, both rows exist.
-        assert first.display_name == "Ada"
-        assert second.display_name == "ADA"
-        names = [c.display_name for c in await list_children(database)]
-        assert names == ["Ada", "ADA"]
-        warnings = [
-            r for r in caplog.records if "duplicates existing child" in r.getMessage()
-        ]
-        assert len(warnings) == 1, (
-            "exactly one duplicate warning for the second create"
-        )
-        assert "Ada" in warnings[0].getMessage()
-        return second
-
-    _with_db(tmp_path, "create-duplicate.db")(_body)
-
-
-def test_create_child_distinct_name_logs_no_warning(
-    tmp_path, caplog
-) -> None:
-    async def _body(database):
-        await create_child(database, "Ada")
-        caplog.clear()
-        await create_child(database, "Jordyn")
-        warnings = [
-            r for r in caplog.records if "duplicates existing child" in r.getMessage()
-        ]
-        assert warnings == []
-        return None
-
-    _with_db(tmp_path, "create-no-duplicate.db")(_body)
-
-
-# ---------------------------------------------------------------------------
-# edit_child: returns the updated record
-# ---------------------------------------------------------------------------
-
-
-def test_edit_child_updates_fields_and_returns_record(tmp_path) -> None:
-    async def _body(database):
-        child = await create_child(database, "Ada", colour="#111111")
-        edited = await edit_child(
-            database,
-            child.id,
-            display_name="  Ada L. ",
-            colour="#222222",
-            avatar_ref="avatars/ada.png",
-            sort_order=3,
-        )
-        assert isinstance(edited, ChildRecord)
-        assert edited.id == child.id
-        assert edited.display_name == "Ada L."
-        assert edited.colour == "#222222"
-        assert edited.avatar_ref == "avatars/ada.png"
-        assert edited.sort_order == 3
-        # The stored row reflects every edit.
-        stored = await list_children(database)
-        assert len(stored) == 1
-        assert stored[0] == edited
-        return edited
-
-    _with_db(tmp_path, "edit-round-trip.db")(_body)
-
-
-def test_edit_child_omitted_fields_unchanged(tmp_path) -> None:
-    async def _body(database):
-        child = await create_child(
-            database, "Ada", colour="#111111", sort_order=5
-        )
-        edited = await edit_child(database, child.id, sort_order=9)
-        # Only sort_order moved; colour and name untouched.
-        assert edited.sort_order == 9
-        assert edited.colour == "#111111"
-        assert edited.display_name == "Ada"
-        return edited
-
-    _with_db(tmp_path, "edit-partial.db")(_body)
-
-
-def test_edit_child_no_fields_returns_current_record(tmp_path) -> None:
-    async def _body(database):
-        child = await create_child(database, "Ada", colour="#111111")
-        edited = await edit_child(database, child.id)
-        assert edited == child
-        return edited
-
-    _with_db(tmp_path, "edit-noop.db")(_body)
-
-
-def test_edit_child_missing_raises(tmp_path) -> None:
-    async def _body(database):
-        with pytest.raises(ValueError, match="does not exist"):
-            await edit_child(database, 999, display_name="X")
-        return None
-
-    _with_db(tmp_path, "edit-missing.db")(_body)
-
-
-@pytest.mark.parametrize("bad", [True, False, 1.0, "1", None])
-def test_edit_child_non_int_id_rejected(tmp_path, bad) -> None:
-    """SQLite binds bools as integers: True must not address child 1,
-    and floats must not round onto a real profile."""
-    async def _body(database):
-        child = await create_child(database, "Ada")
-        with pytest.raises(ValueError, match="child_id must be an integer"):
-            await edit_child(database, bad, display_name="X")
-        # The refused edit left the profile untouched.
-        assert (await list_children(database))[0].display_name == "Ada"
-        return None
-
-    _with_db(tmp_path, "edit-bad-id.db")(_body)
-
-
-@pytest.mark.parametrize("bad", [True, False, 1.0, "1", None])
-def test_set_child_active_non_int_id_rejected(tmp_path, bad) -> None:
-    async def _body(database):
-        child = await create_child(database, "Ada")
-        with pytest.raises(ValueError, match="child_id must be an integer"):
-            await set_child_active(database, bad, False)
-        assert (await list_children(database))[0].is_active is True
-        return None
-
-    _with_db(tmp_path, "set-active-bad-id.db")(_body)
-
-
-def test_edit_child_name_validation(tmp_path) -> None:
-    async def _body(database):
-        child = await create_child(database, "Ada")
-        for bad in ("", "   ", None, 42):
-            with pytest.raises(ValueError, match="display_name"):
-                await edit_child(database, child.id, display_name=bad)
-        # The failed edits left the record untouched.
-        assert (await list_children(database))[0].display_name == "Ada"
-        return None
-
-    _with_db(tmp_path, "edit-name-validation.db")(_body)
-
-
-def test_edit_child_sort_order_must_be_int(tmp_path) -> None:
-    async def _body(database):
-        child = await create_child(database, "Ada")
-        with pytest.raises(ValueError, match="sort_order must be an integer"):
-            await edit_child(database, child.id, sort_order="3")
-        return None
-
-    _with_db(tmp_path, "edit-bad-order.db")(_body)
-
-
-def test_edit_child_explicit_none_clear_rejected(tmp_path) -> None:
-    """Clearing is refused loudly, not silently ignored: the DAO cannot
-    express NULL writes, so an explicit None must never masquerade as a
-    no-op."""
-    async def _body(database):
-        child = await create_child(database, "Ada", colour="#111111")
-        with pytest.raises(ValueError, match="clearing colour"):
-            await edit_child(database, child.id, colour=None)
-        with pytest.raises(ValueError, match="clearing avatar_ref"):
-            await edit_child(database, child.id, avatar_ref=None)
-        # The refused clears left the colour intact.
-        assert (await list_children(database))[0].colour == "#111111"
-        return None
-
-    _with_db(tmp_path, "edit-clear-unsupported.db")(_body)
-
-
-def test_edit_child_rename_to_duplicate_warns_but_different_name_not(
-    tmp_path, caplog
-) -> None:
-    async def _body(database):
-        ada = await create_child(database, "Ada")
-        bo = await create_child(database, "Bo")
-        caplog.clear()
-        # Renaming Bo onto Ada's name warns (different child's name).
-        edited = await edit_child(database, bo.id, display_name="ada")
-        assert edited.display_name == "ada"
-        warnings = [
-            r for r in caplog.records if "duplicates existing child" in r.getMessage()
-        ]
-        assert len(warnings) == 1
-        assert "Ada" in warnings[0].getMessage()
-        return edited
-
-    _with_db(tmp_path, "edit-rename-duplicate.db")(_body)
-
-
-def test_edit_child_rename_to_own_name_casing_alone_warns_not(
-    tmp_path, caplog
-) -> None:
-    """Renaming a child to their own name (casing aside) is not a
-    duplicate when NO OTHER child carries the normalised name."""
-    async def _body(database):
-        ada = await create_child(database, "Ada")
-        caplog.clear()
-        edited = await edit_child(database, ada.id, display_name="ADA")
-        assert edited.display_name == "ADA"
-        assert not any(
-            "duplicates existing child" in r.getMessage()
-            for r in caplog.records
-        )
-        return edited
-
-    _with_db(tmp_path, "edit-rename-self.db")(_body)
-
-
-def test_create_child_concurrent_same_name_still_warns(tmp_path) -> None:
-    """Racing creates of the same normalised name cannot slip through
-    unlogged: the scan and INSERT are serialized on the connection
-    lock, so the second create sees the first's committed row and
-    warns.  Deterministic gate on task A's INSERT while task B queues
-    behind the lock.  Without the lock, B's scan would run before A's
-    INSERT commits and no warning would fire."""
-    async def _main():
-        armed = {"active": False, "gated": False}
-        gate_open = asyncio.Event()
-        a_started = asyncio.Event()
-        hass = _gated_hass(armed, gate_open, a_started)
-        database = NestQuestDatabase(hass)
-        await database.open(tmp_path / "create-race.db")
-        try:
-            await apply_migrations(database)
-            logger = logging.getLogger(
-                "custom_components.nestquest.children"
-            )
-            seen: list[logging.LogRecord] = []
-
-            class _Capture(logging.Handler):
-                def emit(self, record: logging.LogRecord) -> None:
-                    seen.append(record)
-
-            handler = _Capture()
-            logger.addHandler(handler)
-            try:
-                armed["active"] = True
-                task_a = asyncio.ensure_future(
-                    create_child(database, "Ada")
-                )
-                await a_started.wait()
-                armed["active"] = False
-                task_b = asyncio.ensure_future(
-                    create_child(database, " ada ")
-                )
-                await asyncio.sleep(0)
-                gate_open.set()
-                first, second = await asyncio.gather(task_a, task_b)
-            finally:
-                logger.removeHandler(handler)
-
-            # Both creates land; the duplicate is allowed.
-            assert first.display_name == "Ada"
-            assert second.display_name == "ada"
-            names = [c.display_name for c in await list_children(database)]
-            assert names == ["Ada", "ada"]
-            # Exactly one warning: B's scan saw A's committed row.
-            warnings = [
-                r for r in seen if "duplicates existing child" in r.getMessage()
-            ]
-            assert len(warnings) == 1, (
-                "the queued duplicate create must warn exactly once"
-            )
-            assert "Ada" in warnings[0].getMessage()
-        finally:
-            await database.close()
-
-    _run(_main())
-
-
-def test_edit_child_case_only_edit_colliding_with_other_child_warns(
-    tmp_path, caplog
-) -> None:
-    """A case-only edit must not hide a real duplicate: with two Ada
-    profiles already present, editing either one's name to another
-    casing still warns (the scan excludes only the edited child)."""
-    async def _body(database):
-        first = await create_child(database, "Ada")
-        await create_child(database, "ada")
-        caplog.clear()
-        edited = await edit_child(database, first.id, display_name="ADA")
-        assert edited.display_name == "ADA"
-        warnings = [
-            r for r in caplog.records if "duplicates existing child" in r.getMessage()
-        ]
-        assert len(warnings) == 1
-        # Editing the name to a value that STAYS duplicated (no change,
-        # other child still carries it) warns too: the scan is on the
-        # resulting state, not on whether the word moved.
-        caplog.clear()
-        await edit_child(database, first.id, display_name=" ada ")
-        warnings = [
-            r for r in caplog.records if "duplicates existing child" in r.getMessage()
-        ]
-        assert len(warnings) == 1
-        return None
-
-    _with_db(tmp_path, "edit-case-only-duplicate.db")(_body)
-
-
-# ---------------------------------------------------------------------------
-# set_child_active / list_children
-# ---------------------------------------------------------------------------
-
-
-def test_set_child_active_round_trip(tmp_path) -> None:
-    async def _body(database):
-        child = await create_child(database, "Ada")
-        deactivated = await set_child_active(database, child.id, False)
-        assert deactivated.is_active is False
-        assert [c.id for c in await list_children(database)] == [child.id]
-        assert await list_children(database, active_only=True) == []
-        reactivated = await set_child_active(database, child.id, True)
-        assert reactivated.is_active is True
-        assert len(await list_children(database, active_only=True)) == 1
-        return reactivated
-
-    _with_db(tmp_path, "set-active.db")(_body)
-
-
-def test_set_child_active_missing_raises(tmp_path) -> None:
-    async def _body(database):
-        with pytest.raises(ValueError, match="does not exist"):
-            await set_child_active(database, 999, False)
-        return None
-
-    _with_db(tmp_path, "set-active-missing.db")(_body)
-
-
-# ---------------------------------------------------------------------------
-# reorder_children: complete permutation or nothing changes
-# ---------------------------------------------------------------------------
-
-
-def test_reorder_children_persists_display_order(tmp_path) -> None:
-    async def _body(database):
-        first = await create_child(database, "Ada", sort_order=0)
-        second = await create_child(database, "Bo", sort_order=1)
-        third = await create_child(database, "Cleo", sort_order=2)
-        await reorder_children(database, [third.id, first.id, second.id])
-        # The active list returns children in the new sort order.
-        listed = await list_children(database, active_only=True)
-        assert [c.id for c in listed] == [third.id, first.id, second.id]
-        assert [c.sort_order for c in listed] == [0, 1, 2]
-        return listed
-
-    _with_db(tmp_path, "reorder-round-trip.db")(_body)
-
-
-def test_reorder_children_partial_list_rejected_order_unchanged(
-    tmp_path,
-) -> None:
-    async def _body(database):
-        first = await create_child(database, "Ada", sort_order=0)
-        second = await create_child(database, "Bo", sort_order=1)
-        third = await create_child(database, "Cleo", sort_order=2)
-        with pytest.raises(ValueError, match="missing child ids"):
-            await reorder_children(database, [third.id, first.id])
-        listed = await list_children(database)
-        # Nothing changed: rejection happens before any write.
-        assert [c.id for c in listed] == [first.id, second.id, third.id]
-        assert [c.sort_order for c in listed] == [0, 1, 2]
-        return listed
-
-    _with_db(tmp_path, "reorder-partial.db")(_body)
-
-
-def test_reorder_children_unknown_id_rejected_order_unchanged(
-    tmp_path,
-) -> None:
-    async def _body(database):
-        first = await create_child(database, "Ada", sort_order=0)
-        second = await create_child(database, "Bo", sort_order=1)
-        with pytest.raises(ValueError, match="unknown child ids"):
-            await reorder_children(database, [second.id, first.id, 999])
-        listed = await list_children(database)
-        assert [c.id for c in listed] == [first.id, second.id]
-        assert [c.sort_order for c in listed] == [0, 1]
-        return listed
-
-    _with_db(tmp_path, "reorder-unknown.db")(_body)
-
-
-def test_reorder_children_empty_list_rejected_when_children_exist(
-    tmp_path,
-) -> None:
-    """An empty list is the maximally partial reorder: rejected while
-    any child exists (against an empty table it is a complete
-    permutation and stays a harmless no-op)."""
-    async def _body(database):
-        first = await create_child(database, "Ada", sort_order=0)
-        with pytest.raises(ValueError, match="missing child ids"):
-            await reorder_children(database, [])
-        assert [c.sort_order for c in await list_children(database)] == [0]
-        return None
-
-    _with_db(tmp_path, "reorder-empty.db")(_body)
-
-
-def test_reorder_children_duplicate_and_non_int_rejected(tmp_path) -> None:
-    async def _body(database):
-        first = await create_child(database, "Ada", sort_order=0)
-        second = await create_child(database, "Bo", sort_order=1)
-        with pytest.raises(ValueError, match="duplicate child ids"):
-            await reorder_children(database, [first.id, first.id, second.id])
-        with pytest.raises(ValueError, match="child_id must be an integer"):
-            await reorder_children(database, [first.id, second.id, True])
-        with pytest.raises(ValueError, match="child_id must be an integer"):
-            await reorder_children(database, [first.id, second.id, "3"])
-        listed = await list_children(database)
-        assert [c.sort_order for c in listed] == [0, 1]
-        return listed
-
-    _with_db(tmp_path, "reorder-bad-inputs.db")(_body)
-
-
-def test_reorder_children_inactive_children_included(tmp_path) -> None:
-    """Inactive children keep their display position: the permutation
-    covers the whole table, not just the active list."""
-    async def _body(database):
-        first = await create_child(database, "Ada", sort_order=0)
-        second = await create_child(database, "Bo", sort_order=1)
-        await set_child_active(database, second.id, False)
-        # Both ids are required even though one is inactive.
-        await reorder_children(database, [second.id, first.id])
-        listed = await list_children(database)
-        assert [c.id for c in listed] == [second.id, first.id]
-        assert [c.sort_order for c in listed] == [0, 1]
-        # The active list skips the inactive child but keeps position.
-        assert [c.id for c in await list_children(database, active_only=True)] == [
-            first.id
-        ]
-        return listed
-
-    _with_db(tmp_path, "reorder-inactive.db")(_body)
-
-
-@pytest.mark.parametrize("bad", ["1", "0", 1, 0, 1.0, None, "true"])
-def test_set_child_active_rejects_non_bool(tmp_path, bad) -> None:
-    """The DAO's int() would silently coerce "1"/0/1.0 into a state the
-    caller never asked for; the business layer refuses non-bools."""
-    async def _body(database):
-        child = await create_child(database, "Ada")
-        with pytest.raises(ValueError, match="is_active must be a real bool"):
-            await set_child_active(database, child.id, bad)
-        # The refused transition left the child untouched.
-        assert (await list_children(database))[0].is_active is True
-        return None
-
-    _with_db(tmp_path, "set-active-non-bool.db")(_body)
-
-
-# ---------------------------------------------------------------------------
-# Concurrency: edit/set_active are atomic under the connection lock
-# ---------------------------------------------------------------------------
-
-
-def _gated_hass(armed: dict, gate_open: asyncio.Event, a_started: asyncio.Event):
-    """A hass mock whose executor gates the FIRST `_execute` job after
-    arming — the mutate statement of whichever business call starts
-    first — proving the caller holds the connection lock at that
-    moment and the second caller must queue behind it."""
-    from unittest.mock import MagicMock
-
-    hass = MagicMock()
-
-    async def _gated_executor(fn, *args):
-        if armed["active"]:
-            if getattr(fn, "__name__", "") == "_execute" and not armed["gated"]:
-                armed["gated"] = True
-                a_started.set()
-                await gate_open.wait()
-        return fn(*args)
-
-    hass.async_add_executor_job = _gated_executor
-    return hass
-
-
-def test_edit_child_concurrent_opposite_edits_return_own_values(
-    tmp_path,
-) -> None:
-    """Two racing edits cannot cross-contaminate each other's readback.
-
-    Deterministic gate: task A is paused at its UPDATE (it provably
-    holds the connection lock), task B is then created and must queue;
-    A's readback runs before B's edit, so A returns A's value and B
-    returns B's.  Without the lock, A's readback would see B's write.
-    """
-    async def _main():
-        armed = {"active": False, "gated": False}
-        gate_open = asyncio.Event()
-        a_started = asyncio.Event()
-        hass = _gated_hass(armed, gate_open, a_started)
-        database = NestQuestDatabase(hass)
-        await database.open(tmp_path / "edit-race.db")
-        try:
-            await apply_migrations(database)
-            child = await create_child(
-                database, "Ada", colour="#111111", sort_order=0
-            )
-
-            armed["active"] = True
-            task_a = asyncio.ensure_future(
-                edit_child(database, child.id, colour="#AAAAAA", sort_order=1)
-            )
-            await a_started.wait()
-            armed["active"] = False
-            task_b = asyncio.ensure_future(
-                edit_child(
-                    database, child.id, colour="#BBBBBB", sort_order=2
-                )
-            )
-            await asyncio.sleep(0)
-            gate_open.set()
-            record_a, record_b = await asyncio.gather(task_a, task_b)
-
-            # Each caller gets back exactly what it wrote.
-            assert record_a.colour == "#AAAAAA"
-            assert record_a.sort_order == 1
-            assert record_b.colour == "#BBBBBB"
-            assert record_b.sort_order == 2
-            # B landed last: the stored row is B's (read via the DAO —
-            # the children leak guard forbids raw probes here).
-            stored = await ChildrenDao(database).get(child.id)
-            assert stored is not None
-            assert (stored.colour, stored.sort_order) == ("#BBBBBB", 2)
-        finally:
-            await database.close()
-
-    _run(_main())
-
-
-def test_set_child_active_concurrent_opposite_transitions_return_own(
-    tmp_path,
-) -> None:
-    """Racing activate/deactivate calls each report their own request.
-
-    Same deterministic gate on task A's UPDATE; task B queues behind
-    the connection lock and lands the opposite transition after A.
-    """
-    async def _main():
-        armed = {"active": False, "gated": False}
-        gate_open = asyncio.Event()
-        a_started = asyncio.Event()
-        hass = _gated_hass(armed, gate_open, a_started)
-        database = NestQuestDatabase(hass)
-        await database.open(tmp_path / "active-race.db")
-        try:
-            await apply_migrations(database)
-            child = await create_child(database, "Ada")
-
-            armed["active"] = True
-            task_a = asyncio.ensure_future(
-                set_child_active(database, child.id, False)
-            )
-            await a_started.wait()
-            armed["active"] = False
-            task_b = asyncio.ensure_future(
-                set_child_active(database, child.id, True)
-            )
-            await asyncio.sleep(0)
-            gate_open.set()
-            record_a, record_b = await asyncio.gather(task_a, task_b)
-
-            assert record_a.is_active is False
-            assert record_b.is_active is True
-            stored = await ChildrenDao(database).get(child.id)
-            assert stored is not None
-            assert stored.is_active is True
-        finally:
-            await database.close()
-
-    _run(_main())
-
-
-def test_list_children_orders_by_sort_order_then_id(tmp_path) -> None:
-    async def _body(database):
-        second = await create_child(database, "Bo", sort_order=1)
-        first = await create_child(database, "Ada", sort_order=0)
-        third = await create_child(database, "Cleo", sort_order=1)
-        listed = await list_children(database)
-        # sort_order 0 first, then the two sort_order-1 rows by id.
-        assert [c.id for c in listed] == [first.id, second.id, third.id]
-        return listed
-
-    _with_db(tmp_path, "list-order.db")(_body)
-
-
-# ---------------------------------------------------------------------------
-# Deactivation keeps every referencing row intact (Feature 03)
-# ---------------------------------------------------------------------------
-
-
-def test_deactivating_child_preserves_definitions_instances_events(
-    tmp_path,
-) -> None:
-    async def _body(database):
-        from datetime import date, timedelta
-
-        from custom_components.nestquest.dao_children import ChildrenDao
-        from custom_components.nestquest.dao_instances import (
-            CompletionEventsDao,
-            QuestInstancesDao,
-        )
-        from custom_components.nestquest.dao_rules import (
-            QuestDefinitionsDao,
-            ScheduleRulesDao,
-        )
-
-        children = ChildrenDao(database)
-        rules = ScheduleRulesDao(database)
-        definitions = QuestDefinitionsDao(database)
-        instances = QuestInstancesDao(database)
-        events = CompletionEventsDao(database)
-
-        child = await create_child(database, "Ada")
-        rule = await rules.create("daily", "2026-01-01")
-        definition = await definitions.create(
-            "Brush teeth",
-            rule.id,
-            "2026-09-15T12:00:00+00:00",
-            assignee_child_ids=[child.id],
-        )
-        due = (date.today() + timedelta(days=1)).isoformat()
-        stamp = f"{due}T08:00:00+00:00"
-        instance = await instances.upsert(
-            definition.id, child.id, due, stamp, window="morning"
-        )
-        event = await events.append(
-            instance.id,
-            child.id,
-            "completed",
-            "panel",
-            f"{due}T09:00:00+00:00",
-            True,
-            actor_child_id=child.id,
-        )
-
-        # Deactivate: the referencing rows must not move.
-        deactivated = await set_child_active(database, child.id, False)
-        assert deactivated.is_active is False
-        assert await children.get(child.id) == deactivated
-        assert (await definitions.get(definition.id)) == definition
-        assert (await instances.get_by_id(instance.id)) == instance
-        assert await events.list_by_instance(instance.id) == [event]
-        # Excluded from the active list, still present in the full list.
-        assert await list_children(database, active_only=True) == []
-        assert [c.id for c in await list_children(database)] == [child.id]
-
-        # Reactivate: fully restored.
-        reactivated = await set_child_active(database, child.id, True)
-        assert reactivated.is_active is True
-        assert [c.id for c in await list_children(database, active_only=True)] == [
-            child.id
-        ]
-        assert (await instances.get_by_id(instance.id)) == instance
-        return reactivated
-
-    _with_db(tmp_path, "deactivate-data-intact.db")(_body)
-
-
-def test_no_code_path_deletes_a_child_row() -> None:
-    """Structural guardrail: children are deactivated, never deleted.
-
-    The DAO exposes no delete method at all, and no module in the
-    package (nor any test outside the sanctioned DDL/migration layers,
-    which create the tables) carries a statement that removes child
-    rows — the leak guard in test_dao_children enforces the file
-    allowlist, this asserts the no-delete property itself across every
-    file that may legitimately name the table.
-    """
-    import re
-    from pathlib import Path
-
-    package = Path(
-        __import__(
-            "custom_components.nestquest", fromlist=["__file__"]
-        ).__file__
-    ).parent
-
-    delete_pattern = re.compile(
-        r"DELETE\s+(FROM\s+)?((main|temp)\s*\.\s*)?[`'\"]*(\[)?children\b",
-        re.IGNORECASE,
-    )
-    for py in sorted(package.rglob("*.py")):
-        assert delete_pattern.search(py.read_text()) is None, (
-            f"a code path in {py.name} deletes child rows"
-        )
-
-    import inspect
-
-    from custom_components.nestquest.dao_children import ChildrenDao
-
-    methods = {
-        name
-        for name, _ in inspect.getmembers(ChildrenDao, inspect.isfunction)
-    }
-    assert not any(
-        name.startswith("delete") or name == "remove" for name in methods
-    ), f"ChildrenDao exposed a delete-shaped method: {methods}"

tests/test_completion.py

@@ -1,446 +0,0 @@
-"""Tests for completion.py: the Feature 08 append-only business layer."""
-from __future__ import annotations
-
-import asyncio
-import datetime
-import inspect
-import re
-
-import pytest
-
-from custom_components.nestquest.completion import append_event, instance_state
-from custom_components.nestquest.dao_children import ChildrenDao
-from custom_components.nestquest.dao_instances import (
-    EVENT_COMPLETED,
-    EVENT_UNCOMPLETED,
-    CompletionEventRecord,
-    CompletionEventsDao,
-    QuestInstancesDao,
-)
-from custom_components.nestquest.dao_rules import (
-    QuestDefinitionsDao,
-    ScheduleRulesDao,
-)
-from custom_components.nestquest.db import NestQuestDatabase
-from custom_components.nestquest.migrations import apply_migrations
-
-
-def _run(coro):
-    return asyncio.new_event_loop().run_until_complete(coro)
-
-
-def _make_hass_mock():
-    from unittest.mock import AsyncMock, MagicMock
-
-    hass = MagicMock()
-    hass.async_add_executor_job = AsyncMock(side_effect=(lambda fn, *a: fn(*a)))
-    return hass
-
-
-def _today_iso() -> str:
-    return datetime.date.today().isoformat()
-
-
-def _now_stamp() -> str:
-    return f"{_today_iso()}T08:00:00+00:00"
-
-
-def _future_day(offset: int) -> str:
-    return (
-        datetime.date.today() + datetime.timedelta(days=offset)
-    ).isoformat()
-
-
-D1 = _future_day(1)
-
-
-async def _prepare(path) -> tuple:
-    database = NestQuestDatabase(_make_hass_mock())
-    await database.open(path)
-    await apply_migrations(database)
-    children = ChildrenDao(database)
-    rules = ScheduleRulesDao(database)
-    definitions = QuestDefinitionsDao(database)
-    instances = QuestInstancesDao(database)
-    child = await children.create("Ada", _now_stamp())
-    rule = await rules.create("daily", D1)
-    definition = await definitions.create(
-        "Brush teeth", rule.id, _now_stamp(), assignee_child_ids=[child.id]
-    )
-    instance = await instances.upsert(
-        definition.id, child.id, D1, _now_stamp(), window="morning"
-    )
-    return database, child, instance
-
-
-def _with_db(tmp_path, name):
-    def _run_test(body):
-        async def _main():
-            prepared = await _prepare(tmp_path / name)
-            try:
-                return await body(*prepared)
-            finally:
-                await prepared[0].close()
-
-        return _run(_main())
-
-    return _run_test
-
-
-# ---------------------------------------------------------------------------
-# inverted actor shapes: field-naming ValueErrors, no write
-# ---------------------------------------------------------------------------
-
-
-def test_user_without_actor_user_id_rejected() -> None:
-    async def _body():
-        with pytest.raises(ValueError, match="actor_user_id"):
-            await append_event(
-                object(),
-                1,
-                1,
-                EVENT_COMPLETED,
-                actor_source="user",
-                was_on_time=True,
-            )
-        with pytest.raises(ValueError, match="actor_user_id"):
-            await append_event(
-                object(),
-                1,
-                1,
-                EVENT_COMPLETED,
-                actor_source="user",
-                actor_user_id=None,
-                was_on_time=True,
-            )
-        with pytest.raises(ValueError, match="actor_user_id"):
-            await append_event(
-                object(),
-                1,
-                1,
-                EVENT_COMPLETED,
-                actor_source="user",
-                actor_user_id="",
-                was_on_time=True,
-            )
-
-    _run(_body())
-
-
-def test_user_must_not_carry_actor_child_id() -> None:
-    async def _body():
-        with pytest.raises(ValueError, match="actor_child_id"):
-            await append_event(
-                object(),
-                1,
-                1,
-                EVENT_COMPLETED,
-                actor_source="user",
-                actor_user_id="user-1",
-                actor_child_id=1,
-                was_on_time=True,
-            )
-
-    _run(_body())
-
-
-def test_panel_must_not_carry_actor_user_id() -> None:
-    async def _body():
-        with pytest.raises(ValueError, match="actor_user_id"):
-            await append_event(
-                object(),
-                1,
-                1,
-                EVENT_COMPLETED,
-                actor_source="panel",
-                actor_user_id="user-1",
-                actor_child_id=1,
-                was_on_time=True,
-            )
-
-    _run(_body())
-
-
-def test_panel_requires_actor_child_id() -> None:
-    async def _body():
-        with pytest.raises(ValueError, match="actor_child_id"):
-            await append_event(
-                object(),
-                1,
-                1,
-                EVENT_COMPLETED,
-                actor_source="panel",
-                was_on_time=True,
-            )
-
-    _run(_body())
-
-
-def test_actor_source_service_rejected() -> None:
-    async def _body():
-        with pytest.raises(ValueError, match="actor_source"):
-            await append_event(
-                object(),
-                1,
-                1,
-                EVENT_COMPLETED,
-                actor_source="service",
-                actor_user_id="user-1",
-                was_on_time=True,
-            )
-
-    _run(_body())
-
-
-def test_completed_requires_was_on_time() -> None:
-    async def _body():
-        with pytest.raises(ValueError, match="was_on_time"):
-            await append_event(
-                object(),
-                1,
-                1,
-                EVENT_COMPLETED,
-                actor_source="user",
-                actor_user_id="user-1",
-            )
-
-    _run(_body())
-
-
-# ---------------------------------------------------------------------------
-# happy paths
-# ---------------------------------------------------------------------------
-
-
-def test_user_append_round_trips(tmp_path) -> None:
-    async def _body(database, child, instance):
-        event = await append_event(
-            database,
-            instance.id,
-            child.id,
-            EVENT_COMPLETED,
-            actor_source="user",
-            actor_user_id="user-1",
-            was_on_time=True,
-        )
-        assert isinstance(event, CompletionEventRecord)
-        assert event.event_type == EVENT_COMPLETED
-        assert event.actor_source == "user"
-        assert event.actor_user_id == "user-1"
-        assert event.actor_child_id is None
-        assert event.was_on_time is True
-        assert re.fullmatch(
-            r"\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\+00:00", event.occurred_at
-        )
-        return event
-
-    _with_db(tmp_path, "user-append.db")(_body)
-
-
-def test_panel_append_round_trips(tmp_path) -> None:
-    async def _body(database, child, instance):
-        event = await append_event(
-            database,
-            instance.id,
-            child.id,
-            EVENT_COMPLETED,
-            actor_source="panel",
-            actor_child_id=child.id,
-            was_on_time=False,
-        )
-        assert event.actor_source == "panel"
-        assert event.actor_user_id is None
-        assert event.actor_child_id == child.id
-        assert event.was_on_time is False
-        assert re.fullmatch(
-            r"\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\+00:00", event.occurred_at
-        )
-        return event
-
-    _with_db(tmp_path, "panel-append.db")(_body)
-
-
-def test_uncompleted_allows_null_was_on_time(tmp_path) -> None:
-    async def _body(database, child, instance):
-        event = await append_event(
-            database,
-            instance.id,
-            child.id,
-            EVENT_UNCOMPLETED,
-            actor_source="user",
-            actor_user_id="user-1",
-            was_on_time=None,
-        )
-        assert event.event_type == EVENT_UNCOMPLETED
-        assert event.was_on_time is None
-        return event
-
-    _with_db(tmp_path, "uncompleted-null.db")(_body)
-
-
-def test_now_pins_occurred_at_utc(tmp_path) -> None:
-    async def _body(database, child, instance):
-        pinned = datetime.datetime(
-            2026, 9, 18, 8, 0, 0, tzinfo=datetime.timezone.utc
-        )
-        event = await append_event(
-            database,
-            instance.id,
-            child.id,
-            EVENT_COMPLETED,
-            actor_source="user",
-            actor_user_id="user-1",
-            was_on_time=True,
-            now=pinned,
-        )
-        assert event.occurred_at == "2026-09-18T08:00:00+00:00"
-        return event
-
-    _with_db(tmp_path, "pinned-now.db")(_body)
-
-
-# ---------------------------------------------------------------------------
-# append-only: the module never exposes update/delete
-# ---------------------------------------------------------------------------
-
-
-def test_module_never_exposes_update_or_delete() -> None:
-    import custom_components.nestquest.completion as completion
-
-    public = {
-        name
-        for name, _ in inspect.getmembers(completion, inspect.isfunction)
-        if not name.startswith("_")
-    }
-    forbidden = {
-        name
-        for name in public
-        if name.startswith(
-            (
-                "update",
-                "delete",
-                "set",
-                "clear",
-                "remove",
-                "modify",
-                "edit",
-                "upsert",
-            )
-        )
-    }
-    assert forbidden == set(), (
-        f"completion.py exposed mutation methods: {forbidden}"
-    )
-    assert "append_event" in public
-    assert "instance_state" in public
-    assert "complete_instance" not in public
-    assert "uncomplete_instance" not in public
-    source = inspect.getsource(completion)
-    assert "UPDATE" not in source
-    assert "DELETE" not in source
-    assert "INSERT" not in source
-
-
-# ---------------------------------------------------------------------------
-# instance_state: derived from the latest event
-# ---------------------------------------------------------------------------
-
-
-def test_instance_state_open_when_no_events(tmp_path) -> None:
-    async def _body(database, child, instance):
-        assert await instance_state(database, instance.id) == "open"
-
-    _with_db(tmp_path, "state-none.db")(_body)
-
-
-def test_instance_state_open_when_latest_uncompleted(tmp_path) -> None:
-    async def _body(database, child, instance):
-        await append_event(
-            database,
-            instance.id,
-            child.id,
-            EVENT_COMPLETED,
-            actor_source="user",
-            actor_user_id="user-1",
-            was_on_time=True,
-        )
-        await append_event(
-            database,
-            instance.id,
-            child.id,
-            EVENT_UNCOMPLETED,
-            actor_source="user",
-            actor_user_id="user-1",
-        )
-        assert await instance_state(database, instance.id) == "open"
-
-    _with_db(tmp_path, "state-uncompleted.db")(_body)
-
-
-def test_instance_state_unknown_instance_id_raises(tmp_path) -> None:
-    async def _body(database, child, instance):
-        with pytest.raises(ValueError, match="instance_id"):
-            await instance_state(database, instance.id + 999)
-
-    _with_db(tmp_path, "state-unknown.db")(_body)
-
-
-def test_instance_state_rejects_non_integer_id() -> None:
-    async def _body():
-        with pytest.raises(ValueError, match="instance_id"):
-            await instance_state(object(), "1")
-        with pytest.raises(ValueError, match="instance_id"):
-            await instance_state(object(), True)
-
-    _run(_body())
-
-
-def test_instance_state_three_events_returns_done_and_preserves_rows(
-    tmp_path,
-) -> None:
-    async def _body(database, child, instance):
-        base = datetime.datetime(
-            2026, 9, 18, 8, 0, 0, tzinfo=datetime.timezone.utc
-        )
-        await append_event(
-            database,
-            instance.id,
-            child.id,
-            EVENT_COMPLETED,
-            actor_source="user",
-            actor_user_id="user-1",
-            was_on_time=True,
-            now=base,
-        )
-        await append_event(
-            database,
-            instance.id,
-            child.id,
-            EVENT_UNCOMPLETED,
-            actor_source="user",
-            actor_user_id="user-1",
-            now=base + datetime.timedelta(seconds=1),
-        )
-        await append_event(
-            database,
-            instance.id,
-            child.id,
-            EVENT_COMPLETED,
-            actor_source="user",
-            actor_user_id="user-1",
-            was_on_time=False,
-            now=base + datetime.timedelta(seconds=2),
-        )
-        events = CompletionEventsDao(database)
-        before = await events.list_by_instance(instance.id)
-        assert [e.event_type for e in before] == [
-            EVENT_COMPLETED,
-            EVENT_UNCOMPLETED,
-            EVENT_COMPLETED,
-        ]
-        assert await instance_state(database, instance.id) == "done"
-        after = await events.list_by_instance(instance.id)
-        assert after == before
-        assert len(after) == 3
-
-    _with_db(tmp_path, "state-three.db")(_body)

tests/test_config_flow.py

@@ -154,25 +154,4 @@ def test_no_hardcoded_domain_or_db_filename_in_new_modules() -> None:
                     )
                 assert node.value != "nestquest.db", (
                     f"Found hard-coded database filename in {py_file.name}:{node.lineno}"
-                )
-
-async def test_flow_persists_flow_user_as_initial_admin(hass, make_flow) -> None:
-    """The HA user completing the flow lands in entry data as the
-    initial admin copy: entry.context is not persisted by real HA, so
-    the durable record must carry the owner."""
-    from custom_components.nestquest.const import CONF_ADMIN_USER_IDS
-
-    flow = make_flow(hass)
-    flow.context = {"user_id": "ha-owner"}
-    result = await flow.async_step_user({})
-    assert result["type"] == "create_entry"
-    assert result["data"] == {CONF_ADMIN_USER_IDS: ["ha-owner"]}
-
-
-async def test_flow_without_context_user_keeps_data_untouched(
-    hass, make_flow
-) -> None:
-    flow = make_flow(hass)
-    result = await flow.async_step_user({"horizon_days": 7})
-    assert result["type"] == "create_entry"
-    assert result["data"] == {"horizon_days": 7}
+                )

tests/test_const.py

@@ -73,36 +73,6 @@ def test_panel_idle_timeout_config() -> None:
     assert const.DEFAULT_PANEL_IDLE_TIMEOUT > 0
 
 
-def test_quest_windows_canonical_order() -> None:
-    """QUEST_WINDOWS is exactly the three spellings in canonical order."""
-    assert const.QUEST_WINDOWS == ("morning", "afternoon", "evening")
-    assert const.WINDOW_MORNING == "morning"
-    assert const.WINDOW_AFTERNOON == "afternoon"
-    assert const.WINDOW_EVENING == "evening"
-    # No duplicates, every name covered by its individual constant.
-    assert len(set(const.QUEST_WINDOWS)) == 3
-
-
-def test_window_clock_ranges_cover_every_window() -> None:
-    """Each window has a strict HH:MM (start, end) range.
-
-    The ranges follow the documented boundaries (D-008): morning ends
-    11:59, afternoon spans 12:00-17:00, evening 17:00-21:00, and each
-    window's end equals the next window's start (the boundary belongs
-    to the later window at classification time).
-    """
-    assert const.WINDOW_CLOCK_RANGES == {
-        "morning": ("00:00", "11:59"),
-        "afternoon": ("12:00", "17:00"),
-        "evening": ("17:00", "21:00"),
-    }
-    for window in const.QUEST_WINDOWS:
-        start, end = const.WINDOW_CLOCK_RANGES[window]
-        for value in (start, end):
-            parsed = datetime.strptime(value, "%H:%M").time()
-            assert parsed.strftime("%H:%M") == value
-
-
 def test_no_hardcoded_domain_or_db_filename_in_modules() -> None:
     """Ensure no module other than const.py hardcodes DOMAIN string or SQLITE_DB_FILENAME."""
     pkg_dir = Path(const.__file__).parent

tests/test_dao_children.py

@@ -1,889 +0,0 @@
-"""Tests for dao_children.py: typed DAO for children and admin_users."""
-from __future__ import annotations
-
-import asyncio
-import sqlite3
-
-import pytest
-
-from custom_components.nestquest.dao_children import (
-    AdminUserRecord,
-    AdminUsersDao,
-    ChildRecord,
-    ChildrenDao,
-)
-from custom_components.nestquest.db import NestQuestDatabase
-from custom_components.nestquest.schema import SCHEMA_V1_STATEMENTS
-from custom_components.nestquest.migrations import apply_migrations
-
-
-def _run(coro):
-    return asyncio.new_event_loop().run_until_complete(coro)
-
-
-def _make_hass_mock():
-    from unittest.mock import AsyncMock, MagicMock
-
-    hass = MagicMock()
-    hass.async_add_executor_job = AsyncMock(side_effect=(lambda fn, *a: fn(*a)))
-    return hass
-
-
-def _open_db(path) -> NestQuestDatabase:
-    database = NestQuestDatabase(_make_hass_mock())
-    _run(database.open(path))
-    _run(apply_migrations(database))
-    return database
-
-
-def _daos(database) -> tuple[ChildrenDao, AdminUsersDao]:
-    return ChildrenDao(database), AdminUsersDao(database)
-
-
-NOW = "2026-09-14T11:00:00+00:00"
-
-
-def _make_child(dao, name="Ada", **kwargs) -> ChildRecord:
-    return _run(dao.create(name, NOW, **kwargs))
-
-
-# ---------------------------------------------------------------------------
-# children: create and get
-# ---------------------------------------------------------------------------
-
-
-def test_create_returns_typed_record(tmp_path) -> None:
-    database = _open_db(tmp_path / "create.db")
-    try:
-        dao, _ = _daos(database)
-        child = _make_child(dao, colour="#ff0000", avatar_ref="avatars/1")
-        assert isinstance(child, ChildRecord)
-        assert child.id == 1
-        assert child.display_name == "Ada"
-        assert child.colour == "#ff0000"
-        assert child.avatar_ref == "avatars/1"
-        assert child.sort_order == 0
-        assert child.is_active is True
-        assert child.created_at == NOW
-    finally:
-        _run(database.close())
-
-
-def test_get_returns_none_for_missing_child(tmp_path) -> None:
-    database = _open_db(tmp_path / "get-missing.db")
-    try:
-        dao, _ = _daos(database)
-        assert _run(dao.get(999)) is None
-    finally:
-        _run(database.close())
-
-
-def test_create_duplicate_name_is_allowed(tmp_path) -> None:
-    database = _open_db(tmp_path / "dup-name.db")
-    try:
-        dao, _ = _daos(database)
-        first = _make_child(dao, "Ada")
-        second = _make_child(dao, "Ada")
-        assert first.id != second.id
-    finally:
-        _run(database.close())
-
-
-# ---------------------------------------------------------------------------
-# children: list active / list all
-# ---------------------------------------------------------------------------
-
-
-def test_list_active_excludes_inactive_and_sorts(tmp_path) -> None:
-    database = _open_db(tmp_path / "list-active.db")
-    try:
-        dao, _ = _daos(database)
-        _make_child(dao, "Bo", sort_order=2)
-        ada = _make_child(dao, "Ada", sort_order=1)
-        cy = _make_child(dao, "Cy", sort_order=1)
-        _make_child(dao, "Dee", sort_order=0)
-        _run(dao.set_active(ada.id, False))
-        active = _run(dao.list_active())
-        assert [c.display_name for c in active] == ["Dee", "Cy", "Bo"]
-        assert all(c.is_active for c in active)
-    finally:
-        _run(database.close())
-
-
-def test_list_all_includes_inactive(tmp_path) -> None:
-    database = _open_db(tmp_path / "list-all.db")
-    try:
-        dao, _ = _daos(database)
-        ada = _make_child(dao, "Ada", sort_order=1)
-        _make_child(dao, "Bo", sort_order=0)
-        _run(dao.set_active(ada.id, False))
-        all_children = _run(dao.list_all())
-        assert [c.display_name for c in all_children] == ["Bo", "Ada"]
-        assert all_children[1].is_active is False
-    finally:
-        _run(database.close())
-
-
-# ---------------------------------------------------------------------------
-# children: update, set_active, reorder
-# ---------------------------------------------------------------------------
-
-
-def test_update_fields_round_trip(tmp_path) -> None:
-    database = _open_db(tmp_path / "update.db")
-    try:
-        dao, _ = _daos(database)
-        child = _make_child(dao, "Ada", colour="#111111")
-        updated = _run(
-            dao.update(
-                child.id,
-                display_name="Ada L.",
-                colour="#222222",
-                avatar_ref="avatars/x.png",
-            )
-        )
-        assert updated == 1
-        fetched = _run(dao.get(child.id))
-        assert fetched is not None
-        assert fetched.display_name == "Ada L."
-        assert fetched.colour == "#222222"
-        assert fetched.avatar_ref == "avatars/x.png"
-        assert fetched.sort_order == 0
-    finally:
-        _run(database.close())
-
-
-def test_update_omitted_fields_untouched(tmp_path) -> None:
-    database = _open_db(tmp_path / "update-partial.db")
-    try:
-        dao, _ = _daos(database)
-        child = _make_child(dao, "Ada", colour="#111111")
-        _run(dao.update(child.id, display_name="Ada L."))
-        fetched = _run(dao.get(child.id))
-        assert fetched.colour == "#111111"
-    finally:
-        _run(database.close())
-
-
-def test_update_no_fields_returns_zero_and_changes_nothing(tmp_path) -> None:
-    database = _open_db(tmp_path / "update-empty.db")
-    try:
-        dao, _ = _daos(database)
-        child = _make_child(dao, "Ada")
-        assert _run(dao.update(child.id)) == 0
-        fetched = _run(dao.get(child.id))
-        assert fetched is not None and fetched.display_name == "Ada"
-    finally:
-        _run(database.close())
-
-
-def test_update_missing_child_returns_zero(tmp_path) -> None:
-    database = _open_db(tmp_path / "update-missing.db")
-    try:
-        dao, _ = _daos(database)
-        assert _run(dao.update(999, display_name="X")) == 0
-    finally:
-        _run(database.close())
-
-
-def test_set_active_missing_child_returns_zero(tmp_path) -> None:
-    database = _open_db(tmp_path / "set-active-missing.db")
-    try:
-        dao, _ = _daos(database)
-        assert _run(dao.set_active(999, False)) == 0
-    finally:
-        _run(database.close())
-
-
-def test_reorder_assigns_positions_in_order(tmp_path) -> None:
-    database = _open_db(tmp_path / "reorder.db")
-    try:
-        dao, _ = _daos(database)
-        a = _make_child(dao, "Ada")
-        b = _make_child(dao, "Bo")
-        c = _make_child(dao, "Cy")
-        _run(dao.reorder([c.id, a.id, b.id]))
-        children = _run(dao.list_all())
-        assert [x.display_name for x in children] == ["Cy", "Ada", "Bo"]
-        assert [x.sort_order for x in children] == [0, 1, 2]
-    finally:
-        _run(database.close())
-
-
-def test_reorder_is_transactional_and_idempotent(tmp_path) -> None:
-    database = _open_db(tmp_path / "reorder-idempotent.db")
-    try:
-        dao, _ = _daos(database)
-        a = _make_child(dao, "Ada")
-        b = _make_child(dao, "Bo")
-        _run(dao.reorder([b.id, a.id]))
-        _run(dao.reorder([b.id, a.id]))
-        children = _run(dao.list_all())
-        assert [(x.display_name, x.sort_order) for x in children] == [
-            ("Bo", 0),
-            ("Ada", 1),
-        ]
-    finally:
-        _run(database.close())
-
-
-def test_reorder_empty_list_is_rejected(tmp_path) -> None:
-    """An empty list is the maximally partial reorder: rejected while
-    any child exists (Feature 03 reorder contract)."""
-    import pytest as pytest_module
-
-    database = _open_db(tmp_path / "reorder-empty.db")
-    try:
-        dao, _ = _daos(database)
-        _make_child(dao, "Ada")
-        with pytest_module.raises(ValueError, match="missing child ids"):
-            _run(dao.reorder([]))
-        children = _run(dao.list_all())
-        assert children[0].sort_order == 0
-    finally:
-        _run(database.close())
-
-
-def test_reorder_unknown_id_is_rejected(tmp_path) -> None:
-    """An unknown id is rejected before any write; the order is
-    untouched (Feature 03 reorder contract)."""
-    import pytest as pytest_module
-
-    database = _open_db(tmp_path / "reorder-unknown.db")
-    try:
-        dao, _ = _daos(database)
-        a = _make_child(dao, "Ada")
-        with pytest_module.raises(ValueError, match="unknown child ids"):
-            _run(dao.reorder([a.id, 999]))
-        children = _run(dao.list_all())
-        assert children[0].sort_order == 0
-    finally:
-        _run(database.close())
-
-
-def test_reorder_rolls_back_to_original_order_on_failure(tmp_path) -> None:
-    """A failing finalize batch rolls the whole reorder back.
-
-    The two-phase staging is only meaningful if a crash between the
-    batches leaves the original order intact: monkeypatch execute_many
-    so the finalize (non-negative) batch raises, then assert every
-    sort_order is unchanged.
-    """
-    database = _open_db(tmp_path / "reorder-rollback.db")
-    try:
-        dao, _ = _daos(database)
-        a = _make_child(dao, "Ada", sort_order=0)
-        b = _make_child(dao, "Bo", sort_order=1)
-
-        original_execute_many = database.execute_many
-
-        async def _failing_execute_many(sql, parameters):
-            # The staging batch writes negative positions; the finalize
-            # batch writes 0..n-1.  Fail the finalize batch.
-            if all(position >= 0 for position, _ in parameters):
-                raise sqlite3.OperationalError("boom")
-            return await original_execute_many(sql, parameters)
-
-        database.execute_many = _failing_execute_many
-        with pytest.raises(sqlite3.OperationalError, match="boom"):
-            _run(dao.reorder([b.id, a.id]))
-        children = _run(dao.list_all())
-        assert [(c.display_name, c.sort_order) for c in children] == [
-            ("Ada", 0),
-            ("Bo", 1),
-        ], "failed reorder must leave original sort orders intact"
-    finally:
-        _run(database.close())
-
-
-def test_reorder_rejects_duplicate_ids(tmp_path) -> None:
-    database = _open_db(tmp_path / "reorder-duplicate.db")
-    try:
-        dao, _ = _daos(database)
-        a = _make_child(dao, "Ada")
-        with pytest.raises(ValueError, match="duplicate"):
-            _run(dao.reorder([a.id, a.id]))
-        fetched = _run(dao.get(a.id))
-        assert fetched is not None and fetched.sort_order == 0
-    finally:
-        _run(database.close())
-
-
-def test_reorder_concurrent_calls_serialize(tmp_path) -> None:
-    """Concurrent reorders from DIFFERENT DAO instances queue safely.
-
-    Two ChildrenDao objects over one connection race two reorders: the
-    connection-scoped lock makes the second wait, then run against the
-    first call's final state.  Without the lock the wrapper's
-    transaction() would reject the second concurrent transaction with
-    RuntimeError.
-    """
-    async def _main() -> None:
-        database = NestQuestDatabase(_make_hass_mock())
-        await database.open(tmp_path / "reorder-concurrent.db")
-        try:
-            await apply_migrations(database)
-            dao_a, _ = _daos(database)
-            a = await dao_a.create("Ada", NOW)
-            b = await dao_a.create("Bo", NOW)
-            dao_b, _ = _daos(database)  # second instance, same connection
-            task_1 = asyncio.ensure_future(dao_a.reorder([b.id, a.id]))
-            await asyncio.sleep(0)
-            task_2 = asyncio.ensure_future(dao_b.reorder([a.id, b.id]))
-            await asyncio.gather(task_1, task_2)
-            children = await dao_a.list_all()
-            orders = {c.display_name: c.sort_order for c in children}
-            assert sorted(orders.values()) == [0, 1]
-        finally:
-            await database.close()
-
-    _run(_main())
-
-
-# ---------------------------------------------------------------------------
-# admin_users: add, remove, list, exists
-# ---------------------------------------------------------------------------
-
-
-def test_admin_add_then_exists(tmp_path) -> None:
-    database = _open_db(tmp_path / "admin-add.db")
-    try:
-        _, dao = _daos(database)
-        assert _run(dao.add("user-1", NOW)) is True
-        assert _run(dao.exists("user-1")) is True
-        assert _run(dao.exists("user-2")) is False
-    finally:
-        _run(database.close())
-
-
-def test_admin_add_is_idempotent(tmp_path) -> None:
-    database = _open_db(tmp_path / "admin-idempotent.db")
-    try:
-        _, dao = _daos(database)
-        assert _run(dao.add("user-1", NOW)) is True
-        assert _run(dao.add("user-1", NOW)) is False
-        records = _run(dao.list())
-        assert len(records) == 1
-        assert records[0].added_at == NOW
-    finally:
-        _run(database.close())
-
-
-def test_admin_add_concurrent_calls_are_idempotent(tmp_path) -> None:
-    """Concurrent add() calls of the same user: one inserts, rest False.
-
-    The single-statement ON CONFLICT DO NOTHING makes the decision and
-    the write atomic per statement, so racing coroutines cannot both
-    'see no row' and one of them raise IntegrityError.
-    """
-    async def _main() -> None:
-        database = NestQuestDatabase(_make_hass_mock())
-        await database.open(tmp_path / "admin-race.db")
-        try:
-            await apply_migrations(database)
-            _, dao = _daos(database)
-            tasks = [
-                asyncio.ensure_future(dao.add("user-1", NOW))
-                for _ in range(5)
-            ]
-            await asyncio.sleep(0)
-            results = list(await asyncio.gather(*tasks))
-            assert sorted(results) == [False, False, False, False, True]
-            records = await dao.list()
-            assert len(records) == 1
-            assert records[0].added_at == NOW
-        finally:
-            await database.close()
-
-    _run(_main())
-
-
-def test_admin_add_preserves_original_added_at(tmp_path) -> None:
-    database = _open_db(tmp_path / "admin-added-at.db")
-    try:
-        _, dao = _daos(database)
-        _run(dao.add("user-1", NOW))
-        _run(dao.add("user-1", "2026-09-15T00:00:00+00:00"))
-        records = _run(dao.list())
-        assert records[0].added_at == NOW
-    finally:
-        _run(database.close())
-
-
-def test_admin_remove_returns_true_then_false(tmp_path) -> None:
-    database = _open_db(tmp_path / "admin-remove.db")
-    try:
-        _, dao = _daos(database)
-        _run(dao.add("user-1", NOW))
-        assert _run(dao.remove("user-1")) is True
-        assert _run(dao.remove("user-1")) is False
-        assert _run(dao.exists("user-1")) is False
-    finally:
-        _run(database.close())
-
-
-def test_admin_list_returns_typed_records_ordered(tmp_path) -> None:
-    database = _open_db(tmp_path / "admin-list.db")
-    try:
-        _, dao = _daos(database)
-        _run(dao.add("user-2", "2026-09-14T10:00:00+00:00"))
-        _run(dao.add("user-1", "2026-09-14T09:00:00+00:00"))
-        records = _run(dao.list())
-        assert isinstance(records[0], AdminUserRecord)
-        assert [r.ha_user_id for r in records] == ["user-1", "user-2"]
-        assert records[0].added_at == "2026-09-14T09:00:00+00:00"
-    finally:
-        _run(database.close())
-
-
-def test_admin_exists_empty_allowlist_fails_closed(tmp_path) -> None:
-    database = _open_db(tmp_path / "admin-empty.db")
-    try:
-        _, dao = _daos(database)
-        assert _run(dao.exists("user-1")) is False
-        assert _run(dao.list()) == []
-    finally:
-        _run(database.close())
-
-
-def test_admin_records_are_typed_not_raw_rows(tmp_path) -> None:
-    database = _open_db(tmp_path / "admin-typed.db")
-    try:
-        _, dao = _daos(database)
-        _run(dao.add("user-1", NOW))
-        records = _run(dao.list())
-        assert records == [AdminUserRecord("user-1", NOW)]
-    finally:
-        _run(database.close())
-
-
-# ---------------------------------------------------------------------------
-# No SQL for these tables outside the DAO module
-# ---------------------------------------------------------------------------
-
-
-def test_children_and_admin_sql_lives_only_in_dao_module() -> None:
-    """Guardrail: children/admin_users SQL may appear only in the DAO
-    (and the schema DDL declarations).  Scans the integration package
-    AND the repo's test files RECURSIVELY, matching FROM/INTO/UPDATE/
-    DELETE FROM/JOIN against either table — including DELETE FROM
-    children, the hard-delete path the guardrail forbids.
-
-    Exclusions are exact repo-relative paths, narrowly justified:
-    schema.py declares the tables' DDL; migrations.py applies that DDL;
-    test_schema.py and test_migrations.py test exactly those
-    DDL/migration layers.  None of them touch the tables' data paths —
-    that is the DAO's job.
-    """
-    import re
-    from pathlib import Path
-
-    package = Path(
-        __import__(
-            "custom_components.nestquest", fromlist=["__file__"]
-        ).__file__
-    ).parent
-    repo_root = package.parent.parent
-    scan_roots = [package, repo_root / "tests"]
-
-    allowed = {
-        "custom_components/nestquest/dao_children.py",  # the DAO itself
-        "custom_components/nestquest/dao_rules.py",  # validates child
-        # activeness on assignment (FK to children, done-condition
-        # 'validates that the assigned child is active')
-        "custom_components/nestquest/dao_presence.py",  # validates the
-        # schedule/override child exists before writing (same FK shape
-        # as dao_rules: one existence SELECT per write)
-        "custom_components/nestquest/dao_instances.py",  # validates the
-        # instance/event child exists before writing (same FK shape)
-        "custom_components/nestquest/schema.py",  # declares the DDL
-        "custom_components/nestquest/migrations.py",  # applies the DDL
-        "tests/test_schema.py",  # tests the DDL
-        "tests/test_migrations.py",  # tests migration application
-        "tests/test_dao_children.py",  # this file, scanned separately
-        "tests/test_dao_rules.py",  # rules/definitions guard, own scope
-        "tests/test_dao_presence.py",  # presence guard, own scope
-        "tests/test_dao_instances.py",  # instances guard, own scope
-        "tests/test_startup_db.py",  # row-count probe of the children
-        # table only (proving a fresh setup loads); guard below covers
-        # everything else
-    }
-    sql_pattern = re.compile(
-        r"(FROM|INTO|UPDATE|DELETE\s+FROM|JOIN)\s+"
-        r'["\`]*(children|admin_users)["\`]*\b',
-        re.IGNORECASE,
-    )
-    offenders: list[str] = []
-    # test_dao_matrix.py is exempted for exactly its two sanctioned
-    # raw constraint-violation probes (NOT NULL on children, PRIMARY
-    # KEY on admin_users) — the Feature-02 closing suite must prove
-    # the schema surfaces violations to the DAO layer; its guard below
-    # covers everything else in that file.
-    probe_names = {
-        "test_matrix_children_crud_and_constraints",
-        "test_matrix_admin_users_crud_and_constraints",
-    }
-    for root in scan_roots:
-        for py in sorted(root.rglob("*.py")):
-            relative = py.relative_to(repo_root).as_posix()
-            if relative in allowed:
-                continue
-            text = py.read_text()
-            if relative == "tests/test_dao_matrix.py":
-                text = _strip_function_spans(text, probe_names)
-            if sql_pattern.search(text):
-                offenders.append(relative)
-    assert offenders == [], (
-        f"SQL touching children/admin_users leaked into: {offenders}"
-    )
-
-
-def _strip_function_spans(text: str, names: set[str]) -> str:
-    """Return ``text`` minus the source spans of the named functions."""
-    import ast
-
-    lines = text.splitlines(keepends=True)
-    excluded: set[int] = set()
-    tree = ast.parse(text)
-    for node in ast.walk(tree):
-        if (
-            isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef))
-            and node.name in names
-        ):
-            excluded.update(
-                range(node.lineno, (node.end_lineno or node.lineno) + 1)
-            )
-    return "".join(
-        line
-        for number, line in enumerate(lines, start=1)
-        if number not in excluded
-    )
-
-
-def test_startup_db_test_file_uses_dao_elsewhere() -> None:
-    """Compensating self-scan for the startup-test exemption: outside
-    the single sanctioned COUNT(*) probe, test_startup_db.py must go
-    through the DAO for children/admin_users data access.
-    """
-    import re
-    from pathlib import Path
-
-    startup_test = Path(__file__).parent / "test_startup_db.py"
-    stripped = _strip_function_spans(
-        startup_test.read_text(),
-        {"test_setup_with_valid_file_preserves_rows"},
-    )
-    sql_pattern = re.compile(
-        r"(SELECT\s[^\"']*?FROM|INSERT\s+INTO|UPDATE|DELETE\s+FROM|"
-        r"FROM|JOIN)\s+[`'\"]*(\[)?(children|admin_users)\b",
-        re.IGNORECASE,
-    )
-    assert sql_pattern.search(stripped) is None, (
-        "test_startup_db.py must go through the DAO for these tables "
-        "outside its sanctioned row-count probe"
-    )
-
-
-def test_dao_matrix_test_file_raw_probes_are_only_constraint_probes() -> None:
-    """Compensating self-scan for the matrix-file exemption, structurally
-    exact: parse the two sanctioned functions' ASTs and require that
-    (a) they contain NO other raw SQL naming children/admin_users, and
-    (b) every raw table insert among them is an expression nested inside
-    a ``pytest.raises`` context whose matcher mentions IntegrityError.
-    Any additional raw write elsewhere in the file fails this guard.
-    """
-    import ast
-    import re
-    from pathlib import Path
-
-    matrix = Path(__file__).parent / "test_dao_matrix.py"
-    text = matrix.read_text()
-    stripped = _strip_function_spans(
-        text,
-        {
-            "test_matrix_children_crud_and_constraints",
-            "test_matrix_admin_users_crud_and_constraints",
-        },
-    )
-    sql_pattern = re.compile(
-        r"(SELECT\s[^\"']*?FROM|INSERT\s+INTO|UPDATE|DELETE\s+FROM|"
-        r"FROM|JOIN)\s+[`'\"]*(\[)?(children|admin_users)\b",
-        re.IGNORECASE,
-    )
-    assert sql_pattern.search(stripped) is None, (
-        "test_dao_matrix.py raw children/admin_users SQL is limited to "
-        "the two sanctioned constraint probes"
-    )
-
-    tree = ast.parse(text)
-    probe_tables = {
-        "test_matrix_children_crud_and_constraints": ("children", "INSERT"),
-        "test_matrix_admin_users_crud_and_constraints": (
-            "admin_users",
-            "INSERT",
-        ),
-    }
-    any_table = re.compile(
-        r"\b(children|admin_users)\b", re.IGNORECASE
-    )
-    allowed_stmt = re.compile(
-        r"^(INSERT|SELECT)", re.IGNORECASE
-    )
-    #: The sanctioned probe per function: exactly one raw statement
-    #: INSERTing that table, inside a pytest.raises whose matcher is
-    #: IntegrityError (checked as an AST Name/Attribute chain).
-    probes_per_function: dict[str, int] = {name: 0 for name in probe_tables}
-    for node in ast.walk(tree):
-        if (
-            not isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef))
-            or node.name not in probe_tables
-        ):
-            continue
-        table, expected_verb = probe_tables[node.name]
-
-        def _unquote(rendered: str) -> str:
-            rendered = rendered.strip()
-            if len(rendered) >= 2 and rendered[0] == rendered[-1] and (
-                rendered[0] in "'\""
-            ):
-                return rendered[1:-1]
-            return rendered
-
-        # Collect EVERY database SQL entry point (execute, fetch_one,
-        # fetch_all, execute_many) wherever it appears in the awaited
-        # expression tree: a bypass through fetch_one/execute_many OR a
-        # call wrapped in another awaitable (asyncio.gather, a helper
-        # coroutine, a Task) must be caught the same as a bare await.
-        raw_statements: list[tuple[ast.AST, str]] = []
-        for sub in ast.walk(node):
-            if (
-                isinstance(sub, ast.Call)
-                and isinstance(sub.value if False else sub.func, ast.Attribute)
-                and sub.func.attr
-                in {"execute", "fetch_one", "fetch_all", "execute_many"}
-            ):
-                sql_arg = sub.args[0] if sub.args else None
-                rendered = ast.unparse(sql_arg) if sql_arg else ""
-                raw_statements.append((sub, _unquote(rendered)))
-
-        def _raises_blocks():
-            """Yield (block, is_pytest_integrity) for pytest.raises blocks.
-
-            Structurally exact: the call func must resolve to
-            pytest.raises — Attribute(pytest, raises) or a bare Name
-            whose id is bound to pytest via the file's own import
-            section (validated below).  The matcher argument must be an
-            AST chain whose final segment is exactly IntegrityError (so
-            NotIntegrityError and fake.IntegrityError fail).
-            """
-            # Names bound to pytest's raises: parse the FILE's actual
-            # Import nodes in TWO passes so order cannot matter — pass
-            # one collects every binding pytest's raises gets (whatever
-            # alias), pass two rejects ANY competing binding of those
-            # names (or of 'pytest' itself) from a non-pytest import,
-            # wherever it appears.  A spoof imported BEFORE the genuine
-            # binding therefore still fails.
-            pytest_raises_aliases: set[str] = set()
-            for file_node in ast.walk(tree):
-                if (
-                    isinstance(file_node, ast.ImportFrom)
-                    and file_node.module == "pytest"
-                ):
-                    for alias in file_node.names:
-                        if alias.name == "raises":
-                            pytest_raises_aliases.add(
-                                alias.asname or alias.name
-                            )
-            raises_bindings: set[str] = set(pytest_raises_aliases)
-            for file_node in ast.walk(tree):
-                if isinstance(file_node, ast.ImportFrom):
-                    if file_node.module == "pytest":
-                        continue
-                    for alias in file_node.names:
-                        bound = alias.asname or alias.name
-                        if bound in raises_bindings | {"pytest"}:
-                            raise AssertionError(
-                                f"shadowed import of {bound!r} from "
-                                f"{file_node.module!r} defeats the "
-                                "pytest.raises probe validation"
-                            )
-                elif isinstance(file_node, ast.Import):
-                    # import fake_module as pytest (or as any raises
-                    # alias) fails closed.  A plain `import pytest`
-                    # (alias.name == 'pytest', no asname) is the genuine
-                    # module binding and is allowed.
-                    for alias in file_node.names:
-                        bound = alias.asname or alias.name
-                        genuine_pytest = (
-                            alias.name == "pytest" and alias.asname is None
-                        )
-                        if bound in raises_bindings | {"pytest"} and (
-                            not genuine_pytest
-                        ):
-                            raise AssertionError(
-                                f"import shadowing {bound!r} defeats the "
-                                "pytest.raises probe validation"
-                            )
-            for sub in ast.walk(node):
-                if not (
-                    isinstance(sub, ast.With)
-                    and sub.items
-                    and isinstance(sub.items[0].context_expr, ast.Call)
-                ):
-                    continue
-                call = sub.items[0].context_expr
-                func = call.func
-                if isinstance(func, ast.Attribute):
-                    if (
-                        func.attr != "raises"
-                        or not isinstance(func.value, ast.Name)
-                        or func.value.id != "pytest"
-                    ):
-                        continue
-                elif isinstance(func, ast.Name):
-                    if func.id not in raises_bindings:
-                        continue
-                else:
-                    continue
-                matcher_ok = False
-                if call.args:
-                    matcher = call.args[0]
-                    matcher_ok = _is_integrity_error_node(matcher)
-                yield sub, matcher_ok
-
-        def _is_integrity_error_node(matcher) -> bool:
-            """True for an AST chain of Name/Attribute ending exactly at
-            IntegrityError: every Attribute base must itself be a Name
-            or Attribute (a Call base like __import__('x') fails)."""
-            node = matcher
-            while isinstance(node, ast.Attribute):
-                node = node.value
-            if not isinstance(node, ast.Name):
-                return False
-            final = matcher
-            while isinstance(final, ast.Attribute):
-                final = final.attr
-            return (
-                isinstance(final, str)
-                and ast.unparse(matcher).split(".")[-1] == "IntegrityError"
-            )
-
-        # INSERT OR variant / quoted / qualified / schema-qualified
-        # names: normalize the SQL so ANY spelling of an insert into
-        # the table counts as a table insert and requires the raises
-        # block.  Strip quotes/brackets/backticks from identifiers and
-        # drop any schema qualifier, whatever it is.
-        def _is_insert_into_table(rendered: str, table: str) -> bool:
-            insert_match = re.search(
-                r"\bINSERT(\s+OR\s+\w+)?\s+INTO\s+(.+)",
-                rendered,
-                flags=re.IGNORECASE | re.DOTALL,
-            )
-            if not insert_match:
-                return False
-            target = insert_match.group(2)
-            # Tokenize the target's leading identifier: strip quotes
-            # and brackets, take the LAST dot-separated segment,
-            # casefolded so 'CHILDREN' cannot bypass the lowercase
-            # table name the scan looks for.
-            identifier = re.split(r"[\s(]", target, maxsplit=1)[0]
-            segments = re.split(r"\.", identifier)
-            last = segments[-1].strip("`'\"[]")
-            return last.casefold() == table.casefold()
-
-        # In a sanctioned function, EVERY raw statement naming either
-        # table must be exactly that function's one expected-table
-        # constraint insert — an admin_users insert inside the children
-        # function (or vice versa) is a bypass attempt and fails here,
-        # as does any second insert of the expected table.
-        for stmt_node, rendered in raw_statements:
-            if not any_table.search(rendered):
-                continue
-            assert _is_insert_into_table(rendered, table), (
-                f"{node.name}: raw statement naming the other table is "
-                f"forbidden; only the {table} probe is sanctioned: "
-                f"{rendered[:80]!r}"
-            )
-            # This is the sanctioned probe: require pytest.raises
-            # with an exact IntegrityError matcher around it.
-            inside = any(
-                block.lineno <= stmt_node.lineno
-                and stmt_node.end_lineno <= block.end_lineno
-                and matcher_ok
-                for block, matcher_ok in _raises_blocks()
-            )
-            assert inside, (
-                f"the raw {table} insert in {node.name} must be nested "
-                "in a pytest.raises(...IntegrityError...) block "
-                "(expected-to-fail constraint probe, not a write)"
-            )
-            probes_per_function[node.name] += 1
-        # UPDATE/DELETE naming the tables anywhere in a sanctioned
-        # function is forbidden outright.
-        for _, rendered in raw_statements:
-            if any_table.search(rendered) and re.match(
-                r"(UPDATE|DELETE)", rendered.strip(), re.IGNORECASE
-            ):
-                raise AssertionError(
-                    f"{node.name} must not hold UPDATE/DELETE SQL for "
-                    f"children/admin_users: {rendered[:80]!r}"
-                )
-    assert all(
-        count == 1 for count in probes_per_function.values()
-    ) and len(probes_per_function) == 2, (
-        "each sanctioned function must hold exactly one raw constraint "
-        f"probe; found {probes_per_function}"
-    )
-
-
-
-def test_dao_test_file_uses_dao_not_raw_table_sql() -> None:
-    """This test module must exercise the DAO, not raw SQL, for these
-    tables.  The two guard functions in this file necessarily mention
-    the table names inside their regex patterns; their source spans are
-    removed BEFORE the scan, and the remaining lines are then scanned
-    as ONE combined blob (not line-by-line), so SQL split across
-    physical lines — e.g. an implicitly concatenated string ending in
-    FROM children — is still caught.  The guard regexes themselves
-    cannot match the SQL keyword pattern, so removing the spans only
-    spares regex text, not executable SQL.
-    """
-    import ast
-    import re
-    from pathlib import Path
-
-    path = Path(__file__)
-    text = path.read_text()
-    lines = text.splitlines(keepends=True)
-    tree = ast.parse(text)
-    guard_names = {
-        "test_children_and_admin_sql_lives_only_in_dao_module",
-        "test_dao_test_file_uses_dao_not_raw_table_sql",
-        "test_dao_matrix_test_file_raw_probes_are_only_constraint_probes",
-    }
-    excluded: set[int] = set()
-    for node in ast.walk(tree):
-        if (
-            isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef))
-            and node.name in guard_names
-        ):
-            excluded.update(
-                range(node.lineno, (node.end_lineno or node.lineno) + 1)
-            )
-
-    # Scan the source minus excluded lines as ONE blob so SQL split
-    # across physical lines cannot evade the pattern.
-    remaining = "".join(
-        line
-        for number, line in enumerate(lines, start=1)
-        if number not in excluded
-    )
-    sql_pattern = re.compile(
-        r"(SELECT\s[^\"']*?FROM|INSERT\s+INTO|UPDATE|"
-        r"DELETE\s+FROM|FROM|JOIN)\s+[`'\"]*(\[)?"
-        r"(children|admin_users)\b",
-        re.IGNORECASE,
-    )
-    assert sql_pattern.search(remaining) is None, (
-        "tests must go through the DAO, not raw SQL, for these tables"
-    )

tests/test_dao_matrix.py

@@ -1,447 +0,0 @@
-"""Cross-table DAO unit suite: CRUD and constraint coverage for all tables.
-
-The per-DAO test modules (test_dao_children, test_dao_rules,
-test_dao_presence, test_dao_instances) cover each table's operations in
-depth; this module is the FEATURE-02 closing sweep: a single systematic
-matrix proving that for EVERY table, the DAO layer supports insert,
-read, update and surfaces constraint violations — plus the instance
-upsert idempotency and the completion_events no-mutation guarantee —
-all against a temporary database file from a clean checkout.
-
-No raw SQL touches the DAO-owned tables here except the sanctioned
-COUNT(*) probes (each guarded by the per-DAO leak guards); everything
-else goes through the typed DAO methods.
-"""
-from __future__ import annotations
-
-import asyncio
-import datetime
-import sqlite3
-from unittest.mock import AsyncMock, MagicMock
-
-import pytest
-
-from custom_components.nestquest.dao_children import (
-    AdminUsersDao,
-    ChildrenDao,
-)
-from custom_components.nestquest.dao_instances import (
-    CompletionEventsDao,
-    QuestInstancesDao,
-)
-from custom_components.nestquest.dao_presence import (
-    PresenceOverridesDao,
-    PresenceSchedulesDao,
-)
-from custom_components.nestquest.dao_rules import (
-    ScheduleRulesDao,
-    QuestDefinitionsDao,
-)
-from custom_components.nestquest.db import NestQuestDatabase
-from custom_components.nestquest.migrations import apply_migrations
-
-
-def _run(coro):
-    return asyncio.new_event_loop().run_until_complete(coro)
-
-
-def _make_hass_mock():
-    hass = MagicMock()
-    hass.async_add_executor_job = AsyncMock(side_effect=(lambda fn, *a: fn(*a)))
-    return hass
-
-
-def _future_day(offset: int) -> str:
-    return (
-        datetime.date.today() + datetime.timedelta(days=offset)
-    ).isoformat()
-
-
-def _stamp() -> str:
-    return f"{datetime.date.today().isoformat()}T08:00:00+00:00"
-
-
-D1 = _future_day(1)
-D2 = _future_day(2)
-D20 = _future_day(20)
-
-#: Every table the v1 schema owns, with the DAO that governs it.
-ALL_TABLES = (
-    "children",
-    "admin_users",
-    "schedule_rules",
-    "quest_definitions",
-    "quest_definition_assignees",
-    "presence_schedules",
-    "presence_overrides",
-    "quest_instances",
-    "completion_events",
-)
-
-
-class World:
-    """All DAOs over one migrated temporary database."""
-
-    def __init__(self, database: NestQuestDatabase):
-        self.database = database
-        self.children = ChildrenDao(database)
-        self.admins = AdminUsersDao(database)
-        self.rules = ScheduleRulesDao(database)
-        self.definitions = QuestDefinitionsDao(database)
-        self.schedules = PresenceSchedulesDao(database)
-        self.overrides = PresenceOverridesDao(database)
-        self.instances = QuestInstancesDao(database)
-        self.events = CompletionEventsDao(database)
-
-    async def seed(self) -> None:
-        """Populate one valid fixture chain through the DAO layer."""
-        self.child = await self.children.create("Ada", _stamp())
-        self.child2 = await self.children.create("Bo", _stamp())
-        assert await self.admins.add("user-1", _stamp()) is True
-        self.rule = await self.rules.create("daily", D1)
-        self.definition = await self.definitions.create(
-            "Brush teeth",
-            self.rule.id,
-            _stamp(),
-            assignee_child_ids=[self.child.id],
-        )
-        self.schedule = await self.schedules.upsert_by_child(
-            self.child.id, 2, D1, "0,2,4|1,3"
-        )
-        self.override = await self.overrides.create(
-            self.child.id, D1, D2, True, note="test"
-        )
-        self.instance = await self.instances.upsert(
-            self.definition.id, self.child.id, D1, _stamp(),
-            window="morning",
-        )
-
-
-async def _world(path) -> World:
-    database = NestQuestDatabase(_make_hass_mock())
-    await database.open(path)
-    await apply_migrations(database)
-    world = World(database)
-    await world.seed()
-    return world
-
-
-def _with_world(name):
-    def _run_test(body):
-        async def _main():
-            world = await _world(name)
-            try:
-                return await body(world)
-            finally:
-                await world.database.close()
-
-        return _run(_main())
-
-    return _run_test
-
-
-# ---------------------------------------------------------------------------
-# The matrix: every table gets insert / read / update / constraint check
-# ---------------------------------------------------------------------------
-
-
-def test_matrix_children_crud_and_constraints(tmp_path) -> None:
-    async def _body(w: World):
-        # insert (seeded) + read
-        fetched = await w.children.get(w.child.id)
-        assert fetched is not None and fetched.display_name == "Ada"
-        # update
-        await w.children.update(w.child.id, display_name="Ada L.")
-        assert (await w.children.get(w.child.id)).display_name == "Ada L."
-        # constraint: NOT NULL display_name
-        with pytest.raises(sqlite3.IntegrityError):
-            await w.database.execute(
-                "INSERT INTO children (display_name, created_at) "
-                "VALUES (NULL, ?)",
-                (_stamp(),),
-            )
-        return True
-
-    assert _with_world(tmp_path / "m-children.db")(_body) is True
-
-
-def test_matrix_admin_users_crud_and_constraints(tmp_path) -> None:
-    async def _body(w: World):
-        # insert + read
-        assert await w.admins.exists("user-1") is True
-        records = await w.admins.list()
-        assert len(records) == 1
-        # update path: idempotent add is the allowlist's update semantics
-        assert await w.admins.add("user-1", _stamp()) is False
-        # constraint: ha_user_id PRIMARY KEY
-        with pytest.raises(sqlite3.IntegrityError):
-            await w.database.execute(
-                "INSERT INTO admin_users (ha_user_id, added_at) "
-                "VALUES (?, ?)",
-                ("user-1", _stamp()),
-            )
-        # remove
-        assert await w.admins.remove("user-1") is True
-        assert await w.admins.exists("user-1") is False
-        return True
-
-    assert _with_world(tmp_path / "m-admins.db")(_body) is True
-
-
-def test_matrix_schedule_rules_crud_and_constraints(tmp_path) -> None:
-    async def _body(w: World):
-        # insert (seeded) + read
-        fetched = await w.rules.get(w.rule.id)
-        assert fetched.rule_type == "daily"
-        # update
-        await w.rules.update(w.rule.id, interval=3)
-        assert (await w.rules.get(w.rule.id)).interval == 3
-        # constraint: rule_type CHECK
-        with pytest.raises(sqlite3.IntegrityError):
-            await w.rules.create("sometimes", D1)
-        # delete-if-unreferenced: referenced -> rejected
-        assert await w.rules.delete_if_unreferenced(w.rule.id) is False
-        return True
-
-    assert _with_world(tmp_path / "m-rules.db")(_body) is True
-
-
-def test_matrix_quest_definitions_crud_and_constraints(tmp_path) -> None:
-    async def _body(w: World):
-        # insert (seeded) + read
-        fetched = await w.definitions.get(w.definition.id)
-        assert fetched.title == "Brush teeth"
-        assert [c.id for c in await w.definitions.list_assignees(
-            w.definition.id
-        )] == [w.child.id]
-        # update
-        await w.definitions.update(w.definition.id, title="Brush TEETH")
-        assert (await w.definitions.get(w.definition.id)).title == (
-            "Brush TEETH"
-        )
-        # constraint: FK to a nonexistent child rejected with ValueError
-        with pytest.raises(ValueError, match="does not exist"):
-            await w.definitions.create(
-                "X", w.rule.id, _stamp(), assignee_child_ids=[999]
-            )
-        # constraint: inactive child rejected on assignment
-        await w.children.set_active(w.child2.id, False)
-        with pytest.raises(ValueError, match="inactive"):
-            await w.definitions.add_assignee(w.definition.id, w.child2.id)
-        # assignee removal + re-adding the active child
-        assert await w.definitions.remove_assignee(
-            w.definition.id, w.child.id
-        ) is True
-        assert await w.definitions.remove_assignee(
-            w.definition.id, w.child.id
-        ) is False
-        await w.definitions.add_assignee(w.definition.id, w.child.id)
-        # set_active: deactivate, never delete
-        assert await w.definitions.set_active(w.definition.id, False) == 1
-        assert (await w.definitions.get(w.definition.id)).is_active is False
-        return True
-
-    assert _with_world(tmp_path / "m-definitions.db")(_body) is True
-
-
-def test_matrix_presence_schedules_crud_and_constraints(tmp_path) -> None:
-    async def _body(w: World):
-        # insert (seeded) + read
-        fetched = await w.schedules.get_by_child(w.child.id)
-        assert fetched.pattern == "0,2,4|1,3"
-        # update path: upsert replaces in place (same row id)
-        replaced = await w.schedules.upsert_by_child(
-            w.child.id, 2, D2, "1,3|0,2,4"
-        )
-        assert replaced.id == fetched.id
-        assert (await w.schedules.get_by_child(w.child.id)).pattern == (
-            "1,3|0,2,4"
-        )
-        # constraint: malformed pattern CHECK
-        with pytest.raises(sqlite3.IntegrityError):
-            await w.schedules.upsert_by_child(w.child.id, 2, D1, "0,2")
-        # delete: row gone, child present every day
-        assert await w.schedules.delete(w.child.id) is True
-        assert await w.schedules.get_by_child(w.child.id) is None
-        return True
-
-    assert _with_world(tmp_path / "m-schedules.db")(_body) is True
-
-
-def test_matrix_presence_overrides_crud_and_constraints(tmp_path) -> None:
-    async def _body(w: World):
-        # insert (seeded) + read
-        found = await w.overrides.list_by_child_and_range(
-            w.child.id, D1, D2
-        )
-        assert [r.id for r in found] == [w.override.id]
-        # update path: delete + recreate (overrides are append-oriented)
-        assert await w.overrides.delete(w.override.id) is True
-        replacement = await w.overrides.create(
-            w.child.id, D1, D2, False, note="updated"
-        )
-        assert replacement.is_present is False
-        # constraint: end before start CHECK
-        with pytest.raises(sqlite3.IntegrityError):
-            await w.overrides.create(w.child.id, D2, D1, True)
-        return True
-
-    assert _with_world(tmp_path / "m-overrides.db")(_body) is True
-
-
-def test_matrix_quest_instances_crud_and_constraints(tmp_path) -> None:
-    async def _body(w: World):
-        # insert (seeded) + read
-        fetched = await w.instances.get(
-            w.definition.id, w.child.id, D1, "morning"
-        )
-        assert fetched == w.instance
-        # update path: conflict refresh on the OPEN instance — same row
-        # id, snapshot columns (due_time) actually rewritten.
-        refreshed = await w.instances.upsert(
-            w.definition.id, w.child.id, D1, _stamp(),
-            window="morning", due_time="17:00",
-        )
-        assert refreshed.id == fetched.id, (
-            "the conflict path must refresh the existing row in place"
-        )
-        assert refreshed.due_time == "17:00"
-        assert fetched.due_time is None
-        assert await w.instances.get_by_id(fetched.id) is not None
-        return True
-
-    assert _with_world(tmp_path / "m-instances.db")(_body) is True
-
-
-def test_matrix_quest_instances_constraints(tmp_path) -> None:
-    async def _body(w: World):
-        # D20 has no instance yet: a raw insert succeeds, then an
-        # identical second insert must fail on the UNIQUE constraint —
-        # proving the schema backs the DAO's idempotency.
-        await w.database.execute(
-            "INSERT INTO quest_instances (definition_id, child_id, "
-            "window, due_date, due_time, generated_at) "
-            "VALUES (?, ?, 'morning', ?, NULL, ?)",
-            (w.definition.id, w.child.id, D20, _stamp()),
-        )
-        with pytest.raises(sqlite3.IntegrityError):
-            await w.database.execute(
-                "INSERT INTO quest_instances (definition_id, child_id, "
-                "window, due_date, due_time, generated_at) "
-                "VALUES (?, ?, 'morning', ?, NULL, ?)",
-                (w.definition.id, w.child.id, D20, _stamp()),
-            )
-        # delete future uncompleted removes D20's open instance
-        deleted = await w.instances.delete_future_uncompleted(
-            w.definition.id, D20
-        )
-        assert deleted == 1
-        return True
-
-    assert _with_world(tmp_path / "m-instances-constraints.db")(_body) is True
-
-
-def test_matrix_quest_instances_upsert_idempotency(tmp_path) -> None:
-    async def _body(w: World):
-        first = await w.instances.upsert(
-            w.definition.id, w.child.id, D2, _stamp(), window="morning"
-        )
-        second = await w.instances.upsert(
-            w.definition.id, w.child.id, D2, _stamp(),
-            window="morning", due_time="17:00",
-        )
-        assert second.id == first.id
-        count = await w.database.fetch_one(
-            "SELECT COUNT(*) FROM quest_instances"
-        )
-        # Seed created one (D1) plus this one (D2) — no duplicate.
-        assert count == (2,)
-        return True
-
-    assert _with_world(tmp_path / "m-upsert-idempotent.db")(_body) is True
-
-
-# ---------------------------------------------------------------------------
-# completion_events: append-only by construction
-# ---------------------------------------------------------------------------
-
-
-def test_matrix_completion_events_append_read_and_no_mutation(
-    tmp_path,
-) -> None:
-    async def _body(w: World):
-        # insert: append a completion then a reversal, then re-complete
-        await w.events.append(
-            w.instance.id, w.child.id, "completed", "panel", _stamp(), True,
-            actor_child_id=w.child.id,
-        )
-        await w.events.append(
-            w.instance.id, w.child.id, "uncompleted", "user", _stamp(), None,
-            actor_user_id="user-1",
-        )
-        await w.events.append(
-            w.instance.id, w.child.id, "completed", "panel", _stamp(), False,
-            actor_child_id=w.child.id,
-        )
-        # read: full ordered history + latest
-        history = await w.events.list_by_instance(w.instance.id)
-        assert [e.event_type for e in history] == [
-            "completed",
-            "uncompleted",
-            "completed",
-        ]
-        latest = await w.events.get_latest_for_instance(w.instance.id)
-        assert latest.event_type == "completed"
-        assert latest.was_on_time is False
-        # constraint: unknown instance FK + bad actor pair surface as
-        # ValueError from the DAO's atomic validation
-        with pytest.raises(ValueError, match="does not exist"):
-            await w.events.append(
-                999, w.child.id, "completed", "user", _stamp(), True,
-                actor_user_id="user-1",
-            )
-        return history
-
-    assert _with_world(tmp_path / "m-events.db")(_body) is not None
-
-
-def test_completion_events_absolutely_no_mutation_path() -> None:
-    """The structural half of the done-condition: the DAO class exposes
-    no update/delete, AND no module in the package holds mutation SQL
-    for the table (already asserted package-wide in test_dao_instances;
-    re-asserted here so THIS suite stands alone in a clean checkout).
-    """
-    import inspect
-    import re
-    from pathlib import Path
-
-    methods = {
-        name
-        for name, _ in inspect.getmembers(
-            CompletionEventsDao, inspect.isfunction
-        )
-        if not name.startswith("__")
-    }
-    assert methods == {
-        "append",
-        "list_by_instance",
-        "list_by_child_and_date_range",
-        "get_latest_for_instance",
-    }
-
-    package = Path(
-        __import__(
-            "custom_components.nestquest", fromlist=["__file__"]
-        ).__file__
-    ).parent
-    mutation = re.compile(
-        r"(UPDATE(\s+OR\s+\w+)?|DELETE\s+FROM)\s+"
-        r"((main|temp)\s*\.\s*)?[`'\"]*(\[)?completion_events\b",
-        re.IGNORECASE,
-    )
-    offenders = [
-        py.name
-        for py in sorted(package.glob("*.py"))
-        if py.name != "__pycache__" and mutation.search(py.read_text())
-    ]
-    assert offenders == []

tests/test_dao_presence.py

@@ -1,791 +0,0 @@
-"""Tests for dao_presence.py: presence schedules and overrides DAO."""
-from __future__ import annotations
-
-import asyncio
-import sqlite3
-
-import pytest
-
-from custom_components.nestquest.dao_children import ChildrenDao
-from custom_components.nestquest.dao_presence import (
-    PresenceOverrideRecord,
-    PresenceOverridesDao,
-    PresenceScheduleRecord,
-    PresenceSchedulesDao,
-)
-from custom_components.nestquest.db import NestQuestDatabase
-from custom_components.nestquest.migrations import apply_migrations
-
-
-def _run(coro):
-    return asyncio.new_event_loop().run_until_complete(coro)
-
-
-def _make_hass_mock():
-    from unittest.mock import AsyncMock, MagicMock
-
-    hass = MagicMock()
-    hass.async_add_executor_job = AsyncMock(side_effect=(lambda fn, *a: fn(*a)))
-    return hass
-
-
-NOW = "2026-09-14T12:00:00+00:00"
-
-
-async def _prepare(path) -> tuple:
-    database = NestQuestDatabase(_make_hass_mock())
-    await database.open(path)
-    await apply_migrations(database)
-    schedules = PresenceSchedulesDao(database)
-    overrides = PresenceOverridesDao(database)
-    children = ChildrenDao(database)
-    child = await children.create("Ada", NOW)
-    return database, schedules, overrides, children, child
-
-
-def _with_db(tmp_path, name):
-    def _run_test(body):
-        async def _main():
-            database, schedules, overrides, children, child = await _prepare(
-                tmp_path / name
-            )
-            try:
-                return await body(
-                    database, schedules, overrides, children, child
-                )
-            finally:
-                await database.close()
-
-        return _run(_main())
-
-    return _run_test
-
-
-# ---------------------------------------------------------------------------
-# presence_schedules: upsert by child
-# ---------------------------------------------------------------------------
-
-
-def test_upsert_creates_then_updates_same_row(tmp_path) -> None:
-    """Second upsert for the same child UPDATES, not raises."""
-    async def _body(database, schedules, overrides, children, child):
-        first = await schedules.upsert_by_child(
-            child.id, 2, "2026-09-07", "0,2,4|1,3"
-        )
-        assert isinstance(first, PresenceScheduleRecord)
-        assert first.child_id == child.id
-        second = await schedules.upsert_by_child(
-            child.id, 2, "2026-09-14", "1,3|0,2,4"
-        )
-        assert second.id == first.id, "upsert must reuse the existing row"
-        fetched = await schedules.get_by_child(child.id)
-        assert fetched.anchor_date == "2026-09-14"
-        assert fetched.pattern == "1,3|0,2,4"
-        rows = await database.fetch_one(
-            "SELECT COUNT(*) FROM presence_schedules"
-        )
-        assert rows == (1,)
-        return second
-
-    _with_db(tmp_path, "upsert.db")(_body)
-
-
-def test_upsert_typed_record_fields(tmp_path) -> None:
-    async def _body(database, schedules, overrides, children, child):
-        record = await schedules.upsert_by_child(
-            child.id, 4, "2026-09-07", "0|1|2|3"
-        )
-        assert record.id == 1
-        assert record.child_id == child.id
-        assert record.cycle_length_weeks == 4
-        assert record.anchor_date == "2026-09-07"
-        assert record.pattern == "0|1|2|3"
-        return record
-
-    _with_db(tmp_path, "upsert-fields.db")(_body)
-
-
-def test_upsert_unknown_child_raises_value_error(tmp_path) -> None:
-    async def _body(database, schedules, overrides, children, child):
-        with pytest.raises(ValueError, match="does not exist"):
-            await schedules.upsert_by_child(
-                999, 2, "2026-09-07", "0,2|1,3"
-            )
-        return None
-
-    _with_db(tmp_path, "upsert-bad-child.db")(_body)
-
-
-def test_upsert_malformed_anchor_date_raises(tmp_path) -> None:
-    async def _body(database, schedules, overrides, children, child):
-        for bad in ("not-a-date", "2026-9-7", "2026-13-01", ""):
-            with pytest.raises(ValueError, match="YYYY-MM-DD"):
-                await schedules.upsert_by_child(child.id, 2, bad, "0|1")
-        return None
-
-    _with_db(tmp_path, "upsert-bad-date.db")(_body)
-
-
-def test_upsert_malformed_pattern_rejected_by_schema(tmp_path) -> None:
-    async def _body(database, schedules, overrides, children, child):
-        with pytest.raises(sqlite3.IntegrityError, match="CHECK"):
-            await schedules.upsert_by_child(
-                child.id, 2, "2026-09-07", "0,2"
-            )
-        return None
-
-    _with_db(tmp_path, "upsert-bad-pattern.db")(_body)
-
-
-def test_upsert_two_children_have_distinct_rows(tmp_path) -> None:
-    async def _body(database, schedules, overrides, children, child):
-        other = await children.create("Bo", NOW)
-        await schedules.upsert_by_child(child.id, 2, "2026-09-07", "0,2|1,3")
-        await schedules.upsert_by_child(other.id, 2, "2026-09-07", "1,3|0,2")
-        mine = await schedules.get_by_child(child.id)
-        theirs = await schedules.get_by_child(other.id)
-        assert mine.id != theirs.id
-        assert mine.pattern == "0,2|1,3"
-        assert theirs.pattern == "1,3|0,2"
-        return mine
-
-    _with_db(tmp_path, "upsert-two-children.db")(_body)
-
-
-def test_upsert_concurrent_same_child_serializes(tmp_path) -> None:
-    """Racing upserts for one child both succeed; exactly one row.
-
-    Deterministic interleaving: a controllable executor gates task A's
-    job AFTER it has acquired the connection lock and begun its
-    transaction, so task B is created while A provably owns the
-    transaction and must queue on the lock.  Both upserts land, and
-    the table holds exactly one row (the ON CONFLICT upsert, not two
-    plain INSERTs, is what avoids a UNIQUE violation).
-    """
-    async def _main():
-        from unittest.mock import MagicMock
-
-        hass = MagicMock()
-        # Gate exactly ONE job: the first _fetch_one issued after
-        # arming, which is task A's child-existence SELECT inside its
-        # transaction.  The transaction's BEGIN runs first and is NOT
-        # gated, so when the gated fetch signals, BEGIN has executed
-        # and SQLite is inside the open transaction (A holds the
-        # connection lock from BEGIN until commit).  Everything before
-        # arming (open, migrations, child create)
-        # and everything after (B's jobs, A's remaining jobs, reads)
-        # pass straight through.
-        armed = {"active": False, "gated": False}
-        gate_open = asyncio.Event()
-        a_started = asyncio.Event()
-
-        async def _gated_executor(fn, *args):
-            # Gate the SECOND gated-window job: the first is the
-            # transaction's BEGIN (submitted and awaited by
-            # transaction() before upsert_by_child's child-SELECT
-            # runs).  Pausing the child-existence SELECT proves the
-            # BEGIN has EXECUTED — SQLite is actually inside the open
-            # transaction, with A holding the connection lock — when
-            # task B gets scheduled and must queue.
-            if armed["active"]:
-                name = getattr(fn, "__name__", "")
-                if name == "_fetch_one" and not armed["gated"]:
-                    armed["gated"] = True
-                    a_started.set()
-                    await gate_open.wait()
-            return fn(*args)
-
-        hass.async_add_executor_job = _gated_executor
-        database = NestQuestDatabase(hass)
-        await database.open(tmp_path / "upsert-race.db")
-        try:
-            await apply_migrations(database)
-            children = ChildrenDao(database)
-            schedules = PresenceSchedulesDao(database)
-            child = await children.create("Ada", NOW)
-
-            armed["active"] = True
-            task_a = asyncio.ensure_future(
-                schedules.upsert_by_child(
-                    child.id, 2, "2026-09-07", "0,2|1,3"
-                )
-            )
-            # Wait until task A's child-existence SELECT (inside its
-            # open transaction, BEGIN already executed) is paused, then
-            # schedule task B so it must queue behind the open
-            # transaction.
-            await a_started.wait()
-            armed["active"] = False
-            task_b = asyncio.ensure_future(
-                schedules.upsert_by_child(
-                    child.id, 2, "2026-09-14", "1,3|0,2"
-                )
-            )
-            await asyncio.sleep(0)
-            # Release A; B's upsert must wait for A's commit and then
-            # land as the ON CONFLICT update path.
-            gate_open.set()
-            record_a, record_b = await asyncio.gather(task_a, task_b)
-            assert record_a.id == record_b.id
-            fetched = await schedules.get_by_child(child.id)
-            assert fetched is not None
-            rows = await database.fetch_one(
-                "SELECT COUNT(*) FROM presence_schedules"
-            )
-            assert rows == (1,)
-            return fetched
-        finally:
-            await database.close()
-
-    fetched = _run(_main())
-    assert fetched.pattern in {"0,2|1,3", "1,3|0,2"}
-
-
-# ---------------------------------------------------------------------------
-# presence_schedules: get / delete
-# ---------------------------------------------------------------------------
-
-
-def test_get_by_child_missing_schedule_returns_none(tmp_path) -> None:
-    async def _body(database, schedules, overrides, children, child):
-        return await schedules.get_by_child(child.id)
-
-    assert _with_db(tmp_path, "get-none.db")(_body) is None
-
-
-def test_get_by_child_unknown_child_raises(tmp_path) -> None:
-    """None must mean ONLY 'no schedule row': an unknown child id is a
-    caller bug, and silently reading a nonexistent child as 'present
-    every day' would be wrong — so get raises instead.
-    """
-    async def _body(database, schedules, overrides, children, child):
-        with pytest.raises(ValueError, match="does not exist"):
-            await schedules.get_by_child(999)
-        return None
-
-    _with_db(tmp_path, "get-unknown.db")(_body)
-
-
-def test_delete_removes_and_returns_true_then_false(tmp_path) -> None:
-    async def _body(database, schedules, overrides, children, child):
-        await schedules.upsert_by_child(child.id, 2, "2026-09-07", "0,2|1,3")
-        assert await schedules.delete(child.id) is True
-        assert await schedules.get_by_child(child.id) is None
-        assert await schedules.delete(child.id) is False
-        return None
-
-    _with_db(tmp_path, "delete.db")(_body)
-
-
-def test_delete_child_without_schedule_returns_false(tmp_path) -> None:
-    async def _body(database, schedules, overrides, children, child):
-        return await schedules.delete(child.id)
-
-    assert _with_db(tmp_path, "delete-none.db")(_body) is False
-
-
-def test_delete_then_upsert_creates_fresh_row(tmp_path) -> None:
-    async def _body(database, schedules, overrides, children, child):
-        first = await schedules.upsert_by_child(
-            child.id, 2, "2026-09-07", "0,2|1,3"
-        )
-        await schedules.delete(child.id)
-        second = await schedules.upsert_by_child(
-            child.id, 2, "2026-09-07", "0,2|1,3"
-        )
-        assert second.id != first.id
-        return second
-
-    _with_db(tmp_path, "delete-recreate.db")(_body)
-
-
-# ---------------------------------------------------------------------------
-# presence_overrides: create / list / delete
-# ---------------------------------------------------------------------------
-
-
-def test_override_create_returns_typed_record(tmp_path) -> None:
-    async def _body(database, schedules, overrides, children, child):
-        record = await overrides.create(
-            child.id, "2026-12-21", "2027-01-04", False,
-            note="Holiday abroad",
-        )
-        assert isinstance(record, PresenceOverrideRecord)
-        assert record.child_id == child.id
-        assert record.start_date == "2026-12-21"
-        assert record.end_date == "2027-01-04"
-        assert record.is_present is False
-        assert record.note == "Holiday abroad"
-        return record
-
-    _with_db(tmp_path, "override-create.db")(_body)
-
-
-def test_override_create_single_day_same_start_and_end(tmp_path) -> None:
-    async def _body(database, schedules, overrides, children, child):
-        record = await overrides.create(
-            child.id, "2026-09-14", "2026-09-14", True
-        )
-        assert record.start_date == record.end_date
-        assert record.is_present is True
-        assert record.note is None
-        return record
-
-    _with_db(tmp_path, "override-single-day.db")(_body)
-
-
-def test_override_create_unknown_child_raises(tmp_path) -> None:
-    async def _body(database, schedules, overrides, children, child):
-        with pytest.raises(ValueError, match="does not exist"):
-            await overrides.create(
-                999, "2026-09-14", "2026-09-14", True
-            )
-        return None
-
-    _with_db(tmp_path, "override-bad-child.db")(_body)
-
-
-def test_override_create_malformed_dates_raise(tmp_path) -> None:
-    async def _body(database, schedules, overrides, children, child):
-        for bad in ("not-a-date", "2026-9-14", ""):
-            with pytest.raises(ValueError, match="YYYY-MM-DD"):
-                await overrides.create(child.id, bad, "2026-09-14", True)
-            with pytest.raises(ValueError, match="YYYY-MM-DD"):
-                await overrides.create(child.id, "2026-09-14", bad, True)
-        return None
-
-    _with_db(tmp_path, "override-bad-dates.db")(_body)
-
-
-def test_override_end_before_start_rejected_by_schema(tmp_path) -> None:
-    async def _body(database, schedules, overrides, children, child):
-        with pytest.raises(sqlite3.IntegrityError, match="CHECK"):
-            await overrides.create(
-                child.id, "2026-09-14", "2026-09-13", True
-            )
-        return None
-
-    _with_db(tmp_path, "override-end-before-start.db")(_body)
-
-
-def test_override_list_by_child_and_range_filters_correctly(
-    tmp_path,
-) -> None:
-    async def _body(database, schedules, overrides, children, child):
-        await overrides.create(
-            child.id, "2026-09-01", "2026-09-05", False, note="before"
-        )
-        inside = await overrides.create(
-            child.id, "2026-09-10", "2026-09-12", False, note="inside"
-        )
-        overlapping = await overrides.create(
-            child.id, "2026-09-20", "2026-09-25", True, note="overlap"
-        )
-        after = await overrides.create(
-            child.id, "2026-10-01", "2026-10-02", False, note="after"
-        )
-        found = await overrides.list_by_child_and_range(
-            child.id, "2026-09-09", "2026-09-22"
-        )
-        assert [r.id for r in found] == [inside.id, overlapping.id]
-        # Inclusive boundaries: a range touching the override's edges
-        # still matches.
-        edge = await overrides.list_by_child_and_range(
-            child.id, "2026-09-20", "2026-09-20"
-        )
-        assert [r.id for r in edge] == [overlapping.id]
-        return found
-
-    _with_db(tmp_path, "override-list-range.db")(_body)
-
-
-def test_override_list_orders_by_start_date(tmp_path) -> None:
-    async def _body(database, schedules, overrides, children, child):
-        late = await overrides.create(
-            child.id, "2026-09-20", "2026-09-21", True
-        )
-        early = await overrides.create(
-            child.id, "2026-09-10", "2026-09-11", False
-        )
-        found = await overrides.list_by_child_and_range(
-            child.id, "2026-09-01", "2026-09-30"
-        )
-        assert [r.id for r in found] == [early.id, late.id]
-        return found
-
-    _with_db(tmp_path, "override-list-order.db")(_body)
-
-
-def test_override_list_per_child_isolation(tmp_path) -> None:
-    async def _body(database, schedules, overrides, children, child):
-        other = await children.create("Bo", NOW)
-        await overrides.create(child.id, "2026-09-10", "2026-09-11", True)
-        await overrides.create(other.id, "2026-09-10", "2026-09-11", False)
-        mine = await overrides.list_by_child_and_range(
-            child.id, "2026-09-01", "2026-09-30"
-        )
-        assert len(mine) == 1
-        assert mine[0].is_present is True
-        return mine
-
-    _with_db(tmp_path, "override-isolation.db")(_body)
-
-
-def test_override_list_malformed_range_raises(tmp_path) -> None:
-    async def _body(database, schedules, overrides, children, child):
-        with pytest.raises(ValueError, match="YYYY-MM-DD"):
-            await overrides.list_by_child_and_range(
-                child.id, "oops", "2026-09-30"
-            )
-        with pytest.raises(ValueError, match="on or after"):
-            await overrides.list_by_child_and_range(
-                child.id, "2026-09-30", "2026-09-01"
-            )
-        return None
-
-    _with_db(tmp_path, "override-list-bad-range.db")(_body)
-
-
-def test_override_list_unknown_child_returns_empty(tmp_path) -> None:
-    async def _body(database, schedules, overrides, children, child):
-        return await overrides.list_by_child_and_range(
-            999, "2026-09-01", "2026-09-30"
-        )
-
-    assert _with_db(tmp_path, "override-list-unknown.db")(_body) == []
-
-
-def test_override_delete_round_trip(tmp_path) -> None:
-    async def _body(database, schedules, overrides, children, child):
-        record = await overrides.create(
-            child.id, "2026-09-10", "2026-09-11", True
-        )
-        assert await overrides.delete(record.id) is True
-        found = await overrides.list_by_child_and_range(
-            child.id, "2026-09-01", "2026-09-30"
-        )
-        assert found == []
-        assert await overrides.delete(record.id) is False
-        return None
-
-    _with_db(tmp_path, "override-delete.db")(_body)
-
-
-def test_override_delete_missing_returns_false(tmp_path) -> None:
-    async def _body(database, schedules, overrides, children, child):
-        return await overrides.delete(999)
-
-    assert _with_db(tmp_path, "override-delete-missing.db")(_body) is False
-
-
-def test_override_delete_leaves_other_overrides(tmp_path) -> None:
-    async def _body(database, schedules, overrides, children, child):
-        first = await overrides.create(
-            child.id, "2026-09-10", "2026-09-11", True
-        )
-        second = await overrides.create(
-            child.id, "2026-09-20", "2026-09-21", False
-        )
-        assert await overrides.delete(first.id) is True
-        found = await overrides.list_by_child_and_range(
-            child.id, "2026-09-01", "2026-09-30"
-        )
-        assert [r.id for r in found] == [second.id]
-        return found
-
-    _with_db(tmp_path, "override-delete-others.db")(_body)
-
-
-def test_schedule_and_override_independent_for_same_child(tmp_path) -> None:
-    """Deleting the schedule does not touch overrides and vice versa."""
-    async def _body(database, schedules, overrides, children, child):
-        await schedules.upsert_by_child(child.id, 2, "2026-09-07", "0,2|1,3")
-        override = await overrides.create(
-            child.id, "2026-09-10", "2026-09-11", True
-        )
-        assert await schedules.delete(child.id) is True
-        found = await overrides.list_by_child_and_range(
-            child.id, "2026-09-01", "2026-09-30"
-        )
-        assert [r.id for r in found] == [override.id]
-        return found
-
-    _with_db(tmp_path, "independent.db")(_body)
-
-
-# ---------------------------------------------------------------------------
-# No SQL for these tables outside the DAO module
-# ---------------------------------------------------------------------------
-
-
-def test_presence_sql_lives_only_in_dao_module() -> None:
-    """Guardrail: presence_schedules/presence_overrides SQL may appear
-    only in the DAO module (and the schema DDL declarations).
-    RECURSIVE scan of package and tests, FROM/INTO/UPDATE/DELETE FROM/
-    JOIN pattern, with exact repo-relative exclusions justified by
-    role: schema.py declares the DDL, migrations.py applies it, and
-    the test files for exactly those layers verify DDL, not data
-    paths.
-    """
-    import re
-    from pathlib import Path
-
-    package = Path(
-        __import__(
-            "custom_components.nestquest", fromlist=["__file__"]
-        ).__file__
-    ).parent
-    repo_root = package.parent.parent
-    scan_roots = [package, repo_root / "tests"]
-
-    allowed = {
-        "custom_components/nestquest/dao_presence.py",  # this DAO
-        "custom_components/nestquest/schema.py",  # declares the DDL
-        "custom_components/nestquest/migrations.py",  # applies the DDL
-        "tests/test_schema.py",  # tests the DDL
-        "tests/test_migrations.py",  # tests migration application
-        "tests/test_dao_presence.py",  # this file, scanned separately
-    }
-    sql_pattern = re.compile(
-        r"(FROM|INTO|UPDATE|DELETE\s+FROM|JOIN)\s+[`'\"]*(\[)?"
-        r"(presence_schedules|presence_overrides)\b",
-        re.IGNORECASE,
-    )
-    offenders: list[str] = []
-    for root in scan_roots:
-        for py in sorted(root.rglob("*.py")):
-            relative = py.relative_to(repo_root).as_posix()
-            if relative in allowed:
-                continue
-            if sql_pattern.search(py.read_text()):
-                offenders.append(relative)
-    assert offenders == [], (
-        f"SQL touching presence_schedules/presence_overrides leaked "
-        f"into: {offenders}"
-    )
-
-
-def test_dao_presence_test_file_uses_dao_not_raw_table_sql() -> None:
-    """This test module must exercise the DAO, not raw SQL, for these
-    tables.  Exemptions are EXACT lines, not whole-function spans: the
-    two single-statement COUNT(*) row probes (the only honest way to
-    prove 'exactly one row exists' without a listing method) and the
-    guard functions' own regex spans.  Any other raw SQL added anywhere
-    in this file fails the guard.
-    """
-    import ast
-    import re
-    from pathlib import Path
-
-    path = Path(__file__)
-    text = path.read_text()
-    lines = text.splitlines(keepends=True)
-    tree = ast.parse(text)
-    guard_names = {
-        "test_presence_sql_lives_only_in_dao_module",
-        "test_dao_presence_test_file_uses_dao_not_raw_table_sql",
-    }
-    excluded: set[int] = set()
-    for node in ast.walk(tree):
-        if not isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
-            continue
-        if node.name in guard_names:
-            excluded.update(
-                range(node.lineno, (node.end_lineno or node.lineno) + 1)
-            )
-            continue
-        # Narrow probe exemption: only the string-literal line holding
-        # the sanctioned COUNT(*) query, not the enclosing function.
-        for sub in ast.walk(node):
-            if (
-                isinstance(sub, ast.Constant)
-                and isinstance(sub.value, str)
-                and sub.value.strip()
-                == "SELECT COUNT(*) FROM presence_schedules"
-                and sub.lineno is not None
-            ):
-                excluded.add(sub.lineno)
-
-    remaining = "".join(
-        line
-        for number, line in enumerate(lines, start=1)
-        if number not in excluded
-    )
-    sql_pattern = re.compile(
-        r"(SELECT\s[^\"']*?FROM|INSERT\s+INTO|UPDATE|DELETE\s+FROM|"
-        r"FROM|JOIN)\s+[`'\"]*(\[)?(presence_schedules|presence_overrides)"
-        r"\b",
-        re.IGNORECASE,
-    )
-    assert sql_pattern.search(remaining) is None, (
-        "tests must go through the DAO, not raw SQL, for these tables"
-    )
-
-# ---------------------------------------------------------------------------
-# Presence overrides: overlap rejection naming the conflict
-# ---------------------------------------------------------------------------
-
-
-def test_override_create_round_trip_single_and_range(tmp_path) -> None:
-    async def _body(database, schedules, overrides, children, child):
-        single = await overrides.create(
-            child.id, "2026-07-20", "2026-07-20", False
-        )
-        assert (single.start_date, single.end_date) == ("2026-07-20",) * 2
-        span = await overrides.create(
-            child.id, "2026-08-01", "2026-08-05", True, note="traded week"
-        )
-        assert span.is_present is True
-        assert span.note == "traded week"
-        # Distinct, non-overlapping ranges coexist.
-        listed = await overrides.list_by_child_and_range(
-            child.id, "2026-01-01", "2026-12-31"
-        )
-        assert [row.id for row in listed] == [single.id, span.id]
-        return listed
-
-    _with_db(tmp_path, "override-round-trip.db")(_body)
-
-
-def test_override_overlap_rejected_and_names_the_conflict(tmp_path) -> None:
-    async def _body(database, schedules, overrides, children, child):
-        existing = await overrides.create(
-            child.id, "2026-07-20", "2026-07-24", False, note="holiday"
-        )
-        for start, end in (
-            ("2026-07-24", "2026-07-26"),  # touches the existing end
-            ("2026-07-18", "2026-07-20"),  # touches the existing start
-            ("2026-07-21", "2026-07-22"),  # fully inside
-            ("2026-07-01", "2026-07-30"),  # fully covering
-        ):
-            with pytest.raises(ValueError, match="overlaps existing"):
-                await overrides.create(
-                    child.id, start, end, True, note="swap"
-                )
-        # The error NAMES the conflicting override (id + its range).
-        with pytest.raises(
-            ValueError,
-            match=(
-                rf"override {existing.id} "
-                rf"\[2026-07-20, 2026-07-24\].*is_present=False"
-            ),
-        ):
-            await overrides.create(child.id, "2026-07-22", "2026-07-22", True)
-        # Nothing was written by any rejected attempt.
-        listed = await overrides.list_by_child_and_range(
-            child.id, "2026-01-01", "2026-12-31"
-        )
-        assert [row.id for row in listed] == [existing.id]
-        return existing
-
-    _with_db(tmp_path, "override-overlap.db")(_body)
-
-
-def test_override_overlap_is_per_child(tmp_path) -> None:
-    """Different children's overrides may cover the same dates: the
-    conflict rule is per child."""
-    async def _body(database, schedules, overrides, children, child):
-        other = await children.create("Bo", NOW)
-        await overrides.create(child.id, "2026-07-20", "2026-07-24", False)
-        twin = await overrides.create(
-            other.id, "2026-07-20", "2026-07-24", True
-        )
-        assert twin.child_id == other.id
-        listed = await overrides.list_by_child_and_range(
-            other.id, "2026-01-01", "2026-12-31"
-        )
-        assert [row.id for row in listed] == [twin.id]
-        return twin
-
-    _with_db(tmp_path, "override-per-child.db")(_body)
-
-
-def test_override_remove_then_recreate_overlapping(tmp_path) -> None:
-    async def _body(database, schedules, overrides, children, child):
-        first = await overrides.create(
-            child.id, "2026-07-20", "2026-07-24", False
-        )
-        assert await overrides.delete(first.id) is True
-        assert await overrides.delete(first.id) is False
-        replacement = await overrides.create(
-            child.id, "2026-07-20", "2026-07-24", True, note="swap back"
-        )
-        assert replacement.is_present is True
-        return replacement
-
-    _with_db(tmp_path, "override-recreate.db")(_body)
-
-
-def test_override_create_racing_conflicts_serialize(tmp_path) -> None:
-    """Two racing creates for the same child and dates: exactly one
-    lands, the other is rejected with the overlap error.  DETERMINISTIC
-    gate: task A is paused at its INSERT — inside its open transaction,
-    after its overlap probe — so task B is created while A provably
-    holds the connection lock and must queue; B then re-runs the probe
-    against A's committed row and is rejected."""
-    import asyncio as asyncio_module
-    from unittest.mock import MagicMock
-
-    async def _main():
-        from custom_components.nestquest.dao_children import ChildrenDao
-        from custom_components.nestquest.dao_presence import (
-            PresenceOverridesDao,
-        )
-        from custom_components.nestquest.db import NestQuestDatabase
-        from custom_components.nestquest.migrations import apply_migrations
-
-        armed = {"active": False, "gated": False}
-        gate_open = asyncio_module.Event()
-        a_started = asyncio_module.Event()
-
-        hass = MagicMock()
-
-        async def _gated_executor(fn, *args):
-            if armed["active"]:
-                # Gate the FIRST _execute after arming: task A's INSERT,
-                # which runs inside its open transaction (BEGIN already
-                # executed) after the overlap probe.
-                if getattr(fn, "__name__", "") == "_execute" and not armed["gated"]:
-                    armed["gated"] = True
-                    a_started.set()
-                    await gate_open.wait()
-            return fn(*args)
-
-        hass.async_add_executor_job = _gated_executor
-        database = NestQuestDatabase(hass)
-        await database.open(tmp_path / "override-race.db")
-        try:
-            await apply_migrations(database)
-            children = ChildrenDao(database)
-            overrides = PresenceOverridesDao(database)
-            child = await children.create("Ada", NOW)
-
-            armed["active"] = True
-            task_a = asyncio_module.ensure_future(
-                overrides.create(child.id, "2026-07-20", "2026-07-24", True)
-            )
-            await a_started.wait()
-            armed["active"] = False
-            task_b = asyncio_module.ensure_future(
-                overrides.create(child.id, "2026-07-22", "2026-07-26", False)
-            )
-            await asyncio_module.sleep(0)
-            gate_open.set()
-            record_a, error_b = await asyncio_module.gather(
-                task_a, task_b, return_exceptions=True
-            )
-            assert isinstance(record_a, object) and not isinstance(
-                record_a, BaseException
-            ), f"A must land: {record_a!r}"
-            assert isinstance(error_b, ValueError), (
-                f"B must be rejected with the overlap error: {error_b!r}"
-            )
-            assert "overlaps existing" in str(error_b)
-            listed = await overrides.list_by_child_and_range(
-                child.id, "2026-01-01", "2026-12-31"
-            )
-            assert [row.id for row in listed] == [record_a.id]
-        finally:
-            await database.close()
-
-    asyncio.new_event_loop().run_until_complete(_main())

tests/test_lifecycle.py

@@ -8,13 +8,7 @@ import pytest
 from conftest import make_config_entry, make_hass, wire_entry_to_registry
 
 from custom_components.nestquest import DOMAIN, async_setup_entry, async_unload_entry
-from custom_components.nestquest.const import (
-    CONF_DAY_ROLLOVER_TIME,
-    CONF_HORIZON_DAYS,
-    DEFAULT_HORIZON_DAYS,
-    SERVICE_REGENERATE,
-    DOMAIN as DOMAIN_CONST,
-)
+from custom_components.nestquest.const import DOMAIN as DOMAIN_CONST
 
 
 def _wire(entry, registry):
@@ -242,440 +236,4 @@ async def test_unload_closes_database_even_when_listener_removal_raises() -> Non
         await async_unload_entry(hass, entry)
     assert database.connected is False, "database leaked despite remover error"
     assert entry.runtime_data is None
-    assert DOMAIN not in hass.data
-    assert hass.time_change.size == 0, "time-change listener leaked"
-
-
-async def test_unload_cancels_time_listener_even_when_update_remover_raises() -> None:
-    """A raising update-listener remover must not skip the time-change cancel.
-
-    Both removers are independent: the update-listener remover raising must
-    still cancel the daily time-change callback, whose action would otherwise
-    fire after unload against a closed database.
-    """
-
-    class _RemoveBoom(Exception):
-        pass
-
-    def _remover():
-        raise _RemoveBoom()
-
-    entry = make_config_entry(entry_id="update-boom-time-cancel")
-    entry.add_update_listener = lambda listener: _remover
-    hass, _registry = make_hass()
-    await async_setup_entry(hass, entry)
-    assert hass.time_change.size == 1
-    with pytest.raises(_RemoveBoom):
-        await async_unload_entry(hass, entry)
-    assert hass.time_change.size == 0, "time-change listener not cancelled"
-    assert entry.runtime_data is None
-    assert DOMAIN not in hass.data
-
-
-async def test_setup_registers_day_rollover_listener(hass, make_entry) -> None:
-    """Setup registers a daily rollover listener and stores its cancel fn."""
-    entry = _wire(make_entry(), hass.registry)
-    assert await async_setup_entry(hass, entry) is True
-    assert hass.time_change.size == 1
-    registration = hass.time_change.registrations[0]
-    assert registration["hour"] == 0
-    assert registration["minute"] == 0
-    assert callable(entry.runtime_data.remove_time_change_listener)
-
-
-async def test_setup_registers_day_rollover_at_configured_time(hass, make_entry) -> None:
-    """The listener fires at the entry option's rollover time, not the default."""
-    entry = _wire(make_entry(options={CONF_DAY_ROLLOVER_TIME: "06:30"}), hass.registry)
-    await async_setup_entry(hass, entry)
-    registration = hass.time_change.registrations[0]
-    assert registration["hour"] == 6
-    assert registration["minute"] == 30
-
-
-async def test_unload_cancels_day_rollover_listener(hass, make_entry) -> None:
-    """Unload removes the time-change listener alongside the update listener."""
-    entry = _wire(make_entry(), hass.registry)
-    await async_setup_entry(hass, entry)
-    assert hass.time_change.size == 1
-    assert await async_unload_entry(hass, entry) is True
-    assert hass.time_change.size == 0
-
-
-async def test_rollover_time_change_reregisters_listener_at_new_time(
-    hass, make_entry
-) -> None:
-    """A rollover-time options change re-registers the listener at the new time."""
-    entry = _wire(
-        make_entry(options={CONF_DAY_ROLLOVER_TIME: "00:00"}), hass.registry
-    )
-    await async_setup_entry(hass, entry)
-    assert (hass.time_change.registrations[0]["hour"], hass.time_change.registrations[0]["minute"]) == (0, 0)
-
-    # The options flow writes the new rollover time, then HA reloads the
-    # entry: unload tears down the old listener, setup re-registers it.
-    entry.options = {CONF_DAY_ROLLOVER_TIME: "06:30"}
-    await async_unload_entry(hass, entry)
-    assert hass.time_change.size == 0
-
-    assert await async_setup_entry(hass, entry) is True
-    assert hass.time_change.size == 1
-    registration = hass.time_change.registrations[0]
-    assert (registration["hour"], registration["minute"]) == (6, 30)
-
-
-async def test_day_rollover_listener_materializes_ha_local_horizon(
-    hass, make_entry, monkeypatch
-) -> None:
-    """Firing the listener materializes today..today+horizon in HA local time."""
-    import datetime
-    from unittest.mock import AsyncMock
-    from zoneinfo import ZoneInfo
-
-    import custom_components.nestquest as nestquest
-
-    entry = _wire(make_entry(), hass.registry)
-    await async_setup_entry(hass, entry)
-    database = entry.runtime_data.database
-
-    fake = AsyncMock()
-    monkeypatch.setattr(nestquest, "_materialize_run", fake)
-
-    time_zone = ZoneInfo(hass.config.time_zone)
-    today = datetime.datetime.now(time_zone).date()
-    expected_start = today.isoformat()
-    expected_end = (today + datetime.timedelta(days=DEFAULT_HORIZON_DAYS)).isoformat()
-
-    await hass.time_change.fire()
-
-    fake.assert_awaited_once_with(
-        database, expected_start, expected_end, today=today
-    )
-
-
-async def test_day_rollover_uses_configured_horizon_days(hass, make_entry) -> None:
-    """The daily run materializes only the configured horizon window."""
-    import datetime
-
-    from custom_components.nestquest.dao_instances import QuestInstancesDao
-
-    entry = _wire(make_entry(options={CONF_HORIZON_DAYS: 5}), hass.registry)
-    assert await async_setup_entry(hass, entry) is True
-    database = entry.runtime_data.database
-
-    # A definition created AFTER setup has no instances yet (create does not
-    # materialize); firing the daily listener must generate only the horizon.
-    child_id = await _seed_daily_child_and_definition(
-        database, _local_today(hass)
-    )
-    await hass.time_change.fire()
-
-    today = _local_today(hass)
-    end = (today + datetime.timedelta(days=5)).isoformat()
-    records = await QuestInstancesDao(database).list_by_date_range(
-        child_id, today.isoformat(), end
-    )
-    assert len(records) == 6
-
-    beyond = (today + datetime.timedelta(days=6)).isoformat()
-    beyond_end = (
-        today + datetime.timedelta(days=DEFAULT_HORIZON_DAYS)
-    ).isoformat()
-    assert await QuestInstancesDao(database).list_by_date_range(
-        child_id, beyond, beyond_end
-    ) == []
-
-
-def test_day_rollover_time_change_tracker_rejects_local_kwarg() -> None:
-    """The fake async_track_time_change mirrors HA 2024.6 (no ``local`` kwarg).
-
-    Setup drives the local-time wrapper directly, so passing ``local=`` must
-    raise TypeError — otherwise a regression in the production call would be
-    silently masked by the fake.
-    """
-    import inspect as _inspect
-
-    from homeassistant.helpers.event import async_track_time_change
-
-    params = _inspect.signature(async_track_time_change).parameters
-    assert list(params) == ["hass", "action", "hour", "minute", "second"]
-    with pytest.raises(TypeError):
-        async_track_time_change(None, lambda _now: None, hour=0, minute=0, local=True)
-
-
-async def test_setup_applies_all_v1_tables(hass, make_entry) -> None:
-    """Setup applies the full v1 DDL: all four v1 tables exist afterwards."""
-    entry = _wire(make_entry(), hass.registry)
-    assert await async_setup_entry(hass, entry) is True
-    database = entry.runtime_data.database
-    rows = await database.fetch_all(
-        "SELECT name FROM sqlite_master WHERE type = 'table' "
-        "AND name IN ('children', 'admin_users', 'schedule_rules', "
-        "'quest_definitions') ORDER BY name"
-    )
-    assert [row[0] for row in rows] == [
-        "admin_users",
-        "children",
-        "quest_definitions",
-        "schedule_rules",
-    ]
-    await async_unload_entry(hass, entry)
-
-
-async def _seed_daily_child_and_definition(database, today) -> int:
-    """Create one always-present child + a daily definition starting today.
-
-    Returns the child's id.  No presence schedule means the child is present
-    every day, so the daily rule yields exactly one instance per horizon day.
-    """
-    from custom_components.nestquest.dao_children import ChildrenDao
-    from custom_components.nestquest.quest_definitions import (
-        create_quest_definition,
-    )
-    from custom_components.nestquest.recurrence import RuleType, ScheduleRule
-
-    NOW = "2026-09-14T12:00:00+00:00"
-    child = await ChildrenDao(database).create("Ada", NOW)
-    await create_quest_definition(
-        database,
-        "Daily chore",
-        ScheduleRule(rule_type=RuleType.DAILY, start_date=today.isoformat()),
-        [child.id],
-        ["morning"],
-    )
-    return child.id
-
-
-def _local_today(hass) -> "datetime.date":
-    import datetime
-    from zoneinfo import ZoneInfo
-
-    return datetime.datetime.now(ZoneInfo(hass.config.time_zone)).date()
-
-
-async def test_setup_backfills_instances_over_horizon(hass, make_entry) -> None:
-    """Setup materializes once so a restart backfills any missed days."""
-    import datetime
-
-    from custom_components.nestquest.dao_instances import QuestInstancesDao
-    from custom_components.nestquest.db import NestQuestDatabase
-    from custom_components.nestquest.migrations import apply_migrations
-    from custom_components.nestquest.store import async_get_db_path
-
-    # Seed the database BEFORE setup: a restart reopens an existing file that
-    # already holds definitions.  The startup backfill must pick them up.
-    db_path = await async_get_db_path(hass)
-    pre = NestQuestDatabase(hass)
-    await pre.open(db_path)
-    await apply_migrations(pre)
-    child_id = await _seed_daily_child_and_definition(pre, _local_today(hass))
-    await pre.close()
-
-    entry = _wire(make_entry(), hass.registry)
-    assert await async_setup_entry(hass, entry) is True
-
-    today = _local_today(hass)
-    end = (today + datetime.timedelta(days=DEFAULT_HORIZON_DAYS)).isoformat()
-    records = await QuestInstancesDao(entry.runtime_data.database).list_by_date_range(
-        child_id, today.isoformat(), end
-    )
-    assert len(records) == DEFAULT_HORIZON_DAYS + 1
-
-
-async def test_setup_backfills_configured_horizon_days(hass, make_entry) -> None:
-    """Setup backfills only the configured (non-default) horizon window."""
-    import datetime
-
-    from custom_components.nestquest.dao_instances import QuestInstancesDao
-    from custom_components.nestquest.db import NestQuestDatabase
-    from custom_components.nestquest.migrations import apply_migrations
-    from custom_components.nestquest.store import async_get_db_path
-
-    db_path = await async_get_db_path(hass)
-    pre = NestQuestDatabase(hass)
-    await pre.open(db_path)
-    await apply_migrations(pre)
-    child_id = await _seed_daily_child_and_definition(pre, _local_today(hass))
-    await pre.close()
-
-    entry = _wire(
-        make_entry(options={CONF_HORIZON_DAYS: 5}), hass.registry
-    )
-    assert await async_setup_entry(hass, entry) is True
-
-    today = _local_today(hass)
-    end = (today + datetime.timedelta(days=5)).isoformat()
-    records = await QuestInstancesDao(
-        entry.runtime_data.database
-    ).list_by_date_range(child_id, today.isoformat(), end)
-    assert len(records) == 6
-
-    beyond = (today + datetime.timedelta(days=6)).isoformat()
-    beyond_end = (
-        today + datetime.timedelta(days=DEFAULT_HORIZON_DAYS)
-    ).isoformat()
-    assert await QuestInstancesDao(
-        entry.runtime_data.database
-    ).list_by_date_range(child_id, beyond, beyond_end) == []
-
-
-def test_configured_horizon_days_validates_and_falls_back() -> None:
-    """The configured horizon is validated; a malformed value uses the default."""
-    import custom_components.nestquest as nestquest
-
-    assert nestquest._configured_horizon_days({CONF_HORIZON_DAYS: 5}) == 5
-    assert nestquest._configured_horizon_days({}) == DEFAULT_HORIZON_DAYS
-    assert (
-        nestquest._configured_horizon_days({CONF_HORIZON_DAYS: True})
-        == DEFAULT_HORIZON_DAYS
-    )
-    assert (
-        nestquest._configured_horizon_days({CONF_HORIZON_DAYS: "5"})
-        == DEFAULT_HORIZON_DAYS
-    )
-    assert (
-        nestquest._configured_horizon_days({CONF_HORIZON_DAYS: 0})
-        == DEFAULT_HORIZON_DAYS
-    )
-
-
-async def test_regenerate_service_registered_and_materializes(
-    hass, make_entry
-) -> None:
-    """``nestquest.regenerate`` is registered and calling it regenerates."""
-    import datetime
-
-    from custom_components.nestquest.dao_instances import QuestInstancesDao
-
-    entry = _wire(make_entry(), hass.registry)
-    assert await async_setup_entry(hass, entry) is True
-    assert hass.services.has_service(DOMAIN, SERVICE_REGENERATE)
-
-    # A definition created AFTER setup has no instances yet (create does not
-    # materialize); the service must generate them on demand.
-    database = entry.runtime_data.database
-    child_id = await _seed_daily_child_and_definition(database, _local_today(hass))
-
-    await hass.services.call(DOMAIN, SERVICE_REGENERATE)
-
-    today = _local_today(hass)
-    end = (today + datetime.timedelta(days=DEFAULT_HORIZON_DAYS)).isoformat()
-    records = await QuestInstancesDao(database).list_by_date_range(
-        child_id, today.isoformat(), end
-    )
-    assert len(records) == DEFAULT_HORIZON_DAYS + 1
-
-
-async def test_regenerate_service_uses_configured_horizon_days(
-    hass, make_entry
-) -> None:
-    """``nestquest.regenerate`` regenerates only the configured horizon."""
-    import datetime
-
-    from custom_components.nestquest.dao_instances import QuestInstancesDao
-
-    entry = _wire(
-        make_entry(options={CONF_HORIZON_DAYS: 5}), hass.registry
-    )
-    assert await async_setup_entry(hass, entry) is True
-
-    database = entry.runtime_data.database
-    child_id = await _seed_daily_child_and_definition(database, _local_today(hass))
-
-    await hass.services.call(DOMAIN, SERVICE_REGENERATE)
-
-    today = _local_today(hass)
-    end = (today + datetime.timedelta(days=5)).isoformat()
-    records = await QuestInstancesDao(database).list_by_date_range(
-        child_id, today.isoformat(), end
-    )
-    assert len(records) == 6
-
-    beyond = (today + datetime.timedelta(days=6)).isoformat()
-    beyond_end = (
-        today + datetime.timedelta(days=DEFAULT_HORIZON_DAYS)
-    ).isoformat()
-    assert await QuestInstancesDao(database).list_by_date_range(
-        child_id, beyond, beyond_end
-    ) == []
-
-
-async def test_unload_deregisters_regenerate_service(hass, make_entry) -> None:
-    """Unload removes the ``regenerate`` service so no stale entry leaks."""
-    entry = _wire(make_entry(), hass.registry)
-    assert await async_setup_entry(hass, entry) is True
-    assert hass.services.has_service(DOMAIN, SERVICE_REGENERATE)
-
-    assert await async_unload_entry(hass, entry) is True
-    assert not hass.services.has_service(DOMAIN, SERVICE_REGENERATE)
-
-
-async def test_regenerate_service_is_domain_scoped_across_entries(
-    hass, make_entry
-) -> None:
-    """The ``regenerate`` service is domain-global, not per-entry.
-
-    With two loaded entries the service must be registered and functional;
-    unloading one entry must keep it registered and functional for the
-    remaining entry; unloading the final entry must remove it.
-    """
-    import datetime
-
-    from custom_components.nestquest.dao_instances import QuestInstancesDao
-
-    entry_a = _wire(make_entry(entry_id="entry_a"), hass.registry)
-    entry_b = _wire(make_entry(entry_id="entry_b"), hass.registry)
-
-    assert await async_setup_entry(hass, entry_a) is True
-    assert await async_setup_entry(hass, entry_b) is True
-    assert hass.services.has_service(DOMAIN, SERVICE_REGENERATE)
-
-    # The domain-global handler resolves a live database from any entry.
-    database_b = entry_b.runtime_data.database
-    child_id = await _seed_daily_child_and_definition(
-        database_b, _local_today(hass)
-    )
-    await hass.services.call(DOMAIN, SERVICE_REGENERATE)
-    today = _local_today(hass)
-    end = (today + datetime.timedelta(days=DEFAULT_HORIZON_DAYS)).isoformat()
-    records = await QuestInstancesDao(database_b).list_by_date_range(
-        child_id, today.isoformat(), end
-    )
-    assert len(records) == DEFAULT_HORIZON_DAYS + 1
-
-    # Unloading one entry must not tear down the shared service.
-    assert await async_unload_entry(hass, entry_a) is True
-    assert hass.services.has_service(DOMAIN, SERVICE_REGENERATE)
-
-    # It still works for the remaining entry.
-    await hass.services.call(DOMAIN, SERVICE_REGENERATE)
-
-    # Unloading the final entry removes the domain-global service.
-    assert await async_unload_entry(hass, entry_b) is True
-    assert not hass.services.has_service(DOMAIN, SERVICE_REGENERATE)
-
-
-async def test_setup_cleans_listeners_when_materialization_raises(
-    hass, make_entry, monkeypatch
-) -> None:
-    """A startup-materialization failure rolls back every registered listener.
-
-    The daily and update listeners are installed before the startup
-    materialization runs; when that walk raises, the database is closed but
-    the remover callables must also be invoked so no listener survives
-    firing against a closed database.
-    """
-    import custom_components.nestquest as nestquest
-
-    async def _boom(*_args, **_kwargs):
-        raise RuntimeError("materialization failed")
-
-    monkeypatch.setattr(nestquest, "_materialize_run", _boom)
-
-    entry = _wire(make_entry(), hass.registry)
-    with pytest.raises(RuntimeError, match="materialization failed"):
-        await async_setup_entry(hass, entry)
-
-    assert hass.time_change.size == 0
-    assert hass.registry.size == 0
-    assert not hass.services.has_service(DOMAIN, SERVICE_REGENERATE)
-    assert not hasattr(entry, "runtime_data")
+    assert DOMAIN not in hass.data

tests/test_manifest.py

@@ -56,24 +56,6 @@ def test_manifest_requirements(manifest: dict) -> None:
     assert manifest.get("requirements") == []
 
 
-def test_manifest_documentation_url_is_public_github_mirror(manifest: dict) -> None:
-    """Verify documentation URL points at the public GitHub mirror."""
-    assert manifest.get("documentation") == "https://github.com/talon2king/NestQuest"
-
-
-def test_manifest_issue_tracker_url_is_public_github_mirror(manifest: dict) -> None:
-    """Verify issue_tracker URL points at the public GitHub mirror."""
-    assert manifest.get("issue_tracker") == "https://github.com/talon2king/NestQuest/issues"
-
-
-@pytest.mark.parametrize("key", ["documentation", "issue_tracker"])
-def test_manifest_urls_use_github_com(manifest: dict, key: str) -> None:
-    """Verify manifest URLs use github.com rather than the private Gitea host."""
-    url = manifest.get(key, "")
-    assert url.startswith("https://github.com/talon2king/NestQuest")
-    assert "cubecraftlabs" not in url
-
-
 @pytest.mark.parametrize(
     "key",
     ["name", "version", "documentation", "issue_tracker", "codeowners"],

tests/test_options_flow.py

@@ -14,7 +14,6 @@ from conftest import make_config_entry, make_hass, options_flow_base as _options
 from custom_components.nestquest import config_flow
 from custom_components.nestquest import options_flow
 from custom_components.nestquest.const import (
-    CONF_ADMIN_USER_IDS,
     CONF_DAY_ROLLOVER_TIME,
     CONF_HORIZON_DAYS,
     CONF_PANEL_IDLE_TIMEOUT,
@@ -47,48 +46,13 @@ def _make_entry(entry_id: str = "test_entry", options: dict | None = None, data:
     return make_config_entry(entry_id=entry_id, options=options, data=data)
 
 
-def _make_flow(entry, *, users=None, database=None) -> options_flow.NestQuestOptionsFlow:
-    """Create an options flow instance bound to a stubbed config entry.
-
-    ``users`` populates a stubbed hass.auth for the admin picker;
-    ``database`` wires the runtime record so the flow can read and
-    write the allowlist like real HA's options flow does.
-    """
-    from unittest.mock import AsyncMock
-
+def _make_flow(entry) -> options_flow.NestQuestOptionsFlow:
+    """Create an options flow instance bound to a stubbed config entry."""
     flow = options_flow.NestQuestOptionsFlow(config_entry=entry)
     flow.hass = SimpleNamespace()
-    flow.hass.auth = SimpleNamespace(
-        async_get_users=AsyncMock(return_value=users or [])
-    )
-    if database is not None:
-        from custom_components.nestquest.const import DOMAIN
-
-        flow.hass.data = {
-            DOMAIN: {entry.entry_id: SimpleNamespace(database=database)}
-        }
     return flow
 
 
-def _user(user_id: str, name: str):
-    return SimpleNamespace(id=user_id, name=name)
-
-
-def _open_allowlist_db(tmp_path, name):
-    """A real migrated temp database for the flow to read and write."""
-    from unittest.mock import AsyncMock, MagicMock
-
-    from custom_components.nestquest.db import NestQuestDatabase
-    from custom_components.nestquest.migrations import apply_migrations
-
-    hass = MagicMock()
-    hass.async_add_executor_job = AsyncMock(side_effect=(lambda fn, *a: fn(*a)))
-    database = NestQuestDatabase(hass)
-    _run(database.open(tmp_path / name))
-    _run(apply_migrations(database))
-    return database
-
-
 def _schema_values(schema) -> dict:
     """Extract the per-field default values from a real voluptuous schema."""
     return {
@@ -197,12 +161,7 @@ def test_options_flow_falls_back_to_entry_data() -> None:
 
 
 def test_options_flow_schema_applies_stored_defaults() -> None:
-    """A real voluptuous validate({}) fills every field from the stored defaults.
-
-    Without a runtime database (and no auth in the bare harness), the
-    admin picker's default is the empty selection and its choice set is
-    empty — the three legacy settings are unaffected.
-    """
+    """A real voluptuous validate({}) fills every field from the stored defaults."""
     entry = _make_entry(
         options={
             CONF_HORIZON_DAYS: 21,
@@ -215,7 +174,6 @@ def test_options_flow_schema_applies_stored_defaults() -> None:
         CONF_HORIZON_DAYS: 21,
         CONF_DAY_ROLLOVER_TIME: "05:45",
         CONF_PANEL_IDLE_TIMEOUT: 120,
-        CONF_ADMIN_USER_IDS: [],
     }
 
 
@@ -415,223 +373,4 @@ def test_options_flow_no_hardcoded_domain_or_db_filename() -> None:
             )
             assert node.value != "nestquest.db", (
                 f"Hard-coded database filename in {py_file.name}:{node.lineno}"
-            )
-
-# ---------------------------------------------------------------------------
-# Admin allowlist picker (Feature 03)
-# ---------------------------------------------------------------------------
-
-
-def test_options_flow_picker_lists_existing_users(tmp_path) -> None:
-    """The picker offers EXISTING HA users (id -> name), never free text."""
-    import voluptuous as vol
-
-    database = _open_allowlist_db(tmp_path, "picker-users.db")
-    try:
-        from custom_components.nestquest.admin_allowlist import set_admin_ids
-
-        _run(set_admin_ids(database, ["u1"]))
-        entry = _make_entry()
-        flow = _make_flow(
-            entry,
-            users=[_user("u1", "Joshua"), _user("u2", "Sam")],
-            database=database,
-        )
-        result = _run(flow.async_step_init(None))
-        schema = result["data_schema"]
-        marker = next(
-            m for m in schema.schema
-            if getattr(m, "schema", None) == CONF_ADMIN_USER_IDS
-        )
-        # Default is the CURRENT database allowlist.
-        values = _schema_values(schema)
-        assert values[CONF_ADMIN_USER_IDS] == ["u1"]
-        # Both users are selectable; an unknown id is rejected by the
-        # schema itself (this is what real HA submits go through).
-        validated = schema(
-            {
-                CONF_HORIZON_DAYS: 7,
-                CONF_DAY_ROLLOVER_TIME: "03:30",
-                CONF_PANEL_IDLE_TIMEOUT: 60,
-                CONF_ADMIN_USER_IDS: ["u1", "u2"],
-            }
-        )
-        assert validated[CONF_ADMIN_USER_IDS] == ["u1", "u2"]
-        with pytest.raises(vol.Invalid):
-            schema(
-                {
-                    CONF_HORIZON_DAYS: 7,
-                    CONF_DAY_ROLLOVER_TIME: "03:30",
-                    CONF_PANEL_IDLE_TIMEOUT: 60,
-                    CONF_ADMIN_USER_IDS: ["impostor"],
-                }
-            )
-    finally:
-        _run(database.close())
-
-
-def test_options_flow_submit_applies_selection_to_database(tmp_path) -> None:
-    database = _open_allowlist_db(tmp_path, "picker-apply.db")
-    try:
-        from custom_components.nestquest.admin_allowlist import (
-            list_admin_ids,
-            set_admin_ids,
-        )
-
-        _run(set_admin_ids(database, ["u1"]))
-        entry = _make_entry()
-        flow = _make_flow(
-            entry,
-            users=[_user("u1", "Joshua"), _user("u2", "Sam")],
-            database=database,
-        )
-        result = _run(
-            flow.async_step_init({**VALID_INPUT, CONF_ADMIN_USER_IDS: ["u2"]})
-        )
-        assert result["type"] == "create_entry"
-        assert result["data"][CONF_ADMIN_USER_IDS] == ["u2"]
-        # The allowlist (and the entry's recovery copy) carry the pick.
-        assert await_gather(list_admin_ids(database)) == ["u2"]
-    finally:
-        _run(database.close())
-
-
-def await_gather(coro):
-    return _run(coro)
-
-
-def test_options_flow_empty_selection_refused(tmp_path) -> None:
-    """Saving zero admins is refused: an empty allowlist fails closed."""
-    database = _open_allowlist_db(tmp_path, "picker-empty.db")
-    try:
-        from custom_components.nestquest.admin_allowlist import (
-            list_admin_ids,
-            set_admin_ids,
-        )
-
-        _run(set_admin_ids(database, ["u1"]))
-        entry = _make_entry()
-        flow = _make_flow(
-            entry,
-            users=[_user("u1", "Joshua")],
-            database=database,
-        )
-        result = _run(
-            flow.async_step_init({**VALID_INPUT, CONF_ADMIN_USER_IDS: []})
-        )
-        assert result["type"] == "form"
-        assert result["errors"] == {CONF_ADMIN_USER_IDS: "no_admins"}
-        assert await_gather(list_admin_ids(database)) == ["u1"]
-    finally:
-        _run(database.close())
-
-
-def test_options_flow_unknown_selection_refused(tmp_path) -> None:
-    database = _open_allowlist_db(tmp_path, "picker-unknown.db")
-    try:
-        from custom_components.nestquest.admin_allowlist import (
-            list_admin_ids,
-            set_admin_ids,
-        )
-
-        _run(set_admin_ids(database, ["u1"]))
-        entry = _make_entry()
-        flow = _make_flow(
-            entry,
-            users=[_user("u1", "Joshua")],
-            database=database,
-        )
-        result = _run(
-            flow.async_step_init(
-                {**VALID_INPUT, CONF_ADMIN_USER_IDS: ["impostor"]}
-            )
-        )
-        assert result["type"] == "form"
-        assert result["errors"] == {CONF_ADMIN_USER_IDS: "invalid_admin"}
-        assert await_gather(list_admin_ids(database)) == ["u1"]
-    finally:
-        _run(database.close())
-
-
-def test_options_flow_submit_without_admin_key_keeps_allowlist(tmp_path) -> None:
-    """Raw callers omitting the key (pre-picker payloads) do not
-    touch the allowlist; the CURRENT allowlist is carried forward on
-    the options copy so no removed admin can be resurrected later."""
-    database = _open_allowlist_db(tmp_path, "picker-legacy.db")
-    try:
-        from custom_components.nestquest.admin_allowlist import (
-            list_admin_ids,
-            set_admin_ids,
-        )
-
-        _run(set_admin_ids(database, ["u1"]))
-        entry = _make_entry()
-        flow = _make_flow(
-            entry,
-            users=[_user("u1", "Joshua")],
-            database=database,
-        )
-        result = _run(flow.async_step_init(dict(VALID_INPUT)))
-        assert result["type"] == "create_entry"
-        assert result["data"][CONF_ADMIN_USER_IDS] == ["u1"]
-        assert await_gather(list_admin_ids(database)) == ["u1"]
-    finally:
-        _run(database.close())
-
-
-def test_options_flow_duplicate_selection_refused(tmp_path) -> None:
-    """Duplicate ids surface as a field error, not an unhandled
-    ValueError from the business layer."""
-    database = _open_allowlist_db(tmp_path, "picker-dupe.db")
-    try:
-        from custom_components.nestquest.admin_allowlist import (
-            list_admin_ids,
-            set_admin_ids,
-        )
-
-        _run(set_admin_ids(database, ["u1"]))
-        entry = _make_entry()
-        flow = _make_flow(
-            entry,
-            users=[_user("u1", "Joshua"), _user("u2", "Sam")],
-            database=database,
-        )
-        result = _run(
-            flow.async_step_init(
-                {**VALID_INPUT, CONF_ADMIN_USER_IDS: ["u2", "u2"]}
-            )
-        )
-        assert result["type"] == "form"
-        assert result["errors"] == {CONF_ADMIN_USER_IDS: "invalid_admin"}
-        assert await_gather(list_admin_ids(database)) == ["u1"]
-    finally:
-        _run(database.close())
-
-
-def test_options_flow_omitted_picker_carries_allowlist_forward(
-    tmp_path,
-) -> None:
-    """An omitted picker field must not drop the allowlist copy from
-    the returned options: HA replaces entry.options wholesale, and a
-    later database loss must not resurrect removed admins from the
-    stale config-flow copy in entry.data."""
-    database = _open_allowlist_db(tmp_path, "picker-carry.db")
-    try:
-        from custom_components.nestquest.admin_allowlist import (
-            set_admin_ids,
-        )
-
-        _run(set_admin_ids(database, ["u2"]))
-        entry = _make_entry()
-        flow = _make_flow(
-            entry,
-            users=[_user("u1", "Joshua"), _user("u2", "Sam")],
-            database=database,
-        )
-        result = _run(flow.async_step_init(dict(VALID_INPUT)))
-        assert result["type"] == "create_entry"
-        # The current allowlist rides along on the legacy three-key path.
-        assert result["data"][CONF_ADMIN_USER_IDS] == ["u2"]
-        assert result["data"][CONF_HORIZON_DAYS] == VALID_INPUT[CONF_HORIZON_DAYS]
-    finally:
-        _run(database.close())
+            )

tests/test_presence.py

@@ -1,814 +0,0 @@
-"""Tests for presence.py: the Feature 05 custody model."""
-from __future__ import annotations
-
-import datetime
-
-import pytest
-
-from custom_components.nestquest.presence import (
-    MAX_CYCLE_LENGTH_WEEKS,
-    PresenceEngine,
-    PresenceOverride,
-    PresenceSchedule,
-    cycle_week_index,
-)
-
-
-ANCHOR = datetime.date(2026, 1, 5)  # a Monday
-
-TWO_WEEK_PATTERN = {0: {0, 2, 4}, 1: {1, 3}}
-
-
-# ---------------------------------------------------------------------------
-# PresenceSchedule construction
-# ---------------------------------------------------------------------------
-
-
-def test_schedule_holds_validated_fields() -> None:
-    schedule = PresenceSchedule(
-        3, 2, "2026-01-05", {0: {0, 2, 4}, 1: {1, 3}}
-    )
-    assert schedule.child_id == 3
-    assert schedule.cycle_length_weeks == 2
-    assert schedule.anchor_date == ANCHOR
-    assert schedule.pattern == {0: frozenset({0, 2, 4}), 1: frozenset({1, 3})}
-
-
-def test_schedule_accepts_date_objects() -> None:
-    schedule = PresenceSchedule(1, 1, ANCHOR, {0: {0}})
-    assert schedule.anchor_date is ANCHOR
-
-
-def test_schedule_rejects_cycle_length_below_one() -> None:
-    with pytest.raises(ValueError, match="between 1 and"):
-        PresenceSchedule(1, 0, ANCHOR, {})
-    with pytest.raises(ValueError, match="between 1 and"):
-        PresenceSchedule(1, -1, ANCHOR, {})
-
-
-def test_schedule_rejects_cycle_length_above_documented_cap() -> None:
-    """The 4 cap matches the schema's CHECK — both documents agree."""
-    with pytest.raises(ValueError, match="between 1 and"):
-        PresenceSchedule(1, MAX_CYCLE_LENGTH_WEEKS + 1, ANCHOR, {})
-    assert MAX_CYCLE_LENGTH_WEEKS == 4
-
-
-@pytest.mark.parametrize("bad", [True, "2", 1.0, None])
-def test_schedule_rejects_non_int_cycle_length(bad) -> None:
-    with pytest.raises(ValueError, match="cycle_length_weeks must be an integer"):
-        PresenceSchedule(1, bad, ANCHOR, {0: {0}})
-
-
-def test_schedule_rejects_pattern_missing_week_indices() -> None:
-    with pytest.raises(ValueError, match="missing \\[1\\]"):
-        PresenceSchedule(1, 2, ANCHOR, {0: {0, 2}})
-
-
-def test_schedule_rejects_pattern_with_extra_week_indices() -> None:
-    with pytest.raises(ValueError, match="week index must be in 0"):
-        PresenceSchedule(1, 2, ANCHOR, {0: {0}, 1: {1}, 2: {2}})
-
-
-def test_schedule_rejects_pattern_with_non_int_week_keys() -> None:
-    with pytest.raises(ValueError, match="week index must be an integer"):
-        PresenceSchedule(1, 1, ANCHOR, {"0": {0}})
-
-
-def test_schedule_rejects_pattern_with_bool_week_key() -> None:
-    """True would silently be week 1; bools are never valid indices."""
-    with pytest.raises(ValueError, match="week index must be an integer"):
-        PresenceSchedule(1, 2, ANCHOR, {0: {0}, True: {1}})
-
-
-@pytest.mark.parametrize("bad_weekday", [-1, 7, 100])
-def test_schedule_rejects_weekday_outside_zero_to_six(bad_weekday) -> None:
-    with pytest.raises(ValueError, match="weekday must be in 0..6"):
-        PresenceSchedule(1, 1, ANCHOR, {0: {bad_weekday}})
-
-
-@pytest.mark.parametrize("bad", [True, "1", 1.5, None])
-def test_schedule_rejects_non_int_weekdays(bad) -> None:
-    with pytest.raises(ValueError, match="weekday must be an int"):
-        PresenceSchedule(1, 1, ANCHOR, {0: [bad]})
-
-
-def test_schedule_rejects_string_and_none_week_sets() -> None:
-    """A string is iterable — "02" would silently mean {0, 2}."""
-    with pytest.raises(ValueError, match="iterable of weekday ints"):
-        PresenceSchedule(1, 1, ANCHOR, {0: "02"})
-    with pytest.raises(ValueError, match="iterable of weekday ints"):
-        PresenceSchedule(1, 1, ANCHOR, {0: None})
-
-
-def test_schedule_rejects_non_dict_pattern() -> None:
-    with pytest.raises(ValueError, match="must map week index"):
-        PresenceSchedule(1, 1, ANCHOR, "0,2")
-
-
-@pytest.mark.parametrize("bad", [True, 1.0, "2026-01-05", None])
-def test_schedule_rejects_non_int_child_id(bad) -> None:
-    with pytest.raises(ValueError, match="child_id must be an integer"):
-        PresenceSchedule(bad, 1, ANCHOR, {0: {0}})
-
-
-@pytest.mark.parametrize(
-    "bad", ["2026-1-5", "2026/01/05", "not-a-date", 5, None, True]
-)
-def test_schedule_rejects_non_strict_anchor_dates(bad) -> None:
-    with pytest.raises(ValueError, match="anchor_date"):
-        PresenceSchedule(1, 1, bad, {0: {0}})
-
-
-def test_schedule_empty_week_means_absent_week() -> None:
-    """An explicitly empty week is valid: absent every day of it —
-    distinct from having no schedule (the engine's default)."""
-    schedule = PresenceSchedule(1, 2, ANCHOR, {0: {0, 2}, 1: set()})
-    assert schedule.pattern[1] == frozenset()
-
-
-def test_schedule_empty_week_encodes_as_empty_segment() -> None:
-    schedule = PresenceSchedule(1, 2, ANCHOR, {0: {0, 2}, 1: set()})
-    assert schedule.encode() == "0,2|"
-
-
-def test_schedule_equal_patterns_are_equal_and_encode_identically() -> None:
-    one = PresenceSchedule(1, 2, ANCHOR, {0: {4, 2, 0}, 1: {3, 1}})
-    two = PresenceSchedule(2, 2, ANCHOR, {0: {0, 2, 4}, 1: {1, 3}})
-    assert one.encode() == two.encode() == "0,2,4|1,3"
-
-
-# ---------------------------------------------------------------------------
-# Serialization round-trip
-# ---------------------------------------------------------------------------
-
-
-@pytest.mark.parametrize(
-    "encoded",
-    [
-        "0,2,4|1,3",
-        "0|1,2,3,4,5,6",
-        "|",
-        "0,2|",
-        "|0,2",
-        "6",
-        "0,1,2,3,4,5,6|",
-    ],
-)
-def test_schedule_decode_encode_round_trips_losslessly(encoded) -> None:
-    schedule = PresenceSchedule.decode(1, ANCHOR, encoded)
-    assert schedule.encode() == encoded
-    again = PresenceSchedule.decode(1, ANCHOR, schedule.encode())
-    assert again == schedule
-
-
-def test_schedule_decode_sets_cycle_length_from_segments() -> None:
-    one_week = PresenceSchedule.decode(1, ANCHOR, "0,2,4")
-    assert one_week.cycle_length_weeks == 1
-    four_week = PresenceSchedule.decode(1, ANCHOR, "0|1|2|3,4")
-    assert four_week.cycle_length_weeks == 4
-
-
-def test_schedule_decode_rejects_malformed_segments() -> None:
-    for bad in ("0,12|1", "0,,2|1", "x|1", "0|-1|2", "8", "0,|1"):
-        with pytest.raises(ValueError, match="invalid weekday"):
-            PresenceSchedule.decode(1, ANCHOR, bad)
-
-
-def test_schedule_decode_rejects_non_string() -> None:
-    with pytest.raises(ValueError, match="must be a string"):
-        PresenceSchedule.decode(1, ANCHOR, None)
-
-
-def test_schedule_decode_rejects_too_many_segments(tmp_path) -> None:
-    with pytest.raises(ValueError, match="between 1 and"):
-        PresenceSchedule.decode(1, ANCHOR, "0|1|2|3|4")
-
-
-# ---------------------------------------------------------------------------
-# PresenceOverride
-# ---------------------------------------------------------------------------
-
-
-def test_override_single_date_and_range_cover() -> None:
-    single = PresenceOverride(1, "2026-07-20", "2026-07-20", False)
-    assert single.covers(datetime.date(2026, 7, 20))
-    assert not single.covers(datetime.date(2026, 7, 21))
-    span = PresenceOverride(1, "2026-07-20", "2026-07-24", True, note="trade")
-    assert span.covers(datetime.date(2026, 7, 22))
-    assert not span.covers(datetime.date(2026, 7, 19))
-    assert not span.covers(datetime.date(2026, 7, 25))
-    assert span.note == "trade"
-
-
-def test_override_end_before_start_rejected() -> None:
-    with pytest.raises(ValueError, match="end_date must be on or after"):
-        PresenceOverride(1, "2026-07-24", "2026-07-20", True)
-
-
-@pytest.mark.parametrize("bad", ["1", 0, 1.0, None])
-def test_override_rejects_non_bool_is_present(bad) -> None:
-    with pytest.raises(ValueError, match="is_present must be a real bool"):
-        PresenceOverride(1, "2026-07-20", "2026-07-20", bad)
-
-
-@pytest.mark.parametrize("bad", [5, ["note"], 1.5])
-def test_override_rejects_non_string_note(bad) -> None:
-    with pytest.raises(ValueError, match="note must be a string or None"):
-        PresenceOverride(1, "2026-07-20", "2026-07-20", True, note=bad)
-
-
-@pytest.mark.parametrize("bad", [True, 1.0, "1"])
-def test_override_rejects_non_int_child_id(bad) -> None:
-    with pytest.raises(ValueError, match="child_id must be an integer"):
-        PresenceOverride(bad, "2026-07-20", "2026-07-20", True)
-
-
-@pytest.mark.parametrize(
-    ("start", "end"), [("2026-7-20", "2026-07-20"), ("nope", "2026-07-20")]
-)
-def test_override_rejects_non_strict_dates(start, end) -> None:
-    with pytest.raises(ValueError, match="date"):
-        PresenceOverride(1, start, end, True)
-
-
-def test_schedule_rejects_datetime_anchor() -> None:
-    """datetime.datetime subclasses date: a bare isinstance check would
-    store a time component and every date comparison would TypeError."""
-    with pytest.raises(ValueError, match="plain calendar date"):
-        PresenceSchedule(1, 1, datetime.datetime(2026, 1, 5, 9, 30), {0: {0}})
-
-
-def test_override_rejects_datetime_bounds() -> None:
-    with pytest.raises(ValueError, match="plain calendar date"):
-        PresenceOverride(
-            1, datetime.datetime(2026, 7, 20), "2026-07-20", True
-        )
-
-
-def test_schedule_pattern_is_immutable_after_construction() -> None:
-    """The frozen schedule must not leak a mutable dict: injecting
-    unvalidated weekdays or dropping required weeks after construction
-    would bypass total validation."""
-    schedule = PresenceSchedule(1, 2, ANCHOR, {0: {0, 2}, 1: {1}})
-    with pytest.raises(TypeError):
-        schedule.pattern[0] = {9}
-    with pytest.raises(TypeError):
-        del schedule.pattern[1]
-    # mappingproxy exposes no mutators at all.
-    assert not any(
-        hasattr(schedule.pattern, name)
-        for name in ("clear", "pop", "popitem", "setdefault", "update")
-    )
-    # The validated contents are still readable and encode correctly.
-    assert schedule.pattern[0] == frozenset({0, 2})
-    assert schedule.encode() == "0,2|1"
-
-
-# ---------------------------------------------------------------------------
-# Cycle arithmetic: anchor-date only, never ISO week parity
-# ---------------------------------------------------------------------------
-
-
-def test_cycle_week_index_follows_the_anchor_formula() -> None:
-    schedule = PresenceSchedule(1, 2, ANCHOR, {0: {0}, 1: {1}})
-    # The anchor day starts week 0; each whole 7 days steps the cycle.
-    offsets = {0: 0, 1: 0, 6: 0, 7: 1, 8: 1, 13: 1, 14: 0, 15: 0, 22: 1}
-    for offset, expected in offsets.items():
-        assert (
-            cycle_week_index(
-                schedule, ANCHOR + datetime.timedelta(days=offset)
-            )
-            == expected
-        ), f"offset {offset}"
-
-
-def test_cycle_week_index_before_the_anchor_walks_backwards() -> None:
-    """Python floor division: day -1 is the LAST week of the cycle,
-    wrapping backwards — never inverting."""
-    schedule = PresenceSchedule(1, 2, ANCHOR, {0: {0}, 1: {1}})
-    assert cycle_week_index(schedule, ANCHOR - datetime.timedelta(days=1)) == 1
-    assert cycle_week_index(schedule, ANCHOR - datetime.timedelta(days=7)) == 1
-    assert cycle_week_index(schedule, ANCHOR - datetime.timedelta(days=8)) == 0
-
-
-def test_cycle_week_index_three_week_pattern() -> None:
-    schedule = PresenceSchedule(
-        1, 3, ANCHOR, {0: {0}, 1: {1}, 2: {2}}
-    )
-    offsets = [0, 7, 14, 21, 28]
-    assert [cycle_week_index(schedule, ANCHOR + datetime.timedelta(days=o)) for o in offsets] == [
-        0, 1, 2, 0, 1
-    ]
-
-
-def test_cycle_week_index_stable_across_three_year_boundaries() -> None:
-    """The regression this exists for: walking day by day through a
-    December 31st -> January 1st boundary, the cycle index steps by 0
-    or +1 (mod cycle length) and NEVER resets or inverts — including
-    2020, a 53-ISO-week year, where ISO week parity flips and would
-    invert a two-week custody schedule on January 1st."""
-    schedule = PresenceSchedule(
-        1, 2, datetime.date(2019, 1, 6), {0: {0, 2, 4}, 1: {1, 3}}
-    )
-    # Independently derived expectations (anchor 2019-01-06, index =
-    # floor(days-since-anchor / 7) % 2, hand-verified) — hardcoded so
-    # even an implementation that resets or inverts at January 1st
-    # cannot pass by coincidence:
-    expected = {
-        # 2019 -> 2020 boundary
-        datetime.date(2019, 12, 26): 0,
-        datetime.date(2019, 12, 27): 0,
-        datetime.date(2019, 12, 28): 0,
-        datetime.date(2019, 12, 29): 1,
-        datetime.date(2019, 12, 30): 1,
-        datetime.date(2019, 12, 31): 1,
-        datetime.date(2020, 1, 1): 1,
-        datetime.date(2020, 1, 2): 1,
-        datetime.date(2020, 1, 3): 1,
-        datetime.date(2020, 1, 4): 1,
-        datetime.date(2020, 1, 5): 0,
-        datetime.date(2020, 1, 6): 0,
-        datetime.date(2020, 1, 7): 0,
-        # 2020 (53 ISO weeks) -> 2021 boundary
-        datetime.date(2020, 12, 27): 1,
-        datetime.date(2020, 12, 28): 1,
-        datetime.date(2020, 12, 29): 1,
-        datetime.date(2020, 12, 30): 1,
-        datetime.date(2020, 12, 31): 1,
-        datetime.date(2021, 1, 1): 1,
-        datetime.date(2021, 1, 2): 1,
-        datetime.date(2021, 1, 3): 0,
-        datetime.date(2021, 1, 4): 0,
-        datetime.date(2021, 1, 5): 0,
-        datetime.date(2021, 1, 6): 0,
-        datetime.date(2021, 1, 7): 0,
-        # 2021 -> 2022 boundary
-        datetime.date(2021, 12, 27): 1,
-        datetime.date(2021, 12, 28): 1,
-        datetime.date(2021, 12, 29): 1,
-        datetime.date(2021, 12, 30): 1,
-        datetime.date(2021, 12, 31): 1,
-        datetime.date(2022, 1, 1): 1,
-        datetime.date(2022, 1, 2): 0,
-        datetime.date(2022, 1, 3): 0,
-        datetime.date(2022, 1, 4): 0,
-        datetime.date(2022, 1, 5): 0,
-        datetime.date(2022, 1, 6): 0,
-        datetime.date(2022, 1, 7): 0,
-    }
-    for day, wanted in expected.items():
-        got = cycle_week_index(schedule, day)
-        assert got == wanted, f"{day}: expected week {wanted}, got {got}"
-    # And 2020 really is the 53-ISO-week year this guards against.
-    assert datetime.date(2020, 12, 31).isocalendar()[1] == 53
-
-
-def test_module_uses_no_iso_week_functions() -> None:
-    """D-004 guardrail: cycle math never reads ISO week numbers."""
-    from pathlib import Path
-
-    source = Path(
-        __import__("custom_components.nestquest.presence", fromlist=["__file__"]).__file__
-    ).read_text()
-    assert "isocalendar" not in source
-    assert "isoweek" not in source
-
-
-# ---------------------------------------------------------------------------
-# PresenceEngine: is_present with the always-present default
-# ---------------------------------------------------------------------------
-
-
-def _three_child_engine() -> PresenceEngine:
-    """Two children on opposite weeks of one two-week rotation, one
-    with no schedule at all (the always-present sibling)."""
-    anchor = datetime.date(2026, 1, 5)  # Monday, week 0
-    declan = PresenceSchedule(
-        1, 2, anchor, {0: {0, 1, 2, 3, 4, 5, 6}, 1: set()}
-    )
-    jordyn = PresenceSchedule(
-        2, 2, anchor, {0: set(), 1: {0, 1, 2, 3, 4, 5, 6}}
-    )
-    return PresenceEngine({1: declan, 2: jordyn})
-
-
-def test_engine_child_without_schedule_is_always_present() -> None:
-    """Every day of the four-week span, all three children get the
-    expected verdict: Chloe (no schedule) always present; the two
-    rotation children complementary per the anchor pattern."""
-    engine = _three_child_engine()
-    anchor = datetime.date(2026, 1, 5)
-    for offset in range(28):
-        day = anchor + datetime.timedelta(days=offset)
-        week = ((day - anchor).days // 7) % 2
-        assert engine.is_present(3, day) is True, f"offset {offset}: Chloe"
-        assert engine.is_present(1, day) is (week == 0), (
-            f"offset {offset}: Declan should follow week {week}"
-        )
-        assert engine.is_present(2, day) is (week == 1), (
-            f"offset {offset}: Jordyn should follow week {week}"
-        )
-
-
-def test_engine_alternating_children_are_complementary_for_four_weeks() -> None:
-    """Every day of a four-week span: the two rotation children swap
-    presence exactly per the anchor pattern — when one is home the
-    other is away."""
-    engine = _three_child_engine()
-    anchor = datetime.date(2026, 1, 5)
-    for offset in range(28):
-        day = anchor + datetime.timedelta(days=offset)
-        d = engine.is_present(1, day)
-        j = engine.is_present(2, day)
-        assert d == (not j), f"offset {offset}: {d}/{j} not complementary"
-        expected_week = ((day - anchor).days // 7) % 2
-        expected_present = day.weekday() in {0, 1, 2, 3, 4, 5, 6}
-        assert engine.is_present(1, day) == (expected_week == 0), (
-            f"offset {offset}: Declan week {expected_week}"
-        )
-    # Spot-check the swap days.
-    assert engine.is_present(1, anchor) is True
-    assert engine.is_present(2, anchor) is False
-    assert engine.is_present(1, anchor + datetime.timedelta(days=7)) is False
-    assert engine.is_present(2, anchor + datetime.timedelta(days=7)) is True
-
-
-def test_engine_weekend_absence_respects_the_pattern() -> None:
-    """A weekday-set pattern excludes days outside the set even in the
-    child's present week."""
-    engine = PresenceEngine(
-        {
-            1: PresenceSchedule(
-                1, 2, datetime.date(2026, 1, 5), {0: {1, 3}, 1: {2, 4}}
-            )
-        }
-    )
-    # 2026-01-06 (Tue) is week 0, weekday 1 -> present.
-    assert engine.is_present(1, datetime.date(2026, 1, 6)) is True
-    # 2026-01-07 (Wed) is week 0, weekday 2 -> absent.
-    assert engine.is_present(1, datetime.date(2026, 1, 7)) is False
-    # 2026-01-14 (Wed) is week 1, weekday 2 -> present.
-    assert engine.is_present(1, datetime.date(2026, 1, 14)) is True
-
-
-def test_engine_rejects_bad_construction_and_inputs() -> None:
-    schedule = PresenceSchedule(1, 1, ANCHOR, {0: {0}})
-    with pytest.raises(ValueError, match="must map child_id"):
-        PresenceEngine([schedule])
-    with pytest.raises(ValueError, match="must be a PresenceSchedule"):
-        PresenceEngine({1: "not-a-schedule"})
-    with pytest.raises(ValueError, match="holds the schedule"):
-        PresenceEngine({2: schedule})
-    with pytest.raises(ValueError, match="child_id must be an integer"):
-        PresenceEngine({True: schedule})
-    with pytest.raises(ValueError, match="child_id must be an integer"):
-        PresenceEngine({1.0: PresenceSchedule(1, 1, ANCHOR, {0: {0}})})
-    engine = PresenceEngine({1: schedule})
-    with pytest.raises(ValueError, match="child_id must be an integer"):
-        engine.is_present(True, ANCHOR)
-    with pytest.raises(ValueError, match="plain calendar date"):
-        engine.is_present(1, datetime.datetime(2026, 1, 5))
-
-
-def test_engine_is_immutable() -> None:
-    engine = _three_child_engine()
-    with pytest.raises(AttributeError, match="immutable snapshot"):
-        engine._schedules = {}
-    with pytest.raises(AttributeError, match="immutable snapshot"):
-        engine.something_new = 1
-
-
-# ---------------------------------------------------------------------------
-# Overrides take precedence over the pattern
-# ---------------------------------------------------------------------------
-
-
-def _engine_with_overrides(*overrides_for_declan) -> PresenceEngine:
-    anchor = datetime.date(2026, 1, 5)  # Monday
-    return PresenceEngine(
-        {
-            1: PresenceSchedule(
-                1, 2, anchor, {0: {0, 1, 2, 3, 4, 5, 6}, 1: set()}
-            )
-        },
-        overrides={1: list(overrides_for_declan)} if overrides_for_declan else {},
-    )
-
-
-def test_absent_override_on_normally_present_day_wins() -> None:
-    # 2026-01-06 is Tuesday of Declan's week 0: normally present.
-    engine = _engine_with_overrides(
-        PresenceOverride(1, "2026-01-06", "2026-01-06", False, note="away")
-    )
-    assert engine.is_present(1, datetime.date(2026, 1, 6)) is False
-    # The pattern resumes outside the override.
-    assert engine.is_present(1, datetime.date(2026, 1, 7)) is True
-
-
-def test_present_override_on_normally_absent_day_wins() -> None:
-    # 2026-01-13 is in Declan's week 1 (away all week); a present
-    # override on the Tuesday of week 1 brings him home for that day.
-    engine = _engine_with_overrides(
-        PresenceOverride(1, "2026-01-13", "2026-01-13", True, note="trade")
-    )
-    assert engine.is_present(1, datetime.date(2026, 1, 13)) is True
-    assert engine.is_present(1, datetime.date(2026, 1, 14)) is False
-
-
-def test_override_applies_without_a_schedule() -> None:
-    """An override on a schedule-free child still applies: holidays and
-    swaps must work for the always-present sibling too."""
-    engine = PresenceEngine(
-        {},
-        overrides={
-            3: [
-                PresenceOverride(
-                    3, "2026-07-20", "2026-07-24", False, note="holiday"
-                )
-            ]
-        },
-    )
-    assert engine.is_present(3, datetime.date(2026, 7, 22)) is False
-    assert engine.is_present(3, datetime.date(2026, 7, 19)) is True
-    assert engine.is_present(3, datetime.date(2026, 7, 25)) is True
-
-
-def test_override_range_beats_pattern_for_its_span() -> None:
-    engine = _engine_with_overrides(
-        PresenceOverride(1, "2026-01-13", "2026-01-17", True, note="traded week")
-    )
-    for offset in range(12, 17):
-        day = datetime.date(2026, 1, 1) + datetime.timedelta(days=offset)
-        assert engine.is_present(1, day) is True, f"{day}"
-    # Days outside the span stay on the pattern (week 1: absent).
-    assert engine.is_present(1, datetime.date(2026, 1, 12)) is False
-    assert engine.is_present(1, datetime.date(2026, 1, 18)) is False
-
-
-def test_engine_override_snapshot_validation() -> None:
-    schedule = PresenceSchedule(1, 1, ANCHOR, {0: {0}})
-    entry = PresenceOverride(1, "2026-07-20", "2026-07-20", True)
-    with pytest.raises(ValueError, match="must map child_id"):
-        PresenceEngine({1: schedule}, overrides=[entry])
-    with pytest.raises(ValueError, match="must be a list"):
-        PresenceEngine({1: schedule}, overrides={1: entry})
-    with pytest.raises(ValueError, match="must be"):
-        PresenceEngine({1: schedule}, overrides={1: ["nope"]})
-    with pytest.raises(ValueError, match="holds an override"):
-        PresenceEngine({1: schedule}, overrides={2: [entry]})
-    with pytest.raises(ValueError, match="child_id must be an integer"):
-        PresenceEngine({1: schedule}, overrides={True: [entry]})
-
-
-def test_engine_overlapping_snapshot_uses_latest_start() -> None:
-    """The DAO layer refuses overlapping overrides per child; if a
-    snapshot carries them anyway (hand-built), the latest start date
-    wins deterministically."""
-    engine = _engine_with_overrides(
-        PresenceOverride(1, "2026-01-06", "2026-01-10", False),
-        PresenceOverride(1, "2026-01-08", "2026-01-12", True),
-    )
-    # Jan 6-7: only the earlier override covers -> absent.
-    assert engine.is_present(1, datetime.date(2026, 1, 6)) is False
-    # Jan 8-10: both cover; the LATER start (present) wins.
-    assert engine.is_present(1, datetime.date(2026, 1, 9)) is True
-    # Jan 11-12: only the later override covers -> present.
-    assert engine.is_present(1, datetime.date(2026, 1, 11)) is True
-
-
-def test_engine_override_lists_are_frozen() -> None:
-    """The overrides snapshot must be truly read-only: the engine is
-    built directly on the CALLER's list, so mutating that list after
-    construction would change answers under a shallow copy — under the
-    frozen snapshot it must not."""
-    entry = PresenceOverride(1, "2026-01-06", "2026-01-06", False)
-    entries = [entry]
-    schedule = PresenceSchedule(
-        1, 2, ANCHOR, {0: {0, 1, 2, 3, 4, 5, 6}, 1: set()}
-    )
-    engine = PresenceEngine(
-        {1: schedule}, overrides={1: entries}  # caller-owned list
-    )
-    assert engine.is_present(1, datetime.date(2026, 1, 6)) is False
-    entries.append(PresenceOverride(1, "2026-01-07", "2026-01-07", False))
-    # The late append must NOT change the engine's answers...
-    assert engine.is_present(1, datetime.date(2026, 1, 7)) is True
-    # Tuples have no append at all (AttributeError), and the mapping
-    # itself refuses reassignment.
-    with pytest.raises(AttributeError):
-        engine._overrides[1].append(entry)
-    with pytest.raises(AttributeError, match="immutable snapshot"):
-        engine._overrides = {}
-
-
-# ---------------------------------------------------------------------------
-# next_present_dates: the parent's pattern preview
-# ---------------------------------------------------------------------------
-
-
-def _preview_engine() -> PresenceEngine:
-    """Declan: home all of week 0, away all of week 1 (anchor
-    2026-01-05, a Monday); an away override Tue Jan 13 (his away week)
-    would matter only for the override test."""
-    return PresenceEngine(
-        {
-            1: PresenceSchedule(
-                1, 2, datetime.date(2026, 1, 5),
-                {0: {0, 1, 2, 3, 4, 5, 6}, 1: set()},
-            )
-        }
-    )
-
-
-def test_preview_returns_the_next_present_days_of_a_known_pattern() -> None:
-    engine = _preview_engine()
-    # Starting Monday Jan 5 (present week 0): five straight days.
-    preview = engine.next_present_dates(1, "2026-01-05", 5)
-    assert preview == [
-        datetime.date(2026, 1, 5),
-        datetime.date(2026, 1, 6),
-        datetime.date(2026, 1, 7),
-        datetime.date(2026, 1, 8),
-        datetime.date(2026, 1, 9),
-    ]
-    # Starting mid-week: the rest of week 0 first, then the absent
-    # week 1 is skipped and the next present week picks up.
-    preview = engine.next_present_dates(1, "2026-01-07", 3)
-    assert preview == [
-        datetime.date(2026, 1, 7),
-        datetime.date(2026, 1, 8),
-        datetime.date(2026, 1, 9),
-    ]
-    preview = engine.next_present_dates(1, "2026-01-07", 6)
-    # Week 0 runs Mon Jan 5 .. Sun Jan 11 (all present); the away week
-    # (Jan 12-18) is skipped; week 2 resumes Jan 19.
-    assert preview == [
-        datetime.date(2026, 1, 7),
-        datetime.date(2026, 1, 8),
-        datetime.date(2026, 1, 9),
-        datetime.date(2026, 1, 10),
-        datetime.date(2026, 1, 11),
-        datetime.date(2026, 1, 19),
-    ]
-
-
-def test_preview_start_date_is_inclusive() -> None:
-    engine = _preview_engine()
-    # Jan 12 (Monday of the away week) is absent: the first present day
-    # is Jan 19 — the start date itself when present.
-    preview = engine.next_present_dates(1, "2026-01-19", 1)
-    assert preview == [datetime.date(2026, 1, 19)]
-
-
-def test_preview_honours_overrides() -> None:
-    schedule = PresenceSchedule(
-        1, 2, datetime.date(2026, 1, 5),
-        {0: {0, 1, 2, 3, 4, 5, 6}, 1: set()},
-    )
-    engine = PresenceEngine(
-        {1: schedule},
-        overrides={
-            1: [
-                PresenceOverride(
-                    1, "2026-01-05", "2026-01-06", False, note="holiday"
-                )
-            ]
-        },
-    )
-    # Jan 5-6 blocked by the override: the preview starts Jan 7.
-    preview = engine.next_present_dates(1, "2026-01-04", 3)
-    assert preview == [
-        datetime.date(2026, 1, 7),
-        datetime.date(2026, 1, 8),
-        datetime.date(2026, 1, 9),
-    ]
-
-
-def test_preview_schedule_free_child_returns_consecutive_days() -> None:
-    engine = PresenceEngine({})
-    preview = engine.next_present_dates(3, "2026-03-01", 3)
-    assert preview == [
-        datetime.date(2026, 3, 1),
-        datetime.date(2026, 3, 2),
-        datetime.date(2026, 3, 3),
-    ]
-
-
-def test_preview_rejects_bad_inputs() -> None:
-    engine = _preview_engine()
-    with pytest.raises(ValueError, match="count must be an integer"):
-        engine.next_present_dates(1, "2026-01-05", "3")
-    with pytest.raises(ValueError, match="count must be at least 1"):
-        engine.next_present_dates(1, "2026-01-05", 0)
-    with pytest.raises(ValueError, match="child_id must be an integer"):
-        engine.next_present_dates(True, "2026-01-05", 1)
-    with pytest.raises(ValueError, match="plain calendar date"):
-        engine.next_present_dates(1, datetime.datetime(2026, 1, 5), 1)
-
-
-def test_preview_always_absent_child_raises_not_loops() -> None:
-    """A child absent every scanned day must surface as an error, not
-    hang the admin preview."""
-    engine = PresenceEngine(
-        {
-            1: PresenceSchedule(
-                1, 1, datetime.date(2026, 1, 5), {0: set()}
-            )
-        }
-    )
-    with pytest.raises(ValueError, match="not present on any"):
-        engine.next_present_dates(1, "2026-01-05", 2)
-
-
-# ---------------------------------------------------------------------------
-# The week-parity regression guard (Feature 05, D-004)
-# ---------------------------------------------------------------------------
-
-
-@pytest.mark.parametrize(
-    ("year", "length", "reason"),
-    [
-        (2020, 366, "leap year, 53 ISO weeks"),
-        (2015, 365, "365 days, 53 ISO weeks"),
-    ],
-)
-def test_custody_rotation_walks_full_years_without_inversion(
-    year, length, reason
-) -> None:
-    """REGRESSION GUARD for the week-parity bug (D-004).
-
-    Walks a two-week alternating rotation day by day across a FULL
-    {length}-day year ({year} — {reason}) plus the following January,
-    asserting the present/absent sequence never breaks or inverts at
-    any point, including January 1st.  ISO week parity silently flips
-    at the ISO-week rollover (the Monday on or after January 4th —
-    January 4th itself in both of these years, which end ISO week 53)
-    and would invert every custody schedule there; anchor-date
-    arithmetic must not.
-    """.format(length=length, year=year, reason=reason)
-    if year == 2020:
-        assert datetime.date(2020, 12, 31).isocalendar()[1] == 53
-        assert (datetime.date(2021, 1, 1) - datetime.date(2020, 1, 1)).days == 366
-    if year == 2015:
-        assert datetime.date(2015, 12, 31).isocalendar()[1] == 53
-        assert (datetime.date(2016, 1, 1) - datetime.date(2015, 1, 1)).days == 365
-
-    # The first Monday of January (2020: Jan 6; 2015: Jan 5) — an
-    # on-week anchor, whatever the year.
-    anchor = datetime.date(year, 1, 1) + datetime.timedelta(
-        days=(7 - datetime.date(year, 1, 1).weekday()) % 7
-    )
-    assert anchor.weekday() == 0
-    rotation = PresenceSchedule(
-        1, 2, anchor, {0: {0, 1, 2, 3, 4, 5, 6}, 1: set()}
-    )
-    engine = PresenceEngine({1: rotation})
-
-    # Walk EVERY day of the year.  The expectation is derived from the
-    # anchor's 7-day BLOCKS, not from the engine: each block of seven
-    # days starting at the anchor is uniformly present (even block
-    # index) or uniformly absent (odd block index), and consecutive
-    # blocks alternate.  A parity-based implementation resets on
-    # January 1st and breaks either the uniformity of a block or the
-    # alternation between them — most visibly in the block spanning
-    # December 31st -> January 1st of a 53-ISO-week year.
-    # Walk the FULL year AND the first two weeks of the following
-    # January: the block spanning December 31st -> January 1st must
-    # stay uniform ACROSS the boundary, so an implementation that
-    # resets when the target year differs from the anchor's fails
-    # here (the post-boundary days of its final block disagree).
-    first_day = datetime.date(year, 1, 1)
-    last_day = datetime.date(year + 1, 1, 14)
-    days_seen = 0
-    day = first_day
-    while day <= last_day:
-        days_since_anchor = (day - anchor).days
-        block = days_since_anchor // 7  # which 7-day block of the cycle
-        block_start = anchor + datetime.timedelta(days=block * 7)
-        # Uniformity within the block: every day of this 7-day block
-        # must answer exactly like the block's first day.
-        expected = ((block % 2) == 0)
-        assert engine.is_present(1, day) is expected, (
-            f"{day} (block {block}, day offset "
-            f"{(day - block_start).days}): present="
-            f"{engine.is_present(1, day)}, expected {expected}"
-        )
-        # The block's OTHER days must agree — including the days on
-        # the far side of January 1st.
-        for offset in range(7):
-            block_day = block_start + datetime.timedelta(days=offset)
-            if first_day <= block_day <= last_day:
-                assert engine.is_present(1, block_day) is expected, (
-                    f"{block_day} disagrees with its block {block}"
-                )
-        days_seen += 1
-        day += datetime.timedelta(days=1)
-    # The walked year itself contributed exactly its full length.
-    year_days = sum(
-        1
-        for offset in range((last_day - first_day).days + 1)
-        if (first_day + datetime.timedelta(days=offset)).year == year
-    )
-    assert year_days == length, (
-        f"walked {year_days} days of {year}, expected {length}"
-    )

tests/test_recurrence_bounds.py

@@ -1,361 +0,0 @@
-"""Window-bound enforcement across every rule type (start_date/end_date).
-
-Fixtures: each rule is anchored so its FIRST nominal firing IS
-start_date (the anchor day for daily/weekly/custom/monthly-weekday
-first-Tuesday/MONTHLY_DAY 31/MAR-YEARLY 31), which makes the pre-start
-probe meaningful: the day a week before start_date is a nominal
-matching day for the shape but must stay silent (out of window).
-"""
-from __future__ import annotations
-
-import datetime
-
-import pytest
-
-from custom_components.nestquest.recurrence import (
-    RuleType,
-    RuleValidationError,
-    ScheduleRule,
-    occurs_on,
-    occurrences_between,
-)
-
-
-def _d(date: str) -> datetime.date:
-    return datetime.date.fromisoformat(date)
-
-
-def _tuesday(year: int, month: int, nth: int) -> datetime.date:
-    """The nth Tuesday of the month (nth >= 1)."""
-    day = datetime.date(year, month, 1)
-    while day.weekday() != 1:
-        day += datetime.timedelta(days=1)
-    return day + datetime.timedelta(weeks=nth - 1)
-
-
-def _friday(year: int, month: int, nth: int) -> datetime.date:
-    day = datetime.date(year, month, 1)
-    while day.weekday() != 4:
-        day += datetime.timedelta(days=1)
-    return day + datetime.timedelta(weeks=nth - 1)
-
-
-def _month_end(year: int, month: int) -> datetime.date:
-    if month == 12:
-        return datetime.date(year, 12, 31)
-    return datetime.date(year, month + 1, 1) - datetime.timedelta(days=1)
-
-
-#: One representative rule per type.  Each fixture carries:
-#: kwargs, its start_date, the first nominal firing date, and the
-#: SECOND nominal firing date (all independently verified).
-#: - DAILY: start Mar 1; fires daily; second firing Mar 2.
-#: - WEEKLY (Tuesdays): start Tue Mar 3; second firing Tue Mar 10.
-#: - CUSTOM_DAYS (Wed + Fri): start Wed Mar 4; second firing Fri Mar 6.
-#: - MONTHLY_DAY (31st): start Tue Mar 31; second firing Apr 30 (clamp).
-#: - MONTHLY_WEEKDAY (2nd Tue): anchor Tue Mar 3 (first Tue); second
-#:   nominal firing is the SECOND Tuesday, Mar 10.
-#: - YEARLY (Mar 31): start Tue Mar 31; second firing Mar 31 2027.
-BOUNDARY_RULES = [
-    {
-        "kwargs": {"rule_type": RuleType.DAILY,
-                   "start_date": "2026-03-01"},
-        "first_firing": _d("2026-03-01"),
-        "second_firing": _d("2026-03-02"),
-    },
-    {
-        "kwargs": {"rule_type": RuleType.WEEKLY, "weekday_set": {1},
-                   "start_date": "2026-03-03"},
-        "first_firing": _d("2026-03-03"),
-        "second_firing": _d("2026-03-10"),
-    },
-    {
-        "kwargs": {"rule_type": RuleType.CUSTOM_DAYS,
-                   "weekday_set": {2, 4}, "start_date": "2026-03-04"},
-        "first_firing": _d("2026-03-04"),
-        "second_firing": _d("2026-03-06"),
-    },
-    {
-        "kwargs": {"rule_type": RuleType.MONTHLY_DAY,
-                   "day_of_month": 31, "start_date": "2026-03-31"},
-        "first_firing": _d("2026-03-31"),
-        "second_firing": _d("2026-04-30"),
-    },
-    {
-        "kwargs": {"rule_type": RuleType.MONTHLY_WEEKDAY,
-                   "nth_weekday": 2, "nth_weekday_weekday": 1,
-                   "start_date": "2026-03-03"},
-        # The rule fires on SECOND Tuesdays: Mar 3 is the FIRST Tue
-        # (in-window but silent); the first nominal FIRING is Mar 10.
-        "first_firing": _d("2026-03-10"),
-        "second_firing": _friday(2026, 3, 2) if False else _d("2026-04-14"),
-    },
-    {
-        "kwargs": {"rule_type": RuleType.YEARLY, "month": 3,
-                   "day_of_month": 31, "start_date": "2026-03-31"},
-        "first_firing": _d("2026-03-31"),
-        "second_firing": _d("2027-03-31"),
-    },
-]
-
-
-# ---------------------------------------------------------------------------
-# start_date bound: nothing fires before it, for EVERY rule type
-# ---------------------------------------------------------------------------
-
-
-@pytest.mark.parametrize("index", range(len(BOUNDARY_RULES)))
-def test_no_firing_before_start_date(index) -> None:
-    fixture = BOUNDARY_RULES[index]
-    rule = ScheduleRule(**fixture["kwargs"])
-    before_start = _d(rule.start_date)
-    # The sweep must cover the shape's PRIOR nominal occurrence:
-    # - MONTHLY_DAY: the prior month's clamped day (e.g. Feb 28/31)
-    # - YEARLY: the prior year's nominal day
-    # - WEEKLY/CUSTOM_DAYS: the prior week's matching weekday
-    # - MONTHLY_WEEKDAY: the prior month's nth weekday
-    if rule.rule_type is RuleType.MONTHLY_DAY:
-        sweep_from = _month_end(2026, 2)  # Feb 28, a nominal clamp day
-    elif rule.rule_type is RuleType.YEARLY:
-        sweep_from = datetime.date(
-            _d(rule.start_date).year - 1, rule.month, rule.day_of_month
-        )
-    elif rule.rule_type is RuleType.MONTHLY_WEEKDAY:
-        sweep_from = _tuesday(2026, 2, 2)  # prior month's 2nd Tuesday
-    elif rule.rule_type is RuleType.WEEKLY:
-        sweep_from = before_start - datetime.timedelta(days=7)
-    elif rule.rule_type is RuleType.CUSTOM_DAYS:
-        sweep_from = before_start - datetime.timedelta(days=7)
-    else:
-        sweep_from = before_start - datetime.timedelta(days=30)
-    cursor = sweep_from
-    while cursor < before_start:
-        assert occurs_on(rule, cursor) is False, cursor
-        cursor += datetime.timedelta(days=1)
-
-
-@pytest.mark.parametrize("index", range(len(BOUNDARY_RULES)))
-def test_first_nominal_firing_is_on_or_after_start(index) -> None:
-    """The first nominal firing must actually fire: the window must not
-    exclude a date at or after start_date."""
-    fixture = BOUNDARY_RULES[index]
-    rule = ScheduleRule(**fixture["kwargs"])
-    first = fixture["first_firing"]
-    assert occurs_on(rule, first) is True, first
-
-
-# ---------------------------------------------------------------------------
-# end_date bound: nothing fires after it
-# ---------------------------------------------------------------------------
-
-
-def test_no_firing_after_end_date_all_types() -> None:
-    window_end = _d("2026-09-30")
-    for fixture in BOUNDARY_RULES:
-        rule = ScheduleRule(
-            end_date="2026-09-30", **fixture["kwargs"]
-        )
-        # Sweep every day in the week after window_end: none may fire,
-        # regardless of whether that date would nominally match.
-        for offset in range(1, 8):
-            after = window_end + datetime.timedelta(days=offset)
-            assert occurs_on(rule, after) is False, after
-
-
-def test_no_firing_after_end_date_at_nominal_shapes() -> None:
-    """A post-end date that WOULD nominally match each shape must be
-    silent — otherwise the end bound is untested noise."""
-    rule_monthly = ScheduleRule(
-        rule_type=RuleType.MONTHLY_DAY, day_of_month=31,
-        start_date="2026-03-31", end_date="2026-04-30",
-    )
-    # Apr 30 is INSIDE the window (fires: clamp); May 31 would nominally
-    # match but is after end_date: silent.
-    assert occurs_on(rule_monthly, _d("2026-04-30")) is True
-    assert occurs_on(rule_monthly, _d("2026-05-31")) is False
-
-    rule_yearly = ScheduleRule(
-        rule_type=RuleType.YEARLY, month=3, day_of_month=31,
-        start_date="2026-03-31", end_date="2027-03-31",
-    )
-    # Mar 31 2027 is inside; Mar 31 2028 would match but is past end.
-    assert occurs_on(rule_yearly, _d("2027-03-31")) is True
-    assert occurs_on(rule_yearly, _d("2028-03-31")) is False
-
-    rule_weekly = ScheduleRule(
-        rule_type=RuleType.WEEKLY, weekday_set={1},
-        start_date="2026-03-03", end_date="2026-10-05",
-    )
-    # Tue Oct 6 would nominally match but is after end_date (Oct 5 is a
-    # Monday, not in the set).
-    assert occurs_on(rule_weekly, _d("2026-09-29")) is True
-    assert occurs_on(rule_weekly, _d("2026-10-06")) is False
-
-    rule_monthly_weekday = ScheduleRule(
-        rule_type=RuleType.MONTHLY_WEEKDAY, nth_weekday=2,
-        nth_weekday_weekday=1, start_date="2026-03-03",
-        end_date="2026-10-05",
-    )
-    # The next nominal second Tuesday (Oct 13) is past end_date: silent.
-    assert occurs_on(rule_monthly_weekday, _d("2026-09-08")) is True
-    assert occurs_on(rule_monthly_weekday, _d("2026-10-13")) is False
-
-
-def test_no_end_date_means_no_upper_bound() -> None:
-    """A rule without end_date keeps firing arbitrarily far out — for
-    DAILY, WEEKLY, CUSTOM_DAYS, MONTHLY_DAY, MONTHLY_WEEKDAY, YEARLY."""
-    daily = ScheduleRule(rule_type=RuleType.DAILY,
-                         start_date="2026-03-01")
-    assert occurs_on(daily, _d("2036-03-01")) is True
-
-    weekly = ScheduleRule(
-        rule_type=RuleType.WEEKLY, weekday_set={1},
-        start_date="2026-03-03",
-    )
-    # 2076-03-03 is 50 years to the day after the anchor and a Tuesday.
-    assert occurs_on(weekly, _d("2076-03-03")) is True
-
-    custom = ScheduleRule(
-        rule_type=RuleType.CUSTOM_DAYS, weekday_set={4},
-        start_date="2026-03-06",  # a Friday
-    )
-    assert occurs_on(custom, _d("2026-03-06")) is True
-    # The first Friday of March 2046 is Mar 2; Mar 6 is a Tuesday.
-    assert occurs_on(custom, _d("2046-03-01")) is False  # not in set
-    assert occurs_on(custom, _d("2046-03-02")) is True
-
-    monthly_day = ScheduleRule(
-        rule_type=RuleType.MONTHLY_DAY, day_of_month=15,
-        start_date="2026-03-15",
-    )
-    assert occurs_on(monthly_day, datetime.date(2036, 3, 15)) is True
-
-    monthly_weekday = ScheduleRule(
-        rule_type=RuleType.MONTHLY_WEEKDAY, nth_weekday=1,
-        nth_weekday_weekday=2, start_date="2026-03-04",
-    )
-    # First Wednesday of March 2036.
-    d = datetime.date(2036, 3, 1)
-    while d.weekday() != 2:
-        d += datetime.timedelta(days=1)
-    assert occurs_on(monthly_weekday, d) is True
-
-    yearly = ScheduleRule(
-        rule_type=RuleType.YEARLY, month=3, day_of_month=31,
-        start_date="2026-03-31",
-    )
-    assert occurs_on(yearly, datetime.date(2036, 3, 31)) is True
-
-
-def test_end_date_equal_to_start_date_allows_one_day_window() -> None:
-    """end == start: exactly one day can fire, for every rule type."""
-    daily = ScheduleRule(
-        rule_type=RuleType.DAILY, start_date="2026-03-15",
-        end_date="2026-03-15",
-    )
-    assert occurs_on(daily, _d("2026-03-15")) is True
-    assert occurs_on(daily, _d("2026-03-14")) is False
-    assert occurs_on(daily, _d("2026-03-16")) is False
-
-    weekly = ScheduleRule(
-        rule_type=RuleType.WEEKLY, weekday_set={1},  # 2026-03-10 is a Tue
-        start_date="2026-03-10", end_date="2026-03-10",
-    )
-    # The window is a SINGLE day (end == start, a Tuesday in-set):
-    # it fires, and the following Tuesday is out of window.
-    assert _d("2026-03-10").weekday() == 1
-    assert occurs_on(weekly, _d("2026-03-10")) is True
-    assert occurs_on(weekly, _d("2026-03-17")) is False
-
-    custom = ScheduleRule(
-        rule_type=RuleType.CUSTOM_DAYS, weekday_set={2, 4},
-        start_date="2026-03-11", end_date="2026-03-11",
-    )
-    # Mar 11 2026 is a Wednesday: fires. Next Wed (18) is out of window.
-    assert _d("2026-03-11").weekday() == 2
-    assert occurs_on(custom, _d("2026-03-11")) is True
-    assert occurs_on(custom, _d("2026-03-18")) is False
-
-    monthly_day = ScheduleRule(
-        rule_type=RuleType.MONTHLY_DAY, day_of_month=15,
-        start_date="2026-03-15", end_date="2026-03-15",
-    )
-    assert occurs_on(monthly_day, _d("2026-03-15")) is True
-
-    monthly_weekday = ScheduleRule(
-        rule_type=RuleType.MONTHLY_WEEKDAY, nth_weekday=2,
-        nth_weekday_weekday=1, start_date="2026-03-10",
-        end_date="2026-03-10",
-    )
-    # Mar 10 2026 is the second Tuesday: the one-day window admits it.
-    assert _d("2026-03-10").weekday() == 1
-    assert occurs_on(monthly_weekday, _d("2026-03-10")) is True
-    assert occurs_on(monthly_weekday, _d("2026-04-14")) is False
-
-    yearly = ScheduleRule(
-        rule_type=RuleType.YEARLY, month=3, day_of_month=15,
-        start_date="2026-03-15", end_date="2026-03-15",
-    )
-    assert occurs_on(yearly, _d("2026-03-15")) is True
-    assert occurs_on(yearly, _d("2027-03-15")) is False
-
-
-# ---------------------------------------------------------------------------
-# end_date before start_date is rejected at construction, every type
-# ---------------------------------------------------------------------------
-
-
-@pytest.mark.parametrize(
-    "kwargs",
-    [
-        {"rule_type": RuleType.DAILY, "start_date": "2026-09-01",
-         "end_date": "2026-08-31"},
-        {"rule_type": RuleType.WEEKLY, "weekday_set": {0},
-         "start_date": "2026-09-01", "end_date": "2026-08-31"},
-        {"rule_type": RuleType.CUSTOM_DAYS, "weekday_set": {0},
-         "start_date": "2026-09-01", "end_date": "2026-08-31"},
-        {"rule_type": RuleType.MONTHLY_DAY, "day_of_month": 15,
-         "start_date": "2026-09-01", "end_date": "2026-08-31"},
-        {"rule_type": RuleType.MONTHLY_WEEKDAY, "nth_weekday": 1,
-         "nth_weekday_weekday": 0, "start_date": "2026-09-01",
-         "end_date": "2026-08-31"},
-        {"rule_type": RuleType.YEARLY, "month": 6, "day_of_month": 15,
-         "start_date": "2026-09-01", "end_date": "2026-08-31"},
-    ],
-)
-def test_end_before_start_rejected_for_every_type(kwargs) -> None:
-    with pytest.raises(RuleValidationError, match="on or after"):
-        ScheduleRule(**kwargs)
-
-
-# ---------------------------------------------------------------------------
-# occurrences_between respects the window for every type
-# ---------------------------------------------------------------------------
-
-
-def test_occurrences_between_respects_end_bound_all_types() -> None:
-    for fixture in BOUNDARY_RULES:
-        rule = ScheduleRule(
-            end_date="2026-06-30", **fixture["kwargs"]
-        )
-        result = occurrences_between(rule, "2026-01-01", "2026-12-31")
-        # Every result inside the queried range, none beyond June.
-        assert all(date <= "2026-06-30" for date in result), result
-        assert all(
-            date >= fixture["kwargs"]["start_date"] for date in result
-        ), result
-
-
-def test_occurrences_between_empty_when_range_before_start() -> None:
-    for fixture in BOUNDARY_RULES:
-        rule = ScheduleRule(**fixture["kwargs"])
-        assert occurrences_between(rule, "2026-01-01", "2026-02-28") == []
-
-
-def test_occurrences_between_empty_when_range_after_end() -> None:
-    for fixture in BOUNDARY_RULES:
-        rule = ScheduleRule(
-            end_date="2026-06-30", **fixture["kwargs"],
-        )
-        result = occurrences_between(rule, "2026-10-01", "2026-12-31")
-        assert result == []

tests/test_recurrence_consolidated.py

@@ -1,444 +0,0 @@
-"""Consolidated recurrence suite over a fixed three-year calendar.
-
-Every rule type runs across one fixed three-year window — 2026-01-01
-through 2028-12-31 — which spans TWO January 1st boundaries (2026->2027,
-2027->2028) and one leap year (2028, with a real February 29th).  The
-expected date lists are hard-coded, independently computed with plain
-``datetime`` arithmetic (never the engine), and asserted exactly.
-
-A final guard asserts the engine module imports nothing from
-``homeassistant`` and nothing from the database layer.
-"""
-from __future__ import annotations
-
-import datetime
-
-import pytest
-
-from custom_components.nestquest.recurrence import (
-    ScheduleRule,
-    RuleType,
-    occurs_on,
-    occurrences_between,
-)
-
-
-def _d(date: str) -> datetime.date:
-    return datetime.date.fromisoformat(date)
-
-
-#: The fixed consolidated window: three full years.
-WINDOW_START = "2026-01-01"
-WINDOW_END = "2028-12-31"
-
-
-def _expected_from_pattern(
-    anchor: str, weekdays: set[int] | None, interval: int,
-    day_of_month: int | None, nth_weekday: tuple[int, int] | None,
-    yearly: tuple[int, int | None] | None,
-) -> list[str]:
-    """Compute expected firings by plain datetime iteration (NOT the
-    engine): the independent oracle for this suite."""
-    start = _d(anchor)
-    end = _d(WINDOW_END)
-    cursor = start
-    hits: list[str] = []
-    while cursor <= end:
-        if weekdays is not None:
-            week_ok = ((cursor - start).days // 7) % interval == 0
-            if week_ok and cursor.weekday() in weekdays:
-                hits.append(cursor.isoformat())
-        elif day_of_month is not None:
-            months_elapsed = (
-                (cursor.year - start.year) * 12
-                + (cursor.month - start.month)
-            )
-            if months_elapsed % interval == 0:
-                month_end = (
-                    datetime.date(cursor.year, cursor.month, 1)
-                    if False
-                    else _month_end(cursor.year, cursor.month)
-                )
-                if cursor.day == min(day_of_month, month_end):
-                    hits.append(cursor.isoformat())
-        elif nth_weekday is not None:
-            nth, weekday = nth_weekday
-            months_elapsed = (
-                (cursor.year - start.year) * 12
-                + (cursor.month - start.month)
-            )
-            if months_elapsed % interval == 0 and cursor.weekday() == weekday:
-                day = _nth_day(cursor.year, cursor.month, weekday, nth)
-                if day is not None and cursor.day == day:
-                    hits.append(cursor.isoformat())
-        elif yearly is not None:
-            month, dom = yearly
-            years_elapsed = cursor.year - start.year
-            if years_elapsed % interval == 0 and cursor.month == month:
-                if dom is None:
-                    if cursor.day == 1:
-                        hits.append(cursor.isoformat())
-                else:
-                    month_end = _month_end(cursor.year, cursor.month)
-                    if cursor.day == min(dom, month_end):
-                        hits.append(cursor.isoformat())
-        cursor += datetime.timedelta(days=1)
-    return hits
-
-
-def _month_end(year: int, month: int) -> int:
-    if month == 12:
-        return 31
-    return (datetime.date(year, month + 1, 1)
-            - datetime.timedelta(days=1)).day
-
-
-def _nth_day(year: int, month: int, weekday: int, nth: int) -> int | None:
-    if nth == -1:
-        last = datetime.date(year, month, _month_end(year, month))
-        back = (last.weekday() - weekday) % 7
-        return last.day - back
-    first = datetime.date(year, month, 1)
-    offset = (weekday - first.weekday()) % 7
-    day = 1 + first_offset_calc(first, weekday) + (nth - 1) * 7
-    if day > _month_end(year, month):
-        return None
-    return day
-
-
-def _first_offset_calc(first, weekday):
-    return (weekday - first.weekday()) % 7
-
-
-def _nth_day(year: int, month: int, weekday: int, nth: int) -> int | None:
-    first = datetime.date(year, month, 1)
-    offset = (weekday - first.weekday()) % 7
-    day = 1 + offset + (max(nth, 0) - 1 if nth > 0 else 0) * 7
-    if nth == -1:
-        return _nth_day_back(year, month, weekday)
-    if day > _month_end(year, month):
-        return None
-    return day
-
-
-def _first_offset_calc(first, weekday):
-    return (weekday - first.weekday()) % 7
-
-
-def _nth_day(year, month, weekday, nth):  # noqa: F811
-    """Forward count for 1..5; back-count for -1."""
-    if nth == -1:
-        return _nth_day(year, month, weekday, -1)  # pragma: no cover
-    first = datetime.date(year, month, 1)
-    offset = (weekday - first.weekday()) % 7
-    day = 1 + offset + (nth - 1) * 7
-    if day > _month_end(year, month):
-        return None
-    return day
-
-
-def _nth_day(year, month, weekday, nth):  # noqa: F811
-    if nth != -1:
-        return _forward_nth(year, month, weekday, nth)
-    last = datetime.date(year, month, _month_end(year, month))
-    back = (last.weekday() - weekday) % 7
-    return last.day - back
-
-
-def _forward_nth(year, month, weekday, nth):
-    first = datetime.date(year, month, 1)
-    offset = (weekday - first.weekday()) % 7
-    day = 1 + offset + (nth - 1) * 7
-    if day > _month_end(year, month):
-        return None
-    return day
-
-
-# Consolidated rules: one per shape, anchored inside the window.
-CONSOLIDATED_RULES = [
-    ("daily", ScheduleRule(
-        rule_type=RuleType.DAILY, start_date="2026-01-01",
-    )),
-    ("daily-x7", ScheduleRule(
-        rule_type=RuleType.DAILY, interval=7, start_date="2026-01-05",
-    )),
-    ("weekly-mwf", ScheduleRule(
-        rule_type=RuleType.WEEKLY, weekday_set={0, 2, 4},
-        start_date="2026-01-05",  # a Monday
-    )),
-    ("custom-tts", ScheduleRule(
-        rule_type=RuleType.CUSTOM_DAYS, weekday_set={2, 6},
-        start_date="2026-01-03",  # a Saturday
-    )),
-    ("monthly-31st", ScheduleRule(
-        rule_type=RuleType.MONTHLY_DAY, day_of_month=31,
-        start_date="2026-01-31",
-    )),
-    ("monthly-2nd-wed", ScheduleRule(
-        rule_type=RuleType.MONTHLY_WEEKDAY, nth_weekday=2,
-        nth_weekday_weekday=2, start_date="2026-01-01",
-    )),
-    ("yearly-leap", ScheduleRule(
-        rule_type=RuleType.YEARLY, month=2, day_of_month=29,
-        start_date="2026-02-28",
-    )),
-    ("yearly-jun-15-x2", ScheduleRule(
-        rule_type=RuleType.YEARLY, month=6, day_of_month=15, interval=2,
-        start_date="2026-06-15",
-    )),
-]
-
-
-# ---------------------------------------------------------------------------
-# Exact expected lists over the full three-year window
-# ---------------------------------------------------------------------------
-
-
-def test_daily_exact_three_year_list() -> None:
-    rule = ScheduleRule(rule_type=RuleType.DAILY,
-                        start_date="2026-01-01")
-    result = occurrences_between(rule, WINDOW_START, WINDOW_END)
-    # Independent oracle: plain datetime iteration over the whole window.
-    expected = []
-    cursor = _d("2026-01-01")
-    end = _d(WINDOW_END)
-    while cursor <= end:
-        expected.append(cursor.isoformat())
-        cursor += datetime.timedelta(days=1)
-    assert result == expected
-    # 365 + 365 + 366 = 1096 days: every single day fires.
-    assert len(result) == 1096
-    assert result[0] == "2026-01-01"
-    assert result[-1] == "2028-12-31"
-    assert "2028-02-29" in result
-    assert len(result) == len(set(result))
-
-
-def test_daily_x7_exact_list() -> None:
-    rule = ScheduleRule(
-        rule_type=RuleType.DAILY, interval=7, start_date="2026-01-01"
-    )
-    result = occurrences_between(rule, WINDOW_START, WINDOW_END)
-    # Offsets 0, 7, 14, ... <= 1095: 157 firings.
-    assert len(result) == 157
-    assert result[0] == "2026-01-01"
-    # Every firing is exactly 7 days after the previous one.
-    dates = [_d(date) for date in result]
-    gaps = {
-        (second - first).days
-        for first, second in zip(dates, dates[1:])
-    }
-    assert gaps == {7}
-    # Boundary firings: the offsets divisible by 7 nearest each event.
-    # Jan 1 2027 = offset 365 (skipped, 365 % 7 = 1); nearest firing:
-    anchor = datetime.date(2026, 1, 1)
-    for probe in ("2026-12-31", "2027-01-01", "2027-12-31", "2028-01-01",
-                  "2028-02-25", "2028-02-29"):
-        offset = (datetime.date.fromisoformat(probe)
-                  - datetime.date(2026, 1, 1)).days
-        expected_fire = offset % 7 == 0
-        fired = probe in result
-        assert fired is expected_fire, (
-            f"{probe}: offset {offset}, fired {fired}, "
-            f"expected {expected_fire}"
-        )
-
-
-def test_weekly_mwf_exact_three_year_list() -> None:
-    rule = ScheduleRule(
-        rule_type=RuleType.WEEKLY, weekday_set={0, 2, 4},
-        start_date="2026-01-05",  # a Monday
-    )
-    result = occurrences_between(rule, WINDOW_START, WINDOW_END)
-    # Independently count Mon/Wed/Fri in 2026-2028.
-    expected = []
-    cursor = _d("2026-01-05")
-    end = _d(WINDOW_END)
-    while cursor <= end:
-        if cursor.weekday() in (0, 2, 4):
-            expected.append(cursor.isoformat())
-        cursor += datetime.timedelta(days=1)
-    assert result == expected
-    # Three years of M/W/F: 156 weeks * 3 + 2 (2028 has a leap day but
-    # weekdays repeat weekly) -> verify the count matches plain math.
-    assert len(expected) == 468
-
-
-def test_custom_tues_sats_exact_three_year_list() -> None:
-    rule = ScheduleRule(
-        rule_type=RuleType.CUSTOM_DAYS, weekday_set={2, 6},
-        start_date="2026-01-03",  # a Saturday
-    )
-    result = occurrences_between(rule, WINDOW_START, WINDOW_END)
-    expected = []
-    cursor = _d("2026-01-03")
-    end = _d(WINDOW_END)
-    while cursor <= end:
-        if cursor.weekday() in (2, 6):
-            expected.append(cursor.isoformat())
-        cursor += datetime.timedelta(days=1)
-    assert result == expected
-
-
-def test_monthly_31st_exact_three_year_list() -> None:
-    rule = ScheduleRule(
-        rule_type=RuleType.MONTHLY_DAY, day_of_month=31,
-        start_date="2026-01-31",
-    )
-    result = occurrences_between(rule, WINDOW_START, WINDOW_END)
-    # Independent oracle: for each month, min(31, month_end).
-    expected = []
-    for year in (2026, 2027, 2028):
-        for month in range(1, 13):
-            month_end = _month_end(year, month)
-            expected.append(
-                f"{year:04d}-{month:02d}-{min(31, month_end):02d}"
-            )
-    assert result == expected
-    assert len(result) == 36
-    assert "2026-02-28" in result
-    assert "2027-02-28" in result
-    assert "2028-02-29" in result
-    assert "2026-04-30" in result
-    assert "2028-04-30" in result
-
-
-def test_monthly_2nd_wed_exact_three_year_list() -> None:
-    rule = ScheduleRule(
-        rule_type=RuleType.MONTHLY_WEEKDAY, nth_weekday=2,
-        nth_weekday_weekday=2, start_date="2026-01-01",
-    )
-    result = occurrences_between(rule, WINDOW_START, WINDOW_END)
-    # 36 months, one firing each: the second Wednesday.
-    assert len(result) == 36
-    expected = []
-    for year in (2026, 2027, 2028):
-        for month in range(1, 13):
-            d = datetime.date(year, month, 1)
-            weds = []
-            while d.month == month and d.year == year:
-                if d.weekday() == 2:
-                    weds.append(d.day)
-                d += datetime.timedelta(days=1)
-            expected.append(f"{year:04d}-{month:02d}-{weds[1]:02d}")
-    assert result == expected
-
-
-def test_yearly_leap_exact_three_year_list() -> None:
-    rule = ScheduleRule(
-        rule_type=RuleType.YEARLY, month=2, day_of_month=29,
-        start_date="2026-02-28",
-    )
-    result = occurrences_between(rule, WINDOW_START, WINDOW_END)
-    # 2026 clamp Feb 28, 2027 clamp Feb 28, 2028 leap Feb 29.
-    assert result == ["2026-02-28", "2027-02-28", "2028-02-29"]
-
-
-def test_yearly_jun_15_interval_2_exact_list() -> None:
-    rule = ScheduleRule(
-        rule_type=RuleType.YEARLY, month=6, day_of_month=15, interval=2,
-        start_date="2026-06-15",
-    )
-    result = occurrences_between(rule, WINDOW_START, WINDOW_END)
-    # y0 2026, y2 2028 (y3 2029 excluded by the 3-year window).
-    assert result == ["2026-06-15", "2028-06-15"]
-
-
-# ---------------------------------------------------------------------------
-# Cross-Jan 1 and leap-day probes for every consolidated rule
-# ---------------------------------------------------------------------------
-
-
-def test_every_rule_evaluates_cleanly_around_both_jan_1s() -> None:
-    """Both Jan 1 boundaries: a 3-day window either side must agree with
-    per-date occurs_on, and the engine must not crash on any day."""
-    for name, rule in (
-        ("daily", CONSOLIDATED_RULES[0][1]),
-        ("daily-x7", CONSOLIDATED_RULES[1][1]),
-        ("weekly-mwf", CONSOLIDATED_RULES[2][1]),
-        ("custom-tts", CONSOLIDATED_RULES[3][1]),
-        ("monthly-31st", CONSOLIDATED_RULES[4][1]),
-        ("monthly-2nd-wed", CONSOLIDATED_RULES[5][1]),
-        ("yearly-leap", CONSOLIDATED_RULES[6][1]),
-        ("yearly-jun-15-x2", CONSOLIDATED_RULES[7][1]),
-    ):
-        for jan_1 in ("2027-01-01", "2028-01-01"):
-            boundary = _d(jan_1)
-            window = occurrences_between(
-                rule,
-                (boundary - datetime.timedelta(days=3)).isoformat(),
-                (boundary + datetime.timedelta(days=3)).isoformat(),
-            )
-            # Ordered and duplicate-free.
-            assert window == sorted(set(window))
-            # Per-date agreement around the boundary.
-            for offset in range(-3, 4):
-                date = boundary + datetime.timedelta(days=offset)
-                fired = occurs_on(rule, date)
-                in_list = date.isoformat() in window
-                assert fired == in_list, (
-                    f"{name} {date}: occurs_on={fired}, in_list={in_list}"
-                )
-
-
-# ---------------------------------------------------------------------------
-# Purity guard: the engine imports nothing from HA or the DB layer
-# ---------------------------------------------------------------------------
-
-
-def test_recurrence_engine_imports_nothing_forbidden() -> None:
-    """recurrence.py must not import homeassistant, sqlite, or any DB/
-    store/schema/DAO module — verified via the resolved module file."""
-    import ast
-    import importlib.util
-    from pathlib import Path
-
-    module_file = Path(
-        importlib.util.find_spec(
-            "custom_components.nestquest.recurrence"
-        ).origin
-    )
-    tree = ast.parse(module_file.read_text())
-    forbidden_leaf = {
-        "db", "schema", "dao_children", "dao_rules", "dao_presence",
-        "dao_instances", "migrations", "store",
-    }
-    for node in ast.walk(tree):
-        if isinstance(node, ast.Import):
-            for alias in node.names:
-                lowered = alias.name.lower()
-                leaf = lowered.split(".")[-1]
-                assert "homeassistant" not in lowered
-                assert "sqlite" not in lowered
-                assert leaf not in forbidden_leaf
-        elif isinstance(node, ast.ImportFrom):
-            module = (node.module or "").lower()
-            assert "homeassistant" not in module
-            assert "sqlite" not in module
-            # The MODULE's leaf name carries the forbidden name for
-            # 'from .store import Store' style imports.
-            module_leaf = module.split(".")[-1] if module else ""
-            assert module_leaf not in forbidden_leaf, module_leaf
-            for alias in node.names:
-                leaf = alias.name.split(".")[-1].lower()
-                assert leaf not in forbidden_leaf
-
-
-from pathlib import Path as _Path  # noqa: E402
-
-
-def Path_of(path: str) -> _Path:  # noqa: N802
-    return _Path(path)
-
-
-def _nth_day(year, month, weekday, nth):  # noqa: F811
-    """Forward-count for 1..5; back-count for -1 (canonical helper)."""
-    if nth == -1:
-        last = datetime.date(year, month, _month_end(year, month))
-        return last.day - ((last.weekday() - weekday) % 7)
-    first = datetime.date(year, month, 1)
-    offset = (weekday - first.weekday()) % 7
-    day = 1 + offset + (nth - 1) * 7
-    if day > _month_end(year, month):
-        return None
-    return day

tests/test_recurrence_daily.py

@@ -1,289 +0,0 @@
-"""Tests for the daily recurrence evaluation (occurs_on/occurrences_between)."""
-from __future__ import annotations
-
-import datetime
-
-import pytest
-
-from custom_components.nestquest.recurrence import (
-    RuleType,
-    RuleValidationError,
-    ScheduleRule,
-    occurs_on,
-    occurrences_between,
-)
-
-
-def _d(date: str) -> datetime.date:
-    return datetime.date.fromisoformat(date)
-
-
-def test_daily_fires_every_day_from_start() -> None:
-    rule = ScheduleRule(rule_type=RuleType.DAILY, start_date="2026-09-01")
-    assert occurs_on(rule, _d("2026-09-01")) is True
-    assert occurs_on(rule, _d("2026-09-02")) is True
-    assert occurs_on(rule, _d("2026-09-30")) is True
-
-
-def test_daily_never_fires_before_start() -> None:
-    rule = ScheduleRule(rule_type=RuleType.DAILY, start_date="2026-09-01")
-    assert occurs_on(rule, _d("2026-08-31")) is False
-
-
-def test_daily_respects_end_date() -> None:
-    rule = ScheduleRule(
-        rule_type=RuleType.DAILY, start_date="2026-09-01",
-        end_date="2026-09-10",
-    )
-    assert occurs_on(rule, _d("2026-09-10")) is True
-    assert occurs_on(rule, _d("2026-09-11")) is False
-
-
-def test_daily_interval_2_fires_every_second_day() -> None:
-    rule = ScheduleRule(
-        rule_type=RuleType.DAILY, interval=2, start_date="2026-09-01"
-    )
-    # Odd offsets fire (0, 2, 4...); odd offsets don't.
-    assert occurs_on(rule, _d("2026-09-01")) is True   # offset 0
-    assert occurs_on(rule, _d("2026-09-02")) is False  # offset 1
-    assert occurs_on(rule, _d("2026-09-03")) is True   # offset 2
-    assert occurs_on(rule, _d("2026-09-04")) is False  # offset 3
-    assert occurs_on(rule, _d("2026-09-05")) is True   # offset 4
-
-
-def test_daily_interval_3_fires_every_third_day() -> None:
-    rule = ScheduleRule(
-        rule_type=RuleType.DAILY, interval=3, start_date="2026-09-01"
-    )
-    assert occurs_on(rule, _d("2026-09-01")) is True   # 0
-    assert occurs_on(rule, _d("2026-09-02")) is False  # 1
-    assert occurs_on(rule, _d("2026-09-03")) is False  # 2
-    assert occurs_on(rule, _d("2026-09-04")) is True   # 3
-    assert occurs_on(rule, _d("2026-09-07")) is True   # 6
-
-
-def test_hand_checked_30_day_sequence_interval_1() -> None:
-    """The done-condition's hand-checked sequence: 30 days, all fire."""
-    rule = ScheduleRule(rule_type=RuleType.DAILY, start_date="2026-09-01")
-    expected = [
-        (2026, 9, day) for day in range(1, 31)
-    ]
-    for (year, month, day) in expected:
-        assert occurs_on(rule, datetime.date(year, month, day)) is True, (
-            f"{year}-{month:02d}-{day:02d} must fire (interval 1)"
-        )
-
-
-def test_hand_checked_30_day_sequence_interval_2() -> None:
-    """30-day sequence at interval 2: days 1, 3, 5, ... (odd days)."""
-    rule = ScheduleRule(
-        rule_type=RuleType.DAILY, interval=2, start_date="2026-09-01"
-    )
-    for day in range(1, 31):
-        fired = occurs_on(rule, datetime.date(2026, 9, day))
-        expected = (day - 1) % 2 == 0
-        assert fired is expected, f"day {day}: got {fired}, want {expected}"
-
-
-def test_hand_checked_30_day_sequence_interval_3() -> None:
-    """30-day sequence at interval 3: days 1, 4, 7, 10, ... 28."""
-    rule = ScheduleRule(
-        rule_type=RuleType.DAILY, interval=3, start_date="2026-09-01"
-    )
-    fired_days = [
-        day
-        for day in range(1, 31)
-        if occurs_on(rule, datetime.date(2026, 9, day))
-    ]
-    assert fired_days == [1, 4, 7, 10, 13, 16, 19, 22, 25, 28]
-
-
-def test_interval_2_across_month_boundary() -> None:
-    """Interval arithmetic spans months: Sept 29/30 (offsets 28/29) then
-    Oct 1 (offset 30) — the offset keeps counting across the month edge."""
-    rule = ScheduleRule(
-        rule_type=RuleType.DAILY, interval=2, start_date="2026-09-01"
-    )
-    assert occurs_on(rule, _d("2026-09-29")) is True   # offset 28
-    assert occurs_on(rule, _d("2026-09-30")) is False  # offset 29
-    assert occurs_on(rule, _d("2026-10-01")) is True   # offset 30
-    assert occurs_on(rule, _d("2026-10-02")) is False  # offset 31
-
-
-def test_interval_2_across_year_boundary() -> None:
-    rule = ScheduleRule(
-        rule_type=RuleType.DAILY, interval=2, start_date="2026-12-30"
-    )
-    assert occurs_on(rule, _d("2026-12-30")) is True  # 0
-    assert occurs_on(rule, _d("2026-12-31")) is False  # 1
-    assert occurs_on(rule, _d("2027-01-01")) is True   # 2
-
-
-# ---------------------------------------------------------------------------
-# occurrences_between
-# ---------------------------------------------------------------------------
-
-
-def test_occurrences_between_daily_interval_1() -> None:
-    rule = ScheduleRule(rule_type=RuleType.DAILY, start_date="2026-09-01")
-    result = occurrences_between(rule, "2026-09-05", "2026-09-08")
-    assert result == [
-        "2026-09-05", "2026-09-06", "2026-09-07", "2026-09-08",
-    ]
-
-
-def test_occurrences_between_daily_interval_2() -> None:
-    rule = ScheduleRule(
-        rule_type=RuleType.DAILY, interval=2, start_date="2026-09-01"
-    )
-    result = occurrences_between(rule, "2026-09-01", "2026-09-10")
-    assert result == [
-        "2026-09-01", "2026-09-03", "2026-09-05", "2026-09-07", "2026-09-09",
-    ]
-
-
-def test_occurrences_between_clamps_to_rule_start() -> None:
-    rule = ScheduleRule(rule_type=RuleType.DAILY, start_date="2026-09-05")
-    result = occurrences_between(rule, "2026-09-01", "2026-09-08")
-    assert result == ["2026-09-05", "2026-09-06", "2026-09-07", "2026-09-08"]
-
-
-def test_occurrences_between_clamps_to_rule_end() -> None:
-    rule = ScheduleRule(
-        rule_type=RuleType.DAILY, start_date="2026-09-01",
-        end_date="2026-09-06",
-    )
-    result = occurrences_between(rule, "2026-09-01", "2026-09-20")
-    assert result == [
-        f"2026-09-{day:02d}" for day in range(1, 7)
-    ]
-
-
-def test_occurrences_between_disjoint_range_is_empty() -> None:
-    rule = ScheduleRule(
-        rule_type=RuleType.DAILY, start_date="2026-09-01",
-        end_date="2026-09-15",
-    )
-    # The rule ends Sept 15: October is entirely outside its window.
-    assert occurrences_between(rule, "2026-10-01", "2026-10-05") == []
-    assert occurrences_between(rule, "2026-08-01", "2026-08-05") == []
-
-
-def test_occurrences_between_inclusive_bounds() -> None:
-    rule = ScheduleRule(
-        rule_type=RuleType.DAILY, interval=2, start_date="2026-09-01"
-    )
-    # Both boundary dates fire at interval 2 (offsets 0 and 6).
-    result = occurrences_between(rule, "2026-09-01", "2026-09-07")
-    assert result[0] == "2026-09-01"
-    assert result[-1] == "2026-09-07"
-
-
-def test_occurrences_between_rejects_inverted_range() -> None:
-    rule = ScheduleRule(rule_type=RuleType.DAILY, start_date="2026-09-01")
-    with pytest.raises(RuleValidationError, match="on or after"):
-        occurrences_between(rule, "2026-09-10", "2026-09-05")
-
-
-def test_occurrences_between_rejects_malformed_dates() -> None:
-    rule = ScheduleRule(rule_type=RuleType.DAILY, start_date="2026-09-01")
-    with pytest.raises(RuleValidationError, match="YYYY-MM-DD"):
-        occurrences_between(rule, "oops", "2026-09-05")
-    with pytest.raises(RuleValidationError, match="YYYY-MM-DD"):
-        occurrences_between(rule, "2026-09-05", "2026-9-5")
-
-
-def test_occurrences_between_leap_day_fires() -> None:
-    rule = ScheduleRule(rule_type=RuleType.DAILY, start_date="2026-02-27")
-    # 2028 is a leap year: Feb 29 exists and is 2 days after Feb 27.
-    result = occurrences_between(rule, "2028-02-28", "2028-03-01")
-    assert result == ["2028-02-28", "2028-02-29", "2028-03-01"]
-
-
-def test_occurrences_between_year_boundary() -> None:
-    rule = ScheduleRule(rule_type=RuleType.DAILY, start_date="2026-12-30")
-    result = occurrences_between(rule, "2026-12-30", "2027-01-02")
-    assert result == [
-        "2026-12-30", "2026-12-31", "2027-01-01", "2027-01-02",
-    ]
-
-
-# ---------------------------------------------------------------------------
-# Purity: the engine raises on unknown shapes rather than guessing
-# ---------------------------------------------------------------------------
-
-
-def test_occurs_on_rejects_unknown_shapes_loudly() -> None:
-    """All six model shapes are implemented; a shape added to the model
-    without an engine arm must raise a loud NotImplementedError rather
-    than a silent wrong answer.  Forged via a private enum extension
-    because ScheduleRule validation rejects unknown names."""
-    import enum as enum_module
-    from custom_components.nestquest import recurrence as mod
-
-    ForgedType = enum_module.Enum(
-        "ForgedType", {"UNKNOWN_SHAPE": "unknown_shape"}
-    )
-    forged_rule = ScheduleRule.__new__(ScheduleRule)
-    object.__setattr__(forged_rule, "rule_type", ForgedType.UNKNOWN_SHAPE)
-    object.__setattr__(forged_rule, "interval", 1)
-    object.__setattr__(forged_rule, "weekday_set", None)
-    object.__setattr__(forged_rule, "day_of_month", None)
-    object.__setattr__(forged_rule, "nth_weekday", None)
-    object.__setattr__(forged_rule, "nth_weekday_weekday", None)
-    object.__setattr__(forged_rule, "month", None)
-    object.__setattr__(forged_rule, "start_date", "2026-09-01")
-    object.__setattr__(forged_rule, "end_date", None)
-    for day in ("2026-08-31", "2026-09-15", "2026-12-31"):
-        with pytest.raises(NotImplementedError):
-            occurs_on(forged_rule, _d(day))
-        with pytest.raises(NotImplementedError):
-            occurrences_between(forged_rule, "2026-08-01", "2026-12-31")
-
-def test_interval_7_preserves_weekday_alignment_across_months() -> None:
-    """Weekly-by-interval semantics: every firing lands on the SAME
-    weekday as start_date, no matter how many month edges intervene."""
-    rule = ScheduleRule(
-        rule_type=RuleType.DAILY, interval=7, start_date="2026-09-01"
-    )
-    # 2026-09-01 is a Tuesday; every firing must be a Tuesday too.
-    assert _d("2026-09-01").weekday() == 1
-    for day in ("2026-09-08", "2026-09-29", "2026-10-06", "2026-11-03"):
-        assert occurs_on(rule, _d(day)) is True, day
-        assert _d(day).weekday() == 1, f"{day} must be a Tuesday"
-    # The day after a firing is never a firing.
-    assert occurs_on(rule, _d("2026-10-07")) is False
-
-
-def test_interval_2_across_leap_day() -> None:
-    """Interval > 1 arithmetic across a leap day: the extra day shifts
-    subsequent offsets by one, and the mod arithmetic reflects it."""
-    rule = ScheduleRule(
-        rule_type=RuleType.DAILY, interval=2, start_date="2028-02-27"
-    )
-    assert occurs_on(rule, _d("2028-02-27")) is True   # 0
-    assert occurs_on(rule, _d("2028-02-28")) is False  # 1
-    assert occurs_on(rule, _d("2028-02-29")) is True   # 2 (leap day)
-    assert occurs_on(rule, _d("2028-03-01")) is False  # 3
-    assert occurs_on(rule, _d("2028-03-02")) is True   # 4
-
-
-def test_occurrences_between_leap_day_interval_2() -> None:
-    rule = ScheduleRule(
-        rule_type=RuleType.DAILY, interval=2, start_date="2028-02-27"
-    )
-    result = occurrences_between(rule, "2028-02-27", "2028-03-03")
-    assert result == ["2028-02-27", "2028-02-29", "2028-03-02"]
-
-
-def test_occurrences_between_year_boundary_interval_2() -> None:
-    rule = ScheduleRule(
-        rule_type=RuleType.DAILY, interval=2, start_date="2026-12-30"
-    )
-    result = occurrences_between(rule, "2026-12-30", "2027-01-04")
-    # Offsets 0, 2, 4, 6 = Dec 30, Jan 1, Jan 3 ... wait: offsets are
-    # Dec30=0, Dec31=1, Jan1=2, Jan2=3, Jan3=4, Jan4=5. Even offsets:
-    assert result == ["2026-12-30", "2027-01-01", "2027-01-03"]
-
-
-

tests/test_recurrence_model.py

@@ -1,485 +0,0 @@
-"""Tests for recurrence.py: the ScheduleRule model and serialization."""
-from __future__ import annotations
-
-import datetime
-
-import pytest
-
-from custom_components.nestquest.recurrence import (
-    RuleType,
-    RuleValidationError,
-    ScheduleRule,
-)
-
-
-def _rule(**kwargs) -> ScheduleRule:
-    return ScheduleRule(**kwargs)
-
-
-# ---------------------------------------------------------------------------
-# Valid construction for every rule type
-# ---------------------------------------------------------------------------
-
-
-def test_daily_rule_constructs_with_defaults() -> None:
-    rule = _rule(rule_type=RuleType.DAILY, start_date="2026-09-01")
-    assert rule.rule_type is RuleType.DAILY
-    assert rule.interval == 1
-    assert rule.weekday_set is None
-    assert rule.day_of_month is None
-    assert rule.nth_weekday is None
-    assert rule.month is None
-    assert rule.end_date is None
-
-
-def test_string_rule_type_coerces() -> None:
-    rule = _rule(rule_type=RuleType.WEEKLY, weekday_set={0, 2}, start_date="2026-09-01")
-    assert rule.rule_type is RuleType.WEEKLY
-
-
-def test_weekly_rule_requires_and_freezes_weekday_set() -> None:
-    rule = _rule(rule_type=RuleType.WEEKLY, weekday_set={0, 2, 4}, start_date="2026-09-01")
-    assert rule.weekday_set == frozenset({0, 2, 4})
-    # A mutable set passed in is frozen on construction.
-    source = {1, 3}
-    rule2 = _rule(rule_type=RuleType.WEEKLY, weekday_set=source, start_date="2026-09-01")
-    source.add(5)
-    assert rule2.weekday_set == frozenset({1, 3})
-
-
-def test_monthly_day_rule_fields() -> None:
-    rule = _rule(rule_type=RuleType.MONTHLY_DAY, day_of_month=15, start_date="2026-09-01")
-    assert rule.day_of_month == 15
-    assert rule.nth_weekday is None
-
-
-def test_monthly_weekday_rule_fields() -> None:
-    rule = _rule(
-        rule_type=RuleType.MONTHLY_WEEKDAY,
-        nth_weekday=2,
-        nth_weekday_weekday=1,
-        start_date="2026-09-01",
-    )
-    assert rule.nth_weekday == 2
-    assert rule.nth_weekday_weekday == 1
-
-
-def test_monthly_weekday_last_friday_allowed() -> None:
-    rule = _rule(
-        rule_type=RuleType.MONTHLY_WEEKDAY,
-        nth_weekday=-1,
-        nth_weekday_weekday=4,
-        start_date="2026-09-01",
-    )
-    assert rule.nth_weekday == -1
-
-
-def test_yearly_rule_fields() -> None:
-    rule = _rule(rule_type=RuleType.YEARLY, month=6, start_date="2026-09-01")
-    assert rule.month == 6
-
-
-def test_custom_days_rule_fields() -> None:
-    rule = _rule(
-        rule_type=RuleType.CUSTOM_DAYS,
-        weekday_set={1, 3, 5},
-        interval=2,
-        start_date="2026-09-01",
-    )
-    assert rule.weekday_set == frozenset({1, 3, 5})
-    assert rule.interval == 2
-
-
-def test_end_date_round_trips(tmp_path) -> None:
-    rule = _rule(
-        rule_type=RuleType.DAILY,
-        start_date="2026-09-01",
-        end_date="2026-12-31",
-    )
-    assert rule.end_date == "2026-12-31"
-
-
-# ---------------------------------------------------------------------------
-# Invalid combinations are rejected at construction
-# ---------------------------------------------------------------------------
-
-
-@pytest.mark.parametrize(
-    "kwargs",
-    [
-        # weekly without weekday_set
-        {"rule_type": RuleType.WEEKLY.value, "start_date": "2026-09-01"},
-        # daily carrying a weekday_set
-        {"rule_type": "daily", "weekday_set": {0}, "start_date": "2026-09-01"},
-        # monthly_day without day_of_month
-        {"rule_type": "monthly_day", "start_date": "2026-09-01"},
-        # monthly_day out of range
-        {"rule_type": "monthly_day", "day_of_month": 32, "start_date": "2026-09-01"},
-        # monthly_day carrying weekday_set
-        {"rule_type": "monthly_day", "day_of_month": 5, "weekday_set": {0},
-         "start_date": "2026-09-01"},
-        # yearly without month
-        {"rule_type": "yearly", "start_date": "2026-09-01"},
-        # yearly out of range
-        {"rule_type": "yearly", "month": 13, "start_date": "2026-09-01"},
-        # unknown type
-        {"rule_type": "bogus", "start_date": "2026-09-01"},
-        # interval zero
-        {"rule_type": "daily", "interval": 0, "start_date": "2026-09-01"},
-        # interval non-integer
-        {"rule_type": "daily", "interval": "2", "start_date": "2026-09-01"},
-        # end before start
-        {"rule_type": "daily", "start_date": "2026-09-01",
-         "end_date": "2026-08-31"},
-        # malformed dates
-        {"rule_type": "daily", "start_date": "not-a-date"},
-        {"rule_type": "daily", "start_date": "2026-9-1"},
-        # weekly weekday out of range
-        {"rule_type": RuleType.WEEKLY.value, "weekday_set": {7}, "start_date": "2026-09-01"},
-        # weekly empty set
-        {"rule_type": RuleType.WEEKLY.value, "weekday_set": set(), "start_date": "2026-09-01"},
-        # custom_days carrying month-specific fields
-        {"rule_type": "custom_days", "weekday_set": {0}, "day_of_month": 5,
-         "start_date": "2026-09-01"},
-        {"rule_type": "custom_days", "weekday_set": {0}, "nth_weekday": 1,
-         "nth_weekday_weekday": 0, "start_date": "2026-09-01"},
-        {"rule_type": "custom_days", "weekday_set": {0}, "month": 3,
-         "start_date": "2026-09-01"},
-        # monthly_weekday position invalid
-        {"rule_type": "monthly_weekday", "nth_weekday": 0,
-         "nth_weekday_weekday": 1, "start_date": "2026-09-01"},
-        {"rule_type": "monthly_weekday", "nth_weekday": 6,
-         "nth_weekday_weekday": 1, "start_date": "2026-09-01"},
-        {"rule_type": "monthly_weekday", "nth_weekday": 2,
-         "nth_weekday_weekday": None, "start_date": "2026-09-01"},
-        {"rule_type": "monthly_weekday", "nth_weekday": 2,
-         "nth_weekday_weekday": 7, "start_date": "2026-09-01"},
-        # monthly_day carrying nth fields
-        {"rule_type": "monthly_day", "day_of_month": 5, "nth_weekday": 1,
-         "nth_weekday_weekday": 0, "start_date": "2026-09-01"},
-    ],
-)
-def test_invalid_combinations_raise(kwargs) -> None:
-    with pytest.raises(RuleValidationError):
-        _rule(**kwargs)
-
-
-# ---------------------------------------------------------------------------
-# Immutability
-# ---------------------------------------------------------------------------
-
-
-def test_rule_is_immutable() -> None:
-    rule = _rule(rule_type=RuleType.DAILY, start_date="2026-09-01")
-    with pytest.raises(AttributeError):
-        rule.interval = 2
-    with pytest.raises(AttributeError):
-        del rule.interval
-
-
-# ---------------------------------------------------------------------------
-# Serialization round-trip for every rule type
-# ---------------------------------------------------------------------------
-
-
-@pytest.mark.parametrize(
-    "rule",
-    [
-        ScheduleRule(rule_type=RuleType.DAILY, start_date="2026-09-01"),
-        ScheduleRule(rule_type=RuleType.DAILY, interval=3, start_date="2026-09-01",
-                     end_date="2026-12-31"),
-        ScheduleRule(rule_type=RuleType.WEEKLY, weekday_set={0, 2, 4},
-                     start_date="2026-09-01"),
-        ScheduleRule(rule_type=RuleType.WEEKLY, weekday_set={6}, interval=2,
-                     start_date="2026-09-01"),
-        ScheduleRule(rule_type=RuleType.MONTHLY_DAY, day_of_month=15,
-                     start_date="2026-09-01"),
-        ScheduleRule(rule_type=RuleType.MONTHLY_DAY, day_of_month=31, interval=3,
-                     start_date="2026-09-01"),
-        ScheduleRule(rule_type=RuleType.MONTHLY_WEEKDAY, nth_weekday=2,
-                     nth_weekday_weekday=1, start_date="2026-09-01"),
-        ScheduleRule(rule_type=RuleType.MONTHLY_WEEKDAY, nth_weekday=-1,
-                     nth_weekday_weekday=4, interval=2,
-                     start_date="2026-09-01"),
-        ScheduleRule(rule_type=RuleType.YEARLY, month=6, start_date="2026-09-01"),
-        ScheduleRule(rule_type=RuleType.YEARLY, month=2, day_of_month=None,
-                     interval=2, start_date="2026-09-01"),
-        ScheduleRule(rule_type=RuleType.CUSTOM_DAYS, weekday_set={1, 3, 5},
-                     interval=2, start_date="2026-09-01"),
-    ],
-)
-def test_to_dict_from_dict_round_trips_losslessly(rule) -> None:
-    rebuilt = ScheduleRule.from_dict(rule.to_dict())
-    assert rebuilt == rule
-    # Round-tripping twice is stable.
-    assert ScheduleRule.from_dict(rebuilt.to_dict()) == rule
-
-
-def test_from_dict_rejects_unknown_fields() -> None:
-    with pytest.raises(RuleValidationError, match="unknown rule fields"):
-        ScheduleRule.from_dict({"rule_type": "daily", "bogus": 1})
-
-
-def test_from_dict_rejects_missing_rule_type() -> None:
-    with pytest.raises(RuleValidationError, match="missing required"):
-        ScheduleRule.from_dict({"interval": 1})
-
-
-def test_from_dict_rejects_non_dict() -> None:
-    with pytest.raises(RuleValidationError):
-        ScheduleRule.from_dict("daily")
-
-
-def test_from_dict_defaults_start_date_when_absent() -> None:
-    rule = ScheduleRule.from_dict({"rule_type": "daily"})
-    assert rule.start_date == "1970-01-01"
-
-
-def test_from_dict_accepts_list_weekday_set() -> None:
-    rule = ScheduleRule.from_dict(
-        {"rule_type": RuleType.WEEKLY.value, "weekday_set": [0, 2, 4]}
-    )
-    assert rule.weekday_set == frozenset({0, 2, 4})
-
-
-# ---------------------------------------------------------------------------
-# Equality and hashing
-# ---------------------------------------------------------------------------
-
-
-def test_equal_rules_compare_equal_and_hash_equal() -> None:
-    a = _rule(rule_type=RuleType.WEEKLY, weekday_set={0, 2}, start_date="2026-09-01")
-    b = _rule(rule_type=RuleType.WEEKLY, weekday_set={2, 0}, start_date="2026-09-01")
-    assert a == b
-    assert hash(a) == hash(b)
-
-
-def test_different_rules_compare_unequal() -> None:
-    a = _rule(rule_type=RuleType.DAILY, start_date="2026-09-01")
-    b = _rule(rule_type=RuleType.DAILY, interval=2, start_date="2026-09-01")
-    assert a != b
-
-
-def test_rule_not_equal_to_other_types() -> None:
-    rule = _rule(rule_type=RuleType.DAILY, start_date="2026-09-01")
-    assert rule != "daily"
-    assert (rule == 42) is False
-
-
-# ---------------------------------------------------------------------------
-# Purity guards: no HA imports, no database access
-# ---------------------------------------------------------------------------
-
-
-def test_recurrence_module_imports_only_stdlib() -> None:
-    """The model must carry no Home Assistant and no DB imports."""
-    from pathlib import Path
-
-    source = Path(
-        __import__("custom_components.nestquest.recurrence",
-                   fromlist=["__file__"]).__file__
-    ).read_text()
-    offenders = _scan_forbidden_imports(source)
-    assert offenders == [], (
-        f"recurrence.py must not hold forbidden imports: {offenders}"
-    )
-
-
-def _scan_forbidden_imports(source: str) -> list[str]:
-    """The ACTUAL purity-guard logic, shared by the model scan and the
-    probe tests below: returns human-readable offenders (empty = clean).
-
-    Forbidden, at any relative level, for both Import and ImportFrom:
-    - modules containing 'homeassistant' or 'sqlite'
-    - modules whose LEAF name is a DB/store/schema/DAO module
-    - aliases importing a DB/store/schema/DAO module by leaf name
-      ('from . import db', 'from custom_components.nestquest import db')
-    """
-    import ast
-
-    forbidden_targets = {
-        "db", "schema", "dao_children", "dao_rules", "dao_presence",
-        "dao_instances", "migrations", "store",
-    }
-    offenders: list[str] = []
-    tree = ast.parse(source)
-    for node in ast.walk(tree):
-        if isinstance(node, ast.Import):
-            for alias in node.names:
-                lowered = alias.name.lower()
-                leaf = lowered.split(".")[-1]
-                if (
-                    "homeassistant" in lowered
-                    or "sqlite" in lowered
-                    or leaf in forbidden_targets
-                ):
-                    offenders.append(f"import {alias.name}")
-        elif isinstance(node, ast.ImportFrom):
-            module = (node.module or "").lower()
-            module_leaf = module.split(".")[-1] if module else ""
-            if (
-                "homeassistant" in module
-                or "sqlite" in module
-                or (module and module_leaf in forbidden_targets)
-                or (node.level and module_leaf in forbidden_targets)
-            ):
-                offenders.append(
-                    f"from {node.module!r} import ... (level={node.level})"
-                )
-            for alias in node.names:
-                alias_leaf = alias.name.split(".")[-1].lower()
-                if alias_leaf in forbidden_targets:
-                    offenders.append(
-                        f"from {node.module!r} import {alias.name} "
-                        f"(level={node.level})"
-                    )
-    return offenders
-
-
-def test_purity_guard_logic_catches_probe_statements(tmp_path) -> None:
-    """The shared scan function catches every forbidden import shape,
-    including level-0 absolute package DB imports and 'from . import db'.
-    """
-    probes = [
-        "from homeassistant.core import HomeAssistant",
-        "import sqlite3",
-        "from .db import NestQuestDatabase",
-        "from custom_components.nestquest.db import NestQuestDatabase",
-        "from custom_components.nestquest import db",
-        "import custom_components.nestquest.dao_rules",
-        "from . import db",
-        "from . import schema",
-        "from custom_components.nestquest.migrations import apply_migrations",
-    ]
-    for probe in probes:
-        offenders = _scan_forbidden_imports(probe)
-        assert offenders, f"probe must be caught: {probe!r}"
-
-
-def test_non_string_rule_type_rejected() -> None:
-    """Only RuleType members and their string values construct."""
-    for bad in (123, True, None, 3.5, b"daily"):
-        with pytest.raises(RuleValidationError):
-            ScheduleRule(rule_type=bad, start_date="2026-09-01")
-
-
-def test_weekly_rejects_month_and_nth_fields() -> None:
-    with pytest.raises(RuleValidationError, match="must not set"):
-        ScheduleRule(
-            rule_type=RuleType.WEEKLY, weekday_set={0}, day_of_month=5,
-            start_date="2026-09-01",
-        )
-    with pytest.raises(RuleValidationError, match="must not set"):
-        ScheduleRule(
-            rule_type=RuleType.WEEKLY, weekday_set={0}, month=3,
-            start_date="2026-09-01",
-        )
-
-
-def test_daily_rejects_dangling_nth_weekday_weekday() -> None:
-    with pytest.raises(RuleValidationError, match="must not set"):
-        ScheduleRule(
-            rule_type=RuleType.DAILY, nth_weekday_weekday=0,
-            start_date="2026-09-01",
-        )
-
-
-def test_monthly_day_rejects_month() -> None:
-    with pytest.raises(RuleValidationError, match="must not set"):
-        ScheduleRule(
-            rule_type=RuleType.MONTHLY_DAY, day_of_month=5, month=3,
-            start_date="2026-09-01",
-        )
-
-
-def test_yearly_rejects_day_and_nth_fields() -> None:
-    with pytest.raises(RuleValidationError, match="must not set"):
-        ScheduleRule(
-            rule_type=RuleType.YEARLY, month=6, nth_weekday=1,
-            nth_weekday_weekday=0, start_date="2026-09-01",
-        )
-    # YEARLY MAY carry an optional day_of_month (Feb 29 rules need it):
-    rule = ScheduleRule(rule_type=RuleType.YEARLY, month=2,
-                        day_of_month=29, start_date="2026-09-01")
-    assert rule.day_of_month == 29
-    # ...but it is still validated when present.
-    with pytest.raises(RuleValidationError, match="day_of_month"):
-        ScheduleRule(
-            rule_type=RuleType.YEARLY, month=6, day_of_month=32,
-            start_date="2026-09-01",
-        )
-
-
-def test_storage_value_mapping() -> None:
-    """The enum exposes the schema's CHECK values via storage_value."""
-    assert RuleType.DAILY.storage_value == "daily"
-    assert RuleType.WEEKLY.storage_value == "weekly"
-    assert RuleType.MONTHLY_DAY.storage_value == "monthly"
-    assert RuleType.MONTHLY_WEEKDAY.storage_value == "monthly"
-    assert RuleType.YEARLY.storage_value == "yearly"
-    assert RuleType.CUSTOM_DAYS.storage_value == "custom"
-
-
-def test_from_dict_bool_weekday_entry_rejected_before_set_coercion() -> None:
-    """[0, False] must NOT collapse False into 0 via set() coercion."""
-    with pytest.raises(RuleValidationError, match="plain integers"):
-        ScheduleRule.from_dict(
-            {"rule_type": "weekly", "weekday_set": [0, False]}
-        )
-
-
-def test_direct_set_with_int_subclass_entry_rejected() -> None:
-    """A hashable-but-non-plain int subclass is still not a plain int."""
-
-    class IntChild(int):
-        pass
-
-    with pytest.raises(RuleValidationError, match="plain integers"):
-        ScheduleRule(
-            rule_type=RuleType.WEEKLY,
-            weekday_set={IntChild(1)},
-            start_date="2026-09-01",
-        )
-
-
-def test_from_dict_with_int_subclass_entry_rejected() -> None:
-    class IntChild(int):
-        pass
-
-    with pytest.raises(RuleValidationError, match="plain integers"):
-        ScheduleRule.from_dict(
-            {"rule_type": "weekly", "weekday_set": [IntChild(1)]}
-        )
-
-
-def test_from_dict_unknown_key_types_never_leak_typeerror() -> None:
-    """Mixed unhashable unknown keys must surface as
-    RuleValidationError, not a raw TypeError from sorting."""
-    with pytest.raises(RuleValidationError, match="unknown rule fields"):
-        ScheduleRule.from_dict({"rule_type": "daily", 42: "value"})
-
-
-def test_storage_aliases_and_whitespace_are_not_model_names() -> None:
-    """The model boundary is exact names only: storage strings, padded
-    and case variants are all rejected."""
-    for bad in ("monthly", "custom", " DAILY ", "daily ", "DAILY"):
-        with pytest.raises(RuleValidationError):
-            ScheduleRule(rule_type=bad, start_date="2026-09-01")
-
-
-def test_unhashable_int_subclass_interval_rejected() -> None:
-    class UnhashableInt(int):
-        __hash__ = None
-
-    with pytest.raises(RuleValidationError):
-        ScheduleRule(
-            rule_type=RuleType.DAILY,
-            interval=UnhashableInt(1),
-            start_date="2026-09-01",
-        )
-
-
-def test_rule_type_is_a_dataclass() -> None:
-    import dataclasses
-
-    assert dataclasses.is_dataclass(ScheduleRule)

tests/test_recurrence_monthly_day.py

@@ -1,301 +0,0 @@
-"""Tests for MONTHLY_DAY recurrence with the month-end clamp policy."""
-from __future__ import annotations
-
-import datetime
-
-import pytest
-
-from custom_components.nestquest.recurrence import (
-    RuleType,
-    RuleValidationError,
-    ScheduleRule,
-    _month_end,
-    occurs_on,
-    occurrences_between,
-)
-
-
-def _d(date: str) -> datetime.date:
-    return datetime.date.fromisoformat(date)
-
-
-# ---------------------------------------------------------------------------
-# Nominal-day firings
-# ---------------------------------------------------------------------------
-
-
-def test_monthly_day_15_fires_on_the_15th() -> None:
-    rule = ScheduleRule(
-        rule_type=RuleType.MONTHLY_DAY, day_of_month=15,
-        start_date="2026-01-15",
-    )
-    for month in range(1, 13):
-        assert occurs_on(rule, datetime.date(2026, month, 15)) is True
-    assert occurs_on(rule, datetime.date(2026, 1, 14)) is False
-    assert occurs_on(rule, datetime.date(2026, 1, 16)) is False
-
-
-def test_monthly_day_never_fires_on_other_days() -> None:
-    rule = ScheduleRule(
-        rule_type=RuleType.MONTHLY_DAY, day_of_month=10,
-        start_date="2026-01-10",
-    )
-    # Every non-10th day of a short month must be False.
-    for day in range(1, 30):
-        if day != 10:
-            assert occurs_on(
-                rule, datetime.date(2026, 1, day)
-            ) is False, f"Jan {day}"
-
-
-def test_monthly_day_never_fires_before_start() -> None:
-    rule = ScheduleRule(
-        rule_type=RuleType.MONTHLY_DAY, day_of_month=15,
-        start_date="2026-03-15",
-    )
-    # Feb 15 precedes the start: no firing even though the day matches.
-    assert occurs_on(rule, datetime.date(2026, 2, 15)) is False
-    assert occurs_on(rule, datetime.date(2026, 3, 15)) is True
-
-
-def test_monthly_day_respects_end_date() -> None:
-    rule = ScheduleRule(
-        rule_type=RuleType.MONTHLY_DAY, day_of_month=15,
-        start_date="2026-01-15", end_date="2026-06-15",
-    )
-    assert occurs_on(rule, datetime.date(2026, 6, 15)) is True
-    assert occurs_on(rule, datetime.date(2026, 7, 15)) is False
-
-
-# ---------------------------------------------------------------------------
-# Month-end clamp policy
-# ---------------------------------------------------------------------------
-
-
-def test_month_end_helper_is_leap_aware() -> None:
-    assert _month_end(2026, 1) == 31
-    assert _month_end(2026, 4) == 30
-    assert _month_end(2026, 2) == 28   # non-leap
-    assert _month_end(2028, 2) == 29   # leap
-    assert _month_end(2000, 2) == 29   # divisible-by-400 leap
-    assert _month_end(1900, 2) == 28   # divisible-by-100 non-leap
-    assert _month_end(2026, 12) == 31
-
-
-def test_day_31_clamps_to_month_end_in_shorter_months() -> None:
-    rule = ScheduleRule(
-        rule_type=RuleType.MONTHLY_DAY, day_of_month=31,
-        start_date="2026-01-31",
-    )
-    # Months with a 31st: fire on the 31st.
-    for month, day in ((1, 31), (3, 31), (5, 31), (7, 31), (8, 31),
-                       (10, 31), (12, 31)):
-        assert occurs_on(rule, datetime.date(2026, month, day)) is True, (
-            f"2026-{month:02d}-{day:02d}"
-        )
-    # Months WITHOUT a 31st: fire on the month's last day.
-    assert occurs_on(rule, datetime.date(2026, 4, 30)) is True   # Apr 30
-    assert occurs_on(rule, datetime.date(2026, 6, 30)) is True   # Jun 30
-    assert occurs_on(rule, datetime.date(2026, 9, 30)) is True   # Sep 30
-    assert occurs_on(rule, datetime.date(2026, 11, 30)) is True  # Nov 30
-    # The day BEFORE the clamp is not a firing.
-    assert occurs_on(rule, datetime.date(2026, 4, 29)) is False
-    assert occurs_on(rule, datetime.date(2026, 4, 28)) is False
-
-
-def test_day_30_clamps_to_feb_28_non_leap() -> None:
-    rule = ScheduleRule(
-        rule_type=RuleType.MONTHLY_DAY, day_of_month=30,
-        start_date="2026-01-30",
-    )
-    assert occurs_on(rule, datetime.date(2026, 2, 28)) is True   # clamp
-    # No Feb 29 in 2026 (non-leap): nothing else in February fires.
-    assert occurs_on(rule, datetime.date(2026, 2, 27)) is False
-    # Months with a 30th: nominal day.
-    assert occurs_on(rule, datetime.date(2026, 4, 30)) is True
-    assert occurs_on(rule, datetime.date(2026, 3, 30)) is True
-
-
-def test_day_29_feb_clamps_to_28_non_leap_and_29_leap() -> None:
-    rule = ScheduleRule(
-        rule_type=RuleType.MONTHLY_DAY, day_of_month=29,
-        start_date="2026-01-29",
-    )
-    # Non-leap 2027: Feb 28 is the clamp.
-    assert occurs_on(rule, datetime.date(2027, 2, 28)) is True
-    assert occurs_on(rule, datetime.date(2027, 2, 27)) is False
-    # Leap 2028: Feb 29 exists — nominal day.
-    assert occurs_on(rule, datetime.date(2028, 2, 29)) is True
-    assert occurs_on(rule, datetime.date(2028, 2, 28)) is False
-
-
-def test_day_30_feb_leap_year_clamps_to_29() -> None:
-    rule = ScheduleRule(
-        rule_type=RuleType.MONTHLY_DAY, day_of_month=30,
-        start_date="2027-01-30",
-    )
-    # Leap 2028: Feb has 29 days; the 30th clamps to Feb 29.
-    assert occurs_on(rule, datetime.date(2028, 2, 29)) is True
-    # Non-leap 2026 (rule starts 2027 so Feb 2027 is non-leap): clamps 28.
-    assert occurs_on(rule, datetime.date(2027, 2, 28)) is True
-
-
-# ---------------------------------------------------------------------------
-# Full-year sweeps: the 29th, 30th, 31st across leap and non-leap years
-# ---------------------------------------------------------------------------
-
-
-def _sweep_monthly(rule: ScheduleRule, year: int) -> list[tuple[int, int]]:
-    """Every (month, day) in ``rule``'s year the engine says fires."""
-    hits = []
-    for month in range(1, 13):
-        for day in range(1, _month_end(year, month) + 1):
-            if occurs_on(rule, datetime.date(year, month, day)):
-                hits.append((month, day))
-    return hits
-
-
-def test_full_year_day_31_sweep_2026() -> None:
-    rule = ScheduleRule(
-        rule_type=RuleType.MONTHLY_DAY, day_of_month=31,
-        start_date="2026-01-31",
-    )
-    # Exactly one firing per month, twelve total.
-    hits = _sweep_monthly(rule, 2026)
-    assert len(hits) == 12
-    by_month = dict(hits)
-    assert (by_month[1], by_month[2], by_month[4]) == (31, 28, 30)
-    assert by_month[2] == 28  # 2026 Feb is non-leap
-    assert by_month[4] == 30
-    # Each month has exactly one firing.
-    months = [month for month, _ in hits]
-    assert months == list(range(1, 13))
-
-
-def test_full_year_day_31_sweep_2028_leap() -> None:
-    rule = ScheduleRule(
-        rule_type=RuleType.MONTHLY_DAY, day_of_month=31,
-        start_date="2028-01-31",
-    )
-    hits = _sweep_monthly(rule, 2028)
-    by_month = dict(hits)
-    assert by_month[2] == 29  # leap February clamps to the 29th
-    assert by_month[4] == 30
-    months = [month for month, _ in hits]
-    assert months == list(range(1, 13))
-
-
-def test_full_year_day_30_sweep_2028() -> None:
-    rule = ScheduleRule(
-        rule_type=RuleType.MONTHLY_DAY, day_of_month=30,
-        start_date="2028-01-30",
-    )
-    hits = _sweep_monthly(rule, 2028)
-    by_month = dict(hits)
-    assert by_month[2] == 29  # leap Feb clamps to 29
-    months = [month for month, _ in hits]
-    assert months == list(range(1, 13))
-
-
-def test_full_year_day_29_sweep_2027_non_leap() -> None:
-    rule = ScheduleRule(
-        rule_type=RuleType.MONTHLY_DAY, day_of_month=29,
-        start_date="2027-01-29",
-    )
-    hits = _sweep_monthly(rule, 2027)
-    by_month = dict(hits)
-    assert by_month[2] == 28  # non-leap Feb clamps to the 28th
-    months = [month for month, _ in hits]
-    assert months == list(range(1, 13))
-
-
-def test_full_year_day_29_sweep_2028_leap() -> None:
-    rule = ScheduleRule(
-        rule_type=RuleType.MONTHLY_DAY, day_of_month=29,
-        start_date="2028-01-29",
-    )
-    hits = _sweep_monthly(rule, 2028)
-    by_month = dict(hits)
-    assert by_month[2] == 29  # leap Feb has a real 29th: nominal day
-    months = [month for month, _ in hits]
-    assert months == list(range(1, 13))
-
-
-# ---------------------------------------------------------------------------
-# Interval arithmetic
-# ---------------------------------------------------------------------------
-
-
-def test_monthly_interval_2_every_second_month() -> None:
-    rule = ScheduleRule(
-        rule_type=RuleType.MONTHLY_DAY, day_of_month=15, interval=2,
-        start_date="2026-01-15",
-    )
-    assert occurs_on(rule, datetime.date(2026, 1, 15)) is True
-    assert occurs_on(rule, datetime.date(2026, 2, 15)) is False
-    assert occurs_on(rule, datetime.date(2026, 3, 15)) is True
-    assert occurs_on(rule, datetime.date(2026, 4, 15)) is False
-    assert occurs_on(rule, datetime.date(2026, 5, 15)) is True
-
-
-def test_monthly_interval_2_clamped_month_end_alignment() -> None:
-    """Interval counts nominal months from the anchor: Jan 31 anchor,
-    every 2 months -> Jan (m0), Mar (m2), May (m4), Jul (m6).  Clamped
-    firings (Feb 28, Apr 30, Jun 30) occur only in interval months."""
-    rule = ScheduleRule(
-        rule_type=RuleType.MONTHLY_DAY, day_of_month=31, interval=2,
-        start_date="2026-01-31",
-    )
-    assert occurs_on(rule, datetime.date(2026, 1, 31)) is True   # m0
-    assert occurs_on(rule, datetime.date(2026, 2, 28)) is False  # m1
-    assert occurs_on(rule, datetime.date(2026, 3, 31)) is True   # m2
-    assert occurs_on(rule, datetime.date(2026, 4, 30)) is False  # m3
-    assert occurs_on(rule, datetime.date(2026, 5, 31)) is True   # m4
-    assert occurs_on(rule, datetime.date(2026, 6, 30)) is False  # m5
-    assert occurs_on(rule, datetime.date(2026, 7, 31)) is True   # m6
-
-
-def test_monthly_interval_arithmetic_across_year_boundary() -> None:
-    rule = ScheduleRule(
-        rule_type=RuleType.MONTHLY_DAY, day_of_month=15, interval=2,
-        start_date="2026-11-15",
-    )
-    # Nov (m0) fires, Jan 2027 (m2) fires, Mar (m4) fires.
-    assert occurs_on(rule, datetime.date(2026, 11, 15)) is True
-    assert occurs_on(rule, datetime.date(2026, 12, 15)) is False
-    assert occurs_on(rule, datetime.date(2027, 1, 15)) is True
-    assert occurs_on(rule, datetime.date(2027, 2, 15)) is False
-    assert occurs_on(rule, datetime.date(2027, 3, 15)) is True
-
-
-def test_monthly_day_occurrences_between_span() -> None:
-    rule = ScheduleRule(
-        rule_type=RuleType.MONTHLY_DAY, day_of_month=31,
-        start_date="2026-01-31",
-    )
-    result = occurrences_between(rule, "2026-01-01", "2026-06-30")
-    assert result == [
-        "2026-01-31", "2026-02-28", "2026-03-31", "2026-04-30",
-        "2026-05-31", "2026-06-30",
-    ]
-
-
-def test_monthly_day_occurrences_between_rejects_inverted() -> None:
-    rule = ScheduleRule(
-        rule_type=RuleType.MONTHLY_DAY, day_of_month=15,
-        start_date="2026-01-15",
-    )
-    with pytest.raises(RuleValidationError, match="on or after"):
-        occurrences_between(rule, "2026-06-15", "2026-01-15")
-
-
-def test_monthly_day_clamp_is_one_firing_per_month(tmp_path) -> None:
-    """The clamp must not double-fire: only one day per month matches."""
-    rule = ScheduleRule(
-        rule_type=RuleType.MONTHLY_DAY, day_of_month=31,
-        start_date="2026-01-31",
-    )
-    hits = _sweep_monthly(rule, 2026)
-    months = [month for month, _ in hits]
-    assert months == sorted(months)
-    assert len(months) == len(set(months)) == 12

tests/test_recurrence_monthly_weekday.py

@@ -1,324 +0,0 @@
-"""Tests for MONTHLY_WEEKDAY (nth-weekday-of-month) recurrence."""
-from __future__ import annotations
-
-import datetime
-
-import pytest
-
-from custom_components.nestquest.recurrence import (
-    RuleType,
-    RuleValidationError,
-    ScheduleRule,
-    _nth_weekday_of_month,
-    occurs_on,
-    occurrences_between,
-)
-
-
-def _d(date: str) -> datetime.date:
-    return datetime.date.fromisoformat(date)
-
-
-# ---------------------------------------------------------------------------
-# The helper: nth occurrence day-of-month
-# ---------------------------------------------------------------------------
-
-
-def test_nth_weekday_helper_first_second_third() -> None:
-    """Independently verified: Mar 1 2026 is a Sunday; Wednesdays are
-    4, 11, 18, 25 (four — no 5th)."""
-    assert _nth_weekday_of_month(2026, 3, 2, 1) == 4
-    assert _nth_weekday_of_month(2026, 3, 2, 2) == 11
-    assert _nth_weekday_of_month(2026, 3, 2, 3) == 18
-    assert _nth_weekday_of_month(2026, 3, 2, 4) == 25
-    assert _nth_weekday_of_month(2026, 3, 2, 5) is None
-
-
-def test_nth_weekday_helper_none_when_month_lacks_nth() -> None:
-    """Independently verified: April 2026 Fridays are 3, 10, 17, 24
-    (four) — no 5th occurrence."""
-    assert _nth_weekday_of_month(2026, 4, 4, 5) is None
-
-
-def test_nth_weekday_helper_last() -> None:
-    """Independently verified: March 2026 Fridays are 6, 13, 20, 27;
-    February 2028 Saturdays are 5, 12, 19, 26 (Feb 29 2028 is a
-    Tuesday, so the last SATURDAY is the 26th, not the last day)."""
-    assert _nth_weekday_of_month(2026, 3, 4, -1) == 27
-    # February 2026: 28 days, last day IS a Saturday.
-    assert _nth_weekday_of_month(2026, 2, 5, -1) == 28
-    # February 2028: the last Saturday is the 26th (Feb 29 is a Tue).
-    assert _nth_weekday_of_month(2028, 2, 5, -1) == 26
-
-
-def test_nth_weekday_helper_last_when_month_has_five() -> None:
-    """Independently verified: October 2026 Fridays are 2, 9, 16, 23, 30
-    (five) — the last is the 30th, and the 5th is the same day."""
-    assert _nth_weekday_of_month(2026, 10, 4, -1) == 30
-    assert _nth_weekday_of_month(2026, 10, 4, 5) == 30
-
-
-def test_helper_zero_and_out_of_range_nth() -> None:
-    """The model rejects n 0 before the helper sees it; -1/1..5 only."""
-    with pytest.raises(RuleValidationError):
-        ScheduleRule(
-            rule_type=RuleType.MONTHLY_WEEKDAY, nth_weekday=0,
-            nth_weekday_weekday=1, start_date="2026-09-01",
-        )
-    with pytest.raises(RuleValidationError):
-        ScheduleRule(
-            rule_type=RuleType.MONTHLY_WEEKDAY, nth_weekday=6,
-            nth_weekday_weekday=1, start_date="2026-09-01",
-        )
-
-
-# ---------------------------------------------------------------------------
-# occurs_on: first / second / third / fourth / last across 12 months
-# ---------------------------------------------------------------------------
-
-
-def test_first_tuesday_of_twelve_consecutive_months() -> None:
-    rule = ScheduleRule(
-        rule_type=RuleType.MONTHLY_WEEKDAY, nth_weekday=1,
-        nth_weekday_weekday=2,  # first Wednesday
-        start_date="2026-01-01",
-    )
-    first_wednesdays = [
-        (1, 7), (2, 4), (3, 4), (4, 1), (5, 6), (6, 3),
-        (7, 1), (8, 5), (9, 2), (10, 7), (11, 4), (12, 2),
-    ]
-    for month, day in first_wednesdays:
-        date = datetime.date(2026, month, day)
-        assert date.weekday() == 2
-        assert occurs_on(rule, date) is True, date
-        # Neighbors do not fire.
-        assert occurs_on(rule, date - datetime.timedelta(days=7)) is False
-        assert occurs_on(rule, date + datetime.timedelta(days=7)) is False
-
-
-def test_second_wednesday_of_twelve_consecutive_months() -> None:
-    """Independently verified second Wednesdays of 2026 (Jan 1 is a
-    Thursday; Wednesdays per month from the calendar): the SECOND one
-    fires; the FIRST one does not."""
-    rule = ScheduleRule(
-        rule_type=RuleType.MONTHLY_WEEKDAY, nth_weekday=2,
-        nth_weekday_weekday=2,
-        start_date="2026-01-01",
-    )
-    # (month, first_wed, second_wed) from plain datetime arithmetic:
-    verified = [
-        (1, 7, 14), (2, 4, 11), (3, 4, 11), (4, 1, 8),
-        (5, 6, 13), (6, 3, 10), (7, 1, 8), (8, 5, 12),
-        (9, 2, 9), (10, 7, 14), (11, 4, 11), (12, 2, 9),
-    ]
-    for month, first_wed, second_wed in verified:
-        assert _d(f"2026-{month:02d}-{first_wed:02d}").weekday() == 2
-        assert _d(f"2026-{month:02d}-{second_wed:02d}").weekday() == 2
-        assert occurs_on(
-            rule, datetime.date(2026, month, second_wed)
-        ) is True, f"2026-{month:02d}-{second_wed:02d}"
-        assert occurs_on(
-            rule, datetime.date(2026, month, first_wed)
-        ) is False, f"2026-{month:02d}-{first_wed:02d}"
-
-
-def test_third_friday_of_twelve_consecutive_months() -> None:
-    """Independently verified 2026 Fridays; the THIRD fires, the SECOND
-    does not."""
-    rule = ScheduleRule(
-        rule_type=RuleType.MONTHLY_WEEKDAY, nth_weekday=3,
-        nth_weekday_weekday=4,
-        start_date="2026-01-01",
-    )
-    verified = [
-        # (month, first_fri, second_fri, third_fri)
-        (1, 2, 9, 16), (2, 6, 13, 20), (3, 6, 13, 20),
-        (4, 3, 10, 17), (5, 1, 8, 15), (6, 5, 12, 19),
-        (7, 3, 10, 17), (8, 7, 14, 21), (9, 4, 11, 18),
-        (10, 2, 9, 16), (11, 6, 13, 20), (12, 4, 11, 18),
-    ]
-    for month, first_fri, second_fri, third_fri in verified:
-        third = _d(f"2026-{month:02d}-{third_fri:02d}")
-        assert third.weekday() == 4
-        assert occurs_on(rule, third) is True, third
-        second = _d(f"2026-{month:02d}-{second_fri:02d}")
-        assert occurs_on(rule, second) is False, second
-
-
-def test_fourth_wednesday_of_twelve_consecutive_months() -> None:
-    """Independently verified 2026 Wednesdays; the FOURTH fires, the
-    THIRD does not."""
-    rule = ScheduleRule(
-        rule_type=RuleType.MONTHLY_WEEKDAY, nth_weekday=4,
-        nth_weekday_weekday=2,
-        start_date="2026-01-01",
-    )
-    verified = [
-        # (month, third_wed, fourth_wed)
-        (1, 21, 28), (2, 18, 25), (3, 18, 25), (4, 15, 22),
-        (5, 20, 27), (6, 17, 24), (7, 15, 22), (8, 19, 26),
-        (9, 16, 23), (10, 21, 28), (11, 18, 25), (12, 16, 23),
-    ]
-    for month, third_wed, fourth_wed in verified:
-        fourth = _d(f"2026-{month:02d}-{fourth_wed:02d}")
-        assert fourth.weekday() == 2
-        assert occurs_on(rule, fourth) is True, fourth
-        third = _d(f"2026-{month:02d}-{third_wed:02d}")
-        assert not occurs_on(rule, third), third
-
-
-def test_last_monday_of_twelve_consecutive_months() -> None:
-    """Independently verified last Mondays of 2026; each fires, and the
-    PREVIOUS Monday of the same month does not (it is nth-from-last
-    minus one, i.e. the second-to-last)."""
-    rule = ScheduleRule(
-        rule_type=RuleType.MONTHLY_WEEKDAY, nth_weekday=-1,
-        nth_weekday_weekday=0,
-        start_date="2026-01-01",
-    )
-    verified = [
-        # (month, last_monday)
-        (1, 26), (2, 23), (3, 30), (4, 27), (5, 25), (6, 29),
-        (7, 27), (8, 31), (9, 28), (10, 26), (11, 30), (12, 28),
-    ]
-    for month, last_monday in verified:
-        date = _d(f"2026-{month:02d}-{last_monday:02d}")
-        assert date.weekday() == 0
-        assert occurs_on(rule, date) is True, date
-        # The Monday a week earlier is NOT the last: must not fire.
-        week_before = date - datetime.timedelta(days=7)
-        if week_before.month == month:
-            assert occurs_on(rule, week_before) is False, week_before
-
-
-# ---------------------------------------------------------------------------
-# The five-occurrence skip: a 5th on a four-occurrence month
-# ---------------------------------------------------------------------------
-
-
-def test_fifth_weekday_skips_four_occurrence_months() -> None:
-    """Independently verified: 2026 months with FIVE Mondays are March,
-    June, August, November — every other month (four Mondays) must fire
-    on no day at all, and each hit must be the month's FINAL Monday."""
-    rule = ScheduleRule(
-        rule_type=RuleType.MONTHLY_WEEKDAY, nth_weekday=5,
-        nth_weekday_weekday=0,  # fifth Monday
-        start_date="2026-01-01",
-    )
-    five_monday_months = {3: 30, 6: 29, 8: 31, 11: 30}
-    hit_months = set()
-    for month in range(1, 13):
-        if month in five_monday_months:
-            day = five_monday_months[month]
-            hit = _d(f"2026-{month:02d}-{day:02d}")
-            assert hit.weekday() == 0
-            assert occurs_on(rule, hit) is True, hit
-            # It is the FINAL Monday of the month: sweep EVERY remaining
-            # calendar day after the hit — none may fire.
-            for later in range(day + 1, _month_end_days(2026, month) + 1):
-                assert occurs_on(
-                    rule, datetime.date(2026, month, later)
-                ) is False, f"2026-{month:02d}-{later:02d}"
-            # The Monday a week earlier is not the fifth.
-            assert occurs_on(
-                rule, datetime.date(2026, month, day - 7)
-            ) is False
-            hit_months.add(month)
-        else:
-            for day in range(1, _month_end_days(2026, month) + 1):
-                assert occurs_on(
-                    rule, datetime.date(2026, month, day)
-                ) is False, f"2026-{month:02d}-{day:02d}"
-    assert hit_months == {3, 6, 8, 11}, hit_months
-
-
-def _month_end_days(year: int, month: int) -> int:
-    if month == 12:
-        return 31
-    return (datetime.date(year, month + 1, 1)
-            - datetime.timedelta(days=1)).day
-
-
-def test_fifth_weekday_fires_in_five_occurrence_months() -> None:
-    """Independently verified: October 2026 Fridays are 2, 9, 16, 23, 30
-    (five) — the 5th (and last) is the 30th; April 2026 has four Fridays
-    (3, 10, 17, 24) so no day in April fires."""
-    rule = ScheduleRule(
-        rule_type=RuleType.MONTHLY_WEEKDAY, nth_weekday=5,
-        nth_weekday_weekday=4,  # Fridays
-        start_date="2026-01-01",
-    )
-    # October: the 30th fires, is a Friday, and no Monday-later day
-    # (the 31st) is a Friday: the 30th is the FINAL Friday.
-    oct_30 = datetime.date(2026, 10, 30)
-    assert oct_30.weekday() == 4
-    assert occurs_on(rule, oct_30) is True
-    assert occurs_on(rule, datetime.date(2026, 10, 31)) is False
-    # April: no Friday-5th, so no day fires.
-    for day in range(1, _month_end_days(2026, 4) + 1):
-        assert occurs_on(rule, datetime.date(2026, 4, day)) is False, (
-            f"2026-04-{day:02d}"
-        )
-
-
-# ---------------------------------------------------------------------------
-# Interval arithmetic
-# ---------------------------------------------------------------------------
-
-
-def test_monthly_weekday_interval_2() -> None:
-    rule = ScheduleRule(
-        rule_type=RuleType.MONTHLY_WEEKDAY, nth_weekday=2,
-        nth_weekday_weekday=2, interval=2, start_date="2026-01-01",
-    )
-    # Jan (m0) fires on the 2nd Tuesday; Feb (m1) skipped; Mar (m2) fires.
-    jan_second = _nth_weekday_of_month(2026, 1, 2, 2)
-    assert occurs_on(rule, datetime.date(2026, 1, jan_second)) is True
-    feb_second = _nth_weekday_of_month(2026, 2, 2, 2)
-    assert occurs_on(rule, datetime.date(2026, 2, feb_second)) is False
-    mar_second = _nth_weekday_of_month(2026, 3, 2, 2)
-    assert occurs_on(rule, datetime.date(2026, 3, mar_second)) is True
-
-
-def test_monthly_weekday_interval_across_year_boundary() -> None:
-    rule = ScheduleRule(
-        rule_type=RuleType.MONTHLY_WEEKDAY, nth_weekday=1,
-        nth_weekday_weekday=2, interval=3, start_date="2026-11-01",
-    )
-    # Nov (m0) fires; Dec (m1), Jan (m2) skip; Feb (m3) fires.
-    nov_first = _nth_weekday_of_month(2026, 11, 2, 1)
-    assert occurs_on(rule, datetime.date(2026, 11, nov_first)) is True
-    dec_first = _nth_weekday_of_month(2026, 12, 2, 1)
-    assert occurs_on(rule, datetime.date(2026, 12, dec_first)) is False
-    jan_first = _nth_weekday_of_month(2027, 1, 2, 1)
-    assert occurs_on(rule, datetime.date(2027, 1, jan_first)) is False
-    feb_first = _nth_weekday_of_month(2027, 2, 2, 1)
-    assert occurs_on(rule, datetime.date(2027, 2, feb_first)) is True
-
-
-# ---------------------------------------------------------------------------
-# occurrences_between
-# ---------------------------------------------------------------------------
-
-
-def test_monthly_weekday_occurrences_between_span() -> None:
-    rule = ScheduleRule(
-        rule_type=RuleType.MONTHLY_WEEKDAY, nth_weekday=2,
-        nth_weekday_weekday=4,  # second Friday
-        start_date="2026-01-01", end_date="2026-04-30",
-    )
-    result = occurrences_between(rule, "2026-01-01", "2026-04-30")
-    # Independently verified second Fridays: Jan 9 (Jan 1 Thu), Feb 13
-    # (Feb 1 Sun), Mar 13 (Mar 1 Sun), Apr 10 (Apr 1 Wed).
-    assert result == [
-        "2026-01-09", "2026-02-13", "2026-03-13", "2026-04-10",
-    ]
-
-
-def test_monthly_weekday_occurrences_between_rejects_inverted() -> None:
-    rule = ScheduleRule(
-        rule_type=RuleType.MONTHLY_WEEKDAY, nth_weekday=1,
-        nth_weekday_weekday=1, start_date="2026-01-01",
-    )
-    with pytest.raises(RuleValidationError, match="on or after"):
-        occurrences_between(rule, "2026-06-01", "2026-01-01")

tests/test_recurrence_property.py

@@ -1,241 +0,0 @@
-"""Consistency property tests for occurrences_between vs occurs_on.
-
-The done-condition: occurrences_between returns an ordered, duplicate-
-free list of dates that agrees EXACTLY with calling occurs_on on every
-date in the range.  This module proves that agreement two ways:
-
-1. An exhaustive sweep over a fixed grid of rules (every rule type ×
-   several intervals × several windows) cross-checked date by date.
-
-2. A randomized property test (seeded, deterministic) over randomly
-   generated rules and ranges asserting the two functions never
-   disagree.  Seeds are fixed so failures are reproducible.
-"""
-from __future__ import annotations
-
-import datetime
-import random
-
-import pytest
-
-from custom_components.nestquest.recurrence import (
-    RuleType,
-    RuleValidationError,
-    ScheduleRule,
-    occurs_on,
-    occurrences_between,
-)
-
-
-def _d(date: str) -> datetime.date:
-    return datetime.date.fromisoformat(date)
-
-
-def _check_consistency(
-    rule: ScheduleRule, start: str, end: str
-) -> list[str]:
-    """Cross-check occurrences_between against per-date occurs_on.
-
-    Returns the occurrences_between result after asserting, for every
-    date in [start, end]: occurs_on(date) is True iff the date appears
-    in the result.  Also asserts the list is ordered and duplicate-free.
-    """
-    result = occurrences_between(rule, start, end)
-    # Ordered and duplicate-free.
-    assert result == sorted(set(result)), (
-        f"occurrences_between must be ordered, duplicate-free: {result}"
-    )
-    # Exact agreement with occurs_on over every date in the range.
-    cursor = _d(start)
-    end_date = _d(end)
-    expected: list[str] = []
-    while cursor <= end_date:
-        if occurs_on(rule, cursor):
-            expected.append(cursor.isoformat())
-        cursor += datetime.timedelta(days=1)
-    assert result == expected, (
-        f"disagreement for {rule.to_dict()} over [{start}, {end}]:\n"
-        f"  occurrences_between: {result}\n"
-        f"  per-date occurs_on:  {expected}"
-    )
-    return result
-
-
-# ---------------------------------------------------------------------------
-# Exhaustive grid over rule shapes, intervals and windows
-# ---------------------------------------------------------------------------
-
-
-_GRID_RULES = [
-    ScheduleRule(rule_type=RuleType.DAILY, start_date="2026-03-01"),
-    ScheduleRule(rule_type=RuleType.DAILY, interval=2,
-                 start_date="2026-03-01"),
-    ScheduleRule(rule_type=RuleType.DAILY, interval=3,
-                 start_date="2026-03-15", end_date="2027-01-31"),
-    ScheduleRule(rule_type=RuleType.WEEKLY, weekday_set={0, 2, 4},
-                 start_date="2026-03-03"),
-    ScheduleRule(rule_type=RuleType.WEEKLY, weekday_set={1, 3, 5},
-                 interval=2, start_date="2026-03-06",
-                 end_date="2027-06-30"),
-    ScheduleRule(rule_type=RuleType.CUSTOM_DAYS, weekday_set={1, 4},
-                 start_date="2026-03-06"),
-    ScheduleRule(rule_type=RuleType.MONTHLY_DAY, day_of_month=31,
-                 start_date="2026-03-31"),
-    ScheduleRule(rule_type=RuleType.MONTHLY_DAY, day_of_month=29,
-                 interval=2, start_date="2026-01-29"),
-    ScheduleRule(rule_type=RuleType.MONTHLY_WEEKDAY, nth_weekday=2,
-                 nth_weekday_weekday=1, start_date="2026-03-03"),
-    ScheduleRule(rule_type=RuleType.MONTHLY_WEEKDAY, nth_weekday=-1,
-                 nth_weekday_weekday=4, start_date="2026-03-06",
-                 end_date="2028-12-31"),
-    ScheduleRule(rule_type=RuleType.YEARLY, month=2, day_of_month=29,
-                 start_date="2026-02-28"),
-    ScheduleRule(rule_type=RuleType.YEARLY, month=6, day_of_month=15,
-                 interval=2, start_date="2026-06-15"),
-]
-
-_GRID_WINDOWS = [
-    ("2026-01-01", "2026-03-31"),   # mostly before start
-    ("2026-03-01", "2026-03-01"),   # single day == anchor
-    ("2026-03-01", "2026-03-31"),   # within window
-    ("2026-08-01", "2026-08-31"),   # mid-window month
-    ("2026-12-01", "2027-01-31"),   # year boundary
-    ("2028-01-01", "2028-03-01"),   # leap year span
-    ("2029-01-01", "2029-12-31"),   # far out
-]
-
-
-@pytest.mark.parametrize(
-    "rule_index,window_index",
-    [
-        (rule_index, window_index)
-        for rule_index in range(len(_GRID_RULES))
-        for window_index in range(len(_GRID_WINDOWS))
-    ],
-)
-def test_grid_occurrences_between_matches_occurs_on(
-    rule_index, window_index
-) -> None:
-    rule = _GRID_RULES[rule_index]
-    window = _GRID_WINDOWS[window_index]
-    _check_consistency(rule, window[0], window[1])
-
-
-# ---------------------------------------------------------------------------
-# Randomized property test (seeded, deterministic)
-# ---------------------------------------------------------------------------
-
-
-def _generate_random_rules(rng: random.Random, count: int) -> list[ScheduleRule]:
-    """Random but valid rules: shapes, intervals, anchors, windows.
-
-    Any random combo the model rejects (genuinely invalid combinations)
-    is skipped — the property only needs VALID rules; the assertion at
-    the end bounds how many may be rejected.
-    """
-    rules: list[ScheduleRule] = []
-    shapes = list(RuleType)
-    for index in range(count):
-        shape = shapes[rng.randrange(len(shapes))]
-        interval = rng.choice([1, 2, 3, 7])
-        anchor = datetime.date(
-            rng.choice([2024, 2025, 2026, 2027, 2028]),
-            rng.randrange(1, 13),
-            rng.randrange(1, 28),
-        )
-        end_offset = rng.choice([45, 120, 400, 800])
-        end = anchor + datetime.timedelta(days=end_offset)
-        common = {
-            "rule_type": shape,
-            "interval": interval,
-            "start_date": anchor.isoformat(),
-            "end_date": end.isoformat(),
-        }
-        try:
-            if shape is RuleType.WEEKLY:
-                rules.append(ScheduleRule(
-                    **common,
-                    weekday_set={
-                        rng.randrange(7)
-                        for _ in range(rng.randrange(1, 4))
-                    },
-                ))
-            elif shape is RuleType.CUSTOM_DAYS:
-                rules.append(ScheduleRule(
-                    **common,
-                    weekday_set={
-                        rng.randrange(7)
-                        for _ in range(rng.randrange(1, 4))
-                    },
-                ))
-            elif shape is RuleType.MONTHLY_DAY:
-                rules.append(ScheduleRule(
-                    **common, day_of_month=rng.randrange(1, 32)
-                ))
-            elif shape is RuleType.MONTHLY_WEEKDAY:
-                rules.append(ScheduleRule(
-                    **common,
-                    nth_weekday=rng.choice([-1, 1, 2, 3, 4, 5]),
-                    nth_weekday_weekday=rng.randrange(7),
-                ))
-            elif shape is RuleType.YEARLY:
-                rules.append(ScheduleRule(
-                    **common,
-                    month=rng.randrange(1, 13),
-                    day_of_month=rng.choice([None, rng.randrange(1, 29)]),
-                ))
-            else:  # DAILY
-                rules.append(ScheduleRule(**common))
-        except RuleValidationError:
-            continue
-    assert len(rules) >= count * 3 // 4, "too many random rules rejected"
-    return rules
-
-
-def test_random_rules_never_disagree_between_the_two_functions() -> None:
-    """The property: for randomly generated rules and ranges,
-    occurrences_between(rule, s, e) == [d for d in s..e if occurs_on]."""
-    rng = random.Random(0xFEA7)  # fixed seed for reproducibility
-    rules = _generate_random_rules(rng, count=40)
-    checked = 0
-    for rule in rules:
-        anchor = datetime.date.fromisoformat(rule.start_date)
-        for offset_days, span_days in ((-30, 60), (0, 14), (10, 90),
-                                       (100, 200)):
-            range_start = anchor + datetime.timedelta(days=offset_days)
-            range_end = range_start + datetime.timedelta(days=span_days)
-            _check_consistency(
-                rule, range_start.isoformat(), range_end.isoformat()
-            )
-            checked += 1
-    assert checked >= 40 * 4 * 3 // 4, checked
-
-
-def test_random_ranges_include_year_and_leap_spans() -> None:
-    """Every rule is probed across a range that spans Jan 1 (twice) and
-    a February 29 — the Dec 1..Mar 1 two-year span always covers both."""
-    rng = random.Random(42)
-    rules = _generate_random_rules(rng, count=12)
-    for rule in rules:
-        anchor = datetime.date.fromisoformat(rule.start_date)
-        probe_start = datetime.date(anchor.year, 12, 1)
-        probe_end = datetime.date(anchor.year + 2, 3, 1)
-        # The span always contains two Jan 1s and a Feb 28/29 pair.
-        assert probe_end >= probe_start
-        _check_consistency(
-            rule, probe_start.isoformat(), probe_end.isoformat()
-        )
-        # An additional probe pinned ON a Feb 29 window (2028 leap):
-        # every rule is cross-checked over Feb 1 - Mar 15 2028.
-        _check_consistency(rule, "2028-02-01", "2028-03-15")
-
-
-def test_occurrences_between_single_day_range_matches_occurs_on() -> None:
-    """A one-day range is the exact occurs_on of that date."""
-    for rule in _GRID_RULES:
-        for day in ("2026-03-05", "2026-03-15", "2027-06-15"):
-            single = occurrences_between(rule, day, day)
-            if occurs_on(rule, _d(day)):
-                assert single == [day], (rule.to_dict(), day, single)
-            else:
-                assert single == [], (rule.to_dict(), day, single)

tests/test_recurrence_weekly.py

@@ -1,299 +0,0 @@
-"""Tests for weekly and custom day-set recurrence evaluation."""
-from __future__ import annotations
-
-import datetime
-
-import pytest
-
-from custom_components.nestquest.recurrence import (
-    RuleType,
-    RuleValidationError,
-    ScheduleRule,
-    occurs_on,
-    occurrences_between,
-)
-
-
-def _d(date: str) -> datetime.date:
-    return datetime.date.fromisoformat(date)
-
-
-# 2026-09-01 is a TUESDAY (weekday 1).
-# Anchor-week arithmetic (start_date = Tue Sep 1): week 0 spans
-# Sep 1-7, week 1 spans Sep 8-14, week 2 spans Sep 15-21, and so on —
-# whole weeks elapsed from the anchor, NOT calendar-Sunday weeks.
-# A weekly Mon/Wed/Fri (0,2,4) rule at interval 1 anchored here fires
-# on Wed Sep 2, Fri Sep 4 (both week 0), then Mon Sep 7, Wed Sep 9,
-# Fri Sep 11 (week 1), Mon Sep 14... (week 2), and so on.
-
-
-def test_weekly_fires_exactly_on_set_weekdays() -> None:
-    rule = ScheduleRule(
-        rule_type=RuleType.WEEKLY, weekday_set={0, 2, 4},
-        start_date="2026-09-01",
-    )
-    # Sep 2026: 1=Tue(1), 2=Wed(2), 4=Fri(4), 7=Mon(0), 8=Tue(1), 9=Wed,
-    # 10=Thu(3), 11=Fri(4)
-    assert occurs_on(rule, _d("2026-09-01")) is False  # Tue NOT in set
-    assert occurs_on(rule, _d("2026-09-02")) is True   # Wed in set
-    assert occurs_on(rule, _d("2026-09-03")) is False  # Thu not in set
-    assert occurs_on(rule, _d("2026-09-04")) is True   # Fri in set
-    assert occurs_on(rule, _d("2026-09-05")) is False  # Sat
-    assert occurs_on(rule, _d("2026-09-06")) is False  # Sun
-    assert occurs_on(rule, _d("2026-09-07")) is True   # Mon
-    assert occurs_on(rule, _d("2026-09-08")) is False  # Tue not in set
-
-
-def test_weekly_start_date_itself_may_not_be_in_set() -> None:
-    """start_date anchors the WEEK count, not a firing day: a Tuesday
-    start for a Mon/Wed/Fri rule fires on Wed Sep 2, not Sep 1."""
-    rule = ScheduleRule(
-        rule_type=RuleType.WEEKLY, weekday_set={0, 2, 4},
-        start_date="2026-09-01",
-    )
-    assert occurs_on(rule, _d("2026-09-01")) is False  # Tue=1, not in set
-    assert occurs_on(rule, _d("2026-09-02")) is True   # Wed=2
-    assert occurs_on(rule, _d("2026-09-04")) is True   # Fri=4
-    assert occurs_on(rule, _d("2026-09-07")) is True   # Mon, next week
-
-
-def test_weekly_never_fires_before_start() -> None:
-    rule = ScheduleRule(
-        rule_type=RuleType.WEEKLY, weekday_set={2},  # Wednesdays
-        start_date="2026-09-02",  # a Wednesday
-    )
-    # Wed Sep 2 is the anchor day and in-set: fires.  Wed Aug 26 (one
-    # week BEFORE the anchor, in-set) must not fire: pre-window.
-    assert occurs_on(rule, _d("2026-09-02")) is True
-    assert occurs_on(rule, _d("2026-08-26")) is False  # Wed, before start
-    assert occurs_on(rule, _d("2026-09-09")) is True   # Wed, next week
-
-
-def test_weekly_respects_end_date() -> None:
-    rule = ScheduleRule(
-        rule_type=RuleType.WEEKLY, weekday_set={0, 2, 4},
-        start_date="2026-09-01", end_date="2026-09-10",
-    )
-    assert occurs_on(rule, _d("2026-09-09")) is True   # Wed within end
-    assert occurs_on(rule, _d("2026-09-11")) is False  # Fri after end
-
-
-def test_weekly_interval_2_fires_on_alternate_weeks() -> None:
-    """Interval 2: fires on set weekdays only in even week-offsets."""
-    rule = ScheduleRule(
-        rule_type=RuleType.WEEKLY, weekday_set={0}, interval=2,
-        start_date="2026-09-07",  # a Monday
-    )
-    # Week 0 (Sep 7-13): fires Mon Sep 7.
-    assert occurs_on(rule, _d("2026-09-07")) is True
-    # Week 1 (Sep 14-20): skipped.
-    assert occurs_on(rule, _d("2026-09-14")) is False
-    # Week 2 (Sep 21-27): fires Mon Sep 21.
-    assert occurs_on(rule, _d("2026-09-21")) is True
-    # Week 3 (Sep 28-Oct 4): skipped; Mon Sep 28 does not fire.
-    assert occurs_on(rule, _d("2026-09-28")) is False
-    # Week 4 (Oct 5-11): fires Mon Oct 5.
-    assert occurs_on(rule, _d("2026-10-05")) is True
-
-
-def test_weekly_interval_3_every_third_week() -> None:
-    rule = ScheduleRule(
-        rule_type=RuleType.WEEKLY, weekday_set={3}, interval=3,
-        start_date="2026-09-03",  # a Thursday
-    )
-    assert occurs_on(rule, _d("2026-09-03")) is True   # week 0
-    assert occurs_on(rule, _d("2026-09-10")) is False  # week 1
-    assert occurs_on(rule, _d("2026-09-17")) is False  # week 2
-    assert occurs_on(rule, _d("2026-09-24")) is True   # week 3
-    assert occurs_on(rule, _d("2026-10-15")) is True   # week 6
-
-
-def test_weekly_interval_2_never_fires_in_odd_weeks_across_months() -> None:
-    """The week offset is anchored to start_date across month edges."""
-    rule = ScheduleRule(
-        rule_type=RuleType.WEEKLY, weekday_set={2}, interval=2,
-        start_date="2026-09-02",  # a Wednesday
-    )
-    # Week 0: Wed Sep 2 fires. Week 1: Wed Sep 9 skipped.
-    # Week 2: Wed Sep 16 fires. Week 3: Wed Sep 23 skipped.
-    # Week 4 (Oct): Wed Sep 30 fires (still week 4!). Week 5: Wed Oct 7 skipped.
-    assert occurs_on(rule, _d("2026-09-02")) is True
-    assert occurs_on(rule, _d("2026-09-09")) is False
-    assert occurs_on(rule, _d("2026-09-16")) is True
-    assert occurs_on(rule, _d("2026-09-23")) is False
-    assert occurs_on(rule, _d("2026-09-30")) is True
-    assert occurs_on(rule, _d("2026-10-07")) is False
-    assert occurs_on(rule, _d("2026-10-14")) is True
-
-
-def test_custom_days_interval_1_behaves_like_weekly() -> None:
-    """CUSTOM_DAYS with interval 1 behaves identically to WEEKLY."""
-    weekly = ScheduleRule(
-        rule_type=RuleType.WEEKLY, weekday_set={1, 3, 5},
-        start_date="2026-09-01",
-    )
-    custom = ScheduleRule(
-        rule_type=RuleType.CUSTOM_DAYS, weekday_set={1, 3, 5},
-        start_date="2026-09-01",
-    )
-    # Whole month of September must match exactly.
-    for day in range(1, 31):
-        date = datetime.date(2026, 9, day)
-        assert occurs_on(weekly, date) == occurs_on(custom, date), date
-
-
-def test_custom_days_never_fires_before_start(tmp_path) -> None:
-    rule = ScheduleRule(
-        rule_type=RuleType.CUSTOM_DAYS, weekday_set={0},
-        start_date="2026-09-07",  # a Monday
-    )
-    assert occurs_on(rule, _d("2026-09-06")) is False  # Sun, before
-    assert occurs_on(rule, _d("2026-09-07")) is True   # Mon, on
-
-
-def test_hand_checked_8_week_sequence_weekly_mon_wed_fri() -> None:
-    """The done-condition's hand-checked sequence: 8 weeks of a
-    Mon/Wed/Fri rule anchored at Tue 2026-09-01, interval 1.
-
-    Anchor weeks from Tue Sep 1 (week 0 = Sep 1-7, week 1 = Sep 8-14,
-    ... week 7 = Oct 20-26).  Mon/Wed/Fri firings (interval 1, so every
-    in-set weekday fires regardless of week):
-    Week 0 (Sep 1-7):   Wed 2, Fri 4        (Mon Sep 7 is ALSO week 0:
-                        6 elapsed days // 7 = 0 — the anchor week
-                        boundary sits on Sep 8, not on the Monday)
-    Week 1 (Sep 8-14):  Wed 9, Fri 11, Mon 14 (13 elapsed days // 7 = 1)
-    Week 2 (Sep 15-21): Wed 16, Fri 18, Mon 21
-    Week 3 (Sep 22-28): Wed 23, Fri 25, Mon 28
-    Week 4 (Sep 29-Oct 5): Wed 30, Fri 2 (Oct), Mon 5 (Oct)
-    Week 5 (Oct 6-12):  Wed 7, Fri 9, Mon 12
-    Week 6 (Oct 13-19): Wed 14, Fri 16, Mon 19
-    Week 7 (Oct 20-26): Wed 21, Fri 23, Mon 26
-    """
-    rule = ScheduleRule(
-        rule_type=RuleType.WEEKLY, weekday_set={0, 2, 4},
-        start_date="2026-09-01", end_date="2026-10-26",
-    )
-    expected = [
-        "2026-09-02", "2026-09-04",
-        "2026-09-07", "2026-09-09", "2026-09-11",
-        "2026-09-14", "2026-09-16", "2026-09-18",
-        "2026-09-21", "2026-09-23", "2026-09-25",
-        "2026-09-28", "2026-09-30", "2026-10-02",
-        "2026-10-05", "2026-10-07", "2026-10-09",
-        "2026-10-12", "2026-10-14", "2026-10-16",
-        "2026-10-19", "2026-10-21", "2026-10-23", "2026-10-26",
-    ]
-    actual = occurrences_between(rule, "2026-09-01", "2026-10-26")
-    assert actual == expected, (
-        f"diff: {set(expected) ^ set(actual)}"
-    )
-
-
-def test_hand_checked_8_week_sequence_weekly_interval_2_mondays() -> None:
-    """8 weeks of a Monday rule at interval 2, anchored Mon 2026-09-07
-    (week 0 = Sep 7-13): fires in weeks 0, 2, 4, 6 -> Mon Sep 7, Mon Sep 21,
-    Mon Oct 5, Mon Oct 19."""
-    rule = ScheduleRule(
-        rule_type=RuleType.WEEKLY, weekday_set={0}, interval=2,
-        start_date="2026-09-07", end_date="2026-10-31",
-    )
-    actual = occurrences_between(rule, "2026-09-07", "2026-10-31")
-    assert actual == ["2026-09-07", "2026-09-21", "2026-10-05", "2026-10-19"]
-
-
-def test_custom_days_hand_checked_8_week_sequence() -> None:
-    """8 weeks of a Tue/Thu/Sun rule (1,3,6) anchored Mon 2026-09-07:
-    fires Tue 8, Thu 10, Sun 13, then weekly."""
-    rule = ScheduleRule(
-        rule_type=RuleType.CUSTOM_DAYS, weekday_set={1, 3, 6},
-        start_date="2026-09-07",
-    )
-    # Anchor weeks from Mon Sep 7 (w0 = Sep 7-13 ... w7 = Oct 26-Nov 1):
-    # Tue/Thu/Sun firings per week, 8 weeks fully covered.
-    actual = occurrences_between(rule, "2026-09-07", "2026-11-01")
-    assert actual == [
-        "2026-09-08", "2026-09-10", "2026-09-13",
-        "2026-09-15", "2026-09-17", "2026-09-20",
-        "2026-09-22", "2026-09-24", "2026-09-27",
-        "2026-09-29", "2026-10-01", "2026-10-04",
-        "2026-10-06", "2026-10-08", "2026-10-11",
-        "2026-10-13", "2026-10-15", "2026-10-18",
-        "2026-10-20", "2026-10-22", "2026-10-25",
-        "2026-10-27", "2026-10-29", "2026-11-01",
-    ]
-
-
-def test_weekly_survives_53_week_year_boundary() -> None:
-    """Anchor arithmetic never flips at Jan 1 (the ISO parity trap):
-    a weekly rule spanning New Year keeps its weekday pattern."""
-    rule = ScheduleRule(
-        rule_type=RuleType.WEEKLY, weekday_set={3},  # Thursdays
-        start_date="2026-12-24",  # a Thursday
-    )
-    # Thursdays around New Year 2026->2027: Dec 24, 31, Jan 7, 14.
-    assert occurs_on(rule, _d("2026-12-24")) is True
-    assert occurs_on(rule, _d("2026-12-31")) is True
-    assert occurs_on(rule, _d("2027-01-07")) is True
-    assert occurs_on(rule, _d("2027-01-14")) is True
-    # Interleaved days are not Thursdays.
-    assert occurs_on(rule, _d("2027-01-04")) is False  # Monday
-    assert occurs_on(rule, _d("2027-01-05")) is False  # Tuesday
-
-
-def test_weekly_interval_2_across_year_boundary() -> None:
-    """Interval weeks continue across Jan 1 with no parity flip."""
-    rule = ScheduleRule(
-        rule_type=RuleType.WEEKLY, weekday_set={4}, interval=2,
-        start_date="2026-12-25",  # a Friday
-    )
-    # Weeks: Dec 25 (w0) fires, Jan 1 (w1) skipped, Jan 8 (w2) fires,
-    # Jan 15 (w3) skipped, Jan 22 (w4) fires.
-    assert occurs_on(rule, _d("2026-12-25")) is True
-    assert occurs_on(rule, _d("2027-01-01")) is False
-    assert occurs_on(rule, _d("2027-01-08")) is True
-    assert occurs_on(rule, _d("2027-01-15")) is False
-    assert occurs_on(rule, _d("2027-01-22")) is True
-
-
-def test_occurrences_between_weekly_disjoint(tmp_path) -> None:
-    rule = ScheduleRule(
-        rule_type=RuleType.WEEKLY, weekday_set={1},
-        start_date="2026-09-01", end_date="2026-09-30",
-    )
-    assert occurrences_between(rule, "2026-10-01", "2026-10-31") == []
-
-
-def test_occurrences_between_weekly_interval_2_span() -> None:
-    rule = ScheduleRule(
-        rule_type=RuleType.WEEKLY, weekday_set={0}, interval=2,
-        start_date="2026-09-07", end_date="2026-10-31",
-    )
-    result = occurrences_between(rule, "2026-09-01", "2026-10-31")
-    assert result == ["2026-09-07", "2026-09-21", "2026-10-05", "2026-10-19"]
-
-
-def test_occurrences_between_rejects_inverted_bounds() -> None:
-    rule = ScheduleRule(
-        rule_type=RuleType.WEEKLY, weekday_set={0}, start_date="2026-09-01"
-    )
-    with pytest.raises(RuleValidationError, match="on or after"):
-        occurrences_between(rule, "2026-10-10", "2026-09-01")
-
-def test_weekly_interval_2_non_monday_anchor_boundary() -> None:
-    """The anchor week is anchored at start_date, NOT a calendar week:
-    a Tuesday-anchored Monday rule fires on Mon Sep 7 (week 0 extends
-    through Sep 7), skips Mon Sep 14 (week 1), fires Mon Sep 21 (week 2)."""
-    rule = ScheduleRule(
-        rule_type=RuleType.WEEKLY, weekday_set={0}, interval=2,
-        start_date="2026-09-01",  # a TUESDAY anchor
-    )
-    # Sep 7 - Sep 1 = 6 days -> week 0 (even): fires.
-    assert occurs_on(rule, _d("2026-09-07")) is True
-    # Sep 14: 13 days -> week 1 (odd): skipped.
-    assert occurs_on(rule, _d("2026-09-14")) is False
-    # Sep 21: 20 days -> week 2 (even): fires.
-    assert occurs_on(rule, _d("2026-09-21")) is True
-    # Sep 28: 27 days -> week 3 (odd): skipped.
-    assert occurs_on(rule, _d("2026-09-28")) is False
-    # Oct 5: 34 days -> week 4 (even): fires.
-    assert occurs_on(rule, _d("2026-10-05")) is True

tests/test_recurrence_yearly.py

@@ -1,233 +0,0 @@
-"""Tests for YEARLY recurrence with the leap-day clamp policy."""
-from __future__ import annotations
-
-import datetime
-
-import pytest
-
-from custom_components.nestquest.recurrence import (
-    RuleType,
-    RuleValidationError,
-    ScheduleRule,
-    occurs_on,
-    occurrences_between,
-)
-
-
-def _d(date: str) -> datetime.date:
-    return datetime.date.fromisoformat(date)
-
-
-# ---------------------------------------------------------------------------
-# Nominal-day firings across four consecutive years (incl. leap 2028)
-# ---------------------------------------------------------------------------
-
-
-def test_yearly_june_15_four_consecutive_years() -> None:
-    rule = ScheduleRule(
-        rule_type=RuleType.YEARLY, month=6, day_of_month=15,
-        start_date="2026-06-15",
-    )
-    for year in (2026, 2027, 2028, 2029):
-        assert occurs_on(rule, datetime.date(year, 6, 15)) is True, year
-    assert occurs_on(rule, datetime.date(2026, 6, 14)) is False
-    assert occurs_on(rule, datetime.date(2026, 6, 16)) is False
-    assert occurs_on(rule, datetime.date(2026, 5, 15)) is False
-    assert occurs_on(rule, datetime.date(2026, 7, 15)) is False
-
-
-def test_yearly_feb_15_across_four_years() -> None:
-    rule = ScheduleRule(
-        rule_type=RuleType.YEARLY, month=2, day_of_month=15,
-        start_date="2026-02-15",
-    )
-    # Feb 15 exists every year; the leap day is irrelevant.
-    for year in (2026, 2027, 2028, 2029):
-        assert occurs_on(rule, datetime.date(year, 2, 15)) is True, year
-
-
-def test_yearly_never_fires_before_start() -> None:
-    rule = ScheduleRule(
-        rule_type=RuleType.YEARLY, month=6, day_of_month=15,
-        start_date="2027-06-15",
-    )
-    assert occurs_on(rule, datetime.date(2026, 6, 15)) is False
-    assert occurs_on(rule, datetime.date(2027, 6, 15)) is True
-
-
-def test_yearly_respects_end_date() -> None:
-    rule = ScheduleRule(
-        rule_type=RuleType.YEARLY, month=6, day_of_month=15,
-        start_date="2026-06-15", end_date="2028-06-15",
-    )
-    assert occurs_on(rule, datetime.date(2028, 6, 15)) is True
-    assert occurs_on(rule, datetime.date(2029, 6, 15)) is False
-
-
-# ---------------------------------------------------------------------------
-# Leap-day policy: Feb 29 rule fires Feb 28 in non-leap years
-# ---------------------------------------------------------------------------
-
-
-def test_yearly_feb_29_clamps_to_feb_28_non_leap() -> None:
-    rule = ScheduleRule(
-        rule_type=RuleType.YEARLY, month=2, day_of_month=29,
-        start_date="2026-02-28",
-    )
-    # 2026 non-leap: no Feb 29 — the clamp fires Feb 28.
-    assert occurs_on(rule, datetime.date(2026, 2, 28)) is True
-    assert occurs_on(rule, datetime.date(2026, 2, 27)) is False
-    # 2027 non-leap: same clamp.
-    assert occurs_on(rule, datetime.date(2027, 2, 28)) is True
-
-
-def test_yearly_feb_29_fires_feb_29_in_leap_years() -> None:
-    rule = ScheduleRule(
-        rule_type=RuleType.YEARLY, month=2, day_of_month=29,
-        start_date="2026-02-28",
-    )
-    # 2028 leap: Feb 29 exists — nominal day.
-    assert occurs_on(rule, datetime.date(2028, 2, 29)) is True
-    assert occurs_on(rule, datetime.date(2028, 2, 28)) is False
-
-
-def test_yearly_feb_29_four_consecutive_years() -> None:
-    """The done-condition's four-year sweep: 2026 (clamp 28), 2027
-    (clamp 28), 2028 (leap: nominal 29), 2029 (clamp 28)."""
-    rule = ScheduleRule(
-        rule_type=RuleType.YEARLY, month=2, day_of_month=29,
-        start_date="2026-02-28",
-    )
-    assert occurs_on(rule, datetime.date(2026, 2, 28)) is True
-    assert occurs_on(rule, datetime.date(2027, 2, 28)) is True
-    assert occurs_on(rule, datetime.date(2028, 2, 29)) is True
-    assert occurs_on(rule, datetime.date(2029, 2, 28)) is True
-    # No other day in those Februaries fires.
-    for year, non_firing in (
-        (2026, (27,)), (2027, (26, 27)), (2028, (27,)),
-        (2029, (26, 27)),
-    ):
-        for day in non_firing:
-            assert occurs_on(rule, datetime.date(year, 2, day)) is False
-
-
-def test_yearly_feb_30_is_impossible_by_model() -> None:
-    """The model rejects day_of_month 30+ for February? No — 30/31 are
-    accepted (1..31) and clamp to the month end like MONTHLY_DAY."""
-    rule = ScheduleRule(
-        rule_type=RuleType.YEARLY, month=2, day_of_month=30,
-        start_date="2027-02-28",
-    )
-    # Non-leap 2027: Feb 28 is the month end — the clamp fires it.
-    assert occurs_on(rule, datetime.date(2027, 2, 28)) is True
-    # Leap 2028: Feb 29 is the month end — clamps there.
-    assert occurs_on(rule, datetime.date(2028, 2, 29)) is True
-    assert occurs_on(rule, datetime.date(2028, 2, 28)) is False
-
-
-# ---------------------------------------------------------------------------
-# Day-less YEARLY rules fire on the first of the month
-# ---------------------------------------------------------------------------
-
-
-def test_yearly_without_day_fires_on_first_of_month() -> None:
-    rule = ScheduleRule(
-        rule_type=RuleType.YEARLY, month=6, start_date="2026-01-01",
-    )
-    assert occurs_on(rule, datetime.date(2026, 6, 1)) is True
-    assert occurs_on(rule, datetime.date(2026, 6, 2)) is False
-    assert occurs_on(rule, datetime.date(2026, 5, 1)) is False
-    assert occurs_on(rule, datetime.date(2027, 6, 1)) is True
-
-
-# ---------------------------------------------------------------------------
-# Interval: every N years
-# ---------------------------------------------------------------------------
-
-
-def test_yearly_interval_2_every_second_year() -> None:
-    rule = ScheduleRule(
-        rule_type=RuleType.YEARLY, month=6, day_of_month=15, interval=2,
-        start_date="2026-06-15",
-    )
-    assert occurs_on(rule, datetime.date(2026, 6, 15)) is True   # y0
-    assert occurs_on(rule, datetime.date(2027, 6, 15)) is False  # y1
-    assert occurs_on(rule, datetime.date(2028, 6, 15)) is True   # y2
-    assert occurs_on(rule, datetime.date(2029, 6, 15)) is False  # y3
-    assert occurs_on(rule, datetime.date(2030, 6, 15)) is True   # y4
-
-
-def test_yearly_interval_2_leap_day_every_second_year() -> None:
-    """A Feb 29 rule at interval 2 anchored 2026 fires in even years:
-    2026 clamps (Feb 28), 2027 skips, 2028 hits the nominal Feb 29."""
-    rule = ScheduleRule(
-        rule_type=RuleType.YEARLY, month=2, day_of_month=29, interval=2,
-        start_date="2026-02-28",
-    )
-    assert occurs_on(rule, datetime.date(2026, 2, 28)) is True   # y0 clamp
-    assert occurs_on(rule, datetime.date(2027, 2, 28)) is False  # y1
-    assert occurs_on(rule, datetime.date(2028, 2, 29)) is True   # y2 nominal
-    assert occurs_on(rule, datetime.date(2029, 2, 28)) is False  # y3
-    assert occurs_on(rule, datetime.date(2030, 2, 28)) is True   # y4 clamp
-
-
-def test_yearly_interval_3_across_start_year() -> None:
-    rule = ScheduleRule(
-        rule_type=RuleType.YEARLY, month=3, day_of_month=10, interval=3,
-        start_date="2026-03-10",
-    )
-    assert occurs_on(rule, datetime.date(2026, 3, 10)) is True
-    assert occurs_on(rule, datetime.date(2027, 3, 10)) is False
-    assert occurs_on(rule, datetime.date(2028, 3, 10)) is False
-    assert occurs_on(rule, datetime.date(2029, 3, 10)) is True
-
-
-# ---------------------------------------------------------------------------
-# occurrences_between
-# ---------------------------------------------------------------------------
-
-
-def test_yearly_occurrences_between_span() -> None:
-    rule = ScheduleRule(
-        rule_type=RuleType.YEARLY, month=2, day_of_month=29,
-        start_date="2026-02-28",
-    )
-    result = occurrences_between(rule, "2026-01-01", "2029-12-31")
-    assert result == [
-        "2026-02-28", "2027-02-28", "2028-02-29", "2029-02-28",
-    ]
-
-
-def test_yearly_occurrences_between_disjoint_range() -> None:
-    rule = ScheduleRule(
-        rule_type=RuleType.YEARLY, month=6, day_of_month=15,
-        start_date="2026-06-15",
-    )
-    # The rule only ever fires in June: other months are empty.
-    assert occurrences_between(rule, "2027-01-01", "2027-05-31") == []
-    assert occurrences_between(rule, "2027-07-01", "2027-12-31") == []
-
-
-def test_yearly_occurrences_between_rejects_inverted() -> None:
-    rule = ScheduleRule(
-        rule_type=RuleType.YEARLY, month=2, day_of_month=29,
-        start_date="2026-02-28",
-    )
-    with pytest.raises(RuleValidationError, match="on or after"):
-        occurrences_between(rule, "2029-01-01", "2026-01-01")
-
-
-# ---------------------------------------------------------------------------
-# Day of month 31 in a 30-day month: clamp consistency with MONTHLY_DAY
-# ---------------------------------------------------------------------------
-
-
-def test_yearly_june_31_clamps_to_june_30() -> None:
-    """June has 30 days: a June 31st yearly rule clamps to June 30."""
-    rule = ScheduleRule(
-        rule_type=RuleType.YEARLY, month=6, day_of_month=31,
-        start_date="2026-06-30",
-    )
-    assert occurs_on(rule, datetime.date(2026, 6, 30)) is True
-    assert occurs_on(rule, datetime.date(2027, 6, 30)) is True
-    assert occurs_on(rule, datetime.date(2026, 6, 29)) is False

tests/test_services.py

@@ -1,41 +0,0 @@
-"""Tests for the NestQuest services.yaml declaration file."""
-from __future__ import annotations
-
-import re
-from pathlib import Path
-
-SERVICES_PATH = (
-    Path(__file__).parent.parent
-    / "custom_components"
-    / "nestquest"
-    / "services.yaml"
-)
-
-
-def test_services_yaml_exists() -> None:
-    assert SERVICES_PATH.exists(), f"services.yaml missing at {SERVICES_PATH}"
-
-
-def test_services_yaml_declares_regenerate() -> None:
-    text = SERVICES_PATH.read_text(encoding="utf-8")
-    assert re.search(r"^regenerate:\s*$", text, re.MULTILINE), (
-        "services.yaml must declare the 'regenerate' service"
-    )
-
-
-def test_services_yaml_regenerate_has_description_and_no_fields() -> None:
-    """The regenerate service is documented with a clear description and no
-    required fields (there is no ``fields`` block under it)."""
-    text = SERVICES_PATH.read_text(encoding="utf-8")
-    match = re.search(r"^regenerate:\s*$", text, re.MULTILINE)
-    assert match is not None
-    section = text[match.end():]
-    next_service = re.search(r"^(?![#\s])\w+:\s*$", section, re.MULTILINE)
-    if next_service is not None:
-        section = section[: next_service.start()]
-    assert re.search(r"description:", section), (
-        "regenerate must carry a description"
-    )
-    assert "fields:" not in section, (
-        "regenerate declares no required fields"
-    )

tests/test_startup_db.py

@@ -1,467 +0,0 @@
-"""Tests for startup handling of missing, valid, and corrupt databases."""
-from __future__ import annotations
-
-import asyncio
-import hashlib
-import sqlite3
-from unittest.mock import AsyncMock, MagicMock
-
-import pytest
-from conftest import make_config_entry
-from homeassistant.exceptions import ConfigEntryNotReady
-
-from custom_components.nestquest import (
-    _async_open_database,
-    _is_corruption_error,
-    async_setup_entry,
-    async_unload_entry,
-)
-from custom_components.nestquest.db import NestQuestDatabase
-from custom_components.nestquest.migrations import (
-    MIGRATIONS,
-    VERSION_TABLE,
-    apply_migrations,
-)
-from tests.test_lifecycle import _wire
-
-
-def _run(coro):
-    return asyncio.new_event_loop().run_until_complete(coro)
-
-
-def _make_hass_mock():
-    hass = MagicMock()
-    hass.async_add_executor_job = AsyncMock(side_effect=(lambda fn, *a: fn(*a)))
-    return hass
-
-
-def _open_db(path) -> NestQuestDatabase:
-    database = NestQuestDatabase(_make_hass_mock())
-    _run(database.open(path))
-    return database
-
-
-async def _avalid_database(path) -> None:
-    """Create a valid, migrated NestQuest database file (async, on the
-    running loop, for use inside pytest-asyncio tests)."""
-    database = NestQuestDatabase(_make_hass_mock())
-    await database.open(path)
-    try:
-        await apply_migrations(database)
-    finally:
-        await database.close()
-
-
-def _valid_database(path) -> None:
-    """Create a valid, migrated NestQuest database file at ``path``."""
-    database = _open_db(path)
-    try:
-        _run(apply_migrations(database))
-    finally:
-        _run(database.close())
-
-
-def _truncated_database(path) -> None:
-    """Create a deliberately truncated (corrupt) database file.
-
-    A valid database is written, closed, then cut short mid-header:
-    opening it reports 'file is not a database' — exactly what an
-    interrupted write or failing disk leaves behind.
-    """
-    _valid_database(path)
-    data = path.read_bytes()
-    assert len(data) > 64, "valid database must exist before truncation"
-    path.write_bytes(data[: len(data) // 2])
-
-
-# ---------------------------------------------------------------------------
-# Corruption classification
-# ---------------------------------------------------------------------------
-
-
-def test_is_corruption_error_matches_sqlite_spellings() -> None:
-    assert _is_corruption_error(
-        sqlite3.DatabaseError("file is not a database")
-    )
-    assert _is_corruption_error(
-        sqlite3.DatabaseError("file is not a database".upper())
-    )
-    assert _is_corruption_error(
-        sqlite3.DatabaseError("file is encrypted or malformed")
-    )
-    assert _is_corruption_error(
-        sqlite3.OperationalError("file is not a database")
-    )
-
-
-def test_is_corruption_error_rejects_other_failures() -> None:
-    assert not _is_corruption_error(
-        sqlite3.OperationalError("database is locked")
-    )
-    assert not _is_corruption_error(
-        sqlite3.IntegrityError("NOT NULL constraint failed")
-    )
-    assert not _is_corruption_error(RuntimeError("boom"))
-    assert not _is_corruption_error(ValueError("nope"))
-
-
-# ---------------------------------------------------------------------------
-# Startup: three cases through _async_open_database
-# ---------------------------------------------------------------------------
-
-
-def test_missing_file_opens_fresh(tmp_path) -> None:
-    db_path = tmp_path / "nestquest.db"
-    assert not db_path.exists()
-    database = _run(_async_open_database(_make_hass_mock(), db_path))
-    try:
-        # The file was created fresh and migrations stamped the
-        # latest schema version.
-        assert db_path.exists()
-        row = _run(
-            database.fetch_one(f"SELECT version FROM {VERSION_TABLE}")
-        )
-        assert row == (len(MIGRATIONS),)
-    finally:
-        _run(database.close())
-
-
-def test_zero_byte_existing_file_is_corrupt_and_untouched(tmp_path) -> None:
-    """A zero-byte file is neither missing nor valid: it is corrupt.
-
-    The leave-untouched contract applies — startup refuses (retryable)
-    rather than silently initializing over whatever interrupted write
-    left the empty file, and the file stays exactly zero bytes.
-    """
-    db_path = tmp_path / "nestquest.db"
-    db_path.write_bytes(b"")
-    with pytest.raises(ConfigEntryNotReady) as excinfo:
-        _run(_async_open_database(_make_hass_mock(), db_path))
-    assert db_path.stat().st_size == 0
-    assert isinstance(excinfo.value.__cause__, sqlite3.DatabaseError)
-    # No sidecars appeared from the refusal path.
-    assert not (tmp_path / "nestquest.db-wal").exists()
-    assert not (tmp_path / "nestquest.db-shm").exists()
-
-
-def test_valid_file_opens_and_migrations_noop(tmp_path) -> None:
-    db_path = tmp_path / "nestquest.db"
-    _valid_database(db_path)
-    digest_before = hashlib.sha256(db_path.read_bytes()).hexdigest()
-    database = _run(_async_open_database(_make_hass_mock(), db_path))
-    try:
-        row = _run(
-            database.fetch_one(f"SELECT version FROM {VERSION_TABLE}")
-        )
-        assert row == (len(MIGRATIONS),)
-    finally:
-        _run(database.close())
-    # Opening a valid file must not rewrite it (the no-op path).
-    assert (
-        hashlib.sha256(db_path.read_bytes()).hexdigest() == digest_before
-    )
-
-
-def test_corrupt_file_raises_not_ready_and_leaves_file_untouched(
-    tmp_path, caplog
-) -> None:
-    db_path = tmp_path / "nestquest.db"
-    _truncated_database(db_path)
-    corrupt_bytes = db_path.read_bytes()
-    digest = hashlib.sha256(corrupt_bytes).hexdigest()
-
-    with pytest.raises(ConfigEntryNotReady) as excinfo:
-        _run(_async_open_database(_make_hass_mock(), db_path))
-
-    # The file is byte-identical: the owner can restore/inspect it.
-    assert hashlib.sha256(db_path.read_bytes()).hexdigest() == digest
-    assert len(db_path.read_bytes()) == len(corrupt_bytes)
-    # The original error is preserved and the log names the path.
-    assert isinstance(excinfo.value.__cause__, sqlite3.DatabaseError)
-    assert any(
-        "corrupt" in record.getMessage().lower()
-        and str(db_path) in record.getMessage()
-        for record in caplog.records
-        if record.levelname == "ERROR"
-    ), "the error log must name the corrupt path"
-
-
-def test_corrupt_file_raises_not_ready_never_raw_error(tmp_path) -> None:
-    """The corrupt case must surface as ConfigEntryNotReady, not crash
-    setup with a raw sqlite3.DatabaseError — and it must ALWAYS raise
-    (returning normally would mean corruption was silently accepted)."""
-    db_path = tmp_path / "nestquest.db"
-    _truncated_database(db_path)
-    with pytest.raises(ConfigEntryNotReady) as excinfo:
-        _run(_async_open_database(_make_hass_mock(), db_path))
-    assert isinstance(excinfo.value.__cause__, sqlite3.DatabaseError)
-
-
-def test_migration_stage_corruption_leaves_db_and_sidecars_untouched(
-    tmp_path, monkeypatch
-) -> None:
-    """A valid header with a corrupt LATER page must be rejected by the
-    whole-file read-only preflight BEFORE the read-write open can
-    switch the journal mode to WAL.
-
-    The fixture is deliberately a ROLLBACK-JOURNAL file (created with
-    plain sqlite3, default journal_mode=delete, NOT via the wrapper):
-    that is the case where the WAL transition actually rewrites the
-    header — a WAL-mode fixture would mask the write under test.  The
-    open() spy proves the read-write open was never reached.
-    """
-    db_path = tmp_path / "nestquest.db"
-    conn = sqlite3.connect(db_path)
-    try:
-        conn.execute("PRAGMA journal_mode=DELETE")
-        conn.execute(
-            "CREATE TABLE filler (id INTEGER PRIMARY KEY, "
-            "payload TEXT NOT NULL)"
-        )
-        conn.executemany(
-            "INSERT INTO filler (payload) VALUES (?)",
-            [(f"row-{index}" * 8,) for index in range(200)],
-        )
-        conn.commit()
-    finally:
-        conn.close()
-    data = bytearray(db_path.read_bytes())
-    assert conn.execute is not None
-    assert len(data) > 4200, "fixture must span more than one page"
-    # Corrupt a page well past the 100-byte header (offset 4096, the
-    # second page region): the header itself stays valid, so the
-    # read-write open succeeds and only the integrity probe/migrations
-    # discover damage.
-    for offset in range(4096, 4128):
-        data[offset] = 0xFF
-    db_path.write_bytes(bytes(data))
-    corrupt_bytes = db_path.read_bytes()
-    digest = hashlib.sha256(corrupt_bytes).hexdigest()
-
-    # Track whether the read-write open is reached at all: the whole
-    # preflight must reject this corruption BEFORE NestQuestDatabase
-    # .open() is ever called, which is the only way the file can stay
-    # byte-identical (the open persists WAL, rewriting the header).
-    open_calls: list[str] = []
-    original_open = NestQuestDatabase.open
-
-    async def _spy_open(self, path):
-        open_calls.append(str(path))
-        return await original_open(self, path)
-
-    monkeypatch.setattr(NestQuestDatabase, "open", _spy_open)
-
-    with pytest.raises(ConfigEntryNotReady) as excinfo:
-        _run(_async_open_database(_make_hass_mock(), db_path))
-    assert isinstance(excinfo.value.__cause__, sqlite3.DatabaseError)
-
-    # The corruption was caught at the preflight: the read-write open
-    # (and with it the WAL header rewrite) was never attempted.
-    assert open_calls == [], (
-        "whole-file preflight must reject corruption before the "
-        "read-write open can transition the journal mode"
-    )
-
-    # The main file is byte-identical to the corrupt state we handed in.
-    assert hashlib.sha256(db_path.read_bytes()).hexdigest() == digest
-    # No WAL/SHM sidecars left behind (WAL mode was never persisted,
-    # or they were cleaned up on close).
-    assert not (tmp_path / "nestquest.db-wal").exists()
-    assert not (tmp_path / "nestquest.db-shm").exists()
-
-
-def test_wal_mode_corruption_leaves_file_and_sidecars_untouched(
-    tmp_path, monkeypatch
-) -> None:
-    """A corrupt WAL-HEADER file must be rejected without creating
-    -shm sidecars from the read-only preflight itself.
-
-    The immutable=1 probe URI is what guarantees a read-only
-    connection creates no sidecars even for a WAL-header database; the
-    sidecar assertions after the call prove it.
-    """
-    db_path = tmp_path / "nestquest.db"
-    # WAL fixture: created via the wrapper (journal_mode=WAL persists).
-    _valid_database(db_path)
-    data = bytearray(db_path.read_bytes())
-    # Corrupt the WAL header flag region: bytes 18/19 hold the
-    # read/write version numbers (2 = WAL).  Flip them to garbage so
-    # the file claims a broken journal mode.
-    assert len(data) > 64
-    data[18] = 0x99
-    data[19] = 0x99
-    db_path.write_bytes(bytes(data))
-    corrupt_bytes = db_path.read_bytes()
-    digest = hashlib.sha256(corrupt_bytes).hexdigest()
-
-    with pytest.raises(ConfigEntryNotReady):
-        _run(_async_open_database(_make_hass_mock(), db_path))
-
-    # Main file byte-identical; no -shm appeared from the probe.
-    assert hashlib.sha256(db_path.read_bytes()).hexdigest() == digest
-    assert not (tmp_path / "nestquest.db-shm").exists()
-
-
-def test_open_failure_closes_connection_when_opened(
-    tmp_path, monkeypatch
-) -> None:
-    """A failure DURING MIGRATIONS closes the opened connection; a
-    failure inside open() itself has nothing to close (the wrapper
-    never adopted a connection), so close must not be called there.
-    """
-    db_path = tmp_path / "nestquest.db"
-    _truncated_database(db_path)
-
-    close_calls: list[bool] = []
-    original_close = NestQuestDatabase.close
-
-    async def _spy_close(self):
-        close_calls.append(True)
-        return await original_close(self)
-
-    monkeypatch.setattr(NestQuestDatabase, "close", _spy_close)
-    with pytest.raises(ConfigEntryNotReady):
-        _run(_async_open_database(_make_hass_mock(), db_path))
-    # Corruption hit at PRAGMA time inside open(): no connection was
-    # adopted, so there is nothing to close and close() must NOT have
-    # been called (calling close on a never-opened wrapper would be
-    # harmless but the helper deliberately skips it).
-    assert close_calls == []
-
-    # Contrast: a failure DURING migrations (file opens fine) closes.
-    close_calls.clear()
-    valid_path = tmp_path / "migrations-fail.db"
-    _valid_database(valid_path)
-    # _valid_database's own close went through the spy; only the
-    # failure path's close counts from here.
-    close_calls.clear()
-    from custom_components.nestquest import migrations as migrations_mod
-    from custom_components.nestquest.db import NestQuestDatabase as _DB
-
-    async def _failing(database, migrations=None):
-        raise sqlite3.DatabaseError("database disk image is malformed")
-
-    monkeypatch.setattr(migrations_mod, "apply_migrations", _failing)
-    monkeypatch.setattr(
-        "custom_components.nestquest.apply_migrations", _failing
-    )
-    with pytest.raises(ConfigEntryNotReady) as excinfo:
-        _run(_async_open_database(_make_hass_mock(), valid_path))
-    # Exactly one close: the migrations-failure cleanup path.  (The
-    # spy also sees the wrapper's own idempotent close if it were
-    # double-called — it must not be.)
-    assert close_calls == [True], (
-        "an open connection must be closed before the error propagates"
-    )
-    assert isinstance(excinfo.value.__cause__, sqlite3.DatabaseError)
-
-
-# ---------------------------------------------------------------------------
-# Startup through async_setup_entry (the real wiring)
-# ---------------------------------------------------------------------------
-
-
-def _make_setup(hass, registry):
-    def _setup(entry):
-        return async_setup_entry(hass, entry)
-
-    return _setup
-
-
-async def _setup_entry(hass, entry, registry) -> object:
-    entry = _wire(entry, registry)
-    await async_setup_entry(hass, entry)
-    return entry
-
-
-async def test_setup_with_corrupt_file_raises_not_ready(
-    hass, make_entry, monkeypatch, tmp_path, caplog
-) -> None:
-    from custom_components.nestquest.store import async_get_db_path
-
-    db_path = await async_get_db_path(hass)
-    await _avalid_database(db_path)
-    data = db_path.read_bytes()
-    assert len(data) > 64
-    db_path.write_bytes(data[: len(data) // 2])
-    corrupt_bytes = db_path.read_bytes()
-
-    entry = make_entry()
-    with pytest.raises(ConfigEntryNotReady):
-        await _setup_entry(hass, entry, hass.registry)
-    # File untouched, no runtime data stored.
-    assert db_path.read_bytes() == corrupt_bytes
-    assert hass.data["nestquest"].get(entry.entry_id) is None
-
-
-async def test_setup_with_missing_file_creates_and_loads(
-    hass, make_entry
-) -> None:
-    entry = await _setup_entry(hass, make_entry(), hass.registry)
-    database = entry.runtime_data.database
-    try:
-        row = await database.fetch_one(
-            f"SELECT version FROM {VERSION_TABLE}"
-        )
-        assert row == (len(MIGRATIONS),)
-    finally:
-        await database.close()
-    assert await async_unload_entry(hass, entry) is True
-
-
-async def test_setup_with_valid_file_preserves_rows(
-    hass, make_entry
-) -> None:
-    entry_a = await _setup_entry(hass, make_entry(), hass.registry)
-    database_a = entry_a.runtime_data.database
-    await database_a.execute(
-        "INSERT INTO children (display_name, created_at) VALUES (?, ?)",
-        ("Ada", "2026-09-14T12:00:00+00:00"),
-    )
-    # Unload pops the runtime record AND closes the connection; a
-    # fresh setup for the same entry_id then reopens the file.
-    assert await async_unload_entry(hass, entry_a) is True
-
-    entry_b = await _setup_entry(hass, make_entry(), hass.registry)
-    database_b = entry_b.runtime_data.database
-    assert database_b is not database_a
-    try:
-        row = await database_b.fetch_one("SELECT COUNT(*) FROM children")
-        assert row == (1,)
-    finally:
-        await database_b.close()
-    assert await async_unload_entry(hass, entry_b) is True
-
-
-# ---------------------------------------------------------------------------
-# No code path deletes or overwrites an existing database file
-# ---------------------------------------------------------------------------
-
-
-def test_package_never_unlinks_or_truncates_db_files() -> None:
-    """Guardrail: no code path may delete or overwrite an existing
-    database file.  Scans the package for unlink/rmtree/write on the
-    DB filename constant or *.db patterns.
-    """
-    import re
-    from pathlib import Path
-
-    package = Path(
-        __import__(
-            "custom_components.nestquest", fromlist=["__file__"]
-        ).__file__
-    ).parent
-    pattern = re.compile(
-        r"(unlink|rmtree|write_bytes|write_text|open\s*\(\s*[^)]*['\"]w)"
-        r"[^\n]*(nestquest\.db|\.db['\"])|"
-        r"(nestquest\.db|\.db['\"])[^\n]*"
-        r"(unlink|rmtree|write_bytes|write_text)",
-        re.IGNORECASE,
-    )
-    offenders: list[str] = []
-    for py in sorted(package.glob("*.py")):
-        if pattern.search(py.read_text()):
-            offenders.append(py.name)
-    assert offenders == [], (
-        f"code paths that could delete/overwrite the database: {offenders}"
-    )

tests/test_store.py

@@ -101,20 +101,12 @@ def test_executor_helper_creates_directory(tmp_path) -> None:
 
 
 def test_no_sqlite3_import_outside_db_module() -> None:
-    """sqlite3 is banned package-wide except two justified modules.
-
-    db.py is the connection wrapper (all statement execution lives
-    there).  __init__.py imports sqlite3 ONLY for its exception types
-    to classify corruption on startup (done-condition: corrupt file ->
-    ConfigEntryNotReady); it never opens a connection or executes
-    SQL — that is asserted separately below.
-    """
+    """sqlite3 is banned package-wide except db.py, the connection wrapper."""
     pkg_dir = Path(store.__file__).parent
     py_files = list(pkg_dir.glob("*.py"))
     assert py_files
-    allowed = {"db.py", "__init__.py"}
     for py_file in py_files:
-        if py_file.name in allowed:
+        if py_file.name == "db.py":
             continue
         tree = ast.parse(py_file.read_text(encoding="utf-8"), filename=str(py_file))
         for node in ast.walk(tree):
@@ -129,36 +121,6 @@ def test_no_sqlite3_import_outside_db_module() -> None:
                 )
 
 
-def test_init_module_never_opens_or_executes_sqlite() -> None:
-    """The __init__.py sqlite3 usage is limited to (a) exception typing
-    for corruption classification and (b) the ONE read-only preflight
-    connection (mode=ro URI, SELECT-only) that detects corruption in an
-    existing file before the real read-write open.  No read-write
-    connect, no cursor writes, no non-SELECT statements may appear.
-    """
-    import re
-    from pathlib import Path
-
-    init_path = (
-        Path(store.__file__).parent / "__init__.py"
-    ).read_text(encoding="utf-8")
-    # The preflight connect must be the URI read-only form, and only
-    # SELECT statements and the integrity_check PRAGMA may run there.
-    assert "sqlite3.connect(uri, uri=True)" in init_path
-    assert "?mode=ro" in init_path
-    assert 'PRAGMA integrity_check' in init_path
-    forbidden = re.compile(
-        r"sqlite3\s*\.\s*connect(?!\(\s*uri\s*,)"
-        r"|\bconn(ection)?\s*\.\s*execute\s*\(\s*[\"'](?!SELECT\s|PRAGMA\s+integrity_check)"
-        r"|\bexecutemany\b|\bexecutescript\b",
-        re.IGNORECASE,
-    )
-    assert forbidden.search(init_path) is None, (
-        "__init__.py may use sqlite3 only for exception typing and the "
-        "read-only corruption preflight (SELECT + integrity_check)"
-    )
-
-
 def test_no_file_creation_calls_in_store() -> None:
     source = Path(store.__file__).read_text(encoding="utf-8")
     tree = ast.parse(source, filename=str(store.__file__))

tests/test_timezones.py

@@ -1,370 +0,0 @@
-"""Timezone tests for the single HA-local date source in the generation path.
-
-These pin the done-condition that every "today" read in the generation path
-derives from ``hass.config.time_zone`` — not the host clock and not UTC —
-and that the rolling horizon ``[today, today + DEFAULT_HORIZON_DAYS]`` and the
-no-past guard resolve the correct local dates around midnight and across the
-daylight-saving transitions.
-"""
-from __future__ import annotations
-
-import asyncio
-import datetime
-from types import SimpleNamespace
-from zoneinfo import ZoneInfo
-
-from custom_components.nestquest.const import DEFAULT_HORIZON_DAYS
-from custom_components.nestquest.dao_children import ChildrenDao
-from custom_components.nestquest.dao_instances import QuestInstancesDao
-from custom_components.nestquest.db import NestQuestDatabase
-from custom_components.nestquest.migrations import apply_migrations
-from custom_components.nestquest.quest_definitions import (
-    assign_child,
-    create_quest_definition,
-    edit_quest_definition,
-)
-from custom_components.nestquest.recurrence import RuleType, ScheduleRule
-
-NOW = "2026-09-14T12:00:00+00:00"
-NEW_YORK = "America/New_York"
-
-
-def _make_hass_mock():
-    from unittest.mock import AsyncMock, MagicMock
-
-    hass = MagicMock()
-    hass.async_add_executor_job = AsyncMock(side_effect=(lambda fn, *a: fn(*a)))
-    return hass
-
-
-async def _prepare(path):
-    database = NestQuestDatabase(_make_hass_mock())
-    await database.open(path)
-    await apply_migrations(database)
-    return database
-
-
-def _run(coro):
-    return asyncio.new_event_loop().run_until_complete(coro)
-
-
-def _freeze_clock(
-    monkeypatch, instant: datetime.datetime
-) -> tuple[datetime.datetime, list]:
-    """Freeze the integration's ``datetime`` clock to a fixed aware instant.
-
-    Only ``custom_components.nestquest``'s ``datetime`` binding is patched, so
-    the generation path's "today" reads this instant (localized to whatever
-    time zone it asks for) while every other module and the test harness keep
-    the real clock.  Returns ``(frozen, requested)`` where ``frozen`` is the
-    instant normalized to UTC and ``requested`` is the list of ``tzinfo``
-    objects the code under test passed to ``now`` — so a test can prove the
-    generation path actually requested the configured HA time zone rather
-    than silently reading UTC.
-    """
-    import custom_components.nestquest as nestquest
-
-    frozen = instant.astimezone(datetime.timezone.utc)
-    requested: list = []
-
-    class _FrozenDatetime(datetime.datetime):
-        @classmethod
-        def now(cls, tz=None):
-            requested.append(tz)
-            if tz is None:
-                return frozen.replace(tzinfo=None)
-            return frozen.astimezone(tz)
-
-    fake_module = SimpleNamespace(
-        datetime=_FrozenDatetime,
-        timedelta=datetime.timedelta,
-        date=datetime.date,
-    )
-    monkeypatch.setattr(nestquest, "datetime", fake_module)
-    return frozen, requested
-
-
-def _assert_requested_ha_timezone(requested, time_zone: str) -> None:
-    """Assert ``now`` was called with (only) the configured HA time zone.
-
-    This is what turns the DST tests into a real proof of the HA-local date
-    source: if the generation path regressed to ``now(timezone.utc)``, its
-    requested tz would be UTC and this fails.
-    """
-    assert requested, "the generation path never called now(tz)"
-    assert all(tz == ZoneInfo(time_zone) for tz in requested)
-
-
-def _tz_hass(time_zone: str):
-    """A minimal hass exposing only the ``config.time_zone`` the walk reads."""
-    return SimpleNamespace(config=SimpleNamespace(time_zone=time_zone))
-
-
-async def _seed_daily(database, start_iso: str) -> int:
-    """One always-present child + a daily definition starting ``start_iso``."""
-    child = await ChildrenDao(database).create("Ada", NOW)
-    await create_quest_definition(
-        database,
-        "Daily chore",
-        ScheduleRule(rule_type=RuleType.DAILY, start_date=start_iso),
-        [child.id],
-        ["morning"],
-    )
-    return child.id
-
-
-def _local_date(instant_utc: datetime.datetime, time_zone: str) -> datetime.date:
-    return instant_utc.astimezone(ZoneInfo(time_zone)).date()
-
-
-def _assert_contiguous_horizon(records, local_today: datetime.date) -> None:
-    """The horizon is exactly today..today+horizon, no off-by-one, no gap."""
-    expected = {
-        (local_today + datetime.timedelta(days=offset)).isoformat()
-        for offset in range(DEFAULT_HORIZON_DAYS + 1)
-    }
-    assert {r.due_date for r in records} == expected
-    assert len(records) == DEFAULT_HORIZON_DAYS + 1
-
-
-def test_horizon_uses_newyork_local_date_after_local_midnight(
-    tmp_path, monkeypatch
-) -> None:
-    """A run just after New York local midnight uses the local date.
-
-    The frozen instant is 00:05 New York local time on 2026-03-10 (EDT, so
-    04:05 UTC).  The horizon must start on 2026-03-10 — the local calendar
-    date — not any host/UTC-derived value.
-    """
-    instant = datetime.datetime(
-        2026, 3, 10, 0, 5, tzinfo=ZoneInfo(NEW_YORK)
-    )
-    local_today = instant.date()
-
-    async def _body(database):
-        hass = _tz_hass(NEW_YORK)
-        _frozen, requested = _freeze_clock(monkeypatch, instant)
-        import custom_components.nestquest as nestquest
-
-        child_id = await _seed_daily(database, local_today.isoformat())
-        await nestquest._run_horizon_materialization(hass, database)
-        records = await QuestInstancesDao(database).list_by_date_range(
-            child_id,
-            local_today.isoformat(),
-            (local_today + datetime.timedelta(days=DEFAULT_HORIZON_DAYS)).isoformat(),
-        )
-        _assert_contiguous_horizon(records, local_today)
-        _assert_requested_ha_timezone(requested, NEW_YORK)
-        return len(records)
-
-    async def _main():
-        database = await _prepare(tmp_path / "tz-midnight.db")
-        try:
-            return await _body(database)
-        finally:
-            await database.close()
-
-    assert _run(_main()) == DEFAULT_HORIZON_DAYS + 1
-
-
-def test_horizon_uses_local_date_not_utc_when_host_ahead(
-    tmp_path, monkeypatch
-) -> None:
-    """The walk's "today" is HA-local, never the UTC/system calendar date.
-
-    FROZEN at 2026-01-15 03:00 UTC: the UTC calendar date is 2026-01-15, but
-    New York local is still 2026-01-14 22:00 EST.  The horizon must start on
-    2026-01-14 (local), proving the UTC date did not win.
-    """
-    instant = datetime.datetime(2026, 1, 15, 3, 0, tzinfo=datetime.timezone.utc)
-    local_today = _local_date(instant, NEW_YORK)
-    assert local_today == datetime.date(2026, 1, 14)
-    assert instant.date() == datetime.date(2026, 1, 15)
-
-    async def _body(database):
-        hass = _tz_hass(NEW_YORK)
-        _frozen, requested = _freeze_clock(monkeypatch, instant)
-        import custom_components.nestquest as nestquest
-
-        child_id = await _seed_daily(database, local_today.isoformat())
-        await nestquest._run_horizon_materialization(hass, database)
-        records = await QuestInstancesDao(database).list_by_date_range(
-            child_id,
-            local_today.isoformat(),
-            (local_today + datetime.timedelta(days=DEFAULT_HORIZON_DAYS)).isoformat(),
-        )
-        _assert_contiguous_horizon(records, local_today)
-        _assert_requested_ha_timezone(requested, NEW_YORK)
-        return len(records)
-
-    async def _main():
-        database = await _prepare(tmp_path / "tz-host-ahead.db")
-        try:
-            return await _body(database)
-        finally:
-            await database.close()
-
-    assert _run(_main()) == DEFAULT_HORIZON_DAYS + 1
-
-
-def test_horizon_resolves_spring_forward_day_without_off_by_one(
-    tmp_path, monkeypatch
-) -> None:
-    """Across the 2026-03-08 spring-forward, today and the horizon stay local.
-
-    Before the jump ("01:30 EST") and after it ("03:30 EDT") both resolve to
-    2026-03-08 local — the lost hour must not skip or repeat a calendar day —
-    and the full horizon remains 15 contiguous days.
-    """
-    zone = ZoneInfo(NEW_YORK)
-    before = datetime.datetime(2026, 3, 8, 1, 30, tzinfo=zone)  # EST
-    after = datetime.datetime(2026, 3, 8, 3, 30, tzinfo=zone)   # EDT
-    assert before.date() == after.date() == datetime.date(2026, 3, 8)
-
-    async def _body(database):
-        hass = _tz_hass(NEW_YORK)
-        import custom_components.nestquest as nestquest
-
-        requested_batches: list[list] = []
-        for instant in (before, after):
-            _frozen, requested = _freeze_clock(monkeypatch, instant)
-            requested_batches.append(requested)
-            local_today = instant.date()
-            child_id = await _seed_daily(database, local_today.isoformat())
-            await nestquest._run_horizon_materialization(hass, database)
-            records = await QuestInstancesDao(database).list_by_date_range(
-                child_id,
-                local_today.isoformat(),
-                (local_today + datetime.timedelta(days=DEFAULT_HORIZON_DAYS)).isoformat(),
-            )
-            _assert_contiguous_horizon(records, local_today)
-        requested_all = [tz for batch in requested_batches for tz in batch]
-        _assert_requested_ha_timezone(requested_all, NEW_YORK)
-        return local_today
-
-    async def _main():
-        database = await _prepare(tmp_path / "tz-spring-forward.db")
-        try:
-            return await _body(database)
-        finally:
-            await database.close()
-
-    assert _run(_main()) == datetime.date(2026, 3, 8)
-
-
-def test_horizon_resolves_fall_back_day_without_off_by_one(
-    tmp_path, monkeypatch
-) -> None:
-    """Across the 2026-11-01 fall-back, today and the horizon stay local.
-
-    The repeated 01:00-02:00 hour must not resolve to the wrong calendar
-    day: the first 01:30 (``fold=0``, EDT) and the repeated 01:30
-    (``fold=1``, EST) are distinct instants yet both resolve to 2026-11-01
-    — and both, along with 03:30 EST after the jump, materialize the same
-    15 contiguous-day horizon with no off-by-one.
-    """
-    zone = ZoneInfo(NEW_YORK)
-    first = datetime.datetime(2026, 11, 1, 1, 30, tzinfo=zone, fold=0)  # EDT
-    second = datetime.datetime(2026, 11, 1, 1, 30, tzinfo=zone, fold=1)  # EST
-    after = datetime.datetime(2026, 11, 1, 3, 30, tzinfo=zone)  # EST
-    assert first.date() == second.date() == after.date() == datetime.date(2026, 11, 1)
-    assert first.utcoffset() != second.utcoffset()  # the two repeated-hour folds
-
-    async def _body(database):
-        hass = _tz_hass(NEW_YORK)
-        import custom_components.nestquest as nestquest
-
-        requested_batches: list[list] = []
-        for instant in (first, second, after):
-            _frozen, requested = _freeze_clock(monkeypatch, instant)
-            requested_batches.append(requested)
-            local_today = instant.date()
-            child_id = await _seed_daily(database, local_today.isoformat())
-            await nestquest._run_horizon_materialization(hass, database)
-            records = await QuestInstancesDao(database).list_by_date_range(
-                child_id,
-                local_today.isoformat(),
-                (local_today + datetime.timedelta(days=DEFAULT_HORIZON_DAYS)).isoformat(),
-            )
-            _assert_contiguous_horizon(records, local_today)
-        requested_all = [tz for batch in requested_batches for tz in batch]
-        _assert_requested_ha_timezone(requested_all, NEW_YORK)
-        return local_today
-
-    async def _main():
-        database = await _prepare(tmp_path / "tz-fall-back.db")
-        try:
-            return await _body(database)
-        finally:
-            await database.close()
-
-    assert _run(_main()) == datetime.date(2026, 11, 1)
-
-
-def test_definition_business_regeneration_uses_pinned_today_not_host(
-    tmp_path, monkeypatch
-) -> None:
-    """``edit_quest_definition``/``assign_child`` anchor regeneration on
-    the caller-pinned HA-local ``today``, not the host clock.
-
-    The host clock (the ``_today`` fallback) is pinned one day AHEAD of the
-    HA-local ``today``; the guard would reject the local "today" as past
-    (and the horizon would skip it) if it consulted the host clock.  Both
-    business operations must regenerate against the pinned date and keep
-    that first local day, proving the threaded ``today`` wins.
-    """
-    import custom_components.nestquest.dao_instances as dao_instances_module
-
-    pinned = datetime.date(2026, 1, 14)
-    host_today = datetime.date(2026, 1, 15)
-    monkeypatch.setattr(dao_instances_module, "_today", lambda: host_today)
-
-    async def _body(database):
-        children = ChildrenDao(database)
-        dao = QuestInstancesDao(database)
-        horizon_end = pinned + datetime.timedelta(days=DEFAULT_HORIZON_DAYS)
-
-        a = await children.create("Ada", NOW)
-        created = await create_quest_definition(
-            database,
-            "Daily chore",
-            ScheduleRule(rule_type=RuleType.DAILY, start_date=pinned.isoformat()),
-            [a.id],
-            [("morning", "09:00")],
-        )
-        definition_id = created.definition.id
-
-        # edit anchors on pinned: the horizon starts at the local day the
-        # host clock calls "past", so its presence proves pinned won.
-        await edit_quest_definition(
-            database,
-            definition_id,
-            windows=[("morning", "10:15")],
-            today=pinned,
-        )
-        a_records = await dao.list_by_date_range(
-            a.id, pinned.isoformat(), horizon_end.isoformat()
-        )
-        assert [r.due_date for r in a_records][0] == pinned.isoformat()
-        assert {r.due_time for r in a_records} == {"10:15"}
-        assert len(a_records) == DEFAULT_HORIZON_DAYS + 1
-
-        # assign anchors on pinned too: the new child's regeneration keeps
-        # the same pinned-local first day rather than skipping to the host day.
-        b = await children.create("Bo", NOW)
-        await assign_child(database, definition_id, b.id, today=pinned)
-        b_records = await dao.list_by_date_range(
-            b.id, pinned.isoformat(), horizon_end.isoformat()
-        )
-        assert [r.due_date for r in b_records][0] == pinned.isoformat()
-        assert len(b_records) == DEFAULT_HORIZON_DAYS + 1
-        return definition_id
-
-    async def _main():
-        database = await _prepare(tmp_path / "tz-definition-regen.db")
-        try:
-            return await _body(database)
-        finally:
-            await database.close()
-
-    assert _run(_main()) is not None

uv.lock

@@ -22,7 +22,7 @@ wheels = [
 
 [[package]]
 name = "nestquest"
-version = "0.3.0"
+version = "0.1.0"
 source = { virtual = "." }
 
 [package.dev-dependencies]