From 0e726ac64f4aa9fb8e8499d9c158bf67b42aecb5 Mon Sep 17 00:00:00 2001
From: dev_agent <dev_agent@cubecraftlabs.com>
Date: Wed, 30 Sep 2026 10:02:05 -0400
Subject: [PATCH] Manual timezone is the single source of local-time truth
 (task 7e173881) (#285)

Co-authored-by: dev_agent <dev_agent@cubecraftlabs.com>
Co-committed-by: dev_agent <dev_agent@cubecraftlabs.com>
---
 admin/src/App.test.tsx                        |  57 +-
 admin/src/App.tsx                             |  22 +-
 admin/src/api/settings.ts                     |   7 +-
 admin/src/definitions/DefinitionsTab.test.tsx |  57 +-
 admin/src/definitions/DefinitionsTab.tsx      |  42 +-
 admin/src/history/HistoryTab.test.tsx         | 115 ++++
 admin/src/history/HistoryTab.tsx              |  18 +-
 admin/src/history/format.ts                   |  45 +-
 admin/src/schedule/OverrideEditor.test.tsx    |   4 +
 admin/src/schedule/ScheduleTab.test.tsx       |  55 +-
 admin/src/schedule/ScheduleTab.tsx            |   9 +-
 admin/src/schedule/cycle.ts                   |   7 -
 admin/src/settings/SettingsScreen.test.tsx    |  54 +-
 admin/src/settings/SettingsScreen.tsx         |  10 +-
 admin/src/time/AppTimezone.tsx                |  93 ++++
 admin/src/time/zone.test.ts                   |  60 +++
 admin/src/time/zone.ts                        |  81 +++
 admin/src/today/TodayTab.test.tsx             |  60 +++
 admin/src/today/TodayTab.tsx                  |   4 +-
 admin/src/today/format.ts                     |  14 +-
 api/host_zone.py                              |  62 +++
 api/routes_admin.py                           |  40 +-
 api/routes_panel.py                           |  15 +-
 api/scheduler.py                              |   3 +-
 custom_components/nestquest/coordinator.py    |   4 +
 custom_components/nestquest/core/snapshot.py  |   6 +
 custom_components/nestquest/sensor.py         |   4 +
 .../nestquest/www/nestquest-cards.js          | 496 +++++++++---------
 frontend/src/cards/party-board.ts             |  12 +-
 frontend/src/cards/quest-log.ts               |  42 +-
 frontend/tests/render-party-board.mjs         |  25 +-
 tests/conftest.py                             |   1 +
 tests/test_api_admin_settings.py              |  36 +-
 tests/test_api_admin_snapshot.py              |  11 +-
 tests/test_api_host_zone.py                   |  71 +++
 tests/test_api_household_clock.py             | 143 ++++-
 tests/test_binary_sensors.py                  |   1 +
 tests/test_complete_quest_proxy.py            |   1 +
 tests/test_coordinator.py                     |  32 +-
 tests/test_core_snapshot.py                   |   1 +
 tests/test_entity_lifecycle.py                |   1 +
 tests/test_entity_matrix.py                   |   1 +
 tests/test_events.py                          |   1 +
 tests/test_panel_cards.py                     | 138 +++--
 tests/test_sensors.py                         |  17 +
 tests/test_sse_subscription.py                |   7 +-
 46 files changed, 1556 insertions(+), 429 deletions(-)
 create mode 100644 admin/src/time/AppTimezone.tsx
 create mode 100644 admin/src/time/zone.test.ts
 create mode 100644 admin/src/time/zone.ts
 create mode 100644 api/host_zone.py
 create mode 100644 tests/test_api_host_zone.py

diff --git a/admin/src/App.test.tsx b/admin/src/App.test.tsx
index 7a38e6a..942a2fb 100644
--- a/admin/src/App.test.tsx
+++ b/admin/src/App.test.tsx
@@ -2,10 +2,29 @@ import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { cleanup, fireEvent, render, screen } from "@testing-library/react";
 import App from "./App";
 
+function jsonResponse(body: unknown, status = 200): Response {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { "Content-Type": "application/json" },
+  });
+}
+
+let settingsResponse: () => Promise<Response>;
+
 describe("NestQuest Admin shell", () => {
   beforeEach(() => {
-    // The Today tab fetches the admin snapshot; keep the shell tests offline.
-    vi.stubGlobal("fetch", vi.fn(() => new Promise<Response>(() => {})));
+    settingsResponse = () =>
+      Promise.resolve(jsonResponse({ timezone: "", effective_timezone: "Europe/London" }));
+    // The shell loads the stored application timezone; every tab's own
+    // requests stay pending so the shell tests remain offline.
+    vi.stubGlobal(
+      "fetch",
+      vi.fn((url: string) =>
+        String(url).endsWith("/api/v1/admin/settings")
+          ? settingsResponse()
+          : new Promise<Response>(() => {}),
+      ),
+    );
   });
 
   afterEach(() => {
@@ -22,10 +41,10 @@ describe("NestQuest Admin shell", () => {
     }
   });
 
-  it("starts on the Today screen and switches on tab click", () => {
+  it("starts on the Today screen and switches on tab click", async () => {
     render(<App />);
 
-    expect(screen.getByRole("heading", { name: "Today" })).toBeTruthy();
+    expect(await screen.findByRole("heading", { name: "Today" })).toBeTruthy();
 
     fireEvent.click(screen.getByRole("tab", { name: "History" }));
 
@@ -36,12 +55,36 @@ describe("NestQuest Admin shell", () => {
     );
   });
 
-  it("the Tasks tab renders the definitions screen", () => {
+  it("the Tasks tab renders the definitions screen", async () => {
     render(<App />);
 
     fireEvent.click(screen.getByRole("tab", { name: "Tasks" }));
 
-    expect(screen.getByRole("heading", { name: "Tasks" })).toBeTruthy();
+    expect(await screen.findByRole("heading", { name: "Tasks" })).toBeTruthy();
     expect(screen.getByRole("tabpanel").textContent).not.toContain("placeholder");
   });
-});
\ No newline at end of file
+
+  it("renders no screen until the stored application timezone is known", async () => {
+    settingsResponse = () => new Promise<Response>(() => {});
+    render(<App />);
+
+    expect(screen.getByTestId("timezone-loading")).toBeTruthy();
+    expect(screen.queryByRole("heading", { name: "Today" })).toBeNull();
+  });
+
+  it("a failed timezone load says so and retries", async () => {
+    settingsResponse = () => Promise.resolve(jsonResponse({ detail: "boom" }, 500));
+    render(<App />);
+
+    await screen.findByTestId("timezone-error");
+    expect(screen.queryByRole("heading", { name: "Today" })).toBeNull();
+
+    settingsResponse = () =>
+      Promise.resolve(
+        jsonResponse({ timezone: "Pacific/Auckland", effective_timezone: "Pacific/Auckland" }),
+      );
+    fireEvent.click(screen.getByRole("button", { name: "Try again" }));
+
+    expect(await screen.findByRole("heading", { name: "Today" })).toBeTruthy();
+  });
+});
diff --git a/admin/src/App.tsx b/admin/src/App.tsx
index 5f44fad..31ab78a 100644
--- a/admin/src/App.tsx
+++ b/admin/src/App.tsx
@@ -4,6 +4,7 @@ import { TransitionsProvider } from "./api/useTransitions";
 import DefinitionsTab from "./definitions/DefinitionsTab";
 import HistoryTab from "./history/HistoryTab";
 import ScheduleTab from "./schedule/ScheduleTab";
+import { AppTimezoneProvider } from "./time/AppTimezone";
 import TodayTab from "./today/TodayTab";
 
 const TABS = [
@@ -32,15 +33,18 @@ export default function App() {
           role="tabpanel"
           aria-labelledby={`tab-${active}`}
         >
-          {active === "today" ? (
-            <TodayTab />
-          ) : active === "tasks" ? (
-            <DefinitionsTab />
-          ) : active === "schedule" ? (
-            <ScheduleTab />
-          ) : (
-            <HistoryTab />
-          )}
+          {/* Every screen's local time is the stored application timezone. */}
+          <AppTimezoneProvider>
+            {active === "today" ? (
+              <TodayTab />
+            ) : active === "tasks" ? (
+              <DefinitionsTab />
+            ) : active === "schedule" ? (
+              <ScheduleTab />
+            ) : (
+              <HistoryTab />
+            )}
+          </AppTimezoneProvider>
         </main>
         <nav className="admin-tabbar" aria-label="Admin sections">
           {TABS.map((tab) => (
diff --git a/admin/src/api/settings.ts b/admin/src/api/settings.ts
index b72d035..09ef4a1 100644
--- a/admin/src/api/settings.ts
+++ b/admin/src/api/settings.ts
@@ -19,10 +19,15 @@ export interface HouseholdSettings {
   celebration_enabled: boolean;
   /** IANA zone name (e.g. "America/New_York"); "" means the API host's local time. */
   timezone: string;
+  /**
+   * Read-only: the zone the API reads its clock in — `timezone`, or the API
+   * host's own zone when that is "" ("" only when the host's zone has no name).
+   */
+  effective_timezone: string;
 }
 
 /** Only the supplied fields are updated; the API answers with all of them. */
-export type SettingsChanges = Partial<HouseholdSettings>;
+export type SettingsChanges = Partial<Omit<HouseholdSettings, "effective_timezone">>;
 
 export const SETTINGS_PATH = "/api/v1/admin/settings";
 
diff --git a/admin/src/definitions/DefinitionsTab.test.tsx b/admin/src/definitions/DefinitionsTab.test.tsx
index 3a24638..72e4023 100644
--- a/admin/src/definitions/DefinitionsTab.test.tsx
+++ b/admin/src/definitions/DefinitionsTab.test.tsx
@@ -1,4 +1,4 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
 import { act, cleanup, fireEvent, render, screen, waitFor, within } from "@testing-library/react";
 import DefinitionsTab from "./DefinitionsTab";
 import {
@@ -12,6 +12,7 @@ import {
 } from "./definitionIcons";
 import type { AdminChild, DefinitionRule, QuestDefinition } from "../api/definitions";
 import { storeTokens } from "../auth/oidc";
+import { AppTimezoneProvider } from "../time/AppTimezone";
 
 function child(id: number, name: string, overrides: Partial<AdminChild> = {}): AdminChild {
   return {
@@ -1723,3 +1724,57 @@ describe("DefinitionsTab start date", () => {
     expect(within(s).getByText("Pick a start date.")).toBeTruthy();
   });
 });
+
+describe("DefinitionsTab start date in the stored application timezone", () => {
+  async function newSheetStartDate(
+    timezone: string,
+    effective_timezone = timezone,
+  ): Promise<string> {
+    api = fakeApi([BRUSH]);
+    vi.stubGlobal(
+      "fetch",
+      vi.fn((input: RequestInfo | URL, init?: RequestInit) =>
+        String(input).endsWith("/api/v1/admin/settings")
+          ? Promise.resolve(jsonResponse({ timezone, effective_timezone }))
+          : api.fetchMock(input, init),
+      ),
+    );
+    render(
+      <AppTimezoneProvider>
+        <DefinitionsTab />
+      </AppTimezoneProvider>,
+    );
+    await screen.findByText("Brush teeth");
+    fireEvent.click(screen.getByRole("button", { name: "New" }));
+    return startDateInput(sheet()).value;
+  }
+
+  beforeAll(() => {
+    vi.stubEnv("TZ", "UTC");
+  });
+
+  afterAll(() => {
+    vi.unstubAllEnvs();
+  });
+
+  beforeEach(() => {
+    sessionStorage.clear();
+    storeTokens({ access_token: "at-123", expires_in: 600 });
+    // Wed 23 Sep 13:00 UTC is already Thu 24 Sep 01:00 in Auckland.
+    vi.useFakeTimers({ toFake: ["Date"], now: new Date("2026-09-23T13:00:00Z") });
+  });
+
+  afterEach(() => {
+    cleanup();
+    vi.unstubAllGlobals();
+    vi.useRealTimers();
+  });
+
+  it("a new task defaults to today in the stored zone", async () => {
+    expect(await newSheetStartDate("Pacific/Auckland")).toBe("2026-09-24");
+  });
+
+  it("an empty stored zone defaults to today in the API host's published zone", async () => {
+    expect(await newSheetStartDate("", "Pacific/Auckland")).toBe("2026-09-24");
+  });
+});
diff --git a/admin/src/definitions/DefinitionsTab.tsx b/admin/src/definitions/DefinitionsTab.tsx
index a3ff02a..bea4353 100644
--- a/admin/src/definitions/DefinitionsTab.tsx
+++ b/admin/src/definitions/DefinitionsTab.tsx
@@ -57,6 +57,9 @@ import {
   normalizeDefinitionIconName,
 } from "./definitionIcons";
 import { GlyphSvg } from "../icons/GlyphSvg";
+import { weekdayOf } from "../schedule/cycle";
+import { useAppTimezone } from "../time/AppTimezone";
+import { todayIn } from "../time/zone";
 import "./DefinitionsTab.css";
 
 /** ADMIN-SPEC §1: every scroll column ends with 92px so content clears the tab bar. */
@@ -121,20 +124,13 @@ type LoadState =
 /** `null` = closed, `"new"` = creating, a definition = editing it. */
 type SheetTarget = null | "new" | QuestDefinition;
 
-function pad2(n: number): string {
-  return String(n).padStart(2, "0");
-}
-
-function localIsoDate(date: Date): string {
-  return `${date.getFullYear()}-${pad2(date.getMonth() + 1)}-${pad2(date.getDate())}`;
-}
-
 function emptyDueTimes(): Record<WindowName, string> {
   return { morning: "", afternoon: "", evening: "" };
 }
 
-function newDraft(activeChildren: AdminChild[]): Draft {
-  const today = new Date();
+/** Draft defaults take `today` ("YYYY-MM-DD") in the application timezone. */
+function newDraft(activeChildren: AdminChild[], today: string): Draft {
+  const [, month, day] = today.split("-").map(Number);
   return {
     title: "",
     icon: null,
@@ -142,22 +138,22 @@ function newDraft(activeChildren: AdminChild[]): Draft {
     assigneeIds: activeChildren.length === 1 ? [activeChildren[0].id] : [],
     repeats: "daily",
     interval: "1",
-    weekdays: [(today.getDay() + 6) % 7],
-    dayOfMonth: String(today.getDate()),
-    month: String(today.getMonth() + 1),
+    weekdays: [weekdayOf(today)],
+    dayOfMonth: String(day),
+    month: String(month),
     monthlyWeekday: null,
     windows: [],
     dueTimes: emptyDueTimes(),
     // Mirrors the API's create default: no instance on an away day.
     skipOnAway: true,
-    startDate: localIsoDate(today),
+    startDate: today,
     endDate: null,
   };
 }
 
-function draftFrom(definition: QuestDefinition, activeChildren: AdminChild[]): Draft {
+function draftFrom(definition: QuestDefinition, activeChildren: AdminChild[], today: string): Draft {
   const { rule } = definition;
-  const today = new Date();
+  const [, month, day] = today.split("-").map(Number);
   const active = new Set(activeChildren.map((child) => child.id));
   const dueTimes = emptyDueTimes();
   for (const w of definition.windows) dueTimes[w.window] = w.due_time ?? "";
@@ -172,9 +168,9 @@ function draftFrom(definition: QuestDefinition, activeChildren: AdminChild[]): D
     weekdays:
       rule.rule_type === "weekly" || rule.rule_type === "custom_days"
         ? [...(rule.weekday_set ?? [])]
-        : [(today.getDay() + 6) % 7],
-    dayOfMonth: String(rule.day_of_month ?? today.getDate()),
-    month: String(rule.month ?? today.getMonth() + 1),
+        : [weekdayOf(today)],
+    dayOfMonth: String(rule.day_of_month ?? day),
+    month: String(rule.month ?? month),
     monthlyWeekday:
       rule.rule_type === "monthly_weekday"
         ? { nth: rule.nth_weekday ?? 1, weekday: rule.nth_weekday_weekday ?? 0 }
@@ -465,9 +461,11 @@ function EditSheet({
   onSaved: () => void;
   onDeleted: (result: DefinitionDeleteResult) => void;
 }) {
-  const [draft, setDraft] = useState<Draft>(() =>
-    target === "new" ? newDraft(activeChildren) : draftFrom(target, activeChildren),
-  );
+  const timeZone = useAppTimezone();
+  const [draft, setDraft] = useState<Draft>(() => {
+    const today = todayIn(timeZone);
+    return target === "new" ? newDraft(activeChildren, today) : draftFrom(target, activeChildren, today);
+  });
   // The active selection as loaded: while it is unchanged, the PATCH omits
   // assignee_child_ids, because the API replaces the whole set and inactive
   // children cannot be sent back.
diff --git a/admin/src/history/HistoryTab.test.tsx b/admin/src/history/HistoryTab.test.tsx
index 506bd08..650bc83 100644
--- a/admin/src/history/HistoryTab.test.tsx
+++ b/admin/src/history/HistoryTab.test.tsx
@@ -5,6 +5,7 @@ import type { HistoryFilter, HistoryRow } from "../api/history";
 import { storeTokens } from "../auth/oidc";
 import { TransitionsProvider } from "../api/useTransitions";
 import { frame, testStream, type TestStream } from "../api/testStream";
+import { AppTimezoneProvider } from "../time/AppTimezone";
 
 const TODAY = "2026-09-23";
 
@@ -629,3 +630,117 @@ describe("HistoryTab live updates", () => {
     expect(screen.getAllByTestId("history-row")).toHaveLength(ROWS.all.length);
   });
 });
+
+describe("HistoryTab in the stored application timezone", () => {
+  // 13:00 UTC on Sep 23 is 01:00 on Sep 24 in Auckland (NZST, UTC+12).
+  const NOW = new Date("2026-09-23T13:00:00Z");
+  // Due 00:10 Auckland on Sep 24, done 00:30 Auckland (12:30 UTC on Sep 23).
+  const LATE_NZ = row({
+    instance_id: 7,
+    quest_title: "Feed cat",
+    due_date: "2026-09-24",
+    due_time: "00:10",
+    occurred_at: "2026-09-23T12:30:00Z",
+    was_on_time: false,
+  });
+  // 22:00 Auckland on Sep 23; 10:00 UTC.
+  const EVENING_NZ = row({ instance_id: 8, occurred_at: "2026-09-23T10:00:00Z" });
+
+  let fetchMock: ReturnType<typeof vi.fn>;
+
+  function historyRequests(): URL[] {
+    return fetchMock.mock.calls
+      .map(([url]) => new URL(String(url), "http://x"))
+      .filter((url) => url.pathname === "/api/v1/admin/history");
+  }
+
+  async function renderWithZone(timezone: string, effective_timezone = timezone) {
+    fetchMock = vi.fn((url: string) => {
+      const parsed = new URL(url, "http://x");
+      if (parsed.pathname.endsWith("/api/v1/admin/settings")) {
+        return Promise.resolve(jsonResponse({ timezone, effective_timezone }));
+      }
+      const filter = parsed.searchParams.get("filter");
+      const rows = filter === "all" ? [EVENING_NZ, LATE_NZ] : [];
+      return Promise.resolve(
+        jsonResponse({
+          filter,
+          start: parsed.searchParams.get("start"),
+          end: parsed.searchParams.get("end"),
+          count: rows.length,
+          rows,
+        }),
+      );
+    });
+    vi.stubGlobal("fetch", fetchMock);
+    render(
+      <AppTimezoneProvider>
+        <HistoryTab />
+      </AppTimezoneProvider>,
+    );
+    await screen.findByTestId("stat-on-time");
+  }
+
+  function times(section: HTMLElement): string[] {
+    return Array.from(section.querySelectorAll(".history-event-time")).map(
+      (el) => el.textContent ?? "",
+    );
+  }
+
+  beforeAll(() => {
+    vi.stubEnv("TZ", "UTC");
+  });
+
+  afterAll(() => {
+    vi.unstubAllEnvs();
+  });
+
+  beforeEach(() => {
+    sessionStorage.clear();
+    storeTokens({ access_token: "at-123", expires_in: 600 });
+    vi.useFakeTimers({ toFake: ["Date"], now: NOW });
+  });
+
+  afterEach(() => {
+    cleanup();
+    vi.useRealTimers();
+    vi.unstubAllGlobals();
+  });
+
+  it.each([
+    ["the stored zone", "Pacific/Auckland"],
+    ["the API host's published zone when none is stored", ""],
+  ])("today, day grouping, clock and lateness follow %s", async (_label, stored) => {
+    await renderWithZone(stored, "Pacific/Auckland");
+
+    for (const url of historyRequests()) {
+      expect(url.searchParams.get("end")).toBe("2026-09-24");
+      expect(url.searchParams.get("start")).toBe("2026-09-11");
+    }
+    const today = screen.getByTestId("day-2026-09-24");
+    expect(within(today).getByText("Today")).toBeTruthy();
+    expect(times(today)).toEqual(["12:30 AM"]);
+    expect(metas(today)).toEqual(["completed · panel (Declan) · late 20 min"]);
+
+    const yesterday = screen.getByTestId("day-2026-09-23");
+    expect(within(yesterday).getByText("Yesterday")).toBeTruthy();
+    expect(times(yesterday)).toEqual(["10:00 PM"]);
+  });
+
+  it("only an API that publishes no zone leaves the browser's local day and clock", async () => {
+    await renderWithZone("", "");
+
+    for (const url of historyRequests()) {
+      expect(url.searchParams.get("end")).toBe("2026-09-23");
+    }
+    expect(screen.queryByTestId("day-2026-09-24")).toBeNull();
+    const today = screen.getByTestId("day-2026-09-23");
+    expect(within(today).getByText("Today")).toBeTruthy();
+    expect(times(today)).toEqual(["12:30 PM", "10:00 AM"]);
+    // Due 00:10 UTC on Sep 24 is after the 12:30 UTC completion: no minutes.
+    expect(metas(today)).toEqual([
+      "completed · panel (Declan) · late",
+      "completed · panel (Declan) · on time",
+    ]);
+  });
+});
diff --git a/admin/src/history/HistoryTab.tsx b/admin/src/history/HistoryTab.tsx
index 33ab53d..098beba 100644
--- a/admin/src/history/HistoryTab.tsx
+++ b/admin/src/history/HistoryTab.tsx
@@ -9,9 +9,10 @@ import { ApiForbiddenError } from "../api/client";
 import type { TransitionEvent } from "../api/events";
 import { useTransitions } from "../api/useTransitions";
 import { exportHistoryCsv, fetchHistory, type HistoryFilter, type HistoryRow } from "../api/history";
-import { localTodayIso } from "../schedule/cycle";
 import { dayLabel, groupByDay, rowMeta, rowTime, shiftIso } from "./format";
 import { DownloadGlyph, LockGlyph } from "./glyphs";
+import { useAppTimezone } from "../time/AppTimezone";
+import { todayIn } from "../time/zone";
 import "./HistoryTab.css";
 
 /** ADMIN-SPEC §1: every scroll column ends with 92px so content clears the tab bar. */
@@ -129,7 +130,7 @@ function StatRow({ stats }: { stats: HistoryStats }) {
   );
 }
 
-function EventRow({ row }: { row: HistoryRow }) {
+function EventRow({ row, timeZone }: { row: HistoryRow; timeZone: string }) {
   return (
     <li className="history-event" data-testid="history-row">
       <span
@@ -142,10 +143,10 @@ function EventRow({ row }: { row: HistoryRow }) {
           {row.quest_title} · {row.child_name}
         </div>
         <div className="history-event-meta" data-testid="history-meta">
-          {rowMeta(row)}
+          {rowMeta(row, timeZone)}
         </div>
       </div>
-      <span className="history-event-time">{rowTime(row)}</span>
+      <span className="history-event-time">{rowTime(row, timeZone)}</span>
     </li>
   );
 }
@@ -161,7 +162,10 @@ function FooterNote() {
   );
 }
 
-export default function HistoryTab({ today = localTodayIso() }: { today?: string }) {
+/** `today` ("YYYY-MM-DD") defaults to today in the application timezone. */
+export default function HistoryTab({ today: todayProp }: { today?: string }) {
+  const timeZone = useAppTimezone();
+  const today = todayProp ?? todayIn(timeZone);
   const [filter, setFilter] = useState<HistoryFilter>("all");
   const [state, setState] = useState<LoadState>({ kind: "loading" });
   const [attempt, setAttempt] = useState(0);
@@ -244,7 +248,7 @@ export default function HistoryTab({ today = localTodayIso() }: { today?: string
       </div>
     );
   } else {
-    const groups = groupByDay(shown.data.rows);
+    const groups = groupByDay(shown.data.rows, timeZone);
     body =
       groups.length > 0 ? (
         groups.map((group) => (
@@ -252,7 +256,7 @@ export default function HistoryTab({ today = localTodayIso() }: { today?: string
             <h3 className="history-section-label">{dayLabel(group.day, today)}</h3>
             <ul className="history-card history-list">
               {group.rows.map((row, index) => (
-                <EventRow key={`${row.instance_id}-${row.event_type}-${row.occurred_at ?? ""}-${index}`} row={row} />
+                <EventRow key={`${row.instance_id}-${row.event_type}-${row.occurred_at ?? ""}-${index}`} row={row} timeZone={timeZone} />
               ))}
             </ul>
           </section>
diff --git a/admin/src/history/format.ts b/admin/src/history/format.ts
index 7575563..5b64058 100644
--- a/admin/src/history/format.ts
+++ b/admin/src/history/format.ts
@@ -4,12 +4,13 @@
  * Calendar dates ("YYYY-MM-DD") are handled by their components (never
  * `new Date("YYYY-MM-DD")`, which is UTC midnight and reads as the previous
  * day in negative-offset zones); event stamps are UTC and shown in the
- * viewer's local time.
+ * application timezone (`timeZone`: the stored IANA zone, "" = browser).
  */
 import type { HistoryRow } from "../api/history";
-import { dayNumber, isoFromDayNumber, localTodayIso } from "../schedule/cycle";
+import { dayNumber, isoFromDayNumber } from "../schedule/cycle";
 import { shortDate } from "../schedule/format";
 import { formatClockTime, formatDueTime } from "../today/format";
+import { isoDateIn, wallClockInstant } from "../time/zone";
 
 const MS_PER_MINUTE = 60_000;
 
@@ -19,25 +20,21 @@ export function shiftIso(iso: string, days: number): string {
 }
 
 /** The local calendar day an event belongs to (due_date for missed rows). */
-export function rowDay(row: HistoryRow): string {
-  return row.occurred_at ? localTodayIso(new Date(row.occurred_at)) : row.due_date;
+export function rowDay(row: HistoryRow, timeZone: string): string {
+  return row.occurred_at ? isoDateIn(new Date(row.occurred_at), timeZone) : row.due_date;
 }
 
-/** The row's due moment as local wall-clock time, or null without a due time. */
-function dueMoment(row: HistoryRow): Date | null {
+/** The row's due moment (epoch ms) as local wall-clock time, or null without a due time. */
+function dueMoment(row: HistoryRow, timeZone: string): number | null {
   const match = /^(\d{2}):(\d{2})/.exec(row.due_time ?? "");
   if (!match) return null;
-  const [year, month, day] = row.due_date.split("-").map(Number);
-  return new Date(year, month - 1, day, Number(match[1]), Number(match[2]));
+  return wallClockInstant(row.due_date, Number(match[1]), Number(match[2]), timeZone);
 }
 
 /** Newest first; a missed row sorts at its due moment (or the end of its day). */
-function sortKey(row: HistoryRow): number {
+function sortKey(row: HistoryRow, timeZone: string): number {
   if (row.occurred_at) return Date.parse(row.occurred_at);
-  const due = dueMoment(row);
-  if (due) return due.getTime();
-  const [year, month, day] = row.due_date.split("-").map(Number);
-  return new Date(year, month - 1, day, 23, 59).getTime();
+  return dueMoment(row, timeZone) ?? wallClockInstant(row.due_date, 23, 59, timeZone);
 }
 
 export interface DayGroup {
@@ -46,10 +43,10 @@ export interface DayGroup {
 }
 
 /** Rows grouped by day, newest day first and newest row first within a day. */
-export function groupByDay(rows: HistoryRow[]): DayGroup[] {
+export function groupByDay(rows: HistoryRow[], timeZone: string): DayGroup[] {
   const groups = new Map<string, HistoryRow[]>();
   for (const row of rows) {
-    const day = rowDay(row);
+    const day = rowDay(row, timeZone);
     groups.set(day, [...(groups.get(day) ?? []), row]);
   }
   return [...groups.entries()]
@@ -57,7 +54,7 @@ export function groupByDay(rows: HistoryRow[]): DayGroup[] {
     .map(([day, dayRows]) => ({
       day,
       // Stable sort: rows at the same moment keep the API's append order.
-      rows: [...dayRows].sort((a, b) => sortKey(b) - sortKey(a)),
+      rows: [...dayRows].sort((a, b) => sortKey(b, timeZone) - sortKey(a, timeZone)),
     }));
 }
 
@@ -72,23 +69,23 @@ export function dayLabel(day: string, today: string): string {
 }
 
 /** "on time", "late 22 min", or "late" when the lateness is not derivable. */
-function onTimeFlag(row: HistoryRow): string | null {
+function onTimeFlag(row: HistoryRow, timeZone: string): string | null {
   if (row.event_type !== "completed" || row.was_on_time === null) return null;
   if (row.was_on_time) return "on time";
-  const due = dueMoment(row);
-  if (!due || !row.occurred_at) return "late";
-  const minutes = Math.round((Date.parse(row.occurred_at) - due.getTime()) / MS_PER_MINUTE);
+  const due = dueMoment(row, timeZone);
+  if (due === null || !row.occurred_at) return "late";
+  const minutes = Math.round((Date.parse(row.occurred_at) - due) / MS_PER_MINUTE);
   return minutes > 0 ? `late ${minutes} min` : "late";
 }
 
 /** `<event type> · <actor>` plus the on-time flag for completions. */
-export function rowMeta(row: HistoryRow): string {
-  const flag = onTimeFlag(row);
+export function rowMeta(row: HistoryRow, timeZone: string): string {
+  const flag = onTimeFlag(row, timeZone);
   return [row.event_type, row.actor, flag].filter(Boolean).join(" · ");
 }
 
 /** The event's local clock time; a missed row shows its due time, if any. */
-export function rowTime(row: HistoryRow): string {
-  if (row.occurred_at) return formatClockTime(row.occurred_at);
+export function rowTime(row: HistoryRow, timeZone: string): string {
+  if (row.occurred_at) return formatClockTime(row.occurred_at, timeZone);
   return row.due_time ? formatDueTime(row.due_time) : "";
 }
diff --git a/admin/src/schedule/OverrideEditor.test.tsx b/admin/src/schedule/OverrideEditor.test.tsx
index c57c5d5..2763079 100644
--- a/admin/src/schedule/OverrideEditor.test.tsx
+++ b/admin/src/schedule/OverrideEditor.test.tsx
@@ -74,6 +74,10 @@ async function routeFetch(url: string, init: RequestInit = {}): Promise<Response
     overrides = overrides.filter((o) => o.id !== Number(deleteMatch[1]));
     return jsonResponse({ status: "ok" });
   }
+  // The shell loads the application timezone first ("" = none published).
+  if (path.endsWith("/admin/settings")) {
+    return jsonResponse({ timezone: "", effective_timezone: "" });
+  }
   if (path.endsWith("/admin/children")) return jsonResponse({ children: CHILDREN });
   const patternsMatch = /\/children\/(\d+)\/presence-patterns$/.exec(path);
   if (patternsMatch) {
diff --git a/admin/src/schedule/ScheduleTab.test.tsx b/admin/src/schedule/ScheduleTab.test.tsx
index 91b0e62..79874dc 100644
--- a/admin/src/schedule/ScheduleTab.test.tsx
+++ b/admin/src/schedule/ScheduleTab.test.tsx
@@ -1,9 +1,10 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
 import { cleanup, fireEvent, render, screen, waitFor, within } from "@testing-library/react";
 import ScheduleTab from "./ScheduleTab";
 import type { AdminChild } from "../api/definitions";
 import type { PresenceOverride, PresencePattern } from "../api/presence";
 import { storeTokens } from "../auth/oidc";
+import { AppTimezoneProvider } from "../time/AppTimezone";
 import { cycleWeekIndex, monthDates, weekdayOf } from "./cycle";
 
 function child(id: number, display_name: string, sort_order: number, is_active = true): AdminChild {
@@ -655,3 +656,55 @@ describe("ScheduleTab", () => {
     expect(await screen.findByTestId("pattern-1")).toBeTruthy();
   });
 });
+
+describe("ScheduleTab today in the stored application timezone", () => {
+  async function renderWithZone(timezone: string, effective_timezone = timezone) {
+    fetchMock = vi.fn(async (url: string, init?: RequestInit) =>
+      String(url).endsWith("/api/v1/admin/settings")
+        ? jsonResponse({ timezone, effective_timezone })
+        : routeFetch(url, init),
+    );
+    vi.stubGlobal("fetch", fetchMock);
+    render(
+      <AppTimezoneProvider>
+        <ScheduleTab />
+      </AppTimezoneProvider>,
+    );
+    await screen.findByTestId("pattern-1");
+  }
+
+  beforeAll(() => {
+    vi.stubEnv("TZ", "UTC");
+  });
+
+  afterAll(() => {
+    vi.unstubAllEnvs();
+  });
+
+  beforeEach(() => {
+    sessionStorage.clear();
+    storeTokens({ access_token: "at-123", expires_in: 600 });
+    patterns = { 1: [DECLAN_HOME], 2: [MAEVE_THU_FRI, MAEVE_WEEKENDS], 3: [] };
+    writeFailure = null;
+    // 13:00 UTC on Sep 23 is already 01:00 on Sep 24 in Auckland.
+    vi.useFakeTimers({ toFake: ["Date"], now: new Date("2026-09-23T13:00:00Z") });
+  });
+
+  afterEach(() => {
+    cleanup();
+    vi.useRealTimers();
+    vi.unstubAllGlobals();
+  });
+
+  it("marks today in the stored zone", async () => {
+    await renderWithZone("Pacific/Auckland");
+    expect(day("2026-09-24").className).toContain("schedule-day--today");
+    expect(day("2026-09-23").className).not.toContain("schedule-day--today");
+  });
+
+  it("an empty stored zone marks today in the API host's published zone", async () => {
+    await renderWithZone("", "Pacific/Auckland");
+    expect(day("2026-09-24").className).toContain("schedule-day--today");
+    expect(day("2026-09-23").className).not.toContain("schedule-day--today");
+  });
+});
diff --git a/admin/src/schedule/ScheduleTab.tsx b/admin/src/schedule/ScheduleTab.tsx
index 06074ac..16243f2 100644
--- a/admin/src/schedule/ScheduleTab.tsx
+++ b/admin/src/schedule/ScheduleTab.tsx
@@ -20,7 +20,6 @@ import {
 import {
   cycleLabel,
   dayState,
-  localTodayIso,
   monthDates,
   monthStart,
   patternDaysLabel,
@@ -38,6 +37,8 @@ import {
 } from "./glyphs";
 import OverrideEditor from "./OverrideEditor";
 import PatternEditor from "./PatternEditor";
+import { useAppTimezone } from "../time/AppTimezone";
+import { todayIn } from "../time/zone";
 import "./ScheduleTab.css";
 
 /** ADMIN-SPEC §1: every scroll column ends with 92px so content clears the tab bar. */
@@ -324,11 +325,13 @@ function OverrideRow({ override, childName, deletion, onAskDelete, onKeep, onDel
 }
 
 export interface ScheduleTabProps {
-  /** "YYYY-MM-DD"; defaults to the viewer's local date. */
+  /** "YYYY-MM-DD"; defaults to today in the application timezone. */
   today?: string;
 }
 
-export default function ScheduleTab({ today = localTodayIso() }: ScheduleTabProps) {
+export default function ScheduleTab({ today: todayProp }: ScheduleTabProps) {
+  const timeZone = useAppTimezone();
+  const today = todayProp ?? todayIn(timeZone);
   const [state, setState] = useState<LoadState>({ kind: "loading" });
   const [attempt, setAttempt] = useState(0);
   const [selectedId, setSelectedId] = useState<number | null>(null);
diff --git a/admin/src/schedule/cycle.ts b/admin/src/schedule/cycle.ts
index d8e3491..9701b88 100644
--- a/admin/src/schedule/cycle.ts
+++ b/admin/src/schedule/cycle.ts
@@ -55,13 +55,6 @@ export function cycleWeekIndex(anchorDate: string, date: string, cycleLengthWeek
   return mod(Math.floor(days / 7), cycleLengthWeeks);
 }
 
-/** The viewer's local calendar date. */
-export function localTodayIso(now: Date = new Date()): string {
-  const month = String(now.getMonth() + 1).padStart(2, "0");
-  const day = String(now.getDate()).padStart(2, "0");
-  return `${now.getFullYear()}-${month}-${day}`;
-}
-
 /** "YYYY-MM-01" of the month containing `iso`, shifted by `delta` months. */
 export function monthStart(iso: string, delta = 0): string {
   const [year, month] = iso.split("-").map(Number);
diff --git a/admin/src/settings/SettingsScreen.test.tsx b/admin/src/settings/SettingsScreen.test.tsx
index 3c4cfc2..cebc087 100644
--- a/admin/src/settings/SettingsScreen.test.tsx
+++ b/admin/src/settings/SettingsScreen.test.tsx
@@ -6,6 +6,7 @@ import SettingsScreen, { SCROLL_BOTTOM_PADDING } from "./SettingsScreen";
 import type { AdminChild } from "../api/definitions";
 import type { HouseholdSettings } from "../api/settings";
 import { storeTokens } from "../auth/oidc";
+import { AppTimezoneProvider, useAppTimezone } from "../time/AppTimezone";
 
 const CHILDREN_PATH = "/api/v1/admin/children";
 const REORDER_PATH = `${CHILDREN_PATH}/reorder`;
@@ -23,8 +24,17 @@ const DEFAULT_SETTINGS: HouseholdSettings = {
   end_of_day_report_enabled: true,
   celebration_enabled: false,
   timezone: "America/Chicago",
+  effective_timezone: "America/Chicago",
 };
 
+/** The API host's own zone: the effective zone while none is stored. */
+const API_HOST_ZONE = "Europe/London";
+
+/** The settings as the API answers: `effective_timezone` derived like the API's. */
+function settingsBody(): HouseholdSettings {
+  return { ...settings, effective_timezone: settings.timezone || API_HOST_ZONE };
+}
+
 function child(
   id: number,
   display_name: string,
@@ -82,10 +92,10 @@ async function routeFetch(url: string, init: RequestInit = {}): Promise<Response
     return respond();
   }
   if (path === CHILDREN_PATH && method === "GET") return jsonResponse({ children });
-  if (path === SETTINGS_PATH && method === "GET") return jsonResponse(settings);
+  if (path === SETTINGS_PATH && method === "GET") return jsonResponse(settingsBody());
   if (path === SETTINGS_PATH && method === "PATCH") {
     settings = { ...settings, ...body };
-    return jsonResponse(settings);
+    return jsonResponse(settingsBody());
   }
   if (path === CHILDREN_PATH && method === "POST") {
     const created = child(9, body.display_name, body.sort_order ?? 0, {
@@ -791,3 +801,43 @@ describe("SettingsScreen — manual timezone control", () => {
     }
   });
 });
+
+describe("SettingsScreen — the saved zone applies app-wide", () => {
+  function ZoneProbe() {
+    return <output data-testid="app-zone">{useAppTimezone() || "(browser)"}</output>;
+  }
+
+  beforeEach(() => {
+    sessionStorage.clear();
+    storeTokens({ access_token: "at-123", expires_in: 600 });
+    children = [child(1, "Declan", 1)];
+    settings = { ...DEFAULT_SETTINGS, timezone: "" };
+    writeResponse = null;
+    fetchMock = vi.fn(async (url: string, init?: RequestInit) => routeFetch(url, init));
+    vi.stubGlobal("fetch", fetchMock);
+  });
+
+  afterEach(() => {
+    cleanup();
+    vi.unstubAllGlobals();
+  });
+
+  it("a saved zone becomes the application timezone at once", async () => {
+    render(
+      <AppTimezoneProvider>
+        <ZoneProbe />
+        <SettingsScreen onClose={vi.fn()} />
+      </AppTimezoneProvider>,
+    );
+    const form = await screen.findByRole("form", { name: "Preferences" });
+    // No zone stored: the application runs in the API host's zone.
+    expect(screen.getByTestId("app-zone").textContent).toBe(API_HOST_ZONE);
+
+    fireEvent.change(within(form).getByRole("combobox", { name: "Timezone" }), {
+      target: { value: "America/New_York" },
+    });
+    fireEvent.click(within(form).getByRole("button", { name: "Save preferences" }));
+    await screen.findByText("Preferences saved.");
+    expect(screen.getByTestId("app-zone").textContent).toBe("America/New_York");
+  });
+});
diff --git a/admin/src/settings/SettingsScreen.tsx b/admin/src/settings/SettingsScreen.tsx
index 1f31baa..50c78ec 100644
--- a/admin/src/settings/SettingsScreen.tsx
+++ b/admin/src/settings/SettingsScreen.tsx
@@ -7,7 +7,8 @@
  * Preferences: the household settings (planning horizon, day rollover,
  * timezone, notifications). Save patches only the changed fields. The
  * timezone — the application's source of local time — is only ever set by
- * the admin picking or typing a zone here and saving it.
+ * the admin picking or typing a zone here and saving it; every zone loaded
+ * or saved here is published app-wide (time/AppTimezone.tsx).
  *
  * One write at a time across both sections.
  */
@@ -35,6 +36,7 @@ import {
   type SettingsChanges,
 } from "../api/settings";
 import { FOCUSABLE, inertOutside } from "../schedule/OverrideEditor";
+import { usePublishAppTimezone } from "../time/AppTimezone";
 import { ArrowDownGlyph, ArrowUpGlyph, ChevronLeftGlyph, PlusGlyph } from "./glyphs";
 import "./SettingsScreen.css";
 
@@ -593,6 +595,7 @@ export default function SettingsScreen({ onClose }: { onClose: () => void }) {
   const titleRef = useRef<HTMLHeadingElement>(null);
   const addRef = useRef<HTMLButtonElement>(null);
   const formWasOpen = useRef(false);
+  const publishTimezone = usePublishAppTimezone();
 
   // Modal focus: move in on open, keep the background out of reach, and hand
   // focus back to the opener (the Settings button) on close.
@@ -634,7 +637,9 @@ export default function SettingsScreen({ onClose }: { onClose: () => void }) {
     setPreferences({ kind: "loading" });
     fetchSettings()
       .then((settings) => {
-        if (!cancelled) setPreferences({ kind: "ready", settings });
+        if (cancelled) return;
+        setPreferences({ kind: "ready", settings });
+        publishTimezone(settings.effective_timezone);
       })
       .catch((error: unknown) => {
         if (cancelled) return;
@@ -728,6 +733,7 @@ export default function SettingsScreen({ onClose }: { onClose: () => void }) {
     try {
       const settings = await updateSettings(changes);
       setPreferences({ kind: "ready", settings });
+      publishTimezone(settings.effective_timezone);
       setPreferencesMessage({ kind: "info", text: "Preferences saved." });
     } catch (error) {
       setPreferencesMessage({
diff --git a/admin/src/time/AppTimezone.tsx b/admin/src/time/AppTimezone.tsx
new file mode 100644
index 0000000..dcbadb8
--- /dev/null
+++ b/admin/src/time/AppTimezone.tsx
@@ -0,0 +1,93 @@
+/**
+ * The effective application timezone, loaded once per signed-in shell: the
+ * API's `effective_timezone` — the stored zone, or the API host's own zone
+ * when none is stored — so every screen's local time matches the API's.
+ *
+ * <AppTimezoneProvider> fetches the household settings and renders its
+ * screens only once the zone is known (a failed load says so and offers a
+ * retry), so no screen ever computes local time in a zone it will not keep.
+ * The Settings screen publishes every zone it loads or saves, so a change
+ * applies app-wide at once.
+ *
+ * Without a provider (a screen rendered on its own, e.g. in a test)
+ * useAppTimezone() is "" — the documented unset value, i.e. browser-local.
+ */
+import { createContext, useContext, useEffect, useState, type ReactNode } from "react";
+import { ApiForbiddenError } from "../api/client";
+import { fetchSettings } from "../api/settings";
+
+interface ZoneHub {
+  timeZone: string;
+  publish(timeZone: string): void;
+}
+
+const AppTimezoneContext = createContext<ZoneHub | null>(null);
+
+type LoadState =
+  | { kind: "loading" }
+  | { kind: "error"; message: string }
+  | { kind: "ready"; timeZone: string };
+
+export function AppTimezoneProvider({ children }: { children: ReactNode }) {
+  const [state, setState] = useState<LoadState>({ kind: "loading" });
+  const [attempt, setAttempt] = useState(0);
+
+  useEffect(() => {
+    let cancelled = false;
+    setState({ kind: "loading" });
+    fetchSettings()
+      .then((settings) => {
+        if (!cancelled) setState({ kind: "ready", timeZone: settings.effective_timezone });
+      })
+      .catch((error: unknown) => {
+        if (cancelled) return;
+        setState({
+          kind: "error",
+          message:
+            error instanceof ApiForbiddenError
+              ? error.message
+              : "The application timezone could not be loaded. Check your connection and try again.",
+        });
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, [attempt]);
+
+  if (state.kind === "loading") {
+    return (
+      <div className="admin-loading" role="status" data-testid="timezone-loading">
+        Loading…
+      </div>
+    );
+  }
+  if (state.kind === "error") {
+    return (
+      <div className="admin-error" role="alert" data-testid="timezone-error">
+        <p>{state.message}</p>
+        <button type="button" onClick={() => setAttempt((n) => n + 1)}>
+          Try again
+        </button>
+      </div>
+    );
+  }
+  const hub: ZoneHub = {
+    timeZone: state.timeZone,
+    publish: (timeZone) =>
+      setState((prev) =>
+        prev.kind === "ready" && prev.timeZone === timeZone ? prev : { kind: "ready", timeZone },
+      ),
+  };
+  return <AppTimezoneContext.Provider value={hub}>{children}</AppTimezoneContext.Provider>;
+}
+
+/** The effective application timezone: an IANA name, or "" (browser-local). */
+export function useAppTimezone(): string {
+  return useContext(AppTimezoneContext)?.timeZone ?? "";
+}
+
+/** Publish an effective zone just loaded or saved; a no-op without a provider. */
+export function usePublishAppTimezone(): (timeZone: string) => void {
+  const hub = useContext(AppTimezoneContext);
+  return (timeZone) => hub?.publish(timeZone);
+}
diff --git a/admin/src/time/zone.test.ts b/admin/src/time/zone.test.ts
new file mode 100644
index 0000000..03c3511
--- /dev/null
+++ b/admin/src/time/zone.test.ts
@@ -0,0 +1,60 @@
+import { afterAll, beforeAll, describe, expect, it, vi } from "vitest";
+import { isoDateIn, todayIn, wallClockInstant, zoneOption } from "./zone";
+import { formatClockTime } from "../today/format";
+
+// 13:00 UTC on Sep 23 is already 01:00 on Sep 24 in Auckland (NZST, UTC+12).
+const NOW = new Date("2026-09-23T13:00:00Z");
+
+describe("application timezone helpers (process in UTC)", () => {
+  beforeAll(() => {
+    vi.stubEnv("TZ", "UTC");
+  });
+
+  afterAll(() => {
+    vi.unstubAllEnvs();
+  });
+
+  it("a stored zone decides the calendar date; empty means the browser's zone", () => {
+    expect(todayIn("Pacific/Auckland", NOW)).toBe("2026-09-24");
+    expect(isoDateIn(NOW, "Pacific/Auckland")).toBe("2026-09-24");
+    expect(todayIn("", NOW)).toBe("2026-09-23");
+  });
+
+  it("wall-clock time converts in the stored zone, across its DST change", () => {
+    // NZST (UTC+12) before 27 Sep 2026, NZDT (UTC+13) after.
+    expect(wallClockInstant("2026-09-24", 0, 10, "Pacific/Auckland")).toBe(
+      Date.parse("2026-09-23T12:10:00Z"),
+    );
+    expect(wallClockInstant("2026-09-28", 7, 30, "Pacific/Auckland")).toBe(
+      Date.parse("2026-09-27T18:30:00Z"),
+    );
+    expect(wallClockInstant("2026-09-24", 0, 10, "")).toBe(Date.parse("2026-09-24T00:10:00Z"));
+  });
+
+  it("the completion clock reads in the stored zone", () => {
+    expect(formatClockTime("2026-09-23T11:04:00Z", "Pacific/Auckland")).toBe("11:04 PM");
+    expect(formatClockTime("2026-09-23T11:04:00Z", "")).toBe("11:04 AM");
+  });
+
+  it("an invalid stored zone fails fast", () => {
+    expect(zoneOption("")).toBeUndefined();
+    expect(() => todayIn("Not/AZone", NOW)).toThrow(RangeError);
+  });
+});
+
+describe("empty zone keeps browser-local behavior", () => {
+  beforeAll(() => {
+    vi.stubEnv("TZ", "America/Los_Angeles");
+  });
+
+  afterAll(() => {
+    vi.unstubAllEnvs();
+  });
+
+  it("matches the browser's own calendar and wall clock", () => {
+    // 13:00 UTC is 06:00 PDT on Sep 23.
+    expect(todayIn("", NOW)).toBe("2026-09-23");
+    expect(wallClockInstant("2026-09-23", 7, 30, "")).toBe(new Date(2026, 8, 23, 7, 30).getTime());
+    expect(formatClockTime("2026-09-23T14:04:00Z", "")).toBe("7:04 AM");
+  });
+});
diff --git a/admin/src/time/zone.ts b/admin/src/time/zone.ts
new file mode 100644
index 0000000..e4edc6e
--- /dev/null
+++ b/admin/src/time/zone.ts
@@ -0,0 +1,81 @@
+/**
+ * Local time in the application timezone.
+ *
+ * The admin-saved zone (settings `timezone`, an IANA name) is the single
+ * source of local-time truth for the whole application; the API publishes it
+ * as `effective_timezone`, naming its host's own zone when none is stored.
+ * "" means the API published no zone, and only then does the browser's own
+ * zone apply. Every helper takes
+ * that stored value as-is; an invalid zone name throws (Intl's RangeError).
+ */
+
+/** The `timeZone` option for Intl: the zone, or undefined (browser) for "". */
+export function zoneOption(timeZone: string): string | undefined {
+  return timeZone === "" ? undefined : timeZone;
+}
+
+interface WallClock {
+  year: number;
+  month: number;
+  day: number;
+  hour: number;
+  minute: number;
+  second: number;
+}
+
+function wallClock(instant: number, timeZone: string): WallClock {
+  const parts = new Intl.DateTimeFormat("en-US", {
+    timeZone: zoneOption(timeZone),
+    hourCycle: "h23",
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+  }).formatToParts(instant);
+  const part = (type: Intl.DateTimeFormatPartTypes) =>
+    Number(parts.find((p) => p.type === type)?.value);
+  return {
+    year: part("year"),
+    month: part("month"),
+    day: part("day"),
+    hour: part("hour"),
+    minute: part("minute"),
+    second: part("second"),
+  };
+}
+
+/** The "YYYY-MM-DD" calendar date of `instant` in the zone. */
+export function isoDateIn(instant: Date, timeZone: string): string {
+  const { year, month, day } = wallClock(instant.getTime(), timeZone);
+  return `${year}-${String(month).padStart(2, "0")}-${String(day).padStart(2, "0")}`;
+}
+
+/** Today's calendar date in the zone. */
+export function todayIn(timeZone: string, now: Date = new Date()): string {
+  return isoDateIn(now, timeZone);
+}
+
+/** The zone's UTC offset in ms at `instant` (wall clock minus UTC). */
+function offsetAt(instant: number, timeZone: string): number {
+  const c = wallClock(instant, timeZone);
+  const wholeSeconds = Math.floor(instant / 1000) * 1000;
+  return Date.UTC(c.year, c.month - 1, c.day, c.hour, c.minute, c.second) - wholeSeconds;
+}
+
+/**
+ * Epoch ms at which the zone's wall clock reads `hour:minute` on the
+ * "YYYY-MM-DD" date. Two passes settle the offset across a DST change.
+ */
+export function wallClockInstant(
+  iso: string,
+  hour: number,
+  minute: number,
+  timeZone: string,
+): number {
+  const [year, month, day] = iso.split("-").map(Number);
+  const asUtc = Date.UTC(year, month - 1, day, hour, minute);
+  const guess = asUtc - offsetAt(asUtc, timeZone);
+  return asUtc - offsetAt(guess, timeZone);
+}
diff --git a/admin/src/today/TodayTab.test.tsx b/admin/src/today/TodayTab.test.tsx
index 41a59b7..7df60ff 100644
--- a/admin/src/today/TodayTab.test.tsx
+++ b/admin/src/today/TodayTab.test.tsx
@@ -5,6 +5,7 @@ import type { AdminSnapshot, SnapshotInstance } from "../api/snapshot";
 import { TransitionsProvider } from "../api/useTransitions";
 import { frame, testStream, type TestStream } from "../api/testStream";
 import { storeTokens } from "../auth/oidc";
+import { AppTimezoneProvider } from "../time/AppTimezone";
 
 function instance(overrides: Partial<SnapshotInstance>): SnapshotInstance {
   return {
@@ -406,3 +407,62 @@ describe("TodayTab Undo and live updates", () => {
     await waitFor(() => expect(streams[0].cancelled()).toBe(true));
   });
 });
+
+describe("TodayTab in the stored application timezone", () => {
+  function renderWithZone(timezone: string, effective_timezone = timezone) {
+    fetchMock.mockImplementation((url: string) =>
+      Promise.resolve(
+        String(url).endsWith("/api/v1/admin/settings")
+          ? jsonResponse({ timezone, effective_timezone })
+          : jsonResponse(SNAPSHOT),
+      ),
+    );
+    render(
+      <AppTimezoneProvider>
+        <TodayTab />
+      </AppTimezoneProvider>,
+    );
+  }
+
+  beforeAll(() => {
+    // The browser runs in UTC; the household lives in Auckland (UTC+12 on Sep 23).
+    vi.stubEnv("TZ", "UTC");
+  });
+
+  afterAll(() => {
+    vi.unstubAllEnvs();
+  });
+
+  beforeEach(() => {
+    sessionStorage.clear();
+    storeTokens({ access_token: "at-123", expires_in: 600 });
+    fetchMock = vi.fn();
+    vi.stubGlobal("fetch", fetchMock);
+  });
+
+  afterEach(() => {
+    cleanup();
+    vi.unstubAllGlobals();
+  });
+
+  it("shows the completion clock in the stored zone, not the browser's", async () => {
+    renderWithZone("Pacific/Auckland");
+    const completed = await screen.findByTestId("attention-12");
+    // 11:04 UTC is 11:04 PM in Auckland.
+    expect(within(completed).getByText("Completed 11:04 PM")).toBeTruthy();
+    // The header's day is the API's household-local today_iso, as-is.
+    expect(screen.getByText("Wednesday, September 23 · cycle day 5 of 14")).toBeTruthy();
+  });
+
+  it("an empty stored zone shows the clock in the API host's published zone", async () => {
+    renderWithZone("", "Pacific/Auckland");
+    const completed = await screen.findByTestId("attention-12");
+    expect(within(completed).getByText("Completed 11:04 PM")).toBeTruthy();
+  });
+
+  it("only an API that publishes no zone leaves the browser's local clock", async () => {
+    renderWithZone("", "");
+    const completed = await screen.findByTestId("attention-12");
+    expect(within(completed).getByText("Completed 11:04 AM")).toBeTruthy();
+  });
+});
diff --git a/admin/src/today/TodayTab.tsx b/admin/src/today/TodayTab.tsx
index 7646b87..a9519ec 100644
--- a/admin/src/today/TodayTab.tsx
+++ b/admin/src/today/TodayTab.tsx
@@ -13,6 +13,7 @@ import { ApiRequestError } from "../api/definitions";
 import { uncompleteInstance } from "../api/instances";
 import { useTransitions } from "../api/useTransitions";
 import SettingsScreen from "../settings/SettingsScreen";
+import { useAppTimezone } from "../time/AppTimezone";
 import {
   formatClockTime,
   formatDueTime,
@@ -165,6 +166,7 @@ function AttentionRow({ item, undo }: { item: AttentionItem; undo: UndoControl }
   const { instance, childName } = item;
   const overdue = isOverdueOpen(instance);
   const undoing = undo.pendingId === instance.id;
+  const timeZone = useAppTimezone();
   // TODO(e57facc2): wire "Mark done". The admin plane has no complete route
   // yet, so that action is inert here.
   return (
@@ -187,7 +189,7 @@ function AttentionRow({ item, undo }: { item: AttentionItem; undo: UndoControl }
         ) : (
           // The snapshot carries no completion actor, so "from panel" is not printed.
           <div className="today-event-meta">
-            Completed {formatClockTime(instance.completed_at as string)}
+            Completed {formatClockTime(instance.completed_at as string, timeZone)}
           </div>
         )}
       </div>
diff --git a/admin/src/today/format.ts b/admin/src/today/format.ts
index 80537c0..bfbfe97 100644
--- a/admin/src/today/format.ts
+++ b/admin/src/today/format.ts
@@ -4,8 +4,10 @@
  * Calendar dates ("YYYY-MM-DD") are parsed by their components and formatted
  * in UTC, so the printed day never shifts with the viewer's offset — unlike
  * `new Date("YYYY-MM-DD")`, which is UTC midnight and reads as the previous
- * day in negative-offset zones.
+ * day in negative-offset zones. Instants are shown in the application
+ * timezone (time/zone.ts).
  */
+import { zoneOption } from "../time/zone";
 
 const LOCALE = "en-US";
 
@@ -44,7 +46,11 @@ export function formatDueTime(hhmm: string): string {
   return format(date, { hour: "numeric", minute: "2-digit", timeZone: "UTC" });
 }
 
-/** A UTC ISO timestamp shown as the viewer's local time, "7:04 AM". */
-export function formatClockTime(isoTimestamp: string): string {
-  return format(new Date(isoTimestamp), { hour: "numeric", minute: "2-digit" });
+/** A UTC ISO timestamp shown as wall-clock time in `timeZone` ("" = browser), "7:04 AM". */
+export function formatClockTime(isoTimestamp: string, timeZone: string): string {
+  return format(new Date(isoTimestamp), {
+    hour: "numeric",
+    minute: "2-digit",
+    timeZone: zoneOption(timeZone),
+  });
 }
diff --git a/api/host_zone.py b/api/host_zone.py
new file mode 100644
index 0000000..21d45e0
--- /dev/null
+++ b/api/host_zone.py
@@ -0,0 +1,62 @@
+"""The API's effective application timezone (task 7e173881).
+
+The admin-stored ``timezone`` setting is the single source of local-time
+truth; stored empty, the API reads its clock in the API host's local
+time.  :func:`effective_timezone` names the zone the API actually uses —
+the stored zone, or else the host's own IANA zone — so the panel cards
+and the admin app format local time in exactly the API's zone instead of
+guessing with Home Assistant's or the browser's.  ``""`` only when the
+host's zone genuinely cannot be named.
+"""
+from __future__ import annotations
+
+import os
+from collections.abc import Mapping
+from pathlib import Path
+from zoneinfo import ZoneInfo, ZoneInfoNotFoundError
+
+
+def _valid_zone(name: str) -> str:
+    """Return ``name`` if it is a loadable IANA zone key, else ``""``."""
+    name = name.strip().removeprefix(":")
+    if not name:
+        return ""
+    try:
+        ZoneInfo(name)
+    except (ZoneInfoNotFoundError, ValueError):
+        return ""
+    return name
+
+
+def host_timezone(
+    environ: Mapping[str, str] = os.environ,
+    timezone_file: Path = Path("/etc/timezone"),
+    localtime: Path = Path("/etc/localtime"),
+) -> str:
+    """Name the API host's local zone as an IANA key, or ``""``.
+
+    In the order the C library honours them: the ``TZ`` environment
+    variable, then the ``/etc/localtime`` zoneinfo link (with Debian's
+    ``/etc/timezone`` naming it when the link is a copy).  A host with
+    none of them configured runs UTC.  A setting that names no IANA
+    zone (a POSIX rule string, a copied file) is ``""``.
+    """
+    configured = environ.get("TZ")
+    if configured is not None:
+        # An empty TZ is UTC to the C library.
+        return _valid_zone(configured) if configured.strip() else "UTC"
+    if localtime.is_symlink():
+        target = str(localtime.resolve())
+        marker = "/zoneinfo/"
+        if marker in target:
+            return _valid_zone(target.split(marker, 1)[1])
+    if timezone_file.is_file():
+        return _valid_zone(timezone_file.read_text(encoding="utf-8"))
+    if not localtime.exists():
+        return "UTC"
+    return ""
+
+
+def effective_timezone(stored: str) -> str:
+    """The zone the API reads its clock in: ``stored``, else the host's."""
+    return stored or host_timezone()
diff --git a/api/routes_admin.py b/api/routes_admin.py
index 8874230..053c098 100644
--- a/api/routes_admin.py
+++ b/api/routes_admin.py
@@ -170,7 +170,10 @@ are deliberately not unified here:
   notify target, the three notification times, the four enable
   toggles, and the ``timezone`` — the IANA household zone the
   household-local dates derive from, empty meaning host local; only an
-  admin's ``PATCH`` ever sets it) — the defaults on a fresh database.
+  admin's ``PATCH`` ever sets it) — the defaults on a fresh database —
+  plus the read-only ``effective_timezone`` (:mod:`api.host_zone`): the
+  zone the API actually reads its clock in, which the admin app formats
+  local time in.
 - ``PATCH /settings`` updates ONLY the supplied fields: the body is a
   JSON object of settings field names to new values, passed STRAIGHT
   to :func:`nestquest_core.settings_store.update_settings` — the
@@ -349,6 +352,7 @@ from pydantic import (
     model_validator,
 )
 
+from api import host_zone
 from api import transitions as api_transitions
 from api.auth import require_admin
 from api.database import DatabaseState
@@ -920,9 +924,14 @@ class AdminSettingsResponse(BaseModel):
     afternoon_reminder_enabled: bool
     end_of_day_report_enabled: bool
     celebration_enabled: bool
-    #: The household IANA time zone the API reads its clock in; ``""``
-    #: means the API host's local time.
+    #: The household IANA time zone the admin stored; ``""`` means the
+    #: API host's local time.
     timezone: str
+    #: The zone the API actually reads its clock in — ``timezone``, or
+    #: the API host's own zone when that is ``""`` (``""`` only when the
+    #: host's zone cannot be named).  Read-only; the admin app formats
+    #: local time in it.
+    effective_timezone: str
 
 
 class AdminMissedSweepResponse(BaseModel):
@@ -2179,8 +2188,9 @@ def _settings_response(
     """Serialize one core NestQuestSettings into the documented payload.
 
     Explicit field-by-field (not ``dataclasses.asdict``) so the payload
-    stays pinned to the eleven documented fields even if the core
-    dataclass later grows another one.
+    stays pinned to the eleven documented fields (plus the read-only
+    ``effective_timezone``) even if the core dataclass later grows
+    another one.
     """
     return AdminSettingsResponse(
         horizon_days=settings.horizon_days,
@@ -2194,6 +2204,7 @@ def _settings_response(
         end_of_day_report_enabled=settings.end_of_day_report_enabled,
         celebration_enabled=settings.celebration_enabled,
         timezone=settings.timezone,
+        effective_timezone=host_zone.effective_timezone(settings.timezone),
     )
 
 
@@ -2330,12 +2341,25 @@ async def admin_update_settings(
     every value has validated — so a rejected update never changes the
     stored settings.  Every core ``ValueError`` is 422
     (:func:`_raise_settings_error`); anything else re-raises.
+
+    The write holds the missed-sweep scheduler's ``settings_lock`` and
+    then tells it (:meth:`~api.scheduler.MissedSweepScheduler.settings_changed`),
+    so a saved ``timezone`` or ``day_rollover_time`` re-plans a sleeping
+    scheduler (an app without one — no lifespan — just writes).
     """
     state: DatabaseState = request.app.state.db
+    scheduler = getattr(request.app.state, "sweep_scheduler", None)
     try:
-        settings = await core_settings_store.update_settings(
-            state.database, changes
-        )
+        if scheduler is None:
+            settings = await core_settings_store.update_settings(
+                state.database, changes
+            )
+        else:
+            async with scheduler.settings_lock:
+                settings = await core_settings_store.update_settings(
+                    state.database, changes
+                )
+                scheduler.settings_changed(settings)
     except ValueError as error:
         _raise_settings_error(error)
     return _settings_response(settings)
diff --git a/api/routes_panel.py b/api/routes_panel.py
index eb84e4d..cbe9c34 100644
--- a/api/routes_panel.py
+++ b/api/routes_panel.py
@@ -21,6 +21,7 @@ panel payload), and returns the documented JSON shape:
     {
       "today_iso": "2026-09-22",
       "cycle_day": 2,
+      "timezone": "Pacific/Auckland",
       "children": [
         {
           "child_id": 1,
@@ -45,7 +46,11 @@ panel payload), and returns the documented JSON shape:
 active children ``ORDER BY sort_order, id``); ``state`` is the
 documented panel spelling ``open`` | ``completed`` (§1 of
 design/ENTITIES-AND-SERVICES.md); ``cycle_day`` is today's 1-based day
-in the first scheduled child's custody cycle (0 when no child has one).
+in the first scheduled child's custody cycle (0 when no child has one);
+``timezone`` is the effective application timezone — the zone the admin
+stored, or the API host's own zone when none is (``""`` only when the
+host's zone cannot be named; :mod:`api.host_zone`) — which the panel
+cards format their visible date and clock in.
 The same :class:`PanelSnapshotResponse` Pydantic model is the route's
 ``response_model``, so the OpenAPI document carries the shape too.
 """
@@ -66,6 +71,7 @@ from api.nestquest_core import (
     core_settings_store,
     core_snapshot,
 )
+from api import host_zone
 from api import transitions as api_transitions
 from api.sse import transition_event_stream
 
@@ -126,12 +132,14 @@ class PanelSnapshotResponse(BaseModel):
 
     ``today_iso`` anchors the payload's day; ``cycle_day`` is today's
     1-based day in the first scheduled child's custody cycle (0 when no
-    child has a schedule); ``children`` is in the household's sort
-    order.
+    child has a schedule); ``timezone`` is the effective application
+    timezone (:func:`api.host_zone.effective_timezone`); ``children`` is
+    in the household's sort order.
     """
 
     today_iso: str
     cycle_day: int
+    timezone: str
     children: list[PanelChildPayload]
 
 
@@ -218,6 +226,7 @@ async def panel_snapshot(request: Request) -> PanelSnapshotResponse:
     return PanelSnapshotResponse(
         today_iso=snapshot.today_iso,
         cycle_day=snapshot.cycle_day,
+        timezone=host_zone.effective_timezone(snapshot.timezone),
         children=[
             PanelChildPayload(
                 child_id=child.child_id,
diff --git a/api/scheduler.py b/api/scheduler.py
index f31d4f4..e0e4769 100644
--- a/api/scheduler.py
+++ b/api/scheduler.py
@@ -22,7 +22,8 @@ it planned with has moved, and the loop re-reads the settings before
 sweeping and re-plans instead if they no longer match its plan.
 
 Guarantee: no sweep runs for a plan a committed settings write has
-replaced.  A settings writer holds :attr:`MissedSweepScheduler.settings_lock`
+replaced.  The settings writer — the admin ``PATCH /api/v1/admin/settings``
+route, the only one — holds :attr:`MissedSweepScheduler.settings_lock`
 across its write AND its :meth:`~MissedSweepScheduler.settings_changed`
 call; the loop holds the same lock across its plan read (read, record
 the plan, clear the wake flag) and across the pre-sweep re-read plus
diff --git a/custom_components/nestquest/coordinator.py b/custom_components/nestquest/coordinator.py
index 22cbb24..9e152f4 100644
--- a/custom_components/nestquest/coordinator.py
+++ b/custom_components/nestquest/coordinator.py
@@ -111,6 +111,9 @@ def snapshot_from_api_payload(payload: dict[str, Any]) -> NestQuestSnapshot:
       through verbatim;
     - ``present`` and ``next_present`` pass through verbatim (the API
       resolved them through the same presence engine server-side);
+    - ``timezone`` (the API's effective application timezone) passes
+      through verbatim for the cards' date and clock; an API older than
+      the field omits it, which reads as ``""`` (the cards' fallback);
     - the instance list is rebuilt IN ORDER, so the panel payload the
       sensors emit matches the route's order byte for byte.
 
@@ -161,6 +164,7 @@ def snapshot_from_api_payload(payload: dict[str, Any]) -> NestQuestSnapshot:
         today_iso=payload["today_iso"],
         children=tuple(children),
         cycle_day=payload["cycle_day"],
+        timezone=payload.get("timezone", ""),
     )
 
 
diff --git a/custom_components/nestquest/core/snapshot.py b/custom_components/nestquest/core/snapshot.py
index 88679be..7e91c8b 100644
--- a/custom_components/nestquest/core/snapshot.py
+++ b/custom_components/nestquest/core/snapshot.py
@@ -96,6 +96,11 @@ class NestQuestSnapshot:
     today_iso: str
     children: tuple[ChildDaySnapshot, ...]
     cycle_day: int
+    #: The application timezone the admin stored (``""`` when unset —
+    #: the host's local time; the API publishes its effective zone in
+    #: its place, api/host_zone.py).  The panel cards format their
+    #: visible date and clock in it; it never re-resolves the day itself.
+    timezone: str = ""
 
 
 def _cycle_day(
@@ -319,4 +324,5 @@ async def build_snapshot(
         today_iso=today_iso,
         children=tuple(snapshots),
         cycle_day=_cycle_day(patterns, children, today),
+        timezone=settings.timezone,
     )
diff --git a/custom_components/nestquest/sensor.py b/custom_components/nestquest/sensor.py
index 7bfdfc1..8c95a55 100644
--- a/custom_components/nestquest/sensor.py
+++ b/custom_components/nestquest/sensor.py
@@ -441,6 +441,10 @@ class NestQuestHouseholdDueTodaySensor(_NestQuestHouseholdSensor):
                 for child in data.children
             },
             "child_roster": _child_roster(data.children),
+            # The API's effective application timezone ("" only when
+            # it could not name one): the panel cards format their
+            # visible date and clock in it.
+            "timezone": data.timezone,
         }
 
 
diff --git a/custom_components/nestquest/www/nestquest-cards.js b/custom_components/nestquest/www/nestquest-cards.js
index c740b22..6630144 100644
--- a/custom_components/nestquest/www/nestquest-cards.js
+++ b/custom_components/nestquest/www/nestquest-cards.js
@@ -18,11 +18,11 @@ let Fe = class {
   }
 };
 const x = (i) => new Fe(typeof i == "string" ? i : i + "", void 0, de), Ve = (i, ...e) => {
-  const t = i.length === 1 ? i[0] : e.reduce((n, s, r) => n + ((a) => {
-    if (a._$cssResult$ === !0) return a.cssText;
-    if (typeof a == "number") return a;
-    throw Error("Value passed to 'css' function must be a 'css' function result: " + a + ". Use 'unsafeCSS' to pass non-literal values, but take care to ensure page security.");
-  })(s) + i[r + 1], i[0]);
+  const t = i.length === 1 ? i[0] : e.reduce((n, s, a) => n + ((r) => {
+    if (r._$cssResult$ === !0) return r.cssText;
+    if (typeof r == "number") return r;
+    throw Error("Value passed to 'css' function must be a 'css' function result: " + r + ". Use 'unsafeCSS' to pass non-literal values, but take care to ensure page security.");
+  })(s) + i[a + 1], i[0]);
   return new Fe(t, i, de);
 }, tt = (i, e) => {
   if (ce) i.adoptedStyleSheets = e.map((t) => t instanceof CSSStyleSheet ? t : t.styleSheet);
@@ -35,7 +35,7 @@ const x = (i) => new Fe(typeof i == "string" ? i : i + "", void 0, de), Ve = (i,
   for (const n of e.cssRules) t += n.cssText;
   return x(t);
 })(i) : i;
-const { is: nt, defineProperty: it, getOwnPropertyDescriptor: st, getOwnPropertyNames: rt, getOwnPropertySymbols: at, getPrototypeOf: ot } = Object, K = globalThis, _e = K.trustedTypes, lt = _e ? _e.emptyScript : "", ct = K.reactiveElementPolyfillSupport, I = (i, e) => i, re = { toAttribute(i, e) {
+const { is: nt, defineProperty: it, getOwnPropertyDescriptor: st, getOwnPropertyNames: at, getOwnPropertySymbols: rt, getPrototypeOf: ot } = Object, K = globalThis, _e = K.trustedTypes, lt = _e ? _e.emptyScript : "", ct = K.reactiveElementPolyfillSupport, I = (i, e) => i, ae = { toAttribute(i, e) {
   switch (e) {
     case Boolean:
       i = i ? lt : null;
@@ -63,9 +63,9 @@ const { is: nt, defineProperty: it, getOwnPropertyDescriptor: st, getOwnProperty
       }
   }
   return t;
-} }, Ze = (i, e) => !nt(i, e), ye = { attribute: !0, type: String, converter: re, reflect: !1, useDefault: !1, hasChanged: Ze };
+} }, Ze = (i, e) => !nt(i, e), ye = { attribute: !0, type: String, converter: ae, reflect: !1, useDefault: !1, hasChanged: Ze };
 Symbol.metadata ??= /* @__PURE__ */ Symbol("metadata"), K.litPropertyMetadata ??= /* @__PURE__ */ new WeakMap();
-let T = class extends HTMLElement {
+let z = class extends HTMLElement {
   static addInitializer(e) {
     this._$Ei(), (this.l ??= []).push(e);
   }
@@ -79,14 +79,14 @@ let T = class extends HTMLElement {
     }
   }
   static getPropertyDescriptor(e, t, n) {
-    const { get: s, set: r } = st(this.prototype, e) ?? { get() {
+    const { get: s, set: a } = st(this.prototype, e) ?? { get() {
       return this[t];
-    }, set(a) {
-      this[t] = a;
+    }, set(r) {
+      this[t] = r;
     } };
-    return { get: s, set(a) {
+    return { get: s, set(r) {
       const l = s?.call(this);
-      r?.call(this, a), this.requestUpdate(e, l, n);
+      a?.call(this, r), this.requestUpdate(e, l, n);
     }, configurable: !0, enumerable: !0 };
   }
   static getPropertyOptions(e) {
@@ -100,7 +100,7 @@ let T = class extends HTMLElement {
   static finalize() {
     if (this.hasOwnProperty(I("finalized"))) return;
     if (this.finalized = !0, this._$Ei(), this.hasOwnProperty(I("properties"))) {
-      const t = this.properties, n = [...rt(t), ...at(t)];
+      const t = this.properties, n = [...at(t), ...rt(t)];
       for (const s of n) this.createProperty(s, t[s]);
     }
     const e = this[Symbol.metadata];
@@ -162,29 +162,29 @@ let T = class extends HTMLElement {
   _$ET(e, t) {
     const n = this.constructor.elementProperties.get(e), s = this.constructor._$Eu(e, n);
     if (s !== void 0 && n.reflect === !0) {
-      const r = (n.converter?.toAttribute !== void 0 ? n.converter : re).toAttribute(t, n.type);
-      this._$Em = e, r == null ? this.removeAttribute(s) : this.setAttribute(s, r), this._$Em = null;
+      const a = (n.converter?.toAttribute !== void 0 ? n.converter : ae).toAttribute(t, n.type);
+      this._$Em = e, a == null ? this.removeAttribute(s) : this.setAttribute(s, a), this._$Em = null;
     }
   }
   _$AK(e, t) {
     const n = this.constructor, s = n._$Eh.get(e);
     if (s !== void 0 && this._$Em !== s) {
-      const r = n.getPropertyOptions(s), a = typeof r.converter == "function" ? { fromAttribute: r.converter } : r.converter?.fromAttribute !== void 0 ? r.converter : re;
+      const a = n.getPropertyOptions(s), r = typeof a.converter == "function" ? { fromAttribute: a.converter } : a.converter?.fromAttribute !== void 0 ? a.converter : ae;
       this._$Em = s;
-      const l = a.fromAttribute(t, r.type);
+      const l = r.fromAttribute(t, a.type);
       this[s] = l ?? this._$Ej?.get(s) ?? l, this._$Em = null;
     }
   }
-  requestUpdate(e, t, n, s = !1, r) {
+  requestUpdate(e, t, n, s = !1, a) {
     if (e !== void 0) {
-      const a = this.constructor;
-      if (s === !1 && (r = this[e]), n ??= a.getPropertyOptions(e), !((n.hasChanged ?? Ze)(r, t) || n.useDefault && n.reflect && r === this._$Ej?.get(e) && !this.hasAttribute(a._$Eu(e, n)))) return;
+      const r = this.constructor;
+      if (s === !1 && (a = this[e]), n ??= r.getPropertyOptions(e), !((n.hasChanged ?? Ze)(a, t) || n.useDefault && n.reflect && a === this._$Ej?.get(e) && !this.hasAttribute(r._$Eu(e, n)))) return;
       this.C(e, t, n);
     }
     this.isUpdatePending === !1 && (this._$ES = this._$EP());
   }
-  C(e, t, { useDefault: n, reflect: s, wrapped: r }, a) {
-    n && !(this._$Ej ??= /* @__PURE__ */ new Map()).has(e) && (this._$Ej.set(e, a ?? t ?? this[e]), r !== !0 || a !== void 0) || (this._$AL.has(e) || (this.hasUpdated || n || (t = void 0), this._$AL.set(e, t)), s === !0 && this._$Em !== e && (this._$Eq ??= /* @__PURE__ */ new Set()).add(e));
+  C(e, t, { useDefault: n, reflect: s, wrapped: a }, r) {
+    n && !(this._$Ej ??= /* @__PURE__ */ new Map()).has(e) && (this._$Ej.set(e, r ?? t ?? this[e]), a !== !0 || r !== void 0) || (this._$AL.has(e) || (this.hasUpdated || n || (t = void 0), this._$AL.set(e, t)), s === !0 && this._$Em !== e && (this._$Eq ??= /* @__PURE__ */ new Set()).add(e));
   }
   async _$EP() {
     this.isUpdatePending = !0;
@@ -203,13 +203,13 @@ let T = class extends HTMLElement {
     if (!this.isUpdatePending) return;
     if (!this.hasUpdated) {
       if (this.renderRoot ??= this.createRenderRoot(), this._$Ep) {
-        for (const [s, r] of this._$Ep) this[s] = r;
+        for (const [s, a] of this._$Ep) this[s] = a;
         this._$Ep = void 0;
       }
       const n = this.constructor.elementProperties;
-      if (n.size > 0) for (const [s, r] of n) {
-        const { wrapped: a } = r, l = this[s];
-        a !== !0 || this._$AL.has(s) || l === void 0 || this.C(s, void 0, r, l);
+      if (n.size > 0) for (const [s, a] of n) {
+        const { wrapped: r } = a, l = this[s];
+        r !== !0 || this._$AL.has(s) || l === void 0 || this.C(s, void 0, a, l);
       }
     }
     let e = !1;
@@ -246,7 +246,7 @@ let T = class extends HTMLElement {
   firstUpdated(e) {
   }
 };
-T.elementStyles = [], T.shadowRootOptions = { mode: "open" }, T[I("elementProperties")] = /* @__PURE__ */ new Map(), T[I("finalized")] = /* @__PURE__ */ new Map(), ct?.({ ReactiveElement: T }), (K.reactiveElementVersions ??= []).push("2.1.2");
+z.elementStyles = [], z.shadowRootOptions = { mode: "open" }, z[I("elementProperties")] = /* @__PURE__ */ new Map(), z[I("finalized")] = /* @__PURE__ */ new Map(), ct?.({ ReactiveElement: z }), (K.reactiveElementVersions ??= []).push("2.1.2");
 const pe = globalThis, be = (i) => i, V = pe.trustedTypes, ve = V ? V.createPolicy("lit-html", { createHTML: (i) => i }) : void 0, Qe = "$lit$", k = `lit$${Math.random().toFixed(9).slice(2)}$`, We = "?" + k, dt = `<${We}>`, A = document, P = () => A.createComment(""), H = (i) => i === null || typeof i != "object" && typeof i != "function", he = Array.isArray, pt = (i) => he(i) || typeof i?.[Symbol.iterator] == "function", Y = `[ 	
 \f\r]`, L = /<(?:(!--|\/[^a-zA-Z])|(\/?[a-zA-Z][^>\s]*)|(\/?$))/g, xe = /-->/g, we = />/g, $ = RegExp(`>|${Y}(?:([^\\s"'>=/]+)(${Y}*=${Y}*(?:[^ 	
 \f\r"'\`<>=]|("|')|))|$)`, "g"), ke = /'/g, $e = /"/g, Ge = /^(?:script|style|textarea|title)$/i, Ke = (i) => (e, ...t) => ({ _$litType$: i, strings: e, values: t }), d = Ke(1), qe = Ke(2), S = /* @__PURE__ */ Symbol.for("lit-noChange"), g = /* @__PURE__ */ Symbol.for("lit-nothing"), Me = /* @__PURE__ */ new WeakMap(), M = A.createTreeWalker(A, 129);
@@ -256,21 +256,21 @@ function Je(i, e) {
 }
 const ht = (i, e) => {
   const t = i.length - 1, n = [];
-  let s, r = e === 2 ? "<svg>" : e === 3 ? "<math>" : "", a = L;
+  let s, a = e === 2 ? "<svg>" : e === 3 ? "<math>" : "", r = L;
   for (let l = 0; l < t; l++) {
     const o = i[l];
     let p, u, c = -1, f = 0;
-    for (; f < o.length && (a.lastIndex = f, u = a.exec(o), u !== null); ) f = a.lastIndex, a === L ? u[1] === "!--" ? a = xe : u[1] !== void 0 ? a = we : u[2] !== void 0 ? (Ge.test(u[2]) && (s = RegExp("</" + u[2], "g")), a = $) : u[3] !== void 0 && (a = $) : a === $ ? u[0] === ">" ? (a = s ?? L, c = -1) : u[1] === void 0 ? c = -2 : (c = a.lastIndex - u[2].length, p = u[1], a = u[3] === void 0 ? $ : u[3] === '"' ? $e : ke) : a === $e || a === ke ? a = $ : a === xe || a === we ? a = L : (a = $, s = void 0);
-    const h = a === $ && i[l + 1].startsWith("/>") ? " " : "";
-    r += a === L ? o + dt : c >= 0 ? (n.push(p), o.slice(0, c) + Qe + o.slice(c) + k + h) : o + k + (c === -2 ? l : h);
+    for (; f < o.length && (r.lastIndex = f, u = r.exec(o), u !== null); ) f = r.lastIndex, r === L ? u[1] === "!--" ? r = xe : u[1] !== void 0 ? r = we : u[2] !== void 0 ? (Ge.test(u[2]) && (s = RegExp("</" + u[2], "g")), r = $) : u[3] !== void 0 && (r = $) : r === $ ? u[0] === ">" ? (r = s ?? L, c = -1) : u[1] === void 0 ? c = -2 : (c = r.lastIndex - u[2].length, p = u[1], r = u[3] === void 0 ? $ : u[3] === '"' ? $e : ke) : r === $e || r === ke ? r = $ : r === xe || r === we ? r = L : (r = $, s = void 0);
+    const h = r === $ && i[l + 1].startsWith("/>") ? " " : "";
+    a += r === L ? o + dt : c >= 0 ? (n.push(p), o.slice(0, c) + Qe + o.slice(c) + k + h) : o + k + (c === -2 ? l : h);
   }
-  return [Je(i, r + (i[t] || "<?>") + (e === 2 ? "</svg>" : e === 3 ? "</math>" : "")), n];
+  return [Je(i, a + (i[t] || "<?>") + (e === 2 ? "</svg>" : e === 3 ? "</math>" : "")), n];
 };
 class R {
   constructor({ strings: e, _$litType$: t }, n) {
     let s;
     this.parts = [];
-    let r = 0, a = 0;
+    let a = 0, r = 0;
     const l = e.length - 1, o = this.parts, [p, u] = ht(e, t);
     if (this.el = R.createElement(p, n), M.currentNode = this.el.content, t === 2 || t === 3) {
       const c = this.el.content.firstChild;
@@ -279,23 +279,23 @@ class R {
     for (; (s = M.nextNode()) !== null && o.length < l; ) {
       if (s.nodeType === 1) {
         if (s.hasAttributes()) for (const c of s.getAttributeNames()) if (c.endsWith(Qe)) {
-          const f = u[a++], h = s.getAttribute(c).split(k), m = /([.?@])?(.*)/.exec(f);
-          o.push({ type: 1, index: r, name: m[2], strings: h, ctor: m[1] === "." ? ft : m[1] === "?" ? mt : m[1] === "@" ? gt : J }), s.removeAttribute(c);
-        } else c.startsWith(k) && (o.push({ type: 6, index: r }), s.removeAttribute(c));
+          const f = u[r++], h = s.getAttribute(c).split(k), m = /([.?@])?(.*)/.exec(f);
+          o.push({ type: 1, index: a, name: m[2], strings: h, ctor: m[1] === "." ? ft : m[1] === "?" ? mt : m[1] === "@" ? gt : J }), s.removeAttribute(c);
+        } else c.startsWith(k) && (o.push({ type: 6, index: a }), s.removeAttribute(c));
         if (Ge.test(s.tagName)) {
           const c = s.textContent.split(k), f = c.length - 1;
           if (f > 0) {
             s.textContent = V ? V.emptyScript : "";
-            for (let h = 0; h < f; h++) s.append(c[h], P()), M.nextNode(), o.push({ type: 2, index: ++r });
+            for (let h = 0; h < f; h++) s.append(c[h], P()), M.nextNode(), o.push({ type: 2, index: ++a });
             s.append(c[f], P());
           }
         }
-      } else if (s.nodeType === 8) if (s.data === We) o.push({ type: 2, index: r });
+      } else if (s.nodeType === 8) if (s.data === We) o.push({ type: 2, index: a });
       else {
         let c = -1;
-        for (; (c = s.data.indexOf(k, c + 1)) !== -1; ) o.push({ type: 7, index: r }), c += k.length - 1;
+        for (; (c = s.data.indexOf(k, c + 1)) !== -1; ) o.push({ type: 7, index: a }), c += k.length - 1;
       }
-      r++;
+      a++;
     }
   }
   static createElement(e, t) {
@@ -303,11 +303,11 @@ class R {
     return n.innerHTML = e, n;
   }
 }
-function z(i, e, t = i, n) {
+function T(i, e, t = i, n) {
   if (e === S) return e;
   let s = n !== void 0 ? t._$Co?.[n] : t._$Cl;
-  const r = H(e) ? void 0 : e._$litDirective$;
-  return s?.constructor !== r && (s?._$AO?.(!1), r === void 0 ? s = void 0 : (s = new r(i), s._$AT(i, t, n)), n !== void 0 ? (t._$Co ??= [])[n] = s : t._$Cl = s), s !== void 0 && (e = z(i, s._$AS(i, e.values), s, n)), e;
+  const a = H(e) ? void 0 : e._$litDirective$;
+  return s?.constructor !== a && (s?._$AO?.(!1), a === void 0 ? s = void 0 : (s = new a(i), s._$AT(i, t, n)), n !== void 0 ? (t._$Co ??= [])[n] = s : t._$Cl = s), s !== void 0 && (e = T(i, s._$AS(i, e.values), s, n)), e;
 }
 class ut {
   constructor(e, t) {
@@ -322,13 +322,13 @@ class ut {
   u(e) {
     const { el: { content: t }, parts: n } = this._$AD, s = (e?.creationScope ?? A).importNode(t, !0);
     M.currentNode = s;
-    let r = M.nextNode(), a = 0, l = 0, o = n[0];
+    let a = M.nextNode(), r = 0, l = 0, o = n[0];
     for (; o !== void 0; ) {
-      if (a === o.index) {
+      if (r === o.index) {
         let p;
-        o.type === 2 ? p = new N(r, r.nextSibling, this, e) : o.type === 1 ? p = new o.ctor(r, o.name, o.strings, this, e) : o.type === 6 && (p = new _t(r, this, e)), this._$AV.push(p), o = n[++l];
+        o.type === 2 ? p = new N(a, a.nextSibling, this, e) : o.type === 1 ? p = new o.ctor(a, o.name, o.strings, this, e) : o.type === 6 && (p = new _t(a, this, e)), this._$AV.push(p), o = n[++l];
       }
-      a !== o?.index && (r = M.nextNode(), a++);
+      r !== o?.index && (a = M.nextNode(), r++);
     }
     return M.currentNode = A, s;
   }
@@ -356,7 +356,7 @@ class N {
     return this._$AB;
   }
   _$AI(e, t = this) {
-    e = z(this, e, t), H(e) ? e === g || e == null || e === "" ? (this._$AH !== g && this._$AR(), this._$AH = g) : e !== this._$AH && e !== S && this._(e) : e._$litType$ !== void 0 ? this.$(e) : e.nodeType !== void 0 ? this.T(e) : pt(e) ? this.k(e) : this._(e);
+    e = T(this, e, t), H(e) ? e === g || e == null || e === "" ? (this._$AH !== g && this._$AR(), this._$AH = g) : e !== this._$AH && e !== S && this._(e) : e._$litType$ !== void 0 ? this.$(e) : e.nodeType !== void 0 ? this.T(e) : pt(e) ? this.k(e) : this._(e);
   }
   O(e) {
     return this._$AA.parentNode.insertBefore(e, this._$AB);
@@ -371,8 +371,8 @@ class N {
     const { values: t, _$litType$: n } = e, s = typeof n == "number" ? this._$AC(e) : (n.el === void 0 && (n.el = R.createElement(Je(n.h, n.h[0]), this.options)), n);
     if (this._$AH?._$AD === s) this._$AH.p(t);
     else {
-      const r = new ut(s, this), a = r.u(this.options);
-      r.p(t), this.T(a), this._$AH = r;
+      const a = new ut(s, this), r = a.u(this.options);
+      a.p(t), this.T(r), this._$AH = a;
     }
   }
   _$AC(e) {
@@ -383,7 +383,7 @@ class N {
     he(this._$AH) || (this._$AH = [], this._$AR());
     const t = this._$AH;
     let n, s = 0;
-    for (const r of e) s === t.length ? t.push(n = new N(this.O(P()), this.O(P()), this, this.options)) : n = t[s], n._$AI(r), s++;
+    for (const a of e) s === t.length ? t.push(n = new N(this.O(P()), this.O(P()), this, this.options)) : n = t[s], n._$AI(a), s++;
     s < t.length && (this._$AR(n && n._$AB.nextSibling, s), t.length = s);
   }
   _$AR(e = this._$AA.nextSibling, t) {
@@ -403,19 +403,19 @@ class J {
   get _$AU() {
     return this._$AM._$AU;
   }
-  constructor(e, t, n, s, r) {
-    this.type = 1, this._$AH = g, this._$AN = void 0, this.element = e, this.name = t, this._$AM = s, this.options = r, n.length > 2 || n[0] !== "" || n[1] !== "" ? (this._$AH = Array(n.length - 1).fill(new String()), this.strings = n) : this._$AH = g;
+  constructor(e, t, n, s, a) {
+    this.type = 1, this._$AH = g, this._$AN = void 0, this.element = e, this.name = t, this._$AM = s, this.options = a, n.length > 2 || n[0] !== "" || n[1] !== "" ? (this._$AH = Array(n.length - 1).fill(new String()), this.strings = n) : this._$AH = g;
   }
   _$AI(e, t = this, n, s) {
-    const r = this.strings;
-    let a = !1;
-    if (r === void 0) e = z(this, e, t, 0), a = !H(e) || e !== this._$AH && e !== S, a && (this._$AH = e);
+    const a = this.strings;
+    let r = !1;
+    if (a === void 0) e = T(this, e, t, 0), r = !H(e) || e !== this._$AH && e !== S, r && (this._$AH = e);
     else {
       const l = e;
       let o, p;
-      for (e = r[0], o = 0; o < r.length - 1; o++) p = z(this, l[n + o], t, o), p === S && (p = this._$AH[o]), a ||= !H(p) || p !== this._$AH[o], p === g ? e = g : e !== g && (e += (p ?? "") + r[o + 1]), this._$AH[o] = p;
+      for (e = a[0], o = 0; o < a.length - 1; o++) p = T(this, l[n + o], t, o), p === S && (p = this._$AH[o]), r ||= !H(p) || p !== this._$AH[o], p === g ? e = g : e !== g && (e += (p ?? "") + a[o + 1]), this._$AH[o] = p;
     }
-    a && !s && this.j(e);
+    r && !s && this.j(e);
   }
   j(e) {
     e === g ? this.element.removeAttribute(this.name) : this.element.setAttribute(this.name, e ?? "");
@@ -438,13 +438,13 @@ class mt extends J {
   }
 }
 class gt extends J {
-  constructor(e, t, n, s, r) {
-    super(e, t, n, s, r), this.type = 5;
+  constructor(e, t, n, s, a) {
+    super(e, t, n, s, a), this.type = 5;
   }
   _$AI(e, t = this) {
-    if ((e = z(this, e, t, 0) ?? g) === S) return;
-    const n = this._$AH, s = e === g && n !== g || e.capture !== n.capture || e.once !== n.once || e.passive !== n.passive, r = e !== g && (n === g || s);
-    s && this.element.removeEventListener(this.name, this, n), r && this.element.addEventListener(this.name, this, e), this._$AH = e;
+    if ((e = T(this, e, t, 0) ?? g) === S) return;
+    const n = this._$AH, s = e === g && n !== g || e.capture !== n.capture || e.once !== n.once || e.passive !== n.passive, a = e !== g && (n === g || s);
+    s && this.element.removeEventListener(this.name, this, n), a && this.element.addEventListener(this.name, this, e), this._$AH = e;
   }
   handleEvent(e) {
     typeof this._$AH == "function" ? this._$AH.call(this.options?.host ?? this.element, e) : this._$AH.handleEvent(e);
@@ -458,7 +458,7 @@ class _t {
     return this._$AM._$AU;
   }
   _$AI(e) {
-    z(this, e);
+    T(this, e);
   }
 }
 const yt = { I: N }, bt = pe.litHtmlPolyfillSupport;
@@ -467,13 +467,13 @@ const vt = (i, e, t) => {
   const n = t?.renderBefore ?? e;
   let s = n._$litPart$;
   if (s === void 0) {
-    const r = t?.renderBefore ?? null;
-    n._$litPart$ = s = new N(e.insertBefore(P(), r), r, void 0, t ?? {});
+    const a = t?.renderBefore ?? null;
+    n._$litPart$ = s = new N(e.insertBefore(P(), a), a, void 0, t ?? {});
   }
   return s._$AI(i), s;
 };
 const ue = globalThis;
-let C = class extends T {
+let C = class extends z {
   constructor() {
     super(...arguments), this.renderOptions = { host: this }, this._$Do = void 0;
   }
@@ -592,7 +592,7 @@ function Ct(i) {
 function Se(i) {
   return Number.isFinite(i) ? Math.min(100, Math.max(0, i)) : 0;
 }
-function Te(i) {
+function ze(i) {
   return Math.max(0, Math.round(i));
 }
 function At(i) {
@@ -607,9 +607,9 @@ function St(i, e) {
     minute: "2-digit",
     second: "2-digit",
     hourCycle: "h23"
-  }).formatToParts(new Date(i)), n = (r) => {
-    const a = t.find((l) => l.type === r);
-    return a ? Number(a.value) : Number.NaN;
+  }).formatToParts(new Date(i)), n = (a) => {
+    const r = t.find((l) => l.type === a);
+    return r ? Number(r.value) : Number.NaN;
   }, s = Date.UTC(
     n("year"),
     n("month") - 1,
@@ -620,30 +620,30 @@ function St(i, e) {
   );
   return Number.isFinite(s) ? s - i : 0;
 }
-function Tt(i, e) {
+function zt(i, e) {
   if (typeof i != "string")
     return null;
   const t = i.split("-");
   if (t.length !== 3)
     return null;
-  const [n, s, r] = t.map((o) => Number(o));
-  if (!n || !s || !r)
+  const [n, s, a] = t.map((o) => Number(o));
+  if (!n || !s || !a)
     return null;
   if (!e) {
-    const o = new Date(n, s - 1, r);
+    const o = new Date(n, s - 1, a);
     return Number.isNaN(o.getTime()) ? null : o;
   }
-  const a = Date.UTC(n, s - 1, r), l = new Date(a - St(a, e));
+  const r = Date.UTC(n, s - 1, a), l = new Date(r - St(r, e));
   return Number.isNaN(l.getTime()) ? null : l;
 }
-function zt(i) {
+function Tt(i) {
   const e = qt[i];
   return e || i.charAt(0).toUpperCase() + i.slice(1);
 }
 function Et(i, e) {
   return Mt[i] ?? e;
 }
-const ze = "polygon(0 0, 100% 0, 100% 62%, 50% 100%, 0 62%)", Ee = "M50 3 44.5 24.1 50 26 55.5 24.1Z M100 50 75.9 44.5 74 50 75.9 55.5Z M50 97 55.5 75.9 50 74 44.5 75.9Z M0 50 24.1 55.5 26 50 24.1 44.5Z M29.1 29.1 29.7 36.3 36.3 29.7Z M70.9 29.1 63.7 29.7 70.3 36.3Z M70.9 70.9 70.3 63.7 63.7 70.3Z M29.1 70.9 36.3 70.3 29.7 63.7Z", Nt = "M50 26.5 70.4 38.2 70.4 61.8 50 73.5 29.6 61.8 29.6 38.2Z", Lt = "M29.6 38.2H70.4M29.6 61.8H70.4M50 26.5 36.5 38.2M50 26.5 63.5 38.2M50 73.5 36.5 61.8M50 73.5 63.5 61.8M36.5 38.2V61.8M63.5 38.2V61.8M29.6 38.2 36.5 61.8M36.5 38.2 29.6 61.8M70.4 38.2 63.5 61.8M63.5 38.2 70.4 61.8", Ot = d`<svg
+const Te = "polygon(0 0, 100% 0, 100% 62%, 50% 100%, 0 62%)", Ee = "M50 3 44.5 24.1 50 26 55.5 24.1Z M100 50 75.9 44.5 74 50 75.9 55.5Z M50 97 55.5 75.9 50 74 44.5 75.9Z M0 50 24.1 55.5 26 50 24.1 44.5Z M29.1 29.1 29.7 36.3 36.3 29.7Z M70.9 29.1 63.7 29.7 70.3 36.3Z M70.9 70.9 70.3 63.7 63.7 70.3Z M29.1 70.9 36.3 70.3 29.7 63.7Z", Nt = "M50 26.5 70.4 38.2 70.4 61.8 50 73.5 29.6 61.8 29.6 38.2Z", Lt = "M29.6 38.2H70.4M29.6 61.8H70.4M50 26.5 36.5 38.2M50 26.5 63.5 38.2M50 73.5 36.5 61.8M50 73.5 63.5 61.8M36.5 38.2V61.8M63.5 38.2V61.8M29.6 38.2 36.5 61.8M36.5 38.2 29.6 61.8M70.4 38.2 63.5 61.8M63.5 38.2 70.4 61.8", Ot = d`<svg
   class="monogram"
   viewBox="0 0 100 100"
   aria-hidden="true"
@@ -850,7 +850,7 @@ const ze = "polygon(0 0, 100% 0, 100% 62%, 50% 100%, 0 62%)", Ee = "M50 3 44.5 2
     width: 188px;
     height: 214px;
     padding: 4px;
-    clip-path: ${x(ze)};
+    clip-path: ${x(Te)};
     background: rgba(255, 255, 255, 0.22);
   }
 
@@ -861,7 +861,7 @@ const ze = "polygon(0 0, 100% 0, 100% 62%, 50% 100%, 0 62%)", Ee = "M50 3 44.5 2
     align-items: center;
     justify-content: center;
     padding-bottom: 70px;
-    clip-path: ${x(ze)};
+    clip-path: ${x(Te)};
     background: var(--nq-p-crest);
   }
 
@@ -1180,8 +1180,8 @@ const ze = "polygon(0 0, 100% 0, 100% 62%, 50% 100%, 0 62%)", Ee = "M50 3 44.5 2
       return;
     this._subscribed = !0;
     const t = ++this._subGeneration, n = (s) => {
-      s.then((r) => {
-        this._subscribed && t === this._subGeneration ? this._unsubs.push(r) : r();
+      s.then((a) => {
+        this._subscribed && t === this._subGeneration ? this._unsubs.push(a) : a();
       }).catch(() => {
         t === this._subGeneration && (this._unsubscribeLive(), this._armSubscribeRetry());
       });
@@ -1243,8 +1243,15 @@ const ze = "polygon(0 0, 100% 0, 100% 62%, 50% 100%, 0 62%)", Ee = "M50 3 44.5 2
       </div>
     `;
   }
+  /** The zone the visible date and clock render in: the API's effective
+   *  application timezone — the stored zone, or the API host's when none
+   *  is stored (published on the household rollup by
+   *  custom_components/nestquest/sensor.py — ``timezone``).  Only when the
+   *  rollup carries none does Home Assistant's zone (or the browser's)
+   *  apply. */
   _timeZone() {
-    return kt(this.hass);
+    const e = this._state("sensor.nestquest_household_quests_due_today")?.attributes?.timezone;
+    return typeof e == "string" && e.trim() ? e.trim() : kt(this.hass);
   }
   _state(e) {
     const n = this.hass?.states?.[e];
@@ -1276,25 +1283,25 @@ const ze = "polygon(0 0, 100% 0, 100% 62%, 50% 100%, 0 62%)", Ee = "M50 3 44.5 2
   _plate(e) {
     const t = this._dueSensorResolution(e), n = this._state(`sensor.nestquest_${e}_quests_due_today`), s = this._state(
       `sensor.nestquest_${e}_quests_completed_today`
-    ), r = this._state(
-      `sensor.nestquest_${e}_completion_pct_today`
     ), a = this._state(
+      `sensor.nestquest_${e}_completion_pct_today`
+    ), r = this._state(
       `binary_sensor.nestquest_${e}_present_today`
-    ), l = n?.attributes ?? {}, o = Te(te(n?.state, 0)), p = Te(te(s?.state, 0)), u = r ? te(r.state, Number.NaN) : Number.NaN, c = Number.isFinite(u) ? Se(u) : o > 0 ? Se(p / o * 100) : 0;
+    ), l = n?.attributes ?? {}, o = ze(te(n?.state, 0)), p = ze(te(s?.state, 0)), u = a ? te(a.state, Number.NaN) : Number.NaN, c = Number.isFinite(u) ? Se(u) : o > 0 ? Se(p / o * 100) : 0;
     let f = !0;
     const h = l.present;
-    typeof h == "boolean" ? f = h : a && (f = String(a.state ?? "").trim().toLowerCase() === "on");
+    typeof h == "boolean" ? f = h : r && (f = String(r.state ?? "").trim().toLowerCase() === "on");
     let m = "";
     const _ = l.child_name;
     if (typeof _ == "string" && _.trim())
       m = _.trim();
     else {
-      const X = a?.attributes?.child_name;
+      const X = r?.attributes?.child_name;
       typeof X == "string" && X.trim() && (m = X.trim());
     }
     m || (m = At(e));
-    const v = Tt(
-      a?.attributes?.next_present,
+    const v = zt(
+      r?.attributes?.next_present,
       this._timeZone()
     ), U = v ? `Returns ${ee(v, this._timeZone())}` : null;
     return {
@@ -1407,20 +1414,20 @@ const ze = "polygon(0 0, 100% 0, 100% 62%, 50% 100%, 0 62%)", Ee = "M50 3 44.5 2
     if (!n || n === "unavailable" || n === "unknown")
       return null;
     const s = t.attributes ?? {};
-    let r = null, a = null;
+    let a = null, r = null;
     const l = s.forecast;
     if (Array.isArray(l) && l.length > 0) {
       const o = l[0];
       if (o && typeof o == "object") {
         const p = o;
-        r = this._optionalNumber(p.temperature), a = this._optionalNumber(p.templow);
+        a = this._optionalNumber(p.temperature), r = this._optionalNumber(p.templow);
       }
     }
     return {
       condition: n,
       temperature: this._optionalNumber(s.temperature),
-      high: r,
-      low: a
+      high: a,
+      low: r
     };
   }
   _optionalNumber(e) {
@@ -1439,14 +1446,14 @@ const ze = "polygon(0 0, 100% 0, 100% 62%, 50% 100%, 0 62%)", Ee = "M50 3 44.5 2
           <span class="clock">${$t(this._now, this._timeZone())}</span>
         </div>
       `;
-    const t = zt(e.condition), n = Et(e.condition, t), s = e.temperature === null ? g : d`<span class="temp">${Math.round(e.temperature)}°</span>`, r = e.high === null || e.low === null ? null : `${Math.round(e.high)}° / ${Math.round(e.low)}°`;
+    const t = Tt(e.condition), n = Et(e.condition, t), s = e.temperature === null ? g : d`<span class="temp">${Math.round(e.temperature)}°</span>`, a = e.high === null || e.low === null ? null : `${Math.round(e.high)}° / ${Math.round(e.low)}°`;
     return d`
       <div class="dock">
         ${Dt}
         ${s}
         <span class="divider"></span>
         <span class="condition">
-          ${r === null ? t : `${t} · ${r}`}
+          ${a === null ? t : `${t} · ${a}`}
         </span>
         <span class="divider"></span>
         <span class="condition">${n}</span>
@@ -1459,8 +1466,8 @@ Q.properties = {
   _config: { state: !0 },
   _now: { state: !0 }
 }, Q.styles = [x(Xe), Bt];
-let ae = Q;
-customElements.define("nestquest-party-board-card", ae);
+let re = Q;
+customElements.define("nestquest-party-board-card", re);
 fe({
   type: "nestquest-party-board-card",
   name: "NestQuest Party Board",
@@ -1486,17 +1493,17 @@ let Zt = class {
 const { I: Qt } = yt, Le = (i) => i, Oe = () => document.createComment(""), O = (i, e, t) => {
   const n = i._$AA.parentNode, s = e === void 0 ? i._$AB : e._$AA;
   if (t === void 0) {
-    const r = n.insertBefore(Oe(), s), a = n.insertBefore(Oe(), s);
-    t = new Qt(r, a, i, i.options);
+    const a = n.insertBefore(Oe(), s), r = n.insertBefore(Oe(), s);
+    t = new Qt(a, r, i, i.options);
   } else {
-    const r = t._$AB.nextSibling, a = t._$AM, l = a !== i;
+    const a = t._$AB.nextSibling, r = t._$AM, l = r !== i;
     if (l) {
       let o;
-      t._$AQ?.(i), t._$AM = i, t._$AP !== void 0 && (o = i._$AU) !== a._$AU && t._$AP(o);
+      t._$AQ?.(i), t._$AM = i, t._$AP !== void 0 && (o = i._$AU) !== r._$AU && t._$AP(o);
     }
-    if (r !== s || l) {
+    if (a !== s || l) {
       let o = t._$AA;
-      for (; o !== r; ) {
+      for (; o !== a; ) {
         const p = Le(o).nextSibling;
         Le(n).insertBefore(o, s), o = p;
       }
@@ -1517,43 +1524,43 @@ const Be = (i, e, t) => {
   dt(i, e, t) {
     let n;
     t === void 0 ? t = e : e !== void 0 && (n = e);
-    const s = [], r = [];
-    let a = 0;
-    for (const l of i) s[a] = n ? n(l, a) : a, r[a] = t(l, a), a++;
-    return { values: r, keys: s };
+    const s = [], a = [];
+    let r = 0;
+    for (const l of i) s[r] = n ? n(l, r) : r, a[r] = t(l, r), r++;
+    return { values: a, keys: s };
   }
   render(i, e, t) {
     return this.dt(i, e, t).values;
   }
   update(i, [e, t, n]) {
-    const s = Kt(i), { values: r, keys: a } = this.dt(e, t, n);
-    if (!Array.isArray(s)) return this.ut = a, r;
+    const s = Kt(i), { values: a, keys: r } = this.dt(e, t, n);
+    if (!Array.isArray(s)) return this.ut = r, a;
     const l = this.ut ??= [], o = [];
-    let p, u, c = 0, f = s.length - 1, h = 0, m = r.length - 1;
+    let p, u, c = 0, f = s.length - 1, h = 0, m = a.length - 1;
     for (; c <= f && h <= m; ) if (s[c] === null) c++;
     else if (s[f] === null) f--;
-    else if (l[c] === a[h]) o[h] = q(s[c], r[h]), c++, h++;
-    else if (l[f] === a[m]) o[m] = q(s[f], r[m]), f--, m--;
-    else if (l[c] === a[m]) o[m] = q(s[c], r[m]), O(i, o[m + 1], s[c]), c++, m--;
-    else if (l[f] === a[h]) o[h] = q(s[f], r[h]), O(i, s[c], s[f]), f--, h++;
-    else if (p === void 0 && (p = Be(a, h, m), u = Be(l, c, f)), p.has(l[c])) if (p.has(l[f])) {
-      const _ = u.get(a[h]), v = _ !== void 0 ? s[_] : null;
+    else if (l[c] === r[h]) o[h] = q(s[c], a[h]), c++, h++;
+    else if (l[f] === r[m]) o[m] = q(s[f], a[m]), f--, m--;
+    else if (l[c] === r[m]) o[m] = q(s[c], a[m]), O(i, o[m + 1], s[c]), c++, m--;
+    else if (l[f] === r[h]) o[h] = q(s[f], a[h]), O(i, s[c], s[f]), f--, h++;
+    else if (p === void 0 && (p = Be(r, h, m), u = Be(l, c, f)), p.has(l[c])) if (p.has(l[f])) {
+      const _ = u.get(r[h]), v = _ !== void 0 ? s[_] : null;
       if (v === null) {
         const U = O(i, s[c]);
-        q(U, r[h]), o[h] = U;
-      } else o[h] = q(v, r[h]), O(i, s[c], v), s[_] = null;
+        q(U, a[h]), o[h] = U;
+      } else o[h] = q(v, a[h]), O(i, s[c], v), s[_] = null;
       h++;
     } else ne(s[f]), f--;
     else ne(s[c]), c++;
     for (; h <= m; ) {
       const _ = O(i, o[m + 1]);
-      q(_, r[h]), o[h++] = _;
+      q(_, a[h]), o[h++] = _;
     }
     for (; c <= f; ) {
       const _ = s[c++];
       _ !== null && ne(_);
     }
-    return this.ut = a, Gt(i, o), S;
+    return this.ut = r, Gt(i, o), S;
   }
 }), Jt = [
   {
@@ -2289,7 +2296,7 @@ function sn(i, e) {
       return e;
   }
 }
-const rn = [
+const an = [
   "nestquest_quest_completed",
   "nestquest_quest_uncompleted",
   "nestquest_quest_missed",
@@ -2310,7 +2317,7 @@ function E(i, e) {
   }
   return He.set(t, s), s;
 }
-function an(i) {
+function rn(i) {
   const e = i?.config;
   if (!e || typeof e != "object")
     return;
@@ -2350,13 +2357,6 @@ function dn(i) {
   const n = t >= 12 ? "PM" : "AM";
   return `${t % 12 === 0 ? 12 : t % 12}:${e[2]} ${n}`;
 }
-function pn(i) {
-  const e = i ? /^(\d{1,2}):(\d{2})$/.exec(i.trim()) : null;
-  if (!e)
-    return null;
-  const t = Number(e[1]), n = Number(e[2]);
-  return t > 23 || n > 59 ? null : t * 60 + n;
-}
 function w(i) {
   return typeof i == "string" ? i.trim() : "";
 }
@@ -2372,7 +2372,7 @@ function b(i) {
 function ie(i) {
   return i.split(/[-_]+/).filter(Boolean).map((e) => e.charAt(0).toUpperCase() + e.slice(1)).join(" ");
 }
-function hn(i, e) {
+function pn(i, e) {
   const t = E(e, {
     year: "numeric",
     month: "2-digit",
@@ -2381,9 +2381,9 @@ function hn(i, e) {
     minute: "2-digit",
     second: "2-digit",
     hourCycle: "h23"
-  }).formatToParts(new Date(i)), n = (r) => {
-    const a = t.find((l) => l.type === r);
-    return a ? Number(a.value) : Number.NaN;
+  }).formatToParts(new Date(i)), n = (a) => {
+    const r = t.find((l) => l.type === a);
+    return r ? Number(r.value) : Number.NaN;
   }, s = Date.UTC(
     n("year"),
     n("month") - 1,
@@ -2400,21 +2400,21 @@ function Re(i, e) {
   const t = i.split("-");
   if (t.length !== 3)
     return null;
-  const [n, s, r] = t.map((o) => Number(o));
-  if (!n || !s || !r)
+  const [n, s, a] = t.map((o) => Number(o));
+  if (!n || !s || !a)
     return null;
   if (!e) {
-    const o = new Date(n, s - 1, r);
+    const o = new Date(n, s - 1, a);
     return Number.isNaN(o.getTime()) ? null : o;
   }
-  const a = Date.UTC(n, s - 1, r), l = new Date(a - hn(a, e));
+  const r = Date.UTC(n, s - 1, a), l = new Date(r - pn(r, e));
   return Number.isNaN(l.getTime()) ? null : l;
 }
-function un() {
+function hn() {
   const i = window.location.pathname.split("/").filter(Boolean);
   return i.length > 0 ? i[i.length - 1].toLowerCase() : "";
 }
-function fn(i) {
+function un(i) {
   if (!i || typeof i != "object")
     return null;
   const e = i, t = w(e.state).toLowerCase();
@@ -2432,11 +2432,12 @@ function fn(i) {
     window: w(e.window).toLowerCase(),
     due_time: w(e.due_time) || null,
     state: t,
+    overdue: e.overdue === !0,
     completed_at: w(e.completed_at) || null,
     on_time: e.on_time === !0 ? !0 : e.on_time === !1 ? !1 : null
   };
 }
-const mn = {
+const fn = {
   "clear-night": "Clear",
   cloudy: "Cloudy",
   exceptional: "Clear",
@@ -2452,7 +2453,7 @@ const mn = {
   sunny: "Sunny",
   windy: "Windy",
   "windy-variant": "Windy"
-}, gn = {
+}, mn = {
   "clear-night": "Clear night skies",
   cloudy: "Grey skies today",
   exceptional: "A striking day",
@@ -2469,14 +2470,14 @@ const mn = {
   windy: "A blustery day",
   "windy-variant": "A blustery day"
 };
-function _n(i) {
-  const e = mn[i];
+function gn(i) {
+  const e = fn[i];
   return e || i.charAt(0).toUpperCase() + i.slice(1);
 }
-function yn(i, e) {
-  return gn[i] ?? e;
+function _n(i, e) {
+  return mn[i] ?? e;
 }
-const Ue = "polygon(0 0, 100% 0, 100% 62%, 50% 100%, 0 62%)", bn = "polygon(50% 0, 93% 25%, 93% 75%, 50% 100%, 7% 75%, 7% 25%)", je = [-9, 6, -4], vn = Ve`
+const Ue = "polygon(0 0, 100% 0, 100% 62%, 50% 100%, 0 62%)", yn = "polygon(50% 0, 93% 25%, 93% 75%, 50% 100%, 7% 75%, 7% 25%)", je = [-9, 6, -4], bn = Ve`
   * {
     box-sizing: border-box;
   }
@@ -2644,7 +2645,7 @@ const Ue = "polygon(0 0, 100% 0, 100% 62%, 50% 100%, 0 62%)", bn = "polygon(50%
     justify-content: center;
     width: 44px;
     height: 44px;
-    clip-path: ${x(bn)};
+    clip-path: ${x(yn)};
     background: var(--nq-brand-gradient);
   }
 
@@ -3369,7 +3370,7 @@ const Ue = "polygon(0 0, 100% 0, 100% 62%, 50% 100%, 0 62%)", bn = "polygon(50%
   aria-hidden="true"
 >
   <path d="M20 6 9 17l-5-5"></path>
-</svg>`, xn = d`<svg
+</svg>`, vn = d`<svg
   viewBox="0 0 24 24"
   fill="none"
   stroke="currentColor"
@@ -3380,7 +3381,7 @@ const Ue = "polygon(0 0, 100% 0, 100% 62%, 50% 100%, 0 62%)", bn = "polygon(50%
 >
   <path d="M18 6 6 18"></path>
   <path d="m6 6 12 12"></path>
-</svg>`, wn = d`<svg
+</svg>`, xn = d`<svg
   viewBox="0 0 24 24"
   fill="none"
   stroke="currentColor"
@@ -3402,7 +3403,7 @@ const Ue = "polygon(0 0, 100% 0, 100% 62%, 50% 100%, 0 62%)", bn = "polygon(50%
   <polygon
     points="12 2 15.09 8.26 22 9.27 17 14.14 18.18 21.02 12 17.77 5.82 21.02 7 14.14 2 9.27 8.91 8.26"
   ></polygon>
-</svg>`, kn = d`<svg
+</svg>`, wn = d`<svg
   viewBox="0 0 24 24"
   fill="none"
   stroke="currentColor"
@@ -3437,7 +3438,7 @@ const Ue = "polygon(0 0, 100% 0, 100% 62%, 50% 100%, 0 62%)", bn = "polygon(50%
   <path d="M20 12h2"></path>
   <path d="m6.34 17.66-1.41 1.41"></path>
   <path d="m19.07 4.93-1.41 1.41"></path>
-</svg>`, $n = d`<svg
+</svg>`, kn = d`<svg
   viewBox="0 0 24 24"
   fill="none"
   stroke="currentColor"
@@ -3447,7 +3448,7 @@ const Ue = "polygon(0 0, 100% 0, 100% 62%, 50% 100%, 0 62%)", bn = "polygon(50%
   aria-hidden="true"
 >
   <path d="M12 3a6 6 0 0 0 9 9 9 9 0 1 1-9-9Z"></path>
-</svg>`, qn = d`<svg
+</svg>`, $n = d`<svg
   viewBox="0 0 24 24"
   fill="none"
   stroke="currentColor"
@@ -3458,7 +3459,7 @@ const Ue = "polygon(0 0, 100% 0, 100% 62%, 50% 100%, 0 62%)", bn = "polygon(50%
 >
   <path d="M3.5 21 12 3.5 20.5 21"></path>
   <path d="M9 21l3-8 3 8"></path>
-</svg>`, Mn = d`<svg
+</svg>`, qn = d`<svg
   viewBox="0 0 24 24"
   fill="none"
   stroke="currentColor"
@@ -3469,7 +3470,7 @@ const Ue = "polygon(0 0, 100% 0, 100% 62%, 50% 100%, 0 62%)", bn = "polygon(50%
 >
   <circle cx="12" cy="12" r="10"></circle>
   <polygon points="16.24 7.76 14.12 14.12 7.76 16.24 9.88 9.88 16.24 7.76"></polygon>
-</svg>`, Cn = d`<svg
+</svg>`, Mn = d`<svg
   viewBox="0 0 24 24"
   fill="none"
   stroke="currentColor"
@@ -3481,7 +3482,7 @@ const Ue = "polygon(0 0, 100% 0, 100% 62%, 50% 100%, 0 62%)", bn = "polygon(50%
   <path d="m21.73 18-8-14a2 2 0 0 0-3.48 0l-8 14A2 2 0 0 0 4 21h16a2 2 0 0 0 1.73-3Z"></path>
   <path d="M12 9v4"></path>
   <path d="M12 17h.01"></path>
-</svg>`, An = d`<svg
+</svg>`, Cn = d`<svg
   viewBox="0 0 24 24"
   fill="none"
   stroke="currentColor"
@@ -3492,7 +3493,7 @@ const Ue = "polygon(0 0, 100% 0, 100% 62%, 50% 100%, 0 62%)", bn = "polygon(50%
 >
   <path d="M17.5 19H9a7 7 0 1 1 6.71-9h1.79a4.5 4.5 0 1 1 0 9Z"></path>
   <path d="m2 2 20 20"></path>
-</svg>`, Sn = d`<svg
+</svg>`, An = d`<svg
   viewBox="0 0 24 24"
   fill="none"
   stroke="currentColor"
@@ -3503,22 +3504,22 @@ const Ue = "polygon(0 0, 100% 0, 100% 62%, 50% 100%, 0 62%)", bn = "polygon(50%
 >
   <path d="M13 16a3 3 0 1 1 0 6H7a5 5 0 1 1 4.9-6Z"></path>
   <path d="M10.1 9A6 6 0 0 1 16 4a4.5 4.5 0 0 0 8.9 4.2v.1a6 6 0 0 1-5.2 5.7"></path>
-</svg>`, Tn = {
-  icon: Mn,
+</svg>`, Sn = {
+  icon: qn,
   headline: "No adventurer chosen",
   body: "Open The Party and tap your crest to open your quest log."
 }, zn = {
-  icon: Cn,
+  icon: Mn,
   headline: "NestQuest is not set up yet",
   body: "A parent needs to finish setting up NestQuest."
-}, En = {
-  icon: An,
+}, Tn = {
+  icon: Cn,
   headline: "The records cannot be reached",
   body: "The party's records are quiet right now. NestQuest will return shortly."
 }, De = [
-  { key: "morning", name: "Morning", range: "Until 11:59 AM", icon: kn },
+  { key: "morning", name: "Morning", range: "Until 11:59 AM", icon: wn },
   { key: "afternoon", name: "Afternoon", range: "12:00–5:00 PM", icon: Ye },
-  { key: "evening", name: "Evening", range: "5:00–9:00 PM", icon: $n }
+  { key: "evening", name: "Evening", range: "5:00–9:00 PM", icon: kn }
 ], W = class W extends C {
   constructor() {
     super(...arguments), this._now = /* @__PURE__ */ new Date(), this._confirm = null, this._optimistic = /* @__PURE__ */ new Map(), this._toast = null, this._countdown = null, this._unsubs = [], this._subscribed = !1, this._subGeneration = 0, this._onActivity = () => {
@@ -3542,13 +3543,13 @@ const Ue = "polygon(0 0, 100% 0, 100% 62%, 50% 100%, 0 62%)", bn = "polygon(50%
       return;
     this._subscribed = !0;
     const t = ++this._subGeneration, n = (s) => {
-      s.then((r) => {
-        this._subscribed && t === this._subGeneration ? this._unsubs.push(r) : r();
+      s.then((a) => {
+        this._subscribed && t === this._subGeneration ? this._unsubs.push(a) : a();
       }).catch(() => {
         t === this._subGeneration && (this._unsubscribeLive(), this._armSubscribeRetry());
       });
     };
-    for (const s of rn)
+    for (const s of an)
       n(
         e.subscribeEvents(() => this.requestUpdate(), s)
       );
@@ -3601,18 +3602,18 @@ const Ue = "polygon(0 0, 100% 0, 100% 62%, 50% 100%, 0 62%)", bn = "polygon(50%
   _renderMain(e) {
     switch (e.kind) {
       case "no-adventurer":
-        return this._renderNotice(Tn);
+        return this._renderNotice(Sn);
       case "not-set-up":
         return this._renderNotice(zn);
       case "unreachable":
-        return this._renderNotice(En);
+        return this._renderNotice(Tn);
       case "away": {
         const t = ["The quest log unlocks when they return."];
         return e.returns && t.push(`Returns ${e.returns}`), d`
           ${this._renderHeader(e)}
           <div class="notice-wrap">
             <div class="notice away" role="status">
-              ${qn}
+              ${$n}
               <span class="notice-headline">${e.name} is on travels</span>
               ${t.map((n) => d`<p class="notice-body">${n}</p>`)}
             </div>
@@ -3690,8 +3691,8 @@ const Ue = "polygon(0 0, 100% 0, 100% 62%, 50% 100%, 0 62%)", bn = "polygon(50%
     const s = this._state(`binary_sensor.nestquest_${e}_all_done`);
     if (s && String(s.state ?? "").trim().toLowerCase() === "on")
       return { kind: "complete-day", name: n };
-    const r = this._state(`sensor.nestquest_${e}_quests_due_today`);
-    return b(y(r?.state, 0)) === 0 ? { kind: "empty-day", name: n } : this._remaining() === 0 ? { kind: "complete-day", name: n } : { kind: "normal" };
+    const a = this._state(`sensor.nestquest_${e}_quests_due_today`);
+    return b(y(a?.state, 0)) === 0 ? { kind: "empty-day", name: n } : this._remaining() === 0 ? { kind: "complete-day", name: n } : { kind: "normal" };
   }
   /** "missing" when the due sensor does not exist (integration not
    *  configured), "stale" when it answers unavailable/unknown (backend
@@ -3733,25 +3734,22 @@ const Ue = "polygon(0 0, 100% 0, 100% 62%, 50% 100%, 0 62%)", bn = "polygon(50%
       </div>
     `;
   }
-  /** Overdue by the panel's own clock: the browser runs on the
-      household's real local time, so an open quest turns overdue once its
-      ``due_time`` wall time has arrived there — whatever zone the API or
-      Home Assistant computed the API's ``overdue`` flag in.  With no due
-      time it is never overdue (the API's rule too).  ``_now`` is reactive
-      and ticks every 60 s, so the line flips on the minute it falls due. */
-  _isOverdue(e) {
-    const t = pn(e.due_time);
-    return e.state !== "open" || t === null ? !1 : this._now.getHours() * 60 + this._now.getMinutes() >= t;
-  }
+  /** The zone the visible date and clock render in: the API's effective
+   *  application timezone — the stored zone, or the API host's when none
+   *  is stored (published on the household rollup by
+   *  custom_components/nestquest/sensor.py — ``timezone``).  Only when the
+   *  rollup carries none does Home Assistant's zone (or the browser's)
+   *  apply. */
   _timeZone() {
-    return an(this.hass);
+    const e = this._state("sensor.nestquest_household_quests_due_today")?.attributes?.timezone;
+    return typeof e == "string" && e.trim() ? e.trim() : rn(this.hass);
   }
   _state(e) {
     const n = this.hass?.states?.[e];
     return n && typeof n == "object" ? n : null;
   }
   _childSlug() {
-    return un();
+    return hn();
   }
   _boardPath() {
     return w(this._config?.board_path).replace(/\/+$/, "");
@@ -3777,8 +3775,8 @@ const Ue = "polygon(0 0, 100% 0, 100% 62%, 50% 100%, 0 62%)", bn = "polygon(50%
   _childCounts(e) {
     const t = this._state(`sensor.nestquest_${e}_quests_due_today`), n = this._state(
       `sensor.nestquest_${e}_quests_completed_today`
-    ), s = b(y(t?.state, 0)), r = b(y(n?.state, 0));
-    return { due: s, completed: r };
+    ), s = b(y(t?.state, 0)), a = b(y(n?.state, 0));
+    return { due: s, completed: a };
   }
   _instances() {
     const e = this._childSlug();
@@ -3787,18 +3785,18 @@ const Ue = "polygon(0 0, 100% 0, 100% 62%, 50% 100%, 0 62%)", bn = "polygon(50%
     const t = this._state(`sensor.nestquest_${e}_quests_due_today`)?.attributes?.instances;
     if (!Array.isArray(t))
       return [];
-    const n = t.map(fn).filter((r) => r !== null);
+    const n = t.map(un).filter((a) => a !== null);
     if (this._optimistic.size === 0)
       return n;
     let s = !1;
-    for (const r of n) {
-      const a = this._optimistic.get(r.id);
-      if (a !== void 0) {
-        if (r.state === "completed") {
-          this._optimistic.delete(r.id), s = !0;
+    for (const a of n) {
+      const r = this._optimistic.get(a.id);
+      if (r !== void 0) {
+        if (a.state === "completed") {
+          this._optimistic.delete(a.id), s = !0;
           continue;
         }
-        r.state = "completed", r.completed_at = a;
+        a.state = "completed", a.overdue = !1, a.completed_at = r;
       }
     }
     return s && (this._optimistic = new Map(this._optimistic)), n;
@@ -3826,12 +3824,12 @@ const Ue = "polygon(0 0, 100% 0, 100% 62%, 50% 100%, 0 62%)", bn = "polygon(50%
         completed: b(y(t?.state, 0)),
         due: b(y(e?.state, 0))
       };
-    const n = this._childSlug(), { due: s, completed: r } = this._childCounts(n);
-    return { completed: r, due: s };
+    const n = this._childSlug(), { due: s, completed: a } = this._childCounts(n);
+    return { completed: a, due: s };
   }
   _completeStats() {
     const e = this._childCounts(this._childSlug()).completed, t = this._instances().filter(
-      (r) => r.on_time === !0
+      (a) => a.on_time === !0
     ).length, n = b(e - t), s = this._partyCounts();
     return {
       claimed: e,
@@ -3841,19 +3839,19 @@ const Ue = "polygon(0 0, 100% 0, 100% 62%, 50% 100%, 0 62%)", bn = "polygon(50%
     };
   }
   _completeSub(e) {
-    const t = j(this._now, this._timeZone()), { claimed: n, onTime: s, late: r } = this._completeStats();
-    return n === 0 ? `${e} sealed the day on ${t}.` : r === 0 ? `${e} claimed every quest on ${t} — all on time.` : s === 0 ? `${e} claimed every quest on ${t} — all late.` : `${e} claimed every quest on ${t} — ${s} on time, ${r} late.`;
+    const t = j(this._now, this._timeZone()), { claimed: n, onTime: s, late: a } = this._completeStats();
+    return n === 0 ? `${e} sealed the day on ${t}.` : a === 0 ? `${e} claimed every quest on ${t} — all on time.` : s === 0 ? `${e} claimed every quest on ${t} — all late.` : `${e} claimed every quest on ${t} — ${s} on time, ${a} late.`;
   }
   _otherChildren() {
     const e = this.hass?.states;
     if (!e)
       return [];
     const t = this._childSlug(), n = this._timeZone(), s = [];
-    for (const r of Object.keys(e)) {
-      const a = /^sensor\.nestquest_(.+)_quests_due_today$/.exec(r);
-      if (!a || a[1] === "household" || a[1] === t)
+    for (const a of Object.keys(e)) {
+      const r = /^sensor\.nestquest_(.+)_quests_due_today$/.exec(a);
+      if (!r || r[1] === "household" || r[1] === t)
         continue;
-      const l = a[1], o = e[r]?.attributes ?? {};
+      const l = r[1], o = e[a]?.attributes ?? {};
       let p = "";
       typeof o.child_name == "string" && o.child_name.trim() ? p = o.child_name.trim() : p = ie(l);
       let u = !0;
@@ -3867,7 +3865,7 @@ const Ue = "polygon(0 0, 100% 0, 100% 62%, 50% 100%, 0 62%)", bn = "polygon(50%
       }
       const c = this._state(
         `sensor.nestquest_${l}_quests_completed_today`
-      ), f = b(y(e[r]?.state, 0)), h = b(y(c?.state, 0));
+      ), f = b(y(e[a]?.state, 0)), h = b(y(c?.state, 0));
       let m = null;
       if (!u) {
         const _ = this._state(
@@ -3887,10 +3885,10 @@ const Ue = "polygon(0 0, 100% 0, 100% 62%, 50% 100%, 0 62%)", bn = "polygon(50%
         returnsWeekday: m
       });
     }
-    return s.sort((r, a) => r.name.localeCompare(a.name));
+    return s.sort((a, r) => a.name.localeCompare(r.name));
   }
   _renderHeader(e) {
-    const t = this._childSlug(), n = e.kind === "away", s = n ? e.name : this._childName(t) ?? (t ? ie(t) : null), { due: r, completed: a } = this._childCounts(t), l = this._remaining(), o = this._partyCounts(), p = s ? `${s}'s Quest Log` : "Quest Log", u = (s?.charAt(0) || "?").toUpperCase();
+    const t = this._childSlug(), n = e.kind === "away", s = n ? e.name : this._childName(t) ?? (t ? ie(t) : null), { due: a, completed: r } = this._childCounts(t), l = this._remaining(), o = this._partyCounts(), p = s ? `${s}'s Quest Log` : "Quest Log", u = (s?.charAt(0) || "?").toUpperCase();
     return d`
       <header class="header">
         ${this._boardPath() ? d`
@@ -3899,7 +3897,7 @@ const Ue = "polygon(0 0, 100% 0, 100% 62%, 50% 100%, 0 62%)", bn = "polygon(50%
                 type="button"
                 @click=${() => this._returnToBoard()}
               >
-                ${wn}
+                ${xn}
                 <span>The Party</span>
               </button>
             ` : g}
@@ -3912,7 +3910,7 @@ const Ue = "polygon(0 0, 100% 0, 100% 62%, 50% 100%, 0 62%)", bn = "polygon(50%
           <h1 class="title">${p}</h1>
           <p class="sub">
             ${j(this._now, this._timeZone())} ·
-            ${n ? "On travels" : `${a} of ${r} claimed`}
+            ${n ? "On travels" : `${r} of ${a} claimed`}
           </p>
         </div>
         ${n ? g : d`
@@ -3940,28 +3938,28 @@ const Ue = "polygon(0 0, 100% 0, 100% 62%, 50% 100%, 0 62%)", bn = "polygon(50%
       (l, o) => (l.due_time ?? "99:99").localeCompare(o.due_time ?? "99:99")
     ), s = t.filter(
       (l) => l.state === "completed"
-    ), r = t.length;
-    let a = g;
-    if (r > 0) {
+    ), a = t.length;
+    let r = g;
+    if (a > 0) {
       const o = 644 - (e.key === "afternoon" && this._otherChildren().length > 0 ? 160 : 0), p = Math.min(
         24,
-        Math.max(8, Math.floor((o - r * 74) / Math.max(r - 1, 1)))
+        Math.max(8, Math.floor((o - a * 74) / Math.max(a - 1, 1)))
       ), u = Math.min(
         116,
-        Math.max(58, Math.floor((o - (r - 1) * p) / r))
+        Math.max(58, Math.floor((o - (a - 1) * p) / a))
       ), c = Math.max(56, Math.min(72, u - 2));
       let f = `--nq-p-quest-gap: ${p}px; --nq-p-quest-min-height: ${u}px; --nq-p-button-height: ${c}px`;
-      if (r >= 5) {
+      if (a >= 5) {
         const h = Math.max(0, Math.min(22, Math.floor((u - c - 2) / 2))), m = Math.max(44, Math.min(64, u - 2 * h - 2));
         f += `; --nq-p-quest-pad: ${h}px; --nq-p-tile-size: ${m}px`;
       }
-      a = f;
+      r = f;
     }
     return d`
       <section
         class="column"
         aria-label="${e.name} quests"
-        style=${a}
+        style=${r}
       >
         <div class="column-head">
           ${e.icon}
@@ -3989,7 +3987,7 @@ const Ue = "polygon(0 0, 100% 0, 100% 62%, 50% 100%, 0 62%)", bn = "polygon(50%
   }
   _renderQuest(e, t, n) {
     if (t) {
-      const a = je[n % je.length], l = e.completed_at ? ln(e.completed_at, this._timeZone()) : "";
+      const r = je[n % je.length], l = e.completed_at ? ln(e.completed_at, this._timeZone()) : "";
       return d`
         <div class="quest sealed" data-instance-id=${e.id}>
           <span class="tile" aria-hidden="true">${se}</span>
@@ -4002,14 +4000,14 @@ const Ue = "polygon(0 0, 100% 0, 100% 62%, 50% 100%, 0 62%)", bn = "polygon(50%
           <span
             class="seal"
             aria-hidden="true"
-            style="--seal-rot: ${a}deg"
+            style="--seal-rot: ${r}deg"
           >
             ${D}
           </span>
         </div>
       `;
     }
-    const s = dn(e.due_time), r = this._isOverdue(e) ? {
+    const s = dn(e.due_time), a = e.overdue ? {
       text: s ? `Overdue · due ${s}` : "Overdue",
       late: !0
     } : {
@@ -4024,14 +4022,14 @@ const Ue = "polygon(0 0, 100% 0, 100% 62%, 50% 100%, 0 62%)", bn = "polygon(50%
         data-instance-id=${e.id}
         aria-label="Complete ${e.title}"
         @click=${() => this._openConfirm(e.id)}
-        @keydown=${(a) => {
-      (a.key === "Enter" || a.key === " ") && (a.preventDefault(), this._openConfirm(e.id));
+        @keydown=${(r) => {
+      (r.key === "Enter" || r.key === " ") && (r.preventDefault(), this._openConfirm(e.id));
     }}
       >
         <span class="tile" aria-hidden="true">${sn(e.icon, se)}</span>
         <div class="body">
           <span class="quest-title">${e.title}</span>
-          <span class="${r.late ? "meta late" : "meta"}">${r.text}</span>
+          <span class="${a.late ? "meta late" : "meta"}">${a.text}</span>
         </div>
         <button
           class="complete"
@@ -4092,7 +4090,7 @@ const Ue = "polygon(0 0, 100% 0, 100% 62%, 50% 100%, 0 62%)", bn = "polygon(50%
               type="button"
               @click=${() => this._closeConfirm()}
             >
-              ${xn}
+              ${vn}
               <span>Not yet</span>
             </button>
             <button
@@ -4221,20 +4219,20 @@ const Ue = "polygon(0 0, 100% 0, 100% 62%, 50% 100%, 0 62%)", bn = "polygon(50%
     if (!n || n === "unavailable" || n === "unknown")
       return null;
     const s = t.attributes ?? {};
-    let r = null, a = null;
+    let a = null, r = null;
     const l = s.forecast;
     if (Array.isArray(l) && l.length > 0) {
       const o = l[0];
       if (o && typeof o == "object") {
         const p = o;
-        r = this._optionalNumber(p.temperature), a = this._optionalNumber(p.templow);
+        a = this._optionalNumber(p.temperature), r = this._optionalNumber(p.templow);
       }
     }
     return {
       condition: n,
       temperature: this._optionalNumber(s.temperature),
-      high: r,
-      low: a
+      high: a,
+      low: r
     };
   }
   _renderDock() {
@@ -4247,14 +4245,14 @@ const Ue = "polygon(0 0, 100% 0, 100% 62%, 50% 100%, 0 62%)", bn = "polygon(50%
           <span class="clock">${cn(this._now, this._timeZone())}</span>
         </div>
       `;
-    const t = _n(e.condition), n = yn(e.condition, t), s = e.temperature === null ? g : d`<span class="temp">${Math.round(e.temperature)}°</span>`, r = e.high === null || e.low === null ? null : `${Math.round(e.high)}° / ${Math.round(e.low)}°`;
+    const t = gn(e.condition), n = _n(e.condition, t), s = e.temperature === null ? g : d`<span class="temp">${Math.round(e.temperature)}°</span>`, a = e.high === null || e.low === null ? null : `${Math.round(e.high)}° / ${Math.round(e.low)}°`;
     return d`
       <div class="dock">
-        ${Sn}
+        ${An}
         ${s}
         <span class="divider"></span>
         <span class="condition">
-          ${r === null ? t : `${t} · ${r}`}
+          ${a === null ? t : `${t} · ${a}`}
         </span>
         <span class="divider"></span>
         <span class="condition">${n}</span>
@@ -4277,7 +4275,7 @@ W.properties = {
   _optimistic: { state: !0 },
   _toast: { state: !0 },
   _countdown: { state: !0 }
-}, W.styles = [x(Xe), vn];
+}, W.styles = [x(Xe), bn];
 let oe = W;
 customElements.define("nestquest-quest-log-card", oe);
 fe({
@@ -4285,7 +4283,7 @@ fe({
   name: "NestQuest Quest Log",
   description: "One child's daily quests, grouped by window."
 });
-const Nn = ":host{--nq-brand-blue: #3B3AB8;--nq-brand-purple: #A035CC;--nq-brand-gradient: linear-gradient(135deg, var(--nq-brand-blue), var(--nq-brand-purple));--nq-brand-gradient-h: linear-gradient(90deg, var(--nq-brand-blue), var(--nq-brand-purple));--nq-a-page: #F4F4F6;--nq-a-surface: #FFFFFF;--nq-a-surface-subtle: #FAFAFA;--nq-a-selected: #EBEBF8;--nq-a-border: #E4E4EA;--nq-a-divider: #EDEDF1;--nq-a-ink: #18181D;--nq-a-ink-secondary: #52525E;--nq-a-ink-tertiary: #70707E;--nq-a-success: #15803D;--nq-a-danger: #DC2626;--nq-a-danger-strong: #B91C1C;--nq-a-danger-bg: #FEE2E2;--nq-a-warning-ink: #92400E;--nq-a-warning-ink-2: #78350F;--nq-a-warning-bg: #FEF3C7;--nq-a-warning-border: rgba(217,119,6,.35);--nq-a-info-bg: #DBEAFE;--nq-a-info-ink: #1E3A8A;--nq-a-info-icon: #1D4ED8;--nq-a-reversal: #7D28A0;--nq-a-font: Nunito, system-ui, sans-serif;--nq-a-size-screen: 24px;--nq-a-size-hero: 32px;--nq-a-size-card-title: 19px;--nq-a-size-stat: 22px;--nq-a-size-row: 13.5px;--nq-a-size-meta: 11px;--nq-a-size-label: 10px;--nq-a-track-label: .1em;--nq-a-density-page-pad: 14px 16px 92px;--nq-a-density-gap: 10px;--nq-a-density-card-pad: 13px;--nq-a-density-row-pad: 11px 13px;--nq-a-density-radius: 8px;--nq-a-density-shadow: none;--nq-a-tabbar-height: 70px;--nq-a-tap-min: 44px;--nq-a-radius-pill: 9999px;--nq-a-radius-sheet: 20px 20px 0 0;--nq-a-sheet-shadow: 0 -8px 28px rgba(9,9,11,.18);--nq-a-progress-height: 6px;--nq-ease-out: cubic-bezier(0, 0, .2, 1);--nq-dur-micro: .12s;--nq-dur-base: .2s;--nq-dur-modal: .35s}", G = class G extends C {
+const En = ":host{--nq-brand-blue: #3B3AB8;--nq-brand-purple: #A035CC;--nq-brand-gradient: linear-gradient(135deg, var(--nq-brand-blue), var(--nq-brand-purple));--nq-brand-gradient-h: linear-gradient(90deg, var(--nq-brand-blue), var(--nq-brand-purple));--nq-a-page: #F4F4F6;--nq-a-surface: #FFFFFF;--nq-a-surface-subtle: #FAFAFA;--nq-a-selected: #EBEBF8;--nq-a-border: #E4E4EA;--nq-a-divider: #EDEDF1;--nq-a-ink: #18181D;--nq-a-ink-secondary: #52525E;--nq-a-ink-tertiary: #70707E;--nq-a-success: #15803D;--nq-a-danger: #DC2626;--nq-a-danger-strong: #B91C1C;--nq-a-danger-bg: #FEE2E2;--nq-a-warning-ink: #92400E;--nq-a-warning-ink-2: #78350F;--nq-a-warning-bg: #FEF3C7;--nq-a-warning-border: rgba(217,119,6,.35);--nq-a-info-bg: #DBEAFE;--nq-a-info-ink: #1E3A8A;--nq-a-info-icon: #1D4ED8;--nq-a-reversal: #7D28A0;--nq-a-font: Nunito, system-ui, sans-serif;--nq-a-size-screen: 24px;--nq-a-size-hero: 32px;--nq-a-size-card-title: 19px;--nq-a-size-stat: 22px;--nq-a-size-row: 13.5px;--nq-a-size-meta: 11px;--nq-a-size-label: 10px;--nq-a-track-label: .1em;--nq-a-density-page-pad: 14px 16px 92px;--nq-a-density-gap: 10px;--nq-a-density-card-pad: 13px;--nq-a-density-row-pad: 11px 13px;--nq-a-density-radius: 8px;--nq-a-density-shadow: none;--nq-a-tabbar-height: 70px;--nq-a-tap-min: 44px;--nq-a-radius-pill: 9999px;--nq-a-radius-sheet: 20px 20px 0 0;--nq-a-sheet-shadow: 0 -8px 28px rgba(9,9,11,.18);--nq-a-progress-height: 6px;--nq-ease-out: cubic-bezier(0, 0, .2, 1);--nq-dur-micro: .12s;--nq-dur-base: .2s;--nq-dur-modal: .35s}", G = class G extends C {
   setConfig(e) {
     if (!e || typeof e != "object")
       throw new Error("Invalid configuration");
@@ -4301,7 +4299,7 @@ const Nn = ":host{--nq-brand-blue: #3B3AB8;--nq-brand-purple: #A035CC;--nq-brand
 G.properties = {
   hass: { attribute: !1 },
   _config: { state: !0 }
-}, G.styles = [x(Nn)];
+}, G.styles = [x(En)];
 let le = G;
 customElements.define("nestquest-admin-card", le);
 fe({
@@ -4312,59 +4310,59 @@ fe({
 function et(i) {
   return typeof i == "string" ? i.trim() : "";
 }
-function Ln(i) {
+function Nn(i) {
   if (i === null || typeof i != "object" || Array.isArray(i))
     return "";
   const e = i.slug;
   return typeof e == "string" ? e.trim() : "";
 }
-function On(i) {
+function Ln(i) {
   const e = et(i.url_path).replace(/^\/+|\/+$/g, "");
   return e || (window.location.pathname.split("/").filter(Boolean)[0] ?? "");
 }
-function Bn(i) {
+function On(i) {
   if (i === null || typeof i != "object" || Array.isArray(i))
     return "";
   const e = i.name;
   return typeof e == "string" ? e.trim() : "";
 }
-function In(i) {
+function Bn(i) {
   const n = i?.states?.["sensor.nestquest_household_quests_due_today"]?.attributes?.child_roster;
-  return Array.isArray(n) ? n.map((s) => ({ slug: Ln(s), name: Bn(s) })).filter((s) => s.slug.length > 0) : [];
+  return Array.isArray(n) ? n.map((s) => ({ slug: Nn(s), name: On(s) })).filter((s) => s.slug.length > 0) : [];
 }
-class Pn {
+class In {
   static async generate(e, t) {
-    const n = `/${On(e)}`, s = et(e.weather_entity), r = {
+    const n = `/${Ln(e)}`, s = et(e.weather_entity), a = {
       type: "custom:nestquest-party-board-card",
       quest_log_path: n
     };
-    s && (r.weather_entity = s);
-    const a = {
+    s && (a.weather_entity = s);
+    const r = {
       type: "custom:nestquest-quest-log-card",
       board_path: n
     };
-    return s && (a.weather_entity = s), {
+    return s && (r.weather_entity = s), {
       views: [
         {
           path: "party",
           title: "The Party",
           type: "panel",
-          cards: [r]
+          cards: [a]
         },
-        ...In(t).map((l) => ({
+        ...Bn(t).map((l) => ({
           path: l.slug,
           title: l.name ? `${l.name}'s Quest Log` : `${l.slug}'s Quest Log`,
           type: "panel",
-          cards: [{ ...a }]
+          cards: [{ ...r }]
         }))
       ]
     };
   }
 }
 window.customStrategies = window.customStrategies ?? {};
-window.customStrategies["nestquest-party"] = Pn;
-const Hn = "/nestquest-static/nestquest-fonts.css";
+window.customStrategies["nestquest-party"] = In;
+const Pn = "/nestquest-static/nestquest-fonts.css";
 if (!document.querySelector('link[data-nq-fonts=""]')) {
   const i = document.createElement("link");
-  i.rel = "stylesheet", i.href = Hn, i.dataset.nqFonts = "", document.head.appendChild(i);
+  i.rel = "stylesheet", i.href = Pn, i.dataset.nqFonts = "", document.head.appendChild(i);
 }
diff --git a/frontend/src/cards/party-board.ts b/frontend/src/cards/party-board.ts
index 8a7c8eb..f3defff 100644
--- a/frontend/src/cards/party-board.ts
+++ b/frontend/src/cards/party-board.ts
@@ -937,8 +937,18 @@ export class NestQuestPartyBoardCard extends LitElement {
     `;
   }
 
+  /** The zone the visible date and clock render in: the API's effective
+   *  application timezone — the stored zone, or the API host's when none
+   *  is stored (published on the household rollup by
+   *  custom_components/nestquest/sensor.py — ``timezone``).  Only when the
+   *  rollup carries none does Home Assistant's zone (or the browser's)
+   *  apply. */
   private _timeZone(): string | undefined {
-    return hassTimeZone(this.hass);
+    const stored = this._state("sensor.nestquest_household_quests_due_today")
+      ?.attributes?.timezone;
+    return typeof stored === "string" && stored.trim()
+      ? stored.trim()
+      : hassTimeZone(this.hass);
   }
 
   private _state(entityId: string): StateObject | null {
diff --git a/frontend/src/cards/quest-log.ts b/frontend/src/cards/quest-log.ts
index ce06bc1..721e3bc 100644
--- a/frontend/src/cards/quest-log.ts
+++ b/frontend/src/cards/quest-log.ts
@@ -36,6 +36,7 @@ type PanelInstance = {
   window: string;
   due_time: string | null;
   state: string;
+  overdue: boolean;
   completed_at: string | null;
   on_time: boolean | null;
 };
@@ -153,17 +154,6 @@ function formatWallClock(value: string | null): string | null {
   return `${hour12}:${match[2]} ${suffix}`;
 }
 
-/** Minutes past midnight of a household ``HH:MM`` wall time, or null. */
-function wallClockMinutes(value: string | null): number | null {
-  const match = value ? /^(\d{1,2}):(\d{2})$/.exec(value.trim()) : null;
-  if (!match) {
-    return null;
-  }
-  const hours = Number(match[1]);
-  const minutes = Number(match[2]);
-  return hours > 23 || minutes > 59 ? null : hours * 60 + minutes;
-}
-
 function asString(value: unknown): string {
   return typeof value === "string" ? value.trim() : "";
 }
@@ -263,6 +253,7 @@ function toPanelInstance(value: unknown): PanelInstance | null {
     window: asString(row.window).toLowerCase(),
     due_time: asString(row.due_time) || null,
     state,
+    overdue: row.overdue === true,
     completed_at: asString(row.completed_at) || null,
     on_time: row.on_time === true ? true : row.on_time === false ? false : null,
   };
@@ -1758,22 +1749,18 @@ export class NestQuestQuestLogCard extends LitElement {
     `;
   }
 
-  /** Overdue by the panel's own clock: the browser runs on the
-      household's real local time, so an open quest turns overdue once its
-      ``due_time`` wall time has arrived there — whatever zone the API or
-      Home Assistant computed the API's ``overdue`` flag in.  With no due
-      time it is never overdue (the API's rule too).  ``_now`` is reactive
-      and ticks every 60 s, so the line flips on the minute it falls due. */
-  private _isOverdue(instance: PanelInstance): boolean {
-    const due = wallClockMinutes(instance.due_time);
-    if (instance.state !== "open" || due === null) {
-      return false;
-    }
-    return this._now.getHours() * 60 + this._now.getMinutes() >= due;
-  }
-
+  /** The zone the visible date and clock render in: the API's effective
+   *  application timezone — the stored zone, or the API host's when none
+   *  is stored (published on the household rollup by
+   *  custom_components/nestquest/sensor.py — ``timezone``).  Only when the
+   *  rollup carries none does Home Assistant's zone (or the browser's)
+   *  apply. */
   private _timeZone(): string | undefined {
-    return hassTimeZone(this.hass);
+    const stored = this._state("sensor.nestquest_household_quests_due_today")
+      ?.attributes?.timezone;
+    return typeof stored === "string" && stored.trim()
+      ? stored.trim()
+      : hassTimeZone(this.hass);
   }
 
   private _state(entityId: string): StateObject | null {
@@ -1856,6 +1843,7 @@ export class NestQuestQuestLogCard extends LitElement {
         continue;
       }
       instance.state = "completed";
+      instance.overdue = false;
       instance.completed_at = stampedAt;
     }
     if (settled) {
@@ -2152,7 +2140,7 @@ export class NestQuestQuestLogCard extends LitElement {
       `;
     }
     const dueAt = formatWallClock(instance.due_time);
-    const meta = this._isOverdue(instance)
+    const meta = instance.overdue
       ? {
           text: dueAt ? `Overdue · due ${dueAt}` : "Overdue",
           late: true,
diff --git a/frontend/tests/render-party-board.mjs b/frontend/tests/render-party-board.mjs
index 4b0309f..59346d7 100644
--- a/frontend/tests/render-party-board.mjs
+++ b/frontend/tests/render-party-board.mjs
@@ -3,13 +3,15 @@
  *
  * Usage: node render-party-board.mjs < spec.json
  *
- * The spec JSON carries {bundle, tag, config, hass, url?, click_plate?};
+ * The spec JSON carries {bundle, tag, config, hass, url?, click_plate?, now?};
  * stdout receives one JSON object {plates, tappable, location, html} where
  * plates is the ordered plate list the shadow DOM renders (name +
  * present/away/unknown kind), tappable the plate names rendered as tappable
  * <button> plates, and location the window pathname after the optional plate
- * tap. The Python panel tests drive this harness so the assertions run
- * against the exact bundle HACS ships.
+ * tap. With now: <ISO instant> the card's clock is pinned there
+ * (argument-less new Date() and Date.now() return it; the process TZ
+ * decides its local wall time). The Python panel tests drive this harness
+ * so the assertions run against the exact bundle HACS ships.
  */
 import { readFileSync } from "node:fs";
 import { pathToFileURL } from "node:url";
@@ -39,6 +41,23 @@ globalThis.window = dom.window;
 // jsdom Event must shadow it for the dispatched event to be delivered.
 globalThis.Event = dom.window.Event;
 
+// Pin the clock: argument-less construction and Date.now() read `pinned`,
+// every other Date use is the real class.
+if (spec.now !== undefined) {
+  const pinned = new Date(spec.now).getTime();
+  const RealDate = Date;
+  class PinnedDate extends RealDate {
+    constructor(...args) {
+      super(...(args.length === 0 ? [pinned] : args));
+    }
+    static now() {
+      return pinned;
+    }
+  }
+  globalThis.Date = PinnedDate;
+  dom.window.Date = PinnedDate;
+}
+
 await import(pathToFileURL(spec.bundle).href);
 
 const element = document.createElement(spec.tag);
diff --git a/tests/conftest.py b/tests/conftest.py
index 1ae82cb..2204796 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -910,6 +910,7 @@ def coordinator_client_from_test_override():
             {
                 "today_iso": datetime.date.today().isoformat(),
                 "cycle_day": 0,
+                "timezone": "",
                 "children": [],
             }
         )
diff --git a/tests/test_api_admin_settings.py b/tests/test_api_admin_settings.py
index b934f96..7648b6d 100644
--- a/tests/test_api_admin_settings.py
+++ b/tests/test_api_admin_settings.py
@@ -41,6 +41,7 @@ from types import SimpleNamespace
 
 import pytest
 
+from api import host_zone
 from tests.admin_jwt_harness import (
     ADMIN_KEY,
     KID,
@@ -60,9 +61,14 @@ _dao_meta = importlib.import_module("nestquest_core.dao_meta")
 #: independent of the core constant.
 SETTINGS_META_KEY = "settings"
 
+#: The API host's own zone, pinned for every test (:func:`settings_client`):
+#: the ``effective_timezone`` while no zone is stored.
+API_HOST_ZONE = "Australia/Perth"
+
 #: The all-defaults effective settings a fresh database reports — the
-#: documented eleven fields, asserted literally so the payload contract is
-#: pinned here, independent of the core constants.
+#: documented eleven fields plus the read-only ``effective_timezone``,
+#: asserted literally so the payload contract is pinned here, independent
+#: of the core constants.
 DEFAULT_SETTINGS = {
     "horizon_days": 14,
     "day_rollover_time": "00:00",
@@ -75,22 +81,34 @@ DEFAULT_SETTINGS = {
     "end_of_day_report_enabled": True,
     "celebration_enabled": True,
     "timezone": "",
+    "effective_timezone": API_HOST_ZONE,
 }
 
 
+def _with_zone(zone: str) -> dict:
+    """The default settings with ``zone`` stored, as the API reports them."""
+    return {
+        **DEFAULT_SETTINGS,
+        "timezone": zone,
+        "effective_timezone": zone or API_HOST_ZONE,
+    }
+
+
 def _admin_headers() -> dict[str, str]:
     """The Authorization header of a valid nestquest-admins JWT."""
     return {"Authorization": f"Bearer {make_token()}"}
 
 
 @pytest.fixture
-async def settings_client(temp_db_path: str) -> SimpleNamespace:
+async def settings_client(temp_db_path: str, monkeypatch) -> SimpleNamespace:
     """An admin-plane app client plus its live database.
 
     The same runner the children tests use (stubbed JWKS, no network);
     the fixture also exposes the app's ONE database connection so tests
-    can read (or corrupt) the stored settings document itself.
+    can read (or corrupt) the stored settings document itself.  The API
+    host's zone is pinned to :data:`API_HOST_ZONE`.
     """
+    monkeypatch.setattr(host_zone, "host_timezone", lambda: API_HOST_ZONE)
     runner = AdminRunner(temp_db_path, jwks_for(ADMIN_KEY, KID))
     async with runner as client:
         yield SimpleNamespace(
@@ -147,7 +165,9 @@ async def test_update_persists_and_the_next_read_reflects_it(
         SETTINGS_META_KEY
     )
     assert raw is not None
-    assert json.loads(raw) == expected
+    stored = dict(expected)
+    del stored["effective_timezone"]  # derived on read, never stored
+    assert json.loads(raw) == stored
 
 
 async def test_partial_update_merges_onto_the_current_settings(
@@ -254,7 +274,7 @@ async def test_manual_timezone_patch_persists_and_is_returned(
         headers=_admin_headers(),
     )
     assert patched.status_code == 200
-    expected = {**DEFAULT_SETTINGS, "timezone": zone}
+    expected = _with_zone(zone)
     assert patched.json() == expected
 
     reread = await client.get(
@@ -285,7 +305,7 @@ async def test_timezone_alone_sticks_on_a_fresh_database(
     reread = await client.get(
         "/api/v1/admin/settings", headers=_admin_headers()
     )
-    assert reread.json() == {**DEFAULT_SETTINGS, "timezone": zone}
+    assert reread.json() == _with_zone(zone)
 
 
 async def test_timezone_configured_is_an_unknown_field(
@@ -319,7 +339,7 @@ async def test_stored_legacy_timezone_configured_key_is_ignored(
         "/api/v1/admin/settings", headers=_admin_headers()
     )
     assert response.status_code == 200
-    assert response.json() == {**DEFAULT_SETTINGS, "timezone": "America/Chicago"}
+    assert response.json() == _with_zone("America/Chicago")
 
 
 # --- validation: rejected values never change the stored settings -------
diff --git a/tests/test_api_admin_snapshot.py b/tests/test_api_admin_snapshot.py
index 52652ac..fb0995c 100644
--- a/tests/test_api_admin_snapshot.py
+++ b/tests/test_api_admin_snapshot.py
@@ -37,7 +37,7 @@ from zoneinfo import ZoneInfo
 
 import pytest
 
-from api import routes_admin, routes_panel
+from api import host_zone, routes_admin, routes_panel
 from api.nestquest_core import core_snapshot
 from tests.admin_jwt_harness import (
     ADMIN_KEY,
@@ -101,6 +101,8 @@ async def snapshot_household(
 
     monkeypatch.setattr(routes_admin, "_local_now", _admin_now)
     monkeypatch.setattr(routes_panel, "_local_now", lambda: pinned_now)
+    # The API host runs UTC, the zone of the pinned clock.
+    monkeypatch.setattr(host_zone, "host_timezone", lambda: "UTC")
     runner = AdminRunner(temp_db_path, jwks_for(ADMIN_KEY, KID))
     async with runner as client:
         yield SimpleNamespace(
@@ -165,7 +167,10 @@ async def test_admin_jwt_returns_documented_snapshot(
 
     Every field is asserted as an explicit literal, with ONE clock
     read for the request.  With no missed view in the real snapshot,
-    the admin body equals the panel body for the same household.
+    the admin body equals the panel body for the same household — the
+    panel body additionally carries the effective ``timezone`` its cards
+    format the visible date and clock in (none stored here: the UTC
+    host's own zone).
     """
     client = snapshot_household.client
     seed = snapshot_household.seed
@@ -241,7 +246,7 @@ async def test_admin_jwt_returns_documented_snapshot(
         "/api/v1/panel/snapshot", headers=_panel_headers()
     )
     assert panel.status_code == 200
-    assert panel.json() == body
+    assert panel.json() == {**body, "timezone": "UTC"}
 
 
 async def test_admin_keeps_missed_instance_panel_omits_it(
diff --git a/tests/test_api_host_zone.py b/tests/test_api_host_zone.py
new file mode 100644
index 0000000..18d8424
--- /dev/null
+++ b/tests/test_api_host_zone.py
@@ -0,0 +1,71 @@
+"""The API host's zone and the effective application timezone (task 7e173881).
+
+With no zone stored the API reads its clock in the host's local time, so
+:func:`api.host_zone.effective_timezone` names that host zone — resolved
+the way the C library resolves local time — for the panel and admin app
+to format in.  Every host configuration here is a temporary file tree.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from api import host_zone
+
+
+def _host(tmp_path: Path, *, link: str | None = None, name: str | None = None):
+    """A fake ``/etc``: ``localtime`` linked into a zoneinfo tree at
+    ``link``, and/or an ``/etc/timezone`` file holding ``name``."""
+    localtime = tmp_path / "etc" / "localtime"
+    timezone_file = tmp_path / "etc" / "timezone"
+    localtime.parent.mkdir(parents=True)
+    if link is not None:
+        target = tmp_path / "usr" / "share" / "zoneinfo" / link
+        target.parent.mkdir(parents=True)
+        target.write_bytes(b"TZif")
+        localtime.symlink_to(target)
+    if name is not None:
+        timezone_file.write_text(f"{name}\n", encoding="utf-8")
+    return {"timezone_file": timezone_file, "localtime": localtime}
+
+
+def test_tz_environment_variable_wins(tmp_path: Path) -> None:
+    paths = _host(tmp_path, link="Europe/Paris")
+    assert host_zone.host_timezone({"TZ": "Asia/Kolkata"}, **paths) == "Asia/Kolkata"
+    assert host_zone.host_timezone({"TZ": ":Asia/Kolkata"}, **paths) == "Asia/Kolkata"
+    assert host_zone.host_timezone({"TZ": ""}, **paths) == "UTC"
+
+
+def test_localtime_link_names_the_zone(tmp_path: Path) -> None:
+    paths = _host(tmp_path, link="America/Argentina/Buenos_Aires")
+    assert host_zone.host_timezone({}, **paths) == "America/Argentina/Buenos_Aires"
+
+
+def test_etc_timezone_names_a_copied_localtime(tmp_path: Path) -> None:
+    paths = _host(tmp_path, name="Pacific/Auckland")
+    paths["localtime"].write_bytes(b"TZif")
+    assert host_zone.host_timezone({}, **paths) == "Pacific/Auckland"
+
+
+def test_unconfigured_host_runs_utc(tmp_path: Path) -> None:
+    assert host_zone.host_timezone({}, **_host(tmp_path)) == "UTC"
+
+
+@pytest.mark.parametrize("tz", ["EST+5", "Not/AZone", ":/etc/localtime"])
+def test_an_unnamed_host_zone_is_empty(tmp_path: Path, tz: str) -> None:
+    assert host_zone.host_timezone({"TZ": tz}, **_host(tmp_path)) == ""
+
+
+def test_unnamed_copied_localtime_is_empty(tmp_path: Path) -> None:
+    paths = _host(tmp_path)
+    paths["localtime"].write_bytes(b"TZif")
+    assert host_zone.host_timezone({}, **paths) == ""
+
+
+def test_effective_timezone_is_the_stored_zone_else_the_host_zone(
+    monkeypatch,
+) -> None:
+    monkeypatch.setattr(host_zone, "host_timezone", lambda: "Europe/Dublin")
+    assert host_zone.effective_timezone("America/Chicago") == "America/Chicago"
+    assert host_zone.effective_timezone("") == "Europe/Dublin"
diff --git a/tests/test_api_household_clock.py b/tests/test_api_household_clock.py
index 94ea144..4bd6632 100644
--- a/tests/test_api_household_clock.py
+++ b/tests/test_api_household_clock.py
@@ -32,7 +32,7 @@ from zoneinfo import ZoneInfo
 
 import pytest
 
-from api import routes_admin, routes_panel
+from api import host_zone, routes_admin, routes_panel
 from api import scheduler as scheduler_module
 from api.database import _executor
 from api.scheduler import MissedSweepScheduler, _delay_seconds
@@ -92,6 +92,7 @@ async def household(temp_db_path: str, monkeypatch) -> SimpleNamespace:
             seed=seed,
             clock=clock,
             database=runner.app.state.db.database,
+            app=runner.app,
         )
 
 
@@ -532,6 +533,146 @@ async def test_scheduler_rechecks_settings_before_sweeping(
         await database.close()
 
 
+# --- the admin settings route is the scheduler's writer (task 7e173881) ------
+#
+# ``PATCH /api/v1/admin/settings`` is the only settings writer: it holds
+# the scheduler's settings lock across the write and tells the scheduler,
+# so a saved zone or rollover re-plans a sleeping scheduler.
+
+
+async def _sleeping_scheduler(household: SimpleNamespace):
+    """Swap in a scheduler on the pinned clock; return it and its delays.
+
+    Waits until it sleeps on its first plan.
+    """
+    await household.app.state.sweep_scheduler.stop()
+    delays: list[float] = []
+    slept = asyncio.Condition()
+
+    async def sleep_stub(seconds: float) -> None:
+        async with slept:
+            delays.append(seconds)
+            slept.notify_all()
+        await asyncio.Event().wait()
+
+    scheduler = MissedSweepScheduler(
+        household.database,
+        clock=lambda: household.clock["now"],
+        sleep=sleep_stub,
+    )
+    household.app.state.sweep_scheduler = scheduler
+    scheduler.start()
+
+    async def wait_for_sleeps(count: int) -> None:
+        async with slept:
+            await asyncio.wait_for(
+                slept.wait_for(lambda: len(delays) == count), timeout=5
+            )
+
+    await wait_for_sleeps(1)
+    return scheduler, delays, wait_for_sleeps
+
+
+@pytest.mark.parametrize(
+    ("changes", "replanned_delay"),
+    [
+        # 13:00 UTC is 09:00 EDT: New York midnight is 15 hours away.
+        ({"timezone": HOUSEHOLD_ZONE}, _NEW_YORK_MIDNIGHT_DELAY),
+        # Still UTC: 13:00 to a 14:30 rollover is 90 minutes.
+        ({"day_rollover_time": "14:30"}, 90 * 60),
+    ],
+    ids=["timezone", "day_rollover_time"],
+)
+async def test_admin_settings_patch_replans_a_sleeping_scheduler(
+    household: SimpleNamespace, changes: dict, replanned_delay: float
+) -> None:
+    household.clock["now"] = _utc(13, 0)
+    scheduler, delays, wait_for_sleeps = await _sleeping_scheduler(household)
+    try:
+        response = await household.client.patch(
+            "/api/v1/admin/settings", json=changes, headers=_admin_headers()
+        )
+        assert response.status_code == 200
+        await wait_for_sleeps(2)
+    finally:
+        await scheduler.stop()
+    assert delays == [
+        pytest.approx(_UTC_MIDNIGHT_DELAY),
+        pytest.approx(replanned_delay),
+    ]
+
+
+async def test_admin_saved_zone_is_authoritative_across_surfaces(
+    household: SimpleNamespace,
+) -> None:
+    """ONE instant, read by every surface in exactly the admin's zone.
+
+    Asia/Kolkata (UTC+05:30) matches neither the UTC host nor any other
+    zone in play.  04:30:01 UTC is 10:00:01 there: the 10:00 quest is
+    overdue on both snapshots (it would not be in UTC, 04:30), the
+    household day is the 26th, and the scheduler sleeps the 299 s to a
+    10:05 rollover (UTC would be 5h35m).
+    """
+    household.clock["now"] = _utc(4, 30, 1)
+    scheduler, delays, wait_for_sleeps = await _sleeping_scheduler(household)
+    try:
+        response = await household.client.patch(
+            "/api/v1/admin/settings",
+            json={"timezone": "Asia/Kolkata", "day_rollover_time": "10:05"},
+            headers=_admin_headers(),
+        )
+        assert response.status_code == 200
+        await wait_for_sleeps(2)
+        for plane in ("panel", "admin"):
+            today_iso, instance = await _pack_bag(household, plane)
+            assert today_iso == TODAY.isoformat(), plane
+            assert instance["overdue"] is True, plane
+    finally:
+        await scheduler.stop()
+    assert delays[1] == pytest.approx(299)
+
+
+async def test_empty_zone_publishes_the_api_host_zone_to_panel_and_admin(
+    household: SimpleNamespace, monkeypatch
+) -> None:
+    """With no zone stored, the API reads the host's local time — and the
+    panel snapshot and the admin settings both publish that host's own
+    zone, so the cards and the admin app format in the API's zone, never
+    Home Assistant's or the browser's.
+
+    The host runs Pacific/Auckland: 12:30 UTC on the 26th is already
+    00:30 on the 27th there, so the API's household day is the 27th while
+    a UTC Home Assistant or browser would still read the 26th.  Once the
+    admin saves a zone, both publish exactly that zone.
+    """
+    host = "Pacific/Auckland"
+    monkeypatch.setattr(host_zone, "host_timezone", lambda: host)
+    household.clock["now"] = _utc(12, 30).astimezone(ZoneInfo(host))
+
+    panel = await household.client.get(
+        "/api/v1/panel/snapshot", headers=_panel_headers()
+    )
+    assert panel.status_code == 200
+    settings = await _admin_settings(household)
+    assert settings["timezone"] == ""
+    assert panel.json()["timezone"] == settings["effective_timezone"] == host
+    # The published zone reproduces the API's own household day.
+    assert panel.json()["today_iso"] == "2026-09-27"
+    assert (
+        _utc(12, 30).astimezone(ZoneInfo(host)).date().isoformat()
+        == panel.json()["today_iso"]
+    )
+
+    await _set_zone(household, "America/Chicago")
+    panel = await household.client.get(
+        "/api/v1/panel/snapshot", headers=_panel_headers()
+    )
+    settings = await _admin_settings(household)
+    assert settings["timezone"] == "America/Chicago"
+    assert panel.json()["timezone"] == settings["effective_timezone"]
+    assert settings["effective_timezone"] == "America/Chicago"
+
+
 # --- settings writes are serialised with planning and sweeping (TZ-003) ------
 #
 # A zone write racing the loop's own settings reads must never leave a
diff --git a/tests/test_binary_sensors.py b/tests/test_binary_sensors.py
index d7d7b80..09c67c8 100644
--- a/tests/test_binary_sensors.py
+++ b/tests/test_binary_sensors.py
@@ -60,6 +60,7 @@ def _payload(children) -> dict:
     return {
         "today_iso": "2026-09-23",
         "cycle_day": 0,
+        "timezone": "",
         "children": list(children),
     }
 
diff --git a/tests/test_complete_quest_proxy.py b/tests/test_complete_quest_proxy.py
index 4097b23..873374b 100644
--- a/tests/test_complete_quest_proxy.py
+++ b/tests/test_complete_quest_proxy.py
@@ -55,6 +55,7 @@ def _empty_snapshot() -> dict:
     return {
         "today_iso": "2026-09-23",
         "cycle_day": 0,
+        "timezone": "",
         "children": [],
     }
 
diff --git a/tests/test_coordinator.py b/tests/test_coordinator.py
index d7baf23..346e79a 100644
--- a/tests/test_coordinator.py
+++ b/tests/test_coordinator.py
@@ -93,6 +93,7 @@ class FakeMonotonic:
 FIXTURE_SNAPSHOT = {
     "today_iso": _today_iso(),
     "cycle_day": 3,
+    "timezone": "",
     "children": [
         {
             "child_id": 1,
@@ -793,8 +794,37 @@ async def test_snapshot_from_api_payload_empty_household() -> None:
     """An empty household (no children) is a valid snapshot: empty
     children tuple, cycle day passes through."""
     snapshot = snapshot_from_api_payload(
-        {"today_iso": "2026-09-23", "cycle_day": 0, "children": []}
+        {
+            "today_iso": "2026-09-23",
+            "cycle_day": 0,
+            "timezone": "",
+            "children": [],
+        }
     )
     assert snapshot.children == ()
     assert snapshot.cycle_day == 0
     assert snapshot.today_iso == "2026-09-23"
+
+
+#: The panel snapshot exactly as an API from before the ``timezone`` field
+#: serves it: an integration upgraded ahead of its API still reads this.
+LEGACY_SNAPSHOT = {
+    key: value for key, value in FIXTURE_SNAPSHOT.items() if key != "timezone"
+}
+
+
+async def test_coordinator_reads_a_legacy_payload_without_timezone(
+    hass, make_entry
+) -> None:
+    """An older API omits ``timezone``: every refresh still builds the
+    snapshot (the cards then fall back to Home Assistant's zone)."""
+    assert "timezone" not in LEGACY_SNAPSHOT
+    client = StubSnapshotClient(LEGACY_SNAPSHOT)
+    _entry, coordinator = await _wire_entry(hass, make_entry, client)
+    assert coordinator.last_update_success is True
+
+    snapshot = await coordinator._async_update_data()
+    assert snapshot.timezone == ""
+    assert snapshot.cycle_day == 3
+    assert [child.child_name for child in snapshot.children] == ["Ada", "Bo"]
+    assert snapshot_from_api_payload(LEGACY_SNAPSHOT).timezone == ""
diff --git a/tests/test_core_snapshot.py b/tests/test_core_snapshot.py
index 700f8a5..9e7c23d 100644
--- a/tests/test_core_snapshot.py
+++ b/tests/test_core_snapshot.py
@@ -332,6 +332,7 @@ async def test_build_snapshot_explicit_values(hass, make_entry, tmp_path) -> Non
             return {
                 "today_iso": built.today_iso,
                 "cycle_day": built.cycle_day,
+                "timezone": built.timezone,
                 "children": [
                     {
                         "child_id": child.child_id,
diff --git a/tests/test_entity_lifecycle.py b/tests/test_entity_lifecycle.py
index 4dd384f..3811129 100644
--- a/tests/test_entity_lifecycle.py
+++ b/tests/test_entity_lifecycle.py
@@ -67,6 +67,7 @@ def _payload(children) -> dict:
     return {
         "today_iso": "2026-09-23",
         "cycle_day": 0,
+        "timezone": "",
         "children": list(children),
     }
 
diff --git a/tests/test_entity_matrix.py b/tests/test_entity_matrix.py
index dcd9497..dc16a50 100644
--- a/tests/test_entity_matrix.py
+++ b/tests/test_entity_matrix.py
@@ -76,6 +76,7 @@ def _payload(children, cycle_day=0) -> dict:
     return {
         "today_iso": "2026-09-23",
         "cycle_day": cycle_day,
+        "timezone": "",
         "children": list(children),
     }
 
diff --git a/tests/test_events.py b/tests/test_events.py
index ac45112..4114e71 100644
--- a/tests/test_events.py
+++ b/tests/test_events.py
@@ -70,6 +70,7 @@ def _payload(children) -> dict:
     return {
         "today_iso": "2026-09-23",
         "cycle_day": 0,
+        "timezone": "",
         "children": list(children),
     }
 
diff --git a/tests/test_panel_cards.py b/tests/test_panel_cards.py
index 5028d05..a47fcb9 100644
--- a/tests/test_panel_cards.py
+++ b/tests/test_panel_cards.py
@@ -567,6 +567,8 @@ def _render_party_board(
     states: dict,
     url: str | None = None,
     click_plate: str | None = None,
+    now: str | None = None,
+    tz: str | None = None,
 ) -> dict:
     """Render the built bundle's party board and return its plates.
 
@@ -575,7 +577,9 @@ def _render_party_board(
     mounts the card with the given config and hass snapshot, optionally
     taps the named plate, and prints the ordered plates its shadow DOM
     renders, which of them are tappable buttons, and the pathname after
-    the optional tap.
+    the optional tap.  ``now`` pins the card's clock to an ISO instant
+    and ``tz`` sets the node process's ``TZ`` — the panel browser's
+    local zone.
     """
     assert BUNDLE_PATH.is_file(), "bundle missing: run cd frontend && npm run build"
     assert RENDER_HARNESS.is_file()
@@ -589,12 +593,15 @@ def _render_party_board(
         spec["url"] = url
     if click_plate is not None:
         spec["click_plate"] = click_plate
+    if now is not None:
+        spec["now"] = now
     completed = subprocess.run(
         ["node", str(RENDER_HARNESS)],
         input=json.dumps(spec),
         capture_output=True,
         text=True,
         timeout=120,
+        env={**os.environ, "TZ": tz} if tz is not None else None,
     )
     assert completed.returncode == 0, (
         f"render harness failed: {completed.stderr}"
@@ -1102,13 +1109,12 @@ def test_quest_log_meta_line_keeps_its_meta_class() -> None:
     ``meta ${late ? "late" : nothing}``, Lit dropped the whole class
     attribute for every quest that was not late, leaving the due line
     unstyled. The rendered markup must carry ``class="meta"`` on time and
-    ``class="meta late"`` overdue — overdue by the panel's pinned clock
-    (07:15 local: the 07:00 quest is late, the 08:15 one is not)."""
+    ``class="meta late"`` overdue — overdue as the API snapshot says."""
     generated = _generate_dashboard(
         {}, _three_child_states(), url="http://homeassistant.local/nestquest"
     )
 
-    def quest(instance_id: int, title: str, due_time: str) -> dict:
+    def quest(instance_id: int, title: str, overdue: bool) -> dict:
         return {
             "id": instance_id,
             "definition_id": instance_id,
@@ -1116,9 +1122,9 @@ def test_quest_log_meta_line_keeps_its_meta_class() -> None:
             "title": title,
             "icon": None,
             "window": "morning",
-            "due_time": due_time,
+            "due_time": "08:15",
             "state": "open",
-            "overdue": False,
+            "overdue": overdue,
             "completed_at": None,
             "on_time": None,
         }
@@ -1131,8 +1137,8 @@ def test_quest_log_meta_line_keeps_its_meta_class() -> None:
             child_id=1,
             present=True,
             instances=[
-                quest(41, "Make Bed", "08:15"),
-                quest(42, "Brush Teeth", "07:00"),
+                quest(41, "Make Bed", overdue=False),
+                quest(42, "Brush Teeth", overdue=True),
             ],
         ),
     }
@@ -1140,8 +1146,6 @@ def test_quest_log_meta_line_keeps_its_meta_class() -> None:
         generated["views"][1]["cards"][0],
         states,
         url="http://homeassistant.local/nestquest/ada",
-        now="2026-09-29T11:15:00Z",
-        tz="America/New_York",
     )
     metas = {}
     for card in result["html"].split('data-instance-id="')[1:]:
@@ -1175,19 +1179,22 @@ def _quest_metas(html: str) -> dict[str, tuple[str, str]]:
     return metas
 
 
-def test_quest_log_overdue_follows_the_panel_local_clock() -> None:
-    """Overdue is decided by the panel's own local clock, not the API's
-    ``overdue`` flag.  The owner saw 8:15 AM quests read OVERDUE at 7:15 AM
-    America/New_York: the API's flag had been computed on a UTC wall clock
-    (11:15).  Here the API still says ``overdue: true`` and Home
-    Assistant reports ``time_zone`` UTC, yet at 07:15 local the 08:15 quest
-    is due, at 08:15 (and 08:16, via the card's own clock tick) it is
-    overdue, and a quest with no due time is never overdue."""
+def test_quest_log_overdue_follows_the_api_snapshot_not_the_panel_clock() -> None:
+    """The stored application timezone is the single source of local-time
+    truth: the API computes each instance's ``overdue`` in that zone and
+    the card renders exactly that, whatever the panel browser's own clock
+    or zone says.  Here the browser runs in Pacific/Auckland and its clock
+    is pinned (and later ticked) to instants where every due time has, or
+    has not yet, arrived on its local wall clock — the card must still
+    show the snapshot's state: the ``overdue: true`` 08:15 quest reads
+    OVERDUE even though the browser reads long before 08:15, and the
+    ``overdue: false`` 07:00 quest stays due even though the browser reads
+    long after 07:00."""
     generated = _generate_dashboard(
         {}, _three_child_states(), url="http://homeassistant.local/nestquest"
     )
 
-    def quest(instance_id: int, title: str, due_time: str | None) -> dict:
+    def quest(instance_id: int, title: str, due_time: str, overdue: bool) -> dict:
         return {
             "id": instance_id,
             "definition_id": instance_id,
@@ -1197,7 +1204,7 @@ def test_quest_log_overdue_follows_the_panel_local_clock() -> None:
             "window": "morning",
             "due_time": due_time,
             "state": "open",
-            "overdue": True,
+            "overdue": overdue,
             "completed_at": None,
             "on_time": None,
         }
@@ -1210,29 +1217,96 @@ def test_quest_log_overdue_follows_the_panel_local_clock() -> None:
             child_id=1,
             present=True,
             instances=[
-                quest(42, "Brush Teeth", "08:15"),
-                quest(43, "Feed Fish", None),
+                quest(42, "Brush Teeth", "08:15", overdue=True),
+                quest(43, "Feed Fish", "07:00", overdue=False),
             ],
         ),
     }
+    # 2026-09-29T17:00Z is 06:00 NZDT on the 30th: before both due times.
+    # 2026-09-29T23:00Z is 12:00 NZDT: after both.
     result = _render_quest_log(
         generated["views"][1]["cards"][0],
         states,
         url="http://homeassistant.local/nestquest/ada",
-        now="2026-09-29T11:15:00Z",
-        advance_to=["2026-09-29T12:15:00Z", "2026-09-29T12:16:00Z"],
-        tz="America/New_York",
+        now="2026-09-29T17:00:00Z",
+        advance_to=["2026-09-29T23:00:00Z"],
+        tz="Pacific/Auckland",
     )
-    due_by = ('class="meta"', "Due by 8:15 AM")
     overdue = ('class="meta late"', "Overdue · due 8:15 AM")
-    not_due = ('class="meta"', "Due today")
-    at_0715, at_0815, at_0816 = (
+    due_by = ('class="meta"', "Due by 7:00 AM")
+    before, (after,) = (
         _quest_metas(result["html"]),
-        *(_quest_metas(tick["html"]) for tick in result["ticks"]),
+        [_quest_metas(tick["html"]) for tick in result["ticks"]],
+    )
+    assert before == {"42": overdue, "43": due_by}, before
+    assert after == {"42": overdue, "43": due_by}, after
+
+
+def test_panel_date_and_clock_follow_the_stored_application_timezone() -> None:
+    """The stored application timezone is the single source of local-time
+    truth for the panel's visible date and clock too: the household rollup
+    publishes it (``timezone`` — the API's effective zone) and both cards
+    format in it — the party
+    board's kicker and dock date and clock, the quest log's header date —
+    even though Home Assistant's zone and the panel browser's zone are both
+    UTC.  At 2026-09-29T23:30Z it is still Tuesday 11:30 PM in UTC but
+    already Wednesday 12:30 PM in Pacific/Auckland (NZDT)."""
+    generated = _generate_dashboard(
+        {}, _three_child_states(), url="http://homeassistant.local/nestquest"
+    )
+    states = _three_child_states()
+    states["sensor.nestquest_household_quests_due_today"]["attributes"][
+        "timezone"
+    ] = "Pacific/Auckland"
+    now = "2026-09-29T23:30:00Z"
+
+    def text(html: str) -> str:
+        return re.sub(r"<!--.*?-->", "", html).replace("\u202f", " ")
+
+    def board_date_and_clock(html: str) -> tuple[str, str, str]:
+        found = re.search(
+            r'<p class="kicker">The Party · (.*?)</p>.*?'
+            r'<span class="date">(.*?)</span>.*?<span class="clock">(.*?)</span>',
+            text(html),
+            re.DOTALL,
+        )
+        assert found is not None, html
+        return found.group(1), found.group(2), found.group(3)
+
+    board = _render_party_board(
+        generated["views"][0]["cards"][0], states, now=now, tz="UTC"
+    )["html"]
+    assert board_date_and_clock(board) == (
+        "Wednesday, Sep 30",
+        "Wednesday, Sep 30",
+        "12:30 PM",
+    )
+
+    log = _render_quest_log(
+        generated["views"][1]["cards"][0],
+        states,
+        url="http://homeassistant.local/nestquest/ada",
+        now=now,
+        tz="UTC",
+    )["html"]
+    sub = re.search(r'<p class="sub">\s*(.*?) ·', text(log), re.DOTALL)
+    assert sub is not None, log
+    assert sub.group(1) == "Wednesday, Sep 30"
+
+    # With no zone stored the API publishes its host's own zone, so the
+    # rollup always carries one; only a rollup without it (an API older
+    # than the field) falls back to Home Assistant's zone (UTC here).
+    del states["sensor.nestquest_household_quests_due_today"]["attributes"][
+        "timezone"
+    ]
+    fallback = _render_party_board(
+        generated["views"][0]["cards"][0], states, now=now, tz="UTC"
+    )["html"]
+    assert board_date_and_clock(fallback) == (
+        "Tuesday, Sep 29",
+        "Tuesday, Sep 29",
+        "11:30 PM",
     )
-    assert at_0715 == {"42": due_by, "43": not_due}, at_0715
-    assert at_0815 == {"42": overdue, "43": not_due}, at_0815
-    assert at_0816 == {"42": overdue, "43": not_due}, at_0816
 
 
 def test_quest_log_crest_matches_the_spec_geometry() -> None:
diff --git a/tests/test_sensors.py b/tests/test_sensors.py
index 7a54df0..a6b44cf 100644
--- a/tests/test_sensors.py
+++ b/tests/test_sensors.py
@@ -76,6 +76,7 @@ def _payload(children) -> dict:
     return {
         "today_iso": _today_iso(),
         "cycle_day": 0,
+        "timezone": "",
         "children": list(children),
     }
 
@@ -569,6 +570,22 @@ async def test_household_due_sensor_publishes_the_ordered_child_roster(
     }
 
 
+async def test_household_due_sensor_publishes_the_stored_zone(
+    hass, make_entry
+) -> None:
+    """The rollup carries the snapshot's stored application zone verbatim
+    (the panel cards format their date and clock in it); ``""`` — no zone
+    stored — passes through unchanged for the cards' documented fallback."""
+    zoned = {**_seeded_payload(), "timezone": "Pacific/Auckland"}
+    entry, coordinator, _client = await _setup_entry(
+        hass, make_entry, zoned, _seeded_payload()
+    )
+    rollup = hass.entities["nestquest_household_quests_due_today"]
+    assert rollup.extra_state_attributes["timezone"] == "Pacific/Auckland"
+    await coordinator.async_refresh()
+    assert rollup.extra_state_attributes["timezone"] == ""
+
+
 async def test_household_roster_tracks_the_snapshot_on_refresh(
     hass, make_entry
 ) -> None:
diff --git a/tests/test_sse_subscription.py b/tests/test_sse_subscription.py
index 0a5c26d..e0b0b62 100644
--- a/tests/test_sse_subscription.py
+++ b/tests/test_sse_subscription.py
@@ -151,7 +151,12 @@ DOCUMENTED_FIELDS = {
 
 #: A minimal panel snapshot payload for the full-setup wiring tests
 #: (the shape ``snapshot_from_api_payload`` consumes; no children).
-MINIMAL_SNAPSHOT = {"today_iso": "2026-09-23", "cycle_day": 1, "children": []}
+MINIMAL_SNAPSHOT = {
+    "today_iso": "2026-09-23",
+    "cycle_day": 1,
+    "timezone": "",
+    "children": [],
+}
 
 
 # ---------------------------------------------------------------------------