diff --git a/CHANGELOG.md b/CHANGELOG.md
index f78ca073..67a16c4b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,27 @@
+## Unreleased
+
+### New
+
+* Elapsed durations follow a per-user **Duration format** preference, replacing
+  six ad-hoc format strings that had drifted apart across the session list, game
+  pages, the navbar, and statistics. Four profiles: decimal hours (`1.2 h`, the
+  default and what most surfaces already showed), hours and minutes
+  (`1 h 12 m`), whole hours (`1 hour`), and adaptive units, which climbs from
+  minutes through years (`3 d 11 h`). Every profile rounds rather than
+  truncates, so 59 minutes no longer reads as "0 hours". Grouping and the
+  decimal separator follow the formatting locale.
+* Every duration offers the same value under the other profiles on hover, so a
+  rounded rendering is never a dead end. Screen readers get the value in words
+  ("1 hour 12 minutes") instead of the abbreviation.
+
+### Changed
+
+* Finishing or resetting a session posts and reloads the page instead of
+  patching the row in place. The client-side row rebuild is gone, and with it a
+  TypeScript re-implementation of the server's session time-range rules.
+* Resetting a session's start time confirms on its own page rather than in an
+  inline modal.
+
 ## 1.8.1 / 2026-07-28
 
 ### Fixed
diff --git a/common/components/__init__.py b/common/components/__init__.py
index eaa939a4..88f2b430 100644
--- a/common/components/__init__.py
+++ b/common/components/__init__.py
@@ -64,6 +64,9 @@
 )
 from common.components.domain import (
     BrowserTimeZoneInput,
+    Duration,
+    DurationAlternates,
+    DurationText,
     GameLink,
     GameStatus,
     GameStatusSelector,
@@ -273,6 +276,9 @@
     "DropdownMenuPanel",
     "DropdownPostItem",
     "DropdownSubmenu",
+    "Duration",
+    "DurationAlternates",
+    "DurationText",
     "Element",
     "ExternalScript",
     "FilterBuilder",
diff --git a/common/components/domain.py b/common/components/domain.py
index 983230e2..57d8f047 100644
--- a/common/components/domain.py
+++ b/common/components/domain.py
@@ -23,6 +23,7 @@
 from games.models import Game, Purchase, Session
 
 if TYPE_CHECKING:
+    from common.duration_presentation import DurationPresentation
     from common.returns import OriginUrl
 
 
@@ -338,6 +339,100 @@ def SessionDeviceSelector(session, session_devices, csrf_token: str) -> Node:
     )
 
 
+def DurationText(
+    duration,
+    presentation: DurationPresentation,
+    *,
+    manual: bool = False,
+) -> Node:
+    """The value itself: visible text plus its ``sr-only`` spoken form.
+
+    Split out of :func:`Duration` so a surface that already owns a popover can
+    show a duration without nesting one popover inside another.
+    """
+    visible = presentation.format(duration)
+    return Fragment(
+        Span(aria_hidden="true")[f"{visible}*" if manual else visible],
+        Span(class_="sr-only")[presentation.spoken(duration, manual=manual)],
+    )
+
+
+def DurationAlternates(duration, presentation: DurationPresentation) -> Node:
+    """The same value under the other profiles.
+
+    Rendered with the shared informative-tooltip treatment rather than a local
+    one: profile name and value are a term/description pair, which is what a
+    definition list is for, and the colors come from the design system instead
+    of being chosen here.
+    """
+    return TooltipDefinitionList(
+        [
+            TooltipDefinition(label, rendering, [("class", "tabular-nums")])
+            for label, rendering in presentation.alternates(duration)
+        ]
+    )
+
+
+def Duration(
+    duration,
+    presentation: DurationPresentation,
+    *,
+    id_scope: str,
+    manual: bool = False,
+    link: str | None = None,
+    link_class: str = "hover:underline tabular-nums",
+) -> Node:
+    """One elapsed duration, with the same value under the other profiles on hover.
+
+    ``id_scope`` is required and must be unique on the page. ``Popover`` derives
+    its DOM id by hashing its own content, so two rows showing the same duration
+    would collide — and ``Game.playtime`` defaults to zero, which makes that the
+    common case on a game list rather than an edge case.
+
+    The visible text is ``aria-hidden`` and a sibling ``sr-only`` span carries
+    the value in words: screen readers read "1.2 h" as "one point two h". For
+    the same reason the panel drops ``aria-describedby`` — it restates what the
+    ``sr-only`` text already said.
+
+    ``manual`` appends the "*" mark that flags a hand-entered session. It sits
+    inside the trigger with the value and is spoken as ", manual"; it qualifies
+    the value, not its formatting, so it never appears among the alternates.
+
+    ``link`` makes the value a link to ``link`` and moves the popover onto a
+    separate info glyph beside it. A popover trigger is a ``<button>`` and may
+    not nest inside an ``<a>``, so this is the only way a duration can both
+    navigate and offer its alternates — at the cost of one extra glyph.
+    """
+    from common.components.primitives import Popover
+
+    text = DurationText(duration, presentation, manual=manual)
+    if link is None:
+        return Popover(
+            popover_content=DurationAlternates(duration, presentation),
+            children=[text],
+            wrapped_classes="tabular-nums underline decoration-dotted",
+            id=f"duration-{id_scope}",
+            describedby=False,
+            selectable_text=True,
+        )
+    return Popover(
+        popover_content=DurationAlternates(duration, presentation),
+        preface=A(href=link, class_=link_class)[text],
+        children=[Icon("info", size="size-[1.1em]")],
+        # Same treatment as TruncatedText's reveal button: the glyph exists for
+        # devices that cannot hover, where the host's own hover-to-open is
+        # unavailable. On a pointer device it stays out of the way and hovering
+        # the total opens the panel.
+        wrapped_classes=(
+            "hidden [@media(hover:none)]:inline-flex items-center "
+            "text-subtle hover:text-heading hover:cursor-pointer"
+        ),
+        trigger_label="Other duration formats",
+        id=f"duration-{id_scope}",
+        describedby=False,
+    )
+
+
 BROWSER_TIME_ZONE_FIELD = "browser_time_zone"
 
 
diff --git a/common/components/primitives.py b/common/components/primitives.py
index a14f1aaa..005c435e 100644
--- a/common/components/primitives.py
+++ b/common/components/primitives.py
@@ -259,9 +259,14 @@ def custom_element_builder(tag_name: str):
 _PopOver = custom_element_builder("pop-over")
 _TruncatedText = custom_element_builder("truncated-text")
 
+# font-sans is deliberate, not redundant: the panel is a DOM descendant of
+# whatever it annotates, so a tooltip mounted inside a data table or a
+# TruncatedText host inherits font-condensed and renders in a different
+# typeface from every other tooltip on the site. Stating the family here keeps
+# a tooltip looking like a tooltip wherever it is mounted.
 _TOOLTIP_PANEL_CLASS = (
-    f"z-10 inline-block text-type-body text-heading bg-brand-soft border "
-    f"border-brand/30 rounded-base shadow-xs {CONTENT_MAX_WIDTH_CLASS}"
+    f"z-10 inline-block font-sans text-type-body text-heading bg-brand-soft "
+    f"border border-brand/30 rounded-base shadow-xs {CONTENT_MAX_WIDTH_CLASS}"
 )
 
 
