Merge pull request 'Release: Features 06, 07, 08 (2026-09-18)' (#97) from release/2026-09-18-f06-f07-f08 into main

Reviewed-on: #97

RELEASE_NOTES.md

@@ -1,5 +1,87 @@
 # NestQuest Release Notes
 
+## Version 0.5.0 — 2026-09-18
+
+### Scope
+
+Fifth release of NestQuest, promoting Features 06, 07, and 08 from `dev` onto 0.4.0 (quest model, children registry, presence engine):
+
+- **Feature 06 — quest definitions and assignment:** business layer `quest_definitions.py` over the multi-assignee / multi-window model (D-008). Create/edit/deactivate definitions; assign/unassign children; query helpers for materialization. `ScheduleRule` ⇄ `schedule_rules` storage mapping in the DAO layer.
+- **Feature 07 — instance materialization:** `materialize.py` fans out one instance per (definition, child, window, firing date) when the recurrence rule fires and the child is present. Idempotent on `(definition_id, child_id, due_date, window)`; skips completed instances; never generates past dates. HA-local `today` and configured `horizon_days` threaded end-to-end. Regeneration on definition/assignee/presence changes; daily rollover listener; startup backfill; `nestquest.regenerate` service.
+- **Feature 08 — completion and event log:** business layer `completion.py` wrapping the existing append-only `CompletionEventsDao`. `complete_instance` / `uncomplete_instance` (reversal event, original row untouched); state derived from the latest event; HA-local `was_on_time`; derived `missed` (never stored). Actor shapes `'user'` / `'panel'` with `actor_child_id` (D-008). Permission gating of un-complete is Feature 09.
+
+### Requirements
+
+- Minimum Home Assistant version: **2024.6.0**.
+
+### Breaking changes
+
+- None at the schema layer. Schema remains **version 6** (advanced in 0.4.0). This release adds application code only.
+
+### Known Limitations
+
+- No permission decorator yet (Feature 09): `complete_instance` / `uncomplete_instance` are Python APIs, not gated HA services. The only HA service in this release is `nestquest.regenerate`.
+- No entity or event surface (Feature 10): no sensors, no `nestquest_quest_completed` bus events.
+- No panel or admin Lovelace cards (Features 12/13).
+- Un-complete is implemented but not admin-gated until Feature 09.
+- Single-instance only.
+
+### Rollback
+
+Schema version is unchanged from 0.4.0 (still 6). A code downgrade to 0.4.0 does not require a database restore for schema compatibility, but **back up `nestquest.db` (plus `-wal`/`-shm`) before upgrading** — generated instances and completion events written by 0.5.0 remain in the file after downgrade; 0.4.0 will not generate or complete them.
+
+**HACS installs:**
+
+1. Downgrade via HACS (HACS > Integrations > NestQuest > Redownload > 0.4.0).
+2. Restart Home Assistant.
+
+**Manual installs:**
+
+1. Replace `custom_components/nestquest/` with the 0.4.0 tree.
+2. Restart Home Assistant.
+
+**Repository operators:** git-revert the 0.5.0 release merge on `main`.
+
+## Version 0.4.0 — 2026-09-15
+
+### Scope
+
+Fourth release of NestQuest, shipping three completed features on top of the data layer and recurrence engine:
+
+- **Feature 14 — quest domain model (BREAKING rename, D-007/D-008):** `task_definitions`/`task_instances` are now `quest_definitions`/`quest_instances` everywhere; definitions are multi-assignee (`quest_definition_assignees`, no single child column) and multi-window (`quest_definition_windows` — morning/afternoon/evening, clock ranges in `const.py`); the instance key widens to `(definition_id, child_id, due_date, window)` so twice-daily and shared quests materialise one instance per child per window per day; `completion_events` gains `actor_child_id` (the tapped panel profile; admin events stay NULL) with a second actor-pair CHECK. Schema version advances to **6**.
+- **Feature 03 — children registry & admin allowlist:** typed business layer for child profiles (create/edit with trimmed required names and duplicate-name warnings, whole-table reorder, deactivation as the only removal path — history is never touched); the admin allowlist with a fail-closed `is_admin` resolver (empty allowlist denies everyone; the last admin cannot be removed); automatic seeding on first setup (the config-flow user is persisted in entry data, with the options-flow list and HA owner accounts as fallbacks) so the owner is never locked out; the options flow gains a multi-select picker of existing Home Assistant users.
+- **Feature 05 — presence & custody engine:** a pure `PresenceSchedule`/`PresenceOverride` model with total validation and lossless round-trips; anchor-date cycle arithmetic (D-004 — never ISO week numbers or parity); `PresenceEngine.is_present` with the always-present default for schedule-free children; date overrides beat the repeating pattern; a `next_present_dates` preview for the admin schedule UI; a full-year regression guard walking 2020 (366 days, ISO week 53) and 2015 (365 days, ISO week 53) proving the rotation never inverts at a year boundary.
+
+### Requirements
+
+- Minimum Home Assistant version: **2024.6.0**.
+
+### Breaking changes
+
+- The database schema advances from version 1 to version 6. Upgrades are automatic and data-preserving (legacy `task_*` tables are renamed; the definitions table is rebuilt for multi-assignee; legacy instances pin to the morning window; panel events backfill `actor_child_id`). **Back up `nestquest.db` before upgrading** — see Rollback.
+- Dev installs from before 2026-09-15 migrate automatically on first start.
+
+### Known Limitations
+
+- Still no entities, services, calendar platforms, or panel cards: nothing is user-visible in Home Assistant yet (Features 06-10 land the business layer, materialisation, permission gate, and entity surface).
+- No materialisation yet: instances are not generated from definitions + presence yet (Feature 07).
+- Single-instance only.
+
+### Rollback
+
+**Back up `nestquest.db` (plus `-wal`/`-shm` sidecars) BEFORE upgrading.** This release migrates the database to schema version 6 with renamed tables; an older NestQuest build refuses a version-6 database ("newer than this integration understands") and cannot read renamed tables at all — a plain downgrade is NOT possible once the database has been migrated.
+
+**Rollback procedure (after a migrated database):**
+
+1. Stop Home Assistant.
+2. Restore the pre-upgrade `nestquest.db` backup (and sidecars) you made before upgrading.
+3. Downgrade the integration (HACS > Integrations > NestQuest > Redownload > 0.3.0) or replace `custom_components/nestquest/` manually.
+4. Restart Home Assistant.
+
+Without a backup, the only path is staying on 0.4.0 (recommended) or deleting the integration and its database to start fresh (Settings > Devices & Services > NestQuest > Delete, then remove `nestquest.db`).
+
+**Repository operators:** instead of uninstalling, git-revert the release merge on `main` and restore the pre-upgrade database.
+
 ## Version 0.3.0 — 2026-09-14
 
 ### Scope
@@ -126,4 +208,4 @@ v0.1.0 is the first release — there is no previous NestQuest version to downgr
 
 **Data:** the integration does not yet create its own database file, so there is no application data. However, Home Assistant persists the config entry and its selected options — removing the integration deletes that configuration, and the option values (`horizon_days`, `day_rollover_time`, `panel_idle_timeout`) will be lost on removal.
 
-**Repository operators:** instead of uninstalling, you may git-revert the release merge on `main`, which removes the integration files entirely. End users should use the uninstall path above.
+**Repository operators:** instead of uninstalling, you may git-revert the release merge on `main`, which removes the integration files entirely. End users should use the uninstall path above.

custom_components/nestquest/completion.py

@@ -8,8 +8,10 @@ DAO or SQL directly.  This module is the only Feature-08 caller of
 instance (no-op if already done) is :func:`complete_instance`;
 un-completing (no-op if already open) is :func:`uncomplete_instance`.
 Instance current state is derived from the latest event via
-:func:`instance_state` (``open`` / ``done``); there is no status
-column.
+:func:`instance_state` (``open`` / ``done`` / ``missed``); there is
+no status column.  ``missed`` is derived for past-due open instances
+(``due_date`` before HA-local ``today``) and is never stored as an
+event_type.
 
 Actor policy matches the schema CHECKs (D-008): ``actor_source`` is
 ``'user'`` or ``'panel'`` only — never ``'service'``.  ``'user'``
@@ -95,6 +97,37 @@ def _completion_moment(
     return completion_date, now.time()
 
 
+def _resolve_today(today: datetime.date | None) -> datetime.date:
+    """Return the threaded HA-local date, or the host calendar date."""
+    if today is None:
+        return datetime.date.today()
+    return today
+
+
+def _derived_state(
+    instance: QuestInstanceRecord,
+    latest: CompletionEventRecord | None,
+    today: datetime.date,
+) -> str:
+    """Return ``open``, ``done``, or ``missed`` from event plus due date.
+
+    A latest completed event is ``done`` even when past due.  No events
+    or a latest uncompleted event is ``open``, or ``missed`` when
+    ``due_date`` is before ``today``.  ``missed`` is never an event_type.
+    """
+    if latest is None or latest.event_type == EVENT_UNCOMPLETED:
+        due_date = datetime.date.fromisoformat(instance.due_date)
+        if due_date < today:
+            return "missed"
+        return "open"
+    if latest.event_type == EVENT_COMPLETED:
+        return "done"
+    raise ValueError(
+        f"event_type must be '{EVENT_COMPLETED}' or "
+        f"'{EVENT_UNCOMPLETED}', got {latest.event_type!r}"
+    )
+
+
 def _was_on_time(
     instance: QuestInstanceRecord,
     now: datetime.datetime | None,
@@ -291,15 +324,21 @@ async def append_event(
 async def instance_state(
     database: NestQuestDatabase,
     instance_id: int,
+    *,
+    today: datetime.date | None = None,
 ) -> str:
-    """Return ``open`` or ``done`` from the instance's latest event.
+    """Return ``open``, ``done``, or ``missed`` from the latest event.
 
-    No events, or a latest event of uncompleted, is ``open``.  A latest
-    event of completed is ``done``.  Unknown ``instance_id`` raises
-    ValueError naming the field.  Existence and the latest event are
-    read inside the connection lock so the answer is one snapshot.
+    No events, or a latest event of uncompleted, is ``open`` unless
+    ``due_date`` is before ``today`` (HA-local, threaded), in which
+    case it is ``missed``.  A latest event of completed is ``done``
+    even when past due.  ``missed`` is never stored as an event_type.
+    Unknown ``instance_id`` raises ValueError naming the field.
+    Existence and the latest event are read inside the connection lock
+    so the answer is one snapshot.
     """
     instance_id = _validate_int_id(instance_id, "instance_id")
+    today_date = _resolve_today(today)
     async with _connection_lock(database):
         instance = await QuestInstancesDao(database).get_by_id(instance_id)
         if instance is None:
@@ -309,14 +348,7 @@ async def instance_state(
         latest = await CompletionEventsDao(database).get_latest_for_instance(
             instance_id
         )
-    if latest is None or latest.event_type == EVENT_UNCOMPLETED:
-        return "open"
-    if latest.event_type == EVENT_COMPLETED:
-        return "done"
-    raise ValueError(
-        f"event_type must be '{EVENT_COMPLETED}' or "
-        f"'{EVENT_UNCOMPLETED}', got {latest.event_type!r}"
-    )
+    return _derived_state(instance, latest, today_date)
 
 
 async def complete_instance(
@@ -385,19 +417,23 @@ async def uncomplete_instance(
     actor_user_id: str | None = None,
     actor_child_id: int | None = None,
     now: datetime.datetime | None = None,
+    today: datetime.date | None = None,
 ) -> str:
     """Append an uncompleted event unless the instance is already open.
 
-    Returns the derived state ``open``.  An already-open instance is a
-    no-op: nothing is appended.  Unknown ``instance_id`` raises
-    ValueError naming the field.  Existence, latest-event, and the
-    append run under one connection lock so a concurrent uncomplete
-    cannot double-append.  The original completed row is not modified.
+    Returns the derived state ``open``, or ``missed`` when the instance
+    is past due (``due_date`` before HA-local ``today``).  An
+    already-open instance is a no-op: nothing is appended.  Unknown
+    ``instance_id`` raises ValueError naming the field.  Existence,
+    latest-event, and the append run under one connection lock so a
+    concurrent uncomplete cannot double-append.  The original completed
+    row is not modified.
     """
     instance_id = _validate_int_id(instance_id, "instance_id")
     actor_source, actor_user_id, actor_child_id = _validate_actor(
         actor_source, actor_user_id, actor_child_id
     )
+    today_date = _resolve_today(today)
     async with _reentrant_connection_lock(database):
         instance = await QuestInstancesDao(database).get_by_id(instance_id)
         if instance is None:
@@ -408,13 +444,13 @@ async def uncomplete_instance(
             instance_id
         )
         if latest is None or latest.event_type == EVENT_UNCOMPLETED:
-            return "open"
+            return _derived_state(instance, latest, today_date)
         if latest.event_type != EVENT_COMPLETED:
             raise ValueError(
                 f"event_type must be '{EVENT_COMPLETED}' or "
                 f"'{EVENT_UNCOMPLETED}', got {latest.event_type!r}"
             )
-        await append_event(
+        latest = await append_event(
             database,
             instance.id,
             instance.child_id,
@@ -425,4 +461,35 @@ async def uncomplete_instance(
             was_on_time=None,
             now=now,
         )
-    return "open"
+    return _derived_state(instance, latest, today_date)
+
+
+async def list_missed_for_child(
+    database: NestQuestDatabase,
+    child_id: int,
+    range_start: str,
+    range_end: str,
+    *,
+    today: datetime.date | None = None,
+) -> list[QuestInstanceRecord]:
+    """Return the child's missed instances due in the closed date range.
+
+    Missed means the latest event state is open and ``due_date`` is
+    before ``today`` (HA-local, threaded).  Uses
+    :meth:`QuestInstancesDao.list_by_date_range` plus derived state.
+    Never appends a missed event.  Instances and latest events are
+    read inside the connection lock so the list is one snapshot.
+    """
+    child_id = _validate_int_id(child_id, "child_id")
+    today_date = _resolve_today(today)
+    async with _connection_lock(database):
+        instances = await QuestInstancesDao(database).list_by_date_range(
+            child_id, range_start, range_end
+        )
+        events = CompletionEventsDao(database)
+        missed: list[QuestInstanceRecord] = []
+        for instance in instances:
+            latest = await events.get_latest_for_instance(instance.id)
+            if _derived_state(instance, latest, today_date) == "missed":
+                missed.append(instance)
+    return missed

custom_components/nestquest/manifest.json

@@ -10,5 +10,5 @@
   "iot_class": "local_polling",
   "issue_tracker": "https://github.com/talon2king/NestQuest/issues",
   "requirements": [],
-  "version": "0.3.0"
+  "version": "0.5.0"
 }

pyproject.toml

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

tests/test_completion.py

@@ -12,6 +12,7 @@ from custom_components.nestquest.completion import (
     append_event,
     complete_instance,
     instance_state,
+    list_missed_for_child,
     uncomplete_instance,
 )
 from custom_components.nestquest.dao_children import ChildrenDao
@@ -340,6 +341,7 @@ def test_module_never_exposes_update_or_delete() -> None:
     assert "instance_state" in public
     assert "complete_instance" in public
     assert "uncomplete_instance" in public
+    assert "list_missed_for_child" in public
     source = inspect.getsource(completion)
     assert "UPDATE" not in source
     assert "DELETE" not in source
@@ -1123,3 +1125,326 @@ def test_uncomplete_instance_concurrent_second_call_is_noop(tmp_path) -> None:
             await database.close()
 
     _run(_main())
+
+
+# ---------------------------------------------------------------------------
+# missed: derived for past-due open instances, never stored
+# ---------------------------------------------------------------------------
+
+
+def test_append_event_rejects_missed_event_type() -> None:
+    async def _body():
+        with pytest.raises(ValueError, match="event_type"):
+            await append_event(
+                object(),
+                1,
+                1,
+                "missed",
+                actor_source="user",
+                actor_user_id="user-1",
+                was_on_time=True,
+            )
+
+    _run(_body())
+
+
+def test_instance_state_missed_when_past_due_and_open(tmp_path) -> None:
+    async def _body(database, child, instance):
+        due = datetime.date.fromisoformat(instance.due_date)
+        later = due + datetime.timedelta(days=1)
+        assert await instance_state(database, instance.id, today=later) == "missed"
+        rows = await CompletionEventsDao(database).list_by_instance(instance.id)
+        assert rows == []
+
+    _with_db(tmp_path, "state-missed-open.db")(_body)
+
+
+def test_instance_state_open_when_due_today(tmp_path) -> None:
+    async def _body(database, child, instance):
+        due = datetime.date.fromisoformat(instance.due_date)
+        assert await instance_state(database, instance.id, today=due) == "open"
+
+    _with_db(tmp_path, "state-open-due-today.db")(_body)
+
+
+def test_instance_state_done_when_past_due_and_completed(tmp_path) -> None:
+    async def _body(database, child, instance):
+        due = datetime.date.fromisoformat(instance.due_date)
+        await complete_instance(
+            database,
+            instance.id,
+            actor_source="user",
+            actor_user_id="user-1",
+            today=due,
+        )
+        later = due + datetime.timedelta(days=1)
+        assert await instance_state(database, instance.id, today=later) == "done"
+
+    _with_db(tmp_path, "state-done-past-due.db")(_body)
+
+
+def test_instance_state_missed_after_uncompleted_when_past_due(tmp_path) -> None:
+    async def _body(database, child, instance):
+        due = datetime.date.fromisoformat(instance.due_date)
+        await append_event(
+            database,
+            instance.id,
+            child.id,
+            EVENT_COMPLETED,
+            actor_source="user",
+            actor_user_id="user-1",
+            was_on_time=True,
+        )
+        await append_event(
+            database,
+            instance.id,
+            child.id,
+            EVENT_UNCOMPLETED,
+            actor_source="user",
+            actor_user_id="user-1",
+        )
+        later = due + datetime.timedelta(days=1)
+        assert await instance_state(database, instance.id, today=later) == "missed"
+
+    _with_db(tmp_path, "state-missed-uncompleted.db")(_body)
+
+
+def test_instance_state_missed_uses_host_today_when_unthreaded(tmp_path) -> None:
+    async def _body(database, child, instance):
+        yesterday = datetime.date.today() - datetime.timedelta(days=1)
+        past = await QuestInstancesDao(database).upsert(
+            instance.definition_id,
+            child.id,
+            yesterday.isoformat(),
+            _now_stamp(),
+            window="afternoon",
+            today=yesterday,
+        )
+        assert await instance_state(database, past.id) == "missed"
+        rows = await CompletionEventsDao(database).list_by_instance(past.id)
+        assert rows == []
+        assert all(row.event_type != "missed" for row in rows)
+
+    _with_db(tmp_path, "state-missed-host-today.db")(_body)
+
+
+def test_uncomplete_past_due_done_returns_missed_not_done(tmp_path) -> None:
+    async def _body(database, child, instance):
+        due = datetime.date.fromisoformat(instance.due_date)
+        await complete_instance(
+            database,
+            instance.id,
+            actor_source="user",
+            actor_user_id="user-1",
+            today=due,
+        )
+        later = due + datetime.timedelta(days=1)
+        assert await instance_state(database, instance.id, today=later) == "done"
+        state = await uncomplete_instance(
+            database,
+            instance.id,
+            actor_source="user",
+            actor_user_id="user-1",
+            today=later,
+        )
+        assert state == "missed"
+        assert await instance_state(database, instance.id, today=later) == "missed"
+        rows = await CompletionEventsDao(database).list_by_instance(instance.id)
+        assert [row.event_type for row in rows] == [
+            EVENT_COMPLETED,
+            EVENT_UNCOMPLETED,
+        ]
+        assert all(row.event_type != "missed" for row in rows)
+
+    _with_db(tmp_path, "uncomplete-past-due-missed.db")(_body)
+
+
+def test_uncomplete_past_due_already_open_is_noop_missed(tmp_path) -> None:
+    async def _body(database, child, instance):
+        later = datetime.date.fromisoformat(instance.due_date) + datetime.timedelta(
+            days=1
+        )
+        events = CompletionEventsDao(database)
+        assert await events.list_by_instance(instance.id) == []
+        state = await uncomplete_instance(
+            database,
+            instance.id,
+            actor_source="user",
+            actor_user_id="user-1",
+            today=later,
+        )
+        assert state == "missed"
+        assert await events.list_by_instance(instance.id) == []
+
+    _with_db(tmp_path, "uncomplete-past-due-noop.db")(_body)
+
+
+def test_complete_instance_of_missed_returns_done(tmp_path) -> None:
+    async def _body(database, child, instance):
+        due = datetime.date.fromisoformat(instance.due_date)
+        later = due + datetime.timedelta(days=1)
+        assert await instance_state(database, instance.id, today=later) == "missed"
+        state = await complete_instance(
+            database,
+            instance.id,
+            actor_source="user",
+            actor_user_id="user-1",
+            now=_ha_local(later, 8, 0),
+            today=later,
+        )
+        assert state == "done"
+        assert await instance_state(database, instance.id, today=later) == "done"
+        rows = await CompletionEventsDao(database).list_by_instance(instance.id)
+        assert len(rows) == 1
+        assert rows[0].event_type == EVENT_COMPLETED
+        assert rows[0].was_on_time is False
+
+    _with_db(tmp_path, "complete-missed.db")(_body)
+
+
+def test_list_missed_for_child_over_date_range(tmp_path) -> None:
+    async def _body(database, child, instance):
+        due = datetime.date.fromisoformat(instance.due_date)
+        later_due = due + datetime.timedelta(days=1)
+        other = await QuestInstancesDao(database).upsert(
+            instance.definition_id,
+            child.id,
+            later_due.isoformat(),
+            _now_stamp(),
+            window="morning",
+        )
+        await complete_instance(
+            database,
+            instance.id,
+            actor_source="user",
+            actor_user_id="user-1",
+            today=due,
+        )
+        today = later_due + datetime.timedelta(days=1)
+        found = await list_missed_for_child(
+            database,
+            child.id,
+            instance.due_date,
+            later_due.isoformat(),
+            today=today,
+        )
+        assert [row.id for row in found] == [other.id]
+        events = CompletionEventsDao(database)
+        assert await events.list_by_instance(other.id) == []
+        done_rows = await events.list_by_instance(instance.id)
+        assert [row.event_type for row in done_rows] == [EVENT_COMPLETED]
+        assert all(row.event_type != "missed" for row in done_rows)
+
+    _with_db(tmp_path, "list-missed-range.db")(_body)
+
+
+def test_list_missed_for_child_empty_when_due_today(tmp_path) -> None:
+    async def _body(database, child, instance):
+        due = datetime.date.fromisoformat(instance.due_date)
+        found = await list_missed_for_child(
+            database,
+            child.id,
+            instance.due_date,
+            instance.due_date,
+            today=due,
+        )
+        assert found == []
+
+    _with_db(tmp_path, "list-missed-due-today.db")(_body)
+
+
+def test_list_missed_for_child_rejects_non_integer_id() -> None:
+    async def _body():
+        with pytest.raises(ValueError, match="child_id"):
+            await list_missed_for_child(object(), "1", D1, D1)
+        with pytest.raises(ValueError, match="child_id"):
+            await list_missed_for_child(object(), True, D1, D1)
+
+    _run(_body())
+
+
+# ---------------------------------------------------------------------------
+# lifecycle: complete → uncomplete → complete
+# ---------------------------------------------------------------------------
+
+
+def test_complete_uncomplete_complete_three_events_final_done(
+    tmp_path,
+) -> None:
+    async def _body(database, child, instance):
+        due_date = datetime.date.fromisoformat(instance.due_date)
+        later = due_date + datetime.timedelta(days=1)
+        instance = await QuestInstancesDao(database).upsert(
+            instance.definition_id,
+            child.id,
+            instance.due_date,
+            _now_stamp(),
+            window=instance.window,
+            due_time="12:00",
+        )
+        events = CompletionEventsDao(database)
+
+        first = await complete_instance(
+            database,
+            instance.id,
+            actor_source="panel",
+            actor_child_id=child.id,
+            now=_ha_local(due_date, 11, 0),
+            today=due_date,
+        )
+        assert first == "done"
+        before_uncomplete = await events.list_by_instance(instance.id)
+        assert len(before_uncomplete) == 1
+        original = before_uncomplete[0]
+        assert original.event_type == EVENT_COMPLETED
+        assert original.was_on_time is True
+        assert original.actor_source == "panel"
+        assert original.actor_user_id is None
+        assert original.actor_child_id == child.id
+        assert await instance_state(database, instance.id, today=later) == "done"
+
+        reversed_state = await uncomplete_instance(
+            database,
+            instance.id,
+            actor_source="user",
+            actor_user_id="user-1",
+            now=_ha_local(later, 8, 0),
+            today=later,
+        )
+        assert reversed_state == "missed"
+        assert await instance_state(database, instance.id, today=later) == "missed"
+
+        second = await complete_instance(
+            database,
+            instance.id,
+            actor_source="panel",
+            actor_child_id=child.id,
+            now=_ha_local(later, 9, 0),
+            today=later,
+        )
+        assert second == "done"
+        assert await instance_state(database, instance.id, today=later) == "done"
+
+        after = await events.list_by_instance(instance.id)
+        assert [row.event_type for row in after] == [
+            EVENT_COMPLETED,
+            EVENT_UNCOMPLETED,
+            EVENT_COMPLETED,
+        ]
+        assert after[0].id == original.id
+        assert after[0].occurred_at == original.occurred_at
+        assert after[0].actor_source == original.actor_source
+        assert after[0].actor_user_id == original.actor_user_id
+        assert after[0].actor_child_id == original.actor_child_id
+        assert after[0].was_on_time is True
+        assert after[1].actor_source == "user"
+        assert after[1].actor_user_id == "user-1"
+        assert after[1].actor_child_id is None
+        assert after[1].was_on_time is None
+        assert after[2].actor_source == "panel"
+        assert after[2].actor_user_id is None
+        assert after[2].actor_child_id == child.id
+        assert after[2].was_on_time is False
+        assert all(row.event_type != "missed" for row in after)
+
+    _with_db(tmp_path, "lifecycle-three.db")(_body)

uv.lock

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