updates

Co-authored-by: dev_agent <dev_agent@cubecraftlabs.com>

README.md

@@ -1,3 +1,7 @@
+<p align="center">
+  <img src="design/logos/NestQuest-NoBG.png" alt="NestQuest logo" width="200">
+</p>
+
 # NestQuest - House Chaos Coordination
 
 Home Assistant custom integration for managing chores, custody schedules, and house coordination.
@@ -69,12 +73,12 @@ actions:
 
 ## Automation Blueprints
 
-NestQuest ships four automation blueprints in
+NestQuest ships five automation blueprints in
 `custom_components/nestquest/blueprints/automation/`. Import them in
 Home Assistant under **Settings → Automations & Scenes → Blueprints**
 (or place the files in your `config/blueprints/automation/` folder),
-then create one automation per blueprint, filling the inputs with your
+then create automations from the blueprints, filling the inputs with your
-household's choices.
+household's choices. The UniFi blueprint needs one automation per child.
 
 ### Wiring to the integration's notification settings
 
@@ -96,7 +100,7 @@ The end-of-day report deliberately runs BEFORE the midnight missed
 sweep and reads the same day's data — do not schedule it at the
 day-rollover time.
 
-### The four blueprints
+### The five blueprints
 
 1. **Morning summary** (`morning_summary.yaml`) — at the configured
    time, lists every child whose `binary_sensor.nestquest_<child>_present_today`
@@ -124,10 +128,36 @@ day-rollover time.
    not re-fire, but a second child clearing the same day still
    celebrates.
 
