Automatically prepare releases for completed features

RELEASE_NOTES.md

@@ -1,135 +1,27 @@
 # NestQuest Release Notes
 
-## Version 0.6.0 — 2026-09-23
+## Unreleased
 
-### Scope
-
-Sixth release of NestQuest, promoting the re-imagined architecture
-(Features 15, 16, 18 and 20) and the foreground development-orchestration
-tooling from `dev` onto 0.5.0. This is a major architectural change: the
-Home Assistant integration becomes a thin client of a standalone NestQuest
-API service that owns the database.
-
-- **Feature 15 — Domain Core Extraction:** all domain code (schema,
-  migrations, database access, the DAOs, the pure recurrence/presence
-  engines, materialization, completion, the SSE-free event payload
-  builders, the panel snapshot builder, the children/definitions/allowlist
-  business layers, and an explicit settings object) now lives in a
-  Home-Assistant-free package bundled inside the integration at
-  `custom_components/nestquest/core/`. The SQLite schema and migration
-  versions are unchanged, so an existing `nestquest.db` opens without
-  migration. Covered by a no-Home-Assistant end-to-end smoke test.
-  (Tasks d0b691d8, 510c1f78, 4dd8f870, 628473ad.)
-- **Feature 16 — NestQuest API Service:** a standalone FastAPI service
-  (`api/`) that imports `core/` and is the only writer of the database.
-  Panel plane (`/api/v1/panel/*`) is authenticated by a static service
-  token: household snapshot and an idempotent complete route. Admin plane
-  (`/api/v1/admin/*`): children, quest definitions, presence
-  schedule/override, uncomplete, regenerate, history query + CSV export,
-  and settings — authenticated by an Authentik OIDC JWT (issuer, audience,
-  JWKS signature and expiry) plus membership in `nestquest-admins`, with
-  the panel service token rejected outright. A server-sent-events stream
-  publishes the quest-completed, quest-uncompleted, quest-missed and
-  child-day-complete transitions; the missed sweep runs in the API with a
-  cross-process-safe watermark. `/health` and the OpenAPI document are
-  served. (Tasks 042dfc5c, ae7e90ae, 1860ef76, 4d7bae00, 44c93cfd,
-  e70e6bfb, 0f2afb29, e4845baa, b586a2f1, e4a9d31b, da0226b3, 2d2dda53,
-  2b3de7e5, 9047a97b, 9a118da9, 058c7b69, a232c4f5.)
-- **Feature 18 — HA Integration as API Client:** the integration no longer
-  owns a database. It polls `GET /api/v1/panel/snapshot` and builds the
-  existing sensors (entity ids and per-child instance payload shape
-  unchanged), subscribes to the SSE stream and re-fires the four HA bus
-  events, proxies `nestquest.complete_quest` to the panel complete route,
-  and caches the last-good snapshot so a brief API outage does not blank
-  the panel. The HA admin services and the service permission gate are
-  removed; only the panel completion path remains. (Tasks 37d5e806,
-  6e70d166, b1ed9c45, 47c7c90e, d25b875f, d04f5bf3, ad67fc44.)
-- **Feature 20 — Zero-Config Panel Dashboard:** the panel installs with no
-  hand-written card YAML and no manual dashboard creation. The cards
-  auto-discover children from a household entity attribute (ordered by the
-  API's `sort_order`), a Lovelace dashboard strategy generates the
-  party-board view and one quest-log view per child at render time with
-  computed navigation paths, and the integration registers the dashboard
-  on first setup. Navigation and the panel transitions match the design
-  mockups. (Tasks 1b6d91d2, c859af23, c2d4dd8e, 107b8fbe, 50067c1f,
-  fc69c940, 67775be9.)
-- **Development orchestration tooling:** durable OpenCode controller and
-  role launchers, the foreground terminal orchestrator, the independent
-  review/approval gates, and the automatic release-preparation policy.
-
-### Requirements
-
-- Minimum Home Assistant version: **2024.6.0**.
-- A running NestQuest API service, reachable at the base URL and panel
-  service token configured in the integration options. The API service
-  source ships in `api/`; there is no container image, compose file or
-  deployment runbook in this release, and Feature 17 — the deployment
-  (TLS reverse proxy, Authentik, network separation, backups) — is **not**
-  part of this release and must be completed before the integration is
-  functional. See `docs/ARCHITECTURE.md` for the target design.
-
-### Breaking changes
-
-- **The HA integration no longer owns a database.** It reads exclusively
-  from the NestQuest API. The local `nestquest.db` is no longer opened,
-  migrated or written by the integration (the file is left untouched on
-  disk). Without a reachable API the entities become unavailable after the
-  configured staleness threshold; the panel serves the last-good snapshot
-  in the meantime.
-- **HA admin services are removed** (`uncomplete`, quest-definition
-  create/update/set-active, presence pattern/override, CSV export,
-  `manage_child`, `regenerate`) and the HA-side permission gate is gone.
-  Admin operations move to the API, and — once Feature 19 lands — the
-  admin PWA. Any automation that called an admin service must be
-  repointed at the API.
-- **Logger namespaces moved** under `custom_components.nestquest.core.*`:
-  the migrations runner now logs under
-  `custom_components.nestquest.core.migrations` (previously
-  `custom_components.nestquest.migrations`), and the children registry and
-  admin allowlist log under `custom_components.nestquest.core.children` and
-  `custom_components.nestquest.core.admin_allowlist`. The parent
-  `custom_components.nestquest` logger still catches all three; only users
-  who pinned a leaf logger name by its old spelling must update.
-- **The panel installs with no configuration.** `child_order`,
-  `quest_log_path` and `board_path` are no longer required (an explicit
-  value still wins). The integration registers a `custom:nestquest-party`
-  dashboard on setup; point TouchHub at it.
-- **Schema is unchanged at version 7** — no migration runs on upgrade.
-
-### Known Limitations
-
-- **Feature 17 (API deployment and identity) is not in this release.** The
-  API service source ships in `api/`, but no container image, compose
-  file, TLS reverse proxy, Authentik application/provider/`nestquest-admins`
-  group, proven network separation of the panel routes, or backup/restore
-  is included. Feature 17's containerization groundwork was completed on
-  its own feature branch, which is **not** merged into `dev` and therefore
-  is not part of this release. Until that deployment is completed the
-  integration has nothing to talk to.
-- **Feature 19 (admin PWA) is not in this release.** There is no admin UI
-  in 0.6.0; admin operations are reachable only through the API directly.
-- Moving the household database from Home Assistant to the API box is a
-  manual file copy (the schema is unchanged).
-- Single household; single API service.
-
-### Rollback
-
-Schema version is unchanged (7), so no migration is involved in either
-direction. Nevertheless **back up `nestquest.db` (plus `-wal`/`-shm`)
-before upgrading**: 0.6.0 never touches it, and a downgrade to 0.5.0
-resumes using exactly that file.
-
-**HACS installs:**
-
-1. Downgrade via HACS (HACS > Integrations > NestQuest > Redownload > 0.5.0).
-2. Restart Home Assistant.
-
-**Manual installs:**
-
-1. Replace `custom_components/nestquest/` with the 0.5.0 tree.
-2. Restart Home Assistant.
-
-**Repository operators:** git-revert the 0.6.0 release merge on `main`.
+- **Storage layer extraction (task d0b691d8):** the SQLite storage layer
+  (schema, migrations, db, store, const, recurrence, DAOs) is bundled
+  under `custom_components/nestquest/core/`, with the integration's
+  original module names preserved as re-export shims.
+- **Logger namespace change (breaking for logging configuration):** the
+  migrations runner now logs under
+  `custom_components.nestquest.core.migrations` instead of
+  `custom_components.nestquest.migrations`. Users who tuned the old
+  logger name (e.g. in `logger.yaml` or `configuration.yaml`) must
+  update the entry to keep that level, as the old name no longer
+  receives migration log output.
+- **Additional logger namespace moves:** the children registry and the
+  admin allowlist business layers now log under
+  `custom_components.nestquest.core.children` and
+  `custom_components.nestquest.core.admin_allowlist` respectively
+  (moved with the engines/business-layer extraction, task 510c1f78).
+  The parent `custom_components.nestquest` logger still catches both,
+  so users who tune the parent rather than the leaf names are
+  unaffected; only users who pinned a leaf logger name by its old
+  spelling need to update.
 
 ## Version 0.5.0 — 2026-09-18
 

api/routes_admin.py

@@ -116,22 +116,6 @@ owns every rule so the two routes cannot drift:
   a ``Content-Disposition`` attachment filename and the documented,
   stable header row (Admin spec §5 event-row fields).
 
-The snapshot route (task ef3f4877) is the admin-plane twin of the
-panel's ``GET /api/v1/panel/snapshot`` for the admin PWA's Today tab —
-the PWA is internet-facing and never holds the panel service token
-(D-012), so it reads the same snapshot here:
-
-- ``GET /snapshot`` threads ONE clock read (:func:`_local_now`) into
-  :func:`nestquest_core.snapshot.build_snapshot` and shapes each
-  child's instances through
-  :func:`nestquest_core.snapshot.instance_payload` with
-  ``include_missed=True`` — admin payloads KEEP missed instances with
-  their ``missed`` state (D-009), where the panel omits them.  The
-  body is the panel's documented shape (``today_iso``, ``cycle_day``,
-  ``children`` with the per-child presence, rollup counts and
-  ``instances``); the builder, the state derivation and the shaping
-  all live in the core.
-
 The settings routes (task 2b3de7e5) follow the same pattern over
 :mod:`nestquest_core.settings_store` — the API's OWN durable settings
 store.  The API now OWNS settings in the database (a validated JSON
@@ -251,7 +235,7 @@ import datetime
 from typing import Annotated, Literal, NoReturn
 
 from fastapi import APIRouter, Depends, HTTPException, Request, Response
-from pydantic import BaseModel, StrictBool, field_validator, model_validator
+from pydantic import BaseModel, field_validator, model_validator
 
 from api import transitions as api_transitions
 from api.auth import require_admin
@@ -270,7 +254,6 @@ from api.nestquest_core import (
     core_recurrence,
     core_settings,
     core_settings_store,
-    core_snapshot,
     core_sweep,
 )
 
@@ -363,18 +346,11 @@ class AdminQuestDefinitionResponse(BaseModel):
     description: str | None
     icon: str | None
     is_active: bool
-    skip_on_away: bool
     rule: AdminRuleResponse
     assignees: list[AdminAssigneeResponse]
     windows: list[AdminDefinitionWindowResponse]
 
 
-class AdminQuestDefinitionListResponse(BaseModel):
-    """The definitions list: every definition, active AND inactive, by id."""
-
-    definitions: list[AdminQuestDefinitionResponse]
-
-
 class AdminChildCreateRequest(BaseModel):
     """The body of ``POST /api/v1/admin/children``.
 
@@ -451,9 +427,8 @@ class AdminQuestDefinitionCreateRequest(BaseModel):
     ``title``, ``rule``, ``assignee_child_ids`` and ``windows`` are
     required (the core rejects an empty title, a non-list or empty
     assignee/window list, and unknown window names); ``description``
-    and ``icon`` are optional and default to NULL through the core, and
-    ``skip_on_away`` is optional and defaults to true (no instance on a
-    date the child is absent).  ``windows`` entries are a window name (``morning``) or a two-item
+    and ``icon`` are optional and default to NULL through the core.
+    ``windows`` entries are a window name (``morning``) or a two-item
     ``[window, due_time]`` pair whose due time is a strict 24-hour
     HH:MM (or ``null`` for none) — both forms the core normalizes.
     """
@@ -464,7 +439,6 @@ class AdminQuestDefinitionCreateRequest(BaseModel):
     windows: list[str | tuple[str, str | None]]
     description: str | None = None
     icon: str | None = None
-    skip_on_away: StrictBool = True
 
 
 class AdminQuestDefinitionEditRequest(BaseModel):
@@ -479,8 +453,7 @@ class AdminQuestDefinitionEditRequest(BaseModel):
     ``rule`` or ``windows`` is passed and rejected by the core.  A
     supplied ``windows`` list REPLACES the whole window set, and
     ``assignees`` are deliberately absent — assignment is not settable
-    through this route.  An omitted (or ``null``) ``skip_on_away``
-    keeps the stored value.
+    through this route.
     """
 
     title: str | None = None
@@ -488,7 +461,6 @@ class AdminQuestDefinitionEditRequest(BaseModel):
     icon: str | None = None
     rule: AdminRuleRequest | None = None
     windows: list[str | tuple[str, str | None]] | None = None
-    skip_on_away: StrictBool | None = None
 
 
 class AdminQuestDefinitionActiveRequest(BaseModel):
@@ -711,59 +683,6 @@ class AdminMissedSweepResponse(BaseModel):
     fired: int
 
 
-class AdminInstancePayload(BaseModel):
-    """One instance in the admin snapshot payload.
-
-    Mirrors :func:`nestquest_core.snapshot.instance_payload` with
-    ``include_missed=True``: ``state`` is ``open`` | ``completed`` |
-    ``missed`` (admin payloads keep missed instances, D-009),
-    ``on_time`` passes the completion event's flag through verbatim
-    (``None`` unless completed), and ``completed_at`` is the event's
-    UTC timestamp when completed.
-    """
-
-    id: int
-    definition_id: int
-    child_id: int
-    title: str
-    icon: str | None
-    window: str
-    due_time: str | None
-    state: str
-    overdue: bool
-    completed_at: str | None
-    on_time: bool | None
-
-
-class AdminChildSnapshotPayload(BaseModel):
-    """One child's day: presence, rollup counts, and today's instances."""
-
-    child_id: int
-    child_name: str
-    present: bool
-    #: ISO date of the child's next present day while they are away;
-    #: ``None`` when the child is present today.
-    next_present: str | None
-    due_today: int
-    completed_today: int
-    remaining_today: int
-    completion_pct: int
-    instances: list[AdminInstancePayload]
-
-
-class AdminSnapshotResponse(BaseModel):
-    """Today's whole household snapshot for the admin Today tab.
-
-    The panel snapshot's shape (``today_iso``, ``cycle_day``,
-    ``children`` in the household's sort order), with missed instances
-    kept in each child's ``instances``.
-    """
-
-    today_iso: str
-    cycle_day: int
-    children: list[AdminChildSnapshotPayload]
-
-
 #: 404 detail for a child id the core layer reports as non-existent.
 _CHILD_NOT_FOUND_DETAIL = "Child not found"
 
@@ -968,7 +887,6 @@ def _quest_definition_response(
         description=bundle.definition.description,
         icon=bundle.definition.icon,
         is_active=bundle.definition.is_active,
-        skip_on_away=bundle.definition.skip_on_away,
         rule=_rule_response(bundle.rule),
         assignees=[
             AdminAssigneeResponse(id=child.id, display_name=child.display_name)
@@ -1180,32 +1098,6 @@ async def admin_reorder_children(
     return {"status": "ok"}
 
 
-@router.get(
-    "/quest-definitions",
-    summary="List quest definitions",
-    response_model=AdminQuestDefinitionListResponse,
-)
-async def admin_list_quest_definitions(
-    request: Request,
-) -> AdminQuestDefinitionListResponse:
-    """Return every quest definition in rising id order.
-
-    Requires a valid admin JWT (the router's shared
-    :func:`~api.auth.require_admin` dependency — the ONE check; this
-    handler performs NO auth of its own).  Thin adapter: one
-    :func:`nestquest_core.quest_definitions.list_all_definitions` call,
-    active AND inactive definitions included (the admin screen manages
-    both), each serialized exactly as the create/edit responses are.
-    """
-    state: DatabaseState = request.app.state.db
-    bundles = await core_quest_definitions.list_all_definitions(
-        state.database
-    )
-    return AdminQuestDefinitionListResponse(
-        definitions=[_quest_definition_response(bundle) for bundle in bundles]
-    )
-
-
 @router.post(
     "/quest-definitions",
     summary="Create a quest definition",
@@ -1240,7 +1132,6 @@ async def admin_create_quest_definition(
             body.windows,
             description=body.description,
             icon=body.icon,
-            skip_on_away=body.skip_on_away,
         )
     except ValueError as error:
         _raise_quest_definition_error(error)
@@ -1838,51 +1729,4 @@ async def admin_run_missed_sweep(
     return AdminMissedSweepResponse(fired=len(events))
 
 
-@router.get(
-    "/snapshot",
-    summary="Today's household snapshot",
-    response_model=AdminSnapshotResponse,
-)
-async def admin_snapshot(request: Request) -> AdminSnapshotResponse:
-    """Return today's full household snapshot for the admin Today tab.
-
-    Requires a valid admin JWT (the router's shared
-    :func:`~api.auth.require_admin` dependency — the ONE check; this
-    handler performs NO auth of its own).  Thin adapter: ONE clock read
-    (:func:`_local_now`) goes into
-    :func:`nestquest_core.snapshot.build_snapshot` against the live
-    database, and each child's instances are shaped with
-    ``instance_payload(include_missed=True)`` — missed instances are
-    KEPT in the admin payload (D-009) — into
-    :class:`AdminSnapshotResponse`.
-    """
-    state: DatabaseState = request.app.state.db
-    snapshot = await core_snapshot.build_snapshot(
-        state.database, core_settings.NestQuestSettings(), _local_now()
-    )
-    return AdminSnapshotResponse(
-        today_iso=snapshot.today_iso,
-        cycle_day=snapshot.cycle_day,
-        children=[
-            AdminChildSnapshotPayload(
-                child_id=child.child_id,
-                child_name=child.child_name,
-                present=child.present,
-                next_present=child.next_present,
-                due_today=child.due_today,
-                completed_today=child.completed_today,
-                remaining_today=child.remaining_today,
-                completion_pct=child.completion_pct,
-                instances=[
-                    AdminInstancePayload.model_validate(instance)
-                    for instance in core_snapshot.instance_payload(
-                        child.instances, include_missed=True
-                    )
-                ],
-            )
-            for child in snapshot.children
-        ],
-    )
-
-
 __all__ = ["router"]

custom_components/nestquest/core/dao_meta.py

@@ -41,38 +41,4 @@ class MetaStateDao:
                     f"INSERT INTO {_TABLE} (key, value) VALUES (?, ?) "
                     "ON CONFLICT (key) DO UPDATE SET value = excluded.value",
                     (key, value),
-                )
-
-    async def claim(self, key: str, value: str) -> bool:
-        """Atomically set ``key`` to ``value`` unless it already is.
-
-        The single upsert statement carries a ``WHERE`` guard on the
-        conflict path (``t.value IS NOT excluded.value``), so the
-        read-compare-write is ONE SQLite statement — atomic at the
-        DATABASE level, not just within one process: two connections
-        (two processes sharing one SQLite file) cannot both observe
-        "not yet set" and both write, because the second writer's
-        statement re-evaluates the guard against the first writer's
-        committed value and matches zero rows.
-
-        Returns True only when THIS call changed the row: the first
-        claimant wins and every later claimant of the same value
-        returns False.  A DIFFERENT value always wins (an advance, e.g.
-        the sweep watermark moving to a new date) and re-arms the
-        same-value loser check for the new value.
-
-        Runs under the shared connection lock and inside one
-        transaction, like :meth:`set`; ``cursor.rowcount`` (1 for a
-        matched write, 0 for a guarded no-op) is captured by the
-        wrapper on the executor thread, so no sqlite3 object crosses
-        back to the event loop.
-        """
-        async with _connection_lock(self._database):
-            async with self._database.transaction():
-                result = await self._database.execute(
-                    f"INSERT INTO {_TABLE} (key, value) VALUES (?, ?) "
-                    "ON CONFLICT (key) DO UPDATE SET value = excluded.value "
-                    f"WHERE {_TABLE}.value IS NOT excluded.value",
-                    (key, value),
-                )
-        return result.rowcount == 1
+                )

custom_components/nestquest/core/dao_rules.py

@@ -105,19 +105,6 @@ def _validate_window(window: str) -> None:
         )
 
 
-def _validate_skip_on_away(value: object) -> int:
-    """Return ``value`` as 0/1, raising ValueError for anything else.
-
-    The fresh-schema CHECK constraint enforces this in SQLite, but a
-    migrated database gained the column through ``ADD COLUMN`` without
-    it, so every DAO write path validates here instead.  Accepts a bool
-    or the ints 0/1; floats, strings and other ints are rejected.
-    """
-    if not isinstance(value, int) or value not in (0, 1):
-        raise ValueError(f"skip_on_away must be 0 or 1, got {value!r}")
-    return int(value)
-
-
 @dataclass(frozen=True)
 class ScheduleRuleRecord:
     """One row of ``schedule_rules``."""
@@ -165,7 +152,6 @@ class QuestDefinitionRecord:
     due_time: str | None
     is_active: bool
     created_at: str
-    skip_on_away: bool
 
 
 @dataclass(frozen=True)
@@ -201,7 +187,7 @@ _RULE_COLUMNS = (
 )
 _DEFINITION_COLUMNS = (
     "id, title, description, icon, schedule_rule_id, due_time, "
-    "is_active, created_at, skip_on_away"
+    "is_active, created_at"
 )
 _WINDOW_COLUMNS = "definition_id, window, due_time"
 
@@ -230,7 +216,6 @@ def _definition_from_row(row: tuple) -> QuestDefinitionRecord:
         due_time=row[5],
         is_active=bool(row[6]),
         created_at=row[7],
-        skip_on_away=bool(row[8]),
     )
 
 
@@ -647,7 +632,6 @@ class QuestDefinitionsDao:
         due_time: str | None = None,
         is_active: bool = True,
         assignee_child_ids: list[int] | None = None,
-        skip_on_away: bool = True,
     ) -> QuestDefinitionRecord:
         """Insert one definition and return the record as stored.
 
@@ -660,7 +644,6 @@ class QuestDefinitionsDao:
         empty list or None creates an unassigned definition, which
         callers may fill via :meth:`add_assignee`.
         """
-        skip_on_away_value = _validate_skip_on_away(skip_on_away)
         async with _connection_lock(self._database):
             async with self._database.transaction():
                 await self._validate_rule_exists(schedule_rule_id)
@@ -669,8 +652,7 @@ class QuestDefinitionsDao:
                 result = await self._database.execute(
                     "INSERT INTO quest_definitions (title, description, "
                     "icon, schedule_rule_id, due_time, is_active, "
-                    "created_at, skip_on_away) "
-                    "VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
+                    "created_at) VALUES (?, ?, ?, ?, ?, ?, ?)",
                     (
                         title,
                         description,
@@ -679,7 +661,6 @@ class QuestDefinitionsDao:
                         due_time,
                         int(is_active),
                         created_at,
-                        skip_on_away_value,
                     ),
                 )
                 definition_id = result.lastrowid
@@ -703,7 +684,6 @@ class QuestDefinitionsDao:
         *,
         description: str | None = None,
         icon: str | None = None,
-        skip_on_away: bool = True,
     ) -> QuestDefinitionSnapshot:
         """Insert a rule, definition, assignees and windows atomically.
 
@@ -733,7 +713,6 @@ class QuestDefinitionsDao:
         _validate_date(schedule_rule.start_date, "start_date")
         if schedule_rule.end_date is not None:
             _validate_date(schedule_rule.end_date, "end_date")
-        skip_on_away_value = _validate_skip_on_away(skip_on_away)
         async with _connection_lock(self._database):
             async with self._database.transaction():
                 for child_id in assignee_child_ids:
@@ -742,18 +721,8 @@ class QuestDefinitionsDao:
                 result = await self._database.execute(
                     "INSERT INTO quest_definitions (title, description, "
                     "icon, schedule_rule_id, due_time, is_active, "
-                    "created_at, skip_on_away) "
-                    "VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
-                    (
-                        title,
-                        description,
-                        icon,
-                        rule_id,
-                        None,
-                        1,
-                        created_at,
-                        skip_on_away_value,
-                    ),
+                    "created_at) VALUES (?, ?, ?, ?, ?, ?, ?)",
+                    (title, description, icon, rule_id, None, 1, created_at),
                 )
                 definition_id = result.lastrowid
                 for child_id in assignee_child_ids:
@@ -795,7 +764,6 @@ class QuestDefinitionsDao:
         icon: str | None | object = _UNSET,
         rule: ScheduleRuleStorage | object = _UNSET,
         windows: list[tuple[str, str | None]] | object = _UNSET,
-        skip_on_away: bool | object = _UNSET,
     ) -> QuestDefinitionSnapshot:
         """Edit a definition's metadata, rule and windows atomically.
 
@@ -806,10 +774,9 @@ class QuestDefinitionsDao:
         ``_UNSET`` meaning "leave this field alone"; ``None`` writes SQL
         NULL so optional metadata (description, icon) can be cleared.
 
-        - ``title``/``description``/``icon``/``skip_on_away`` update the
-          definition row in place; the definition-level ``due_time``
-          column is never written (per-window due times supersede it,
-          D-008).
+        - ``title``/``description``/``icon`` update the definition row
+          in place; the definition-level ``due_time`` column is never
+          written (per-window due times supersede it, D-008).
         - ``rule`` (a pre-validated :class:`ScheduleRuleStorage`)
           overwrites the referenced ``schedule_rules`` row in place: the
           definition keeps its ``schedule_rule_id``, so no new or
@@ -825,8 +792,6 @@ class QuestDefinitionsDao:
         does not exist.  Edits change future instances only: no
         ``quest_instances`` or ``completion_events`` row is touched.
         """
