diff --git a/DOCS-web-control-api.md b/DOCS-web-control-api.md
index 0a69b28..62edc3f 100644
--- a/DOCS-web-control-api.md
+++ b/DOCS-web-control-api.md
@@ -41,7 +41,7 @@ mirror is `web/src/api/contract.ts`; change both together or neither.
| Method | Path | Body / query | Returns |
|---|---|---|---|
| GET | `/api/dataset` | – | `WebDataset` (exists) |
-| GET | `/api/budget` | `?demo=1` | `BudgetSnapshot` (exists) |
+| GET | `/api/budget` | `?demo=1` | `BudgetSnapshot` (exists); from 2026-11-16 `unlimited: true` and every budget/remaining/fraction field is `null` |
| GET | `/api/status` | – | `StatusPayload` (`status_payload()`) |
| GET | `/api/stats` | – | `StatsPayload` (as MCP `get_stats`) |
| GET | `/api/installed` | – | `InstalledPayload` |
diff --git a/pyproject.toml b/pyproject.toml
index a250084..5ede866 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -16,11 +16,11 @@ dependencies = [
"websockets==17.4",
# The earner registry (gaming budget terms); stdlib-only, so the root
# daemon imports it from the desktop user's site-packages.
- "earned-time @ git+https://github.com/kuhyx/utils@earned-time-v0.21.0#subdirectory=earned_time",
+ "earned-time @ git+https://github.com/kuhyx/utils@earned-time-v0.22.0#subdirectory=earned_time",
# The shared /proc game scan and the signed leisure facts (shadow budget,
# contract C4); stdlib-only, imported by root from the user site like
# earned-time.
- "leisure-watch @ git+https://github.com/kuhyx/leisure-watch@leisure-watch-v0.2.7",
+ "leisure-watch @ git+https://github.com/kuhyx/leisure-watch@leisure-watch-v0.2.8",
]
# Optional extras. The `mcp` group is ONLY needed by the MCP server
diff --git a/requirements.txt b/requirements.txt
index 895bf72..c18e455 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -5,9 +5,9 @@ aiohttp==3.14.5
bandit==1.9.4
codespell==2.4.3
coverage==7.17.3
-earned-time @ git+https://github.com/kuhyx/utils@earned-time-v0.21.0#subdirectory=earned_time
+earned-time @ git+https://github.com/kuhyx/utils@earned-time-v0.22.0#subdirectory=earned_time
howlongtobeatpy==1.0.24
-leisure-watch @ git+https://github.com/kuhyx/leisure-watch@leisure-watch-v0.2.7
+leisure-watch @ git+https://github.com/kuhyx/leisure-watch@leisure-watch-v0.2.8
mcp==2.3.0
mypy==2.4.1
pre-commit==4.7.0
diff --git a/steam_backlog_enforcer/_budget_resolve.py b/steam_backlog_enforcer/_budget_resolve.py
index 31e6167..2cb80f0 100644
--- a/steam_backlog_enforcer/_budget_resolve.py
+++ b/steam_backlog_enforcer/_budget_resolve.py
@@ -48,6 +48,7 @@ from typing import TYPE_CHECKING, Final
import earned_time
from steam_backlog_enforcer._gaming_days import gaming_day_key
+from steam_backlog_enforcer._gaming_gate import gaming_enforced_on
from steam_backlog_enforcer._ledger_earners import (
first_credits,
ledger_answer,
@@ -108,6 +109,9 @@ class BudgetResolution:
shadow_seconds: The same answers priced as leisure
(``earned_time.resolve(leisure=True)``, contract C4). Shown, never
enforced.
+ enforced: Whether any budget applies on this gaming day. ``False`` from
+ 2026-11-16 (:mod:`_gaming_gate`): the numbers above are then
+ history, never a limit.
"""
seconds: float
@@ -118,6 +122,7 @@ class BudgetResolution:
reading_seconds: float = 0.0
earned_seconds: dict[str, float] = field(default_factory=dict)
shadow_seconds: float = 0.0
+ enforced: bool = True
def _price(
@@ -180,8 +185,11 @@ def leisure_priced(now: datetime) -> bool:
The same question billing asks (``_leisure_mode.leisure_on`` of the billed
day), so 00:00-05:59 on the go-live date stays pre-leisure, like its bill.
"""
- day = date.fromisoformat(gaming_day_key(now))
- return bool(earned_time.leisure_active(day, LEISURE_FROM_PATH))
+ key = gaming_day_key(now)
+ day = date.fromisoformat(key)
+ return gaming_enforced_on(key) and bool(
+ earned_time.leisure_active(day, LEISURE_FROM_PATH)
+ )
def resolve_budget(config: Config) -> BudgetResolution:
@@ -214,7 +222,11 @@ def resolve_budget(config: Config) -> BudgetResolution:
parts = ", ".join(
_describe(t.earner.name, t.earner.label, t.answer) for t in day.terms
)
+ enforced = gaming_enforced_on(gaming_day_key(now))
reason = f"{total / _SECONDS_PER_HOUR:.1f}h: {parts}"
+ if not enforced:
+ # Priced for history and the shadow only; no number may read as a limit.
+ reason = "unlimited (no gaming budget)"
# The daemon resolves every tick (3 s): an unchanged answer logged each
# time was 25k identical journal lines a day that buried everything else.
if reason != _last_logged.get("reason"):
@@ -229,4 +241,5 @@ def resolve_budget(config: Config) -> BudgetResolution:
reading_seconds=earned.get("reading", 0.0),
earned_seconds=earned,
shadow_seconds=shadow.gaming_minutes * _SECONDS_PER_MINUTE,
+ enforced=enforced,
)
diff --git a/steam_backlog_enforcer/_budget_state_access.py b/steam_backlog_enforcer/_budget_state_access.py
new file mode 100644
index 0000000..ea07d14
--- /dev/null
+++ b/steam_backlog_enforcer/_budget_state_access.py
@@ -0,0 +1,57 @@
+"""Why the budget state file did or did not open, for the budget view.
+
+Split from :mod:`_budget_view` (250-line cap); that module re-exports every name.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Final
+
+if TYPE_CHECKING:
+ from pathlib import Path
+
+READABLE: Final = "ok"
+MISSING: Final = "missing"
+DENIED: Final = "denied"
+CORRUPT: Final = "corrupt"
+
+STATUS_MESSAGES: Final[dict[str, str]] = {
+ DENIED: (
+ "Cannot read the budget state file. It is owned by root, and only "
+ "becomes world-readable once the enforcer has rewritten it — restart "
+ "steam-backlog-enforcer.service."
+ ),
+ MISSING: "No gaming time has been recorded yet today.",
+ CORRUPT: (
+ "The budget state file could not be parsed. The enforcer treats that "
+ "as tampering and will start the day fail-closed."
+ ),
+}
+
+
+def state_access(path: Path) -> str:
+ """Classify why the state file did or did not open.
+
+ ``load_state`` deliberately collapses "missing", "corrupt" and "unreadable"
+ into ``None`` — its caller is the enforcer, whose recovery is the same for
+ all three. A display needs to tell them apart, because "you have not gamed
+ today" and "I am not allowed to look" are opposite messages.
+
+ The read is attempted rather than pre-checked with ``os.access``: the
+ kernel's answer to the actual open is the only one that cannot disagree
+ with what ``load_state`` just experienced. The file is a couple of hundred
+ bytes, so reading it twice costs nothing.
+
+ Args:
+ path: The state file.
+
+ Returns:
+ ``READABLE``, ``MISSING`` or ``DENIED``.
+ """
+ try:
+ path.read_bytes()
+ except FileNotFoundError:
+ return MISSING
+ except OSError:
+ return DENIED
+ return READABLE
diff --git a/steam_backlog_enforcer/_budget_view.py b/steam_backlog_enforcer/_budget_view.py
index fb1bdaa..5eee58f 100644
--- a/steam_backlog_enforcer/_budget_view.py
+++ b/steam_backlog_enforcer/_budget_view.py
@@ -21,6 +21,14 @@ from steam_backlog_enforcer._budget_games import (
today_games,
)
from steam_backlog_enforcer._budget_log_tail import last_verdict
+from steam_backlog_enforcer._budget_state_access import (
+ CORRUPT,
+ DENIED,
+ MISSING,
+ READABLE,
+ STATUS_MESSAGES,
+ state_access,
+)
from steam_backlog_enforcer._ledger_earners import registry_for
from steam_backlog_enforcer._playtime_block import mounted_targets
from steam_backlog_enforcer._playtime_history import load_history
@@ -33,59 +41,24 @@ from steam_backlog_enforcer._shadow_view import shadow_view
from steam_backlog_enforcer.config import Config, State
if TYPE_CHECKING:
- from pathlib import Path
-
import earned_time
from steam_backlog_enforcer._playtime_state import PlaytimeRules, PlaytimeState
-READABLE: Final = "ok"
-MISSING: Final = "missing"
-DENIED: Final = "denied"
-CORRUPT: Final = "corrupt"
-
-_STATUS_MESSAGES: Final[dict[str, str]] = {
- DENIED: (
- "Cannot read the budget state file. It is owned by root, and only "
- "becomes world-readable once the enforcer has rewritten it — restart "
- "steam-backlog-enforcer.service."
- ),
- MISSING: "No gaming time has been recorded yet today.",
- CORRUPT: (
- "The budget state file could not be parsed. The enforcer treats that "
- "as tampering and will start the day fail-closed."
- ),
-}
-
_HISTORY_DAYS: Final = 14
-
-def state_access(path: Path) -> str:
- """Classify why the state file did or did not open.
-
- ``load_state`` deliberately collapses "missing", "corrupt" and "unreadable"
- into ``None`` — its caller is the enforcer, whose recovery is the same for
- all three. A display needs to tell them apart, because "you have not gamed
- today" and "I am not allowed to look" are opposite messages.
-
- The read is attempted rather than pre-checked with ``os.access``: the
- kernel's answer to the actual open is the only one that cannot disagree
- with what ``load_state`` just experienced. The file is a couple of hundred
- bytes, so reading it twice costs nothing.
-
- Args:
- path: The state file.
-
- Returns:
- ``READABLE``, ``MISSING`` or ``DENIED``.
- """
- try:
- path.read_bytes()
- except FileNotFoundError:
- return MISSING
- except OSError:
- return DENIED
- return READABLE
+# Re-exported: the status classifier moved to _budget_state_access (250-line cap).
+__all__ = [
+ "CORRUPT",
+ "DENIED",
+ "MISSING",
+ "READABLE",
+ "build_budget_snapshot",
+ "build_rules",
+ "build_today",
+ "next_warning",
+ "state_access",
+]
def next_warning(state: PlaytimeState, rules: PlaytimeRules) -> int | None:
@@ -125,19 +98,25 @@ def build_today(state: PlaytimeState, rules: PlaytimeRules) -> dict[str, Any]:
"""
remaining = max(0.0, rules.budget_seconds - state.seconds)
fraction = state.seconds / rules.budget_seconds if rules.budget_seconds else 1.0
+ unlimited = not rules.gaming_enforced
return {
"gaming_day": state.day_key,
"day_starts_at": "06:00 local",
"seconds_used": round(state.seconds, 1),
- "budget_seconds": rules.budget_seconds,
- "seconds_remaining": round(remaining, 1),
- "fraction_used": round(min(1.0, max(0.0, fraction)), 4),
- "blocked": state.is_blocked(),
- "blocked_at": state.blocked_at,
- "next_warning_seconds": next_warning(state, rules),
- "warned_seconds": list(state.warned_seconds),
+ # No budget since 2026-11-16: the day is "unlimited" and carries no
+ # number a reader could take for a limit. Past days keep their history.
+ "unlimited": unlimited,
+ "budget_seconds": None if unlimited else rules.budget_seconds,
+ "seconds_remaining": None if unlimited else round(remaining, 1),
+ "fraction_used": (
+ None if unlimited else round(min(1.0, max(0.0, fraction)), 4)
+ ),
+ "blocked": False if unlimited else state.is_blocked(),
+ "blocked_at": 0.0 if unlimited else state.blocked_at,
+ "next_warning_seconds": None if unlimited else next_warning(state, rules),
+ "warned_seconds": [] if unlimited else list(state.warned_seconds),
"games": today_games(state),
- "shadow": shadow_view(state),
+ "shadow": shadow_view(state, unlimited=unlimited),
}
@@ -158,11 +137,13 @@ def build_rules(rules: PlaytimeRules) -> dict[str, Any]:
Returns:
Serialisable rules block.
"""
+ unlimited = not rules.gaming_enforced
return {
- "budget_seconds": rules.budget_seconds,
+ "unlimited": unlimited,
+ "budget_seconds": None if unlimited else rules.budget_seconds,
"enforcement": rules.enforcement,
"counts_launchers": rules.count_launchers,
- "warn_at": list(rules.warn_at),
+ "warn_at": [] if unlimited else list(rules.warn_at),
"demo": rules.demo,
"masked_launchers": sorted(str(path) for path in mounted_targets()),
# Read off the rules, never re-resolved: resolving a second time here
@@ -188,6 +169,8 @@ def build_rules(rules: PlaytimeRules) -> dict[str, Any]:
"bonus_seconds": _most(earner) * 60,
}
for earner in registry_for(datetime.now().astimezone().date())
+ # An earner's gaming pay is a budget term: none when unlimited.
+ if not unlimited
],
}
@@ -221,7 +204,7 @@ def build_budget_snapshot(*, demo: bool = False) -> dict[str, Any]:
"ok": True,
"readable": status == READABLE,
"state_status": status,
- "error": _STATUS_MESSAGES.get(status),
+ "error": STATUS_MESSAGES.get(status),
"today": build_today(stored, rules) if stored is not None else None,
"session": {
# What the budget is actually charging — a different question from
diff --git a/steam_backlog_enforcer/_cmd_playtime.py b/steam_backlog_enforcer/_cmd_playtime.py
index 97494ac..cb745af 100644
--- a/steam_backlog_enforcer/_cmd_playtime.py
+++ b/steam_backlog_enforcer/_cmd_playtime.py
@@ -74,15 +74,19 @@ def cmd_gaming_status(config: Config, _state: State) -> None:
continue
_echo(f"{'Demo' if demo else 'Gaming'} budget:")
_echo(f" state file: {state_path(demo=demo)}")
- _echo(f" budget_seconds: {rules.budget_seconds:.0f}")
+ if rules.gaming_enforced:
+ _echo(f" budget_seconds: {rules.budget_seconds:.0f}")
+ else:
+ _echo(" unlimited: no gaming budget (until shutdown)")
if stored is None:
_echo(" (no state recorded yet)")
else:
- remaining = max(0.0, rules.budget_seconds - stored.seconds)
_echo(f" gaming day: {stored.day_key} (starts 06:00 local)")
_echo(f" used: {stored.seconds:.0f}s")
- _echo(f" remaining: {remaining:.0f}s")
- _echo(f" blocked: {stored.is_blocked()}")
+ if rules.gaming_enforced:
+ remaining = max(0.0, rules.budget_seconds - stored.seconds)
+ _echo(f" remaining: {remaining:.0f}s")
+ _echo(f" blocked: {stored.is_blocked()}")
masked = mounted_targets()
_echo(f"Masked launchers: {len(masked)}/{len(block_targets())}")
diff --git a/steam_backlog_enforcer/_gaming_gate.py b/steam_backlog_enforcer/_gaming_gate.py
new file mode 100644
index 0000000..17701ac
--- /dev/null
+++ b/steam_backlog_enforcer/_gaming_gate.py
@@ -0,0 +1,59 @@
+"""The one switch that says whether a gaming budget exists on a gaming day.
+
+kuhy removed the daily gaming (and leisure) budget on 2026-11-16: from then on
+games may run until shutdown, and shutdown time (screen-locker) is the only
+carrot. ``earned_time.gaming_enforced`` owns the date; every place that
+*applies* a budget (kill, block, warning, leisure kill, leisure billing) asks
+this wrapper, and every place that *reports* one prints "unlimited" instead of
+a number. Numbers stay resolvable for history and the shadow view.
+
+**Fail open, loudly.** If the switch cannot be read (an old ``earned_time``
+without the function, a day key that is no date) the answer is "unlimited", not
+"enforce whatever the registry falls back to": from the switch the fallback is
+the 5 h base, a *lower* budget than kuhy lived under, and a crash here would
+take the root daemon down. The failure is logged at ERROR, once per distinct
+cause, because this runs every 3 s tick.
+"""
+
+from __future__ import annotations
+
+from datetime import date
+import logging
+from typing import Final
+
+import earned_time
+
+logger = logging.getLogger(__name__)
+
+# Failures already logged, so a permanent fault is one journal line, not 28k a day.
+_logged: Final[set[str]] = set()
+
+
+def reset_logged() -> None:
+ """Forget the failures already logged (tests, and a daemon reload)."""
+ _logged.clear()
+
+
+def gaming_enforced_on(day_key: str) -> bool:
+ """Whether a gaming budget is enforced on the gaming day *day_key*.
+
+ Args:
+ day_key: The 06:00-shifted gaming day, ``YYYY-MM-DD``.
+
+ Returns:
+ ``False`` from ``earned_time.GAMING_UNLIMITED_FROM`` (no budget), and
+ ``False`` when the switch cannot be read (fail open, logged).
+ """
+ try:
+ return bool(earned_time.gaming_enforced(date.fromisoformat(day_key)))
+ except (AttributeError, TypeError, ValueError) as exc:
+ cause = f"{type(exc).__name__}: {exc}"
+ if cause not in _logged:
+ _logged.add(cause)
+ logger.exception(
+ "Cannot read the gaming-budget switch for %r (%s); treating the "
+ "day as unlimited so no lower budget is enforced.",
+ day_key,
+ cause,
+ )
+ return False
diff --git a/steam_backlog_enforcer/_leisure_kill.py b/steam_backlog_enforcer/_leisure_kill.py
index f5ec673..5fe221a 100644
--- a/steam_backlog_enforcer/_leisure_kill.py
+++ b/steam_backlog_enforcer/_leisure_kill.py
@@ -22,8 +22,7 @@ over; a reason carrying the start time it saw (leisure-watch 0.2.1 ``start``)
names only that process, never a later one reusing the pid. Root/system
processes, lockers and the enforcer itself are never signalled, nor --
whatever ``now.json`` says -- the desktop session (:mod:`_leisure_never_kill`;
-each refusal logged once). Every SIGTERM and the first SIGKILL go to
-``budget.jsonl``.
+each refusal logged once). Every SIGTERM and the first SIGKILL go to ``budget.jsonl``.
"""
from __future__ import annotations
@@ -154,7 +153,8 @@ class LeisureKiller:
verdict: ShadowVerdict,
stamp: float,
) -> None:
- if not rules.leisure or rules.demo or not rules.enforcement:
+ armed = rules.leisure and rules.enforcement and rules.gaming_enforced
+ if rules.demo or not armed:
return
untrusted_for = self._untrusted_for(verdict, stamp)
if state.seconds < rules.budget_seconds:
diff --git a/steam_backlog_enforcer/_leisure_mode.py b/steam_backlog_enforcer/_leisure_mode.py
index 465580a..827a978 100644
--- a/steam_backlog_enforcer/_leisure_mode.py
+++ b/steam_backlog_enforcer/_leisure_mode.py
@@ -20,6 +20,7 @@ from typing import TYPE_CHECKING, Final
import earned_time
from leisure_watch.procscan import attributed_key
+from steam_backlog_enforcer._gaming_gate import gaming_enforced_on
from steam_backlog_enforcer._playtime_budget import accumulate, bill
if TYPE_CHECKING:
@@ -45,6 +46,9 @@ def leisure_on(day_key: str) -> bool:
day = date.fromisoformat(day_key)
except ValueError:
return False
+ # No gaming budget (2026-11-16) means no leisure budget either.
+ if not gaming_enforced_on(day_key):
+ return False
return bool(earned_time.leisure_active(day, LEISURE_FROM_PATH))
diff --git a/steam_backlog_enforcer/_mcp_gaming_time.py b/steam_backlog_enforcer/_mcp_gaming_time.py
index d59f60c..dfd701c 100644
--- a/steam_backlog_enforcer/_mcp_gaming_time.py
+++ b/steam_backlog_enforcer/_mcp_gaming_time.py
@@ -42,6 +42,7 @@ def get_gaming_time() -> dict[str, Any]:
"ok": True,
"recorded": False,
"state_status": snapshot["state_status"],
+ "unlimited": rules["unlimited"],
"budget_seconds": rules["budget_seconds"],
"enforcement": rules["enforcement"],
"masked_launchers": masked,
@@ -54,6 +55,8 @@ def get_gaming_time() -> dict[str, Any]:
"gaming_day": today["gaming_day"],
"day_starts_at": today["day_starts_at"],
"seconds_used": today["seconds_used"],
+ # True from 2026-11-16: no budget, so no number below.
+ "unlimited": today["unlimited"],
"budget_seconds": today["budget_seconds"],
"seconds_remaining": today["seconds_remaining"],
# What earned budget_seconds.
diff --git a/steam_backlog_enforcer/_playtime.py b/steam_backlog_enforcer/_playtime.py
index dcdc6fb..f0718cd 100644
--- a/steam_backlog_enforcer/_playtime.py
+++ b/steam_backlog_enforcer/_playtime.py
@@ -221,6 +221,11 @@ def _policy(
Returns:
The updated state.
"""
+ if not rules.gaming_enforced:
+ # No gaming budget (2026-11-16): lift any block; time is still billed.
+ reconcile_for(rules, should_block=False)
+ return replace(state, blocked_at=0.0, warned_seconds=[])
+
if not rules.enforcement:
# A kill switch must still release: leaving live mounts behind would
# make "disabled" mean "permanently blocked".
diff --git a/steam_backlog_enforcer/_playtime_log.py b/steam_backlog_enforcer/_playtime_log.py
index fcb6018..8f16c22 100644
--- a/steam_backlog_enforcer/_playtime_log.py
+++ b/steam_backlog_enforcer/_playtime_log.py
@@ -223,6 +223,7 @@ def _snapshot(
"qualifying": sorted(qualifying),
"day_key": state.day_key,
"billed_seconds": round(state.seconds, 3),
+ "gaming_enforced": rules.gaming_enforced,
"budget_seconds": round(rules.budget_seconds, 3),
"remaining_seconds": round(rules.budget_seconds - state.seconds, 3),
}
diff --git a/steam_backlog_enforcer/_playtime_state.py b/steam_backlog_enforcer/_playtime_state.py
index babe475..636eb82 100644
--- a/steam_backlog_enforcer/_playtime_state.py
+++ b/steam_backlog_enforcer/_playtime_state.py
@@ -101,6 +101,9 @@ class PlaytimeRules:
# Phase 2: the billed gaming day is on the leisure budget (set per tick by
# _leisure_mode.leisure_billed, never by rules_for). Only wording and kills.
leisure: bool = False
+ # False from 2026-11-16 (_gaming_gate): no budget is enforced -- no kill, no
+ # block, no warning. budget_seconds is then history, not a limit.
+ gaming_enforced: bool = True
def rules_for(config: Config, *, demo: bool) -> PlaytimeRules:
@@ -126,6 +129,7 @@ def rules_for(config: Config, *, demo: bool) -> PlaytimeRules:
live = 0.0 if resolved is None else resolved.seconds
held = held_today(stored, now)
held_note = f"; held at {held / 3600:.1f}h (earned earlier today)"
+ enforced = resolved is None or resolved.enforced
return PlaytimeRules(
budget_seconds=_DEMO_BUDGET_SECONDS if resolved is None else max(live, held),
warn_at=_DEMO_WARN_AT if demo else _WARN_AT,
@@ -133,7 +137,8 @@ def rules_for(config: Config, *, demo: bool) -> PlaytimeRules:
count_launchers=config.playtime.count_launcher_processes,
enforcement=config.playtime.playtime_enforcement,
demo=demo,
- breakdown=_breakdown(resolved, held_note if held > live else ""),
+ gaming_enforced=enforced,
+ breakdown=_breakdown(resolved, held_note if enforced and held > live else ""),
shadow_budget_seconds=0.0
if resolved is None
else max(resolved.shadow_seconds, held_shadow_today(stored, now)),
diff --git a/steam_backlog_enforcer/_shadow_view.py b/steam_backlog_enforcer/_shadow_view.py
index 0004b14..6a6da4a 100644
--- a/steam_backlog_enforcer/_shadow_view.py
+++ b/steam_backlog_enforcer/_shadow_view.py
@@ -12,11 +12,12 @@ if TYPE_CHECKING:
from steam_backlog_enforcer._playtime_state import PlaytimeState
-def shadow_view(state: PlaytimeState) -> dict[str, Any]:
+def shadow_view(state: PlaytimeState, *, unlimited: bool = False) -> dict[str, Any]:
"""Compose the shadow block from stored state.
Args:
state: Loaded accounting state.
+ unlimited: No budget applies (2026-11-16): report no budget number.
Returns:
Used/budget/remaining seconds, whether the leisure budget would block
@@ -25,9 +26,9 @@ def shadow_view(state: PlaytimeState) -> dict[str, Any]:
remaining = max(0.0, state.shadow.budget_seconds - state.shadow.seconds)
return {
"seconds_used": round(state.shadow.seconds, 1),
- "budget_seconds": state.shadow.budget_seconds,
- "seconds_remaining": round(remaining, 1),
- "would_block": remaining <= 0.0,
+ "budget_seconds": None if unlimited else state.shadow.budget_seconds,
+ "seconds_remaining": None if unlimited else round(remaining, 1),
+ "would_block": False if unlimited else remaining <= 0.0,
"paused_seconds": round(state.shadow.paused_seconds, 1),
"per_source": {k: round(v, 1) for k, v in state.shadow.per_source.items()},
}
diff --git a/steam_backlog_enforcer/tests/test_budget_view.py b/steam_backlog_enforcer/tests/test_budget_view.py
index 7971f15..4d5daab 100644
--- a/steam_backlog_enforcer/tests/test_budget_view.py
+++ b/steam_backlog_enforcer/tests/test_budget_view.py
@@ -27,8 +27,7 @@ from steam_backlog_enforcer.tests._no_workout_http import earned_budget, fixed_b
# Built at import time, so the autouse _no_workout_http fixture is not in
# effect yet -- without this patch, collecting this module makes a real HTTP
-# call to the screen locker and pins RULES to whatever budget today happens to
-# have earned. Stub it explicitly so the constant is the earned budget always.
+# call to the screen locker and pins RULES to today's earned budget. Stub it.
# The held budget is pinned for the same reason: conftest's redirects are not
# active at import either, so rules_for would read the LIVE playtime_state.json
# and hold RULES at whatever high-water mark it records today. Nor would the
@@ -238,6 +237,7 @@ class TestBuildBudgetSnapshot:
snapshot = self._snapshot()
assert "SEKRET" not in json.dumps(snapshot)
assert set(snapshot["rules"]) == {
+ "unlimited",
"budget_seconds",
"enforcement",
"counts_launchers",
diff --git a/steam_backlog_enforcer/tests/test_gaming_unlimited.py b/steam_backlog_enforcer/tests/test_gaming_unlimited.py
new file mode 100644
index 0000000..235fdad
--- /dev/null
+++ b/steam_backlog_enforcer/tests/test_gaming_unlimited.py
@@ -0,0 +1,237 @@
+"""From 2026-11-16 the gaming budget is gone: no kill, no block, no warning.
+
+Each test pairs the new behaviour (a day on or after the switch) with the old
+one (the day before it), so the gate is proven in both directions.
+"""
+
+from __future__ import annotations
+
+from contextlib import ExitStack
+from dataclasses import replace
+from datetime import date, datetime, timedelta, timezone
+import logging
+from typing import TYPE_CHECKING
+from unittest.mock import DEFAULT, patch
+
+from leisure_watch.facts import Reason
+import pytest
+
+from steam_backlog_enforcer import _gaming_gate
+from steam_backlog_enforcer._budget_resolve import BudgetResolution, resolve_budget
+from steam_backlog_enforcer._gaming_gate import gaming_enforced_on
+from steam_backlog_enforcer._leisure_kill import LeisureKiller
+from steam_backlog_enforcer._leisure_mode import leisure_on
+from steam_backlog_enforcer._playtime import playtime_tick
+from steam_backlog_enforcer._playtime_state import (
+ PlaytimeState,
+ load_state,
+ rules_for,
+ save_state,
+)
+from steam_backlog_enforcer.config import Config
+from steam_backlog_enforcer.tests._budget_dates import pin_today
+from steam_backlog_enforcer.tests._budget_earners import (
+ LEETCODE,
+ READING,
+ WORKOUT,
+)
+from steam_backlog_enforcer.tests._fake_session import fake_session
+from steam_backlog_enforcer.tests._leisure_kill_world import (
+ RULES as LEISURE_RULES,
+)
+from steam_backlog_enforcer.tests._leisure_kill_world import (
+ SPENT,
+ StubLog,
+ build_proc,
+ now_with,
+ verdict_of,
+)
+
+if TYPE_CHECKING:
+ from collections.abc import Iterator
+ from pathlib import Path
+ from unittest.mock import MagicMock
+
+PKG = "steam_backlog_enforcer._playtime"
+_RESOLVER = "steam_backlog_enforcer._playtime_state.resolve_budget"
+LOCAL = timezone(timedelta(hours=2))
+LAST_DAY = datetime(2026, 11, 15, 20, 0, tzinfo=LOCAL)
+FIRST_DAY = datetime(2026, 11, 17, 20, 0, tzinfo=LOCAL)
+_THREE_HOURS = 3 * 3600.0
+
+
+@pytest.fixture(autouse=True)
+def _fresh_gate() -> Iterator[None]:
+ """Forget which failures were logged, so each test sees its own."""
+ _gaming_gate.reset_logged()
+ yield
+ _gaming_gate.reset_logged()
+
+
+@pytest.fixture(name="effects")
+def fixture_effects() -> Iterator[dict[str, MagicMock]]:
+ """Neutralise and expose every side effect a cutoff can have."""
+ with ExitStack() as stack:
+ mocks: dict[str, MagicMock] = stack.enter_context(
+ patch.multiple(
+ "steam_backlog_enforcer._playtime_cutoff",
+ reconcile=DEFAULT,
+ request_steam_shutdown=DEFAULT,
+ kill_gaming_processes=DEFAULT,
+ notify_desktop_user=DEFAULT,
+ )
+ )
+ stack.enter_context(patch(f"{PKG}.mounted_targets", return_value=set()))
+ stack.enter_context(patch(f"{PKG}.is_total_block_active", return_value=False))
+ stack.enter_context(patch(f"{PKG}.qualifying_pids", return_value={7: "app:1"}))
+ yield mocks
+
+
+def _real_resolver(*, workout: bool = False) -> ExitStack:
+ """Patch ``rules_for`` to use the real ``resolve_budget``, earners fixed."""
+ stack = ExitStack()
+ stack.enter_context(patch(_RESOLVER, side_effect=resolve_budget))
+ stack.enter_context(patch(WORKOUT, return_value=workout))
+ stack.enter_context(patch(LEETCODE, return_value=False))
+ stack.enter_context(patch(READING, return_value=False))
+ return stack
+
+
+def _tick(now: datetime, key: str) -> PlaytimeState:
+ """Run one real-resolver tick at *now* with a day already past any budget."""
+ save_state(
+ PlaytimeState(
+ day_key=key,
+ seconds=12 * 3600.0,
+ blocked_at=now.timestamp() - 60,
+ warned_seconds=[3600],
+ last_tick_at=now.timestamp() - 3.0,
+ ),
+ demo=False,
+ )
+ with (
+ _real_resolver(),
+ pin_today(now.date()),
+ patch(f"{PKG}.datetime") as clock,
+ patch("steam_backlog_enforcer._playtime_state.datetime") as state_clock,
+ ):
+ clock.now.return_value = now
+ state_clock.now.return_value.astimezone.return_value = now
+ playtime_tick(Config(), interval=3.0, session=fake_session())
+ stored = load_state(demo=False)
+ assert stored is not None
+ return stored
+
+
+class TestGate:
+ """``gaming_enforced_on``: the date switch, failing open and loud."""
+
+ def test_enforced_the_day_before(self) -> None:
+ """2026-11-15 still has its budget."""
+ assert gaming_enforced_on("2026-11-15") is True
+
+ @pytest.mark.parametrize("day", ["2026-11-16", "2026-11-17", "2027-03-01"])
+ def test_unlimited_from_the_switch(self, day: str) -> None:
+ """The switch day and every later one have no budget."""
+ assert gaming_enforced_on(day) is False
+
+ @pytest.mark.parametrize("failure", [AttributeError("old lib"), ValueError("x")])
+ def test_failure_is_unlimited_and_logged_once(
+ self, failure: Exception, caplog: pytest.LogCaptureFixture
+ ) -> None:
+ """An unreadable switch never re-imposes a budget; it logs, once."""
+ with (
+ patch("earned_time.gaming_enforced", side_effect=failure),
+ caplog.at_level(logging.ERROR),
+ ):
+ assert gaming_enforced_on("2026-11-20") is False
+ assert gaming_enforced_on("2026-11-20") is False
+ assert [r.levelno for r in caplog.records] == [logging.ERROR]
+
+ def test_a_key_that_is_no_date_is_unlimited_and_logged(
+ self, caplog: pytest.LogCaptureFixture
+ ) -> None:
+ """A garbled day key cannot price a budget; it fails open, loudly."""
+ with caplog.at_level(logging.ERROR):
+ assert gaming_enforced_on("not-a-day") is False
+ assert "not-a-day" in caplog.text
+
+
+class TestResolve:
+ """``resolve_budget`` marks the day unlimited from the switch."""
+
+ def test_unlimited_day_has_no_budget_to_enforce(self) -> None:
+ """On 2026-11-17 the resolution says unlimited, whatever the registry."""
+ with _real_resolver(), pin_today(date(2026, 11, 17)):
+ resolved = resolve_budget(Config())
+ assert resolved.enforced is False
+ assert "unlimited" in resolved.reason
+
+ def test_the_day_before_is_unchanged(self) -> None:
+ """On 2026-11-15 the budget is still a number to enforce."""
+ with _real_resolver(), pin_today(date(2026, 11, 15)):
+ resolved = resolve_budget(Config())
+ assert resolved.enforced is True
+ assert resolved.seconds > 0
+ assert "unlimited" not in resolved.reason
+
+ def test_rules_carry_the_flag(self) -> None:
+ """``rules_for`` hands the gate to every consumer; a demo is always on."""
+ off = BudgetResolution(0.0, 0.0, 0.0, 0.0, "unlimited", enforced=False)
+ with patch(_RESOLVER, return_value=off):
+ assert rules_for(Config(), demo=False).gaming_enforced is False
+ assert rules_for(Config(), demo=True).gaming_enforced is True
+
+
+class TestTick:
+ """The enforce tick: zero credits, budget long spent."""
+
+ def test_unlimited_day_never_kills_and_lifts_the_block(
+ self, effects: dict[str, MagicMock]
+ ) -> None:
+ """2026-11-17, 12 h billed, nothing earned: no kill, mounts off."""
+ stored = _tick(FIRST_DAY, "2026-11-17")
+ effects["kill_gaming_processes"].assert_not_called()
+ effects["request_steam_shutdown"].assert_not_called()
+ effects["notify_desktop_user"].assert_not_called()
+ assert not stored.is_blocked()
+ assert stored.warned_seconds == []
+ effects["reconcile"].assert_called_with(should_block=False)
+
+ def test_the_day_before_still_cuts_off(self, effects: dict[str, MagicMock]) -> None:
+ """2026-11-15, same state: the old cutoff holds."""
+ stored = _tick(LAST_DAY, "2026-11-15")
+ effects["kill_gaming_processes"].assert_called()
+ effects["request_steam_shutdown"].assert_not_called()
+ assert stored.is_blocked()
+
+ def test_time_is_still_billed_for_history(
+ self, effects: dict[str, MagicMock]
+ ) -> None:
+ """No budget does not stop the day's history from counting."""
+ stored = _tick(FIRST_DAY, "2026-11-17")
+ assert stored.seconds == pytest.approx(12 * 3600.0 + 3.0)
+ del effects
+
+
+class TestLeisure:
+ """Leisure is a budget too: off from the switch."""
+
+ def test_leisure_never_on_from_the_switch(self) -> None:
+ """Even a live switch file cannot bill leisure on an unlimited day."""
+ with patch("earned_time.leisure_active", return_value=True):
+ assert leisure_on("2026-11-15") is True
+ assert leisure_on("2026-11-16") is False
+
+ @pytest.mark.parametrize(("enforced", "kills"), [(True, 1), (False, 0)])
+ def test_leisure_kill_stands_down(
+ self, tmp_path: Path, *, enforced: bool, kills: int
+ ) -> None:
+ """A spent leisure budget kills mpv only while gaming is enforced."""
+ build_proc(tmp_path)
+ killer = LeisureKiller(StubLog())
+ verdict = verdict_of(now_with(Reason("media", "app:mpv", 10, "mpv")))
+ rules = replace(LEISURE_RULES, gaming_enforced=enforced)
+ with patch("os.kill") as kill:
+ killer.enforce(SPENT, rules, verdict=verdict, stamp=1000.0)
+ assert kill.call_count == kills
diff --git a/steam_backlog_enforcer/tests/test_gaming_unlimited_views.py b/steam_backlog_enforcer/tests/test_gaming_unlimited_views.py
new file mode 100644
index 0000000..c5ba4d4
--- /dev/null
+++ b/steam_backlog_enforcer/tests/test_gaming_unlimited_views.py
@@ -0,0 +1,111 @@
+"""MCP, CLI and web report "unlimited" with no number once the budget is gone."""
+
+from __future__ import annotations
+
+from typing import Any
+from unittest.mock import patch
+
+import pytest
+
+from steam_backlog_enforcer import _budget_view as view
+from steam_backlog_enforcer import _mcp_gaming_time as mcp_gaming_time
+from steam_backlog_enforcer._budget_resolve import BudgetResolution
+from steam_backlog_enforcer._cmd_playtime import cmd_gaming_status
+from steam_backlog_enforcer._playtime_state import PlaytimeState
+from steam_backlog_enforcer.config import Config, State
+from steam_backlog_enforcer.tests._cmd_playtime_patches import cli_as, echoed
+
+_RESOLVER = "steam_backlog_enforcer._playtime_state.resolve_budget"
+_STORED = PlaytimeState(day_key="2026-11-17", seconds=40_000.0, budget_seconds=18_000.0)
+
+
+def _resolution(*, enforced: bool) -> BudgetResolution:
+ """A resolution that would be a 5 h budget if it were enforced."""
+ return BudgetResolution(
+ seconds=18_000.0,
+ base_seconds=18_000.0,
+ workout_seconds=0.0,
+ leetcode_seconds=0.0,
+ reason="5.0h: base" if enforced else "unlimited",
+ enforced=enforced,
+ )
+
+
+def _snapshot(*, enforced: bool) -> dict[str, Any]:
+ with (
+ patch(_RESOLVER, return_value=_resolution(enforced=enforced)),
+ patch.object(view, "load_state", return_value=_STORED),
+ patch.object(view, "mounted_targets", return_value=set()),
+ ):
+ return view.build_budget_snapshot()
+
+
+class TestWebView:
+ """``/api/budget`` payload."""
+
+ def test_unlimited_has_no_number(self) -> None:
+ """No budget, remaining, fraction or warning; the flag says why."""
+ snap = _snapshot(enforced=False)
+ today, rules = snap["today"], snap["rules"]
+ assert today["unlimited"] is True
+ assert rules["unlimited"] is True
+ for field in ("budget_seconds", "seconds_remaining", "fraction_used"):
+ assert today[field] is None
+ assert today["next_warning_seconds"] is None
+ assert today["shadow"]["budget_seconds"] is None
+ assert rules["budget_seconds"] is None
+ assert rules["warn_at"] == []
+ assert rules["earners"] == []
+ assert today["seconds_used"] == 40_000.0
+
+ def test_enforced_day_keeps_its_numbers(self) -> None:
+ """Before the switch the payload is what it always was."""
+ snap = _snapshot(enforced=True)
+ today = snap["today"]
+ assert today["unlimited"] is False
+ assert snap["rules"]["unlimited"] is False
+ assert today["budget_seconds"] == 18_000.0
+ assert today["seconds_remaining"] == 0.0
+ assert today["fraction_used"] == 1.0
+
+
+class TestMcp:
+ """``get_gaming_time`` tool."""
+
+ @pytest.mark.parametrize("recorded", [True, False])
+ def test_unlimited(self, *, recorded: bool) -> None:
+ """Recorded or not, the reply says unlimited and carries no budget."""
+ stored = _STORED if recorded else None
+ with (
+ patch(_RESOLVER, return_value=_resolution(enforced=False)),
+ patch.object(view, "load_state", return_value=stored),
+ patch.object(view, "mounted_targets", return_value=set()),
+ ):
+ out = mcp_gaming_time.get_gaming_time()
+ assert out["unlimited"] is True
+ assert out["budget_seconds"] is None
+ assert out.get("seconds_remaining") is None
+
+
+class TestCli:
+ """``gaming-status``."""
+
+ def test_unlimited_prints_no_budget_number(self) -> None:
+ """The status says unlimited, not a remaining count."""
+ with (
+ patch(_RESOLVER, return_value=_resolution(enforced=False)),
+ patch(
+ "steam_backlog_enforcer._cmd_playtime.load_state",
+ side_effect=lambda demo: None if demo else _STORED,
+ ),
+ patch(
+ "steam_backlog_enforcer._cmd_playtime.mounted_targets",
+ return_value=set(),
+ ),
+ cli_as(None) as cli,
+ ):
+ cmd_gaming_status(Config(), State())
+ text = echoed(cli.echo)
+ assert "unlimited" in text
+ assert "budget_seconds" not in text
+ assert "remaining" not in text
diff --git a/web/mock/budget.ts b/web/mock/budget.ts
index 4456715..0ec414c 100644
--- a/web/mock/budget.ts
+++ b/web/mock/budget.ts
@@ -23,8 +23,10 @@ export function budget(demo: boolean): BudgetSnapshot {
const budgetSeconds = demo ? 60 : 3 * 3600
const base = demo ? 20 : 2 * 3600 + 10 * 60
const since = resetAt ?? started
- const used = Math.min(budgetSeconds, (resetAt === null ? base : 0) + Math.floor((Date.now() - since) / 1000))
- const remaining = budgetSeconds - used
+ // From 2026-11-16 the real backend has no budget (unlimited); the demo run still does.
+ const unlimited = !demo
+ const used = Math.min(unlimited ? Infinity : budgetSeconds, (resetAt === null ? base : 0) + Math.floor((Date.now() - since) / 1000))
+ const remaining = unlimited ? null : budgetSeconds - used
const today = new Date()
const history = Array.from({ length: 14 }, (_, i) => {
const d = new Date(today.getTime() - (13 - i) * 86_400_000)
@@ -49,19 +51,20 @@ export function budget(demo: boolean): BudgetSnapshot {
gaming_day: today.toISOString().slice(0, 10),
day_starts_at: '06:00 local',
seconds_used: used,
- budget_seconds: budgetSeconds,
+ unlimited,
+ budget_seconds: unlimited ? null : budgetSeconds,
seconds_remaining: remaining,
- fraction_used: used / budgetSeconds,
- blocked: remaining <= 0,
- blocked_at: remaining <= 0 ? Math.floor(Date.now() / 1000) : 0,
- next_warning_seconds: remaining > 1800 ? 1800 : remaining > 600 ? 600 : null,
- warned_seconds: remaining <= 3600 ? [3600] : [],
+ fraction_used: unlimited ? null : used / budgetSeconds,
+ blocked: remaining !== null && remaining <= 0,
+ blocked_at: remaining !== null && remaining <= 0 ? Math.floor(Date.now() / 1000) : 0,
+ next_warning_seconds: remaining === null ? null : remaining > 1800 ? 1800 : remaining > 600 ? 600 : null,
+ warned_seconds: remaining !== null && remaining <= 3600 ? [3600] : [],
games: used > 0 ? slices : [],
},
session: {
available: true,
observed_at: new Date().toISOString(),
- state: remaining > 0 ? 'engaged' : 'blocked',
+ state: remaining === null || remaining > 0 ? 'engaged' : 'blocked',
game_name: 'Hades',
billing_label: 'Hades',
qualifying_count: 2,
@@ -73,10 +76,11 @@ export function budget(demo: boolean): BudgetSnapshot {
history,
legend: LEGEND,
rules: {
- budget_seconds: budgetSeconds,
+ unlimited,
+ budget_seconds: unlimited ? null : budgetSeconds,
enforcement: true,
counts_launchers: true,
- warn_at: [3600, 1800, 600, 300],
+ warn_at: unlimited ? [] : [3600, 1800, 600, 300],
demo,
masked_launchers: ['heroic', 'lutris'],
},
diff --git a/web/src/lib/charts/budgetHistory.test.ts b/web/src/lib/charts/budgetHistory.test.ts
index 634949e..e57bf25 100644
--- a/web/src/lib/charts/budgetHistory.test.ts
+++ b/web/src/lib/charts/budgetHistory.test.ts
@@ -35,6 +35,14 @@ describe('budgetHistorySvg', () => {
expect(svg.querySelectorAll('line.grid')).toHaveLength(3)
})
+ it('draws no budget line and scales to the tallest day when there is no budget', () => {
+ const svg = render(budgetHistorySvg([day()], LEGEND, null))
+ expect(svg.querySelector('line.budget-line')).toBeNull()
+ expect(svg.querySelectorAll('rect.seg')).toHaveLength(1)
+ // The only day fills the plot: nothing to measure it against.
+ expect(num(svg.querySelector('rect.seg') ?? undefined, 'height')).toBeGreaterThan(100)
+ })
+
it('stacks one band per game and colours it by legend position', () => {
const svg = render(
budgetHistorySvg(
diff --git a/web/src/lib/charts/budgetHistory.ts b/web/src/lib/charts/budgetHistory.ts
index a9817ab..d4b6ef5 100644
--- a/web/src/lib/charts/budgetHistory.ts
+++ b/web/src/lib/charts/budgetHistory.ts
@@ -24,11 +24,13 @@ export function esc(text: string): string {
const n = (v: number): string => String(v)
/** The chart for `days` (non-empty; the caller shows the empty state). */
-export function budgetHistorySvg(days: readonly BudgetHistoryDay[], legend: readonly BudgetLegendEntry[], budgetSeconds: number): string {
+export function budgetHistorySvg(days: readonly BudgetHistoryDay[], legend: readonly BudgetLegendEntry[], budgetSeconds: number | null): string {
// Scaled against the budget rather than the tallest bar, so a single day
// reads as "most of the allowance" instead of a lone full-height bar that
// means nothing on its own.
- const maxSeconds = Math.max(budgetSeconds, ...days.map((d) => d.seconds)) || 1
+ // With no budget (unlimited days) there is no allowance to scale against: the
+ // tallest day fills the plot and no dashed line is drawn.
+ const maxSeconds = Math.max(budgetSeconds ?? 0, ...days.map((d) => d.seconds)) || 1
const plotW = W - PAD.left - PAD.right
const plotH = H - PAD.top - PAD.bottom
const sy = (seconds: number) => PAD.top + plotH - (seconds / maxSeconds) * plotH
@@ -43,7 +45,10 @@ export function budgetHistorySvg(days: readonly BudgetHistoryDay[], legend: read
`` +
`${esc(fmtDuration(s))}`,
)
- const budgetLine = ``
+ const budgetLine =
+ budgetSeconds === null
+ ? ''
+ : ``
const bars = days.flatMap((d, i) => {
// Bands stack upwards from the axis in legend order, so a game keeps the
diff --git a/web/src/sections/dashboard.ts b/web/src/sections/dashboard.ts
index 389e391..1043586 100644
--- a/web/src/sections/dashboard.ts
+++ b/web/src/sections/dashboard.ts
@@ -123,13 +123,18 @@ export class BudgetGlanceElement extends LiveElement {
const t = data.today
const body = t
? [
- h(
- 'p',
- { class: 'hero-num' },
- `${fmtDuration(t.seconds_remaining)} `,
- h('span', { class: 'muted' }, said(`left of ${fmtDuration(t.budget_seconds)}`, `/ ${fmtDuration(t.budget_seconds)}`)),
- ),
- progressBar(t.fraction_used, 'Budget used', budgetTone(t.blocked, t.fraction_used)),
+ // From 2026-11-16 there is no budget: the mark replaces the countdown and the bar.
+ t.unlimited || t.fraction_used === null || t.budget_seconds === null
+ ? h('p', { class: 'hero-num' }, glyph('filter.no-cap', 'No gaming limit'))
+ : [
+ h(
+ 'p',
+ { class: 'hero-num' },
+ `${fmtDuration(t.seconds_remaining ?? 0)} `,
+ h('span', { class: 'muted' }, said(`left of ${fmtDuration(t.budget_seconds)}`, `/ ${fmtDuration(t.budget_seconds)}`)),
+ ),
+ progressBar(t.fraction_used, 'Budget used', budgetTone(t.blocked, t.fraction_used)),
+ ],
billingLine(t.blocked, data.session.billing_label),
]
: h('p', { class: 'text-danger' }, data.error ?? glyph('state.warn', 'Budget state unavailable.'))
diff --git a/web/src/sections/dashboard.unlimited.test.ts b/web/src/sections/dashboard.unlimited.test.ts
new file mode 100644
index 0000000..75583f2
--- /dev/null
+++ b/web/src/sections/dashboard.unlimited.test.ts
@@ -0,0 +1,18 @@
+import { screen } from '@testing-library/dom'
+import { describe, expect, it } from 'vitest'
+import { makeBudget, makeBudgetToday } from '../test/factories'
+import { mount, stubApi } from '../test/harness'
+import './dashboard'
+
+// From 2026-11-16 the backend sends no budget number: the glance paints the
+// no-limit mark and no bar, and still says what is billing.
+describe('budget glance on an unlimited day', () => {
+ it('shows the no-limit mark, no progress bar, and the billing line', async () => {
+ const today = makeBudgetToday({ unlimited: true, budget_seconds: null, seconds_remaining: null, fraction_used: null })
+ stubApi({ 'GET /api/budget': makeBudget({ today }) })
+ mount('')
+ expect(await screen.findByText('∞')).toBeInTheDocument()
+ expect(screen.queryByRole('progressbar', { name: 'Budget used' })).toBeNull()
+ expect(screen.getByText('Now: Hollow Knight')).toBeInTheDocument()
+ })
+})
diff --git a/web/src/sections/gaming/cards.ts b/web/src/sections/gaming/cards.ts
index 2d750d9..864de14 100644
--- a/web/src/sections/gaming/cards.ts
+++ b/web/src/sections/gaming/cards.ts
@@ -60,11 +60,28 @@ function warningLine(today: BudgetToday, maskedCount: number): HTMLElement {
: said(`Next warning at ${fmtDuration(next)} remaining.`, iconInline('gaming.warning'), ' ', fmtDuration(next))
}
+/** The "no limit" mark: the registry's no-cap icon. */
+const unlimitedMark = (): HTMLElement => glyph('filter.no-cap', 'No gaming limit')
+
function usageLine(t: BudgetToday): HTMLElement {
- const used = `${fmtDuration(t.seconds_used)} / ${fmtDuration(t.budget_seconds)} · ${Math.round(t.fraction_used * 100)}%`
+ if (t.unlimited) {
+ return said(
+ `${fmtDuration(t.seconds_used)} played · gaming day ${t.gaming_day} (starts ${t.day_starts_at})`,
+ fmtDuration(t.seconds_used),
+ ' · ',
+ iconInline('gaming.day'),
+ ' ',
+ t.gaming_day,
+ ' · ',
+ iconInline('gaming.day_start'),
+ ' ',
+ t.day_starts_at.replace(/\s*local$/, ''),
+ )
+ }
+ const used = `${fmtDuration(t.seconds_used)} / ${fmtDuration(t.budget_seconds ?? 0)} · ${Math.round((t.fraction_used ?? 0) * 100)}%`
const spoken =
- `${fmtDuration(t.seconds_used)} of ${fmtDuration(t.budget_seconds)} used · ` +
- `${Math.round(t.fraction_used * 100)}% · gaming day ${t.gaming_day} (starts ${t.day_starts_at})`
+ `${fmtDuration(t.seconds_used)} of ${fmtDuration(t.budget_seconds ?? 0)} used · ` +
+ `${Math.round((t.fraction_used ?? 0) * 100)}% · gaming day ${t.gaming_day} (starts ${t.day_starts_at})`
return said(
spoken,
used,
@@ -81,19 +98,25 @@ function usageLine(t: BudgetToday): HTMLElement {
export function todayCard(today: BudgetToday, legend: readonly BudgetLegendEntry[], maskedCount: number): HTMLElement {
// Colour by the chart's legend position so a game reads the same in both
- // places; today can hold games the capped 14-day legend left out, and those
- // fall back to their own row order.
+ // places; games the capped legend left out fall back to their row order.
const indexFor = new Map(legend.map((e, i) => [e.key, i]))
const fill = h('div', { class: 'budget-meter-fill' })
- fill.style.width = `${(today.fraction_used * 100).toFixed(1)}%`
+ fill.style.width = `${((today.fraction_used ?? 0) * 100).toFixed(1)}%`
+ const unlimited = today.unlimited
return h(
'section',
{ class: 'budget-today' },
h('h2', {}, glyph('gaming.today', 'Today')),
- h('p', { class: 'budget-hero' }, h('strong', {}, fmtDuration(today.seconds_remaining)), h('span', { class: 'sr-only' }, ' left')),
- h('div', { class: `budget-meter budget-meter--${meterState(today)}` }, fill),
+ h(
+ 'p',
+ { class: 'budget-hero' },
+ h('strong', {}, unlimited ? unlimitedMark() : fmtDuration(today.seconds_remaining ?? 0)),
+ unlimited ? null : h('span', { class: 'sr-only' }, ' left'),
+ ),
+ // No budget, no meter and no warnings: there is nothing to fill or warn of.
+ unlimited ? null : h('div', { class: `budget-meter budget-meter--${meterState(today)}` }, fill),
h('p', { class: 'hint' }, usageLine(today)),
- h('p', { class: 'hint' }, warningLine(today, maskedCount)),
+ unlimited ? null : h('p', { class: 'hint' }, warningLine(today, maskedCount)),
today.games.length > 0
? [
h('h3', { class: 'budget-subhead' }, glyph('gaming.by_game', 'Today by game')),
@@ -171,7 +194,7 @@ export function liveCard(session: BudgetSession): HTMLElement {
)
}
-export function historyCard(days: readonly BudgetHistoryDay[], legend: readonly BudgetLegendEntry[], budgetSeconds: number): HTMLElement {
+export function historyCard(days: readonly BudgetHistoryDay[], legend: readonly BudgetLegendEntry[], budgetSeconds: number | null): HTMLElement {
const title = h('h2', {}, glyph('gaming.history', 'Last 14 days'))
if (days.length === 0) {
return h(
@@ -216,10 +239,10 @@ export function rulesCard(rules: BudgetRules): HTMLElement {
h(
'dl',
{ class: 'budget-rules-list' },
- row('gaming.budget', 'Daily budget', fmtDuration(rules.budget_seconds)),
+ row('gaming.budget', 'Daily budget', rules.budget_seconds === null ? unlimitedMark() : fmtDuration(rules.budget_seconds)),
row('gaming.enforcement', 'Enforcement', onOff(rules.enforcement, 'on', 'off')),
row('gaming.launcher', 'Counts launchers', onOff(rules.counts_launchers, 'yes', 'no')),
- row('gaming.warning', 'Warnings at', said(`${warn} remaining`, warn)),
+ rules.warn_at.length > 0 ? row('gaming.warning', 'Warnings at', said(`${warn} remaining`, warn)) : null,
rules.demo ? row('gaming.mode', 'Mode', glyph('gaming.demo', 'demo (short budget, separate state)')) : null,
rules.masked_launchers.length > 0 ? row('gaming.masked', 'Masked now', rules.masked_launchers.join(', ')) : null,
),
diff --git a/web/src/sections/gaming/cards.unlimited.test.ts b/web/src/sections/gaming/cards.unlimited.test.ts
new file mode 100644
index 0000000..5645575
--- /dev/null
+++ b/web/src/sections/gaming/cards.unlimited.test.ts
@@ -0,0 +1,47 @@
+import { screen } from '@testing-library/dom'
+import { describe, expect, it } from 'vitest'
+import { makeBudgetRules, makeBudgetToday } from '../../test/factories'
+import { rulesCard, todayCard } from './cards'
+
+const show = (el: HTMLElement) => {
+ document.body.replaceChildren(el)
+}
+
+// From 2026-11-16 the backend sends no budget number at all.
+const unlimitedToday = () =>
+ makeBudgetToday({
+ unlimited: true,
+ budget_seconds: null,
+ seconds_remaining: null,
+ fraction_used: null,
+ next_warning_seconds: null,
+ seconds_used: 40_000,
+ })
+
+describe('unlimited day', () => {
+ it('paints infinity, no meter, no warning line, no percentage', () => {
+ show(todayCard(unlimitedToday(), [], 0))
+ expect(screen.getByText('∞')).toBeInTheDocument()
+ expect(document.querySelector('.budget-meter')).toBeNull()
+ expect(document.body.textContent).not.toMatch(/warning/i)
+ expect(document.querySelector('.budget-hero')?.textContent).not.toMatch(/%|left/)
+ expect(document.querySelector('.hint')?.textContent).not.toMatch(/%/)
+ expect(document.body.textContent).toContain('11h 6m')
+ })
+
+ it('keeps showing what was billed, by game', () => {
+ show(todayCard(unlimitedToday(), [], 0))
+ expect(screen.getByText('Hollow Knight')).toBeInTheDocument()
+ })
+
+ it('rules: no daily budget and no warning thresholds', () => {
+ show(rulesCard(makeBudgetRules({ unlimited: true, budget_seconds: null, warn_at: [] })))
+ expect(screen.getByText('∞')).toBeInTheDocument()
+ expect(screen.queryByText('Warnings at')).toBeNull()
+ })
+
+ it('an enforced day still has its meter', () => {
+ show(todayCard(makeBudgetToday(), [], 0))
+ expect(document.querySelector('.budget-meter')).not.toBeNull()
+ })
+})
diff --git a/web/src/test/factories.ts b/web/src/test/factories.ts
index 6101980..d17b273 100644
--- a/web/src/test/factories.ts
+++ b/web/src/test/factories.ts
@@ -108,6 +108,7 @@ export function makeBudgetToday(over: Partial = {}): BudgetToday {
gaming_day: '2026-08-28',
day_starts_at: '06:00 local',
seconds_used: 3600,
+ unlimited: false,
budget_seconds: 28800,
seconds_remaining: 25200,
fraction_used: 0.125,
@@ -137,6 +138,7 @@ export function makeBudgetSession(over: Partial = {}): BudgetSess
export function makeBudgetRules(over: Partial = {}): BudgetRules {
return {
+ unlimited: false,
budget_seconds: 28800,
enforcement: true,
counts_launchers: true,
diff --git a/web/src/types.ts b/web/src/types.ts
index 23ed307..303ae5e 100644
--- a/web/src/types.ts
+++ b/web/src/types.ts
@@ -104,10 +104,12 @@ export interface BudgetToday {
gaming_day: string
day_starts_at: string
seconds_used: number
- budget_seconds: number
- seconds_remaining: number
- /** 0..1, already clamped by the backend. */
- fraction_used: number
+ /** True from 2026-11-16: no gaming budget, so the three fields below are null. */
+ unlimited: boolean
+ budget_seconds: number | null
+ seconds_remaining: number | null
+ /** 0..1, already clamped by the backend; null when unlimited. */
+ fraction_used: number | null
blocked: boolean
/** Epoch seconds; 0 means the cutoff has not engaged. */
blocked_at: number
@@ -167,7 +169,8 @@ export interface BudgetLegendEntry {
}
export interface BudgetRules {
- budget_seconds: number
+ unlimited: boolean
+ budget_seconds: number | null
enforcement: boolean
counts_launchers: boolean
warn_at: number[]