+5. **UniFi quest access** (`unifi_quest_access.yaml`) — create one
+   automation per child. Select that child's quests-remaining-today
+   sensor, present-today sensor, and all of their UniFi client access
+   switches. At 18:25 local
+   time Monday-Friday or 14:00 Saturday-Sunday, clients with open
+   quests lose all network access; access returns as soon as the count
+   reaches zero. When the child is **On travels** (`present today` is off),
+   access stays on regardless of open quests. An unavailable presence sensor
+   also leaves access on; verify that sensor before relying on enforcement.
+   Returning after the cutoff reapplies the rule immediately. At midnight
+   the old day's quests stop affecting access.
+   The automation also reconciles after Home Assistant starts and every
+   five minutes. If the quest sensor is unavailable after the cutoff,
+   it keeps the child blocked until a valid zero is observed.
+
+   First configure the [Home Assistant UniFi Network integration](https://www.home-assistant.io/integrations/unifi/)
+   with a local account that can manage clients. Under its **Network
+   access controlled clients** option, add each child's devices by MAC
+   address, then verify the resulting client access switches manually.
+   Those switches are **on = allowed** and **off = blocked**. Do not
+   select gateway, access-point, Home Assistant, or adult-device
+   switches. To override in an emergency, disable that child's
+   automation and turn their client switches on; re-enable the
+   automation to resume the quest rule. Device MAC randomization or
+   cellular data can bypass a MAC-based Wi-Fi block.
+
 ### Example package
 
 ```yaml
-# One automation per blueprint — Settings → Automations & Scenes →
+# Create automations from blueprints — Settings → Automations & Scenes →
 # Create → Blueprint, then pick each NestQuest blueprint.
 #
 # morning_summary:   morning_time 08:00, notify_target notify.mobile_app_your_phone

RELEASE_NOTES.md

@@ -1,5 +1,212 @@
 # NestQuest Release Notes
 
+## Version 0.10.3 — 2026-10-06
+
+### Scope
+
+Patch release carrying the admin PWA desktop-icon update onto `main` (PR #301,
+task 55e1e687).
+
+### Behaviour
+
+- The admin PWA's installable icons (192, 512, and 512 maskable) are now
+  generated from `design/logos/NestQuest_Logo.png` instead of placeholder
+  graphics, so a home-screen install of the admin app shows the NestQuest logo.
+
+### Requirements
+
+- Home Assistant floor 2024.6.0 (unchanged).
+
+### Breaking changes
+
+- None. Schema unchanged at version 9; no migration, no database backup
+  required.
+
+### Rollback
+
+- No schema change: rolling back to 0.10.2 requires no database restore.
+
+## Version 0.10.2 — 2026-10-06
+
+### Scope
+
+Patch release carrying the panel SSE idle-timeout fix onto `main` (PR #298, task
+6c4b0fa4).
+
+### Behaviour
+
+- The panel event-stream request is no longer subject to aiohttp's default
+  ~300 s total timeout; it now uses an unbounded total with a bounded connect,
+  so a healthy stream stays open instead of reconnecting every ~5 minutes.
+  Because the API does not replay transitions onto the Home Assistant event bus,
+  this also shrinks the windows in which a transition could be missed.
+
+### Requirements
+
+- Home Assistant floor 2024.6.0 (unchanged).
+
+### Breaking changes
+
+- None. Schema unchanged at version 9; no migration, no database backup
+  required.
+
+### Rollback
+
+- No schema change: rolling back to 0.10.1 requires no database restore.
+
+## Version 0.10.1 — 2026-10-06
+
+### Scope
+
+Patch release carrying the panel SSE stream fix onto `main` (PR #295, task
+4cbf2e96).
+
+### Behaviour
+
+- The Home Assistant integration now reads the panel event stream from the
+  response body (`response.content`), fixing the logged failure
+  `'async for' requires an object with __aiter__ method, got HassClientResponse`
+  that logged ~935 times and prevented live panel events (completions,
+  un-completions, day-complete, missed) from re-firing from the API's SSE
+  stream. SSE line-buffering and JSON-frame parsing are unchanged.
+
+### Requirements
+
+- Home Assistant floor 2024.6.0 (unchanged).
+
+### Breaking changes
+
+- None. Schema unchanged at version 9; no migration, no database backup
+  required.
+
+### Known limitations
+
+- Intermittent `GET /api/v1/panel/events failed with HTTP 502` during API
+  restarts/redeploys is expected (the integration reconnects with backoff).
+- The event stream still reconnects periodically because Home Assistant's
+  shared aiohttp session applies a default total timeout — tracked as a
+  follow-up; it does not affect correctness.
+
+### Rollback
+
+- No schema change: rolling back to 0.10.0 requires no database restore.
+
+## Version 0.10.0 — 2026-09-30
+
+### Scope
+
+Feature release: choose task icons by typing any Font Awesome Free **solid**
+icon name, not just the curated subset. The shared icon registry now embeds the
+full Font Awesome Free solid set offline (no CDN — the panel may be offline),
+the admin icon picker is searchable with free-text entry and validation, and the
+kids' panel renders any Free Solid icon. (Feature `6c681b17`; PRs #289–#292.)
+
+### Behaviour
+
+- **Full Free Solid set**: the panel and admin bundles now carry ~1,422 Font
+  Awesome Free solid glyphs as inline SVG path data, in addition to the existing
+  curated quick-pick lists (Lucide and Font Awesome). `fa:<name>` resolves any
+  Free Solid icon; unknown names still render the fallback glyph.
+- **Searchable picker**: the admin definition icon picker's Font Awesome tab has
+  a search input. Empty shows the curated quick picks; typing filters the full
+  set into a bounded (≤40 per page) result grid, with Previous / Show more.
+- **Free-text entry**: typing an exact Free Solid name selects and stores
+  `fa:<name>`. A partial, misspelled, Pro, or Brands name is rejected with an
+  inline message and nothing is saved.
+- Stored format is unchanged: `lucide:<name>`, `fa:<name>`, `emoji:<grapheme>`,
+  or a legacy bare name.
+
+### Requirements
+
+- Home Assistant floor 2024.6.0 (unchanged).
+
+### Breaking changes
+
+- None to the database: schema unchanged at version 9, no migration and no
+  database backup required.
+- Font Awesome **Pro** and **Brands/Regular** icons are NOT included — only the
+  Free Solid set. A Pro/Brands name is rejected in the picker (and an unknown
+  `fa:` name falls back on the panel).
+
+### Known limitations
+
+- **Bundle size**: the embedded icon set increases the committed panel bundle to
+  ~1.06 MB raw (~276 kB gzip) and the admin PWA bundle similarly. This is
+  expected for the full Free Solid set.
+- Alias names (e.g. Font Awesome's `fa:home` alias of `fa:house`) are
+  de-duplicated to the canonical name, so `fa:house` resolves but `fa:home`
+  falls back.
+- The backend still validates only the `fa:<kebab-name>` format; unknown names
+  are caught in the picker and render as the fallback on the panel.
+
+### Rollback
+
+- No schema change: rolling back to 0.9.8 requires no database restore.
+
+## Version 0.9.8 — 2026-09-30
+
+### Scope
+
+Owner-directed change: the application's timezone is now **manual-only and
+admin-authoritative**. Nothing sets it automatically any more; an admin sets it
+from the admin app, and the saved value is the single source of local time for
+the whole application. This reverses the automatic Home Assistant zone adoption
+shipped in 0.9.6 and the admin app's browser-zone auto-set, and supersedes
+decision D-018 with D-019. (PRs #282, #283, #285, #286; feature
+`a3cd8e27` "Manual application timezone control".)
+
+### Behaviour
+
+- **No automatic timezone setting.** Removed: the API's adoption of Home
+  Assistant's reported zone (the `X-NestQuest-Timezone` request header and the
+  `adopt_reported_timezone` path), the integration's reporting of
+  `hass.config.time_zone`, the admin app's browser-zone auto-detect and
+  automatic save, and the `timezone_configured` marker.
+- **The admin sets it manually**, in the admin app's Preferences: a curated IANA
+  zone picker plus a free "Other IANA zone" entry, with an explicit choice for
+  empty ("API host local time"). Nothing is auto-filled or auto-saved.
+- **The saved value is authoritative across the whole application**: the panel
+  snapshot's overdue/today derivation, both panel cards' dates and clocks,
+  completion timestamps, the missed-sweep scheduler, and the admin reads all use
+  it. The API publishes the effective zone (`api/host_zone.effective_timezone`:
+  the saved value, else the API host's own zone) on the panel snapshot and the
+  admin settings response, so the panel and admin app render in the same zone.
+- **The kids' panel now follows the application zone, not the browser.** This
+  supersedes the panel-local overdue behaviour from 0.9.7; a quest is overdue
+  when the application clock says so, not when the panel device's clock does.
+- **An admin save of the timezone or the day-rollover time re-plans the running
+  missed-sweep scheduler.**
+- The integration tolerates an API snapshot without the timezone field, so the
+  integration and the API may be upgraded in either order.
+
+### Requirements
+
+- Home Assistant floor 2024.6.0 (unchanged).
+
+### Breaking changes
+
+- None to the database. The schema is unchanged at version 9: no migration and
+  no database backup is required for this release.
+- Behavioural reversal: if a timezone had been auto-set by 0.9.6–0.9.7, the
+  stored value persists after upgrading (it is simply no longer changed
+  automatically), so no action is needed unless a different zone is wanted.
+- With no timezone saved, the API host's local zone applies (UTC on the standard
+  deployment). Set the timezone in the admin Preferences for correct
+  household-local behaviour. A previously auto-set value counts as saved and
+  will be kept.
+
+### Known limitations
+
+- If no timezone has been saved, the API host zone applies; on the standard
+  UTC-host deployment, overdue and day boundaries will be wrong until an admin
+  sets the zone.
+- The admin app's timezone picker replaces any zone outside its curated list via
+  the "Other IANA zone" entry; the value is validated as an IANA name.
+
+### Rollback
+
+- No schema change: rolling back to 0.9.7 requires no database restore.
+
 ## Version 0.9.7 — 2026-09-29
 
 ### Scope

THIRD-PARTY-NOTICES.md

@@ -1,8 +1,8 @@
 # Third-party notices
 
-NestQuest bundles glyph data from the icon sets below. The curated names are listed in
+NestQuest bundles glyph data from the icon sets below. The curated Lucide names and the
-`tools/icons/curated-icons.json`; `tools/icons/generate.mjs` reads each glyph's SVG path
+Font Awesome quick-pick names are listed in `tools/icons/curated-icons.json`;
-data from the locally installed packages and generates it into both bundles
+`tools/icons/generate.mjs` reads each glyph's SVG path data from the locally installed packages and generates it into both bundles
 (`admin/src/icons/registry.generated.ts` and `frontend/src/icons/registry.generated.ts`).
 Nothing is loaded from a CDN or fetched at runtime. The package versions used are recorded
 in the header of each generated file.
@@ -15,8 +15,8 @@ in the header of each generated file.
   - Icons: [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/)
   - Fonts: [SIL OFL 1.1](https://openfontlicense.org)
   - Code: [MIT](https://opensource.org/licenses/MIT)
-- Use in NestQuest: a curated subset of the Free **solid** icon set, embedded as SVG path
+- Use in NestQuest: the full Free **solid** icon set, embedded as SVG path data (a curated
-  data. No fonts are bundled.
+  subset doubles as the admin picker's quick picks). No fonts are bundled.
 
 Font Awesome Free by @fontawesome — https://fontawesome.com — icons licensed under CC BY 4.0.
 

admin/scripts/generate-icons.mjs

@@ -1,14 +1,12 @@
-// Generates the committed PWA icons under public/icons/ as genuine PNGs.
+// Generates the committed PWA icons under public/icons/ from the brand logo
+// (design/logos/NestQuest_Logo.png), box-filter downscaled.
 // Pure Node (zlib only) — no network, no image dependencies.
 // Run: node scripts/generate-icons.mjs
-import { writeFileSync } from "node:fs";
+import { readFileSync, writeFileSync } from "node:fs";
-import { deflateSync } from "node:zlib";
+import { deflateSync, inflateSync } from "node:zlib";
 import { fileURLToPath } from "node:url";
 
-// Brand tokens (design/tokens/nestquest-admin-tokens.css).
+const SIG = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
-const BLUE = [0x3b, 0x3a, 0xb8];
-const PURPLE = [0xa0, 0x35, 0xcc];
-const WHITE = [0xff, 0xff, 0xff];
 
 const CRC_TABLE = Array.from({ length: 256 }, (_, n) => {
   let c = n;
@@ -44,37 +42,129 @@ function encodePng(size, pixel) {
     for (let x = 0; x < size; x++) raw.set(pixel(x, y), row + 1 + x * 3);
   }
   return Buffer.concat([
-    Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]),
+    SIG,
     chunk("IHDR", ihdr),
     chunk("IDAT", deflateSync(raw, { level: 9 })),
     chunk("IEND", Buffer.alloc(0)),
   ]);
 }
 
-// Flat brand mark: diagonal blue→purple gradient with a white ring ("nest")
+// Minimal decoder for the source logo: 8-bit RGB, non-interlaced only.
-// around a white dot ("quest"). `scale` shrinks the mark for the maskable
+// Anything else fails loudly rather than producing a wrong icon.
-// safe zone (inner 80% circle).
+function decodePng(buf) {
-function brandMark(size, scale) {
+  if (!buf.subarray(0, 8).equals(SIG)) throw new Error("not a PNG");
-  const c = size / 2;
+  let width, height;
-  const outer = size * 0.34 * scale;
+  const idat = [];
-  const inner = size * 0.24 * scale;
+  for (let off = 8; off < buf.length; ) {
-  const dot = size * 0.1 * scale;
+    const len = buf.readUInt32BE(off);
+    const type = buf.toString("ascii", off + 4, off + 8);
+    const data = buf.subarray(off + 8, off + 8 + len);
+    if (type === "IHDR") {
+      width = data.readUInt32BE(0);
+      height = data.readUInt32BE(4);
+      const [depth, colour, , , interlace] = data.subarray(8);
+      if (depth !== 8 || colour !== 2 || interlace !== 0) {
+        throw new Error(`unsupported PNG: depth ${depth}, colour type ${colour}, interlace ${interlace}`);
+      }
+    } else if (type === "IDAT") idat.push(data);
+    else if (type === "IEND") break;
+    off += 12 + len;
+  }
+  const raw = inflateSync(Buffer.concat(idat));
+  const stride = width * 3;
+  const px = Buffer.alloc(stride * height);
+  for (let y = 0; y < height; y++) {
+    const filter = raw[y * (stride + 1)];
+    const src = y * (stride + 1) + 1;
+    const dst = y * stride;
+    for (let i = 0; i < stride; i++) {
+      const a = i >= 3 ? px[dst + i - 3] : 0;
+      const b = y > 0 ? px[dst - stride + i] : 0;
+      const c = i >= 3 && y > 0 ? px[dst - stride + i - 3] : 0;
+      let p;
+      if (filter === 0) p = 0;
+      else if (filter === 1) p = a;
+      else if (filter === 2) p = b;
+      else if (filter === 3) p = (a + b) >> 1;
+      else if (filter === 4) {
+        const pa = Math.abs(b - c), pb = Math.abs(a - c), pc = Math.abs(a + b - 2 * c);
+        p = pa <= pb && pa <= pc ? a : pb <= pc ? b : c;
+      } else throw new Error(`bad PNG filter ${filter} on row ${y}`);
+      px[dst + i] = (raw[src + i] + p) & 0xff;
+    }
+  }
+  return { width, height, px };
+}
+
+// Box-filter (area-average) resize along one axis: each output sample is the
+// coverage-weighted mean of the source samples it spans.
+function boxWeights(srcLen, dstLen) {
+  const scale = srcLen / dstLen;
+  return Array.from({ length: dstLen }, (_, o) => {
+    const start = o * scale, end = start + scale;
+    const taps = [];
+    for (let s = Math.floor(start); s < Math.min(Math.ceil(end), srcLen); s++) {
+      taps.push([s, (Math.min(end, s + 1) - Math.max(start, s)) / scale]);
+    }
+    return taps;
+  });
+}
+
+function resize({ width, height, px }, size) {
+  const wx = boxWeights(width, size);
+  const wy = boxWeights(height, size);
+  const tmp = new Float64Array(size * height * 3); // horizontal pass
+  for (let y = 0; y < height; y++) {
+    for (let x = 0; x < size; x++) {
+      for (const [s, w] of wx[x]) {
+        for (let k = 0; k < 3; k++) tmp[(y * size + x) * 3 + k] += px[(y * width + s) * 3 + k] * w;
+      }
+    }
+  }
+  const out = new Uint8Array(size * size * 3); // vertical pass
+  for (let y = 0; y < size; y++) {
+    for (let x = 0; x < size; x++) {
+      for (let k = 0; k < 3; k++) {
+        let v = 0;
+        for (const [s, w] of wy[y]) v += tmp[(s * size + x) * 3 + k] * w;
+        out[(y * size + x) * 3 + k] = Math.min(255, Math.round(v));
+      }
+    }
+  }
+  return (x, y) => out.subarray((y * size + x) * 3, (y * size + x) * 3 + 3);
+}
+
+// Mean of the four corner pixels — the logo's solid background colour.
+function cornerColour({ width, height, px }) {
+  const corners = [[0, 0], [width - 1, 0], [0, height - 1], [width - 1, height - 1]];
+  return [0, 1, 2].map((k) =>
+    Math.round(corners.reduce((sum, [x, y]) => sum + px[(y * width + x) * 3 + k], 0) / 4),
+  );
+}
+
+// `scale` < 1 shrinks the logo onto a background-coloured canvas so a
+// maskable icon keeps the whole emblem inside the safe zone (inner 80% circle).
+function logoIcon(logo, size, scale) {
+  if (scale === 1) return resize(logo, size);
+  const inner = Math.round(size * scale);
+  const offset = Math.floor((size - inner) / 2);
+  const pixel = resize(logo, inner);
+  const bg = cornerColour(logo);
   return (x, y) => {
-    const d = Math.hypot(x + 0.5 - c, y + 0.5 - c);
+    const ix = x - offset, iy = y - offset;
-    if ((d <= outer && d >= inner) || d <= dot) return WHITE;
+    return ix >= 0 && iy >= 0 && ix < inner && iy < inner ? pixel(ix, iy) : bg;
-    const t = (x + y) / (2 * (size - 1));
-    return BLUE.map((b, i) => Math.round(b + (PURPLE[i] - b) * t));
   };
 }
 
+const logo = decodePng(readFileSync(new URL("../../design/logos/NestQuest_Logo.png", import.meta.url)));
 const outDir = new URL("../public/icons/", import.meta.url);
 const icons = [
   ["icon-192.png", 192, 1],
   ["icon-512.png", 512, 1],
-  ["icon-maskable-512.png", 512, 0.75],
+  ["icon-maskable-512.png", 512, 0.8],
 ];
 for (const [name, size, scale] of icons) {
   const path = fileURLToPath(new URL(name, outDir));
-  writeFileSync(path, encodePng(size, brandMark(size, scale)));
+  writeFileSync(path, encodePng(size, logoIcon(logo, size, scale)));
   console.log(`wrote ${path}`);
 }

admin/src/definitions/DefinitionsTab.css

@@ -614,3 +614,34 @@
 .defs-emoji {
   line-height: 1;
 }
+
+/* Font Awesome search: glyph + label tiles, inline validation, paging */
+.defs-icon-grid--results {
+  grid-template-columns: repeat(auto-fill, minmax(88px, 1fr));
+}
+
+.defs-icon-result {
+  flex-direction: column;
+  gap: 4px;
+  padding: 6px 4px;
+  font-family: inherit;
+}
+
+.defs-icon-label {
+  max-width: 100%;
+  overflow: hidden;
+  font-size: 11px;
+  font-weight: 600;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.defs-hint--error {
+  color: var(--nq-a-danger-strong);
+}
+
+.defs-show-more {
+  align-self: flex-start;
+  display: flex;
+  gap: 8px;
+}

admin/src/definitions/DefinitionsTab.test.tsx

@@ -7,8 +7,10 @@ import {
   FA_DEFINITION_ICONS,
   emojiIconKey,
   faIconName,
+  faTypedIconKey,
   findDefinitionIcon,
   normalizeDefinitionIconName,
+  searchFaIcons,
 } from "./definitionIcons";
 import type { AdminChild, DefinitionRule, QuestDefinition } from "../api/definitions";
 import { storeTokens } from "../auth/oidc";
@@ -1353,7 +1355,7 @@ describe("DefinitionsTab Font Awesome and emoji icons", () => {
     fireEvent.click(within(s).getByRole("button", { name: "Morning" }));
   }
 
-  it("ships the curated Font Awesome subset, each drawn as a filled glyph", () => {
+  it("ships the curated Font Awesome quick picks, each drawn as a filled glyph", () => {
     expect(FA_DEFINITION_ICONS.length).toBeGreaterThan(0);
     for (const entry of FA_DEFINITION_ICONS) {
       expect(entry.kind).toBe("fa");
@@ -1529,6 +1531,245 @@ describe("DefinitionsTab Font Awesome and emoji icons", () => {
   });
 });
 
+/* ── Font Awesome search ────────────────────────────────────────────── */
+
+describe("DefinitionsTab Font Awesome search", () => {
+  beforeEach(() => {
+    sessionStorage.clear();
+    storeTokens({ access_token: "at-123", expires_in: 600 });
+  });
+
+  afterEach(() => {
+    cleanup();
+    vi.unstubAllGlobals();
+    vi.useRealTimers();
+  });
+
+  const CURATED = new Set(FA_DEFINITION_ICONS.map((icon) => icon.name));
+
+  function searchInput(s: HTMLElement): HTMLInputElement {
+    return within(s).getByRole("searchbox", { name: "Search Font Awesome icons" }) as HTMLInputElement;
+  }
+
+  function results(s: HTMLElement): HTMLElement {
+    return within(s).getByRole("radiogroup", { name: "Font Awesome search results" });
+  }
+
+  function resultKeys(s: HTMLElement): string[] {
+    return within(results(s))
+      .getAllByRole("radio")
+      .map((option) => option.getAttribute("data-icon-option")!);
+  }
+
+  function rowFaIcon(row: HTMLElement): string | null {
+    const svg = row.querySelector(".defs-row-glyph svg");
+    return svg!.getAttribute("fill") === "none" ? null : svg!.getAttribute("data-icon");
+  }
+
+  async function save(s: HTMLElement) {
+    await act(async () => {
+      fireEvent.click(within(s).getByRole("button", { name: "Save changes" }));
+    });
+  }
+
+  function fillNewTask(s: HTMLElement) {
+    fireEvent.change(within(s).getByRole("textbox", { name: "Title" }), {
+      target: { value: "Walk the dog" },
+    });
+    fireEvent.click(within(s).getByRole("button", { name: /Assigned children/ }));
+    fireEvent.click(within(s).getByRole("checkbox", { name: "Declan" }));
+    fireEvent.click(within(s).getByRole("button", { name: "Morning" }));
+  }
+
+  it("searches the full Free Solid set by name or label, exact and prefix matches first", () => {
+    expect(searchFaIcons("")).toEqual([]);
+    expect(searchFaIcons("   ")).toEqual([]);
+    const dog = searchFaIcons(" DOG ").map((icon) => icon.name);
+    expect(dog[0]).toBe("dog");
+    expect(dog).toEqual(expect.arrayContaining(["hotdog", "shield-dog"]));
+    expect(dog.some((name) => !CURATED.has(name))).toBe(true);
+    // A label match: "Shield Dog" contains "shield d" though no name does.
+    expect(searchFaIcons("shield d").map((icon) => icon.name)).toContain("shield-dog");
+    expect(searchFaIcons("dog-leashed")).toEqual([]);
+
+    expect(faTypedIconKey("dragon")).toBe("fa:dragon");
+    expect(faTypedIconKey("  Dragon ")).toBe("fa:dragon");
+    for (const bad of ["", "drag", "dgo", "dog-leashed", "github", "fa:dog"]) {
+      expect(faTypedIconKey(bad), bad).toBeNull();
+    }
+  });
+
+  it("shows the curated quick picks while the search is empty", async () => {
+    await renderReady();
+    fireEvent.click(screen.getByRole("button", { name: "New" }));
+    const s = sheet();
+    expect(searchInput(s).value).toBe("");
+    const quick = within(s).getByRole("radiogroup", { name: "Font Awesome" });
+    expect(within(quick).getAllByRole("radio")).toHaveLength(FA_DEFINITION_ICONS.length);
+    expect(within(s).queryByRole("radiogroup", { name: "Font Awesome search results" })).toBeNull();
+  });
+
+  it("a query swaps the quick picks for one bounded, labelled page of results", async () => {
+    await renderReady();
+    fireEvent.click(screen.getByRole("button", { name: "New" }));
+    const s = sheet();
+    fireEvent.change(searchInput(s), { target: { value: "a" } });
+    const total = searchFaIcons("a").length;
+    expect(total).toBeGreaterThan(80);
+    expect(within(s).queryByRole("radiogroup", { name: "Font Awesome" })).toBeNull();
+    expect(resultKeys(s)).toHaveLength(40);
+    expect(within(results(s)).getAllByRole("radio")[0].textContent).toBe(searchFaIcons("a")[0].label);
+    expect(within(s).getByText(`Showing 1–40 of ${total}`)).toBeTruthy();
+    expect(within(s).queryByRole("button", { name: "Previous" })).toBeNull();
+
+    // "Show more" replaces the page rather than appending to it.
+    const firstPage = resultKeys(s);
+    fireEvent.click(within(s).getByRole("button", { name: "Show more" }));
+    expect(resultKeys(s)).toEqual(searchFaIcons("a").slice(40, 80).map((icon) => `fa:${icon.name}`));
+    expect(resultKeys(s).some((key) => firstPage.includes(key))).toBe(false);
+    expect(within(s).getByText(`Showing 41–80 of ${total}`)).toBeTruthy();
+    fireEvent.click(within(s).getByRole("button", { name: "Previous" }));
+    expect(resultKeys(s)).toEqual(firstPage);
+
+    // A new query starts again from the first page.
+    fireEvent.change(searchInput(s), { target: { value: "dog" } });
+    expect(resultKeys(s)[0]).toBe("fa:dog");
+    expect(resultKeys(s)).toContain("fa:hotdog");
+    expect(within(s).queryByRole("button", { name: "Show more" })).toBeNull();
+
+    fireEvent.change(searchInput(s), { target: { value: "" } });
+    expect(within(s).getByRole("radiogroup", { name: "Font Awesome" })).toBeTruthy();
+  });
+
+  it("paging through every match never mounts more than one page", async () => {
+    await renderReady();
+    fireEvent.click(screen.getByRole("button", { name: "New" }));
+    const s = sheet();
+    fireEvent.change(searchInput(s), { target: { value: "-" } });
+    const all = searchFaIcons("-").map((icon) => `fa:${icon.name}`);
+    expect(all.length).toBeGreaterThan(900);
+
+    const seen: string[] = [];
+    for (;;) {
+      expect(results(s).children.length).toBeGreaterThan(0);
+      expect(results(s).children.length).toBeLessThanOrEqual(40);
+      seen.push(...resultKeys(s));
+      const more = within(s).queryByRole("button", { name: "Show more" });
+      if (!more) break;
+      fireEvent.click(more);
+    }
+    // Every match stays reachable, one page at a time, in order.
+    expect(seen).toEqual(all);
+    const lastStart = Math.floor((all.length - 1) / 40) * 40 + 1;
+    expect(within(s).getByText(`Showing ${lastStart}–${all.length} of ${all.length}`)).toBeTruthy();
+  });
+
+  it("selecting a search result POSTs fa:<name> and renders on its row", async () => {
+    await renderReady();
+    fireEvent.click(screen.getByRole("button", { name: "New" }));
+    const s = sheet();
+    fillNewTask(s);
+    fireEvent.change(searchInput(s), { target: { value: "hot" } });
+    expect(within(s).getByRole("alert").textContent).toMatch(/Select a Font Awesome icon from the results/);
+    const hotdog = within(results(s)).getByRole("radio", { name: "Hotdog" });
+    fireEvent.click(hotdog);
+    expect(hotdog.getAttribute("aria-checked")).toBe("true");
+    expect(within(s).queryByRole("alert")).toBeNull();
+    expect(searchInput(s).value).toBe("hot");
+
+    await save(s);
+    expect((api.writes()[0].body as { icon: string }).icon).toBe("fa:hotdog");
+    await waitFor(() => expect(rowFaIcon(screen.getByTestId("definition-99"))).toBe("hotdog"));
+  });
+
+  it("a typed non-curated Free Solid name is accepted and PATCHed", async () => {
+    expect(CURATED.has("dragon")).toBe(false);
+    await renderReady([{ ...BRUSH, id: 70, icon: "lucide:dog" }]);
+    fireEvent.click(screen.getByTestId("definition-70"));
+    const s = sheet();
+    fireEvent.change(searchInput(s), { target: { value: "Dragon" } });
+    expect(within(s).queryByRole("alert")).toBeNull();
+    expect(within(results(s)).getByRole("radio", { name: "Dragon" }).getAttribute("aria-checked")).toBe(
+      "true",
+    );
+    const lucide = within(s).getByRole("radiogroup", { name: "Icon" });
+    expect(within(lucide).queryAllByRole("radio", { checked: true })).toHaveLength(0);
+
+    await save(s);
+    expect((api.writes()[0].body as { icon: string }).icon).toBe("fa:dragon");
+    await waitFor(() => expect(rowFaIcon(screen.getByTestId("definition-70"))).toBe("dragon"));
+  });
+
+  for (const [typed, message] of [
+    ["do", /Select a Font Awesome icon from the results/],
+    ["dgo", /“dgo” is not a Font Awesome Free Solid icon/],
+    ["dog-leashed", /“dog-leashed” is not a Font Awesome Free Solid icon/],
+    ["github", /“github” is not a Font Awesome Free Solid icon/],
+  ] as const) {
+    it(`typed ${JSON.stringify(typed)} is rejected with a message and nothing is saved`, async () => {
+      await renderReady([{ ...BRUSH, id: 71, icon: "lucide:dog" }]);
+      fireEvent.click(screen.getByTestId("definition-71"));
+      const s = sheet();
+      fireEvent.change(searchInput(s), { target: { value: typed } });
+      expect(within(s).getByRole("alert").textContent).toMatch(message);
+      expect(within(s).getByRole("radio", { name: "No icon" }).getAttribute("aria-checked")).toBe("false");
+
+      await save(s);
+      expect(api.writes()).toHaveLength(0);
+      expect(within(s).getByTestId("sheet-error").textContent).toMatch(message);
+      expect(screen.getByRole("dialog")).toBe(s);
+    });
+  }
+
+  it("clearing the search, or No icon, removes the icon", async () => {
+    await renderReady([
+      { ...BRUSH, id: 72, icon: "fa:dragon" },
+      { ...BRUSH, id: 73, title: "Task 73", icon: "fa:dragon" },
+    ]);
+    fireEvent.click(screen.getByTestId("definition-72"));
+    let s = sheet();
+    fireEvent.change(searchInput(s), { target: { value: "" } });
+    expect(within(s).getByRole("radio", { name: "No icon" }).getAttribute("aria-checked")).toBe("true");
+    await save(s);
+    expect((api.writes()[0].body as { icon: string | null }).icon).toBeNull();
+    await waitFor(() => expect(screen.queryByRole("dialog")).toBeNull());
+
+    fireEvent.click(screen.getByTestId("definition-73"));
+    s = sheet();
+    fireEvent.click(within(s).getByRole("radio", { name: "No icon" }));
+    expect(searchInput(s).value).toBe("");
+    await save(s);
+    expect((api.writes()[1].body as { icon: string | null }).icon).toBeNull();
+  });
+
+  it("a saved non-curated fa:<name> renders on its row and opens selected in the results", async () => {
+    await renderReady([{ ...BRUSH, id: 74, icon: "fa:dragon" }]);
+    expect(rowFaIcon(screen.getByTestId("definition-74"))).toBe("dragon");
+    fireEvent.click(screen.getByTestId("definition-74"));
+    const s = sheet();
+    expect(searchInput(s).value).toBe("dragon");
+    expect(within(s).queryByRole("alert")).toBeNull();
+    expect(within(results(s)).getByRole("radio", { name: "Dragon" }).getAttribute("aria-checked")).toBe(
+      "true",
+    );
+
+    fireEvent.change(within(s).getByRole("textbox", { name: "Title" }), {
+      target: { value: "Feed the dragon" },
+    });
+    await save(s);
+    expect(api.writes()[0].body).not.toHaveProperty("icon");
+  });
+
+  it("a saved curated fa:<name> opens in the quick picks with an empty search", async () => {
+    await renderReady([{ ...BRUSH, id: 75, icon: "fa:dog" }]);
+    fireEvent.click(screen.getByTestId("definition-75"));
+    const s = sheet();
+    expect(searchInput(s).value).toBe("");
+    const quick = within(s).getByRole("radiogroup", { name: "Font Awesome" });
+    expect(within(quick).getByRole("radio", { name: "Dog" }).getAttribute("aria-checked")).toBe("true");
+  });
+});
+
 /* ── Legacy icons ───────────────────────────────────────────────────── */
 
 describe("DefinitionsTab legacy icon edits", () => {

admin/src/definitions/DefinitionsTab.tsx

@@ -4,6 +4,7 @@
  */
 import {
   useEffect,
+  useMemo,
   useRef,
   useState,
   type KeyboardEvent as ReactKeyboardEvent,
@@ -53,8 +54,12 @@ import {
   emojiIconText,
   faIconKey,
   faIconName,
+  faTextProblem,
+  faTypedIconKey,
+  findDefinitionIcon,
   lucideIconKey,
   normalizeDefinitionIconName,
+  searchFaIcons,
 } from "./definitionIcons";
 import { GlyphSvg } from "../icons/GlyphSvg";
 import { weekdayOf } from "../schedule/cycle";
@@ -87,6 +92,9 @@ const REPEATS_BY_RULE: Record<DefinitionRule["rule_type"], Repeats> = {
 /** How many upcoming dates the edit sheet previews. */
 const PREVIEW_COUNT = 5;
 
+/** Font Awesome search results per page; only one page is ever mounted. */
+const FA_RESULTS_PAGE = 40;
+
 /** Quiet period after the last rule edit before the preview is requested. */
 const PREVIEW_DEBOUNCE_MS = 300;
 
@@ -101,6 +109,11 @@ interface Draft {
   icon: string | null;
   /** The emoji field's text; typing in it sets `icon` to `emoji:<text>`. */
   emoji: string;
+  /**
+   * The Font Awesome search text; typing an exact Free Solid name sets
+   * `icon` to `fa:<name>`, and picking a search result keeps the text.
+   */
+  faText: string;
   assigneeIds: number[];
   repeats: Repeats;
   interval: string;
@@ -135,6 +148,7 @@ function newDraft(activeChildren: AdminChild[], today: string): Draft {
     title: "",
     icon: null,
     emoji: "",
+    faText: "",
     assigneeIds: activeChildren.length === 1 ? [activeChildren[0].id] : [],
     repeats: "daily",
     interval: "1",
@@ -157,10 +171,13 @@ function draftFrom(definition: QuestDefinition, activeChildren: AdminChild[], to
   const active = new Set(activeChildren.map((child) => child.id));
   const dueTimes = emptyDueTimes();
   for (const w of definition.windows) dueTimes[w.window] = w.due_time ?? "";
+  const fa = findDefinitionIcon(definition.icon);
   return {
     title: definition.title,
     icon: definition.icon,
     emoji: emojiIconText(definition.icon),
+    // A Free Solid icon outside the quick picks opens as its search result.
+    faText: fa?.kind === "fa" && !FA_DEFINITION_ICONS.includes(fa) ? fa.name : "",
     // Inactive children cannot be submitted (the API rejects them with 422).
     assigneeIds: definition.assignees.map((a) => a.id).filter((id) => active.has(id)),
     repeats: REPEATS_BY_RULE[rule.rule_type],
@@ -250,6 +267,7 @@ function buildBody(draft: Draft, keepsAssignees = false): DefinitionCreateBody |
   if (draft.emoji && draft.icon === null) {
     return "Enter a single emoji (no spaces or < > &), or clear the emoji field.";
   }
+  if (draft.faText.trim() && draft.icon === null) return faTextProblem(draft.faText);
   const rule = buildRule(draft);
   if (typeof rule === "string") return rule;
   const windows: WindowEntry[] = WINDOW_ORDER.filter((w) => draft.windows.includes(w)).map(
@@ -479,6 +497,11 @@ function EditSheet({
       ? []
       : target.assignees.filter((a) => !activeChildren.some((child) => child.id === a.id));
   const [pickerOpen, setPickerOpen] = useState(false);
+  const faResults = useMemo(() => searchFaIcons(draft.faText), [draft.faText]);
+  const [faPage, setFaPage] = useState(0);
+  const faStart = faPage * FA_RESULTS_PAGE;
+  const faEnd = Math.min(faStart + FA_RESULTS_PAGE, faResults.length);
+  const noIcon = draft.icon === null && !draft.emoji && !draft.faText.trim();
   const [saving, setSaving] = useState(false);
   const [confirming, setConfirming] = useState(false);
   const [confirmingDelete, setConfirmingDelete] = useState(false);
@@ -619,12 +642,10 @@ function EditSheet({
               <button
                 type="button"
                 role="radio"
-                aria-checked={draft.icon === null && !draft.emoji}
+                aria-checked={noIcon}
                 aria-label="No icon"
-                className={
+                className={noIcon ? "defs-icon defs-icon--on" : "defs-icon"}
-                  draft.icon === null && !draft.emoji ? "defs-icon defs-icon--on" : "defs-icon"
+                onClick={() => update({ icon: null, emoji: "", faText: "" })}
-                }
-                onClick={() => update({ icon: null, emoji: "" })}
               >
                 <TaskGlyph size={18} />
               </button>
@@ -640,7 +661,7 @@ function EditSheet({
                     aria-label={label}
                     data-icon-option={name}
                     className={on ? "defs-icon defs-icon--on" : "defs-icon"}
-                    onClick={() => update({ icon: lucideIconKey(name), emoji: "" })}
+                    onClick={() => update({ icon: lucideIconKey(name), emoji: "", faText: "" })}
                   >
                     <GlyphSvg icon={icon} size={18} />
                   </button>
@@ -650,26 +671,93 @@ function EditSheet({
             <span className="defs-sublabel" id="defs-label-icon-fa">
               Font Awesome
             </span>
-            <div className="defs-icon-grid" role="radiogroup" aria-labelledby="defs-label-icon-fa">
+            <input
-              {FA_DEFINITION_ICONS.map((icon) => {
+              className="defs-input"
-                const { name, label } = icon;
+              type="search"
-                const on = faIconName(draft.icon) === name;
+              aria-label="Search Font Awesome icons"
-                return (
+              placeholder="Search or type an icon name, e.g. dog"
-                  <button
+              value={draft.faText}
-                    key={name}
+              onChange={(e) => {
-                    type="button"
+                setFaPage(0);
-                    role="radio"
+                update({ faText: e.target.value, icon: faTypedIconKey(e.target.value), emoji: "" });
-                    aria-checked={on}
+              }}
-                    aria-label={label}
+            />
-                    data-icon-option={faIconKey(name)}
+            {draft.faText.trim() && draft.icon === null ? (
-                    className={on ? "defs-icon defs-icon--on" : "defs-icon"}
+              <p className="defs-hint defs-hint--error" role="alert">
-                    onClick={() => update({ icon: faIconKey(name), emoji: "" })}
+                {faTextProblem(draft.faText)}
+              </p>
+            ) : null}
+            {draft.faText.trim() ? (
+              faResults.length > 0 ? (
+                <>
+                  <div
+                    className="defs-icon-grid defs-icon-grid--results"
+                    role="radiogroup"
+                    aria-label="Font Awesome search results"
                   >
-                    <GlyphSvg icon={icon} size={18} />
+                    {faResults.slice(faStart, faEnd).map((icon) => {
-                  </button>
+                      const { name, label } = icon;
-                );
+                      const on = faIconName(draft.icon) === name;
-              })}
+                      return (
-            </div>
+                        <button
+                          key={name}
+                          type="button"
+                          role="radio"
+                          aria-checked={on}
+                          aria-label={label}
+                          data-icon-option={faIconKey(name)}
+                          className={
+                            on ? "defs-icon defs-icon-result defs-icon--on" : "defs-icon defs-icon-result"
+                          }
+                          onClick={() => update({ icon: faIconKey(name), emoji: "" })}
+                        >
+                          <GlyphSvg icon={icon} size={18} />
+                          <span className="defs-icon-label">{label}</span>
+                        </button>
+                      );
+                    })}
+                  </div>
+                  <p className="defs-hint">
+                    Showing {faStart + 1}–{faEnd} of {faResults.length}
+                  </p>
+                  {faResults.length > FA_RESULTS_PAGE ? (
+                    <div className="defs-show-more">
+                      {faPage > 0 ? (
+                        <button type="button" className="defs-retry" onClick={() => setFaPage((page) => page - 1)}>
+                          Previous
+                        </button>
+                      ) : null}
+                      {faEnd < faResults.length ? (
+                        <button type="button" className="defs-retry" onClick={() => setFaPage((page) => page + 1)}>
+                          Show more
+                        </button>
+                      ) : null}
+                    </div>
+                  ) : null}
+                </>
+              ) : null
+            ) : (
+              <div className="defs-icon-grid" role="radiogroup" aria-labelledby="defs-label-icon-fa">
+                {FA_DEFINITION_ICONS.map((icon) => {
+                  const { name, label } = icon;
+                  const on = faIconName(draft.icon) === name;
+                  return (
+                    <button
+                      key={name}
+                      type="button"
+                      role="radio"
+                      aria-checked={on}
+                      aria-label={label}
+                      data-icon-option={faIconKey(name)}
+                      className={on ? "defs-icon defs-icon--on" : "defs-icon"}
+                      onClick={() => update({ icon: faIconKey(name), emoji: "", faText: "" })}
+                    >
+                      <GlyphSvg icon={icon} size={18} />
+                    </button>
+                  );
+                })}
+              </div>
+            )}
             <label className="defs-due">
               <span>Emoji</span>
               <input
@@ -677,7 +765,9 @@ function EditSheet({
                 aria-label="Emoji"
                 placeholder="e.g. 🐶"
                 value={draft.emoji}
-                onChange={(e) => update({ emoji: e.target.value, icon: emojiIconKey(e.target.value) })}
+                onChange={(e) =>
+                  update({ emoji: e.target.value, icon: emojiIconKey(e.target.value), faText: "" })
+                }
               />
             </label>
           </Field>

admin/src/definitions/definitionIcons.tsx

@@ -1,14 +1,23 @@
 /**
  * The icons a definition's `icon` may name (ADMIN-SPEC §3.3): the curated
- * Lucide set, the curated Font Awesome Free solid subset, or an emoji. The
+ * Lucide set, any icon in the full Font Awesome Free Solid set, or an emoji.
- * names, labels and path data come from the shared icon registry
+ * The Font Awesome quick picks (`FA_DEFINITION_ICONS`) are only a curated
- * (`src/icons/registry.generated.ts`, generated from
+ * shortcut list; `fa:<name>` resolves against the full set
- * `tools/icons/curated-icons.json`) — no CDN, no runtime fetch. The stored
+ * (`FA_SOLID_ICONS`). The names, labels and path data come from the shared
- * value is namespaced — `lucide:<name>`, `fa:<name>` or `emoji:<grapheme>` —
+ * icon registry (`src/icons/registry.generated.ts`, generated by
- * and a legacy bare `<kebab-name>` still names the same Lucide entry.
+ * `tools/icons/generate.mjs` from `tools/icons/curated-icons.json` and the
+ * installed Free Solid package) — no CDN, no runtime fetch. The stored value
+ * is namespaced — `lucide:<name>`, `fa:<name>` or `emoji:<grapheme>` — and a
+ * legacy bare `<kebab-name>` still names the same Lucide entry.
  */
 import { GlyphSvg } from "../icons/GlyphSvg";
-import { FA_ICONS, LUCIDE_ICONS, resolveIcon, type GlyphIcon } from "../icons/registry.generated";
+import {
+  FA_ICONS,
+  FA_SOLID_ICONS,
+  LUCIDE_ICONS,
+  resolveIcon,
+  type GlyphIcon,
+} from "../icons/registry.generated";
 import { TaskGlyph } from "./glyphs";
 
 export type DefinitionIconEntry = GlyphIcon;
@@ -58,14 +67,50 @@ export function faIconName(value: string | null): string | null {
   return value?.startsWith(FA_PREFIX) ? value.slice(FA_PREFIX.length) : null;
 }
 
+/**
+ * The Font Awesome Free Solid icons whose name or label contains `query`
+ * (trimmed, case-insensitive): an exact name first, then name-prefix
+ * matches, then the rest, each in registry (name) order. An empty query
+ * gives no results — the curated quick picks cover that case.
+ */
+export function searchFaIcons(query: string): DefinitionIconEntry[] {
+  const q = query.trim().toLowerCase();
+  if (!q) return [];
+  const rank = (icon: DefinitionIconEntry) => (icon.name === q ? 0 : icon.name.startsWith(q) ? 1 : 2);
+  return FA_SOLID_ICONS.filter(
+    (icon) => icon.name.includes(q) || icon.label.toLowerCase().includes(q),
+  ).sort((a, b) => rank(a) - rank(b));
+}
+
+/**
+ * The stored key for a typed Font Awesome name, e.g. `Dog` → `fa:dog`: the
+ * trimmed, lower-cased text must be the exact name of a Free Solid icon,
+ * else null (a misspelling, a partial search, or a Pro/Brands name).
+ */
+export function faTypedIconKey(text: string): string | null {
+  const key = faIconKey(text.trim().toLowerCase());
+  return resolveIcon(key).kind === "fa" ? key : null;
+}
+
+/**
+ * Why Font Awesome search text cannot be saved as it stands: it matches
+ * icons but names none of them, or it matches nothing in the Free Solid set.
+ */
+export function faTextProblem(text: string): string {
+  return searchFaIcons(text).length > 0
+    ? "Select a Font Awesome icon from the results, or type its full name."
+    : `“${text.trim()}” is not a Font Awesome Free Solid icon.`;
+}
+
 /** The emoji text an `emoji:<grapheme>` value holds; anything else gives "". */
 export function emojiIconText(value: string | null): string {
   return value?.startsWith(EMOJI_PREFIX) ? value.slice(EMOJI_PREFIX.length) : "";
 }
 
 /**
- * The curated glyph (Lucide or Font Awesome) an icon value resolves to via
+ * The glyph an icon value resolves to via the shared parser: a curated
- * the shared parser; emoji, unknown and null values give null.
+ * Lucide entry or any Font Awesome Free Solid icon (quick pick or not);
+ * emoji, unknown and null values give null.
  */
 export function findDefinitionIcon(value: string | null): DefinitionIconEntry | null {
   const icon = resolveIcon(value);

admin/src/icons/registry.test.ts

@@ -3,7 +3,14 @@ import { join } from "node:path";
 import { describe, expect, it } from "vitest";
 // The offline generator is the only writer of both registry artefacts.
 import { OUTPUT_PATHS, REPO_ROOT, SOURCE_PATH, renderRegistry } from "../../../tools/icons/generate.mjs";
-import { EMOJI_MAX_CODE_POINTS, FALLBACK_ICON, FA_ICONS, LUCIDE_ICONS, resolveIcon } from "./registry.generated";
+import {
+  EMOJI_MAX_CODE_POINTS,
+  FALLBACK_ICON,
+  FA_ICONS,
+  FA_SOLID_ICONS,
+  LUCIDE_ICONS,
+  resolveIcon,
+} from "./registry.generated";
 
 type Curated = { lucide: { name: string; label: string }[]; fa: { name: string; label: string }[] };
 
@@ -45,7 +52,18 @@ describe("shared icon registry — one source of truth", () => {
       expect(icon.viewBox).toMatch(/^0 0 \d+ 512$/);
       expect(icon.paths.length, icon.name).toBeGreaterThan(0);
     }
-    for (const icon of [...LUCIDE_ICONS, ...FA_ICONS]) {
+    const solidNames = FA_SOLID_ICONS.map((icon) => icon.name);
+    expect(solidNames.length).toBeGreaterThanOrEqual(1400);
+    expect(solidNames).toEqual([...solidNames].sort());
+    expect(new Set(solidNames).size).toBe(solidNames.length);
+    for (const { name } of FA_ICONS) expect(solidNames, name).toContain(name);
+    for (const icon of FA_SOLID_ICONS) {
+      expect(icon.kind).toBe("fa");
+      expect(icon.key).toBe(`fa:${icon.name}`);
+      expect(icon.viewBox).toMatch(/^0 0 \d+ 512$/);
+      expect(icon.paths.length, icon.name).toBeGreaterThan(0);
+    }
+    for (const icon of [...LUCIDE_ICONS, ...FA_ICONS, ...FA_SOLID_ICONS]) {
       for (const d of icon.paths) expect(d, icon.key).toMatch(/^[Mm][-0-9.,\sA-Za-z]+$/);
     }
   });
@@ -61,6 +79,12 @@ describe("resolveIcon", () => {
     expect(broom.kind).toBe("fa");
     expect(broom).toBe(FA_ICONS.find((icon) => icon.name === "broom"));
 
+    // Any Free Solid name resolves, not just the curated quick-pick set.
+    const rocket = resolveIcon("fa:rocket");
+    expect(rocket).toBe(FA_SOLID_ICONS.find((icon) => icon.name === "rocket"));
+    expect(rocket).toMatchObject({ kind: "fa", key: "fa:rocket", label: "Rocket" });
+    expect(resolveIcon("fa:person-dress-burst")).toMatchObject({ kind: "fa", label: "Person Dress Burst" });
+
     expect(resolveIcon("emoji:🐶")).toEqual({ kind: "emoji", key: "emoji:🐶", text: "🐶" });
     expect(resolveIcon("emoji:👨‍👩‍👧")).toEqual({ kind: "emoji", key: "emoji:👨‍👩‍👧", text: "👨‍👩‍👧" });
   });
@@ -133,7 +157,7 @@ describe("offline bundling", () => {
     }
   });
 
-  it("no bundled source imports an icon package — only the curated generated data ships", () => {
+  it("no bundled source imports an icon package — only the generated registry data ships", () => {
     const sources = [join(REPO_ROOT, "admin", "src"), join(REPO_ROOT, "frontend", "src")]
       .flatMap(filesUnder)
       .filter((path) => /\.(ts|tsx)$/.test(path) && !path.endsWith(".test.ts") && !path.endsWith(".test.tsx"));

custom_components/nestquest/api_client.py

@@ -16,9 +16,11 @@ network and NO aiohttp installed; production builds the client through
 :func:`client_from_entry`, which hands in Home Assistant's shared
 aiohttp session (``homeassistant.helpers.aiohttp_client
 .async_get_clientsession``).  The module itself imports NEITHER
-homeassistant NOR aiohttp at runtime (aiohttp appears only behind
+homeassistant NOR aiohttp at module import (aiohttp appears only
-``TYPE_CHECKING`` for annotations), so the client is usable anywhere —
+behind ``TYPE_CHECKING`` for annotations, plus one lazy import inside
-the HA coupling lives in the one production factory.
+:meth:`NestQuestApiClient.stream_events` for its ``ClientTimeout``), so
+the client is importable anywhere — the HA coupling lives in the one
+production factory.
 
 Every failure is typed: a transport failure (connection refused, DNS
 failure, timeout — the exchange never produced a response) and every
@@ -38,7 +40,11 @@ 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).
+reconnection and backoff).  That includes the session's own default:
+Home Assistant's shared session carries ``ClientTimeout(total=300)``,
+which would cut a healthy stream every five minutes, so the stream
+request overrides it with ``total=None`` (keeping a finite
+``sock_connect``).
 """
 from __future__ import annotations
 
@@ -278,8 +284,19 @@ class NestQuestApiClient:
         (``aclose``, i.e. the consumer's task being cancelled) stops
         cleanly and closes the underlying response in every path.
         """
+        # Lazy: aiohttp ships with Home Assistant, but importing it at
+        # module level would make the client unimportable without it.
+        import aiohttp
+
         url = f"{self._base_url}{EVENTS_PATH}"
         headers = self._headers()
+        # The session's default total timeout (HA's shared session:
+        # 300 s) would cut a healthy stream mid-body, and events fired
+        # while reconnecting are not replayed — so the stream request
+        # is unbounded in total time; only connecting stays bounded.
+        stream_timeout = aiohttp.ClientTimeout(
+            total=None, sock_connect=self._timeout_seconds
+        )
         # 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.
@@ -289,7 +306,7 @@ class NestQuestApiClient:
         try:
             async with asyncio.timeout(self._timeout_seconds):
                 stream_cm = self._session.request(
-                    "GET", url, headers=headers, json=None
+                    "GET", url, headers=headers, json=None, timeout=stream_timeout
                 )
                 response = await stream_cm.__aenter__()
         except asyncio.CancelledError:
@@ -315,7 +332,10 @@ class NestQuestApiClient:
             event_type: str | None = None
             data_lines: list[str] = []
             buffer = ""
-            async for chunk in response:
+            # The body is ``response.content`` (aiohttp's StreamReader,
+            # yielding bytes); the response object itself — HA's
+            # ``HassClientResponse`` included — is NOT async-iterable.
+            async for chunk in response.content:
                 if isinstance(chunk, (bytes, bytearray)):
                     chunk = chunk.decode("utf-8")
                 buffer += chunk

custom_components/nestquest/binary_sensor.py

@@ -9,7 +9,7 @@ snapshot (the same ChildDaySnapshot the day sensors read):
   celebration automation must never fire on an empty day (the
   day-complete event carries the same rule, Feature 10 task 7).
 - ``binary_sensor.nestquest_<child>_present_today`` — ON when the
-  presence engine resolves the child present on the HA-local date
+  presence engine resolves the child present on the household-local date
   (schedules and overrides, D-004 anchor-date arithmetic).
 
 Naming and registry identity follow the day sensors' contract: names

custom_components/nestquest/blueprints/automation/unifi_quest_access.yaml

@@ -0,0 +1,96 @@
+blueprint:
+  name: NestQuest UniFi quest access
+  description: >-
+    One automation per child. Completely block the selected UniFi clients
+    after the local weekday/weekend cutoff while that child has quests
+    remaining TODAY. Restore network access immediately when the count
+    reaches zero, and at midnight even if yesterday was incomplete.
+    A missing or unavailable quest sensor is treated as still open after
+    the cutoff; verify the sensor before enabling this automation. The
+    selected UniFi client switches are ON when access is allowed and
+    OFF when blocked. Do not select infrastructure or adult devices.
+  domain: automation
+  input:
+    remaining_sensor:
+      name: Child's quests remaining today
+      description: Select this child's NestQuest quests remaining today sensor.
+      selector:
+        entity:
+          filter:
+            - integration: nestquest
+              domain: sensor
+    client_switches:
+      name: Child's UniFi client access switches
+      description: >-
+        Select every UniFi client access switch for this child. These
+        switches are ON when network access is allowed and OFF when blocked.
+      selector:
+        entity:
+          multiple: true
+          filter:
+            - integration: unifi
+              domain: switch
+    weekday_cutoff:
+      name: Monday-Friday cutoff
+      default: "18:25:00"
+      selector:
+        time: {}
+    weekend_cutoff:
+      name: Saturday-Sunday cutoff
+      default: "14:00:00"
+      selector:
+        time: {}
+
+mode: restart
+
+variables:
+  remaining_sensor: !input remaining_sensor
+  client_switches: !input client_switches
+  weekday_cutoff: !input weekday_cutoff
+  weekend_cutoff: !input weekend_cutoff
+
+triggers:
+  - trigger: state
+    entity_id: !input remaining_sensor
+  - trigger: time
+    at: !input weekday_cutoff
+  - trigger: time
+    at: !input weekend_cutoff
+  - trigger: time
+    at: "00:00:00"
+  - trigger: homeassistant
+    event: start
+  # Reconcile after missed events or a temporary UniFi outage.
+  - trigger: time_pattern
+    minutes: "/5"
+
+conditions:
+  - condition: template
+    value_template: "{{ client_switches | count > 0 }}"
+
+actions:
+  - variables:
+      should_block: >-
+        {{ now().strftime('%H:%M') >=
+           (weekday_cutoff[:5] if now().weekday() < 5 else weekend_cutoff[:5])
+           and (states(remaining_sensor) | int(-1)) != 0 }}
+  - repeat:
+      for_each: "{{ client_switches }}"
+      sequence:
+        - choose:
+            - conditions:
+                - condition: template
+                  value_template: >-
+                    {{ should_block | bool and is_state(repeat.item, 'on') }}
+              sequence:
+                - action: switch.turn_off
+                  target:
+                    entity_id: "{{ repeat.item }}"
+            - conditions:
+                - condition: template
+                  value_template: >-
+                    {{ not (should_block | bool) and is_state(repeat.item, 'off') }}
+              sequence:
+                - action: switch.turn_on
+                  target:
+                    entity_id: "{{ repeat.item }}"

custom_components/nestquest/core/completion.py

@@ -10,7 +10,7 @@ un-completing (no-op if already open) is :func:`uncomplete_instance`.
 Instance current state is derived from the latest event via
 :func:`instance_state` (``open`` / ``done`` / ``missed``); there is
 no status column.  ``missed`` is derived for past-due open instances
-(``due_date`` before HA-local ``today``) and is never stored as an
+(``due_date`` before household-local ``today``) and is never stored as an
 event_type.
 
 Actor policy matches the schema CHECKs (D-008): ``actor_source`` is
@@ -71,10 +71,10 @@ def _completion_moment(
     now: datetime.datetime | None,
     today: datetime.date | None,
 ) -> tuple[datetime.date, datetime.time | None]:
-    """Return the HA-local completion date and optional wall-clock time.
+    """Return the household-local completion date and optional wall-clock time.
 
-    ``today`` is the HA-local calendar date when threaded (Feature 07
+    ``today`` is the household-local calendar date when threaded (Feature 07
-    style).  ``now`` is a timezone-aware HA-local datetime; its wall
+    style).  ``now`` is a timezone-aware household-local datetime; its wall
     clock is used as-is and is never converted to UTC.  When ``today``
     is omitted the date comes from ``now``.  When both are omitted the
     host calendar date is the Feature 07 fallback — never the UTC
@@ -98,7 +98,7 @@ def _completion_moment(
 
 
 def _resolve_today(today: datetime.date | None) -> datetime.date:
-    """Return the threaded HA-local date, or the host calendar date."""
+    """Return the threaded household-local date, or the host calendar date."""
     if today is None:
         return datetime.date.today()
     return today
@@ -138,7 +138,7 @@ def derive_state(
     Thin wrapper over :func:`_derived_state`: ``open``, ``done``, or
     ``missed`` from the latest event plus the due date (``missed`` is
     derived, never an event_type).  ``today`` is the caller-resolved
-    HA-local date.
+    household-local date.
     """
     return _derived_state(instance, latest, today)
 
@@ -345,7 +345,7 @@ async def instance_state(
     """Return ``open``, ``done``, or ``missed`` from the latest event.
 
     No events, or a latest event of uncompleted, is ``open`` unless
-    ``due_date`` is before ``today`` (HA-local, threaded), in which
+    ``due_date`` is before ``today`` (household-local, threaded), in which
     case it is ``missed``.  A latest event of completed is ``done``
     even when past due.  ``missed`` is never stored as an event_type.
     Unknown ``instance_id`` raises ValueError naming the field.
@@ -414,9 +414,9 @@ async def complete_instance(
     latest-event, and the append run under one connection lock so a
     concurrent complete cannot double-append.
 
-    ``was_on_time`` is computed from the HA-local completion moment
+    ``was_on_time`` is computed from the household-local completion moment
     (threaded ``now`` / ``today``) against the instance ``due_date``
-    and optional ``due_time``.  ``now`` is the timezone-aware HA-local
+    and optional ``due_time``.  ``now`` is the timezone-aware household-local
     datetime; its wall clock is never converted to UTC.  Same-day
     ``due_time`` comparison requires ``now``.
     """
@@ -471,7 +471,7 @@ async def uncomplete_instance(
     """Append an uncompleted event unless the instance is already open.
 
     Returns the derived state ``open``, or ``missed`` when the instance
-    is past due (``due_date`` before HA-local ``today``); ``appended``
+    is past due (``due_date`` before household-local ``today``); ``appended``
     reports whether THIS call appended (False on an already-open
     no-op).  Unknown ``instance_id`` raises ValueError naming the
     field.  Existence, latest-event, and the append run under one
@@ -529,7 +529,7 @@ async def list_missed_for_child(
     """Return the child's missed instances due in the closed date range.
 
     Missed means the latest event state is open and ``due_date`` is
-    before ``today`` (HA-local, threaded).  Uses
+    before ``today`` (household-local, threaded).  Uses
     :meth:`QuestInstancesDao.list_by_date_range` plus derived state.
     Never appends a missed event.  Instances and latest events are
     read inside the connection lock so the list is one snapshot.

custom_components/nestquest/core/const.py

@@ -115,8 +115,12 @@ DEFAULT_AUTOMATION_ENABLED = True
 # The household's IANA time zone (e.g. ``America/New_York``) the API
 # service reads its clock in.  The empty string is the API host's own
 # local time.  Only an admin sets it (manually, from the admin app);
-# nothing sets it automatically.  The integration itself always uses
+# nothing sets it automatically.  The integration relays the API's
-# Home Assistant's ``time_zone`` and ignores this field.
+# effective application timezone (the coordinator carries it and the
+# household sensor publishes it for the panel cards) and never derives
+# the application clock from Home Assistant's configuration; the Home
+# Assistant / browser zone applies only when the API publishes no zone
+# (e.g. an older API).
 CONF_TIMEZONE = "timezone"
 DEFAULT_TIMEZONE = ""
 

custom_components/nestquest/core/dao_instances.py

@@ -68,7 +68,7 @@ def _resolve_today(today: datetime.date | None) -> datetime.date:
     around midnight, so when the caller has already resolved the local
     date (``today``) that anchor is authoritative; ``None`` falls back to
     the host clock (:func:`_today`), which is exactly the previous
-    behavior for callers with no HA-local date.
+    behavior for callers with no household-local date.
     """
     return _today() if today is None else today
 
@@ -225,7 +225,7 @@ class QuestInstancesDao:
         - ``due_date`` must be TODAY or later: instances are never
           generated in the past (Feature 07).  The caller's
           materialization horizon is future-dated by definition.
-          ``today`` optionally pins the resolved HA-local date the
+          ``today`` optionally pins the resolved household-local date the
           guard compares against (falling back to the host clock when
           omitted) so a household time zone behind the host around
           midnight is not misread as "past".
@@ -248,7 +248,7 @@ class QuestInstancesDao:
         # check runs after the lock is acquired, because a caller can
         # wait on the lock across midnight — a date that was "today"
         # at call time may be "yesterday" by the time the INSERT runs.
-        # A caller-supplied ``today`` (HA-local) is used for BOTH
+        # A caller-supplied ``today`` (household-local) is used for BOTH
         # checks and never re-read, since it is already the anchor the
         # batch runs against.
         today_date = _resolve_today(today)
@@ -257,7 +257,7 @@ class QuestInstancesDao:
             async with self._database.transaction():
                 # Re-read "today" under the lock: this is the date the
                 # insert actually executes on, so the no-past rule
-                # holds across midnight rollovers.  A pinned HA-local
+                # holds across midnight rollovers.  A pinned household-local
                 # anchor is exempt from the re-read (see above).
                 if today is None:
                     today_date = _today()
@@ -364,7 +364,7 @@ class QuestInstancesDao:
         rather than raising, so the rest of the batch is unaffected.  The
         no-past rule (instances are never generated in the past) is
         preserved from :meth:`upsert` and still raises ValueError; ``today``
-        optionally pins the HA-local anchor it compares against.  An
+        optionally pins the household-local anchor it compares against.  An
         instance that ALREADY has a completion event is also skipped
         (returns ``None``) rather than raised: it is immutable, so the
         walk leaves it untouched instead of failing the batch — the
@@ -504,7 +504,7 @@ class QuestInstancesDao:
         append-only contract: an instance that was ever completed is
         never reported missed, even when later reversed — history keeps
         both rows and the sweep never mutates any).  The watermark is
-        the HA-local date the sweep last ran, and the window is
+        the household-local date the sweep last ran, and the window is
         ``[watermark, today)``: the nightly run entering day D+1 sweeps
         exactly day D's instances, so every day's quests are announced
         once — at the midnight after their due date — and a same-night
@@ -544,9 +544,10 @@ class QuestInstancesDao:
         rolling horizon from now), so a caller cannot use this to
         rewrite past open instances either — the day-rollover missed
         sweep (Feature 11) handles past-due instances instead.  ``today``
-        optionally pins the HA-local anchor the clamp compares against
+        optionally pins the household-local anchor the clamp compares
-        (falling back to the host clock when omitted).  Any instance with
+        against (falling back to the host clock when omitted).  Any
-        a completion event is never touched, regardless of its date.
+        instance with a completion event is never touched, regardless of
+        its date.
         Returns the number deleted.
         """
         _validate_date(cutoff_date, "cutoff_date")
@@ -581,8 +582,9 @@ class QuestInstancesDao:
         one transaction — an instance that gains a completion event
         mid-flight cannot be deleted.  The cutoff cannot be backdated below
         today, for the same reason as the definition-scoped method (see its
-        docstring).  ``today`` optionally pins the HA-local anchor the clamp
+        docstring).  ``today`` optionally pins the household-local anchor
-        compares against (falling back to the host clock when omitted).
+        the clamp compares against (falling back to the host clock when
+        omitted).
         Any instance with a completion event is never touched, regardless
         of its date.
 

custom_components/nestquest/core/events.py

@@ -39,10 +39,11 @@ ISO-8601 timestamp.  Completion payloads additionally carry
 ``was_on_time``.  No other personal data: names and titles are the
 household's own records, and nothing beyond them leaks.
 
-Timezone policy: the day-complete check needs the HA-local "today",
+Timezone policy: the day-complete check needs the household-local
-which the caller passes in as a plain :class:`datetime.date`.  Nothing
+"today", which the caller passes in as a plain :class:`datetime.date`.
-here reads ``hass.config.time_zone`` — the integration owns HA
+Nothing here reads a timezone — the API owns the clock (the
-timezone, the core owns the calendar arithmetic.
+admin-stored application timezone, or the API host's local zone when
+none is stored), the core owns the calendar arithmetic.
 """
 from __future__ import annotations
 
@@ -147,10 +148,10 @@ async def build_child_day_complete_event(
     completion of TODAY'S instance evaluates it: completing a
     back-dated or future instance must not announce a cleared day.
 
-    ``today`` is the HA-local calendar date the day-complete rule is
+    ``today`` is the household-local calendar date the day-complete
-    evaluated against; the integration reads it from
+    rule is evaluated against; the API resolves it in the application
-    ``hass.config.time_zone`` and passes it in, so this module never
+    timezone and passes it in, so this module never reads a clock or a
-    touches HA config.
+    timezone of its own.
     """
     # Only a completion of TODAY'S instance evaluates the day-complete
     # rule: completing a back-dated or future instance must not

custom_components/nestquest/core/history.py

@@ -153,7 +153,7 @@ def _validate_range(start_date: str, end_date: str) -> tuple[str, str]:
 
 
 def _resolve_today(today: datetime.date | None) -> datetime.date:
-    """Return the threaded HA-local date, or the host calendar date."""
+    """Return the threaded household-local date, or the host calendar date."""
     if today is None:
         return datetime.date.today()
     return today
@@ -283,7 +283,7 @@ async def query_history(
 
     Rows are ordered deterministically by ``due_date``, then instance,
     then event id (the per-instance append order, so a completion and
-    its reversal keep their order).  ``today`` pins the HA-local date
+    its reversal keep their order).  ``today`` pins the household-local date
     the missed derivation compares due dates against (the host calendar
     date when omitted).  The whole read runs under the task-reentrant
     connection lock — :func:`list_missed_for_child` re-enters it — so

custom_components/nestquest/core/materialize.py

@@ -255,12 +255,12 @@ async def materialize(
     after a presence change) cannot touch any unrelated child's rows.
     When omitted (or None) the walk covers every assignee as before.
 
-    ``today`` optionally pins the resolved HA-local date the walk's
+    ``today`` optionally pins the resolved household-local date the walk's
     no-past guard compares against; it is threaded into every
     :meth:`~.dao_instances.QuestInstancesDao.upsert_if_valid` write.  When
     omitted the host clock (``datetime.date.today``) is used, which is the
-    historical default.  A caller that computed the horizon in Home
+    historical default.  A caller that computed the horizon in the
-    Assistant's configured time zone MUST pass that same date here so a
+    household's application time zone MUST pass that same date here so a
     time zone behind the host around midnight is not rejected as "past".
 
     ``start_date`` is clamped up to the resolved "today" (the same
@@ -298,8 +298,8 @@ async def materialize(
     start = datetime.datetime.strptime(start_date, "%Y-%m-%d").date()
     end = datetime.datetime.strptime(end_date, "%Y-%m-%d").date()
 
-    # Clamp a past start up to today (the HA-local anchor when the caller
+    # Clamp a past start up to today (the household-local anchor when the
-    # pinned one, else the host clock) so the walk can never emit a
+    # caller pinned one, else the host clock) so the walk can never emit a
     # past-dated instance; the DAO's no-past guard remains the backstop.
     # A range entirely in the past therefore yields zero instances.
     today_date = _resolve_today(today)
@@ -345,7 +345,7 @@ async def regenerate_for_definition(
     :func:`~.dao_instances._today` — so the delete cutoff and the
     re-materialization range share one anchor, and the walk's
     ``upsert_if_valid`` no-past guard never rejects the regenerated
-    range.  ``today`` optionally pins a caller-resolved HA-local date
+    range.  ``today`` optionally pins a caller-resolved household-local date
     (threaded into both the delete cutoff and the re-materialization)
     so a household time zone behind the host around midnight stays
     consistent.  ``horizon_days`` sizes the re-materialization window;
@@ -413,9 +413,9 @@ async def regenerate_for_child(
     :meth:`~.dao_instances.QuestInstancesDao.delete_future_uncompleted_for_child`),
     so the delete cutoff and the re-materialization window share ONE
     execution-day anchor even when the call is queued across midnight.
-    ``today`` optionally pins a caller-resolved HA-local date, threaded
+    ``today`` optionally pins a caller-resolved household-local date, threaded
     into the delete cutoff and the re-materialization for the same
-    host-vs-HA time-zone consistency.  ``horizon_days`` sizes the
+    host-vs-household time-zone consistency.  ``horizon_days`` sizes the
     re-materialization window; when omitted it falls back to
     :data:`~.const.DEFAULT_HORIZON_DAYS`.  A bool, non-int, or sub-1 value
     raises ValueError BEFORE any delete.  Returns the number of instances

custom_components/nestquest/core/quest_definitions.py

@@ -345,7 +345,7 @@ async def edit_quest_definition(
     future instances only; no ``quest_instances`` or
     ``completion_events`` row is touched.
 
-    ``today`` optionally pins the caller-resolved HA-local date the
+    ``today`` optionally pins the caller-resolved household-local date the
     regeneration's no-past guard and horizon are anchored to (threaded
     into :func:`~.materialize.regenerate_for_definition`); it is a plain
     ``datetime.date`` with no HA import here — the Feature 09 service
@@ -449,7 +449,7 @@ async def assign_child(
     ``quest_definition_assignees`` link is written; existing instances
     and completion history are never touched.
 
-    ``today`` optionally pins the caller-resolved HA-local date threaded
+    ``today`` optionally pins the caller-resolved household-local date threaded
     into the assignment's regeneration (see :func:`edit_quest_definition`).
     ``horizon_days`` optionally sizes the regeneration's re-materialization
     window the same way.
@@ -491,7 +491,7 @@ async def unassign_child(
     argument.  Only the ``quest_definition_assignees`` link is written;
     existing instances and completion history are never touched.
 
-    ``today`` optionally pins the caller-resolved HA-local date threaded
+    ``today`` optionally pins the caller-resolved household-local date threaded
     into the unassignment's regeneration (see :func:`edit_quest_definition`).
     ``horizon_days`` optionally sizes the regeneration's re-materialization
     window the same way.
@@ -548,7 +548,7 @@ async def set_quest_definition_active(
     connection-scoped lock, so the returned bundle is a consistent
     snapshot that a concurrent mutation cannot race.
 
-    ``today`` optionally pins the caller-resolved HA-local date threaded
+    ``today`` optionally pins the caller-resolved household-local date threaded
     into the activation change's regeneration (see
     :func:`edit_quest_definition`).  ``horizon_days`` optionally sizes the
     regeneration's re-materialization window the same way.

custom_components/nestquest/core/settings.py

@@ -316,12 +316,11 @@ class NestQuestSettings:
 
         The API service does not run inside Home Assistant, so its one
         clock read (an aware host-local ``now``) is converted here: with
-        :attr:`timezone` set — the admin's choice, or else the zone the
+        :attr:`timezone` set — only ever by an admin, from the admin
-        integration reports from Home Assistant — the SAME instant is
+        app — the SAME instant is re-expressed in that zone, so
-        re-expressed in that zone, so ``.date()`` and ``.time()`` are the
+        ``.date()`` and ``.time()`` are the household's wall clock even
-        household's wall clock even when the host runs UTC.  With
+        when the host runs UTC.  With :attr:`timezone` empty the instant
-        :attr:`timezone` empty the instant is returned unchanged (the
+        is returned unchanged (the host's local time).
-        host's local time).
         """
         if not self.timezone:
             return instant
@@ -341,7 +340,7 @@ class NestQuestSettings:
         """Return the rolling horizon window ``[today, today + horizon_days]``.
 
         ``today`` is REQUIRED (there is no host-clock default): the
-        integration passes the HA-local ``hass.config.time_zone`` date so
+        API passes the household-local date (:meth:`household_now`) so
         the horizon tracks the household's own day, and a silent
         host-clock fallback would be a wrong-day footgun (a test or a
         caller that forgets to pass ``today`` would otherwise materialize

custom_components/nestquest/core/snapshot.py

@@ -18,7 +18,7 @@ the panel payload shaper (:func:`instance_payload`), and the async
 service's panel snapshot route share ONE implementation of both the
 snapshot assembly and the entity-facing attribute payload shape.
 Nothing here imports :mod:`homeassistant`; the builder takes the
-database, the settings object, and the HA-local ``now`` (a single
+database, the settings object, and the household-local ``now`` (a single
 clock read the caller already resolved, from which it derives
 ``today``) and returns the snapshot, mirroring exactly what the
 coordinator used to do inline.
@@ -187,7 +187,7 @@ async def build_snapshot(
     :func:`instance_payload` layer — this builder produces the shared
     shape both consumers read.
 
-    ``now`` is the HA-local timezone-aware datetime the caller already
+    ``now`` is the household-local timezone-aware datetime the caller already
     resolved (a SINGLE clock read); the overdue check compares
     ``now.time()`` against the instance's ``due_time`` for today's open
     instances.  The builder performs NO internal clock read — it never

custom_components/nestquest/core/sweep.py

@@ -39,9 +39,10 @@ lets exactly one of them win the claim — the loser returns [] and
 announces nothing.
 
 The caller supplies ``today`` as a plain :class:`datetime.date`: the
-household-local calendar date, read from ``hass.config.time_zone`` by
+household-local calendar date, which the API reads in the
-the integration or from the configured household timezone by the API.
+admin-stored application timezone (the API host's local zone when none
-This module never reads a timezone database or config of its own.
+is stored).  This module never reads a timezone database or config of
+its own.
 """
 from __future__ import annotations
 
@@ -97,9 +98,9 @@ async def run_missed_sweep(
     """Build one missed event per unswept past-due open instance.
 
     ``today`` is the household-local calendar date the sweep runs for
-    (the caller owns the clock: the integration reads it from
+    (the caller owns the clock: the API reads it in the admin-stored
-    ``hass.config.time_zone``, the API from the configured household
+    application timezone, falling back to its host's local time when
-    timezone, falling back to its host's local time when unset).
+    unset).
     Returns the ``(event_type, payload)`` tuples to announce, EMPTY
     when the watermark already covers ``today`` (a same-night rerun) —
     the caller decides how to publish them and announces nothing on

custom_components/nestquest/manifest.json

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

design/ADMIN-SPEC.md

@@ -105,14 +105,25 @@ Each definition carries one optional icon, shown on both surfaces. The picker of
 sources:
 
 - **Lucide** — a grid of the curated Lucide glyphs, drawn stroked.
-- **Font Awesome** — a grid of a curated subset of the Font Awesome Free *solid* set,
+- **Font Awesome** — a search over the **full** Font Awesome Free *solid* set (every
-  drawn filled.
+  glyph in `@fortawesome/free-solid-svg-icons`), plus a curated quick-pick grid, all drawn
+  filled. With the search field empty the quick-pick grid shows; typing filters the full
+  set by name or label (an exact name ranks first, then name prefixes, then the rest),
+  shown 40 results per page with *Previous* / *Show more*.
+  **Free-text rule:** an admin may type a Free Solid icon name directly (trimmed,
+  case-insensitive — `Dog` stores `fa:dog`). Text that is not the exact name of a Free
+  Solid icon — a partial search, a misspelling, or a Pro or Brands name — is rejected in
+  the picker with an inline error and cannot be saved until a result is selected or the
+  full name is typed.
 - **Emoji** — a text input; the typed emoji is stored as entered (not trimmed) and must be
   1–8 code points with no whitespace, control characters, `<`, `>` or `&`.
 
-Both curated lists come from `tools/icons/curated-icons.json`; their glyph path data is
+The curated Lucide set and the Font Awesome quick-pick list come from
-generated into the admin and panel bundles by `tools/icons/generate.mjs` (no CDN, no
+`tools/icons/curated-icons.json`; `tools/icons/generate.mjs` generates their glyph path
-runtime fetch). See `THIRD-PARTY-NOTICES.md` for licences.
+data, together with the full Font Awesome Free Solid set, into the admin and panel bundles
+(no CDN, no runtime fetch). Embedding the full set makes both bundles heavier — the panel
+bundle (`nestquest-cards.js`) is about 1 MB raw / 276 kB gzip. See
+`THIRD-PARTY-NOTICES.md` for licences.
 
 The stored value is a **namespaced key**:
 

design/DESIGN-HANDOFF.md

@@ -78,6 +78,6 @@ The panel speaks tabletop; the admin speaks plainly. Both sit on the same `quest
   decide before shipping the card.
 - No gamification is in scope. XP, levels, streaks and rarity were explicitly deferred,
   but the append-only event log already supports computing them later.
-- Icon per quest definition is chosen by the parent from curated Lucide and Font Awesome
+- Icon per quest definition is chosen by the parent from the curated Lucide set, the full
-  Free sets or as an emoji, stored as a namespaced key (`lucide:`/`fa:`/`emoji:`) —
+  Font Awesome Free Solid set (searchable, with curated quick picks) or as an emoji, stored as a namespaced key (`lucide:`/`fa:`/`emoji:`) —
   resolved 2026-09-26, see `ADMIN-SPEC.md` §3.3.

design/PANEL-SPEC.md

@@ -106,7 +106,8 @@ collapse the column, the three-column rhythm is the layout.
 1. **Icon tile** 64×64, radius 10px, `--nq-p-icon-tile`, glyph 34px white — the
    definition's icon, resolved from its namespaced key (`ADMIN-SPEC.md` §3.3):
    `lucide:<name>` draws the curated Lucide glyph **stroked** (fill none, stroke-width 2,
-   round caps and joins); `fa:<name>` draws the curated Font Awesome glyph **filled**;
+   round caps and joins); `fa:<name>` draws the Font Awesome Free Solid glyph **filled** (any icon in the full
+   set, not only the quick picks);
    `emoji:<grapheme>` renders the emoji **as text**. A legacy bare name resolves as
    `lucide:<name>`. No icon, or any key that does not resolve (unknown namespace or name,
    malformed emoji), falls back to the **star** glyph. Glyph data is bundled from the