@@ -274,7 +279,12 @@ def TooltipDefinitionList(
     list_class = f"flex flex-col gap-2 {class_}".strip()
     items = [
         Div(definition.attributes)[
-            Dt(class_="text-type-micro text-body")[definition.term],
+            # font-medium on the term as well as the value: the term set no
+            # weight, so it inherited one from wherever the tooltip was
+            # mounted — 500 on an ordinary page but 400 inside a data table,
+            # which made the same tooltip look different per surface. Term and
+            # value are separated by size and color, not weight.
+            Dt(class_="text-type-micro text-body font-medium")[definition.term],
             Dd(class_="font-medium")[definition.description],
         ]
         for definition in definitions
@@ -325,6 +335,7 @@ def _popover_html(
     trigger_disabled: bool = False,
     preface: Node | str = "",
     selectable_text: bool = False,
+    describedby: bool = True,
 ) -> Node:
     """Generate popover HTML. Single source of truth for popover structure.
 
@@ -391,19 +402,18 @@ def _popover_html(
                 Button(control_attributes)[*trigger_children]
             ]
         else:
-            control_attributes.append(("aria-describedby", id))
+            if describedby:
+                control_attributes.append(("aria-describedby", id))
             if trigger_label:
                 control_attributes.append(("aria-label", trigger_label))
             control_attributes.append(("data-pop-over-trigger", ""))
             trigger = Button(control_attributes)[*trigger_children]
     else:
-        trigger = Span(
-            [
-                ("data-pop-over-trigger", ""),
-                ("aria-describedby", id),
-                ("class", wrapped_classes),
-            ]
-        )[*trigger_children]
+        span_attributes: list[HTMLAttribute] = [("data-pop-over-trigger", "")]
+        if describedby:
+            span_attributes.append(("aria-describedby", id))
+        span_attributes.append(("class", wrapped_classes))
+        trigger = Span(span_attributes)[*trigger_children]
 
     # No positioning class — the element sets `position: fixed` + coords on show
     # and clears them on hide; the `hidden` attribute owns the closed state.
@@ -443,6 +453,7 @@ def Popover(
     trigger_disabled: bool = False,
     preface: Node | str = "",
     selectable_text: bool = False,
+    describedby: bool = True,
 ) -> Node:
     children = as_children(children)
     if not wrapped_content and not children:
@@ -462,6 +473,7 @@ def Popover(
         trigger_disabled=trigger_disabled,
         preface=preface,
         selectable_text=selectable_text,
+        describedby=describedby,
     )
 
 
diff --git a/common/duration_presentation.py b/common/duration_presentation.py
new file mode 100644
index 00000000..1526ea49
--- /dev/null
+++ b/common/duration_presentation.py
@@ -0,0 +1,277 @@
+"""Request-scoped formatting for every human-visible elapsed duration.
+
+A duration is not a datetime: it has no timezone, no calendar, and no 12/24-hour
+clock, so it carries its own preference rather than riding on ``DATETIME_FORMAT``.
+Stored values, API values, filtering, and sorting never come through here — this
+module is display only.
+
+Two rules hold across every profile:
+
+* **Round the total once, then decompose.** Rounding a component after the split
+  renders 1 h 59 m 45 s as "2 h 60 m".
+* **Round, never truncate**, at each profile's own resolution. Truncation renders
+  59 minutes as "0 hours", which is a lie the popover should not have to repair.
+"""
+
+import math
+from dataclasses import dataclass
+from datetime import timedelta
+from functools import cache
+from types import MappingProxyType
+from typing import Protocol
+
+from django.http import HttpRequest
+from django.utils.formats import number_format
+from django.utils.translation import override
+
+from timetracker.settings_resolver import resolve_str_for_user
+
+type DurationProfileId = str  # e.g. "decimal_hours"
+type ProfileLabel = str  # e.g. "Hours and minutes"
+
+MINUTE_SECONDS = 60
+HOUR_SECONDS = 60 * MINUTE_SECONDS
+DAY_SECONDS = 24 * HOUR_SECONDS
+WEEK_SECONDS = 7 * DAY_SECONDS
+# A year is not a whole number of weeks. 52 weeks keeps the ladder exact, and
+# nothing here is a calendar date, so the four-day drift is harmless.
+YEAR_SECONDS = 52 * WEEK_SECONDS
+
+
+class NumberFormatter(Protocol):
+    """Renders a number for display. Locale-aware in a request, plain in tests
+    of the rules themselves."""
+
+    def __call__(self, value: float, decimals: int) -> str: ...
+
+
+def plain_number(value: float, decimals: int) -> str:
+    return f"{value:.{decimals}f}"
+
+
+def _round_half_away(value: float) -> int:
+    """Half away from zero, unlike ``round()``'s banker's rounding. Durations
+    are clamped non-negative before they reach here."""
+    return math.floor(value + 0.5)
+
+
+def _total_seconds(duration: timedelta | float | None) -> int:
+    """Whole seconds, never negative: ``timestamp_end`` before
+    ``timestamp_start`` is bad data, not a negative duration."""
+    if duration is None:
+        return 0
+    seconds = (
+        duration.total_seconds() if isinstance(duration, timedelta) else float(duration)
+    )
+    return max(int(seconds), 0)
+
+
+@dataclass(frozen=True)
+class LadderUnit:
+    """One rung of the adaptive ladder."""
+
+    key: str  # e.g. "day"
+    seconds: int
+    symbol: str  # e.g. "d"
+    pad_below: bool  # zero-pad the next unit down to two digits
+
+
+# Largest first; the search below relies on the order.
+LADDER: tuple[LadderUnit, ...] = (
+    LadderUnit("year", YEAR_SECONDS, "y", pad_below=False),
+    LadderUnit("week", WEEK_SECONDS, "w", pad_below=False),
+    LadderUnit("day", DAY_SECONDS, "d", pad_below=True),
+    LadderUnit("hour", HOUR_SECONDS, "h", pad_below=True),
+    LadderUnit("minute", MINUTE_SECONDS, "m", pad_below=False),
+)
+
+
+@dataclass(frozen=True)
+class DurationProfile:
+    """One display rendering. ``label`` names it in the settings control and in
+    the popover listing the other profiles."""
+
+    id: DurationProfileId
+    label: ProfileLabel
+
+    def render(self, seconds: int, numbers: NumberFormatter) -> str:
+        raise NotImplementedError
+
+
+@dataclass(frozen=True)
+class DecimalHoursProfile(DurationProfile):
+    def render(self, seconds: int, numbers: NumberFormatter) -> str:
+        tenths = _round_half_away(seconds / HOUR_SECONDS * 10)
+        return f"{numbers(tenths / 10, 1)} h"
+
+
+@dataclass(frozen=True)
+class HoursMinutesProfile(DurationProfile):
+    def render(self, seconds: int, numbers: NumberFormatter) -> str:
+        total_minutes = _round_half_away(seconds / MINUTE_SECONDS)
+        hours, minutes = divmod(total_minutes, 60)
+        if hours:
+            return f"{numbers(hours, 0)} h {minutes:02d} m"
+        # Zero keeps the column's unit stable; anything else under an hour drops
+        # the pointless leading "0 h".
+        return f"{minutes} m" if minutes else "0 h"
+
+
+@dataclass(frozen=True)
+class WholeHoursProfile(DurationProfile):
+    def render(self, seconds: int, numbers: NumberFormatter) -> str:
+        hours = _round_half_away(seconds / HOUR_SECONDS)
+        return f"{numbers(hours, 0)} hour{'' if hours == 1 else 's'}"
+
+
+@dataclass(frozen=True)
+class AdaptiveProfile(DurationProfile):
+    """Minutes through years, showing the largest unit the value reaches and
+    the one below it."""
+
+    def render(self, seconds: int, numbers: NumberFormatter) -> str:
+        unit, below = self._units_for(seconds)
+        if below is None:
+            return self._minutes_only(seconds, numbers)
+        rounded = _round_half_away(seconds / below.seconds) * below.seconds
+        # Rounding can carry into a higher unit — 6 d 23 h 40 m becomes 1 w 0 d,
+        # never 6 d 24 h.
+        unit, below = self._units_for(rounded)
+        if below is None:
+            return self._minutes_only(rounded, numbers)
+        top, remainder = divmod(rounded, unit.seconds)
+        lower = remainder // below.seconds
+        lower_text = f"{lower:02d}" if unit.pad_below else str(lower)
+        return f"{numbers(top, 0)} {unit.symbol} {lower_text} {below.symbol}"
+
+    def _minutes_only(self, seconds: int, numbers: NumberFormatter) -> str:
+        """Below an hour the ladder agrees with hours_minutes, zero included:
+        an empty duration reads "0 h" so a column's unit stays put."""
+        minutes = _round_half_away(seconds / MINUTE_SECONDS)
+        return f"{numbers(minutes, 0)} m" if minutes else "0 h"
+
+    def _units_for(self, seconds: int) -> tuple[LadderUnit, LadderUnit | None]:
+        """The largest unit ``seconds`` reaches and the rung below it. Below a
+        minute the pair collapses to minutes alone."""
+        for index, unit in enumerate(LADDER):
+            if seconds >= unit.seconds:
+                below = LADDER[index + 1] if index + 1 < len(LADDER) else None
+                return unit, below
+        return LADDER[-1], None
+
+
+DURATION_FORMAT_PROFILES = MappingProxyType(
+    {
+        "decimal_hours": DecimalHoursProfile("decimal_hours", "Decimal hours"),
+        "hours_minutes": HoursMinutesProfile("hours_minutes", "Hours and minutes"),
+        "whole_hours": WholeHoursProfile("whole_hours", "Whole hours"),
+        "adaptive": AdaptiveProfile("adaptive", "Adaptive units"),
+    }
+)
+
+DEFAULT_DURATION_FORMAT_PROFILE = DURATION_FORMAT_PROFILES["decimal_hours"]
+
+
+def duration_format_profile(profile_id: DurationProfileId) -> DurationProfile:
+    """Return the registered immutable profile for ``profile_id``."""
+    try:
+        return DURATION_FORMAT_PROFILES[profile_id]
+    except KeyError as error:
+        raise ValueError(f"Unsupported duration format {profile_id!r}.") from error
+
+
+def format_decimal_hours(duration: timedelta | float | None) -> str:
+    """Decimal hours, preference-independent, for callers with no request —
+    ``Session.__str__`` and other debug or log strings."""
+    seconds = _total_seconds(duration)
+    return plain_number(_round_half_away(seconds / HOUR_SECONDS * 10) / 10, 1)
+
+
+@dataclass(frozen=True)
+class DurationPresentation:
+    """The immutable duration display contract active for one request."""
+
+    profile: DurationProfile
+    locale: str
+
+    def _numbers(self, value: float, decimals: int) -> str:
+        """Grouping and the decimal separator come from the formatting locale.
+
+        ``force_grouping`` is explicit because ``USE_THOUSAND_SEPARATOR`` is
+        unset project-wide; turning it on globally would retroactively regroup
+        every price on the site. ``override`` is scoped to this call for the
+        same reason ``day_periods_for_locale`` scopes its own — the formatting
+        locale is deliberately never activated request-wide, so it cannot
+        change application copy.
+        """
+        with override(self.locale):
+            return number_format(value, decimals, force_grouping=True)
+
+    def format(self, duration: timedelta | float | None) -> str:
+        return self.profile.render(_total_seconds(duration), self._numbers)
+
+    def alternates(
+        self, duration: timedelta | float | None
+    ) -> tuple[tuple[ProfileLabel, str], ...]:
+        """The same value under the other profiles, in registry order.
+
+        Deduplicated on the *rendered string*, never on profile identity:
+        hours_minutes and adaptive agree below a day but diverge at the carry
+        boundary, so "these two profiles are equivalent" is not a rule that
+        holds.
+        """
+        seconds = _total_seconds(duration)
+        seen = {self.profile.render(seconds, self._numbers)}
+        rows: list[tuple[ProfileLabel, str]] = []
+        for profile in DURATION_FORMAT_PROFILES.values():
+            if profile.id == self.profile.id:
+                continue
+            rendered = profile.render(seconds, self._numbers)
+            if rendered in seen:
+                continue
+            seen.add(rendered)
+            rows.append((profile.label, rendered))
+        return tuple(rows)
+
+    def spoken(
+        self, duration: timedelta | float | None, *, manual: bool = False
+    ) -> str:
+        """The value in full words, independent of the visible profile.
+
+        Screen readers mangle abbreviations — "1.2 h" is read "one point two
+        h", and "3 d 11 h" is worse. Hours and minutes only: no reader is
+        helped by "375 days". Numbers are ungrouped so no separator is voiced.
+        """
+        total_minutes = _round_half_away(_total_seconds(duration) / MINUTE_SECONDS)
+        hours, minutes = divmod(total_minutes, 60)
+        parts = [
+            f"{count} {unit}{'' if count == 1 else 's'}"
+            for count, unit in ((hours, "hour"), (minutes, "minute"))
+            if count
+        ]
+        spoken = " ".join(parts) if parts else "0 hours"
+        return f"{spoken}, manual" if manual else spoken
+
+
+_REQUEST_CACHE_ATTRIBUTE = "_duration_presentation"
+
+
+@cache
+def _profile_for_id(profile_id: DurationProfileId) -> DurationProfile:
+    return duration_format_profile(profile_id)
+
+
+def duration_presentation_for_request(request: HttpRequest) -> DurationPresentation:
+    """Resolve and cache the presentation directly on ``request``."""
+    cached = getattr(request, _REQUEST_CACHE_ATTRIBUTE, None)
+    if isinstance(cached, DurationPresentation):
+        return cached
+
+    profile_id = resolve_str_for_user(getattr(request, "user", None), "DURATION_FORMAT")
+    locale = getattr(request, "_date_format_locale", None)
+    presentation = DurationPresentation(
+        profile=_profile_for_id(profile_id),
+        locale=locale if isinstance(locale, str) else "en-us",
+    )
+    setattr(request, _REQUEST_CACHE_ATTRIBUTE, presentation)
+    return presentation
diff --git a/common/layout.py b/common/layout.py
index 626f6eca..4c5f8c2e 100644
--- a/common/layout.py
+++ b/common/layout.py
@@ -165,8 +165,8 @@ def _main_script(mastered: bool) -> str:
 
 
 def NavbarPlaytime(
-    today_played: str,
-    last_7_played: str,
+    today_played: Node | str,
+    last_7_played: Node | str,
     *,
     today_url: str | None = None,
     last_7_url: str | None = None,
@@ -176,25 +176,33 @@ def NavbarPlaytime(
     htmx endpoints can refresh it out-of-band after a session change.
 
     When ``today_url`` / ``last_7_url`` are given, each total links to the
-    matching filtered session list."""
-    from common.components import Safe
+    matching filtered session list.
 
-    def total(text: str, url: str | None) -> str:
+    A total may be a node rather than text — a ``Duration`` carries its own
+    popover and declares its own ``Media``, which only survives while the
+    navbar stays a node tree.
+    """
+    from common.components import A, HTMLAttribute, Li, Span
+
+    def total(value: Node | str, url: str | None) -> Node | str:
         if not url:
-            return text
-        return f'<a href="{url}" class="hover:underline">{text}</a>'
-
-    oob_attr = ' hx-swap-oob="true"' if oob else ""
-    return Safe(
-        f'<li id="navbar-playtime"{oob_attr} '
-        'class="flex flex-col items-center text-type-micro">'
-        '<span class="flex uppercase gap-1">Today'
-        '<span class="">·</span>Last 7 days</span>'
-        '<span class="flex items-center gap-1">'
-        f"{total(today_played, today_url)}"
-        '<span class="">·</span>'
-        f"{total(last_7_played, last_7_url)}</span></li>"
-    )
+            return value
+        return A(href=url, class_="hover:underline")[value]
+
+    attributes: list[HTMLAttribute] = [
+        ("id", "navbar-playtime"),
+        ("class", "flex flex-col items-center text-type-micro"),
+    ]
+    if oob:
+        attributes.append(("hx-swap-oob", "true"))
+    return Li(attributes)[
+        Span(class_="flex uppercase gap-1")["Today", Span()["·"], "Last 7 days"],
+        Span(class_="flex items-center gap-1")[
+            total(today_played, today_url),
+            Span()["·"],
+            total(last_7_played, last_7_url),
+        ],
+    ]
 
 
 # Shared classes for the plain navbar entries (Home/Stats/Log out).
@@ -207,8 +215,8 @@ def total(text: str, url: str | None) -> str:
 
 def NavbarMenu(
     *,
-    today_played: str,
-    last_7_played: str,
+    today_played: Node | str,
+    last_7_played: Node | str,
     today_url: str | None,
     last_7_url: str | None,
     current_year: int,
@@ -336,12 +344,9 @@ def entity_submenu(label, slug, add_url, list_url):
             "md:flex-row md:mt-0 md:border-0 md:bg-neutral-primary-soft"
         )[
             theme_toggle,
-            NavbarPlaytime(
-                today_played,
-                last_7_played,
-                today_url=today_url,
-                last_7_url=last_7_url,
-            ),
+            # No url arguments: each Duration owns its own link, because a
+            # popover trigger may not sit inside one.
+            NavbarPlaytime(today_played, last_7_played),
             desktop_log,
             home,
             entity_menu,
@@ -446,8 +451,8 @@ def NavbarLogButton(
 
 def Navbar(
     *,
-    today_played: str,
-    last_7_played: str,
+    today_played: Node | str,
+    last_7_played: Node | str,
     today_url: str | None = None,
     last_7_url: str | None = None,
     current_year: int,
diff --git a/common/time.py b/common/time.py
index 0776b2c0..1502e2fe 100644
--- a/common/time.py
+++ b/common/time.py
@@ -1,83 +1,9 @@
-import re
 from datetime import date, timedelta
 
 from django.utils import timezone
 
 from common.utils import generate_split_ranges
 
-durationformat: str = "%2.1H hours"
-durationformat_manual: str = "%H hours"
-
-
-def _safe_timedelta(duration: timedelta | float | None):
-    if duration is None:
-        return timedelta(0)
-    elif isinstance(duration, (int, float)):
-        return timedelta(seconds=duration)
-    elif isinstance(duration, timedelta):
-        return duration
-
-
-def format_duration(
-    duration: timedelta | float | None, format_string: str = "%H hours"
-) -> str:
-    """
-    Format timedelta into the specified format_string.
-    Valid format variables:
-    - %H hours
-    - %m minutes
-    - %s seconds
-    - %r total seconds
-    Values don't change into higher units if those units are missing
-    from the formatting string. For example:
-    - 61 seconds as "%s" = 61 seconds
-    - 61 seconds as "%m %s" = 1 minutes 1 seconds"
-    Format specifiers can include width and precision options:
-    - %5.2H: hours formatted with width 5 and 2 decimal places (padded with zeros)
-    """
-    minute_seconds = 60
-    hour_seconds = 60 * minute_seconds
-    day_seconds = 24 * hour_seconds
-    safe_duration = _safe_timedelta(duration)
-    # we don't need float
-    seconds_total = int(safe_duration.total_seconds())
-    # timestamps where end is before start
-    seconds_total = max(seconds_total, 0)
-    days = hours_float = minutes = seconds = 0
-    hours: float = 0
-    remainder = seconds = seconds_total
-    if "%d" in format_string:
-        days, remainder = divmod(seconds_total, day_seconds)
-    if re.search(r"%\d*\.?\d*H", format_string):
-        hours_float, remainder = divmod(remainder, hour_seconds)
-        hours = float(hours_float) + remainder / hour_seconds
-    if re.search(r"%\d*\.?\d*m", format_string):
-        minutes, seconds = divmod(remainder, minute_seconds)
-    literals = {
-        "d": str(days),
-        "H": str(hours) if "m" not in format_string else str(hours_float),
-        "m": str(minutes),
-        "s": str(seconds),
-        "r": str(seconds_total),
-    }
-    formatted_string = format_string
-    for pattern, replacement in literals.items():
-        # Match format specifiers with optional width and precision
-        match = re.search(rf"%(\d*\.?\d*){pattern}", formatted_string)
-        if match:
-            format_spec = match.group(1)
-            if "." in format_spec:
-                # Format the number as float if precision is specified
-                replacement = f"{float(replacement):{format_spec}f}"
-            else:
-                # Format the number as integer if no precision is specified
-                replacement = f"{int(float(replacement)):>{format_spec}}"
-            # Replace the format specifier with the formatted number
-            formatted_string = re.sub(
-                rf"%\d*\.?\d*{pattern}", replacement, formatted_string
-            )
-    return formatted_string
-
 
 def daterange(start: date, end: date, end_inclusive: bool = False) -> list[date]:
     time_between: timedelta = end - start
diff --git a/docs/configuration.md b/docs/configuration.md
index 29df7ff7..32ff767f 100644
--- a/docs/configuration.md
+++ b/docs/configuration.md
@@ -208,6 +208,25 @@ Changes save immediately against the account through `/api/settings/user`:
 - **Formatting locale** (`DATE_FORMAT_LOCALE`) selects the locale used for month
   names, weekday names, and localized AM/PM labels. It is never activated as a
   translation, so application copy is unaffected.
+- **Duration format** controls how elapsed playtime is displayed. Supported
+  profiles are:
+
+  | Value | 45 minutes | 1 h 12 m | 83 h 12 m |
+  |-------|-----------|----------|-----------|
+  | `decimal_hours` | `0.8 h` | `1.2 h` | `83.2 h` |
+  | `hours_minutes` | `45 m` | `1 h 12 m` | `83 h 12 m` |
+  | `whole_hours` | `1 hour` | `1 hour` | `83 hours` |
+  | `adaptive` | `45 m` | `1 h 12 m` | `3 d 11 h` |
+
+  `decimal_hours` is the built-in default. Every profile rounds to its own
+  resolution rather than truncating, so a 45-minute session reads as `1 hour`
+  under `whole_hours`, never `0 hours`. Only `adaptive` rolls hours into days,
+  weeks, and years; the others keep counting hours, because hours are this
+  application's unit of account (the filter facets are `playtime_hours` and
+  `duration_total_hours`). Grouping and the decimal separator come from the
+  formatting locale, so 1234 hours reads `1,234` under `en-us` and `1 234`
+  under `cs`. The preference is display only: stored values, the API, filtering,
+  and sorting are unaffected.
 - **Date/time format** controls numeric date order, visible date separators, and
   the 12- or 24-hour clock used throughout the rendered application. Supported
   profiles are:
diff --git a/docs/superpowers/plans/2026-07-29-issue-486-duration-format.md b/docs/superpowers/plans/2026-07-29-issue-486-duration-format.md
deleted file mode 100644
index 98353528..00000000
--- a/docs/superpowers/plans/2026-07-29-issue-486-duration-format.md
+++ /dev/null
@@ -1,535 +0,0 @@
-# Duration display format preference (#486) Implementation Plan
-
-> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
-
-**Goal:** One per-user preference selects how every human-visible duration renders, with a popover offering the same value under the other profiles.
-
-**Architecture:** A request-scoped `DurationPresentation`, mirroring `DateTimePresentation`, resolves the user's profile and formats values. A `Duration()` component wraps the rendering in a popover listing deduplicated alternates. Formatting leaves the model layer entirely, because a model method has no request and cannot resolve a per-user preference.
-
-**Tech Stack:** Django 6, the settings registry/resolver, `common.components` node tree, pytest + pytest-django, Playwright e2e.
-
-**Depends on #583.** That PR removes the app's only client-rendered duration; without it this work also needs a TypeScript formatter and a cross-language parity contract.
-
-**Design:** `docs/superpowers/specs/2026-07-29-issue-486-duration-format-design.md`. The rendering-rules table there is the source of truth for every expected value below.
-
-## Global Constraints
-
-- Python 3.14 only. Drive everything through `make`. Iterate on `make check-fast`; gate on the full `make check`.
-- Never run `make test-e2e` while `make dev` is up.
-- Never write to `GeneratedField`s: `duration_calculated`, `duration_total`, `price_per_game`, `days_to_finish`.
-- New settings go through `config()` / the registry, never bare `os.environ`.
-- Build UI with `common.components` builders in htpy form. JS-bearing components declare their own `Media`; views never thread `scripts=` for them.
-- Name compound types explicitly (`TypedDict`, `NamedTuple`, `type` alias) and give primitive roles PEP 695 aliases with an example value in a trailing comment.
-- Name variables with complete words. Comments explain non-obvious intent only, with no issue or PR references.
-- Seconds never appear in any rendered duration. Negative durations clamp to zero.
-
----
-
-### Task 1: The four profiles and their rendering rules
-
-**Files:**
-- Create: `common/duration_presentation.py`
-- Test: `tests/test_duration_presentation.py`
-
-**Interfaces:**
-- Produces: `type DurationProfileId = str  # e.g. "decimal_hours"`
-- Produces: `DURATION_FORMAT_PROFILES: Mapping[DurationProfileId, DurationProfile]` (a `MappingProxyType`), and `duration_format_profile(profile_id) -> DurationProfile` raising `ValueError` on an unregistered id, mirroring `date_time_format_profile()`.
-- Produces: `DurationPresentation(profile, locale)` frozen dataclass with `format(value: timedelta | None) -> str`.
-- Produces: `format_decimal_hours(value: timedelta | None) -> str`, preference-independent, for non-request callers.
-
-**Gotchas:**
-- **Round the total once, then decompose.** Rounding a component after the split yields `2 h 60 m` at 1 h 59 m 45 s. This single rule keeps every profile's carry correct.
-- `adaptive` picks the largest unit the raw value reaches, rounds the total to the *next unit down*, decomposes, shows the top two units, and **re-picks if the rounding carried**: `6 d 23 h 40 m` is `1 w 0 d`, not `6 d 24 h`.
-- `adaptive` and `hours_minutes` therefore diverge below 24 h at the boundary: 23 h 59 m 45 s renders `1 d 00 h` and `24 h 00 m` respectively. Task 3's dedup must not assume they agree.
-- Year is 52 weeks = 364 days. Deliberate: a year is not a whole number of weeks, and nothing here is a calendar date.
-- Padding: `hours_minutes` pads minutes to two digits only when hours are present; `adaptive` pads its second unit only when that unit is the hour. Nothing else pads.
-- Zero renders `0 h` under `hours_minutes` and `adaptive`, `0.0 h` under `decimal_hours`, `0 hours` under `whole_hours`.
-- Leave locale grouping out of this task — Task 2 adds it. Assert ungrouped values here.
-
-- [ ] **Step 1: Write the failing table test**
-
-Drive one parametrized test from the spec's rendering-rules table — every row, every profile, as `(seconds, profile_id, expected)` tuples. Include, beyond the table: `1 h 59 m 45 s` (carry into hours), `6 d 23 h 40 m` (carry into weeks), `29 m 30 s` (half-up at the minute), and a negative `timedelta` (clamps to the zero rendering). Add `test_unregistered_profile_id_raises` and `test_none_renders_as_zero`.
-
-- [ ] **Step 2: Run to verify it fails**
-
-```bash
-make test ARGS="tests/test_duration_presentation.py -x"
-```
-
-Expected: FAIL — `ModuleNotFoundError: No module named 'common.duration_presentation'`.
-
-- [ ] **Step 3: Implement**
-
-The unit ladder is the only piece worth spelling out; the three fixed profiles fall out of `divmod` on a rounded total.
-
-```python
-@dataclass(frozen=True)
-class DurationUnit:
-    """One rung of the adaptive ladder, largest first."""
-
-    key: str  # e.g. "day"
-    seconds: int
-    symbol: str  # e.g. "d"
-    pad_below: bool  # zero-pad the *next* unit down to two digits
-
-
-LADDER: Final[tuple[DurationUnit, ...]] = (
-    DurationUnit("year", 364 * 86400, "y", pad_below=False),
-    DurationUnit("week", 7 * 86400, "w", pad_below=False),
-    DurationUnit("day", 86400, "d", pad_below=True),
-    DurationUnit("hour", 3600, "h", pad_below=True),
-    DurationUnit("minute", 60, "m", pad_below=False),
-)
-```
-
-`adaptive` then: find the first ladder unit whose `seconds` the total reaches (falling back to the minute), round the total to the next unit down, and re-enter the search if the rounded total now reaches a higher unit. Decompose into that unit and the one below it, padding the lower one when the higher unit's `pad_below` is set.
-
-- [ ] **Step 4: Run tests**
-
-```bash
-make test ARGS="tests/test_duration_presentation.py -x"
-```
-
-Expected: PASS.
-
-- [ ] **Step 5: Commit**
-
-```bash
-git add common/duration_presentation.py tests/test_duration_presentation.py
-git commit -m "feat: four duration rendering profiles"
-```
-
----
-
-### Task 2: Locale grouping and the decimal separator
-
-**Files:**
-- Modify: `common/duration_presentation.py`
-- Test: `tests/test_duration_presentation.py`
-
-**Gotchas:**
-- `USE_THOUSAND_SEPARATOR` is **absent from `timetracker/settings.py`**, so Django's default `False` applies and `number_format()` groups nothing. Pass `force_grouping=True` per call. Do **not** set the global — it would retroactively regroup every price on the site.
-- `DATE_FORMAT_LOCALE` is deliberately never activated request-wide: `common/middleware.py:49` stashes it on the request precisely so date formatting cannot change application translations. Scope `override(locale)` around the `number_format()` call only, following `day_periods_for_locale()` (`common/date_time_presentation.py:293`).
-- The `cs` thousand separator is **U+00A0**, not an ASCII space. Write it as `"\xa0"` in assertions.
-- `cs` also uses `,` as the decimal separator, so `decimal_hours` renders `1,2 h` there.
-
-- [ ] **Step 1: Write failing tests**
-
-- `test_grouping_under_cs_uses_a_non_breaking_space` — 1234 h under `whole_hours` is `f"1{chr(0xa0)}234 hours"`
-- `test_grouping_under_en_us_uses_a_comma` — `"1,234 hours"`
-- `test_decimal_separator_follows_the_locale` — 1 h 12 m under `decimal_hours` is `"1,2 h"` for `cs`, `"1.2 h"` for `en-us`
-- `test_small_values_are_not_grouped` — 26 h has no separator in either locale
-- `test_formatting_does_not_leak_the_active_translation` — assert `get_language()` is unchanged after a `cs` format call
-
-- [ ] **Step 2: Run to verify they fail**
-
-```bash
-make test ARGS="tests/test_duration_presentation.py -k locale -x"
-```
-
-Expected: FAIL — values render ungrouped with a `.` separator.
-
-- [ ] **Step 3: Implement, then update Task 1's expectations**
-
-Route every numeric component through one helper that wraps `number_format(..., force_grouping=True)` in `override(self.locale)`. Update the four-digit rows in Task 1's table test to expect grouped output.
-
-- [ ] **Step 4: Run tests**
-
-```bash
-make test ARGS="tests/test_duration_presentation.py -x"
-```
-
-Expected: PASS.
-
-- [ ] **Step 5: Commit**
-
-```bash
-git add common/duration_presentation.py tests/test_duration_presentation.py
-git commit -m "feat: durations group and punctuate numbers by locale"
-```
-
----
-
-### Task 3: Alternates and the spoken form
-
-**Files:**
-- Modify: `common/duration_presentation.py`
-- Test: `tests/test_duration_presentation.py`
-
-**Interfaces:**
-- Produces: `type ProfileLabel = str  # e.g. "Hours and minutes"`
-- Produces: `alternates(value) -> tuple[tuple[ProfileLabel, str], ...]` — the other profiles' renderings, deduplicated.
-- Produces: `spoken(value, *, manual: bool = False) -> str`
-
-**Gotchas:**
-- **Dedup compares rendered strings**, never profile identity. `adaptive` and `hours_minutes` agree below 24 h but diverge at the carry boundary, so any "these two profiles are equivalent" shortcut is wrong.
-- Drop an alternate equal to the visible rendering or to an earlier alternate. Preserve registry order otherwise.
-- The spoken form is profile-independent: hours and minutes in words only, never days or weeks, each component pluralized, zero components omitted, and zero itself spoken as "0 hours". `manual=True` appends ", manual".
-
-- [ ] **Step 1: Write failing tests**
-
-- `test_alternates_exclude_the_visible_rendering`
-- `test_alternates_drop_duplicates_below_24h` — under `decimal_hours`, a 1 h 12 m value yields exactly two lines
-- `test_alternates_keep_all_three_above_24h` — an 83 h 12 m value yields three
-- `test_adaptive_and_hours_minutes_diverge_at_the_carry_boundary` — 23 h 59 m 45 s under `decimal_hours` yields three lines, because `1 d 00 h` and `24 h 00 m` differ
-- `test_spoken_uses_words_and_pluralizes` — `"1 hour 12 minutes"`, `"45 minutes"`, `"9000 hours"`, `"0 hours"`
-- `test_spoken_never_uses_days_or_weeks`
-- `test_spoken_marks_a_manual_session`
-
-- [ ] **Step 2: Run to verify they fail**
-
-```bash
-make test ARGS="tests/test_duration_presentation.py -k 'alternates or spoken' -x"
-```
-
-Expected: FAIL — `AttributeError: 'DurationPresentation' object has no attribute 'alternates'`.
-
-- [ ] **Step 3: Implement**
-
-- [ ] **Step 4: Run tests**
-
-```bash
-make test ARGS="tests/test_duration_presentation.py -x"
-```
-
-Expected: PASS.
-
-- [ ] **Step 5: Commit**
-
-```bash
-git add common/duration_presentation.py tests/test_duration_presentation.py
-git commit -m "feat: deduplicated duration alternates and a spoken form"
-```
-
----
-
-### Task 4: Register `DURATION_FORMAT`
-
-**Files:**
-- Modify: `timetracker/settings_registry.py`
-- Modify: `common/duration_presentation.py` (add `duration_presentation_for_request`)
-- Modify: `tests/test_settings_registry.py:21`, `tests/test_admin_settings_page.py:25,38,326`, `e2e/test_admin_settings_page_e2e.py:13`
-- Test: `tests/test_duration_setting.py` (create)
-
-**Interfaces:**
-- Produces: `duration_presentation_for_request(request) -> DurationPresentation`, caching on the request object exactly as `date_time_presentation_for_request` does.
-- Produces: `DURATION_FORMAT_CHOICES: Final[tuple[tuple[str, str], ...]]`.
-
-**Gotchas:**
-- `SettingDefinition.__post_init__` raises at import for a USER setting without a `widget` (`:148`) and for a SELECT without `choices` (`:150`). Both are required.
-- `reload_after_save=True` is only legal with `ApplyTiming.LIVE` (`:163`).
-- **No migration.** Unmapped keys fall through `UserPreferences.extra_preferences` (`games/models.py:570`), as `SESSION_TIME_ZONE_DISPLAY` already does.
-- Five fixtures enumerate settings by hand and fail until updated: `USER_KEYS`; `SITE_SETTING_KEYS` (order-sensitive — `tests/test_admin_settings_page.py:239` asserts the rendered order matches it exactly); the literal SELECT-widget count at `:326`, which goes from 8 to 9; and the two env-scrub fixtures.
-
-- [ ] **Step 1: Write failing tests**
-
-In `tests/test_duration_setting.py`: `test_default_is_decimal_hours`, `test_personal_value_overrides_the_site_default`, `test_clearing_the_personal_value_restores_the_site_default`, `test_unregistered_profile_is_rejected`, `test_presentation_is_cached_on_the_request`.
-
-- [ ] **Step 2: Run to verify they fail**
-
-```bash
-make test ARGS="tests/test_duration_setting.py -x"
-```
-
-Expected: FAIL — `UnregisteredSettingError: DURATION_FORMAT`.
-
-- [ ] **Step 3: Implement**
-
-```python
-DURATION_FORMAT_CHOICES: Final[tuple[tuple[str, str], ...]] = (
-    ("decimal_hours", "Decimal hours (1.2 h)"),
-    ("hours_minutes", "Hours and minutes (1 h 12 m)"),
-    ("whole_hours", "Whole hours (1 hour)"),
-    ("adaptive", "Adaptive units (3 d 11 h)"),
-)
-```
-
-Add `_validate_duration_format` alongside `_validate_datetime_format`, then the `SettingDefinition` with `label="Duration format"`, `SettingScope.USER`, `ApplyTiming.LIVE`, `SettingWidget.SELECT`, those choices, `reload_after_save=True`, and `default_factory=lambda: "decimal_hours"`. Update all five pinned fixtures.
-
-- [ ] **Step 4: Run tests**
-
-```bash
-make test ARGS="tests/test_duration_setting.py tests/test_settings_registry.py tests/test_admin_settings_page.py -x"
-```
-
-Expected: PASS.
-
-- [ ] **Step 5: Commit**
-
-```bash
-git add timetracker/settings_registry.py common/duration_presentation.py tests/ e2e/
-git commit -m "feat: register the duration format preference"
-```
-
----
-
-### Task 5: A popover that can omit `aria-describedby`
-
-**Files:**
-- Modify: `common/components/primitives.py:316-465`
-- Test: `tests/test_components.py`
-
-**Interfaces:**
-- Produces: `Popover(..., describedby: bool = True)`; when `False`, the trigger omits `aria-describedby` while the panel keeps its `id` and `role="tooltip"`.
-
-**Gotchas:**
-- Safe for the element's JS: `ts/elements/pop-over.ts` addresses `[data-pop-over-panel]` and `[data-pop-over-trigger]` and never reads `aria-describedby`. No existing test asserts it is unconditionally present.
-- The panel still needs its `id`, so the duplicate-id problem in Task 6 is unaffected by this flag.
-
-- [ ] **Step 1: Write failing tests**
-
-`test_popover_omits_describedby_when_disabled` and `test_panel_keeps_its_id_and_tooltip_role_when_describedby_is_off`.
-
-- [ ] **Step 2: Run to verify they fail**
-
-```bash
-make test ARGS="tests/test_components.py -k describedby -x"
-```
-
-Expected: FAIL — `TypeError: Popover() got an unexpected keyword argument 'describedby'`.
-
-- [ ] **Step 3: Implement**
-
-- [ ] **Step 4: Run tests**
-
-```bash
-make test ARGS="tests/test_components.py -x"
-```
-
-Expected: PASS.
-
-- [ ] **Step 5: Commit**
-
-```bash
-git add common/components/primitives.py tests/test_components.py
-git commit -m "feat: popovers can opt out of aria-describedby"
-```
-
----
-
-### Task 6: The `Duration()` component
-
-**Files:**
-- Modify: `common/components/domain.py`
-- Test: `tests/test_duration_component.py` (create)
-
-**Interfaces:**
-- Produces: `Duration(value: timedelta | None, presentation: DurationPresentation, *, id_scope: str, manual: bool = False) -> Node`
-
-**Gotchas:**
-- **`id_scope` is required, and every call site must pass a unique one.** `Popover()` otherwise hashes its own content for an id (`primitives.py:450`), so two rows with the same duration collide and `assert_unique_element_ids()` raises during DEBUG page assembly (`core.py:506`). `Game.playtime` defaults to `timedelta(0)`, so any game list with two never-played games trips it — and `tests/test_html_validity.py:187` asserts exactly that page. `PurchasePrice` carries a comment about having been bitten by this.
-- The trigger stays `tap=True` — a real `<button>`, keyboard-operable. The tab-stop cost is ordinary: `DEFAULT_PAGE_SIZE` is 25, and a session row already carries a game link, a device dropdown, Edit, and Delete.
-- Pass `describedby=False` from Task 5: the panel duplicates what the `sr-only` text already says, and without this Orca reads the same number three ways per row.
-- Visible text is `aria-hidden`; the `sr-only` sibling carries `presentation.spoken(...)`.
-- The manual `*` mark goes **inside the trigger, after the visible value**, under the same `aria-hidden`, with `manual=True` adding ", manual" to the spoken text. It never appears in alternates — it qualifies the value, not its formatting.
-- `tabular-nums` on both the visible cell and the popover values. The visible cell currently gets its fixed width from the `%02.1H` pattern being deleted.
-- Reuse `underline decoration-dotted` so durations and prices share one hoverable-value look.
-
-- [ ] **Step 1: Write failing tests**
-
-- `test_visible_value_is_hidden_from_assistive_technology`
-- `test_spoken_text_is_rendered_sr_only`
-- `test_manual_mark_follows_the_value_and_is_spoken`
-- `test_alternates_render_as_label_value_rows`
-- `test_two_equal_durations_get_distinct_ids` — render two `Duration()` nodes with the same value and different `id_scope`, assert the ids differ
-- `test_describedby_is_absent`
-
-- [ ] **Step 2: Run to verify they fail**
-
-```bash
-make test ARGS="tests/test_duration_component.py -x"
-```
-
-Expected: FAIL — `ImportError: cannot import name 'Duration'`.
-
-- [ ] **Step 3: Implement**
-
-- [ ] **Step 4: Run tests**
-
-```bash
-make test ARGS="tests/test_duration_component.py -x"
-```
-
-Expected: PASS.
-
-- [ ] **Step 5: Commit**
-
-```bash
-git add common/components/domain.py common/components/__init__.py tests/test_duration_component.py
-git commit -m "feat: Duration renders a value with its alternate formats"
-```
-
----
-
-### Task 7: Port the session and game surfaces
-
-**Files:**
-- Modify: `games/views/session.py:62`, `games/views/game.py:124,451,505,612`
-- Modify: `games/views/general.py:82-83`
-- Test: `tests/test_rendered_pages.py`
-
-**Interfaces:**
-- Consumes: `Duration()` and `duration_presentation_for_request()`.
-
-**Gotchas:**
-- The navbar values come from the `model_counts` context processor, which has the request — no new plumbing.
-- `id_scope` per surface: `f"session-{pk}-duration"`, `f"game-{pk}-playtime"`, `"navbar-today"`, `"navbar-last-7"`. Two durations in one page must never share one.
-- The session cell's `*` is now `Duration(..., manual=session.is_manual())`, not a string concatenation.
-
-- [ ] **Step 1: Write failing tests**
-
-Assert each page renders the popover markup and that a list with two equal-duration rows has unique ids.
-
-- [ ] **Step 2: Run to verify they fail**
-
-```bash
-make test ARGS="tests/test_rendered_pages.py -x"
-```
-
-- [ ] **Step 3: Implement**
-
-- [ ] **Step 4: Run tests**
-
-```bash
-make test ARGS="tests/test_rendered_pages.py tests/test_html_validity.py -x"
-```
-
-Expected: PASS.
-
-- [ ] **Step 5: Commit**
-
-```bash
-git add games/views/ tests/
-git commit -m "feat: sessions, games, and the navbar use the duration formatter"
-```
-
----
-
-### Task 8: Move stats and play events to `timedelta`
-
-**Files:**
-- Modify: `games/views/stats_data.py:39,59,63,279,306,318`
-- Modify: `games/views/stats_content.py:105,149,199,212`
-- Modify: `games/views/playevent.py:166`
-- Test: `tests/test_stats.py`
-
-**Gotchas:**
-- `compute_stats()` is documented as pure computation with no HTTP and must stay that way, so it returns `timedelta` and `stats_content` formats.
-- `StatsData.total_hours` changes from `str` to `timedelta`; `longest_session_time` and `highest_session_average` change from `Any` (today `timedelta`-or-integer-`0`) to `timedelta | None`. **The `0` fallback becomes `None`** — every consumer must handle it.
-- `playevent.py:166` has the same shape: return the `timedelta`, format at the call site.
-- `stats_links.py` parity tests assert counts, not durations, and should be unaffected — confirm rather than assume.
-
-- [ ] **Step 1: Write failing tests**
-
-Assert `compute_stats()` returns `timedelta` values and `None` where a stat is absent, and that the stats page renders duration popovers.
-
-- [ ] **Step 2: Run to verify they fail**
-
-```bash
-make test ARGS="tests/test_stats.py -x"
-```
-
-- [ ] **Step 3: Implement**
-
-- [ ] **Step 4: Run tests**
-
-```bash
-make test ARGS="tests/test_stats.py tests/test_rendered_pages.py -x" && make typecheck
-```
-
-Expected: PASS. mypy is the real gate here — the `TypedDict` change ripples.
-
-- [ ] **Step 5: Commit**
-
-```bash
-git add games/views/ tests/
-git commit -m "refactor: stats compute durations and render them separately"
-```
-
----
-
-### Task 9: Delete the old formatter
-
-**Files:**
-- Modify: `common/time.py:8-79` (delete `format_duration`, `durationformat`, `durationformat_manual`)
-- Modify: `games/models.py:106,273-283,352-365`
-- Modify: `tests/test_time.py`, `tests/test_session_formatting.py:36-39`
-
-**Gotchas:**
-- `Session.duration_formatted()`, `duration_formatted_with_mark()`, and `Game.playtime_formatted()` are deleted — a model method has no request and cannot resolve a per-user preference.
-- `Session.__str__` calls `format_decimal_hours()` from Task 1 instead. It is a debug/admin/log string, not UI.
-- `SessionQuerySet.total_duration_formatted()` and `calculated_duration_formatted()` have **no callers anywhere** (verified across Python, templates, `ts/`, `dist/`, e2e, management commands, and the API). Delete them. Their `*_unformatted()` siblings **do** have callers and must stay.
-- `tests/test_session_formatting.py:37` asserts `duration_formatted()` but its class also holds unrelated datetime tests, so it cannot be deleted wholesale alongside `tests/test_time.py`'s duration half.
-
-- [ ] **Step 1: Delete and update**
-
-- [ ] **Step 2: Verify nothing references the removed names**
-
-```bash
-grep -rn "format_duration\|durationformat\|duration_formatted\|playtime_formatted" --include=*.py . | grep -v "_unformatted"
-```
-
-Expected: no output.
-
-- [ ] **Step 3: Run the suite**
-
-```bash
-make check-fast
-```
-
-Expected: PASS.
-
-- [ ] **Step 4: Commit**
-
-```bash
-git add -A common/ games/ tests/
-git commit -m "refactor: retire the format_duration mini-language"
-```
-
----
-
-### Task 10: Documentation, changelog, and the gate
-
-**Files:**
-- Modify: `docs/configuration.md` (a `Duration format` bullet beside the other per-preference entries)
-- Modify: the changelog
-- Test: `e2e/test_duration_format_e2e.py` (create)
-
-**Gotchas:**
-- The per-preference list is ordered to match `SITE_SETTING_KEYS`; keep it that way.
-- Document what each profile does with a sub-hour value, since that is where they visibly disagree.
-
-- [ ] **Step 1: Write the e2e test**
-
-Change the preference on `/settings`, confirm the sessions list re-renders in the new profile, open a duration popover, and assert the alternates exclude the visible value.
-
-- [ ] **Step 2: Run it**
-
-```bash
-make test-e2e
-```
-
-Expected: PASS. Confirm `make dev` is not running first.
-
-- [ ] **Step 3: Write the docs and changelog entries**
-
-- [ ] **Step 4: Full gate**
-
-```bash
-make check && git diff --check
-```
-
-Expected: PASS.
-
-- [ ] **Step 5: Commit and open the PR**
-
-```bash
-git add -A docs/ e2e/
-git commit -m "docs: describe the duration format preference"
-```
-
-PR targets `main` and closes #486.
-
-- [ ] **Step 6: Screen-reader pass**
-
-Ask for an Orca run over a session list. The check: each duration is announced once, in words, with no repetition of the same number in other formats. If it is noisy, the `describedby=False` decision from Task 5 is the first thing to revisit.
diff --git a/docs/superpowers/specs/2026-07-29-issue-486-duration-format-design.md b/docs/superpowers/specs/2026-07-29-issue-486-duration-format-design.md
deleted file mode 100644
index 7725a9b7..00000000
--- a/docs/superpowers/specs/2026-07-29-issue-486-duration-format-design.md
+++ /dev/null
@@ -1,412 +0,0 @@
-# Per-user duration display format (#486)
-
-Follow-up to the settings epic (#381), sibling to the date/time format preference
-(#389). Duration is a distinct semantic value — no timezone, no calendar, no
-12/24-hour clock — so it gets its own contract rather than riding on
-`DATETIME_FORMAT`.
-
-## Problem
-
-Nine call sites format durations today, through eight distinct
-`format_duration()` pattern strings:
-
-| site | pattern | renders |
-|---|---|---|
-| `Session.duration_formatted()` | `%02.1H` | `3.2` |
-| `Game.playtime_formatted()` | `%2.1H` | `3.2` |
-| `SessionQuerySet.total_duration_formatted()` | `%H hours` | `3 hours` |
-| game detail filtered playtime (`game.py:124`, `:451`) | `%2.1H` | `3.2` |
-| navbar today / last-7 (`general.py:82`) | `%H h %m m` | `3 h 12 m` |
-| play-event range total (`playevent.py:166`) | `%Hh %mm` | `3h 12m` |
-| stats longest session / average (`stats_data.py:306`, `:318`) | `%2.0Hh %2.0mm` | ` 3h 12m` |
-| stats year total (`stats_data.py:279`) | `%2.0H` | `1234` |
-| stats card durations (`stats_content.py:105`) | `%2.1H hours` | `3.2 hours` |
-
-That is drift, not intent. There is no user preference, and the `%H`/`%m`
-mini-language in `common/time.py` invites a ninth variant with every new surface.
-
-## Shape of the solution
-
-One profile ID per user selects how *every* human-visible duration renders.
-Each duration also carries a popover listing the same value in the other
-profiles, so no rendering is a dead end — the lossy profiles are exactly the
-ones that need it.
-
-Four profiles:
-
-| id | settings label | 1 h 12 m renders as |
-|---|---|---|
-| `decimal_hours` | Decimal hours (1.2 h) | `1.2 h` |
-| `hours_minutes` | Hours and minutes (1 h 12 m) | `1 h 12 m` |
-| `whole_hours` | Whole hours (1 hour) | `1 hour` |
-| `adaptive` | Adaptive units (3 d 11 h) | `1 h 12 m` |
-
-Default is `decimal_hours` — what the session list and game playtime already
-render, so an untouched install looks unchanged.
-
-### Rendering rules
-
-Grouped values below use `_` for the locale group separator, which is **U+00A0
-NBSP under `cs`**, not an ASCII space (see Locale, below).
-
-| value | `decimal_hours` | `hours_minutes` | `whole_hours` | `adaptive` |
-|---|---|---|---|---|
-| 0 | `0.0 h` | `0 h` | `0 hours` | `0 h` |
-| 45 s | `0.0 h` | `1 m` | `0 hours` | `1 m` |
-| 29 min | `0.5 h` | `29 m` | `0 hours` | `29 m` |
-| 45 min | `0.8 h` | `45 m` | `1 hour` | `45 m` |
-| 1 h 12 m | `1.2 h` | `1 h 12 m` | `1 hour` | `1 h 12 m` |
-| 3 h 5 m | `3.1 h` | `3 h 05 m` | `3 hours` | `3 h 05 m` |
-| 3 h 30 m | `3.5 h` | `3 h 30 m` | `4 hours` | `3 h 30 m` |
-| 23 h 59 m 45 s | `24.0 h` | `24 h 00 m` | `24 hours` | `1 d 00 h` |
-| 26 h | `26.0 h` | `26 h 00 m` | `26 hours` | `1 d 02 h` |
-| 83 h 12 m | `83.2 h` | `83 h 12 m` | `83 hours` | `3 d 11 h` |
-| 200 h | `200.0 h` | `200 h 00 m` | `200 hours` | `1 w 1 d` |
-| 1234 h | `1_234.0 h` | `1_234 h 00 m` | `1_234 hours` | `7 w 2 d` |
-| 9000 h | `9_000.0 h` | `9_000 h 00 m` | `9_000 hours` | `1 y 2 w` |
-
-Invariants behind the table:
-
-- **Round, never truncate**, each profile at its own resolution, half away from
-  zero. Truncation renders `59 m` as `0 hours`, a lie the popover should not
-  have to repair.
-- **Round the total once, then decompose.** Rounding a component after the split
-  produces `2 h 60 m` at 1 h 59 m 45 s. This is the single rule that keeps every
-  profile's carry correct, including `adaptive`'s.
-- **Seconds never appear.** Sessions are wall-clock ranges and aggregates are
-  hours; nothing in the app records durations where seconds are meaningful.
-- **Negative clamps to zero**, as `common/time.py` does today. `timestamp_end <
-  timestamp_start` is bad data, not a negative duration.
-- **`hours_minutes` suppresses a zero hour** (`45 m`, not `0 h 45 m`) and pads
-  minutes to two digits when hours are present, so a table column stays aligned.
-  Zero is the one special case: `0 h`, keeping the column's unit stable.
-- **Zero-padding elsewhere:** `adaptive` pads its second unit to two digits only
-  when that unit is the hour (`1 d 02 h`); day, week, and year second units are
-  unpadded (`1 w 1 d`, `1 y 2 w`). Nothing else pads.
-- **`whole_hours` pluralizes** on the rounded value: `1 hour`, `0 hours`,
-  `4 hours`.
-- **Hours never roll into days** in the first three profiles. Hours are this
-  app's unit of account — the filter facets are `playtime_hours` and
-  `duration_total_hours`, the stats headline is total hours. `adaptive` exists
-  precisely so that wanting days does not force everyone else to have them.
-
-### The `adaptive` ladder
-
-Units are minute, hour, day (24 h), week (7 d), year (52 w = 364 d). A year is
-not a whole number of weeks; 364 is the definition that keeps the ladder exact,
-and nothing here is a calendar date, so the drift is harmless.
-
-Algorithm: pick the largest unit the raw value reaches, round the total to the
-*next unit down*'s resolution, decompose, and show the top two units. If the
-rounding carries into a higher unit, re-pick — `6 d 23 h 40 m` becomes `1 w 0 d`,
-not `6 d 24 h`.
-
-`adaptive` and `hours_minutes` agree below 24 h **except at the carry
-boundary**: 23 h 59 m 45 s rounds to 1440 minutes, which `hours_minutes` renders
-`24 h 00 m` while `adaptive` re-picks to `1 d 00 h`. This is why popover dedup is
-computed on rendered strings, never on a "which profiles are equivalent" rule.
-
-### The popover
-
-Every human-visible duration renders as a `Popover` listing the same value under
-the *other* profiles, labelled:
-
-```
-1.2 h                          ← visible, underline decoration-dotted
-  Hours and minutes  1 h 12 m
-  Whole hours        1 hour
-```
-
-- **Distinct renderings only**, compared as strings after rendering. Drop any
-  alternate equal to the visible value or to an earlier alternate. In practice
-  most values show two lines and long ones show three, but the count is a
-  consequence, never an assumption — see the carry boundary above.
-- **Bare label/value rows**, no panel title. The panel is `role="tooltip"`; a
-  title is a word every screen reader reads before the data, for no information.
-- **Values get `tabular-nums`**, as does the visible cell, which today gets its
-  fixed width from the `%02.1H` pattern being deleted.
-- **`tap=True`** (the default) — the trigger is a real `<button>`, operable by
-  mouse, touch, and keyboard. See Accessibility.
-
-**Every popover needs a caller-supplied DOM id.** `Popover()` otherwise derives
-one by hashing its own content (`primitives.py:450`), so two rows with the same
-duration collide, and `assert_unique_element_ids()` raises during DEBUG page
-assembly (`core.py:506`). `Game.playtime` defaults to `timedelta(0)`, so any
-game list with two never-played games would trip it — and
-`tests/test_html_validity.py:187` asserts exactly this on `games:list_games`.
-`PurchasePrice` already carries a comment about being bitten by this
-(`domain.py:281`). So `Duration()` takes a required id scope, and every call site
-supplies one: `f"session-{pk}-duration"`, `f"game-{pk}-playtime"`,
-`"navbar-today"`, `"stats-total-hours"`, and so on.
-
-### The manual-session mark
-
-`duration_formatted_with_mark()` appends `*` for manual sessions. The mark stays
-**inside the trigger, after the visible value**, is covered by the same
-`aria-hidden`, and the `sr-only` text ends with ", manual" so the information
-survives for screen readers. It does not appear in popover alternates — it
-qualifies the value, not its formatting.
-
-### Accessibility
-
-The visible text is `aria-hidden`; a sibling `sr-only` span carries the value in
-full words, **independent of profile**: hours and minutes only (never days or
-weeks — "375 days" helps nobody), each component pluralized, a zero component
-omitted, and a zero duration spoken as "0 hours". So `1 h 12 m` is "1 hour 12
-minutes", `45 m` is "45 minutes", and `9000 h` is "9000 hours".
-
-`1.2 h` spoken is "one point two h", and `3 d 11 h` is worse — abbreviation is
-exactly what screen readers mangle. The spoken form is more precise than
-`decimal_hours` shows; that is fine, it is the same value said unambiguously.
-
-`aria-describedby` is **dropped** on duration popovers (a new `describedby=False`
-option on `Popover`; the panel stays for sighted users). Without it, Orca would
-read the same number three ways on every row. This is safe for the element's JS:
-`ts/elements/pop-over.ts` addresses `[data-pop-over-panel]` and
-`[data-pop-over-trigger]` and never reads `aria-describedby`, and no existing
-test asserts it is unconditionally present.
-
-**The trigger stays a real `<button>` (`tap=True`).** Both alternatives
-considered — `tap=False`, and a `<span>` carrying the tap bindings — reach the
-panel by pointer but not by keyboard, which fails WCAG 2.1.1 for a sighted
-keyboard-only user: they would see one format where a mouse user sees four. The
-"it exposes no unique information" defence is too thin to rest on.
-
-The cost is one tab stop per duration. That is ordinary: `DEFAULT_PAGE_SIZE` is
-25, and a session row already carries a game link, a device dropdown, Edit, and
-Delete, so this is roughly a 20% increase in a row's tab stops rather than a new
-class of problem. A user who selects the 1000-row page size has opted into a
-dense page in which every existing per-row control multiplies identically.
-
-Verify with a real Orca pass on a session list before merge.
-
-## Architecture
-
-### `common/duration_presentation.py`
-
-Mirrors `common/date_time_presentation.py`:
-
-- `type DurationProfileId = str` and a `MappingProxyType` registry of the four
-  profiles, each a frozen dataclass of its rendering rules.
-- `DurationPresentation(profile, locale)` — frozen, immutable, one per request.
-  `format(value) -> str` for the visible rendering, `alternates(value) ->
-  tuple[tuple[str, str], ...]` for the deduplicated (label, rendering) pairs,
-  `spoken(value) -> str` for the sr-only form.
-- `duration_presentation_for_request(request)` — resolves via
-  `resolve_str_for_user(user, "DURATION_FORMAT")`, caches on the request object,
-  exactly as the date/time equivalent does.
-- A module-level `format_decimal_hours(value) -> str`, preference-independent,
-  for `Session.__str__` and any other non-request caller.
-
-No `to_client_config()` and no TypeScript counterpart — see the prerequisite.
-
-### Locale: grouping is opt-in per call
-
-`USE_THOUSAND_SEPARATOR` is **absent from settings**, so Django's default
-`False` applies and `number_format()` does no grouping. Flipping it globally
-would retroactively regroup every price on the site, so instead the formatter
-passes `force_grouping=True` explicitly.
-
-`DATE_FORMAT_LOCALE` is deliberately never activated request-wide —
-`common/middleware.py:49` stashes it on the request precisely so date formatting
-cannot change application translations. The duration formatter follows the
-`day_periods_for_locale()` precedent (`date_time_presentation.py:293`) and scopes
-`override(locale)` around its own `number_format()` call only.
-
-The `cs` separator is U+00A0 (`django/conf/locale/cs/formats.py`). Tests must
-assert the NBSP, not an ASCII space.
-
-### `Duration()` component
-
-A new builder in `common/components/domain.py`, taking the value, the
-presentation, and a required id scope (see above). Call sites never assemble the
-popover themselves, so a surface cannot forget it — or forget its id.
-
-### Registry entry
-
-`DURATION_FORMAT` in `timetracker/settings_registry.py`, as a
-`SettingDefinition`: `SettingScope.USER`, `ApplyTiming.LIVE`,
-`SettingWidget.SELECT`, a `label`, a `DURATION_FORMAT_CHOICES` tuple (the
-`__post_init__` guard at `:150` rejects a SELECT without `choices`, and `:148`
-rejects a USER setting without a widget), `reload_after_save=True`,
-`default_factory` returning `"decimal_hours"`, and a `_validate_duration_format`
-rejecting unregistered IDs the way `_validate_datetime_format` does.
-
-**No migration.** Unmapped keys fall through `UserPreferences.extra_preferences`
-(`games/models.py:570`), as `SESSION_TIME_ZONE_DISPLAY` already does.
-
-Pinned test fixtures that enumerate settings by hand and will fail until
-updated: `tests/test_settings_registry.py:21` (`USER_KEYS`),
-`tests/test_admin_settings_page.py:25` (`SITE_SETTING_KEYS`, order-sensitive),
-`tests/test_admin_settings_page.py:326` (a literal count of SELECT widgets),
-plus the env-scrub fixtures at `tests/test_admin_settings_page.py:38` and
-`e2e/test_admin_settings_page_e2e.py:13`.
-
-### Formatting moves off the models
-
-`Session.duration_formatted()`, `Session.duration_formatted_with_mark()`, and
-`Game.playtime_formatted()` are **deleted**. A model method has no request and
-therefore cannot resolve a per-user preference; the date/time contract already
-established that formatting lives in views and components.
-
-- `Session.__str__` calls `format_decimal_hours()` directly — it is a
-  debug/admin/log string, not UI.
-- `SessionQuerySet.total_duration_formatted()` and
-  `calculated_duration_formatted()` have **no callers anywhere** (verified across
-  Python, templates, `ts/`, `dist/`, e2e, management commands, and the API).
-  Deleted, not ported. Their `*_unformatted()` siblings do have callers and stay.
-- `tests/test_session_formatting.py:37` asserts `duration_formatted()` and must
-  be updated; it also holds unrelated datetime tests, so it cannot simply be
-  deleted alongside `tests/test_time.py`.
-
-### Stats layering
-
-`compute_stats()` is documented as pure computation with no HTTP, and it must
-stay that way rather than take a presentation. So it returns **`timedelta`**
-values and `stats_content` formats them. That changes `StatsData.total_hours`
-from `str` to `timedelta`, and `longest_session_time` /
-`highest_session_average` from `Any` (currently `timedelta`-or-integer-`0`) to
-`timedelta | None` — the `0` fallback becomes `None`. Consumers at
-`stats_content.py:149`, `:199`, `:212` follow. `playevent.py:166` has the same
-shape: return the `timedelta`, format at the call site.
-
-### `common/time.py` cleanup
-
-`format_duration()`, `durationformat`, and `durationformat_manual` are deleted
-outright, along with the `%H`/`%m` mini-language. `tests/test_time.py`'s duration
-half is replaced by the new formatter's tests. Keeping a second duration
-formatter around is the drift this work exists to end.
-
-## Prerequisite: retire the finish/reset row swap (#583)
-
-**Separate, separately-landable PR, merged first.**
-
-Finish and reset currently PATCH `/api/session/{id}` and rebuild the row
-client-side (`ts/session-row.ts`, driven by `ts/elements/session-actions.ts`).
-That is the only client-rendered duration in the app. Keeping it would force a
-TypeScript duration formatter, a cross-language parity contract, and a real
-locale hazard — Django's `number_format` and JS `Intl.NumberFormat` do not
-reliably agree on the `cs` group separator.
-
-Replacing the swap with a plain POST and a full page reload deletes that entire
-half of the feature, and a second hand-port with it: `formatSessionTimeRange`
-re-implements the server's zone-label and date-line rules in TypeScript (verified
-to have `session-row.ts` as its only consumer).
-
-**`<session-actions>` shrinks; it is not deleted.** `custom_element_builder`
-auto-attaches `Media(js="dist/elements/<tag>.js")` (`primitives.py:252`), and
-`HashedStaticStorage` treats a missing manifest entry as a hard error — so
-deleting the TS file while keeping the element emits a `<script>` for a file that
-does not exist. The element survives as a ~15-line browser-time-zone stamper (see
-below); the props drop to what that needs.
-
-**Deletes** — `ts/session-row.ts`, `ts/session-row.test.ts`,
-`tests/test_session_row.py`, the row-swap and modal logic inside
-`ts/elements/session-actions.ts`, the `api_url` prop, the inline reset `Modal`
-and its body-portal hack in `SessionActions`, and `formatSessionTimeRange` plus
-its tests.
-
-Removing that modal also orphans `Modal(self_dismiss=False)` — its only
-consumer — and the `data-manage="false"` branch in `ts/elements/modal-dialog.ts`,
-along with `tests/test_components.py:1088` and
-`ts/elements/modal-dialog.test.ts:51`. Either delete the branch too or leave it
-deliberately, but do not leave the stale comments at `primitives.py:1679` and
-`modal-dialog.ts:9` pointing at a component that no longer exists.
-
-**Adds** — `games:finish_session` and `games:reset_session`, both POST-acting,
-both classified `ORIGIN_AWARE` in `games/views/returns.py`, both ending in
-`redirect(return_url(request, fallback="games:list_sessions"))`. Finish is a
-`ControlButton(method="post")`. Reset answers GET with a `ConfirmPage` and acts
-on POST at the same URL. Both targets built with
-`action_url(name, session.pk, origin=origin)`.
-
-`ORIGIN_AWARE` is correct and verified: `tests/test_returns_classification.py`
-enforces only exactly-one-bucket membership, and every `games:delete_*` route —
-all GET-confirms/POST-acts at one URL — already sits there.
-
-**`confirm_and_delete()` cannot be reused as-is**: it hardcodes
-`instance.delete()` (`deletion.py:54`) and `confirm_label="Delete"` (`:50`).
-Generalize it into a `confirm_and_apply(action, confirm_label, ...)` with
-`confirm_and_delete()` kept as a thin wrapper, so the seven existing delete views
-are untouched.
-
-**Browser time zone.** The client currently sends
-`timestamp_end_timezone: browserTimeZone()`. A plain POST does not know it, and
-`SESSION_TIME_ZONE_DISPLAY` defaults to `"own"`, so recording the account zone
-would visibly lie for a travelling user — the exact case #473 exists for. The
-shrunken `<session-actions>` fills a hidden input using the same
-`Intl.DateTimeFormat().resolvedOptions()` detection `ts/elements/time-zone-row.ts`
-already uses. The zone is data, not presentation.
-
-**`PATCH /api/session/{id}` stays.** It becomes UI-unused (verified: no other UI
-caller), but it is a documented REST surface next to the device PATCH.
-
-**Rewrites** — `e2e/test_session_finish_e2e.py`, `e2e/test_session_reset_e2e.py`,
-and `e2e/test_time_zone_row_e2e.py:100` (`test_finish_stamps_the_end_zone`),
-which clicks `[data-finish]` and asserts the row updates *without* a reload. It
-is also the only regression guard for the browser-zone hazard above, so it must
-be rewritten rather than dropped. `tests/test_rendered_pages.py:467` and
-`tests/test_components.py:307` assert the `api-url` attribute and fail outright
-once the prop goes — not touch-ups.
-
-Consequence for #486: "server-rendered and client-rebuilt content are
-byte-identical" is satisfied by construction; no client rebuild exists. Already
-moved to out-of-scope on the issue.
-
-## Audit: surfaces that consume the formatter
-
-| surface | file |
-|---|---|
-| session list duration cell | `games/views/session.py:62` |
-| game detail sessions table | `games/views/game.py:612` |
-| game list playtime | `games/views/game.py:505` |
-| game detail filtered playtime | `games/views/game.py:124`, `:451` |
-| navbar today / last-7 | `games/views/general.py:82` |
-| play-event range total | `games/views/playevent.py:166` |
-| stats total, longest session, session average | `games/views/stats_data.py:279`, `:306`, `:318` |
-| stats card durations | `games/views/stats_content.py:105` |
-
-Threading: the navbar values come from the `model_counts` context processor,
-which has the request. Stats formats in `stats_content`, which receives one.
-Neither needs new plumbing; `compute_stats()` deliberately gets none.
-
-## Untouched, canonical
-
-Database values, `GeneratedField` computation, all filtering and sorting
-(DB-side), the `duration_manual` form input (`HH:MM:SS`), the API's
-`duration_manual_seconds` integer, and the `playtime_hours` /
-`duration_total_hours` filter facets. None of these are presentation.
-
-## Testing
-
-- Table-driven unit tests over every cell above, plus the carry boundaries
-  (`1 h 59 m 45 s`, `23 h 59 m 45 s`, `6 d 23 h 40 m`, `29 m 30 s`).
-- Locale tests asserting `force_grouping` output and the decimal separator under
-  `cs` and `en-us`, with the NBSP written explicitly as `\xa0`.
-- Popover dedup by rendered string, including the 23 h 59 m 45 s case where
-  `adaptive` and `hours_minutes` diverge below 24 h.
-- Popover id uniqueness on a list page with two equal-duration rows — the case
-  `tests/test_html_validity.py:187` already guards for other components.
-- Registry tests: unregistered profile ID rejected; clearing the user value
-  restores the site default; live-save and source metadata behave like
-  `DATETIME_FORMAT`.
-- Rendered-page assertions on the audited surfaces.
-- One e2e pass changing the preference and confirming a session list re-renders.
-
-## Tracking
-
-- #583 — retire the finish/reset row swap. #486 is blocked on it.
-- #486 — design section points here; TypeScript parity moved to out-of-scope.
-- #584 — per-table duration-format explainer, a nice-to-have this design
-  deliberately does not include.
-
-`docs/configuration.md` gains a `DURATION_FORMAT` entry alongside the existing
-per-preference bullets. Its prior staleness (a missing
-`SESSION_TIME_ZONE_DISPLAY`, a stale "eight live site defaults" count, three
-undocumented preferences) is already fixed on this branch.
-
-## Out of scope
-
-Calendar date, clock time, datetime, timezone, and formatting-locale behaviour
-(#388, #389, #473). Changing stored duration precision or calculation semantics.
-A days-based option for the non-`adaptive` profiles.
diff --git a/e2e/test_admin_settings_page_e2e.py b/e2e/test_admin_settings_page_e2e.py
index 8eb0a987..6542c79e 100644
--- a/e2e/test_admin_settings_page_e2e.py
+++ b/e2e/test_admin_settings_page_e2e.py
@@ -19,6 +19,7 @@
     "DISPLAY_TIME_ZONE",
     "DATE_FORMAT_LOCALE",
     "DATETIME_FORMAT",
+    "DURATION_FORMAT",
 )
 
 
diff --git a/e2e/test_duration_format_e2e.py b/e2e/test_duration_format_e2e.py
new file mode 100644
index 00000000..8a805a35
--- /dev/null
+++ b/e2e/test_duration_format_e2e.py
@@ -0,0 +1,89 @@
+"""Changing the duration format preference re-renders every visible duration."""
+
+import datetime as dt
+
+import pytest
+from django.urls import reverse
+from playwright.sync_api import Page, expect
+
+from games.models import Game, Platform, Session
+from timetracker.settings_commands import change_user_setting
+
+
+@pytest.fixture
+def authenticated_page(live_server, page: Page, django_user_model) -> Page:
+    django_user_model.objects.create_user(username="tester", password="secret123")
+    page.goto(f"{live_server.url}{reverse('login')}")
+    page.fill('input[name="username"]', "tester")
+    page.fill('input[name="password"]', "secret123")
+    page.click('button:has-text("Login")')
+    page.wait_for_url(f"{live_server.url}/tracker**")
+    return page
+
+
+@pytest.fixture
+def session(db) -> Session:
+    game = Game.objects.create(
+        name="Duration Game", platform=Platform.objects.create(name="PC")
+    )
+    return Session.objects.create(
+        game=game,
+        timestamp_start=dt.datetime(2024, 6, 1, 12, 0, tzinfo=dt.UTC),
+        timestamp_end=dt.datetime(2024, 6, 1, 13, 12, tzinfo=dt.UTC),
+    )
+
+
+def _duration_cell(page: Page, session: Session):
+    return page.locator(f"#session-row-{session.pk} td").nth(1)
+
+
+def test_default_profile_renders_decimal_hours(
+    authenticated_page: Page, live_server, session
+):
+    page = authenticated_page
+    page.goto(f"{live_server.url}{reverse('games:list_sessions')}")
+
+    expect(_duration_cell(page, session)).to_contain_text("1.2 h")
+
+
+def test_changing_the_preference_rerenders_the_list(
+    authenticated_page: Page, live_server, django_user_model, session
+):
+    page = authenticated_page
+    change_user_setting(
+        django_user_model.objects.get(username="tester"),
+        "DURATION_FORMAT",
+        "hours_minutes",
+    )
+
+    page.goto(f"{live_server.url}{reverse('games:list_sessions')}")
+
+    expect(_duration_cell(page, session)).to_contain_text("1 h 12 m")
+
+
+def test_popover_lists_the_other_profiles(
+    authenticated_page: Page, live_server, session
+):
+    page = authenticated_page
+    page.goto(f"{live_server.url}{reverse('games:list_sessions')}")
+
+    trigger = _duration_cell(page, session).locator("[data-pop-over-control]")
+    trigger.click()
+
+    panel = page.locator(f"#duration-session-{session.pk}")
+    expect(panel).to_be_visible()
+    # The visible value never repeats inside its own panel.
+    expect(panel).to_contain_text("1 h 12 m")
+    expect(panel).to_contain_text("1 hour")
+    expect(panel).not_to_contain_text("1.2 h")
+
+
+def test_screen_reader_text_spells_the_value_out(
+    authenticated_page: Page, live_server, session
+):
+    page = authenticated_page
+    page.goto(f"{live_server.url}{reverse('games:list_sessions')}")
+
+    spoken = _duration_cell(page, session).locator(".sr-only")
+
+    expect(spoken).to_have_text("1 hour 12 minutes")
diff --git a/games/models.py b/games/models.py
index e79ecac0..329277e7 100644
--- a/games/models.py
+++ b/games/models.py
@@ -13,7 +13,7 @@
 from django.template.defaultfilters import floatformat, pluralize, slugify
 from django.utils import timezone
 
-from common.time import format_duration
+from common.duration_presentation import format_decimal_hours
 from common.utils import label_with_details
 from timetracker.settings_registry import THEME_CHOICES, SettingKey
 
@@ -102,9 +102,6 @@ def played(self):
     def unplayed(self):
         return self.status == self.Status.UNPLAYED
 
-    def playtime_formatted(self):
-        return format_duration(self.playtime, "%2.1H")
-
 
 class Platform(models.Model):
     name = models.CharField(max_length=255)
@@ -270,18 +267,12 @@ def save(self, *args, **kwargs):
 
 
 class SessionQuerySet(models.QuerySet):
-    def total_duration_formatted(self):
-        return format_duration(self.total_duration_unformatted())
-
     def total_duration_unformatted(self):
         result = self.aggregate(
             duration=Sum(F("duration_calculated") + F("duration_manual"))
         )
         return result["duration"]
 
-    def calculated_duration_formatted(self):
-        return format_duration(self.calculated_duration_unformatted())
-
     def calculated_duration_unformatted(self):
         result = self.aggregate(duration=Sum(F("duration_calculated")))
         return result["duration"]
@@ -351,19 +342,14 @@ class Meta:
 
     def __str__(self):
         mark = "*" if self.is_manual() else ""
-        return f"{self.game!s} {self.timestamp_start.date()!s} ({self.duration_formatted()}{mark})"
+        return (
+            f"{self.game!s} {self.timestamp_start.date()!s} "
+            f"({format_decimal_hours(self.duration_total)}{mark})"
+        )
 
     def finish_now(self):
         self.timestamp_end = timezone.now()
 
-    def duration_formatted(self) -> str:
-        result = format_duration(self.duration_total, "%02.1H")
-        return result
-
-    def duration_formatted_with_mark(self) -> str:
-        mark = "*" if self.is_manual() else ""
-        return f"{self.duration_formatted()}{mark}"
-
     def is_manual(self) -> bool:
         return self.duration_manual != timedelta(0)
 
diff --git a/games/views/game.py b/games/views/game.py
index 6d1cbf9c..e717be1e 100644
--- a/games/views/game.py
+++ b/games/views/game.py
@@ -17,6 +17,9 @@
     ContentContainer,
     ControlButton,
     Div,
+    Duration,
+    DurationAlternates,
+    DurationText,
     Fragment,
     GameStatus,
     GameStatusSelector,
@@ -42,9 +45,12 @@
     DateTimePresentation,
     date_time_presentation_for_request,
 )
+from common.duration_presentation import (
+    DurationPresentation,
+    duration_presentation_for_request,
+)
 from common.layout import render_page
 from common.returns import OriginUrl, action_url
-from common.time import format_duration
 from common.utils import paginate, safe_division
 from games.filters import (
     PlayEventFilter,
@@ -70,6 +76,7 @@
 @login_required
 def list_games(request: HttpRequest) -> HttpResponse:
     presentation = date_time_presentation_for_request(request)
+    durations = duration_presentation_for_request(request)
     origin = request.get_full_path()
     games = Game.objects.select_related("platform")
 
@@ -121,7 +128,11 @@ def list_games(request: HttpRequest) -> HttpResponse:
             make_row(
                 NameWithIcon(game=game, include_sort_name=True),
                 str(game.year_released),
-                format_duration(game.filtered_playtime or timedelta(0), "%2.1H"),
+                Duration(
+                    game.filtered_playtime or timedelta(0),
+                    durations,
+                    id_scope=f"game-{game.pk}-playtime",
+                ),
                 GameStatusSelector(game, Game.Status.choices, get_token(request)),
                 game.wikidata,
                 presentation.format(game.created_at, "date"),
@@ -317,12 +328,26 @@ def _played_row(game: Game, request: HttpRequest, origin: OriginUrl | None) -> N
     ]
 
 
-def _stat_popover(popover_id: str, tooltip: str, svg_key: str, value: str) -> Node:
+def _stat_popover(
+    popover_id: str,
+    tooltip: str,
+    svg_key: str,
+    value: Node | str,
+    details: Node | None = None,
+) -> Node:
+    """One header stat. ``details`` adds rows beneath the tooltip line — the
+    playtime stat puts its alternate formats there rather than nesting a second
+    popover inside this one."""
+    content: Node | str = (
+        tooltip
+        if details is None
+        else Div(class_="flex flex-col gap-1")[tooltip, details]
+    )
     return Popover(
-        popover_content=tooltip,
+        popover_content=content,
         wrapped_classes="flex gap-2 items-center",
         id=popover_id,
-        children=[Safe(_STAT_SVGS[svg_key]), str(value)],
+        children=[Safe(_STAT_SVGS[svg_key]), value],
     )
 
 
@@ -447,9 +472,8 @@ def _game_overview_metrics(game: Game) -> dict[str, Any]:
     playrange_start = sessions.earliest().timestamp_start if sessions.exists() else None
     playrange_end = sessions.latest().timestamp_start if sessions.exists() else None
 
-    total_hours_without_manual = float(
-        format_duration(sessions.calculated_duration_unformatted(), "%2.1H")
-    )
+    calculated_total = sessions.calculated_duration_unformatted() or timedelta(0)
+    total_hours_without_manual = calculated_total.total_seconds() / 3600
     session_average_without_manual = round(
         safe_division(total_hours_without_manual, int(session_count_without_manual)), 1
     )
@@ -466,6 +490,7 @@ def _game_header(
     request: HttpRequest,
     metrics: dict[str, Any],
     presentation: DateTimePresentation,
+    durations: DurationPresentation,
     origin: OriginUrl | None,
 ) -> Node:
     playrange_start = metrics["playrange_start"]
@@ -502,7 +527,8 @@ def _game_header(
             "popover-hours",
             "Total hours played",
             "hours",
-            game.playtime_formatted(),
+            DurationText(game.playtime, durations),
+            DurationAlternates(game.playtime, durations),
         ),
         _stat_popover(
             "popover-sessions",
@@ -603,13 +629,22 @@ def _purchases_section(
     )
 
 
-def _sessions_section(game: Game, presentation: DateTimePresentation) -> Node:
+def _sessions_section(
+    game: Game,
+    presentation: DateTimePresentation,
+    durations: DurationPresentation,
+) -> Node:
     sessions = game.sessions.select_related("device").order_by("-timestamp_start")
     session_count = sessions.count()
     rows = [
         make_row(
             session_time_range(session, presentation),
-            session.duration_formatted_with_mark(),
+            Duration(
+                session.duration_total,
+                durations,
+                id_scope=f"game-session-{session.pk}",
+                manual=session.is_manual(),
+            ),
             session.device.name if session.device else "No device",
         )
         for session in sessions[:5]
@@ -691,11 +726,19 @@ def _history_section(
 def view_game(request: HttpRequest, game_id: int) -> HttpResponse:
     game = Game.objects.get(id=game_id)
     presentation = date_time_presentation_for_request(request)
+    durations = duration_presentation_for_request(request)
     origin = request.get_full_path()
     content = ContentContainer(class_="dark:text-white")[
-        _game_header(game, request, _game_overview_metrics(game), presentation, origin),
+        _game_header(
+            game,
+            request,
+            _game_overview_metrics(game),
+            presentation,
+            durations,
+            origin,
+        ),
         _purchases_section(game, presentation, origin),
-        _sessions_section(game, presentation),
+        _sessions_section(game, presentation, durations),
         _playevents_section(game, presentation, origin),
         _history_section(game, presentation, origin),
     ]
diff --git a/games/views/general.py b/games/views/general.py
index 825e71cd..9f8050a0 100644
--- a/games/views/general.py
+++ b/games/views/general.py
@@ -17,6 +17,7 @@
 from common.components import (
     CsrfInput,
     Div,
+    Duration,
     FilterBuilder,
     FilterCount,
     FilterGroup,
@@ -29,8 +30,8 @@
 )
 from common.components.primitives import ContentContainer, PageHeading, Span
 from common.date_time_presentation import date_time_presentation_for_request
+from common.duration_presentation import duration_presentation_for_request
 from common.layout import render_page
-from common.time import format_duration
 from games.filters import SessionFilter, filter_url, model_field_registry
 from games.models import Device, Game, Platform, Purchase, Session
 from games.sorting import parse_per_page_override
@@ -63,6 +64,8 @@ def model_counts(request: HttpRequest) -> dict[str, Any]:
         timestamp_start__lt=start_of_tomorrow,
     ).aggregate(time=Sum(F("duration_total")))["time"]
 
+    durations = duration_presentation_for_request(request)
+
     today_iso = today.isoformat()
     today_url = filter_url(SessionFilter.where(timestamp_start=today_iso))
     last_7_url = filter_url(
@@ -79,8 +82,12 @@ def model_counts(request: HttpRequest) -> dict[str, Any]:
         "platform_available": Platform.objects.exists(),
         "purchase_available": Purchase.objects.exists(),
         "session_count": Session.objects.exists(),
-        "today_played": format_duration(today_played, "%H h %m m"),
-        "last_7_played": format_duration(last_7_played, "%H h %m m"),
+        "today_played": Duration(
+            today_played, durations, id_scope="navbar-today", link=today_url
+        ),
+        "last_7_played": Duration(
+            last_7_played, durations, id_scope="navbar-last-7", link=last_7_url
+        ),
         "today_url": today_url,
         "last_7_url": last_7_url,
     }
@@ -94,7 +101,10 @@ def global_current_year(request: HttpRequest) -> dict[str, int]:
 def stats_alltime(request: HttpRequest) -> HttpResponse:
     data = compute_stats(None)
     presentation = date_time_presentation_for_request(request)
-    return render_page(request, stats_content(data, presentation), title=data["title"])
+    durations = duration_presentation_for_request(request)
+    return render_page(
+        request, stats_content(data, presentation, durations), title=data["title"]
+    )
 
 
 @login_required
@@ -108,7 +118,10 @@ def stats(request: HttpRequest, year: int = 0) -> HttpResponse:
         return HttpResponseRedirect(reverse("games:stats_alltime"))
     data = compute_stats(year)
     presentation = date_time_presentation_for_request(request)
-    return render_page(request, stats_content(data, presentation), title=data["title"])
+    durations = duration_presentation_for_request(request)
+    return render_page(
+        request, stats_content(data, presentation, durations), title=data["title"]
+    )
 
 
 # The lists backed by an OperatorFilter + nested builder. Keys are model keys
diff --git a/games/views/playevent.py b/games/views/playevent.py
index 8e802845..1d1eb742 100644
--- a/games/views/playevent.py
+++ b/games/views/playevent.py
@@ -31,9 +31,12 @@
     DateTimePresentation,
     date_time_presentation_for_request,
 )
+from common.duration_presentation import (
+    DurationPresentation,
+    duration_format_profile,
+)
 from common.layout import render_page
 from common.returns import OriginUrl, action_url
-from common.time import format_duration
 from common.utils import paginate
 from games.filters import parse_playevent_filter
 from games.forms import PlayEventForm
@@ -163,7 +166,10 @@ def _get_formatted_playtime_for_game_sessions_in_range(
     sessions_in_range = sessions_queryset.filter(
         timestamp_start__gte=actual_start_ts, timestamp_start__lte=actual_end_ts
     )
-    return format_duration(sessions_in_range.total_duration_unformatted(), "%Hh %mm")
+    # This seeds a note the user then saves, so it is stored text rather than
+    # display: a per-viewer duration preference must not leak into it.
+    fixed = DurationPresentation(duration_format_profile("hours_minutes"), "en-us")
+    return fixed.format(sessions_in_range.total_duration_unformatted())
 
 
 @login_required
diff --git a/games/views/session.py b/games/views/session.py
index 43dc91fe..d25969bc 100644
--- a/games/views/session.py
+++ b/games/views/session.py
@@ -13,6 +13,7 @@
     AddForm,
     BrowserTimeZoneInput,
     Column,
+    Duration,
     FormFields,
     Fragment,
     ModuleScript,
@@ -29,6 +30,10 @@
     date_time_presentation_for_request,
     zone_or_none,
 )
+from common.duration_presentation import (
+    DurationPresentation,
+    duration_presentation_for_request,
+)
 from common.layout import render_page
 from common.returns import OriginUrl
 from common.utils import paginate
@@ -52,6 +57,7 @@ def session_row_data(
     device_list,
     csrf_token: str,
     presentation: DateTimePresentation,
+    durations: DurationPresentation,
     *,
     origin: OriginUrl | None,
 ) -> TableRowData:
@@ -60,7 +66,12 @@ def session_row_data(
     return make_row(
         NameWithIcon(session=session),
         session_time_range(session, presentation),
-        session.duration_formatted_with_mark(),
+        Duration(
+            session.duration_total,
+            durations,
+            id_scope=f"session-{session.pk}",
+            manual=session.is_manual(),
+        ),
         SessionDeviceSelector(session, device_list, csrf_token),
         presentation.format(session.created_at, "date"),
         SessionActions(session, csrf_token, origin),
@@ -71,6 +82,7 @@ def session_row_data(
 @login_required
 def list_sessions(request: HttpRequest) -> HttpResponse:
     presentation = date_time_presentation_for_request(request)
+    durations = duration_presentation_for_request(request)
     origin = request.get_full_path()
     sessions: QuerySet[Session] = Session.objects.select_related(
         "game", "game__platform", "device"
@@ -108,7 +120,12 @@ def list_sessions(request: HttpRequest) -> HttpResponse:
         "sort_terms": sort.terms,
         "rows": [
             session_row_data(
-                session, device_list, csrf_token, presentation, origin=origin
+                session,
+                device_list,
+                csrf_token,
+                presentation,
+                durations,
+                origin=origin,
             )
             for session in sessions
         ],
diff --git a/games/views/stats_content.py b/games/views/stats_content.py
index c5f402e4..602c9c87 100644
--- a/games/views/stats_content.py
+++ b/games/views/stats_content.py
@@ -17,6 +17,7 @@
     ContentContainer,
     ControlButton,
     Div,
+    Duration,
     Fragment,
     GameLink,
     Icon,
@@ -29,7 +30,7 @@
     make_row,
 )
 from common.date_time_presentation import DateTimePresentation
-from common.time import durationformat, format_duration
+from common.duration_presentation import DurationPresentation
 from games.filters import filter_url
 from games.views import stats_links
 from games.views.stats_data import StatsData
@@ -101,10 +102,6 @@ def _card(title: str, body: Node) -> Node:
     return Div(class_="min-w-0")[_card_title(title), body]
 
 
-def _dur(value) -> str:
-    return format_duration(value, durationformat)
-
-
 def _purchase_name(purchase) -> Node:
     """Mirror of the `purchase-name` partial in the old template."""
     game_name = getattr(purchase, "game_name", None)
@@ -143,10 +140,15 @@ def _year_nav(year, year_range, url_template) -> Node:
     return Div(class_="flex justify-center items-center mb-12")[alltime_btn, picker]
 
 
-def _playtime_table(ctx, presentation: DateTimePresentation) -> Node:
+def _playtime_table(
+    ctx, presentation: DateTimePresentation, durations: DurationPresentation
+) -> Node:
     year = ctx.get("year")
     rows = [
-        make_row("Hours", _cell(ctx.get("total_hours"))),
+        make_row(
+            "Hours",
+            Duration(ctx.get("total_hours"), durations, id_scope="stats-total-hours"),
+        ),
         make_row(
             "Sessions",
             _count_link(
@@ -185,7 +187,7 @@ def _game_row(label, value, game):
         return make_row(
             label,
             Fragment(
-                _cell(value),
+                value if isinstance(value, Node) else _cell(value),
                 " (",
                 GameLink(game.id, game.name),
                 ")",
@@ -196,7 +198,15 @@ def _game_row(label, value, game):
     longest_game = ctx.get("longest_session_game")
     if longest_game and longest_game.id:
         rows.append(
-            _game_row("Longest session", ctx.get("longest_session_time"), longest_game)
+            _game_row(
+                "Longest session",
+                Duration(
+                    ctx.get("longest_session_time"),
+                    durations,
+                    id_scope="stats-longest-session",
+                ),
+                longest_game,
+            )
         )
     most_sessions_game = ctx.get("highest_session_count_game")
     if most_sessions_game and most_sessions_game.id:
@@ -209,7 +219,13 @@ def _game_row(label, value, game):
     if avg_game and avg_game.id:
         rows.append(
             _game_row(
-                "Highest session average", ctx.get("highest_session_average"), avg_game
+                "Highest session average",
+                Duration(
+                    ctx.get("highest_session_average"),
+                    durations,
+                    id_scope="stats-session-average",
+                ),
+                avg_game,
             )
         )
     first_game = ctx.get("first_play_game")
@@ -340,7 +356,11 @@ def _priced_table(purchases, currency, view_all_url=None, total=None) -> Node:
     return table
 
 
-def stats_content(ctx: StatsData, presentation: DateTimePresentation) -> Node:
+def stats_content(
+    ctx: StatsData,
+    presentation: DateTimePresentation,
+    durations: DurationPresentation,
+) -> Node:
     year = ctx["year"]
     currency = ctx.get("total_spent_currency")
     # Build a navigation URL with an `__year__` placeholder the picker's JS
@@ -351,7 +371,7 @@ def stats_content(ctx: StatsData, presentation: DateTimePresentation) -> Node:
     )
     # Each stats section is one card in the grid: a title above its table.
     cards: list[Node] = [
-        _card("Playtime", _playtime_table(ctx, presentation)),
+        _card("Playtime", _playtime_table(ctx, presentation, durations)),
     ]
 
     months = list(ctx.get("month_playtimes") or [])
@@ -359,13 +379,16 @@ def stats_content(ctx: StatsData, presentation: DateTimePresentation) -> Node:
         month_rows = [
             make_row(
                 presentation.format(m["month"], "month"),
-                A(
-                    href=filter_url(
+                Duration(
+                    m["playtime"],
+                    durations,
+                    id_scope=f"stats-month-{m['month'].month}",
+                    link=filter_url(
                         stats_links.games_in_month(year, m["month"].month),
                         sort="-filtered_playtime",
                     ),
-                    class_=_FILTER_LINK_CLASS,
-                )[_dur(m["playtime"])],
+                    link_class=_FILTER_LINK_CLASS,
+                ),
             )
             for m in months
         ]
@@ -381,7 +404,11 @@ def stats_content(ctx: StatsData, presentation: DateTimePresentation) -> Node:
                 lambda g: Fragment(
                     GameLink(g.id, g.name), _session_link(g.id, year, g.name)
                 ),
-                lambda g: _dur(g.total_playtime),
+                lambda g: Duration(
+                    g.total_playtime,
+                    durations,
+                    id_scope=f"stats-game-{g.id}-playtime",
+                ),
                 view_all_url=filter_url(
                     stats_links.games_played(year), sort="-filtered_playtime"
                 ),
@@ -393,14 +420,17 @@ def stats_content(ctx: StatsData, presentation: DateTimePresentation) -> Node:
                 "Platform",
                 ctx.get("total_playtime_per_platform") or [],
                 lambda item: item["platform_name"] or "Unspecified",
-                lambda item: A(
-                    href=filter_url(
+                lambda item: Duration(
+                    item["playtime"],
+                    durations,
+                    id_scope=f"stats-platform-{item['platform_id'] or 'none'}",
+                    link=filter_url(
                         stats_links.sessions_for_platform(
                             item["platform_id"], year, item["platform_name"] or ""
                         )
                     ),
-                    class_=_FILTER_LINK_CLASS,
-                )[_dur(item["playtime"])],
+                    link_class=_FILTER_LINK_CLASS,
+                ),
             ),
         ),
     ]
diff --git a/games/views/stats_data.py b/games/views/stats_data.py
index 6651deb9..f81aa488 100644
--- a/games/views/stats_data.py
+++ b/games/views/stats_data.py
@@ -27,7 +27,7 @@
 )
 from django.db.models.functions import TruncDate, TruncMonth
 
-from common.time import available_stats_year_range, format_duration
+from common.time import available_stats_year_range
 from common.utils import safe_division
 from games.models import Game, Purchase, Session
 
@@ -36,7 +36,7 @@ class StatsData(TypedDict):
     # --- always present (both scopes) ---
     year: Any  # int for a year, "Alltime" for all-time
     title: str
-    total_hours: str
+    total_hours: timedelta
     total_sessions: int
     unique_days: int
     unique_days_percent: int
@@ -56,11 +56,11 @@ class StatsData(TypedDict):
     purchased_unfinished_count: int
     unfinished_purchases_percent: int
     backlog_decrease_count: int
-    longest_session_time: Any
+    longest_session_time: timedelta | None
     longest_session_game: Any
     highest_session_count: int
     highest_session_count_game: Any
-    highest_session_average: Any
+    highest_session_average: timedelta | None
     highest_session_average_game: Any
     first_play_game: Any
     first_play_date: datetime | None
@@ -276,7 +276,7 @@ def compute_stats(year: int | None = None) -> StatsData:
     data: StatsData = {
         "year": year_label,
         "title": f"{year_label} Stats",
-        "total_hours": format_duration(sessions.total_duration_unformatted(), "%2.0H"),
+        "total_hours": sessions.total_duration_unformatted() or timedelta(0),
         "total_sessions": sessions.count(),
         "unique_days": unique_days,
         "unique_days_percent": unique_days_percent,
@@ -302,11 +302,7 @@ def compute_stats(year: int | None = None) -> StatsData:
             safe_division(unfinished_count, without_refunded_count) * 100
         ),
         "backlog_decrease_count": backlog_decrease_count,
-        "longest_session_time": (
-            format_duration(longest_session.duration, "%2.0Hh %2.0mm")
-            if longest_session
-            else 0
-        ),
+        "longest_session_time": longest_session.duration if longest_session else None,
         "longest_session_game": longest_session.game if longest_session else None,
         "highest_session_count": (
             highest_session_count_game.session_count
@@ -315,11 +311,9 @@ def compute_stats(year: int | None = None) -> StatsData:
         ),
         "highest_session_count_game": highest_session_count_game,
         "highest_session_average": (
-            format_duration(
-                highest_session_average_game.session_average, "%2.0Hh %2.0mm"
-            )
+            highest_session_average_game.session_average
             if highest_session_average_game
-            else 0
+            else None
         ),
         "highest_session_average_game": highest_session_average_game,
         "first_play_game": first_play_game,
diff --git a/tests/test_admin_settings_page.py b/tests/test_admin_settings_page.py
index 4355f1ea..6481b3cc 100644
--- a/tests/test_admin_settings_page.py
+++ b/tests/test_admin_settings_page.py
@@ -32,6 +32,7 @@
     "SESSION_TIME_ZONE_DISPLAY",
     "DATE_FORMAT_LOCALE",
     "DATETIME_FORMAT",
+    "DURATION_FORMAT",
 )
 
 
@@ -323,8 +324,8 @@ def test_admin_page_lists_device_rows_and_select_options(
 
     # One per USER-scope SELECT setting: default_landing_page, default_page_size,
     # theme, display_time_zone, session_time_zone_display, date_format_locale,
-    # datetime_format (default_currency/default_device are not SELECT widgets).
-    assert html.count(">Use configured default</option>") == 8
+    # datetime_format, duration_format (default_currency is not a SELECT widget).
+    assert html.count(">Use configured default</option>") == 9
     assert html.index(
         f'<option value="{desktop.pk}">Desktop (PC)</option>'
     ) < html.index(">Steam Deck (Handheld)</option>")
diff --git a/tests/test_components.py b/tests/test_components.py
index efa9cc47..52385dab 100644
--- a/tests/test_components.py
+++ b/tests/test_components.py
@@ -195,7 +195,9 @@ def test_shared_semantic_term_and_value_treatment(self):
         self.assertIn("<dl", html)
         self.assertIn('data-tooltip-definition-list=""', html)
         self.assertIn("flex flex-col gap-2 max-w-sm", html)
-        self.assertEqual(html.count('<dt class="text-type-micro text-body">'), 2)
+        self.assertEqual(
+            html.count('<dt class="text-type-micro text-body font-medium">'), 2
+        )
         self.assertEqual(html.count('<dd class="font-medium">'), 2)
         self.assertIn(">Name</dt>", html)
         self.assertIn(">The Display Name</dd>", html)
@@ -2755,3 +2757,63 @@ def test_confirm_page_renders_details_outside_the_message_paragraph():
 
 if __name__ == "__main__":
     unittest.main()
+
+
+class PopoverDescribedbyTest(unittest.TestCase):
+    """A popover whose panel only restates the trigger can drop the
+    description, so a screen reader does not read the value twice."""
+
+    def test_popover_omits_describedby_when_disabled(self):
+        html = str(
+            components.Popover(
+                popover_content="1 h 12 m",
+                wrapped_content="1.2 h",
+                id="duration-1",
+                describedby=False,
+            )
+        )
+        self.assertNotIn("aria-describedby", html)
+
+    def test_panel_keeps_its_id_and_tooltip_role_when_describedby_is_off(self):
+        html = str(
+            components.Popover(
+                popover_content="1 h 12 m",
+                wrapped_content="1.2 h",
+                id="duration-2",
+                describedby=False,
+            )
+        )
+        self.assertIn('id="duration-2"', html)
+        self.assertIn('role="tooltip"', html)
+
+    def test_describedby_is_present_by_default(self):
+        html = str(
+            components.Popover(
+                popover_content="original", wrapped_content="converted", id="price-1"
+            )
+        )
+        self.assertIn('aria-describedby="price-1"', html)
+
+
+class TooltipPanelFontTest(unittest.TestCase):
+    """A tooltip panel is a descendant of whatever it annotates, so it must
+    state its own font family — otherwise one mounted inside a data table or a
+    TruncatedText host renders condensed while every other tooltip does not."""
+
+    def test_definition_terms_state_their_own_weight(self):
+        html = str(
+            components.TooltipDefinitionList(
+                [components.TooltipDefinition("Term", "Value")]
+            )
+        )
+        term_class = html.split("<dt")[1].split('class="')[1].split('"')[0]
+        self.assertIn("font-medium", term_class)
+
+    def test_panel_states_its_font_family(self):
+        html = str(
+            components.Popover(
+                popover_content="detail", wrapped_content="value", id="font-check"
+            )
+        )
+        panel_class = html.split('data-pop-over-panel=""')[1].split('class="')[1]
+        self.assertIn("font-sans", panel_class.split('"')[0])
diff --git a/tests/test_duration_component.py b/tests/test_duration_component.py
new file mode 100644
index 00000000..395f2bfe
--- /dev/null
+++ b/tests/test_duration_component.py
@@ -0,0 +1,104 @@
+"""Duration(): the visible rendering, its alternates, and its spoken form."""
+
+from datetime import timedelta
+
+import pytest
+
+from common.components import Duration
+from common.components.core import assert_unique_element_ids
+from common.duration_presentation import (
+    DurationPresentation,
+    duration_format_profile,
+)
+
+MINUTE = 60
+HOUR = 60 * MINUTE
+
+
+def _presentation(profile_id: str = "decimal_hours") -> DurationPresentation:
+    return DurationPresentation(
+        profile=duration_format_profile(profile_id), locale="en-us"
+    )
+
+
+def _render(seconds: int, *, id_scope: str = "session-1-duration", **kwargs) -> str:
+    return str(
+        Duration(
+            timedelta(seconds=seconds),
+            _presentation(),
+            id_scope=id_scope,
+            **kwargs,
+        )
+    )
+
+
+def test_visible_value_is_hidden_from_assistive_technology():
+    html = _render(HOUR + 12 * MINUTE)
+
+    assert 'aria-hidden="true"' in html
+    assert "1.2 h" in html
+
+
+def test_spoken_text_is_rendered_sr_only():
+    html = _render(HOUR + 12 * MINUTE)
+
+    assert 'class="sr-only"' in html
+    assert "1 hour 12 minutes" in html
+
+
+def test_manual_mark_follows_the_value_and_is_spoken():
+    html = _render(HOUR + 12 * MINUTE, manual=True)
+
+    assert "1.2 h*" in html
+    assert "1 hour 12 minutes, manual" in html
+
+
+def test_alternates_render_as_label_value_rows():
+    html = _render(HOUR + 12 * MINUTE)
+
+    assert "Hours and minutes" in html
+    assert "1 h 12 m" in html
+    assert "Whole hours" in html
+    assert "1 hour" in html
+
+
+def test_describedby_is_absent():
+    """The sr-only text already carries the value; describing the trigger with
+    the panel would read the same number three times per row."""
+    assert "aria-describedby" not in _render(HOUR + 12 * MINUTE)
+
+
+def test_two_equal_durations_get_distinct_ids():
+    """Popover derives an id by hashing its content, so equal durations on one
+    page would collide without a caller-supplied scope."""
+    from common.components import Fragment
+
+    document = Fragment(
+        Duration(timedelta(0), _presentation(), id_scope="game-1-playtime"),
+        Duration(timedelta(0), _presentation(), id_scope="game-2-playtime"),
+    )
+
+    assert_unique_element_ids(str(document))
+
+
+def test_id_scope_is_required():
+    with pytest.raises(TypeError):
+        Duration(timedelta(0), _presentation())  # type: ignore[call-arg]
+
+
+def test_linked_duration_hides_its_glyph_on_pointer_devices():
+    """The info glyph exists for devices that cannot hover, matching
+    TruncatedText's reveal button. On a pointer device the panel opens by
+    hovering the total itself, so the glyph would be noise."""
+    html = str(
+        Duration(
+            timedelta(seconds=HOUR),
+            _presentation(),
+            id_scope="navbar-today",
+            link="/tracker/session/list",
+        )
+    )
+
+    assert "hidden [@media(hover:none)]:inline-flex" in html
+    assert 'href="/tracker/session/list"' in html
+    assert 'aria-label="Other duration formats"' in html
diff --git a/tests/test_duration_presentation.py b/tests/test_duration_presentation.py
new file mode 100644
index 00000000..5a02c04e
--- /dev/null
+++ b/tests/test_duration_presentation.py
@@ -0,0 +1,242 @@
+"""Every duration profile's exact rendering, including the carry boundaries.
+
+The table mirrors the rendering rules in
+docs/superpowers/specs/2026-07-29-issue-486-duration-format-design.md — it is
+the specification, so a change here is a design change, not a test fix.
+"""
+
+from datetime import timedelta
+
+import pytest
+
+from common.duration_presentation import (
+    DurationPresentation,
+    duration_format_profile,
+    format_decimal_hours,
+)
+
+MINUTE = 60
+HOUR = 60 * MINUTE
+DAY = 24 * HOUR
+
+# (seconds, decimal_hours, hours_minutes, whole_hours, adaptive)
+RENDERINGS = [
+    (0, "0.0 h", "0 h", "0 hours", "0 h"),
+    (45, "0.0 h", "1 m", "0 hours", "1 m"),
+    (29 * MINUTE, "0.5 h", "29 m", "0 hours", "29 m"),
+    (45 * MINUTE, "0.8 h", "45 m", "1 hour", "45 m"),
+    (HOUR + 12 * MINUTE, "1.2 h", "1 h 12 m", "1 hour", "1 h 12 m"),
+    (3 * HOUR + 5 * MINUTE, "3.1 h", "3 h 05 m", "3 hours", "3 h 05 m"),
+    (3 * HOUR + 30 * MINUTE, "3.5 h", "3 h 30 m", "4 hours", "3 h 30 m"),
+    (23 * HOUR + 59 * MINUTE + 45, "24.0 h", "24 h 00 m", "24 hours", "1 d 00 h"),
+    (26 * HOUR, "26.0 h", "26 h 00 m", "26 hours", "1 d 02 h"),
+    (83 * HOUR + 12 * MINUTE, "83.2 h", "83 h 12 m", "83 hours", "3 d 11 h"),
+    (200 * HOUR, "200.0 h", "200 h 00 m", "200 hours", "1 w 1 d"),
+    (1234 * HOUR, "1,234.0 h", "1,234 h 00 m", "1,234 hours", "7 w 2 d"),
+    (9000 * HOUR, "9,000.0 h", "9,000 h 00 m", "9,000 hours", "1 y 2 w"),
+]
+
+PROFILE_IDS = ("decimal_hours", "hours_minutes", "whole_hours", "adaptive")
+
+
+def _presentation(profile_id: str) -> DurationPresentation:
+    return DurationPresentation(
+        profile=duration_format_profile(profile_id), locale="en-us"
+    )
+
+
+@pytest.mark.parametrize("row", RENDERINGS, ids=[str(row[0]) for row in RENDERINGS])
+@pytest.mark.parametrize("index,profile_id", list(enumerate(PROFILE_IDS, start=1)))
+def test_renders_the_specified_value(row, index, profile_id):
+    seconds, *expected_per_profile = row
+
+    rendered = _presentation(profile_id).format(timedelta(seconds=seconds))
+
+    assert rendered == expected_per_profile[index - 1]
+
+
+@pytest.mark.parametrize("profile_id", PROFILE_IDS)
+def test_none_renders_as_zero(profile_id):
+    presentation = _presentation(profile_id)
+
+    assert presentation.format(None) == presentation.format(timedelta(0))
+
+
+@pytest.mark.parametrize("profile_id", PROFILE_IDS)
+def test_negative_clamps_to_zero(profile_id):
+    """timestamp_end before timestamp_start is bad data, not a negative
+    duration."""
+    presentation = _presentation(profile_id)
+
+    assert presentation.format(timedelta(seconds=-500)) == presentation.format(
+        timedelta(0)
+    )
+
+
+@pytest.mark.parametrize(
+    "seconds,expected",
+    [
+        # Rounding a component after the split would give "2 h 60 m".
+        (HOUR + 59 * MINUTE + 45, "2 h 00 m"),
+        (29 * MINUTE + 30, "30 m"),
+    ],
+)
+def test_hours_minutes_rounds_the_total_once(seconds, expected):
+    assert _presentation("hours_minutes").format(timedelta(seconds=seconds)) == expected
+
+
+@pytest.mark.parametrize(
+    "seconds,expected",
+    [
+        # Rounding carries into a higher unit, so the ladder re-picks rather
+        # than rendering "6 d 24 h".
+        (6 * DAY + 23 * HOUR + 40 * MINUTE, "1 w 0 d"),
+        (HOUR + 59 * MINUTE + 45, "2 h 00 m"),
+    ],
+)
+def test_adaptive_repicks_when_rounding_carries(seconds, expected):
+    assert _presentation("adaptive").format(timedelta(seconds=seconds)) == expected
+
+
+def test_unregistered_profile_id_raises():
+    with pytest.raises(ValueError, match="two_hours"):
+        duration_format_profile("two_hours")
+
+
+def test_format_decimal_hours_is_preference_independent():
+    """Session.__str__ and other request-less callers need one fixed
+    rendering, not the viewer's profile."""
+    assert format_decimal_hours(timedelta(seconds=HOUR + 12 * MINUTE)) == "1.2"
+    assert format_decimal_hours(None) == "0.0"
+
+
+# The cs thousand separator is U+00A0, not an ASCII space.
+CZECH_GROUP = "\xa0"
+
+
+@pytest.mark.parametrize(
+    "locale,expected",
+    [("en-us", "1,234 hours"), ("cs", f"1{CZECH_GROUP}234 hours")],
+)
+def test_grouping_follows_the_locale(locale, expected):
+    presentation = DurationPresentation(
+        profile=duration_format_profile("whole_hours"), locale=locale
+    )
+
+    assert presentation.format(timedelta(seconds=1234 * HOUR)) == expected
+
+
+@pytest.mark.parametrize("locale,expected", [("en-us", "1.2 h"), ("cs", "1,2 h")])
+def test_decimal_separator_follows_the_locale(locale, expected):
+    presentation = DurationPresentation(
+        profile=duration_format_profile("decimal_hours"), locale=locale
+    )
+
+    assert presentation.format(timedelta(seconds=HOUR + 12 * MINUTE)) == expected
+
+
+@pytest.mark.parametrize("locale", ["en-us", "cs"])
+def test_small_values_are_not_grouped(locale):
+    presentation = DurationPresentation(
+        profile=duration_format_profile("whole_hours"), locale=locale
+    )
+
+    assert presentation.format(timedelta(seconds=26 * HOUR)) == "26 hours"
+
+
+def test_formatting_does_not_leak_the_active_translation():
+    """The formatting locale must never become the application's language —
+    common/middleware.py keeps them apart deliberately."""
+    from django.utils.translation import get_language
+
+    before = get_language()
+    DurationPresentation(
+        profile=duration_format_profile("whole_hours"), locale="cs"
+    ).format(timedelta(seconds=1234 * HOUR))
+
+    assert get_language() == before
+
+
+def _alternates(profile_id: str, seconds: int):
+    return _presentation(profile_id).alternates(timedelta(seconds=seconds))
+
+
+def test_alternates_exclude_the_visible_rendering():
+    visible = _presentation("decimal_hours").format(
+        timedelta(seconds=HOUR + 12 * MINUTE)
+    )
+
+    renderings = [
+        text for _label, text in _alternates("decimal_hours", HOUR + 12 * MINUTE)
+    ]
+
+    assert visible not in renderings
+
+
+def test_alternates_drop_duplicates_below_24h():
+    """hours_minutes and adaptive agree below a day, so the popover shows the
+    value once, not twice."""
+    renderings = [
+        text for _label, text in _alternates("decimal_hours", HOUR + 12 * MINUTE)
+    ]
+
+    assert renderings == ["1 h 12 m", "1 hour"]
+
+
+def test_alternates_keep_all_three_above_24h():
+    renderings = [
+        text for _label, text in _alternates("decimal_hours", 83 * HOUR + 12 * MINUTE)
+    ]
+
+    assert renderings == ["83 h 12 m", "83 hours", "3 d 11 h"]
+
+
+def test_adaptive_and_hours_minutes_diverge_at_the_carry_boundary():
+    """23 h 59 m 45 s rounds to 24 h 00 m under hours_minutes but re-picks to
+    1 d 00 h under adaptive — which is why dedup compares rendered strings and
+    never profile identity."""
+    renderings = [
+        text
+        for _label, text in _alternates("decimal_hours", 23 * HOUR + 59 * MINUTE + 45)
+    ]
+
+    assert renderings == ["24 h 00 m", "24 hours", "1 d 00 h"]
+
+
+def test_alternates_are_labelled_with_their_profile():
+    labels = [label for label, _text in _alternates("decimal_hours", 83 * HOUR)]
+
+    assert labels == ["Hours and minutes", "Whole hours", "Adaptive units"]
+
+
+@pytest.mark.parametrize(
+    "seconds,expected",
+    [
+        (0, "0 hours"),
+        (45, "1 minute"),
+        (45 * MINUTE, "45 minutes"),
+        (HOUR + 12 * MINUTE, "1 hour 12 minutes"),
+        (2 * HOUR, "2 hours"),
+        (9000 * HOUR, "9000 hours"),
+        # Never days or weeks: "375 days" helps nobody.
+        (9 * DAY, "216 hours"),
+    ],
+)
+def test_spoken_uses_words_and_pluralizes(seconds, expected):
+    assert _presentation("adaptive").spoken(timedelta(seconds=seconds)) == expected
+
+
+def test_spoken_is_the_same_whatever_the_visible_profile():
+    value = timedelta(seconds=HOUR + 12 * MINUTE)
+
+    spoken = {_presentation(profile_id).spoken(value) for profile_id in PROFILE_IDS}
+
+    assert spoken == {"1 hour 12 minutes"}
+
+
+def test_spoken_marks_a_manual_session():
+    spoken = _presentation("decimal_hours").spoken(
+        timedelta(seconds=HOUR + 12 * MINUTE), manual=True
+    )
+
+    assert spoken == "1 hour 12 minutes, manual"
diff --git a/tests/test_duration_setting.py b/tests/test_duration_setting.py
new file mode 100644
index 00000000..0f727b4b
--- /dev/null
+++ b/tests/test_duration_setting.py
@@ -0,0 +1,59 @@
+"""DURATION_FORMAT resolves through the same chain every user preference does."""
+
+import pytest
+from django.core.exceptions import ValidationError
+from django.test import RequestFactory
+
+from common.duration_presentation import duration_presentation_for_request
+from timetracker.settings_commands import change_site_setting, change_user_setting
+from timetracker.settings_resolver import resolve_str_for_user
+
+
+@pytest.fixture
+def user(django_user_model, db):
+    return django_user_model.objects.create_user(username="u", password="p")
+
+
+def test_default_is_decimal_hours(user):
+    assert resolve_str_for_user(user, "DURATION_FORMAT") == "decimal_hours"
+
+
+def test_personal_value_overrides_the_site_default(user):
+    change_site_setting("DURATION_FORMAT", "whole_hours")
+    change_user_setting(user, "DURATION_FORMAT", "adaptive")
+
+    assert resolve_str_for_user(user, "DURATION_FORMAT") == "adaptive"
+
+
+def test_clearing_the_personal_value_restores_the_site_default(user):
+    change_site_setting("DURATION_FORMAT", "whole_hours")
+    change_user_setting(user, "DURATION_FORMAT", "adaptive")
+
+    change_user_setting(user, "DURATION_FORMAT", None)
+
+    assert resolve_str_for_user(user, "DURATION_FORMAT") == "whole_hours"
+
+
+@pytest.mark.parametrize("value", ["two_hours", "", "ADAPTIVE!"])
+def test_unregistered_profile_is_rejected(user, value):
+    with pytest.raises(ValidationError):
+        change_user_setting(user, "DURATION_FORMAT", value)
+
+
+def test_presentation_is_cached_on_the_request(user):
+    request = RequestFactory().get("/tracker/session/list")
+    request.user = user
+
+    first = duration_presentation_for_request(request)
+    second = duration_presentation_for_request(request)
+
+    assert first is second
+    assert first.profile.id == "decimal_hours"
+
+
+def test_presentation_follows_the_personal_preference(user):
+    change_user_setting(user, "DURATION_FORMAT", "adaptive")
+    request = RequestFactory().get("/tracker/session/list")
+    request.user = user
+
+    assert duration_presentation_for_request(request).profile.id == "adaptive"
diff --git a/tests/test_session_formatting.py b/tests/test_session_formatting.py
index e86e9020..d3d9f8b7 100644
--- a/tests/test_session_formatting.py
+++ b/tests/test_session_formatting.py
@@ -10,6 +10,10 @@
     build_format_profile,
     date_time_format_profile,
 )
+from common.duration_presentation import (
+    DurationPresentation,
+    duration_format_profile,
+)
 from games.formatting import session_time_range
 from games.models import Game, Purchase, Session
 
@@ -34,8 +38,10 @@ def test_duration_format(self):
         )
         s.save()
         self.assertEqual(
-            s.duration_formatted(),
-            "2.7",
+            DurationPresentation(
+                duration_format_profile("decimal_hours"), "en-us"
+            ).format(s.duration_total),
+            "2.7 h",
         )
 
     def test_session_range_uses_explicit_presentation(self):
diff --git a/tests/test_settings_registry.py b/tests/test_settings_registry.py
index f12ee727..36a8afd8 100644
--- a/tests/test_settings_registry.py
+++ b/tests/test_settings_registry.py
@@ -27,6 +27,7 @@
     "DISPLAY_TIME_ZONE",
     "DATE_FORMAT_LOCALE",
     "DATETIME_FORMAT",
+    "DURATION_FORMAT",
     "SESSION_TIME_ZONE_DISPLAY",
 }
 
diff --git a/tests/test_stats_content_links.py b/tests/test_stats_content_links.py
index d3c140db..96f64d07 100644
--- a/tests/test_stats_content_links.py
+++ b/tests/test_stats_content_links.py
@@ -10,6 +10,10 @@
     DEFAULT_DATE_TIME_FORMAT_PROFILE,
     DateTimePresentation,
 )
+from common.duration_presentation import (
+    DEFAULT_DURATION_FORMAT_PROFILE,
+    DurationPresentation,
+)
 from games.filters import filter_url
 from games.models import Game, Platform, PlayEvent, Purchase, Session
 from games.views import stats_links
@@ -22,8 +26,11 @@
 )
 
 
+_DURATIONS = DurationPresentation(DEFAULT_DURATION_FORMAT_PROFILE, "en-us")
+
+
 def stats_content(ctx):
-    return _stats_content(ctx, _PRESENTATION)
+    return _stats_content(ctx, _PRESENTATION, _DURATIONS)
 
 
 def _dt(month, day, hour=12):
diff --git a/tests/test_time.py b/tests/test_time.py
deleted file mode 100644
index e910d7b3..00000000
--- a/tests/test_time.py
+++ /dev/null
@@ -1,117 +0,0 @@
-import unittest
-from datetime import timedelta
-
-from common.time import format_duration
-
-
-class FormatDurationTest(unittest.TestCase):
-    def setUp(self) -> None:
-        return super().setUp()
-
-    def test_only_days(self):
-        delta = timedelta(days=3)
-        result = format_duration(delta, "%d days")
-        self.assertEqual(result, "3 days")
-
-    def test_only_hours(self):
-        delta = timedelta(hours=1)
-        result = format_duration(delta, "%H hours")
-        self.assertEqual(result, "1 hours")
-
-    def test_only_hours_fractional(self):
-        delta = timedelta(hours=1)
-        result = format_duration(delta, "%.1H hours")
-        self.assertEqual(result, "1.0 hours")
-
-    def test_less_than_hour_with_precision(self):
-        delta = timedelta(hours=0.5)
-        result = format_duration(delta, "%.1H hours")
-        self.assertEqual(result, "0.5 hours")
-
-    def test_less_than_hour_without_precision(self):
-        delta = timedelta(hours=0.5)
-        result = format_duration(delta, "%H hours")
-        self.assertEqual(result, "0 hours")
-
-    def test_overflow_hours(self):
-        delta = timedelta(hours=25)
-        result = format_duration(delta, "%H hours")
-        self.assertEqual(result, "25 hours")
-
-    def test_overflow_hours_into_days(self):
-        delta = timedelta(hours=25)
-        result = format_duration(delta, "%d days, %H hours")
-        self.assertEqual(result, "1 days, 1 hours")
-
-    def test_only_minutes(self):
-        delta = timedelta(minutes=34)
-        result = format_duration(delta, "%m minutes")
-        self.assertEqual(result, "34 minutes")
-
-    def test_only_overflow_minutes(self):
-        delta = timedelta(minutes=61)
-        result = format_duration(delta, "%m minutes")
-        self.assertEqual(result, "61 minutes")
-
-    def test_overflow_minutes_into_hours(self):
-        delta = timedelta(minutes=61)
-        result = format_duration(delta, "%H hours, %m minutes")
-        self.assertEqual(result, "1 hours, 1 minutes")
-
-    def test_only_overflow_seconds(self):
-        delta = timedelta(seconds=61)
-        result = format_duration(delta, "%s seconds")
-        self.assertEqual(result, "61 seconds")
-
-    def test_overflow_seconds_into_minutes(self):
-        delta = timedelta(seconds=61)
-        result = format_duration(delta, "%m minutes, %s seconds")
-        self.assertEqual(result, "1 minutes, 1 seconds")
-
-    def test_only_rawseconds(self):
-        delta = timedelta(seconds=5690)
-        result = format_duration(delta, "%r total seconds")
-        self.assertEqual(result, "5690 total seconds")
-
-    def test_empty(self):
-        delta = timedelta()
-        result = format_duration(delta, "")
-        self.assertEqual(result, "")
-
-    def test_zero(self):
-        delta = timedelta()
-        result = format_duration(delta, "%r seconds")
-        self.assertEqual(result, "0 seconds")
-
-    def test_specific(self):
-        delta = timedelta(hours=2, minutes=40)
-        result = format_duration(delta, "%H:%m")
-        self.assertEqual(result, "2:40")
-
-    def test_specific_precise_if_unncessary(self):
-        delta = timedelta(hours=2, minutes=40)
-        result = format_duration(delta, "%02.0H:%02.0m")
-        self.assertEqual(result, "02:40")
-
-    def test_all_at_once(self):
-        delta = timedelta(days=50, hours=10, minutes=34, seconds=24)
-        result = format_duration(
-            delta, "%d days, %H hours, %m minutes, %s seconds, %r total seconds"
-        )
-        self.assertEqual(
-            result, "50 days, 10 hours, 34 minutes, 24 seconds, 4358064 total seconds"
-        )
-
-    def test_negative(self):
-        delta = timedelta(hours=-2)
-        result = format_duration(delta, "%H hours")
-        self.assertEqual(result, "0 hours")
-
-    def test_none(self):
-        try:
-            format_duration(None)
-        except TypeError as exc:
-            assert False, f"format_duration(None) raised an exception {exc}"
-
-    def test_number(self):
-        self.assertEqual(format_duration(3600, "%H hour"), "1 hour")
diff --git a/timetracker/settings_registry.py b/timetracker/settings_registry.py
index b6120f06..9bcfe5d2 100644
--- a/timetracker/settings_registry.py
+++ b/timetracker/settings_registry.py
@@ -71,6 +71,15 @@
 _DATETIME_FORMAT_VALUES: Final[frozenset[str]] = frozenset(
     value for value, _label in DATETIME_FORMAT_CHOICES
 )
+DURATION_FORMAT_CHOICES: Final[tuple[tuple[str, str], ...]] = (
+    ("decimal_hours", "Decimal hours (1.2 h)"),
+    ("hours_minutes", "Hours and minutes (1 h 12 m)"),
+    ("whole_hours", "Whole hours (1 hour)"),
+    ("adaptive", "Adaptive units (3 d 11 h)"),
+)
+_DURATION_FORMAT_VALUES: Final[frozenset[str]] = frozenset(
+    value for value, _label in DURATION_FORMAT_CHOICES
+)
 DISPLAY_TIME_ZONE_CHOICES: Final[tuple[tuple[str, str], ...]] = tuple(
     (time_zone, time_zone) for time_zone in sorted(available_timezones())
 )
@@ -263,6 +272,16 @@ def _validate_datetime_format(value: object) -> str:
     return normalized
 
 
+def _validate_duration_format(value: object) -> str:
+    normalized = value.strip().lower() if isinstance(value, str) else value
+    if not isinstance(normalized, str) or normalized not in _DURATION_FORMAT_VALUES:
+        choices = ", ".join(sorted(_DURATION_FORMAT_VALUES))
+        raise ValidationError(
+            f"Duration format must be one of {choices} (got {value!r})."
+        )
+    return normalized
+
+
 def _validate_session_time_zone_display(value: object) -> str:
     normalized = value.strip().lower() if isinstance(value, str) else value
     if (
@@ -408,6 +427,21 @@ def _build_registry() -> dict[SettingKey, SettingDefinition]:
             choices=DATETIME_FORMAT_CHOICES,
             reload_after_save=True,
         ),
+        SettingDefinition(
+            "DURATION_FORMAT",
+            scope=SettingScope.USER,
+            apply_timing=ApplyTiming.LIVE,
+            label="Duration format",
+            help_text=(
+                "How elapsed playtime is displayed. Every duration also offers "
+                "the other formats on hover."
+            ),
+            default_factory=lambda: "decimal_hours",
+            validator=_validate_duration_format,
+            widget=SettingWidget.SELECT,
+            choices=DURATION_FORMAT_CHOICES,
+            reload_after_save=True,
+        ),
         SettingDefinition(
             "TZ",
             scope=SettingScope.INFRA,