test: three-run idempotency with stable instance ids

custom_components/nestquest/__init__.py

@@ -2,31 +2,19 @@
 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 (
+from .const import CONF_ADMIN_USER_IDS, DOMAIN, LOGGER
-    CONF_ADMIN_USER_IDS,
-    CONF_DAY_ROLLOVER_TIME,
-    DEFAULT_DAY_ROLLOVER_TIME,
-    DEFAULT_HORIZON_DAYS,
-    DOMAIN,
-    LOGGER,
-    SERVICE_REGENERATE,
-)
 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
@@ -236,7 +224,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]:
@@ -261,112 +248,6 @@ async def _async_owner_user_ids(hass: HomeAssistant) -> list[str]:
     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)
-
-
-async def _run_horizon_materialization(
-    hass: HomeAssistant, database: NestQuestDatabase
-) -> None:
-    """Materialize the rolling horizon ``[today, today + DEFAULT_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.
-    """
-    time_zone = ZoneInfo(hass.config.time_zone)
-    today = datetime.datetime.now(time_zone).date()
-    start_date = today.isoformat()
-    end_date = (
-        today + datetime.timedelta(days=DEFAULT_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 + DEFAULT_HORIZON_DAYS]``
-    through the shared :func:`_run_horizon_materialization` path.
-    """
-    hour, minute = _day_rollover_hour_minute(options)
-
-    async def _run_materialization(_now: datetime.datetime) -> None:
-        await _run_horizon_materialization(hass, database)
-
-    return async_track_time_change(
-        hass, _run_materialization, hour=hour, minute=minute
-    )
-
-
-def _find_live_database(hass: HomeAssistant) -> NestQuestDatabase | None:
-    """Return a connected database from the active runtime data, or None.
-
-    The domain-global services (e.g. ``regenerate``) have no database of
-    their own; they resolve whichever config entry's database is currently
-    live at call time, so none of them can hold a stale handle to a closed
-    connection after another entry unloads.
-    """
-    for runtime_data in hass.data.get(DOMAIN, {}).values():
-        database = getattr(runtime_data, "database", None)
-        if database is not None and database.connected:
-            return database
-    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:
-        database = _find_live_database(hass)
-        if database is None:
-            _LOGGER.warning(
-                "NestQuest regenerate requested but no config entry has a "
-                "live database; ignoring"
-            )
-            return
-        await _run_horizon_materialization(hass, database)
-
-    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:
     """Set up the NestQuest integration. YAML configuration is not used, returns True."""
     return True
@@ -424,8 +305,6 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
         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
     try:
         # Seed the admin allowlist on first setup so the owner is never
         # locked out: an empty database takes the persisted admin copy
@@ -451,43 +330,14 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
             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 + DEFAULT_HORIZON_DAYS] once at setup.  This runs
-        # through the SAME path as the daily listener and regenerate service.
-        await _run_horizon_materialization(hass, database)
-        _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
@@ -498,47 +348,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 not domain_data:
-    if is_last:
         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(
+        unload_error: BaseException | None = None
-            runtime_data, "remove_time_change_listener", None
-        )
         try:
-            for remove_listener in (
+            if remove_update_listener is not None:
-                remove_update_listener,
+                result = remove_update_listener()
-                remove_time_change_listener,
+                if inspect.isawaitable(result):
-            ):
+                    await result
-                if remove_listener is None:
+        except BaseException as err:
-                    continue
+            unload_error = err
-                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
         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
+        if unload_error is not None:
-    # once the FINAL entry unloads (``hass.data[DOMAIN]`` is now empty),
+            if getattr(entry, "runtime_data", None) is not None:
-    # never when a sibling entry is still loaded.
+                entry.runtime_data = None
-    if is_last:
+            raise unload_error
-        _deregister_regenerate_service(hass)
     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/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

custom_components/nestquest/dao_instances.py

@@ -47,46 +47,6 @@ from .db import NestQuestDatabase
 _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.
 
@@ -206,7 +166,6 @@ class QuestInstancesDao:
         *,
         window: str,
         due_time: str | None = None,
-        today: datetime.date | None = None,
     ) -> QuestInstanceRecord:
         """Create the dated instance for the widened key idempotently.
 
@@ -225,10 +184,6 @@ class QuestInstancesDao:
         - ``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
@@ -248,20 +203,24 @@ class QuestInstancesDao:
         # 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
+        today = datetime.date.today().isoformat()
-        # checks and never re-read, since it is already the anchor the
+        if due_date < today:
-        # batch runs against.
+            raise ValueError(
-        today_date = _resolve_today(today)
+                f"instances are never generated in the past: due_date "
-        _reject_past(due_date, today_date.isoformat())
+                f"{due_date!r} is before today {today!r}"
+            )
         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
+                # holds across midnight rollovers.
-                # anchor is exempt from the re-read (see above).
+                today = datetime.date.today().isoformat()
-                if today is None:
+                if due_date < today:
-                    today_date = _today()
+                    raise ValueError(
-                _reject_past(due_date, today_date.isoformat())
+                        f"instances are never generated in the past: "
+                        f"due_date {due_date!r} is before today "
+                        f"{today!r}"
+                    )
                 definition = await self._database.fetch_one(
                     "SELECT 1 FROM quest_definitions WHERE id = ?",
                     (definition_id,),
@@ -327,7 +286,6 @@ class QuestInstancesDao:
         *,
         window: str,
         due_time: str | None = None,
-        today: datetime.date | None = None,
     ) -> QuestInstanceRecord | None:
         """Insert one dated instance iff its tuple is still materializable.
 
@@ -356,26 +314,28 @@ class QuestInstancesDao:
         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
+        no-past rule and the immutable-completed-instance refusal are
-        preserved from :meth:`upsert` and still raises ValueError; ``today``
+        preserved from :meth:`upsert` (those are not configuration
-        optionally pins the HA-local anchor it compares against.  An
+        invalidations and still raise ValueError).
-        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)
+        today = datetime.date.today().isoformat()
-        _reject_past(due_date, today_date.isoformat())
+        if due_date < today:
+            raise ValueError(
+                f"instances are never generated in the past: due_date "
+                f"{due_date!r} is before today {today!r}"
+            )
         async with _connection_lock(self._database):
             async with self._database.transaction():
-                if today is None:
+                today = datetime.date.today().isoformat()
-                    today_date = _today()
+                if due_date < today:
-                _reject_past(due_date, today_date.isoformat())
+                    raise ValueError(
+                        f"instances are never generated in the past: "
+                        f"due_date {due_date!r} is before today {today!r}"
+                    )
                 still_valid = await self._database.fetch_one(
                     "SELECT 1 FROM quest_definitions d "
                     "JOIN quest_definition_assignees a "
@@ -399,12 +359,12 @@ class QuestInstancesDao:
                     (definition_id, child_id, due_date, window),
                 )
                 if existing is not None:
-                    # The instance is already completed and therefore
+                    raise ValueError(
-                    # immutable: the walk SKIPS it (no-op) rather than
+                        f"instance for (definition {definition_id}, "
-                    # rewriting its snapshot columns or failing the
+                        f"child {child_id}, due_date {due_date!r}, "
-                    # batch.  This is the materialization walk's skip,
+                        f"window {window!r}) already has a completion "
-                    # distinct from the generic :meth:`upsert` refusal.
+                        "event and is immutable; it cannot be regenerated"
-                    return None
+                    )
                 await self._database.execute(
                     "INSERT INTO quest_instances (definition_id, child_id, "
                     "window, due_date, due_time, generated_at) "
@@ -487,7 +447,7 @@ class QuestInstancesDao:
         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
+        self, definition_id: int, cutoff_date: str
     ) -> int:
         """Delete the definition's open instances at/after cutoff.
 
@@ -499,11 +459,9 @@ class QuestInstancesDao:
         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``
+        sweep (Feature 11) handles past-due instances instead.  Any
-        optionally pins the HA-local anchor the clamp compares against
+        instance with a completion event is never touched, regardless
-        (falling back to the host clock when omitted).  Any instance with
+        of its date.  Returns the number deleted.
-        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):
@@ -513,8 +471,8 @@ class QuestInstancesDao:
                 # 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)