design/logos/BRAND-ICONS.md

@@ -0,0 +1,48 @@
+# NestQuest brand icons in Home Assistant
+
+## Where the icon comes from
+
+Since Home Assistant 2026.3, a custom integration can ship its own brand
+images in `custom_components/<domain>/brand/`, and Home Assistant serves them
+ahead of the brands CDN (`brands.home-assistant.io`). NestQuest ships:
+
+| File | Size |
+|------|------|
+| `custom_components/nestquest/brand/icon.png` | 256×256 |
+| `custom_components/nestquest/brand/icon@2x.png` | 512×512 |
+| `custom_components/nestquest/brand/logo.png` | 256×256 |
+| `custom_components/nestquest/brand/logo@2x.png` | 512×512 |
+
+HACS installs the whole `custom_components/nestquest/` directory, so these
+images arrive with the integration. On Home Assistant 2026.3 or newer they
+appear on the integrations page and the integration tile, through Home
+Assistant's brand endpoint. Older Home Assistant versions ignore the directory
+and show the generic placeholder icon.
+
+The `custom_integrations` folder of the `home-assistant/brands` repository is
+legacy for this purpose; NestQuest does not depend on it.
+
+## Known caveat: the HACS store card
+
+The HACS store card (the repository listing inside HACS, shown before and
+after installing) is rendered by HACS itself, not by the integration. It may
+still take its image from the brands CDN or fall back to the avatar of the
+repository owner (the `Maniacs-Mansion` organization). Whether HACS reads the
+local `brand/` directory for that card has not been verified, so that icon
+may stay generic. The repository page inside HACS shows the README, which
+embeds the logo from `design/logos/NestQuest-NoBG.png`.
+
+## Regenerating
+
+The PNGs are generated offline and deterministically (pure Node, zlib only)
+from `design/logos/NestQuest-NoBG.png`, box-filter downscaled with
+transparency kept. From the repository root:
+
+```bash
+node design/logos/generate-brand-icons.mjs          # write the four PNGs
+node design/logos/generate-brand-icons.mjs --check  # exit 1 if any drifted
+```
+
+`tests/test_brand_icons.py` runs the `--check` and asserts the four files
+exist with the expected sizes, so a missing or hand-edited image fails the
+test suite.