-        if skip_on_away is not _UNSET:
-            skip_on_away = _validate_skip_on_away(skip_on_away)
         async with _connection_lock(self._database):
             async with self._database.transaction():
                 definition = await self.get(definition_id)
@@ -844,9 +809,6 @@ class QuestDefinitionsDao:
                     if value is not _UNSET:
                         assignments.append(f"{column} = ?")
                         parameters.append(value)
-                if skip_on_away is not _UNSET:
-                    assignments.append("skip_on_away = ?")
-                    parameters.append(skip_on_away)
                 if assignments:
                     parameters.append(definition_id)
                     await self._database.execute(
@@ -945,13 +907,6 @@ class QuestDefinitionsDao:
         )
         return [_definition_from_row(row) for row in rows]
 
-    async def list_all(self) -> list[QuestDefinitionRecord]:
-        """Return every definition, active AND inactive, oldest first."""
-        rows = await self._database.fetch_all(
-            f"SELECT {_DEFINITION_COLUMNS} FROM quest_definitions ORDER BY id"
-        )
-        return [_definition_from_row(row) for row in rows]
-
     async def _snapshots_for(
         self, definitions: list[QuestDefinitionRecord]
     ) -> list[QuestDefinitionSnapshot]:
@@ -996,18 +951,6 @@ class QuestDefinitionsDao:
                 definitions = await self.list_active()
                 return await self._snapshots_for(definitions)
 