+                today = datetime.date.today().isoformat()
-                effective_cutoff = max(cutoff_date, today_date.isoformat())
+                effective_cutoff = max(cutoff_date, today)
                 result = await self._database.execute(
                     "DELETE FROM quest_instances WHERE definition_id = ? "
                     "AND due_date >= ? AND NOT EXISTS ("
@@ -525,51 +483,6 @@ class QuestInstancesDao:
                 )
         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.

custom_components/nestquest/materialize.py

@@ -3,8 +3,8 @@
 :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
+windows; HA scheduling (day-rollover triggers) and skip-completed
-task and lives elsewhere.
+generation are separate later tasks and live elsewhere.
 
 The walk is deterministic and idempotent:
 
@@ -32,39 +32,15 @@ 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,
+The upsert is idempotent on (definition_id, child_id, due_date, window),
-window), so re-running the materialization over the same range never
+so re-running the materialization over the same range never duplicates a
-duplicates a row; a tuple whose instance is already completed is SKIPPED
+row; skipped-completed handling is deliberately NOT done here.
-(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 + 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
-from .dao_instances import QuestInstancesDao, _resolve_today
 from .dao_rules import (
     _validate_date,
     load_materialization_input,
@@ -125,9 +101,6 @@ 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].
 
@@ -137,28 +110,6 @@ async def materialize(
     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
@@ -178,7 +129,6 @@ async def materialize(
         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),
@@ -192,13 +142,6 @@ async def materialize(
     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:
@@ -207,8 +150,6 @@ async def materialize(
             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:
@@ -219,123 +160,8 @@ async def materialize(
                         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,
-) -> 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 + DEFAULT_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.  Returns the number of instances the re-materialization
-    upserted across the whole snapshot (idempotent — other active
-    definitions' tuples refresh in place, never duplicate).
-    """
-    today_date = _resolve_today(today)
-    start_date = today_date.isoformat()
-    end_date = (
-        today_date + datetime.timedelta(days=DEFAULT_HORIZON_DAYS)
-    ).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,
-) -> 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 + DEFAULT_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.  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}")
-
-    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=DEFAULT_HORIZON_DAYS)).isoformat()
-    return await materialize(
-        database, start.isoformat(), end_date, child_ids=[child_id], today=today
-    )

custom_components/nestquest/quest_definitions.py

@@ -58,7 +58,6 @@ from .dao_rules import (
     schedule_rule_to_storage,
 )
 from .db import NestQuestDatabase
-from .materialize import regenerate_for_definition
 from .recurrence import ScheduleRule, occurs_on
 
 
@@ -271,7 +270,6 @@ async def edit_quest_definition(
     icon: str | None | object = _UNSET,
     rule: ScheduleRule | object = _UNSET,
     windows: list[str | tuple[str, str | None]] | object = _UNSET,
-    today: datetime.date | None = None,
 ) -> CreatedQuestDefinition:
     """Edit a quest definition's metadata, rule and windows atomically.
 
@@ -293,13 +291,6 @@ async def edit_quest_definition(
     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.
     """
     _validate_definition_id(definition_id)
 
@@ -350,8 +341,6 @@ async def edit_quest_definition(
         schedule_rule_storage_from_record(snapshot.rule)
     )
 
-    await regenerate_for_definition(database, definition_id, today=today)
-
     return CreatedQuestDefinition(
         definition=snapshot.definition,
         rule=decoded_rule,
@@ -364,8 +353,6 @@ async def assign_child(
     database: NestQuestDatabase,
     definition_id: int,
     child_id: int,
-    *,
-    today: datetime.date | None = None,
 ) -> list[ChildRecord]:
     """Assign ``child_id`` to the definition (idempotent).
 
@@ -379,15 +366,12 @@ async def assign_child(
     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`).
     """
     _validate_definition_id(definition_id)
     _validate_child_id(child_id)
     dao = QuestDefinitionsDao(database)
     try:
-        assignees = await dao.add_assignee(definition_id, child_id)
+        return 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.
@@ -397,16 +381,12 @@ async def assign_child(
         if message.startswith("quest definition "):
             raise ValueError(f"definition_id: {message}") from error
         raise
-    await regenerate_for_definition(database, definition_id, today=today)
-    return assignees
 
 
 async def unassign_child(
     database: NestQuestDatabase,
     definition_id: int,
     child_id: int,
-    *,
-    today: datetime.date | None = None,
 ) -> bool:
     """Unassign ``child_id`` from the definition; True when removed.
 
@@ -416,9 +396,6 @@ async def unassign_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`).
     """
     _validate_definition_id(definition_id)
     _validate_child_id(child_id)
@@ -428,17 +405,13 @@ async def unassign_child(
         raise ValueError(
             f"definition_id: quest definition {definition_id} does not exist"
         )
-    removed = await dao.remove_assignee(definition_id, child_id)
+    return await dao.remove_assignee(definition_id, child_id)
-    await regenerate_for_definition(database, definition_id, today=today)
-    return removed
 
 
 async def set_quest_definition_active(
     database: NestQuestDatabase,
     definition_id: int,
     is_active: bool,
-    *,
-    today: datetime.date | None = None,
 ) -> CreatedQuestDefinition:
     """Deactivate or reactivate a definition; returns the updated view.
 
@@ -461,10 +434,6 @@ async def set_quest_definition_active(
     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`).
     """
     _validate_definition_id(definition_id)
     if not isinstance(is_active, bool):
@@ -488,7 +457,6 @@ async def set_quest_definition_active(
     rule = schedule_rule_from_storage(
         schedule_rule_storage_from_record(rule_record)
     )
-    await regenerate_for_definition(database, definition_id, today=today)
     return CreatedQuestDefinition(
         definition=updated,
         rule=rule,

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.

tests/conftest.py

@@ -44,7 +44,6 @@ _HA_MODULES = (
     "homeassistant.exceptions",
     "homeassistant.helpers",
     "homeassistant.helpers.config_validation",
-    "homeassistant.helpers.event",
 )
 
 def _find_spec(name: str):
@@ -84,7 +83,6 @@ for _parent, _child in (
     ("homeassistant", "exceptions"),
     ("homeassistant", "helpers"),
     ("homeassistant.helpers", "config_validation"),
-    ("homeassistant.helpers", "event"),
 ):
     setattr(sys.modules[_parent], _child, sys.modules[f"{_parent}.{_child}"])
 
@@ -244,113 +242,6 @@ 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,
@@ -412,11 +303,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)

tests/test_lifecycle.py

@@ -8,12 +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 (
+from custom_components.nestquest.const import DOMAIN as DOMAIN_CONST
-    CONF_DAY_ROLLOVER_TIME,
-    DEFAULT_HORIZON_DAYS,
-    SERVICE_REGENERATE,
-    DOMAIN as DOMAIN_CONST,
-)
 
 
 def _wire(entry, registry):
@@ -242,130 +237,6 @@ async def test_unload_closes_database_even_when_listener_removal_raises() -> Non
     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
-    )
-
-
-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:
@@ -385,172 +256,3 @@ async def test_setup_applies_all_v1_tables(hass, make_entry) -> None:
         "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_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_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")

tests/test_materialize.py

@@ -7,31 +7,16 @@ import datetime
 import pytest
 
 from custom_components.nestquest.dao_children import ChildrenDao
-from custom_components.nestquest.dao_instances import (
+from custom_components.nestquest.dao_instances import QuestInstancesDao
-    CompletionEventsDao,
-    QuestInstancesDao,
-)
 from custom_components.nestquest.dao_presence import PresenceSchedulesDao
-from custom_components.nestquest.dao_rules import (
+from custom_components.nestquest.dao_rules import QuestDefinitionsDao
-    QuestDefinitionsDao,
-    schedule_rule_to_storage,
-)
 from custom_components.nestquest.db import NestQuestDatabase
-from custom_components.nestquest.materialize import (
+from custom_components.nestquest.materialize import materialize
-    materialize,
-    regenerate_for_child,
-    regenerate_for_definition,
-)
 from custom_components.nestquest.migrations import apply_migrations
 from custom_components.nestquest.quest_definitions import (
     create_quest_definition,
-    edit_quest_definition,
-)
-from custom_components.nestquest.recurrence import (
-    RuleType,
-    ScheduleRule,
-    occurs_on,
 )
+from custom_components.nestquest.recurrence import RuleType, ScheduleRule
 
 
 def _run(coro):
@@ -260,65 +245,6 @@ def test_materialize_is_idempotent(tmp_path) -> None:
     _with_db(tmp_path, "materialize-idempotent.db")(_body)
 
 
-def test_materialize_skips_completed_instance_on_re_run(tmp_path) -> None:
-    async def _body(database):
-        children = ChildrenDao(database)
-        child = await children.create("Ada", NOW)
-        start = _future_monday()
-        start_iso = start.isoformat()
-        end_iso = (start + datetime.timedelta(days=2)).isoformat()
-        created = await create_quest_definition(
-            database,
-            "Daily chore",
-            ScheduleRule(rule_type=RuleType.DAILY, start_date=start_iso),
-            [child.id],
-            [("morning", "09:00")],
-        )
-
-        await materialize(database, start_iso, end_iso)
-        dao = QuestInstancesDao(database)
-        records = await dao.list_by_date_range(child.id, start_iso, end_iso)
-        assert len(records) == 3
-        completed = records[0]
-
-        await CompletionEventsDao(database).append(
-            completed.id,
-            child.id,
-            "completed",
-            "user",
-            f"{start_iso}T08:00:00+00:00",
-            True,
-            actor_user_id="user-1",
-        )
-
-        # Change the definition so the tuple would otherwise regenerate:
-        # the morning window's due time moves from 09:00 to 10:15.
-        await edit_quest_definition(
-            database,
-            created.definition.id,
-            windows=[("morning", "10:15")],
-        )
-
-        # Re-running must skip the completed instance (no exception) and
-        # leave it untouched, while the open days regenerate to 10:15.
-        count = await materialize(database, start_iso, end_iso)
-        assert count == 2
-
-        refreshed = await dao.list_by_date_range(child.id, start_iso, end_iso)
-        by_due_date = {r.due_date: r for r in refreshed}
-        survived = by_due_date[completed.due_date]
-        assert survived.id == completed.id
-        assert survived.due_time == "09:00"
-        assert survived.generated_at == completed.generated_at
-
-        others = [r for r in refreshed if r.id != completed.id]
-        assert len(others) == 2
-        assert {r.due_time for r in others} == {"10:15"}
-        return count
-
-    _with_db(tmp_path, "materialize-skip-completed.db")(_body)
-
-
 async def _materialize_with_change(
     database, start_iso, end_iso, change
 ) -> int:
@@ -340,7 +266,7 @@ async def _materialize_with_change(
     seen = {"n": 0}
 
     async def _gated(self, definition_id, child_id, due_date, generated_at,
-                     *, window, due_time=None, today=None):
+                     *, window, due_time=None):
         seen["n"] += 1
         if seen["n"] == 1:
             seen["first"] = (definition_id, child_id, window)
@@ -348,7 +274,7 @@ async def _materialize_with_change(
             await release.wait()
         return await original_upsert(
             self, definition_id, child_id, due_date, generated_at,
-            window=window, due_time=due_time, today=today,
+            window=window, due_time=due_time,
         )
 
     QuestInstancesDao.upsert_if_valid = _gated
@@ -630,88 +556,6 @@ def test_materialize_rejects_malformed_or_inverted_bounds(tmp_path) -> None:
     _with_db(tmp_path, "materialize-bounds.db")(_body)
 
 
-def test_materialize_accepts_ha_local_today_behind_host(tmp_path) -> None:
-    """The clamp and no-past guard compare against a caller-supplied HA-local today.
-
-    A household time zone behind the host clock around midnight resolves a
-    HA-local "today" one calendar day earlier than the host's
-    ``date.today()``.  The walk clamps its start to that anchor: without
-    a pinned HA-local date the effective start is the host's today (one
-    day after ha_today), so the now-past day is skipped rather than
-    rejected, and only the host-today-onward days materialize.
-    """
-    async def _body(database):
-        children = ChildrenDao(database)
-        child = await children.create("Ada", NOW)
-        ha_today = datetime.date.today() - datetime.timedelta(days=1)
-        start_iso = ha_today.isoformat()
-        end_iso = (ha_today + datetime.timedelta(days=14)).isoformat()
-        await create_quest_definition(
-            database,
-            "Daily chore",
-            ScheduleRule(rule_type=RuleType.DAILY, start_date=start_iso),
-            [child.id],
-            ["morning"],
-        )
-
-        # Without a pinned HA-local today, the walk clamps its start to the
-        # host's today (one day after ha_today); the past day is dropped and
-        # the 14 host-today-onward days materialize.
-        without_pin = await materialize(database, start_iso, end_iso)
-        assert without_pin == 14
-
-        # With today=ha_today, the full 15-day horizon materializes.
-        count = await materialize(database, start_iso, end_iso, today=ha_today)
-        assert count == 15
-        return count
-
-    _with_db(tmp_path, "materialize-ha-local-today.db")(_body)
-
-
-def test_materialize_clamps_past_start_to_today(tmp_path) -> None:
-    """A past start_date is clamped to today: no past-dated instance is created.
-
-    A caller passing a start one month in the past never yields a
-    past-dated instance: the walk clamps its effective start up to today
-    and materializes only dates on/after today, leaving the past untouched
-    rather than raising or corrupting state.
-    """
-    async def _body(database):
-        children = ChildrenDao(database)
-        child = await children.create("Ada", NOW)
-
-        today = datetime.date.today()
-        start_iso = (today - datetime.timedelta(days=30)).isoformat()
-        end_iso = (today + datetime.timedelta(days=14)).isoformat()
-
-        await create_quest_definition(
-            database,
-            "Daily chore",
-            ScheduleRule(rule_type=RuleType.DAILY, start_date=start_iso),
-            [child.id],
-            ["morning"],
-        )
-
-        count = await materialize(database, start_iso, end_iso, today=today)
-        assert count == 15
-
-        dao = QuestInstancesDao(database)
-        records = await dao.list_by_date_range(child.id, start_iso, end_iso)
-        assert len(records) == 15
-        assert all(r.due_date >= today.isoformat() for r in records)
-
-        # The past month is empty: no past-dated instance was ever created.
-        past_records = await dao.list_by_date_range(
-            child.id,
-            start_iso,
-            (today - datetime.timedelta(days=1)).isoformat(),
-        )
-        assert past_records == []
-        return count
-
-    _with_db(tmp_path, "materialize-past-start.db")(_body)
-
-
 def test_materialize_skips_inactive_definitions(tmp_path) -> None:
     async def _body(database):
         from custom_components.nestquest.quest_definitions import (
@@ -736,724 +580,3 @@ def test_materialize_skips_inactive_definitions(tmp_path) -> None:
         return count
 
     _with_db(tmp_path, "materialize-inactive.db")(_body)
-
-
-def test_regenerate_for_definition_rebuilds_horizon_and_preserves_completed(
-    tmp_path,
-) -> None:
-    async def _body(database):
-        children = ChildrenDao(database)
-        child = await children.create("Ada", NOW)
-
-        today = datetime.date.today()
-        horizon_end = today + datetime.timedelta(days=14)
-        start_iso = today.isoformat()
-
-        created = await create_quest_definition(
-            database,
-            "Daily chore",
-            ScheduleRule(rule_type=RuleType.DAILY, start_date=start_iso),
-            [child.id],
-            [("morning", "09:00")],
-        )
-        definition_id = created.definition.id
-
-        dao = QuestInstancesDao(database)
-        await materialize(database, start_iso, horizon_end.isoformat())
-        baseline = await dao.list_by_date_range(
-            child.id, start_iso, horizon_end.isoformat()
-        )
-        assert len(baseline) == 15
-
-        # Park a completion on tomorrow.  The rule rewrite below gives the
-        # new weekly shape a weekday two days out, so tomorrow never fires
-        # under it — only the completion's immutability keeps the row.
-        completed_due = (today + datetime.timedelta(days=1)).isoformat()
-        completed = next(r for r in baseline if r.due_date == completed_due)
-        await CompletionEventsDao(database).append(
-            completed.id,
-            child.id,
-            "completed",
-            "user",
-            f"{completed_due}T08:00:00+00:00",
-            True,
-            actor_user_id="user-1",
-        )
-
-        # Rewrite the rule through the DAO (not the business layer) so
-        # this test drives ``regenerate_for_definition`` directly.
-        new_weekday = (today + datetime.timedelta(days=2)).weekday()
-        weekly = ScheduleRule(
-            rule_type=RuleType.WEEKLY,
-            weekday_set={new_weekday},
-            start_date=start_iso,
-        )
-        await QuestDefinitionsDao(database).edit_definition(
-            definition_id, rule=schedule_rule_to_storage(weekly)
-        )
-
-        await regenerate_for_definition(database, definition_id)
-
-        records = await dao.list_by_date_range(
-            child.id, start_iso, horizon_end.isoformat()
-        )
-        by_due = {r.due_date: r for r in records}
-
-        # The completed row survived untouched (same physical id).
-        assert by_due[completed_due].id == completed.id
-
-        # Every other horizon day matches the new weekly rule exactly.
-        for offset in range(15):
-            day = today + datetime.timedelta(days=offset)
-            iso = day.isoformat()
-            if iso == completed_due:
-                assert iso in by_due
-            else:
-                assert (iso in by_due) == occurs_on(weekly, day)
-        return None
-
-    _with_db(tmp_path, "regenerate.db")(_body)
-
-
-def test_edit_quest_definition_regenerates_future_instances(tmp_path) -> None:
-    async def _body(database):
-        children = ChildrenDao(database)
-        child = await children.create("Ada", NOW)
-
-        today = datetime.date.today()
-        horizon_end = today + datetime.timedelta(days=14)
-        start_iso = today.isoformat()
-
-        created = await create_quest_definition(
-            database,
-            "Daily chore",
-            ScheduleRule(rule_type=RuleType.DAILY, start_date=start_iso),
-            [child.id],
-            ["morning"],
-        )
-        definition_id = created.definition.id
-
-        dao = QuestInstancesDao(database)
-        await materialize(database, start_iso, horizon_end.isoformat())
-
-        # The business-layer edit wires regeneration: no explicit
-        # ``regenerate_for_definition`` call is made here.
-        new_weekday = (today + datetime.timedelta(days=2)).weekday()
-        weekly = ScheduleRule(
-            rule_type=RuleType.WEEKLY,
-            weekday_set={new_weekday},
-            start_date=start_iso,
-        )
-        await edit_quest_definition(database, definition_id, rule=weekly)
-
-        records = await dao.list_by_date_range(
-            child.id, start_iso, horizon_end.isoformat()
-        )
-        by_due = {r.due_date: r for r in records}
-        for offset in range(15):
-            day = today + datetime.timedelta(days=offset)
-            assert (day.isoformat() in by_due) == occurs_on(weekly, day)
-        return None
-
-    _with_db(tmp_path, "edit-regenerates.db")(_body)
-
-
-def test_regenerate_for_child_rebuilds_horizon_preserves_history(
-    tmp_path,
-) -> None:
-    async def _body(database):
-        from custom_components.nestquest.dao_presence import (
-            PresenceOverridesDao,
-        )
-
-        children = ChildrenDao(database)
-        overrides = PresenceOverridesDao(database)
-        child = await children.create("Ada", NOW)
-
-        today = datetime.date.today()
-        horizon_end = today + datetime.timedelta(days=14)
-        start_iso = today.isoformat()
-
-        created = await create_quest_definition(
-            database,
-            "Daily chore",
-            ScheduleRule(rule_type=RuleType.DAILY, start_date=start_iso),
-            [child.id],
-            [("morning", "09:00")],
-        )
-
-        dao = QuestInstancesDao(database)
-        events = CompletionEventsDao(database)
-
-        # Instances across the full horizon: 15 daily rows.
-        await materialize(database, start_iso, horizon_end.isoformat())
-        all_future = await dao.list_by_date_range(
-            child.id, start_iso, horizon_end.isoformat()
-        )
-        assert len(all_future) == 15
-
-        # A completed instance on tomorrow: immutable, must be spared.
-        completed_due = (today + datetime.timedelta(days=1)).isoformat()
-        completed = next(r for r in all_future if r.due_date == completed_due)
-        await events.append(
-            completed.id,
-            child.id,
-            "completed",
-            "user",
-            f"{completed_due}T08:00:00+00:00",
-            True,
-            actor_user_id="user-1",
-        )
-
-        # A past instance (yesterday): raw insert bypasses the walk's
-        # no-past guard so the child-scoped delete has history to spare.
-        past_due = (today - datetime.timedelta(days=1)).isoformat()
-        await database.execute(
-            "INSERT INTO quest_instances (definition_id, child_id, "
-            "window, due_date, due_time, generated_at) "
-            "VALUES (?, ?, 'morning', ?, '09:00', ?)",
-            (created.definition.id, child.id, past_due, NOW),
-        )
-
-        # An ABSENT override covering three future dates that had
-        # instances: days 2..4 after today.
-        absent_start = (today + datetime.timedelta(days=2)).isoformat()
-        absent_end = (today + datetime.timedelta(days=4)).isoformat()
-        override = await overrides.create(
-            child.id, absent_start, absent_end, False, note="away"
-        )
-
-        await regenerate_for_child(database, child.id)
-
-        records = await dao.list_by_date_range(
-            child.id, past_due, horizon_end.isoformat()
-        )
-        by_due = {r.due_date: r for r in records}
-
-        # The now-absent days' instances are gone.
-        for offset in range(2, 5):
-            iso = (today + datetime.timedelta(days=offset)).isoformat()
-            assert iso not in by_due
-
-        # The completed instance survived untouched (same physical id).
-        assert by_due[completed_due].id == completed.id
-
-        # The past instance survived.
-        assert past_due in by_due
-
-        # Every non-absent future day still has its instance.
-        for offset in range(15):
-            iso = (today + datetime.timedelta(days=offset)).isoformat()
-            if 2 <= offset <= 4:
-                continue
-            assert iso in by_due
-
-        # Remove the override and regenerate again: the absent days return.
-        await overrides.delete(override.id)
-        await regenerate_for_child(database, child.id)
-
-        records = await dao.list_by_date_range(
-            child.id, past_due, horizon_end.isoformat()
-        )
-        by_due = {r.due_date: r for r in records}
-
-        for offset in range(15):
-            iso = (today + datetime.timedelta(days=offset)).isoformat()
-            assert iso in by_due
-
-        # The completed instance is still the same untouched row, and the
-        # past instance is still there.
-        assert by_due[completed_due].id == completed.id
-        assert by_due[completed_due].due_time == "09:00"
-        assert past_due in by_due
-        return None
-
-    _with_db(tmp_path, "regenerate-child.db")(_body)
-
-
-def test_regenerate_for_child_uses_single_anchor_across_midnight(
-    tmp_path, monkeypatch
-) -> None:
-    """A call queued across midnight must not delete-then-fail-to-rebuild.
-
-    ``regenerate_for_child`` reads "today" once as a cutoff hint, but the
-    delete clamps that cutoff to the execution-day under its own lock and
-    RETURNS the effective cutoff; the re-materialization window is then
-    anchored to the same returned day.  This test fakes a midnight rollover
-    between the two reads: the caller's hint is day0 while the delete
-    executes on day1.  The rebuild must start on day1 (so the walk's
-    no-past guard never fires) and the now-past day0 instance must survive.
-    """
-    day0 = datetime.date.today() + datetime.timedelta(days=30)
-    day1 = day0 + datetime.timedelta(days=1)
-
-    clock = {"rolled": False, "reads": 0}
-
-    def _fake_today() -> datetime.date:
-        if not clock["rolled"]:
-            return day0
-        clock["reads"] += 1
-        return day0 if clock["reads"] == 1 else day1
-
-    import custom_components.nestquest.dao_instances as dao_instances_module
-
-    monkeypatch.setattr(dao_instances_module, "_today", _fake_today)
-
-    async def _body(database):
-        children = ChildrenDao(database)
-        child = await children.create("Ada", NOW)
-
-        day0_iso = day0.isoformat()
-        horizon_end = day0 + datetime.timedelta(days=14)
-
-        created = await create_quest_definition(
-            database,
-            "Daily chore",
-            ScheduleRule(rule_type=RuleType.DAILY, start_date=day0_iso),
-            [child.id],
-            [("morning", "09:00")],
-        )
-        dao = QuestInstancesDao(database)
-
-        # Seed the horizon while the clock reads day0.
-        await materialize(database, day0_iso, horizon_end.isoformat())
-
-        # Roll the clock forward: every read after the caller's single
-        # cutoff hint now returns day1 (the delete's execution-day).
-        clock["rolled"] = True
-        clock["reads"] = 0
-
-        rebuilt = await regenerate_for_child(database, child.id)
-
-        # No raise occurred; the rebuilt window is anchored on the delete's
-        # execution-day (day1), so day1..day1+14 all exist.
-        assert rebuilt == 15
-        day1_iso = day1.isoformat()
-        day1_horizon_end = day1 + datetime.timedelta(days=14)
-        assert len(await dao.list_by_date_range(
-            child.id, day1_iso, day1_horizon_end.isoformat()
-        )) == 15
-
-        # day0 was the caller's "today" but rolled over to the past by the
-        # time the delete ran; it must survive (never delete the past).
-        assert await dao.get(
-            created.definition.id, child.id, day0_iso, "morning"
-        ) is not None
-        return rebuilt
-
-    _with_db(tmp_path, "regenerate-child-midnight.db")(_body)
-
-
-def test_regenerate_for_child_is_child_scoped(tmp_path) -> None:
-    """Regenerating one child must never touch another child's rows."""
-    async def _body(database):
-        from custom_components.nestquest.dao_presence import (
-            PresenceOverridesDao,
-        )
-
-        children = ChildrenDao(database)
-        overrides = PresenceOverridesDao(database)
-        a = await children.create("Ada", NOW)
-        b = await children.create("Bo", NOW)
-
-        today = datetime.date.today()
-        horizon_end = today + datetime.timedelta(days=14)
-        start_iso = today.isoformat()
-
-        await create_quest_definition(
-            database,
-            "Daily chore",
-            ScheduleRule(rule_type=RuleType.DAILY, start_date=start_iso),
-            [a.id, b.id],
-            [("morning", "09:00")],
-        )
-
-        dao = QuestInstancesDao(database)
-        await materialize(database, start_iso, horizon_end.isoformat())
-
-        # Baseline for child b, keyed by due_date, so we can prove its rows
-        # are byte-for-byte unchanged afterward.
-        baseline_b = {
-            r.due_date: (r.id, r.due_time, r.generated_at)
-            for r in await dao.list_by_date_range(
-                b.id, start_iso, horizon_end.isoformat()
-            )
-        }
-        assert len(baseline_b) == 15
-
-        # An ABSENT override for child a only, covering days 2..4.
-        absent_start = (today + datetime.timedelta(days=2)).isoformat()
-        absent_end = (today + datetime.timedelta(days=4)).isoformat()
-        await overrides.create(
-            a.id, absent_start, absent_end, False, note="away"
-        )
-
-        await regenerate_for_child(database, a.id)
-
-        # Child a's now-absent days vanished.
-        a_by_due = {
-            r.due_date: r
-            for r in await dao.list_by_date_range(
-                a.id, start_iso, horizon_end.isoformat()
-            )
-        }
-        for offset in range(2, 5):
-            iso = (today + datetime.timedelta(days=offset)).isoformat()
-            assert iso not in a_by_due
-
-        # Child b is untouched: same physical rows, same snapshot columns.
-        b_records = await dao.list_by_date_range(
-            b.id, start_iso, horizon_end.isoformat()
-        )
-        assert len(b_records) == 15
-        for r in b_records:
-            assert (r.id, r.due_time, r.generated_at) == baseline_b[r.due_date]
-        return None
-
-    _with_db(tmp_path, "regenerate-child-scoped.db")(_body)
-
-
-#: Fixed end-to-end anchor: 2026-06-01 is a Monday AND the 1st of its month,
-#: so the two-week custody cycle is week-aligned and the yearly rule's
-#: "1st of the anchor month" is GUARANTEED to fire inside the 28-day window
-#: (pin ``today=anchor`` throughout so the walk never clamps this fixed
-#: calendar date up to the host clock).
-_E2E_ANCHOR = "2026-06-01"
-
-#: Hand-checked oracle over 2026-06-01 .. 2026-06-28 (69 entries).  Each row
-#: is one independent (definition, child, window, due_date, due_time); the
-#: definition/child slugs are substituted with runtime ids, but the dates are
-#: literal, reviewed by hand — no recurrence/presence math is re-run here.
-#: Custody (2-week cycle anchored on the Monday): A present weeks 0 and 2,
-#: B present weeks 1 and 3, C present every day.
-_E2E_EXPECTED = [
-    # daily  [A, C]  morning 09:00, every day.  A present weeks 0, 2.
-    ("daily", "A", "morning", "2026-06-01", "09:00"),
-    ("daily", "A", "morning", "2026-06-02", "09:00"),
-    ("daily", "A", "morning", "2026-06-03", "09:00"),
-    ("daily", "A", "morning", "2026-06-04", "09:00"),
-    ("daily", "A", "morning", "2026-06-05", "09:00"),
-    ("daily", "A", "morning", "2026-06-06", "09:00"),
-    ("daily", "A", "morning", "2026-06-07", "09:00"),
-    ("daily", "A", "morning", "2026-06-15", "09:00"),
-    ("daily", "A", "morning", "2026-06-16", "09:00"),
-    ("daily", "A", "morning", "2026-06-17", "09:00"),
-    ("daily", "A", "morning", "2026-06-18", "09:00"),
-    ("daily", "A", "morning", "2026-06-19", "09:00"),
-    ("daily", "A", "morning", "2026-06-20", "09:00"),
-    ("daily", "A", "morning", "2026-06-21", "09:00"),
-    # daily  C is present every day: all 28 days.
-    ("daily", "C", "morning", "2026-06-01", "09:00"),
-    ("daily", "C", "morning", "2026-06-02", "09:00"),
-    ("daily", "C", "morning", "2026-06-03", "09:00"),
-    ("daily", "C", "morning", "2026-06-04", "09:00"),
-    ("daily", "C", "morning", "2026-06-05", "09:00"),
-    ("daily", "C", "morning", "2026-06-06", "09:00"),
-    ("daily", "C", "morning", "2026-06-07", "09:00"),
-    ("daily", "C", "morning", "2026-06-08", "09:00"),
-    ("daily", "C", "morning", "2026-06-09", "09:00"),
-    ("daily", "C", "morning", "2026-06-10", "09:00"),
-    ("daily", "C", "morning", "2026-06-11", "09:00"),
-    ("daily", "C", "morning", "2026-06-12", "09:00"),
-    ("daily", "C", "morning", "2026-06-13", "09:00"),
-    ("daily", "C", "morning", "2026-06-14", "09:00"),
-    ("daily", "C", "morning", "2026-06-15", "09:00"),
-    ("daily", "C", "morning", "2026-06-16", "09:00"),
-    ("daily", "C", "morning", "2026-06-17", "09:00"),
-    ("daily", "C", "morning", "2026-06-18", "09:00"),
-    ("daily", "C", "morning", "2026-06-19", "09:00"),
-    ("daily", "C", "morning", "2026-06-20", "09:00"),
-    ("daily", "C", "morning", "2026-06-21", "09:00"),
-    ("daily", "C", "morning", "2026-06-22", "09:00"),
-    ("daily", "C", "morning", "2026-06-23", "09:00"),
-    ("daily", "C", "morning", "2026-06-24", "09:00"),
-    ("daily", "C", "morning", "2026-06-25", "09:00"),
-    ("daily", "C", "morning", "2026-06-26", "09:00"),
-    ("daily", "C", "morning", "2026-06-27", "09:00"),
-    ("daily", "C", "morning", "2026-06-28", "09:00"),
-    # weekly  [B, C]  Mondays, morning 07:00 + evening 19:00.
-    # B present weeks 1, 3 -> Mondays 06-08 and 06-22.
-    ("weekly", "B", "morning", "2026-06-08", "07:00"),
-    ("weekly", "B", "evening", "2026-06-08", "19:00"),
-    ("weekly", "B", "morning", "2026-06-22", "07:00"),
-    ("weekly", "B", "evening", "2026-06-22", "19:00"),
-    # C present every Monday: 06-01, 06-08, 06-15, 06-22.
-    ("weekly", "C", "morning", "2026-06-01", "07:00"),
-    ("weekly", "C", "evening", "2026-06-01", "19:00"),
-    ("weekly", "C", "morning", "2026-06-08", "07:00"),
-    ("weekly", "C", "evening", "2026-06-08", "19:00"),
-    ("weekly", "C", "morning", "2026-06-15", "07:00"),
-    ("weekly", "C", "evening", "2026-06-15", "19:00"),
-    ("weekly", "C", "morning", "2026-06-22", "07:00"),
-    ("weekly", "C", "evening", "2026-06-22", "19:00"),
-    # month_day  [C]  the 15th, morning 08:00.  2026-06-15 is the 15th.
-    ("month_day", "C", "morning", "2026-06-15", "08:00"),
-    # month_wd  [C]  2nd Wednesday, morning 07:30.  June 2026's 2nd
-    # Wednesday is 06-10 (the 1st is 06-03).
-    ("month_wd", "C", "morning", "2026-06-10", "07:30"),
-    # yearly  [C]  1st of June, afternoon 12:00.  Fires on 06-01.
-    ("yearly", "C", "afternoon", "2026-06-01", "12:00"),
-    # custom  [A, C]  Saturdays + Sundays, evening 20:00.
-    # A present weeks 0, 2 -> 06-06, 06-07, 06-20, 06-21.
-    ("custom", "A", "evening", "2026-06-06", "20:00"),
-    ("custom", "A", "evening", "2026-06-07", "20:00"),
-    ("custom", "A", "evening", "2026-06-20", "20:00"),
-    ("custom", "A", "evening", "2026-06-21", "20:00"),
-    # C present every weekend day.
-    ("custom", "C", "evening", "2026-06-06", "20:00"),
-    ("custom", "C", "evening", "2026-06-07", "20:00"),
-    ("custom", "C", "evening", "2026-06-13", "20:00"),
-    ("custom", "C", "evening", "2026-06-14", "20:00"),
-    ("custom", "C", "evening", "2026-06-20", "20:00"),
-    ("custom", "C", "evening", "2026-06-21", "20:00"),
-    ("custom", "C", "evening", "2026-06-27", "20:00"),
-    ("custom", "C", "evening", "2026-06-28", "20:00"),
-]
-
-# The tuples that must disappear when Cleo (C) is overridden to ABSENT for
-# 2026-06-04 .. 2026-06-06 (a mid-window stretch): her two daily chores and
-# the Saturday-evening custom chore on 06-06.
-_E2E_REMOVED = [
-    ("daily", "C", "morning", "2026-06-04", "09:00"),
-    ("daily", "C", "morning", "2026-06-05", "09:00"),
-    ("daily", "C", "morning", "2026-06-06", "09:00"),
-    ("custom", "C", "evening", "2026-06-06", "20:00"),
-]
-
-
-def _resolve_e2e(raw, def_ids, child_ids) -> set:
-    """Substitute the oracle's definition/child slugs with runtime ids."""
-    return {
-        (def_ids[slug], child_ids[child], window, due_date, due_time)
-        for slug, child, window, due_date, due_time in raw
-    }
-
-
-async def _collect_keyed(database, child_ids, start, end) -> dict:
-    """Return {(definition_id, child_id, window, due_date): (id, due_time)}.
-
-    The stable parts of an instance — its widened key, its physical id and
-    its due_time snapshot — with the refreshable ``generated_at`` stamp
-    deliberately excluded.  Comparing two of these captures the real
-    re-run contract: no rows added/removed, ids stable (upsert refreshes
-    in place, never delete + reinsert), and due_time untouched.
-    """
-    dao = QuestInstancesDao(database)
-    keyed = {}
-    for child_id in child_ids:
-        for record in await dao.list_by_date_range(child_id, start, end):
-            key = (
-                record.definition_id,
-                record.child_id,
-                record.window,
-                record.due_date,
-            )
-            keyed[key] = (record.id, record.due_time)
-    return keyed
-
-
-async def _collect_records(database, child_ids, start, end) -> set:
-    """Return the full 7-field instance records over the children/range.
-
-    Includes the ``generated_at`` stamp, so this is only used for children
-    that should NEVER be written (Ada/Bo during Cleo's override): their
-    records are truly byte-for-byte untouched, unlike the idempotency
-    re-run where the stamp legitimately refreshes.
-    """
-    dao = QuestInstancesDao(database)
-    records = set()
-    for child_id in child_ids:
-        for record in await dao.list_by_date_range(child_id, start, end):
-            records.add(
-                (
-                    record.id,
-                    record.definition_id,
-                    record.child_id,
-                    record.window,
-                    record.due_date,
-                    record.due_time,
-                    record.generated_at,
-                )
-            )
-    return records
-
-
-def test_materialize_end_to_end_six_rule_types(tmp_path, monkeypatch) -> None:
-    import custom_components.nestquest.materialize as materialize_module
-
-    # Give each materialize run a DISTINCT batch stamp: production upserts
-    # rewrite generated_at on every re-run, so a shared pinned stamp would
-    # merely hide that rewrite.  The idempotency assertion below therefore
-    # ignores generated_at and checks the stable columns only.
-    stamps = {"n": 0}
-
-    def _distinct_stamp() -> str:
-        stamps["n"] += 1
-        return f"2026-06-01T00:00:{stamps['n']:02d}+00:00"
-
-    monkeypatch.setattr(materialize_module, "_now_stamp", _distinct_stamp)
-
-    async def _body(database):
-        from custom_components.nestquest.dao_presence import (
-            PresenceOverridesDao,
-        )
-        from custom_components.nestquest.presence import PresenceSchedule
-
-        children = ChildrenDao(database)
-        schedules = PresenceSchedulesDao(database)
-        overrides = PresenceOverridesDao(database)
-
-        a = await children.create("Ada", NOW)      # present weeks 0, 2
-        b = await children.create("Bo", NOW)       # present weeks 1, 3
-        c = await children.create("Cleo", NOW)     # no schedule: always present
-
-        anchor = datetime.date.fromisoformat(_E2E_ANCHOR)
-        start_iso = anchor.isoformat()
-        end_iso = (anchor + datetime.timedelta(days=27)).isoformat()
-
-        # Two-week custody with OPPOSITE weeks, encoded through the
-        # PresenceSchedule model on the fixed Monday anchor.
-        all_week = frozenset(range(7))
-        a_schedule = PresenceSchedule(a.id, 2, anchor, {0: all_week, 1: frozenset()})
-        b_schedule = PresenceSchedule(b.id, 2, anchor, {0: frozenset(), 1: all_week})
-        await schedules.upsert_by_child(a.id, 2, start_iso, a_schedule.encode())
-        await schedules.upsert_by_child(b.id, 2, start_iso, b_schedule.encode())
-
-        def_ids = {}
-        def_ids["daily"] = (await create_quest_definition(
-            database,
-            "Daily chore",
-            ScheduleRule(rule_type=RuleType.DAILY, start_date=start_iso),
-            [a.id, c.id],
-            [("morning", "09:00")],
-        )).definition.id
-        def_ids["weekly"] = (await create_quest_definition(
-            database,
-            "Weekly Monday chore",
-            ScheduleRule(
-                rule_type=RuleType.WEEKLY,
-                weekday_set={0},
-                start_date=start_iso,
-            ),
-            [b.id, c.id],
-            [("morning", "07:00"), ("evening", "19:00")],
-        )).definition.id
-        def_ids["month_day"] = (await create_quest_definition(
-            database,
-            "Monthly 15th chore",
-            ScheduleRule(
-                rule_type=RuleType.MONTHLY_DAY,
-                day_of_month=15,
-                start_date=start_iso,
-            ),
-            [c.id],
-            [("morning", "08:00")],
-        )).definition.id
-        def_ids["month_wd"] = (await create_quest_definition(
-            database,
-            "Monthly 2nd-Wednesday chore",
-            ScheduleRule(
-                rule_type=RuleType.MONTHLY_WEEKDAY,
-                nth_weekday=2,
-                nth_weekday_weekday=2,
-                start_date=start_iso,
-            ),
-            [c.id],
-            [("morning", "07:30")],
-        )).definition.id
-        def_ids["yearly"] = (await create_quest_definition(
-            database,
-            "Yearly first-of-June chore",
-            ScheduleRule(
-                rule_type=RuleType.YEARLY,
-                month=anchor.month,
-                day_of_month=1,
-                start_date=start_iso,
-            ),
-            [c.id],
-            [("afternoon", "12:00")],
-        )).definition.id
-        def_ids["custom"] = (await create_quest_definition(
-            database,
-            "Weekend chore",
-            ScheduleRule(
-                rule_type=RuleType.CUSTOM_DAYS,
-                weekday_set={5, 6},
-                start_date=start_iso,
-            ),
-            [a.id, c.id],
-            [("evening", "20:00")],
-        )).definition.id
-
-        child_ids = {"A": a.id, "B": b.id, "C": c.id}
-        expected = _resolve_e2e(_E2E_EXPECTED, def_ids, child_ids)
-        removed = _resolve_e2e(_E2E_REMOVED, def_ids, child_ids)
-        all_children = (a.id, b.id, c.id)
-
-        # First run: every (definition, child, window, date) tuple, exactly.
-        first = await materialize(database, start_iso, end_iso, today=anchor)
-        assert first == len(expected)
-        assert await _collect_instances(
-            database, all_children, start_iso, end_iso
-        ) == expected
-
-        # Re-run contract: the upsert refreshes each existing row IN PLACE,
-        # so the widened key set, the physical ids and each due_time are all
-        # stable (only generated_at may refresh to the new run's stamp).
-        first_keyed = await _collect_keyed(
-            database, all_children, start_iso, end_iso
-        )
-        second = await materialize(database, start_iso, end_iso, today=anchor)
-        assert second == len(expected)
-        assert await _collect_keyed(
-            database, all_children, start_iso, end_iso
-        ) == first_keyed
-
-        # Capture Ada and Bo's complete records BEFORE the override, so we
-        # can prove they are untouched afterward.
-        a_before = await _collect_records(database, (a.id,), start_iso, end_iso)
-        b_before = await _collect_records(database, (b.id,), start_iso, end_iso)
-
-        # Cleo is ABSENT 2026-06-04 .. 2026-06-06 (mid-window).
-        await overrides.create(
-            c.id, "2026-06-04", "2026-06-06", False, note="away"
-        )
-
-        # regenerate_for_child deletes + rebuilds CLEO ONLY (Ada and Bo are
-        # never touched).  It rebuilds a 14-day rolling horizon though, so
-        # the child-scoped materialize below restores the remainder of the
-        # 28-day window without ever writing another child.
-        await regenerate_for_child(database, c.id, today=anchor)
-        await materialize(
-            database, start_iso, end_iso, child_ids=[c.id], today=anchor
-        )
-
-        # Ada and Bo are byte-for-byte untouched: id, snapshot columns and
-        # generated_at alike.
-        assert await _collect_records(
-            database, (a.id,), start_iso, end_iso
-        ) == a_before
-        assert await _collect_records(
-            database, (b.id,), start_iso, end_iso
-        ) == b_before
-
-        # Exactly Cleo's override-covered tuples vanish; every other tuple
-        # survives.
-        remaining = await _collect_instances(
-            database, all_children, start_iso, end_iso
-        )
-        assert remaining == expected - removed
-        assert remaining.isdisjoint(removed)
-        return first
-
-    _with_db(tmp_path, "materialize-e2e.db")(_body)
-
-
-def test_regenerate_for_child_rejects_non_int_child_id(tmp_path) -> None:
-    async def _body(database):
-        for bad in (True, False, 1.0, "1"):
-            with pytest.raises(ValueError, match="child_id must be an integer"):
-                await regenerate_for_child(database, bad)
-        return None
-
-    _with_db(tmp_path, "regenerate-child-badid.db")(_body)

tests/test_quest_definitions.py

@@ -1279,19 +1279,11 @@ def test_set_quest_definition_active_nonexistent_definition_names_field(
     _with_db(tmp_path, "set-active-missing-definition.db")(_body)
 
 
-def test_set_quest_definition_active_preserves_completed_and_history(
+def test_set_quest_definition_active_never_deletes_or_touches_instances(
     tmp_path,
 ) -> None:
-    """Deactivation stops future generation; reactivation resumes it.
+    """Deactivation hides the definition but deletes nothing, and
-
+    pre-existing instances and completion history survive unchanged."""
-    The Feature 07 wiring makes both transitions regenerate the
-    definition's rolling horizon: future OPEN instances are removed on
-    deactivation and re-materialized on reactivation.  A pre-existing
-    COMPLETED instance and its completion events always survive both
-    transitions unchanged (regeneration never touches completed rows or
-    the past), and the append-only completion-events table is never
-    rewritten.
-    """
     async def _body(database, children, rules, definitions, child):
         created = await create_quest_definition(
             database, "Brush teeth", _daily_rule(), [child.id], ["morning"]
@@ -1318,6 +1310,9 @@ def test_set_quest_definition_active_preserves_completed_and_history(
             actor_user_id="admin-1",
         )
 
+        instance_count = await database.fetch_one(
+            "SELECT COUNT(*) FROM quest_instances"
+        )
         event_count = await database.fetch_one(
             "SELECT COUNT(*) FROM completion_events"
         )
@@ -1337,25 +1332,29 @@ def test_set_quest_definition_active_preserves_completed_and_history(
             definition_id
         )] == ["morning"]
         # The pre-existing instance and completion event survive with
-        # unchanged ids and contents, and no new event rows appeared.
+        # unchanged ids and contents, and no new rows appeared.
         assert await instances.get_by_id(instance.id) == instance
         assert await events.list_by_instance(instance.id) == [event]
+        assert await database.fetch_one(
+            "SELECT COUNT(*) FROM quest_instances"
+        ) == instance_count
         assert await database.fetch_one(
             "SELECT COUNT(*) FROM completion_events"
         ) == event_count
 
         await set_quest_definition_active(database, definition_id, True)
         assert (await definitions.get(definition_id)).is_active is True
-        # Reactivation regenerates future OPEN instances, but the
-        # completed instance and its history survive the sweep unchanged.
         assert await instances.get_by_id(instance.id) == instance
         assert await events.list_by_instance(instance.id) == [event]
+        assert await database.fetch_one(
+            "SELECT COUNT(*) FROM quest_instances"
+        ) == instance_count
         assert await database.fetch_one(
             "SELECT COUNT(*) FROM completion_events"
         ) == event_count
         return None
 
-    _with_db(tmp_path, "set-active-preserves-completed.db")(_body)
+    _with_db(tmp_path, "set-active-never-deletes.db")(_body)
 
 
 def _gated_hass(
@@ -1842,15 +1841,16 @@ def test_list_active_definitions_snapshot_coherent_under_racing_edit(
 # ---------------------------------------------------------------------------
 
 
-def test_full_lifecycle_preserves_completed_and_history(tmp_path) -> None:
+def test_full_lifecycle_never_touches_instances_or_history(tmp_path) -> None:
-    """End-to-end lifecycle preserves completed rows and append-only history.
+    """End-to-end lifecycle on one definition writes only the four
+    definition tables; ``quest_instances`` and ``completion_events`` are
+    left exactly as they were at every stage.
 
-    Each stage (create -> edit rule/windows -> assign a second child ->
+    A real instance and completion event are seeded before the lifecycle
-    unassign the original child -> deactivate -> reactivate) now
+    begins, so each stage is checked against pre-existing data being
-    regenerates the definition's future OPEN instances (Feature 07
+    mutated (not an empty table staying empty): create -> edit
-    wiring), but a pre-existing COMPLETED instance and its completion
+    rule/windows -> assign a second child -> unassign the original child
-    events survive every stage unchanged — the completed row keeps its
+    -> deactivate -> reactivate.
-    id and snapshot columns, the completion-events table stays append-only.
     """
     async def _body(database, children, rules, definitions, child):
         created = await create_quest_definition(
@@ -1876,18 +1876,24 @@ def test_full_lifecycle_preserves_completed_and_history(tmp_path) -> None:
             True,
             actor_user_id="admin-1",
         )
+        instance_count = await database.fetch_one(
+            "SELECT COUNT(*) FROM quest_instances"
+        )
         event_count = await database.fetch_one(
             "SELECT COUNT(*) FROM completion_events"
         )
 
-        async def _assert_history_preserved():
+        async def _assert_history_untouched():
             assert await instances.get_by_id(instance.id) == instance
             assert await events.list_by_instance(instance.id) == [event]
+            assert await database.fetch_one(
+                "SELECT COUNT(*) FROM quest_instances"
+            ) == instance_count
             assert await database.fetch_one(
                 "SELECT COUNT(*) FROM completion_events"
             ) == event_count
 
-        await _assert_history_preserved()
+        await _assert_history_untouched()
 
         # Edit rule and windows together; the definition's rule row is
         # rewritten in place and its window set replaced.
@@ -1908,32 +1914,32 @@ def test_full_lifecycle_preserves_completed_and_history(tmp_path) -> None:
         )
         by_name = {w.window: w.due_time for w in edited.windows}
         assert by_name == {"morning": "08:00", "evening": "19:30"}
-        await _assert_history_preserved()
+        await _assert_history_untouched()
 
         # Assign a second child: multi-assignee, both present.
         bo = await children.create("Bo", NOW)
         roster = await assign_child(database, definition_id, bo.id)
         assert sorted(c.id for c in roster) == sorted([child.id, bo.id])
-        await _assert_history_preserved()
+        await _assert_history_untouched()
 
         # Unassign the original child: only the link drops.
         assert await unassign_child(database, definition_id, child.id) is True
         assert [
             c.id for c in await definitions.list_assignees(definition_id)
         ] == [bo.id]
-        await _assert_history_preserved()
+        await _assert_history_untouched()
 
         # Deactivate, then reactivate: the definition survives both.
         deactivated = await set_quest_definition_active(
             database, definition_id, False
         )
         assert deactivated.definition.is_active is False
-        await _assert_history_preserved()
+        await _assert_history_untouched()
         reactivated = await set_quest_definition_active(
             database, definition_id, True
         )
         assert reactivated.definition.is_active is True
-        await _assert_history_preserved()
+        await _assert_history_untouched()
 
         return reactivated
 

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_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