design/logos/generate-brand-icons.mjs

@@ -0,0 +1,187 @@
+// Generates the integration's local brand images in
+// custom_components/nestquest/brand/ (read by Home Assistant 2026.3+) from the
+// transparent logo (design/logos/NestQuest-NoBG.png), box-filter downscaled
+// with alpha kept. Adapted from admin/scripts/generate-icons.mjs for RGBA.
+// Pure Node (zlib only) — no network, no image dependencies.
+// Run (from the repository root):
+//   node design/logos/generate-brand-icons.mjs          # write the PNGs
+//   node design/logos/generate-brand-icons.mjs --check  # exit 1 if any drifted
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { deflateSync, inflateSync } from "node:zlib";
+import { fileURLToPath } from "node:url";
+
+const SIG = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
+
+const CRC_TABLE = Array.from({ length: 256 }, (_, n) => {
+  let c = n;
+  for (let k = 0; k < 8; k++) c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+  return c >>> 0;
+});
+
+function crc32(buf) {
+  let c = 0xffffffff;
+  for (const b of buf) c = CRC_TABLE[(c ^ b) & 0xff] ^ (c >>> 8);
+  return (c ^ 0xffffffff) >>> 0;
+}
+
+function chunk(type, data) {
+  const len = Buffer.alloc(4);
+  len.writeUInt32BE(data.length);
+  const body = Buffer.concat([Buffer.from(type, "ascii"), data]);
+  const crc = Buffer.alloc(4);
+  crc.writeUInt32BE(crc32(body));
+  return Buffer.concat([len, body, crc]);
+}
+
+function encodePng(size, rgba) {
+  const ihdr = Buffer.alloc(13);
+  ihdr.writeUInt32BE(size, 0);
+  ihdr.writeUInt32BE(size, 4);
+  ihdr[8] = 8; // bit depth
+  ihdr[9] = 6; // colour type: RGBA
+  const stride = size * 4;
+  const raw = Buffer.alloc(size * (stride + 1));
+  for (let y = 0; y < size; y++) {
+    raw[y * (stride + 1)] = 0; // filter: none
+    raw.set(rgba.subarray(y * stride, (y + 1) * stride), y * (stride + 1) + 1);
+  }
+  return Buffer.concat([
+    SIG,
+    chunk("IHDR", ihdr),
+    chunk("IDAT", deflateSync(raw, { level: 9 })),
+    chunk("IEND", Buffer.alloc(0)),
+  ]);
+}
+
+// Minimal decoder for the source logo: 8-bit RGBA, non-interlaced only.
+// Anything else fails loudly rather than producing a wrong icon.
+function decodePng(buf) {
+  if (!buf.subarray(0, 8).equals(SIG)) throw new Error("not a PNG");
+  let width, height;
+  const idat = [];
+  for (let off = 8; off < buf.length; ) {
+    const len = buf.readUInt32BE(off);
+    const type = buf.toString("ascii", off + 4, off + 8);
+    const data = buf.subarray(off + 8, off + 8 + len);
+    if (type === "IHDR") {
+      width = data.readUInt32BE(0);
+      height = data.readUInt32BE(4);
+      const [depth, colour, , , interlace] = data.subarray(8);
+      if (depth !== 8 || colour !== 6 || interlace !== 0) {
+        throw new Error(`unsupported PNG: depth ${depth}, colour type ${colour}, interlace ${interlace}`);
+      }
+    } else if (type === "IDAT") idat.push(data);
+    else if (type === "IEND") break;
+    off += 12 + len;
+  }
+  const raw = inflateSync(Buffer.concat(idat));
+  const stride = width * 4;
+  const px = Buffer.alloc(stride * height);
+  for (let y = 0; y < height; y++) {
+    const filter = raw[y * (stride + 1)];
+    const src = y * (stride + 1) + 1;
+    const dst = y * stride;
+    for (let i = 0; i < stride; i++) {
+      const a = i >= 4 ? px[dst + i - 4] : 0;
+      const b = y > 0 ? px[dst - stride + i] : 0;
+      const c = i >= 4 && y > 0 ? px[dst - stride + i - 4] : 0;
+      let p;
+      if (filter === 0) p = 0;
+      else if (filter === 1) p = a;
+      else if (filter === 2) p = b;
+      else if (filter === 3) p = (a + b) >> 1;
+      else if (filter === 4) {
+        const pa = Math.abs(b - c), pb = Math.abs(a - c), pc = Math.abs(a + b - 2 * c);
+        p = pa <= pb && pa <= pc ? a : pb <= pc ? b : c;
+      } else throw new Error(`bad PNG filter ${filter} on row ${y}`);
+      px[dst + i] = (raw[src + i] + p) & 0xff;
+    }
+  }
+  if (width !== height) throw new Error(`logo must be square, got ${width}x${height}`);
+  return { width, height, px };
+}
+
+// Box-filter (area-average) resize along one axis: each output sample is the
+// coverage-weighted mean of the source samples it spans.
+function boxWeights(srcLen, dstLen) {
+  const scale = srcLen / dstLen;
+  return Array.from({ length: dstLen }, (_, o) => {
+    const start = o * scale, end = start + scale;
+    const taps = [];
+    for (let s = Math.floor(start); s < Math.min(Math.ceil(end), srcLen); s++) {
+      taps.push([s, (Math.min(end, s + 1) - Math.max(start, s)) / scale]);
+    }
+    return taps;
+  });
+}
+
+// Colour is averaged premultiplied by alpha, so fully transparent source
+// pixels (whatever RGB they carry) cannot bleed a fringe into the edges.
+function resize({ width, height, px }, size) {
+  const wx = boxWeights(width, size);
+  const wy = boxWeights(height, size);
+  const tmp = new Float64Array(size * height * 4); // horizontal pass, premultiplied
+  for (let y = 0; y < height; y++) {
+    for (let x = 0; x < size; x++) {
+      const t = (y * size + x) * 4;
+      for (const [s, w] of wx[x]) {
+        const p = (y * width + s) * 4;
+        const aw = px[p + 3] * w;
+        for (let k = 0; k < 3; k++) tmp[t + k] += px[p + k] * aw;
+        tmp[t + 3] += aw;
+      }
+    }
+  }
+  const out = new Uint8Array(size * size * 4); // vertical pass, un-premultiply
+  for (let y = 0; y < size; y++) {
+    for (let x = 0; x < size; x++) {
+      const acc = [0, 0, 0, 0];
+      for (const [s, w] of wy[y]) {
+        const t = (s * size + x) * 4;
+        for (let k = 0; k < 4; k++) acc[k] += tmp[t + k] * w;
+      }
+      const o = (y * size + x) * 4;
+      const alpha = Math.min(255, Math.round(acc[3]));
+      for (let k = 0; k < 3; k++) {
+        out[o + k] = alpha === 0 ? 0 : Math.min(255, Math.round(acc[k] / acc[3]));
+      }
+      out[o + 3] = alpha;
+    }
+  }
+  return out;
+}
+
+const logo = decodePng(readFileSync(new URL("NestQuest-NoBG.png", import.meta.url)));
+const outDir = new URL("../../custom_components/nestquest/brand/", import.meta.url);
+const files = [
+  ["icon.png", 256],
+  ["icon@2x.png", 512],
+  ["logo.png", 256],
+  ["logo@2x.png", 512],
+];
+const check = process.argv.includes("--check");
+let drifted = false;
+if (!check) mkdirSync(outDir, { recursive: true });
+for (const [name, size] of files) {
+  const path = fileURLToPath(new URL(name, outDir));
+  const png = encodePng(size, resize(logo, size));
+  if (check) {
+    let current = null;
+    try {
+      current = readFileSync(path);
+    } catch {
+      // missing counts as drift
+    }
+    if (!current || !current.equals(png)) {
+      drifted = true;
+      console.error(`drift: ${path} differs from a fresh generation`);
+    }
+  } else {
+    writeFileSync(path, png);
+    console.log(`wrote ${path}`);
+  }
+}
+if (drifted) {
+  console.error("run `node design/logos/generate-brand-icons.mjs` and commit the result");
+  process.exit(1);
+}