-    async def list_snapshots_all(self) -> list[QuestDefinitionSnapshot]:
-        """Return every definition (active AND inactive) with its rule,
-        assignees and windows, all read inside one locked transaction.
-
-        Mirrors :meth:`list_snapshots_active` over :meth:`list_all`
-        (oldest first), with the same coherence guarantee.
-        """
-        async with _connection_lock(self._database):
-            async with self._database.transaction():
-                definitions = await self.list_all()
-                return await self._snapshots_for(definitions)
-
     async def read_snapshots_active(self) -> list[QuestDefinitionSnapshot]:
         """Return every active definition's snapshot WITHOUT locking.
 
@@ -1047,16 +990,13 @@ class QuestDefinitionsDao:
         description: str | None | object = _UNSET,
         icon: str | None | object = _UNSET,
         due_time: str | None | object = _UNSET,
-        skip_on_away: bool | None = None,
     ) -> int:
         """Update the given fields; returns rows updated (0 if absent).
 
         Arguments default to the module sentinel ``_UNSET`` meaning
         "leave this column alone"; passing ``None`` explicitly writes
         SQL NULL, so callers can remove optional metadata
-        (description, icon, due_time).  ``skip_on_away`` is NOT NULL,
-        so its ``None`` default leaves it unchanged; a supplied value
-        must be 0/1 (a bool).  Assignment and activation are
+        (description, icon, due_time).  Assignment and activation are
         deliberately NOT settable here: they have their own explicit
         operations (:meth:`add_assignee`, :meth:`remove_assignee`,
         :meth:`set_active`) so they stay separately loggable and
@@ -1073,9 +1013,6 @@ class QuestDefinitionsDao:
             if value is not _UNSET:
                 assignments.append(f"{column} = ?")
                 parameters.append(value)
-        if skip_on_away is not None:
-            assignments.append("skip_on_away = ?")
-            parameters.append(_validate_skip_on_away(skip_on_away))
         if not assignments:
             return 0
         parameters.append(definition_id)

custom_components/nestquest/core/materialize.py

@@ -18,8 +18,7 @@ The walk is deterministic and idempotent:
   :class:`~.presence.PresenceEngine` from that same coherent read.
 - For each date in the range, each definition whose decoded rule
   :func:`~.recurrence.occurs_on` on that date, each assignee who is
-  ``is_present`` on that date (or every assignee, when the definition's
-  ``skip_on_away`` is off) and each declared window, one instance is
+  ``is_present`` on that date and each declared window, one instance is
   written through :class:`~.dao_instances.QuestInstancesDao.upsert_if_valid`
   with a ``generated_at`` stamp shared by the whole batch (one coherent
   time per run).
@@ -209,8 +208,7 @@ async def materialize(
 
     definitions = [
         (snapshot.definition.id, _decode_rule(snapshot),
-         snapshot.assignees, snapshot.windows,
-         snapshot.definition.skip_on_away)
+         snapshot.assignees, snapshot.windows)
         for snapshot in snapshots
     ]
 
