diff --git a/openspec/changes/archive/2026/08/2026-08-07-fix-completed-today-stale-on-day-rollover/.openspec.yaml b/openspec/changes/archive/2026/08/2026-08-07-fix-completed-today-stale-on-day-rollover/.openspec.yaml
new file mode 100644
index 00000000..1c37182e
--- /dev/null
+++ b/openspec/changes/archive/2026/08/2026-08-07-fix-completed-today-stale-on-day-rollover/.openspec.yaml
@@ -0,0 +1,2 @@
+schema: spec-driven
+created: 2026-08-05
diff --git a/openspec/changes/archive/2026/08/2026-08-07-fix-completed-today-stale-on-day-rollover/design.md b/openspec/changes/archive/2026/08/2026-08-07-fix-completed-today-stale-on-day-rollover/design.md
new file mode 100644
index 00000000..e3b73337
--- /dev/null
+++ b/openspec/changes/archive/2026/08/2026-08-07-fix-completed-today-stale-on-day-rollover/design.md
@@ -0,0 +1,66 @@
+## Context
+
+Driven by FR1–FR8 of this change. "Today"-relative UI surfaces compute the logical date imperatively at render/`useMemo` time with no dependency on the passage of time. When the app stays mounted across a day boundary, the logical date the UI used is never recomputed, so five surfaces go stale (see proposal Impact): `ActiveTasksPage` completed-today (`ActiveTasksPage.tsx:145`), `CompletedPage` grouping (`CompletedPage.tsx:77`), `TaskItem` label (`TaskItem.tsx:244`), `GoalItem` label (`GoalItem.tsx:99`), `TaskDetailsTab` next-date label (`TaskDetailsTab.tsx:311`).
+
+Current constraints:
+- The only existing day-boundary timer lives inside `useHiddenTasksReveal.ts:37-62` (`scheduleNextBoundary`), but it only triggers hidden-task reveal — it never publishes a date to render state.
+- The repo already has the exact reactive pattern needed: `stores/menuOrderStore.ts` (module-level store: `getSnapshot`/`subscribe`/setter) consumed via `useSyncExternalStore` in `hooks/useMenuOrder.ts`. React 18.3, no external state library.
+- Time is always accessed through the `Clock` abstraction (`lib/temporal.ts`): `systemClock` in prod, `fakeClock` in tests. `vi.useFakeTimers`/`Date.now` are forbidden.
+
+## Goals / Non-Goals
+
+**Goals:**
+- Provide one shared reactive logical-date source so all five surfaces update on day rollover without a remount (FR1, FR3–FR7).
+- Keep exactly one boundary timer + one set of re-arm listeners app-wide (NFR-P1, FR2).
+- Extract the boundary-timer math into a shared helper reused by `useHiddenTasksReveal` with zero behavior change (FR8).
+
+**Non-Goals:**
+- Changing `getLogicalDate` or the day-boundary setting UI (NG1).
+- Changing reveal behavior (NG2) — pure refactor of its timer math.
+- Reactivity for authoring-time date defaults (NG3).
+
+## Decisions
+
+### D1: Components subscribe directly to a module-level store (not prop-drilling)
+
+`todayCompleted`/grouping consumers add the reactive date to their `useMemo` deps; leaf label components (`TaskItem`, `GoalItem`, `TaskDetailsTab`) call `useLogicalToday()` directly.
+
+**Why over prop-drilling the date from list parents:** a module-level store means the number of subscribers is decoupled from the number of timers — one timer regardless of list length (NFR-P1). Prop-drilling would still need the timer somewhere, and would additionally require threading a prop through `TaskList→TaskItem`, `GoalList→GoalItem`, and into `TaskDetailsTab` — five render paths, easy to miss one. Direct subscription has every consumer self-register, so no path can be forgotten.
+
+**Alternative considered — event-only (`dispatchEvent` on boundary, each consumer bumps local state):** rejected because it duplicates subscription bookkeeping in every component and has no single snapshot; `useSyncExternalStore` gives a consistent snapshot and tearing-free reads for free.
+
+### D2: Implement as `logicalTodayStore` + `useLogicalToday`, mirroring `menuOrderStore`/`useMenuOrder`
+
+- `stores/logicalTodayStore.ts`: holds `currentSnapshot: ISODate`, a `Set<Listener>`, and exports `getSnapshot()`, `subscribe(listener)`, plus internal recompute. Snapshot recomputed via `getLogicalDate(clock, getCachedDayBoundary())`; `emitChange()` only fires when the date string actually changes (avoids needless renders on spurious re-arms).
+- `hooks/useLogicalToday.ts`: `useSyncExternalStore(subscribe, getSnapshot)` — a one-line hook, exactly like `useMenuOrder`.
+- Testability: export `_resetForTesting()` and allow injecting a `Clock` (default `systemClock`) so `fakeClock` drives the store in tests — same seam the reveal tests use.
+
+### D3: Ref-counted lazy timer lifecycle (resolves proposal Q1)
+
+The store starts its boundary timer and attaches re-arm listeners (`visibilitychange`, `pageshow`, `DAY_BOUNDARY_CHANGED_EVENT`) when the **first** subscriber registers, and tears them down when the **last** unsubscribes.
+
+**Why over always-on from module load:** cleaner in tests (no dangling timer between cases), no work when no "today" surface is mounted, and it matches `useSyncExternalStore`'s subscribe/unsubscribe lifecycle. Trade-off: slightly more bookkeeping than a module-load singleton — acceptable and covered by unit tests.
+
+### D4: Extract `scheduleNextBoundary(clock, dayBoundary, onFire)` into a shared helper
+
+Move the pure `nextBoundary`/`msUntilBoundary` math (currently `useHiddenTasksReveal.ts:37-62`, incl. `BOUNDARY_BUFFER_MS`) into a shared module. `useHiddenTasksReveal` calls it with `onFire = revealTasks`; the store calls it with `onFire = recompute`. The helper self-reschedules via the caller re-invoking it inside `onFire` (same shape as today). No observable change to reveal (FR8) — guarded by the existing `useHiddenTasksReveal.midnight.test.ts`.
+
+### D5: Consumer wiring
+
+- `ActiveTasksPage`/`CompletedPage`: `const logicalToday = useLogicalToday();` added to the `useMemo` deps alongside `completedTasks`.
+- `TaskItem`/`GoalItem`/`TaskDetailsTab`: `useLogicalToday()` called (value used to key the label or simply to force re-render); label functions keep reading `getCachedDayBoundary()` as today. Because these are list leaves, subscribing them directly is what makes the labels reactive.
+
+## Risks / Trade-offs
+
+- **Every `TaskItem` in a long list subscribes to the store** → With a module-level store this is cheap (Set insert + one shared snapshot); still, re-render on rollover touches all mounted items at once. Mitigation: `emitChange` fires only on an actual date-string change (≤ once/day), so the mass re-render happens at most once per boundary.
+- **Refactoring `useHiddenTasksReveal`'s timer could regress reveal timing** → Mitigation: extraction is behavior-preserving and covered by `useHiddenTasksReveal.midnight.test.ts`; run it before/after.
+- **Timer drift / suspended tabs** (a backgrounded tab may not fire the timeout on time) → Mitigation: `visibilitychange`→visible and `pageshow` re-arm recompute immediately on return, so a missed timeout self-heals (U3).
+- **Two independent timers (reveal + store) firing near the same boundary** → Acceptable; they do different work and both use the shared helper with the same buffer. No shared mutable state between them.
+
+## Migration Plan
+
+Additive, no data migration. Deploy the store/hook/helper and rewire consumers together. Rollback = revert the change; no persisted state or schema is touched. No feature flag needed (client-only behavior, covered by tests).
+
+## Open Questions
+
+None — Q1 from the proposal is resolved by D3 (ref-counted lazy lifecycle).
diff --git a/openspec/changes/archive/2026/08/2026-08-07-fix-completed-today-stale-on-day-rollover/proposal.md b/openspec/changes/archive/2026/08/2026-08-07-fix-completed-today-stale-on-day-rollover/proposal.md
new file mode 100644
index 00000000..f4b899ab
--- /dev/null
+++ b/openspec/changes/archive/2026/08/2026-08-07-fix-completed-today-stale-on-day-rollover/proposal.md
@@ -0,0 +1,102 @@
+# Fix completed-today stale on day rollover
+
+## Why
+
+When the app stays open across a day boundary, "today"-relative surfaces freeze on the previous day: the "completed today" section on the Active Tasks page keeps showing yesterday's completed tasks until the user closes/reopens the app or navigates away and back. The logical date is computed imperatively inside `useMemo`/render with no dependency on the passage of time, so nothing forces a recompute when a new day begins. Users who leave the PWA open overnight see incorrect data every morning.
+
+## What Changes
+
+- **ADDED**: a single shared reactive source of the current logical date (`useLogicalToday`, backed by a module-level store consumed via `useSyncExternalStore`, mirroring the existing `menuOrderStore`/`useMenuOrder` pattern). It updates React state exactly when the logical day changes while the app stays mounted.
+- **ADDED**: an extracted `scheduleNextBoundary(clock, dayBoundary, onFire)` helper carrying the day-boundary timer math currently inlined in `useHiddenTasksReveal`, reused by both the reveal hook and the new store (single timer per app, ref-counted).
+- **MODIFIED**: `ActiveTasksPage` "completed today" section, `CompletedPage` grouping, `TaskItem` completed-at label, `GoalItem` date label, and `TaskDetailsTab` next-date label now recompute/re-render on logical-day change without a remount.
+- **ADDED**: an integration test that reproduces the bug (list frozen on yesterday) by advancing a fake clock across the boundary while mounted, then verifies the fix.
+
+## Capabilities
+
+### New Capabilities
+
+_None._
+
+### Modified Capabilities
+
+- `day-boundary`: adds a requirement that "today"-relative displays react to the logical day changing while the app stays mounted (not only on remount), via a shared reactive logical-date source and a single re-armed boundary timer.
+
+## Impact
+
+- **Code**: new `src/stores/logicalTodayStore.ts` + `src/hooks/useLogicalToday.ts`; extracted boundary-timer helper (from `src/hooks/useHiddenTasksReveal.ts`); edits to `src/pages/ActiveTasksPage.tsx`, `src/pages/CompletedPage.tsx`, `src/components/tasks/TaskItem.tsx`, `src/components/goals/GoalItem.tsx`, `src/components/tasks/TaskDetailsTab.tsx`.
+- **Behavior**: no data model, sync, or storage changes. No breaking changes. `useHiddenTasksReveal` behavior is preserved (pure refactor of its timer math).
+- **Tests**: new integration test crossing the boundary while mounted; unit tests for the store/hook and extracted helper; mutation testing on new logic.
+
+## Goals
+
+- **G1**: When the logical day changes while the app is open, the "completed today" section clears yesterday's tasks within one day-boundary tick (≤ boundary + buffer) — no user action, no remount.
+- **G2**: All five "today"-relative display surfaces stay correct across a day boundary without a remount.
+- **G3**: Exactly one boundary timer and one set of re-arm listeners exist regardless of how many list items are mounted.
+
+## Non-Goals
+
+- **NG1**: Changing how the logical date itself is computed (`getLogicalDate`) or the day-boundary setting UI.
+- **NG2**: Changing the reveal-of-hidden-tasks behavior in `useHiddenTasksReveal` (only its timer math is extracted, behavior unchanged).
+- **NG3**: Reactivity for authoring-time date defaults (e.g. `RepeatRuleSelector`, `HideTaskPanel`) — those are not "today" labels and are out of scope.
+
+## Users & Scenarios
+
+- **U1**: A user leaves the PWA open overnight. In the morning, without touching anything, the "completed today" section shows an empty (or newly-started) today, not yesterday's completions.
+- **U2**: A user with a custom day boundary (e.g. `04:00`) sees the section roll over at 04:00, not at midnight.
+- **U3**: A user returns to a backgrounded tab after the boundary passed; on becoming visible, the "today" surfaces are already correct.
+
+## Requirements
+
+### Functional
+
+- **FR1**: The system SHALL provide a shared reactive current-logical-date source that exposes the logical date (computed via `getLogicalDate` in the user's timezone and day boundary) as React state, updating when the logical day changes while the app stays mounted.
+- **FR2**: The reactive source SHALL schedule a single day-boundary timer (via the extracted `scheduleNextBoundary` helper) that self-reschedules, and SHALL re-arm/recompute on `visibilitychange` → visible, `pageshow` (persisted), and `DAY_BOUNDARY_CHANGED_EVENT`.
+- **FR3**: `ActiveTasksPage` "completed today" section SHALL recompute when the logical date changes, so tasks completed on the previous logical day leave the section at the boundary without a remount.
+- **FR4**: `CompletedPage` grouping SHALL recompute its Today/Yesterday/Week/Month buckets when the logical date changes without a remount.
+- **FR5**: `TaskItem` completed-at label ("Completed today/yesterday …") SHALL re-render to the correct label when the logical date changes without a remount.
+- **FR6**: `GoalItem` date label ("Today/Yesterday …") SHALL re-render to the correct label when the logical date changes without a remount.
+- **FR7**: `TaskDetailsTab` next-date label ("Today/Tomorrow …") SHALL re-render to the correct label when the logical date changes without a remount.
+- **FR8**: The day-boundary timer math SHALL be extracted into a reusable helper and reused by `useHiddenTasksReveal` with no change to its observable reveal behavior.
+
+### Non-Functional
+
+#### Performance
+
+- **NFR-P1**: Regardless of the number of mounted list items, the reactive source SHALL maintain at most one boundary timer and one set of global re-arm listeners (module-level store, ref-counted subscriptions).
+
+#### Accessibility
+
+- **NFR-A1**: The rollover update SHALL cause no accessibility regressions; axe-core checks on the affected pages SHALL remain green.
+
+## UX Acceptance Criteria
+
+- **UX1**: With the app open and a completed-today task visible, when the clock crosses the day boundary, the task disappears from the "completed today" section automatically within one boundary tick.
+- **UX2**: Yesterday's completed task never reappears in "completed today" after the rollover, even without navigation.
+- **UX3**: Custom day boundary is respected — the rollover happens at the configured time, not midnight.
+
+## UI States Matrix
+
+| Network | Data                                       | UI                                                              |
+|---------|--------------------------------------------|-----------------------------------------------------------------|
+| any     | before boundary, has today-completed tasks | tasks shown in "completed today"                                |
+| any     | boundary crosses, no new completions       | "completed today" empty state                                   |
+| any     | boundary crosses, list unchanged otherwise | grouping/labels update; other sections unaffected               |
+| offline | boundary crosses                           | rollover still occurs (timer is client-side, no network needed) |
+
+## Behavior
+
+See `features/day_boundary_rollover.feature` (tags `@fix-completed-today-stale-on-day-rollover`).
+
+## Affected IA
+
+No changes.
+
+## Success Metrics
+
+- **M1**: An integration test reproduces the bug on the pre-fix code (fails: yesterday's task still shown after the clock crosses the boundary while mounted) and passes after the fix.
+- **M2**: After the boundary crosses while mounted, zero previous-logical-day completed tasks remain in the "completed today" section.
+- **M3**: Mutation score on new store/hook/helper code ≥ 90% (target ≥ 95%).
+
+## Open Questions
+
+- **Q1**: Timer lifecycle — ref-counted lazy start/stop (start on first subscriber, stop on last) vs. always-on from module load. Leaning ref-counted for cleaner tests and background behavior. Resolved in `design.md`.
diff --git a/openspec/changes/archive/2026/08/2026-08-07-fix-completed-today-stale-on-day-rollover/specs/day-boundary/spec.md b/openspec/changes/archive/2026/08/2026-08-07-fix-completed-today-stale-on-day-rollover/specs/day-boundary/spec.md
new file mode 100644
index 00000000..1ee0538f
--- /dev/null
+++ b/openspec/changes/archive/2026/08/2026-08-07-fix-completed-today-stale-on-day-rollover/specs/day-boundary/spec.md
@@ -0,0 +1,81 @@
+## ADDED Requirements
+
+### Requirement: Reactive current logical date source
+# implements FR1, FR2 of fix-completed-today-stale-on-day-rollover
+
+The system SHALL provide a shared reactive source of the current logical date that exposes the logical date (computed via `getLogicalDate` in the user's timezone and configured day boundary) to React as state via `useSyncExternalStore`. The source SHALL update its value when the logical day changes while the app stays mounted, by scheduling a single self-rescheduling day-boundary timer. It SHALL also recompute on `visibilitychange` → visible, on `pageshow` when persisted, and on `DAY_BOUNDARY_CHANGED_EVENT`. On return to visibility (`visibilitychange` → visible and persisted `pageshow`) and on `DAY_BOUNDARY_CHANGED_EVENT` the source SHALL additionally re-arm (clear and reschedule) the day-boundary timer, because the timezone or configured boundary may have changed while the app was inactive, leaving the timer aimed at a stale instant. This mirrors the re-arm behavior of `useHiddenTasksReveal`, the other consumer of `scheduleNextBoundary`. It SHALL emit a change to subscribers only when the logical date value actually changes.
+
+#### Scenario: Value updates when boundary is crossed while mounted
+- **WHEN** a component subscribes to the source, current logical date is June 4, and the clock advances past the day boundary into June 5
+- **THEN** the source emits and its value becomes June 5 without any remount
+
+#### Scenario: No emit when re-armed but date unchanged
+- **WHEN** the source recomputes (e.g. on visibilitychange) but the logical date is unchanged
+- **THEN** no change is emitted to subscribers
+
+#### Scenario: Recompute on return to visibility after boundary passed
+- **WHEN** the tab was hidden while the clock crossed the boundary and then becomes visible
+- **THEN** the source recomputes immediately and reflects the new logical date
+
+#### Scenario: Re-arm boundary timer on return to visibility after timezone change
+- **WHEN** the tab was hidden while the timezone changed and then becomes visible (or a persisted `pageshow` fires)
+- **THEN** the source clears the existing boundary timer and reschedules it against the current timezone and boundary, so the next boundary fires at the correct instant
+
+#### Scenario: Recompute on day boundary setting change
+- **WHEN** `DAY_BOUNDARY_CHANGED_EVENT` fires and the new boundary changes the current logical date
+- **THEN** the source recomputes and emits the new logical date
+
+### Requirement: Single boundary timer regardless of subscriber count
+# implements NFR-P1, FR2 of fix-completed-today-stale-on-day-rollover
+
+The reactive logical-date source SHALL maintain at most one day-boundary timer and one set of global re-arm listeners regardless of how many components are subscribed. The timer and listeners SHALL be created when the first subscriber registers and torn down when the last subscriber unsubscribes.
+
+#### Scenario: Many subscribers share one timer
+- **WHEN** many list items subscribe to the source
+- **THEN** exactly one boundary timer and one set of re-arm listeners exist
+
+#### Scenario: Teardown on last unsubscribe
+- **WHEN** the last subscriber unsubscribes
+- **THEN** the boundary timer is cleared and the re-arm listeners are removed
+
+### Requirement: Today-relative displays react to day rollover without remount
+# implements FR3, FR4, FR5, FR6, FR7 of fix-completed-today-stale-on-day-rollover
+
+Every "today"-relative display surface SHALL recompute or re-render when the reactive logical date changes, without requiring a remount. This applies to: the ActiveTasksPage "completed today" section, the CompletedPage grouping, the TaskItem completed-at label, the GoalItem date label, and the TaskDetailsTab next-date label.
+
+#### Scenario: Completed-today section clears yesterday's tasks at boundary
+- **WHEN** the ActiveTasksPage is mounted showing a task completed on the previous logical day, and the clock crosses the day boundary
+- **THEN** the task is removed from the "completed today" section without a remount
+
+#### Scenario: Completed page grouping rebuckets at boundary
+- **WHEN** the CompletedPage is mounted and the clock crosses the day boundary
+- **THEN** a task previously in the "Today" group moves to the "Yesterday" group without a remount
+
+#### Scenario: TaskItem label updates at boundary
+- **WHEN** a TaskItem shows a "completed today" label and the clock crosses the day boundary
+- **THEN** the label re-renders to the "completed yesterday" (previous-day) form without a remount
+
+#### Scenario: GoalItem label updates at boundary
+- **WHEN** a GoalItem shows a "Today" date label and the clock crosses the day boundary
+- **THEN** the label re-renders to the "Yesterday" form without a remount
+
+#### Scenario: TaskDetailsTab next-date label updates at boundary
+- **WHEN** a TaskDetailsTab shows a next-date "Today"/"Tomorrow" label and the clock crosses the day boundary
+- **THEN** the label re-renders to the correct relative form without a remount
+
+#### Scenario: Custom day boundary respected for rollover
+- **WHEN** the day boundary is "04:00" and the app is mounted with a task completed at 10:00 on June 4, and the clock advances to 04:00 on June 5
+- **THEN** the task leaves the "completed today" section exactly at the 04:00 rollover, not at midnight
+
+### Requirement: Shared boundary-timer helper reused by hidden-task reveal
+# implements FR8 of fix-completed-today-stale-on-day-rollover
+
+The day-boundary timer math SHALL be extracted into a reusable `scheduleNextBoundary(clock, dayBoundary, onFire)` helper and reused by both `useHiddenTasksReveal` and the reactive logical-date source. The extraction SHALL NOT change the observable reveal behavior of `useHiddenTasksReveal`.
+
+#### Scenario: Reveal behavior unchanged after extraction
+- **WHEN** the hidden-task reveal runs across a day boundary using the extracted helper
+- **THEN** hidden tasks are revealed at the boundary exactly as before the refactor
+
+#### Scenario: Helper schedules next boundary for non-midnight time
+- **WHEN** `scheduleNextBoundary` is called with day boundary "02:00" and current time 23:00
+- **THEN** the scheduled fire time is the next 02:00 occurrence (plus the boundary buffer)
diff --git a/openspec/changes/archive/2026/08/2026-08-07-fix-completed-today-stale-on-day-rollover/tasks.md b/openspec/changes/archive/2026/08/2026-08-07-fix-completed-today-stale-on-day-rollover/tasks.md
new file mode 100644
index 00000000..d2e5f677
--- /dev/null
+++ b/openspec/changes/archive/2026/08/2026-08-07-fix-completed-today-stale-on-day-rollover/tasks.md
@@ -0,0 +1,41 @@
+## 1. Reproduce the bug (RED integration test)
+
+- [x] 1.1 Add a failing integration test that mounts `ActiveTasksPage` with a task completed on the previous logical day, advances a `fakeClock` across the day boundary WITHOUT remount/rerender, drives the boundary timer, and asserts the task is gone from "completed today" (FR3, M1). Confirm it FAILS on current code.
+- [x] 1.2 Add a parallel RED case for a custom day boundary ("04:00") verifying rollover happens at 04:00, not midnight (UX3, FR3). Confirm it FAILS.
+
+## 2. Extract shared boundary-timer helper (FR8)
+
+- [x] 2.1 RED: write unit tests for `scheduleNextBoundary(clock, dayBoundary, onFire)` covering next-boundary-today vs next-day and the boundary buffer, using `fakeClock` (FR8).
+- [x] 2.2 GREEN: extract the `nextBoundary`/`msUntilBoundary` math and `BOUNDARY_BUFFER_MS` from `useHiddenTasksReveal.ts` into a shared `src/utils/scheduleNextBoundary.ts` helper, imported by path per the `src/utils/` convention (no barrel `index.ts`) (FR8).
+- [x] 2.3 Refactor `useHiddenTasksReveal` to call the helper; run `useHiddenTasksReveal.midnight.test.ts` to prove reveal behavior is unchanged (FR8).
+
+## 3. Reactive logical-date store (FR1, FR2, NFR-P1)
+
+- [x] 3.1 RED: unit tests for `logicalTodayStore` — `getSnapshot` returns current logical date; `subscribe` triggers on boundary cross; emits only on actual date change; ref-counted timer/listener setup on first subscribe and teardown on last unsubscribe; recompute on `visibilitychange`/`pageshow`/`DAY_BOUNDARY_CHANGED_EVENT`; `_resetForTesting` + injectable `Clock` (FR1, FR2, NFR-P1).
+- [x] 3.2 GREEN: implement `src/stores/logicalTodayStore.ts` mirroring `menuOrderStore.ts`, using the extracted helper and `getLogicalDate(clock, getCachedDayBoundary())` (FR1, FR2, NFR-P1).
+- [x] 3.3 Implement `src/hooks/useLogicalToday.ts` via `useSyncExternalStore(subscribe, getSnapshot)`, mirroring `useMenuOrder.ts` (FR1).
+
+## 4. Wire consumers to the reactive date
+
+- [x] 4.1 `ActiveTasksPage.tsx`: add `useLogicalToday()` to `todayCompleted` `useMemo` deps (FR3).
+- [x] 4.2 `CompletedPage.tsx`: add `useLogicalToday()` to the grouping `useMemo` deps (FR4).
+- [x] 4.3 `TaskItem.tsx`: subscribe via `useLogicalToday()` so the completed-at label re-renders on rollover (FR5).
+- [x] 4.4 `GoalItem.tsx`: subscribe via `useLogicalToday()` so the date label re-renders on rollover (FR6).
+- [x] 4.5 `TaskDetailsTab.tsx`: subscribe via `useLogicalToday()` so the next-date label re-renders on rollover (FR7).
+
+## 5. Turn the bug tests GREEN
+
+- [x] 5.1 Run the section-1 integration tests; confirm they now PASS (M1, M2).
+- [x] 5.2 Add integration assertions for `CompletedPage` rebucketing and for a `TaskItem`/`GoalItem` label flip across the boundary while mounted (FR4, FR5, FR6).
+- [x] 5.3 Add a `TaskDetailsTab` next-date label flip test (`TaskDetailsTab.dayRollover.test.tsx`): mount with a repeating task whose `next_date` is tomorrow, cross the boundary while mounted, assert the label flips "завтра" → "сегодня" without remount (FR7).
+
+## 6. BDD behavior spec
+
+- [x] 6.1 Author `features/day_boundary_rollover.feature` with `@fix-completed-today-stale-on-day-rollover` scenarios mirroring the spec (rollover clears completed-today, custom boundary, no-emit-when-unchanged) (FR3, FR2).
+- [x] 6.2 Implement step definitions using `fakeClock` (no `vi.useFakeTimers`) (FR3).
+
+## 7. Verification
+
+- [x] 7.1 axe-core check on `ActiveTasksPage` and `CompletedPage` remains green after rollover (NFR-A1). E2e scenarios cross the day boundary in place (`page.clock` + `visibilitychange`) and scan the POST-rollover DOM — the active page after the completed-today task leaves, and the completed page after the task regroups into "yesterday" — not only the pre-rollover state.
+- [x] 7.2 `get_file_problems` on all changed files; fix errors; run `pnpm run build`.
+- [x] 7.3 Mutation testing (scoped) on `logicalTodayStore.ts`, `useLogicalToday.ts`, and the extracted helper; add tests to kill survivors; target ≥95%, minimum ≥90% (M3). Full Stryker run is delegated to the user.
diff --git a/openspec/specs/day-boundary/spec.md b/openspec/specs/day-boundary/spec.md
index a8d68928..c0f71e6e 100644
--- a/openspec/specs/day-boundary/spec.md
+++ b/openspec/specs/day-boundary/spec.md
@@ -192,3 +192,83 @@ The Settings page SHALL include a "Day start time" section with an `<input type=
 #### Scenario: Default value shown for new users
 - **WHEN** no day_boundary setting exists
 - **THEN** the picker shows "00:00"
+
+### Requirement: Reactive current logical date source
+# implements FR1, FR2 of fix-completed-today-stale-on-day-rollover
+
+The system SHALL provide a shared reactive source of the current logical date that exposes the logical date (computed via `getLogicalDate` in the user's timezone and configured day boundary) to React as state via `useSyncExternalStore`. The source SHALL update its value when the logical day changes while the app stays mounted, by scheduling a single self-rescheduling day-boundary timer. It SHALL also recompute on `visibilitychange` → visible, on `pageshow` when persisted, and on `DAY_BOUNDARY_CHANGED_EVENT`. On return to visibility (`visibilitychange` → visible and persisted `pageshow`) and on `DAY_BOUNDARY_CHANGED_EVENT` the source SHALL additionally re-arm (clear and reschedule) the day-boundary timer, because the timezone or configured boundary may have changed while the app was inactive, leaving the timer aimed at a stale instant. This mirrors the re-arm behavior of `useHiddenTasksReveal`, the other consumer of `scheduleNextBoundary`. It SHALL emit a change to subscribers only when the logical date value actually changes.
+
+#### Scenario: Value updates when boundary is crossed while mounted
+- **WHEN** a component subscribes to the source, current logical date is June 4, and the clock advances past the day boundary into June 5
+- **THEN** the source emits and its value becomes June 5 without any remount
+
+#### Scenario: No emit when re-armed but date unchanged
+- **WHEN** the source recomputes (e.g. on visibilitychange) but the logical date is unchanged
+- **THEN** no change is emitted to subscribers
+
+#### Scenario: Recompute on return to visibility after boundary passed
+- **WHEN** the tab was hidden while the clock crossed the boundary and then becomes visible
+- **THEN** the source recomputes immediately and reflects the new logical date
+
+#### Scenario: Re-arm boundary timer on return to visibility after timezone change
+- **WHEN** the tab was hidden while the timezone changed and then becomes visible (or a persisted `pageshow` fires)
+- **THEN** the source clears the existing boundary timer and reschedules it against the current timezone and boundary, so the next boundary fires at the correct instant
+
+#### Scenario: Recompute on day boundary setting change
+- **WHEN** `DAY_BOUNDARY_CHANGED_EVENT` fires and the new boundary changes the current logical date
+- **THEN** the source recomputes and emits the new logical date
+
+### Requirement: Single boundary timer regardless of subscriber count
+# implements NFR-P1, FR2 of fix-completed-today-stale-on-day-rollover
+
+The reactive logical-date source SHALL maintain at most one day-boundary timer and one set of global re-arm listeners regardless of how many components are subscribed. The timer and listeners SHALL be created when the first subscriber registers and torn down when the last subscriber unsubscribes.
+
+#### Scenario: Many subscribers share one timer
+- **WHEN** many list items subscribe to the source
+- **THEN** exactly one boundary timer and one set of re-arm listeners exist
+
+#### Scenario: Teardown on last unsubscribe
+- **WHEN** the last subscriber unsubscribes
+- **THEN** the boundary timer is cleared and the re-arm listeners are removed
+
+### Requirement: Today-relative displays react to day rollover without remount
+# implements FR3, FR4, FR5, FR6, FR7 of fix-completed-today-stale-on-day-rollover
+
+Every "today"-relative display surface SHALL recompute or re-render when the reactive logical date changes, without requiring a remount. This applies to: the ActiveTasksPage "completed today" section, the CompletedPage grouping, the TaskItem completed-at label, the GoalItem date label, and the TaskDetailsTab next-date label.
+
+#### Scenario: Completed-today section clears yesterday's tasks at boundary
+- **WHEN** the ActiveTasksPage is mounted showing a task completed on the previous logical day, and the clock crosses the day boundary
+- **THEN** the task is removed from the "completed today" section without a remount
+
+#### Scenario: Completed page grouping rebuckets at boundary
+- **WHEN** the CompletedPage is mounted and the clock crosses the day boundary
+- **THEN** a task previously in the "Today" group moves to the "Yesterday" group without a remount
+
+#### Scenario: TaskItem label updates at boundary
+- **WHEN** a TaskItem shows a "completed today" label and the clock crosses the day boundary
+- **THEN** the label re-renders to the "completed yesterday" (previous-day) form without a remount
+
+#### Scenario: GoalItem label updates at boundary
+- **WHEN** a GoalItem shows a "Today" date label and the clock crosses the day boundary
+- **THEN** the label re-renders to the "Yesterday" form without a remount
+
+#### Scenario: TaskDetailsTab next-date label updates at boundary
+- **WHEN** a TaskDetailsTab shows a next-date "Today"/"Tomorrow" label and the clock crosses the day boundary
+- **THEN** the label re-renders to the correct relative form without a remount
+
+#### Scenario: Custom day boundary respected for rollover
+- **WHEN** the day boundary is "04:00" and the app is mounted with a task completed at 10:00 on June 4, and the clock advances to 04:00 on June 5
+- **THEN** the task leaves the "completed today" section exactly at the 04:00 rollover, not at midnight
+
+### Requirement: Shared boundary-timer helper reused by hidden-task reveal
+# implements FR8 of fix-completed-today-stale-on-day-rollover
+
+The day-boundary timer math SHALL be extracted into a reusable `scheduleNextBoundary(clock, dayBoundary, onFire)` helper and reused by both `useHiddenTasksReveal` and the reactive logical-date source. The extraction SHALL NOT change the observable reveal behavior of `useHiddenTasksReveal`.
+
+#### Scenario: Reveal behavior unchanged after extraction
+- **WHEN** the hidden-task reveal runs across a day boundary using the extracted helper
+- **THEN** hidden tasks are revealed at the boundary exactly as before the refactor
+
+#### Scenario: Helper schedules next boundary for non-midnight time
+- **WHEN** `scheduleNextBoundary` is called with day boundary "02:00" and current time 23:00
+- **THEN** the scheduled fire time is the next 02:00 occurrence (plus the boundary buffer)
diff --git a/packages/client/src/components/goals/GoalItem.dayRollover.test.tsx b/packages/client/src/components/goals/GoalItem.dayRollover.test.tsx
new file mode 100644
index 00000000..f416bbaf
--- /dev/null
+++ b/packages/client/src/components/goals/GoalItem.dayRollover.test.tsx
@@ -0,0 +1,101 @@
+import { act, render, screen, waitFor } from "@testing-library/react";
+import { MemoryRouter } from "react-router-dom";
+import { describe, expect, it, vi } from "vitest";
+import { DAY_BOUNDARY_CHANGED_EVENT } from "@/constants";
+import { type Clock, fakeClock } from "@/lib/temporal";
+import { buildGoal } from "@/test/factories/goalFactory";
+import { GoalItem } from "./GoalItem";
+
+vi.mock("@/hooks/useIsUnsynced", () => ({
+  useIsUnsynced: vi.fn().mockReturnValue(false),
+}));
+vi.mock("@/hooks/useAttachmentCount", () => ({
+  useAttachmentCount: vi.fn().mockReturnValue({
+    attachmentCount: 0,
+    hasUnsyncedAttachments: false,
+    isLoading: false,
+  }),
+}));
+vi.mock("@/hooks/usePanelSide", () => ({
+  usePanelSide: vi
+    .fn()
+    .mockReturnValue({ panelSide: "right", setPanelSide: vi.fn() }),
+}));
+vi.mock("@/hooks/useFileUrl", () => ({
+  useFileUrl: vi.fn().mockReturnValue({ url: null }),
+}));
+
+const clockState = vi.hoisted(() => ({
+  fakeClockOverride: null as unknown,
+}));
+
+vi.mock("@/lib/temporal", async (importOriginal) => {
+  const actualTemporal =
+    await importOriginal<typeof import("@/lib/temporal")>();
+  const resolveClock = () =>
+    (clockState.fakeClockOverride as typeof actualTemporal.systemClock) ??
+    actualTemporal.systemClock;
+  return {
+    ...actualTemporal,
+    systemClock: {
+      instant: () => resolveClock().instant(),
+      plainDateISO: () => resolveClock().plainDateISO(),
+      timeZoneId: () => resolveClock().timeZoneId(),
+    },
+  };
+});
+
+function setFakeClock(isoTimestamp: string, timeZone?: string) {
+  clockState.fakeClockOverride = fakeClock(
+    isoTimestamp,
+    timeZone,
+  ) as unknown as Clock;
+}
+
+function renderGoalItem(overrides = {}) {
+  const goal = buildGoal();
+  const props = {
+    goal,
+    taskCount: 0,
+    onNavigate: vi.fn(),
+    ...overrides,
+  };
+  render(
+    <MemoryRouter>
+      <GoalItem {...props} />
+    </MemoryRouter>,
+  );
+  return props;
+}
+
+/**
+ * Reproduces FR6 of fix-completed-today-stale-on-day-rollover: the finished
+ * goal's date label must re-render with the correct relative day when the
+ * logical day changes while the item stays mounted, not only on remount.
+ */
+describe("GoalItem — day boundary rollover", () => {
+  // implements FR6 of fix-completed-today-stale-on-day-rollover
+  it("should flip the finished-at label from today to yesterday when the day boundary is crossed while mounted", async () => {
+    setFakeClock("2026-06-04T20:00:00Z", "UTC");
+    const goal = buildGoal({
+      status: "completed",
+      updated_at: "2026-06-04T10:00:00.000Z",
+    });
+    renderGoalItem({ goal });
+
+    expect(screen.getByTestId("goal-item-finished-at")).toHaveTextContent(
+      /Сегодня/,
+    );
+
+    setFakeClock("2026-06-05T00:30:00Z", "UTC");
+    act(() => {
+      window.dispatchEvent(new CustomEvent(DAY_BOUNDARY_CHANGED_EVENT));
+    });
+
+    await waitFor(() => {
+      expect(screen.getByTestId("goal-item-finished-at")).toHaveTextContent(
+        /Вчера/,
+      );
+    });
+  });
+});
diff --git a/packages/client/src/components/goals/GoalItem.tsx b/packages/client/src/components/goals/GoalItem.tsx
index ab963692..13a92dea 100644
--- a/packages/client/src/components/goals/GoalItem.tsx
+++ b/packages/client/src/components/goals/GoalItem.tsx
@@ -4,6 +4,7 @@ import defaultCoverSvg from "@/assets/default-goal-cover.svg";
 import { ENTITY_TYPE, FINISHED_GOAL_STATUSES } from "@/constants";
 import { useAttachmentCount } from "@/hooks/useAttachmentCount";
 import { useFileUrl } from "@/hooks/useFileUrl";
+import { useLogicalToday } from "@/hooks/useLogicalToday";
 import { usePanelSide } from "@/hooks/usePanelSide";
 import { getCachedDayBoundary } from "@/hooks/useSettings";
 import { cn } from "@/shared/lib/cn";
@@ -45,6 +46,8 @@ export function GoalItem({
   );
   const { panelSide } = usePanelSide();
   const { url: coverUrl } = useFileUrl(goal.cover_hash);
+  // implements FR6 of fix-completed-today-stale-on-day-rollover
+  useLogicalToday();
   return (
     <li
       ref={nodeRef}
diff --git a/packages/client/src/components/tasks/TaskDetailsTab.dayRollover.test.tsx b/packages/client/src/components/tasks/TaskDetailsTab.dayRollover.test.tsx
new file mode 100644
index 00000000..78b07671
--- /dev/null
+++ b/packages/client/src/components/tasks/TaskDetailsTab.dayRollover.test.tsx
@@ -0,0 +1,127 @@
+import { act, render, screen, waitFor } from "@testing-library/react";
+import { describe, expect, it, vi } from "vitest";
+import { DAY_BOUNDARY_CHANGED_EVENT } from "@/constants";
+import { type Clock, fakeClock } from "@/lib/temporal";
+import { buildTask } from "@/test/factories/taskFactory";
+import type { Box, RepeatRule } from "@/types/common";
+
+vi.mock("@/hooks/useSettings", async (importOriginal) => ({
+  ...(await importOriginal<typeof import("@/hooks/useSettings")>()),
+  useSettings: () => ({ defaultBox: "today" }),
+}));
+
+vi.mock("@/hooks/useRepeatRuleChangeDialog", () => ({
+  useRepeatRuleChangeDialog: () => ({
+    pendingRuleChange: null,
+    handleRepeatChange: vi.fn(),
+    handleRuleChangeConfirm: vi.fn(),
+    handleRuleChangeCancel: vi.fn(),
+  }),
+}));
+
+vi.mock("@/components/ui/EditableDescription", () => ({
+  EditableDescription: () => <textarea data-testid="mock-description" />,
+}));
+
+vi.mock("./TaskDetailSelector", () => ({
+  TaskDetailSelector: () => <div data-testid="mock-selector" />,
+}));
+
+const clockState = vi.hoisted(() => ({
+  fakeClockOverride: null as unknown,
+}));
+
+vi.mock("@/lib/temporal", async (importOriginal) => {
+  const actualTemporal =
+    await importOriginal<typeof import("@/lib/temporal")>();
+  const resolveClock = () =>
+    (clockState.fakeClockOverride as typeof actualTemporal.systemClock) ??
+    actualTemporal.systemClock;
+  return {
+    ...actualTemporal,
+    systemClock: {
+      instant: () => resolveClock().instant(),
+      plainDateISO: () => resolveClock().plainDateISO(),
+      timeZoneId: () => resolveClock().timeZoneId(),
+    },
+  };
+});
+
+function setFakeClock(isoTimestamp: string, timeZone?: string) {
+  clockState.fakeClockOverride = fakeClock(
+    isoTimestamp,
+    timeZone,
+  ) as unknown as Clock;
+}
+
+// Import after mocks so the mocked systemClock is captured everywhere.
+const { TaskDetailsTab } = await import("./TaskDetailsTab");
+
+const VALID_DAILY_RULE: RepeatRule = {
+  type: "fixed",
+  frequency: "daily",
+  interval: 1,
+  target_box: "today" as Box,
+  advance_days: 0,
+};
+
+function detailsTabProps(
+  overrides: Partial<Parameters<typeof TaskDetailsTab>[0]> = {},
+): Parameters<typeof TaskDetailsTab>[0] {
+  return {
+    task: buildTask(),
+    onUpdate: vi.fn().mockResolvedValue(undefined),
+    onMove: vi.fn().mockResolvedValue(undefined),
+    onDuplicate: vi.fn().mockResolvedValue(undefined),
+    description: "",
+    setDescription: vi.fn(),
+    selectedBox: "today" as Box,
+    setSelectedBox: vi.fn(),
+    selectedGoalId: "",
+    setSelectedGoalId: vi.fn(),
+    selectedGoalName: "",
+    selectedContextId: "",
+    setSelectedContextId: vi.fn(),
+    selectedContextName: "",
+    selectedCategoryId: "",
+    setSelectedCategoryId: vi.fn(),
+    selectedCategoryName: "",
+    selectedRepeatRule: VALID_DAILY_RULE,
+    setSelectedRepeatRule: vi.fn(),
+    goals: [],
+    contexts: [],
+    categories: [],
+    openSelector: null,
+    onOpenSelector: vi.fn(),
+    onCloseSelector: vi.fn(),
+    ...overrides,
+  };
+}
+
+/**
+ * Reproduces FR7 of fix-completed-today-stale-on-day-rollover: the next-date
+ * "Today"/"Tomorrow" label must re-render with the correct relative day when
+ * the logical day changes while the tab stays mounted, not only on remount.
+ */
+describe("TaskDetailsTab — day boundary rollover", () => {
+  // implements FR7 of fix-completed-today-stale-on-day-rollover
+  it("should flip the next-date label from tomorrow to today when the day boundary is crossed while mounted", async () => {
+    setFakeClock("2026-06-04T20:00:00Z", "UTC");
+    const task = buildTask({
+      repeat_rule: JSON.stringify(VALID_DAILY_RULE),
+      next_date: "2026-06-05",
+    });
+    render(<TaskDetailsTab {...detailsTabProps({ task })} />);
+
+    expect(screen.getByTestId("next-date-line")).toHaveTextContent(/завтра/);
+
+    setFakeClock("2026-06-05T00:30:00Z", "UTC");
+    act(() => {
+      window.dispatchEvent(new CustomEvent(DAY_BOUNDARY_CHANGED_EVENT));
+    });
+
+    await waitFor(() => {
+      expect(screen.getByTestId("next-date-line")).toHaveTextContent(/сегодня/);
+    });
+  });
+});
diff --git a/packages/client/src/components/tasks/TaskDetailsTab.test.tsx b/packages/client/src/components/tasks/TaskDetailsTab.test.tsx
index 45f7694c..6a97d4b5 100644
--- a/packages/client/src/components/tasks/TaskDetailsTab.test.tsx
+++ b/packages/client/src/components/tasks/TaskDetailsTab.test.tsx
@@ -12,7 +12,8 @@ vi.mock("react-i18next", () => ({
   }),
 }));
 
-vi.mock("@/hooks/useSettings", () => ({
+vi.mock("@/hooks/useSettings", async (importOriginal) => ({
+  ...(await importOriginal<typeof import("@/hooks/useSettings")>()),
   useSettings: () => ({ defaultBox: "today" }),
 }));
 
diff --git a/packages/client/src/components/tasks/TaskDetailsTab.tsx b/packages/client/src/components/tasks/TaskDetailsTab.tsx
index c9a60f49..2bbb8a96 100644
--- a/packages/client/src/components/tasks/TaskDetailsTab.tsx
+++ b/packages/client/src/components/tasks/TaskDetailsTab.tsx
@@ -2,6 +2,7 @@ import { useCallback } from "react";
 import { useTranslation } from "react-i18next";
 import { ConfirmDialog } from "@/components/shared/ConfirmDialog";
 import { EditableDescription } from "@/components/ui/EditableDescription";
+import { useLogicalToday } from "@/hooks/useLogicalToday";
 import { useRepeatRuleChangeDialog } from "@/hooks/useRepeatRuleChangeDialog";
 import { useSettings } from "@/hooks/useSettings";
 import { systemClock } from "@/lib/temporal";
@@ -80,6 +81,8 @@ export function TaskDetailsTab({
 }: TaskDetailsTabProps) {
   const { t } = useTranslation();
   const { defaultBox } = useSettings();
+  // implements FR7 of fix-completed-today-stale-on-day-rollover
+  useLogicalToday();
   const DescriptionIcon = TASK_DETAIL_ICONS.description;
   const DuplicateIcon = TASK_DETAIL_ICONS.duplicate;
 
diff --git a/packages/client/src/components/tasks/TaskItem.completion.test.tsx b/packages/client/src/components/tasks/TaskItem.completion.test.tsx
index 85a7f028..5960b133 100644
--- a/packages/client/src/components/tasks/TaskItem.completion.test.tsx
+++ b/packages/client/src/components/tasks/TaskItem.completion.test.tsx
@@ -35,6 +35,13 @@ vi.mock("@/hooks/useAttachmentCount", () => ({
   }),
 }));
 
+// logicalTodayStore schedules a self-rescheduling real setTimeout; under
+// vi.useFakeTimers() + vi.runAllTimers() that loops forever, so it's
+// stubbed here since these tests don't exercise day-rollover behavior.
+vi.mock("@/hooks/useLogicalToday", () => ({
+  useLogicalToday: vi.fn().mockReturnValue("2025-01-15"),
+}));
+
 describe("TaskItem — completion", () => {
   afterEach(() => {
     vi.useRealTimers();
diff --git a/packages/client/src/components/tasks/TaskItem.dayRollover.test.tsx b/packages/client/src/components/tasks/TaskItem.dayRollover.test.tsx
new file mode 100644
index 00000000..8a4c51b5
--- /dev/null
+++ b/packages/client/src/components/tasks/TaskItem.dayRollover.test.tsx
@@ -0,0 +1,112 @@
+import { act, render, screen, waitFor } from "@testing-library/react";
+import { describe, expect, it, vi } from "vitest";
+import { DAY_BOUNDARY_CHANGED_EVENT } from "@/constants";
+import { type Clock, fakeClock } from "@/lib/temporal";
+import { buildTask } from "@/test/factories/taskFactory";
+import { TaskItem } from "./TaskItem";
+
+vi.mock("@/hooks/useChecklist", () => ({
+  useChecklist: vi.fn().mockReturnValue({
+    items: [],
+    progress: { completed: 0, total: 0 },
+    hasUnsyncedItems: false,
+    isLoading: false,
+    reload: vi.fn(),
+    createItem: vi.fn(),
+    toggleItem: vi.fn(),
+    updateItem: vi.fn(),
+    deleteItem: vi.fn(),
+    reorderItems: vi.fn(),
+  }),
+}));
+
+vi.mock("@/hooks/useIsDesktop", () => ({
+  useIsDesktop: vi.fn().mockReturnValue(false),
+}));
+
+vi.mock("@/hooks/useHasTouchPointer", () => ({
+  useHasTouchPointer: vi.fn().mockReturnValue(false),
+}));
+
+vi.mock("@/hooks/useAttachmentCount", () => ({
+  useAttachmentCount: vi.fn().mockReturnValue({
+    attachmentCount: 0,
+    hasUnsyncedAttachments: false,
+    isLoading: false,
+  }),
+}));
+
+const clockState = vi.hoisted(() => ({
+  fakeClockOverride: null as unknown,
+}));
+
+vi.mock("@/lib/temporal", async (importOriginal) => {
+  const actualTemporal =
+    await importOriginal<typeof import("@/lib/temporal")>();
+  const resolveClock = () =>
+    (clockState.fakeClockOverride as typeof actualTemporal.systemClock) ??
+    actualTemporal.systemClock;
+  return {
+    ...actualTemporal,
+    systemClock: {
+      instant: () => resolveClock().instant(),
+      plainDateISO: () => resolveClock().plainDateISO(),
+      timeZoneId: () => resolveClock().timeZoneId(),
+    },
+  };
+});
+
+function setFakeClock(isoTimestamp: string, timeZone?: string) {
+  clockState.fakeClockOverride = fakeClock(
+    isoTimestamp,
+    timeZone,
+  ) as unknown as Clock;
+}
+
+function taskItemProps(
+  overrides: Partial<Parameters<typeof TaskItem>[0]> = {},
+): Parameters<typeof TaskItem>[0] {
+  return {
+    task: buildTask(),
+    goals: [],
+    contexts: [],
+    categories: [],
+    onComplete: vi.fn(),
+    onUpdate: vi.fn().mockResolvedValue(undefined),
+    onMove: vi.fn().mockResolvedValue(undefined),
+    onDelete: vi.fn(),
+    ...overrides,
+  };
+}
+
+/**
+ * Reproduces FR5 of fix-completed-today-stale-on-day-rollover: the
+ * completed-at label must re-render with the correct relative day when the
+ * logical day changes while the item stays mounted, not only on remount.
+ */
+describe("TaskItem — day boundary rollover", () => {
+  // implements FR5 of fix-completed-today-stale-on-day-rollover
+  it("should flip the completed-at label from today to yesterday when the day boundary is crossed while mounted", async () => {
+    setFakeClock("2026-06-04T20:00:00Z", "UTC");
+    const task = buildTask({
+      is_completed: true,
+      completed_at: "2026-06-04T10:00:00.000Z",
+    });
+    render(<TaskItem {...taskItemProps({ task })} />);
+
+    expect(screen.getByTestId("task-item-completed-at")).toHaveTextContent(
+      /Сегодня/,
+    );
+
+    setFakeClock("2026-06-05T00:30:00Z", "UTC");
+    act(() => {
+      window.dispatchEvent(new CustomEvent(DAY_BOUNDARY_CHANGED_EVENT));
+    });
+
+    await waitFor(() => {
+      expect(screen.getByTestId("task-item-completed-at")).toHaveTextContent(
+        /Вчера/,
+      );
+    });
+  });
+});
diff --git a/packages/client/src/components/tasks/TaskItem.tsx b/packages/client/src/components/tasks/TaskItem.tsx
index 9388dc2f..cbccd197 100644
--- a/packages/client/src/components/tasks/TaskItem.tsx
+++ b/packages/client/src/components/tasks/TaskItem.tsx
@@ -22,6 +22,7 @@ import {
 import { useAttachmentCount } from "@/hooks/useAttachmentCount";
 import { useChecklist } from "@/hooks/useChecklist";
 import { useIsDesktop } from "@/hooks/useIsDesktop";
+import { useLogicalToday } from "@/hooks/useLogicalToday";
 import { useLongPress } from "@/hooks/useLongPress";
 import { usePanelSide } from "@/hooks/usePanelSide";
 import { getCachedDayBoundary } from "@/hooks/useSettings";
@@ -85,6 +86,8 @@ export function TaskItem({
   );
   const isDesktop = useIsDesktop();
   const showCheckbox = useShowCheckbox();
+  // implements FR5 of fix-completed-today-stale-on-day-rollover
+  useLogicalToday();
   const { panelSide } = usePanelSide();
   const [isConfirmingRestore, setIsConfirmingRestore] = useState(false);
   const [isCompleting, setIsCompleting] = useState(false);
diff --git a/packages/client/src/components/tasks/TaskSection.tsx b/packages/client/src/components/tasks/TaskSection.tsx
index ca5d6268..11166197 100644
--- a/packages/client/src/components/tasks/TaskSection.tsx
+++ b/packages/client/src/components/tasks/TaskSection.tsx
@@ -64,7 +64,7 @@ export function TaskSection({
     !isCollapsed && (!hideEmptyState || tasks.length > 0);
 
   return (
-    <section>
+    <section data-testid={`task-section-${sectionKey}`}>
       <button
         type="button"
         onClick={toggleCollapse}
diff --git a/packages/client/src/hooks/useHiddenTasksReveal.test-utils.ts b/packages/client/src/hooks/useHiddenTasksReveal.test-utils.ts
index 18e26f51..bda252b4 100644
--- a/packages/client/src/hooks/useHiddenTasksReveal.test-utils.ts
+++ b/packages/client/src/hooks/useHiddenTasksReveal.test-utils.ts
@@ -1,21 +1,6 @@
 import { afterEach, beforeEach, type Mock, vi } from "vitest";
 
-import { type Clock, Temporal } from "@/lib/temporal";
-
-export function createMutableClock(
-  isoTimestamp: string,
-  timeZone: string,
-): Clock & { setInstant(iso: string): void } {
-  let instant = Temporal.Instant.from(isoTimestamp);
-  return {
-    instant: () => instant,
-    plainDateISO: () => instant.toZonedDateTimeISO(timeZone).toPlainDate(),
-    timeZoneId: () => timeZone,
-    setInstant(iso: string) {
-      instant = Temporal.Instant.from(iso);
-    },
-  };
-}
+export { createMutableClock } from "@/test/helpers/mutableClock";
 
 export function setupHiddenTasksRevealMocks(
   mockRevealHiddenTasks: Mock,
diff --git a/packages/client/src/hooks/useHiddenTasksReveal.ts b/packages/client/src/hooks/useHiddenTasksReveal.ts
index e7aa7bf1..0d73f90c 100644
--- a/packages/client/src/hooks/useHiddenTasksReveal.ts
+++ b/packages/client/src/hooks/useHiddenTasksReveal.ts
@@ -1,15 +1,14 @@
 import { useEffect, useRef } from "react";
 import { DAY_BOUNDARY_CHANGED_EVENT, SYNC_COMPLETE_EVENT } from "@/constants";
 import { TaskRepository } from "@/db/repositories/TaskRepository";
-import { type Clock, systemClock, Temporal } from "@/lib/temporal";
+import { type Clock, systemClock } from "@/lib/temporal";
 import { HiddenTaskService } from "@/services/HiddenTaskService";
 import type { ISODate } from "@/types/entities";
 import { getLogicalDate } from "@/utils/getLogicalDate";
+import { scheduleNextBoundary } from "@/utils/scheduleNextBoundary";
 
 import { getCachedDayBoundary } from "./useSettings";
 
-const BOUNDARY_BUFFER_MS = 1000;
-
 const taskRepository = new TaskRepository();
 
 export function useHiddenTasksReveal(clock: Clock = systemClock) {
@@ -34,32 +33,11 @@ export function useHiddenTasksReveal(clock: Clock = systemClock) {
       }
     };
 
-    const scheduleBoundaryReveal = (): ReturnType<typeof setTimeout> => {
-      const now = clock.instant();
-      const timeZone = clock.timeZoneId();
-      const boundaryTime = Temporal.PlainTime.from(dayBoundaryRef.current);
-      const today = clock.plainDateISO();
-      const todayBoundary = today
-        .toZonedDateTime({ timeZone, plainTime: boundaryTime })
-        .toInstant();
-
-      const nextBoundary =
-        Temporal.Instant.compare(todayBoundary, now) > 0
-          ? todayBoundary
-          : today
-              .add({ days: 1 })
-              .toZonedDateTime({ timeZone, plainTime: boundaryTime })
-              .toInstant();
-
-      const msUntilBoundary = nextBoundary
-        .since(now)
-        .total({ unit: "milliseconds" });
-
-      return setTimeout(() => {
+    const scheduleBoundaryReveal = (): ReturnType<typeof setTimeout> =>
+      scheduleNextBoundary(clock, dayBoundaryRef.current, () => {
         void revealTasks();
         boundaryTimeoutRef.current = scheduleBoundaryReveal();
-      }, msUntilBoundary + BOUNDARY_BUFFER_MS);
-    };
+      });
 
     const clearBoundaryTimeout = () => {
       if (boundaryTimeoutRef.current) {
diff --git a/packages/client/src/hooks/useLogicalToday.ts b/packages/client/src/hooks/useLogicalToday.ts
new file mode 100644
index 00000000..6fc48d85
--- /dev/null
+++ b/packages/client/src/hooks/useLogicalToday.ts
@@ -0,0 +1,8 @@
+import { useSyncExternalStore } from "react";
+import { getSnapshot, subscribe } from "@/stores/logicalTodayStore";
+import type { ISODate } from "@/types/entities";
+
+// implements FR1 of fix-completed-today-stale-on-day-rollover
+export function useLogicalToday(): ISODate {
+  return useSyncExternalStore(subscribe, getSnapshot);
+}
diff --git a/packages/client/src/pages/ActiveTasksPage.dayRollover.test.tsx b/packages/client/src/pages/ActiveTasksPage.dayRollover.test.tsx
new file mode 100644
index 00000000..d88498ed
--- /dev/null
+++ b/packages/client/src/pages/ActiveTasksPage.dayRollover.test.tsx
@@ -0,0 +1,91 @@
+import { act, screen, waitFor } from "@testing-library/react";
+import { beforeEach, describe, expect, it } from "vitest";
+import { DAY_BOUNDARY_CHANGED_EVENT } from "@/constants";
+import {
+  buildCompletedTasksHook,
+  buildTask,
+  mockUseCompletedTasks,
+  pageConfig,
+  renderPage,
+  resetDefaultMocks,
+  setFakeClock,
+} from "./activeTasksPage.testSetup";
+
+/**
+ * Reproduces the bug from fix-completed-today-stale-on-day-rollover: the app
+ * stays mounted across a day boundary and "completed today" keeps showing
+ * yesterday's tasks. `DAY_BOUNDARY_CHANGED_EVENT` is one of the re-arm
+ * triggers required by FR2, so dispatching it here after moving the fake
+ * clock past the boundary drives the reactive recompute without a remount —
+ * standing in for the self-rescheduling boundary timer, which cannot be
+ * driven with `vi.useFakeTimers()` per this project's temporal rules.
+ */
+describe("ActiveTasksPage — day boundary rollover", () => {
+  beforeEach(() => {
+    resetDefaultMocks();
+  });
+
+  // implements FR3, M1 of fix-completed-today-stale-on-day-rollover
+  it("should remove a task from completed today when the day boundary is crossed while mounted", async () => {
+    setFakeClock("2026-06-04T20:00:00Z", "UTC");
+    const completedTasks = [
+      buildTask({
+        name: "Yesterday task",
+        is_completed: true,
+        completed_at: "2026-06-04T10:00:00.000Z",
+      }),
+    ];
+    mockUseCompletedTasks.mockReturnValue(
+      buildCompletedTasksHook({ completedTasks }),
+    );
+    renderPage();
+    expect(screen.getByText(/Yesterday task/)).toBeInTheDocument();
+
+    setFakeClock("2026-06-05T00:30:00Z", "UTC");
+    act(() => {
+      window.dispatchEvent(new CustomEvent(DAY_BOUNDARY_CHANGED_EVENT));
+    });
+
+    await waitFor(() => {
+      expect(screen.queryByText(/Yesterday task/)).not.toBeInTheDocument();
+    });
+  });
+
+  // implements UX3, FR3 of fix-completed-today-stale-on-day-rollover
+  it("should roll over at a custom 04:00 boundary, not at midnight", async () => {
+    pageConfig.dayBoundary = "04:00";
+    setFakeClock("2026-06-04T20:00:00Z", "UTC");
+    const completedTasks = [
+      buildTask({
+        name: "Custom boundary task",
+        is_completed: true,
+        completed_at: "2026-06-04T10:00:00.000Z",
+      }),
+    ];
+    mockUseCompletedTasks.mockReturnValue(
+      buildCompletedTasksHook({ completedTasks }),
+    );
+    renderPage();
+    expect(screen.getByText(/Custom boundary task/)).toBeInTheDocument();
+
+    // Midnight passes, but the configured 04:00 boundary hasn't — task stays.
+    setFakeClock("2026-06-05T01:00:00Z", "UTC");
+    act(() => {
+      window.dispatchEvent(new CustomEvent(DAY_BOUNDARY_CHANGED_EVENT));
+    });
+    await waitFor(() => {
+      expect(screen.getByText(/Custom boundary task/)).toBeInTheDocument();
+    });
+
+    // Clock crosses the configured 04:00 boundary — task now leaves.
+    setFakeClock("2026-06-05T04:30:00Z", "UTC");
+    act(() => {
+      window.dispatchEvent(new CustomEvent(DAY_BOUNDARY_CHANGED_EVENT));
+    });
+    await waitFor(() => {
+      expect(
+        screen.queryByText(/Custom boundary task/),
+      ).not.toBeInTheDocument();
+    });
+  });
+});
diff --git a/packages/client/src/pages/ActiveTasksPage.timerPath.dayRollover.test.tsx b/packages/client/src/pages/ActiveTasksPage.timerPath.dayRollover.test.tsx
new file mode 100644
index 00000000..236d85d1
--- /dev/null
+++ b/packages/client/src/pages/ActiveTasksPage.timerPath.dayRollover.test.tsx
@@ -0,0 +1,100 @@
+import { act, screen, waitFor } from "@testing-library/react";
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  it,
+  type MockInstance,
+  vi,
+} from "vitest";
+import { _resetForTesting } from "@/stores/logicalTodayStore";
+import { createMutableClock } from "@/test/helpers/mutableClock";
+import {
+  buildCompletedTasksHook,
+  buildTask,
+  mockUseCompletedTasks,
+  renderPage,
+  resetDefaultMocks,
+  setFakeClock,
+} from "./activeTasksPage.testSetup";
+
+/**
+ * Closes the timer → recompute → UI gap for
+ * fix-completed-today-stale-on-day-rollover. The sibling
+ * `ActiveTasksPage.dayRollover.test.tsx` drives the recompute via
+ * `DAY_BOUNDARY_CHANGED_EVENT` as a stand-in; here we exercise the genuine
+ * end-to-end path: mount the page, capture the self-rescheduling boundary
+ * timer the store arms on subscribe, advance the clock past the boundary,
+ * and invoke the captured timer callback — never `vi.useFakeTimers()`, per
+ * this project's temporal rules. No remount, no manual event dispatch.
+ *
+ * The store receives an injected mutable clock via `_resetForTesting`, while
+ * the page's own `systemClock` is driven by `setFakeClock`; both are advanced
+ * in lockstep so the store's recompute and the page's completed-today filter
+ * observe the same wall-clock instant.
+ */
+
+/**
+ * The store arms its boundary timer with a delay of hours (until the next
+ * boundary), far larger than any incidental React/RTL timer, so the longest
+ * scheduled callback is unambiguously the boundary timer.
+ */
+function captureBoundaryTimerCallback(
+  setTimeoutSpy: MockInstance<typeof setTimeout>,
+): () => void {
+  const scheduledCalls = setTimeoutSpy.mock.calls as Array<
+    [() => void, number]
+  >;
+  const longestScheduledCall = scheduledCalls.reduce((longest, call) =>
+    call[1] > longest[1] ? call : longest,
+  );
+  return longestScheduledCall[0];
+}
+
+const BEFORE_BOUNDARY = "2026-06-04T20:00:00Z";
+const AFTER_BOUNDARY = "2026-06-05T00:30:00Z";
+const TIME_ZONE = "UTC";
+
+describe("ActiveTasksPage — day boundary rollover via the boundary timer", () => {
+  beforeEach(() => {
+    resetDefaultMocks();
+  });
+
+  afterEach(() => {
+    _resetForTesting();
+    vi.restoreAllMocks();
+  });
+
+  // implements FR3, M1 of fix-completed-today-stale-on-day-rollover
+  it("should remove a task from completed today when the boundary timer fires while mounted", async () => {
+    setFakeClock(BEFORE_BOUNDARY, TIME_ZONE);
+    const storeClock = createMutableClock(BEFORE_BOUNDARY, TIME_ZONE);
+    _resetForTesting(storeClock);
+    const completedTasks = [
+      buildTask({
+        name: "Yesterday task",
+        is_completed: true,
+        completed_at: "2026-06-04T10:00:00.000Z",
+      }),
+    ];
+    mockUseCompletedTasks.mockReturnValue(
+      buildCompletedTasksHook({ completedTasks }),
+    );
+
+    const setTimeoutSpy = vi.spyOn(globalThis, "setTimeout");
+    renderPage();
+    expect(screen.getByText(/Yesterday task/)).toBeInTheDocument();
+
+    const fireBoundaryTimer = captureBoundaryTimerCallback(setTimeoutSpy);
+    setFakeClock(AFTER_BOUNDARY, TIME_ZONE);
+    storeClock.setInstant(AFTER_BOUNDARY);
+    act(() => {
+      fireBoundaryTimer();
+    });
+
+    await waitFor(() => {
+      expect(screen.queryByText(/Yesterday task/)).not.toBeInTheDocument();
+    });
+  });
+});
diff --git a/packages/client/src/pages/ActiveTasksPage.tsx b/packages/client/src/pages/ActiveTasksPage.tsx
index e51ff3a6..8f234de8 100644
--- a/packages/client/src/pages/ActiveTasksPage.tsx
+++ b/packages/client/src/pages/ActiveTasksPage.tsx
@@ -29,6 +29,7 @@ import { useCompletedTasks } from "@/hooks/useCompletedTasks";
 import { useContexts } from "@/hooks/useContexts";
 import { useFocusMode } from "@/hooks/useFocusMode";
 import { useGoals } from "@/hooks/useGoals";
+import { useLogicalToday } from "@/hooks/useLogicalToday";
 import { getCachedDayBoundary } from "@/hooks/useSettings";
 import { useShowHidden } from "@/hooks/useShowHidden";
 import { useTargetBox } from "@/hooks/useTargetBox";
@@ -55,6 +56,7 @@ export default function ActiveTasksPage() {
   const { contexts } = useContexts();
   const { categories } = useCategories();
   const { completedTasks, reload: reloadCompleted } = useCompletedTasks();
+  const logicalToday = useLogicalToday();
   const today = useTasks(BOX.TODAY);
   const week = useTasks(BOX.WEEK);
   const later = useTasks(BOX.LATER);
@@ -141,12 +143,16 @@ export default function ActiveTasksPage() {
     onExpand: selection.handleTaskExpand,
   };
 
-  /** Implements FR1, FR2 of fix-today-completed-logical-date */
+  /**
+   * Implements FR1, FR2 of fix-today-completed-logical-date.
+   * Implements FR3 of fix-completed-today-stale-on-day-rollover.
+   */
+  // biome-ignore lint/correctness/useExhaustiveDependencies: logicalToday triggers recompute on day rollover even though it isn't read inside the callback
   const todayCompleted = useMemo(
     () =>
       groupCompletedTasks(completedTasks, undefined, getCachedDayBoundary())
         .todayTasks,
-    [completedTasks],
+    [completedTasks, logicalToday],
   );
 
   const sections = [
diff --git a/packages/client/src/pages/CompletedPage.dayRollover.test.tsx b/packages/client/src/pages/CompletedPage.dayRollover.test.tsx
new file mode 100644
index 00000000..62037806
--- /dev/null
+++ b/packages/client/src/pages/CompletedPage.dayRollover.test.tsx
@@ -0,0 +1,106 @@
+import { act, render, screen, waitFor } from "@testing-library/react";
+import { MemoryRouter } from "react-router-dom";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import {
+  buildCategoriesHook,
+  buildCompletedTasksHook,
+  buildContextsHook,
+  buildGoalsHook,
+  buildTasksHook,
+} from "@/test/builders/hookBuilders";
+import { buildTask } from "@/test/factories/taskFactory";
+import "@/test/mocks/taskPageMocks";
+import { DAY_BOUNDARY_CHANGED_EVENT } from "@/constants";
+import { useCategories } from "@/hooks/useCategories";
+import { useCompletedTasks } from "@/hooks/useCompletedTasks";
+import { useContexts } from "@/hooks/useContexts";
+import { useGoals } from "@/hooks/useGoals";
+import { useTasks } from "@/hooks/useTasks";
+import { type Clock, fakeClock } from "@/lib/temporal";
+import CompletedPage from "./CompletedPage";
+
+const mockUseTasks = vi.mocked(useTasks);
+const mockUseGoals = vi.mocked(useGoals);
+const mockUseContexts = vi.mocked(useContexts);
+const mockUseCategories = vi.mocked(useCategories);
+const mockUseCompletedTasks = vi.mocked(useCompletedTasks);
+
+const clockState = vi.hoisted(() => ({
+  fakeClockOverride: null as unknown,
+}));
+
+vi.mock("@/lib/temporal", async (importOriginal) => {
+  const actualTemporal =
+    await importOriginal<typeof import("@/lib/temporal")>();
+  const resolveClock = () =>
+    (clockState.fakeClockOverride as typeof actualTemporal.systemClock) ??
+    actualTemporal.systemClock;
+  return {
+    ...actualTemporal,
+    systemClock: {
+      instant: () => resolveClock().instant(),
+      plainDateISO: () => resolveClock().plainDateISO(),
+      timeZoneId: () => resolveClock().timeZoneId(),
+    },
+  };
+});
+
+function setFakeClock(isoTimestamp: string, timeZone?: string) {
+  clockState.fakeClockOverride = fakeClock(
+    isoTimestamp,
+    timeZone,
+  ) as unknown as Clock;
+}
+
+function resetFakeClock() {
+  clockState.fakeClockOverride = null;
+}
+
+function renderPage() {
+  return render(
+    <MemoryRouter>
+      <CompletedPage />
+    </MemoryRouter>,
+  );
+}
+
+describe("CompletedPage — day boundary rollover", () => {
+  beforeEach(() => {
+    resetFakeClock();
+    mockUseTasks.mockReturnValue(buildTasksHook());
+    mockUseGoals.mockReturnValue(buildGoalsHook());
+    mockUseContexts.mockReturnValue(buildContextsHook());
+    mockUseCategories.mockReturnValue(buildCategoriesHook());
+    mockUseCompletedTasks.mockReturnValue(buildCompletedTasksHook());
+  });
+
+  // implements FR4 of fix-completed-today-stale-on-day-rollover
+  it("should move a task from the today group to the yesterday group when the day boundary is crossed while mounted", async () => {
+    setFakeClock("2026-06-04T20:00:00Z", "UTC");
+    const completedTasks = [
+      buildTask({
+        name: "Rolling task",
+        is_completed: true,
+        completed_at: "2026-06-04T10:00:00.000Z",
+      }),
+    ];
+    mockUseCompletedTasks.mockReturnValue(
+      buildCompletedTasksHook({ completedTasks }),
+    );
+    renderPage();
+
+    expect(screen.getByText(/Rolling task/)).toBeInTheDocument();
+    expect(screen.getAllByText(/Сегодня/).length).toBeGreaterThanOrEqual(1);
+    expect(screen.queryAllByText(/^Вчера/)).toHaveLength(0);
+
+    setFakeClock("2026-06-05T00:30:00Z", "UTC");
+    act(() => {
+      window.dispatchEvent(new CustomEvent(DAY_BOUNDARY_CHANGED_EVENT));
+    });
+
+    await waitFor(() => {
+      expect(screen.getAllByText(/Вчера/).length).toBeGreaterThanOrEqual(1);
+    });
+    expect(screen.getByText(/Rolling task/)).toBeInTheDocument();
+  });
+});
diff --git a/packages/client/src/pages/CompletedPage.tsx b/packages/client/src/pages/CompletedPage.tsx
index ef241b16..51e6694e 100644
--- a/packages/client/src/pages/CompletedPage.tsx
+++ b/packages/client/src/pages/CompletedPage.tsx
@@ -14,6 +14,7 @@ import { useCompletedTasks } from "@/hooks/useCompletedTasks";
 import { useContexts } from "@/hooks/useContexts";
 import { useFocusMode } from "@/hooks/useFocusMode";
 import { useGoals } from "@/hooks/useGoals";
+import { useLogicalToday } from "@/hooks/useLogicalToday";
 import { getCachedDayBoundary } from "@/hooks/useSettings";
 import { useTaskCompletion } from "@/hooks/useTaskCompletion";
 import { useTaskSelection } from "@/hooks/useTaskSelection";
@@ -27,6 +28,7 @@ export default function CompletedPage() {
   const { categories } = useCategories();
   const { isFocusMode, focusOpacity } = useFocusMode();
   const { completedTasks, reload: reloadCompleted } = useCompletedTasks();
+  const logicalToday = useLogicalToday();
 
   const inbox = useTasks(BOX.INBOX);
   const today = useTasks(BOX.TODAY);
@@ -68,16 +70,18 @@ export default function CompletedPage() {
     setSelectedTaskId,
   });
 
+  // implements FR4 of fix-completed-today-stale-on-day-rollover
   const {
     todayTasks: todayCompletedTasks,
     yesterdayTasks: yesterdayCompletedTasks,
     weekTasks: weekCompletedTasks,
     monthTasks: monthCompletedTasks,
     earlierTasks: earlierCompletedTasks,
+    // biome-ignore lint/correctness/useExhaustiveDependencies: logicalToday triggers recompute on day rollover even though it isn't read inside the callback
   } = useMemo(
     () =>
       groupCompletedTasks(completedTasks, undefined, getCachedDayBoundary()),
-    [completedTasks],
+    [completedTasks, logicalToday],
   );
 
   const sharedSelectProps = {
diff --git a/packages/client/src/stores/logicalTodayStore.getSnapshot.test.ts b/packages/client/src/stores/logicalTodayStore.getSnapshot.test.ts
new file mode 100644
index 00000000..a50799f4
--- /dev/null
+++ b/packages/client/src/stores/logicalTodayStore.getSnapshot.test.ts
@@ -0,0 +1,25 @@
+import { beforeEach, describe, expect, it } from "vitest";
+import { STORAGE_KEYS } from "@/constants";
+import { fakeClock } from "@/lib/temporal";
+import { _resetForTesting, getSnapshot } from "./logicalTodayStore";
+
+// implements FR1 of fix-completed-today-stale-on-day-rollover
+describe("logicalTodayStore — getSnapshot", () => {
+  beforeEach(() => {
+    localStorage.clear();
+    _resetForTesting();
+  });
+
+  it("should return the current logical date for the injected clock", () => {
+    _resetForTesting(fakeClock("2026-06-04T20:00:00Z", "UTC"));
+
+    expect(getSnapshot()).toBe("2026-06-04");
+  });
+
+  it("should return the previous logical day before a custom day boundary", () => {
+    localStorage.setItem(STORAGE_KEYS.DAY_BOUNDARY, "04:00");
+    _resetForTesting(fakeClock("2026-06-05T01:00:00Z", "UTC"));
+
+    expect(getSnapshot()).toBe("2026-06-04");
+  });
+});
diff --git a/packages/client/src/stores/logicalTodayStore.recompute.test.ts b/packages/client/src/stores/logicalTodayStore.recompute.test.ts
new file mode 100644
index 00000000..9b678788
--- /dev/null
+++ b/packages/client/src/stores/logicalTodayStore.recompute.test.ts
@@ -0,0 +1,229 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { DAY_BOUNDARY_CHANGED_EVENT } from "@/constants";
+import {
+  captureScheduledCallback,
+  createMutableClock,
+} from "@/test/helpers/mutableClock";
+import { _resetForTesting, getSnapshot, subscribe } from "./logicalTodayStore";
+
+// implements FR1, FR2 of fix-completed-today-stale-on-day-rollover
+describe("logicalTodayStore — recompute", () => {
+  let unsubscribe: () => void;
+
+  beforeEach(() => {
+    localStorage.clear();
+  });
+
+  afterEach(() => {
+    unsubscribe();
+    vi.restoreAllMocks();
+  });
+
+  it("should emit and update the snapshot when the boundary timer fires past the boundary", () => {
+    const clock = createMutableClock("2026-06-04T20:00:00Z", "UTC");
+    _resetForTesting(clock);
+    const setTimeoutSpy = vi.spyOn(globalThis, "setTimeout");
+    const listener = vi.fn();
+    unsubscribe = subscribe(listener);
+
+    const scheduledCallback = captureScheduledCallback(setTimeoutSpy);
+    clock.setInstant("2026-06-05T00:30:00Z");
+    scheduledCallback();
+
+    expect(getSnapshot()).toBe("2026-06-05");
+    expect(listener).toHaveBeenCalledTimes(1);
+  });
+
+  it("should not emit when the boundary timer fires but the logical date is unchanged", () => {
+    const clock = createMutableClock("2026-06-04T10:00:00Z", "UTC");
+    _resetForTesting(clock);
+    const setTimeoutSpy = vi.spyOn(globalThis, "setTimeout");
+    const listener = vi.fn();
+    unsubscribe = subscribe(listener);
+
+    const scheduledCallback = captureScheduledCallback(setTimeoutSpy);
+    // Boundary math re-invoked without the clock actually crossing a day —
+    // simulates a spurious re-arm with no real date change.
+    scheduledCallback();
+
+    expect(listener).not.toHaveBeenCalled();
+  });
+
+  it("should recompute when the tab becomes visible", () => {
+    const clock = createMutableClock("2026-06-04T20:00:00Z", "UTC");
+    _resetForTesting(clock);
+    const listener = vi.fn();
+    unsubscribe = subscribe(listener);
+
+    clock.setInstant("2026-06-05T00:30:00Z");
+    Object.defineProperty(document, "visibilityState", {
+      configurable: true,
+      value: "visible",
+    });
+    document.dispatchEvent(new Event("visibilitychange"));
+
+    expect(getSnapshot()).toBe("2026-06-05");
+    expect(listener).toHaveBeenCalledTimes(1);
+  });
+
+  it("should not recompute when visibilitychange fires while hidden", () => {
+    const clock = createMutableClock("2026-06-04T20:00:00Z", "UTC");
+    _resetForTesting(clock);
+    const listener = vi.fn();
+    unsubscribe = subscribe(listener);
+
+    clock.setInstant("2026-06-05T00:30:00Z");
+    Object.defineProperty(document, "visibilityState", {
+      configurable: true,
+      value: "hidden",
+    });
+    document.dispatchEvent(new Event("visibilitychange"));
+
+    expect(listener).not.toHaveBeenCalled();
+  });
+
+  it("should recompute on a persisted pageshow event", () => {
+    const clock = createMutableClock("2026-06-04T20:00:00Z", "UTC");
+    _resetForTesting(clock);
+    const listener = vi.fn();
+    unsubscribe = subscribe(listener);
+
+    clock.setInstant("2026-06-05T00:30:00Z");
+    const persistedEvent = new Event("pageshow");
+    Object.defineProperty(persistedEvent, "persisted", { value: true });
+    window.dispatchEvent(persistedEvent);
+
+    expect(getSnapshot()).toBe("2026-06-05");
+    expect(listener).toHaveBeenCalledTimes(1);
+  });
+
+  it("should not recompute on a non-persisted pageshow event", () => {
+    const clock = createMutableClock("2026-06-04T20:00:00Z", "UTC");
+    _resetForTesting(clock);
+    const listener = vi.fn();
+    unsubscribe = subscribe(listener);
+
+    clock.setInstant("2026-06-05T00:30:00Z");
+    const nonPersistedEvent = new Event("pageshow");
+    Object.defineProperty(nonPersistedEvent, "persisted", { value: false });
+    window.dispatchEvent(nonPersistedEvent);
+
+    expect(listener).not.toHaveBeenCalled();
+  });
+
+  it("should reschedule the boundary timer when the tab becomes visible", () => {
+    const clock = createMutableClock("2026-06-04T20:00:00Z", "UTC");
+    _resetForTesting(clock);
+    const listener = vi.fn();
+    unsubscribe = subscribe(listener);
+
+    const clearTimeoutSpy = vi.spyOn(globalThis, "clearTimeout");
+    const setTimeoutSpy = vi.spyOn(globalThis, "setTimeout");
+    setTimeoutSpy.mockClear();
+
+    Object.defineProperty(document, "visibilityState", {
+      configurable: true,
+      value: "visible",
+    });
+    document.dispatchEvent(new Event("visibilitychange"));
+
+    expect(clearTimeoutSpy).toHaveBeenCalledTimes(1);
+    expect(setTimeoutSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("should not reschedule the boundary timer while hidden", () => {
+    const clock = createMutableClock("2026-06-04T20:00:00Z", "UTC");
+    _resetForTesting(clock);
+    const listener = vi.fn();
+    unsubscribe = subscribe(listener);
+
+    const clearTimeoutSpy = vi.spyOn(globalThis, "clearTimeout");
+
+    Object.defineProperty(document, "visibilityState", {
+      configurable: true,
+      value: "hidden",
+    });
+    document.dispatchEvent(new Event("visibilitychange"));
+
+    expect(clearTimeoutSpy).not.toHaveBeenCalled();
+  });
+
+  it("should reschedule the boundary timer on a persisted pageshow event", () => {
+    const clock = createMutableClock("2026-06-04T20:00:00Z", "UTC");
+    _resetForTesting(clock);
+    const listener = vi.fn();
+    unsubscribe = subscribe(listener);
+
+    const clearTimeoutSpy = vi.spyOn(globalThis, "clearTimeout");
+    const setTimeoutSpy = vi.spyOn(globalThis, "setTimeout");
+    setTimeoutSpy.mockClear();
+
+    const persistedEvent = new Event("pageshow");
+    Object.defineProperty(persistedEvent, "persisted", { value: true });
+    window.dispatchEvent(persistedEvent);
+
+    expect(clearTimeoutSpy).toHaveBeenCalledTimes(1);
+    expect(setTimeoutSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("should not reschedule the boundary timer on a non-persisted pageshow event", () => {
+    const clock = createMutableClock("2026-06-04T20:00:00Z", "UTC");
+    _resetForTesting(clock);
+    const listener = vi.fn();
+    unsubscribe = subscribe(listener);
+
+    const clearTimeoutSpy = vi.spyOn(globalThis, "clearTimeout");
+
+    const nonPersistedEvent = new Event("pageshow");
+    Object.defineProperty(nonPersistedEvent, "persisted", { value: false });
+    window.dispatchEvent(nonPersistedEvent);
+
+    expect(clearTimeoutSpy).not.toHaveBeenCalled();
+  });
+
+  it("should recompute on DAY_BOUNDARY_CHANGED_EVENT", () => {
+    const clock = createMutableClock("2026-06-04T20:00:00Z", "UTC");
+    _resetForTesting(clock);
+    const listener = vi.fn();
+    unsubscribe = subscribe(listener);
+
+    clock.setInstant("2026-06-05T00:30:00Z");
+    window.dispatchEvent(new CustomEvent(DAY_BOUNDARY_CHANGED_EVENT));
+
+    expect(getSnapshot()).toBe("2026-06-05");
+    expect(listener).toHaveBeenCalledTimes(1);
+  });
+
+  it("should refresh the snapshot for the first subscriber after a full teardown", () => {
+    const clock = createMutableClock("2026-06-04T20:00:00Z", "UTC");
+    _resetForTesting(clock);
+
+    // First subscriber comes and goes, tearing the store fully down so no
+    // timer keeps the snapshot current.
+    subscribe(vi.fn())();
+
+    // The clock crosses the day boundary while there are no subscribers.
+    clock.setInstant("2026-06-05T00:30:00Z");
+
+    // The first subscriber after teardown must observe the fresh logical date.
+    unsubscribe = subscribe(vi.fn());
+
+    expect(getSnapshot()).toBe("2026-06-05");
+  });
+
+  it("should clear and reschedule the boundary timer on DAY_BOUNDARY_CHANGED_EVENT", () => {
+    const clock = createMutableClock("2026-06-04T20:00:00Z", "UTC");
+    _resetForTesting(clock);
+    const listener = vi.fn();
+    unsubscribe = subscribe(listener);
+
+    const clearTimeoutSpy = vi.spyOn(globalThis, "clearTimeout");
+    const setTimeoutSpy = vi.spyOn(globalThis, "setTimeout");
+    setTimeoutSpy.mockClear();
+
+    window.dispatchEvent(new CustomEvent(DAY_BOUNDARY_CHANGED_EVENT));
+
+    expect(clearTimeoutSpy).toHaveBeenCalledTimes(1);
+    expect(setTimeoutSpy).toHaveBeenCalledTimes(1);
+  });
+});
diff --git a/packages/client/src/stores/logicalTodayStore.timerLifecycle.test.ts b/packages/client/src/stores/logicalTodayStore.timerLifecycle.test.ts
new file mode 100644
index 00000000..0a529a61
--- /dev/null
+++ b/packages/client/src/stores/logicalTodayStore.timerLifecycle.test.ts
@@ -0,0 +1,107 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { DAY_BOUNDARY_CHANGED_EVENT } from "@/constants";
+import { fakeClock } from "@/lib/temporal";
+import { _resetForTesting, subscribe } from "./logicalTodayStore";
+
+// implements FR2, NFR-P1 of fix-completed-today-stale-on-day-rollover
+describe("logicalTodayStore — timer lifecycle", () => {
+  beforeEach(() => {
+    localStorage.clear();
+    _resetForTesting(fakeClock("2026-06-04T20:00:00Z", "UTC"));
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("should start exactly one boundary timer regardless of subscriber count", () => {
+    const setTimeoutSpy = vi.spyOn(globalThis, "setTimeout");
+
+    const unsubscribeA = subscribe(vi.fn());
+    const unsubscribeB = subscribe(vi.fn());
+    const unsubscribeC = subscribe(vi.fn());
+
+    expect(setTimeoutSpy).toHaveBeenCalledTimes(1);
+
+    unsubscribeA();
+    unsubscribeB();
+    unsubscribeC();
+  });
+
+  it("should attach exactly one set of re-arm listeners for many subscribers", () => {
+    const documentAddSpy = vi.spyOn(document, "addEventListener");
+    const windowAddSpy = vi.spyOn(window, "addEventListener");
+
+    const unsubscribeA = subscribe(vi.fn());
+    const unsubscribeB = subscribe(vi.fn());
+
+    expect(
+      documentAddSpy.mock.calls.filter(([type]) => type === "visibilitychange"),
+    ).toHaveLength(1);
+    expect(
+      windowAddSpy.mock.calls.filter(([type]) => type === "pageshow"),
+    ).toHaveLength(1);
+    expect(
+      windowAddSpy.mock.calls.filter(
+        ([type]) => type === DAY_BOUNDARY_CHANGED_EVENT,
+      ),
+    ).toHaveLength(1);
+
+    unsubscribeA();
+    unsubscribeB();
+  });
+
+  it("should not clear the timer while other subscribers remain", () => {
+    const clearTimeoutSpy = vi.spyOn(globalThis, "clearTimeout");
+
+    const unsubscribeA = subscribe(vi.fn());
+    const unsubscribeB = subscribe(vi.fn());
+
+    unsubscribeA();
+
+    expect(clearTimeoutSpy).not.toHaveBeenCalled();
+
+    unsubscribeB();
+  });
+
+  it("should clear the boundary timer and remove listeners on last unsubscribe", () => {
+    const clearTimeoutSpy = vi.spyOn(globalThis, "clearTimeout");
+    const documentRemoveSpy = vi.spyOn(document, "removeEventListener");
+    const windowRemoveSpy = vi.spyOn(window, "removeEventListener");
+
+    const unsubscribeA = subscribe(vi.fn());
+    const unsubscribeB = subscribe(vi.fn());
+
+    unsubscribeA();
+    unsubscribeB();
+
+    expect(clearTimeoutSpy).toHaveBeenCalledTimes(1);
+    expect(
+      documentRemoveSpy.mock.calls.filter(
+        ([type]) => type === "visibilitychange",
+      ),
+    ).toHaveLength(1);
+    expect(
+      windowRemoveSpy.mock.calls.filter(([type]) => type === "pageshow"),
+    ).toHaveLength(1);
+    expect(
+      windowRemoveSpy.mock.calls.filter(
+        ([type]) => type === DAY_BOUNDARY_CHANGED_EVENT,
+      ),
+    ).toHaveLength(1);
+  });
+
+  it("should start a fresh timer when a new subscriber registers after teardown", () => {
+    const setTimeoutSpy = vi.spyOn(globalThis, "setTimeout");
+
+    const unsubscribeA = subscribe(vi.fn());
+    unsubscribeA();
+    setTimeoutSpy.mockClear();
+
+    const unsubscribeB = subscribe(vi.fn());
+
+    expect(setTimeoutSpy).toHaveBeenCalledTimes(1);
+
+    unsubscribeB();
+  });
+});
diff --git a/packages/client/src/stores/logicalTodayStore.ts b/packages/client/src/stores/logicalTodayStore.ts
new file mode 100644
index 00000000..a9f7ad66
--- /dev/null
+++ b/packages/client/src/stores/logicalTodayStore.ts
@@ -0,0 +1,128 @@
+import { DAY_BOUNDARY_CHANGED_EVENT } from "@/constants";
+import { getCachedDayBoundary } from "@/hooks/useSettings";
+import { type Clock, systemClock } from "@/lib/temporal";
+import type { ISODate } from "@/types/entities";
+import { getLogicalDate } from "@/utils/getLogicalDate";
+import { scheduleNextBoundary } from "@/utils/scheduleNextBoundary";
+
+type Listener = () => void;
+
+let currentClock: Clock = systemClock;
+let currentSnapshot: ISODate = computeSnapshot();
+const listeners = new Set<Listener>();
+let boundaryTimeout: ReturnType<typeof setTimeout> | null = null;
+
+function computeSnapshot(): ISODate {
+  return getLogicalDate(currentClock, getCachedDayBoundary()) as ISODate;
+}
+
+function emitChange(): void {
+  for (const listener of listeners) {
+    listener();
+  }
+}
+
+function recompute(): void {
+  const nextSnapshot = computeSnapshot();
+  if (nextSnapshot !== currentSnapshot) {
+    currentSnapshot = nextSnapshot;
+    emitChange();
+  }
+}
+
+function clearBoundaryTimeout(): void {
+  if (boundaryTimeout) {
+    clearTimeout(boundaryTimeout);
+    boundaryTimeout = null;
+  }
+}
+
+function scheduleBoundaryRecompute(): void {
+  boundaryTimeout = scheduleNextBoundary(
+    currentClock,
+    getCachedDayBoundary(),
+    () => {
+      recompute();
+      scheduleBoundaryRecompute();
+    },
+  );
+}
+
+function rescheduleBoundaryTimer(): void {
+  clearBoundaryTimeout();
+  scheduleBoundaryRecompute();
+}
+
+// On return from background the boundary timer may be aimed at a stale
+// instant (the timezone can change while inactive), so re-arm it alongside
+// recompute — mirroring useHiddenTasksReveal.
+function handleVisibilityChange(): void {
+  if (document.visibilityState === "visible") {
+    recompute();
+    rescheduleBoundaryTimer();
+  }
+}
+
+function handlePageShow(event: PageTransitionEvent): void {
+  if (event.persisted) {
+    recompute();
+    rescheduleBoundaryTimer();
+  }
+}
+
+// FR2: day boundary may change while other tabs/instances are inactive
+function handleDayBoundaryChanged(): void {
+  recompute();
+  rescheduleBoundaryTimer();
+}
+
+function start(): void {
+  // The snapshot can go stale while there are no subscribers (the timer is
+  // torn down), so refresh it before the first subscriber reads it — keeping
+  // the invariant "snapshot equals the current logical date while subscribed".
+  recompute();
+  scheduleBoundaryRecompute();
+  document.addEventListener("visibilitychange", handleVisibilityChange);
+  window.addEventListener("pageshow", handlePageShow as EventListener);
+  window.addEventListener(DAY_BOUNDARY_CHANGED_EVENT, handleDayBoundaryChanged);
+}
+
+function stop(): void {
+  clearBoundaryTimeout();
+  document.removeEventListener("visibilitychange", handleVisibilityChange);
+  window.removeEventListener("pageshow", handlePageShow as EventListener);
+  window.removeEventListener(
+    DAY_BOUNDARY_CHANGED_EVENT,
+    handleDayBoundaryChanged,
+  );
+}
+
+export function getSnapshot(): ISODate {
+  return currentSnapshot;
+}
+
+/**
+ * Implements FR2, NFR-P1 of fix-completed-today-stale-on-day-rollover.
+ * Ref-counted: the boundary timer and re-arm listeners start on the first
+ * subscriber and tear down on the last, so there is at most one of each
+ * regardless of subscriber count.
+ */
+export function subscribe(listener: Listener): () => void {
+  if (listeners.size === 0) {
+    start();
+  }
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+    if (listeners.size === 0) {
+      stop();
+    }
+  };
+}
+
+export function _resetForTesting(clock: Clock = systemClock): void {
+  stop();
+  listeners.clear();
+  currentClock = clock;
+  currentSnapshot = computeSnapshot();
+}
diff --git a/packages/client/src/test/features/day_boundary/day_boundary_rollover.feature b/packages/client/src/test/features/day_boundary/day_boundary_rollover.feature
new file mode 100644
index 00000000..cf988982
--- /dev/null
+++ b/packages/client/src/test/features/day_boundary/day_boundary_rollover.feature
@@ -0,0 +1,30 @@
+Feature: Completed-today section stays fresh across a day rollover
+  Implements FR2, FR3 of fix-completed-today-stale-on-day-rollover.
+
+  @fix-completed-today-stale-on-day-rollover @FR3
+  Scenario: Completed-today section clears yesterday's task at the boundary
+    Given day boundary is "00:00"
+    And a task was completed at "20:00" on "2026-06-04"
+    And the app is subscribed to the current logical date
+    And current local time is "20:30" on "2026-06-04"
+    Then the task appears in the "completed today" section
+    When the clock advances to "00:30" on "2026-06-05" and the boundary timer fires
+    Then the task no longer appears in the "completed today" section
+
+  @fix-completed-today-stale-on-day-rollover @FR3
+  Scenario: Custom day boundary respected for rollover
+    Given day boundary is "04:00"
+    And a task was completed at "10:00" on "2026-06-04"
+    And the app is subscribed to the current logical date
+    And current local time is "10:30" on "2026-06-04"
+    Then the task appears in the "completed today" section
+    When the clock advances to "04:00" on "2026-06-05" and the boundary timer fires
+    Then the task no longer appears in the "completed today" section
+
+  @fix-completed-today-stale-on-day-rollover @FR2
+  Scenario: No emit when re-armed but the logical date is unchanged
+    Given day boundary is "00:00"
+    And the app is subscribed to the current logical date
+    And current local time is "10:00" on "2026-06-04"
+    When the boundary timer fires without the date changing
+    Then no change is emitted to subscribers
diff --git a/packages/client/src/test/features/day_boundary/day_boundary_rollover_a11y_e2e.feature b/packages/client/src/test/features/day_boundary/day_boundary_rollover_a11y_e2e.feature
new file mode 100644
index 00000000..fa0bb180
--- /dev/null
+++ b/packages/client/src/test/features/day_boundary/day_boundary_rollover_a11y_e2e.feature
@@ -0,0 +1,30 @@
+Feature: Day boundary rollover — Accessibility (E2E)
+  Implements NFR-A1 of fix-completed-today-stale-on-day-rollover.
+  Tests that require a real browser for axe-core checks on the affected pages.
+
+  @fix-completed-today-stale-on-day-rollover @NFR-A1
+  Scenario: Active tasks page with a completed-today task passes axe-core checks
+    Given user is on the active tasks page with a task completed today
+    Then the active tasks page passes axe-core accessibility checks
+
+  @fix-completed-today-stale-on-day-rollover @NFR-A1
+  Scenario: Completed page with grouped tasks passes axe-core checks
+    Given user is on the completed page with a task completed today
+    Then the completed page passes axe-core accessibility checks
+
+  # NFR-A1 verifies "the rollover update SHALL cause no accessibility
+  # regressions" — so axe must scan the post-rollover DOM, not only the
+  # pre-rollover DOM. These scenarios cross the day boundary in-place first.
+  @fix-completed-today-stale-on-day-rollover @NFR-A1
+  Scenario: Active tasks page still passes axe-core after the day boundary passes
+    Given user is on the active tasks page with a task completed today
+    When the day boundary passes without navigation
+    Then the task is no longer shown in "completed today"
+    And the active tasks page passes axe-core accessibility checks
+
+  @fix-completed-today-stale-on-day-rollover @NFR-A1
+  Scenario: Completed page still passes axe-core after the day boundary passes
+    Given user is on the completed page with a task completed today
+    When the day boundary passes without navigation
+    Then the task is regrouped from today into yesterday
+    And the completed page passes axe-core accessibility checks
diff --git a/packages/client/src/test/features/day_boundary/steps/day_boundary_rollover.steps.ts b/packages/client/src/test/features/day_boundary/steps/day_boundary_rollover.steps.ts
new file mode 100644
index 00000000..87b14932
--- /dev/null
+++ b/packages/client/src/test/features/day_boundary/steps/day_boundary_rollover.steps.ts
@@ -0,0 +1,182 @@
+// implements FR2, FR3 of fix-completed-today-stale-on-day-rollover
+import type { FeatureDescriibeCallbackParams } from "@amiceli/vitest-cucumber";
+import { describeFeature, loadFeature } from "@amiceli/vitest-cucumber";
+import { expect, type MockInstance, type TestContext, vi } from "vitest";
+import { groupCompletedTasks } from "@/shared/lib/utils";
+import {
+  _resetForTesting,
+  getSnapshot,
+  subscribe,
+} from "@/stores/logicalTodayStore";
+import { buildTask } from "@/test/factories/taskFactory";
+import {
+  captureScheduledCallback,
+  createMutableClock,
+} from "@/test/helpers/mutableClock";
+import type { Task } from "@/types/entities";
+
+const feature = await loadFeature("../day_boundary_rollover.feature");
+
+type Context = Record<string, never>;
+
+describeFeature(feature, (f: FeatureDescriibeCallbackParams<Context>) => {
+  let dayBoundary: string;
+  let clock: ReturnType<typeof createMutableClock>;
+  let task: Task | null;
+  let unsubscribe: () => void;
+  let setTimeoutSpy: MockInstance<typeof setTimeout>;
+  let changeListener: ReturnType<typeof vi.fn>;
+
+  function isTaskInCompletedToday(): boolean {
+    if (!task) return false;
+    const completedTasks = [task];
+    return groupCompletedTasks(
+      completedTasks,
+      clock,
+      dayBoundary,
+    ).todayTasks.includes(task);
+  }
+
+  f.BeforeEachScenario(() => {
+    dayBoundary = "";
+    task = null;
+    setTimeoutSpy = vi.spyOn(globalThis, "setTimeout");
+    changeListener = vi.fn();
+  });
+
+  f.AfterEachScenario(() => {
+    unsubscribe?.();
+    vi.restoreAllMocks();
+  });
+
+  function givenDayBoundary(boundary: string) {
+    return (_ctx: TestContext) => {
+      dayBoundary = boundary;
+    };
+  }
+
+  function givenTaskCompletedAt(time: string, date: string) {
+    return (_ctx: TestContext) => {
+      task = buildTask({
+        is_completed: true,
+        completed_at: `${date}T${time}:00.000Z`,
+      });
+    };
+  }
+
+  function givenSubscribed(_ctx: TestContext) {
+    // Clock is finalized by the following "current local time" step;
+    // subscribe with a temporary instant, corrected once the real one lands.
+    clock = createMutableClock("2026-06-01T00:00:00Z", "UTC");
+    _resetForTesting(clock);
+    unsubscribe = subscribe(changeListener);
+  }
+
+  function givenCurrentLocalTime(time: string, date: string) {
+    return (_ctx: TestContext) => {
+      clock.setInstant(`${date}T${time}:00Z`);
+      _resetForTesting(clock);
+      unsubscribe = subscribe(changeListener);
+    };
+  }
+
+  function thenTaskAppearsToday(_ctx: TestContext) {
+    expect(isTaskInCompletedToday()).toBe(true);
+  }
+
+  function thenTaskDoesNotAppearToday(_ctx: TestContext) {
+    expect(isTaskInCompletedToday()).toBe(false);
+  }
+
+  function whenClockAdvancesAndTimerFires(time: string, date: string) {
+    return (_ctx: TestContext) => {
+      const scheduledCallback = captureScheduledCallback(setTimeoutSpy);
+      clock.setInstant(`${date}T${time}:00Z`);
+      scheduledCallback();
+    };
+  }
+
+  // @fix-completed-today-stale-on-day-rollover @FR3
+  f.Scenario(
+    "Completed-today section clears yesterday's task at the boundary",
+    ({ Given, And, When, Then }) => {
+      Given('day boundary is "00:00"', givenDayBoundary("00:00"));
+      And(
+        'a task was completed at "20:00" on "2026-06-04"',
+        givenTaskCompletedAt("20:00", "2026-06-04"),
+      );
+      And("the app is subscribed to the current logical date", givenSubscribed);
+      And(
+        'current local time is "20:30" on "2026-06-04"',
+        givenCurrentLocalTime("20:30", "2026-06-04"),
+      );
+      Then(
+        'the task appears in the "completed today" section',
+        thenTaskAppearsToday,
+      );
+      When(
+        'the clock advances to "00:30" on "2026-06-05" and the boundary timer fires',
+        whenClockAdvancesAndTimerFires("00:30", "2026-06-05"),
+      );
+      Then(
+        'the task no longer appears in the "completed today" section',
+        thenTaskDoesNotAppearToday,
+      );
+    },
+  );
+
+  // @fix-completed-today-stale-on-day-rollover @FR3
+  f.Scenario(
+    "Custom day boundary respected for rollover",
+    ({ Given, And, When, Then }) => {
+      Given('day boundary is "04:00"', givenDayBoundary("04:00"));
+      And(
+        'a task was completed at "10:00" on "2026-06-04"',
+        givenTaskCompletedAt("10:00", "2026-06-04"),
+      );
+      And("the app is subscribed to the current logical date", givenSubscribed);
+      And(
+        'current local time is "10:30" on "2026-06-04"',
+        givenCurrentLocalTime("10:30", "2026-06-04"),
+      );
+      Then(
+        'the task appears in the "completed today" section',
+        thenTaskAppearsToday,
+      );
+      When(
+        'the clock advances to "04:00" on "2026-06-05" and the boundary timer fires',
+        whenClockAdvancesAndTimerFires("04:00", "2026-06-05"),
+      );
+      Then(
+        'the task no longer appears in the "completed today" section',
+        thenTaskDoesNotAppearToday,
+      );
+    },
+  );
+
+  // @fix-completed-today-stale-on-day-rollover @FR2
+  f.Scenario(
+    "No emit when re-armed but the logical date is unchanged",
+    ({ Given, And, When, Then }) => {
+      Given('day boundary is "00:00"', givenDayBoundary("00:00"));
+      And("the app is subscribed to the current logical date", givenSubscribed);
+      And(
+        'current local time is "10:00" on "2026-06-04"',
+        givenCurrentLocalTime("10:00", "2026-06-04"),
+      );
+
+      When(
+        "the boundary timer fires without the date changing",
+        (_ctx: TestContext) => {
+          const scheduledCallback = captureScheduledCallback(setTimeoutSpy);
+          scheduledCallback();
+        },
+      );
+
+      Then("no change is emitted to subscribers", (_ctx: TestContext) => {
+        expect(changeListener).not.toHaveBeenCalled();
+        expect(getSnapshot()).toBe("2026-06-04");
+      });
+    },
+  );
+});
diff --git a/packages/client/src/test/features/day_boundary/steps/day_boundary_rollover_a11y_e2e.steps.ts b/packages/client/src/test/features/day_boundary/steps/day_boundary_rollover_a11y_e2e.steps.ts
new file mode 100644
index 00000000..0d2a47bc
--- /dev/null
+++ b/packages/client/src/test/features/day_boundary/steps/day_boundary_rollover_a11y_e2e.steps.ts
@@ -0,0 +1,164 @@
+// Verifies NFR-A1 of fix-completed-today-stale-on-day-rollover
+import AxeBuilder from "@axe-core/playwright";
+import type { Page } from "@playwright/test";
+import { expect } from "@playwright/test";
+import { createBdd } from "playwright-bdd";
+
+const { Given, When, Then } = createBdd();
+
+// ============================================================================
+// Helpers
+// ============================================================================
+
+const TASKS_PAGE_URL = "/tasks";
+const COMPLETED_PAGE_URL = "/completed";
+const ACTIVE_TASKS_PAGE_TEST_ID = "active-tasks-page";
+const COMPLETED_PAGE_TEST_ID = "completed-page";
+const YESTERDAY_SECTION_TEST_ID = "task-section-completed_yesterday";
+const COMPLETED_TODAY_TASK_NAME = "E2E task completed today";
+const DB_NAME = "clear-progress";
+const SEED_WAIT_TIMEOUT_MS = 5000;
+
+// Fixed midday instant so the seeded task lands squarely inside "today", and a
+// +24h jump crosses exactly one day boundary regardless of the runner timezone.
+const ONE_DAY_MS = 24 * 60 * 60 * 1000;
+const BASE_TIME_ISO = "2026-08-07T12:00:00.000Z";
+const BASE_TIME_MS = Date.parse(BASE_TIME_ISO);
+
+// Freeze the clock before the app boots so both the seeded completed_at and the
+// logical-today snapshot start at BASE_TIME_MS.
+async function freezeClockAtBaseTime(page: Page): Promise<void> {
+  await page.clock.setFixedTime(BASE_TIME_MS);
+}
+
+// Advance the clock past the next midnight and nudge the app the same way a
+// back-grounded tab is nudged on return, so logicalTodayStore recomputes in
+// place — no navigation, no remount.
+async function crossDayBoundaryInPlace(page: Page): Promise<void> {
+  await page.clock.setFixedTime(BASE_TIME_MS + ONE_DAY_MS);
+  await page.evaluate(() => {
+    document.dispatchEvent(new Event("visibilitychange"));
+  });
+}
+
+async function seedCompletedTodayTask(page: Page): Promise<void> {
+  await page.evaluate(
+    ({ dbName, taskName }) => {
+      return new Promise<void>((resolve, reject) => {
+        const request = indexedDB.open(dbName);
+        request.onerror = () => reject(request.error);
+        request.onsuccess = () => {
+          const database = request.result;
+          const transaction = database.transaction("tasks", "readwrite");
+          const store = transaction.objectStore("tasks");
+          const now = new Date().toISOString();
+          store.put({
+            id: crypto.randomUUID(),
+            name: taskName,
+            description: "",
+            box: "inbox",
+            goal_id: "",
+            context_id: "",
+            category_id: "",
+            is_completed: true,
+            completed_at: now,
+            repeat_rule: "",
+            is_hidden: false,
+            next_date: "",
+            appear_date: "",
+            original_task_id: "",
+            sort_order: "a0",
+            is_deleted: false,
+            created_at: now,
+            updated_at: now,
+            revision: 0,
+            syncStatus: "synced" as const,
+          });
+          transaction.oncomplete = () => resolve();
+          transaction.onerror = () => reject(transaction.error);
+        };
+      });
+    },
+    { dbName: DB_NAME, taskName: COMPLETED_TODAY_TASK_NAME },
+  );
+}
+
+// ============================================================================
+// Background
+// ============================================================================
+
+// Verifies NFR-A1 of fix-completed-today-stale-on-day-rollover
+Given(
+  "user is on the active tasks page with a task completed today",
+  async ({ page }) => {
+    await freezeClockAtBaseTime(page);
+    await page.goto(TASKS_PAGE_URL);
+    await seedCompletedTodayTask(page);
+    await page.reload();
+    await page
+      .getByTestId(ACTIVE_TASKS_PAGE_TEST_ID)
+      .waitFor({ state: "visible", timeout: SEED_WAIT_TIMEOUT_MS });
+    await expect(page.getByText(COMPLETED_TODAY_TASK_NAME)).toBeVisible();
+  },
+);
+
+// Verifies NFR-A1 of fix-completed-today-stale-on-day-rollover
+Given(
+  "user is on the completed page with a task completed today",
+  async ({ page }) => {
+    await freezeClockAtBaseTime(page);
+    await page.goto(COMPLETED_PAGE_URL);
+    await seedCompletedTodayTask(page);
+    await page.reload();
+    await page
+      .getByTestId(COMPLETED_PAGE_TEST_ID)
+      .waitFor({ state: "visible", timeout: SEED_WAIT_TIMEOUT_MS });
+    await expect(page.getByText(COMPLETED_TODAY_TASK_NAME)).toBeVisible();
+  },
+);
+
+// ============================================================================
+// Rollover trigger + regrouping assertions
+// ============================================================================
+
+// Verifies NFR-A1 of fix-completed-today-stale-on-day-rollover
+When("the day boundary passes without navigation", async ({ page }) => {
+  await crossDayBoundaryInPlace(page);
+});
+
+// Verifies NFR-A1 of fix-completed-today-stale-on-day-rollover
+Then('the task is no longer shown in "completed today"', async ({ page }) => {
+  await expect(page.getByText(COMPLETED_TODAY_TASK_NAME)).toBeHidden();
+});
+
+// Verifies NFR-A1 of fix-completed-today-stale-on-day-rollover
+Then("the task is regrouped from today into yesterday", async ({ page }) => {
+  await expect(page.getByTestId(YESTERDAY_SECTION_TEST_ID)).toBeVisible();
+  await expect(page.getByText(COMPLETED_TODAY_TASK_NAME)).toBeVisible();
+});
+
+// ============================================================================
+// NFR-A1: axe-core checks
+// ============================================================================
+
+// Verifies NFR-A1 of fix-completed-today-stale-on-day-rollover
+Then(
+  "the active tasks page passes axe-core accessibility checks",
+  async ({ page }) => {
+    const accessibilityScanResults = await new AxeBuilder({ page })
+      .include(`[data-testid="${ACTIVE_TASKS_PAGE_TEST_ID}"]`)
+      .analyze();
+    expect(accessibilityScanResults.violations).toEqual([]);
+  },
+);
+
+// Verifies NFR-A1 of fix-completed-today-stale-on-day-rollover
+Then(
+  "the completed page passes axe-core accessibility checks",
+  async ({ page }) => {
+    const accessibilityScanResults = await new AxeBuilder({ page })
+      .include(`[data-testid="${COMPLETED_PAGE_TEST_ID}"]`)
+      .analyze();
+    expect(accessibilityScanResults.violations).toEqual([]);
+  },
+);
diff --git a/packages/client/src/test/helpers/mutableClock.ts b/packages/client/src/test/helpers/mutableClock.ts
new file mode 100644
index 00000000..dbe1e303
--- /dev/null
+++ b/packages/client/src/test/helpers/mutableClock.ts
@@ -0,0 +1,34 @@
+import type { MockInstance } from "vitest";
+
+import { type Clock, Temporal } from "@/lib/temporal";
+
+/** A test `Clock` whose current instant can be advanced between assertions. */
+export type MutableClock = Clock & { setInstant(iso: string): void };
+
+/**
+ * Builds a `Clock` seeded at `isoTimestamp` in `timeZone` whose instant can be
+ * moved forward via `setInstant`, letting a test cross a day boundary without
+ * `vi.useFakeTimers()` (banned by this project's temporal rules).
+ */
+export function createMutableClock(
+  isoTimestamp: string,
+  timeZone: string,
+): MutableClock {
+  let instant = Temporal.Instant.from(isoTimestamp);
+  return {
+    instant: () => instant,
+    plainDateISO: () => instant.toZonedDateTimeISO(timeZone).toPlainDate(),
+    timeZoneId: () => timeZone,
+    setInstant(iso: string) {
+      instant = Temporal.Instant.from(iso);
+    },
+  };
+}
+
+/** Returns the callback passed to the most recent `setTimeout` spy call. */
+export function captureScheduledCallback(
+  setTimeoutSpy: MockInstance<typeof setTimeout>,
+): () => void {
+  const [callback] = setTimeoutSpy.mock.calls.at(-1) as [() => void, number];
+  return callback;
+}
diff --git a/packages/client/src/utils/scheduleNextBoundary.test.ts b/packages/client/src/utils/scheduleNextBoundary.test.ts
new file mode 100644
index 00000000..283441a8
--- /dev/null
+++ b/packages/client/src/utils/scheduleNextBoundary.test.ts
@@ -0,0 +1,108 @@
+import { describe, expect, it, vi } from "vitest";
+
+import { fakeClock } from "@/lib/temporal";
+
+import {
+  BOUNDARY_BUFFER_MS,
+  scheduleNextBoundary,
+} from "./scheduleNextBoundary";
+
+// implements FR8 of fix-completed-today-stale-on-day-rollover
+describe("scheduleNextBoundary", () => {
+  it("should schedule onFire at today's boundary when the boundary has not yet passed", () => {
+    const clock = fakeClock("2026-04-16T22:00:00Z", "UTC");
+    const onFire = vi.fn();
+    const setTimeoutSpy = vi.spyOn(globalThis, "setTimeout");
+
+    scheduleNextBoundary(clock, "00:00", onFire);
+
+    const expectedDelayMs = 2 * 60 * 60 * 1000 + BOUNDARY_BUFFER_MS;
+    expect(setTimeoutSpy).toHaveBeenCalledWith(onFire, expectedDelayMs);
+
+    setTimeoutSpy.mockRestore();
+  });
+
+  it("should schedule onFire at the next day's boundary when today's boundary already passed", () => {
+    const clock = fakeClock("2026-04-16T06:00:00Z", "UTC");
+    const onFire = vi.fn();
+    const setTimeoutSpy = vi.spyOn(globalThis, "setTimeout");
+
+    scheduleNextBoundary(clock, "04:00", onFire);
+
+    const expectedDelayMs = 22 * 60 * 60 * 1000 + BOUNDARY_BUFFER_MS;
+    expect(setTimeoutSpy).toHaveBeenCalledWith(onFire, expectedDelayMs);
+
+    setTimeoutSpy.mockRestore();
+  });
+
+  it("should schedule onFire at the next day's boundary when now is exactly at today's boundary", () => {
+    const clock = fakeClock("2026-04-16T00:00:00Z", "UTC");
+    const onFire = vi.fn();
+    const setTimeoutSpy = vi.spyOn(globalThis, "setTimeout");
+
+    scheduleNextBoundary(clock, "00:00", onFire);
+
+    const expectedDelayMs = 24 * 60 * 60 * 1000 + BOUNDARY_BUFFER_MS;
+    expect(setTimeoutSpy).toHaveBeenCalledWith(onFire, expectedDelayMs);
+
+    setTimeoutSpy.mockRestore();
+  });
+
+  it("should account for timezone when computing the boundary instant", () => {
+    // 2026-04-16 20:00 UTC = 2026-04-16 23:00 Europe/Moscow (UTC+3)
+    const clock = fakeClock("2026-04-16T20:00:00Z", "Europe/Moscow");
+    const onFire = vi.fn();
+    const setTimeoutSpy = vi.spyOn(globalThis, "setTimeout");
+
+    scheduleNextBoundary(clock, "00:00", onFire);
+
+    const expectedDelayMs = 60 * 60 * 1000 + BOUNDARY_BUFFER_MS;
+    expect(setTimeoutSpy).toHaveBeenCalledWith(onFire, expectedDelayMs);
+
+    setTimeoutSpy.mockRestore();
+  });
+
+  it("should include BOUNDARY_BUFFER_MS on top of the raw time-until-boundary", () => {
+    const clock = fakeClock("2026-04-16T23:59:00Z", "UTC");
+    const onFire = vi.fn();
+    const setTimeoutSpy = vi.spyOn(globalThis, "setTimeout");
+
+    scheduleNextBoundary(clock, "00:00", onFire);
+
+    const [, delayMs] = setTimeoutSpy.mock.calls[0];
+    expect(delayMs).toBe(60_000 + BOUNDARY_BUFFER_MS);
+
+    setTimeoutSpy.mockRestore();
+  });
+
+  it("should pass onFire itself as the setTimeout callback so it fires exactly once at the boundary", () => {
+    const clock = fakeClock("2026-04-16T23:59:00Z", "UTC");
+    const onFire = vi.fn();
+    const setTimeoutSpy = vi.spyOn(globalThis, "setTimeout");
+
+    scheduleNextBoundary(clock, "00:00", onFire);
+
+    const [scheduledCallback] = setTimeoutSpy.mock.calls[0];
+    expect(onFire).not.toHaveBeenCalled();
+
+    scheduledCallback();
+    expect(onFire).toHaveBeenCalledTimes(1);
+
+    setTimeoutSpy.mockRestore();
+  });
+
+  it("should return the underlying setTimeout handle so callers can clear it", () => {
+    const clock = fakeClock("2026-04-16T22:00:00Z", "UTC");
+    const onFire = vi.fn();
+    const fakeTimeoutHandle = 42 as unknown as ReturnType<typeof setTimeout>;
+    const setTimeoutSpy = vi
+      .spyOn(globalThis, "setTimeout")
+      .mockReturnValue(fakeTimeoutHandle);
+
+    const timeoutHandle = scheduleNextBoundary(clock, "00:00", onFire);
+
+    expect(timeoutHandle).toBe(fakeTimeoutHandle);
+
+    setTimeoutSpy.mockRestore();
+  });
+});
diff --git a/packages/client/src/utils/scheduleNextBoundary.ts b/packages/client/src/utils/scheduleNextBoundary.ts
new file mode 100644
index 00000000..31698875
--- /dev/null
+++ b/packages/client/src/utils/scheduleNextBoundary.ts
@@ -0,0 +1,36 @@
+import type { Clock } from "@/lib/temporal";
+import { Temporal } from "@/lib/temporal";
+
+export const BOUNDARY_BUFFER_MS = 1000;
+
+/**
+ * Implements FR8 of fix-completed-today-stale-on-day-rollover.
+ * Schedules onFire to run once, at the next day-boundary instant plus a
+ * small buffer. Does not self-reschedule — callers re-invoke it from
+ * inside onFire if they need a recurring timer.
+ */
+export function scheduleNextBoundary(
+  clock: Clock,
+  dayBoundary: string,
+  onFire: () => void,
+): ReturnType<typeof setTimeout> {
+  const now = clock.instant();
+  const timeZone = clock.timeZoneId();
+  const boundaryTime = Temporal.PlainTime.from(dayBoundary);
+  const today = clock.plainDateISO();
+
+  const boundaryInstantOn = (date: Temporal.PlainDate): Temporal.Instant =>
+    date.toZonedDateTime({ timeZone, plainTime: boundaryTime }).toInstant();
+
+  const todayBoundary = boundaryInstantOn(today);
+  const nextBoundary =
+    Temporal.Instant.compare(todayBoundary, now) > 0
+      ? todayBoundary
+      : boundaryInstantOn(today.add({ days: 1 }));
+
+  const msUntilBoundary = nextBoundary
+    .since(now)
+    .total({ unit: "milliseconds" });
+
+  return setTimeout(onFire, msUntilBoundary + BOUNDARY_BUFFER_MS);
+}