docs/ARCHITECTURE.md

@@ -99,6 +99,38 @@ A lone `home` pattern answers exactly as the old schedule did, so no
 child's presence changes. The drop is one-way and 0.7.1 refuses a
 version-9 database; see the rollback step in `deploy/RUNBOOK.md` §11.
 
+### Application timezone (manual, admin-set)
+
+The application timezone is set **manually by an admin from the admin
+app** — the Settings screen's timezone picker, which reads and writes the
+`timezone` field of `GET`/`PATCH /api/v1/admin/settings`. Nothing sets it
+automatically: there is no Home Assistant zone adoption, no browser-zone
+auto-detect, and no auto-save when a screen loads. Only an admin's `PATCH`
+ever changes the stored value.
+
+The stored value is the **single source of local-time truth for the whole
+application.** The API reads its one clock and re-expresses it in that zone
+(`NestQuestSettings.household_now`), so every local date and time comes
+from it:
+
+- the panel snapshot's today and overdue state, and both panel cards'
+  visible dates and clocks (the snapshot publishes the zone as `timezone`,
+  which the integration exposes on the household rollup sensor);
+- completion timestamps (the local completion date and the on-time check);
+- the missed-sweep scheduler's household rollover;
+- every admin read, and the admin app's local-time formatting.
+
+**Empty means the API host's local zone.** While `timezone` is empty the
+API reads its clock in the host's local time, and publishes that zone as
+the effective zone (`api/host_zone.py`: the `effective_timezone` field of
+the admin settings response and the snapshot's `timezone`) until an admin
+sets one. No code fills the empty value in.
+
+**A save re-plans the sweep.** An admin save that changes `timezone` or
+`day_rollover_time` notifies the running missed-sweep scheduler
+(`MissedSweepScheduler.settings_changed`, under its settings lock), which
+re-plans its next sweep for the new household rollover.
+
 ## 4. Authentication: two planes
 
 The kid panel and the admin PWA have opposite trust levels, so they use

frontend/src/icons/render.ts

@@ -1,7 +1,8 @@
 /**
  * Lit rendering for the shared icon registry (`registry.generated.ts`,
- * generated from tools/icons/curated-icons.json). The glyph path data is
+ * generated by tools/icons/generate.mjs: the curated Lucide set plus the full
- * bundled — no CDN and no runtime fetch.
+ * Font Awesome Free Solid set). The glyph path data is bundled — no CDN and
+ * no runtime fetch.
  */
 import { html, svg, type TemplateResult } from "lit";
 

pyproject.toml

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

tests/conftest.py

@@ -879,6 +879,29 @@ def set_coordinator_client(entry, client):
     return client
 
 
+@dataclass(frozen=True)
+class FakeClientTimeout:
+    """Stand-in for ``aiohttp.ClientTimeout`` (the fields the client sets)."""
+
+    total: float | None = None
+    sock_connect: float | None = None
+
+
+@pytest.fixture
+def fake_aiohttp(monkeypatch):
+    """Install a stand-in ``aiohttp`` module for one test.
+
+    aiohttp ships only with Home Assistant, so this mock-only harness
+    does not have it; the API client imports it lazily inside
+    ``stream_events`` (for ``ClientTimeout``).  Tests driving the real
+    stream path request this fixture; the module is removed again when
+    the test ends.
+    """
+    module = SimpleNamespace(ClientTimeout=FakeClientTimeout)
+    monkeypatch.setitem(sys.modules, "aiohttp", module)
+    return module
+
+
 @pytest.fixture(autouse=True)
 def coordinator_client_from_test_override():
     """Resolve every entry's coordinator client through the test seam.
@@ -1017,8 +1040,8 @@ def make_hass() -> tuple:
     hass.bus = EventBus()
     hass.http = HttpRegistry()
     hass.extra_js_urls: list[str] = []
-    # A valid IANA time zone (the day-rollover listener reads it to
+    # A valid IANA time zone for the fake Home Assistant config (the
-    # compute "today" in HA local time).
+    # NestQuest application timezone is the admin-set setting, not this).
     hass.config.time_zone = "UTC"
 
     # The minimal entity registry: entities self-register through

tests/test_api_client.py

@@ -17,7 +17,7 @@ import types
 
 import pytest
 
-from conftest import make_config_entry
+from conftest import FakeClientTimeout, make_config_entry
 
 from custom_components.nestquest import api_client
 from custom_components.nestquest.api_client import (
@@ -33,6 +33,10 @@ from custom_components.nestquest.const import (
     DEFAULT_PANEL_TOKEN,
 )
 
+# ``stream_events`` imports aiohttp lazily; the harness has none, so
+# every test here runs with the stand-in module installed.
+pytestmark = pytest.mark.usefixtures("fake_aiohttp")
+
 BASE_URL = "http://api.test:8000"
 TOKEN = "test-panel-token"
 
@@ -124,6 +128,7 @@ class StubTransport:
                 "url": url,
                 "headers": kwargs.get("headers"),
                 "json": kwargs.get("json"),
+                "timeout": kwargs.get("timeout"),
             }
         )
         if not self._outcomes:
@@ -472,4 +477,109 @@ async def test_client_logs_nothing() -> None:
             await client.get_snapshot()
     finally:
         logging.getLogger().removeHandler(handler)
-    assert records == []
+    assert records == []
+
+# ---------------------------------------------------------------------------
+# stream_events: the body is read from ``response.content``
+# ---------------------------------------------------------------------------
+
+
+class _StubStreamContent:
+    """A fake aiohttp ``StreamReader``: async-iterable over byte chunks."""
+
+    def __init__(self, chunks) -> None:
+        self._chunks = list(chunks)
+
+    def __aiter__(self):
+        return self._iterate()
+
+    async def _iterate(self):
+        for chunk in self._chunks:
+            yield chunk
+
+
+class StubStreamResponse:
+    """A fake aiohttp/HA ``ClientResponse`` for a streaming body.
+
+    Like the real ``HassClientResponse`` it does NOT implement
+    ``__aiter__`` — the body is iterated through ``.content`` — so a
+    client that iterates the response object itself raises the
+    ``'async for' requires an object with __aiter__ method`` TypeError.
+    """
+
+    def __init__(self, status: int, chunks) -> None:
+        self.status = status
+        self.content = _StubStreamContent(chunks)
+
+
+async def test_stream_events_reads_frames_from_response_content() -> None:
+    """Frames are parsed from ``response.content`` byte chunks, including
+    a frame split across chunk boundaries; a trailing incomplete frame
+    is discarded."""
+    assert not hasattr(StubStreamResponse, "__aiter__")
+    chunks = [
+        b'event: nestquest_quest_completed\ndata: {"instance_id"',
+        b': 7}\n',
+        b'\nevent: nestquest_child_day_complete\n',
+        b'data: {"child_id": 1}\n\n',
+        b'event: nestquest_quest_missed\ndata: {"instance_id": 9}\n',
+    ]
+    transport = StubTransport(StubStreamResponse(200, chunks))
+    client = make_client(transport)
+
+    frames = [frame async for frame in client.stream_events()]
+
+    assert frames == [
+        ("nestquest_quest_completed", {"instance_id": 7}),
+        ("nestquest_child_day_complete", {"child_id": 1}),
+    ]
+    assert transport.calls[0]["method"] == "GET"
+    assert transport.calls[0]["url"] == f"{BASE_URL}/api/v1/panel/events"
+
+
+async def test_stream_events_non_2xx_raises_typed_with_status() -> None:
+    transport = StubTransport(StubStreamResponse(502, []))
+    client = make_client(transport)
+
+    with pytest.raises(NestQuestApiError) as excinfo:
+        async for _ in client.stream_events():
+            pass
+
+    assert excinfo.value.status == 502
+    assert not excinfo.value.is_transport_error
+
+
+async def test_stream_events_invalid_json_frame_raises_typed() -> None:
+    transport = StubTransport(
+        StubStreamResponse(200, [b"event: nestquest_quest_completed\n", b"data: {nope\n\n"])
+    )
+    client = make_client(transport)
+
+    with pytest.raises(NestQuestApiError) as excinfo:
+        async for _ in client.stream_events():
+            pass
+
+    assert excinfo.value.status == 200
+    assert not excinfo.value.is_transport_error
+    assert isinstance(excinfo.value.__cause__, ValueError)
+
+
+async def test_stream_events_disables_the_session_total_timeout() -> None:
+    """The stream request overrides the session's default total timeout
+    (HA's shared session: 300 s, which would cut a healthy stream) with
+    ``total=None`` while keeping a finite connect timeout; the plain
+    request calls pass no per-request timeout."""
+    transport = StubTransport(
+        StubStreamResponse(200, []), StubResponse(200, json.dumps(SNAPSHOT_PAYLOAD))
+    )
+    client = make_client(transport, timeout_seconds=7.0)
+
+    frames = [frame async for frame in client.stream_events()]
+    await client.get_snapshot()
+
+    assert frames == []
+    stream_timeout = transport.calls[0]["timeout"]
+    assert isinstance(stream_timeout, FakeClientTimeout)
+    assert stream_timeout.total is None
+    assert stream_timeout.sock_connect == 7.0
+    assert transport.calls[1]["timeout"] is None

tests/test_blueprint_unifi_access.py

@@ -0,0 +1,123 @@
+"""Behavior and wiring tests for the UniFi quest-access blueprint."""
+
+from __future__ import annotations
+
+from datetime import datetime
+
+import pytest
+
+from tests.blueprint_helpers import BlueprintInput, blueprint, render
+
+
+def _blueprint() -> dict:
+    return blueprint("unifi_quest_access")
+
+
+def test_inputs_and_reconciliation_triggers() -> None:
+    bp = _blueprint()
+    inputs = bp["blueprint"]["input"]
+    assert set(inputs) == {
+        "remaining_sensor",
+        "present_sensor",
+        "client_switches",
+        "weekday_cutoff",
+        "weekend_cutoff",
+    }
+    assert inputs["weekday_cutoff"]["default"] == "18:25:00"
+    assert inputs["weekend_cutoff"]["default"] == "14:00:00"
+    assert inputs["remaining_sensor"]["selector"]["entity"]["filter"] == [
+        {"integration": "nestquest", "domain": "sensor"}
+    ]
+    assert inputs["present_sensor"]["selector"]["entity"]["filter"] == [
+        {"integration": "nestquest", "domain": "binary_sensor"}
+    ]
+    assert inputs["client_switches"]["selector"]["entity"] == {
+        "multiple": True,
+        "filter": [{"integration": "unifi", "domain": "switch"}],
+    }
+    assert bp["variables"]["remaining_sensor"] == BlueprintInput(
+        "remaining_sensor"
+    )
+    assert bp["variables"]["present_sensor"] == BlueprintInput(
+        "present_sensor"
+    )
+    assert bp["variables"]["client_switches"] == BlueprintInput(
+        "client_switches"
+    )
+    assert bp["mode"] == "restart"
+
+    triggers = bp["triggers"]
+    assert {trigger["trigger"] for trigger in triggers} == {
+        "state",
+        "time",
+        "homeassistant",
+        "time_pattern",
+    }
+    assert {trigger["at"] for trigger in triggers if trigger["trigger"] == "time"} == {
+        BlueprintInput("weekday_cutoff"),
+        BlueprintInput("weekend_cutoff"),
+        "00:00:00",
+    }
+    assert any(
+        trigger.get("entity_id") == BlueprintInput("remaining_sensor")
+        for trigger in triggers
+    )
+    assert any(
+        trigger.get("entity_id") == BlueprintInput("present_sensor")
+        for trigger in triggers
+    )
+    assert any(
+        trigger.get("event") == "start" for trigger in triggers
+    )
+    assert any(
+        trigger.get("minutes") == "/5" for trigger in triggers
+    )
+
+
+@pytest.mark.parametrize(
+    ("when", "remaining", "presence", "should_block"),
+    [
+        (datetime(2026, 10, 19, 18, 24), "2", "on", False),  # Monday, pre-cutoff
+        (datetime(2026, 10, 19, 18, 25), "2", "on", True),
+        (datetime(2026, 10, 19, 19, 0), "0", "on", False),
+        (datetime(2026, 10, 19, 19, 0), "unknown", "on", True),
+        (datetime(2026, 10, 19, 19, 0), "2", "off", False),  # On travels
+        (datetime(2026, 10, 19, 19, 0), "2", "unavailable", False),
+        (datetime(2026, 10, 17, 13, 59), "1", "on", False),  # Saturday
+        (datetime(2026, 10, 17, 14, 0), "1", "on", True),
+        (datetime(2026, 10, 18, 14, 0), "0", "on", False),  # Sunday
+        (datetime(2026, 10, 20, 0, 0), "1", "on", False),  # no carry-over
+    ],
+)
+def test_access_decision(
+    when: datetime, remaining: str, presence: str, should_block: bool
+) -> None:
+    decision = _blueprint()["actions"][0]["variables"]["should_block"]
+    actual = render(
+        decision,
+        now=lambda: when,
+        states=lambda entity_id: remaining,
+        is_state=lambda entity_id, state: presence == state,
+        remaining_sensor="sensor.selected_child",
+        present_sensor="binary_sensor.selected_child_present_today",
+        weekday_cutoff="18:25:00",
+        weekend_cutoff="14:00:00",
+    ).strip()
+    assert actual == str(should_block)
+
+
+def test_only_out_of_sync_clients_receive_commands() -> None:
+    bp = _blueprint()
+    loop = bp["actions"][1]["repeat"]
+    assert loop["for_each"] == "{{ client_switches }}"
+    choices = loop["sequence"][0]["choose"]
+    assert len(choices) == 2
+    block, allow = choices
+    assert "is_state(repeat.item, 'on')" in block["conditions"][0]["value_template"]
+    assert block["sequence"][0]["action"] == "switch.turn_off"
+    assert "is_state(repeat.item, 'off')" in allow["conditions"][0]["value_template"]
+    assert allow["sequence"][0]["action"] == "switch.turn_on"
+    assert all(
+        choice["sequence"][0]["target"]["entity_id"] == "{{ repeat.item }}"
+        for choice in choices
+    )

tests/test_brand_icons.py

@@ -0,0 +1,55 @@
+"""The integration's local brand images (Home Assistant 2026.3+).
+
+``custom_components/nestquest/brand/`` ships through HACS with the
+integration, and Home Assistant serves those images ahead of the brands CDN.
+They are generated offline from ``design/logos/NestQuest-NoBG.png`` by
+``design/logos/generate-brand-icons.mjs``; these checks fail if the directory
+goes missing, changes shape, or drifts from a fresh generation.
+"""
+from __future__ import annotations
+
+import shutil
+import struct
+import subprocess
+from pathlib import Path
+
+import pytest
+
+REPO_ROOT = Path(__file__).parent.parent
+BRAND_DIR = REPO_ROOT / "custom_components" / "nestquest" / "brand"
+GENERATOR = REPO_ROOT / "design" / "logos" / "generate-brand-icons.mjs"
+EXPECTED = {
+    "icon.png": 256,
+    "icon@2x.png": 512,
+    "logo.png": 256,
+    "logo@2x.png": 512,
+}
+PNG_SIGNATURE = b"\x89PNG\r\n\x1a\n"
+
+
+def test_brand_dir_holds_exactly_the_four_images() -> None:
+    assert sorted(p.name for p in BRAND_DIR.iterdir()) == sorted(EXPECTED)
+
+
+@pytest.mark.parametrize(("name", "size"), sorted(EXPECTED.items()))
+def test_brand_image_is_square_rgba_png(name: str, size: int) -> None:
+    data = (BRAND_DIR / name).read_bytes()
+    assert data[:8] == PNG_SIGNATURE
+    assert data[12:16] == b"IHDR"
+    width, height, depth, colour = struct.unpack(">IIBB", data[16:26])
+    assert (width, height) == (size, size)
+    assert (depth, colour) == (8, 6)  # 8-bit RGBA keeps the transparency
+
+
+def test_generator_reproduces_the_committed_images() -> None:
+    node = shutil.which("node")
+    if node is None:
+        pytest.skip("needs node")
+    result = subprocess.run(
+        [node, str(GENERATOR), "--check"],
+        cwd=REPO_ROOT,
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    assert result.returncode == 0, result.stderr

tests/test_completion.py

@@ -834,7 +834,7 @@ def test_complete_instance_no_due_time_after_due_date_is_late(
 
 
 def test_complete_instance_ha_local_wall_clock_not_utc(tmp_path) -> None:
-    """HA-local 11:00 with due_time 12:00 is on time even when UTC is 19:00.
+    """Household-local 11:00, due 12:00, is on time even when UTC is 19:00.
 
     The helper's zone is UTC-8, so 11:00 local is 19:00 UTC.  Converting
     to UTC before comparing would mark this late.

tests/test_core_snapshot.py

@@ -136,7 +136,7 @@ async def test_build_snapshot_explicit_values(hass, make_entry, tmp_path) -> Non
 
     # Single clock read for the seed/snapshot anchor (no midnight skew);
     # the coordinator no longer owns a clock read (the API serves the
-    # snapshot), so the test resolves the HA-local zone directly.
+    # snapshot), so the test resolves its own local zone directly.
     time_zone = ZoneInfo(hass.config.time_zone)
     today = datetime.datetime.now(time_zone).date()
     # Pin the build instant at 12:00 local: past Ada's 10:00 due time

tests/test_icon_registry.py

@@ -63,6 +63,75 @@ def test_artefacts_carry_exactly_the_curated_names_and_labels() -> None:
     assert 15 <= len(curated["fa"]) <= 25
 
 
+def test_artefacts_carry_the_full_font_awesome_free_solid_set() -> None:
+    text = ARTEFACTS[0].read_text(encoding="utf-8")
+    solid = _generated_set(text, "FA_SOLID_ICONS")
+    names = [entry["name"] for entry in solid]
+    assert names == sorted(names)
+    assert len(set(names)) == len(names)
+    # The complete Free Solid set, not a curated pick (7.x ships ~1,400).
+    assert len(solid) >= 1400
+    for entry in solid:
+        assert set(entry) == {"kind", "key", "name", "label", "viewBox", "paths"}
+        assert entry["kind"] == "fa"
+        assert entry["key"] == f"fa:{entry['name']}"
+        assert entry["label"] == " ".join(
+            part[0].upper() + part[1:] for part in entry["name"].split("-")
+        )
+        assert re.fullmatch(r"0 0 \d+ \d+", entry["viewBox"])
+        assert entry["paths"] and all(entry["paths"])
+    # A well-known glyph, a barely-known one, and every curated quick-pick.
+    assert {"rocket", "mug-hot", "person-dress-burst"} <= set(names)
+    assert {e["name"] for e in _curated()["fa"]} <= set(names)
+    assert "rocket-ship-9000" not in names
+
+
+def test_resolve_icon_resolves_any_free_solid_name() -> None:
+    node = shutil.which("node")
+    if node is None:
+        pytest.skip("needs node")
+    script = (
+        "const m = await import(process.argv[1]);"
+        "const out = {};"
+        "for (const v of JSON.parse(process.argv[2])) {"
+        " const r = m.resolveIcon(v); out[v] = [r.kind, r.label ?? null]; }"
+        "console.log(JSON.stringify(out));"
+    )
+    values = [
+        "fa:rocket",
+        "fa:mug-hot",
+        "fa:person-dress-burst",
+        "fa:paw",
+        "fa:rocket-ship-9000",
+        "fa:Rocket",
+        "fa:",
+        "lucide:dog",
+        "dog",
+        "lucide:rocket",
+    ]
+    result = subprocess.run(
+        [node, "--input-type=module", "-e", script,
+         ARTEFACTS[0].as_uri(), json.dumps(values)],
+        cwd=REPO_ROOT,
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    if result.returncode != 0 and "Unknown file extension" in result.stderr:
+        pytest.skip("node cannot strip TypeScript types (needs Node 22.18+)")
+    assert result.returncode == 0, result.stderr
+    resolved = json.loads(result.stdout)
+    assert resolved["fa:rocket"] == ["fa", "Rocket"]
+    assert resolved["fa:mug-hot"] == ["fa", "Mug Hot"]
+    assert resolved["fa:person-dress-burst"] == ["fa", "Person Dress Burst"]
+    # Curated entries keep their quick-pick label.
+    assert resolved["fa:paw"] == ["fa", "Pets"]
+    assert resolved["lucide:dog"][0] == "lucide"
+    assert resolved["dog"][0] == "lucide"
+    for unknown in ("fa:rocket-ship-9000", "fa:Rocket", "fa:", "lucide:rocket"):
+        assert resolved[unknown] == ["fallback", None], unknown
+
+
 def test_registry_has_no_remote_url_cdn_or_lucide_runtime() -> None:
     for path in (SOURCE, GENERATOR, *ARTEFACTS):
         text = path.read_text(encoding="utf-8")

tests/test_materialize.py

@@ -940,14 +940,15 @@ def test_materialize_rejects_malformed_or_inverted_bounds(tmp_path) -> None:
 
 
 def test_materialize_accepts_ha_local_today_behind_host(tmp_path) -> None:
-    """The clamp and no-past guard compare against a caller-supplied HA-local today.
+    """The clamp and no-past guard compare against a caller-supplied today.
 
     A household time zone behind the host clock around midnight resolves a
-    HA-local "today" one calendar day earlier than the host's
+    household-local "today" one calendar day earlier than the host's
     ``date.today()``.  The walk clamps its start to that anchor: without
-    a pinned HA-local date the effective start is the host's today (one
+    a pinned household-local date the effective start is the host's
-    day after ha_today), so the now-past day is skipped rather than
+    today (one day after ha_today), so the now-past day is skipped
-    rejected, and only the host-today-onward days materialize.
+    rather than rejected, and only the host-today-onward days
+    materialize.
     """
     async def _body(database):
         children = ChildrenDao(database)
@@ -963,9 +964,9 @@ def test_materialize_accepts_ha_local_today_behind_host(tmp_path) -> None:
             ["morning"],
         )
 
-        # Without a pinned HA-local today, the walk clamps its start to the
+        # Without a pinned household-local today, the walk clamps its start
-        # host's today (one day after ha_today); the past day is dropped and
+        # to the host's today (one day after ha_today); the past day is
-        # the 14 host-today-onward days materialize.
+        # dropped and the 14 host-today-onward days materialize.
         without_pin = await materialize(database, start_iso, end_iso)
         assert without_pin == 14
 

tests/test_panel_cards.py

@@ -1431,6 +1431,26 @@ def test_open_quest_tile_falls_back_to_the_star() -> None:
         assert tile["icon"] is None
 
 
+def test_open_quest_tile_renders_any_free_solid_icon() -> None:
+    """A Font Awesome Free Solid name outside the curated quick-pick list
+    still renders its glyph from the shipped bundle; an unknown ``fa:`` name
+    keeps the star."""
+    tiles = _quest_log_tiles(
+        [
+            _quest_row(1, "fa:rocket"),
+            _quest_row(2, "fa:mug-hot"),
+            _quest_row(3, "fa:definitely-not-an-icon"),
+        ]
+    )
+    for instance_id, key in ((1, "fa:rocket"), (2, "fa:mug-hot")):
+        assert tiles[instance_id]["icon"] == key
+        assert tiles[instance_id]["fill"] == "currentColor"
+        assert tiles[instance_id]["paths"] > 0
+        assert not tiles[instance_id]["star"]
+    assert tiles[3]["star"]
+    assert tiles[3]["icon"] is None
+
+
 def test_sealed_quest_tile_keeps_the_star() -> None:
     """A sealed card keeps its star tile (and its wax seal) whatever the
     definition's icon; only the open card shows the quest's icon."""

tests/test_sse_subscription.py

@@ -44,6 +44,10 @@ from custom_components.nestquest.api_client import (
 )
 from custom_components.nestquest.sse import NestQuestEventStream
 
+# ``stream_events`` imports aiohttp lazily; the harness has none, so
+# every test here runs with the stand-in module installed.
+pytestmark = pytest.mark.usefixtures("fake_aiohttp")
+
 BASE_URL = "http://api.test:8000"
 TOKEN = "test-panel-token"
 
@@ -165,19 +169,29 @@ MINIMAL_SNAPSHOT = {
 
 
 class _StreamingResponse:
-    """A fake aiohttp streaming response: ``status`` + chunk iteration.
+    """A fake aiohttp streaming response: ``status`` + ``.content``.
 
-    ``chunks`` are the body pieces the stream yields in order; a chunk
+    Like aiohttp's ``ClientResponse`` (and HA's ``HassClientResponse``)
-    may be an exception, raised when the iteration reaches it (a
+    the response itself is NOT async-iterable; the body is iterated
-    mid-stream transport drop).  ``hold_open`` keeps the stream open
+    through ``.content``.  ``chunks`` are the body pieces the stream
-    forever after the chunks run out, for cancellation tests.
+    yields in order; a chunk may be an exception, raised when the
+    iteration reaches it (a mid-stream transport drop).  ``hold_open``
+    keeps the stream open forever after the chunks run out, for
+    cancellation tests.
     """
 
     def __init__(self, status: int, chunks, *, hold_open: bool = False) -> None:
         self.status = status
+        self.content = _StreamingContent(chunks, hold_open)
+        self.closed = False
+
+
+class _StreamingContent:
+    """The fake response body: an async-iterable chunk stream."""
+
+    def __init__(self, chunks, hold_open: bool) -> None:
         self._chunks = list(chunks)
         self._hold_open = hold_open
-        self.closed = False
 
     def __aiter__(self):
         return self._iterate()

tools/icons/generate.mjs

@@ -2,9 +2,10 @@
  * Offline generator for the shared quest-icon registry.
  *
  * Reads the curated names + labels in `curated-icons.json` (the one source of
- * truth), pulls each glyph's SVG path data from locally installed packages in
+ * truth for the quick-pick lists), pulls each glyph's SVG path data from
- * `admin/node_modules` (lucide-react and @fortawesome/free-solid-svg-icons —
+ * locally installed packages in `admin/node_modules` (lucide-react and
- * no network), and writes the same TypeScript module into both bundles:
+ * @fortawesome/free-solid-svg-icons — no network), and writes the same
+ * TypeScript module into both bundles:
  *
  *   admin/src/icons/registry.generated.ts
  *   frontend/src/icons/registry.generated.ts
@@ -14,6 +15,16 @@
  *
  * Lucide circles, rects and lines are converted to path `d` strings so every
  * glyph is plain `{ viewBox, paths }` data any renderer can draw.
+ *
+ * Besides the curated sets (the Lucide set and the Font Awesome quick picks),
+ * the module embeds the complete Font Awesome Free Solid set (`FA_SOLID_ICONS`),
+ * which is what `fa:<name>` resolves against. Its source is the installed
+ * @fortawesome/free-solid-svg-icons package itself: every exported icon
+ * definition, de-duplicated by canonical `iconName` (the package also exports
+ * each legacy alias, e.g. faHome for `house`, as the same definition). The
+ * package carries no human labels, so each label is the kebab name in Title
+ * Case (`spray-can-sparkles` → "Spray Can Sparkles"). Embedding the full set
+ * makes both bundles heavier: the panel bundle is about 1 MB raw / 276 kB gzip.
  */
 import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
 import { createRequire } from "node:module";
@@ -89,6 +100,37 @@ function faExportName(name) {
   return "fa" + name.split("-").map((part) => part[0].toUpperCase() + part.slice(1)).join("");
 }
 
+function faGlyph(definition, label) {
+  const { iconName: name } = definition;
+  const [width, height, , , pathData] = definition.icon;
+  const paths = Array.isArray(pathData) ? pathData.filter(Boolean) : [pathData];
+  return { kind: "fa", key: `fa:${name}`, name, label, viewBox: `0 0 ${width} ${height}`, paths };
+}
+
+function titleCase(name) {
+  return name.split("-").map((part) => part[0].toUpperCase() + part.slice(1)).join(" ");
+}
+
+/** Every Free Solid glyph, one per canonical name, sorted by name. */
+function allSolidGlyphs(faPackage) {
+  const byName = new Map();
+  for (const definition of Object.values(faPackage)) {
+    if (!definition || typeof definition !== "object" || !Array.isArray(definition.icon)) continue;
+    if (definition.prefix !== "fas") throw new Error(`fa ${definition.iconName}: unexpected prefix ${definition.prefix}`);
+    const name = definition.iconName;
+    if (!/^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/.test(name)) throw new Error(`fa ${name}: not a kebab name`);
+    const seen = byName.get(name);
+    if (seen && JSON.stringify(seen.icon) !== JSON.stringify(definition.icon)) {
+      throw new Error(`fa ${name}: two exports disagree on the glyph`);
+    }
+    byName.set(name, definition);
+  }
+  if (byName.size === 0) throw new Error("fa: no icons found in @fortawesome/free-solid-svg-icons");
+  return [...byName.keys()]
+    .sort((a, b) => (a < b ? -1 : a > b ? 1 : 0))
+    .map((name) => faGlyph(byName.get(name), titleCase(name)));
+}
+
 function checkCurated(list, namespace) {
   const seen = new Set();
   for (const { name, label } of list) {
@@ -116,11 +158,9 @@ async function buildEntries() {
   for (const { name, label } of curated.fa) {
     const definition = faPackage[faExportName(name)];
     if (!definition || definition.iconName !== name) throw new Error(`fa ${name}: not in @fortawesome/free-solid-svg-icons`);
-    const [width, height, , , pathData] = definition.icon;
+    fa.push(faGlyph(definition, label));
-    const paths = Array.isArray(pathData) ? pathData.filter(Boolean) : [pathData];
-    fa.push({ kind: "fa", key: `fa:${name}`, name, label, viewBox: `0 0 ${width} ${height}`, paths });
   }
-  return { lucide, fa };
+  return { lucide, fa, faSolid: allSolidGlyphs(faPackage) };
 }
 
 const RESOLVER = `
@@ -130,7 +170,10 @@ export const FALLBACK_ICON: FallbackIcon = { kind: "fallback", key: null };
 export const EMOJI_MAX_CODE_POINTS = 8;
 
 const LUCIDE_BY_NAME: ReadonlyMap<string, GlyphIcon> = new Map(LUCIDE_ICONS.map((icon) => [icon.name, icon]));
-const FA_BY_NAME: ReadonlyMap<string, GlyphIcon> = new Map(FA_ICONS.map((icon) => [icon.name, icon]));
+/** The full Free Solid set, with each curated entry (and its quick-pick label) taking precedence. */
+const FA_BY_NAME: ReadonlyMap<string, GlyphIcon> = new Map(
+  [...FA_SOLID_ICONS, ...FA_ICONS].map((icon) => [icon.name, icon]),
+);
 
 function isEmojiPayload(text: string): boolean {
   const codePoints = [...text];
@@ -142,7 +185,8 @@ function isEmojiPayload(text: string): boolean {
  * The renderable icon for a stored definition \`icon\` value.
  *
  * \`lucide:<name>\` and a legacy bare \`<name>\` resolve against the curated
- * Lucide set, \`fa:<name>\` against the curated Font Awesome set, and
+ * Lucide set, \`fa:<name>\` against the full Font Awesome Free Solid set
+ * (curated entries keep their quick-pick labels), and
  * \`emoji:<grapheme>\` to its text. Like the backend's
  * normalize_icon_for_read, nothing here throws: null, empty, an unknown
  * namespace or name, or a malformed emoji all resolve to FALLBACK_ICON.
@@ -162,7 +206,7 @@ export function resolveIcon(value: string | null | undefined): ResolvedIcon {
 
 /** The generated module's full text (identical for both bundles). */
 export async function renderRegistry() {
-  const { lucide, fa } = await buildEntries();
+  const { lucide, fa, faSolid } = await buildEntries();
   const source = relative(REPO_ROOT, SOURCE_PATH);
   return `// GENERATED by tools/icons/generate.mjs from ${source} — do not edit.
 // Regenerate with \`node tools/icons/generate.mjs\` (the drift tests fail if this
@@ -202,7 +246,13 @@ export type ResolvedIcon = GlyphIcon | EmojiIcon | FallbackIcon;
 
 export const LUCIDE_ICONS: readonly GlyphIcon[] = ${JSON.stringify(lucide, null, 2)};
 
+/** The curated Font Awesome quick-pick set. */
 export const FA_ICONS: readonly GlyphIcon[] = ${JSON.stringify(fa, null, 2)};
+
+/** Every Font Awesome Free Solid glyph (${faSolid.length}), sorted by name; one entry per line. */
+export const FA_SOLID_ICONS: readonly GlyphIcon[] = [
+${faSolid.map((icon) => JSON.stringify(icon)).join(",\n")}
+];
 ${RESOLVER}`;
 }
 

uv.lock

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