@@ -231,15 +229,13 @@ async def materialize(
     cursor = start
     while cursor <= end:
         iso = cursor.isoformat()
-        for (
-            definition_id, rule, assignees, windows, skip_on_away
-        ) in definitions:
+        for definition_id, rule, assignees, windows in definitions:
             if not occurs_on(rule, cursor):
                 continue
             for child in assignees:
                 if child_filter is not None and child.id not in child_filter:
                     continue
-                if skip_on_away and not engine.is_present(child.id, cursor):
+                if not engine.is_present(child.id, cursor):
                     continue
                 for window in windows:
                     written = await instances.upsert_if_valid(

custom_components/nestquest/core/migrations.py

@@ -30,9 +30,8 @@ widened (definition_id, child_id, due_date, window) key, and migration
 6 rebuilds ``completion_events`` with the D-008 ``actor_child_id``
 column.  Migration 7 adds the generic ``nestquest_meta_state``
 key/value table for integration-owned bookkeeping (Feature 11's
-missed-sweep watermark).  Migration 8 adds the ``skip_on_away``
-column to ``quest_definitions`` (Feature 22), defaulting to 1.  Each
-callable migration runs inside its own transaction
+missed-sweep watermark).  Each callable migration runs inside its own
+transaction
 together with its version stamp, so a crash mid-step rolls the
 statements and the stamp back together.
 
@@ -401,28 +400,6 @@ async def _add_actor_child_id(
         await database.execute("PRAGMA foreign_keys = ON")
 
 
-async def _add_skip_on_away(
-    database: NestQuestDatabase, target_version: int
-) -> None:
-    """Add the ``skip_on_away`` column to ``quest_definitions``.
-
-    Strictly additive: ``ALTER TABLE ... ADD COLUMN`` with a NOT NULL
-    DEFAULT 1, so existing rows read as 1 (skip absent dates — the
-    behaviour before the flag existed).  Fresh databases already carry
-    the column from the canonical DDL, so the ALTER is guarded and the
-    step only stamps there.
-    """
-    async with database.transaction():
-        if not await _table_has_column(
-            database, "quest_definitions", "skip_on_away"
-        ):
-            await database.execute(
-                "ALTER TABLE quest_definitions ADD COLUMN "
-                "skip_on_away INTEGER NOT NULL DEFAULT 1"
-            )
-        await stamp_schema_version(database, target_version)
-
-
 #: The ordered migration list.  Append-only: never edit an applied
 #: entry, add the next one instead.  (Migration 1's content was
 #: rewritten pre-release per D-007 — no version 1 database shipped.)
@@ -446,10 +423,6 @@ MIGRATIONS: Sequence[MigrationStep] = [
     # fresh databases (which already made it in migration 1) and
     # pre-v7 databases.  Strictly additive; no existing table changes.
     list(SCHEMA_V7_META_STATE_DDL),
-    # Migration 8 (Feature 22): the skip_on_away flag on
-    # quest_definitions — an additive column defaulting to 1, so every
-    # pre-existing definition keeps today's skip-when-absent behaviour.
-    _add_skip_on_away,
 ]
 
 

custom_components/nestquest/core/quest_definitions.py

@@ -191,17 +191,6 @@ def _validate_definition_id(value: object) -> int:
     return value
 
 
-def _validate_skip_on_away(value: object) -> bool:
-    """Reject a non-bool ``skip_on_away`` before any write.
-
-    The DAO's ``int()`` would otherwise silently coerce strings and
-    numerics ("0", 1) into a state the caller never asked for.
-    """
-    if not isinstance(value, bool):
-        raise ValueError(f"skip_on_away must be a real bool, got {value!r}")
-    return value
-
-
 def _validate_child_id(value: object) -> int:
     """Reject non-int child ids (bools included) before any lookup.
 
@@ -223,7 +212,6 @@ async def create_quest_definition(
     *,
     description: str | None = None,
     icon: str | None = None,
-    skip_on_away: bool = True,
 ) -> CreatedQuestDefinition:
     """Create a quest definition (rule + assignees + windows) atomically.
 
@@ -243,7 +231,6 @@ async def create_quest_definition(
     window_specs = _normalize_windows(windows)
     description_value = _validate_text(description, "description")
     icon_value = _validate_text(icon, "icon")
-    skip_on_away_value = _validate_skip_on_away(skip_on_away)
 
     storage = schedule_rule_to_storage(rule)
     dao = QuestDefinitionsDao(database)
@@ -256,7 +243,6 @@ async def create_quest_definition(
             window_specs,
             description=description_value,
             icon=icon_value,
-            skip_on_away=skip_on_away_value,
         )
     except ValueError as error:
         # The DAO's assignee check names only the child; re-raise so the
@@ -285,7 +271,6 @@ async def edit_quest_definition(
     icon: str | None | object = _UNSET,
     rule: ScheduleRule | object = _UNSET,
     windows: list[str | tuple[str, str | None]] | object = _UNSET,
-    skip_on_away: bool | None = None,
     today: datetime.date | None = None,
     horizon_days: int | None = None,
 ) -> CreatedQuestDefinition:
@@ -300,9 +285,7 @@ async def edit_quest_definition(
     ``schedule_rules`` row is updated, never orphaned or duplicated.  A
     provided ``windows`` list REPLACES the whole window set (each entry
     a ``const.QUEST_WINDOWS`` name, optionally with a strict HH:MM due
-    time), matching create's non-empty contract.  A provided
-    ``skip_on_away`` (a real bool) replaces the stored flag; ``None``
-    leaves it unchanged.  Assignment is NOT
+    time), matching create's non-empty contract.  Assignment is NOT
     settable here.  Raises ValueError when the definition does not
     exist or any argument is rejected.
 
@@ -348,10 +331,6 @@ async def edit_quest_definition(
     if windows is not _UNSET:
         window_specs = _normalize_windows(windows)
 
-    skip_on_away_value: bool | object = _UNSET
-    if skip_on_away is not None:
-        skip_on_away_value = _validate_skip_on_away(skip_on_away)
-
     dao = QuestDefinitionsDao(database)
     try:
         snapshot = await dao.edit_definition(
@@ -361,7 +340,6 @@ async def edit_quest_definition(
             icon=icon_value,
             rule=rule_storage,
             windows=window_specs,
-            skip_on_away=skip_on_away_value,
         )
     except ValueError as error:
         # The DAO's missing-definition error names only the id; re-raise
@@ -580,21 +558,6 @@ async def list_active_definitions(
     return [_bundle_snapshot(snapshot) for snapshot in snapshots]
 
 
-async def list_all_definitions(
-    database: NestQuestDatabase,
-) -> list[CreatedQuestDefinition]:
-    """Return EVERY definition, active AND inactive (rich view).
-
-    Mirrors :func:`list_active_definitions` without the activity
-    filter: ordered by rising definition id, each entry the same
-    :class:`CreatedQuestDefinition` snapshot, read by the DAO inside one
-    locked transaction.
-    """
-    dao = QuestDefinitionsDao(database)
-    snapshots = await dao.list_snapshots_all()
-    return [_bundle_snapshot(snapshot) for snapshot in snapshots]
-
-
 async def list_definitions_for_child(
     database: NestQuestDatabase,
     child_id: int,

custom_components/nestquest/core/schema.py

@@ -257,8 +257,7 @@ QUEST_DEFINITIONS_TABLE_SQL = """(
     schedule_rule_id INTEGER NOT NULL REFERENCES schedule_rules(id),
     due_time TEXT,
     is_active INTEGER NOT NULL DEFAULT 1 CHECK (typeof(is_active) = 'integer' AND is_active IN (0, 1)),
-    created_at TEXT NOT NULL,
-    skip_on_away INTEGER NOT NULL DEFAULT 1 CHECK (skip_on_away IN (0, 1))
+    created_at TEXT NOT NULL
 )"""
 
 SCHEMA_V1_QUEST_DEFINITIONS_DDL: list[str] = [

custom_components/nestquest/core/sweep.py

@@ -26,17 +26,12 @@ later completed simply gains its completion event; history keeps both
 rows (append-only), and the sweep's later runs skip it via the
 no-completion-event rule.
 
-The whole watermark read → query → build span runs inside the
+The whole watermark read → query → build → write span runs inside the
 per-database sweep lock (one lock per connection wrapper and running
 loop, the settings store's pattern): an overlapping startup sweep and
-a rollover sweep of the SAME process queue instead of interleaving.
-The announce decision itself is the DATABASE-level claim
-(:meth:`MetaStateDao.claim`), so two PROCESSES sharing one SQLite file
-(the integration's rollover sweep and the API service's scheduler)
-cannot both announce the same missed batch either: both may read the
-old watermark and build the events, but the single conditional upsert
-lets exactly one of them win the claim — the loser returns [] and
-announces nothing.
+a rollover sweep queue instead of interleaving, and the loser re-reads
+the watermark INSIDE the lock — sees the winner's date — and announces
+nothing twice.
 
 The caller supplies ``today`` as a plain :class:`datetime.date`: the
 household-local calendar date, read from ``hass.config.time_zone`` by
@@ -65,11 +60,11 @@ LOGGER = logging.getLogger(__name__)
 SWEEP_WATERMARK_KEY = "missed_sweep_last_run_date"
 
 #: One asyncio.Lock per (connection wrapper, running loop), mirroring
-#: the settings store's pattern: the watermark read → query → build
-#: span is one critical section, so an overlapping startup sweep and
-#: rollover sweep of the SAME process queue instead of interleaving.
-#: Same-process callers are fully serialised by it; the cross-process
-#: case is closed by the database-level claim, not by this lock.
+#: the settings store's pattern: the whole watermark read → query →
+#: build → write span is one critical section, so an overlapping
+#: startup sweep and rollover sweep queue instead of double-announcing.
+#: The loser re-reads the watermark INSIDE the lock, sees the winner's
+#: date, and fires nothing.
 _SWEEP_LOCKS: dict[tuple[int, int], asyncio.Lock] = {}
 
 
@@ -104,24 +99,15 @@ async def run_missed_sweep(
     the caller decides how to publish them and announces nothing on
     its own.
 
-    The watermark read → query → build span runs inside the
-    per-database sweep lock, so overlapping callers of ONE process
-    queue instead of interleaving.  The announce decision is the
-    DATABASE-level claim (:meth:`MetaStateDao.claim` — a single
-    conditional upsert on the watermark, atomic across processes):
-    every caller builds the events optimistically, then only the
-    caller whose claim actually advanced the watermark returns them;
-    a loser (another process already announced for ``today``) returns
-    [] and announces nothing twice.  Every event in one run shares one
+    The whole watermark read → query → build → write span runs inside
+    the per-database sweep lock: an overlapping startup sweep and a
+    rollover sweep queue instead of interleaving, and the loser
+    re-reads the watermark inside the lock — sees the winner's date —
+    and announces nothing twice.  Every event in one run shares one
     ``occurred_at`` stamp (one run, one announcement moment), and the
     payload comes from the shared
     :func:`~.events._instance_payload` builder so the shape can never
     drift from the documented §3 contract.
-
-    Failure ordering: the watermark is advanced ONLY by the claim,
-    AFTER the events are fully built — a failure before the claim
-    leaves the watermark unadvanced, so a later run re-sweeps the same
-    window and nothing is lost.
     """
     today_iso = today.isoformat()
     dao = MetaStateDao(database)
@@ -148,23 +134,10 @@ async def run_missed_sweep(
                     ),
                 )
             )
-        # The database-level claim gates the announcement: only the
-        # caller that actually advanced the watermark may publish the
-        # built events, so two processes racing one SQLite file cannot
-        # both announce the same missed batch.  A same-value loser's
-        # claim matches zero rows and this run announces nothing.
-        claimed = await dao.claim(SWEEP_WATERMARK_KEY, today_iso)
-        if not claimed:
-            LOGGER.info(
-                "NestQuest missed sweep for %s lost the watermark claim; "
-                "announcing nothing",
-                today_iso,
-            )
-            return []
+        await dao.set(SWEEP_WATERMARK_KEY, today_iso)
     LOGGER.info(
         "NestQuest missed sweep for %s built %d event(s)",
         today_iso,
         len(events),
     )
     return events
-

custom_components/nestquest/manifest.json

@@ -15,5 +15,5 @@
   "iot_class": "local_polling",
   "issue_tracker": "https://github.com/Maniacs-Mansion/NestQuest/issues",
   "requirements": [],
-  "version": "0.6.0"
+  "version": "0.5.0"
 }

docs/ARCHITECTURE.md

@@ -1,203 +0,0 @@
-# NestQuest Architecture
-
-Status: approved direction (2026-09-21). This document supersedes the
-single-process design implied by Features 01–14, in which the Home Assistant
-integration owned the database and the parent admin surface was planned as a
-Lovelace card inside Home Assistant.
-
-## 1. Why this changed
-
-The original design put everything inside the Home Assistant integration: the
-SQLite database, the business logic, the kid panel cards, and (planned) the
-parent admin card. Three problems surfaced:
-
-1. **The panel needed hand configuration.** Standing up the kid panel required
-   hand-writing card YAML (`child_order`, `quest_log_path`, `board_path`) and
-   hand-creating a Lovelace dashboard. A fresh install rendered nothing.
-2. **The admin surface fought Home Assistant.** The admin design
-   (`design/ADMIN-SPEC.md`) is drawn at 390×844 — it is a phone app. Trapping it
-   inside a Lovelace card meant fighting HA's UI constraints for a mobile-first
-   experience.
-3. **Data was locked to one process.** A standalone admin web app cannot reach a
-   SQLite file inside Home Assistant's config directory.
-
-The re-imagined design keeps the panel in Home Assistant (TouchHub loads an HA
-dashboard), moves data ownership to a standalone API service, and promotes the
-admin surface to a standalone mobile-first PWA.
-
-## 2. Target architecture
-
-```
- DAKboard TouchHub
-       │  (loads an HA dashboard URL)
-       ▼
- HA box                                        API box
- ┌───────────────────────────────┐            ┌───────────────────────────────────┐
- │ Lovelace panel dashboard      │            │ reverse proxy (TLS)               │
- │  ├ nestquest-party-board-card │  service   │  ├ /api/v1/panel/*   LAN-only     │
- │  └ nestquest-quest-log-card   │  token     │  └ /api/v1/admin/*   public       │
- │                               │ ─────────▶ │ FastAPI (imports core/)           │
- │ NestQuest integration         │            │  └ SQLite (owned here)            │
- │  (thin client, no database)   │ ◀───────── │ Authentik (OIDC)                  │
- │  sensors + HA bus events      │  SSE       └───────────────────────────────────┘
- └───────────────────────────────┘                          ▲
-                                            PWA ───────────┘
-                                  https://nestquest.cubecraftlabs.com
-```
-
-One owner of the data (the API). Two clients (the HA integration, the PWA).
-
-## 3. Data ownership
-
-**The API service is the only writer.** The HA integration never opens the
-database; it reads a snapshot and posts completions. This removes the
-two-writer problem entirely.
-
-- **Storage:** SQLite on the API box. Single household, trivial concurrency,
-  and the existing schema, migrations, and DAO tests are already SQLite. Postgres
-  buys nothing at this scale.
-- **Schema:** unchanged. The cutover from the current HA-hosted database is a
-  file copy — same schema, same migration version.
-- **Backups:** continuous replication (e.g. Litestream) plus a proven restore.
-  A configured-but-untested backup is not a backup.
-
-## 4. Authentication: two planes
-
-The kid panel and the admin PWA have opposite trust levels, so they use
-separate credentials and separate network exposure.
-
-### Panel plane (machine)
-
-- **Credential:** a static service token.
-- **Exposure:** `/api/v1/panel/*` is reachable **only from the LAN**.
-- **Grants:** read the snapshot, and the single open write — complete a quest as
-  `actor: panel` with the tapped `actor_child_id`.
-- **Refused:** admin routes reject the service token outright, not merely as a
-  non-admin. The internet cannot reach these routes at all.
-
-This preserves the original fail-closed boundary: the kiosk can complete a
-quest and nothing else.
-
-### Admin plane (human)
-
-- **Credential:** an Authentik OIDC JWT (authorization code + PKCE).
-- **Exposure:** `/api/v1/admin/*` is internet-facing behind Authentik.
-- **Grants:** everything a parent can do — definitions, assignment, presence,
-  children, un-complete, history, export, settings, regenerate.
-- **Gate:** the API validates the JWT (issuer, audience, JWKS signature, expiry)
-  and requires membership in the `nestquest-admins` group. The Authentik group
-  is the single source of truth for "who is a parent", replacing the
-  integration-side admin allowlist.
-
-## 5. Components
-
-### `core/` — domain library
-
-The extracted domain layer: schema, migrations, database access, DAOs, the pure
-recurrence and presence engines, materialization, completion, event payload
-construction, and the children/definitions/allowlist business layers. **No
-Home Assistant imports.** Consumed by both the API and (during transition) the
-integration. This is where the ~1500 existing tests live after extraction.
-
-### `api/` — NestQuest API
-
-A FastAPI service importing `core/`. Owns the database. Serves the panel and
-admin planes, validates Authentik tokens, and publishes a transition event
-stream (SSE) that the integration consumes. No business logic in route handlers.
-
-### `custom_components/nestquest/` — HA integration (client)
-
-A thin client. Polls the snapshot and builds the existing sensors; subscribes to
-the SSE stream and re-fires the four HA bus events; proxies the panel completion.
-Holds a last-good snapshot cache so a brief API outage does not blank the panel.
-Owns no database and no business logic.
-
-### `panel/` — Lovelace cards and dashboard strategy
-
-The two kid-facing Lit cards plus a dashboard strategy that generates the panel
-views at render time. Cards auto-discover children, so no `child_order` is
-required; the strategy computes navigation paths, so `quest_log_path` and
-`board_path` are not required.
-
-### `admin/` — Admin PWA
-
-A React progressive web app implementing `design/ADMIN-SPEC.md`, authenticated
-via Authentik OIDC, installable on a phone. The only admin surface.
-
-## 6. Zero-configuration panel
-
-A fresh install should show the panel with no YAML:
-
-1. **Auto-discovery.** The party-board card reads an ordered child list from a
-   household entity attribute instead of a configured `child_order`.
-2. **Dashboard strategy.** A Lovelace strategy generates a party-board view and
-   one quest-log view per child, wiring navigation between them, so paths are
-   computed rather than configured. Explicit configuration still wins if a user
-   supplies it.
-3. **Auto-registration.** The integration registers the dashboard on first
-   setup, so there is no manual dashboard step.
-
-## 7. Home Assistant surface preserved
-
-The re-imagining must not break what already works:
-
-- **Sensors:** the per-child and household sensor entity_ids and the per-child
-  instance attribute payload shape are unchanged. The panel cards and the four
-  blueprints depend on them.
-- **Events:** the four HA bus events (`nestquest_quest_completed`,
-  `nestquest_quest_uncompleted`, `nestquest_quest_missed`,
-  `nestquest_child_day_complete`) keep firing with their documented payloads.
-  They are now driven by the API's transition stream rather than by local
-  service handlers.
-- **Blueprints:** the morning summary, afternoon reminder, end-of-day report, and
-  day-complete celebration continue to work with no change.
-
-## 8. Events without an HA token on the API box
-
-The API publishes transitions on an SSE stream; the integration subscribes and
-re-fires the HA bus events locally. This deliberately avoids storing a Home
-Assistant long-lived token on the API box, which would grant full HA access.
-
-## 9. Migration phases
-
-Mapped to the Maestro features:
-
-| Phase | Feature | Outcome |
-|---|---|---|
-| 1 | 15 — Domain Core Extraction | `core/` runs with no HA imports; one implementation of the rules |
-| 2 | 16 — NestQuest API Service | Panel and admin planes served with two-plane auth |
-| 3 | 17 — API Deployment and Identity | TLS, Authentik, backups, network separation |
-| 4 | 18 — HA Integration as API Client | Integration becomes a client; entity/event surface preserved |
-| 5 | 19 — Admin PWA | Mobile-first React PWA replaces the admin card |
-| 6 | 20 — Zero-Config Panel Dashboard | Panel installs itself; navigation and animations match the mockups |
-
-Cutover: copy the existing SQLite file to the API box (same schema).
-
-## 10. Locked decisions
-
-- **API on its own box** — separate from Home Assistant.
-- **Authentik** (`https://auth.cubecraftlabs.com`) for admin identity; a
-  `nestquest-admins` group is the admin source of truth.
-- **Single household** — no tenant column, no multi-household auth.
-- **React** for the admin PWA.
-- **Drop the HA admin services** — the PWA is the only admin surface. The panel
-  completion path stays.
-- **SQLite on the API box** initially; Postgres only if multi-household ever
-  becomes real.
-
-## 11. Preserved vs. changed
-
-**Preserved:** the tested Python domain layer, the panel card designs and
-tokens, the sensor and event contract, the completion model, the append-only
-event log, the panel's fail-closed "complete only" boundary.
-
-**Changed:** data ownership moves to the API; the integration becomes a client;
-the admin card becomes a PWA; panel cards become config-free with a
-strategy-generated dashboard.
-
-**New:** the API service, Authentik-gated admin auth, the PWA, and a
-last-good-snapshot cache in the integration.
-
-**Cost:** two new deployables (the API and the PWA) and one new box. Accepted
-knowingly in exchange for a self-installing panel, an admin surface that is not
-fighting HA's UI, and a data layer with real auth in front of it.

pyproject.toml

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

tests/test_api_admin_questdef.py

@@ -215,7 +215,6 @@ async def test_create_persists_definition_with_assignees_and_windows(
         "description",
         "icon",
         "is_active",
-        "skip_on_away",
         "rule",
         "assignees",
         "windows",
@@ -224,7 +223,6 @@ async def test_create_persists_definition_with_assignees_and_windows(
     assert payload["description"] == "Put everything back where it belongs."
     assert payload["icon"] == "toy-box"
     assert payload["is_active"] is True
-    assert payload["skip_on_away"] is True
     assert payload["rule"] == _weekly_rule_dict()
     assert {a["id"]: a["display_name"] for a in payload["assignees"]} == {
         ada: "Ada",
@@ -523,130 +521,9 @@ async def test_edit_rejections_are_422_and_change_nothing(
     }
 
 
-@pytest.mark.parametrize("coercible", [0, 1, "true", "false"])
-async def test_create_rejects_coercible_skip_on_away_and_persists_nothing(
-    admin_questdefs: SimpleNamespace, coercible: object
-) -> None:
-    """A numeric or string skip_on_away is 422, not coerced to a bool."""
-    client = admin_questdefs.client
-    dao = _dao_rules.QuestDefinitionsDao(admin_questdefs.database)
-    ada = (await _create_children(client, ("Ada",)))[0]
-    existing = await client.post(
-        "/api/v1/admin/quest-definitions",
-        json={
-            "title": "Feed the cat",
-            "rule": _weekly_rule_body(),
-            "assignee_child_ids": [ada],
-            "windows": ["morning"],
-            "skip_on_away": False,
-        },
-        headers=_admin_headers(),
-    )
-    assert existing.status_code == 201
-    existing_id = existing.json()["id"]
-
-    response = await client.post(
-        "/api/v1/admin/quest-definitions",
-        json={
-            "title": "Tidy the den",
-            "rule": _weekly_rule_body(),
-            "assignee_child_ids": [ada],
-            "windows": ["morning"],
-            "skip_on_away": coercible,
-        },
-        headers=_admin_headers(),
-    )
-    assert response.status_code == 422
-    assert set(await _definitions_by_id(admin_questdefs.database)) == {
-        existing_id
-    }
-    assert (await dao.get(existing_id)).skip_on_away is False
-
-
-@pytest.mark.parametrize("coercible", [0, 1, "true", "false"])
-async def test_edit_rejects_coercible_skip_on_away_and_changes_nothing(
-    admin_questdefs: SimpleNamespace, coercible: object
-) -> None:
-    """A numeric or string skip_on_away edit is 422; the flag is kept."""
-    client = admin_questdefs.client
-    dao = _dao_rules.QuestDefinitionsDao(admin_questdefs.database)
-    ada = (await _create_children(client, ("Ada",)))[0]
-    definition_id = (await _create_definition(client, [ada])).json()["id"]
-    # Start from each stored value so a coerced write would be visible.
-    for stored in (True, False):
-        set_flag = await client.patch(
-            f"/api/v1/admin/quest-definitions/{definition_id}",
-            json={"skip_on_away": stored},
-            headers=_admin_headers(),
-        )
-        assert set_flag.status_code == 200
-
-        response = await client.patch(
-            f"/api/v1/admin/quest-definitions/{definition_id}",
-            json={"skip_on_away": coercible, "title": "Renamed"},
-            headers=_admin_headers(),
-        )
-        assert response.status_code == 422
-        stored_definition = await dao.get(definition_id)
-        assert stored_definition.skip_on_away is stored
-        assert stored_definition.title == "Tidy the den"
-
-
 # --- set_active -------------------------------------------------------------
 
 
-async def test_edit_toggles_skip_on_away_and_omission_keeps_it(
-    admin_questdefs: SimpleNamespace,
-) -> None:
-    """A supplied skip_on_away persists; an edit omitting it keeps it."""
-    client = admin_questdefs.client
-    dao = _dao_rules.QuestDefinitionsDao(admin_questdefs.database)
-    ada = (await _create_children(client, ("Ada",)))[0]
-    created = await _create_definition(client, [ada])
-    assert created.status_code == 201
-    definition_id = created.json()["id"]
-    assert created.json()["skip_on_away"] is True
-
-    toggled_off = await client.patch(
-        f"/api/v1/admin/quest-definitions/{definition_id}",
-        json={"skip_on_away": False},
-        headers=_admin_headers(),
-    )
-    assert toggled_off.status_code == 200
-    assert toggled_off.json()["skip_on_away"] is False
-    assert (await dao.get(definition_id)).skip_on_away is False
-
-    # An edit that omits the flag leaves the stored False untouched.
-    renamed = await client.patch(
-        f"/api/v1/admin/quest-definitions/{definition_id}",
-        json={"title": "Tidy the den properly"},
-        headers=_admin_headers(),
-    )
-    assert renamed.status_code == 200
-    assert renamed.json()["skip_on_away"] is False
-    stored = await dao.get(definition_id)
-    assert stored.title == "Tidy the den properly"
-    assert stored.skip_on_away is False
-
-    toggled_on = await client.patch(
-        f"/api/v1/admin/quest-definitions/{definition_id}",
-        json={"skip_on_away": True},
-        headers=_admin_headers(),
-    )
-    assert toggled_on.status_code == 200
-    assert toggled_on.json()["skip_on_away"] is True
-    assert (await dao.get(definition_id)).skip_on_away is True
-
-    # A non-boolean value is a malformed body: 422, nothing changes.
-    rejected = await client.patch(
-        f"/api/v1/admin/quest-definitions/{definition_id}",
-        json={"skip_on_away": "sometimes"},
-        headers=_admin_headers(),
-    )
-    assert rejected.status_code == 422
-    assert (await dao.get(definition_id)).skip_on_away is True
-
-
 async def test_set_active_toggles_the_flag_and_the_definition_survives(
     admin_questdefs: SimpleNamespace,
 ) -> None:

tests/test_api_admin_questdef_list.py

@@ -1,299 +0,0 @@
-"""Admin-plane quest-definition LIST route tests (task d4667573).
-
-``GET /api/v1/admin/quest-definitions`` against the ASGI app with httpx,
-reusing the shared local-RSA-key/stubbed-JWKS harness
-(:mod:`tests.admin_jwt_harness`) so an admin JWT genuinely authenticates
-with NO network access.
-
-- An admin JWT lists EVERY definition — active AND inactive — in rising
-  id order, each in the same documented shape as the create/edit
-  responses (id, title, description, icon, is_active, rule, assignees,
-  windows).
-- An empty household lists nothing: 200 with an empty list.
-- Authentication runs through the router's ONE ``require_admin``
-  dependency: an absent credential is 401, the panel service token is
-  refused outright (403, the credential-type detail), and a JWT without
-  the nestquest-admins group is 403.
-"""
-from __future__ import annotations
-
-from types import SimpleNamespace
-
-import pytest
-
-from tests.admin_jwt_harness import (
-    ADMIN_KEY,
-    KID,
-    AdminRunner,
-    jwks_for,
-    make_token,
-)
-
-#: The admin list route under test.
-LIST_PATH = "/api/v1/admin/quest-definitions"
-
-#: The panel service token the harness app is configured with.
-HARNESS_PANEL_TOKEN = "admin-test-panel-token"
-
-#: The 403 detail for the panel service token on an admin route.
-PANEL_TOKEN_REJECTION_DETAIL = (
-    "This credential type is not accepted for admin access"
-)
-
-#: The 403 detail for a valid JWT without the admin group.
-FORBIDDEN_DETAIL = (
-    "Admin access requires membership in the nestquest-admins group"
-)
-
-
-def _admin_headers() -> dict[str, str]:
-    """The Authorization header of a valid nestquest-admins JWT."""
-    return {"Authorization": f"Bearer {make_token()}"}
-
-
-@pytest.fixture
-async def admin_client(temp_db_path: str) -> SimpleNamespace:
-    """An admin-plane app client over a fresh (empty) household."""
-    runner = AdminRunner(temp_db_path, jwks_for(ADMIN_KEY, KID))
-    async with runner as client:
-        yield client
-
-
-async def _seed_active_and_inactive(client: object) -> tuple[int, int, int]:
-    """Seed one child, an ACTIVE definition and an INACTIVE one.
-
-    Returns ``(child_id, active_id, inactive_id)``.  Seeded through the
-    admin routes so the rows are exactly what the admin plane writes.
-    """
-    child = await client.post(
-        "/api/v1/admin/children",
-        json={"display_name": "Ada"},
-        headers=_admin_headers(),
-    )
-    assert child.status_code == 201
-    child_id = child.json()["id"]
-
-    active = await client.post(
-        LIST_PATH,
-        json={
-            "title": "Tidy the den",
-            "rule": {
-                "rule_type": "weekly",
-                "interval": 1,
-                "weekday_set": [0, 2],
-                "start_date": "2026-03-02",
-            },
-            "assignee_child_ids": [child_id],
-            "windows": ["morning", ["evening", "19:30"]],
-            "description": "Put everything back where it belongs.",
-            "icon": "toy-box",
-        },
-        headers=_admin_headers(),
-    )
-    assert active.status_code == 201
-
-    inactive = await client.post(
-        LIST_PATH,
-        json={
-            "title": "Water the plants",
-            "rule": {
-                "rule_type": "daily",
-                "interval": 1,
-                "start_date": "2026-03-01",
-            },
-            "assignee_child_ids": [child_id],
-            "windows": ["afternoon"],
-        },
-        headers=_admin_headers(),
-    )
-    assert inactive.status_code == 201
-    inactive_id = inactive.json()["id"]
-    deactivated = await client.patch(
-        f"{LIST_PATH}/{inactive_id}/active",
-        json={"is_active": False},
-        headers=_admin_headers(),
-    )
-    assert deactivated.status_code == 200
-
-    return child_id, active.json()["id"], inactive_id
-
-
-async def test_admin_lists_active_and_inactive_definitions_with_full_shape(
-    admin_client: object,
-) -> None:
-    """Both definitions come back, by rising id, in the documented shape."""
-    child_id, active_id, inactive_id = await _seed_active_and_inactive(
-        admin_client
-    )
-
-    response = await admin_client.get(LIST_PATH, headers=_admin_headers())
-
-    assert response.status_code == 200
-    assert response.json() == {
-        "definitions": [
-            {
-                "id": active_id,
-                "title": "Tidy the den",
-                "description": "Put everything back where it belongs.",
-                "icon": "toy-box",
-                "is_active": True,
-                "skip_on_away": True,
-                "rule": {
-                    "rule_type": "weekly",
-                    "interval": 1,
-                    "weekday_set": [0, 2],
-                    "day_of_month": None,
-                    "nth_weekday": None,
-                    "nth_weekday_weekday": None,
-                    "month": None,
-                    "start_date": "2026-03-02",
-                    "end_date": None,
-                },
-                "assignees": [{"id": child_id, "display_name": "Ada"}],
-                "windows": [
-                    {"window": "morning", "due_time": None},
-                    {"window": "evening", "due_time": "19:30"},
-                ],
-            },
-            {
-                "id": inactive_id,
-                "title": "Water the plants",
-                "description": None,
-                "icon": None,
-                "is_active": False,
-                "skip_on_away": True,
-                "rule": {
-                    "rule_type": "daily",
-                    "interval": 1,
-                    "weekday_set": None,
-                    "day_of_month": None,
-                    "nth_weekday": None,
-                    "nth_weekday_weekday": None,
-                    "month": None,
-                    "start_date": "2026-03-01",
-                    "end_date": None,
-                },
-                "assignees": [{"id": child_id, "display_name": "Ada"}],
-                "windows": [{"window": "afternoon", "due_time": None}],
-            },
-        ]
-    }
-
-
-async def test_list_items_match_the_create_response_shape(
-    admin_client: object,
-) -> None:
-    """Each listed item is exactly what the create route returned."""
-    child = await admin_client.post(
-        "/api/v1/admin/children",
-        json={"display_name": "Ben"},
-        headers=_admin_headers(),
-    )
-    created = await admin_client.post(
-        LIST_PATH,
-        json={
-            "title": "Feed the cat",
-            "rule": {
-                "rule_type": "daily",
-                "interval": 1,
-                "start_date": "2026-03-01",
-            },
-            "assignee_child_ids": [child.json()["id"]],
-            "windows": ["morning"],
-        },
-        headers=_admin_headers(),
-    )
-    assert created.status_code == 201
-
-    response = await admin_client.get(LIST_PATH, headers=_admin_headers())
-
-    assert response.status_code == 200
-    assert response.json() == {"definitions": [created.json()]}
-
-
-async def test_skip_on_away_round_trips_true_and_false_through_list(
-    admin_client: object,
-) -> None:
-    """skip_on_away posted true, false, or omitted lists back as stored."""
-    child = await admin_client.post(
-        "/api/v1/admin/children",
-        json={"display_name": "Cleo"},
-        headers=_admin_headers(),
-    )
-    child_id = child.json()["id"]
-
-    async def create(title: str, extra: dict[str, object]) -> dict:
-        response = await admin_client.post(
-            LIST_PATH,
-            json={
-                "title": title,
-                "rule": {
-                    "rule_type": "daily",
-                    "interval": 1,
-                    "start_date": "2026-03-01",
-                },
-                "assignee_child_ids": [child_id],
-                "windows": ["morning"],
-                **extra,
-            },
-            headers=_admin_headers(),
-        )
-        assert response.status_code == 201
-        return response.json()
-
-    skipping = await create("Skip when away", {"skip_on_away": True})
-    keeping = await create("Keep when away", {"skip_on_away": False})
-    defaulted = await create("Default", {})
-    assert skipping["skip_on_away"] is True
-    assert keeping["skip_on_away"] is False
-    assert defaulted["skip_on_away"] is True
-
-    response = await admin_client.get(LIST_PATH, headers=_admin_headers())
-
-    assert response.status_code == 200
-    listed = {item["id"]: item for item in response.json()["definitions"]}
-    assert listed[skipping["id"]]["skip_on_away"] is True
-    assert listed[keeping["id"]]["skip_on_away"] is False
-    assert listed[defaulted["id"]]["skip_on_away"] is True
-    assert response.json() == {"definitions": [skipping, keeping, defaulted]}
-
-
-async def test_empty_household_lists_no_definitions(
-    admin_client: object,
-) -> None:
-    """With no definitions stored the list is 200 and empty."""
-    response = await admin_client.get(LIST_PATH, headers=_admin_headers())
-
-    assert response.status_code == 200
-    assert response.json() == {"definitions": []}
-
-
-async def test_list_without_credentials_is_401(admin_client: object) -> None:
-    """An absent credential is the uniform 401."""
-    response = await admin_client.get(LIST_PATH)
-
-    assert response.status_code == 401
-
-
-async def test_list_with_panel_service_token_is_403(
-    admin_client: object,
-) -> None:
-    """The panel service token is refused outright, never a JWT."""
-    response = await admin_client.get(
-        LIST_PATH,
-        headers={"Authorization": f"Bearer {HARNESS_PANEL_TOKEN}"},
-    )
-
-    assert response.status_code == 403
-    assert response.json()["detail"] == PANEL_TOKEN_REJECTION_DETAIL
-
-
-async def test_list_with_non_admin_jwt_is_403(admin_client: object) -> None:
-    """A valid JWT without the nestquest-admins group is 403."""
-    non_admin = make_token(groups=("some-other-group",))
-    response = await admin_client.get(
-        LIST_PATH, headers={"Authorization": f"Bearer {non_admin}"}
-    )
-
-    assert response.status_code == 403
-    assert response.json()["detail"] == FORBIDDEN_DETAIL

tests/test_api_admin_snapshot.py

@@ -1,328 +0,0 @@
-"""Admin-plane snapshot route tests (task ef3f4877).
-
-These tests exercise ``GET /api/v1/admin/snapshot`` against the ASGI
-app with httpx, reusing the shared local-RSA-key/stubbed-JWKS harness
-(:mod:`tests.admin_jwt_harness`) so an admin JWT genuinely
-authenticates with NO network access.  The household is seeded with
-:func:`tests.test_api_panel._seed_household` through the SAME core
-copy the app uses (``nestquest_core.*``), and both routes' single
-clock read (``_local_now``) is pinned to noon so nothing straddles
-midnight.
-
-Proven per the done-condition:
-
-- An admin JWT returns 200 with the documented shape: ``today_iso``,
-  ``cycle_day`` and, per child, the presence fields, the rollup counts
-  and ``instances`` in the core ``instance_payload`` shape.
-- A MISSED instance is KEPT in the admin payload (D-009) and still
-  OMITTED from the panel payload.  The core builder lists only
-  instances due on ``now.date()``, and ``derive_state`` calls an
-  instance missed only when its due date is BEFORE that day — so a
-  real snapshot never carries a missed view.  The test therefore
-  wraps the real builder to add the seeded past-due instance as a
-  view whose state the core's own ``derive_state`` computes
-  (``missed``), and reads it through both routes.
-- Auth runs through the router's ONE ``require_admin`` dependency: no
-  credential is 401, the panel service token is refused outright
-  (403, the credential-type detail), and a non-admin JWT is 403.
-- The handler performs exactly ONE clock read per request.
-"""
-from __future__ import annotations
-
-import dataclasses
-import datetime
-import importlib
-from types import SimpleNamespace
-from zoneinfo import ZoneInfo
-
-import pytest
-
-from api import routes_admin, routes_panel
-from api.nestquest_core import core_snapshot
-from tests.admin_jwt_harness import (
-    ADMIN_KEY,
-    KID,
-    AdminRunner,
-    jwks_for,
-    make_token,
-)
-from tests.test_api_panel import _seed_household
-
-# The completion layer through the SAME core copy the app uses — the
-# missed test derives its view's state with the core's own rule.
-_completion = importlib.import_module("nestquest_core.completion")
-
-#: The panel service token the harness app is configured with.
-HARNESS_PANEL_TOKEN = "admin-test-panel-token"
-
-#: The 403 detail for the panel service token on an admin route.
-PANEL_TOKEN_REJECTION_DETAIL = (
-    "This credential type is not accepted for admin access"
-)
-
-#: The 403 detail for a valid JWT without the admin group.
-FORBIDDEN_DETAIL = (
-    "Admin access requires membership in the nestquest-admins group"
-)
-
-
-def _admin_headers() -> dict[str, str]:
-    """The Authorization header of a valid nestquest-admins JWT."""
-    return {"Authorization": f"Bearer {make_token()}"}
-
-
-def _panel_headers() -> dict[str, str]:
-    """The Authorization header carrying the harness panel token."""
-    return {"Authorization": f"Bearer {HARNESS_PANEL_TOKEN}"}
-
-
-@pytest.fixture
-async def snapshot_household(
-    temp_db_path: str, monkeypatch
-) -> SimpleNamespace:
-    """A seeded household served by the admin-plane app, clock pinned.
-
-    ``today`` comes from one host clock read; the pinned instant is
-    12:00 UTC that day (past Ada's 10:00 due, before Bo's 17:00).  Both
-    the admin and the panel route's ``_local_now`` return it, and the
-    admin one counts its calls.
-    """
-    today = datetime.datetime.now().astimezone().date()
-    pinned_now = datetime.datetime(
-        today.year, today.month, today.day, 12, 0, 0, tzinfo=ZoneInfo("UTC")
-    )
-    seed = await _seed_household(temp_db_path, today, pinned_now)
-
-    clock_reads: list[datetime.datetime] = []
-
-    def _admin_now() -> datetime.datetime:
-        clock_reads.append(pinned_now)
-        return pinned_now
-
-    monkeypatch.setattr(routes_admin, "_local_now", _admin_now)
-    monkeypatch.setattr(routes_panel, "_local_now", lambda: pinned_now)
-    runner = AdminRunner(temp_db_path, jwks_for(ADMIN_KEY, KID))
-    async with runner as client:
-        yield SimpleNamespace(
-            client=client,
-            seed=seed,
-            today=today,
-            pinned_now=pinned_now,
-            pinned_utc_iso=pinned_now.astimezone(
-                datetime.timezone.utc
-            ).isoformat(),
-            clock_reads=clock_reads,
-        )
-
-
-# --- authentication: the ONE require_admin dependency ----------------------
-
-
-async def test_snapshot_without_credential_is_401(
-    snapshot_household: SimpleNamespace,
-) -> None:
-    """No Authorization header is the uniform 401."""
-    response = await snapshot_household.client.get("/api/v1/admin/snapshot")
-    assert response.status_code == 401
-
-
-async def test_snapshot_refuses_panel_service_token_outright(
-    snapshot_household: SimpleNamespace,
-) -> None:
-    """The panel service token is refused as a credential type (403).
-
-    403 with the credential-type detail — not the uniform 401 and not
-    the non-admin group detail — proves the token was refused outright,
-    never tried as a JWT.
-    """
-    response = await snapshot_household.client.get(
-        "/api/v1/admin/snapshot", headers=_panel_headers()
-    )
-    assert response.status_code == 403
-    assert response.json()["detail"] == PANEL_TOKEN_REJECTION_DETAIL
-
-
-async def test_snapshot_refuses_non_admin_jwt(
-    snapshot_household: SimpleNamespace,
-) -> None:
-    """A valid JWT without the nestquest-admins group is 403."""
-    non_admin = make_token(groups=("some-other-group",))
-    response = await snapshot_household.client.get(
-        "/api/v1/admin/snapshot",
-        headers={"Authorization": f"Bearer {non_admin}"},
-    )
-    assert response.status_code == 403
-    assert response.json()["detail"] == FORBIDDEN_DETAIL
-
-
-# --- the payload -----------------------------------------------------------
-
-
-async def test_admin_jwt_returns_documented_snapshot(
-    snapshot_household: SimpleNamespace,
-) -> None:
-    """An admin JWT returns 200 with the documented snapshot shape.
-
-    Every field is asserted as an explicit literal, with ONE clock
-    read for the request.  With no missed view in the real snapshot,
-    the admin body equals the panel body for the same household.
-    """
-    client = snapshot_household.client
-    seed = snapshot_household.seed
-
-    response = await client.get(
-        "/api/v1/admin/snapshot", headers=_admin_headers()
-    )
-    assert response.status_code == 200
-    assert len(snapshot_household.clock_reads) == 1
-    body = response.json()
-
-    assert body == {
-        "today_iso": snapshot_household.today.isoformat(),
-        # Ada's 2-week cycle anchored yesterday => today is cycle day 2.
-        "cycle_day": 2,
-        "children": [
-            {
-                "child_id": seed.ada.id,
-                "child_name": "Ada",
-                "present": False,
-                "next_present": seed.returns_date.isoformat(),
-                "due_today": 1,
-                "completed_today": 0,
-                "remaining_today": 1,
-                "completion_pct": 0,
-                "instances": [
-                    {
-                        "id": seed.pack_bag_instance.id,
-                        "definition_id": seed.pack_bag_instance.definition_id,
-                        "child_id": seed.ada.id,
-                        "title": "Pack bag",
-                        "icon": None,
-                        "window": "morning",
-                        "due_time": "10:00",
-                        "state": "open",
-                        "overdue": True,
-                        "completed_at": None,
-                        "on_time": None,
-                    }
-                ],
-            },
-            {
-                "child_id": seed.bo.id,
-                "child_name": "Bo",
-                "present": True,
-                "next_present": None,
-                "due_today": 1,
-                "completed_today": 1,
-                "remaining_today": 0,
-                "completion_pct": 100,
-                "instances": [
-                    {
-                        "id": seed.brush_teeth_instance.id,
-                        "definition_id": (
-                            seed.brush_teeth_instance.definition_id
-                        ),
-                        "child_id": seed.bo.id,
-                        "title": "Brush teeth",
-                        "icon": None,
-                        "window": "morning",
-                        "due_time": "17:00",
-                        "state": "completed",
-                        "overdue": False,
-                        "completed_at": snapshot_household.pinned_utc_iso,
-                        "on_time": True,
-                    }
-                ],
-            },
-        ],
-    }
-
-    panel = await client.get(
-        "/api/v1/panel/snapshot", headers=_panel_headers()
-    )
-    assert panel.status_code == 200
-    assert panel.json() == body
-
-
-async def test_admin_keeps_missed_instance_panel_omits_it(
-    snapshot_household: SimpleNamespace, monkeypatch
-) -> None:
-    """A missed view is KEPT by the admin route, OMITTED by the panel's.
-
-    The real builder is wrapped to add the seeded past-due Stale chore
-    instance to Ada's views, its state derived by the core's own
-    ``derive_state`` (no events, due yesterday => ``missed``).  Both
-    routes read the SAME wrapped snapshot, so the only difference is
-    each route's ``include_missed`` flag.
-    """
-    client = snapshot_household.client
-    seed = snapshot_household.seed
-    stale = seed.stale_instance
-    missed_state = _completion.derive_state(
-        stale, None, snapshot_household.today
-    )
-    assert missed_state == "missed"
-    missed_view = core_snapshot.QuestInstanceView(
-        instance_id=stale.id,
-        definition_id=stale.definition_id,
-        child_id=stale.child_id,
-        title="Stale chore",
-        icon=None,
-        window=stale.window,
-        due_date=stale.due_date,
-        due_time=stale.due_time,
-        state=missed_state,
-        overdue=False,
-        completed_at=None,
-        was_on_time=None,
-    )
-    real_build_snapshot = core_snapshot.build_snapshot
-
-    async def _with_missed_view(database, settings, now):
-        snapshot = await real_build_snapshot(database, settings, now)
-        return dataclasses.replace(
-            snapshot,
-            children=tuple(
-                dataclasses.replace(
-                    child, instances=(*child.instances, missed_view)
-                )
-                if child.child_id == seed.ada.id
-                else child
-                for child in snapshot.children
-            ),
-        )
-
-    monkeypatch.setattr(core_snapshot, "build_snapshot", _with_missed_view)
-
-    admin = await client.get(
-        "/api/v1/admin/snapshot", headers=_admin_headers()
-    )
-    assert admin.status_code == 200
-    admin_ada = admin.json()["children"][0]
-    assert admin_ada["child_id"] == seed.ada.id
-    assert [instance["id"] for instance in admin_ada["instances"]] == [
-        seed.pack_bag_instance.id,
-        stale.id,
-    ]
-    assert admin_ada["instances"][1] == {
-        "id": stale.id,
-        "definition_id": stale.definition_id,
-        "child_id": seed.ada.id,
-        "title": "Stale chore",
-        "icon": None,
-        "window": "morning",
-        "due_time": "09:00",
-        "state": "missed",
-        "overdue": False,
-        "completed_at": None,
-        "on_time": None,
-    }
-
-    panel = await client.get(
-        "/api/v1/panel/snapshot", headers=_panel_headers()
-    )
-    assert panel.status_code == 200
-    panel_ada = panel.json()["children"][0]
-    assert [instance["id"] for instance in panel_ada["instances"]] == [
-        seed.pack_bag_instance.id
-    ], "the panel payload must still omit missed instances"

tests/test_core_sweep.py

@@ -1,295 +0,0 @@
-"""Cross-process safety of the missed-sweep watermark claim.
-
-Feature 11's sweep guards its announcement with the watermark; the
-original guard was a read-then-set inside a per-PROCESS asyncio lock,
-so two PROCESSES sharing one SQLite file (the HA integration's
-rollover sweep and the API service's scheduler) could both read the
-old watermark and both announce the same missed batch.  These tests
-pin the fix:
-
-- :meth:`MetaStateDao.claim` is the atomic, database-level primitive:
-  one conditional upsert whose ``rowcount`` says whether THIS caller
-  changed the row.  The first claimant of a value wins; a second
-  claimant of the same value — even on an INDEPENDENT connection to
-  the same file, the shape two processes produce — loses.
-- :func:`run_missed_sweep` gates the announcement on that claim: two
-  independent ``NestQuestDatabase`` wrappers (two processes' shape)
-  racing one seeded database yields exactly one announcer.
-- The documented sweep semantics are unchanged: a same-night rerun
-  announces nothing, and a run after days of downtime announces the
-  accumulated ``[watermark, today)`` window exactly once.
-
-Everything here runs against the bundled HA-free core copy
-(``custom_components.nestquest.core``) with a plain
-``asyncio.to_thread`` executor — no Home Assistant, no API server.
-"""
-from __future__ import annotations
-
-import asyncio
-import datetime
-from types import SimpleNamespace
-
-import pytest
-
-from custom_components.nestquest.core.dao_instances import (
-    QuestInstancesDao,
-)
-from custom_components.nestquest.core.dao_meta import MetaStateDao
-from custom_components.nestquest.core.db import NestQuestDatabase
-from custom_components.nestquest.core.migrations import apply_migrations
-from custom_components.nestquest.core.children import create_child
-from custom_components.nestquest.core.quest_definitions import (
-    create_quest_definition,
-)
-from custom_components.nestquest.core.materialize import materialize
-from custom_components.nestquest.core.recurrence import ScheduleRule
-from custom_components.nestquest.core.sweep import (
-    SWEEP_WATERMARK_KEY,
-    run_missed_sweep,
-)
-
-#: One missed event per unswept past-due instance — the sweep's only
-#: event type.
-EVENT_QUEST_MISSED = "nestquest_quest_missed"
-
-
-async def _executor(fn, *args, **kwargs):
-    """Run a synchronous callable on a worker thread and await it.
-
-    The :class:`NestQuestDatabase` executor contract (the shape of
-    ``hass.async_add_executor_job``), so sqlite3 calls never block the
-    event loop.
-    """
-    return await asyncio.to_thread(fn, *args, **kwargs)
-
-
-async def _open_database(db_path: str) -> NestQuestDatabase:
-    """Open (without migrating) one independent connection wrapper."""
-    database = NestQuestDatabase(_executor)
-    await database.open(db_path)
-    return database
-
-
-async def _seed_missed_household(
-    db_path: str, today: datetime.date
-) -> SimpleNamespace:
-    """Seed a household with two past-due open instances on ``db_path``.
-
-    One child, two quests whose ONLY instances are due YESTERDAY
-    (materialized with ``today`` pinned to yesterday, ``end_date``
-    closing the rules so the later today-walk cannot duplicate them).
-    Seeding uses its OWN connection, opened and closed here, so the
-    connections the tests race with start fresh.
-    """
-    database = await _open_database(db_path)
-    try:
-        await apply_migrations(database)
-        today_iso = today.isoformat()
-        yesterday = today - datetime.timedelta(days=1)
-        yesterday_iso = yesterday.isoformat()
-        rule = ScheduleRule.from_dict(
-            {
-                "rule_type": "daily",
-                "start_date": yesterday_iso,
-                "end_date": yesterday_iso,
-            }
-        )
-        ada = await create_child(database, "Ada", sort_order=0)
-        await create_quest_definition(
-            database, "Stale chore", rule, [ada.id], [("morning", "09:00")]
-        )
-        await create_quest_definition(
-            database, "Old chore", rule, [ada.id], [("evening", "18:30")]
-        )
-        await materialize(database, yesterday_iso, yesterday_iso, today=yesterday)
-        # A quest due TODAY (created after the yesterday walk so it has
-        # no past-due instance): the post-downtime catch-up run's
-        # target — inside [watermark=today, later_today) but not
-        # inside the day-one sweep's window.
-        await create_quest_definition(
-            database,
-            "Recoverable chore",
-            ScheduleRule.from_dict(
-                {"rule_type": "daily", "start_date": today_iso}
-            ),
-            [ada.id],
-            [("afternoon", "17:00")],
-        )
-        await materialize(database, today_iso, today_iso, today=today)
-        instances = QuestInstancesDao(database)
-        rows = await instances.list_by_child_and_date(ada.id, yesterday_iso)
-        assert len(rows) == 2
-        today_rows = await instances.list_by_child_and_date(
-            ada.id, today_iso
-        )
-        assert len(today_rows) == 1
-        return SimpleNamespace(
-            child=ada,
-            instances=rows,
-            recoverable_instance=today_rows[0],
-            yesterday_iso=yesterday_iso,
-            today_iso=today_iso,
-        )
-    finally:
-        await database.close()
-
-
-# --- the claim primitive: atomic at the database level ------------------
-
-
-async def test_claim_first_caller_wins_and_second_same_value_loses(
-    temp_db_path: str,
-) -> None:
-    """claim() is a conditional upsert: first True, same-value second False.
-
-    A different value always wins (an advance re-arms the check), and
-    the stored value follows the winner.
-    """
-    database = await _open_database(temp_db_path)
-    try:
-        await apply_migrations(database)
-        dao = MetaStateDao(database)
-        assert await dao.get(SWEEP_WATERMARK_KEY) is None
-
-        assert await dao.claim(SWEEP_WATERMARK_KEY, "2026-09-01") is True
-        # Same value again: the row is already there — nothing changed.
-        assert await dao.claim(SWEEP_WATERMARK_KEY, "2026-09-01") is False
-        assert await dao.get(SWEEP_WATERMARK_KEY) == "2026-09-01"
-        # A DIFFERENT value is an advance, not a re-claim: it wins.
-        assert await dao.claim(SWEEP_WATERMARK_KEY, "2026-09-02") is True
-        assert await dao.get(SWEEP_WATERMARK_KEY) == "2026-09-02"
-        assert await dao.claim(SWEEP_WATERMARK_KEY, "2026-09-02") is False
-    finally:
-        await database.close()
-
-
-async def test_claim_is_atomic_across_independent_connections(
-    temp_db_path: str,
-) -> None:
-    """Two connections to one file cannot both claim the same value.
-
-    This is the two-process shape: independent sqlite3 connections (one
-    per ``NestQuestDatabase`` wrapper), racing the SAME key on the SAME
-    event loop with no shared lock.  The single conditional upsert is
-    serialized by SQLite itself, so exactly one caller's rowcount is 1.
-    """
-    first = await _open_database(temp_db_path)
-    second = await _open_database(temp_db_path)
-    try:
-        await apply_migrations(first)
-        won = await asyncio.gather(
-            MetaStateDao(first).claim(SWEEP_WATERMARK_KEY, "2026-09-01"),
-            MetaStateDao(second).claim(SWEEP_WATERMARK_KEY, "2026-09-01"),
-        )
-        assert sorted(won) == [False, True]
-        # One stored row, holding the winner's value.
-        assert await MetaStateDao(first).get(SWEEP_WATERMARK_KEY) == (
-            "2026-09-01"
-        )
-        assert await MetaStateDao(second).get(SWEEP_WATERMARK_KEY) == (
-            "2026-09-01"
-        )
-    finally:
-        await first.close()
-        await second.close()
-
-
-# --- the sweep: the announcement is gated by the atomic claim -----------
-
-
-async def test_two_process_shape_race_exactly_one_announces(
-    temp_db_path: str,
-) -> None:
-    """Two independent connections racing the sweep: ONE announcer.
-
-    Each wrapper carries its own connection AND its own per-process
-    sweep lock, so nothing in-process serialises the two runs — the
-    only guard left is the database-level claim.  Both read the unset
-    watermark and both build the events, but exactly one claim wins:
-    one run returns the missed events, the loser returns [].
-    """
-    today = datetime.datetime.now().astimezone().date()
-    seed = await _seed_missed_household(temp_db_path, today)
-    first = await _open_database(temp_db_path)
-    second = await _open_database(temp_db_path)
-    try:
-        results = await asyncio.gather(
-            run_missed_sweep(first, today=today),
-            run_missed_sweep(second, today=today),
-        )
-        announcers = [r for r in results if r]
-        assert len(announcers) == 1
-        event_type, payload = announcers[0][0]
-        assert event_type == EVENT_QUEST_MISSED
-        assert payload["due_date"] == seed.yesterday_iso
-        # Both instances of the seeded window, one event each.
-        assert len(announcers[0]) == 2
-        losers = [r for r in results if not r]
-        assert losers == [[]]
-        # The watermark holds the run's date for whoever looks next.
-        assert (
-            await MetaStateDao(first).get(SWEEP_WATERMARK_KEY)
-            == seed.today_iso
-        )
-    finally:
-        await first.close()
-        await second.close()
-
-
-async def test_same_night_rerun_announces_nothing(temp_db_path: str) -> None:
-    """A second sweep for the same date is an empty no-op (the watermark)."""
-    today = datetime.datetime.now().astimezone().date()
-    await _seed_missed_household(temp_db_path, today)
-    database = await _open_database(temp_db_path)
-    try:
-        first = await run_missed_sweep(database, today=today)
-        assert len(first) == 2
-        second = await run_missed_sweep(database, today=today)
-        assert second == []
-    finally:
-        await database.close()
-
-
-async def test_post_downtime_run_announces_accumulated_window_once(
-    temp_db_path: str,
-) -> None:
-    """After days of downtime the catch-up run sweeps the window once.
-
-    The first run sweeps yesterday's instances (watermark := today);
-    ``today`` then jumps two days and the catch-up run — on a
-    DIFFERENT connection, the two-process shape — announces the
-    accumulated ``[watermark, later_today)`` window exactly once, and
-    a rerun on the original connection is silent again.
-    """
-    today = datetime.datetime.now().astimezone().date()
-    later_today = today + datetime.timedelta(days=2)
-    seed = await _seed_missed_household(temp_db_path, today)
-    first = await _open_database(temp_db_path)
-    second = await _open_database(temp_db_path)
-    try:
-        # Day one: yesterday's two instances fire once.
-        day_one = await run_missed_sweep(first, today=today)
-        assert len(day_one) == 2
-        assert all(
-            payload["due_date"] == seed.yesterday_iso
-            for _, payload in day_one
-        )
-
-        # The downtime catch-up: the window is [watermark, later_today).
-        catchup = await run_missed_sweep(second, today=later_today)
-        assert len(catchup) == 1
-        event_type, payload = catchup[0]
-        assert event_type == EVENT_QUEST_MISSED
-        assert payload["due_date"] == seed.today_iso
-        assert payload["instance_id"] == seed.recoverable_instance.id
-        assert payload["child_id"] == seed.child.id
-
-        # A further rerun announces nothing.
-        assert await run_missed_sweep(first, today=later_today) == []
-        assert (
-            await MetaStateDao(first).get(SWEEP_WATERMARK_KEY)
-            == later_today.isoformat()
-        )
-    finally:
-        await first.close()
-        await second.close()

tests/test_dao_rules.py

@@ -847,7 +847,6 @@ def test_definition_update_cannot_change_assignee_or_active(
             "description",
             "icon",
             "due_time",
-            "skip_on_away",
         }
         assert await definitions.update(
             definition.id, title="A2"
@@ -863,72 +862,6 @@ def test_definition_update_cannot_change_assignee_or_active(
     _with_db(tmp_path, "definition-update-shape.db")(_body)
 
 
-def test_definition_update_toggles_skip_on_away_and_omission_keeps_it(
-    tmp_path,
-) -> None:
-    async def _body(database, rules, definitions, children, child):
-        rule = await rules.create("daily", "2026-09-14")
-        definition = await definitions.create("A", rule.id, NOW)
-        assert definition.skip_on_away is True
-        assert await definitions.update(
-            definition.id, skip_on_away=False
-        ) == 1
-        assert (await definitions.get(definition.id)).skip_on_away is False
-        # Omitting the flag (None) leaves the stored False untouched.
-        assert await definitions.update(definition.id, title="A2") == 1
-        kept = await definitions.get(definition.id)
-        assert kept.title == "A2"
-        assert kept.skip_on_away is False
-        assert await definitions.update(definition.id) == 0
-        assert await definitions.update(
-            definition.id, skip_on_away=True
-        ) == 1
-        assert (await definitions.get(definition.id)).skip_on_away is True
-
-    _with_db(tmp_path, "definition-update-skip-on-away.db")(_body)
-
-
-@pytest.mark.parametrize("bad", [2, -1, 0.0, 1.5, "1", "true", b"\x01"])
-def test_skip_on_away_rejected_unless_zero_or_one_at_every_write(
-    tmp_path, bad
-) -> None:
-    """Every DAO entry point taking the flag rejects non-0/1 values.
-
-    This is the only guard on migrated databases, whose column was
-    added without the fresh-schema CHECK constraint.
-    """
-    async def _body(database, rules, definitions, children, child):
-        rule = await rules.create("daily", "2026-09-14")
-        definition = await definitions.create("A", rule.id, NOW)
-        with pytest.raises(ValueError, match="skip_on_away must be 0 or 1"):
-            await definitions.create("B", rule.id, NOW, skip_on_away=bad)
-        with pytest.raises(ValueError, match="skip_on_away must be 0 or 1"):
-            await definitions.create_with_rule_and_windows(
-                "C",
-                schedule_rule_to_storage(
-                    ScheduleRule(
-                        rule_type=RuleType.DAILY, start_date="2026-09-14"
-                    )
-                ),
-                NOW,
-                [child.id],
-                [("morning", None)],
-                skip_on_away=bad,
-            )
-        with pytest.raises(ValueError, match="skip_on_away must be 0 or 1"):
-            await definitions.edit_definition(
-                definition.id, title="A2", skip_on_away=bad
-            )
-        with pytest.raises(ValueError, match="skip_on_away must be 0 or 1"):
-            await definitions.update(
-                definition.id, title="A2", skip_on_away=bad
-            )
-        stored = await definitions.list_all()
-        assert [(d.title, d.skip_on_away) for d in stored] == [("A", True)]
-
-    _with_db(tmp_path, "definition-skip-on-away-invalid.db")(_body)
-
-
 def test_definition_update_no_fields_returns_zero(tmp_path) -> None:
     async def _body(database, rules, definitions, children, child):
         rule = await rules.create("daily", "2026-09-14")

tests/test_materialize.py

@@ -657,133 +657,6 @@ def test_materialize_honours_overrides(tmp_path) -> None:
     _with_db(tmp_path, "materialize-override.db")(_body)
 
 
-async def _absent_midweek_setup(database, skip_on_away: bool):
-    """One child absent on days 2..4 of a future week, one daily quest.
-
-    Returns ``(child_id, definition_id, start, end_iso, absent_dates)``.
-    """
-    from custom_components.nestquest.core.dao_presence import (
-        PresenceOverridesDao,
-    )
-
-    child = await ChildrenDao(database).create("Ada", NOW)
-    start = _future_monday()
-    end_iso = (start + datetime.timedelta(days=6)).isoformat()
-    absent = {
-        (start + datetime.timedelta(days=offset)).isoformat()
-        for offset in (2, 3, 4)
-    }
-    await PresenceOverridesDao(database).create(
-        child.id, min(absent), max(absent), False, note="away"
-    )
-    created = await create_quest_definition(
-        database,
-        "Daily chore",
-        ScheduleRule(rule_type=RuleType.DAILY, start_date=start.isoformat()),
-        [child.id],
-        ["morning"],
-        skip_on_away=skip_on_away,
-    )
-    assert created.definition.skip_on_away is skip_on_away
-    return child.id, created.definition.id, start, end_iso, absent
-
-
-def test_materialize_skip_on_away_true_skips_absent_dates(tmp_path) -> None:
-    async def _body(database):
-        child_id, _, start, end_iso, absent = await _absent_midweek_setup(
-            database, skip_on_away=True
-        )
-        count = await materialize(database, start.isoformat(), end_iso)
-        records = await QuestInstancesDao(database).list_by_date_range(
-            child_id, start.isoformat(), end_iso
-        )
-        due_dates = {record.due_date for record in records}
-        assert count == 4
-        assert due_dates.isdisjoint(absent)
-        assert len(due_dates) == 4
-
-    _with_db(tmp_path, "skip-on-away-true.db")(_body)
-
-
-def test_materialize_skip_on_away_false_generates_absent_dates(
-    tmp_path,
-) -> None:
-    async def _body(database):
-        child_id, _, start, end_iso, absent = await _absent_midweek_setup(
-            database, skip_on_away=False
-        )
-        count = await materialize(database, start.isoformat(), end_iso)
-        records = await QuestInstancesDao(database).list_by_date_range(
-            child_id, start.isoformat(), end_iso
-        )
-        due_dates = {record.due_date for record in records}
-        assert count == 7
-        assert absent <= due_dates
-        assert len(due_dates) == 7
-
-    _with_db(tmp_path, "skip-on-away-false.db")(_body)
-
-
-def test_edit_skip_on_away_regenerates_absent_dates(tmp_path) -> None:
-    """Toggling the flag through the edit path rebuilds future instances."""
-    async def _body(database):
-        child_id, definition_id, start, end_iso, absent = (
-            await _absent_midweek_setup(database, skip_on_away=True)
-        )
-        await materialize(database, start.isoformat(), end_iso)
-        dao = QuestInstancesDao(database)
-
-        async def due_dates() -> set[str]:
-            records = await dao.list_by_date_range(
-                child_id, start.isoformat(), end_iso
-            )
-            return {record.due_date for record in records}
-
-        assert (await due_dates()).isdisjoint(absent)
-
-        edited = await edit_quest_definition(
-            database, definition_id, skip_on_away=False
-        )
-        assert edited.definition.skip_on_away is False
-        assert absent <= await due_dates()
-
-        # None leaves the stored flag unchanged.
-        unchanged = await edit_quest_definition(
-            database, definition_id, title="Daily chore (renamed)"
-        )
-        assert unchanged.definition.skip_on_away is False
-
-        edited = await edit_quest_definition(
-            database, definition_id, skip_on_away=True
-        )
-        assert edited.definition.skip_on_away is True
-        assert (await due_dates()).isdisjoint(absent)
-
-    _with_db(tmp_path, "skip-on-away-edit.db")(_body)
-
-
-def test_skip_on_away_rejects_non_bool(tmp_path) -> None:
-    async def _body(database):
-        child = await ChildrenDao(database).create("Ada", NOW)
-        rule = ScheduleRule(rule_type=RuleType.DAILY, start_date="2026-01-01")
-        with pytest.raises(ValueError, match="skip_on_away must be a real bool"):
-            await create_quest_definition(
-                database, "Chore", rule, [child.id], ["morning"],
-                skip_on_away=1,
-            )
-        created = await create_quest_definition(
-            database, "Chore", rule, [child.id], ["morning"]
-        )
-        with pytest.raises(ValueError, match="skip_on_away must be a real bool"):
-            await edit_quest_definition(
-                database, created.definition.id, skip_on_away="false"
-            )
-        stored = await QuestDefinitionsDao(database).get(created.definition.id)
-        assert stored.skip_on_away is True
-
-    _with_db(tmp_path, "skip-on-away-validation.db")(_body)
-
-
 def test_materialize_rejects_malformed_or_inverted_bounds(tmp_path) -> None:
     async def _body(database):
         start = (_future_monday()).isoformat()

tests/test_migrations.py

@@ -153,9 +153,7 @@ def test_migration_list_shape() -> None:
     migration 3 brings pre-D-008 definitions to the multi-assignee
     model, migration 4 adds the windows table, migration 5 rebuilds
     quest_instances onto the widened (definition, child, date, window)
-    key, migration 6 adds actor_child_id to completion_events,
-    migration 7 adds the meta_state table and migration 8 adds
-    skip_on_away to quest_definitions.
+    key, and migration 6 adds actor_child_id to completion_events.
     """
     assert MIGRATIONS[0] == SCHEMA_V1_STATEMENTS
     assert callable(MIGRATIONS[1])
@@ -164,8 +162,7 @@ def test_migration_list_shape() -> None:
     assert callable(MIGRATIONS[4])
     assert callable(MIGRATIONS[5])
     assert MIGRATIONS[6] == SCHEMA_V7_META_STATE_DDL
-    assert callable(MIGRATIONS[7])
-    assert len(MIGRATIONS) == 8
+    assert len(MIGRATIONS) == 7
 
 
 # ---------------------------------------------------------------------------
@@ -567,13 +564,6 @@ def test_v2_definitions_rebuilt_to_multi_assignee(tmp_path) -> None:
             database.fetch_all("PRAGMA table_info(quest_definitions)")
         )
         assert "child_id" not in {c[1] for c in columns}
-        # The rebuilt row reads the pre-flag behaviour: skip on away.
-        skip = _run(
-            database.fetch_one(
-                "SELECT skip_on_away FROM quest_definitions WHERE id = 1"
-            )
-        )
-        assert skip == (1,)
         # The single assignee moved into the assignees table.
         assignees = _run(
             database.fetch_all(
@@ -647,87 +637,6 @@ def test_v2_definitions_rebuilt_to_multi_assignee(tmp_path) -> None:
         _run(database.close())
 
 
-# ---------------------------------------------------------------------------
-# Migration 8: skip_on_away on quest_definitions (Feature 22)
-# ---------------------------------------------------------------------------
-
-
-def _seed_v7_database(database) -> None:
-    """Build a genuine version-7 database holding one definition.
-
-    Migrations 1..7 run first; the fresh v1 DDL already carries
-    ``skip_on_away`` (canonical shape), so the column is dropped to
-    reproduce the exact pre-migration-8 table a shipped v7 file holds,
-    and a definition row is written through that old column list.
-    """
-    assert _migrate(database, MIGRATIONS[:7]) == 7
-    _run(
-        database.execute(
-            "ALTER TABLE quest_definitions DROP COLUMN skip_on_away"
-        )
-    )
-    columns = _run(database.fetch_all("PRAGMA table_info(quest_definitions)"))
-    assert "skip_on_away" not in {c[1] for c in columns}
-    _run(
-        database.execute(
-            "INSERT INTO schedule_rules (id, rule_type, interval, "
-            "start_date) VALUES (1, 'daily', 1, '2026-09-01')"
-        )
-    )
-    _run(
-        database.execute(
-            "INSERT INTO quest_definitions (id, title, schedule_rule_id, "
-            "is_active, created_at) VALUES (1, 'Dishes', 1, 1, "
-            "'2026-09-01T00:00:00+00:00')"
-        )
-    )
-
-
-def test_v7_definitions_gain_skip_on_away_defaulting_true(tmp_path) -> None:
-    from custom_components.nestquest.core.dao_rules import (
-        QuestDefinitionsDao,
-    )
-
-    database = _open_db(tmp_path / "v7-upgrade.db")
-    try:
-        _seed_v7_database(database)
-        before = _version(database)
-        assert before == 7
-
-        final = _migrate(database)
-
-        assert final == before + 1
-        assert _version(database) == before + 1
-        columns = {
-            c[1]: c
-            for c in _run(
-                database.fetch_all("PRAGMA table_info(quest_definitions)")
-            )
-        }
-        assert "skip_on_away" in columns
-        # (cid, name, type, notnull, dflt_value, pk)
-        assert columns["skip_on_away"][2:5] == ("INTEGER", 1, "1")
-        record = _run(QuestDefinitionsDao(database).get(1))
-        assert record is not None
-        assert record.title == "Dishes"
-        assert record.skip_on_away is True
-    finally:
-        _run(database.close())
-
-
-def test_skip_on_away_migration_is_noop_on_fresh_schema(tmp_path) -> None:
-    """A fresh file already has the column; step 8 only stamps."""
-    database = _open_db(tmp_path / "fresh-v8.db")
-    try:
-        assert _migrate(database) == len(MIGRATIONS)
-        columns = _run(
-            database.fetch_all("PRAGMA table_info(quest_definitions)")
-        )
-        assert [c[1] for c in columns].count("skip_on_away") == 1
-    finally:
-        _run(database.close())
-
-
 # ---------------------------------------------------------------------------
 # Idempotence: second start is a no-op
 # ---------------------------------------------------------------------------

tests/test_schema.py

@@ -322,7 +322,6 @@ def test_quest_definitions_columns_types_and_constraints(tmp_path) -> None:
             ("due_time", "TEXT", 0, None, 0),
             ("is_active", "INTEGER", 1, "1", 0),
             ("created_at", "TEXT", 1, None, 0),
-            ("skip_on_away", "INTEGER", 1, "1", 0),
         ]
     finally:
         _run(database.close())
@@ -634,30 +633,6 @@ def test_schedule_rules_rule_type_check_enforced(tmp_path) -> None:
         _run(database.close())
 
 
-@pytest.mark.parametrize("bad_flag", [2, -1])
-def test_quest_definitions_skip_on_away_check_enforced(
-    tmp_path, bad_flag
-) -> None:
-    database = _open_db(tmp_path / f"skip-on-away-{bad_flag}.db")
-    try:
-        _apply(database)
-        _child(database)
-        _insert_rule(database)
-        with pytest.raises(sqlite3.IntegrityError, match="CHECK"):
-            _insert_definition(database, skip_on_away=bad_flag)
-        definition_id = _insert_definition(database, skip_on_away=0)
-        with pytest.raises(sqlite3.IntegrityError, match="CHECK"):
-            _run(
-                database.execute(
-                    "UPDATE quest_definitions SET skip_on_away = ? "
-                    "WHERE id = ?",
-                    (bad_flag, definition_id),
-                )
-            )
-    finally:
-        _run(database.close())
-
-
 def test_schedule_rules_interval_zero_fails(tmp_path) -> None:
     database = _open_db(tmp_path / "interval-zero.db")
     try:

uv.lock

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