Fix review findings: first-refresh handling, stale runtime record, P3s

P1: the first-refresh error handling never fired against real Home
Assistant.  Real DataUpdateCoordinator.async_config_entry_first_refresh
converts ANY refresh failure into ConfigEntryNotReady (the original
exception survives only as __cause__), so `except NestQuestApiError`
could never match: the failure fell through to the outer except block,
unwound listeners, closed the DB and re-raised, and
async_forward_entry_setups never ran — no entities at all.  Two-sided
fix: _async_update_data now converts every typed NestQuestApiError
(unconfigured stub, transport failure, non-2xx) into
homeassistant.helpers.update_coordinator.UpdateFailed — the exception
HA's coordinator machinery records as a failed pass
(last_update_success=False, data=None) — and setup catches
ConfigEntryNotReady around the first refresh instead, so an unconfigured
API or failed fetch keeps setup alive with unavailable entities while
everything else still unwinds.  The conftest DataUpdateCoordinator
stand-in now reproduces HA's real contract (async_refresh records a
failure instead of raising; first_refresh wraps it in
ConfigEntryNotReady) and gains an UpdateFailed stand-in, so this class
of bug is caught by the suite — verified by reverting the catch, which
fails both unconfigured-API and failed-fetch tests.

P1: a stale hass.data[DOMAIN][entry.entry_id] survived a failed setup.
The runtime record registers in hass.data before the first refresh and
platform forward, but the except cleanup only cleared
entry.runtime_data; after any failure in that window a later unload
picked up the stale, already-torn-down record and re-invoked the
already-consumed update-listener remover (ValueError).  The except block
now also pops the hass.data entry, and
test_setup_failure_after_registration_shuts_coordinator_down (reworked
from the fiction-based first-refresh trigger: a failed first refresh is
tolerated setup, not an unwind) proves a failed setup followed by an
unload does not raise and leaves no residue.

P3: dropped the function-local re-import of NestQuestApiClient in
coordinator_client_from_entry (module-level import already covers it),
and the unused coordinator_client_from_entry alias in the conftest
fixture.

P3: test_due_today_payload_omits_missed_admin_equals_panel dropped the
missed-instance count assertions in the Feature 18 rewrite; restored
quests_completed_today == 0 / quests_remaining_today == 1 so the
missed-derivation + counts pairing stays verified (the counts arrive
precomputed and still roll the full day).

README.md

@@ -159,50 +159,9 @@ Sensors the automations read: `sensor.nestquest_<child>_quests_due_today`
 
 Run these steps in order to display the NestQuest panel on a TouchHub
 wall device. The panel is an HA Lovelace dashboard, so the kiosk browser
-is simply a Home Assistant client. The path below is zero-config: the
-integration registers its panel dashboard itself on setup, so no YAML
-and no hand-built views are involved.
+is simply a Home Assistant client.
 
-1. **Install the integration and add the config entry.** Install
-   NestQuest via HACS or manually (see Installation above) and restart
-   Home Assistant. Then, in *Settings → Devices & Services*, click
-   **Add Integration**, search for **NestQuest**, and submit the flow —
-   it has no fields; it just creates the single config entry. Then open
-   the entry, click **Configure**, and fill the panel-plane API
-   connection in the options flow:
-
-   - **NestQuest API base URL** — the full `http://host:port` URL of
-     your NestQuest API service (default `http://127.0.0.1:8000`).
-   - **Panel service token** — the token the panel presents to the API
-     service as its Bearer credential. It may stay empty until you have
-     one; a pasted token must be unpadded.
-
-   The form's remaining fields (panel idle timeout, coordinator update
-   interval, last-good snapshot staleness) have defaults that serve the
-   panel and need no change here.
-
-2. **The panel dashboard appears automatically.** On setup the
-   integration registers one storage-mode Lovelace dashboard: a sidebar
-   entry titled **NestQuest** at the URL path `/nestquest`, whose stored
-   config is nothing but the **`custom:nestquest-party` strategy**
-   (`strategy: { type: custom:nestquest-party }`). The strategy
-   generates the views at render time from the household roster:
-
-   - **The Party** — the party-board view at `/nestquest/party`; the
-     dashboard root `/nestquest` shows it as the first view.
-   - one quest-log view per child at `/nestquest/<child-slug>`
-     ("Ada's Quest Log", …), in roster order.
-
-   Nothing is hand-configured: no YAML, no manual views, no
-   `child_order`, no `quest_log_path`/`board_path` — the board and the
-   quest logs compute their navigation paths from the dashboard's own
-   URL — and every generated view is already in **Panel** layout (see
-   the two constraints below). If the Lovelace surfaces are unavailable
-   (for example when Lovelace runs in YAML mode), setup logs a warning
-   and skips the registration; create the dashboard manually with the
-   same strategy as described in the manual alternative below.
-
-3. **Create a dedicated kiosk user.** In *Settings → People → Users*, add
+1. **Create a dedicated kiosk user.** In *Settings → People → Users*, add
    a new user for the wall device. Make it **non-admin**, and ensure it is
    not in the NestQuest admin allowlist. The allowlist blocks the NestQuest
    **admin** operations — `uncomplete_quest`, `create_quest_definition`,
@@ -215,101 +174,66 @@ and no hand-built views are involved.
    Assistant user it may also reach other permitted Home Assistant entities
    and services.
 
-4. **Open the dashboard and point TouchHub at it.** Open
-   `http://<home-assistant>/nestquest` in a browser first and check the
-   party board renders with your children's crests. Then, in the
-   TouchHub launcher, add the **Home Assistant Lovelace** app to the
-   dock and paste the dashboard URL from step 2 — the dashboard root,
-   `/nestquest` (TouchHub loads that URL directly as the kiosk landing
-   page). Set TouchHub **Auto-Return** to a value GREATER than the
-   quest log's `idle_return_seconds` (default 40s) — recommend **60s or
-   higher**. If Auto-Return is at or below 40s, TouchHub returns to its
-   launcher before the quest log's idle return can navigate back to the
-   party board.
+2. **Build a dashboard with only the NestQuest panel cards.** Create a
+   Lovelace dashboard whose **URL slug is `nestquest`** (Settings →
+   Dashboards → Edit → URL slug). A functional panel needs **two** views
+   in that dashboard, each with its own card config from
+   `design/ENTITIES-AND-SERVICES.md` §4. Give the views these exact URL
+   paths (the path segment after the dashboard slug):
 
-5. **Log the kiosk session in.** Sign in on the device as the dedicated
-   kiosk user from step 3, and leave that session logged in.
+   - **View 1 path `board`** (URL `/nestquest/board`) — party board
+     (`type: custom:nestquest-party-board-card`): the household quest
+     board. Set `weather_entity` (optional; the dock falls back to
+     date/time), `quest_log_path: /nestquest/log` (the view the crest tap
+     navigates to), and `child_order: [slug1, slug2, slug3]` listing each
+     child's slug in display order.
+
+   - **View 2 path `log`** (URL `/nestquest/log`) — quest log
+     (`type: custom:nestquest-quest-log-card`): the per-child quest screen
+     the party board hops to. Set `board_path: /nestquest/board` (the
+     party-board view to return to), `weather_entity`,
+     `idle_return_seconds` (must be shorter than TouchHub Auto-Return),
+     `confirm_timeout_seconds`, and `complete_screen_seconds`. The quest
+     log reads the selected child's slug from the view's URL path, so the
+     board → log hop is a plain Lovelace navigation.
+
+    Each view's layout MUST be set to **Panel** (Edit Dashboard → pencil on the
+    view → View type: Panel). Home Assistant's default Masonry layout constrains
+    the 1080px-tall NestQuest card to a narrow column; Panel (single-card)
+    layout is what renders the card full-screen at 1920×1080.
+
+    The dashboard contains only the NestQuest panel card for each view —
+    no other cards, no admin controls.
+
+   The `quest_log_path` and `board_path` values must match the dashboard
+   slug and view paths above: `/<slug>/<view>`. If you chose `nestquest`
+   as the dashboard slug with view paths `board` and `log`, the card
+   configs are already correct. If you pick different names, substitute
+   your actual paths in **both** card configs — e.g. a dashboard slug
+   `chores` with view paths `main` and `history` needs
+   `quest_log_path: /chores/history` and `board_path: /chores/main`.
+   Navigation between the two views fails (the crest tap or back button
+   lands on a 404) if the card config paths do not match the dashboard
+   slug and view paths exactly.
+
+   See `design/ENTITIES-AND-SERVICES.md` §4 for the full card YAML.
+
+3. **Point TouchHub at it.** In the TouchHub launcher, add the **Home
+   Assistant Lovelace** app to the dock and paste the dashboard URL from
+   step 2 — the party-board view URL, e.g. `/nestquest/board` (TouchHub
+   loads that URL directly as the kiosk landing page). Set TouchHub
+   **Auto-Return** to a value GREATER than the quest log's
+   `idle_return_seconds` (default 40s) — recommend **60s or higher**. If
+   Auto-Return is at or below 40s, TouchHub returns to its launcher before
+   the quest log's idle return can navigate back to the party board.
+
+4. **Log the kiosk session in.** Sign in on the device as the dedicated
+   kiosk user from step 1, and leave that session logged in.
 
 TouchHub loads the dashboard URL directly. The NestQuest cards are normal
 Lovelace cards, not an iframe, so no Home Assistant framing setting is
 needed.
 
-### The two constraints
-
-- **Panel layout.** Every view must be in **Panel** (single-card)
-  layout: Home Assistant's default Masonry layout constrains the
-  1080px-tall NestQuest card to a narrow column, while Panel renders the
-  card full-screen at 1920×1080. The zero-config path already satisfies
-  the requirement — the strategy generates every view as
-  `type: panel` — while the manual alternative below requires setting
-  the layout by hand on each view (Edit Dashboard → pencil on the view
-  → View type: Panel).
-
-- **TouchHub Auto-Return.** TouchHub's **Auto-Return** must be greater
-  than the quest log's `idle_return_seconds` (default 40s) — recommend
-  **60s or higher** — so the launcher does not reclaim the wall device
-  before the quest log's own idle return navigates back to the party
-  board.
-
-### Manual alternative: build the dashboard by hand
-
-If you prefer not to use the zero-config dashboard above — or its
-registration was skipped — configure a Lovelace dashboard whose **URL
-slug is `nestquest`** (Settings → Dashboards → Edit → URL slug)
-yourself. Two options, in decreasing order of convenience:
-
-- **Use the strategy.** Give the dashboard
-
-  ```yaml
-  strategy:
-    type: custom:nestquest-party
-  ```
-
-  and no views of your own — the strategy generates the party-board and
-  quest-log views (each already in Panel layout) from the household
-  roster at render time. Optional `url_path` and `weather_entity` keys
-  may sit beside `strategy:`.
-
-- **Build the two views by hand.** A functional panel needs **two**
-  views in that dashboard, each with its own card config from
-  `design/ENTITIES-AND-SERVICES.md` §4. Give the views these exact URL
-  paths (the path segment after the dashboard slug):
-
-  - **View 1 path `board`** (URL `/nestquest/board`) — party board
-    (`type: custom:nestquest-party-board-card`): the household quest
-    board. Set `weather_entity` (optional; the dock falls back to
-    date/time), `quest_log_path: /nestquest/log` (the view the crest tap
-    navigates to), and `child_order: [slug1, slug2, slug3]` listing each
-    child's slug in display order.
-
-  - **View 2 path `log`** (URL `/nestquest/log`) — quest log
-    (`type: custom:nestquest-quest-log-card`): the per-child quest screen
-    the party board hops to. Set `board_path: /nestquest/board` (the
-    party-board view to return to), `weather_entity`,
-    `idle_return_seconds` (must be shorter than TouchHub Auto-Return —
-    see the two constraints above), `confirm_timeout_seconds`, and
-    `complete_screen_seconds`. The quest log reads the selected child's
-    slug from the view's URL path, so the board → log hop is a plain
-    Lovelace navigation.
-
-  The dashboard contains only the NestQuest panel card for each view —
-  no other cards, no admin controls. Each view's layout MUST be set to
-  **Panel** — see the two constraints above for why; the strategy
-  generates it for you, hand-built views do not get it for free.
-
-  The `quest_log_path` and `board_path` values must match the dashboard
-  slug and view paths above: `/<slug>/<view>`. If you chose `nestquest`
-  as the dashboard slug with view paths `board` and `log`, the card
-  configs are already correct. If you pick different names, substitute
-  your actual paths in **both** card configs — e.g. a dashboard slug
-  `chores` with view paths `main` and `history` needs
-  `quest_log_path: /chores/history` and `board_path: /chores/main`.
-  Navigation between the two views fails (the crest tap or back button
-  lands on a 404) if the card config paths do not match the dashboard
-  slug and view paths exactly.
-
-  See `design/ENTITIES-AND-SERVICES.md` §4 for the full card YAML.
-
 ## Developer Setup and Testing
 
 This project uses [`uv`](https://github.com/astral-sh/uv) for fast Python package and dependency management.

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
 

admin/.env.example

@@ -1,13 +0,0 @@
-# NestQuest Admin PWA — runtime configuration (Vite env).
-# Copy to .env (or .env.local) and fill in real values. NEVER commit .env.
-
-# Authentik OIDC provider. Defaults to the issuer below when unset.
-VITE_AUTHENTIK_ISSUER=https://auth.cubecraftlabs.com/application/o/nestquest/
-
-# REQUIRED. OAuth2/OIDC client id of the PUBLIC (PKCE) Authentik application.
-# No default: the app shows a configuration error screen when this is missing.
-# Never set a client_secret — this is a browser SPA using PKCE only.
-VITE_AUTHENTIK_CLIENT_ID=
-
-# NestQuest API base URL.
-VITE_API_BASE_URL=https://nestquest.cubecraftlabs.com

admin/.gitignore

@@ -1,2 +0,0 @@
-node_modules/
-dist/

admin/index.html

@@ -1,12 +0,0 @@
-<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0, viewport-fit=cover" />
-    <title>NestQuest Admin</title>
-  </head>
-  <body>
-    <div id="root"></div>
-    <script type="module" src="/src/main.tsx"></script>
-  </body>
-</html>

admin/package.json

@@ -1,27 +0,0 @@
-{
-  "name": "nestquest-admin",
-  "private": true,
-  "version": "0.0.0",
-  "type": "module",
-  "scripts": {
-    "dev": "vite",
-    "build": "vite build",
-    "preview": "vite preview",
-    "test": "vitest run"
-  },
-  "dependencies": {
-    "react": "^19.2.0",
-    "react-dom": "^19.2.0"
-  },
-  "devDependencies": {
-    "@testing-library/dom": "^10.4.1",
-    "@testing-library/react": "^16.3.0",
-    "@types/react": "^19.2.0",
-    "@types/react-dom": "^19.2.0",
-    "@vitejs/plugin-react": "^5.0.0",
-    "jsdom": "^30.1.1",
-    "typescript": "^5.9.2",
-    "vite": "^7.1.5",
-    "vitest": "^3.2.4"
-  }
-}

admin/src/App.css

@@ -1,117 +0,0 @@
-/* Shell layout — mobile-first (390x844 reference), plain CubeCraft styling. */
-
-.admin-shell {
-  display: flex;
-  flex-direction: column;
-  min-height: 100%;
-}
-
-.admin-header {
-  background: var(--nq-a-surface);
-  border-bottom: 1px solid var(--nq-a-border);
-  padding: 14px 16px;
-}
-
-.admin-title {
-  margin: 0;
-  font-size: 24px;
-  font-weight: 800;
-  letter-spacing: -0.02em;
-}
-
-.admin-subline {
-  margin: 2px 0 0;
-  font-size: 12px;
-  font-weight: 600;
-  color: var(--nq-a-ink-secondary);
-}
-
-.admin-panel {
-  flex: 1;
-  padding: 14px 16px 92px; /* bottom padding clears the 70px tab bar */
-}
-
-.admin-placeholder {
-  margin: 0;
-  padding: 13px;
-  background: var(--nq-a-surface);
-  border: 1px solid var(--nq-a-border);
-  border-radius: 8px;
-  font-size: 13.5px;
-  font-weight: 600;
-  color: var(--nq-a-ink-secondary);
-}
-
-.admin-tabbar {
-  position: fixed;
-  inset: auto 0 0;
-  display: flex;
-  min-height: calc(var(--nq-a-tabbar-height) + 12px);
-  padding: 8px 4px calc(12px + env(safe-area-inset-bottom));
-  background: var(--nq-a-surface);
-  border-top: 1px solid var(--nq-a-border);
-}
-
-.admin-tab {
-  flex: 1;
-  border: 0;
-  background: none;
-  font-family: inherit;
-  font-size: 12px;
-  font-weight: 600;
-  color: var(--nq-a-ink-secondary);
-  cursor: pointer;
-  padding: 6px 4px;
-}
-
-.admin-tab.active {
-  font-weight: 700;
-  color: var(--nq-brand-blue);
-}
-/* Auth screens (login, errors, refusal). */
-
-.admin-login,
-.admin-error,
-.admin-refusal,
-.admin-loading {
-  display: flex;
-  flex-direction: column;
-  align-items: center;
-  justify-content: center;
-  gap: 10px;
-  min-height: 100%;
-  padding: 32px 16px;
-  text-align: center;
-}
-
-.admin-login-button {
-  margin-top: 8px;
-  padding: 12px 24px;
-  border: none;
-  border-radius: 8px;
-  background: var(--nq-a-accent, #2563eb);
-  color: #fff;
-  font-size: 15px;
-  font-weight: 700;
-  cursor: pointer;
-}
-
-.admin-error,
-.admin-refusal {
-  color: var(--nq-a-ink, inherit);
-}
-
-.admin-refusal h1,
-.admin-error h1 {
-  margin: 0;
-  font-size: 20px;
-}
-
-.admin-refusal p,
-.admin-error p {
-  margin: 0;
-  max-width: 34em;
-  font-size: 14px;
-  font-weight: 600;
-  color: var(--nq-a-ink-secondary);
-}

admin/src/App.test.tsx

@@ -1,33 +0,0 @@
-import { afterEach, describe, expect, it } from "vitest";
-import { cleanup, fireEvent, render, screen } from "@testing-library/react";
-import App from "./App";
-
-describe("NestQuest Admin shell", () => {
-  afterEach(cleanup);
-
-  it("renders the title and all four tab labels", () => {
-    render(<App />);
-
-    expect(screen.getByRole("heading", { name: "NestQuest Admin" })).toBeTruthy();
-    for (const label of ["Today", "Tasks", "Schedule", "History"]) {
-      expect(screen.getByRole("tab", { name: label })).toBeTruthy();
-    }
-  });
-
-  it("starts on the Today placeholder and switches on tab click", () => {
-    render(<App />);
-
-    expect(screen.getByRole("tabpanel").textContent).toContain(
-      "Today placeholder",
-    );
-
-    fireEvent.click(screen.getByRole("tab", { name: "History" }));
-
-    expect(screen.getByRole("tabpanel").textContent).toContain(
-      "History placeholder",
-    );
-    expect(screen.getByRole("tab", { name: "History" }).getAttribute("aria-selected")).toBe(
-      "true",
-    );
-  });
-});

admin/src/App.tsx

@@ -1,49 +0,0 @@
-import { useState } from "react";
-import "./App.css";
-
-const TABS = [
-  { id: "today", label: "Today" },
-  { id: "tasks", label: "Tasks" },
-  { id: "schedule", label: "Schedule" },
-  { id: "history", label: "History" },
-] as const;
-
-type TabId = (typeof TABS)[number]["id"];
-
-export default function App() {
-  const [active, setActive] = useState<TabId>("today");
-
-  return (
-    <div className="admin-shell">
-      <header className="admin-header">
-        <h1 className="admin-title">NestQuest Admin</h1>
-        <p className="admin-subline">Admin console</p>
-      </header>
-      <main
-        className="admin-panel"
-        role="tabpanel"
-        aria-labelledby={`tab-${active}`}
-      >
-        <p className="admin-placeholder">
-          {TABS.find((tab) => tab.id === active)?.label} placeholder — screens
-          arrive in later tasks.
-        </p>
-      </main>
-      <nav className="admin-tabbar" aria-label="Admin sections">
-        {TABS.map((tab) => (
-          <button
-            key={tab.id}
-            id={`tab-${tab.id}`}
-            type="button"
-            role="tab"
-            aria-selected={tab.id === active}
-            className={tab.id === active ? "admin-tab active" : "admin-tab"}
-            onClick={() => setActive(tab.id)}
-          >
-            {tab.label}
-          </button>
-        ))}
-      </nav>
-    </div>
-  );
-}

admin/src/AppRoutes.test.tsx

@@ -1,73 +0,0 @@
-import { afterEach, describe, expect, it, vi } from "vitest";
-import { cleanup, render, screen, waitFor } from "@testing-library/react";
-import AppRoutes from "./AppRoutes";
-import { storeTokens } from "./auth/oidc";
-import { config } from "./config";
-
-// The bundled config reads real env at import time; seed the shared module's
-// clientId directly so AppRoutes sees a configured app in these tests.
-(config as { clientId: string | undefined }).clientId = "test-client-id";
-
-function jsonResponse(body: unknown, status = 200): Response {
-  return new Response(JSON.stringify(body), {
-    status,
-    headers: { "Content-Type": "application/json" },
-  });
-}
-
-describe("AppRoutes auth gating", () => {
-  afterEach(() => {
-    cleanup();
-    sessionStorage.clear();
-    vi.restoreAllMocks();
-    vi.unstubAllGlobals();
-    window.history.replaceState({}, "", "/");
-  });
-
-  it("renders the login screen when unauthenticated at /", () => {
-    render(<AppRoutes />);
-    expect(screen.getByTestId("login-screen")).toBeTruthy();
-    expect(
-      screen.getByRole("button", { name: /sign in with authentik/i }),
-    ).toBeTruthy();
-  });
-
-  it("renders the four-tab shell after a successful authenticated probe", async () => {
-    storeTokens({ access_token: "at-123", expires_in: 600 });
-    const fetchMock = vi.fn().mockResolvedValue(jsonResponse([]));
-    vi.stubGlobal("fetch", fetchMock);
-
-    render(<AppRoutes />);
-
-    await waitFor(() => {
-      expect(screen.getByRole("heading", { name: "NestQuest Admin" })).toBeTruthy();
-    });
-    for (const label of ["Today", "Tasks", "Schedule", "History"]) {
-      expect(screen.getByRole("tab", { name: label })).toBeTruthy();
-    }
-  });
-
-  it("renders the explicit refusal when the API answers 403", async () => {
-    storeTokens({ access_token: "at-123", expires_in: 600 });
-    const fetchMock = vi.fn().mockResolvedValue(new Response("", { status: 403 }));
-    vi.stubGlobal("fetch", fetchMock);
-
-    render(<AppRoutes />);
-
-    await waitFor(() => {
-      expect(screen.getByTestId("refusal-screen")).toBeTruthy();
-    });
-    expect(screen.getByText(/not in the nestquest-admins group/i)).toBeTruthy();
-  });
-
-  it("shows the configuration error screen when the client id is missing", () => {
-    const original = config.clientId;
-    (config as { clientId: string | undefined }).clientId = undefined;
-    try {
-      render(<AppRoutes />);
-      expect(screen.getByTestId("config-error-screen")).toBeTruthy();
-    } finally {
-      (config as { clientId: string | undefined }).clientId = original;
-    }
-  });
-});

admin/src/AppRoutes.tsx

@@ -1,176 +0,0 @@
-/**
- * Minimal path-based routing without react-router-dom: the app only needs two
- * paths (`/` shell and `/auth/callback`), so a tiny window.location switch is
- * enough and keeps the bundle small. Change screens listen to popstate.
- */
-import { useEffect, useState } from "react";
-import { ConfigError, config } from "./config";
-import {
-  AuthError,
-  buildAuthorizeUrl,
-  clearAuth,
-  handleCallback,
-  isAuthenticated,
-} from "./auth/oidc";
-import { ApiForbiddenError, apiFetch } from "./api/client";
-import AdminShell from "./App";
-
-type Screen =
-  | { kind: "loading" }
-  | { kind: "login" }
-  | { kind: "config-error"; message: string }
-  | { kind: "auth-error"; message: string }
-  | { kind: "refusal"; message: string }
-  | { kind: "app" };
-
-function currentPath(): string {
-  return window.location.pathname.replace(/\/+$/, "") || "/";
-}
-
-async function probeApi(setScreen: (screen: Screen) => void) {
-  // A cheap authenticated probe so a 403 surfaces as an explicit refusal
-  // right after login instead of a silent empty shell.
-  try {
-    await apiFetch("/api/v1/children", {}, config);
-    setScreen({ kind: "app" });
-  } catch (error) {
-    if (error instanceof ConfigError) {
-      setScreen({ kind: "config-error", message: error.message });
-      return;
-    }
-    if (error instanceof ApiForbiddenError) {
-      setScreen({ kind: "refusal", message: error.message });
-      return;
-    }
-    // Network or other failures still allow the shell to render; API screens
-    // handle their own errors in later tasks.
-    setScreen({ kind: "app" });
-  }
-}
-
-function LoginScreen({ onLogin }: { onLogin: () => void }) {
-  return (
-    <div className="admin-login" data-testid="login-screen">
-      <h1 className="admin-title">NestQuest Admin</h1>
-      <p className="admin-subline">Sign in to continue</p>
-      <button type="button" className="admin-login-button" onClick={onLogin}>
-        Sign in with Authentik
-      </button>
-    </div>
-  );
-}
-
-export default function AppRoutes() {
-  const [screen, setScreen] = useState<Screen>({ kind: "loading" });
-
-  useEffect(() => {
-    // Re-evaluate on navigation (popstate) — routing is path based.
-    const onPop = () => setScreen({ kind: "loading" });
-    window.addEventListener("popstate", onPop);
-    return () => window.removeEventListener("popstate", onPop);
-  }, []);
-
-  useEffect(() => {
-    let cancelled = false;
-    const path = currentPath();
-
-    if (!config.clientId) {
-      setScreen({
-        kind: "config-error",
-        message:
-          "Missing VITE_AUTHENTIK_CLIENT_ID configuration. Set it in your .env before building the admin PWA.",
-      });
-      return;
-    }
-
-    if (path === "/auth/callback") {
-      (async () => {
-        try {
-          await handleCallback(window.location.search, config);
-          if (cancelled) return;
-          window.history.replaceState({}, "", "/");
-          await probeApi((next) => !cancelled && setScreen(next));
-        } catch (error) {
-          if (cancelled) return;
-          const message =
-            error instanceof AuthError || error instanceof Error
-              ? error.message
-              : "Authentication failed.";
-          setScreen({ kind: "auth-error", message });
-        }
-      })();
-      return () => {
-        cancelled = true;
-      };
-    }
-
-    if (isAuthenticated()) {
-      void probeApi((next) => !cancelled && setScreen(next));
-    } else {
-      setScreen({ kind: "login" });
-    }
-    return () => {
-      cancelled = true;
-    };
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, []);
-
-  const startLogin = async () => {
-    try {
-      const url = await buildAuthorizeUrl(config);
-      window.location.assign(url);
-    } catch (error) {
-      setScreen({
-        kind: "config-error",
-        message: error instanceof Error ? error.message : "Login failed.",
-      });
-    }
-  };
-
-  switch (screen.kind) {
-    case "loading":
-      return (
-        <div className="admin-loading" role="status" data-testid="loading-screen">
-          Loading…
-        </div>
-      );
-    case "login":
-      return <LoginScreen onLogin={startLogin} />;
-    case "config-error":
-      return (
-        <div className="admin-error" role="alert" data-testid="config-error-screen">
-          <h1>Configuration error</h1>
-          <p>{screen.message}</p>
-        </div>
-      );
-    case "auth-error":
-      return (
-        <div className="admin-error" role="alert" data-testid="auth-error-screen">
-          <h1>Sign-in failed</h1>
-          <p>{screen.message}</p>
-          <button
-            type="button"
-            onClick={() => {
-              clearAuth();
-              window.history.replaceState({}, "", "/");
-              setScreen({ kind: "loading" });
-            }}
-          >
-            Try again
-          </button>
-        </div>
-      );
-    case "refusal":
-      return (
-        <div className="admin-refusal" role="alert" data-testid="refusal-screen">
-          <h1>Access refused</h1>
-          <p>{screen.message}</p>
-          <button type="button" onClick={() => { clearAuth(); window.history.replaceState({}, "", "/"); setScreen({ kind: "login" }); }}>
-            Sign out
-          </button>
-        </div>
-      );
-    case "app":
-      return <AdminShell />;
-  }
-}

admin/src/api/client.test.ts

@@ -1,94 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import {
-  ApiForbiddenError,
-  ApiUnauthorizedError,
-  apiFetch,
-} from "./client";
-import { storeTokens } from "../auth/oidc";
-import type { AppConfig } from "../config";
-
-const app: AppConfig = {
-  issuer: "https://auth.example.com/application/o/nestquest",
-  clientId: "test-client-id",
-  apiBaseUrl: "https://api.example.com",
-  authorizeEndpoint: "https://auth.example.com/application/o/authorize/",
-  tokenEndpoint: "https://auth.example.com/application/o/token/",
-  userinfoEndpoint: "https://auth.example.com/application/o/userinfo/",
-  endSessionEndpoint: "https://auth.example.com/application/o/nestquest/end-session/",
-  redirectUri: "http://localhost:5173/auth/callback",
-};
-
-function jsonResponse(body: unknown, status = 200): Response {
-  return new Response(JSON.stringify(body), {
-    status,
-    headers: { "Content-Type": "application/json" },
-  });
-}
-
-describe("API client", () => {
-  beforeEach(() => {
-    sessionStorage.clear();
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-    vi.unstubAllGlobals();
-  });
-
-  it("attaches the Bearer token to API calls", async () => {
-    storeTokens({ access_token: "at-123", expires_in: 600 });
-    const fetchMock = vi.fn().mockResolvedValue(jsonResponse([]));
-
-    await apiFetch("/api/v1/children", {}, app, fetchMock as any);
-
-    expect(fetchMock).toHaveBeenCalledTimes(1);
-    const [url, init] = fetchMock.mock.calls[0];
-    expect(url).toBe("https://api.example.com/api/v1/children");
-    expect(init.headers.Authorization).toBe("Bearer at-123");
-  });
-
-  it("throws ApiForbiddenError on 403 (authenticated but refused)", async () => {
-    storeTokens({ access_token: "at-123", expires_in: 600 });
-    const fetchMock = vi.fn().mockResolvedValue(new Response("", { status: 403 }));
-
-    await expect(
-      apiFetch("/api/v1/children", {}, app, fetchMock as any),
-    ).rejects.toBeInstanceOf(ApiForbiddenError);
-  });
-
-  it("triggers a login redirect on 401 with no refresh token", async () => {
-    storeTokens({ access_token: "stale", expires_in: 600 });
-    const assign = vi.fn();
-    vi.stubGlobal("location", { ...window.location, assign });
-    const fetchMock = vi.fn().mockResolvedValue(new Response("", { status: 401 }));
-
-    await expect(
-      apiFetch("/api/v1/children", {}, app, fetchMock as any),
-    ).rejects.toBeInstanceOf(ApiUnauthorizedError);
-    expect(assign).toHaveBeenCalledTimes(1);
-    const url = new URL(assign.mock.calls[0][0] as string);
-    expect(url.origin + url.pathname).toBe(
-      "https://auth.example.com/application/o/authorize/",
-    );
-    expect(url.searchParams.get("code_challenge_method")).toBe("S256");
-  });
-
-  it("preserves non-401/403 statuses on the post-refresh retry (500 is not mislabeled)", async () => {
-    storeTokens({ access_token: "stale", refresh_token: "rt-1", expires_in: 600 });
-    const fetchMock = vi
-      .fn()
-      .mockResolvedValueOnce(new Response("", { status: 401 })) // initial API call
-      .mockResolvedValueOnce(
-        jsonResponse({ access_token: "fresh", expires_in: 600 }), // refresh grant
-      )
-      .mockResolvedValueOnce(new Response("", { status: 500 })); // retry
-
-    const response = await apiFetch("/api/v1/children", {}, app, fetchMock as any);
-
-    expect(fetchMock).toHaveBeenCalledTimes(3);
-    expect(fetchMock.mock.calls[1][0]).toBe(app.tokenEndpoint);
-    expect(fetchMock.mock.calls[2][1].headers.Authorization).toBe("Bearer fresh");
-    // A server failure must surface as the real status, not ApiUnauthorizedError.
-    expect(response.status).toBe(500);
-  });
-});

admin/src/api/client.ts

@@ -1,93 +0,0 @@
-/**
- * Minimal fetch wrapper for the NestQuest API.
- *
- * - Attaches `Authorization: Bearer <access_token>` when a token is stored.
- * - 401: not authenticated (or token expired) -> trigger a new login.
- * - 403: authenticated but refused -> throws ApiForbiddenError so the UI can
- *   render an explicit refusal message.
- */
-import { config, type AppConfig } from "../config";
-import {
-  buildAuthorizeUrl,
-  getToken,
-  isExpired,
-  refreshAccessToken,
-} from "../auth/oidc";
-
-export class ApiForbiddenError extends Error {
-  constructor(message = "Your account is not in the nestquest-admins group.") {
-    super(message);
-    this.name = "ApiForbiddenError";
-  }
-}
-
-export class ApiUnauthorizedError extends Error {
-  constructor(message = "Not authenticated.") {
-    super(message);
-    this.name = "ApiUnauthorizedError";
-  }
-}
-
-export interface ApiRequestOptions extends Omit<RequestInit, "headers"> {
-  headers?: Record<string, string>;
-}
-
-/**
- * Redirect the browser to Authentik to start a new login.
- * Exported for testing injection.
- */
-export async function triggerLogin(app: AppConfig = config): Promise<void> {
-  const url = await buildAuthorizeUrl(app);
-  window.location.assign(url);
-}
-
-export async function apiFetch(
-  path: string,
-  options: ApiRequestOptions = {},
-  app: AppConfig = config,
-  fetchImpl: typeof fetch = fetch,
-): Promise<Response> {
-  if (isExpired() && (await refreshAccessToken(app, fetchImpl))) {
-    // token renewed; fall through and use the fresh one
-  }
-
-  const token = getToken();
-  const headers = {
-    ...(options.headers ?? {}),
-    ...(token ? { Authorization: `Bearer ${token}` } : {}),
-  };
-
-  const response = await fetchImpl(`${app.apiBaseUrl}${path}`, {
-    ...options,
-    headers,
-  });
-
-  if (response.status === 401) {
-    // Not authenticated: either no token or an unusable one.
-    if (await refreshAccessToken(app, fetchImpl)) {
-      const retryToken = getToken();
-      const retryResponse = await fetchImpl(`${app.apiBaseUrl}${path}`, {
-        ...options,
-        headers: {
-          ...(options.headers ?? {}),
-          ...(retryToken ? { Authorization: `Bearer ${retryToken}` } : {}),
-        },
-      });
-      if (retryResponse.status === 403) throw new ApiForbiddenError();
-      if (retryResponse.ok) return retryResponse;
-      // Only 401 means "unauthorized"; preserve every other status (e.g. a
-      // 500 from the API) so callers can react to the real response.
-      if (retryResponse.status === 401) throw new ApiUnauthorizedError();
-      return retryResponse;
-    }
-    await triggerLogin(app);
-    throw new ApiUnauthorizedError();
-  }
-
-  if (response.status === 403) {
-    // Authenticated, but Authentik's token does not belong to nestquest-admins.
-    throw new ApiForbiddenError();
-  }
-
-  return response;
-}

admin/src/auth/oidc.test.ts

@@ -1,173 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import {
-  buildAuthorizeUrl,
-  clearAuth,
-  getToken,
-  handleCallback,
-  logout,
-  storeTokens,
-} from "./oidc";
-import type { AppConfig } from "../config";
-
-function testApp(): AppConfig {
-  return {
-    issuer: "https://auth.example.com/application/o/nestquest",
-    clientId: "test-client-id",
-    apiBaseUrl: "https://api.example.com",
-    authorizeEndpoint: "https://auth.example.com/application/o/authorize/",
-    tokenEndpoint: "https://auth.example.com/application/o/token/",
-    userinfoEndpoint: "https://auth.example.com/application/o/userinfo/",
-    endSessionEndpoint: "https://auth.example.com/application/o/nestquest/end-session/",
-    redirectUri: "http://localhost:5173/auth/callback",
-  };
-}
-
-function jsonResponse(body: unknown, status = 200): Response {
-  return new Response(JSON.stringify(body), {
-    status,
-    headers: { "Content-Type": "application/json" },
-  });
-}
-
-describe("OIDC flow", () => {
-  beforeEach(() => {
-    sessionStorage.clear();
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  it("buildAuthorizeUrl carries all required params and stores state/verifier", async () => {
-    const app = testApp();
-    const url = new URL(await buildAuthorizeUrl(app));
-
-    expect(url.origin + url.pathname).toBe(app.authorizeEndpoint);
-    expect(url.searchParams.get("response_type")).toBe("code");
-    expect(url.searchParams.get("client_id")).toBe("test-client-id");
-    expect(url.searchParams.get("redirect_uri")).toBe(app.redirectUri);
-    expect(url.searchParams.get("scope")).toBe("openid email profile");
-    expect(url.searchParams.get("code_challenge_method")).toBe("S256");
-    expect(url.searchParams.get("code_challenge")).toMatch(/^[A-Za-z0-9_-]{43}$/);
-    expect(url.searchParams.get("state")).toMatch(/^[A-Za-z0-9_-]+$/);
-
-    expect(sessionStorage.getItem("nestquest.oidc_state")).toBe(
-      url.searchParams.get("state"),
-    );
-    expect(sessionStorage.getItem("nestquest.code_verifier")).toMatch(/^[A-Za-z0-9-._~]{43,128}$/);
-  });
-
-  it("handleCallback rejects a mismatched state", async () => {
-    await buildAuthorizeUrl(testApp());
-    sessionStorage.setItem("nestquest.oidc_state", "different-state");
-
-    const fetchMock = vi.fn();
-    await expect(
-      handleCallback("?code=abc&state=tampered", testApp(), fetchMock as any),
-    ).rejects.toThrow(/state mismatch/i);
-    expect(fetchMock).not.toHaveBeenCalled();
-    expect(getToken()).toBeUndefined();
-  });
-
-  it("handleCallback exchanges the code with the correct form body and stores the token", async () => {
-    await buildAuthorizeUrl(testApp());
-    const verifier = sessionStorage.getItem("nestquest.code_verifier")!;
-    const state = sessionStorage.getItem("nestquest.oidc_state")!;
-
-    const fetchMock = vi.fn().mockResolvedValue(
-      jsonResponse({
-        access_token: "at-123",
-        refresh_token: "rt-456",
-        id_token: "id-789",
-        expires_in: 300,
-      }),
-    );
-    await handleCallback(`?code=abc&state=${state}`, testApp(), fetchMock as any);
-
-    expect(fetchMock).toHaveBeenCalledTimes(1);
-    const [url, init] = fetchMock.mock.calls[0];
-    expect(url).toBe("https://auth.example.com/application/o/token/");
-    expect(init.method).toBe("POST");
-    expect(init.headers["Content-Type"]).toBe("application/x-www-form-urlencoded");
-
-    const body = new URLSearchParams(init.body);
-    expect(body.get("grant_type")).toBe("authorization_code");
-    expect(body.get("code")).toBe("abc");
-    expect(body.get("redirect_uri")).toBe(testApp().redirectUri);
-    expect(body.get("client_id")).toBe("test-client-id");
-    expect(body.get("code_verifier")).toBe(verifier);
-    expect(body.has("client_secret")).toBe(false);
-
-    expect(getToken()).toBe("at-123");
-    // one-time values consumed
-    expect(sessionStorage.getItem("nestquest.oidc_state")).toBeNull();
-    expect(sessionStorage.getItem("nestquest.code_verifier")).toBeNull();
-  });
-
-  it("handleCallback surfaces provider errors", async () => {
-    await expect(
-      handleCallback("?error=access_denied&error_description=nope", testApp(), vi.fn() as any),
-    ).rejects.toThrow(/nope|access_denied/);
-  });
-
-  it("clearAuth removes all stored auth data", () => {
-    storeTokens({ access_token: "a", refresh_token: "r", expires_in: 60 });
-    clearAuth();
-    expect(getToken()).toBeUndefined();
-    expect(sessionStorage.length).toBe(0);
-  });
-
-  it("logout clears auth and redirects to the end-session endpoint", async () => {
-    storeTokens({ access_token: "a", id_token: "idt", expires_in: 60 });
-    const assign = vi.fn();
-    const original = window.location;
-    vi.stubGlobal("location", { ...original, assign, origin: "http://localhost:5173" });
-
-    await logout(testApp());
-
-    expect(assign).toHaveBeenCalledTimes(1);
-    const url = new URL(assign.mock.calls[0][0] as string);
-    expect(url.toString()).toBe(
-      "https://auth.example.com/application/o/nestquest/end-session/?id_token_hint=idt&client_id=test-client-id&post_logout_redirect_uri=http%3A%2F%2Flocalhost%3A5173",
-    );
-    expect(getToken()).toBeUndefined();
-    vi.unstubAllGlobals();
-  });
-
-  it("buildAuthorizeUrl resolves the authorize endpoint via discovery for a non-default issuer", async () => {
-    const issuer = "https://sso.discovery.example/application/o/discovered";
-    const discoveryDoc = {
-      issuer,
-      authorization_endpoint: "https://sso.discovery.example/application/o/authorize/",
-      token_endpoint: "https://sso.discovery.example/application/o/token/",
-      userinfo_endpoint: "https://sso.discovery.example/application/o/userinfo/",
-      end_session_endpoint: `${issuer}/end-session/`,
-      jwks_uri: `${issuer}/jwks/`,
-    };
-    const fetchMock = vi.fn().mockImplementation((url: string) =>
-      Promise.resolve(
-        String(url).endsWith("/.well-known/openid-configuration")
-          ? jsonResponse(discoveryDoc)
-          : jsonResponse({}),
-      ),
-    );
-    const app: AppConfig = {
-      issuer,
-      clientId: "test-client-id",
-      apiBaseUrl: "https://api.example.com",
-      redirectUri: "http://localhost:5173/auth/callback",
-    };
-
-    const url = new URL(await buildAuthorizeUrl(app, fetchMock as any));
-
-    // The authorize endpoint comes from the discovery document — Authentik
-    // serves it outside the app-specific issuer path, so it is NOT
-    // `${issuer}/authorize/` and must never be a hardcoded production host.
-    expect(url.origin + url.pathname).toBe(discoveryDoc.authorization_endpoint);
-    expect(url.searchParams.get("client_id")).toBe("test-client-id");
-    expect(fetchMock).toHaveBeenCalledTimes(1);
-    expect(String(fetchMock.mock.calls[0][0])).toBe(
-      `${issuer}/.well-known/openid-configuration`,
-    );
-  });
-});

admin/src/auth/oidc.ts

@@ -1,225 +0,0 @@
-/**
- * OIDC authorization-code + PKCE flow for a PUBLIC client.
- *
- * Never sends a client_secret anywhere. Tokens are stored in sessionStorage
- * (per-tab, cleared on tab close) — never localStorage.
- */
-import { config, resolveEndpoints, type AppConfig, type ResolvedAppConfig } from "../config";
-import {
-  computeCodeChallenge,
-  generateCodeVerifier,
-  generateState,
-} from "./pkce";
-
-const STORAGE_KEYS = {
-  accessToken: "nestquest.access_token",
-  refreshToken: "nestquest.refresh_token",
-  expiresAt: "nestquest.expires_at",
-  idToken: "nestquest.id_token",
-  state: "nestquest.oidc_state",
-  codeVerifier: "nestquest.code_verifier",
-} as const;
-
-export class AuthError extends Error {}
-
-export interface TokenResponse {
-  access_token?: string;
-  refresh_token?: string;
-  id_token?: string;
-  expires_in?: number;
-  token_type?: string;
-}
-
-function makeScopes(): string {
-  return "openid email profile";
-}
-
-/**
- * Build the Authentik authorization redirect URL, storing state + verifier in
- * sessionStorage so the callback can validate them. Endpoints are resolved
- * from the issuer's OIDC discovery document when not set on the config.
- */
-export async function buildAuthorizeUrl(
-  app: AppConfig = config,
-  fetchImpl: typeof fetch = fetch,
-): Promise<string> {
-  if (!app.clientId) {
-    throw new AuthError(
-      "Missing VITE_AUTHENTIK_CLIENT_ID configuration. Set it in your .env before building the admin PWA.",
-    );
-  }
-  const resolved = await resolveEndpoints(app, fetchImpl);
-  const state = generateState();
-  const codeVerifier = generateCodeVerifier();
-  const codeChallenge = await computeCodeChallenge(codeVerifier);
-
-  sessionStorage.setItem(STORAGE_KEYS.state, state);
-  sessionStorage.setItem(STORAGE_KEYS.codeVerifier, codeVerifier);
-
-  const url = new URL(resolved.authorizeEndpoint);
-  url.searchParams.set("response_type", "code");
-  url.searchParams.set("client_id", app.clientId);
-  url.searchParams.set("redirect_uri", app.redirectUri);
-  url.searchParams.set("scope", makeScopes());
-  url.searchParams.set("state", state);
-  url.searchParams.set("code_challenge", codeChallenge);
-  url.searchParams.set("code_challenge_method", "S256");
-  return url.toString();
-}
-
-/**
- * Handle the OAuth callback: validate state, exchange the code at the token
- * endpoint (PKCE, form-urlencoded, no client_secret), store tokens.
- */
-export async function handleCallback(
-  query: URLSearchParams | string = window.location.search,
-  app: AppConfig = config,
-  fetchImpl: typeof fetch = fetch,
-): Promise<void> {
-  const params =
-    typeof query === "string" ? new URLSearchParams(query) : query;
-
-  const providerError = params.get("error");
-  if (providerError) {
-    throw new AuthError(
-      params.get("error_description") || `Provider returned error: ${providerError}`,
-    );
-  }
-
-  const code = params.get("code");
-  const state = params.get("state");
-  if (!code || !state) {
-    throw new AuthError("Callback is missing the code or state parameter.");
-  }
-
-  const storedState = sessionStorage.getItem(STORAGE_KEYS.state);
-  const codeVerifier = sessionStorage.getItem(STORAGE_KEYS.codeVerifier);
-  if (!storedState || storedState !== state || !codeVerifier) {
-    throw new AuthError("State mismatch — possible CSRF; refusing to log in.");
-  }
-
-  if (!app.clientId) {
-    throw new AuthError(
-      "Missing VITE_AUTHENTIK_CLIENT_ID configuration. Set it in your .env before building the admin PWA.",
-    );
-  }
-
-  const resolved: ResolvedAppConfig = await resolveEndpoints(app, fetchImpl);
-
-  const body = new URLSearchParams({
-    grant_type: "authorization_code",
-    code,
-    redirect_uri: app.redirectUri,
-    client_id: app.clientId,
-    code_verifier: codeVerifier,
-  });
-
-  const response = await fetchImpl(resolved.tokenEndpoint, {
-    method: "POST",
-    headers: { "Content-Type": "application/x-www-form-urlencoded" },
-    body: body.toString(),
-  });
-  if (!response.ok) {
-    throw new AuthError(`Token exchange failed with HTTP ${response.status}`);
-  }
-  const tokens = (await response.json()) as TokenResponse;
-  if (!tokens.access_token) {
-    throw new AuthError("Token response did not include an access token.");
-  }
-
-  storeTokens(tokens);
-  // One-time use values are consumed on success.
-  sessionStorage.removeItem(STORAGE_KEYS.state);
-  sessionStorage.removeItem(STORAGE_KEYS.codeVerifier);
-}
-
-export function storeTokens(tokens: TokenResponse): void {
-  sessionStorage.setItem(STORAGE_KEYS.accessToken, tokens.access_token!);
-  if (tokens.refresh_token) {
-    sessionStorage.setItem(STORAGE_KEYS.refreshToken, tokens.refresh_token);
-  }
-  if (tokens.id_token) {
-    sessionStorage.setItem(STORAGE_KEYS.idToken, tokens.id_token);
-  }
-  if (typeof tokens.expires_in === "number") {
-    sessionStorage.setItem(
-      STORAGE_KEYS.expiresAt,
-      String(Date.now() + tokens.expires_in * 1000),
-    );
-  }
-}
-
-export function getToken(): string | undefined {
-  return sessionStorage.getItem(STORAGE_KEYS.accessToken) ?? undefined;
-}
-
-export function getRefreshToken(): string | undefined {
-  return sessionStorage.getItem(STORAGE_KEYS.refreshToken) ?? undefined;
-}
-
-export function getIdToken(): string | undefined {
-  return sessionStorage.getItem(STORAGE_KEYS.idToken) ?? undefined;
-}
-
-export function isAuthenticated(): boolean {
-  return Boolean(getToken());
-}
-
-/** True once the stored access token has passed its (approximate) expiry. */
-export function isExpired(): boolean {
-  const expiresAt = sessionStorage.getItem(STORAGE_KEYS.expiresAt);
-  if (!expiresAt) return false;
-  return Date.now() >= Number(expiresAt);
-}
-
-/**
- * Refresh the access token with the refresh token grant. Returns false when
- * no refresh token is stored or the grant fails (caller should re-login).
- */
-export async function refreshAccessToken(
-  app: AppConfig = config,
-  fetchImpl: typeof fetch = fetch,
-): Promise<boolean> {
-  const refreshToken = getRefreshToken();
-  if (!refreshToken || !app.clientId) return false;
-
-  const resolved = await resolveEndpoints(app, fetchImpl);
-
-  const body = new URLSearchParams({
-    grant_type: "refresh_token",
-    refresh_token: refreshToken,
-    client_id: app.clientId,
-  });
-
-  const response = await fetchImpl(resolved.tokenEndpoint, {
-    method: "POST",
-    headers: { "Content-Type": "application/x-www-form-urlencoded" },
-    body: body.toString(),
-  });
-  if (!response.ok) return false;
-  const tokens = (await response.json()) as TokenResponse;
-  if (!tokens.access_token) return false;
-  storeTokens(tokens);
-  return true;
-}
-
-export function clearAuth(): void {
-  for (const key of Object.values(STORAGE_KEYS)) {
-    sessionStorage.removeItem(key);
-  }
-}
-
-/** Sign out: clear local auth, then send the browser to the end-session endpoint. */
-export async function logout(
-  app: AppConfig = config,
-  fetchImpl: typeof fetch = fetch,
-): Promise<void> {
-  const resolved = await resolveEndpoints(app, fetchImpl);
-  const idTokenHint = getIdToken();
-  clearAuth();
-  const params = new URLSearchParams();
-  if (idTokenHint) params.set("id_token_hint", idTokenHint);
-  if (app.clientId) params.set("client_id", app.clientId);
-  params.set("post_logout_redirect_uri", window.location.origin);
-  window.location.assign(`${resolved.endSessionEndpoint}?${params.toString()}`);
-}

admin/src/auth/pkce.test.ts

@@ -1,41 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import {
-  base64UrlEncode,
-  computeCodeChallenge,
-  generateCodeVerifier,
-  generateState,
-  isLikelyValidVerifier,
-} from "./pkce";
-
-describe("PKCE helpers", () => {
-  it("base64UrlEncode has no padding and url-safe characters", () => {
-    // bytes chosen to force "+" and "/" and padding in plain base64
-    const bytes = new Uint8Array([0xfb, 0xff, 0xbf, 0xff]);
-    const encoded = base64UrlEncode(bytes);
-    expect(encoded).not.toMatch(/[+/=]/);
-  });
-
-  it("computes the RFC 7636 appendix-B S256 vector", async () => {
-    const verifier =
-      "dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk";
-    const challenge = await computeCodeChallenge(verifier);
-    expect(challenge).toBe("E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM");
-  });
-
-  it("generates verifiers with valid charset and length", () => {
-    for (let i = 0; i < 20; i++) {
-      const verifier = generateCodeVerifier();
-      expect(isLikelyValidVerifier(verifier)).toBe(true);
-    }
-  });
-
-  it("rejects verifiers outside 43-128 chars or with reserved chars", () => {
-    expect(isLikelyValidVerifier("short")).toBe(false);
-    expect(isLikelyValidVerifier("a".repeat(129))).toBe(false);
-    expect(isLikelyValidVerifier("a".repeat(43) + "+")).toBe(false);
-  });
-
-  it("generates distinct random states", () => {
-    expect(generateState()).not.toBe(generateState());
-  });
-});

admin/src/auth/pkce.ts

@@ -1,55 +0,0 @@
-/**
- * PKCE (RFC 7636) helpers for a public SPA client.
- *
- * Uses the Web Crypto API, which requires a SECURE CONTEXT: the app must be
- * served over https or http://localhost, otherwise crypto.subtle is
- * unavailable and login cannot work.
- */
-
-const VERIFIER_CHARSET =
-  "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~";
-
-/** base64url-encode bytes with NO padding. */
-export function base64UrlEncode(bytes: Uint8Array): string {
-  let binary = "";
-  for (const byte of bytes) {
-    binary += String.fromCharCode(byte);
-  }
-  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
-}
-
-function randomBase64Url(byteLength: number): string {
-  const bytes = new Uint8Array(byteLength);
-  crypto.getRandomValues(bytes);
-  return base64UrlEncode(bytes);
-}
-
-/**
- * Random code_verifier: 43-128 chars, unreserved charset only.
- * 32 random bytes -> 43 base64url chars, which is the minimum allowed length.
- */
-export function generateCodeVerifier(): string {
-  return randomBase64Url(32);
-}
-
-/** S256 code_challenge = base64url(SHA-256(verifier)), no padding. */
-export async function computeCodeChallenge(verifier: string): Promise<string> {
-  const digest = await crypto.subtle.digest(
-    "SHA-256",
-    new TextEncoder().encode(verifier),
-  );
-  return base64UrlEncode(new Uint8Array(digest));
-}
-
-/** Random opaque state value for CSRF protection. */
-export function generateState(): string {
-  return randomBase64Url(16);
-}
-
-export function isLikelyValidVerifier(verifier: string): boolean {
-  return (
-    verifier.length >= 43 &&
-    verifier.length <= 128 &&
-    [...verifier].every((char) => VERIFIER_CHARSET.includes(char))
-  );
-}

admin/src/config.test.ts

@@ -1,215 +0,0 @@
-import { afterEach, describe, expect, it, vi } from "vitest";
-import {
-  ConfigError,
-  discoveryUrlForIssuer,
-  readConfig,
-  resolveEndpoints,
-  resolveEndpointsFromDiscovery,
-  type AppConfig,
-} from "./config";
-
-function jsonResponse(body: unknown, status = 200): Response {
-  return new Response(JSON.stringify(body), {
-    status,
-    headers: { "Content-Type": "application/json" },
-  });
-}
-
-// Mirrors Authentik's layout: authorize/token/userinfo live OUTSIDE the
-// application-specific issuer path, end-session/jwks under it.
-function discoveryDocument(issuer: string) {
-  const normalized = issuer.replace(/\/+$/, "");
-  const origin = new URL(normalized).origin;
-  return {
-    issuer,
-    authorization_endpoint: `${origin}/application/o/authorize/`,
-    token_endpoint: `${origin}/application/o/token/`,
-    userinfo_endpoint: `${origin}/application/o/userinfo/`,
-    end_session_endpoint: `${normalized}/end-session/`,
-    jwks_uri: `${normalized}/jwks/`,
-  };
-}
-
-describe("config", () => {
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  it("readConfig keeps the production issuer as the default", () => {
-    const cfg = readConfig({});
-    expect(cfg.issuer).toBe("https://auth.cubecraftlabs.com/application/o/nestquest");
-    expect(cfg.clientId).toBeUndefined();
-  });
-
-  it("readConfig normalizes a trailing slash off a custom issuer", () => {
-    expect(
-      readConfig({ VITE_AUTHENTIK_ISSUER: "https://sso.custom.example/application/o/custom/" })
-        .issuer,
-    ).toBe("https://sso.custom.example/application/o/custom");
-  });
-
-  it("readConfig hardcodes no OIDC endpoints — they come from discovery", () => {
-    const cfg = readConfig({});
-    expect(cfg.authorizeEndpoint).toBeUndefined();
-    expect(cfg.tokenEndpoint).toBeUndefined();
-    expect(cfg.userinfoEndpoint).toBeUndefined();
-    expect(cfg.endSessionEndpoint).toBeUndefined();
-    expect(cfg.jwksUri).toBeUndefined();
-  });
-
-  it("builds the discovery URL for issuers with and without a trailing slash", () => {
-    expect(discoveryUrlForIssuer("https://sso.example.com/application/o/app/")).toBe(
-      "https://sso.example.com/application/o/app/.well-known/openid-configuration",
-    );
-    expect(discoveryUrlForIssuer("https://sso.example.com/application/o/app")).toBe(
-      "https://sso.example.com/application/o/app/.well-known/openid-configuration",
-    );
-  });
-
-  it("resolves every endpoint from the discovery document of a non-default issuer", async () => {
-    const issuer = "https://sso.other-host.example/application/o/other-app";
-    const doc = discoveryDocument(issuer);
-    const fetchMock = vi.fn().mockResolvedValue(jsonResponse(doc));
-    const app: AppConfig = {
-      issuer,
-      clientId: "client-id",
-      apiBaseUrl: "https://api.example.com",
-      redirectUri: "http://localhost:5173/auth/callback",
-    };
-
-    const resolved = await resolveEndpoints(app, fetchMock as unknown as typeof fetch);
-
-    expect(fetchMock).toHaveBeenCalledTimes(1);
-    expect(fetchMock).toHaveBeenCalledWith(
-      "https://sso.other-host.example/application/o/other-app/.well-known/openid-configuration",
-    );
-    // Every endpoint comes verbatim from the (non-default) discovery document.
-    expect(resolved.authorizeEndpoint).toBe(doc.authorization_endpoint);
-    expect(resolved.tokenEndpoint).toBe(doc.token_endpoint);
-    expect(resolved.userinfoEndpoint).toBe(doc.userinfo_endpoint);
-    expect(resolved.endSessionEndpoint).toBe(doc.end_session_endpoint);
-    expect(resolved.jwksUri).toBe(doc.jwks_uri);
-    // Proves no hardcoded production host leaked into the resolved endpoints.
-    for (const endpoint of [
-      resolved.authorizeEndpoint,
-      resolved.tokenEndpoint,
-      resolved.userinfoEndpoint,
-      resolved.endSessionEndpoint,
-      resolved.jwksUri,
-    ]) {
-      expect(endpoint).not.toMatch(/cubecraftlabs/);
-    }
-  });
-
-  it("resolves discovery for an issuer configured with a trailing slash", async () => {
-    const issuer = "https://sso.slashy.example/application/o/slashy/";
-    const doc = discoveryDocument(issuer);
-    const fetchMock = vi.fn().mockResolvedValue(jsonResponse(doc));
-
-    const resolved = await resolveEndpointsFromDiscovery(issuer, fetchMock as any);
-
-    expect(fetchMock).toHaveBeenCalledWith(
-      "https://sso.slashy.example/application/o/slashy/.well-known/openid-configuration",
-    );
-    expect(resolved.authorizeEndpoint).toBe(doc.authorization_endpoint);
-    expect(resolved.endSessionEndpoint).toBe(doc.end_session_endpoint);
-  });
-
-  it("caches discovery per issuer for the session", async () => {
-    const issuer = "https://sso.cached.example/application/o/cached";
-    const fetchMock = vi.fn().mockResolvedValue(jsonResponse(discoveryDocument(issuer)));
-
-    const first = await resolveEndpointsFromDiscovery(issuer, fetchMock as any);
-    const second = await resolveEndpointsFromDiscovery(issuer, fetchMock as any);
-
-    expect(fetchMock).toHaveBeenCalledTimes(1);
-    expect(second).toBe(first);
-  });
-
-  it("surfaces a clear configuration error when discovery returns an HTTP error", async () => {
-    const issuer = "https://sso.http-error.example/application/o/broken";
-    const fetchMock = vi.fn().mockResolvedValue(new Response("", { status: 500 }));
-
-    const error = await resolveEndpointsFromDiscovery(issuer, fetchMock as any).then(
-      () => null,
-      (error: unknown) => error,
-    );
-
-    expect(error).toBeInstanceOf(ConfigError);
-    expect((error as Error).message).toContain(issuer);
-    expect((error as Error).message).toContain("HTTP 500");
-  });
-
-  it("surfaces a clear configuration error when discovery is unreachable", async () => {
-    const issuer = "https://sso.unreachable.example/application/o/unreachable";
-    const fetchMock = vi.fn().mockRejectedValue(new TypeError("network down"));
-
-    await expect(
-      resolveEndpointsFromDiscovery(issuer, fetchMock as any),
-    ).rejects.toBeInstanceOf(ConfigError);
-  });
-
-  it("surfaces a clear configuration error when the discovery document is incomplete", async () => {
-    const issuer = "https://sso.incomplete.example/application/o/incomplete";
-    const doc = discoveryDocument(issuer) as Record<string, string>;
-    delete doc.end_session_endpoint;
-    const fetchMock = vi.fn().mockResolvedValue(jsonResponse(doc));
-
-    await expect(
-      resolveEndpointsFromDiscovery(issuer, fetchMock as any),
-    ).rejects.toThrow(/end_session_endpoint/);
-  });
-
-  it("rejects a discovery document advertising a different issuer", async () => {
-    const issuer = "https://sso.mismatch.example/application/o/mismatch";
-    const doc = {
-      ...discoveryDocument(issuer),
-      issuer: "https://sso.elsewhere.example/application/o/elsewhere",
-    };
-    const fetchMock = vi.fn().mockResolvedValue(jsonResponse(doc));
-
-    await expect(
-      resolveEndpointsFromDiscovery(issuer, fetchMock as any),
-    ).rejects.toThrow(/issuer mismatch/i);
-  });
-
-  it("the bundled config resolves its endpoints from discovery at runtime", async () => {
-    const issuer = "https://sso.bundled.example/application/o/bundled";
-    const fetchMock = vi.fn().mockResolvedValue(jsonResponse(discoveryDocument(issuer)));
-    const bundled = readConfig({ VITE_AUTHENTIK_ISSUER: `${issuer}/`, VITE_AUTHENTIK_CLIENT_ID: "bundled-client" });
-    expect(bundled.authorizeEndpoint).toBeUndefined();
-
-    const resolved = await resolveEndpoints(bundled, fetchMock as any);
-
-    expect(resolved.authorizeEndpoint).toBe(
-      "https://sso.bundled.example/application/o/authorize/",
-    );
-    expect(resolved.tokenEndpoint).toBe("https://sso.bundled.example/application/o/token/");
-    expect(resolved.userinfoEndpoint).toBe(
-      "https://sso.bundled.example/application/o/userinfo/",
-    );
-    expect(resolved.endSessionEndpoint).toBe(
-      "https://sso.bundled.example/application/o/bundled/end-session/",
-    );
-    expect(resolved.jwksUri).toBe("https://sso.bundled.example/application/o/bundled/jwks/");
-  });
-
-  it("does not re-fetch discovery when the config already carries endpoints", async () => {
-    const app: AppConfig = {
-      issuer: "https://auth.example.com/application/o/nestquest",
-      clientId: "client-id",
-      apiBaseUrl: "https://api.example.com",
-      authorizeEndpoint: "https://auth.example.com/application/o/authorize/",
-      tokenEndpoint: "https://auth.example.com/application/o/token/",
-      userinfoEndpoint: "https://auth.example.com/application/o/userinfo/",
-      endSessionEndpoint: "https://auth.example.com/application/o/nestquest/end-session/",
-      redirectUri: "http://localhost:5173/auth/callback",
-    };
-    const fetchMock = vi.fn();
-
-    const resolved = await resolveEndpoints(app, fetchMock as any);
-
-    expect(fetchMock).not.toHaveBeenCalled();
-    expect(resolved).toBe(app);
-  });
-});

admin/src/config.ts

@@ -1,221 +0,0 @@
-/**
- * Runtime configuration, read from Vite env (import.meta.env).
- * See .env.example for the variables and their defaults.
- *
- * OIDC endpoints are NOT hardcoded here. They are resolved lazily from the
- * issuer's OIDC discovery document (see resolveEndpoints), because Authentik
- * serves authorize/token/userinfo OUTSIDE the application-specific issuer
- * path (issuer is /application/o/<slug>/, authorize is /application/o/authorize/).
- * Both hardcoding the production host and naively concatenating onto the
- * issuer would break non-default issuers; discovery is the only correct way.
- */
-
-export interface AppConfig {
-  issuer: string;
-  clientId: string | undefined;
-  apiBaseUrl: string;
-  /** Resolved from the issuer's OIDC discovery document — see resolveEndpoints(). */
-  authorizeEndpoint?: string;
-  tokenEndpoint?: string;
-  userinfoEndpoint?: string;
-  endSessionEndpoint?: string;
-  jwksUri?: string;
-  redirectUri: string;
-}
-
-/** AppConfig whose OIDC endpoints have been filled in by resolveEndpoints(). */
-export type ResolvedAppConfig = AppConfig &
-  Required<
-    Pick<
-      AppConfig,
-      "authorizeEndpoint" | "tokenEndpoint" | "userinfoEndpoint" | "endSessionEndpoint"
-    >
-  >;
-
-export interface DiscoveredEndpoints {
-  issuer: string;
-  authorizeEndpoint: string;
-  tokenEndpoint: string;
-  userinfoEndpoint: string;
-  endSessionEndpoint: string;
-  jwksUri: string;
-}
-
-/** Raised when OIDC discovery fails or the configuration is unusable. */
-export class ConfigError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = "ConfigError";
-  }
-}
-
-const REQUIRED_ENDPOINT_NAMES = [
-  "authorizeEndpoint",
-  "tokenEndpoint",
-  "userinfoEndpoint",
-  "endSessionEndpoint",
-] as const;
-
-export function readConfig(env: Record<string, string | undefined> = import.meta.env as any): AppConfig {
-  const issuer = (
-    env.VITE_AUTHENTIK_ISSUER || "https://auth.cubecraftlabs.com/application/o/nestquest/"
-  ).replace(/\/$/, "");
-  const clientId = env.VITE_AUTHENTIK_CLIENT_ID;
-  const apiBaseUrl = env.VITE_API_BASE_URL || "https://nestquest.cubecraftlabs.com";
-
-  return {
-    issuer,
-    // No default: a missing client id must surface as a configuration error
-    // screen, not a broken redirect to Authentik.
-    clientId: clientId || undefined,
-    apiBaseUrl,
-    // authorize/token/userinfo/end-session endpoints are resolved from the
-    // issuer's discovery document at runtime — never hardcoded here.
-    redirectUri: `${window.location.origin}/auth/callback`,
-  };
-}
-
-export const config: AppConfig = readConfig();
-
-interface DiscoveryDocument {
-  issuer?: unknown;
-  authorization_endpoint?: unknown;
-  token_endpoint?: unknown;
-  userinfo_endpoint?: unknown;
-  end_session_endpoint?: unknown;
-  jwks_uri?: unknown;
-}
-
-function normalizeIssuer(issuer: string): string {
-  return issuer.replace(/\/+$/, "");
-}
-
-function nonEmptyString(value: unknown): string | undefined {
-  return typeof value === "string" && value.length > 0 ? value : undefined;
-}
-
-/** Discovery document location for an issuer, tolerant of a trailing slash. */
-export function discoveryUrlForIssuer(issuer: string): string {
-  return `${normalizeIssuer(issuer)}/.well-known/openid-configuration`;
-}
-
-async function fetchDiscoveredEndpoints(
-  issuer: string,
-  fetchImpl: typeof fetch,
-): Promise<DiscoveredEndpoints> {
-  const normalizedIssuer = normalizeIssuer(issuer);
-  const discoveryUrl = `${normalizedIssuer}/.well-known/openid-configuration`;
-
-  let response: Response;
-  try {
-    response = await fetchImpl(discoveryUrl);
-  } catch (error) {
-    const reason = error instanceof Error ? error.message : String(error);
-    throw new ConfigError(
-      `OIDC discovery request to ${discoveryUrl} failed (${reason}). ` +
-        "Check VITE_AUTHENTIK_ISSUER and network reachability.",
-    );
-  }
-  if (!response.ok) {
-    throw new ConfigError(
-      `OIDC discovery failed: ${discoveryUrl} returned HTTP ${response.status}. ` +
-        "Check VITE_AUTHENTIK_ISSUER.",
-    );
-  }
-
-  let doc: DiscoveryDocument;
-  try {
-    doc = (await response.json()) as DiscoveryDocument;
-  } catch {
-    throw new ConfigError(
-      `OIDC discovery document at ${discoveryUrl} is not valid JSON. Check VITE_AUTHENTIK_ISSUER.`,
-    );
-  }
-
-  const authorizationEndpoint = nonEmptyString(doc.authorization_endpoint);
-  const tokenEndpoint = nonEmptyString(doc.token_endpoint);
-  const userinfoEndpoint = nonEmptyString(doc.userinfo_endpoint);
-  const endSessionEndpoint = nonEmptyString(doc.end_session_endpoint);
-  const jwksUri = nonEmptyString(doc.jwks_uri);
-  const discoveredIssuer = nonEmptyString(doc.issuer);
-
-  const endpointFields: Array<[string, string | undefined]> = [
-    ["authorization_endpoint", authorizationEndpoint],
-    ["token_endpoint", tokenEndpoint],
-    ["userinfo_endpoint", userinfoEndpoint],
-    ["end_session_endpoint", endSessionEndpoint],
-    ["jwks_uri", jwksUri],
-  ];
-  const missing = endpointFields.filter(([, value]) => !value).map(([name]) => name);
-  if (missing.length > 0) {
-    throw new ConfigError(
-      `OIDC discovery document at ${discoveryUrl} is missing: ${missing.join(", ")}. ` +
-        "The issuer must point at an OIDC provider that publishes these endpoints.",
-    );
-  }
-
-  if (discoveredIssuer && normalizeIssuer(discoveredIssuer) !== normalizedIssuer) {
-    throw new ConfigError(
-      `OIDC discovery issuer mismatch: ${discoveryUrl} advertises "${discoveredIssuer}" ` +
-        `but VITE_AUTHENTIK_ISSUER is "${normalizedIssuer}".`,
-    );
-  }
-
-  return {
-    issuer: normalizedIssuer,
-    authorizeEndpoint: authorizationEndpoint!,
-    tokenEndpoint: tokenEndpoint!,
-    userinfoEndpoint: userinfoEndpoint!,
-    endSessionEndpoint: endSessionEndpoint!,
-    jwksUri: jwksUri!,
-  };
-}
-
-/**
- * Session cache: one discovery fetch per issuer per SPA session. Failed
- * lookups are evicted so a transient network error can be retried instead of
- * poisoning the whole session.
- */
-const discoveryCache = new Map<string, Promise<DiscoveredEndpoints>>();
-
-export function resolveEndpointsFromDiscovery(
-  issuer: string,
-  fetchImpl: typeof fetch = fetch,
-): Promise<DiscoveredEndpoints> {
-  const normalizedIssuer = normalizeIssuer(issuer);
-  const cached = discoveryCache.get(normalizedIssuer);
-  if (cached) return cached;
-
-  const pending = fetchDiscoveredEndpoints(normalizedIssuer, fetchImpl);
-  discoveryCache.set(normalizedIssuer, pending);
-  pending.catch(() => {
-    discoveryCache.delete(normalizedIssuer);
-  });
-  return pending;
-}
-
-/**
- * Return `app` with all OIDC endpoints filled in. When the config already
- * carries them (pre-resolved config, tests) this is a no-op; otherwise the
- * issuer's discovery document is fetched (cached for the session) and its
- * authorization/token/userinfo/end-session/jwks endpoints are used.
- */
-export async function resolveEndpoints(
-  app: AppConfig,
-  fetchImpl: typeof fetch = fetch,
-): Promise<ResolvedAppConfig> {
-  const missing = REQUIRED_ENDPOINT_NAMES.filter((name) => !app[name]);
-  if (missing.length === 0) {
-    return app as ResolvedAppConfig;
-  }
-
-  const discovered = await resolveEndpointsFromDiscovery(app.issuer, fetchImpl);
-  return {
-    ...app,
-    authorizeEndpoint: discovered.authorizeEndpoint,
-    tokenEndpoint: discovered.tokenEndpoint,
-    userinfoEndpoint: discovered.userinfoEndpoint,
-    endSessionEndpoint: discovered.endSessionEndpoint,
-    jwksUri: discovered.jwksUri,
-  };
-}

admin/src/index.css

@@ -1,39 +0,0 @@
-/* NestQuest Admin — global tokens + base.
-   Plain CubeCraft styling, mobile-first, 390x844 reference
-   (design/ADMIN-SPEC.md). Values mirror design/tokens/nestquest-admin-tokens.css,
-   re-scoped to :root for the standalone PWA. */
-
-:root {
-  --nq-brand-blue: #3b3ab8;
-  --nq-brand-purple: #a035cc;
-
-  --nq-a-page: #f4f4f6;
-  --nq-a-surface: #ffffff;
-  --nq-a-border: #e4e4ea;
-  --nq-a-divider: #ededf1;
-
-  --nq-a-ink: #18181d;
-  --nq-a-ink-secondary: #52525e;
-  --nq-a-ink-tertiary: #70707e;
-
-  --nq-a-font: Nunito, system-ui, sans-serif;
-  --nq-a-tabbar-height: 70px;
-}
-
-* {
-  box-sizing: border-box;
-}
-
-html,
-body,
-#root {
-  margin: 0;
-  height: 100%;
-}
-
-body {
-  font-family: var(--nq-a-font);
-  background: var(--nq-a-page);
-  color: var(--nq-a-ink);
-  -webkit-font-smoothing: antialiased;
-}

admin/src/main.tsx

@@ -1,10 +0,0 @@
-import { StrictMode } from "react";
-import { createRoot } from "react-dom/client";
-import AppRoutes from "./AppRoutes";
-import "./index.css";
-
-createRoot(document.getElementById("root")!).render(
-  <StrictMode>
-    <AppRoutes />
-  </StrictMode>,
-);

admin/tsconfig.json

@@ -1,16 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "ESNext",
-    "moduleResolution": "bundler",
-    "lib": ["ES2022", "DOM", "DOM.Iterable"],
-    "jsx": "react-jsx",
-    "types": ["vite/client"],
-    "strict": true,
-    "skipLibCheck": true,
-    "noEmit": true,
-    "isolatedModules": true,
-    "useDefineForClassFields": true
-  },
-  "include": ["src"]
-}

admin/vite.config.ts

@@ -1,9 +0,0 @@
-import { defineConfig } from "vitest/config";
-import react from "@vitejs/plugin-react";
-
-export default defineConfig({
-  plugins: [react()],
-  test: {
-    environment: "jsdom",
-  },
-});

custom_components/nestquest/__init__.py

@@ -1,78 +1,375 @@
-"""The NestQuest integration (Feature 18: a thin client of the NestQuest API service).
-
-The integration owns NO database: the API service (Feature 16) owns the
-SQLite file, the migrations, and every business rule.  Setup builds the
-entry's ONE shared API client, the coordinator that polls the panel
-snapshot through it, and the SSE subscription that re-fires the API's
-transition frames on the HA bus, registers the single
-``nestquest.complete_quest`` proxy service, registers the zero-config
-panel dashboard (Feature 20), and forwards the sensor and
-binary_sensor platforms.
-"""
+"""The NestQuest integration."""
 from __future__ import annotations
 
+import asyncio
+import datetime
 import inspect
+import sqlite3
 from collections.abc import Callable
 from dataclasses import dataclass
+from pathlib import Path
 from typing import Any
+from zoneinfo import ZoneInfo
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryNotReady
+from homeassistant.helpers.event import async_track_time_change
 
 from .const import (
-    CONF_SNAPSHOT_STALENESS,
+    CONF_ADMIN_USER_IDS,
     CONF_UPDATE_INTERVAL,
-    DEFAULT_SNAPSHOT_STALENESS,
     DEFAULT_UPDATE_INTERVAL,
     DOMAIN,
     LOGGER,
     PLATFORMS,
 )
-from .coordinator import NestQuestCoordinator, coordinator_client_from_entry
-from .dashboard import async_register_dashboard
+from .core.settings import NestQuestSettings
 from .frontend import async_register_frontend
+from .coordinator import NestQuestCoordinator, coordinator_client_from_entry
+from .db import NestQuestDatabase, make_database
+from .materialize import materialize as _materialize_run
+from .migrations import apply_migrations
 from .services import async_deregister_services, async_register_services
-from .sse import NestQuestEventStream
+from .store import async_get_db_path
+from .admin_allowlist import seed_setup_admin
+from .sweep import run_missed_sweep
 
 _LOGGER = LOGGER
 
+#: SQLite reports "file is not a database" for corruption in every
+#: sqlite3 version this integration targets; the version-specific
+#: "encrypted or malformed" spelling (3.41+) maps to the same failure.
+_CORRUPTION_MARKERS = (
+    "file is not a database",
+    "database disk image is malformed",
+    "encrypted or malformed",
+    "is not a database",
+)
+
+#: Primary sqlite error codes that mean "the file is corrupt" (SQLite
+#: result codes, https://www.sqlite.org/c3ref/c_abort.html).  Extended
+#: codes carry the primary code in their low byte, so the match is on
+#: errcode & 0xff.
+_CORRUPT_PRIMARY_CODES = frozenset({11, 26})  # SQLITE_CORRUPT, SQLITE_NOTADB
+
+
+def _is_corruption_error(error: BaseException) -> bool:
+    """Return True when ``error`` indicates a corrupt database file.
+
+    Classification order: sqlite_errorcode (Python 3.11+) is primary
+    and locale-independent — SQLITE_CORRUPT and SQLITE_NOTADB, matched
+    on the primary byte so extended codes (SQLITE_CORRUPT_VTAB etc.)
+    classify correctly too.  Message matching is the fallback for
+    older Pythons: the corruption spellings are the documented English
+    texts; a non-English locale could evade them, but the code check
+    already covers every locale on supported Pythons.
+    """
+    if not isinstance(error, sqlite3.DatabaseError):
+        return False
+    errorcode = getattr(error, "sqlite_errorcode", None)
+    if errorcode is not None and (errorcode & 0xFF) in _CORRUPT_PRIMARY_CODES:
+        return True
+    message = str(error).lower()
+    return any(marker in message for marker in _CORRUPTION_MARKERS)
+
+
+async def _preflight_existing_file(
+    hass: HomeAssistant, db_path: Path
+) -> None:
+    """Detect corruption in an EXISTING file before it is opened read-write.
+
+    Opening read-write persists WAL mode — for a rollback-journal file
+    that rewrites the header byte 18/19 and can create -wal/-shm
+    sidecars — which would modify a corrupt file before detection and
+    break the leave-untouched guarantee.  This preflight therefore
+    validates the WHOLE file with a READ-ONLY connection (mode=ro +
+    immutable=1 URI, PRAGMA integrity_check, run on the executor like
+    every other DB call): corruption anywhere fails there, before
+    anything is written.  ``immutable=1`` is SQLite's documented
+    guarantee that the connection performs NO writes and creates NO
+    sidecars — even a WAL-header file gets its -wal/-shm reads served
+    without creating the shared-memory file.  Missing/empty files skip
+    the preflight (they are created fresh by the real open).  All
+    filesystem stat/URI work runs inside the executor job with the
+    probe so the event loop never touches disk.
+    """
+    def _probe() -> None:
+        # The file-state check and URI construction live inside the
+        # executor job: exists/stat/resolve are disk I/O.
+        if not db_path.exists():
+            return
+        # A zero-byte file is neither missing nor a valid database: it
+        # is a corrupt (truncated-to-nothing) existing file, likely an
+        # interrupted first write.  The leave-untouched contract applies
+        # to it too: refuse rather than silently initialize over it.
+        if db_path.stat().st_size == 0:
+            raise sqlite3.DatabaseError(
+                "existing database file is empty (zero bytes): file is "
+                "not a database"
+            )
+        # Properly escape the path: '#'/'?'/'%' in a directory or file
+        # name would otherwise be parsed as URI fragments/parameters/
+        # escapes.  immutable=1: SQLite guarantees no writes and no
+        # sidecar creation from this connection.
+        uri = db_path.resolve().as_uri() + "?mode=ro&immutable=1"
+        conn = sqlite3.connect(uri, uri=True)
+        try:
+            row = conn.execute("PRAGMA integrity_check").fetchone()
+        finally:
+            conn.close()
+        verdict = row[0] if row else "missing"
+        if verdict != "ok":
+            # A non-ok integrity verdict IS corruption: raise with the
+            # verdict text (which matches the corruption markers) and
+            # the NOTADB code so classification is code-based.
+            raise sqlite3.DatabaseError(
+                f"integrity_check verdict {verdict!r} on read-only "
+                f"probe: file is not a database"
+            )
+
+    try:
+        # Every DB-touching call goes through the executor (the mock
+        # harness's async_add_executor_job is awaitable too).
+        await hass.async_add_executor_job(_probe)
+    except sqlite3.DatabaseError as err:
+        # Non-ok integrity verdicts are corruption, full stop: there is
+        # no benign reading of a failed whole-file integrity check, so
+        # ANY DatabaseError out of the probe that carries a corruption
+        # marker or code propagates as corruption.  Only exotic probe
+        # failures that classify as non-corruption (e.g. a transient
+        # 'database is locked' on the read) are downgraded to a debug
+        # log, letting the real open path surface them.
+        if _is_corruption_error(err):
+            raise
+        raise sqlite3.DatabaseError(
+            f"read-only corruption probe of {db_path} failed: {err}"
+        ) from err
+
+async def _async_open_database(
+    hass: HomeAssistant, db_path: Path
+) -> NestQuestDatabase:
+    """Open the NestQuest database, mapping failure modes for setup.
+
+    Three startup cases (Feature 02 done-condition):
+
+    - file missing: SQLite creates it fresh on open — no special path,
+      migrations stamp version 1 on the next step.
+    - file present and valid: opens normally.
+    - file present but corrupt: log an ERROR with the path, close
+      anything opened, and raise ConfigEntryNotReady so HA retries —
+      the file is left byte-for-byte untouched so the owner can
+      restore a backup.  No code path here deletes or overwrites an
+      existing database file.
+
+    Corruption can surface at EITHER stage: a truncated header fails
+    in the read-only preflight (before the file is ever opened
+    read-write), while damaged later pages fail during migrations —
+    the preflight guarantees no WAL sidecar or header write happens
+    on a corrupt file before it is detected.  Both are classified the
+    same way.
+    """
+    try:
+        await _preflight_existing_file(hass, db_path)
+        database = await make_database(hass).open(db_path)
+    except asyncio.CancelledError:
+        raise
+    except sqlite3.DatabaseError as err:
+        if _is_corruption_error(err):
+            _LOGGER.error(
+                "NestQuest database at %s is corrupt: %s. Refusing to "
+                "start with a corrupt database; the file was left "
+                "untouched so a backup can be restored. Home Assistant "
+                "will retry setup.",
+                db_path,
+                err,
+            )
+            raise ConfigEntryNotReady(
+                f"NestQuest database corrupt: {db_path}"
+            ) from err
+        # open() failed for a non-corruption reason (locked file,
+        # permission problem): retryable, but nothing was opened.
+        _LOGGER.error(
+            "NestQuest database at %s failed to open: %s. Home "
+            "Assistant will retry setup.",
+            db_path,
+            err,
+        )
+        raise ConfigEntryNotReady(
+            f"NestQuest database unavailable: {db_path}"
+        ) from err
+    try:
+        await apply_migrations(database)
+    except (sqlite3.DatabaseError, RuntimeError) as err:
+        await database.close()
+        if _is_corruption_error(err):
+            _LOGGER.error(
+                "NestQuest database at %s is corrupt: %s. Refusing to "
+                "start with a corrupt database; the file was left "
+                "untouched so a backup can be restored. Home Assistant "
+                "will retry setup.",
+                db_path,
+                err,
+            )
+            raise ConfigEntryNotReady(
+                f"NestQuest database corrupt: {db_path}"
+            ) from err
+        # A non-corruption failure (e.g. a locked file, a future schema
+        # version) is also a retryable setup problem, but without the
+        # corruption framing.
+        _LOGGER.error(
+            "NestQuest database at %s failed to open: %s. Home "
+            "Assistant will retry setup.",
+            db_path,
+            err,
+        )
+        raise ConfigEntryNotReady(
+            f"NestQuest database unavailable: {db_path}"
+        ) from err
+    except asyncio.CancelledError:
+        await database.close()
+        raise
+    return database
+
 
 @dataclass
 class NestQuestRuntimeData:
     """Runtime data stored on a NestQuest config entry."""
 
     entry_id: str
+    settings: NestQuestSettings
+    database: NestQuestDatabase
     remove_update_listener: Callable[[], Any]
+    remove_time_change_listener: Callable[[], Any]
     coordinator: Any = None
-    event_stream: NestQuestEventStream | None = None
+
+
+async def _async_owner_user_ids(hass: HomeAssistant) -> list[str]:
+    """Return every Home Assistant owner-account user id.
+
+    The last-resort admin seed: when no persisted allowlist copy and no
+    flow-context user survive to first setup, the HA owner accounts are
+    seeded so the household is never left with zero admins (an empty
+    allowlist fails closed, which would lock the household out of its
+    own integration).  Owner accounts can already do everything in HA,
+    so granting NestQuest admin is not a privilege escalation.
+    """
+    auth = getattr(hass, "auth", None)
+    if auth is None:
+        return []
+    users = await auth.async_get_users()
+    owners = [
+        user.id
+        for user in users
+        if getattr(user, "is_owner", False) and getattr(user, "id", None)
+    ]
+    return owners
+
+
+async def _run_horizon_materialization(
+    hass: HomeAssistant,
+    database: NestQuestDatabase,
+    settings: NestQuestSettings,
+) -> None:
+    """Materialize the rolling horizon ``[today, today + horizon_days]``.
+
+    "today" is computed in HA local time (``hass.config.time_zone``) rather
+    than the system clock, so the horizon tracks the household's own day.
+    The walk itself runs through :func:`~.materialize.materialize`, whose DB
+    access is executor-only.
+
+    This is the ONE generation path: the startup backfill, the daily rollover
+    listener and the ``regenerate`` service all funnel through it, so there is
+    no duplicated materialization logic.  ``settings`` (REQUIRED — there is no
+    silent default; every caller already passes the entry's validated
+    :class:`NestQuestSettings`) carries the configured ``horizon_days``.  The
+    window itself comes from :meth:`settings.horizon_window` so the helper is
+    real and shared (not recomputed inline here).
+    """
+    time_zone = ZoneInfo(hass.config.time_zone)
+    today = datetime.datetime.now(time_zone).date()
+    start, end = settings.horizon_window(today)
+    await _materialize_run(database, start.isoformat(), end.isoformat(), today=today)
+
+
+def _register_day_rollover_listener(
+    hass: HomeAssistant,
+    database: NestQuestDatabase,
+    settings: NestQuestSettings,
+) -> Callable[[], Any]:
+    """Register the daily rollover listener and return its remover.
+
+    Fires once per day at the configured local ``day_rollover_time``:
+    first re-materializes the rolling horizon
+    ``[today, today + horizon_days]`` through the shared
+    :func:`_run_horizon_materialization` path (the entry's configured,
+    validated ``horizon_days`` carried on ``settings``), then runs the
+    Feature 11 missed sweep — announcing yesterday's still-open quests
+    as missed AFTER today's instances exist, watermark-guarded so a
+    re-fire of the listener the same night announces nothing twice.
+    """
+    hour, minute = settings.day_rollover_hour_minute
+
+    async def _run_materialization(_now: datetime.datetime) -> None:
+        await _run_horizon_materialization(hass, database, settings)
+        await run_missed_sweep(hass, database)
+
+    return async_track_time_change(
+        hass, _run_materialization, hour=hour, minute=minute
+    )
 
 
 def _find_live_runtime_data(hass: HomeAssistant) -> NestQuestRuntimeData | None:
-    """Return a live runtime record with a coordinator, or None.
+    """Return a live runtime record with a connected database, or None.
 
-    The domain-global service (the panel completion proxy) has no
-    database of its own; it resolves whichever config entry's runtime
-    data is currently live at call time, so it cannot hold a stale
-    handle to an unloaded entry's coordinator.
+    The domain-global services (e.g. ``regenerate``) have no database of
+    their own; they resolve whichever config entry's runtime data is
+    currently live at call time, so none of them can hold a stale handle
+    to a closed connection after another entry unloads.  The record also
+    carries that entry's validated ``settings`` (e.g. the configured
+    horizon) so service handlers read horizon days off it rather than
+    re-reading HA config.
     """
     for runtime_data in hass.data.get(DOMAIN, {}).values():
-        if getattr(runtime_data, "coordinator", None) is not None:
+        database = getattr(runtime_data, "database", None)
+        if database is not None and database.connected:
             return runtime_data
     return None
 
 
-def _register_services(hass: HomeAssistant) -> None:
-    """Register the domain-global NestQuest service once.
+def _make_regenerate_handler(hass: HomeAssistant):
+    """Return the Feature 07 ``regenerate`` handler closed over ``hass``."""
 
-    The service is DOMAIN-global — registered exactly once (guarded by
-    ``has_service``) and NOT bound to any config entry — so the panel
-    completion proxy resolves the currently-live runtime at call time
+    async def _regenerate(_call: Any) -> None:
+        runtime_data = _find_live_runtime_data(hass)
+        if runtime_data is None:
+            _LOGGER.warning(
+                "NestQuest regenerate requested but no config entry has a "
+                "live database; ignoring"
+            )
+            return
+        await _run_horizon_materialization(
+            hass, runtime_data.database, runtime_data.settings
+        )
+
+    return _regenerate
+
+
+def _register_services(hass: HomeAssistant) -> None:
+    """Register domain-global NestQuest services once.
+
+    Services are DOMAIN-global — registered exactly once (guarded by
+    ``has_service`` on regenerate) and NOT bound to any config entry —
+    so each handler resolves the currently-live database at call time
     and a name collision or duplicate setup is impossible.  Removal is
     handled by the unload path only once the LAST entry is removed
     (see :func:`_deregister_services`).
     """
-    async_register_services(hass, find_runtime=_find_live_runtime_data)
+    async_register_services(
+        hass,
+        find_runtime=_find_live_runtime_data,
+        regenerate_handler=_make_regenerate_handler(hass),
+    )
 
 
 def _deregister_services(hass: HomeAssistant) -> None:
@@ -89,14 +386,48 @@ async def async_setup(hass: HomeAssistant, config: dict[str, Any]) -> bool:
 async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Set up NestQuest from a config entry."""
     await async_register_frontend(hass)
-    # The zero-config panel dashboard (Feature 20): register the
-    # storage-mode strategy dashboard if no dashboard under the stable
-    # url_path exists yet.  Unavailability of the Lovelace dashboards
-    # collection (YAML mode, lovelace not loaded) logs a warning and
-    # NEVER fails setup; an existing dashboard — ours or the user's —
-    # is left untouched, so a reload cannot duplicate it.
-    await async_register_dashboard(hass)
     hass.data.setdefault(DOMAIN, {})
+    existing = hass.data[DOMAIN].get(entry.entry_id)
+    if existing is not None:
+        db = getattr(existing, "database", None)
+        if db is None or not db.connected:
+            # Reopen through the SAME safety path as first setup: a
+            # record without a live connection (a previous setup's
+            # close-on-failure, or a hand-replaced file) must get the
+            # missing/valid/corrupt classification too, never a raw
+            # sqlite3 error and never skipped migrations — and the
+            # same allowlist seeding, so a reopened fresh file is
+            # never ownerless.
+            db = await _async_open_database(
+                hass, await async_get_db_path(hass)
+            )
+            try:
+                stored_admin_ids = (
+                    entry.options.get(CONF_ADMIN_USER_IDS)
+                    or entry.data.get(CONF_ADMIN_USER_IDS)
+                )
+                context = getattr(entry, "context", None)
+                context_user_id = (
+                    context.get("user_id")
+                    if isinstance(context, dict)
+                    else None
+                )
+                await seed_setup_admin(
+                    db,
+                    stored_admin_ids=stored_admin_ids,
+                    context_user_id=context_user_id,
+                    owner_ids=await _async_owner_user_ids(hass),
+                )
+            except BaseException:
+                # A seeding failure must not leak the just-opened
+                # connection: close it before the error propagates, so
+                # HA's setup retry starts from a clean handle (the
+                # first-setup path closes symmetrically).
+                await db.close()
+                raise
+            existing.database = db
+        entry.runtime_data = existing
+        return True
 
     async def _async_update_listener(
         listener_hass: HomeAssistant, listener_entry: ConfigEntry
@@ -104,57 +435,90 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
         """Reload the entry when its options change."""
         await listener_hass.config_entries.async_reload(listener_entry.entry_id)
 
+    database = await _async_open_database(hass, await async_get_db_path(hass))
     remove_update_listener: Callable[[], Any] | None = None
+    remove_time_change_listener: Callable[[], Any] | None = None
     coordinator: Any = None
-    event_stream: NestQuestEventStream | None = None
     try:
+        # Seed the admin allowlist on first setup so the owner is never
+        # locked out: an empty database takes the persisted admin copy
+        # — the options flow's saved list first (it is the current
+        # one), else the config flow's user from entry data — and only
+        # then the HA user still present on the entry context.  No-op
+        # on a non-empty list (fail-closed narrowing is deliberate).
+        stored_admin_ids = (
+            entry.options.get(CONF_ADMIN_USER_IDS)
+            or entry.data.get(CONF_ADMIN_USER_IDS)
+        )
+        context = getattr(entry, "context", None)
+        context_user_id = (
+            context.get("user_id")
+            if isinstance(context, dict)
+            else None
+        )
+        owner_ids = await _async_owner_user_ids(hass)
+        await seed_setup_admin(
+            database,
+            stored_admin_ids=stored_admin_ids,
+            context_user_id=context_user_id,
+            owner_ids=owner_ids,
+        )
+        # Build the explicit settings object from entry.options ONCE: the
+        # horizon materialization and the daily-rollover listener both
+        # consume it, so core never reads HA config itself.  A malformed
+        # stored option falls back PER FIELD (via from_options_resilient)
+        # so a single bad sibling option cannot reset the user's
+        # horizon_days or day_rollover_time — the two fields core
+        # consumes — to their defaults.
+        settings = NestQuestSettings.from_options_resilient(entry.options)
         remove_update_listener = entry.add_update_listener(_async_update_listener)
+        remove_time_change_listener = _register_day_rollover_listener(
+            hass, database, settings
+        )
+        # Backfill any days the daily listener missed while the integration
+        # was off (or freshly installed): run the one idempotent walk over
+        # [today, today + horizon_days] once at setup, using the entry's
+        # configured horizon.  This runs through the SAME path as the daily
+        # listener and regenerate service.
+        await _run_horizon_materialization(hass, database, settings)
+        # The missed sweep runs at startup too (Feature 11): if HA was
+        # down at the rollover time, the previous night's still-open
+        # quests are announced as missed now instead of waiting for
+        # the next midnight.  Watermark-guarded, so this is a no-op
+        # when the night's sweep already ran.
+        await run_missed_sweep(hass, database)
         _register_services(hass)
-        # ONE API client for the entry, shared by the coordinator's
-        # snapshot polling, the SSE subscription, and the completion
-        # proxy (the client is stateless — one session, one connection
-        # pool).  An entry with no panel token yet gets the
-        # typed-error stub (unavailable entities, never a setup crash).
-        api_client = coordinator_client_from_entry(hass, entry)
-        # The shared coordinator: one refresh cycle every entity reads
-        # from (CONF_UPDATE_INTERVAL seconds, default five minutes).
-        # It polls the API service's panel snapshot; a failed poll
-        # keeps the entities rendering the last-good snapshot within
-        # CONF_SNAPSHOT_STALENESS, unavailable past it.
+        # The shared Feature 10 coordinator: one refresh cycle every
+        # entity reads from (CONF_UPDATE_INTERVAL seconds, default
+        # five minutes).  Since Feature 18 it polls the API service's
+        # panel snapshot instead of reading the local database; an
+        # entry with no panel token yet gets the typed-error stub
+        # (unavailable entities, never a setup crash).  Created AFTER
+        # services so a failure below unwinds them through the except
+        # path's listener handling.
         coordinator = NestQuestCoordinator(
             hass,
             entry_id=entry.entry_id,
-            api_client=api_client,
+            api_client=coordinator_client_from_entry(hass, entry),
             update_interval_seconds=entry.options.get(
                 CONF_UPDATE_INTERVAL, DEFAULT_UPDATE_INTERVAL
             ),
-            staleness_seconds=entry.options.get(
-                CONF_SNAPSHOT_STALENESS, DEFAULT_SNAPSHOT_STALENESS
-            ),
         )
-        # The panel event subscription (the SSE task): a background
-        # task consumes the API service's transition-event stream and
-        # re-fires the four documented HA bus events.  It reuses the
-        # coordinator's client, so it only starts when that client
-        # actually offers a stream — an unconfigured-token stub (or a
-        # test snapshot client without ``stream_events``) leaves it
-        # unstarted, and the typed-error path already covers
-        # availability for those entries.
-        if callable(getattr(api_client, "stream_events", None)):
-            event_stream = NestQuestEventStream(hass, api_client)
-            event_stream.start()
         runtime_data = NestQuestRuntimeData(
             entry_id=entry.entry_id,
+            settings=settings,
+            database=database,
             remove_update_listener=remove_update_listener,
+            remove_time_change_listener=remove_time_change_listener,
             coordinator=coordinator,
-            event_stream=event_stream,
         )
         # The runtime record is registered BEFORE the first refresh:
-        # the service proxy resolves the entry's runtime state through
-        # hass.data, and it must find the live coordinator there —
-        # never a half-set-up entry.  The platforms forward below reads
-        # the coordinator off the entry (the HA runtime-data contract);
-        # a forward failure below unwinds it through the except path.
+        # the refresh path (and anything it calls) resolves the entry's
+        # runtime state through hass.data, and it must find the live
+        # database there — never a half-set-up entry.  The platforms
+        # forward below reads the coordinator off the entry
+        # (the HA runtime-data contract); a forward failure below
+        # unwinds it through the except path.
         hass.data[DOMAIN][entry.entry_id] = runtime_data
         entry.runtime_data = runtime_data
         # The first refresh polls the API snapshot; an API failure
@@ -174,24 +538,27 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
             pass
         await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
     except BaseException:
-        # A failure anywhere after the listener was registered must not
-        # leak it (or the SSE task): unwind EVERYTHING acquired before
-        # the failure, keeping the original error as the one raised.
-        # Removal is best-effort — a failing step must not mask the
-        # setup error that triggered it.
-        if event_stream is not None:
+        # A failure anywhere after the database is open must not leak the
+        # listeners already registered against that (now-closed) database:
+        # unwind EVERY remover we acquired before the failure, keeping the
+        # original error as the one raised.  Removal is best-effort — a
+        # failing remover must not mask the setup error that triggered it.
+        for remove_listener in (
+            remove_time_change_listener,
+            remove_update_listener,
+        ):
+            if remove_listener is None:
+                continue
             try:
-                await event_stream.stop()
-            except BaseException:
-                pass
-        if remove_update_listener is not None:
-            try:
-                remove_update_listener()
+                result = remove_listener()
+                if inspect.isawaitable(result):
+                    await result
             except BaseException:
                 pass
         # A coordinator created before the failure holds entity
-        # listeners pointed at the never-registered runtime — shut it
-        # down so no scheduled refresh outlives the failed setup.
+        # listeners pointed at the database being closed below —
+        # shut it down FIRST so no scheduled refresh can ever run
+        # against a closed connection.
         if coordinator is not None:
             try:
                 await coordinator.async_shutdown()
@@ -199,8 +566,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
                 pass
         # A platform-forward failure reached this unwind AFTER
         # runtime_data was assigned: clear it so no later unload path
-        # re-invokes the already-consumed update-listener remover
-        # through the stale record.
+        # closes the already-closed database through the stale record.
         if getattr(entry, "runtime_data", None) is not None:
             entry.runtime_data = None
         # The runtime record was ALSO registered in hass.data before
@@ -209,7 +575,10 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
         # (hass.data wins over entry.runtime_data there) and
         # re-invokes the already-consumed update-listener remover.
         hass.data.get(DOMAIN, {}).pop(entry.entry_id, None)
+        await database.close()
         raise
+    assert remove_update_listener is not None
+    assert remove_time_change_listener is not None
     # The runtime record was already registered before the first
     # refresh; re-assert the (unchanged) record so the return path
     # stays readable as one registration site.
@@ -227,50 +596,58 @@ async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     if runtime_data is None:
         runtime_data = getattr(entry, "runtime_data", None)
     # Platforms unload FIRST (mirroring HA conventions): entity
-    # listeners must not outlive the coordinator the teardown below
-    # shuts down.
+    # listeners must not outlive the database and coordinator the
+    # teardown below closes.
     platforms_unloaded = await hass.config_entries.async_unload_platforms(
         entry, PLATFORMS
     )
     if platforms_unloaded is False and runtime_data is not None:
         # Home Assistant KEPT one or more platforms loaded — their
-        # entities still live and must keep their coordinator.  Restore
+        # entities still live and must keep their database.  Restore
         # the runtime record popped above and report failure so HA
         # retries the unload later instead of leaving live entities
-        # backed by a torn-down coordinator.
+        # backed by a closed database.
         hass.data.setdefault(DOMAIN, {})[entry.entry_id] = runtime_data
         return False
     unload_error: BaseException | None = None
     if runtime_data is not None:
-        # The SSE subscription is stopped FIRST: its task must be gone
-        # (no frame can fire) before anything else is torn down.
-        event_stream = getattr(runtime_data, "event_stream", None)
-        if event_stream is not None:
-            stop_stream = getattr(event_stream, "stop", None)
-            if stop_stream is not None:
-                await stop_stream()
-        remove_update_listener = getattr(
-            runtime_data, "remove_update_listener", None
+        remove_update_listener = getattr(runtime_data, "remove_update_listener", None)
+        remove_time_change_listener = getattr(
+            runtime_data, "remove_time_change_listener", None
         )
         try:
-            if remove_update_listener is not None:
-                result = remove_update_listener()
-                if inspect.isawaitable(result):
-                    await result
-        except BaseException as err:
-            # A failing remover must not skip the coordinator shutdown
-            # below; the first error is retained and re-raised only
-            # after the teardown ran.
-            if unload_error is None:
-                unload_error = err
+            for remove_listener in (
+                remove_update_listener,
+                remove_time_change_listener,
+            ):
+                if remove_listener is None:
+                    continue
+                try:
+                    result = remove_listener()
+                    if inspect.isawaitable(result):
+                        await result
+                except BaseException as err:
+                    # Cancel EVERY listener even when an earlier remover
+                    # raises: a skipped remover would leave a daily
+                    # callback firing against a closed database after
+                    # unload.  The first error is retained and re-raised
+                    # only after both removers (and the DB close) ran.
+                    if unload_error is None:
+                        unload_error = err
         finally:
-            # The coordinator's entity listeners must stop here: a
-            # scheduled refresh must never outlive the unload.
+            # The coordinator's entity listeners must stop BEFORE the
+            # database closes: a scheduled refresh starting during the
+            # close await would touch a cleared connection.  (The
+            # platform unload above already removed the entities; this
+            # clears the coordinator's own remaining listeners.)
             coordinator = getattr(runtime_data, "coordinator", None)
             if coordinator is not None:
                 shutdown = getattr(coordinator, "async_shutdown", None)
                 if shutdown is not None:
                     await shutdown()
+            database = getattr(runtime_data, "database", None)
+            if database is not None:
+                await database.close()
     # Domain-global services are torn down only once the FINAL entry
     # unloads (``hass.data[DOMAIN]`` is now empty), never when a sibling
     # entry is still loaded.

custom_components/nestquest/admin_allowlist.py

@@ -0,0 +1,11 @@
+"""Re-export of :mod:`custom_components.nestquest.core.admin_allowlist` for the integration package.
+
+The admin allowlist business layer lives in
+:mod:`custom_components.nestquest.core.admin_allowlist` (extracted in
+task 510c1f78); this module re-exports it so existing
+``from .admin_allowlist import ...`` references inside the integration
+keep working.
+"""
+from __future__ import annotations
+
+from .core.admin_allowlist import *  # noqa: F401,F403

custom_components/nestquest/api_client.py

@@ -30,22 +30,11 @@ swallowed.  There are NO retries and the client logs nothing: refresh
 cadence is the coordinator's concern (the next task), and the panel
 token is a secret that must never reach a log line or an error
 message — the error texts name the method, path, and status only.
-
-The panel plane's SSE event stream (``GET /api/v1/panel/events``) is
-exposed by :meth:`NestQuestApiClient.stream_events` — an async
-generator yielding ``(event_type, payload)`` per Server-Sent Events
-frame (``event: <type>`` / ``data: <json>`` lines separated by a blank
-line).  Opening the stream gets the same one-timeout, typed-error
-contract as every other call; reading it has NO body-wide timeout (a
-healthy stream is long-lived — the subscription manager owns
-reconnection and backoff).
 """
 from __future__ import annotations
 
 import asyncio
-import inspect
 import json
-from collections.abc import AsyncIterator
 from typing import TYPE_CHECKING, Any
 from urllib.parse import urlparse
 
@@ -62,7 +51,6 @@ if TYPE_CHECKING:
 __all__ = [
     "COMPLETE_INSTANCE_PATH",
     "DEFAULT_TIMEOUT_SECONDS",
-    "EVENTS_PATH",
     "NestQuestApiError",
     "NestQuestApiClient",
     "SNAPSHOT_PATH",
@@ -74,10 +62,6 @@ __all__ = [
 #: The panel plane's snapshot route (Feature 16).
 SNAPSHOT_PATH = "/api/v1/panel/snapshot"
 
-#: The panel plane's SSE event-stream route (Feature 16): each
-#: transition arrives as an ``event: <type>`` / ``data: <json>`` frame.
-EVENTS_PATH = "/api/v1/panel/events"
-
 #: The panel plane's completion route template (Feature 16); the
 #: ``{instance_id}`` placeholder is filled per call.
 COMPLETE_INSTANCE_PATH = "/api/v1/panel/instances/{instance_id}/complete"
@@ -246,121 +230,6 @@ class NestQuestApiClient:
             "POST", path, json_body={"actor_child_id": actor_child_id}
         )
 
-    async def stream_events(
-        self,
-    ) -> AsyncIterator[tuple[str, dict[str, Any]]]:
-        """Yield ``(event_type, payload)`` for every panel SSE frame.
-
-        Opens ``GET /api/v1/panel/events`` with the Bearer credential
-        and parses the Server-Sent Events framing the API service
-        emits: ``event: <type>`` and ``data: <json>`` lines closed by a
-        blank line (one frame per transition event; a frame's ``data``
-        may span several ``data:`` lines, joined with newlines — the
-        standard SSE rule).  Line splits across chunk boundaries are
-        buffered, so frames are parsed correctly whatever chunking the
-        transport produces.
-
-        Opening the stream carries the SAME one-timeout, typed-error
-        contract as every other call: a non-2xx response raises
-        :class:`NestQuestApiError` with its status and a transport
-        failure (connection refused, DNS, the open timing out) raises
-        one with ``status=None`` and the original error chained.  The
-        reading loop itself has NO timeout — a healthy stream is
-        long-lived — but any failure raised from the transport
-        mid-stream raises typed as well, so the consumer can reconnect.
-        A frame whose ``data`` is not valid JSON is a protocol failure
-        and raises typed, carrying the response status it arrived
-        with.  Cancellation is never converted: closing the generator
-        (``aclose``, i.e. the consumer's task being cancelled) stops
-        cleanly and closes the underlying response in every path.
-        """
-        url = f"{self._base_url}{EVENTS_PATH}"
-        headers = {"Authorization": f"Bearer {self._panel_token}"}
-        # Opening the response gets ONE request timeout, exactly like
-        # ``_request_json``; the read loop below runs WITHOUT one — a
-        # body-wide timeout would kill a healthy long-lived stream.
-        # The response context manager is entered manually (not via
-        # ``async with``) because the block must span the yields below;
-        # the ``finally`` closes it on EVERY exit path.
-        try:
-            async with asyncio.timeout(self._timeout_seconds):
-                stream_cm = self._session.request(
-                    "GET", url, headers=headers, json=None
-                )
-                response = await stream_cm.__aenter__()
-        except asyncio.CancelledError:
-            # Cancellation is never converted (see ``_request_json``).
-            raise
-        except NestQuestApiError:
-            raise
-        except Exception as err:
-            raise NestQuestApiError(
-                f"NestQuest API GET {EVENTS_PATH} transport failure: {err}",
-                status=None,
-            ) from err
-
-        status = response.status
-        if not 200 <= status < 300:
-            await self._close_stream(stream_cm)
-            raise NestQuestApiError(
-                f"NestQuest API GET {EVENTS_PATH} failed with HTTP {status}",
-                status=status,
-            )
-
-        try:
-            event_type: str | None = None
-            data_lines: list[str] = []
-            buffer = ""
-            async for chunk in response:
-                if isinstance(chunk, (bytes, bytearray)):
-                    chunk = chunk.decode("utf-8")
-                buffer += chunk
-                while "\n" in buffer:
-                    line, buffer = buffer.split("\n", 1)
-                    if line.startswith("event:"):
-                        event_type = line[len("event:"):].strip()
-                    elif line.startswith("data:"):
-                        data_lines.append(line[len("data:"):].strip())
-                    elif not line and event_type is not None:
-                        # A blank line ends the frame.  A trailing
-                        # incomplete frame (stream ends without its
-                        # closing blank line) is discarded, per the
-                        # SSE spec's treatment of incomplete events.
-                        try:
-                            payload = json.loads("\n".join(data_lines))
-                        except ValueError as err:
-                            raise NestQuestApiError(
-                                f"NestQuest API GET {EVENTS_PATH} "
-                                f"delivered a malformed SSE frame: {err}",
-                                status=status,
-                            ) from err
-                        yield event_type, payload
-                        event_type = None
-                        data_lines = []
-        except asyncio.CancelledError:
-            raise
-        except NestQuestApiError:
-            raise
-        except Exception as err:
-            raise NestQuestApiError(
-                f"NestQuest API GET {EVENTS_PATH} transport failure: {err}",
-                status=None,
-            ) from err
-        finally:
-            await self._close_stream(stream_cm)
-
-    @staticmethod
-    async def _close_stream(stream_cm: Any) -> None:
-        """Close an opened streaming response context manager.
-
-        Works for aiohttp's response context manager (whose
-        ``__aexit__`` is a coroutine) and for test stubs that return
-        either a coroutine or a plain value.
-        """
-        result = stream_cm.__aexit__(None, None, None)
-        if inspect.isawaitable(result):
-            await result
-
     async def _request_json(
         self,
         method: str,

custom_components/nestquest/children.py

@@ -0,0 +1,11 @@
+"""Re-export of :mod:`custom_components.nestquest.core.children` for the integration package.
+
+The children registry business layer lives in
+:mod:`custom_components.nestquest.core.children` (extracted in
+task 510c1f78); this module re-exports it so existing
+``from .children import ...`` references inside the integration keep
+working.
+"""
+from __future__ import annotations
+
+from .core.children import *  # noqa: F401,F403

custom_components/nestquest/completion.py

@@ -0,0 +1,11 @@
+"""Re-export of :mod:`custom_components.nestquest.core.completion` for the integration package.
+
+The completion business layer lives in
+:mod:`custom_components.nestquest.core.completion` (extracted in
+task 510c1f78); this module re-exports it so existing
+``from .completion import ...`` references inside the integration keep
+working.
+"""
+from __future__ import annotations
+
+from .core.completion import *  # noqa: F401,F403

custom_components/nestquest/config_flow.py

@@ -7,7 +7,7 @@ from homeassistant import config_entries
 from homeassistant.core import callback
 from homeassistant.data_entry_flow import FlowResult
 
-from .const import DOMAIN
+from .const import CONF_ADMIN_USER_IDS, DOMAIN
 
 
 class NestQuestConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
@@ -30,11 +30,11 @@ class NestQuestConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
     ) -> FlowResult:
         """Handle the user step of the config flow.
 
-        The integration needs no configuration to start (the API
-        connection is set in the options flow), so the user input is
-        stored as-is.  The former admin-allowlist copy is gone: with
-        the database removed the allowlist lives in the API service's
-        own store, not on the entry.
+        The HA user completing the flow is persisted into the entry
+        data as the initial admin allowlist copy: real HA does not
+        guarantee the flow context survives to setup, and entry data is
+        the persisted record first setup seeds from — the owner is
+        never locked out.
         """
         await self.async_set_unique_id(DOMAIN, raise_on_progress=False)
         if self._async_in_progress() or self._async_current_entries():
@@ -43,4 +43,12 @@ class NestQuestConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
         if user_input is None:
             return self.async_show_form(step_id="user")
 
-        return self.async_create_entry(title="NestQuest", data=dict(user_input))
+        data = dict(user_input)
+        flow_user_id = (
+            self.context.get("user_id")
+            if isinstance(self.context, dict)
+            else None
+        )
+        if flow_user_id:
+            data[CONF_ADMIN_USER_IDS] = [flow_user_id]
+        return self.async_create_entry(title="NestQuest", data=data)

custom_components/nestquest/coordinator.py

@@ -43,24 +43,11 @@ conversion matters at setup: HA's real
 ``async_config_entry_first_refresh`` wraps any failed pass in
 ``ConfigEntryNotReady``, so a setup that keys on the original
 exception type would never match it.)
-
-Last-good cache and staleness: every successful pass refreshes a cache
-of the rebuilt snapshot stamped with the :func:`time.monotonic`
-instant of the success.  A typed failure is checked against that stamp
-BEFORE the pass is declared failed: within the configured staleness
-threshold (``CONF_SNAPSHOT_STALENESS``, seconds, default three update
-intervals) the pass SUCCEEDS with the cached snapshot — the panel
-keeps rendering last-good data and the entities stay available — and
-the outage is logged as a warning.  Entities go unavailable only once
-the cache is older than the threshold (or before the first success);
-a later successful fetch refreshes the cache and the entities recover
-on their own, without a config-entry reload.
 """
 from __future__ import annotations
 
 import asyncio
 import datetime
-import time
 from typing import Any
 
 from homeassistant.core import HomeAssistant
@@ -72,7 +59,6 @@ from homeassistant.helpers.update_coordinator import (
 from .api_client import NestQuestApiClient, NestQuestApiError, resolve_api_config
 from .const import (
     CONF_UPDATE_INTERVAL,
-    DEFAULT_SNAPSHOT_STALENESS,
     DEFAULT_UPDATE_INTERVAL,
     DOMAIN,
     LOGGER,
@@ -190,17 +176,6 @@ class _UnconfiguredApiClient:
         )
 
 
-def _monotonic() -> float:
-    """The monotonic clock the staleness math reads.
-
-    A one-line indirection over :func:`time.monotonic` so the staleness
-    tests can drive the clock deterministically (patch THIS function,
-    never the stdlib clock).  Monotonic is deliberate: wall-clock jumps
-    (NTP corrections, suspends) must not shorten or extend the window.
-    """
-    return time.monotonic()
-
-
 class NestQuestCoordinator(DataUpdateCoordinator):
     """Shared refresh cycle for every NestQuest entity.
 
@@ -224,15 +199,6 @@ class NestQuestCoordinator(DataUpdateCoordinator):
     newer one and leave entities wrong until the next poll.  Real
     HA's coordinator already serializes internally; the lock keeps
     the same guarantee on the stand-in and costs nothing upstream.
-
-    Last-good cache: a successful pass stamps the rebuilt snapshot
-    with the :func:`~.coordinator._monotonic` instant of the success;
-    a typed failure within the configured staleness threshold
-    (``staleness_seconds``, from ``CONF_SNAPSHOT_STALENESS``) serves
-    that cached snapshot instead of failing the pass, so a short API
-    outage keeps the board up.  Past the threshold — or before the
-    first success — the pass fails as above, and a later successful
-    pass refreshes the cache and recovers the entities on its own.
     """
 
     def __init__(
@@ -242,7 +208,6 @@ class NestQuestCoordinator(DataUpdateCoordinator):
         entry_id: str,
         api_client: NestQuestApiClient,
         update_interval_seconds: int | None = None,
-        staleness_seconds: int | None = None,
     ) -> None:
         interval = update_interval_seconds
         if (
@@ -251,19 +216,6 @@ class NestQuestCoordinator(DataUpdateCoordinator):
             or interval < MIN_UPDATE_INTERVAL
         ):
             interval = DEFAULT_UPDATE_INTERVAL
-        staleness = staleness_seconds
-        if (
-            not isinstance(staleness, int)
-            or isinstance(staleness, bool)
-            or staleness < interval
-        ):
-            # A missing or nonsensical threshold falls back to the
-            # shipped default; a configured-but-too-short one (below
-            # even one poll interval) falls back to whichever of
-            # default/interval spans at least one failed poll, so the
-            # cache is never dead on arrival.  (The options flow
-            # validates the same rule at the form.)
-            staleness = max(DEFAULT_SNAPSHOT_STALENESS, interval)
         super().__init__(
             hass,
             LOGGER,
@@ -273,14 +225,6 @@ class NestQuestCoordinator(DataUpdateCoordinator):
         self.entry_id = entry_id
         self.api_client = api_client
         self._refresh_lock = asyncio.Lock()
-        #: The configured last-good window, in SECONDS (const.py:
-        #: CONF_SNAPSHOT_STALENESS / DEFAULT_SNAPSHOT_STALENESS).
-        self._staleness_seconds = staleness
-        #: The last-good cache: the snapshot from the most recent
-        #: SUCCESSFUL fetch and the :func:`time.monotonic` instant it
-        #: landed.  Both stay None until the first success.
-        self._last_good_snapshot: NestQuestSnapshot | None = None
-        self._last_good_monotonic: float | None = None
 
     async def async_refresh(self) -> None:
         """One refresh at a time; a queued refresh runs AFTER the
@@ -292,19 +236,8 @@ class NestQuestCoordinator(DataUpdateCoordinator):
     async def _async_update_data(self) -> NestQuestSnapshot:
         """One refresh pass: fetch the panel snapshot and rebuild it.
 
-        A successful pass rebuilds the snapshot and refreshes the
-        last-good cache (the snapshot plus the
-        :func:`time.monotonic` instant of the success).
-
         A typed API failure (unconfigured token stub, transport
-        failure, non-2xx response) is first checked against that
-        stamp: WITHIN the configured staleness threshold (elapsed time
-        since the last successful fetch, inclusive of the threshold
-        itself) the pass SUCCEEDS with the cached snapshot — the panel
-        keeps rendering last-good data, the entities stay available —
-        and the outage is logged as a clear warning (never silent).
-        With no cache yet, or past the threshold, the typed error is
-        converted to
+        failure, non-2xx response) is converted to
         :class:`~homeassistant.helpers.update_coordinator.UpdateFailed`
         — the exception HA's coordinator machinery records as a failed
         pass (``last_update_success = False``, ``data`` unchanged) so
@@ -315,31 +248,11 @@ class NestQuestCoordinator(DataUpdateCoordinator):
         try:
             payload = await self.api_client.get_snapshot()
         except NestQuestApiError as err:
-            now = _monotonic()
-            cached = self._last_good_snapshot
-            fetched_at = self._last_good_monotonic
-            if (
-                cached is not None
-                and fetched_at is not None
-                and now - fetched_at <= self._staleness_seconds
-            ):
-                LOGGER.warning(
-                    "NestQuest API refresh failed (%s); serving the "
-                    "last-good snapshot fetched %.0f s ago, within the "
-                    "%d s staleness threshold",
-                    err,
-                    now - fetched_at,
-                    self._staleness_seconds,
-                )
-                return cached
             LOGGER.error(
                 "NestQuest coordinator refresh failed: %s", err
             )
             raise UpdateFailed(str(err)) from err
-        snapshot = snapshot_from_api_payload(payload)
-        self._last_good_snapshot = snapshot
-        self._last_good_monotonic = _monotonic()
-        return snapshot
+        return snapshot_from_api_payload(payload)
 
 
 def coordinator_client_from_entry(

custom_components/nestquest/core/const.py

@@ -20,41 +20,44 @@ TIME_PATTERN = re.compile(r"(?:[01]\d|2[0-3]):[0-5]\d")
 PLATFORMS: list[str] = ["sensor", "binary_sensor"]
 
 # Home Assistant bus events (design/ENTITIES-AND-SERVICES.md §3).  The
-# panel and admin cards listen for these; since Feature 18 the
-# completed/uncompleted/day-complete transitions are published by the
-# API service on its SSE stream and re-fired on the bus by the
-# integration's subscription, and Feature 11's nightly sweep fires
-# quest_missed.
+# panel and admin cards listen for these; Feature 10 fires completed,
+# uncompleted, and child_day_complete from the service paths, and
+# Feature 11's nightly sweep fires quest_missed.
 EVENT_QUEST_COMPLETED = "nestquest_quest_completed"
 EVENT_QUEST_UNCOMPLETED = "nestquest_quest_uncompleted"
 EVENT_QUEST_MISSED = "nestquest_quest_missed"
 EVENT_CHILD_DAY_COMPLETE = "nestquest_child_day_complete"
 
-#: Canonical domain-global service name (design/ENTITIES-AND-SERVICES.md §2).
-#: Since Feature 18 only the panel completion service remains: the admin
-#: surface is the PWA and the API service's admin routes, so the former
-#: HA admin services (uncomplete, quest-definition and presence
-#: management, CSV export, child management, regenerate) are gone.
+#: Canonical domain-global service names (design/ENTITIES-AND-SERVICES.md §2
+#: plus the existing Feature 07 regenerate service).
 SERVICE_COMPLETE_QUEST = "complete_quest"
+SERVICE_UNCOMPLETE_QUEST = "uncomplete_quest"
+SERVICE_CREATE_QUEST_DEFINITION = "create_quest_definition"
+SERVICE_UPDATE_QUEST_DEFINITION = "update_quest_definition"
+SERVICE_SET_QUEST_DEFINITION_ACTIVE = "set_quest_definition_active"
+SERVICE_SET_PRESENCE_PATTERN = "set_presence_pattern"
+SERVICE_CREATE_PRESENCE_OVERRIDE = "create_presence_override"
+SERVICE_DELETE_PRESENCE_OVERRIDE = "delete_presence_override"
+SERVICE_EXPORT_HISTORY_CSV = "export_history_csv"
+SERVICE_MANAGE_CHILD = "manage_child"
+SERVICE_REGENERATE = "regenerate"
 
 DOMAIN_SERVICES: tuple[str, ...] = (
     SERVICE_COMPLETE_QUEST,
+    SERVICE_UNCOMPLETE_QUEST,
+    SERVICE_CREATE_QUEST_DEFINITION,
+    SERVICE_UPDATE_QUEST_DEFINITION,
+    SERVICE_SET_QUEST_DEFINITION_ACTIVE,
+    SERVICE_SET_PRESENCE_PATTERN,
+    SERVICE_CREATE_PRESENCE_OVERRIDE,
+    SERVICE_DELETE_PRESENCE_OVERRIDE,
+    SERVICE_EXPORT_HISTORY_CSV,
+    SERVICE_MANAGE_CHILD,
+    SERVICE_REGENERATE,
 )
 
 SQLITE_DB_FILENAME = "nestquest.db"
 
-# Zero-config panel dashboard (Feature 20): ONE storage-mode Lovelace
-# dashboard registered on setup whose config carries the bundle's
-# ``custom:nestquest-party`` strategy (frontend/src/strategy.ts) — the
-# views are generated at render time from the household roster.  The
-# url_path IS the domain: the stable key idempotency is keyed on (a
-# reload or a second entry never duplicates it, and a dashboard already
-# registered under it — ours or the user's — is left untouched).
-DASHBOARD_URL_PATH = DOMAIN
-DASHBOARD_TITLE = "NestQuest"
-DASHBOARD_ICON = "mdi:party-popper"
-DASHBOARD_STRATEGY_TYPE = "custom:nestquest-party"
-
 # Configuration keys and default values
 CONF_HORIZON_DAYS = "horizon_days"
 DEFAULT_HORIZON_DAYS = 14
@@ -78,21 +81,6 @@ CONF_UPDATE_INTERVAL = "update_interval"
 DEFAULT_UPDATE_INTERVAL = 300
 MIN_UPDATE_INTERVAL = 30
 
-# Last-good snapshot staleness (Feature 18), in SECONDS: how long the
-# coordinator keeps SERVING the last good snapshot after the API stops
-# answering.  A failed poll whose elapsed time since the last successful
-# fetch is within the threshold returns the cached snapshot (the panel
-# keeps rendering last-good data, entities stay available); past it the
-# poll fails the HA way and the entities go unavailable.  The default is
-# 3x the default update interval (900 s = 15 minutes): three consecutive
-# failed five-minute polls before the board is declared stale — enough
-# to ride out an API service restart, short enough not to render a
-# days-old board all day.  Validation floor: the threshold must be at
-# least the configured update interval, or the cache could never span
-# even one failed poll.
-CONF_SNAPSHOT_STALENESS = "snapshot_staleness"
-DEFAULT_SNAPSHOT_STALENESS = 3 * DEFAULT_UPDATE_INTERVAL
-
 # Notification automations (Feature 11).  The notify target is a free-text
 # Home Assistant service name (e.g. "notify.mobile_app_dads_phone") the
 # household fills in — never a hard-coded personal target; the times are

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/service_policy.py

@@ -0,0 +1,46 @@
+"""Explicit admin-only versus open service registry (Feature 09).
+
+One mapping, one file: every registered ``nestquest`` service name is
+either ``open`` or ``admin_only``.  The permission decorator (later
+Feature 09 tasks) reads this table; it does not take per-handler
+policy arguments.
+"""
+from __future__ import annotations
+
+from .const import (
+    DOMAIN_SERVICES,
+    SERVICE_COMPLETE_QUEST,
+    SERVICE_CREATE_PRESENCE_OVERRIDE,
+    SERVICE_CREATE_QUEST_DEFINITION,
+    SERVICE_DELETE_PRESENCE_OVERRIDE,
+    SERVICE_EXPORT_HISTORY_CSV,
+    SERVICE_MANAGE_CHILD,
+    SERVICE_REGENERATE,
+    SERVICE_SET_PRESENCE_PATTERN,
+    SERVICE_SET_QUEST_DEFINITION_ACTIVE,
+    SERVICE_UNCOMPLETE_QUEST,
+    SERVICE_UPDATE_QUEST_DEFINITION,
+)
+
+OPEN = "open"
+ADMIN_ONLY = "admin_only"
+
+SERVICE_POLICY: dict[str, str] = {
+    SERVICE_COMPLETE_QUEST: OPEN,
+    SERVICE_UNCOMPLETE_QUEST: ADMIN_ONLY,
+    SERVICE_CREATE_QUEST_DEFINITION: ADMIN_ONLY,
+    SERVICE_UPDATE_QUEST_DEFINITION: ADMIN_ONLY,
+    SERVICE_SET_QUEST_DEFINITION_ACTIVE: ADMIN_ONLY,
+    SERVICE_SET_PRESENCE_PATTERN: ADMIN_ONLY,
+    SERVICE_CREATE_PRESENCE_OVERRIDE: ADMIN_ONLY,
+    SERVICE_DELETE_PRESENCE_OVERRIDE: ADMIN_ONLY,
+    SERVICE_EXPORT_HISTORY_CSV: ADMIN_ONLY,
+    SERVICE_MANAGE_CHILD: ADMIN_ONLY,
+    SERVICE_REGENERATE: ADMIN_ONLY,
+}
+
+if frozenset(SERVICE_POLICY) != frozenset(DOMAIN_SERVICES):
+    raise RuntimeError(
+        "SERVICE_POLICY must name exactly the registered nestquest services, "
+        f"got {sorted(SERVICE_POLICY)} vs {list(DOMAIN_SERVICES)}"
+    )

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/dao_children.py

@@ -0,0 +1,12 @@
+"""Re-export of :mod:`custom_components.nestquest.core.dao_children` for the integration package.
+
+The children/admin DAO lives in
+:mod:`custom_components.nestquest.core.dao_children` (extracted in
+task d0b691d8); this module re-exports it so existing
+``from .dao_children import ...`` references inside the integration keep
+working.
+"""
+from __future__ import annotations
+
+from .core.dao_children import *  # noqa: F401,F403
+from .core.dao_children import _CONNECTION_LOCKS, _connection_lock  # noqa: F401

custom_components/nestquest/dao_instances.py

@@ -0,0 +1,12 @@
+"""Re-export of :mod:`custom_components.nestquest.core.dao_instances` for the integration package.
+
+The instances/completion-events DAO lives in
+:mod:`custom_components.nestquest.core.dao_instances`
+(extracted in task d0b691d8); this module re-exports it so existing
+``from .dao_instances import ...`` references inside the integration keep
+working.
+"""
+from __future__ import annotations
+
+from .core.dao_instances import *  # noqa: F401,F403
+from .core.dao_instances import _resolve_today  # noqa: F401

custom_components/nestquest/dao_meta.py

@@ -0,0 +1,11 @@
+"""Re-export of :mod:`custom_components.nestquest.core.dao_meta` for the integration package.
+
+The meta-state DAO lives in
+:mod:`custom_components.nestquest.core.dao_meta` (extracted in task
+d0b691d8); this module re-exports it so existing
+``from .dao_meta import ...`` references inside the integration keep
+working.
+"""
+from __future__ import annotations
+
+from .core.dao_meta import *  # noqa: F401,F403

custom_components/nestquest/dao_presence.py

@@ -0,0 +1,11 @@
+"""Re-export of :mod:`custom_components.nestquest.core.dao_presence` for the integration package.
+
+The presence DAOs live in
+:mod:`custom_components.nestquest.core.dao_presence` (extracted in
+task d0b691d8); this module re-exports them so existing
+``from .dao_presence import ...`` references inside the integration keep
+working.
+"""
+from __future__ import annotations
+
+from .core.dao_presence import *  # noqa: F401,F403

custom_components/nestquest/dao_rules.py

@@ -0,0 +1,17 @@
+"""Re-export of :mod:`custom_components.nestquest.core.dao_rules` for the integration package.
+
+The schedule-rules/quest-definitions DAO lives in
+:mod:`custom_components.nestquest.core.dao_rules` (extracted in task
+d0b691d8); this module re-exports it so existing
+``from .dao_rules import ...`` references inside the integration keep
+working.
+"""
+from __future__ import annotations
+
+from .core.dao_rules import *  # noqa: F401,F403
+from .core.dao_rules import (  # noqa: F401
+    _UNSET,
+    _validate_date,
+    _validate_time,
+    _validate_window,
+)

custom_components/nestquest/dashboard.py

@@ -1,215 +0,0 @@
-"""Zero-config panel dashboard registration for NestQuest (Feature 20).
-
-On setup the integration registers ONE storage-mode Lovelace dashboard
-whose CONFIG uses the bundle's ``custom:nestquest-party`` strategy (see
-``frontend/src/strategy.ts``): the views themselves are GENERATED at
-render time from the household roster, so the stored dashboard config
-carries nothing but the strategy reference.
-
-Registration mirrors the REAL two-step sequence the lovelace
-integration itself uses when it creates the onboarding map dashboard
-(``homeassistant/components/lovelace/__init__.py``,
-``_create_map_dashboard``):
-
-1. create the dashboard METADATA through the ``DashboardsCollection``
-   (``hass.data["lovelace"]["dashboards_collection"]``) — url_path,
-   title, icon, sidebar visibility.  The strategy reference is NOT part
-   of the create payload: the collection's create schema allows only
-   the metadata fields, so a ``strategy`` key there fails the whole
-   create (this was the silent no-op the first implementation shipped).
-2. save the dashboard CONFIG — ``{"strategy": ...}`` — through the
-   per-url_path CONTENT manager that the collection's change listener
-   registers under ``hass.data["lovelace"]["dashboards"][url_path]``
-   (a ``LovelaceStorage``), exactly the second step HA performs.
-
-Registration is IDEMPOTENT — a dashboard already under the stable
-``url_path`` (ours or a user's) skips BOTH steps and its stored config
-is never overwritten — and the Lovelace surfaces being unavailable
-(YAML mode, lovelace not loaded) is a logged warning, never a setup
-failure.
-"""
-from __future__ import annotations
-
-import asyncio
-
-from homeassistant.core import HomeAssistant
-
-from .const import (
-    DASHBOARD_ICON,
-    DASHBOARD_STRATEGY_TYPE,
-    DASHBOARD_TITLE,
-    DASHBOARD_URL_PATH,
-    LOGGER,
-)
-
-_LOGGER = LOGGER
-
-# Single-flight guard for the check-then-create below: HA can set up
-# several config entries CONCURRENTLY, and two overlapping setups would
-# both pass the exists-check and race on the url_path create.  The lock
-# is per hass instance (kept as an attribute on the hass object, since
-# hass.data is the integrations' shared registry the unload path
-# empties) rather than one module-level asyncio.Lock — a bare
-# module-level lock binds to whichever event loop first awaits it and
-# raises RuntimeError on any other loop, while the race it must prevent
-# only exists between setups running on the SAME hass anyway.
-_REGISTRATION_LOCK_ATTR = "_nestquest_dashboard_registration_lock"
-
-
-def _registration_lock(hass: HomeAssistant) -> asyncio.Lock:
-    """Return the per-hass registration lock, creating it on first use."""
-    lock = getattr(hass, _REGISTRATION_LOCK_ATTR, None)
-    if lock is None:
-        lock = asyncio.Lock()
-        setattr(hass, _REGISTRATION_LOCK_ATTR, lock)
-    return lock
-
-
-def _lovelace_data(hass: HomeAssistant) -> dict | None:
-    """Return ``hass.data["lovelace"]`` when it is the real dict shape.
-
-    The lovelace integration stores a plain DICT of surfaces (``mode``,
-    ``dashboards``, ``dashboards_collection``, ``resources``,
-    ``yaml_dashboards``) under the ``lovelace`` key; anything else
-    (missing key, unexpected object) means the surfaces below cannot be
-    reached and registration must warn and continue.
-    """
-    lovelace_data = hass.data.get("lovelace")
-    if not isinstance(lovelace_data, dict):
-        return None
-    return lovelace_data
-
-
-def _dashboards_collection(hass: HomeAssistant):
-    """Return the Lovelace dashboards METADATA collection, or None.
-
-    The collection lives at ``hass.data["lovelace"]
-    ["dashboards_collection"]`` — NOT under ``["dashboards"]``, which
-    maps url_path to the per-dashboard CONTENT managers
-    (``LovelaceStorage``/``LovelaceYAML``).  A missing key (lovelace
-    not loaded) and a missing/None entry (YAML mode never sets the
-    collection) both mean "cannot create storage dashboards here" —
-    callers log and continue.  The presence of the surface is verified
-    by capability (``async_create_item`` callable), not by type, so no
-    lovelace import is needed.
-    """
-    lovelace_data = _lovelace_data(hass)
-    if lovelace_data is None:
-        return None
-    collection = lovelace_data.get("dashboards_collection")
-    if collection is None or not callable(
-        getattr(collection, "async_create_item", None)
-    ):
-        return None
-    return collection
-
-
-def _dashboard_store(hass: HomeAssistant, url_path: str):
-    """Return a url_path's dashboard CONTENT manager, or None.
-
-    After a metadata create, the collection's change listener registers
-    a ``LovelaceStorage`` for the new dashboard under
-    ``hass.data["lovelace"]["dashboards"][url_path]``; the dashboard
-    CONFIG (the strategy reference) is saved through THAT manager —
-    the second step of HA's own dashboard creation.
-    """
-    lovelace_data = _lovelace_data(hass)
-    if lovelace_data is None:
-        return None
-    dashboards = lovelace_data.get("dashboards")
-    if not isinstance(dashboards, dict):
-        return None
-    store = dashboards.get(url_path)
-    if store is None or not callable(getattr(store, "async_save", None)):
-        return None
-    return store
-
-
-def _item_url_path(item) -> str | None:
-    """Read a dashboard item's ``url_path`` through either access shape.
-
-    The collection hands back storage items as dicts while builtin
-    dashboards come back as config objects; the url_path is reachable
-    through ``item["url_path"]`` or ``item.url_path`` respectively.
-    """
-    url_path = getattr(item, "url_path", None)
-    if isinstance(url_path, str):
-        return url_path
-    get_url_path = getattr(item, "get", None)
-    if callable(get_url_path):
-        value = get_url_path("url_path")
-        if isinstance(value, str):
-            return value
-    return None
-
-
-def _existing_dashboard(items) -> bool:
-    """Whether a dashboard under the stable url_path already exists."""
-    return any(_item_url_path(item) == DASHBOARD_URL_PATH for item in items)
-
-
-async def async_register_dashboard(hass: HomeAssistant) -> bool:
-    """Register the NestQuest panel dashboard exactly once.
-
-    Returns True when a dashboard under the stable ``url_path`` exists
-    after the call (pre-existing or created here), False when the
-    Lovelace surfaces were unavailable or refused.  A dashboard already
-    registered under the stable ``url_path`` — whether ours from a
-    previous setup or a user's own — skips BOTH steps and is left
-    COMPLETELY alone: its stored config is never overwritten, it is
-    never deleted, never a duplicate.  The strategy config is saved
-    ONLY for the dashboard created in THIS call, whose fresh content
-    store is empty, so the save cannot clobber anything.
-    """
-    collection = _dashboards_collection(hass)
-    if collection is None:
-        _LOGGER.warning(
-            "Lovelace dashboards collection unavailable; the NestQuest "
-            "panel dashboard was not registered. Enable the Lovelace "
-            "integration in storage mode or create a dashboard with "
-            "strategy %s manually.",
-            DASHBOARD_STRATEGY_TYPE,
-        )
-        return False
-    try:
-        # Single-flight: two concurrent entry setups must not both pass
-        # the exists-check and race on the url_path create.
-        async with _registration_lock(hass):
-            # async_items() is a SYNC @callback on the real collection
-            # (helpers/collection.py ObservableCollection) — not awaited.
-            if _existing_dashboard(collection.async_items()):
-                return True
-            await collection.async_create_item(
-                {
-                    "url_path": DASHBOARD_URL_PATH,
-                    "title": DASHBOARD_TITLE,
-                    "icon": DASHBOARD_ICON,
-                    "show_in_sidebar": True,
-                    "allow_single_word": True,
-                }
-            )
-            # Step two (mirroring HA's _create_map_dashboard): the
-            # strategy CONFIG goes through the fresh dashboard's
-            # content manager, not through the metadata collection.
-            store = _dashboard_store(hass, DASHBOARD_URL_PATH)
-            if store is None:
-                _LOGGER.warning(
-                    "The NestQuest panel dashboard was registered but its "
-                    "Lovelace content manager never appeared; add the "
-                    "strategy %s to the dashboard manually.",
-                    DASHBOARD_STRATEGY_TYPE,
-                )
-                return False
-            await store.async_save(
-                {"strategy": {"type": DASHBOARD_STRATEGY_TYPE}}
-            )
-    except Exception:
-        _LOGGER.warning(
-            "Registering the NestQuest panel dashboard in the Lovelace "
-            "dashboards collection failed; set it up manually with "
-            "strategy %s.",
-            DASHBOARD_STRATEGY_TYPE,
-            exc_info=True,
-        )
-        return False
-    return True

custom_components/nestquest/db.py

@@ -0,0 +1,31 @@
+"""Re-export of :mod:`custom_components.nestquest.core.db` for the integration package.
+
+The async SQLite wrapper lives in :mod:`custom_components.nestquest.core.db` (extracted in task
+d0b691d8) and is Home-Assistant-free: :class:`NestQuestDatabase` takes
+an executor callable rather than a ``hass`` object.  This module
+re-exports it and provides :func:`make_database`, a thin adapter that
+constructs a wrapper backed by ``hass.async_add_executor_job``, so the
+integration constructs the database the same way it always did.
+"""
+from __future__ import annotations
+
+from typing import Any, TypeVar
+
+from homeassistant.core import HomeAssistant
+
+from .core.db import ExecutionResult, NestQuestDatabase
+
+__all__ = ["ExecutionResult", "NestQuestDatabase", "make_database"]
+
+T = TypeVar("T")
+
+
+def make_database(hass: HomeAssistant) -> NestQuestDatabase:
+    """Construct a :class:`NestQuestDatabase` wired to ``hass``'s executor.
+
+    Mirrors the pre-extraction ``NestQuestDatabase(hass)`` call: the
+    wrapper's executor is ``hass.async_add_executor_job``, so every
+    sqlite3 call runs on the HA executor thread and the event loop
+    never blocks.
+    """
+    return NestQuestDatabase(hass.async_add_executor_job)

custom_components/nestquest/events.py

@@ -0,0 +1,79 @@
+"""Re-export / HA wiring of :mod:`custom_components.nestquest.core.events` for the integration package.
+
+The transition-event payload construction lives in
+:mod:`custom_components.nestquest.core.events` (extracted in
+task 510c1f78) and is HA-free: it builds and RETURNS the events.  This
+shim keeps the integration's old ``fire_quest_completed`` /
+``fire_quest_uncompleted`` API (the complete/uncomplete service
+handlers call them with ``hass``), reads the HA-local timezone from
+``hass.config.time_zone`` to derive ``today``, asks the core builder
+for the events, and fires each on ``hass.bus`` with the documented
+payloads.  The four blueprints keep working with identical payloads.
+
+The completed event is fired BEFORE the day-complete rule evaluates:
+``fire_quest_completed`` asks
+:func:`build_quest_completed_event` for the completed event and fires
+it immediately, THEN reads the HA-local ``today``, asks
+:func:`build_child_day_complete_event` for the day-complete event, and
+fires it (if any) afterwards.  This restores the pre-extraction
+ordering — a failure in the day-complete DB reads or the ZoneInfo
+lookup cannot suppress the completed event.
+"""
+from __future__ import annotations
+
+import datetime
+from zoneinfo import ZoneInfo
+
+from .core.db import NestQuestDatabase
+from .core.events import (
+    build_child_day_complete_event,
+    build_quest_completed_event,
+    build_quest_uncompleted_events,
+)
+
+__all__ = ["fire_quest_completed", "fire_quest_uncompleted"]
+
+
+async def fire_quest_completed(
+    hass,
+    database: NestQuestDatabase,
+    instance_id: int,
+    *,
+    was_on_time: bool | None,
+) -> None:
+    """Fire ``nestquest_quest_completed`` and, when the completion
+    cleared the child's whole day, ``nestquest_child_day_complete``.
+
+    Thin HA wiring over the HA-free
+    :func:`custom_components.nestquest.core.events.build_quest_completed_event`
+    and
+    :func:`build_child_day_complete_event`: the completed event is
+    built and fired FIRST (so a failure in the day-complete DB reads
+    or the HA-local ``today`` lookup cannot suppress it), then the
+    HA-local ``today`` (the day-complete rule's input) is read from
+    ``hass.config.time_zone`` and the day-complete builder is asked
+    whether the child's whole day cleared.  Identical payloads and
+    day-complete rule to the pre-extraction implementation.
+    """
+    completed = await build_quest_completed_event(
+        database,
+        instance_id,
+        was_on_time=was_on_time,
+    )
+    hass.bus.async_fire(*completed)
+
+    today = datetime.datetime.now(ZoneInfo(hass.config.time_zone)).date()
+    day_complete = await build_child_day_complete_event(
+        database, completed[1], today=today
+    )
+    if day_complete is not None:
+        hass.bus.async_fire(*day_complete)
+
+
+async def fire_quest_uncompleted(
+    hass, database: NestQuestDatabase, instance_id: int
+) -> None:
+    """Fire ``nestquest_quest_uncompleted`` for an actual reversal."""
+    events = await build_quest_uncompleted_events(database, instance_id)
+    for event_type, payload in events:
+        hass.bus.async_fire(event_type, payload)

custom_components/nestquest/manifest.json

@@ -7,13 +7,12 @@
   "config_flow": true,
   "dependencies": [
     "frontend",
-    "http",
-    "lovelace"
+    "http"
   ],
   "documentation": "https://github.com/Maniacs-Mansion/NestQuest",
   "integration_type": "hub",
   "iot_class": "local_polling",
   "issue_tracker": "https://github.com/Maniacs-Mansion/NestQuest/issues",
   "requirements": [],
-  "version": "0.6.0"
+  "version": "0.5.0"
 }

custom_components/nestquest/materialize.py

@@ -0,0 +1,11 @@
+"""Re-export of :mod:`custom_components.nestquest.core.materialize` for the integration package.
+
+The materialization walk lives in
+:mod:`custom_components.nestquest.core.materialize` (extracted in
+task 510c1f78); this module re-exports it so existing
+``from .materialize import ...`` references inside the integration keep
+working.
+"""
+from __future__ import annotations
+
+from .core.materialize import *  # noqa: F401,F403

custom_components/nestquest/migrations.py

@@ -0,0 +1,11 @@
+"""Re-export of :mod:`custom_components.nestquest.core.migrations` for the integration package.
+
+The versioned migration runner lives in
+:mod:`custom_components.nestquest.core.migrations`
+(extracted in task d0b691d8); this module re-exports it so existing
+``from .migrations import ...`` references inside the integration keep
+working.
+"""
+from __future__ import annotations
+
+from .core.migrations import *  # noqa: F401,F403

custom_components/nestquest/options_flow.py

@@ -1,15 +1,4 @@
-"""Options flow for NestQuest post-setup settings.
-
-Since the DB removal (Feature 18) the integration is a thin client of
-the NestQuest API service: the settings that only served the local
-database (the generation horizon, the day rollover, the notification
-defaults, the admin allowlist) are gone — the API service owns those in
-its own settings store, and the automations take their behaviour from
-blueprint inputs.  What remains is what the CLIENT itself consumes: the
-panel-plane API connection (base URL + token), the shared coordinator's
-refresh interval, the last-good staleness threshold, and the
-panel-facing idle timeout.
-"""
+"""Options flow for NestQuest post-setup settings."""
 from __future__ import annotations
 
 from typing import Any
@@ -17,39 +6,66 @@ from typing import Any
 import voluptuous as vol
 from homeassistant import config_entries
 from homeassistant.data_entry_flow import FlowResult
+from homeassistant.helpers import config_validation as cv
 
 from .const import (
+    CONF_ADMIN_USER_IDS,
+    CONF_AFTERNOON_REMINDER_ENABLED,
+    CONF_AFTERNOON_REMINDER_TIME,
     CONF_API_BASE_URL,
+    CONF_CELEBRATION_ENABLED,
+    CONF_DAY_ROLLOVER_TIME,
+    CONF_END_OF_DAY_REPORT_ENABLED,
+    CONF_END_OF_DAY_REPORT_TIME,
+    CONF_HORIZON_DAYS,
+    CONF_MORNING_SUMMARY_ENABLED,
+    CONF_MORNING_SUMMARY_TIME,
+    CONF_NOTIFY_TARGET,
     CONF_PANEL_IDLE_TIMEOUT,
     CONF_PANEL_TOKEN,
-    CONF_SNAPSHOT_STALENESS,
     CONF_UPDATE_INTERVAL,
     DEFAULT_API_BASE_URL,
+    DEFAULT_AFTERNOON_REMINDER_TIME,
+    DEFAULT_AUTOMATION_ENABLED,
+    DEFAULT_DAY_ROLLOVER_TIME,
+    DEFAULT_END_OF_DAY_REPORT_TIME,
+    DEFAULT_HORIZON_DAYS,
+    DEFAULT_MORNING_SUMMARY_TIME,
     DEFAULT_PANEL_IDLE_TIMEOUT,
     DEFAULT_PANEL_TOKEN,
-    DEFAULT_SNAPSHOT_STALENESS,
     DEFAULT_UPDATE_INTERVAL,
+    DOMAIN,
     MIN_UPDATE_INTERVAL,
+    TIME_PATTERN,
 )
+from .admin_allowlist import list_admin_ids, set_admin_ids
 from .api_client import is_valid_base_url
 
+MIN_HORIZON_DAYS = 1
 MIN_PANEL_IDLE_TIMEOUT = 30
 
 
-def _async_validate(
-    user_input: dict[str, Any],
-    current: dict[str, Any] | None = None,
-) -> dict[str, str]:
-    """Validate user input and return field-level errors instead of raising.
+def _parse_time(value: str) -> bool:
+    """Return True when value is a valid 24-hour HH:MM string."""
+    return TIME_PATTERN.fullmatch(value) is not None
 
-    ``current`` carries the stored values (entry options → entry data →
-    defaults) so a raw submit that sets one field but omits a sibling it
-    is validated against (the staleness threshold vs. the update
-    interval) can still check the effective pair; raw submits omitting
-    BOTH keys keep their stored values untouched.
-    """
+
+def _async_validate(user_input: dict[str, Any]) -> dict[str, str]:
+    """Validate user input and return field-level errors instead of raising."""
     errors: dict[str, str] = {}
 
+    horizon_days = user_input.get(CONF_HORIZON_DAYS)
+    if (
+        isinstance(horizon_days, bool)
+        or not isinstance(horizon_days, int)
+        or horizon_days < MIN_HORIZON_DAYS
+    ):
+        errors[CONF_HORIZON_DAYS] = "invalid"
+
+    day_rollover_time = user_input.get(CONF_DAY_ROLLOVER_TIME)
+    if not isinstance(day_rollover_time, str) or not _parse_time(day_rollover_time):
+        errors[CONF_DAY_ROLLOVER_TIME] = "invalid_time"
+
     panel_idle_timeout = user_input.get(CONF_PANEL_IDLE_TIMEOUT)
     if (
         isinstance(panel_idle_timeout, bool)
@@ -70,32 +86,40 @@ def _async_validate(
     ):
         errors[CONF_UPDATE_INTERVAL] = "invalid"
 
-    # The last-good staleness threshold (Feature 18) is OPTIONAL in raw
-    # submits the same way: a missing key keeps the current value.  It
-    # must be a positive int, and at least the EFFECTIVE update interval
-    # (the one this submit carries, else the stored or default one) — a
-    # threshold shorter than the poll cadence could never serve even one
-    # cached snapshot.
-    staleness = user_input.get(CONF_SNAPSHOT_STALENESS)
-    if staleness is not None and (
-        isinstance(staleness, bool)
-        or not isinstance(staleness, int)
-        or staleness < 1
+    # The notification section (Feature 11) is OPTIONAL in raw submits
+    # the same way: a missing key keeps the current value.  The three
+    # times are strict HH:MM; the notify target is a non-empty HA
+    # service name; the toggles are real booleans.
+    for time_key in (
+        CONF_MORNING_SUMMARY_TIME,
+        CONF_AFTERNOON_REMINDER_TIME,
+        CONF_END_OF_DAY_REPORT_TIME,
     ):
-        errors[CONF_SNAPSHOT_STALENESS] = "invalid"
-    elif staleness is not None and not errors.get(CONF_UPDATE_INTERVAL):
-        stored_interval = (current or {}).get(CONF_UPDATE_INTERVAL)
-        effective_interval = update_interval
-        if effective_interval is None and (
-            isinstance(stored_interval, int)
-            and not isinstance(stored_interval, bool)
-            and stored_interval >= MIN_UPDATE_INTERVAL
+        time_value = user_input.get(time_key)
+        if time_value is not None and (
+            not isinstance(time_value, str) or not _parse_time(time_value)
         ):
-            effective_interval = stored_interval
-        if effective_interval is None:
-            effective_interval = DEFAULT_UPDATE_INTERVAL
-        if staleness < effective_interval:
-            errors[CONF_SNAPSHOT_STALENESS] = "invalid_staleness"
+            errors[time_key] = "invalid_time"
+    notify_target = user_input.get(CONF_NOTIFY_TARGET)
+    if notify_target is not None and not isinstance(notify_target, str):
+        errors[CONF_NOTIFY_TARGET] = "invalid"
+    elif isinstance(notify_target, str) and notify_target != (
+        notify_target.strip()
+    ):
+        # An EMPTY target is valid — it means "no notifications
+        # configured yet" and is the shipped default; a value that
+        # differs from its own trim (padded or whitespace-only) is
+        # malformed and rejected.
+        errors[CONF_NOTIFY_TARGET] = "invalid"
+    for toggle_key in (
+        CONF_MORNING_SUMMARY_ENABLED,
+        CONF_AFTERNOON_REMINDER_ENABLED,
+        CONF_END_OF_DAY_REPORT_ENABLED,
+        CONF_CELEBRATION_ENABLED,
+    ):
+        toggle_value = user_input.get(toggle_key)
+        if toggle_value is not None and not isinstance(toggle_value, bool):
+            errors[toggle_key] = "invalid"
 
     # The panel-plane API connection (Feature 18) is OPTIONAL in raw
     # submits the same way: a missing key keeps the current value.  The
@@ -119,78 +143,249 @@ def _async_validate(
     return errors
 
 
-def _build_schema(current: dict[str, Any]) -> vol.Schema:
+def _strict_bool(value: object) -> bool:
+    """Require a real bool; voluptuous ``bool`` would coerce strings."""
+    if not isinstance(value, bool):
+        raise vol.Invalid(f"expected a boolean, got {value!r}")
+    return value
+
+
+def _build_schema(
+    current: dict[str, Any],
+    *,
+    admin_choices: dict[str, str] | None = None,
+    admin_default: list[str] | None = None,
+) -> vol.Schema:
     """Build the form schema, pre-filled with the current values.
 
-    The API connection (Feature 18) carries the base URL the API client
-    talks to and the panel service token it presents as the Bearer
-    credential.  Schema-validated submits always carry every field (the
-    defaults pre-fill from the stored values); raw callers omitting one
-    keep its stored value (see _async_validate).
+    The admin picker is a multi-select of EXISTING Home Assistant users
+    (never a free-text field — the allowlist stores user IDs); its
+    default is the current database allowlist, so an untouched submit
+    re-saves exactly who is already allowed.  The notification section
+    (Feature 11) carries the household's notify target, the three
+    automation times, and four enable toggles — defaults from
+    :mod:`~.const`, never a hard-coded personal target.
     """
-    return vol.Schema(
-        {
-            vol.Required(
-                CONF_PANEL_IDLE_TIMEOUT,
-                default=current[CONF_PANEL_IDLE_TIMEOUT],
-            ): int,
-            vol.Required(
-                CONF_UPDATE_INTERVAL, default=current[CONF_UPDATE_INTERVAL]
-            ): int,
-            # The last-good staleness threshold (Feature 18): how long
-            # the coordinator keeps serving the cached snapshot after
-            # the API stops answering.
-            vol.Required(
-                CONF_SNAPSHOT_STALENESS,
-                default=current[CONF_SNAPSHOT_STALENESS],
-            ): int,
-            # Panel-plane API connection (Feature 18): the base URL the
-            # API client talks to and the panel service token it
-            # presents as the Bearer credential.
-            vol.Required(
-                CONF_API_BASE_URL, default=current[CONF_API_BASE_URL]
-            ): str,
-            vol.Required(
-                CONF_PANEL_TOKEN, default=current[CONF_PANEL_TOKEN]
-            ): str,
-        }
-    )
+    fields: dict[Any, Any] = {
+        vol.Required(
+            CONF_HORIZON_DAYS, default=current[CONF_HORIZON_DAYS]
+        ): int,
+        vol.Required(
+            CONF_DAY_ROLLOVER_TIME, default=current[CONF_DAY_ROLLOVER_TIME]
+        ): str,
+        vol.Required(
+            CONF_PANEL_IDLE_TIMEOUT, default=current[CONF_PANEL_IDLE_TIMEOUT]
+        ): int,
+        vol.Required(
+            CONF_UPDATE_INTERVAL, default=current[CONF_UPDATE_INTERVAL]
+        ): int,
+        vol.Required(
+            CONF_NOTIFY_TARGET, default=current[CONF_NOTIFY_TARGET]
+        ): str,
+        vol.Required(
+            CONF_MORNING_SUMMARY_TIME,
+            default=current[CONF_MORNING_SUMMARY_TIME],
+        ): str,
+        vol.Required(
+            CONF_AFTERNOON_REMINDER_TIME,
+            default=current[CONF_AFTERNOON_REMINDER_TIME],
+        ): str,
+        vol.Required(
+            CONF_END_OF_DAY_REPORT_TIME,
+            default=current[CONF_END_OF_DAY_REPORT_TIME],
+        ): str,
+        vol.Required(
+            CONF_MORNING_SUMMARY_ENABLED,
+            default=current[CONF_MORNING_SUMMARY_ENABLED],
+        ): _strict_bool,
+        vol.Required(
+            CONF_AFTERNOON_REMINDER_ENABLED,
+            default=current[CONF_AFTERNOON_REMINDER_ENABLED],
+        ): _strict_bool,
+        vol.Required(
+            CONF_END_OF_DAY_REPORT_ENABLED,
+            default=current[CONF_END_OF_DAY_REPORT_ENABLED],
+        ): _strict_bool,
+        vol.Required(
+            CONF_CELEBRATION_ENABLED,
+            default=current[CONF_CELEBRATION_ENABLED],
+        ): _strict_bool,
+        # Panel-plane API connection (Feature 18): the base URL the API
+        # client talks to and the panel service token it presents as
+        # the Bearer credential.  Schema-validated submits always carry
+        # both (the defaults pre-fill from the stored values); raw
+        # callers omitting them keep their stored values (see
+        # _async_validate).
+        vol.Required(
+            CONF_API_BASE_URL, default=current[CONF_API_BASE_URL]
+        ): str,
+        vol.Required(
+            CONF_PANEL_TOKEN, default=current[CONF_PANEL_TOKEN]
+        ): str,
+    }
+    if admin_choices is not None:
+        # HA's supported multi-select validator: the frontend can
+        # serialize the field as a real picker of the given choices.
+        fields[
+            vol.Optional(
+                CONF_ADMIN_USER_IDS, default=list(admin_default or [])
+            )
+        ] = cv.multi_select(admin_choices)
+    return vol.Schema(fields)
 
 
 class NestQuestOptionsFlow(config_entries.OptionsFlowWithConfigEntry):
     """Handle the options flow for NestQuest."""
 
+    def _async_database(self):
+        """Return the runtime database for this entry, or None.
+
+        Real HA only opens the options flow for an existing entry, so
+        the runtime record (and its database) exists; the None branch
+        covers direct construction in tests and degraded states.
+        """
+        hass_data = getattr(self.hass, "data", None)
+        if not isinstance(hass_data, dict):
+            return None
+        record = hass_data.get(DOMAIN, {}).get(self.config_entry.entry_id)
+        database = getattr(record, "database", None)
+        return database if getattr(database, "connected", False) else None
+
+    async def _async_admin_choices(self) -> dict[str, str]:
+        """Map HA user id -> display name for the picker.
+
+        Real Home Assistant always provides ``hass.auth``; a missing
+        one (direct construction in tests, degraded harness) degrades
+        to an empty picker rather than crashing the form.
+        """
+        auth = getattr(self.hass, "auth", None)
+        if auth is None:
+            return {}
+        users = await auth.async_get_users()
+        return {
+            user.id: user.name
+            for user in users
+            if getattr(user, "id", None)
+        }
+
+    async def _async_current_admin_ids(self) -> list[str]:
+        """Return the current allowlist, or [] without a database."""
+        database = self._async_database()
+        if database is None:
+            return []
+        return await list_admin_ids(database)
+
     async def async_step_init(
         self, user_input: dict[str, Any] | None = None
     ) -> FlowResult:
         """Manage the NestQuest options."""
+        admin_choices = await self._async_admin_choices()
+        admin_default = await self._async_current_admin_ids()
         if user_input is None:
             return self.async_show_form(
                 step_id="init",
-                data_schema=_build_schema(self._current_values()),
+                data_schema=_build_schema(
+                    self._current_values(),
+                    admin_choices=admin_choices,
+                    admin_default=admin_default,
+                ),
             )
 
-        errors = _async_validate(user_input, self._current_values())
+        errors = _async_validate(user_input)
+        # The admin ids are validated only when the key is present:
+        # schema-validated submits always carry it (vol.Optional's
+        # default fills from the current allowlist), while raw callers
+        # omitting the key keep the field untouched.
+        admin_ids_present = CONF_ADMIN_USER_IDS in user_input
+        admin_ids = user_input.get(CONF_ADMIN_USER_IDS)
         if errors:
             return self.async_show_form(
                 step_id="init",
-                data_schema=_build_schema(self._current_values()),
+                data_schema=_build_schema(
+                    self._current_values(),
+                    admin_choices=admin_choices,
+                    admin_default=admin_default,
+                ),
+                errors=errors,
+            )
+        if admin_ids_present and (
+            not isinstance(admin_ids, list)
+            or any(not isinstance(value, str) for value in admin_ids)
+        ):
+            errors[CONF_ADMIN_USER_IDS] = "invalid_admin"
+        elif admin_ids_present and not admin_ids:
+            # An empty allowlist fails closed: saving zero admins is
+            # refused, never silently applied.
+            errors[CONF_ADMIN_USER_IDS] = "no_admins"
+        elif admin_ids_present and any(
+            value not in admin_choices for value in admin_ids
+        ):
+            # The schema enforces membership for real HA submits; this
+            # backs the raw-input path up so an unknown id can never
+            # reach the allowlist.
+            errors[CONF_ADMIN_USER_IDS] = "invalid_admin"
+        elif admin_ids_present and len(set(admin_ids)) != len(admin_ids):
+            # set_admin_ids refuses duplicates with ValueError; a flow
+            # submission must surface that as a field error instead of
+            # an unhandled crash.
+            errors[CONF_ADMIN_USER_IDS] = "invalid_admin"
+        if errors:
+            return self.async_show_form(
+                step_id="init",
+                data_schema=_build_schema(
+                    self._current_values(),
+                    admin_choices=admin_choices,
+                    admin_default=admin_default,
+                ),
                 errors=errors,
             )
 
-        # Every remaining key is stored the fall-back-to-current way, so
-        # raw submits that predate a section keep that section's stored
-        # values.
+        # Apply the picker's selection to the allowlist when the
+        # runtime database is reachable; the selection is always
+        # stored on the entry as the disaster-recovery copy.
+        database = self._async_database()
+        if database is not None and admin_ids_present:
+            await set_admin_ids(database, admin_ids)
+        data = {
+            CONF_HORIZON_DAYS: user_input[CONF_HORIZON_DAYS],
+            CONF_DAY_ROLLOVER_TIME: user_input[CONF_DAY_ROLLOVER_TIME],
+            CONF_PANEL_IDLE_TIMEOUT: user_input[CONF_PANEL_IDLE_TIMEOUT],
+            CONF_UPDATE_INTERVAL: user_input.get(
+                CONF_UPDATE_INTERVAL,
+                self._current_values()[CONF_UPDATE_INTERVAL],
+            ),
+        }
+        # The notification section (Feature 11) stores the household's
+        # choices the same fall-back-to-current way, so raw submits
+        # that predate the section keep their stored values.
         current = self._current_values()
-        data: dict[str, Any] = {}
-        for key in (
-            CONF_PANEL_IDLE_TIMEOUT,
-            CONF_UPDATE_INTERVAL,
-            CONF_SNAPSHOT_STALENESS,
-            CONF_API_BASE_URL,
-            CONF_PANEL_TOKEN,
+        for notification_key in (
+            CONF_NOTIFY_TARGET,
+            CONF_MORNING_SUMMARY_TIME,
+            CONF_AFTERNOON_REMINDER_TIME,
+            CONF_END_OF_DAY_REPORT_TIME,
+            CONF_MORNING_SUMMARY_ENABLED,
+            CONF_AFTERNOON_REMINDER_ENABLED,
+            CONF_END_OF_DAY_REPORT_ENABLED,
+            CONF_CELEBRATION_ENABLED,
         ):
-            data[key] = user_input.get(key, current[key])
+            data[notification_key] = user_input.get(
+                notification_key, current[notification_key]
+            )
+        # The API connection section (Feature 18) stores the base URL
+        # and panel token the same fall-back-to-current way, so raw
+        # submits that predate the section keep their stored values.
+        for api_key in (CONF_API_BASE_URL, CONF_PANEL_TOKEN):
+            data[api_key] = user_input.get(api_key, current[api_key])
+        if admin_ids_present:
+            data[CONF_ADMIN_USER_IDS] = admin_ids
+        elif admin_default:
+            # HA replaces entry.options wholesale, so an omitted picker
+            # field must carry the CURRENT allowlist forward: dropping
+            # it would leave only the stale config-flow copy in entry
+            # data, and a later database loss would resurrect admins
+            # the owner has since removed.
+            data[CONF_ADMIN_USER_IDS] = list(admin_default)
         return self.async_create_entry(title="NestQuest", data=data)
 
     def _current_values(self) -> dict[str, Any]:
@@ -199,9 +394,18 @@ class NestQuestOptionsFlow(config_entries.OptionsFlowWithConfigEntry):
         entry_data = getattr(self.config_entry, "data", None) or {}
         values: dict[str, Any] = {}
         for key, default in (
+            (CONF_HORIZON_DAYS, DEFAULT_HORIZON_DAYS),
+            (CONF_DAY_ROLLOVER_TIME, DEFAULT_DAY_ROLLOVER_TIME),
             (CONF_PANEL_IDLE_TIMEOUT, DEFAULT_PANEL_IDLE_TIMEOUT),
             (CONF_UPDATE_INTERVAL, DEFAULT_UPDATE_INTERVAL),
-            (CONF_SNAPSHOT_STALENESS, DEFAULT_SNAPSHOT_STALENESS),
+            (CONF_NOTIFY_TARGET, ""),
+            (CONF_MORNING_SUMMARY_TIME, DEFAULT_MORNING_SUMMARY_TIME),
+            (CONF_AFTERNOON_REMINDER_TIME, DEFAULT_AFTERNOON_REMINDER_TIME),
+            (CONF_END_OF_DAY_REPORT_TIME, DEFAULT_END_OF_DAY_REPORT_TIME),
+            (CONF_MORNING_SUMMARY_ENABLED, DEFAULT_AUTOMATION_ENABLED),
+            (CONF_AFTERNOON_REMINDER_ENABLED, DEFAULT_AUTOMATION_ENABLED),
+            (CONF_END_OF_DAY_REPORT_ENABLED, DEFAULT_AUTOMATION_ENABLED),
+            (CONF_CELEBRATION_ENABLED, DEFAULT_AUTOMATION_ENABLED),
             (CONF_API_BASE_URL, DEFAULT_API_BASE_URL),
             (CONF_PANEL_TOKEN, DEFAULT_PANEL_TOKEN),
         ):
@@ -211,4 +415,4 @@ class NestQuestOptionsFlow(config_entries.OptionsFlowWithConfigEntry):
                 values[key] = entry_data[key]
             else:
                 values[key] = default
-        return values
+        return values

custom_components/nestquest/permissions.py

@@ -0,0 +1,90 @@
+"""Permission gate for NestQuest services (Feature 09).
+
+A wrapper factory, applied to EVERY registered service at registration
+time (no handler is exempt), reads ``call.context.user_id``, consults
+the :data:`~.service_policy.SERVICE_POLICY` registry and
+:func:`~.admin_allowlist.is_admin`, and raises
+:class:`homeassistant.exceptions.Unauthorized` for an admin-only
+operation called by a non-admin — including a call with NO user
+context, which fails closed.  ``complete_quest`` (policy ``open``)
+proceeds regardless of the allowlist.
+
+Logging (later Feature 09 tasks): every denied admin-only call logs a
+warning and every successful one logs a debug line, both carrying the
+service, the user id (or ``none``), and a UTC timestamp.
+"""
+from __future__ import annotations
+
+import datetime
+import logging
+from collections.abc import Awaitable, Callable
+from typing import Any
+
+from homeassistant.exceptions import Unauthorized
+
+from .admin_allowlist import is_admin
+from .service_policy import ADMIN_ONLY
+
+LOGGER = logging.getLogger(__name__)
+
+ServiceHandler = Callable[[Any], Awaitable[None]]
+
+
+def _context_user_id(call: Any) -> str | None:
+    context = getattr(call, "context", None)
+    user_id = getattr(context, "user_id", None) if context is not None else None
+    if isinstance(user_id, str) and user_id:
+        return user_id
+    return None
+
+
+def _stamp() -> str:
+    return datetime.datetime.now(datetime.timezone.utc).isoformat(
+        timespec="seconds"
+    )
+
+
+def permission_gate(
+    service: str,
+    policy: str,
+    database_of: Callable[[Any], Any],
+) -> Callable[[ServiceHandler], ServiceHandler]:
+    """Wrap ``handler`` with the Feature 09 permission check.
+
+    ``database_of`` resolves the live database from the call-time
+    runtime (the same ``find_runtime`` the handler uses), so the gate
+    never opens its own connection.  The verdict is fail-closed:
+    absent allowlist row, unknown id, no user context — all not admin.
+    """
+
+    def _wrap(handler: ServiceHandler) -> ServiceHandler:
+        if policy != ADMIN_ONLY:
+            return handler
+
+        async def _gated(call: Any) -> None:
+            user_id = _context_user_id(call)
+            allowed = user_id is not None and await is_admin(
+                database_of(call), user_id
+            )
+            if not allowed:
+                LOGGER.warning(
+                    "NestQuest denied %s: caller user_id=%s at %s",
+                    service,
+                    user_id if user_id is not None else "none",
+                    _stamp(),
+                )
+                raise Unauthorized(
+                    f"User '{user_id if user_id is not None else 'none'}' "
+                    f"is not allowed to call nestquest.{service}"
+                )
+            LOGGER.debug(
+                "NestQuest allowed %s: caller user_id=%s at %s",
+                service,
+                user_id,
+                _stamp(),
+            )
+            await handler(call)
+
+        return _gated
+
+    return _wrap

custom_components/nestquest/presence.py

@@ -0,0 +1,11 @@
+"""Re-export of :mod:`custom_components.nestquest.core.presence` for the integration package.
+
+The presence and custody model lives in
+:mod:`custom_components.nestquest.core.presence` (extracted in
+task 510c1f78); this module re-exports it so existing
+``from .presence import ...`` references inside the integration keep
+working.
+"""
+from __future__ import annotations
+
+from .core.presence import *  # noqa: F401,F403

custom_components/nestquest/presence_management.py

@@ -0,0 +1,10 @@
+"""Re-export of :mod:`custom_components.nestquest.core.presence_management` for the integration package.
+
+The presence-write business layer lives in
+:mod:`custom_components.nestquest.core.presence_management` (added for
+task e4a9d31b); this module re-exports it so the integration's service
+handlers call the ONE implementation the API admin plane shares.
+"""
+from __future__ import annotations
+
+from .core.presence_management import *  # noqa: F401,F403

custom_components/nestquest/quest_definitions.py

@@ -0,0 +1,11 @@
+"""Re-export of :mod:`custom_components.nestquest.core.quest_definitions` for the integration package.
+
+The quest definitions business layer lives in
+:mod:`custom_components.nestquest.core.quest_definitions` (extracted in
+task 510c1f78); this module re-exports it so existing
+``from .quest_definitions import ...`` references inside the integration
+keep working.
+"""
+from __future__ import annotations
+
+from .core.quest_definitions import *  # noqa: F401,F403

custom_components/nestquest/recurrence.py

@@ -0,0 +1,10 @@
+"""Re-export of :mod:`custom_components.nestquest.core.recurrence` for the integration package.
+
+The recurrence model lives in :mod:`custom_components.nestquest.core.recurrence`
+(extracted in task d0b691d8); this module re-exports it so existing
+``from .recurrence import ...`` references inside the integration keep
+working.
+"""
+from __future__ import annotations
+
+from .core.recurrence import *  # noqa: F401,F403

custom_components/nestquest/schema.py

@@ -0,0 +1,11 @@
+"""Re-export of :mod:`custom_components.nestquest.core.schema` for the integration package.
+
+The declarative schema DDL lives in
+:mod:`custom_components.nestquest.core.schema` (extracted in
+task d0b691d8); this module re-exports it so existing
+``from .schema import ...`` references inside the integration keep
+working.
+"""
+from __future__ import annotations
+
+from .core.schema import *  # noqa: F401,F403

custom_components/nestquest/sensor.py

@@ -32,7 +32,6 @@ from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity import DeviceInfo
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
-from homeassistant.util import slugify
 
 from .const import DOMAIN
 from .coordinator import (
@@ -42,21 +41,13 @@ from .coordinator import (
 )
 from .core.snapshot import instance_payload
 
-#: HA's state machine refuses states longer than 255
+#: Home Assistant's state machine refuses states longer than 255
 #: characters (its hard recorder/state limit).  These sensors' states
 #: are numeric, but the guard is applied uniformly: a payload-bearing
 #: sensor can never crash the state write, and later string-state
 #: sensors reuse the same helper.
 MAX_STATE_LENGTH = 255
 
-#: Entity-id length cap the roster applies to HA's slugify: HA's
-#: slugifier itself does NOT truncate, but the entity registry derives
-#: entity ids as ``<domain>.<slug>`` and truncates the full entity_id at
-#: MAX_LENGTH_STATE_ENTITY_ID (64), so for this module's ``sensor.``
-#: entities the slugged object id alone may not exceed
-#: 64 - len("sensor.").
-_MAX_SLUG_LENGTH = 64 - len("sensor.")
-
 
 def _state_within_limit(state: Any) -> Any:
     """Return ``state`` unchanged, refusing strings over HA's limit.
@@ -107,51 +98,6 @@ def _next_open_quest(
     )
 
 
-def _slugify(text: str) -> str:
-    """Slugify a display name the way Home Assistant derives entity ids.
-
-    Runs ``homeassistant.util.slugify`` — the real slugifier HA runs
-    entity names through, which transliterates every script to ASCII
-    through unidecode (so non-Latin names survive: ``京子`` slugs to
-    ``jing_zi``) before folding to lowercase and turning every run of
-    non-alphanumerics into one underscore, answering HA's ``unknown``
-    sentinel when a name slugs to nothing — then caps the result at
-    the object-id length the entity registry enforces (the registry
-    truncates the full ``sensor.`` + slug entity_id at 64 characters,
-    so the slug alone is capped like this; HA's slugify does not
-    truncate by itself).
-    """
-    return slugify(text)[:_MAX_SLUG_LENGTH]
-
-
-def _child_roster(children: Iterable[ChildDaySnapshot]) -> list[dict[str, Any]]:
-    """The ordered child roster the panel cards discover children from.
-
-    One entry per ACTIVE child in the snapshot's order (the API's
-    sort_order, then id): ``child_id``, ``name``, and the ``slug`` the
-    entity-id derivation produces for the child's name — the piece the
-    cards need to build ``sensor.nestquest_<slug>_...`` ids.  Duplicate
-    display names get the registry's ``_2``/``_3`` suffix in snapshot
-    order, matching how HA resolves the collision at registration.  The
-    rollups' ``children`` attribute (per-child counts) is unchanged and
-    carries a different shape on purpose.
-    """
-    slugs: dict[str, int] = {}
-    roster: list[dict[str, Any]] = []
-    for child in children:
-        base = _slugify(child.child_name)
-        taken = slugs.get(base, 0) + 1
-        slugs[base] = taken
-        roster.append(
-            {
-                "child_id": child.child_id,
-                "name": child.child_name,
-                "slug": base if taken == 1 else f"{base}_{taken}",
-            }
-        )
-    return roster
-
-
 class _NestQuestChildDaySensor(CoordinatorEntity, SensorEntity):
     """Base for the per-child day sensors.
 
@@ -410,12 +356,7 @@ class _NestQuestHouseholdSensor(CoordinatorEntity, SensorEntity):
 
 
 class NestQuestHouseholdDueTodaySensor(_NestQuestHouseholdSensor):
-    """Total quests due today across active children.
-
-    Also publishes ``child_roster`` (see :func:`_child_roster`): the
-    ordered child identity list the panel cards read to discover the
-    board's children when the card config carries no ``child_order``.
-    """
+    """Total quests due today across active children."""
 
     _attr_name = "NestQuest household quests due today"
     _attr_state_class = SensorStateClass.MEASUREMENT
@@ -439,8 +380,7 @@ class NestQuestHouseholdDueTodaySensor(_NestQuestHouseholdSensor):
             "children": {
                 str(child.child_id): child.due_today
                 for child in data.children
-            },
-            "child_roster": _child_roster(data.children),
+            }
         }
 
 

custom_components/nestquest/service_policy.py

@@ -0,0 +1,11 @@
+"""Re-export of :mod:`custom_components.nestquest.core.service_policy` for the integration package.
+
+The service policy registry lives in
+:mod:`custom_components.nestquest.core.service_policy` (extracted in
+task 510c1f78); this module re-exports it so existing
+``from .service_policy import ...`` references inside the integration
+keep working.
+"""
+from __future__ import annotations
+
+from .core.service_policy import *  # noqa: F401,F403

custom_components/nestquest/services.py

@@ -1,36 +1,61 @@
-"""The domain-global ``nestquest.complete_quest`` service (Feature 18).
+"""Domain-global NestQuest service schemas and handlers (Feature 09).
 
 Registration is domain-scoped and happens once (see
-:func:`async_register_services`).  Since Feature 18 the integration is
-a client of the NestQuest API service, so ``complete_quest`` proxies
-to the API's panel complete route through the entry's shared API
-client instead of writing any database.  The former HA admin services
-(uncomplete, quest-definition and presence management, CSV export,
-child management, regenerate) are removed: the admin surface is the
-PWA and the API service's admin routes, so the only HA service left is
-the panel completion path.
+:func:`async_register_services`); handlers resolve a live database at
+call time through the injected ``find_runtime`` callable.  Permission
+checks are Feature 09 later tasks — this module only validates payload
+shape and forwards to the Feature 03/06/08 business layers (the
+presence writes included, through :mod:`.presence_management` — the
+ONE implementation the API admin plane shares).
+``export_history_csv`` is registered with a schema but raises until
+Feature 13.  ``regenerate`` is supplied by the caller so
+the Feature 07 handler stays the one in ``__init__``.
 """
 from __future__ import annotations
 
+import datetime
 from collections.abc import Awaitable, Callable
 from typing import Any
+from zoneinfo import ZoneInfo
 
 import voluptuous as vol
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
 
-from .api_client import NestQuestApiError
+from . import children as children_layer
+from . import completion as completion_layer
+from . import presence_management as presence_management_layer
+from . import quest_definitions as quest_definitions_layer
 from .const import (
     DOMAIN,
     DOMAIN_SERVICES,
+    QUEST_WINDOWS,
     SERVICE_COMPLETE_QUEST,
+    SERVICE_CREATE_PRESENCE_OVERRIDE,
+    SERVICE_CREATE_QUEST_DEFINITION,
+    SERVICE_DELETE_PRESENCE_OVERRIDE,
+    SERVICE_EXPORT_HISTORY_CSV,
+    SERVICE_MANAGE_CHILD,
+    SERVICE_REGENERATE,
+    SERVICE_SET_PRESENCE_PATTERN,
+    SERVICE_SET_QUEST_DEFINITION_ACTIVE,
+    SERVICE_UNCOMPLETE_QUEST,
+    SERVICE_UPDATE_QUEST_DEFINITION,
 )
+from .events import fire_quest_completed, fire_quest_uncompleted
+from .permissions import permission_gate
+from .recurrence import ScheduleRule
+from .service_policy import SERVICE_POLICY
 
 FindRuntime = Callable[[HomeAssistant], Any]
 ServiceHandler = Callable[[Any], Awaitable[None]]
 
 ACTOR_PANEL = "panel"
 ACTOR_USER = "user"
+MANAGE_CHILD_CREATE = "create"
+MANAGE_CHILD_EDIT = "edit"
+MANAGE_CHILD_SET_ACTIVE = "set_active"
+MANAGE_CHILD_REORDER = "reorder"
 
 
 def _strict_int(value: object) -> int:
@@ -40,6 +65,82 @@ def _strict_int(value: object) -> int:
     return value
 
 
+def _strict_bool(value: object) -> bool:
+    """Reject ints and other truthy values; require a real bool."""
+    if type(value) is not bool:
+        raise vol.Invalid(f"expected bool, got {value!r}")
+    return value
+
+
+def _weekday_list(value: object) -> list[int]:
+    if type(value) is not list:
+        raise vol.Invalid(f"expected a list of weekday ints, got {value!r}")
+    return [_strict_int(item) for item in value]
+
+
+def _presence_pattern(value: object) -> dict[int, list[int]]:
+    if not isinstance(value, dict):
+        raise vol.Invalid(f"pattern must be a mapping, got {value!r}")
+    pattern: dict[int, list[int]] = {}
+    for week, days in value.items():
+        if isinstance(week, str):
+            try:
+                week_index = int(week)
+            except ValueError as err:
+                raise vol.Invalid(
+                    f"pattern week index must be an integer, got {week!r}"
+                ) from err
+            if str(week_index) != week:
+                raise vol.Invalid(
+                    f"pattern week index must be an integer, got {week!r}"
+                )
+        else:
+            week_index = _strict_int(week)
+        pattern[week_index] = _weekday_list(days)
+    return pattern
+
+
+def _window_entry(value: object) -> str | tuple[str, str | None]:
+    if isinstance(value, str):
+        if value not in QUEST_WINDOWS:
+            raise vol.Invalid(f"unknown window {value!r}")
+        return value
+    if isinstance(value, dict):
+        parsed = vol.Schema(
+            {
+                vol.Required("window"): vol.In(QUEST_WINDOWS),
+                vol.Optional("due_time"): str,
+            }
+        )(value)
+        due_time = parsed.get("due_time")
+        if due_time is None:
+            return parsed["window"]
+        return (parsed["window"], due_time)
+    raise vol.Invalid(
+        f"windows entry must be a window name or object, got {value!r}"
+    )
+
+
+def _windows(value: object) -> list[str | tuple[str, str | None]]:
+    if type(value) is not list:
+        raise vol.Invalid(f"windows must be a list, got {value!r}")
+    if not value:
+        raise vol.Invalid("windows must not be empty")
+    return [_window_entry(entry) for entry in value]
+
+
+def _int_list(value: object) -> list[int]:
+    if type(value) is not list:
+        raise vol.Invalid(f"expected a list of ints, got {value!r}")
+    return [_strict_int(item) for item in value]
+
+
+def _rule_dict(value: object) -> dict:
+    if not isinstance(value, dict):
+        raise vol.Invalid(f"rule must be a dict, got {value!r}")
+    return value
+
+
 SCHEMA_COMPLETE_QUEST = vol.Schema(
     {
         vol.Required("instance_id"): _strict_int,
@@ -49,22 +150,102 @@ SCHEMA_COMPLETE_QUEST = vol.Schema(
     }
 )
 
+SCHEMA_UNCOMPLETE_QUEST = SCHEMA_COMPLETE_QUEST
+
+SCHEMA_CREATE_QUEST_DEFINITION = vol.Schema(
+    {
+        vol.Required("title"): str,
+        vol.Required("rule"): _rule_dict,
+        vol.Required("assignee_child_ids"): vol.All(
+            _int_list, vol.Length(min=1)
+        ),
+        vol.Required("windows"): _windows,
+        vol.Optional("description"): str,
+        vol.Optional("icon"): str,
+    }
+)
+
+SCHEMA_UPDATE_QUEST_DEFINITION = vol.Schema(
+    {
+        vol.Required("definition_id"): _strict_int,
+        vol.Optional("title"): str,
+        vol.Optional("description"): vol.Any(str, None),
+        vol.Optional("icon"): vol.Any(str, None),
+        vol.Optional("rule"): _rule_dict,
+        vol.Optional("windows"): _windows,
+    }
+)
+
+SCHEMA_SET_QUEST_DEFINITION_ACTIVE = vol.Schema(
+    {
+        vol.Required("definition_id"): _strict_int,
+        vol.Required("is_active"): _strict_bool,
+    }
+)
+
+SCHEMA_SET_PRESENCE_PATTERN = vol.Schema(
+    {
+        vol.Required("child_id"): _strict_int,
+        vol.Required("cycle_length_weeks"): _strict_int,
+        vol.Required("anchor_date"): str,
+        vol.Required("pattern"): _presence_pattern,
+    }
+)
+
+SCHEMA_CREATE_PRESENCE_OVERRIDE = vol.Schema(
+    {
+        vol.Required("child_id"): _strict_int,
+        vol.Required("start_date"): str,
+        vol.Required("end_date"): str,
+        vol.Required("is_present"): _strict_bool,
+        vol.Optional("note"): str,
+    }
+)
+
+SCHEMA_DELETE_PRESENCE_OVERRIDE = vol.Schema(
+    {
+        vol.Required("override_id"): _strict_int,
+    }
+)
+
+SCHEMA_EXPORT_HISTORY_CSV = vol.Schema({})
+
+SCHEMA_MANAGE_CHILD = vol.Schema(
+    {
+        vol.Required("action"): vol.In(
+            [
+                MANAGE_CHILD_CREATE,
+                MANAGE_CHILD_EDIT,
+                MANAGE_CHILD_SET_ACTIVE,
+                MANAGE_CHILD_REORDER,
+            ]
+        ),
+        vol.Optional("child_id"): _strict_int,
+        vol.Optional("display_name"): str,
+        vol.Optional("colour"): str,
+        vol.Optional("avatar_ref"): str,
+        vol.Optional("sort_order"): _strict_int,
+        vol.Optional("is_active"): _strict_bool,
+        vol.Optional("ordered_ids"): _int_list,
+    }
+)
+
 
 def _require_runtime(hass: HomeAssistant, find_runtime: FindRuntime):
     runtime = find_runtime(hass)
     if runtime is None:
         raise HomeAssistantError(
-            "NestQuest is not loaded; cannot run this service"
+            "NestQuest has no live database; cannot run this service"
         )
     return runtime
 
 
 async def _refresh_entities(runtime: Any) -> None:
-    """Force an immediate coordinator refresh after the service call.
+    """Force an immediate coordinator refresh after a service mutation.
 
-    Only the SERVICE path calls this — the scheduled materialize and
+    Only the SERVICE paths call this — the scheduled materialize and
     rollover internals are direct function calls and never widen this
-    gate — so the entities reflect a completion the moment the service
+    gate — so entities reflect a completion the moment the service
     call returns instead of waiting for the poll interval.
     """
     coordinator = getattr(runtime, "coordinator", None)
@@ -72,6 +253,12 @@ async def _refresh_entities(runtime: Any) -> None:
         await coordinator.async_refresh()
 
 
+def _generation_kwargs(hass: HomeAssistant, runtime: Any) -> dict[str, Any]:
+    time_zone = ZoneInfo(hass.config.time_zone)
+    today = datetime.datetime.now(time_zone).date()
+    return {"today": today, "horizon_days": runtime.settings.horizon_days}
+
+
 def _actor_kwargs(call: Any) -> dict[str, Any]:
     actor = call.data["actor"]
     if actor == ACTOR_PANEL:
@@ -114,50 +301,223 @@ def _complete_quest(
     async def _handler(call: Any) -> None:
         runtime = _require_runtime(hass, find_runtime)
         instance_id = call.data["instance_id"]
-        # The panel contract (decision 9): a tap completes as the
-        # tapped child profile, the only actor shape the API's panel
-        # route accepts.  The payload schema is unchanged — the panel
-        # cards call it with instance_id, actor=panel, actor_child_id.
-        actor = _actor_kwargs(call)
-        if actor["actor_source"] != ACTOR_PANEL:
-            raise HomeAssistantError(
-                "nestquest.complete_quest completes through the API's "
-                "panel route as the tapped child profile; actor must "
-                "be 'panel' with actor_child_id"
-            )
-        # The entry's ONE shared API client (built at setup): the
-        # coordinator's snapshot poll, the SSE subscription, and this
-        # proxy all ride the same instance.  An entry with no panel
-        # token runs the unconfigured stub, which has no completion
-        # surface — fail fast with a clear, token-free message.
-        complete_instance = getattr(
-            getattr(runtime.coordinator, "api_client", None),
-            "complete_instance",
-            None,
+        # ``appended`` is decided under the same lock as the write, so
+        # a concurrent duplicate call (a double tap) can not produce a
+        # second transition event: the loser appends nothing.
+        result = await completion_layer.complete_instance(
+            runtime.database,
+            instance_id,
+            **_actor_kwargs(call),
         )
-        if complete_instance is None:
-            raise HomeAssistantError(
-                "NestQuest API is not configured; cannot complete a "
-                "quest"
+        if result.appended:
+            await fire_quest_completed(
+                hass,
+                runtime.database,
+                instance_id,
+                was_on_time=result.was_on_time,
             )
-        try:
-            await complete_instance(instance_id, actor["actor_child_id"])
-        except NestQuestApiError as err:
-            # The typed API failure surfaces as a service error the
-            # caller sees — never swallowed, never retried here.  The
-            # typed message names method, path, and status only; the
-            # panel token never appears in it.
+            await _refresh_entities(runtime)
+
+    return _with_errors(_handler)
+
+
+def _uncomplete_quest(
+    hass: HomeAssistant, find_runtime: FindRuntime
+) -> ServiceHandler:
+    async def _handler(call: Any) -> None:
+        runtime = _require_runtime(hass, find_runtime)
+        instance_id = call.data["instance_id"]
+        result = await completion_layer.uncomplete_instance(
+            runtime.database,
+            instance_id,
+            **_actor_kwargs(call),
+        )
+        if result.appended:
+            await fire_quest_uncompleted(
+                hass, runtime.database, instance_id
+            )
+            await _refresh_entities(runtime)
+
+    return _with_errors(_handler)
+
+
+def _create_quest_definition(
+    hass: HomeAssistant, find_runtime: FindRuntime
+) -> ServiceHandler:
+    async def _handler(call: Any) -> None:
+        database = _require_runtime(hass, find_runtime).database
+        data = call.data
+        await quest_definitions_layer.create_quest_definition(
+            database,
+            data["title"],
+            ScheduleRule.from_dict(data["rule"]),
+            data["assignee_child_ids"],
+            data["windows"],
+            description=data.get("description"),
+            icon=data.get("icon"),
+        )
+
+    return _with_errors(_handler)
+
+
+def _update_quest_definition(
+    hass: HomeAssistant, find_runtime: FindRuntime
+) -> ServiceHandler:
+    async def _handler(call: Any) -> None:
+        runtime = _require_runtime(hass, find_runtime)
+        data = call.data
+        kwargs: dict[str, Any] = _generation_kwargs(hass, runtime)
+        if "title" in data:
+            kwargs["title"] = data["title"]
+        if "description" in data:
+            kwargs["description"] = data["description"]
+        if "icon" in data:
+            kwargs["icon"] = data["icon"]
+        if "rule" in data:
+            kwargs["rule"] = ScheduleRule.from_dict(data["rule"])
+        if "windows" in data:
+            kwargs["windows"] = data["windows"]
+        await quest_definitions_layer.edit_quest_definition(
+            runtime.database, data["definition_id"], **kwargs
+        )
+
+    return _with_errors(_handler)
+
+
+def _set_quest_definition_active(
+    hass: HomeAssistant, find_runtime: FindRuntime
+) -> ServiceHandler:
+    async def _handler(call: Any) -> None:
+        runtime = _require_runtime(hass, find_runtime)
+        await quest_definitions_layer.set_quest_definition_active(
+            runtime.database,
+            call.data["definition_id"],
+            call.data["is_active"],
+            **_generation_kwargs(hass, runtime),
+        )
+
+    return _with_errors(_handler)
+
+
+def _set_presence_pattern(
+    hass: HomeAssistant, find_runtime: FindRuntime
+) -> ServiceHandler:
+    async def _handler(call: Any) -> None:
+        runtime = _require_runtime(hass, find_runtime)
+        data = call.data
+        await presence_management_layer.set_presence_schedule(
+            runtime.database,
+            data["child_id"],
+            data["cycle_length_weeks"],
+            data["anchor_date"],
+            data["pattern"],
+            **_generation_kwargs(hass, runtime),
+        )
+
+    return _with_errors(_handler)
+
+
+def _create_presence_override(
+    hass: HomeAssistant, find_runtime: FindRuntime
+) -> ServiceHandler:
+    async def _handler(call: Any) -> None:
+        runtime = _require_runtime(hass, find_runtime)
+        data = call.data
+        await presence_management_layer.create_presence_override(
+            runtime.database,
+            data["child_id"],
+            data["start_date"],
+            data["end_date"],
+            data["is_present"],
+            note=data.get("note"),
+            **_generation_kwargs(hass, runtime),
+        )
+
+    return _with_errors(_handler)
+
+
+def _delete_presence_override(
+    hass: HomeAssistant, find_runtime: FindRuntime
+) -> ServiceHandler:
+    async def _handler(call: Any) -> None:
+        runtime = _require_runtime(hass, find_runtime)
+        await presence_management_layer.delete_presence_override(
+            runtime.database,
+            call.data["override_id"],
+            **_generation_kwargs(hass, runtime),
+        )
+
+    return _with_errors(_handler)
+
+
+async def _export_history_csv(_call: Any) -> None:
+    raise HomeAssistantError(
+        "CSV history export is not implemented until Feature 13"
+    )
+
+
+def _manage_child(
+    hass: HomeAssistant, find_runtime: FindRuntime
+) -> ServiceHandler:
+    async def _handler(call: Any) -> None:
+        database = _require_runtime(hass, find_runtime).database
+        data = call.data
+        action = data["action"]
+        if action == MANAGE_CHILD_CREATE:
+            display_name = data.get("display_name")
+            if display_name is None:
+                raise HomeAssistantError(
+                    "display_name is required when action is create"
+                )
+            kwargs: dict[str, Any] = {}
+            if "colour" in data:
+                kwargs["colour"] = data["colour"]
+            if "avatar_ref" in data:
+                kwargs["avatar_ref"] = data["avatar_ref"]
+            if "sort_order" in data:
+                kwargs["sort_order"] = data["sort_order"]
+            await children_layer.create_child(
+                database, display_name, **kwargs
+            )
+            return
+        if action == MANAGE_CHILD_EDIT:
+            child_id = data.get("child_id")
+            if child_id is None:
+                raise HomeAssistantError(
+                    "child_id is required when action is edit"
+                )
+            kwargs = {}
+            if "display_name" in data:
+                kwargs["display_name"] = data["display_name"]
+            if "colour" in data:
+                kwargs["colour"] = data["colour"]
+            if "avatar_ref" in data:
+                kwargs["avatar_ref"] = data["avatar_ref"]
+            if "sort_order" in data:
+                kwargs["sort_order"] = data["sort_order"]
+            await children_layer.edit_child(database, child_id, **kwargs)
+            return
+        if action == MANAGE_CHILD_SET_ACTIVE:
+            child_id = data.get("child_id")
+            is_active = data.get("is_active")
+            if child_id is None:
+                raise HomeAssistantError(
+                    "child_id is required when action is set_active"
+                )
+            if is_active is None:
+                raise HomeAssistantError(
+                    "is_active is required when action is set_active"
+                )
+            await children_layer.set_child_active(
+                database, child_id, is_active
+            )
+            return
+        ordered_ids = data.get("ordered_ids")
+        if ordered_ids is None:
             raise HomeAssistantError(
-                f"NestQuest quest completion failed: {err}"
-            ) from err
-        # NO local completion write and NO local event: the API service
-        # emits the transition on its SSE stream and the integration's
-        # subscription re-fires it on the bus — firing it here too
-        # would double-fire.  The immediate refresh keeps the old
-        # behaviour where the sensors reflect the completion the
-        # moment the service call returns instead of waiting for the
-        # poll interval.
-        await _refresh_entities(runtime)
+                "ordered_ids is required when action is reorder"
+            )
+        await children_layer.reorder_children(database, ordered_ids)
 
     return _with_errors(_handler)
 
@@ -166,25 +526,84 @@ def async_register_services(
     hass: HomeAssistant,
     *,
     find_runtime: FindRuntime,
+    regenerate_handler: ServiceHandler,
 ) -> None:
-    """Register the panel completion service once at domain scope.
+    """Register every canonical service once at domain scope.
 
-    The one remaining HA service is the panel completion path; every
-    admin operation moved to the API service's admin routes, so there
-    is no permission gate to apply here.
+    Every service — regenerate included — passes through the Feature
+    09 permission gate before its handler runs; the gate reads
+    :data:`~.service_policy.SERVICE_POLICY`, so no service can be
+    registered exempt from the policy.
     """
-    if hass.services.has_service(DOMAIN, SERVICE_COMPLETE_QUEST):
+    if hass.services.has_service(DOMAIN, SERVICE_REGENERATE):
         return
-    hass.services.async_register(
-        DOMAIN,
-        SERVICE_COMPLETE_QUEST,
-        _complete_quest(hass, find_runtime),
-        schema=SCHEMA_COMPLETE_QUEST,
-    )
+    gate = permission_gate
+    specs: list[tuple[str, ServiceHandler, object]] = [
+        (SERVICE_REGENERATE, regenerate_handler, None),
+        (
+            SERVICE_COMPLETE_QUEST,
+            _complete_quest(hass, find_runtime),
+            SCHEMA_COMPLETE_QUEST,
+        ),
+        (
+            SERVICE_UNCOMPLETE_QUEST,
+            _uncomplete_quest(hass, find_runtime),
+            SCHEMA_UNCOMPLETE_QUEST,
+        ),
+        (
+            SERVICE_CREATE_QUEST_DEFINITION,
+            _create_quest_definition(hass, find_runtime),
+            SCHEMA_CREATE_QUEST_DEFINITION,
+        ),
+        (
+            SERVICE_UPDATE_QUEST_DEFINITION,
+            _update_quest_definition(hass, find_runtime),
+            SCHEMA_UPDATE_QUEST_DEFINITION,
+        ),
+        (
+            SERVICE_SET_QUEST_DEFINITION_ACTIVE,
+            _set_quest_definition_active(hass, find_runtime),
+            SCHEMA_SET_QUEST_DEFINITION_ACTIVE,
+        ),
+        (
+            SERVICE_SET_PRESENCE_PATTERN,
+            _set_presence_pattern(hass, find_runtime),
+            SCHEMA_SET_PRESENCE_PATTERN,
+        ),
+        (
+            SERVICE_CREATE_PRESENCE_OVERRIDE,
+            _create_presence_override(hass, find_runtime),
+            SCHEMA_CREATE_PRESENCE_OVERRIDE,
+        ),
+        (
+            SERVICE_DELETE_PRESENCE_OVERRIDE,
+            _delete_presence_override(hass, find_runtime),
+            SCHEMA_DELETE_PRESENCE_OVERRIDE,
+        ),
+        (
+            SERVICE_EXPORT_HISTORY_CSV,
+            _export_history_csv,
+            SCHEMA_EXPORT_HISTORY_CSV,
+        ),
+        (
+            SERVICE_MANAGE_CHILD,
+            _manage_child(hass, find_runtime),
+            SCHEMA_MANAGE_CHILD,
+        ),
+    ]
+
+    def _database_of(_call: Any) -> Any:
+        return _require_runtime(hass, find_runtime).database
+
+    for service, handler, schema in specs:
+        gated = gate(
+            service, SERVICE_POLICY[service], _database_of
+        )(handler)
+        hass.services.async_register(DOMAIN, service, gated, schema=schema)
 
 
 def async_deregister_services(hass: HomeAssistant) -> None:
     """Remove every canonical service when the last entry unloads."""
     for service in DOMAIN_SERVICES:
         if hass.services.has_service(DOMAIN, service):
-            hass.services.async_remove(DOMAIN, service)
+            hass.services.async_remove(DOMAIN, service)

custom_components/nestquest/services.yaml

@@ -1,8 +1,15 @@
 # Service declarations for the NestQuest integration (Home Assistant
 # services.yaml metadata). Services are domain-scoped: nested under the
-# "nestquest" domain, not repeated per config entry.  Since Feature 18
-# only the panel completion service remains — every admin operation
-# moved to the PWA and the API service's admin routes.
+# "nestquest" domain, not repeated per config entry.
+
+regenerate:
+  name: Regenerate quest instances
+  description: >-
+    Regenerate every future quest instance for the household over the rolling
+    horizon, using the same idempotent materialization as the daily rollover
+    and the startup backfill. Safe to call at any time: a re-run refreshes the
+    same rows instead of duplicating them, and completed instances are never
+    touched.
 
 complete_quest:
   name: Complete quest
@@ -36,4 +43,284 @@ complete_quest:
       description: Home Assistant user id when actor is user and no call context is present.
       required: false
       selector:
-        text:
+        text:
+
+uncomplete_quest:
+  name: Uncomplete quest
+  description: Undo a quest instance completion.
+  fields:
+    instance_id:
+      name: Instance ID
+      description: The quest instance to uncomplete.
+      required: true
+      selector:
+        number:
+          mode: box
+    actor:
+      name: Actor
+      description: Who is undoing the completion (panel or user).
+      required: true
+      selector:
+        select:
+          options:
+            - panel
+            - user
+    actor_child_id:
+      name: Actor child ID
+      description: The tapped child profile. Required when actor is panel.
+      required: false
+      selector:
+        number:
+          mode: box
+    actor_user_id:
+      name: Actor user ID
+      description: Home Assistant user id when actor is user and no call context is present.
+      required: false
+      selector:
+        text:
+
+create_quest_definition:
+  name: Create quest definition
+  description: Create a quest definition with its schedule rule, assignees and windows.
+  fields:
+    title:
+      name: Title
+      description: Display title for the quest.
+      required: true
+      selector:
+        text:
+    rule:
+      name: Rule
+      description: Recurrence rule as a mapping (rule_type plus shape fields).
+      required: true
+      selector:
+        object:
+    assignee_child_ids:
+      name: Assignee child IDs
+      description: Child ids this definition is assigned to.
+      required: true
+      selector:
+        object:
+    windows:
+      name: Windows
+      description: Day windows (morning, afternoon, evening), optionally with a due time.
+      required: true
+      selector:
+        object:
+    description:
+      name: Description
+      description: Optional longer description.
+      required: false
+      selector:
+        text:
+    icon:
+      name: Icon
+      description: Optional icon name.
+      required: false
+      selector:
+        text:
+
+update_quest_definition:
+  name: Update quest definition
+  description: Edit a quest definition's title, description, icon, rule or windows.
+  fields:
+    definition_id:
+      name: Definition ID
+      description: The quest definition to update.
+      required: true
+      selector:
+        number:
+          mode: box
+    title:
+      name: Title
+      description: Replacement display title.
+      required: false
+      selector:
+        text:
+    description:
+      name: Description
+      description: Replacement description, or null to clear.
+      required: false
+      selector:
+        text:
+    icon:
+      name: Icon
+      description: Replacement icon, or null to clear.
+      required: false
+      selector:
+        text:
+    rule:
+      name: Rule
+      description: Replacement recurrence rule as a mapping.
+      required: false
+      selector:
+        object:
+    windows:
+      name: Windows
+      description: Replacement day windows.
+      required: false
+      selector:
+        object:
+
+set_quest_definition_active:
+  name: Set quest definition active
+  description: Deactivate or reactivate a quest definition.
+  fields:
+    definition_id:
+      name: Definition ID
+      description: The quest definition to update.
+      required: true
+      selector:
+        number:
+          mode: box
+    is_active:
+      name: Active
+      description: Whether the definition should generate future instances.
+      required: true
+      selector:
+        boolean:
+
+set_presence_pattern:
+  name: Set presence pattern
+  description: Upsert a child's repeating presence schedule.
+  fields:
+    child_id:
+      name: Child ID
+      description: The child whose schedule is being set.
+      required: true
+      selector:
+        number:
+          mode: box
+    cycle_length_weeks:
+      name: Cycle length weeks
+      description: Number of weeks in the repeating cycle (1 to 4).
+      required: true
+      selector:
+        number:
+          mode: box
+          min: 1
+          max: 4
+    anchor_date:
+      name: Anchor date
+      description: Cycle anchor as a YYYY-MM-DD date.
+      required: true
+      selector:
+        date:
+    pattern:
+      name: Pattern
+      description: Mapping of week index to present weekday ints (Monday is 0).
+      required: true
+      selector:
+        object:
+
+create_presence_override:
+  name: Create presence override
+  description: Create a date-range presence override for a child.
+  fields:
+    child_id:
+      name: Child ID
+      description: The child the override applies to.
+      required: true
+      selector:
+        number:
+          mode: box
+    start_date:
+      name: Start date
+      description: Inclusive start date (YYYY-MM-DD).
+      required: true
+      selector:
+        date:
+    end_date:
+      name: End date
+      description: Inclusive end date (YYYY-MM-DD).
+      required: true
+      selector:
+        date:
+    is_present:
+      name: Present
+      description: Whether the child is present for this range.
+      required: true
+      selector:
+        boolean:
+    note:
+      name: Note
+      description: Optional note stored with the override.
+      required: false
+      selector:
+        text:
+
+delete_presence_override:
+  name: Delete presence override
+  description: Delete a presence override by id.
+  fields:
+    override_id:
+      name: Override ID
+      description: The override to delete.
+      required: true
+      selector:
+        number:
+          mode: box
+
+export_history_csv:
+  name: Export history CSV
+  description: Export completion history as CSV. Not implemented until Feature 13.
+
+manage_child:
+  name: Manage child
+  description: Create, edit, activate or reorder child profiles.
+  fields:
+    action:
+      name: Action
+      description: create, edit, set_active, or reorder.
+      required: true
+      selector:
+        select:
+          options:
+            - create
+            - edit
+            - set_active
+            - reorder
+    child_id:
+      name: Child ID
+      description: Required for edit and set_active.
+      required: false
+      selector:
+        number:
+          mode: box
+    display_name:
+      name: Display name
+      description: Required for create; optional for edit.
+      required: false
+      selector:
+        text:
+    colour:
+      name: Colour
+      description: Optional colour string.
+      required: false
+      selector:
+        text:
+    avatar_ref:
+      name: Avatar
+      description: Optional avatar reference.
+      required: false
+      selector:
+        text:
+    sort_order:
+      name: Sort order
+      description: Optional panel sort order.
+      required: false
+      selector:
+        number:
+          mode: box
+    is_active:
+      name: Active
+      description: Required for set_active.
+      required: false
+      selector:
+        boolean:
+    ordered_ids:
+      name: Ordered IDs
+      description: Complete permutation of child ids. Required for reorder.
+      required: false
+      selector:
+        object:

custom_components/nestquest/sse.py

@@ -1,172 +0,0 @@
-"""HA-bus subscription over the API service's panel SSE stream.
-
-The NestQuest API service (Feature 16) publishes every quest
-transition on ``GET /api/v1/panel/events`` as Server-Sent Events
-frames.  This module is the integration-side subscriber: ONE
-background task consumes :meth:`~.api_client.NestQuestApiClient
-.stream_events` and re-fires each frame on ``hass.bus`` with the SAME
-event type and payload fields the local transition path
-(:mod:`~.events`) emits — ``nestquest_quest_completed``,
-``nestquest_quest_uncompleted``, ``nestquest_quest_missed`` and
-``nestquest_child_day_complete`` — so the four blueprints fire
-identically whether a completion happens through the integration's own
-service or through the API service's panel route.
-
-Failure handling: a failed stream (API down, network blip, non-2xx, a
-dropped connection) is retried FOREVER with a bounded exponential
-backoff — :data:`RECONNECT_MIN_SECONDS` after the first failure,
-doubling up to :data:`RECONNECT_MAX_SECONDS` — so a long API outage
-neither pins the event loop nor spams the log, and a frame received on
-a healthy stream resets the backoff.  Nothing escapes the task: every
-failure is logged with its reason and the loop reconnects; a
-:class:`asyncio.CancelledError` (from :meth:`stop` or integration
-unload) is the only thing that ends it, and it stops cleanly — no
-frame fires after :meth:`stop` returns and the response is closed.
-"""
-from __future__ import annotations
-
-import asyncio
-from typing import Any
-
-from .const import LOGGER
-
-__all__ = [
-    "NestQuestEventStream",
-    "RECONNECT_MAX_SECONDS",
-    "RECONNECT_MIN_SECONDS",
-]
-
-#: Delay before the FIRST reconnect attempt after a stream failure.
-#: One failed frame must not turn into a hot reconnect loop.
-RECONNECT_MIN_SECONDS = 5.0
-
-#: Ceiling for the exponential reconnect backoff: a long API outage
-#: retries at a calm fixed cadence instead of growing without bound.
-RECONNECT_MAX_SECONDS = 60.0
-
-
-class NestQuestEventStream:
-    """Consume the panel SSE stream in the background, fire the HA bus.
-
-    ONE instance per config entry, built in integration setup with the
-    SAME API client the coordinator polls (the client is stateless —
-    one shared session, one connection pool).  ``start()`` schedules
-    the background task; ``stop()`` cancels and awaits it, so unload
-    never leaks the task and no frame fires after teardown.  The task
-    itself is failure-proof: any exception from the stream (typed
-    :class:`~.api_client.NestQuestApiError` or anything else) is
-    logged and retried after the current backoff, never allowed to
-    escape the task.
-    """
-
-    def __init__(
-        self,
-        hass: Any,
-        client: Any,
-        *,
-        reconnect_min_seconds: float = RECONNECT_MIN_SECONDS,
-        reconnect_max_seconds: float = RECONNECT_MAX_SECONDS,
-    ) -> None:
-        """Store the hass bus target, the API client, and the backoff.
-
-        The client is anything exposing ``stream_events()`` (the real
-        :class:`~.api_client.NestQuestApiClient` in production, a stub
-        in tests).  The backoff bounds must be positive and the minimum
-        must not exceed the maximum — a misconfiguration should fail
-        loudly at construction, not quietly reconnect at delay 0.
-        """
-        if (
-            not isinstance(reconnect_min_seconds, (int, float))
-            or isinstance(reconnect_min_seconds, bool)
-            or reconnect_min_seconds <= 0
-            or reconnect_min_seconds > reconnect_max_seconds
-        ):
-            raise ValueError(
-                "reconnect_min_seconds must be a positive number no "
-                f"greater than reconnect_max_seconds, got "
-                f"{reconnect_min_seconds!r}"
-            )
-        if (
-            not isinstance(reconnect_max_seconds, (int, float))
-            or isinstance(reconnect_max_seconds, bool)
-            or reconnect_max_seconds <= 0
-        ):
-            raise ValueError(
-                f"reconnect_max_seconds must be a positive number, got "
-                f"{reconnect_max_seconds!r}"
-            )
-        self._hass = hass
-        self._client = client
-        self._min_backoff = float(reconnect_min_seconds)
-        self._max_backoff = float(reconnect_max_seconds)
-        self._backoff = float(reconnect_min_seconds)
-        self._task: asyncio.Task | None = None
-
-    @property
-    def task(self) -> asyncio.Task | None:
-        """The background task, or ``None`` when never started/stopped."""
-        return self._task
-
-    def start(self) -> None:
-        """Schedule the subscription task (idempotent while it runs)."""
-        if self._task is not None and not self._task.done():
-            return
-        self._backoff = self._min_backoff
-        self._task = asyncio.create_task(
-            self._run(), name="nestquest-sse-subscription"
-        )
-
-    async def stop(self) -> None:
-        """Cancel and await the subscription task.
-
-        Returns only after the task has actually finished, so unload
-        can rely on: no further frame is fired after ``stop()``, and
-        the underlying stream response has been closed.  Safe to call
-        when the task was never started or already stopped.
-        """
-        task, self._task = self._task, None
-        if task is None:
-            return
-        task.cancel()
-        try:
-            await task
-        except asyncio.CancelledError:
-            # The task's own cancellation surfaces here — expected and
-            # swallowed; a cancelling the CALLER would re-raise out of
-            # the surrounding await on its own.
-            pass
-
-    async def _run(self) -> None:
-        """Consume stream frames forever, reconnecting on failure."""
-        while True:
-            try:
-                async for event_type, payload in self._client.stream_events():
-                    # A frame arrived on a healthy stream: the next
-                    # failure reconnects quickly again.
-                    self._backoff = self._min_backoff
-                    try:
-                        self._hass.bus.async_fire(event_type, dict(payload))
-                    except Exception as err:
-                        # Firing one frame must never tear down a
-                        # healthy connection: log and keep consuming.
-                        LOGGER.error(
-                            "NestQuest panel event %s could not be fired "
-                            "on the Home Assistant event bus: %s",
-                            event_type,
-                            err,
-                        )
-            except asyncio.CancelledError:
-                # Unload / shutdown: stop cleanly, never converted.
-                raise
-            except Exception as err:
-                delay = self._backoff
-                self._backoff = min(
-                    self._backoff * 2, self._max_backoff
-                )
-                LOGGER.warning(
-                    "NestQuest panel event stream failed (%s); "
-                    "reconnecting in %.1f s",
-                    err,
-                    delay,
-                )
-                await asyncio.sleep(delay)

custom_components/nestquest/store.py

@@ -0,0 +1,32 @@
+"""Re-export of :mod:`custom_components.nestquest.core.store` for the integration package.
+
+The path resolver lives in
+:mod:`custom_components.nestquest.core.store` (extracted in task
+d0b691d8) and is Home-Assistant-free:
+:func:`custom_components.nestquest.core.store.async_get_db_path`
+takes the full database path.  This module re-exports it and provides
+the original ``async_get_db_path(hass)`` signature so the integration
+resolves the path from ``hass.config.path`` exactly as before.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+from homeassistant.core import HomeAssistant
+
+from .core.const import SQLITE_DB_FILENAME
+from .core.store import async_get_db_path as _core_async_get_db_path
+from .core.store import _ensure_dir
+
+__all__ = ["async_get_db_path", "_ensure_dir"]
+
+
+async def async_get_db_path(hass: HomeAssistant) -> Path:
+    """Return the absolute path to the NestQuest SQLite database file.
+
+    Resolves the database file from ``hass.config.path`` and delegates to
+    :func:`custom_components.nestquest.core.store.async_get_db_path`,
+    which ensures the parent directory exists off the event loop via
+    :func:`asyncio.to_thread`.
+    """
+    return await _core_async_get_db_path(hass.config.path(SQLITE_DB_FILENAME))

custom_components/nestquest/strings.json

@@ -18,19 +18,23 @@
     "step": {
       "init": {
         "title": "NestQuest Settings",
-        "description": "Adjust how the NestQuest API client polls and reaches the NestQuest API service.",
+        "description": "Adjust how NestQuest plans, rolls over days, idles its panel, and reaches the NestQuest API service.",
         "data": {
+          "horizon_days": "Generation horizon (days)",
+          "day_rollover_time": "Day rollover time (HH:MM)",
           "panel_idle_timeout": "Panel idle timeout (seconds)",
-          "snapshot_staleness": "Last-good snapshot staleness (seconds)",
           "api_base_url": "NestQuest API base URL (http://host:port)",
-          "panel_token": "Panel service token"
+          "panel_token": "Panel service token",
+          "admin_user_ids": "Admin users (parents)"
         }
       }
     },
     "errors": {
       "invalid": "Invalid value.",
+      "invalid_time": "Time must use 24-hour HH:MM format.",
       "invalid_url": "Enter the API base URL as a full http:// or https:// URL with a host.",
-      "invalid_staleness": "Last-good snapshot staleness must be at least the update interval."
+      "no_admins": "Select at least one admin user; an empty allowlist would lock everyone out.",
+      "invalid_admin": "Invalid admin selection."
     }
   }
 }

custom_components/nestquest/sweep.py

@@ -0,0 +1,72 @@
+"""The nightly missed-quest sweep (Feature 11) — the Home Assistant shim.
+
+The sweep's policy is the HA-free core's :mod:`~.core.sweep`: the
+watermark read → ``list_missed_unswept`` query → payload build →
+watermark span, all inside the per-database sweep lock, shared with
+the API plane.  This module is the integration's thin adapter over it:
+at the configured day-rollover time (the same HA-local listener that
+re-materializes the rolling horizon) and once at setup it calls the
+core's :func:`~.core.sweep.run_missed_sweep` and fires each returned
+event on ``hass.bus`` — ONE ``nestquest_quest_missed`` per past-due
+open instance with the documented payload.  The core never touches
+Home Assistant; the firing lives here.
+
+Idempotency is the core's watermark: after a run, ``nestquest_meta_state``
+records the HA-local date the sweep ran, and the next run only sweeps
+instances due in ``[watermark, today)`` — a second run the same night
+fires nothing new, and a run after days of downtime sweeps exactly the
+accumulated window once.  An instance swept as missed that is later
+completed simply gains its completion event; the sweep is read-only
+over the domain tables (``missed`` is derived state, never an
+event_type — Feature 08's contract).
+"""
+from __future__ import annotations
+
+import datetime
+import logging
+from zoneinfo import ZoneInfo
+
+from .core.sweep import (
+    SWEEP_WATERMARK_KEY,
+    run_missed_sweep as _run_core_missed_sweep,
+)
+from .db import NestQuestDatabase
+
+LOGGER = logging.getLogger(__name__)
+
+__all__ = ["SWEEP_WATERMARK_KEY", "run_missed_sweep"]
+
+
+async def run_missed_sweep(
+    hass,
+    database: NestQuestDatabase,
+    *,
+    today: datetime.date | None = None,
+) -> int:
+    """Fire one missed event per unswept past-due open instance.
+
+    ``today`` optionally pins the HA-local date (threaded like the
+    materialization and completion layers); when omitted it is read
+    from ``hass.config.time_zone``.  Returns the number of events
+    fired.  Fires nothing and returns 0 when the watermark already
+    covers ``today`` (a same-night rerun) — the watermark read, the
+    query, the payload build and the watermark write all live in the
+    core's locked
+    :func:`~.core.sweep.run_missed_sweep`; this shim only fires each
+    returned event on the bus and counts them.
+    """
+    today_date = (
+        today
+        if today is not None
+        else datetime.datetime.now(ZoneInfo(hass.config.time_zone)).date()
+    )
+    events = await _run_core_missed_sweep(database, today=today_date)
+    for event_type, payload in events:
+        hass.bus.async_fire(event_type, payload)
+    fired = len(events)
+    LOGGER.info(
+        "NestQuest missed sweep for %s fired %d event(s)",
+        today_date.isoformat(),
+        fired,
+    )
+    return fired

custom_components/nestquest/translations/en.json

@@ -18,19 +18,23 @@
     "step": {
       "init": {
         "title": "NestQuest Settings",
-        "description": "Adjust how the NestQuest API client polls and reaches the NestQuest API service.",
+        "description": "Adjust how NestQuest plans, rolls over days, idles its panel, and reaches the NestQuest API service.",
         "data": {
+          "horizon_days": "Generation horizon (days)",
+          "day_rollover_time": "Day rollover time (HH:MM)",
           "panel_idle_timeout": "Panel idle timeout (seconds)",
-          "snapshot_staleness": "Last-good snapshot staleness (seconds)",
           "api_base_url": "NestQuest API base URL (http://host:port)",
-          "panel_token": "Panel service token"
+          "panel_token": "Panel service token",
+          "admin_user_ids": "Admin users (parents)"
         }
       }
     },
     "errors": {
       "invalid": "Invalid value.",
+      "invalid_time": "Time must use 24-hour HH:MM format.",
       "invalid_url": "Enter the API base URL as a full http:// or https:// URL with a host.",
-      "invalid_staleness": "Last-good snapshot staleness must be at least the update interval."
+      "no_admins": "Select at least one admin user; an empty allowlist would lock everyone out.",
+      "invalid_admin": "Invalid admin selection."
     }
   }
 }

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.

frontend/package-lock.json

@@ -9,197 +9,10 @@
         "lit": "^3.3.0"
       },
       "devDependencies": {
-        "jsdom": "^30.1.1",
         "typescript": "^5.9.2",
         "vite": "^7.1.5"
       }
     },
-    "node_modules/@asamuzakjp/css-color": {
-      "version": "7.0.1",
-      "resolved": "https://registry.npmjs.org/@asamuzakjp/css-color/-/css-color-7.0.1.tgz",
-      "integrity": "sha512-C9duntabagkBZ1LebM7FKmphR4Q1pBclLxVbZETQV0akkFjV0ooFxo8FlvAQyKj9F6l8rEnmidgcTlpyxFYizg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@csstools/css-calc": "^3.4.0",
-        "@csstools/css-color-parser": "^4.2.3",
-        "@csstools/css-parser-algorithms": "^4.0.0",
-        "@csstools/css-tokenizer": "^4.0.1",
-        "lru-cache": "^11.5.3"
-      },
-      "engines": {
-        "node": "^22.22.2 || ^24.15.0 || >=26.0.0"
-      }
-    },
-    "node_modules/@asamuzakjp/dom-selector": {
-      "version": "9.2.1",
-      "resolved": "https://registry.npmjs.org/@asamuzakjp/dom-selector/-/dom-selector-9.2.1.tgz",
-      "integrity": "sha512-NT4s3yZLjovPpliRpTvdsdzyPjqRqiCZj9MxnarBihbaY5MbAG7DWAJcrLlhmC7xKTNCXsTELcqB8YsqpLnUFQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "bidi-js": "^1.1.0",
-        "css-tree": "^3.2.1",
-        "is-potential-custom-element-name": "^1.0.1",
-        "lru-cache": "^11.5.3"
-      },
-      "engines": {
-        "node": "^22.22.2 || ^24.15.0 || >=26.0.0"
-      }
-    },
-    "node_modules/@bramus/specificity": {
-      "version": "2.4.2",
-      "resolved": "https://registry.npmjs.org/@bramus/specificity/-/specificity-2.4.2.tgz",
-      "integrity": "sha512-ctxtJ/eA+t+6q2++vj5j7FYX3nRu311q1wfYH3xjlLOsczhlhxAg2FWNUXhpGvAw3BWo1xBcvOV6/YLc2r5FJw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "css-tree": "^3.0.0"
-      },
-      "bin": {
-        "specificity": "bin/cli.js"
-      }
-    },
-    "node_modules/@csstools/color-helpers": {
-      "version": "6.1.1",
-      "resolved": "https://registry.npmjs.org/@csstools/color-helpers/-/color-helpers-6.1.1.tgz",
-      "integrity": "sha512-gLNsunvwf3mCi5u5o46/Z/JcJMnhbHSaZ69rkgPzNM3J4s8hWwpPUQB6/tt0EDFyCiWzxANlx+2LJwpYj4zS1w==",
-      "dev": true,
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/csstools"
-        },
-        {
-          "type": "opencollective",
-          "url": "https://opencollective.com/csstools"
-        }
-      ],
-      "license": "MIT-0",
-      "engines": {
-        "node": ">=20.19.0"
-      }
-    },
-    "node_modules/@csstools/css-calc": {
-      "version": "3.4.0",
-      "resolved": "https://registry.npmjs.org/@csstools/css-calc/-/css-calc-3.4.0.tgz",
-      "integrity": "sha512-XQKj5B7QiZcHiegCOCAzcAOJdhGgWOHbbu62h5e5mkHnn8lWcfiJhllkqWmxu5zWR9jucPHuo1iTB56P033hcg==",
-      "dev": true,
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/csstools"
-        },
-        {
-          "type": "opencollective",
-          "url": "https://opencollective.com/csstools"
-        }
-      ],
-      "license": "MIT",
-      "engines": {
-        "node": ">=20.19.0"
-      },
-      "peerDependencies": {
-        "@csstools/css-parser-algorithms": "^4.0.0",
-        "@csstools/css-tokenizer": "^4.0.0"
-      }
-    },
-    "node_modules/@csstools/css-color-parser": {
-      "version": "4.2.3",
-      "resolved": "https://registry.npmjs.org/@csstools/css-color-parser/-/css-color-parser-4.2.3.tgz",
-      "integrity": "sha512-y4LpL+lmpuyKDiEFq2PnZUVFdAjsoB/qQJod79yLNokXyW7jewi+/WJ69EfItj8A2unWtxXnGjw6LYXgXu5ZjA==",
-      "dev": true,
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/csstools"
-        },
-        {
-          "type": "opencollective",
-          "url": "https://opencollective.com/csstools"
-        }
-      ],
-      "license": "MIT",
-      "dependencies": {
-        "@csstools/color-helpers": "^6.1.1",
-        "@csstools/css-calc": "^3.4.0"
-      },
-      "engines": {
-        "node": ">=20.19.0"
-      },
-      "peerDependencies": {
-        "@csstools/css-parser-algorithms": "^4.0.0",
-        "@csstools/css-tokenizer": "^4.0.0"
-      }
-    },
-    "node_modules/@csstools/css-parser-algorithms": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/@csstools/css-parser-algorithms/-/css-parser-algorithms-4.0.0.tgz",
-      "integrity": "sha512-+B87qS7fIG3L5h3qwJ/IFbjoVoOe/bpOdh9hAjXbvx0o8ImEmUsGXN0inFOnk2ChCFgqkkGFQ+TpM5rbhkKe4w==",
-      "dev": true,
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/csstools"
-        },
-        {
-          "type": "opencollective",
-          "url": "https://opencollective.com/csstools"
-        }
-      ],
-      "license": "MIT",
-      "engines": {
-        "node": ">=20.19.0"
-      },
-      "peerDependencies": {
-        "@csstools/css-tokenizer": "^4.0.0"
-      }
-    },
-    "node_modules/@csstools/css-syntax-patches-for-csstree": {
-      "version": "1.1.14",
-      "resolved": "https://registry.npmjs.org/@csstools/css-syntax-patches-for-csstree/-/css-syntax-patches-for-csstree-1.1.14.tgz",
-      "integrity": "sha512-HpbVXyrofRXpHpgkNIjU/3EWR4WJvOkO3emNK/L6X/mTJU7bGUI3AkkpoTNXznQLp0KRjLHELTGeKI5dIkI9JQ==",
-      "dev": true,
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/csstools"
-        },
-        {
-          "type": "opencollective",
-          "url": "https://opencollective.com/csstools"
-        }
-      ],
-      "license": "MIT-0",
-      "peerDependencies": {
-        "css-tree": "^3.2.1"
-      },
-      "peerDependenciesMeta": {
-        "css-tree": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/@csstools/css-tokenizer": {
-      "version": "4.0.1",
-      "resolved": "https://registry.npmjs.org/@csstools/css-tokenizer/-/css-tokenizer-4.0.1.tgz",
-      "integrity": "sha512-bPlN9S9O1A0euCpEWE4qnvB5YDuyYVsUTrxSgmAM1Is0j4tICHoVyOVAXfWMP/kS9ZrjvyIXWV2PmomiAXXqOw==",
-      "dev": true,
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/csstools"
-        },
-        {
-          "type": "opencollective",
-          "url": "https://opencollective.com/csstools"
-        }
-      ],
-      "license": "MIT",
-      "engines": {
-        "node": ">=20.19.0"
-      }
-    },
     "node_modules/@esbuild/aix-ppc64": {
       "version": "0.28.2",
       "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.28.2.tgz",
@@ -642,24 +455,6 @@
         "node": ">=18"
       }
     },
-    "node_modules/@exodus/bytes": {
-      "version": "1.16.0",
-      "resolved": "https://registry.npmjs.org/@exodus/bytes/-/bytes-1.16.0.tgz",
-      "integrity": "sha512-IcpW84uEn3N7ETtNZMlxKhfl6Pec8rUNGOTBtWbK1FKhJxIFAptZyVrvVRVBimAJxJCgc3PxepxkdWWG4DVzfA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
-      },
-      "peerDependencies": {
-        "@noble/hashes": "^1.8.0 || ^2.0.0"
-      },
-      "peerDependenciesMeta": {
-        "@noble/hashes": {
-          "optional": true
-        }
-      }
-    },
     "node_modules/@lit-labs/ssr-dom-shim": {
       "version": "1.6.0",
       "resolved": "https://registry.npmjs.org/@lit-labs/ssr-dom-shim/-/ssr-dom-shim-1.6.0.tgz",
@@ -1097,79 +892,6 @@
       "integrity": "sha512-ScaPdn1dQczgbl0QFTeTOmVHFULt394XJgOQNoyVhZ6r2vLnMLJfBPd53SB52T/3G36VI1/g2MZaX0cwDuXsfw==",
       "license": "MIT"
     },
-    "node_modules/bidi-js": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/bidi-js/-/bidi-js-1.1.0.tgz",
-      "integrity": "sha512-fX1Onk0tdVPC7obPWB5EbJ1z7NVhLq4m2xZLq2YXBkxzMXIGRpNMU88n0EPgWseKl12J7zXs7qrDxPK4sRs2fg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "require-from-string": "^2.0.2"
-      }
-    },
-    "node_modules/css-tree": {
-      "version": "3.2.1",
-      "resolved": "https://registry.npmjs.org/css-tree/-/css-tree-3.2.1.tgz",
-      "integrity": "sha512-X7sjQzceUhu1u7Y/ylrRZFU2FS6LRiFVp6rKLPg23y3x3c3DOKAwuXGDp+PAGjh6CSnCjYeAul8pcT8bAl+lSA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "mdn-data": "2.27.1",
-        "source-map-js": "^1.2.1"
-      },
-      "engines": {
-        "node": "^10 || ^12.20.0 || ^14.13.0 || >=15.0.0"
-      }
-    },
-    "node_modules/data-urls": {
-      "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/data-urls/-/data-urls-7.0.0.tgz",
-      "integrity": "sha512-23XHcCF+coGYevirZceTVD7NdJOqVn+49IHyxgszm+JIiHLoB2TkmPtsYkNWT1pvRSGkc35L6NHs0yHkN2SumA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "whatwg-mimetype": "^5.0.0",
-        "whatwg-url": "^16.0.0"
-      },
-      "engines": {
-        "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
-      }
-    },
-    "node_modules/data-urls/node_modules/whatwg-url": {
-      "version": "16.0.1",
-      "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-16.0.1.tgz",
-      "integrity": "sha512-1to4zXBxmXHV3IiSSEInrreIlu02vUOvrhxJJH5vcxYTBDAx51cqZiKdyTxlecdKNSjj8EcxGBxNf6Vg+945gw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@exodus/bytes": "^1.11.0",
-        "tr46": "^6.0.0",
-        "webidl-conversions": "^8.0.1"
-      },
-      "engines": {
-        "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
-      }
-    },
-    "node_modules/decimal.js": {
-      "version": "10.6.0",
-      "resolved": "https://registry.npmjs.org/decimal.js/-/decimal.js-10.6.0.tgz",
-      "integrity": "sha512-YpgQiITW3JXGntzdUmyUR1V812Hn8T1YVXhCu+wO3OpS4eU9l4YdD3qjyiKdV6mvV29zapkMeD390UVEf2lkUg==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/entities": {
-      "version": "8.1.0",
-      "resolved": "https://registry.npmjs.org/entities/-/entities-8.1.0.tgz",
-      "integrity": "sha512-kxL7msIffSuh9aaFAMD7rxAIuTRMAHMeBtgHW2yUdWw732ZNh4MehkF2gdjvtdmikkaIP9bFDDJOPlsvm7avrA==",
-      "dev": true,
-      "license": "BSD-2-Clause",
-      "engines": {
-        "node": ">=20.19.0"
-      },
-      "funding": {
-        "url": "https://github.com/fb55/entities?sponsor=1"
-      }
-    },
     "node_modules/esbuild": {
       "version": "0.28.2",
       "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.28.2.tgz",
@@ -1245,66 +967,6 @@
         "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
       }
     },
-    "node_modules/html-encoding-sniffer": {
-      "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/html-encoding-sniffer/-/html-encoding-sniffer-7.0.0.tgz",
-      "integrity": "sha512-UikN5yr7xsCDAq87Or5or0PAlD3HJJOKVzM05az588WnpDJ4Ux7a2A53Qi6gofGg2/EtvF/H4hCi/TXfCW4Y6w==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@exodus/bytes": "^1.15.1"
-      },
-      "engines": {
-        "node": "^22.13.0 || >=24.0.0"
-      }
-    },
-    "node_modules/is-potential-custom-element-name": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/is-potential-custom-element-name/-/is-potential-custom-element-name-1.0.1.tgz",
-      "integrity": "sha512-bCYeRA2rVibKZd+s2625gGnGF/t7DSqDs4dP7CrLA1m7jKWz6pps0LpYLJN8Q64HtmPKJ1hrN3nzPNKFEKOUiQ==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/jsdom": {
-      "version": "30.1.1",
-      "resolved": "https://registry.npmjs.org/jsdom/-/jsdom-30.1.1.tgz",
-      "integrity": "sha512-FahmoPK5vbPc+jxV1iErMHmAZypCZ942NHF4+qqaWAuvaKKTBZxawnmAtrbGWLU7MtlxfqIP0qw6aSI+aWGtLg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@asamuzakjp/css-color": "^7.0.0",
-        "@asamuzakjp/dom-selector": "^9.2.1",
-        "@bramus/specificity": "^2.4.2",
-        "@csstools/css-syntax-patches-for-csstree": "^1.1.13",
-        "@exodus/bytes": "^1.15.1",
-        "css-tree": "^3.2.1",
-        "data-urls": "^7.0.0",
-        "decimal.js": "^10.6.0",
-        "html-encoding-sniffer": "^7.0.0",
-        "is-potential-custom-element-name": "^1.0.1",
-        "lru-cache": "^11.5.2",
-        "parse5": "^8.0.1",
-        "saxes": "^6.0.0",
-        "tough-cookie": "^6.0.2",
-        "undici": "^8.10.2",
-        "w3c-xmlserializer": "^6.0.0",
-        "webidl-conversions": "^8.0.1",
-        "whatwg-mimetype": "^5.0.0",
-        "whatwg-url": "^17.1.1",
-        "xml-name-validator": "^5.0.0"
-      },
-      "engines": {
-        "node": "^22.22.2 || ^24.15.0 || >=26.0.0"
-      },
-      "peerDependencies": {
-        "canvas": "^3.2.3"
-      },
-      "peerDependenciesMeta": {
-        "canvas": {
-          "optional": true
-        }
-      }
-    },
     "node_modules/lit": {
       "version": "3.3.3",
       "resolved": "https://registry.npmjs.org/lit/-/lit-3.3.3.tgz",
@@ -1336,23 +998,6 @@
         "@types/trusted-types": "^2.0.2"
       }
     },
-    "node_modules/lru-cache": {
-      "version": "11.5.3",
-      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.5.3.tgz",
-      "integrity": "sha512-U4N8FgzmWxc8k1VH8Kr6lQg18U7Fjvby6wXHVRX/ZZ7IwWbRMgrRbP0Wrb5q5NVinryp4SQampHKdvtecItxUg==",
-      "dev": true,
-      "license": "BlueOak-1.0.0",
-      "engines": {
-        "node": "20 || >=22"
-      }
-    },
-    "node_modules/mdn-data": {
-      "version": "2.27.1",
-      "resolved": "https://registry.npmjs.org/mdn-data/-/mdn-data-2.27.1.tgz",
-      "integrity": "sha512-9Yubnt3e8A0OKwxYSXyhLymGW4sCufcLG6VdiDdUGVkPhpqLxlvP5vl1983gQjJl3tqbrM731mjaZaP68AgosQ==",
-      "dev": true,
-      "license": "CC0-1.0"
-    },
     "node_modules/nanoid": {
       "version": "3.3.19",
       "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.19.tgz",
@@ -1372,19 +1017,6 @@
         "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
       }
     },
-    "node_modules/parse5": {
-      "version": "8.0.1",
-      "resolved": "https://registry.npmjs.org/parse5/-/parse5-8.0.1.tgz",
-      "integrity": "sha512-z1e/HMG90obSGeidlli3hj7cbocou0/wa5HacvI3ASx34PecNjNQeaHNo5WIZpWofN9kgkqV1q5YvXe3F0FoPw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "entities": "^8.0.0"
-      },
-      "funding": {
-        "url": "https://github.com/inikulin/parse5?sponsor=1"
-      }
-    },
     "node_modules/picocolors": {
       "version": "1.1.1",
       "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
@@ -1434,26 +1066,6 @@
         "node": "^10 || ^12 || >=14"
       }
     },
-    "node_modules/punycode": {
-      "version": "2.3.1",
-      "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz",
-      "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/require-from-string": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/require-from-string/-/require-from-string-2.0.2.tgz",
-      "integrity": "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
     "node_modules/rollup": {
       "version": "4.63.4",
       "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.63.4.tgz",
@@ -1500,19 +1112,6 @@
         "fsevents": "~2.3.2"
       }
     },
-    "node_modules/saxes": {
-      "version": "6.0.0",
-      "resolved": "https://registry.npmjs.org/saxes/-/saxes-6.0.0.tgz",
-      "integrity": "sha512-xAg7SOnEhrm5zI3puOOKyy1OMcMlIJZYNJY7xLBwSze0UjhPLnWfj2GF2EpT0jmzaJKIWKHLsaSSajf35bcYnA==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "xmlchars": "^2.2.0"
-      },
-      "engines": {
-        "node": ">=v12.22.7"
-      }
-    },
     "node_modules/source-map-js": {
       "version": "1.2.1",
       "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",
@@ -1540,52 +1139,6 @@
         "url": "https://github.com/sponsors/SuperchupuDev"
       }
     },
-    "node_modules/tldts": {
-      "version": "7.4.14",
-      "resolved": "https://registry.npmjs.org/tldts/-/tldts-7.4.14.tgz",
-      "integrity": "sha512-EahQoi+Q5oqmG3yxRHx+bwn36OaLbtw6jnTFcGjc8fcmktzTgk45xRnzAx8Ch87PFEiqRhoc3FWBmY+LBrvEGQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "tldts-core": "^7.4.14"
-      },
-      "bin": {
-        "tldts": "bin/cli.js"
-      }
-    },
-    "node_modules/tldts-core": {
-      "version": "7.4.14",
-      "resolved": "https://registry.npmjs.org/tldts-core/-/tldts-core-7.4.14.tgz",
-      "integrity": "sha512-KYkjfJHnIC5t+Gy7hPrMHgJmWc/N9FfmS+fggRPSlpFckidpB9HD6OzPsSTkfDH+MpZgcu2tJPGgLfHl979N1Q==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/tough-cookie": {
-      "version": "6.0.2",
-      "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-6.0.2.tgz",
-      "integrity": "sha512-exgYmnmL/sJpR3upZfXG5PoatXQii55xAiXGXzY+sROLZ/Y+SLcp9PgJNI9Vz37HpQ74WvDcLT8eqm+kV3FzrA==",
-      "dev": true,
-      "license": "BSD-3-Clause",
-      "dependencies": {
-        "tldts": "^7.0.5"
-      },
-      "engines": {
-        "node": ">=16"
-      }
-    },
-    "node_modules/tr46": {
-      "version": "6.0.0",
-      "resolved": "https://registry.npmjs.org/tr46/-/tr46-6.0.0.tgz",
-      "integrity": "sha512-bLVMLPtstlZ4iMQHpFHTR7GAGj2jxi8Dg0s2h2MafAE4uSWF98FC/3MomU51iQAMf8/qDUbKWf5GxuvvVcXEhw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "punycode": "^2.3.1"
-      },
-      "engines": {
-        "node": ">=20"
-      }
-    },
     "node_modules/typescript": {
       "version": "5.9.3",
       "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz",
@@ -1600,16 +1153,6 @@
         "node": ">=14.17"
       }
     },
-    "node_modules/undici": {
-      "version": "8.11.0",
-      "resolved": "https://registry.npmjs.org/undici/-/undici-8.11.0.tgz",
-      "integrity": "sha512-AdzuGcAkzhbha3GgCSoUBx2P0quwym6qdFNCQz/fDGZc8w9XJ741wHUbt2kTmfPz+ZIOMkySFkiY7RXmiDDC8w==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=22.19.0"
-      }
-    },
     "node_modules/vite": {
       "version": "7.3.6",
       "resolved": "https://registry.npmjs.org/vite/-/vite-7.3.6.tgz",
@@ -1684,71 +1227,6 @@
           "optional": true
         }
       }
-    },
-    "node_modules/w3c-xmlserializer": {
-      "version": "6.0.0",
-      "resolved": "https://registry.npmjs.org/w3c-xmlserializer/-/w3c-xmlserializer-6.0.0.tgz",
-      "integrity": "sha512-4Nsy8K5Tr6SPDH9jhKJOHf7ChDrc1zufZTVSF7x72hwuEXBqxqk9G6cK+K2NRUtB3iELRJqjXb4JPDMBjMTl2Q==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "xml-name-validator": "^5.0.0"
-      },
-      "engines": {
-        "node": "^22.22.2 || ^24.15.0 || >=26.0.0"
-      }
-    },
-    "node_modules/webidl-conversions": {
-      "version": "8.0.1",
-      "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-8.0.1.tgz",
-      "integrity": "sha512-BMhLD/Sw+GbJC21C/UgyaZX41nPt8bUTg+jWyDeg7e7YN4xOM05YPSIXceACnXVtqyEw/LMClUQMtMZ+PGGpqQ==",
-      "dev": true,
-      "license": "BSD-2-Clause",
-      "engines": {
-        "node": ">=20"
-      }
-    },
-    "node_modules/whatwg-mimetype": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/whatwg-mimetype/-/whatwg-mimetype-5.0.0.tgz",
-      "integrity": "sha512-sXcNcHOC51uPGF0P/D4NVtrkjSU2fNsm9iog4ZvZJsL3rjoDAzXZhkm2MWt1y+PUdggKAYVoMAIYcs78wJ51Cw==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=20"
-      }
-    },
-    "node_modules/whatwg-url": {
-      "version": "17.1.2",
-      "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-17.1.2.tgz",
-      "integrity": "sha512-TEZA+Zqxin7Jjsm2cjRohCmen5awh+hT6Zi3VZdqZlNRk7zvOI/9WpBFg/DWlA56bWnzwm6DuB8NS0EsxQH9uQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@exodus/bytes": "^1.15.1",
-        "tr46": "^6.0.0",
-        "webidl-conversions": "^8.0.1"
-      },
-      "engines": {
-        "node": "^22.14.0 || >=24.0.0"
-      }
-    },
-    "node_modules/xml-name-validator": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/xml-name-validator/-/xml-name-validator-5.0.0.tgz",
-      "integrity": "sha512-EvGK8EJ3DhaHfbRlETOWAS5pO9MZITeauHKJyb8wyajUfQUenkIg2MvLDTZ4T/TgIcm3HU0TFBgWWboAZ30UHg==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/xmlchars": {
-      "version": "2.2.0",
-      "resolved": "https://registry.npmjs.org/xmlchars/-/xmlchars-2.2.0.tgz",
-      "integrity": "sha512-JZnDKK8B0RCDw84FNdDAIpZK+JuJw+s7Lz8nksI7SIuU3UXJJslUthsi+uWBUYOwPFwW7W7PRLRfUKpxjtjFCw==",
-      "dev": true,
-      "license": "MIT"
     }
   }
 }

frontend/package.json

@@ -9,7 +9,6 @@
     "lit": "^3.3.0"
   },
   "devDependencies": {
-    "jsdom": "^30.1.1",
     "typescript": "^5.9.2",
     "vite": "^7.1.5"
   }

frontend/src/cards/party-board.ts

@@ -143,16 +143,6 @@ function asNumber(value: unknown, fallback: number): number {
   return Number.isFinite(parsed) ? parsed : fallback;
 }
 
-/** The slug a discovered roster entry carries, or "" when the entry is
- *  not an object with a non-empty slug string. */
-function asRosterSlug(entry: unknown): string {
-  if (entry === null || typeof entry !== "object" || Array.isArray(entry)) {
-    return "";
-  }
-  const slug = (entry as Record<string, unknown>).slug;
-  return typeof slug === "string" ? slug.trim() : "";
-}
-
 function clampPercent(value: number): number {
   if (!Number.isFinite(value)) {
     return 0;
@@ -902,34 +892,15 @@ export class NestQuestPartyBoardCard extends LitElement {
       return [];
     }
     const order = this._config.child_order;
-    if (Array.isArray(order)) {
-      return order
-        .filter(
-          (entry): entry is string =>
-            typeof entry === "string" && entry.trim().length > 0
-        )
-        .map((entry) => entry.trim());
-    }
-    return this._discoveredChildSlugs();
-  }
-
-  /** Zero-config discovery (Feature 20): the ordered child roster the
-   *  integration publishes on the household rollup
-   *  (custom_components/nestquest/sensor.py — ``child_roster``, the
-   *  snapshot's sort_order, then id), each entry carrying the slug the
-   *  per-child entity ids are built from.  Consulted only when the
-   *  config has no child_order — explicit configuration wins. */
-  private _discoveredChildSlugs(): string[] {
-    const household = this._state(
-      "sensor.nestquest_household_quests_due_today"
-    );
-    const roster = household?.attributes?.child_roster;
-    if (!Array.isArray(roster)) {
+    if (!Array.isArray(order)) {
       return [];
     }
-    return roster
-      .map((entry) => asRosterSlug(entry))
-      .filter((slug) => slug.length > 0);
+    return order
+      .filter(
+        (entry): entry is string =>
+          typeof entry === "string" && entry.trim().length > 0
+      )
+      .map((entry) => entry.trim());
   }
 
   private _plates(): ChildPlate[] {

frontend/src/nestquest-cards.ts

@@ -1,7 +1,6 @@
 import "./cards/party-board";
 import "./cards/quest-log";
 import "./cards/admin";
-import "./strategy";
 
 const FONTS_HREF = "/nestquest-static/nestquest-fonts.css";
 if (!document.querySelector('link[data-nq-fonts=""]')) {

frontend/src/strategy.ts

@@ -1,161 +0,0 @@
-import type { HassLike } from "./types";
-
-type StateObject = {
-  state: unknown;
-  attributes?: Record<string, unknown> | null;
-};
-
-type RosterEntry = {
-  name: string;
-  slug: string;
-};
-
-type View = {
-  path?: string;
-  title?: string;
-  type: string;
-  cards: Record<string, unknown>[];
-};
-
-type LovelaceConfig = {
-  views: View[];
-};
-
-type StrategyConfig = Record<string, unknown>;
-
-type StrategyClass = {
-  generate: (
-    config: StrategyConfig,
-    hass: HassLike | undefined
-  ) => Promise<LovelaceConfig>;
-};
-
-declare global {
-  interface Window {
-    customStrategies?: Record<string, StrategyClass>;
-  }
-}
-
-function asString(value: unknown): string {
-  return typeof value === "string" ? value.trim() : "";
-}
-
-/** The slug a discovered roster entry carries, or "" when the entry is
- *  not an object with a non-empty slug string — the same shape check
- *  the party board applies to the same attribute. */
-function asRosterSlug(entry: unknown): string {
-  if (entry === null || typeof entry !== "object" || Array.isArray(entry)) {
-    return "";
-  }
-  const slug = (entry as Record<string, unknown>).slug;
-  return typeof slug === "string" ? slug.trim() : "";
-}
-
-/** The dashboard's URL path segment, used to COMPUTE the card paths the
- *  navigation needs.  A dashboard lives at a single top-level segment
- *  (/<url_path>), so the first pathname segment is the dashboard root —
- *  this is where the strategy renders, and navigating back to it shows
- *  the first view (the party board).  An explicit ``url_path`` in the
- *  strategy configuration wins for setups that need to pin it. */
-function dashboardUrlPath(config: StrategyConfig): string {
-  const configured = asString(config.url_path).replace(/^\/+|\/+$/g, "");
-  if (configured) {
-    return configured;
-  }
-  const segment = window.location.pathname.split("/").filter(Boolean)[0];
-  return segment ?? "";
-}
-
-/** The display name a roster entry carries, or "" when it is not a
- *  non-empty string — the roster's ``name`` field (sensor.py
- *  ``_child_roster``), used for the quest-log view titles. */
-function asRosterName(entry: unknown): string {
-  if (entry === null || typeof entry !== "object" || Array.isArray(entry)) {
-    return "";
-  }
-  const name = (entry as Record<string, unknown>).name;
-  return typeof name === "string" ? name.trim() : "";
-}
-
-/** The ordered child roster the integration publishes on the household
- *  rollup (custom_components/nestquest/sensor.py — ``child_roster``,
- *  the snapshot's sort_order, then id).  The same source the party
- *  board's plate discovery reads, consumed here at render time so the
- *  quest-log views exist for exactly the active children. */
-function rosterEntries(hass: HassLike | undefined): RosterEntry[] {
-  const states = hass?.states as Record<string, StateObject> | undefined;
-  const household = states?.["sensor.nestquest_household_quests_due_today"];
-  const roster = household?.attributes?.child_roster;
-  if (!Array.isArray(roster)) {
-    return [];
-  }
-  return roster
-    .map((entry) => ({ slug: asRosterSlug(entry), name: asRosterName(entry) }))
-    .filter((entry) => entry.slug.length > 0);
-}
-
-/**
- * Zero-config NestQuest dashboard strategy (Feature 20).
- *
- * A dashboard configured with ``strategy: { type: custom:nestquest-party }``
- * gets its views GENERATED at render time from the household roster: one
- * party-board view (the dashboard root) and one quest-log view per child,
- * ordered by the roster's sort_order.  The paths the cards navigate by are
- * COMPUTED, not configured:
- *
- * - the board's ``quest_log_path`` is the dashboard root; tapping a crest
- *   pushes ``<root>/<slug>`` (party-board.ts ``_openQuestLog``);
- * - each log view's ``path`` IS the child's slug, so the log resolves its
- *   child from the last pathname segment (quest-log.ts
- *   ``childSlugFromPath``) and its ``board_path`` back to the dashboard
- *   root (quest-log.ts ``_returnToBoard``).
- *
- * With zero children the board view still renders — the board card shows
- * its own "not set up yet" notice for an empty roster, so no log views are
- * needed.  ``url_path`` and ``weather_entity`` may still be set explicitly
- * in the strategy configuration; everything else is derived.
- */
-export class NestQuestPartyStrategy {
-  static async generate(
-    config: StrategyConfig,
-    hass: HassLike | undefined
-  ): Promise<LovelaceConfig> {
-    const root = `/${dashboardUrlPath(config)}`;
-    const weatherEntity = asString(config.weather_entity);
-    const boardCard: Record<string, unknown> = {
-      type: "custom:nestquest-party-board-card",
-      quest_log_path: root,
-    };
-    if (weatherEntity) {
-      boardCard.weather_entity = weatherEntity;
-    }
-    const logCard: Record<string, unknown> = {
-      type: "custom:nestquest-quest-log-card",
-      board_path: root,
-    };
-    if (weatherEntity) {
-      logCard.weather_entity = weatherEntity;
-    }
-    return {
-      views: [
-        {
-          path: "party",
-          title: "The Party",
-          type: "panel",
-          cards: [boardCard],
-        },
-        ...rosterEntries(hass).map<View>((entry) => ({
-          path: entry.slug,
-          title: entry.name
-            ? `${entry.name}'s Quest Log`
-            : `${entry.slug}'s Quest Log`,
-          type: "panel",
-          cards: [{ ...logCard }],
-        })),
-      ],
-    };
-  }
-}
-
-window.customStrategies = window.customStrategies ?? {};
-window.customStrategies["nestquest-party"] = NestQuestPartyStrategy;

frontend/tests/render-party-board.mjs

@@ -1,80 +0,0 @@
-/**
- * Render the built party-board card under jsdom and print its plates.
- *
- * Usage: node render-party-board.mjs < spec.json
- *
- * The spec JSON carries {bundle, tag, config, hass, url?, click_plate?};
- * stdout receives one JSON object {plates, tappable, location, html} where
- * plates is the ordered plate list the shadow DOM renders (name +
- * present/away/unknown kind), tappable the plate names rendered as tappable
- * <button> plates, and location the window pathname after the optional plate
- * tap. The Python panel tests drive this harness so the assertions run
- * against the exact bundle HACS ships.
- */
-import { readFileSync } from "node:fs";
-import { pathToFileURL } from "node:url";
-import { JSDOM } from "jsdom";
-
-const spec = JSON.parse(readFileSync(0, "utf8"));
-
-const dom = new JSDOM("<!doctype html><html><body></body></html>", {
-  url: spec.url ?? "http://homeassistant.local/nestquest/board",
-  pretendToBeVisual: true,
-});
-
-// Expose the jsdom globals the Lit bundle expects. Node's own intrinsics
-// (Object, Array, ...) are kept — only what globalThis lacks is copied.
-for (const key of Object.getOwnPropertyNames(dom.window)) {
-  if (!(key in globalThis)) {
-    try {
-      globalThis[key] = dom.window[key];
-    } catch {
-      // jsdom getters may throw on access; the card does not need them.
-    }
-  }
-}
-globalThis.window = dom.window;
-// The card navigates by dispatching new Event("location-changed") on this
-// window; jsdom's EventTarget rejects Node's own global Event class, so the
-// jsdom Event must shadow it for the dispatched event to be delivered.
-globalThis.Event = dom.window.Event;
-
-await import(pathToFileURL(spec.bundle).href);
-
-const element = document.createElement(spec.tag);
-element.setConfig(spec.config);
-element.hass = spec.hass;
-document.body.appendChild(element);
-await element.updateComplete;
-
-const plateNodes = [
-  ...element.shadowRoot.querySelectorAll(".plates .plate"),
-];
-const plates = plateNodes.map((plate) => ({
-  name: plate.querySelector(".name")?.textContent?.trim() ?? "",
-  kind: plate.classList.contains("unknown")
-    ? "unknown"
-    : plate.classList.contains("away")
-      ? "away"
-      : "present",
-}));
-const tappable = plateNodes
-  .filter((plate) => plate.tagName === "BUTTON")
-  .map((plate) => plate.querySelector(".name")?.textContent?.trim() ?? "");
-
-if (spec.click_plate !== undefined) {
-  const plate = plateNodes.find(
-    (candidate) =>
-      candidate.querySelector(".name")?.textContent?.trim() === spec.click_plate
-  );
-  plate?.click();
-}
-
-const payload = JSON.stringify({
-  plates,
-  tappable,
-  location: window.location.pathname,
-  html: element.shadowRoot.innerHTML,
-});
-await new Promise((resolve) => process.stdout.write(payload, () => resolve()));
-process.exit(0);

frontend/tests/render-quest-log.mjs

@@ -1,73 +0,0 @@
-/**
- * Render the built quest-log card under jsdom and report its location.
- *
- * Usage: node render-quest-log.mjs < spec.json
- *
- * The spec JSON carries {bundle, url, config, hass, idle_ms?, probe_ms?};
- * the card is mounted at the given URL (it resolves its child from the
- * pathname's last segment), after the optional probe wait one snapshot of
- * the render is taken mid-wait, then after the optional idle wait stdout
- * receives one JSON object {location, headline, countdown, html, probe} —
- * the final window pathname, the rendered title, the complete-screen
- * countdown text, the rendered shadow DOM, and the probe snapshot when
- * probe_ms was given. The Python panel tests drive this harness so the
- * assertions run against the exact bundle HACS ships.
- */
-import { readFileSync } from "node:fs";
-import { pathToFileURL } from "node:url";
-import { JSDOM } from "jsdom";
-
-const spec = JSON.parse(readFileSync(0, "utf8"));
-
-const dom = new JSDOM("<!doctype html><html><body></body></html>", {
-  url: spec.url ?? "http://homeassistant.local/nestquest/ada",
-  pretendToBeVisual: true,
-});
-
-// Expose the jsdom globals the Lit bundle expects. Node's own intrinsics
-// (Object, Array, ...) are kept — only what globalThis lacks is copied.
-for (const key of Object.getOwnPropertyNames(dom.window)) {
-  if (!(key in globalThis)) {
-    try {
-      globalThis[key] = dom.window[key];
-    } catch {
-      // jsdom getters may throw on access; the card does not need them.
-    }
-  }
-}
-globalThis.window = dom.window;
-// The card navigates by dispatching new Event("location-changed") on this
-// window; jsdom's EventTarget rejects Node's own global Event class, so the
-// jsdom Event must shadow it for the return navigation to be delivered.
-globalThis.Event = dom.window.Event;
-
-await import(pathToFileURL(spec.bundle).href);
-
-const element = document.createElement("nestquest-quest-log-card");
-element.setConfig(spec.config);
-element.hass = spec.hass;
-document.body.appendChild(element);
-await element.updateComplete;
-
-const snapshot = () => ({
-  location: window.location.pathname,
-  headline: element.shadowRoot.querySelector(".title")?.textContent?.trim() ?? "",
-  countdown:
-    element.shadowRoot.querySelector(".complete-countdown")?.textContent?.trim() ??
-    "",
-  html: element.shadowRoot.innerHTML,
-});
-
-let probe = null;
-if (spec.probe_ms !== undefined) {
-  await new Promise((resolve) => setTimeout(resolve, spec.probe_ms));
-  probe = snapshot();
-}
-
-if (spec.idle_ms !== undefined) {
-  await new Promise((resolve) => setTimeout(resolve, spec.idle_ms));
-}
-
-const payload = JSON.stringify({ ...snapshot(), probe });
-await new Promise((resolve) => process.stdout.write(payload, () => resolve()));
-process.exit(0);

frontend/tests/render-strategy.mjs

@@ -1,48 +0,0 @@
-/**
- * Import the built bundle into jsdom and generate the dashboard strategy's
- * views.
- *
- * Usage: node render-strategy.mjs < spec.json
- *
- * The spec JSON carries {bundle, url, config, hass}; stdout receives one
- * JSON object {views} — the strategy output's views array with the paths
- * and card configs the generated dashboard renders.  The Python panel
- * tests drive this harness so the assertions run against the exact bundle
- * HACS ships.
- */
-import { readFileSync } from "node:fs";
-import { pathToFileURL } from "node:url";
-import { JSDOM } from "jsdom";
-
-const spec = JSON.parse(readFileSync(0, "utf8"));
-
-const dom = new JSDOM("<!doctype html><html><body></body></html>", {
-  url: spec.url ?? "http://homeassistant.local/nestquest/party",
-  pretendToBeVisual: true,
-});
-
-// Expose the jsdom globals the Lit bundle expects. Node's own intrinsics
-// (Object, Array, ...) are kept — only what globalThis lacks is copied.
-for (const key of Object.getOwnPropertyNames(dom.window)) {
-  if (!(key in globalThis)) {
-    try {
-      globalThis[key] = dom.window[key];
-    } catch {
-      // jsdom getters may throw on access; the strategy does not need them.
-    }
-  }
-}
-globalThis.window = dom.window;
-
-await import(pathToFileURL(spec.bundle).href);
-
-const strategy = window.customStrategies?.["nestquest-party"];
-if (!strategy) {
-  console.error("nestquest-party strategy is not registered on the bundle");
-  process.exit(1);
-}
-
-const lovelace = await strategy.generate(spec.config, spec.hass);
-const payload = JSON.stringify({ views: lovelace.views });
-await new Promise((resolve) => process.stdout.write(payload, () => resolve()));
-process.exit(0);

orchestration_tests/test_cycle_prompt.py

@@ -51,36 +51,6 @@ class CyclePromptTests(unittest.TestCase):
         self.assertNotIn("The persistent user service runs", output)
         self.assertNotIn("---\n\n---\n\n# 27", output)
 
-    def test_task_complete_feature_triggers_one_guarded_promotion(self):
-        output = RENDER(TEMPLATE, PROFILE)
-        self.assertIn(
-            "feature becomes task-complete and its reviewed merge into `dev` is verified",
-            output,
-        )
-        self.assertIn("Every required feature task is `done`", output)
-        self.assertIn("No task review, remediation, approval, or merge remains pending", output)
-        self.assertIn("feature acceptance criteria and integrated checks pass", output)
-        self.assertIn("Independent approval applies to the exact feature head", output)
-        self.assertIn("approver's merge of that head into `dev` is verified", output)
-        self.assertIn("reflects the completed feature and exact repository references", output)
-        self.assertIn("Task completion inside an unmerged feature branch does not trigger", output)
-        self.assertIn("Do not create a duplicate promotion", output)
-        self.assertIn("Allow only one active promotion pull request to `main`", output)
-        self.assertIn("if it was closed without merge, recalculate", output)
-        self.assertIn("sole active orchestrator for the project", output)
-        self.assertIn("including controller exclusivity, reconciliation", output)
-        self.assertIn("RELEASE_PREPARATION_POLICY = EXCLUDED", output)
-        self.assertIn("Active promotion branch and pull request", output)
-        self.assertIn("An active promotion that has not reached `RELEASE_READY`", output)
-        self.assertIn("RELEASE_PREPARATION_POLICY:\n", output)
-        self.assertIn("A ready promotion is a local checkpoint", output)
-        self.assertIn("continue that work while the ready promotion waits", output)
-        self.assertLess(
-            output.index("Begin an automatically triggered, requested, or scheduled release"),
-            output.index("Advance to the next eligible feature"),
-        )
-        self.assertIn("Only Joshua may merge into `main`", output)
-
 
 if __name__ == "__main__":
     unittest.main()

orchestration_tests/test_nq_orchestrate.py

@@ -1,5 +1,4 @@
 from pathlib import Path
-import fcntl
 import os
 import subprocess
 import tempfile
@@ -48,7 +47,6 @@ class ForegroundLauncherTests(unittest.TestCase):
                 "NQ_PROJECT_ROOT": str(project),
                 "OPENCODE_BIN": str(opencode),
                 "SYSTEMCTL_BIN": str(systemctl),
-                "NQ_STATE_DIR": str(root / "state"),
             })
             printed = subprocess.run([str(SCRIPT), "--print-prompt"], env=env,
                                      text=True, capture_output=True)
@@ -69,16 +67,6 @@ class ForegroundLauncherTests(unittest.TestCase):
                              ["--check-interactive", "--project", str(project)])
 
             output.unlink()
-            lock_path = root / "state/controller.lock"
-            with lock_path.open("w") as held_lock:
-                fcntl.flock(held_lock, fcntl.LOCK_EX | fcntl.LOCK_NB)
-                locked = subprocess.run([str(SCRIPT)], env=env, text=True,
-                                        capture_output=True)
-                self.assertEqual(locked.returncode, 75)
-                self.assertIn("Another NestQuest orchestrator or controller",
-                              locked.stderr)
-                self.assertFalse(output.exists())
-
             open_marker.touch()
             refused = subprocess.run([str(SCRIPT)], env=env, text=True,
                                      capture_output=True)

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"
@@ -21,7 +21,6 @@ dev = [
     "pytest>=8.0.0",
     "pytest-asyncio>=0.24",
     "pyyaml>=6",
-    "unidecode>=1.4.0",
     "uvicorn>=0.30",
     "voluptuous>=0.14",
 ]

scripts/nq-orchestrate

@@ -11,7 +11,6 @@ control_home=${NQ_CONTROL_HOME:-/home/overseer/.local/share/nestquest-controller
 project=${NQ_PROJECT_ROOT:-/mnt/ai-storage/projects/NestQuest}
 opencode_bin=${OPENCODE_BIN:-/home/overseer/.opencode/bin/opencode}
 systemctl_bin=${SYSTEMCTL_BIN:-systemctl}
-state_dir=${NQ_STATE_DIR:-/home/overseer/.local/state/nestquest-controller}
 renderer="$control_home/scripts/render-cycle-prompt"
 profile="$control_home/templates/nestquest.profile.json"
 
@@ -42,17 +41,6 @@ fi
 # Foreground mode owns orchestration. A dormant service must never race it.
 "$systemctl_bin" --user stop nestquest-controller.service
 
-# Share the controller's lock and hold it across the final exec. This closes
-# the launch-time race between two foreground sessions as well as the race with
-# the background controller.
-mkdir -p "$state_dir"
-chmod 700 "$state_dir"
-exec 9>"$state_dir/controller.lock"
-if ! flock -n 9; then
-  echo "Another NestQuest orchestrator or controller is running." >&2
-  exit 75
-fi
-
 session_status=$("$control_home/scripts/nq-controller" --check-interactive --project "$project")
 if [[ "$session_status" == "interactive NestQuest session open" ]]; then
   echo "Another interactive NestQuest OpenCode session is open." >&2

templates/ORCHESTRATOR-PROMPT.template.md

@@ -150,15 +150,6 @@ Possible scopes:
 - `PROJECT_QUEUE`
 - `RELEASE_PREPARATION`
 
-Also set `RELEASE_PREPARATION_POLICY` at startup:
-
-- `AUTO` by default.
-- `EXCLUDED` only when the user's launch request explicitly says not to prepare
-  a release or `{{INTEGRATION_BRANCH}}`-to-`{{RELEASE_BRANCH}}` promotion.
-
-Record both `MISSION_SCOPE` and `RELEASE_PREPARATION_POLICY` in durable run
-state. Do not infer exclusion merely from `SINGLE_TASK` or `SINGLE_FEATURE`.
-
 If the user explicitly names one task or feature, respect that scope.
 
 If the user launches the orchestrator for general/autonomous {{PROJECT_NAME}} development without limiting it to one feature, use:
@@ -180,7 +171,6 @@ Maintain a durable orchestration checkpoint using {{WORK_TRACKER}} wherever its
 Track at minimum:
 
 - `MISSION_SCOPE`
-- `RELEASE_PREPARATION_POLICY`
 - Current feature
 - Current controller phase
 - Active development agents
@@ -195,9 +185,6 @@ Track at minimum:
 - Blocked items
 - Tests/checks status
 - Last verified repository state
-- Active promotion branch and pull request
-- Triggering feature and exact `{{INTEGRATION_BRANCH}}` commit for each automatic promotion
-- Completed features pending the next promotion
 - `NEXT_ACTION`
 
 After every material state transition:
@@ -267,8 +254,8 @@ Choose the highest-priority actionable transition in this order:
 8. Remediate feature-level review findings.
 9. Obtain feature approval.
 10. Merge an approved feature into `{{INTEGRATION_BRANCH}}`.
-11. Begin an automatically triggered, requested, or scheduled release when appropriate. The automatic post-feature trigger is in scope for both `SINGLE_FEATURE` and `PROJECT_QUEUE` unless `RELEASE_PREPARATION_POLICY = EXCLUDED`.
-12. Advance to the next eligible feature when mission scope permits.
+11. Advance to the next eligible feature when mission scope permits.
+12. Begin a requested/scheduled release when appropriate.
 13. Continue unrelated work around locally blocked items.
 14. Escalate only when the defined escalation rules require it.
 
@@ -601,10 +588,9 @@ Immediately transition to `FEATURE_INTEGRATION`.
 
 A merged feature is a transition.
 
-It is terminal only when `MISSION_SCOPE = SINGLE_FEATURE` and no authorized
-post-feature release transition is pending. Preparing the automatic promotion
-for that completed feature is part of `SINGLE_FEATURE` scope when
-`RELEASE_PREPARATION_POLICY = AUTO`.
+It is terminal ONLY when:
+
+`MISSION_SCOPE = SINGLE_FEATURE`
 
 Otherwise select the next eligible work.
 
@@ -651,19 +637,13 @@ The orchestrator itself does not perform the merge.
 When `MISSION_SCOPE = PROJECT_QUEUE` and a feature is successfully merged into `{{INTEGRATION_BRANCH}}`:
 
 1. Reconcile {{WORK_TRACKER}}.
-2. Evaluate the automatic, requested, and scheduled release triggers.
+2. Check for a requested/scheduled release.
 3. Identify remaining incomplete features.
 4. Determine which features are eligible based on dependencies and priority.
 5. Select the next eligible feature.
 6. Initialize it.
 7. Continue the development loop.
 
-If an automatic promotion becomes `RELEASE_READY` while another eligible
-feature remains, keep that promotion waiting for {{RELEASE_OWNER_NAME}} and
-continue the project queue. A ready promotion is a local checkpoint in this
-case, not a global terminal condition. Features completed while it remains open
-are recorded as pending for the next promotion under Section 18.
-
 Do not return to the user simply because one feature completed.
 
 If several features are available, choose using:
@@ -678,52 +658,27 @@ If several features are available, choose using:
 
 # 18. RELEASE RULES
 
-Completed features accumulate in `{{INTEGRATION_BRANCH}}`. With no active
-promotion, each verified feature completion starts release preparation. While
-one promotion is active, later completed features accumulate for the next
-promotion.
+Completed features accumulate in `{{INTEGRATION_BRANCH}}`.
 
-Prepare a release when any of these conditions is true:
+Prepare a release only when:
 
 - {{RELEASE_OWNER_NAME}} requests it; OR
-- {{WORK_TRACKER}} schedules it; OR
-- `RELEASE_PREPARATION_POLICY = AUTO`, and a feature becomes task-complete and its reviewed merge into `{{INTEGRATION_BRANCH}}` is verified.
-
-For the automatic trigger, a feature is task-complete only when:
-
-- Every required feature task is `done`, or deliberately `canceled` with recorded evidence.
-- No task review, remediation, approval, or merge remains pending.
-- The feature acceptance criteria and integrated checks pass.
-- Independent approval applies to the exact feature head.
-- The approver's merge of that head into `{{INTEGRATION_BRANCH}}` is verified.
-- {{WORK_TRACKER}} reflects the completed feature and exact repository references.
-
-Task completion inside an unmerged feature branch does not trigger a release.
-The verified feature-to-`{{INTEGRATION_BRANCH}}` merge is the triggering transition.
-
-Before creating a release branch or pull request:
-
-1. Verify this session is the sole active orchestrator for the project. `{{TERMINAL_LAUNCHER}}` enforces that exclusivity by holding the shared controller lock for the full foreground session. If that lock is not held by this session, do not create a release branch or pull request; escalate instead.
-2. Reconcile open release records, release branches, and promotion pull requests.
-3. Do not create a duplicate promotion for an already-covered `{{INTEGRATION_BRANCH}}` commit.
-4. Allow only one active promotion pull request to `{{RELEASE_BRANCH}}`. If an earlier promotion is still open and does not contain the newly completed feature, record the feature as pending for the next automatic promotion. Resume it after the active promotion is merged or closed; if it was closed without merge, recalculate the next promotion from the current validated `{{INTEGRATION_BRANCH}}` head.
-5. Record the triggering feature and exact `{{INTEGRATION_BRANCH}}` commit so the automatic trigger runs once for that merge.
+- {{WORK_TRACKER}} schedules it.
 
 Release process:
 
-1. Enforce every pre-creation requirement above, including controller exclusivity, reconciliation, duplicate and active-promotion checks, and trigger recording.
-2. Reconcile release scope.
-3. Confirm included features are complete.
-4. Create release branch from exact validated `{{INTEGRATION_BRANCH}}`.
-5. Run complete release checks.
-6. Open release PR → `{{RELEASE_BRANCH}}`.
-7. Obtain fresh independent {{REVIEWER_VENDOR}} review.
-8. Remediate findings through development agents.
-9. Incorporate every release correction back into `{{INTEGRATION_BRANCH}}`.
-10. Revalidate.
-11. Assign final release PR to `{{HOST_ACCOUNT}}`.
-12. Update {{WORK_TRACKER}}.
-13. Stop before {{RELEASE_BRANCH}} merge.
+1. Reconcile release scope.
+2. Confirm included features are complete.
+3. Create release branch from exact validated `{{INTEGRATION_BRANCH}}`.
+4. Run complete release checks.
+5. Open release PR → `{{RELEASE_BRANCH}}`.
+6. Obtain fresh independent {{REVIEWER_VENDOR}} review.
+7. Remediate findings through development agents.
+8. Incorporate every release correction back into `{{INTEGRATION_BRANCH}}`.
+9. Revalidate.
+10. Assign final release PR to `{{HOST_ACCOUNT}}`.
+11. Update {{WORK_TRACKER}}.
+12. Stop before {{RELEASE_BRANCH}} merge.
 
 Only {{RELEASE_OWNER_NAME}} may merge into `{{RELEASE_BRANCH}}`.
 
@@ -769,23 +724,13 @@ For `PROJECT_QUEUE`, this additionally requires:
 
 - No eligible incomplete feature remains.
 - No task/review/remediation/merge is pending.
-- No release preparation, release review, or release remediation is pending.
-- Every in-scope automatic trigger is either incorporated into the active
-  `RELEASE_READY` promotion or durably recorded for the next promotion.
 - No development agent is active.
 - No approver is active.
 
-An active promotion that has not reached `RELEASE_READY` makes
-`MISSION_COMPLETE` false.
-
 ## `RELEASE_READY`
 
 Release PR has passed required gates and is assigned to `{{HOST_ACCOUNT}}`, awaiting {{RELEASE_OWNER_NAME}}'s {{RELEASE_BRANCH}} merge.
 
-`RELEASE_READY` is globally terminal only when no other in-scope engineering
-action is executable. In `PROJECT_QUEUE`, if another eligible incomplete
-feature remains, continue that work while the ready promotion waits.
-
 ## `GLOBAL_ESCALATION`
 
 All remaining in-scope work is blocked by decisions/access that require {{RELEASE_OWNER_NAME}}.
@@ -833,12 +778,9 @@ Output a machine-readable continuation checkpoint:
 ```text
 ORCHESTRATOR_STATE: CONTINUE
 MISSION_SCOPE:
-RELEASE_PREPARATION_POLICY:
 CONTROLLER_PHASE:
 CURRENT_FEATURE:
 ACTIVE_TASKS:
-ACTIVE_PROMOTION:
-PENDING_PROMOTION_FEATURES:
 BLOCKED_ITEMS:
 LAST_VERIFIED_STATE:
 NEXT_ACTION:

tests/conftest.py

@@ -22,22 +22,19 @@ pytest -q``); it is never meant to run against a real HA install.
 from __future__ import annotations
 
 import asyncio
+import datetime
 import importlib.util
 import inspect
-import re
 import sys
 import tempfile
-import unicodedata
 import weakref
 from dataclasses import dataclass
-from html.entities import name2codepoint
 from pathlib import Path
 from types import SimpleNamespace
 from unittest.mock import AsyncMock, MagicMock
 
 import httpx
 import pytest
-from unidecode import unidecode as _unidecode
 
 from tests.admin_jwt_harness import ADMIN_KEY, KID, AdminRunner, jwks_for
 
@@ -50,7 +47,6 @@ _HA_MODULES = (
     "homeassistant.config_entries",
     "homeassistant.data_entry_flow",
     "homeassistant.exceptions",
-    "homeassistant.util",
     "homeassistant.helpers",
     "homeassistant.helpers.config_validation",
     "homeassistant.helpers.entity",
@@ -99,7 +95,6 @@ for _parent, _child in (
     ("homeassistant", "data_entry_flow"),
     ("homeassistant", "core"),
     ("homeassistant", "exceptions"),
-    ("homeassistant", "util"),
     ("homeassistant", "helpers"),
     ("homeassistant.helpers", "config_validation"),
     ("homeassistant.helpers", "entity"),
@@ -224,68 +219,6 @@ _exceptions_mock.ConfigEntryNotReady = ConfigEntryNotReady
 _exceptions_mock.Unauthorized = Unauthorized
 
 
-# ---------------------------------------------------------------------------
-# homeassistant.util.slugify: a faithful stand-in for the real slugifier.
-#
-# Real HA (2024.6) wraps python-slugify's frozen legacy pipeline and answers
-# its "unknown" sentinel when a non-empty name slugs to nothing.  The stub
-# mirrors that pipeline step for step — quotes to dashes, NFKD-normalize,
-# TRANSLITERATE through unidecode (the backend python-slugify's "auto" mode
-# prefers, and a dev dependency here), decode HTML entities, NFKD again,
-# lowercase, drop quotes, fold runs of non-[a-z0-9-] to one dash, collapse
-# and strip dashes, then map dashes to the requested separator — and was
-# verified byte-for-byte against real python-slugify across Latin, Cyrillic,
-# CJK and Greek household-name shapes.  Transliteration is the point: HA
-# derives the per-child entity ids from a name like "京子" as
-# "nestquest_jing_zi_…", so the roster's slugs must transliterate too,
-# never dropping characters into "unknown".  Deliberately NOT truncating:
-# real slugify caps nothing; the entity registry truncates the full
-# entity_id instead.
-# ---------------------------------------------------------------------------
-_HA_QUOTE_PATTERN = re.compile(r"[']+")
-_HA_CHAR_ENTITY_PATTERN = re.compile(r"&(%s);" % "|".join(name2codepoint))
-_HA_DECIMAL_PATTERN = re.compile(r"&#(\d+);")
-_HA_HEX_PATTERN = re.compile(r"&#x([\da-fA-F]+);")
-_HA_NUMBERS_PATTERN = re.compile(r"(?<=\d),(?=\d)")
-_HA_DISALLOWED_CHARS_PATTERN = re.compile(r"[^-a-zA-Z0-9]+")
-_HA_DUPLICATE_DASH_PATTERN = re.compile(r"-{2,}")
-
-
-def _ha_slugify(text: str | None, *, separator: str = "_") -> str:
-    """Faithful homeassistant.util.slugify stand-in (see section above)."""
-    if text == "" or text is None:
-        return ""
-    text = str(text)
-    text = _HA_QUOTE_PATTERN.sub("-", text)
-    text = unicodedata.normalize("NFKD", text)
-    text = _unidecode(text)
-    text = _HA_CHAR_ENTITY_PATTERN.sub(
-        lambda match: chr(name2codepoint[match.group(1)]), text
-    )
-    try:
-        text = _HA_DECIMAL_PATTERN.sub(
-            lambda match: chr(int(match.group(1))), text
-        )
-    except (ValueError, OverflowError):
-        pass
-    try:
-        text = _HA_HEX_PATTERN.sub(
-            lambda match: chr(int(match.group(1), 16)), text
-        )
-    except (ValueError, OverflowError):
-        pass
-    text = unicodedata.normalize("NFKD", text)
-    text = text.lower()
-    text = _HA_QUOTE_PATTERN.sub("", text)
-    text = _HA_NUMBERS_PATTERN.sub("", text)
-    text = _HA_DISALLOWED_CHARS_PATTERN.sub("-", text)
-    text = _HA_DUPLICATE_DASH_PATTERN.sub("-", text).strip("-")
-    return "unknown" if text == "" else text.replace("-", separator)
-
-
-_ha_mock("homeassistant.util").slugify = _ha_slugify
-
-
 @dataclass
 class DeviceInfo:
     """Stand-in for homeassistant.helpers.entity.DeviceInfo.
@@ -809,92 +742,89 @@ def wire_entry_to_registry(entry, registry: ListenerRegistry):
     return entry
 
 
-class StubSnapshotClient:
-    """A no-network stand-in for the API client's snapshot surface.
+class LazyLocalSnapshotClient:
+    """A test client that serves the snapshot built LOCALLY.
 
-    Answers ``get_snapshot()`` from a scripted queue of outcomes — a
-    payload dict or an exception per call, consumed in order — and
-    records every call.  When the queue is exhausted it re-serves the
-    last outcome, so setup's first refresh and a test's explicit
-    refreshes poll the same scripted state.  Register it (or any
-    scripted client) with :func:`set_coordinator_client` BEFORE setup.
+    Feature 18 moved the coordinator's refresh onto the API service's
+    panel snapshot, but most integration tests still seed the local
+    database directly (the DB removal is a later task).  This stub
+    bridges the two: ``get_snapshot`` resolves the entry's runtime
+    record (its database and settings) and runs the SAME pure core
+    builder the API route runs
+    (:func:`~custom_components.nestquest.core.snapshot.build_snapshot`),
+    shaping the payload exactly like ``api/routes_panel.py`` —
+    instances via ``instance_payload(include_missed=False)`` — so the
+    coordinator reconstructs from a byte-identical payload without any
+    network or FastAPI machinery.
+
+    The resolution is LAZY on purpose: the coordinator's factory runs
+    mid-setup, before the runtime record exists, so the first refresh
+    (and any refresh while the entry is torn down) serves an EMPTY but
+    valid snapshot; every later refresh reads the seeded database.
     """
 
-    def __init__(self, *outcomes) -> None:
+    def __init__(self, hass, entry_id: str) -> None:
+        self._hass = hass
+        self._entry_id = entry_id
         self.calls = 0
-        self._outcomes = list(outcomes)
-        self._last = outcomes[-1] if outcomes else None
-        #: The SSE frames the stand-in "published" (the API service's
-        # stream content), drained by :func:`refire_api_transitions`.
-        self.published_frames = []
 
     async def get_snapshot(self):
+        import datetime
+        import zoneinfo
+
+        from custom_components.nestquest.const import DOMAIN as NQ_DOMAIN
+        from custom_components.nestquest.core import snapshot as core_snapshot
+
         self.calls += 1
-        if not self._outcomes:
-            # Re-serve the last outcome: setup's first refresh and the
-            # test's explicit pass both poll the same scripted state.
-            outcome = self._last
-        else:
-            outcome = self._outcomes.pop(0)
-            self._last = outcome
-        if isinstance(outcome, BaseException):
-            raise outcome
-        return outcome
-
-
-class ScriptedPanelClient(StubSnapshotClient):
-    """Snapshot + completion stand-in for the API service's panel plane.
-
-    Serves the scripted snapshot outcomes (like
-    :class:`StubSnapshotClient`), records ``complete_instance`` calls
-    the way the panel route receives them, optionally fails them the
-    way the client types the failure, and carries the SSE frames the
-    API "published" in ``published_frames`` for
-    :func:`refire_api_transitions` to deliver.  Everything the
-    integration reads over the wire, no network.
-    """
-
-    def __init__(self, *outcomes) -> None:
-        super().__init__(*outcomes)
-        self.complete_calls: list[tuple[int, int]] = []
-        self.published_frames: list[tuple[str, dict]] = []
-        #: When set, the next ``complete_instance`` raises this instead
-        # of succeeding (a typed NestQuestApiError in production).
-        self.fail_complete_with: BaseException | None = None
-
-    async def complete_instance(
-        self, instance_id: int, actor_child_id: int
-    ) -> dict:
-        self.complete_calls.append((instance_id, actor_child_id))
-        if self.fail_complete_with is not None:
-            raise self.fail_complete_with
-        return {"status": "done"}
-
-
-def set_coordinator_client(entry, client):
-    """Register a scripted client for ``entry``'s coordinator factory."""
-    import custom_components.nestquest.coordinator as coordinator_module
-
-    coordinator_module._COORDINATOR_CLIENT_OVERRIDES[entry.entry_id] = client
-    return client
+        runtime = self._hass.data.get(NQ_DOMAIN, {}).get(self._entry_id)
+        database = getattr(runtime, "database", None)
+        if database is None or not getattr(database, "connected", True):
+            return {
+                "today_iso": datetime.date.today().isoformat(),
+                "cycle_day": 0,
+                "children": [],
+            }
+        settings = getattr(runtime, "settings", None)
+        # The HA-LOCAL now, the same single clock read the production
+        # coordinator used to hand the builder: the hass stub's
+        # configured time zone, never the host clock.
+        now = datetime.datetime.now(
+            zoneinfo.ZoneInfo(self._hass.config.time_zone)
+        )
+        snapshot = await core_snapshot.build_snapshot(database, settings, now)
+        return {
+            "today_iso": snapshot.today_iso,
+            "cycle_day": snapshot.cycle_day,
+            "children": [
+                {
+                    "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": core_snapshot.instance_payload(
+                        child.instances, include_missed=False
+                    ),
+                }
+                for child in snapshot.children
+            ],
+        }
 
 
 @pytest.fixture(autouse=True)
-def coordinator_client_from_test_override():
-    """Resolve every entry's coordinator client through the test seam.
+def coordinator_serves_local_snapshot():
+    """Default every test entry's coordinator to the local-snapshot client.
 
     The integration's setup builds its API client through
-    ``coordinator_client_from_entry``; this fixture swaps that factory
-    for a test one handing out the client registered with
-    :func:`set_coordinator_client`, or — for an entry with no scripted
-    client — a stub serving an EMPTY but valid household snapshot (the
-    shape the API's panel route returns before any child exists; the
-    real client would need aiohttp, which this mock-only harness does
-    not provide).
+    ``coordinator_client_from_entry``; the fixture swaps that factory
+    for a test one handing out :class:`LazyLocalSnapshotClient` (so
+    DB-seeded tests exercise the coordinator's API path against local
+    data).  Tests that script their own client register it with
+    :func:`set_coordinator_client`, which the factory honours first.
     """
-    import datetime
-    import unittest.mock as mock
-
     import custom_components.nestquest as nq_mod
     import custom_components.nestquest.coordinator as coordinator_module
 
@@ -906,13 +836,9 @@ def coordinator_client_from_test_override():
         override = _COORDINATOR_CLIENT_OVERRIDES.get(entry.entry_id)
         if override is not None:
             return override
-        return StubSnapshotClient(
-            {
-                "today_iso": datetime.date.today().isoformat(),
-                "cycle_day": 0,
-                "children": [],
-            }
-        )
+        return LazyLocalSnapshotClient(hass, entry.entry_id)
+
+    import unittest.mock as mock
 
     _COORDINATOR_CLIENT_OVERRIDES.clear()
     patcher = mock.patch.object(
@@ -924,57 +850,12 @@ def coordinator_client_from_test_override():
     _COORDINATOR_CLIENT_OVERRIDES.clear()
 
 
-async def refire_api_transitions(hass, entry, client):
-    """Deliver the SSE frames the stand-in client has published so far
-    through the integration's SSE subscription — the production event
-    path.
+def set_coordinator_client(entry, client):
+    """Register a scripted client for ``entry``'s coordinator factory."""
+    import custom_components.nestquest.coordinator as coordinator_module
 
-    Since Feature 18 the ``complete_quest`` service fires no local
-    bus event: the API service builds and publishes the transition
-    frames on its SSE stream, and the integration's subscription
-    (:mod:`custom_components.nestquest.sse`) re-fires each frame on
-    the bus.  This helper streams the frames the stand-in client
-    published (``client.published_frames``) through a real
-    :class:`~custom_components.nestquest.sse.NestQuestEventStream`
-    and waits (bounded) until the bus has re-fired every one of them.
-    """
-    import asyncio
-
-    from custom_components.nestquest.sse import NestQuestEventStream
-
-    frames, client.published_frames = client.published_frames, []
-
-    class _ScriptedStream:
-        """A healthy stream: the frames, then it stays open."""
-
-        def __init__(self, frames) -> None:
-            self._frames = frames
-
-        def stream_events(self):
-            async def _gen():
-                for frame in self._frames:
-                    yield frame
-                await asyncio.Event().wait()
-
-            return _gen()
-
-    before = {etype: len(hass.bus.fired(etype)) for etype, _ in frames}
-    expected = len(frames)
-    manager = NestQuestEventStream(hass, _ScriptedStream(frames))
-    manager.start()
-    try:
-        async with asyncio.timeout(2):
-            while True:
-                delivered = sum(
-                    len(hass.bus.fired(etype)) - before[etype]
-                    for etype, _ in frames
-                )
-                if delivered >= expected:
-                    break
-                await asyncio.sleep(0.01)
-    finally:
-        await manager.stop()
-    return frames
+    coordinator_module._COORDINATOR_CLIENT_OVERRIDES[entry.entry_id] = client
+    return client
 
 
 class _HassNamespace(SimpleNamespace):
@@ -1200,6 +1081,42 @@ def make_config_flow_entry():
     return _factory
 
 
+def freeze_nestquest_clock(
+    monkeypatch, instant: datetime.datetime
+) -> tuple[datetime.datetime, list]:
+    """Freeze the integration's ``datetime`` clock to a fixed aware instant.
+
+    Only ``custom_components.nestquest``'s ``datetime`` binding is patched,
+    so the generation path's ``datetime.datetime.now`` reads this instant
+    (localized to whatever time zone it asks for) while every other module
+    and the test harness keep the real clock.  Returns ``(frozen, requested)``
+    where ``frozen`` is the instant normalized to UTC and ``requested`` is
+    the list of ``tzinfo`` objects the code under test passed to ``now`` —
+    so a caller can prove the generation path actually requested the
+    configured HA time zone rather than silently reading UTC.
+    """
+    import custom_components.nestquest as nestquest
+
+    frozen = instant.astimezone(datetime.timezone.utc)
+    requested: list = []
+
+    class _FrozenDatetime(datetime.datetime):
+        @classmethod
+        def now(cls, tz=None):
+            requested.append(tz)
+            if tz is None:
+                return frozen.replace(tzinfo=None)
+            return frozen.astimezone(tz)
+
+    fake_module = SimpleNamespace(
+        datetime=_FrozenDatetime,
+        timedelta=datetime.timedelta,
+        date=datetime.date,
+    )
+    monkeypatch.setattr(nestquest, "datetime", fake_module)
+    return frozen, requested
+
+
 # ---------------------------------------------------------------------------
 # Admin-plane API fixtures (shared by the admin-plane test modules).
 #

tests/test_admin_allowlist.py

@@ -1,18 +1,21 @@
-"""Tests for the Feature 03 admin allowlist business layer (core.admin_allowlist)."""
+"""Tests for admin_allowlist.py: the Feature 03 allowlist business layer."""
 from __future__ import annotations
 
 import asyncio
+from types import SimpleNamespace
 from unittest.mock import AsyncMock, MagicMock
 
 import pytest
 
-from custom_components.nestquest.core.admin_allowlist import (
+from custom_components.nestquest import async_setup_entry, async_unload_entry
+from custom_components.nestquest.admin_allowlist import (
     list_admin_ids,
     seed_setup_admin,
     set_admin_ids,
 )
-from custom_components.nestquest.core.db import NestQuestDatabase
-from custom_components.nestquest.core.migrations import apply_migrations
+from custom_components.nestquest.dao_children import AdminUsersDao
+from custom_components.nestquest.db import NestQuestDatabase
+from custom_components.nestquest.migrations import apply_migrations
 
 
 def _run(coro):
@@ -190,6 +193,165 @@ def test_seed_rejects_malformed_candidates(tmp_path) -> None:
 
 
 # ---------------------------------------------------------------------------
+# Setup wiring: async_setup_entry seeds automatically
+# ---------------------------------------------------------------------------
+
+
+async def _setup_entry(hass, entry, registry):
+    from tests.test_lifecycle import _wire
+
+    entry = _wire(entry, registry)
+    await async_setup_entry(hass, entry)
+    return entry
+
+
+async def test_setup_seeds_allowlist_from_entry_context(
+    hass, make_entry
+) -> None:
+    entry = await _setup_entry(
+        hass,
+        make_entry(context={"user_id": "ha-owner"}),
+        hass.registry,
+    )
+    database = entry.runtime_data.database
+    try:
+        assert await list_admin_ids(database) == ["ha-owner"]
+    finally:
+        await database.close()
+    assert await async_unload_entry(hass, entry) is True
+
+
+async def test_setup_seeds_allowlist_from_stored_entry_data(
+    hass, make_entry
+) -> None:
+    """A lost database re-seeded from the entry's stored admin copy."""
+    from custom_components.nestquest.const import CONF_ADMIN_USER_IDS
+
+    entry = await _setup_entry(
+        hass,
+        make_entry(data={CONF_ADMIN_USER_IDS: ["user-a", "user-b"]}),
+        hass.registry,
+    )
+    database = entry.runtime_data.database
+    try:
+        assert await list_admin_ids(database) == ["user-a", "user-b"]
+    finally:
+        await database.close()
+    assert await async_unload_entry(hass, entry) is True
+
+
+async def test_setup_without_context_leaves_allowlist_empty(
+    hass, make_entry
+) -> None:
+    """Fail closed: no context user and no stored copy means an empty
+    allowlist — nobody is admin until the owner configures it."""
+    entry = await _setup_entry(hass, make_entry(), hass.registry)
+    database = entry.runtime_data.database
+    try:
+        assert await list_admin_ids(database) == []
+    finally:
+        await database.close()
+    assert await async_unload_entry(hass, entry) is True
+
+
+async def test_setup_does_not_reseed_narrowed_allowlist(
+    hass, make_entry
+) -> None:
+    from custom_components.nestquest import async_unload_entry
+    from custom_components.nestquest.const import CONF_ADMIN_USER_IDS
+
+    entry = await _setup_entry(
+        hass, make_entry(context={"user_id": "ha-owner"}), hass.registry
+    )
+    database = entry.runtime_data.database
+    await set_admin_ids(database, ["user-parent"])
+    await database.close()
+    assert await async_unload_entry(hass, entry) is True
+
+    # Reload with the SAME context: the narrowed list survives.
+    entry_reloaded = await _setup_entry(
+        hass, make_entry(context={"user_id": "ha-owner"}), hass.registry
+    )
+    database_b = entry_reloaded.runtime_data.database
+    try:
+        assert await list_admin_ids(database_b) == ["user-parent"]
+    finally:
+        await database.close()
+    assert await async_unload_entry(hass, entry_reloaded) is True
+
+
+async def test_setup_seed_prefers_options_over_entry_data(
+    hass, make_entry
+) -> None:
+    """Seed precedence on a fresh database: the options flow's saved
+    list (the current one) beats the config flow's original copy."""
+    from custom_components.nestquest.const import CONF_ADMIN_USER_IDS
+
+    entry = await _setup_entry(
+        hass,
+        make_entry(
+            options={CONF_ADMIN_USER_IDS: ["user-current"]},
+            data={CONF_ADMIN_USER_IDS: ["ha-owner"]},
+            context={"user_id": "ha-owner"},
+        ),
+        hass.registry,
+    )
+    database = entry.runtime_data.database
+    try:
+        assert await list_admin_ids(database) == ["user-current"]
+    finally:
+        await database.close()
+    assert await async_unload_entry(hass, entry) is True
+
+
+async def test_setup_owner_fallback_seeds_owner_accounts(
+    hass, make_entry
+) -> None:
+    """Last-resort seed: with no persisted copy and no flow-context
+    user, HA owner accounts are seeded so first setup is never
+    ownerless (the real flow may lose the context; owners can already
+    do everything in HA)."""
+    from unittest.mock import AsyncMock
+
+    hass.auth.async_get_users = AsyncMock(
+        return_value=[
+            SimpleNamespace(id="owner-1", is_owner=True),
+            SimpleNamespace(id="member-1", is_owner=False),
+            SimpleNamespace(id="owner-2", is_owner=True),
+        ]
+    )
+    entry = await _setup_entry(hass, make_entry(), hass.registry)
+    database = entry.runtime_data.database
+    try:
+        assert sorted(await list_admin_ids(database)) == ["owner-1", "owner-2"]
+    finally:
+        await database.close()
+    assert await async_unload_entry(hass, entry) is True
+
+
+async def test_setup_owner_fallback_not_used_when_context_present(
+    hass, make_entry
+) -> None:
+    """The context user (flow caller) wins over the owner fallback:
+    a non-owner parent configuring the integration becomes the admin."""
+    from unittest.mock import AsyncMock
+
+    hass.auth.async_get_users = AsyncMock(
+        return_value=[SimpleNamespace(id="owner-1", is_owner=True)]
+    )
+    entry = await _setup_entry(
+        hass,
+        make_entry(context={"user_id": "parent-configured"}),
+        hass.registry,
+    )
+    database = entry.runtime_data.database
+    try:
+        assert await list_admin_ids(database) == ["parent-configured"]
+    finally:
+        await database.close()
+    assert await async_unload_entry(hass, entry) is True
+
+
 def test_seed_owner_ids_argument(tmp_path) -> None:
     async def _body(database):
         # Malformed owner lists are rejected like any other candidate —
@@ -215,13 +377,54 @@ def test_seed_owner_ids_argument(tmp_path) -> None:
     _with_db(tmp_path, "seed-owner-arg.db")(_body)
 
 
+async def test_reopened_setup_failure_closes_database(
+    hass, make_entry, monkeypatch
+) -> None:
+    """A seeding failure on the reopened-record path closes the just-
+    opened connection before re-raising (no leaked handles across HA's
+    setup retries)."""
+    import pytest as pytest_module
+    from unittest.mock import AsyncMock
+
+    import custom_components.nestquest as nestquest_module
+    from custom_components.nestquest.db import NestQuestDatabase
+
+    # First: a successful setup to create the runtime record and file.
+    entry = await _setup_entry(hass, make_entry(), hass.registry)
+    await async_unload_entry(hass, entry)
+
+    # Now a re-setup whose seeding fails after the reopen.
+    async def _failing_seed(database, **kwargs):
+        raise RuntimeError("seed boom")
+
+    monkeypatch.setattr(
+        nestquest_module, "seed_setup_admin", _failing_seed, raising=True
+    )
+
+    close_calls: list[bool] = []
+    original_close = NestQuestDatabase.close
+
+    async def _spy_close(self):
+        close_calls.append(True)
+        return await original_close(self)
+
+    monkeypatch.setattr(NestQuestDatabase, "close", _spy_close)
+
+    with pytest_module.raises(RuntimeError, match="seed boom"):
+        await _setup_entry(hass, entry, hass.registry)
+    # The reopen path opened AND closed a connection; the failure is
+    # the last thing observed.
+    assert close_calls[-1] is True
+
+
+# ---------------------------------------------------------------------------
 # is_admin: the fail-closed resolver (Feature 09's verdict function)
 # ---------------------------------------------------------------------------
 
 
 def test_is_admin_verdict_matrix(tmp_path) -> None:
     async def _body(database):
-        from custom_components.nestquest.core.admin_allowlist import is_admin
+        from custom_components.nestquest.admin_allowlist import is_admin
 
         await set_admin_ids(database, ["user-owner"])
         assert await is_admin(database, "user-owner") is True
@@ -244,7 +447,7 @@ def test_is_admin_verdict_matrix(tmp_path) -> None:
 def test_is_admin_empty_allowlist_fails_closed(tmp_path) -> None:
     """An empty allowlist returns False for EVERYONE, not True."""
     async def _body(database):
-        from custom_components.nestquest.core.admin_allowlist import is_admin
+        from custom_components.nestquest.admin_allowlist import is_admin
 
         for candidate in ("user-owner", "", None, 1):
             assert await is_admin(database, candidate) is False
@@ -257,7 +460,7 @@ def test_is_admin_false_after_last_admin_removal_attempt(tmp_path) -> None:
     """The refusal keeps the verdict sound: a refused removal leaves
     the admin in place, so is_admin still resolves True."""
     async def _body(database):
-        from custom_components.nestquest.core.admin_allowlist import is_admin
+        from custom_components.nestquest.admin_allowlist import is_admin
 
         await set_admin_ids(database, ["user-owner"])
         with pytest.raises(ValueError, match="at least one admin"):

tests/test_binary_sensors.py

@@ -1,85 +1,50 @@
-"""Tests for the per-child binary sensors (Feature 10, task 4).
-
-The snapshot comes from the API service's panel route (the presence
-engine resolves server-side), so these tests script the route's
-payload through :class:`conftest.StubSnapshotClient` instead of
-seeding a local database.
-"""
+"""Tests for the per-child binary sensors (Feature 10, task 4)."""
 from __future__ import annotations
 
-from conftest import StubSnapshotClient, set_coordinator_client, wire_entry_to_registry
+import datetime
+
+from conftest import wire_entry_to_registry
 
 from custom_components.nestquest import async_setup_entry
+from custom_components.nestquest.children import create_child, list_children
 from custom_components.nestquest.const import DOMAIN
+from custom_components.nestquest.dao_presence import PresenceSchedulesDao
+from custom_components.nestquest.materialize import materialize
+from custom_components.nestquest.quest_definitions import (
+    create_quest_definition,
+)
+from custom_components.nestquest.recurrence import ScheduleRule
+from custom_components.nestquest.completion import complete_instance
+
+SEED_HORIZON_DAYS = 3
 
 
 def _binary(hass, child_id: int, kind: str):
     return hass.entities[f"{DOMAIN}_child_{child_id}_{kind}"]
 
 
-def _child(
-    child_id: int,
-    name: str,
-    *,
-    present=True,
-    next_present=None,
-    instances=(),
-):
-    completed = sum(1 for i in instances if i["state"] == "completed")
-    due = len(instances)
-    return {
-        "child_id": child_id,
-        "child_name": name,
-        "present": present,
-        "next_present": next_present,
-        "due_today": due,
-        "completed_today": completed,
-        "remaining_today": due - completed,
-        "completion_pct": 100 if due == 0 else round(completed / due * 100),
-        "instances": list(instances),
-    }
-
-
-def _instance(instance_id: int, child_id: int, *, state="open") -> dict:
-    return {
-        "id": instance_id,
-        "definition_id": 3,
-        "child_id": child_id,
-        "title": "Brush teeth",
-        "icon": "🦷",
-        "window": "morning",
-        "due_time": "08:00",
-        "state": state,
-        "overdue": False,
-        "completed_at": None if state == "open" else "2026-09-23T07:55:00+00:00",
-        "on_time": None if state == "open" else True,
-    }
-
-
-def _payload(children) -> dict:
-    return {
-        "today_iso": "2026-09-23",
-        "cycle_day": 0,
-        "children": list(children),
-    }
-
-
-ADA = 1
-BO = 2
-CORY = 3
-
-
-async def _setup_entry(hass, make_entry, *payloads):
-    """Set up the integration with a scripted snapshot client."""
-    entry = wire_entry_to_registry(
-        make_entry(
-            data={"api_base_url": "http://api.test:8000", "panel_token": "tok"}
-        ),
-        hass.registry,
-    )
-    set_coordinator_client(entry, StubSnapshotClient(*payloads))
+async def _setup_entry(hass, make_entry):
+    entry = wire_entry_to_registry(make_entry(), hass.registry)
     assert await async_setup_entry(hass, entry) is True
-    return entry, entry.runtime_data.coordinator
+    return entry
+
+
+async def _seed_two_children(database) -> tuple:
+    ada = await create_child(database, "Ada")
+    bo = await create_child(database, "Bo")
+    today = datetime.date.today()
+    await create_quest_definition(
+        database,
+        "Brush teeth",
+        ScheduleRule.from_dict(
+            {"rule_type": "daily", "start_date": today.isoformat()}
+        ),
+        [ada.id, bo.id],
+        ["morning"],
+    )
+    end = (today + datetime.timedelta(days=SEED_HORIZON_DAYS)).isoformat()
+    await materialize(database, today.isoformat(), end, today=today)
+    return ada, bo
 
 
 async def test_all_done_off_with_open_quests_and_zero_quests(
@@ -87,76 +52,88 @@ async def test_all_done_off_with_open_quests_and_zero_quests(
 ) -> None:
     """all_done is OFF while quests are owed AND on a zero-quest day;
     a child with no quests never fires the celebration automation."""
-    _entry, coordinator = await _setup_entry(
-        hass,
-        make_entry,
-        _payload(
-            [
-                _child(ADA, "Ada", instances=[_instance(7, ADA)]),
-                _child(BO, "Bo", instances=[_instance(8, BO)]),
-                _child(CORY, "Cory"),
-            ]
-        ),
-    )
+    entry = await _setup_entry(hass, make_entry)
+    coordinator = entry.runtime_data.coordinator
+    database = entry.runtime_data.database
+    ada, _bo = await _seed_two_children(database)
+    await create_child(database, "Cory")  # zero quests
+    await coordinator.async_refresh()
 
-    assert _binary(hass, ADA, "all_done").is_on is False
-    assert _binary(hass, BO, "all_done").is_on is False
-    assert _binary(hass, CORY, "all_done").is_on is False
+    assert _binary(hass, ada.id, "all_done").is_on is False
+    cory = [
+        child for child in coordinator.data.children
+        if child.child_name == "Cory"
+    ][0]
+    assert _binary(hass, cory.child_id, "all_done").is_on is False
 
 
 async def test_all_done_on_only_when_day_clear(hass, make_entry) -> None:
-    _entry, coordinator = await _setup_entry(
-        hass,
-        make_entry,
-        _payload([_child(ADA, "Ada", instances=[_instance(7, ADA)])]),
-        _payload(
-            [
-                _child(
-                    ADA,
-                    "Ada",
-                    instances=[_instance(7, ADA, state="completed")],
-                )
-            ]
-        ),
+    entry = await _setup_entry(hass, make_entry)
+    coordinator = entry.runtime_data.coordinator
+    database = entry.runtime_data.database
+    ada, _bo = await _seed_two_children(database)
+    await coordinator.async_refresh()
+    snapshot_ada = [
+        child for child in coordinator.data.children
+        if child.child_id == ada.id
+    ][0]
+    instance_id = snapshot_ada.instances[0].instance_id
+    await complete_instance(
+        database,
+        instance_id,
+        actor_source="panel",
+        actor_child_id=ada.id,
     )
     await coordinator.async_refresh()
-    assert _binary(hass, ADA, "all_done").is_on is True
+    assert _binary(hass, ada.id, "all_done").is_on is True
 
 
 async def test_present_today_on_without_schedule_off_when_absent(
     hass, make_entry
 ) -> None:
-    """Presence is resolved by the API's presence engine: present=True
-    renders ON, present=False renders OFF."""
-    _entry, _coordinator = await _setup_entry(
-        hass,
-        make_entry,
-        _payload([_child(ADA, "Ada"), _child(CORY, "Cory", present=False)]),
+    """No schedule means present every day; an all-absent pattern
+    today reports OFF."""
+    entry = await _setup_entry(hass, make_entry)
+    coordinator = entry.runtime_data.coordinator
+    database = entry.runtime_data.database
+    ada, _bo = await _seed_two_children(database)
+    await create_child(database, "Cory")
+    today = datetime.date.today()
+    await coordinator.async_refresh()
+    cory = [
+        child for child in coordinator.data.children
+        if child.child_name == "Cory"
+    ][0]
+    await PresenceSchedulesDao(database).upsert_by_child(
+        cory.child_id, 1, today.isoformat(), ""
     )
+    await coordinator.async_refresh()
 
-    assert _binary(hass, ADA, "present_today").is_on is True
-    assert _binary(hass, CORY, "present_today").is_on is False
+    assert _binary(hass, ada.id, "present_today").is_on is True
+    assert _binary(hass, cory.child_id, "present_today").is_on is False
 
 
 async def test_binary_sensor_identity_and_attributes(hass, make_entry) -> None:
-    _entry, _coordinator = await _setup_entry(
-        hass, make_entry, _payload([_child(ADA, "Ada")])
-    )
+    entry = await _setup_entry(hass, make_entry)
+    coordinator = entry.runtime_data.coordinator
+    database = entry.runtime_data.database
+    ada, _bo = await _seed_two_children(database)
+    await coordinator.async_refresh()
 
-    all_done = _binary(hass, ADA, "all_done")
-    present = _binary(hass, ADA, "present_today")
-    assert all_done.unique_id == f"nestquest_child_{ADA}_all_done"
-    assert present.unique_id == f"nestquest_child_{ADA}_present_today"
+    all_done = _binary(hass, ada.id, "all_done")
+    present = _binary(hass, ada.id, "present_today")
+    assert all_done.unique_id == f"nestquest_child_{ada.id}_all_done"
+    assert present.unique_id == f"nestquest_child_{ada.id}_present_today"
     assert all_done.name == "NestQuest Ada all done"
     assert present.name == "NestQuest Ada present today"
     for entity in (all_done, present):
         assert entity.device_info.name == "NestQuest Ada"
         assert all_done.extra_state_attributes == {
-            "child_id": ADA,
+            "child_id": ada.id,
             "child_name": "Ada",
         }
         assert present.extra_state_attributes == {
-            "child_id": ADA,
+            "child_id": ada.id,
             "child_name": "Ada",
             "next_present": None,
         }
@@ -168,28 +145,40 @@ async def test_present_today_carries_next_present_when_away(
     """A child away today carries the ISO date of their next present
     day (the panel's away plate renders ``Returns <weekday>, <Mon D>``
     from it); an always-absent pattern carries ``None``."""
-    _entry, _coordinator = await _setup_entry(
-        hass,
-        make_entry,
-        _payload(
-            [
-                _child(
-                    ADA,
-                    "Ada",
-                    present=False,
-                    next_present="2026-09-24",
-                ),
-                _child(CORY, "Cory", present=False, next_present=None),
-            ]
-        ),
+    entry = await _setup_entry(hass, make_entry)
+    coordinator = entry.runtime_data.coordinator
+    database = entry.runtime_data.database
+    ada, _bo = await _seed_two_children(database)
+    await create_child(database, "Cory")
+    today = datetime.date.today()
+    pattern = ",".join(
+        str(day) for day in range(7) if day != today.weekday()
     )
+    await PresenceSchedulesDao(database).upsert_by_child(
+        ada.id, 1, today.isoformat(), pattern
+    )
+    await PresenceSchedulesDao(database).upsert_by_child(
+        await _cory_id(database), 1, today.isoformat(), ""
+    )
+    await coordinator.async_refresh()
 
-    assert _binary(hass, ADA, "present_today").is_on is False
-    assert _binary(hass, ADA, "present_today").extra_state_attributes[
+    assert _binary(hass, ada.id, "present_today").is_on is False
+    assert _binary(hass, ada.id, "present_today").extra_state_attributes[
         "next_present"
-    ] == "2026-09-24"
+    ] == (today + datetime.timedelta(days=1)).isoformat()
 
-    assert _binary(hass, CORY, "present_today").is_on is False
-    assert _binary(hass, CORY, "present_today").extra_state_attributes[
+    cory = [
+        child for child in coordinator.data.children
+        if child.child_name == "Cory"
+    ][0]
+    assert _binary(hass, cory.child_id, "present_today").is_on is False
+    assert _binary(hass, cory.child_id, "present_today").extra_state_attributes[
         "next_present"
     ] is None
+
+
+async def _cory_id(database) -> int:
+    for child in await list_children(database):
+        if child.display_name == "Cory":
+            return child.id
+    raise AssertionError("Cory was not created")

tests/test_children_registry.py

@@ -8,16 +8,16 @@ from unittest.mock import AsyncMock, MagicMock
 
 import pytest
 
-from custom_components.nestquest.core.children import (
+from custom_components.nestquest.children import (
     create_child,
     edit_child,
     list_children,
     reorder_children,
     set_child_active,
 )
-from custom_components.nestquest.core.dao_children import ChildRecord, ChildrenDao
-from custom_components.nestquest.core.db import NestQuestDatabase
-from custom_components.nestquest.core.migrations import apply_migrations
+from custom_components.nestquest.dao_children import ChildRecord, ChildrenDao
+from custom_components.nestquest.db import NestQuestDatabase
+from custom_components.nestquest.migrations import apply_migrations
 
 
 def _run(coro):
@@ -739,12 +739,12 @@ def test_deactivating_child_preserves_definitions_instances_events(
     async def _body(database):
         from datetime import date, timedelta
 
-        from custom_components.nestquest.core.dao_children import ChildrenDao
-        from custom_components.nestquest.core.dao_instances import (
+        from custom_components.nestquest.dao_children import ChildrenDao
+        from custom_components.nestquest.dao_instances import (
             CompletionEventsDao,
             QuestInstancesDao,
         )
-        from custom_components.nestquest.core.dao_rules import (
+        from custom_components.nestquest.dao_rules import (
             QuestDefinitionsDao,
             ScheduleRulesDao,
         )
@@ -831,7 +831,7 @@ def test_no_code_path_deletes_a_child_row() -> None:
 
     import inspect
 
-    from custom_components.nestquest.core.dao_children import ChildrenDao
+    from custom_components.nestquest.dao_children import ChildrenDao
 
     methods = {
         name

tests/test_complete_quest_proxy.py

@@ -1,214 +0,0 @@
-"""The ``nestquest.complete_quest`` proxy to the API client (Feature 18).
-
-The service is a thin proxy: a panel tap must reach the API's panel
-complete route through the entry's ONE shared API client (the same
-instance the coordinator polls and the SSE subscription reads), with
-exactly the payload contract the panel cards send (``instance_id``,
-``actor=panel``, ``actor_child_id``).  The service performs NO local
-completion and fires NO local bus event — the API service emits the
-transition on its SSE stream and the integration's subscription
-re-fires it (firing it locally too would double-fire) — and it
-refreshes the coordinator after a successful call so the sensors
-reflect the completion immediately.  Every failure (a typed
-:class:`NestQuestApiError`, an unconfigured client, a non-panel actor)
-surfaces as a :class:`HomeAssistantError`, token-free.
-
-The scripted clients here stand in for the API service: recording and
-failing ``complete_instance`` implementations, no network, no aiohttp.
-"""
-from __future__ import annotations
-
-import pytest
-from homeassistant.exceptions import HomeAssistantError
-
-from conftest import ScriptedPanelClient, set_coordinator_client, wire_entry_to_registry
-
-from custom_components.nestquest import async_setup_entry
-from custom_components.nestquest.api_client import NestQuestApiError
-from custom_components.nestquest.const import (
-    CONF_PANEL_TOKEN,
-    DOMAIN,
-    EVENT_CHILD_DAY_COMPLETE,
-    EVENT_QUEST_COMPLETED,
-    SERVICE_COMPLETE_QUEST,
-)
-
-
-class _RecordingApiClient(ScriptedPanelClient):
-    """Snapshot-only stand-in that RECORDS completion calls.
-
-    ``complete_instance`` deliberately performs NO local write: the
-    API service is remote, and the assertions below must be able to
-    prove the service handler itself completed nothing locally.
-    """
-
-
-class _FailingApiClient(_RecordingApiClient):
-    """A stand-in whose completion fails the way the client types it."""
-
-    def __init__(self, error: NestQuestApiError, *outcomes) -> None:
-        super().__init__(*outcomes)
-        self.fail_complete_with = error
-
-
-def _empty_snapshot() -> dict:
-    return {
-        "today_iso": "2026-09-23",
-        "cycle_day": 0,
-        "children": [],
-    }
-
-
-async def _setup_entry(hass, make_entry, client):
-    """Wire, script, and set up an entry against the scripted client."""
-    entry = wire_entry_to_registry(
-        make_entry(data={CONF_PANEL_TOKEN: "secret-panel-token"}),
-        hass.registry,
-    )
-    set_coordinator_client(entry, client)
-    assert await async_setup_entry(hass, entry) is True
-    return entry
-
-
-def _record_refreshes(entry) -> list[bool]:
-    """Replace the coordinator's refresh with a recording stand-in."""
-    refreshes: list[bool] = []
-
-    async def _fake_refresh():
-        refreshes.append(True)
-
-    entry.runtime_data.coordinator.async_refresh = _fake_refresh
-    return refreshes
-
-
-async def test_complete_quest_reaches_the_shared_api_client(
-    hass, make_entry
-) -> None:
-    """A panel tap calls ``complete_instance`` on the entry's shared
-    client with the tapped child, fires NO local event, and refreshes
-    the coordinator immediately."""
-    client = _RecordingApiClient(_empty_snapshot())
-    entry = await _setup_entry(hass, make_entry, client)
-    assert entry.runtime_data.coordinator.api_client is client, (
-        "the service must proxy through the entry's ONE shared client"
-    )
-    refreshes = _record_refreshes(entry)
-
-    await hass.services.call(
-        DOMAIN,
-        SERVICE_COMPLETE_QUEST,
-        {
-            "instance_id": 7,
-            "actor": "panel",
-            "actor_child_id": 1,
-        },
-    )
-
-    assert client.complete_calls == [(7, 1)]
-    # No local firing: the completed (and day-complete) events arrive
-    # over the SSE stream, re-fired by the subscription — never from
-    # this handler.
-    assert hass.bus.fired(EVENT_QUEST_COMPLETED) == []
-    assert hass.bus.fired(EVENT_CHILD_DAY_COMPLETE) == []
-    # The old immediate-update behaviour: the sensors' coordinator
-    # refresh runs before the service call returns.
-    assert refreshes == [True]
-
-
-@pytest.mark.parametrize(
-    ("error", "fragment"),
-    [
-        (
-            NestQuestApiError(
-                "NestQuest API POST /api/v1/panel/instances/7/complete "
-                "failed with HTTP 401",
-                status=401,
-            ),
-            "failed with HTTP 401",
-        ),
-        (
-            NestQuestApiError(
-                "NestQuest API POST /api/v1/panel/instances/7/complete "
-                "transport failure: connection refused",
-                status=None,
-            ),
-            "transport failure",
-        ),
-    ],
-)
-async def test_api_failure_surfaces_as_a_service_error(
-    hass, make_entry, error, fragment
-) -> None:
-    """A typed API failure (non-2xx or transport) raises
-    ``HomeAssistantError`` carrying the typed message — which never
-    includes the panel token — with nothing fired locally, and no
-    refresh for a mutation that never happened."""
-    client = _FailingApiClient(error, _empty_snapshot())
-    entry = await _setup_entry(hass, make_entry, client)
-    refreshes = _record_refreshes(entry)
-
-    with pytest.raises(HomeAssistantError, match=fragment) as excinfo:
-        await hass.services.call(
-            DOMAIN,
-            SERVICE_COMPLETE_QUEST,
-            {
-                "instance_id": 7,
-                "actor": "panel",
-                "actor_child_id": 1,
-            },
-        )
-    # The typed error is chained, and the service error carries the
-    # typed message only — never the panel token.
-    assert excinfo.value.__cause__ is error
-    assert "secret-panel-token" not in str(excinfo.value)
-    assert client.complete_calls == [(7, 1)]
-    assert hass.bus.fired(EVENT_QUEST_COMPLETED) == []
-    assert hass.bus.fired(EVENT_CHILD_DAY_COMPLETE) == []
-    assert refreshes == []
-
-
-async def test_unconfigured_api_client_surfaces_as_a_service_error(
-    hass, make_entry
-) -> None:
-    """An entry with no completion surface (the unconfigured-token
-    stub the coordinator swaps in) fails the service clearly instead
-    of reaching an attribute error."""
-    from custom_components.nestquest.coordinator import _UnconfiguredApiClient
-
-    await _setup_entry(hass, make_entry, _UnconfiguredApiClient())
-
-    with pytest.raises(
-        HomeAssistantError, match="NestQuest API is not configured"
-    ):
-        await hass.services.call(
-            DOMAIN,
-            SERVICE_COMPLETE_QUEST,
-            {
-                "instance_id": 7,
-                "actor": "panel",
-                "actor_child_id": 1,
-            },
-        )
-
-
-async def test_non_panel_actor_is_rejected_before_the_client(
-    hass, make_entry
-) -> None:
-    """The API's panel route completes as the tapped child only: a
-    user-actor call fails fast with a clear error and never reaches
-    the client."""
-    client = _RecordingApiClient(_empty_snapshot())
-    await _setup_entry(hass, make_entry, client)
-
-    with pytest.raises(HomeAssistantError, match="actor must be 'panel'"):
-        await hass.services.call(
-            DOMAIN,
-            SERVICE_COMPLETE_QUEST,
-            {
-                "instance_id": 7,
-                "actor": "user",
-                "actor_user_id": "admin-1",
-            },
-            context={"user_id": "admin-1"},
-        )
-    assert client.complete_calls == []

tests/test_completion.py

@@ -8,27 +8,27 @@ import re
 
 import pytest
 
-from custom_components.nestquest.core.completion import (
+from custom_components.nestquest.completion import (
     append_event,
     complete_instance,
     instance_state,
     list_missed_for_child,
     uncomplete_instance,
 )
-from custom_components.nestquest.core.dao_children import ChildrenDao
-from custom_components.nestquest.core.dao_instances import (
+from custom_components.nestquest.dao_children import ChildrenDao
+from custom_components.nestquest.dao_instances import (
     EVENT_COMPLETED,
     EVENT_UNCOMPLETED,
     CompletionEventRecord,
     CompletionEventsDao,
     QuestInstancesDao,
 )
-from custom_components.nestquest.core.dao_rules import (
+from custom_components.nestquest.dao_rules import (
     QuestDefinitionsDao,
     ScheduleRulesDao,
 )
-from custom_components.nestquest.core.db import NestQuestDatabase
-from custom_components.nestquest.core.migrations import apply_migrations
+from custom_components.nestquest.db import NestQuestDatabase
+from custom_components.nestquest.migrations import apply_migrations
 
 
 def _run(coro):
@@ -311,7 +311,7 @@ def test_now_pins_occurred_at_utc(tmp_path) -> None:
 
 
 def test_module_never_exposes_update_or_delete() -> None:
-    import custom_components.nestquest.core.completion as completion
+    import custom_components.nestquest.completion as completion
 
     public = {
         name

tests/test_config_flow.py

@@ -156,13 +156,23 @@ def test_no_hardcoded_domain_or_db_filename_in_new_modules() -> None:
                     f"Found hard-coded database filename in {py_file.name}:{node.lineno}"
                 )
 
+async def test_flow_persists_flow_user_as_initial_admin(hass, make_flow) -> None:
+    """The HA user completing the flow lands in entry data as the
+    initial admin copy: entry.context is not persisted by real HA, so
+    the durable record must carry the owner."""
+    from custom_components.nestquest.const import CONF_ADMIN_USER_IDS
+
+    flow = make_flow(hass)
+    flow.context = {"user_id": "ha-owner"}
+    result = await flow.async_step_user({})
+    assert result["type"] == "create_entry"
+    assert result["data"] == {CONF_ADMIN_USER_IDS: ["ha-owner"]}
+
+
 async def test_flow_without_context_user_keeps_data_untouched(
     hass, make_flow
 ) -> None:
-    """A submit with user input stores it as-is; no admin copy is
-    invented (the allowlist lives in the API service's own store since
-    the DB removal)."""
     flow = make_flow(hass)
-    result = await flow.async_step_user({"update_interval": 60})
+    result = await flow.async_step_user({"horizon_days": 7})
     assert result["type"] == "create_entry"
-    assert result["data"] == {"update_interval": 60}
+    assert result["data"] == {"horizon_days": 7}

tests/test_coordinator.py

@@ -12,7 +12,6 @@ cycle day, and the unconfigured / failed-fetch behaviour.
 from __future__ import annotations
 
 import datetime
-import logging
 
 import pytest
 
@@ -24,9 +23,7 @@ from custom_components.nestquest.api_client import (
     NestQuestApiError,
 )
 from custom_components.nestquest.const import (
-    CONF_SNAPSHOT_STALENESS,
     CONF_UPDATE_INTERVAL,
-    DEFAULT_SNAPSHOT_STALENESS,
     DEFAULT_UPDATE_INTERVAL,
     DOMAIN,
 )
@@ -70,23 +67,6 @@ class StubSnapshotClient:
         return outcome
 
 
-class FakeMonotonic:
-    """A deterministic stand-in for the staleness clock.
-
-    The coordinator reads elapsed time through
-    :func:`custom_components.nestquest.coordinator._monotonic`; tests
-    patch that seam with an instance of this class and advance ``now``
-    by whole seconds, so the staleness window is exercised without any
-    real waiting.
-    """
-
-    def __init__(self, start: float = 1000.0) -> None:
-        self.now = start
-
-    def __call__(self) -> float:
-        return self.now
-
-
 #: A fixture panel snapshot (the documented Feature 16 route shape):
 #: two children — Ada owes one, owes none of it yet, is away today with
 #: a returns date; Bo completed his only quest and is present.
@@ -360,20 +340,13 @@ async def test_coordinator_entities_read_the_api_snapshot(hass, make_entry) -> N
     await async_unload_entry(hass, entry)
 
 
-async def test_coordinator_failed_fetch_marks_unavailable(
-    hass, make_entry, monkeypatch
-) -> None:
-    """A failed fetch (transport failure or non-2xx — both typed) PAST
-    the staleness threshold is a FAILED refresh pass: the update pass
-    converts the typed error to UpdateFailed (the exception HA's
-    coordinator machinery records as a failed pass, chaining the typed
-    error as ``__cause__``), the refresh records the failure instead of
-    raising, and data keeps its last good value.  (Within the threshold
-    the last-good cache serves instead — the staleness tests below.)"""
-    import custom_components.nestquest.coordinator as coordinator_module
-
-    clock = FakeMonotonic()
-    monkeypatch.setattr(coordinator_module, "_monotonic", clock)
+async def test_coordinator_failed_fetch_marks_unavailable(hass, make_entry) -> None:
+    """A failed fetch (transport failure or non-2xx — both typed) is a
+    FAILED refresh pass: the update pass converts the typed error to
+    UpdateFailed (the exception HA's coordinator machinery records as a
+    failed pass, chaining the typed error as ``__cause__``), the refresh
+    records the failure instead of raising, and data keeps its last
+    good value."""
     error = NestQuestApiError(
         "NestQuest API GET /api/v1/panel/snapshot failed with HTTP 503",
         status=503,
@@ -386,11 +359,8 @@ async def test_coordinator_failed_fetch_marks_unavailable(
     assert coordinator.data is not None
     assert coordinator.last_update_success is True
 
-    # The next pass hits the scripted failure AFTER the cache went
-    # stale — one second past the shipped 900 s default threshold: the
-    # update pass converts the typed error to UpdateFailed, with the
-    # typed error chained.
-    clock.now += DEFAULT_SNAPSHOT_STALENESS + 1
+    # The next pass hits the scripted failure: the update pass converts
+    # the typed error to UpdateFailed, with the typed error chained.
     with pytest.raises(UpdateFailed, match="HTTP 503") as excinfo:
         await coordinator._async_update_data()
     assert isinstance(excinfo.value.__cause__, NestQuestApiError)
@@ -406,163 +376,6 @@ async def test_coordinator_failed_fetch_marks_unavailable(
     assert isinstance(coordinator.last_exception.__cause__, NestQuestApiError)
 
 
-async def test_coordinator_serves_cached_snapshot_within_staleness(
-    hass, make_entry, monkeypatch, caplog
-) -> None:
-    """API down WITHIN the staleness threshold: the failed fetch serves
-    the last-good cache — the pass succeeds with the SAME snapshot, so
-    ``last_update_success`` stays True (entities remain available) and
-    the outage is logged as a clear warning, never silently."""
-    import custom_components.nestquest.coordinator as coordinator_module
-
-    clock = FakeMonotonic()
-    monkeypatch.setattr(coordinator_module, "_monotonic", clock)
-    error = NestQuestApiError(
-        "NestQuest API GET /api/v1/panel/snapshot failed with HTTP 503",
-        status=503,
-    )
-    # Setup's first refresh consumes the good snapshot; the two test
-    # passes hit the scripted failure.
-    client = StubSnapshotClient(FIXTURE_SNAPSHOT, error, error)
-    _entry, coordinator = await _wire_entry(
-        hass,
-        make_entry,
-        client,
-        options={CONF_UPDATE_INTERVAL: 300, CONF_SNAPSHOT_STALENESS: 900},
-    )
-    # The successful first pass cached the snapshot (stamped at the
-    # fake clock's start).
-    first = coordinator.data
-    assert first is not None
-    assert coordinator.last_update_success is True
-
-    # The API goes down 900 s after that success — exactly the
-    # threshold, still WITHIN the inclusive window: the pass serves the
-    # cached snapshot instead of failing.
-    clock.now += 900
-    with caplog.at_level(
-        logging.WARNING, logger="custom_components.nestquest"
-    ):
-        await coordinator.async_refresh()
-    assert coordinator.last_update_success is True
-    assert coordinator.data is first
-    assert coordinator.data.children[0].child_name == "Ada"
-    # The fetch WAS attempted (and failed) — the cache is a fallback,
-    # not a replacement for polling.
-    assert client.calls == 2
-    assert any(
-        "last-good" in record.getMessage() for record in caplog.records
-    )
-
-
-async def test_coordinator_recovers_without_reload_after_outage(
-    hass, make_entry, monkeypatch
-) -> None:
-    """The full outage arc: within the threshold the cache serves, past
-    it the entities go unavailable, and when the API comes back the
-    next pass succeeds with the FRESH snapshot, re-arms the cache, and
-    the entities recover — without any config-entry reload."""
-    import custom_components.nestquest.coordinator as coordinator_module
-
-    clock = FakeMonotonic()
-    monkeypatch.setattr(coordinator_module, "_monotonic", clock)
-    outage = NestQuestApiError(
-        "NestQuest API GET /api/v1/panel/snapshot failed with HTTP 503",
-        status=503,
-    )
-    post_recovery_outage = NestQuestApiError(
-        "NestQuest API GET /api/v1/panel/snapshot failed with HTTP 502",
-        status=502,
-    )
-    fresh = {**FIXTURE_SNAPSHOT, "cycle_day": 4}
-    client = StubSnapshotClient(
-        FIXTURE_SNAPSHOT, outage, outage, fresh, post_recovery_outage
-    )
-    _entry, coordinator = await _wire_entry(
-        hass,
-        make_entry,
-        client,
-        options={CONF_UPDATE_INTERVAL: 300, CONF_SNAPSHOT_STALENESS: 900},
-    )
-    first = coordinator.data
-    assert first.cycle_day == 3
-
-    # Within the threshold: the outage serves the cache.
-    clock.now += 300
-    await coordinator.async_refresh()
-    assert coordinator.last_update_success is True
-    assert coordinator.data is first
-
-    # Past the threshold: the outage fails the pass (unavailable).
-    clock.now += 901
-    await coordinator.async_refresh()
-    assert coordinator.last_update_success is False
-
-    # The API returns: the next pass succeeds with the fresh snapshot
-    # and no reload was involved anywhere.
-    await coordinator.async_refresh()
-    assert coordinator.last_update_success is True
-    fresh_data = coordinator.data
-    assert fresh_data.cycle_day == 4
-    assert hass.registry.reloaded == []
-
-    # The success re-armed the cache with the FRESH stamp: another
-    # outage within the threshold serves the new snapshot now, not the
-    # pre-outage one.
-    clock.now += 300
-    await coordinator.async_refresh()
-    assert coordinator.last_update_success is True
-    assert coordinator.data is fresh_data
-    assert client.calls == 5
-
-
-async def test_setup_creates_coordinator_with_configured_staleness(
-    hass, make_entry
-) -> None:
-    """The staleness threshold rides the entry options into the
-    coordinator, alongside the update interval."""
-    entry = wire_entry_to_registry(
-        make_entry(
-            options={CONF_UPDATE_INTERVAL: 60, CONF_SNAPSHOT_STALENESS: 600}
-        ),
-        hass.registry,
-    )
-    assert await async_setup_entry(hass, entry) is True
-    coordinator = entry.runtime_data.coordinator
-    assert coordinator._staleness_seconds == 600
-
-
-async def test_setup_staleness_below_interval_falls_back_to_default(
-    hass, make_entry
-) -> None:
-    """A stored threshold below the update interval (a raw hand-edited
-    option) never reaches the coordinator as-is: it falls back to the
-    shipped default, which still spans the configured interval."""
-    entry = wire_entry_to_registry(
-        make_entry(
-            options={CONF_UPDATE_INTERVAL: 600, CONF_SNAPSHOT_STALENESS: 60}
-        ),
-        hass.registry,
-    )
-    assert await async_setup_entry(hass, entry) is True
-    coordinator = entry.runtime_data.coordinator
-    assert coordinator._staleness_seconds == DEFAULT_SNAPSHOT_STALENESS
-
-
-async def test_coordinator_staleness_floor_never_below_interval(hass) -> None:
-    """A threshold below the interval falls back to whichever of
-    default/interval is larger, so the cache can always span at least
-    one failed poll (here the interval exceeds the shipped default)."""
-    coordinator = NestQuestCoordinator(
-        hass,
-        entry_id="floor",
-        api_client=StubSnapshotClient(),
-        update_interval_seconds=1800,
-        staleness_seconds=60,
-    )
-    assert coordinator._staleness_seconds == 1800
-
-
 async def test_failed_first_refresh_does_not_crash_setup(
     hass, make_entry
 ) -> None:

tests/test_core_settings.py

@@ -14,9 +14,9 @@ Covers the contracts from task 4dd8f870 plus the review fixes:
   test feeds the scanner each bypass shape and asserts it flags them.
 - A settings object constructed with NON-default ``horizon_days`` and
   ``day_rollover_time`` drives a materialization whose resulting window
-  matches the non-default horizon — via the core ``materialize`` path
-  (the integration path it used to share is gone with the integration's
-  database).
+  matches the non-default horizon — via BOTH the core ``materialize``
+  path and the INTEGRATION path (``_run_horizon_materialization`` +
+  ``_register_day_rollover_listener``).
 """
 from __future__ import annotations
 
@@ -29,6 +29,7 @@ from typing import Any
 import pytest
 
 import custom_components.nestquest.core as _core_mod
+from conftest import freeze_nestquest_clock
 
 from custom_components.nestquest.const import (
     CONF_AFTERNOON_REMINDER_ENABLED,
@@ -740,7 +741,7 @@ def test_settings_module_has_no_ha_imports() -> None:
 
 
 # ---------------------------------------------------------------------------
-# Materialization over a non-default horizon (core path).
+# Materialization over a non-default horizon: core path + integration path.
 # ---------------------------------------------------------------------------
 
 
@@ -827,3 +828,85 @@ async def test_materialize_over_non_default_horizon(hass, tmp_path) -> None:
         ) == []
     finally:
         await database.close()
+
+
+async def test_integration_path_threads_settings(
+    hass, tmp_path, monkeypatch
+) -> None:
+    """The integration path threads ``settings`` through horizon_window + rollover.
+
+    ``_run_horizon_materialization`` calls
+    ``settings.horizon_window(today)`` (so the helper is real and shared,
+    not recomputed inline), and ``_register_day_rollover_listener``
+    registers at ``settings.day_rollover_hour_minute``.  This runs the
+    INTEGRATION path with ``horizon_days=3`` and
+    ``day_rollover_time='03:30'`` and asserts the resulting instance
+    window matches [today, today+3] AND the registered hour/minute are 3/30.
+    """
+    import custom_components.nestquest as nestquest
+    from custom_components.nestquest.core.dao_children import ChildrenDao
+    from custom_components.nestquest.core.dao_instances import (
+        QuestInstancesDao,
+    )
+    from custom_components.nestquest.core.quest_definitions import (
+        create_quest_definition,
+    )
+    from custom_components.nestquest.core.recurrence import (
+        RuleType,
+        ScheduleRule,
+    )
+
+    # Freeze the integration clock so "today" is deterministic (the
+    # hass fixture's config.time_zone is UTC, so 2026-03-01 12:00 UTC
+    # localizes to 2026-03-01).
+    freeze_nestquest_clock(
+        monkeypatch, datetime.datetime(2026, 3, 1, 12, 0, tzinfo=datetime.timezone.utc)
+    )
+
+    database = await _prepare(tmp_path / "nq.db", hass.async_add_executor_job)
+    try:
+        settings = NestQuestSettings(horizon_days=3, day_rollover_time="03:30")
+        today = datetime.date(2026, 3, 1)
+
+        NOW = "2026-03-01T12:00:00+00:00"
+        child = await ChildrenDao(database).create("Ada", NOW)
+        await create_quest_definition(
+            database,
+            "Daily chore",
+            ScheduleRule(
+                rule_type=RuleType.DAILY, start_date=today.isoformat()
+            ),
+            [child.id],
+            ["morning"],
+        )
+
+        # Integration path: the window comes from settings.horizon_window.
+        await nestquest._run_horizon_materialization(hass, database, settings)
+
+        end = today + datetime.timedelta(days=3)
+        records = await QuestInstancesDao(database).list_by_date_range(
+            child.id, today.isoformat(), end.isoformat()
+        )
+        dates = sorted({r.due_date for r in records})
+        assert dates == [
+            (today + datetime.timedelta(days=i)).isoformat()
+            for i in range(4)
+        ]
+        beyond = (end + datetime.timedelta(days=1)).isoformat()
+        far = (end + datetime.timedelta(days=10)).isoformat()
+        assert await QuestInstancesDao(database).list_by_date_range(
+            child.id, beyond, far
+        ) == []
+
+        # The rollover listener registers at the configured hour/minute.
+        remove = nestquest._register_day_rollover_listener(
+            hass, database, settings
+        )
+        try:
+            reg = hass.time_change.registrations[-1]
+            assert reg["hour"] == 3
+            assert reg["minute"] == 30
+        finally:
+            remove()
+    finally:
+        await database.close()

tests/test_core_snapshot.py

@@ -10,22 +10,17 @@ child's ``next_present``, a due-timed quest's ``overdue`` under a
 pinned ``now``, the custody ``cycle_day`` (> 1), and the panel payload
 dict shape (``done`` -> ``completed``, ``on_time`` passthrough, and
 ``missed`` omission) are all exercised as literals.
-
-The database is a standalone core one (the integration owns no
-database since Feature 18's DB removal); the closing round-trip pins
-that the integration's coordinator reconstructs the SAME dataclasses
-from the route's payload.
 """
 from __future__ import annotations
 
 import datetime
 from zoneinfo import ZoneInfo
 
-from conftest import set_coordinator_client, wire_entry_to_registry
+from conftest import wire_entry_to_registry
 
 from custom_components.nestquest import async_setup_entry
-from custom_components.nestquest.core.children import create_child
-from custom_components.nestquest.core.completion import complete_instance
+from custom_components.nestquest.children import create_child
+from custom_components.nestquest.completion import complete_instance
 from custom_components.nestquest.core.snapshot import (
     ChildDaySnapshot,
     NestQuestSnapshot,
@@ -33,17 +28,14 @@ from custom_components.nestquest.core.snapshot import (
     build_snapshot,
     instance_payload,
 )
-from custom_components.nestquest.core.dao_instances import QuestInstancesDao
-from custom_components.nestquest.core.dao_presence import (
+from custom_components.nestquest.dao_instances import QuestInstancesDao
+from custom_components.nestquest.dao_presence import (
     PresenceOverridesDao,
     PresenceSchedulesDao,
 )
-from custom_components.nestquest.core.db import NestQuestDatabase
-from custom_components.nestquest.core.materialize import materialize
-from custom_components.nestquest.core.migrations import apply_migrations
-from custom_components.nestquest.core.quest_definitions import create_quest_definition
-from custom_components.nestquest.core.recurrence import ScheduleRule
-from custom_components.nestquest.core.settings import NestQuestSettings
+from custom_components.nestquest.materialize import materialize
+from custom_components.nestquest.quest_definitions import create_quest_definition
+from custom_components.nestquest.recurrence import ScheduleRule
 
 
 async def test_instance_payload_shape_and_missed_omission() -> None:
@@ -113,7 +105,7 @@ async def test_instance_payload_shape_and_missed_omission() -> None:
     )
 
 
-async def test_build_snapshot_explicit_values(hass, make_entry, tmp_path) -> None:
+async def test_build_snapshot_explicit_values(hass, make_entry, monkeypatch) -> None:
     """The builder produces the documented shape as literals, pinned in time.
 
     Ada is AWAY today (a 2-week schedule whose absent week 0 covers today,
@@ -125,12 +117,11 @@ async def test_build_snapshot_explicit_values(hass, make_entry, tmp_path) -> Non
     scheduled active child is Ada, whose 2-week cycle anchored one day
     before today puts ``cycle_day`` at 2.
     """
-    # A standalone core database (the integration owns none): the
-    # builder and its seed run against it through the executor.
-    database = NestQuestDatabase(hass.async_add_executor_job)
-    await database.open(tmp_path / "snapshot.db")
-    await apply_migrations(database)
-    settings = NestQuestSettings()
+    entry = wire_entry_to_registry(make_entry(), hass.registry)
+    assert await async_setup_entry(hass, entry) is True
+    coordinator = entry.runtime_data.coordinator
+    database = entry.runtime_data.database
+    settings = entry.runtime_data.settings
 
     # Single clock read for the seed/snapshot anchor (no midnight skew);
     # the coordinator no longer owns a clock read (the API serves the
@@ -312,6 +303,8 @@ async def test_build_snapshot_explicit_values(hass, make_entry, tmp_path) -> Non
     # The dataclasses are frozen, so == is a full deep compare — a
     # reconstruction that dropped or reshaped a field would diverge
     # here even though the literal assertions above still pass.
+    from conftest import set_coordinator_client
+
     class _PinnedPayloadClient:
         async def get_snapshot(self):
             return {
@@ -335,12 +328,6 @@ async def test_build_snapshot_explicit_values(hass, make_entry, tmp_path) -> Non
                 ],
             }
 
-    entry = wire_entry_to_registry(
-        make_entry(data={"api_base_url": "http://api.test:8000", "panel_token": "tok"}),
-        hass.registry,
-    )
     set_coordinator_client(entry, _PinnedPayloadClient())
-    assert await async_setup_entry(hass, entry) is True
-    coordinator = entry.runtime_data.coordinator
+    await coordinator.async_refresh()
     assert coordinator.data == built
-    await database.close()

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_children.py

@@ -6,15 +6,15 @@ import sqlite3
 
 import pytest
 
-from custom_components.nestquest.core.dao_children import (
+from custom_components.nestquest.dao_children import (
     AdminUserRecord,
     AdminUsersDao,
     ChildRecord,
     ChildrenDao,
 )
-from custom_components.nestquest.core.db import NestQuestDatabase
-from custom_components.nestquest.core.schema import SCHEMA_V1_STATEMENTS
-from custom_components.nestquest.core.migrations import apply_migrations
+from custom_components.nestquest.db import NestQuestDatabase
+from custom_components.nestquest.schema import SCHEMA_V1_STATEMENTS
+from custom_components.nestquest.migrations import apply_migrations
 
 
 def _run(coro):
@@ -504,6 +504,9 @@ def test_children_and_admin_sql_lives_only_in_dao_module() -> None:
         "tests/test_dao_rules.py",  # rules/definitions guard, own scope
         "tests/test_dao_presence.py",  # presence guard, own scope
         "tests/test_dao_instances.py",  # instances guard, own scope
+        "tests/test_startup_db.py",  # row-count probe of the children
+        # table only (proving a fresh setup loads); guard below covers
+        # everything else
     }
     sql_pattern = re.compile(
         r"(FROM|INTO|UPDATE|DELETE\s+FROM|JOIN)\s+"
@@ -555,6 +558,32 @@ def _strip_function_spans(text: str, names: set[str]) -> str:
         for number, line in enumerate(lines, start=1)
         if number not in excluded
     )
+
+
+def test_startup_db_test_file_uses_dao_elsewhere() -> None:
+    """Compensating self-scan for the startup-test exemption: outside
+    the single sanctioned COUNT(*) probe, test_startup_db.py must go
+    through the DAO for children/admin_users data access.
+    """
+    import re
+    from pathlib import Path
+
+    startup_test = Path(__file__).parent / "test_startup_db.py"
+    stripped = _strip_function_spans(
+        startup_test.read_text(),
+        {"test_setup_with_valid_file_preserves_rows"},
+    )
+    sql_pattern = re.compile(
+        r"(SELECT\s[^\"']*?FROM|INSERT\s+INTO|UPDATE|DELETE\s+FROM|"
+        r"FROM|JOIN)\s+[`'\"]*(\[)?(children|admin_users)\b",
+        re.IGNORECASE,
+    )
+    assert sql_pattern.search(stripped) is None, (
+        "test_startup_db.py must go through the DAO for these tables "
+        "outside its sanctioned row-count probe"
+    )
+
+
 def test_dao_matrix_test_file_raw_probes_are_only_constraint_probes() -> None:
     """Compensating self-scan for the matrix-file exemption, structurally
     exact: parse the two sanctioned functions' ASTs and require that

tests/test_dao_instances.py

@@ -7,16 +7,16 @@ import sqlite3
 
 import pytest
 
-from custom_components.nestquest.core.dao_children import ChildrenDao
-from custom_components.nestquest.core.dao_instances import (
+from custom_components.nestquest.dao_children import ChildrenDao
+from custom_components.nestquest.dao_instances import (
     CompletionEventRecord,
     CompletionEventsDao,
     QuestInstanceRecord,
     QuestInstancesDao,
 )
-from custom_components.nestquest.core.dao_rules import ScheduleRulesDao, QuestDefinitionsDao
-from custom_components.nestquest.core.db import NestQuestDatabase
-from custom_components.nestquest.core.migrations import apply_migrations
+from custom_components.nestquest.dao_rules import ScheduleRulesDao, QuestDefinitionsDao
+from custom_components.nestquest.db import NestQuestDatabase
+from custom_components.nestquest.migrations import apply_migrations
 
 
 def _run(coro):

tests/test_dao_matrix.py

@@ -21,24 +21,24 @@ from unittest.mock import AsyncMock, MagicMock
 
 import pytest
 
-from custom_components.nestquest.core.dao_children import (
+from custom_components.nestquest.dao_children import (
     AdminUsersDao,
     ChildrenDao,
 )
-from custom_components.nestquest.core.dao_instances import (
+from custom_components.nestquest.dao_instances import (
     CompletionEventsDao,
     QuestInstancesDao,
 )
-from custom_components.nestquest.core.dao_presence import (
+from custom_components.nestquest.dao_presence import (
     PresenceOverridesDao,
     PresenceSchedulesDao,
 )
-from custom_components.nestquest.core.dao_rules import (
+from custom_components.nestquest.dao_rules import (
     ScheduleRulesDao,
     QuestDefinitionsDao,
 )
-from custom_components.nestquest.core.db import NestQuestDatabase
-from custom_components.nestquest.core.migrations import apply_migrations
+from custom_components.nestquest.db import NestQuestDatabase
+from custom_components.nestquest.migrations import apply_migrations
 
 
 def _run(coro):

tests/test_dao_presence.py

@@ -6,15 +6,15 @@ import sqlite3
 
 import pytest
 
-from custom_components.nestquest.core.dao_children import ChildrenDao
-from custom_components.nestquest.core.dao_presence import (
+from custom_components.nestquest.dao_children import ChildrenDao
+from custom_components.nestquest.dao_presence import (
     PresenceOverrideRecord,
     PresenceOverridesDao,
     PresenceScheduleRecord,
     PresenceSchedulesDao,
 )
-from custom_components.nestquest.core.db import NestQuestDatabase
-from custom_components.nestquest.core.migrations import apply_migrations
+from custom_components.nestquest.db import NestQuestDatabase
+from custom_components.nestquest.migrations import apply_migrations
 
 
 def _run(coro):
@@ -741,12 +741,12 @@ def test_override_create_racing_conflicts_serialize(tmp_path) -> None:
     from unittest.mock import MagicMock
 
     async def _main():
-        from custom_components.nestquest.core.dao_children import ChildrenDao
-        from custom_components.nestquest.core.dao_presence import (
+        from custom_components.nestquest.dao_children import ChildrenDao
+        from custom_components.nestquest.dao_presence import (
             PresenceOverridesDao,
         )
-        from custom_components.nestquest.core.db import NestQuestDatabase
-        from custom_components.nestquest.core.migrations import apply_migrations
+        from custom_components.nestquest.db import NestQuestDatabase
+        from custom_components.nestquest.migrations import apply_migrations
 
         armed = {"active": False, "gated": False}
         gate_open = asyncio_module.Event()

tests/test_dao_rules.py

@@ -6,8 +6,8 @@ import sqlite3
 
 import pytest
 
-from custom_components.nestquest.core.dao_children import ChildrenDao
-from custom_components.nestquest.core.dao_rules import (
+from custom_components.nestquest.dao_children import ChildrenDao
+from custom_components.nestquest.dao_rules import (
     ScheduleRuleRecord,
     ScheduleRuleStorage,
     ScheduleRulesDao,
@@ -17,9 +17,9 @@ from custom_components.nestquest.core.dao_rules import (
     schedule_rule_from_storage,
     schedule_rule_to_storage,
 )
-from custom_components.nestquest.core.db import NestQuestDatabase
-from custom_components.nestquest.core.migrations import apply_migrations
-from custom_components.nestquest.core.recurrence import (
+from custom_components.nestquest.db import NestQuestDatabase
+from custom_components.nestquest.migrations import apply_migrations
+from custom_components.nestquest.recurrence import (
     RuleType,
     RuleValidationError,
     ScheduleRule,
@@ -341,7 +341,7 @@ def test_rule_delete_concurrent_with_definition_create_is_safe(
                 # delete task has been scheduled, so the create holds
                 # the connection lock while the delete queues behind
                 # it — then the create proceeds and wins.
-                import custom_components.nestquest.core.dao_rules as dao_rules
+                import custom_components.nestquest.dao_rules as dao_rules
 
                 original_validate = (
                     dao_rules.QuestDefinitionsDao._validate_rule_exists

tests/test_db.py

@@ -14,7 +14,7 @@ import pytest
 from conftest import executor_for, make_hass
 
 import custom_components.nestquest.core.db as db_module
-from custom_components.nestquest.core.db import NestQuestDatabase
+from custom_components.nestquest.db import NestQuestDatabase
 
 
 def _run(coro):
@@ -933,3 +933,68 @@ def test_execute_many_exposes_rowcount(tmp_path) -> None:
 
 
 # ---------------------------------------------------------------------------
+# Lifecycle wiring: opened once per entry, closed on unload
+# ---------------------------------------------------------------------------
+
+
+async def test_setup_entry_opens_database_in_runtime_data(hass, make_entry) -> None:
+    from conftest import wire_entry_to_registry
+
+    from custom_components.nestquest import async_setup_entry, async_unload_entry
+
+    entry = wire_entry_to_registry(make_entry(), hass.registry)
+    assert await async_setup_entry(hass, entry) is True
+    runtime = entry.runtime_data
+    assert runtime.database is not None
+    assert runtime.database.connected is True
+    await async_unload_entry(hass, entry)
+
+
+async def test_unload_entry_closes_database(hass, make_entry) -> None:
+    from conftest import wire_entry_to_registry
+
+    from custom_components.nestquest import async_setup_entry, async_unload_entry
+
+    entry = wire_entry_to_registry(make_entry(), hass.registry)
+    await async_setup_entry(hass, entry)
+    database = entry.runtime_data.database
+    assert database.connected is True
+    assert await async_unload_entry(hass, entry) is True
+    assert database.connected is False
+    with pytest.raises(RuntimeError, match="closed"):
+        await database.fetch_one("SELECT 1")
+
+
+async def test_second_setup_does_not_open_second_connection(hass, make_entry) -> None:
+    from conftest import wire_entry_to_registry
+
+    from custom_components.nestquest import async_setup_entry, async_unload_entry
+
+    entry = wire_entry_to_registry(make_entry(), hass.registry)
+    await async_setup_entry(hass, entry)
+    first = entry.runtime_data.database
+
+    await async_setup_entry(hass, entry)
+    second = entry.runtime_data.database
+
+    assert first is second
+    assert first.connected is True
+    await async_unload_entry(hass, entry)
+
+
+async def test_setup_unload_cycles_reopen_fresh_connection(hass, make_entry) -> None:
+    from conftest import wire_entry_to_registry
+
+    from custom_components.nestquest import async_setup_entry, async_unload_entry
+
+    entry = wire_entry_to_registry(make_entry(), hass.registry)
+    seen: list[NestQuestDatabase] = []
+    for _ in range(3):
+        await async_setup_entry(hass, entry)
+        runtime = entry.runtime_data
+        assert runtime.database.connected is True
+        seen.append(runtime.database)
+        await async_unload_entry(hass, entry)
+        assert runtime.database.connected is False
+    assert len(set(seen)) == 3
+    assert hass.data == {}

tests/test_entity_lifecycle.py

@@ -1,16 +1,24 @@
-"""Entity lifecycle across child add/deactivate/reactivate (Feature 10, task 8).
-
-The household state the entities mirror comes from the API service's
-panel route, so a deactivate/reactivate/add is scripted as a payload
-change served by :class:`conftest.StubSnapshotClient`; the reload
-(unload + setup) re-polls it, exactly as production does.
-"""
+"""Entity lifecycle across child add/deactivate/reactivate (Feature 10, task 8)."""
 from __future__ import annotations
 
-from conftest import StubSnapshotClient, set_coordinator_client, wire_entry_to_registry
+import datetime
+
+from conftest import wire_entry_to_registry
 
 from custom_components.nestquest import async_setup_entry, async_unload_entry
+from custom_components.nestquest.children import (
+    create_child,
+    list_children,
+    set_child_active,
+)
+from custom_components.nestquest.const import DOMAIN
+from custom_components.nestquest.materialize import materialize
+from custom_components.nestquest.quest_definitions import (
+    create_quest_definition,
+)
+from custom_components.nestquest.recurrence import ScheduleRule
 
+SEED_HORIZON_DAYS = 3
 PER_CHILD_KINDS = (
     "quests_due_today",
     "quests_completed_today",
@@ -26,78 +34,6 @@ HOUSEHOLD_UNIQUE_IDS = (
     "nestquest_cycle_day",
 )
 
-ADA = 1
-BO = 2
-CORY_ID = 4
-
-
-def _child(child_id: int, name: str, *, present=True, instances=()):
-    completed = sum(1 for i in instances if i["state"] == "completed")
-    due = len(instances)
-    return {
-        "child_id": child_id,
-        "child_name": name,
-        "present": present,
-        "next_present": None,
-        "due_today": due,
-        "completed_today": completed,
-        "remaining_today": due - completed,
-        "completion_pct": 100 if due == 0 else round(completed / due * 100),
-        "instances": list(instances),
-    }
-
-
-def _instance(instance_id: int, child_id: int, *, state="open") -> dict:
-    return {
-        "id": instance_id,
-        "definition_id": 3,
-        "child_id": child_id,
-        "title": "Brush teeth",
-        "icon": "🦷",
-        "window": "morning",
-        "due_time": "08:00",
-        "state": state,
-        "overdue": False,
-        "completed_at": None if state == "open" else "2026-09-23T07:55:00+00:00",
-        "on_time": None if state == "open" else True,
-    }
-
-
-def _payload(children) -> dict:
-    return {
-        "today_iso": "2026-09-23",
-        "cycle_day": 0,
-        "children": list(children),
-    }
-
-
-#: The full household (Ada + Bo, one daily quest each) and the states
-#: the lifecycle walks through: Bo deactivated, reactivated, completed.
-_BOTH = _payload(
-    [
-        _child(ADA, "Ada", instances=[_instance(7, ADA)]),
-        _child(BO, "Bo", instances=[_instance(8, BO)]),
-    ]
-)
-_BO_GONE = _payload([_child(ADA, "Ada", instances=[_instance(7, ADA)])])
-_BO_DONE = _payload(
-    [
-        _child(ADA, "Ada", instances=[_instance(7, ADA)]),
-        _child(BO, "Bo", instances=[_instance(8, BO, state="completed")]),
-    ]
-)
-_ADA_ONLY = _payload([_child(ADA, "Ada", instances=[_instance(7, ADA)])])
-_ADA_AND_CORY = _payload(
-    [
-        _child(ADA, "Ada", instances=[_instance(7, ADA)]),
-        _child(CORY_ID, "Cory"),
-    ]
-)
-
-
-def _child_unique_ids(child_id: int) -> set[str]:
-    return {f"nestquest_child_{child_id}_{kind}" for kind in PER_CHILD_KINDS}
-
 
 async def _reload(hass, entry) -> None:
     """Unload then set up: the harness's restart/reload equivalent."""
@@ -105,36 +41,46 @@ async def _reload(hass, entry) -> None:
     assert await async_setup_entry(hass, entry) is True
 
 
-async def _setup_with_household(hass, make_entry, *payloads):
-    """Set up the entry with a scripted, ordered snapshot history."""
-    entry = wire_entry_to_registry(
-        make_entry(
-            data={"api_base_url": "http://api.test:8000", "panel_token": "tok"}
-        ),
-        hass.registry,
-    )
-    client = set_coordinator_client(entry, StubSnapshotClient(*payloads))
+def _child_unique_ids(child_id: int) -> set[str]:
+    return {f"nestquest_child_{child_id}_{kind}" for kind in PER_CHILD_KINDS}
+
+
+async def _setup_and_seed(hass, make_entry):
+    entry = wire_entry_to_registry(make_entry(), hass.registry)
     assert await async_setup_entry(hass, entry) is True
-    return entry, entry.runtime_data.coordinator, client
+    database = entry.runtime_data.database
+    ada = await create_child(database, "Ada")
+    bo = await create_child(database, "Bo")
+    today = datetime.date.today()
+    await create_quest_definition(
+        database,
+        "Brush teeth",
+        ScheduleRule.from_dict(
+            {"rule_type": "daily", "start_date": today.isoformat()}
+        ),
+        [ada.id, bo.id],
+        ["morning"],
+    )
+    end = (today + datetime.timedelta(days=SEED_HORIZON_DAYS)).isoformat()
+    await materialize(database, today.isoformat(), end, today=today)
+    await entry.runtime_data.coordinator.async_refresh()
+    return entry, ada, bo
 
 
 async def test_deactivated_child_entities_removed_on_reload(
     hass, make_entry
 ) -> None:
-    """A child absent from the API's snapshot loses its entities on
-    reload; the surviving child's entities are untouched."""
-    entry, _coordinator, _client = await _setup_with_household(
-        hass, make_entry, _BOTH, _BO_GONE
-    )
-    assert _child_unique_ids(ADA) <= set(hass.entities)
-    assert _child_unique_ids(BO) <= set(hass.entities)
+    entry, ada, bo = await _setup_and_seed(hass, make_entry)
+    assert _child_unique_ids(ada.id) <= set(hass.entities)
+    assert _child_unique_ids(bo.id) <= set(hass.entities)
 
+    await set_child_active(entry.runtime_data.database, bo.id, False)
     await _reload(hass, entry)
 
-    assert _child_unique_ids(ADA) <= set(hass.entities), (
+    assert _child_unique_ids(ada.id) <= set(hass.entities), (
         "the surviving child's entities must be untouched"
     )
-    assert not (_child_unique_ids(BO) & set(hass.entities)), (
+    assert not (_child_unique_ids(bo.id) & set(hass.entities)), (
         "the deactivated child's entities must be gone after reload"
     )
 
@@ -142,61 +88,100 @@ async def test_deactivated_child_entities_removed_on_reload(
 async def test_reactivation_restores_entities_with_original_unique_ids(
     hass, make_entry
 ) -> None:
-    original = _child_unique_ids(BO)
-    entry, _coordinator, _client = await _setup_with_household(
-        hass, make_entry, _BOTH, _BO_GONE, _BOTH
-    )
+    entry, ada, bo = await _setup_and_seed(hass, make_entry)
+    original = _child_unique_ids(bo.id)
+    await set_child_active(entry.runtime_data.database, bo.id, False)
     await _reload(hass, entry)
     assert not (original & set(hass.entities))
 
+    await set_child_active(entry.runtime_data.database, bo.id, True)
     await _reload(hass, entry)
 
     assert original <= set(hass.entities), (
         "reactivation must restore the exact original unique_ids"
     )
-    bo_due = hass.entities[f"nestquest_child_{BO}_quests_due_today"]
+    bo_due = hass.entities[f"nestquest_child_{bo.id}_quests_due_today"]
     assert bo_due.native_value == 1, "restored entities carry live state"
 
 
 async def test_new_child_gets_entities_without_disturbing_existing(
     hass, make_entry
 ) -> None:
-    """A child ADDED to the API's snapshot gains its entities on
-    reload; the existing children's entities are untouched."""
-    entry, _coordinator, _client = await _setup_with_household(
-        hass, make_entry, _ADA_ONLY, _ADA_AND_CORY
-    )
-    before_ada = set(hass.entities) & _child_unique_ids(ADA)
+    entry, ada, bo = await _setup_and_seed(hass, make_entry)
+    before_ada = set(hass.entities) & _child_unique_ids(ada.id)
 
+    cory = await create_child(entry.runtime_data.database, "Cory")
     await _reload(hass, entry)
 
     assert before_ada <= set(hass.entities), "existing entities untouched"
-    assert _child_unique_ids(CORY_ID) <= set(hass.entities), (
+    assert _child_unique_ids(cory.id) <= set(hass.entities), (
         "the new child's entities appear after reload"
     )
-    assert hass.entities[
-        f"nestquest_child_{CORY_ID}_quests_due_today"
-    ].native_value == 0
+    assert hass.entities[f"nestquest_child_{cory.id}_quests_due_today"].native_value == 0
 
 
 async def test_restart_equivalent_restores_all_entity_states(
     hass, make_entry
 ) -> None:
     """Unload + setup (the restart equivalent) restores every active
-    child's entities with the API's current states and the household
-    rollups."""
-    entry, _coordinator, _client = await _setup_with_household(
-        hass, make_entry, _BOTH, _BO_DONE
+    child's entities with correct states and the household rollups."""
+    from custom_components.nestquest.completion import complete_instance
+
+    entry, ada, bo = await _setup_and_seed(hass, make_entry)
+    coordinator = entry.runtime_data.coordinator
+    snapshot_ada = next(
+        child
+        for child in coordinator.data.children
+        if child.child_id == ada.id
     )
+    await complete_instance(
+        entry.runtime_data.database,
+        snapshot_ada.instances[0].instance_id,
+        actor_source="panel",
+        actor_child_id=ada.id,
+    )
+    await coordinator.async_refresh()
+    assert hass.entities[
+        f"nestquest_child_{ada.id}_quests_completed_today"
+    ].native_value == 1
+
     await _reload(hass, entry)
 
     assert hass.entities[
-        f"nestquest_child_{ADA}_quests_completed_today"
-    ].native_value == 0
+        f"nestquest_child_{ada.id}_quests_completed_today"
+    ].native_value == 1, "completed count survives the restart"
     assert hass.entities[
-        f"nestquest_child_{BO}_quests_completed_today"
-    ].native_value == 1, "the API's recorded completion survives the restart"
+        f"nestquest_child_{bo.id}_quests_completed_today"
+    ].native_value == 0
     assert set(HOUSEHOLD_UNIQUE_IDS) <= set(hass.entities)
     assert hass.entities[
         "nestquest_household_quests_completed_today"
     ].native_value == 1
+
+
+async def test_unload_shuts_coordinator_before_closing_database(
+    hass, make_entry
+) -> None:
+    """The coordinator's listeners are cleared while the database is
+    still connected: a scheduled refresh must never race the close."""
+    entry = wire_entry_to_registry(make_entry(), hass.registry)
+    assert await async_setup_entry(hass, entry) is True
+    coordinator = entry.runtime_data.coordinator
+    database = entry.runtime_data.database
+    seen_connected = []
+
+    async def _probe_shutdown():
+        seen_connected.append(database.connected)
+
+    original_close = database.close
+
+    async def _recording_close():
+        seen_connected.append("closing")
+        await original_close()
+
+    coordinator.async_shutdown = _probe_shutdown
+    database.close = _recording_close
+    assert await async_unload_entry(hass, entry) is True
+    assert seen_connected == [True, "closing"], (
+        "coordinator shutdown must precede the database close"
+    )

tests/test_entity_matrix.py

@@ -2,156 +2,72 @@
 
 One fixture drives every assertion the done-condition names: correct
 values for every sensor and binary sensor (including the zero-quest
-child and the 255-character state limit), the completed/uncompleted/
-day-complete events re-fired exactly once from the API's SSE frames,
-the panel payload omitting missed instances while admin_instances
-equals it, and no entities for a child the API does not report.  The
-per-task test files cover each behavior in depth; this file is the
-single pass that proves them all against ONE fixture, so a regression
-in any contract fails here too.
-
-Since the DB removal the household state and every transition come
-from the API service, so the fixture scripts the panel route's
-payloads and completion surface (:class:`conftest.ScriptedPanelClient`)
-and delivers the transition frames through the SSE subscription — the
-production event path.
+child and the 255-character state limit), the three events firing
+exactly once with schema-valid payloads, the instances payload
+omitting missed instances while admin_instances includes them, and no
+entities for an inactive child.  The per-task test files cover each
+behavior in depth; this file is the single pass that proves them all
+against ONE fixture, so a regression in any contract fails here too.
 """
 from __future__ import annotations
 
+import datetime
 import re
 
-from conftest import ScriptedPanelClient, set_coordinator_client, wire_entry_to_registry
+from conftest import wire_entry_to_registry
 
 from custom_components.nestquest import async_setup_entry
+from custom_components.nestquest.children import (
+    create_child,
+    list_children,
+    set_child_active,
+)
+from custom_components.nestquest.completion import derive_state
 from custom_components.nestquest.const import (
+    CONF_ADMIN_USER_IDS,
     DOMAIN,
     EVENT_CHILD_DAY_COMPLETE,
     EVENT_QUEST_COMPLETED,
     EVENT_QUEST_UNCOMPLETED,
     SERVICE_COMPLETE_QUEST,
+    SERVICE_UNCOMPLETE_QUEST,
 )
+from custom_components.nestquest.dao_instances import QuestInstancesDao
+from custom_components.nestquest.materialize import materialize
+from custom_components.nestquest.quest_definitions import (
+    create_quest_definition,
+)
+from custom_components.nestquest.recurrence import ScheduleRule
 
 _TIMESTAMP = re.compile(r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\+00:00$")
 
-ADA = 1
-BO = 2
-CORY = 3
-
-_OCCURRED = "2026-09-23T07:55:00+00:00"
-
-
-def _instance(instance_id: int, child_id: int, *, window="morning", state="open"):
-    return {
-        "id": instance_id,
-        "definition_id": 3,
-        "child_id": child_id,
-        "title": "Brush teeth",
-        "icon": "🦷",
-        "window": window,
-        "due_time": "08:00" if window == "morning" else "19:00",
-        "state": state,
-        "overdue": False,
-        "completed_at": None if state == "open" else _OCCURRED,
-        "on_time": None if state == "open" else True,
-    }
-
-
-def _child(child_id: int, name: str, instances=()):
-    completed = sum(1 for i in instances if i["state"] == "completed")
-    due = len(instances)
-    return {
-        "child_id": child_id,
-        "child_name": name,
-        "present": True,
-        "next_present": None,
-        "due_today": due,
-        "completed_today": completed,
-        "remaining_today": due - completed,
-        "completion_pct": 100 if due == 0 else round(completed / due * 100),
-        "instances": list(instances),
-    }
-
-
-def _payload(children, cycle_day=0) -> dict:
-    return {
-        "today_iso": "2026-09-23",
-        "cycle_day": cycle_day,
-        "children": list(children),
-    }
-
-
-def _completed_frame(instance_id: int, child_id: int, child_name: str, window: str):
-    """The completed-event frame the API service publishes for one
-    panel completion (the day-complete rule is the API's; its payload
-    shape is pinned by tests/test_api_sse.py on the production
-    plane)."""
-    return (
-        EVENT_QUEST_COMPLETED,
-        {
-            "child_id": child_id,
-            "child_name": child_name,
-            "instance_id": instance_id,
-            "quest_title": "Brush teeth",
-            "window": window,
-            "due_date": "2026-09-23",
-            "due_time": "08:00" if window == "morning" else "19:00",
-            "occurred_at": _OCCURRED,
-            "was_on_time": True,
-        },
-    )
-
-
-def _day_complete_frame(child_id: int, child_name: str):
-    """The day-complete frame the API publishes once a child's day
-    clears (after the LAST completion of the day)."""
-    return (
-        EVENT_CHILD_DAY_COMPLETE,
-        {
-            "child_id": child_id,
-            "child_name": child_name,
-            "quests_due": 2,
-            "quests_completed": 2,
-            "occurred_at": _OCCURRED,
-        },
-    )
-
 
 async def _fixture(hass, make_entry):
-    """Two quest children, one zero-quest child; the inactive child is
-    simply ABSENT from the API's snapshot (the API only reports active
-    children, so the integration can never create its entities)."""
+    """Two quest children, one zero-quest child, one inactive child."""
     entry = wire_entry_to_registry(
-        make_entry(
-            data={"api_base_url": "http://api.test:8000", "panel_token": "tok"}
-        ),
-        hass.registry,
+        make_entry(data={CONF_ADMIN_USER_IDS: ["admin-1"]}), hass.registry
     )
-    client = ScriptedPanelClient(
-        _payload(
-            [
-                _child(ADA, "Ada", [_instance(7, ADA), _instance(8, ADA, window="evening")]),
-                _child(BO, "Bo", [_instance(9, BO), _instance(10, BO, window="evening")]),
-                _child(CORY, "Cory"),
-            ]
-        ),
-        _payload(
-            [
-                _child(
-                    ADA,
-                    "Ada",
-                    [
-                        _instance(7, ADA, state="completed"),
-                        _instance(8, ADA, window="evening", state="completed"),
-                    ],
-                ),
-                _child(BO, "Bo", [_instance(9, BO), _instance(10, BO, window="evening")]),
-                _child(CORY, "Cory"),
-            ]
-        ),
-    )
-    set_coordinator_client(entry, client)
     assert await async_setup_entry(hass, entry) is True
-    return entry, client
+    database = entry.runtime_data.database
+    ada = await create_child(database, "Ada")
+    bo = await create_child(database, "Bo")
+    cory = await create_child(database, "Cory")
+    ghost = await create_child(database, "Ghost")
+    await set_child_active(database, ghost.id, False)
+    today = datetime.date.today()
+    await create_quest_definition(
+        database,
+        "Brush teeth",
+        ScheduleRule.from_dict(
+            {"rule_type": "daily", "start_date": today.isoformat()}
+        ),
+        [ada.id, bo.id],
+        ["morning", "evening"],
+    )
+    end = (today + datetime.timedelta(days=3)).isoformat()
+    await materialize(database, today.isoformat(), end, today=today)
+    await entry.runtime_data.coordinator.async_refresh()
+    return entry, (ada, bo, cory, ghost)
 
 
 def _sensor(hass, child_id, kind):
@@ -159,11 +75,11 @@ def _sensor(hass, child_id, kind):
 
 
 async def test_entity_and_event_matrix(hass, make_entry) -> None:
-    entry, client = await _fixture(hass, make_entry)
+    entry, (ada, bo, cory, ghost) = await _fixture(hass, make_entry)
     coordinator = entry.runtime_data.coordinator
 
-    # --- Every reported child has the full entity set; the child the
-    # API does not report has none.
+    # --- Every active child has the full entity set; the inactive
+    # child has none.
     kinds = (
         "quests_due_today",
         "quests_completed_today",
@@ -173,37 +89,36 @@ async def test_entity_and_event_matrix(hass, make_entry) -> None:
         "all_done",
         "present_today",
     )
-    ghost_id = 99
-    for child in (ADA, BO, CORY):
+    for child in (ada, bo, cory):
         for kind in kinds:
-            assert f"{DOMAIN}_child_{child}_{kind}" in hass.entities, kind
+            assert f"{DOMAIN}_child_{child.id}_{kind}" in hass.entities, kind
     for kind in kinds:
-        assert f"{DOMAIN}_child_{ghost_id}_{kind}" not in hass.entities, (
-            "children absent from the API snapshot must have no entities"
+        assert f"{DOMAIN}_child_{ghost.id}_{kind}" not in hass.entities, (
+            "inactive children must have no entities"
         )
 
     # --- Correct values against the fixture: Ada and Bo owe two
     # quests (morning + evening), Cory owes none and is still 100%.
-    for child in (ADA, BO):
-        assert _sensor(hass, child, "quests_due_today").native_value == 2
+    for child in (ada, bo):
+        assert _sensor(hass, child.id, "quests_due_today").native_value == 2
         assert (
-            _sensor(hass, child, "quests_completed_today").native_value == 0
+            _sensor(hass, child.id, "quests_completed_today").native_value == 0
         )
         assert (
-            _sensor(hass, child, "quests_remaining_today").native_value == 2
+            _sensor(hass, child.id, "quests_remaining_today").native_value == 2
         )
         assert (
-            _sensor(hass, child, "completion_pct_today").native_value == 0
+            _sensor(hass, child.id, "completion_pct_today").native_value == 0
         )
-        assert _sensor(hass, child, "next_quest").native_value == (
+        assert _sensor(hass, child.id, "next_quest").native_value == (
             "Brush teeth"
         )
-        assert _sensor(hass, child, "all_done").is_on is False
-        assert _sensor(hass, child, "present_today").is_on is True
-    assert _sensor(hass, CORY, "quests_due_today").native_value == 0
-    assert _sensor(hass, CORY, "completion_pct_today").native_value == 100
-    assert _sensor(hass, CORY, "all_done").is_on is False
-    assert _sensor(hass, CORY, "next_quest").native_value == "none"
+        assert _sensor(hass, child.id, "all_done").is_on is False
+        assert _sensor(hass, child.id, "present_today").is_on is True
+    assert _sensor(hass, cory.id, "quests_due_today").native_value == 0
+    assert _sensor(hass, cory.id, "completion_pct_today").native_value == 100
+    assert _sensor(hass, cory.id, "all_done").is_on is False
+    assert _sensor(hass, cory.id, "next_quest").native_value == "none"
 
     # --- Household rollups equal the per-child sums.
     assert hass.entities[
@@ -223,31 +138,22 @@ async def test_entity_and_event_matrix(hass, make_entry) -> None:
         ), unique_id
 
     # --- Completing both of Ada's quests fires the events exactly
-    # once each and flips her entities immediately.  The transition
-    # events arrive over the API's SSE stream (the subscription
-    # re-fires them), never from the service handler.
-    await hass.services.call(
-        DOMAIN,
-        SERVICE_COMPLETE_QUEST,
-        {"instance_id": 7, "actor": "panel", "actor_child_id": ADA},
+    # once each and flips her entities immediately.
+    instances = await QuestInstancesDao(
+        entry.runtime_data.database
+    ).list_by_date_range(
+        ada.id, datetime.date.today().isoformat(), datetime.date.today().isoformat()
     )
-    await hass.services.call(
-        DOMAIN,
-        SERVICE_COMPLETE_QUEST,
-        {"instance_id": 8, "actor": "panel", "actor_child_id": ADA},
-    )
-    client.published_frames.extend(
-        [
-            _completed_frame(7, ADA, "Ada", "morning"),
-            _completed_frame(8, ADA, "Ada", "evening"),
-            # The API publishes the day-complete frame only when the
-            # day clears — after the LAST completion of the day.
-            _day_complete_frame(ADA, "Ada"),
-        ]
-    )
-    from conftest import refire_api_transitions
-
-    await refire_api_transitions(hass, entry, client)
+    for instance in instances:
+        await hass.services.call(
+            DOMAIN,
+            SERVICE_COMPLETE_QUEST,
+            {
+                "instance_id": instance.id,
+                "actor": "panel",
+                "actor_child_id": ada.id,
+            },
+        )
     assert len(hass.bus.fired(EVENT_QUEST_COMPLETED)) == 2
     for payload in hass.bus.fired(EVENT_QUEST_COMPLETED):
         assert _TIMESTAMP.match(payload["occurred_at"])
@@ -256,53 +162,56 @@ async def test_entity_and_event_matrix(hass, make_entry) -> None:
         assert payload["quest_title"] == "Brush teeth"
         assert isinstance(payload["instance_id"], int)
     assert len(hass.bus.fired(EVENT_CHILD_DAY_COMPLETE)) == 1
-    # The next scripted snapshot reflects both completions.
-    await coordinator.async_refresh()
-    assert _sensor(hass, ADA, "all_done").is_on is True
-    assert _sensor(hass, ADA, "quests_remaining_today").native_value == 0
+    assert _sensor(hass, ada.id, "all_done").is_on is True
+    assert _sensor(hass, ada.id, "quests_remaining_today").native_value == 0
     assert (
-        _sensor(hass, ADA, "completion_pct_today").native_value == 100
+        _sensor(hass, ada.id, "completion_pct_today").native_value == 100
     )
 
-    # --- Reversing one quest fires the uncompleted event exactly once.
-    #  The HA ``uncomplete_quest`` service is gone (the API service's
-    # admin route is the reversal path), so the reversal is the API's:
-    # it publishes the uncompleted frame and the integration re-fires
-    # it; the coordinator's next poll picks the restored counts up.
-    client.published_frames.append(
-        (
-            EVENT_QUEST_UNCOMPLETED,
-            {
-                "child_id": ADA,
-                "child_name": "Ada",
-                "instance_id": 7,
-                "quest_title": "Brush teeth",
-                "window": "morning",
-                "due_date": "2026-09-23",
-                "due_time": "08:00",
-                "occurred_at": _OCCURRED,
-            },
-        )
+    # --- Reversing one quest fires the uncompleted event exactly once
+    # and restores the owed counts.
+    await hass.services.call(
+        DOMAIN,
+        SERVICE_UNCOMPLETE_QUEST,
+        {"instance_id": instances[0].id, "actor": "user"},
+        context={"user_id": "admin-1"},
     )
-    await refire_api_transitions(hass, entry, client)
     assert len(hass.bus.fired(EVENT_QUEST_UNCOMPLETED)) == 1
+    assert _sensor(hass, ada.id, "all_done").is_on is False
+    assert _sensor(hass, ada.id, "quests_remaining_today").native_value == 1
 
-    # --- The panel payload omits missed instances (D-009) — the API
-    # panel route omits missed rows ENTIRELY, so admin_instances
-    # cannot carry them either (the admin surface for missed quests is
-    # the PWA, reading the API directly).  A snapshot built from the
-    # payload can only ever hold open and completed rows: pin that
-    # the payload round-trips verbatim.
+    # --- The instances payload omits missed instances (D-009) — and
+    # since Feature 18 the snapshot comes from the API panel route,
+    # which omits missed rows ENTIRELY, so admin_instances cannot
+    # carry them either (the admin surface for missed quests is the
+    # PWA, reading the API directly): pin the derive clock forward in
+    # the TEST ONLY so today's open instances read missed.
+    original_refresh = coordinator._async_update_data
+
+    async def _future_dated_refresh():
+        import custom_components.nestquest.core.snapshot as snapshot_module
+
+        real_derive = snapshot_module.derive_state
+
+        def _derive(instance, latest, today):
+            return real_derive(instance, latest, today + datetime.timedelta(days=1))
+
+        snapshot_module.derive_state = _derive
+        try:
+            return await original_refresh()
+        finally:
+            snapshot_module.derive_state = real_derive
+
+    coordinator._async_update_data = _future_dated_refresh
     await coordinator.async_refresh()
-    attributes = _sensor(hass, BO, "quests_due_today").extra_state_attributes
-    assert attributes["instances"] == [
-        dict(_instance(9, BO)),
-        dict(_instance(10, BO, window="evening")),
-    ], "the panel payload round-trips the API's open rows verbatim"
-    assert attributes["admin_instances"] == attributes["instances"], (
+    attributes = _sensor(hass, bo.id, "quests_due_today").extra_state_attributes
+    assert attributes["instances"] == [], "panel payload omits missed"
+    assert attributes["admin_instances"] == [], (
         "the API payload omits missed rows, so the admin payload "
         "carries none either (the PWA is the admin surface now)"
     )
+    coordinator._async_update_data = original_refresh
+    await coordinator.async_refresh()
 
 
 async def test_payload_schema_matches_the_documented_contract(
@@ -310,16 +219,21 @@ async def test_payload_schema_matches_the_documented_contract(
 ) -> None:
     """Every fired payload carries the documented fields with the
     documented types."""
-    entry, client = await _fixture(hass, make_entry)
+    entry, (ada, _bo, _cory, _ghost) = await _fixture(hass, make_entry)
+    instances = await QuestInstancesDao(
+        entry.runtime_data.database
+    ).list_by_date_range(
+        ada.id, datetime.date.today().isoformat(), datetime.date.today().isoformat()
+    )
     await hass.services.call(
         DOMAIN,
         SERVICE_COMPLETE_QUEST,
-        {"instance_id": 7, "actor": "panel", "actor_child_id": ADA},
+        {
+            "instance_id": instances[0].id,
+            "actor": "panel",
+            "actor_child_id": ada.id,
+        },
     )
-    client.published_frames.append(_completed_frame(7, ADA, "Ada", "morning"))
-    from conftest import refire_api_transitions
-
-    await refire_api_transitions(hass, entry, client)
     payload = hass.bus.fired(EVENT_QUEST_COMPLETED)[0]
     for key, check in (
         ("child_id", lambda v: isinstance(v, int)),

tests/test_lifecycle.py

@@ -9,103 +9,27 @@ from conftest import make_config_entry, make_hass, wire_entry_to_registry
 
 from custom_components.nestquest import DOMAIN, async_setup_entry, async_unload_entry
 from custom_components.nestquest.const import (
+    CONF_ADMIN_USER_IDS,
+    CONF_DAY_ROLLOVER_TIME,
+    CONF_HORIZON_DAYS,
+    CONF_MORNING_SUMMARY_TIME,
+    DEFAULT_HORIZON_DAYS,
+    SERVICE_REGENERATE,
     DOMAIN as DOMAIN_CONST,
-    SERVICE_COMPLETE_QUEST,
-)
-from custom_components.nestquest.dashboard import (
-    DASHBOARD_STRATEGY_TYPE,
-    DASHBOARD_URL_PATH,
-    async_register_dashboard,
 )
 
+ADMIN_ID = "admin-1"
+ADMIN_CTX = {"user_id": ADMIN_ID}
+
+
+def _admin_data():
+    return {CONF_ADMIN_USER_IDS: [ADMIN_ID]}
+
 
 def _wire(entry, registry):
     return wire_entry_to_registry(entry, registry)
 
 
-class FakeDashboardStore:
-    """Stand-in for a per-dashboard CONTENT manager (LovelaceStorage).
-
-    In the real API the dashboard CONFIG (the strategy reference) is
-    saved through THIS manager's ``async_save``, NOT through the
-    metadata collection — so every strategy-save assertion reads here.
-    """
-
-    def __init__(self) -> None:
-        self.saved: list[dict] = []
-        self.config: dict | None = None
-
-    async def async_save(self, config: dict) -> None:
-        self.saved.append(dict(config))
-        self.config = dict(config)
-
-
-class FakeDashboardsCollection:
-    """Stand-in mirroring the REAL Lovelace dashboards API shapes.
-
-    Faithful to ``homeassistant/components/lovelace`` +
-    ``helpers/collection.py``: ``async_items()`` is a SYNC ``@callback``
-    (ObservableCollection.async_items returns list(data.values())),
-    ``async_create_item`` IS async, and — mirroring lovelace's
-    ``storage_dashboard_changed`` listener — a successful create
-    registers a fresh CONTENT manager under
-    ``hass.data["lovelace"]["dashboards"][url_path]``, which is where
-    the dashboard config is then saved.  Records ``async_create_item``
-    calls so tests can assert exactly what the setup path registered —
-    and that a reload registers nothing more.
-    """
-
-    def __init__(self, hass, items=None) -> None:
-        self.hass = hass
-        self.items = list(items or [])
-        self.created: list[dict] = []
-        #: url_path -> content manager, mirroring the real listener's
-        # registrations (pre-existing items included).
-        self.stores: dict[str, FakeDashboardStore] = {}
-
-    def async_items(self):
-        """SYNC, like the real ``ObservableCollection.async_items``."""
-        return list(self.items)
-
-    async def async_create_item(self, item_config: dict) -> None:
-        # The real collection awaits validation and change notification
-        # around the item insertion; yield first so two concurrent
-        # callers without a single-flight guard would BOTH get here.
-        await asyncio.sleep(0)
-        self.created.append(dict(item_config))
-        self.items.append(dict(item_config))
-        self.stores[item_config["url_path"]] = FakeDashboardStore()
-        self.hass.data["lovelace"]["dashboards"][item_config["url_path"]] = (
-            self.stores[item_config["url_path"]]
-        )
-
-
-def _install_dashboard_collection(
-    hass, items=None
-) -> FakeDashboardsCollection:
-    """Install the REAL-API-shaped lovelace surfaces on the hass stub.
-
-    Mirrors what lovelace's ``async_setup`` leaves behind in storage
-    mode: ``hass.data["lovelace"]`` is a DICT with the metadata
-    collection under ``dashboards_collection`` and the per-url_path
-    CONTENT managers under ``dashboards``.  Any pre-existing item gets
-    a content manager, exactly as lovelace's change listener would
-    have registered one when the dashboard was created.
-    """
-    collection = FakeDashboardsCollection(hass, items)
-    hass.data["lovelace"] = {
-        "mode": "storage",
-        "dashboards": {},
-        "dashboards_collection": collection,
-    }
-    for item in collection.items:
-        url_path = item.get("url_path")
-        store = FakeDashboardStore()
-        collection.stores[url_path] = store
-        hass.data["lovelace"]["dashboards"][url_path] = store
-    return collection
-
-
 async def test_setup_stores_runtime_data_in_hass_data(hass, make_entry) -> None:
     entry = _wire(make_entry(), hass.registry)
     assert await async_setup_entry(hass, entry) is True
@@ -113,25 +37,15 @@ async def test_setup_stores_runtime_data_in_hass_data(hass, make_entry) -> None:
     assert hass.data[DOMAIN][entry.entry_id] is entry.runtime_data
 
 
-async def test_setup_runtime_data_has_entry_id_and_coordinator(hass, make_entry) -> None:
-    entry = _wire(make_entry(), hass.registry)
+async def test_setup_runtime_data_has_entry_id_and_settings(hass, make_entry) -> None:
+    entry = _wire(make_entry(options={"horizon_days": 7}), hass.registry)
     await async_setup_entry(hass, entry)
     runtime = entry.runtime_data
     assert runtime.entry_id == entry.entry_id
-    assert runtime.coordinator is not None
+    assert runtime.settings.horizon_days == 7
     assert callable(runtime.remove_update_listener)
 
 
-async def test_setup_registers_no_time_change_listener(hass, make_entry) -> None:
-    """The integration owns no database any more: the daily
-    day-rollover/materialization listener is gone (the API service
-    owns the horizon), so setup registers NOTHING against the
-    time-change listener bookkeeping."""
-    entry = _wire(make_entry(), hass.registry)
-    await async_setup_entry(hass, entry)
-    assert hass.time_change.size == 0
-
-
 async def test_unload_returns_true_and_removes_hass_data(hass, make_entry) -> None:
     registry = hass.registry
     entry = _wire(make_entry(), registry)
@@ -206,7 +120,7 @@ async def test_options_update_triggers_reload_once(hass, make_entry) -> None:
     registry = hass.registry
     entry = _wire(make_entry(), registry)
     await async_setup_entry(hass, entry)
-    entry.options = {"update_interval": 60}
+    entry.options = {"horizon_days": 30}
     await registry.async_dispatch_options_update(entry)
     assert hass.config_entries.async_reload.call_count == 1
     assert registry.reloaded == [entry.entry_id]
@@ -284,16 +198,6 @@ async def test_setup_entry_uses_domain_constant(hass, make_entry) -> None:
     assert set(hass.data) == {DOMAIN_CONST}
 
 
-async def test_setup_registers_the_completion_service(hass, make_entry) -> None:
-    """The one domain-global service registers with setup and deregisters
-    on the last unload."""
-    entry = _wire(make_entry(), hass.registry)
-    await async_setup_entry(hass, entry)
-    assert hass.services.has_service(DOMAIN, SERVICE_COMPLETE_QUEST)
-    await async_unload_entry(hass, entry)
-    assert not hass.services.has_service(DOMAIN, SERVICE_COMPLETE_QUEST)
-
-
 async def test_setup_awaitable_listener_removal_supported() -> None:
     """A coroutine-returning remover is awaited during unload."""
     removed = []
@@ -312,9 +216,9 @@ async def test_setup_awaitable_listener_removal_supported() -> None:
     assert entry.runtime_data is None
 
 
-async def test_setup_unwinds_when_listener_registration_fails() -> None:
-    """A listener-registration failure must not leak partial setup state."""
-    from custom_components.nestquest.const import DOMAIN as DOMAIN_CONST
+async def test_setup_closes_database_when_listener_registration_fails() -> None:
+    """A listener-registration failure must not leak the opened database."""
+    from custom_components.nestquest.db import NestQuestDatabase
 
     class _Boom(Exception):
         pass
@@ -324,16 +228,13 @@ async def test_setup_unwinds_when_listener_registration_fails() -> None:
     hass, _registry = make_hass()
     with pytest.raises(_Boom):
         await async_setup_entry(hass, entry)
-    assert hass.data.get(DOMAIN_CONST, {}) == {}
+    assert hass.data.get(DOMAIN, {}) == {}
     assert not hasattr(entry, "runtime_data")
-    assert not hass.services.has_service(DOMAIN_CONST, SERVICE_COMPLETE_QUEST)
 
 
-async def test_unload_shuts_coordinator_even_when_listener_removal_raises() -> None:
-    """A raising update-listener remover must not skip the coordinator
-    shutdown: the retained error is re-raised only after the teardown
-    ran and the runtime record was cleared."""
-    from custom_components.nestquest.const import DOMAIN as DOMAIN_CONST
+async def test_unload_closes_database_even_when_listener_removal_raises() -> None:
+    """Unload removes the listener, closes the DB in a finally, then raises."""
+    from custom_components.nestquest.db import NestQuestDatabase
 
     class _RemoveBoom(Exception):
         pass
@@ -345,175 +246,504 @@ async def test_unload_shuts_coordinator_even_when_listener_removal_raises() -> N
     entry.add_update_listener = lambda listener: _remover
     hass, _registry = make_hass()
     await async_setup_entry(hass, entry)
-    coordinator = entry.runtime_data.coordinator
-    seen = []
-
-    async def _shutdown():
-        seen.append("shutdown")
-
-    coordinator.async_shutdown = _shutdown
-
+    database = entry.runtime_data.database
     with pytest.raises(_RemoveBoom):
         await async_unload_entry(hass, entry)
-    assert seen == ["shutdown"], "coordinator shutdown must have run"
+    assert database.connected is False, "database leaked despite remover error"
     assert entry.runtime_data is None
-    assert DOMAIN_CONST not in hass.data
+    assert DOMAIN not in hass.data
+    assert hass.time_change.size == 0, "time-change listener leaked"
+
+
+async def test_unload_cancels_time_listener_even_when_update_remover_raises() -> None:
+    """A raising update-listener remover must not skip the time-change cancel.
+
+    Both removers are independent: the update-listener remover raising must
+    still cancel the daily time-change callback, whose action would otherwise
+    fire after unload against a closed database.
+    """
+
+    class _RemoveBoom(Exception):
+        pass
+
+    def _remover():
+        raise _RemoveBoom()
+
+    entry = make_config_entry(entry_id="update-boom-time-cancel")
+    entry.add_update_listener = lambda listener: _remover
+    hass, _registry = make_hass()
+    await async_setup_entry(hass, entry)
+    assert hass.time_change.size == 1
+    with pytest.raises(_RemoveBoom):
+        await async_unload_entry(hass, entry)
+    assert hass.time_change.size == 0, "time-change listener not cancelled"
+    assert entry.runtime_data is None
+    assert DOMAIN not in hass.data
+
+
+async def test_setup_registers_day_rollover_listener(hass, make_entry) -> None:
+    """Setup registers a daily rollover listener and stores its cancel fn."""
+    entry = _wire(make_entry(), hass.registry)
+    assert await async_setup_entry(hass, entry) is True
+    assert hass.time_change.size == 1
+    registration = hass.time_change.registrations[0]
+    assert registration["hour"] == 0
+    assert registration["minute"] == 0
+    assert callable(entry.runtime_data.remove_time_change_listener)
+
+
+async def test_setup_registers_day_rollover_at_configured_time(hass, make_entry) -> None:
+    """The listener fires at the entry option's rollover time, not the default."""
+    entry = _wire(make_entry(options={CONF_DAY_ROLLOVER_TIME: "06:30"}), hass.registry)
+    await async_setup_entry(hass, entry)
+    registration = hass.time_change.registrations[0]
+    assert registration["hour"] == 6
+    assert registration["minute"] == 30
+
+
+async def test_unload_cancels_day_rollover_listener(hass, make_entry) -> None:
+    """Unload removes the time-change listener alongside the update listener."""
+    entry = _wire(make_entry(), hass.registry)
+    await async_setup_entry(hass, entry)
+    assert hass.time_change.size == 1
+    assert await async_unload_entry(hass, entry) is True
     assert hass.time_change.size == 0
 
 
-async def test_setup_creates_the_panel_dashboard(hass, make_entry) -> None:
-    """A fresh install gets the storage-mode strategy dashboard via the
-    REAL two-step Lovelace sequence: the METADATA (url_path, title,
-    icon, sidebar, single-word allowance — nothing else: the real
-    create schema rejects unknown keys like ``strategy``) through the
-    collection, then the dashboard CONFIG (the strategy reference)
-    through the fresh dashboard's content manager."""
-    collection = _install_dashboard_collection(hass)
-    entry = _wire(make_entry(), hass.registry)
-    assert await async_setup_entry(hass, entry) is True
-    # Step 1: the metadata create through the collection.
-    assert len(collection.created) == 1
-    created = collection.created[0]
-    assert created["url_path"] == DASHBOARD_URL_PATH
-    assert created["title"]
-    assert created["show_in_sidebar"] is True
-    assert created["allow_single_word"] is True
-    assert "icon" in created
-    # The create payload carries METADATA only: a ``strategy`` key is
-    # rejected by the real collection's create schema (the silent
-    # no-op the first implementation shipped).
-    assert "strategy" not in created
-    assert "mode" not in created
-    # Step 2: the strategy CONFIG saved through the content manager
-    # the create registered, with the custom strategy type.
-    store = hass.data["lovelace"]["dashboards"][DASHBOARD_URL_PATH]
-    assert store is collection.stores[DASHBOARD_URL_PATH]
-    assert store.saved == [{"strategy": {"type": DASHBOARD_STRATEGY_TYPE}}]
-    assert store.config == {"strategy": {"type": DASHBOARD_STRATEGY_TYPE}}
-
-
-async def test_setup_reload_does_not_duplicate_the_dashboard(
+async def test_rollover_time_change_reregisters_listener_at_new_time(
     hass, make_entry
 ) -> None:
-    """A reload (or a second entry) must not create a second dashboard:
-    the one under the stable url_path is reused as-is — BOTH steps are
-    skipped, so the strategy config is not re-saved either."""
-    collection = _install_dashboard_collection(hass)
-    entry = _wire(make_entry(), hass.registry)
-    assert await async_setup_entry(hass, entry) is True
-    assert len(collection.created) == 1
-    store = hass.data["lovelace"]["dashboards"][DASHBOARD_URL_PATH]
-    assert len(store.saved) == 1
-    # A reload: setup again on the same hass (the reload cycle) —
-    # the existing dashboard must be left alone.
+    """A rollover-time options change re-registers the listener at the new time."""
+    entry = _wire(
+        make_entry(options={CONF_DAY_ROLLOVER_TIME: "00:00"}), hass.registry
+    )
+    await async_setup_entry(hass, entry)
+    assert (hass.time_change.registrations[0]["hour"], hass.time_change.registrations[0]["minute"]) == (0, 0)
+
+    # The options flow writes the new rollover time, then HA reloads the
+    # entry: unload tears down the old listener, setup re-registers it.
+    entry.options = {CONF_DAY_ROLLOVER_TIME: "06:30"}
     await async_unload_entry(hass, entry)
+    assert hass.time_change.size == 0
+
     assert await async_setup_entry(hass, entry) is True
-    assert len(collection.created) == 1
-    assert len(store.saved) == 1
-    # And a second entry on the same install.
-    other = _wire(make_entry(entry_id="other"), hass.registry)
-    assert await async_setup_entry(hass, other) is True
-    assert len(collection.created) == 1
-    assert len(store.saved) == 1
+    assert hass.time_change.size == 1
+    registration = hass.time_change.registrations[0]
+    assert (registration["hour"], registration["minute"]) == (6, 30)
 
 
-async def test_setup_leaves_an_existing_user_dashboard_alone(
-    hass, make_entry
+async def test_day_rollover_listener_materializes_ha_local_horizon(
+    hass, make_entry, monkeypatch
 ) -> None:
-    """A dashboard already occupying the stable url_path — the user's
-    own — is never overwritten, deleted or duplicated: no metadata
-    create AND no strategy save against its content manager."""
-    users_dashboard = {"url_path": DASHBOARD_URL_PATH, "title": "My Board"}
-    collection = _install_dashboard_collection(hass, items=[users_dashboard])
-    entry = _wire(make_entry(), hass.registry)
-    assert await async_setup_entry(hass, entry) is True
-    assert collection.created == []
-    assert collection.items[0] is users_dashboard
-    users_store = hass.data["lovelace"]["dashboards"][DASHBOARD_URL_PATH]
-    assert users_store.saved == []
-    assert users_store.config is None
+    """Firing the listener materializes today..today+horizon in HA local time."""
+    import datetime
+    from unittest.mock import AsyncMock
+    from zoneinfo import ZoneInfo
 
+    import custom_components.nestquest as nestquest
 
-async def test_setup_succeeds_without_the_dashboards_collection(
-    hass, make_entry, caplog
-) -> None:
-    """YAML mode / lovelace not loaded: log a warning, continue setup."""
     entry = _wire(make_entry(), hass.registry)
-    assert await async_setup_entry(hass, entry) is True
-    assert entry.entry_id in hass.data[DOMAIN]
-    assert any(
-        "dashboard" in record.message.lower()
-        and record.levelname == "WARNING"
-        for record in caplog.records
+    await async_setup_entry(hass, entry)
+    database = entry.runtime_data.database
+
+    fake = AsyncMock()
+    monkeypatch.setattr(nestquest, "_materialize_run", fake)
+
+    time_zone = ZoneInfo(hass.config.time_zone)
+    today = datetime.datetime.now(time_zone).date()
+    expected_start = today.isoformat()
+    expected_end = (today + datetime.timedelta(days=DEFAULT_HORIZON_DAYS)).isoformat()
+
+    await hass.time_change.fire()
+
+    fake.assert_awaited_once_with(
+        database, expected_start, expected_end, today=today
     )
 
 
-async def test_setup_survives_a_failing_dashboards_collection(
-    hass, make_entry
-) -> None:
-    """A collection that refuses the create (permissions, admin-only)
-    logs a warning and setup still succeeds — entities come up."""
-    class _RefusingCollection(FakeDashboardsCollection):
-        async def async_create_item(self, item_config):
-            raise PermissionError("not an admin")
+async def test_day_rollover_uses_configured_horizon_days(hass, make_entry) -> None:
+    """The daily run materializes only the configured horizon window."""
+    import datetime
 
-    collection = _RefusingCollection(hass)
-    hass.data["lovelace"] = {
-        "mode": "storage",
-        "dashboards": {},
-        "dashboards_collection": collection,
-    }
-    entry = _wire(make_entry(), hass.registry)
+    from custom_components.nestquest.dao_instances import QuestInstancesDao
+
+    entry = _wire(make_entry(options={CONF_HORIZON_DAYS: 5}), hass.registry)
     assert await async_setup_entry(hass, entry) is True
-    assert collection.created == []
+    database = entry.runtime_data.database
 
-
-async def test_setup_survives_a_failing_content_manager_save(
-    hass, make_entry
-) -> None:
-    """A content manager that refuses the config save after the
-    metadata create succeeded (storage write failure) logs a warning
-    and setup still succeeds — the dashboard exists, the strategy
-    simply was not persisted through it."""
-    class _RefusingStore(FakeDashboardStore):
-        async def async_save(self, config):
-            raise OSError("disk full")
-
-    class _StorelessCreateCollection(FakeDashboardsCollection):
-        async def async_create_item(self, item_config):
-            await asyncio.sleep(0)
-            self.created.append(dict(item_config))
-            self.items.append(dict(item_config))
-            self.stores[item_config["url_path"]] = _RefusingStore()
-            self.hass.data["lovelace"]["dashboards"][
-                item_config["url_path"]
-            ] = self.stores[item_config["url_path"]]
-
-    collection = _StorelessCreateCollection(hass)
-    hass.data["lovelace"] = {
-        "mode": "storage",
-        "dashboards": {},
-        "dashboards_collection": collection,
-    }
-    entry = _wire(make_entry(), hass.registry)
-    assert await async_setup_entry(hass, entry) is True
-    assert len(collection.created) == 1
-    store = hass.data["lovelace"]["dashboards"][DASHBOARD_URL_PATH]
-    assert store.saved == []
-
-
-async def test_concurrent_registrations_create_the_dashboard_once(hass) -> None:
-    """Two CONCURRENT registrations (the race two entry setups run)
-    must produce exactly ONE dashboard: the single-flight guard makes
-    the second caller's exists-check run after the first caller's
-    create completed, so it skips both steps.  The fake's create
-    yields before recording, so without the guard both callers would
-    pass the exists-check and the dashboard would be created twice."""
-    collection = _install_dashboard_collection(hass)
-    results = await asyncio.gather(
-        async_register_dashboard(hass),
-        async_register_dashboard(hass),
+    # A definition created AFTER setup has no instances yet (create does not
+    # materialize); firing the daily listener must generate only the horizon.
+    child_id = await _seed_daily_child_and_definition(
+        database, _local_today(hass)
     )
-    assert results == [True, True]
-    assert len(collection.created) == 1
-    assert len(collection.stores[DASHBOARD_URL_PATH].saved) == 1
+    await hass.time_change.fire()
+
+    today = _local_today(hass)
+    end = (today + datetime.timedelta(days=5)).isoformat()
+    records = await QuestInstancesDao(database).list_by_date_range(
+        child_id, today.isoformat(), end
+    )
+    assert len(records) == 6
+
+    beyond = (today + datetime.timedelta(days=6)).isoformat()
+    beyond_end = (
+        today + datetime.timedelta(days=DEFAULT_HORIZON_DAYS)
+    ).isoformat()
+    assert await QuestInstancesDao(database).list_by_date_range(
+        child_id, beyond, beyond_end
+    ) == []
+
+
+def test_day_rollover_time_change_tracker_rejects_local_kwarg() -> None:
+    """The fake async_track_time_change mirrors HA 2024.6 (no ``local`` kwarg).
+
+    Setup drives the local-time wrapper directly, so passing ``local=`` must
+    raise TypeError — otherwise a regression in the production call would be
+    silently masked by the fake.
+    """
+    import inspect as _inspect
+
+    from homeassistant.helpers.event import async_track_time_change
+
+    params = _inspect.signature(async_track_time_change).parameters
+    assert list(params) == ["hass", "action", "hour", "minute", "second"]
+    with pytest.raises(TypeError):
+        async_track_time_change(None, lambda _now: None, hour=0, minute=0, local=True)
+
+
+async def test_setup_applies_all_v1_tables(hass, make_entry) -> None:
+    """Setup applies the full v1 DDL: all four v1 tables exist afterwards."""
+    entry = _wire(make_entry(), hass.registry)
+    assert await async_setup_entry(hass, entry) is True
+    database = entry.runtime_data.database
+    rows = await database.fetch_all(
+        "SELECT name FROM sqlite_master WHERE type = 'table' "
+        "AND name IN ('children', 'admin_users', 'schedule_rules', "
+        "'quest_definitions') ORDER BY name"
+    )
+    assert [row[0] for row in rows] == [
+        "admin_users",
+        "children",
+        "quest_definitions",
+        "schedule_rules",
+    ]
+    await async_unload_entry(hass, entry)
+
+
+async def _seed_daily_child_and_definition(database, today) -> int:
+    """Create one always-present child + a daily definition starting today.
+
+    Returns the child's id.  No presence schedule means the child is present
+    every day, so the daily rule yields exactly one instance per horizon day.
+    """
+    from custom_components.nestquest.dao_children import ChildrenDao
+    from custom_components.nestquest.quest_definitions import (
+        create_quest_definition,
+    )
+    from custom_components.nestquest.recurrence import RuleType, ScheduleRule
+
+    NOW = "2026-09-14T12:00:00+00:00"
+    child = await ChildrenDao(database).create("Ada", NOW)
+    await create_quest_definition(
+        database,
+        "Daily chore",
+        ScheduleRule(rule_type=RuleType.DAILY, start_date=today.isoformat()),
+        [child.id],
+        ["morning"],
+    )
+    return child.id
+
+
+def _local_today(hass) -> "datetime.date":
+    import datetime
+    from zoneinfo import ZoneInfo
+
+    return datetime.datetime.now(ZoneInfo(hass.config.time_zone)).date()
+
+
+async def test_setup_backfills_instances_over_horizon(hass, make_entry) -> None:
+    """Setup materializes once so a restart backfills any missed days."""
+    import datetime
+
+    from custom_components.nestquest.dao_instances import QuestInstancesDao
+    from custom_components.nestquest.db import NestQuestDatabase
+    from custom_components.nestquest.migrations import apply_migrations
+    from custom_components.nestquest.store import async_get_db_path
+
+    # Seed the database BEFORE setup: a restart reopens an existing file that
+    # already holds definitions.  The startup backfill must pick them up.
+    db_path = await async_get_db_path(hass)
+    pre = NestQuestDatabase(hass.async_add_executor_job)
+    await pre.open(db_path)
+    await apply_migrations(pre)
+    child_id = await _seed_daily_child_and_definition(pre, _local_today(hass))
+    await pre.close()
+
+    entry = _wire(make_entry(), hass.registry)
+    assert await async_setup_entry(hass, entry) is True
+
+    today = _local_today(hass)
+    end = (today + datetime.timedelta(days=DEFAULT_HORIZON_DAYS)).isoformat()
+    records = await QuestInstancesDao(entry.runtime_data.database).list_by_date_range(
+        child_id, today.isoformat(), end
+    )
+    assert len(records) == DEFAULT_HORIZON_DAYS + 1
+
+
+async def test_setup_backfills_configured_horizon_days(hass, make_entry) -> None:
+    """Setup backfills only the configured (non-default) horizon window."""
+    import datetime
+
+    from custom_components.nestquest.dao_instances import QuestInstancesDao
+    from custom_components.nestquest.db import NestQuestDatabase
+    from custom_components.nestquest.migrations import apply_migrations
+    from custom_components.nestquest.store import async_get_db_path
+
+    db_path = await async_get_db_path(hass)
+    pre = NestQuestDatabase(hass.async_add_executor_job)
+    await pre.open(db_path)
+    await apply_migrations(pre)
+    child_id = await _seed_daily_child_and_definition(pre, _local_today(hass))
+    await pre.close()
+
+    entry = _wire(
+        make_entry(options={CONF_HORIZON_DAYS: 5}), hass.registry
+    )
+    assert await async_setup_entry(hass, entry) is True
+
+    today = _local_today(hass)
+    end = (today + datetime.timedelta(days=5)).isoformat()
+    records = await QuestInstancesDao(
+        entry.runtime_data.database
+    ).list_by_date_range(child_id, today.isoformat(), end)
+    assert len(records) == 6
+
+    beyond = (today + datetime.timedelta(days=6)).isoformat()
+    beyond_end = (
+        today + datetime.timedelta(days=DEFAULT_HORIZON_DAYS)
+    ).isoformat()
+    assert await QuestInstancesDao(
+        entry.runtime_data.database
+    ).list_by_date_range(child_id, beyond, beyond_end) == []
+
+
+async def test_setup_succeeds_with_fully_malformed_options(
+    hass, make_entry
+) -> None:
+    """A fully malformed options dict falls back per field and setup succeeds.
+
+    ``horizon_days=True``, ``day_rollover_time='99:99'`` and
+    ``morning_summary_time='25:00'`` are all invalid; the integration's
+    ``from_options_resilient`` falls each back to its default, so setup
+    SUCCEEDS, the day-rollover listener registers at the default hour 0
+    minute 0, and the startup backfill materializes the default horizon
+    window.
+    """
+    import datetime
+
+    from custom_components.nestquest.dao_instances import QuestInstancesDao
+    from custom_components.nestquest.db import NestQuestDatabase
+    from custom_components.nestquest.migrations import apply_migrations
+    from custom_components.nestquest.store import async_get_db_path
+
+    db_path = await async_get_db_path(hass)
+    pre = NestQuestDatabase(hass.async_add_executor_job)
+    await pre.open(db_path)
+    await apply_migrations(pre)
+    child_id = await _seed_daily_child_and_definition(pre, _local_today(hass))
+    await pre.close()
+
+    entry = _wire(
+        make_entry(
+            options={
+                CONF_HORIZON_DAYS: True,
+                CONF_DAY_ROLLOVER_TIME: "99:99",
+                CONF_MORNING_SUMMARY_TIME: "25:00",
+            }
+        ),
+        hass.registry,
+    )
+    assert await async_setup_entry(hass, entry) is True
+
+    # The day-rollover listener fell back to the default 00:00.
+    registration = hass.time_change.registrations[0]
+    assert registration["hour"] == 0
+    assert registration["minute"] == 0
+
+    # The startup backfill used the default horizon window.
+    today = _local_today(hass)
+    end = (today + datetime.timedelta(days=DEFAULT_HORIZON_DAYS)).isoformat()
+    records = await QuestInstancesDao(
+        entry.runtime_data.database
+    ).list_by_date_range(child_id, today.isoformat(), end)
+    assert len(records) == DEFAULT_HORIZON_DAYS + 1
+
+
+async def test_setup_keeps_horizon_when_sibling_option_is_bad(
+    hass, make_entry
+) -> None:
+    """A malformed sibling option does not reset the configured horizon.
+
+    ``horizon_days=5`` is valid while ``morning_summary_time='25:00'`` is
+    invalid; ``from_options_resilient`` falls back ONLY the bad sibling,
+    so the entry's resolved settings keep ``horizon_days == 5``.
+    """
+    entry = _wire(
+        make_entry(
+            options={
+                CONF_HORIZON_DAYS: 5,
+                CONF_MORNING_SUMMARY_TIME: "25:00",
+            }
+        ),
+        hass.registry,
+    )
+    assert await async_setup_entry(hass, entry) is True
+    assert entry.runtime_data.settings.horizon_days == 5
+
+
+async def test_regenerate_service_registered_and_materializes(
+    hass, make_entry
+) -> None:
+    """``nestquest.regenerate`` is registered and calling it regenerates."""
+    import datetime
+
+    from custom_components.nestquest.dao_instances import QuestInstancesDao
+
+    entry = _wire(make_entry(data=_admin_data()), hass.registry)
+    assert await async_setup_entry(hass, entry) is True
+    assert hass.services.has_service(DOMAIN, SERVICE_REGENERATE)
+
+    # A definition created AFTER setup has no instances yet (create does not
+    # materialize); the service must generate them on demand.
+    database = entry.runtime_data.database
+    child_id = await _seed_daily_child_and_definition(database, _local_today(hass))
+
+    await hass.services.call(DOMAIN, SERVICE_REGENERATE, context=ADMIN_CTX)
+
+    today = _local_today(hass)
+    end = (today + datetime.timedelta(days=DEFAULT_HORIZON_DAYS)).isoformat()
+    records = await QuestInstancesDao(database).list_by_date_range(
+        child_id, today.isoformat(), end
+    )
+    assert len(records) == DEFAULT_HORIZON_DAYS + 1
+
+
+async def test_regenerate_service_uses_configured_horizon_days(
+    hass, make_entry
+) -> None:
+    """``nestquest.regenerate`` regenerates only the configured horizon."""
+    import datetime
+
+    from custom_components.nestquest.dao_instances import QuestInstancesDao
+
+    entry = _wire(
+        make_entry(options={CONF_HORIZON_DAYS: 5}, data=_admin_data()),
+        hass.registry,
+    )
+    assert await async_setup_entry(hass, entry) is True
+
+    database = entry.runtime_data.database
+    child_id = await _seed_daily_child_and_definition(database, _local_today(hass))
+
+    await hass.services.call(DOMAIN, SERVICE_REGENERATE, context=ADMIN_CTX)
+
+    today = _local_today(hass)
+    end = (today + datetime.timedelta(days=5)).isoformat()
+    records = await QuestInstancesDao(database).list_by_date_range(
+        child_id, today.isoformat(), end
+    )
+    assert len(records) == 6
+
+    beyond = (today + datetime.timedelta(days=6)).isoformat()
+    beyond_end = (
+        today + datetime.timedelta(days=DEFAULT_HORIZON_DAYS)
+    ).isoformat()
+    assert await QuestInstancesDao(database).list_by_date_range(
+        child_id, beyond, beyond_end
+    ) == []
+
+
+async def test_unload_deregisters_regenerate_service(hass, make_entry) -> None:
+    """Unload removes the ``regenerate`` service so no stale entry leaks."""
+    entry = _wire(make_entry(), hass.registry)
+    assert await async_setup_entry(hass, entry) is True
+    assert hass.services.has_service(DOMAIN, SERVICE_REGENERATE)
+
+    assert await async_unload_entry(hass, entry) is True
+    assert not hass.services.has_service(DOMAIN, SERVICE_REGENERATE)
+
+
+async def test_regenerate_service_is_domain_scoped_across_entries(
+    hass, make_entry
+) -> None:
+    """The ``regenerate`` service is domain-global, not per-entry.
+
+    With two loaded entries the service must be registered and functional;
+    unloading one entry must keep it registered and functional for the
+    remaining entry; unloading the final entry must remove it.
+    """
+    import datetime
+
+    from custom_components.nestquest.dao_instances import QuestInstancesDao
+
+    entry_a = _wire(
+        make_entry(entry_id="entry_a", data=_admin_data()), hass.registry
+    )
+    entry_b = _wire(
+        make_entry(entry_id="entry_b", data=_admin_data()), hass.registry
+    )
+
+    assert await async_setup_entry(hass, entry_a) is True
+    assert await async_setup_entry(hass, entry_b) is True
+    assert hass.services.has_service(DOMAIN, SERVICE_REGENERATE)
+
+    # The domain-global handler resolves a live database from any entry.
+    database_b = entry_b.runtime_data.database
+    child_id = await _seed_daily_child_and_definition(
+        database_b, _local_today(hass)
+    )
+    await hass.services.call(DOMAIN, SERVICE_REGENERATE, context=ADMIN_CTX)
+    today = _local_today(hass)
+    end = (today + datetime.timedelta(days=DEFAULT_HORIZON_DAYS)).isoformat()
+    records = await QuestInstancesDao(database_b).list_by_date_range(
+        child_id, today.isoformat(), end
+    )
+    assert len(records) == DEFAULT_HORIZON_DAYS + 1
+
+    # Unloading one entry must not tear down the shared service.
+    assert await async_unload_entry(hass, entry_a) is True
+    assert hass.services.has_service(DOMAIN, SERVICE_REGENERATE)
+
+    # It still works for the remaining entry.
+    await hass.services.call(DOMAIN, SERVICE_REGENERATE, context=ADMIN_CTX)
+
+    # Unloading the final entry removes the domain-global service.
+    assert await async_unload_entry(hass, entry_b) is True
+    assert not hass.services.has_service(DOMAIN, SERVICE_REGENERATE)
+
+
+async def test_setup_cleans_listeners_when_materialization_raises(
+    hass, make_entry, monkeypatch
+) -> None:
+    """A startup-materialization failure rolls back every registered listener.
+
+    The daily and update listeners are installed before the startup
+    materialization runs; when that walk raises, the database is closed but
+    the remover callables must also be invoked so no listener survives
+    firing against a closed database.
+    """
+    import custom_components.nestquest as nestquest
+
+    async def _boom(*_args, **_kwargs):
+        raise RuntimeError("materialization failed")
+
+    monkeypatch.setattr(nestquest, "_materialize_run", _boom)
+
+    entry = _wire(make_entry(), hass.registry)
+    with pytest.raises(RuntimeError, match="materialization failed"):
+        await async_setup_entry(hass, entry)
+
+    assert hass.time_change.size == 0
+    assert hass.registry.size == 0
+    assert not hass.services.has_service(DOMAIN, SERVICE_REGENERATE)
+    assert not hasattr(entry, "runtime_data")

tests/test_materialize.py

@@ -6,29 +6,29 @@ import datetime
 
 import pytest
 
-from custom_components.nestquest.core.dao_children import ChildrenDao
+from custom_components.nestquest.dao_children import ChildrenDao
 from custom_components.nestquest.const import DEFAULT_HORIZON_DAYS
-from custom_components.nestquest.core.dao_instances import (
+from custom_components.nestquest.dao_instances import (
     CompletionEventsDao,
     QuestInstancesDao,
 )
-from custom_components.nestquest.core.dao_presence import PresenceSchedulesDao
-from custom_components.nestquest.core.dao_rules import (
+from custom_components.nestquest.dao_presence import PresenceSchedulesDao
+from custom_components.nestquest.dao_rules import (
     QuestDefinitionsDao,
     schedule_rule_to_storage,
 )
-from custom_components.nestquest.core.db import NestQuestDatabase
-from custom_components.nestquest.core.materialize import (
+from custom_components.nestquest.db import NestQuestDatabase
+from custom_components.nestquest.materialize import (
     materialize,
     regenerate_for_child,
     regenerate_for_definition,
 )
-from custom_components.nestquest.core.migrations import apply_migrations
-from custom_components.nestquest.core.quest_definitions import (
+from custom_components.nestquest.migrations import apply_migrations
+from custom_components.nestquest.quest_definitions import (
     create_quest_definition,
     edit_quest_definition,
 )
-from custom_components.nestquest.core.recurrence import (
+from custom_components.nestquest.recurrence import (
     RuleType,
     ScheduleRule,
     occurs_on,
@@ -505,7 +505,7 @@ def test_materialize_skips_deactivated_child_mid_walk(tmp_path) -> None:
 
 def test_materialize_uses_single_presence_snapshot_mid_walk(tmp_path) -> None:
     async def _body(database):
-        from custom_components.nestquest.core.dao_presence import (
+        from custom_components.nestquest.dao_presence import (
             PresenceOverridesDao,
         )
 
@@ -628,7 +628,7 @@ def test_materialize_does_not_overwrite_regenerated_due_time(tmp_path) -> None:
 
 def test_materialize_honours_overrides(tmp_path) -> None:
     async def _body(database):
-        from custom_components.nestquest.core.dao_presence import (
+        from custom_components.nestquest.dao_presence import (
             PresenceOverridesDao,
         )
 
@@ -758,7 +758,7 @@ def test_materialize_clamps_past_start_to_today(tmp_path) -> None:
 
 def test_materialize_skips_inactive_definitions(tmp_path) -> None:
     async def _body(database):
-        from custom_components.nestquest.core.quest_definitions import (
+        from custom_components.nestquest.quest_definitions import (
             set_quest_definition_active,
         )
 
@@ -906,7 +906,7 @@ def test_regenerate_for_child_rebuilds_horizon_preserves_history(
     tmp_path,
 ) -> None:
     async def _body(database):
-        from custom_components.nestquest.core.dao_presence import (
+        from custom_components.nestquest.dao_presence import (
             PresenceOverridesDao,
         )
 
@@ -1091,7 +1091,7 @@ def test_regenerate_for_child_uses_single_anchor_across_midnight(
 def test_regenerate_for_child_is_child_scoped(tmp_path) -> None:
     """Regenerating one child must never touch another child's rows."""
     async def _body(database):
-        from custom_components.nestquest.core.dao_presence import (
+        from custom_components.nestquest.dao_presence import (
             PresenceOverridesDao,
         )
 
@@ -1493,10 +1493,10 @@ def test_materialize_end_to_end_six_rule_types(tmp_path, monkeypatch) -> None:
     monkeypatch.setattr(materialize_module, "_now_stamp", _distinct_stamp)
 
     async def _body(database):
-        from custom_components.nestquest.core.dao_presence import (
+        from custom_components.nestquest.dao_presence import (
             PresenceOverridesDao,
         )
-        from custom_components.nestquest.core.presence import PresenceSchedule
+        from custom_components.nestquest.presence import PresenceSchedule
 
         children = ChildrenDao(database)
         schedules = PresenceSchedulesDao(database)

tests/test_migrations.py

@@ -9,16 +9,16 @@ from unittest.mock import AsyncMock
 
 import pytest
 
-from custom_components.nestquest.core.db import NestQuestDatabase
-from custom_components.nestquest.core.schema import SCHEMA_V7_META_STATE_DDL
-from custom_components.nestquest.core.migrations import (
+from custom_components.nestquest.db import NestQuestDatabase
+from custom_components.nestquest.schema import SCHEMA_V7_META_STATE_DDL
+from custom_components.nestquest.migrations import (
     MIGRATIONS,
     VERSION_TABLE,
     VERSION_TABLE_DDL,
     apply_migrations,
     read_schema_version,
 )
-from custom_components.nestquest.core.schema import (
+from custom_components.nestquest.schema import (
     SCHEMA_V1_STATEMENTS,
     SCHEMA_V1_QUEST_DEFINITION_WINDOWS_DDL,
 )
@@ -1064,3 +1064,133 @@ def test_partial_pending_migrations_resume_from_current_version(
         assert "step_b" in _tables(database)
     finally:
         _run(database.close())
+
+
+# ---------------------------------------------------------------------------
+# Startup wiring: setup runs the migration runner, not raw DDL
+# ---------------------------------------------------------------------------
+
+
+async def _setup_entry(hass, entry, registry) -> object:
+    from tests.test_lifecycle import _wire  # reuse the established wiring
+
+    entry = _wire(entry, registry)
+    from custom_components.nestquest import async_setup_entry
+
+    await async_setup_entry(hass, entry)
+    return entry
+
+
+async def test_setup_entry_migrates_fresh_database(hass, make_entry) -> None:
+    import sqlite3 as sqlite3_mod
+
+    from custom_components.nestquest.migrations import read_schema_version
+    from custom_components.nestquest.store import async_get_db_path
+
+    entry = await _setup_entry(hass, make_entry(), hass.registry)
+    database = entry.runtime_data.database
+    assert await read_schema_version(database) == len(MIGRATIONS)
+    # The v1 tables exist because the runner applied migration 1.
+    names = {
+        row[0]
+        for row in await database.fetch_all(
+            "SELECT name FROM sqlite_master WHERE type = 'table' "
+            "AND name NOT LIKE 'sqlite_%'"
+        )
+    }
+    assert "children" in names and "completion_events" in names
+    # The version table exists with its singleton row stamped.
+    columns = await database.fetch_all(f"PRAGMA table_info({VERSION_TABLE})")
+    assert [(row[1], row[3]) for row in columns] == [("id", 1), ("version", 1)]
+    db_path = await async_get_db_path(hass)
+    conn = sqlite3_mod.connect(db_path)
+    try:
+        conn.execute(f"INSERT INTO {VERSION_TABLE} (id, version) VALUES (2, 1)")
+        violated = False
+    except sqlite3_mod.IntegrityError:
+        violated = True
+    finally:
+        conn.close()
+    assert violated, "singleton-row CHECK must be live in the setup-created DB"
+    await database.close()
+
+
+async def test_options_reload_reopens_and_rechecks_version(
+    hass, make_entry
+) -> None:
+    """A listener-triggered reload re-runs setup against the same file.
+
+    Unload then setup is the reload lifecycle: the old connection is
+    closed, apply_migrations runs again on the persisted file, keeps
+    version and rows intact, and the reopened connection is live.
+    """
+    from custom_components.nestquest import async_unload_entry
+    from custom_components.nestquest.migrations import read_schema_version
+
+    entry = await _setup_entry(hass, make_entry(), hass.registry)
+    database_a = entry.runtime_data.database
+    await database_a.execute(
+        "INSERT INTO children (display_name, created_at) VALUES (?, ?)",
+        ("Ada", "2026-09-13T00:00:00+00:00"),
+    )
+    assert await async_unload_entry(hass, entry) is True
+    assert not database_a.connected
+
+    entry_reloaded = await _setup_entry(hass, make_entry(), hass.registry)
+    database_b = entry_reloaded.runtime_data.database
+    assert database_b is not database_a
+    try:
+        assert await read_schema_version(database_b) == len(MIGRATIONS)
+        row = await database_b.fetch_one("SELECT COUNT(*) FROM children")
+        assert row == (1,)
+    finally:
+        await database_b.close()
+
+
+async def test_setup_entry_failure_closes_database(
+    hass, make_entry, monkeypatch
+) -> None:
+    """A failing migration closes the opened connection before re-raising.
+
+    A migration failure surfaces as ConfigEntryNotReady (HA retries
+    setup) with the original error preserved as __cause__.  Spies on
+    the real wrapper instance: records whether close() ran, rather
+    than inferring from hass.data (a failed setup never stores a
+    runtime record).
+    """
+    import pytest as pytest_module
+    from homeassistant.exceptions import ConfigEntryNotReady
+
+    import custom_components.nestquest as nestquest_module
+    from custom_components.nestquest.db import NestQuestDatabase
+    from custom_components.nestquest.migrations import (
+        MIGRATIONS as _MIGRATIONS,
+    )
+
+    async def _failing(database, migrations=_MIGRATIONS):
+        raise RuntimeError("boom")
+
+    monkeypatch.setattr(
+        nestquest_module, "apply_migrations", _failing, raising=True
+    )
+
+    close_calls: list[bool] = []
+    original_close = NestQuestDatabase.close
+
+    async def _spy_close(self):
+        close_calls.append(True)
+        return await original_close(self)
+
+    monkeypatch.setattr(NestQuestDatabase, "close", _spy_close)
+
+    entry = make_entry()
+    with pytest_module.raises(ConfigEntryNotReady) as excinfo:
+        await _setup_entry(hass, entry, hass.registry)
+    assert isinstance(excinfo.value.__cause__, RuntimeError)
+    assert "boom" in str(excinfo.value.__cause__)
+
+    assert close_calls == [True], (
+        "failed setup must close the connection it opened"
+    )
+    record = hass.data["nestquest"].get(entry.entry_id)
+    assert record is None, "failed setup must not store runtime data"