From 445ad011bb5f85030c7c736420cb29244a839a7b Mon Sep 17 00:00:00 2001
From: Krzysztof kuhy Rudnicki
Date: Wed, 2 Sep 2026 18:14:27 +0200
Subject: [PATCH] Remove engagement gating from the gaming budget
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
A qualifying game process running is now sufficient on its own to bill
the budget. Previously a tick only counted if the screen wasn't locked,
the game's window was X11-focused, and input hadn't gone idle for 5
minutes — with an idle-grace refund on top. That leniency is gone
entirely: no focus check, no idle check, no screen-lock check, no
refund. Deletes the engagement-probing modules (_playtime_engagement,
_engagement_probes, _engagement_types, _x_focus, _x_probe, _screen_hold,
_controller_input) and their config fields, simplifies the audit log
and budget-view/web session schema accordingly.
Co-Authored-By: Claude Opus 4.8
---
steam_backlog_enforcer/_budget_log_tail.py | 25 +-
steam_backlog_enforcer/_budget_view.py | 7 -
steam_backlog_enforcer/_controller_input.py | 153 -----------
steam_backlog_enforcer/_enforce_loop.py | 6 +-
steam_backlog_enforcer/_engagement_probes.py | 170 ------------
steam_backlog_enforcer/_engagement_types.py | 91 -------
steam_backlog_enforcer/_playtime.py | 18 +-
.../_playtime_engagement.py | 172 -------------
steam_backlog_enforcer/_playtime_log.py | 53 ++--
steam_backlog_enforcer/_playtime_procs.py | 34 +--
steam_backlog_enforcer/_playtime_session.py | 40 +--
steam_backlog_enforcer/_playtime_state.py | 6 -
steam_backlog_enforcer/_screen_hold.py | 124 ---------
steam_backlog_enforcer/_x_focus.py | 176 -------------
steam_backlog_enforcer/_x_probe.py | 185 -------------
steam_backlog_enforcer/config.py | 8 -
steam_backlog_enforcer/tests/_fake_session.py | 91 +------
.../tests/test_budget_log_tail.py | 16 +-
.../tests/test_budget_view.py | 7 -
.../tests/test_controller_input.py | 137 ----------
.../tests/test_engagement_probes.py | 155 -----------
.../tests/test_engagement_types.py | 50 ----
.../tests/test_playtime_attribution.py | 37 +--
.../tests/test_playtime_engagement.py | 242 ------------------
.../tests/test_playtime_log.py | 50 +---
.../tests/test_playtime_session.py | 39 +--
.../tests/test_screen_hold.py | 111 --------
steam_backlog_enforcer/tests/test_x_focus.py | 187 --------------
steam_backlog_enforcer/tests/test_x_probe.py | 120 ---------
web/src/components/BudgetLiveCard.test.tsx | 32 +--
web/src/components/BudgetLiveCard.tsx | 21 +-
web/src/components/BudgetRulesCard.test.tsx | 5 -
web/src/components/BudgetRulesCard.tsx | 5 -
web/src/index.css | 3 -
web/src/test/factories.ts | 7 -
web/src/types.ts | 7 -
36 files changed, 89 insertions(+), 2501 deletions(-)
delete mode 100644 steam_backlog_enforcer/_controller_input.py
delete mode 100644 steam_backlog_enforcer/_engagement_probes.py
delete mode 100644 steam_backlog_enforcer/_engagement_types.py
delete mode 100644 steam_backlog_enforcer/_playtime_engagement.py
delete mode 100644 steam_backlog_enforcer/_screen_hold.py
delete mode 100644 steam_backlog_enforcer/_x_focus.py
delete mode 100644 steam_backlog_enforcer/_x_probe.py
delete mode 100644 steam_backlog_enforcer/tests/test_controller_input.py
delete mode 100644 steam_backlog_enforcer/tests/test_engagement_probes.py
delete mode 100644 steam_backlog_enforcer/tests/test_engagement_types.py
delete mode 100644 steam_backlog_enforcer/tests/test_playtime_engagement.py
delete mode 100644 steam_backlog_enforcer/tests/test_screen_hold.py
delete mode 100644 steam_backlog_enforcer/tests/test_x_focus.py
delete mode 100644 steam_backlog_enforcer/tests/test_x_probe.py
diff --git a/steam_backlog_enforcer/_budget_log_tail.py b/steam_backlog_enforcer/_budget_log_tail.py
index 91e0f92..e49b2e6 100644
--- a/steam_backlog_enforcer/_budget_log_tail.py
+++ b/steam_backlog_enforcer/_budget_log_tail.py
@@ -1,10 +1,10 @@
"""Reading the last recorded verdict back out of the budget audit log.
-``_playtime_log`` writes the daemon's own view of why time is or is not being
-billed — engagement state, the causes behind it, which PIDs qualified. That is
-exactly what a live status display wants, and reading it back beats having the
-web server run its own engagement probes: a second opinion that disagreed with
-the daemon's would be worse than no opinion at all.
+``_playtime_log`` writes the daemon's own view of whether a qualifying process
+was running and which PIDs qualified. That is exactly what a live status
+display wants, and reading it back beats having the web server re-derive it
+itself: a second opinion that disagreed with the daemon's would be worse than
+no opinion at all.
The log is append-only and can reach 5 MB before rotating, so only its tail is
read. One record is all anyone needs and a status endpoint polled every few
@@ -43,15 +43,11 @@ class RunningGame:
@dataclass(frozen=True)
class SessionView:
- """The most recently logged engagement verdict."""
+ """The most recently logged tick observation."""
observed_at: str = ""
"""ISO-8601 timestamp the daemon recorded, ``""`` if unknown."""
state: str = ""
- reason: str = ""
- causes: list[str] = field(default_factory=list)
- idle_seconds: float | None = None
- screen_held: bool | None = None
games: list[RunningGame] = field(default_factory=list)
available: bool = False
"""Whether a record was found at all."""
@@ -111,7 +107,7 @@ def _live_games(record: dict[str, Any]) -> list[RunningGame]:
def last_verdict(*, demo: bool) -> SessionView:
- """Return the most recently logged engagement verdict.
+ """Return the most recently logged tick observation.
Args:
demo: Whether to read the demo log.
@@ -123,16 +119,9 @@ def last_verdict(*, demo: bool) -> SessionView:
if record is None:
return SessionView()
- causes = record.get("causes")
- idle = record.get("idle_seconds")
- held = record.get("screen_held")
return SessionView(
observed_at=str(record.get("timestamp") or ""),
state=str(record.get("state") or ""),
- reason=str(record.get("reason") or ""),
- causes=[str(cause) for cause in causes] if isinstance(causes, list) else [],
- idle_seconds=float(idle) if isinstance(idle, (int, float)) else None,
- screen_held=held if isinstance(held, bool) else None,
games=_live_games(record),
available=True,
)
diff --git a/steam_backlog_enforcer/_budget_view.py b/steam_backlog_enforcer/_budget_view.py
index f5ce655..07827be 100644
--- a/steam_backlog_enforcer/_budget_view.py
+++ b/steam_backlog_enforcer/_budget_view.py
@@ -151,9 +151,6 @@ def build_rules(rules: PlaytimeRules) -> dict[str, Any]:
"budget_seconds": rules.budget_seconds,
"enforcement": rules.enforcement,
"counts_launchers": rules.count_launchers,
- "engagement_gate": rules.engagement_gate,
- "idle_grace_seconds": rules.idle_grace_seconds,
- "require_game_focus": rules.require_game_focus,
"warn_at": list(rules.warn_at),
"demo": rules.demo,
"masked_launchers": sorted(str(path) for path in mounted_targets()),
@@ -207,10 +204,6 @@ def build_budget_snapshot(*, demo: bool = False) -> dict[str, Any]:
"available": session.available,
"observed_at": session.observed_at,
"state": session.state,
- "reason": session.reason,
- "causes": session.causes,
- "idle_seconds": session.idle_seconds,
- "screen_held": session.screen_held,
# A single Proton title qualifies a dozen processes — reaper,
# srt-bwrap, wineserver, plugplay.exe. Listing those as "games
# running" would be nonsense, so the headline is the game the
diff --git a/steam_backlog_enforcer/_controller_input.py b/steam_backlog_enforcer/_controller_input.py
deleted file mode 100644
index 4f119c8..0000000
--- a/steam_backlog_enforcer/_controller_input.py
+++ /dev/null
@@ -1,153 +0,0 @@
-"""Noticing that a game controller is being used.
-
-The X screensaver idle counter only tracks keyboards and pointers. A gamepad
-session that goes five minutes without touching either would look idle, and
-pausing the budget there would hand out free gaming — the single worst failure
-mode of the engagement gate, because it rewards the behaviour it fails to see.
-
-Presence is not a usable proxy for use. Measured on this machine, ``/dev/input/js0``
-is an *ASRock LED Controller*: the kernel exposes the motherboard's RGB device as
-a joystick. Treating "a js device exists" as "a controller is in play" would
-disable the idle criterion permanently, on a machine with no gamepad attached.
-
-So this watches for actual events instead. Each joystick device is opened
-non-blocking and drained every tick; joydev gives every reader its own event
-queue, so draining ours cannot steal input from the game. The synthetic burst
-joydev replays on open is flagged ``JS_EVENT_INIT`` and is skipped — without that
-filter, merely opening the device would look like a button press.
-"""
-
-from __future__ import annotations
-
-import contextlib
-import errno
-import logging
-import os
-from pathlib import Path
-from typing import Final
-
-logger = logging.getLogger(__name__)
-
-_DEVICE_DIR: Final = Path("/dev/input")
-_DEVICE_PREFIX: Final = "js"
-
-# struct js_event { __u32 time; __s16 value; __u8 type; __u8 number; }
-_EVENT_SIZE: Final = 8
-_TYPE_OFFSET: Final = 6
-_JS_EVENT_INIT: Final = 0x80
-
-# Cap per device per tick so a flood cannot stall the enforce loop.
-_MAX_EVENTS_PER_POLL: Final = 64
-
-
-class ControllerActivity:
- """Tracks when a joystick device last produced a real event."""
-
- def __init__(self, *, device_dir: Path = _DEVICE_DIR) -> None:
- """Start with no devices open and no activity seen.
-
- Args:
- device_dir: Directory holding ``js*`` nodes.
- """
- self._device_dir = device_dir
- self._fds: dict[Path, int] = {}
- self._last_event_at: float | None = None
-
- def poll(self, *, now: float) -> None:
- """Drain pending controller events, recording any real activity.
-
- Args:
- now: Monotonic timestamp for this tick.
- """
- self._sync_devices()
- for path in list(self._fds):
- if self._drain(path):
- self._last_event_at = now
-
- def seconds_since_activity(self, *, now: float) -> float | None:
- """Return seconds since the last real controller event.
-
- Args:
- now: Monotonic timestamp for this tick.
-
- Returns:
- The elapsed seconds, or ``None`` if no event has been seen at all —
- which the caller must not read as "idle", only as "no evidence".
- """
- if self._last_event_at is None:
- return None
- return now - self._last_event_at
-
- def close(self) -> None:
- """Close every open device."""
- for path in list(self._fds):
- self._forget(path)
-
- def _sync_devices(self) -> None:
- """Open newly appeared ``js*`` devices and forget vanished ones."""
- try:
- present = {
- entry
- for entry in self._device_dir.iterdir()
- if entry.name.startswith(_DEVICE_PREFIX)
- }
- except OSError:
- present = set()
-
- for path in list(self._fds):
- if path not in present:
- self._forget(path)
-
- for path in present - set(self._fds):
- self._open(path)
-
- def _open(self, path: Path) -> None:
- """Open *path* for reading, ignoring devices we may not read.
-
- Args:
- path: Device to open.
- """
- try:
- self._fds[path] = os.open(path, os.O_RDONLY | os.O_NONBLOCK)
- except OSError:
- # A js node we cannot open tells us nothing either way; the idle
- # criterion simply falls back to keyboard and pointer input.
- logger.debug("Cannot open controller device %s", path)
-
- def _drain(self, path: Path) -> bool:
- """Read pending events from *path*.
-
- Args:
- path: Device to drain.
-
- Returns:
- Whether at least one non-synthetic event was read.
- """
- fd = self._fds[path]
- seen = False
- for _ in range(_MAX_EVENTS_PER_POLL):
- try:
- chunk = os.read(fd, _EVENT_SIZE)
- except OSError as exc:
- if exc.errno != errno.EAGAIN:
- self._forget(path)
- break
- if len(chunk) < _EVENT_SIZE:
- break
- if not chunk[_TYPE_OFFSET] & _JS_EVENT_INIT:
- seen = True
- return seen
-
- def _forget(self, path: Path) -> None:
- """Close and drop *path*.
-
- Args:
- path: Device to close.
- """
- fd = self._fds.pop(path, None)
- if fd is not None:
- # The usual reason to forget a device is that reading it just
- # failed, which often means the fd is already unusable; closing it
- # again must not take the enforce loop down with it.
- with contextlib.suppress(OSError):
- os.close(fd)
diff --git a/steam_backlog_enforcer/_enforce_loop.py b/steam_backlog_enforcer/_enforce_loop.py
index a95b419..870ae44 100644
--- a/steam_backlog_enforcer/_enforce_loop.py
+++ b/steam_backlog_enforcer/_enforce_loop.py
@@ -116,7 +116,7 @@ def _enforce_loop_iteration(
Args:
config: Enforcer configuration.
state: Current enforcer state.
- session: Cross-tick engagement and logging state.
+ session: Cross-tick logging state.
demo: Run the gaming budget on a 60-second demo budget.
"""
# Daily gaming budget runs FIRST and unconditionally. Every guard below
@@ -220,8 +220,8 @@ def do_enforce(config: Config, state: State, *, demo: bool = False) -> None:
_echo(f" Enforce loop: ACTIVE (every {ENFORCE_INTERVAL}s)")
_echo(" Guarding: processes + installs + store")
_echo(" Press Ctrl+C to stop.\n")
- # One session for the whole daemon: the engagement backdate needs to see
- # the previous tick's verdict, so it cannot be rebuilt per iteration.
+ # One session for the whole daemon: the audit journal needs to see the
+ # previous tick's record, so it cannot be rebuilt per iteration.
session = new_session(demo=demo)
try:
while True:
diff --git a/steam_backlog_enforcer/_engagement_probes.py b/steam_backlog_enforcer/_engagement_probes.py
deleted file mode 100644
index 1e6a048..0000000
--- a/steam_backlog_enforcer/_engagement_probes.py
+++ /dev/null
@@ -1,170 +0,0 @@
-"""Turning each raw engagement signal into a pause cause.
-
-Split from :mod:`_playtime_engagement`, which owns the per-tick decision and the
-backdate; this owns the three probes and the rule each one applies. Every probe
-follows the same contract: append to *causes* when the criterion says "not
-playing", append to *degraded* when the probe could not answer, and never raise.
-
-**A probe that fails does not pause the tick.** Failure means the tick is billed.
-A detector that stopped working must never become an unlimited-gaming exploit,
-so the burden of proof sits on "not playing", not on "playing".
-"""
-
-from __future__ import annotations
-
-import logging
-from typing import TYPE_CHECKING
-
-from steam_backlog_enforcer._engagement_types import (
- CAUSE_FOCUS,
- CAUSE_IDLE,
- CAUSE_SCREEN_HELD,
- PROBE_FOCUS,
- PROBE_IDLE,
- PROBE_SCREEN_HELD,
- CauseTally,
-)
-from steam_backlog_enforcer._playtime_kill import (
- _INIT_PID,
- _MAX_PROCESS_TREE_DEPTH,
- _read_ppid,
-)
-from steam_backlog_enforcer._screen_hold import ScreenHoldError, screen_hold
-from steam_backlog_enforcer._x_focus import focused_pid
-from steam_backlog_enforcer._x_probe import XProbeError
-
-if TYPE_CHECKING:
- from pathlib import Path
-
- from steam_backlog_enforcer._controller_input import ControllerActivity
- from steam_backlog_enforcer._playtime_state import PlaytimeRules
- from steam_backlog_enforcer._x_probe import XProbe
-
-logger = logging.getLogger(__name__)
-
-
-def assess_screen(
- holder_path: Path, tally: CauseTally
-) -> tuple[bool | None, int | None]:
- """Add the screen-held cause if a gatelock guard owns the display.
-
- Args:
- holder_path: The gatelock holder lock.
- tally: Accumulating causes and probe failures.
-
- Returns:
- The hold state and holding PID, both ``None`` when the probe failed.
- """
- try:
- hold = screen_hold(holder_path)
- except ScreenHoldError as exc:
- logger.warning("Screen-hold probe failed; billing this tick: %s", exc)
- tally.degraded.append(PROBE_SCREEN_HELD)
- return None, None
-
- if hold.held:
- tally.causes.append(CAUSE_SCREEN_HELD)
- return hold.held, hold.holder_pid
-
-
-def assess_focus(
- probe: XProbe,
- rules: PlaytimeRules,
- qualifying: set[int],
- tally: CauseTally,
-) -> int | None:
- """Add the focus cause unless a qualifying process owns the focus.
-
- Args:
- probe: X connection.
- rules: Policy for this tick.
- qualifying: PIDs that would otherwise count.
- tally: Accumulating causes and probe failures.
-
- Returns:
- The focused PID, or ``None``.
- """
- if not rules.require_game_focus:
- return None
- try:
- pid = focused_pid(probe.connect())
- except XProbeError as exc:
- logger.warning("Focus probe failed; billing this tick: %s", exc)
- tally.degraded.append(PROBE_FOCUS)
- probe.close()
- return None
-
- if not focus_qualifies(pid, qualifying):
- tally.causes.append(CAUSE_FOCUS)
- return pid
-
-
-def assess_idle(
- probe: XProbe,
- controller: ControllerActivity,
- rules: PlaytimeRules,
- tally: CauseTally,
- now_monotonic: float,
-) -> tuple[float | None, float | None]:
- """Add the idle cause when every input source has gone quiet.
-
- The controller is polled first and its age folded in with ``min``: the X
- idle counter does not see a gamepad, and pausing during controller play
- would be the gate's worst failure.
-
- Args:
- probe: X connection.
- controller: Controller-activity watcher.
- rules: Policy for this tick.
- tally: Accumulating causes and probe failures.
- now_monotonic: Monotonic timestamp for controller ages.
-
- Returns:
- The effective idle seconds and the controller idle seconds.
- """
- controller.poll(now=now_monotonic)
- controller_idle = controller.seconds_since_activity(now=now_monotonic)
-
- try:
- pointer_idle = probe.idle_seconds()
- except XProbeError as exc:
- logger.warning("Idle probe failed; billing this tick: %s", exc)
- tally.degraded.append(PROBE_IDLE)
- probe.close()
- return None, controller_idle
-
- idle = pointer_idle
- if controller_idle is not None:
- idle = min(idle, controller_idle)
- if idle >= rules.idle_grace_seconds:
- tally.causes.append(CAUSE_IDLE)
- return idle, controller_idle
-
-
-def focus_qualifies(focus_pid: int | None, qualifying: set[int]) -> bool:
- """Whether *focus_pid* is, or descends from, a qualifying process.
-
- A game's visible window is often owned by a child of the process carrying
- ``SteamAppId`` — Proton in particular — so the ancestry is walked rather
- than compared directly.
-
- Args:
- focus_pid: PID owning the focused window, or ``None``.
- qualifying: PIDs that count as gaming.
-
- Returns:
- Whether the focused window belongs to the game.
- """
- if focus_pid is None:
- return False
- pid = focus_pid
- for _ in range(_MAX_PROCESS_TREE_DEPTH):
- if pid in qualifying:
- return True
- if pid <= _INIT_PID:
- return False
- parent = _read_ppid(pid)
- if parent is None:
- return False
- pid = parent
- return False
diff --git a/steam_backlog_enforcer/_engagement_types.py b/steam_backlog_enforcer/_engagement_types.py
deleted file mode 100644
index f229419..0000000
--- a/steam_backlog_enforcer/_engagement_types.py
+++ /dev/null
@@ -1,91 +0,0 @@
-"""The verdict describing whether this tick should bill the gaming budget.
-
-Split from :mod:`_playtime_engagement` so the decision *record* stays a plain
-frozen value with no probes attached: everything that writes it is testable
-without an X server, and everything that reads it — the accumulator and the
-audit log — sees the same shape.
-
-The verdict deliberately records *every* cause rather than short-circuiting on
-the first one. The idle backdate only fires when idle is the sole cause, and a
-log that recorded just the first-matching reason could not answer "was the
-screen also locked?" after the fact.
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-from typing import Final
-
-STATE_ENGAGED: Final = "engaged"
-STATE_PAUSED: Final = "paused"
-STATE_NOT_APPLICABLE: Final = "not_applicable"
-
-CAUSE_IDLE: Final = "idle"
-CAUSE_SCREEN_HELD: Final = "screen_held"
-CAUSE_FOCUS: Final = "focus"
-
-PROBE_IDLE: Final = "idle"
-PROBE_SCREEN_HELD: Final = "screen_held"
-PROBE_FOCUS: Final = "focus"
-
-
-@dataclass
-class CauseTally:
- """Pause causes and probe failures accumulated across one tick's probes.
-
- Passed to each probe instead of two parallel lists: it keeps the probe
- signatures short, and it makes "this probe appends to both" a single idea
- rather than a convention two arguments have to remember.
- """
-
- causes: list[str] = field(default_factory=list)
- degraded: list[str] = field(default_factory=list)
-
-
-@dataclass(frozen=True)
-class EngagementVerdict:
- """Why this tick did or did not count against the budget."""
-
- state: str
- causes: tuple[str, ...] = ()
- degraded: tuple[str, ...] = ()
- idle_seconds: float | None = None
- controller_idle_seconds: float | None = None
- screen_held: bool | None = None
- holder_pid: int | None = None
- focus_pid: int | None = None
- qualifying: tuple[int, ...] = field(default_factory=tuple)
-
- @property
- def engaged(self) -> bool:
- """Whether this tick should be billed.
-
- ``not_applicable`` counts as engaged: nothing qualifies, so the
- accumulator will credit nothing regardless, and calling it "paused"
- would fill the audit log with a pause reason during ordinary desktop
- use.
-
- Returns:
- Whether the tick bills.
- """
- return self.state != STATE_PAUSED
-
- @property
- def reason(self) -> str:
- """A short human-readable summary of *causes*.
-
- Returns:
- The joined causes, or the state when there are none.
- """
- return "+".join(self.causes) if self.causes else self.state
-
- def idle_only(self) -> bool:
- """Whether idleness is the sole reason this tick was paused.
-
- The backdate refunds the idle grace period, which is only correct when
- nothing else would have paused the tick anyway.
-
- Returns:
- Whether *causes* is exactly ``(CAUSE_IDLE,)``.
- """
- return self.causes == (CAUSE_IDLE,)
diff --git a/steam_backlog_enforcer/_playtime.py b/steam_backlog_enforcer/_playtime.py
index c2169af..a9d861b 100644
--- a/steam_backlog_enforcer/_playtime.py
+++ b/steam_backlog_enforcer/_playtime.py
@@ -81,14 +81,13 @@ def playtime_tick(
that time is still counted (and a 06:00 release still happens) in the
situations where the rest of the loop early-returns.
- Time only accrues while the user is actually engaged: a resident game
- process behind a locked screen, an unfocused window or five minutes of
- silence is not play. See :mod:`_playtime_engagement`.
+ A qualifying process running is sufficient on its own — there is no
+ engagement gate on top of it.
Args:
config: Loaded user configuration.
interval: Nominal seconds between enforce-loop ticks.
- session: Cross-tick engagement and logging state.
+ session: Cross-tick logging state.
demo: Whether this is a short-budget demo run.
"""
now = datetime.now(UTC).astimezone()
@@ -106,21 +105,16 @@ def playtime_tick(
owners = qualifying_pids(rules)
pids = set(owners)
- monotonic = time.monotonic()
- verdict = session.tracker.assess(rules, qualifying=pids, now_monotonic=monotonic)
state = accumulate(
state,
now=now,
- qualifying=pids if verdict.engaged else set(),
+ qualifying=pids,
interval=interval,
- credited_key=(
- attributed_key(owners, verdict.focus_pid) if verdict.engaged else ""
- ),
+ credited_key=attributed_key(owners),
)
- state = session.tracker.backdate(state, verdict, rules=rules)
state = _policy(state, rules, now=now)
- session.journal.observe(verdict, state, rules=rules, now_monotonic=monotonic)
+ session.journal.observe(pids, state, rules=rules, now_monotonic=time.monotonic())
save_state(state, demo=demo)
session.history.observe(state, demo=demo)
diff --git a/steam_backlog_enforcer/_playtime_engagement.py b/steam_backlog_enforcer/_playtime_engagement.py
deleted file mode 100644
index 265be4f..0000000
--- a/steam_backlog_enforcer/_playtime_engagement.py
+++ /dev/null
@@ -1,172 +0,0 @@
-"""Deciding whether the user is actually playing, not just leaving a game open.
-
-A running game process is not evidence of play. The budget was previously billed
-for two hours during which a screen locker covered the display and the machine
-could not be touched at all — the game was simply still resident.
-
-Three signals gate a tick, evaluated together rather than short-circuited, so
-that the log can answer "was the screen *also* locked?" after the fact and the
-backdate can tell an idle-only pause from a compound one. The probes themselves
-live in :mod:`_engagement_probes`.
-
-This module owns the per-tick verdict and the one piece of state a pure function
-cannot hold: the previous verdict, which the idle backdate needs to recognise an
-engaged-to-paused edge.
-"""
-
-from __future__ import annotations
-
-from dataclasses import replace
-import logging
-from typing import TYPE_CHECKING
-
-from steam_backlog_enforcer._controller_input import ControllerActivity
-from steam_backlog_enforcer._engagement_probes import (
- assess_focus,
- assess_idle,
- assess_screen,
-)
-from steam_backlog_enforcer._engagement_types import (
- STATE_ENGAGED,
- STATE_NOT_APPLICABLE,
- STATE_PAUSED,
- CauseTally,
- EngagementVerdict,
-)
-from steam_backlog_enforcer._screen_hold import holder_lock_path
-from steam_backlog_enforcer._x_probe import XProbe
-
-if TYPE_CHECKING:
- from pathlib import Path
-
- from steam_backlog_enforcer._playtime_state import PlaytimeRules, PlaytimeState
-
-logger = logging.getLogger(__name__)
-
-
-class EngagementTracker:
- """Assesses engagement per tick and owns the state the backdate needs."""
-
- def __init__(
- self,
- *,
- uid: int,
- probe: XProbe | None = None,
- controller: ControllerActivity | None = None,
- holder_path: Path | None = None,
- ) -> None:
- """Build a tracker over the desktop session owned by *uid*.
-
- Args:
- uid: Owner of the desktop session.
- probe: X probe, injected by tests.
- controller: Controller-activity watcher, injected by tests.
- holder_path: gatelock holder lock, injected by tests.
- """
- self._probe = probe if probe is not None else XProbe()
- self._controller = (
- controller if controller is not None else ControllerActivity()
- )
- self._holder_path = (
- holder_path if holder_path is not None else holder_lock_path(uid)
- )
- self._previous: EngagementVerdict | None = None
- self._previous_day: str | None = None
-
- def close(self) -> None:
- """Release the X connection and controller devices."""
- self._probe.close()
- self._controller.close()
-
- def assess(
- self,
- rules: PlaytimeRules,
- *,
- qualifying: set[int],
- now_monotonic: float,
- ) -> EngagementVerdict:
- """Judge whether this tick counts against the budget.
-
- Args:
- rules: Policy for this tick.
- qualifying: PIDs that would otherwise count.
- now_monotonic: Monotonic timestamp, for controller-activity ages.
-
- Returns:
- The verdict for this tick.
- """
- if not qualifying:
- return EngagementVerdict(state=STATE_NOT_APPLICABLE)
-
- pids = tuple(sorted(qualifying))
- if not rules.engagement_gate:
- return EngagementVerdict(state=STATE_ENGAGED, qualifying=pids)
-
- tally = CauseTally()
-
- held, holder_pid = assess_screen(self._holder_path, tally)
- focus_pid = assess_focus(self._probe, rules, qualifying, tally)
- idle, controller_idle = assess_idle(
- self._probe, self._controller, rules, tally, now_monotonic
- )
-
- return EngagementVerdict(
- state=STATE_PAUSED if tally.causes else STATE_ENGAGED,
- causes=tuple(tally.causes),
- degraded=tuple(tally.degraded),
- idle_seconds=idle,
- controller_idle_seconds=controller_idle,
- screen_held=held,
- holder_pid=holder_pid,
- focus_pid=focus_pid,
- qualifying=pids,
- )
-
- def backdate(
- self,
- state: PlaytimeState,
- verdict: EngagementVerdict,
- *,
- rules: PlaytimeRules,
- ) -> PlaytimeState:
- """Refund the idle grace period once per walk-away.
-
- Time billed *before* the idle threshold tripped was not play either, so
- the first paused tick of an idle-only spell gives it back. Deliberately
- conservative: it fires only on the engaged-to-paused edge, only when
- idleness is the sole cause, and never across a day rollover — and after
- a daemon restart there is no previous verdict, so nothing is refunded.
-
- Args:
- state: Accounting state after this tick's accumulation.
- verdict: This tick's verdict.
- rules: Policy for this tick.
-
- Returns:
- The state, with the grace period deducted when all of that holds.
- """
- previous, previous_day = self._previous, self._previous_day
- self._previous, self._previous_day = verdict, state.day_key
-
- if previous is None or previous.state != STATE_ENGAGED:
- return state
- if previous_day != state.day_key:
- return state
- if not verdict.idle_only():
- return state
-
- refunded = max(0.0, state.seconds - rules.idle_grace_seconds)
- amount = state.seconds - refunded
- logger.info(
- "Idle for %.0fs; refunding the %.0fs grace period.",
- verdict.idle_seconds or 0.0,
- amount,
- )
- # The refund must come off the same key it was billed to, or the
- # per-game parts drift above the whole on every walk-away — which is
- # many times a day, and would render as segments overflowing the bar.
- per_game = dict(state.per_game)
- key = state.last_credited_key
- if key and key in per_game:
- per_game[key] = max(0.0, per_game[key] - amount)
- return replace(state, seconds=refunded, per_game=per_game)
diff --git a/steam_backlog_enforcer/_playtime_log.py b/steam_backlog_enforcer/_playtime_log.py
index 5cef21f..0e42ef9 100644
--- a/steam_backlog_enforcer/_playtime_log.py
+++ b/steam_backlog_enforcer/_playtime_log.py
@@ -7,7 +7,9 @@ from the spacing of two warning notifications. That is not an audit trail.
So every budget decision is recorded here as one JSON object per line, readable
without ``sudo`` (unlike the state file, whose ``PermissionError`` is swallowed
-on load and silently reported as "no state recorded yet").
+on load and silently reported as "no state recorded yet"). There is no
+engagement gate any more, so the record is deliberately thin: it answers
+"was a qualifying process running," not "why wasn't it billing."
Volume is controlled by only writing when something *changes*. At a three-second
tick, one line per tick would be 28 800 lines a day of almost entirely identical
@@ -27,10 +29,7 @@ import logging.handlers
from pathlib import Path
from typing import TYPE_CHECKING, Final, cast
-from steam_backlog_enforcer._engagement_types import STATE_NOT_APPLICABLE
-
if TYPE_CHECKING:
- from steam_backlog_enforcer._engagement_types import EngagementVerdict
from steam_backlog_enforcer._playtime_state import PlaytimeRules, PlaytimeState
logger = logging.getLogger(__name__)
@@ -44,9 +43,11 @@ _HEARTBEAT_SECONDS: Final = 300.0
EVENT_VERDICT_CHANGE: Final = "verdict_change"
EVENT_HEARTBEAT: Final = "heartbeat"
-EVENT_DETECTOR_FAILURE: Final = "detector_failure"
EVENT_MANUAL_ADJUSTMENT: Final = "manual_adjustment"
+STATE_ENGAGED: Final = "engaged"
+STATE_NOT_APPLICABLE: Final = "not_applicable"
+
def budget_log_path(*, demo: bool) -> Path:
"""Return the audit log for a demo or production run.
@@ -162,35 +163,30 @@ class TickJournal:
def observe(
self,
- verdict: EngagementVerdict,
+ qualifying: set[int],
state: PlaytimeState,
*,
rules: PlaytimeRules,
now_monotonic: float,
) -> None:
- """Record *verdict* if it changed, failed, or is due a heartbeat.
+ """Record this tick's qualifying set if it changed or is due a heartbeat.
Args:
- verdict: This tick's verdict.
+ qualifying: PIDs that qualified this tick.
state: Accounting state after this tick.
rules: Policy for this tick.
now_monotonic: Monotonic timestamp for heartbeat spacing.
"""
- if verdict.degraded:
- self._log.record(
- EVENT_DETECTOR_FAILURE,
- degraded=list(verdict.degraded),
- billed=True,
- **_snapshot(verdict, state, rules),
- )
-
- if verdict.reason != self._last_reason:
- self._last_reason = verdict.reason
+ reason = STATE_ENGAGED if qualifying else STATE_NOT_APPLICABLE
+ if reason != self._last_reason:
+ self._last_reason = reason
self._last_written_at = now_monotonic
- self._log.record(EVENT_VERDICT_CHANGE, **_snapshot(verdict, state, rules))
+ self._log.record(
+ EVENT_VERDICT_CHANGE, **_snapshot(qualifying, state, rules)
+ )
return
- if verdict.state == STATE_NOT_APPLICABLE:
+ if reason == STATE_NOT_APPLICABLE:
return
# The change branch above always fires on the first observation and
# sets both fields together, so by here this is never None.
@@ -199,11 +195,11 @@ class TickJournal:
return
self._last_written_at = now_monotonic
- self._log.record(EVENT_HEARTBEAT, **_snapshot(verdict, state, rules))
+ self._log.record(EVENT_HEARTBEAT, **_snapshot(qualifying, state, rules))
def _snapshot(
- verdict: EngagementVerdict, state: PlaytimeState, rules: PlaytimeRules
+ qualifying: set[int], state: PlaytimeState, rules: PlaytimeRules
) -> dict[str, object]:
"""Flatten a tick into the fields every record carries.
@@ -211,7 +207,7 @@ def _snapshot(
after the last game exited could not be attributed without them.
Args:
- verdict: This tick's verdict.
+ qualifying: PIDs that qualified this tick.
state: Accounting state after this tick.
rules: Policy for this tick.
@@ -219,15 +215,8 @@ def _snapshot(
The record body.
"""
return {
- "state": verdict.state,
- "reason": verdict.reason,
- "causes": list(verdict.causes),
- "idle_seconds": verdict.idle_seconds,
- "controller_idle_seconds": verdict.controller_idle_seconds,
- "screen_held": verdict.screen_held,
- "holder_pid": verdict.holder_pid,
- "focus_pid": verdict.focus_pid,
- "qualifying": list(verdict.qualifying),
+ "state": STATE_ENGAGED if qualifying else STATE_NOT_APPLICABLE,
+ "qualifying": sorted(qualifying),
"day_key": state.day_key,
"billed_seconds": round(state.seconds, 3),
"remaining_seconds": round(rules.budget_seconds - state.seconds, 3),
diff --git a/steam_backlog_enforcer/_playtime_procs.py b/steam_backlog_enforcer/_playtime_procs.py
index d7553a5..60ffbc9 100644
--- a/steam_backlog_enforcer/_playtime_procs.py
+++ b/steam_backlog_enforcer/_playtime_procs.py
@@ -12,11 +12,6 @@ from pathlib import Path
from typing import TYPE_CHECKING
from steam_backlog_enforcer._counted_procs import key_by_name, load_counted_processes
-from steam_backlog_enforcer._playtime_kill import (
- _INIT_PID,
- _MAX_PROCESS_TREE_DEPTH,
- _read_ppid,
-)
from steam_backlog_enforcer._total_block_launchers import LAUNCHER_PROCESS_NAMES
from steam_backlog_enforcer.enforcer import (
get_pids_by_process_names,
@@ -177,38 +172,19 @@ def qualifying_pids(rules: PlaytimeRules) -> dict[int, str]:
return found
-def attributed_key(qualifying: dict[int, str], focus_pid: int | None) -> str:
+def attributed_key(qualifying: dict[int, str]) -> str:
"""Return the single attribution key this tick should be credited to.
- The focused window decides it, walking ancestry the same way
- ``_engagement_probes.focus_qualifies`` does — a Proton game's window belongs
- to a child of the process carrying ``SteamAppId``.
-
- Falling back to "the only game running" keeps attribution working when the
- focus probe is unavailable (no X, or a toolkit that omits ``_NET_WM_PID``).
- With two games running and no focus signal there is no honest answer, so it
- returns ``""``: the tick still bills, and the gap shows up as Unattributed
- rather than being charged to a guess.
+ With exactly one game qualifying, it gets the credit. With two or more
+ running at once there is no honest way to say which one earned the tick,
+ so this returns ``""``: the tick still bills, and the gap shows up as
+ Unattributed rather than being charged to a guess.
Args:
qualifying: Mapping of qualifying PID to attribution key.
- focus_pid: PID owning the focused window, or ``None``.
Returns:
The attribution key, or ``""`` if none can be determined.
"""
- if focus_pid is not None:
- pid = focus_pid
- for _ in range(_MAX_PROCESS_TREE_DEPTH):
- key = qualifying.get(pid)
- if key is not None:
- return key
- if pid <= _INIT_PID:
- break
- parent = _read_ppid(pid)
- if parent is None:
- break
- pid = parent
-
distinct = set(qualifying.values())
return distinct.pop() if len(distinct) == 1 else ""
diff --git a/steam_backlog_enforcer/_playtime_session.py b/steam_backlog_enforcer/_playtime_session.py
index e4dea7b..f271961 100644
--- a/steam_backlog_enforcer/_playtime_session.py
+++ b/steam_backlog_enforcer/_playtime_session.py
@@ -1,9 +1,7 @@
"""The cross-tick state the daily budget carries, and how it is built.
-Two things cannot be recomputed from scratch each tick. The engagement backdate
-must recognise an engaged-to-paused *edge*, so it needs the previous verdict;
-and the audit journal only writes on change, so it needs the previous record.
-Both live on a session that the enforce loop creates once and threads through,
+The audit journal only writes on change, so it needs the previous record. That
+lives on a session that the enforce loop creates once and threads through,
rather than in module globals.
The session's fields are typed by :class:`Protocol` so a test can supply an
@@ -17,8 +15,6 @@ from __future__ import annotations
from dataclasses import dataclass
from typing import TYPE_CHECKING, Protocol
-from steam_backlog_enforcer._desktop_env import desktop_uid, resolve_desktop_user
-from steam_backlog_enforcer._playtime_engagement import EngagementTracker
from steam_backlog_enforcer._playtime_history import HistoryWriter
from steam_backlog_enforcer._playtime_log import (
BudgetLog,
@@ -27,38 +23,15 @@ from steam_backlog_enforcer._playtime_log import (
)
if TYPE_CHECKING:
- from steam_backlog_enforcer._engagement_types import EngagementVerdict
from steam_backlog_enforcer._playtime_state import PlaytimeRules, PlaytimeState
-class EngagementSource(Protocol):
- """What the budget tick needs from an engagement tracker."""
-
- def assess(
- self,
- rules: PlaytimeRules,
- *,
- qualifying: set[int],
- now_monotonic: float,
- ) -> EngagementVerdict:
- """Judge whether this tick counts against the budget."""
-
- def backdate(
- self,
- state: PlaytimeState,
- verdict: EngagementVerdict,
- *,
- rules: PlaytimeRules,
- ) -> PlaytimeState:
- """Refund the idle grace period on an engaged-to-idle edge."""
-
-
class TickRecorder(Protocol):
"""What the budget tick needs from the audit journal."""
def observe(
self,
- verdict: EngagementVerdict,
+ qualifying: set[int],
state: PlaytimeState,
*,
rules: PlaytimeRules,
@@ -76,9 +49,8 @@ class HistoryRecorder(Protocol):
@dataclass(frozen=True)
class PlaytimeSession:
- """Per-daemon engagement and logging state."""
+ """Per-daemon logging state."""
- tracker: EngagementSource
journal: TickRecorder
history: HistoryRecorder
@@ -92,11 +64,9 @@ def new_session(*, demo: bool = False) -> PlaytimeSession:
audit trail.
Returns:
- A session bound to the desktop user's X display and runtime dir.
+ A session for this daemon run.
"""
- uid = desktop_uid(resolve_desktop_user())
return PlaytimeSession(
- tracker=EngagementTracker(uid=uid),
journal=TickJournal(BudgetLog(path=budget_log_path(demo=demo))),
history=HistoryWriter(),
)
diff --git a/steam_backlog_enforcer/_playtime_state.py b/steam_backlog_enforcer/_playtime_state.py
index bd63e5d..a5b0730 100644
--- a/steam_backlog_enforcer/_playtime_state.py
+++ b/steam_backlog_enforcer/_playtime_state.py
@@ -118,9 +118,6 @@ class PlaytimeRules:
count_launchers: bool
enforcement: bool
demo: bool
- engagement_gate: bool = True
- idle_grace_seconds: float = 300.0
- require_game_focus: bool = True
# What earned today's budget, carried here rather than resolved a second
# time: _budget_view reads the breakdown off these fields, so there stays
# exactly one resolution site.
@@ -157,9 +154,6 @@ def rules_for(config: Config, *, demo: bool) -> PlaytimeRules:
count_launchers=config.count_launcher_processes,
enforcement=config.playtime_enforcement,
demo=demo,
- engagement_gate=config.engagement_gate,
- idle_grace_seconds=float(config.idle_grace_seconds),
- require_game_focus=config.require_game_focus,
base_seconds=_DEMO_BUDGET_SECONDS
if resolved is None
else resolved.base_seconds,
diff --git a/steam_backlog_enforcer/_screen_hold.py b/steam_backlog_enforcer/_screen_hold.py
deleted file mode 100644
index 6533e04..0000000
--- a/steam_backlog_enforcer/_screen_hold.py
+++ /dev/null
@@ -1,124 +0,0 @@
-"""Detecting that a gatelock guard currently owns the screen.
-
-The screen lockers (``screen_locker``, ``leetcode_guard``) coordinate through a
-single advisory ``flock`` on ``$XDG_RUNTIME_DIR/gatelock/holder.lock``. The file's
-*contents* cannot answer "is it held right now" — a stale record left by a dead
-process is byte-identical to a live one — and gatelock's own
-``read_claim_if_held`` answers the question by *taking* the lock.
-
-The enforcer must not do that. Taking the lock every three seconds, even for
-microseconds, would race a guard trying to claim the screen. ``/proc/locks``
-reports the same fact by observation, so this reads that instead and never
-touches the file.
-
-Line format is ``idx: FLOCK ADVISORY WRITE ``,
-with major and minor in hex. Lines containing ``->`` describe processes *waiting*
-for a lock, not holding one, and are skipped.
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-import os
-from pathlib import Path
-import re
-from typing import Final
-
-_PROC_LOCKS: Final = Path("/proc/locks")
-_HOLDER_RELATIVE: Final = Path("gatelock/holder.lock")
-
-# `maj:min:inode`, major and minor hex, inode decimal.
-_DEVICE_FIELD: Final = re.compile(r"^[0-9a-f]+:[0-9a-f]+:\d+$")
-
-_WAITER_MARKER: Final = "->"
-_PID_FIELD_INDEX: Final = 4
-
-
-class ScreenHoldError(RuntimeError):
- """Whether the screen is held could not be determined."""
-
-
-@dataclass(frozen=True)
-class ScreenHold:
- """Whether a guard owns the screen, and which process does."""
-
- held: bool
- holder_pid: int | None = None
-
-
-def holder_lock_path(uid: int) -> Path:
- """Return the gatelock holder-lock path for *uid*.
-
- Args:
- uid: Owner of the desktop session.
-
- Returns:
- Path to ``holder.lock``.
- """
- return Path(f"/run/user/{uid}") / _HOLDER_RELATIVE
-
-
-def screen_hold(path: Path) -> ScreenHold:
- """Report whether *path*'s advisory lock is currently held.
-
- Args:
- path: The gatelock holder-lock file.
-
- Returns:
- The hold state, with the holding PID when there is one.
-
- Raises:
- ScreenHoldError: If ``/proc/locks`` cannot be read. A missing *path* is
- not an error — it means no guard has ever run this boot.
- """
- try:
- stat = path.stat()
- except OSError:
- return ScreenHold(held=False)
-
- target = f"{os.major(stat.st_dev):02x}:{os.minor(stat.st_dev):02x}:{stat.st_ino}"
-
- try:
- raw = _PROC_LOCKS.read_text(encoding="utf-8")
- except OSError as exc:
- msg = f"cannot read {_PROC_LOCKS}: {exc}"
- raise ScreenHoldError(msg) from exc
-
- return _find_holder(raw, target)
-
-
-def _find_holder(raw: str, target: str) -> ScreenHold:
- """Scan ``/proc/locks`` text for a live lock on *target*.
-
- Args:
- raw: Contents of ``/proc/locks``.
- target: ``maj:min:inode`` string to match.
-
- Returns:
- The hold state.
- """
- for line in raw.splitlines():
- fields = line.split()
- if _WAITER_MARKER in fields:
- continue
- if not any(field == target for field in fields if _DEVICE_FIELD.match(field)):
- continue
- return ScreenHold(held=True, holder_pid=_pid_of(fields))
- return ScreenHold(held=False)
-
-
-def _pid_of(fields: list[str]) -> int | None:
- """Return the PID column of a ``/proc/locks`` row.
-
- Args:
- fields: Whitespace-split row.
-
- Returns:
- The PID, or ``None`` if the row is shaped unexpectedly.
- """
- if len(fields) <= _PID_FIELD_INDEX:
- return None
- try:
- return int(fields[_PID_FIELD_INDEX])
- except ValueError:
- return None
diff --git a/steam_backlog_enforcer/_x_focus.py b/steam_backlog_enforcer/_x_focus.py
deleted file mode 100644
index f02db6e..0000000
--- a/steam_backlog_enforcer/_x_focus.py
+++ /dev/null
@@ -1,176 +0,0 @@
-"""Resolving which process owns the focused X window.
-
-``_NET_WM_PID`` is the obvious answer and the one every window-manager guide
-names, but it is a *convention* toolkits opt into, not a guarantee. Measured on
-this machine: Aseprite's window carries no ``_NET_WM_PID`` at all. Treating that
-as "cannot tell" and billing the tick would make the focus criterion useless for
-every such application — including, plausibly, games.
-
-So the absent property falls through to the X-Resource extension, which asks the
-*server* which client owns the window rather than trusting the client to have
-announced itself. Verified against the same Aseprite window: ``XResQueryClientIds``
-returned the correct PID where ``_NET_WM_PID`` returned nothing.
-"""
-
-from __future__ import annotations
-
-import ctypes
-from typing import Final
-
-from steam_backlog_enforcer._x_probe import Conn, XProbeError, root_window
-
-# XGetWindowProperty's `req_type`: accept whatever type the property carries.
-_ANY_PROPERTY_TYPE: Final = 0
-_SUCCESS: Final = 0
-
-# XInternAtom's `only_if_exists`: never create an atom just by asking for it.
-# An int, not a bool: it is a C ``Bool`` argument, not a Python flag.
-_ONLY_IF_EXISTS: Final = 1
-
-# XRes client-id spec masks, from .
-_XRES_PID_MASK: Final = 1 << 1
-_XRES_PID_BYTES: Final = 4
-
-
-class _XResSpec(ctypes.Structure):
- """Mirror of libXRes's ``XResClientIdSpec``."""
-
- _fields_ = (("client", ctypes.c_ulong), ("mask", ctypes.c_uint))
-
-
-class _XResValue(ctypes.Structure):
- """Mirror of libXRes's ``XResClientIdValue``."""
-
- _fields_ = (
- ("spec", _XResSpec),
- ("length", ctypes.c_long),
- ("value", ctypes.c_void_p),
- )
-
-
-def focused_pid(conn: Conn) -> int | None:
- """Return the PID owning the focused window.
-
- Args:
- conn: Live connection.
-
- Returns:
- The PID, or ``None`` when nothing is focused — a real answer, not a
- failure.
-
- Raises:
- XProbeError: If a window is focused but cannot be attributed to a
- process, which the caller must treat as "cannot tell" and bill.
- """
- active = read_cardinal(conn, root_window(conn), b"_NET_ACTIVE_WINDOW")
- if not active:
- return None
-
- declared = read_cardinal(conn, active, b"_NET_WM_PID")
- if declared is not None:
- return declared
-
- resolved = _xres_pid(conn, active)
- if resolved is None:
- msg = f"window {active:#x} has no _NET_WM_PID and XRes could not name it"
- raise XProbeError(msg)
- return resolved
-
-
-def _xres_pid(conn: Conn, window: int) -> int | None:
- """Ask the X server which process owns *window*.
-
- Args:
- conn: Live connection.
- window: Window to attribute.
-
- Returns:
- The owning PID, or ``None`` if XRes is unavailable or has no answer.
- """
- if conn.xres is None:
- return None
-
- spec = _XResSpec(client=window, mask=_XRES_PID_MASK)
- count = ctypes.c_long()
- values = ctypes.POINTER(_XResValue)()
-
- status = conn.xres.XResQueryClientIds(
- conn.display,
- ctypes.c_long(1),
- ctypes.byref(spec),
- ctypes.byref(count),
- ctypes.byref(values),
- )
- if status != _SUCCESS or not values:
- return None
-
- try:
- return _first_pid(values, count.value)
- finally:
- conn.xres.XResClientIdsDestroy(count, values)
-
-
-def _first_pid(values: ctypes._Pointer[_XResValue], count: int) -> int | None:
- """Return the first PID among *count* XRes client-id values.
-
- Args:
- values: Array returned by ``XResQueryClientIds``.
- count: Number of entries in *values*.
-
- Returns:
- The PID, or ``None`` if no entry carries one.
- """
- for index in range(count):
- entry = values[index]
- if entry.spec.mask != _XRES_PID_MASK or entry.length < _XRES_PID_BYTES:
- continue
- if not entry.value:
- continue
- return int(ctypes.cast(entry.value, ctypes.POINTER(ctypes.c_uint32))[0])
- return None
-
-
-def read_cardinal(conn: Conn, window: int, name: bytes) -> int | None:
- """Read the first 32-bit value of window property *name*.
-
- Args:
- conn: Live connection.
- window: Window to query.
- name: Property name, e.g. ``b"_NET_WM_PID"``.
-
- Returns:
- The value, or ``None`` if the property is absent or empty.
- """
- conn.x11.XInternAtom.restype = ctypes.c_ulong
- atom = conn.x11.XInternAtom(conn.display, name, _ONLY_IF_EXISTS)
- if not atom:
- return None
-
- actual_type = ctypes.c_ulong()
- actual_format = ctypes.c_int()
- nitems = ctypes.c_ulong()
- bytes_after = ctypes.c_ulong()
- prop = ctypes.POINTER(ctypes.c_ulong)()
-
- status = conn.x11.XGetWindowProperty(
- conn.display,
- ctypes.c_ulong(window),
- ctypes.c_ulong(atom),
- ctypes.c_long(0),
- ctypes.c_long(1),
- ctypes.c_int(0),
- ctypes.c_ulong(_ANY_PROPERTY_TYPE),
- ctypes.byref(actual_type),
- ctypes.byref(actual_format),
- ctypes.byref(nitems),
- ctypes.byref(bytes_after),
- ctypes.byref(prop),
- )
- if status != _SUCCESS or not prop:
- return None
- try:
- if nitems.value == 0:
- return None
- return int(prop[0])
- finally:
- conn.x11.XFree(prop)
diff --git a/steam_backlog_enforcer/_x_probe.py b/steam_backlog_enforcer/_x_probe.py
deleted file mode 100644
index 05b89c8..0000000
--- a/steam_backlog_enforcer/_x_probe.py
+++ /dev/null
@@ -1,185 +0,0 @@
-"""An X11 connection for reading input-idle time, without forking.
-
-The enforce loop ticks every three seconds, so shelling out to ``xprintidle``
-would cost roughly twenty forks a minute for a number the X server hands over
-directly. This talks to libX11 and libXss through ``ctypes`` over one cached
-connection instead. Focused-window resolution lives in :mod:`_x_focus`.
-
-The daemon runs as root with ``DISPLAY=:0`` and ``HOME=/home/kuhy`` set by its
-unit file, which is what lets it authenticate against the user's session.
-
-Two details are load-bearing:
-
-**A no-op X error handler is installed.** Xlib's default handler calls
-``exit(1)``. Asking about a window that vanished mid-query is an ordinary race,
-not a fatal condition, and the enforcer must not die of it.
-
-**Every failure raises :class:`XProbeError`.** The caller bills the tick when a
-probe cannot answer, so returning a bland ``None`` would be indistinguishable
-from a real "not idle" and would quietly become free gaming.
-"""
-
-from __future__ import annotations
-
-import ctypes
-from dataclasses import dataclass
-from typing import Final
-
-_MILLISECONDS_PER_SECOND: Final = 1000.0
-
-
-class XProbeError(RuntimeError):
- """The X server could not be reached or did not answer."""
-
-
-class _ScreenSaverInfo(ctypes.Structure):
- """Mirror of libXss's ``XScreenSaverInfo``."""
-
- _fields_ = (
- ("window", ctypes.c_ulong),
- ("state", ctypes.c_int),
- ("kind", ctypes.c_int),
- ("til_or_since", ctypes.c_ulong),
- ("idle", ctypes.c_ulong),
- ("event_mask", ctypes.c_ulong),
- )
-
-
-@dataclass(frozen=True)
-class Conn:
- """An open display and the libraries it was opened with.
-
- ``xres`` is optional: the X-Resource extension is the fallback for windows
- that advertise no ``_NET_WM_PID``, and a server without it simply means
- those windows cannot be attributed.
- """
-
- display: ctypes.c_void_p
- x11: ctypes.CDLL
- xss: ctypes.CDLL
- xres: ctypes.CDLL | None
-
-
-_ERROR_HANDLER = ctypes.CFUNCTYPE(ctypes.c_int, ctypes.c_void_p, ctypes.c_void_p)
-
-
-def _ignore_x_error(_display: ctypes.c_void_p, _event: ctypes.c_void_p) -> int:
- """Swallow an X protocol error instead of letting Xlib call ``exit``."""
- return 0
-
-
-def load_libraries() -> tuple[ctypes.CDLL, ctypes.CDLL, ctypes.CDLL | None]:
- """Load libX11, libXss and — if present — libXRes.
-
- Returns:
- The ``(x11, xss, xres)`` handles; ``xres`` is ``None`` when absent.
-
- Raises:
- XProbeError: If libX11 or libXss is missing.
- """
- try:
- x11 = ctypes.CDLL("libX11.so.6")
- xss = ctypes.CDLL("libXss.so.1")
- except OSError as exc:
- msg = f"X client libraries unavailable: {exc}"
- raise XProbeError(msg) from exc
- try:
- xres: ctypes.CDLL | None = ctypes.CDLL("libXRes.so.1")
- except OSError:
- xres = None
- return x11, xss, xres
-
-
-Libraries = tuple[ctypes.CDLL, ctypes.CDLL, ctypes.CDLL | None]
-
-
-class XProbe:
- """A cached X connection answering idle-time queries."""
-
- def __init__(self, *, libraries: Libraries | None = None) -> None:
- """Store the library handles; the connection is opened lazily.
-
- Args:
- libraries: Pre-loaded ``(x11, xss, xres)`` handles, for tests.
- """
- self._libraries = libraries
- self._conn: Conn | None = None
- # Xlib keeps only a borrowed pointer, so the trampoline must outlive it.
- self._handler = _ERROR_HANDLER(_ignore_x_error)
-
- def connect(self) -> Conn:
- """Return the open connection, opening it on first use.
-
- Returns:
- The live connection.
-
- Raises:
- XProbeError: If the display cannot be opened.
- """
- if self._conn is not None:
- return self._conn
-
- if self._libraries is None:
- self._libraries = load_libraries()
- x11, xss, xres = self._libraries
-
- x11.XSetErrorHandler(self._handler)
- x11.XOpenDisplay.restype = ctypes.c_void_p
- display = x11.XOpenDisplay(None)
- if not display:
- msg = "XOpenDisplay returned NULL; no reachable X session"
- raise XProbeError(msg)
-
- self._conn = Conn(display=ctypes.c_void_p(display), x11=x11, xss=xss, xres=xres)
- return self._conn
-
- def close(self) -> None:
- """Drop the connection so the next query reconnects."""
- if self._conn is not None:
- self._conn.x11.XCloseDisplay(self._conn.display)
- self._conn = None
-
- def idle_seconds(self) -> float:
- """Return seconds since the last keyboard or pointer input.
-
- Note that a game controller does **not** reset this counter unless it
- is presented to X as a keyboard or pointer, which is why the caller
- drops the idle criterion while a controller is connected.
-
- Returns:
- The idle time in seconds.
-
- Raises:
- XProbeError: If the query fails.
- """
- conn = self.connect()
-
- conn.xss.XScreenSaverAllocInfo.restype = ctypes.POINTER(_ScreenSaverInfo)
- info = conn.xss.XScreenSaverAllocInfo()
- if not info:
- msg = "XScreenSaverAllocInfo returned NULL"
- raise XProbeError(msg)
-
- try:
- queried = conn.xss.XScreenSaverQueryInfo(
- conn.display, ctypes.c_ulong(root_window(conn)), info
- )
- if not queried:
- msg = "XScreenSaverQueryInfo failed; MIT-SCREEN-SAVER missing?"
- raise XProbeError(msg)
- return float(info.contents.idle) / _MILLISECONDS_PER_SECOND
- finally:
- conn.x11.XFree(info)
-
-
-def root_window(conn: Conn) -> int:
- """Return the default root window id.
-
- Args:
- conn: Live connection.
-
- Returns:
- The root window id.
- """
- conn.x11.XDefaultRootWindow.restype = ctypes.c_ulong
- return int(conn.x11.XDefaultRootWindow(conn.display))
diff --git a/steam_backlog_enforcer/config.py b/steam_backlog_enforcer/config.py
index 71cd941..4587359 100644
--- a/steam_backlog_enforcer/config.py
+++ b/steam_backlog_enforcer/config.py
@@ -119,14 +119,6 @@ class Config:
Disabling stops the cutoff but never strands a live block — the release
path runs regardless, so "disabled" cannot come to mean "blocked forever".
"""
- # Engagement gating: without it a resident game process bills the budget
- # while the screen is locked. See :mod:`_playtime_engagement`.
- engagement_gate: bool = True
- """Whether a tick must show active engagement before it bills."""
- idle_grace_seconds: int = 300
- """Input silence before billing stops; controller input counts as input."""
- require_game_focus: bool = True
- """Whether the focused window must belong to the game for a tick to bill."""
def save(self) -> None:
"""Persist config to disk."""
diff --git a/steam_backlog_enforcer/tests/_fake_session.py b/steam_backlog_enforcer/tests/_fake_session.py
index 6ba9611..da15a16 100644
--- a/steam_backlog_enforcer/tests/_fake_session.py
+++ b/steam_backlog_enforcer/tests/_fake_session.py
@@ -1,9 +1,8 @@
-"""A :class:`PlaytimeSession` stub for tests that are not about engagement.
+"""A :class:`PlaytimeSession` stub for tests that are not about the log.
-Most budget tests predate the engagement gate and care only about accounting,
-warnings and the cutoff. They get a session that always says "engaged", which
-reproduces the pre-gate behaviour exactly, so those tests keep asserting what
-they were written to assert.
+Most budget tests care only about accounting, warnings and the cutoff, not
+about what the audit journal records. They get a session with an in-memory
+journal and history so nothing touches the log file or disk.
Deliberately hand-written rather than ``MagicMock``: a mock satisfies every
attribute lookup, including ones a later refactor renamed, so a stub that must
@@ -14,101 +13,37 @@ from __future__ import annotations
from typing import TYPE_CHECKING
-from steam_backlog_enforcer._engagement_types import (
- STATE_ENGAGED,
- STATE_PAUSED,
- EngagementVerdict,
-)
from steam_backlog_enforcer._playtime_session import PlaytimeSession
if TYPE_CHECKING:
from steam_backlog_enforcer._playtime_state import PlaytimeRules, PlaytimeState
-class StubTracker:
- """An engagement tracker with a fixed answer and no probes."""
-
- def __init__(self, *, engaged: bool = True) -> None:
- """Record the answer this tracker always gives.
-
- Args:
- engaged: Whether every tick should count.
- """
- self.engaged = engaged
- self.verdicts: list[EngagementVerdict] = []
-
- def assess(
- self,
- rules: PlaytimeRules,
- *,
- qualifying: set[int],
- now_monotonic: float,
- ) -> EngagementVerdict:
- """Return the fixed verdict.
-
- Args:
- rules: Ignored.
- qualifying: PIDs recorded on the verdict.
- now_monotonic: Ignored.
-
- Returns:
- The verdict.
- """
- del rules, now_monotonic
- verdict = EngagementVerdict(
- state=STATE_ENGAGED if self.engaged else STATE_PAUSED,
- causes=() if self.engaged else ("focus",),
- qualifying=tuple(sorted(qualifying)),
- )
- self.verdicts.append(verdict)
- return verdict
-
- def backdate(
- self,
- state: PlaytimeState,
- verdict: EngagementVerdict,
- *,
- rules: PlaytimeRules,
- ) -> PlaytimeState:
- """Return *state* untouched.
-
- Args:
- state: Accounting state.
- verdict: Ignored.
- rules: Ignored.
-
- Returns:
- The unchanged state.
- """
- del verdict, rules
- return state
-
-
class StubJournal:
"""A journal that keeps records in memory instead of on disk."""
def __init__(self) -> None:
"""Start with nothing recorded."""
- self.observed: list[EngagementVerdict] = []
+ self.observed: list[set[int]] = []
def observe(
self,
- verdict: EngagementVerdict,
+ qualifying: set[int],
state: PlaytimeState,
*,
rules: PlaytimeRules,
now_monotonic: float,
) -> None:
- """Remember *verdict*.
+ """Remember *qualifying*.
Args:
- verdict: This tick's verdict.
+ qualifying: This tick's qualifying PIDs.
state: Ignored.
rules: Ignored.
now_monotonic: Ignored.
"""
del state, rules, now_monotonic
- self.observed.append(verdict)
+ self.observed.append(qualifying)
class StubHistory:
@@ -128,17 +63,13 @@ class StubHistory:
self.recorded.append((state.day_key, state.seconds))
-def fake_session(*, engaged: bool = True) -> PlaytimeSession:
- """Build a session that never touches X, /proc/locks or the log file.
-
- Args:
- engaged: Whether every tick should count against the budget.
+def fake_session() -> PlaytimeSession:
+ """Build a session that never touches the log file or disk.
Returns:
The session.
"""
return PlaytimeSession(
- tracker=StubTracker(engaged=engaged),
journal=StubJournal(),
history=StubHistory(),
)
diff --git a/steam_backlog_enforcer/tests/test_budget_log_tail.py b/steam_backlog_enforcer/tests/test_budget_log_tail.py
index 91f13e9..116f205 100644
--- a/steam_backlog_enforcer/tests/test_budget_log_tail.py
+++ b/steam_backlog_enforcer/tests/test_budget_log_tail.py
@@ -20,10 +20,6 @@ def _record(**over: object) -> str:
"timestamp": "2026-08-28T20:42:19+02:00",
"event": "verdict_change",
"state": "engaged",
- "reason": "engaged",
- "causes": [],
- "idle_seconds": 1.5,
- "screen_held": False,
"qualifying": [],
"day_key": "2026-08-28",
"billed_seconds": 100.0,
@@ -41,13 +37,10 @@ class TestLastVerdict:
assert view.state == ""
def test_reads_the_last_record(self) -> None:
- _write([_record(state="paused"), _record(state="engaged", reason="ok")])
+ _write([_record(state="not_applicable"), _record(state="engaged")])
view = last_verdict(demo=False)
assert view.available is True
assert view.state == "engaged"
- assert view.reason == "ok"
- assert view.idle_seconds == 1.5
- assert view.screen_held is False
assert view.observed_at.startswith("2026-08-28")
def test_skips_a_malformed_last_line(self) -> None:
@@ -93,15 +86,8 @@ class TestLastVerdict:
view = last_verdict(demo=False)
assert view.available is True
assert view.state == ""
- assert view.causes == []
- assert view.idle_seconds is None
- assert view.screen_held is None
assert view.observed_at == ""
- def test_non_list_causes_are_dropped(self) -> None:
- _write([_record(causes="focus")])
- assert last_verdict(demo=False).causes == []
-
class TestLiveGames:
"""Tests for resolving qualifying PIDs to live processes."""
diff --git a/steam_backlog_enforcer/tests/test_budget_view.py b/steam_backlog_enforcer/tests/test_budget_view.py
index bc0d6e0..2422c78 100644
--- a/steam_backlog_enforcer/tests/test_budget_view.py
+++ b/steam_backlog_enforcer/tests/test_budget_view.py
@@ -177,10 +177,6 @@ class TestBuildBudgetSnapshot:
session = SessionView(
observed_at="2026-08-28T20:42:19+02:00",
state="engaged",
- reason="engaged",
- causes=["focus"],
- idle_seconds=2.0,
- screen_held=False,
games=[RunningGame(pid=7, name="hollow_knight")],
available=True,
)
@@ -229,9 +225,6 @@ class TestBuildBudgetSnapshot:
"budget_seconds",
"enforcement",
"counts_launchers",
- "engagement_gate",
- "idle_grace_seconds",
- "require_game_focus",
"warn_at",
"demo",
"masked_launchers",
diff --git a/steam_backlog_enforcer/tests/test_controller_input.py b/steam_backlog_enforcer/tests/test_controller_input.py
deleted file mode 100644
index 86bc347..0000000
--- a/steam_backlog_enforcer/tests/test_controller_input.py
+++ /dev/null
@@ -1,137 +0,0 @@
-"""Tests for noticing real gamepad input.
-
-The distinction that matters: this machine exposes an *ASRock LED Controller*
-as ``/dev/input/js0``, so mere presence of a js device must not register as
-play — only actual, non-synthetic events do.
-"""
-
-from __future__ import annotations
-
-import errno
-import os
-from typing import TYPE_CHECKING
-from unittest.mock import patch
-
-from steam_backlog_enforcer._controller_input import ControllerActivity
-
-if TYPE_CHECKING:
- from pathlib import Path
-
-CI = "steam_backlog_enforcer._controller_input"
-
-
-def _event(*, init: bool) -> bytes:
- """Build one 8-byte ``struct js_event``; byte 6 is the type field."""
- return bytes([0, 0, 0, 0, 0, 0, 0x81 if init else 0x01, 0])
-
-
-class TestSyncDevices:
- def test_missing_directory_is_not_an_error(self, tmp_path: Path) -> None:
- activity = ControllerActivity(device_dir=tmp_path / "absent")
- activity.poll(now=1.0)
- assert activity.seconds_since_activity(now=1.0) is None
-
- def test_non_js_entries_are_ignored(self, tmp_path: Path) -> None:
- (tmp_path / "event0").write_bytes(_event(init=False))
- activity = ControllerActivity(device_dir=tmp_path)
- activity.poll(now=1.0)
- assert activity.seconds_since_activity(now=1.0) is None
-
- def test_a_vanished_device_is_forgotten(self, tmp_path: Path) -> None:
- node = tmp_path / "js0"
- node.write_bytes(_event(init=False))
- activity = ControllerActivity(device_dir=tmp_path)
- activity.poll(now=1.0)
- node.unlink()
- activity.poll(now=2.0)
- activity.close()
-
- def test_an_unopenable_device_is_skipped(self, tmp_path: Path) -> None:
- node = tmp_path / "js0"
- node.write_bytes(_event(init=False))
- with patch(f"{CI}.os.open", side_effect=OSError("denied")):
- activity = ControllerActivity(device_dir=tmp_path)
- activity.poll(now=1.0)
- assert activity.seconds_since_activity(now=1.0) is None
-
-
-class TestDrain:
- def test_a_real_event_is_activity(self, tmp_path: Path) -> None:
- (tmp_path / "js0").write_bytes(_event(init=False))
- activity = ControllerActivity(device_dir=tmp_path)
- activity.poll(now=10.0)
- assert activity.seconds_since_activity(now=12.5) == 2.5
- activity.close()
-
- def test_the_synthetic_open_burst_is_not_activity(self, tmp_path: Path) -> None:
- # joydev replays current state on open; treating that as a button press
- # would make simply having an LED device look like a gaming session.
- (tmp_path / "js0").write_bytes(_event(init=True) * 3)
- activity = ControllerActivity(device_dir=tmp_path)
- activity.poll(now=10.0)
- assert activity.seconds_since_activity(now=10.0) is None
- activity.close()
-
- def test_a_truncated_record_stops_the_drain(self, tmp_path: Path) -> None:
- (tmp_path / "js0").write_bytes(b"\x00\x00\x00")
- activity = ControllerActivity(device_dir=tmp_path)
- activity.poll(now=10.0)
- assert activity.seconds_since_activity(now=10.0) is None
- activity.close()
-
- def test_the_per_tick_cap_bounds_the_drain(self, tmp_path: Path) -> None:
- (tmp_path / "js0").write_bytes(_event(init=False) * 200)
- activity = ControllerActivity(device_dir=tmp_path)
- activity.poll(now=10.0)
- assert activity.seconds_since_activity(now=10.0) == 0.0
- activity.close()
-
- def test_eagain_leaves_the_device_open(self, tmp_path: Path) -> None:
- # "No events pending" is the normal case on a quiet controller; it must
- # not be mistaken for the device going away.
- (tmp_path / "js0").write_bytes(_event(init=False))
- activity = ControllerActivity(device_dir=tmp_path)
- with patch(f"{CI}.os.read", side_effect=OSError(errno.EAGAIN, "again")):
- activity.poll(now=10.0)
- assert list(activity._fds) == [tmp_path / "js0"]
- assert activity.seconds_since_activity(now=10.0) is None
- activity.close()
-
- def test_an_empty_device_yields_nothing(self, tmp_path: Path) -> None:
- fifo = tmp_path / "js0"
- os.mkfifo(fifo)
- activity = ControllerActivity(device_dir=tmp_path)
- activity.poll(now=10.0)
- assert activity.seconds_since_activity(now=10.0) is None
- activity.close()
-
- def test_a_device_that_stays_is_kept_open_across_ticks(
- self, tmp_path: Path
- ) -> None:
- node = tmp_path / "js0"
- node.write_bytes(_event(init=False))
- activity = ControllerActivity(device_dir=tmp_path)
- activity.poll(now=10.0)
- first = dict(activity._fds)
- activity.poll(now=11.0)
- assert activity._fds == first
- activity.close()
-
- def test_forgetting_an_unknown_device_is_a_no_op(self, tmp_path: Path) -> None:
- activity = ControllerActivity(device_dir=tmp_path)
- activity._forget(tmp_path / "js9")
- assert activity._fds == {}
-
- def test_a_hard_read_error_drops_the_device(self, tmp_path: Path) -> None:
- (tmp_path / "js0").write_bytes(_event(init=False))
- activity = ControllerActivity(device_dir=tmp_path)
- with patch(f"{CI}.os.read", side_effect=OSError(errno.EIO, "gone")):
- activity.poll(now=10.0)
- assert activity.seconds_since_activity(now=10.0) is None
-
- def test_forgetting_survives_an_already_closed_fd(self, tmp_path: Path) -> None:
- (tmp_path / "js0").write_bytes(_event(init=False))
- activity = ControllerActivity(device_dir=tmp_path)
- activity.poll(now=10.0)
- with patch(f"{CI}.os.close", side_effect=OSError("bad fd")):
- activity.close()
diff --git a/steam_backlog_enforcer/tests/test_engagement_probes.py b/steam_backlog_enforcer/tests/test_engagement_probes.py
deleted file mode 100644
index 7645854..0000000
--- a/steam_backlog_enforcer/tests/test_engagement_probes.py
+++ /dev/null
@@ -1,155 +0,0 @@
-"""Tests for turning each engagement signal into a pause cause.
-
-The rule under test everywhere: a probe that *fails* must not pause the tick.
-Failing closed keeps a broken detector from becoming free gaming.
-"""
-
-from __future__ import annotations
-
-from dataclasses import replace
-from pathlib import Path
-from unittest.mock import MagicMock, patch
-
-from steam_backlog_enforcer._engagement_probes import (
- assess_focus,
- assess_idle,
- assess_screen,
- focus_qualifies,
-)
-from steam_backlog_enforcer._engagement_types import CauseTally
-from steam_backlog_enforcer._playtime_state import PlaytimeRules
-from steam_backlog_enforcer._screen_hold import ScreenHold, ScreenHoldError
-from steam_backlog_enforcer._x_probe import XProbeError
-
-EP = "steam_backlog_enforcer._engagement_probes"
-
-RULES = PlaytimeRules(
- budget_seconds=28800.0,
- warn_at=(3600,),
- sigkill_after=30.0,
- count_launchers=True,
- enforcement=True,
- demo=False,
- engagement_gate=True,
- idle_grace_seconds=300.0,
- require_game_focus=True,
-)
-
-
-def _probe(idle: float = 0.0) -> MagicMock:
- probe = MagicMock(name="XProbe")
- probe.idle_seconds.return_value = idle
- return probe
-
-
-class TestAssessScreen:
- def test_a_held_screen_pauses(self) -> None:
- tally = CauseTally()
- held = ScreenHold(held=True, holder_pid=99)
- with patch(f"{EP}.screen_hold", return_value=held):
- assert assess_screen(Path("x"), tally) == (True, 99)
- assert tally.causes == ["screen_held"]
- assert tally.degraded == []
-
- def test_a_free_screen_does_not_pause(self) -> None:
- tally = CauseTally()
- with patch(f"{EP}.screen_hold", return_value=ScreenHold(held=False)):
- assert assess_screen(Path("x"), tally) == (False, None)
- assert tally.causes == []
-
- def test_a_failed_probe_bills_and_is_recorded(self) -> None:
- tally = CauseTally()
- with patch(f"{EP}.screen_hold", side_effect=ScreenHoldError("boom")):
- assert assess_screen(Path("x"), tally) == (None, None)
- assert tally.causes == []
- assert tally.degraded == ["screen_held"]
-
-
-class TestAssessFocus:
- def test_disabled_criterion_reports_nothing(self) -> None:
- tally = CauseTally()
- relaxed = replace(RULES, require_game_focus=False)
- assert assess_focus(_probe(), relaxed, {1}, tally) is None
- assert tally.causes == []
-
- def test_the_game_owning_focus_does_not_pause(self) -> None:
- tally = CauseTally()
- with patch(f"{EP}.focused_pid", return_value=42):
- assert assess_focus(_probe(), RULES, {42}, tally) == 42
- assert tally.causes == []
-
- def test_another_window_owning_focus_pauses(self) -> None:
- tally = CauseTally()
- with patch(f"{EP}.focused_pid", return_value=7):
- assert assess_focus(_probe(), RULES, {42}, tally) == 7
- assert tally.causes == ["focus"]
-
- def test_a_failed_probe_bills_and_drops_the_connection(self) -> None:
- tally = CauseTally()
- probe = _probe()
- with patch(f"{EP}.focused_pid", side_effect=XProbeError("no display")):
- assert assess_focus(probe, RULES, {42}, tally) is None
- assert tally.causes == []
- assert tally.degraded == ["focus"]
- probe.close.assert_called_once()
-
-
-class TestAssessIdle:
- def test_recent_input_does_not_pause(self) -> None:
- tally = CauseTally()
- controller = MagicMock()
- controller.seconds_since_activity.return_value = None
- assert assess_idle(_probe(1.0), controller, RULES, tally, 5.0) == (1.0, None)
- assert tally.causes == []
-
- def test_silence_past_the_grace_pauses(self) -> None:
- tally = CauseTally()
- controller = MagicMock()
- controller.seconds_since_activity.return_value = None
- assess_idle(_probe(400.0), controller, RULES, tally, 5.0)
- assert tally.causes == ["idle"]
-
- def test_recent_controller_input_keeps_the_tick_alive(self) -> None:
- # The X idle counter cannot see a gamepad; without this, a controller
- # session would pause the budget and hand out free gaming.
- tally = CauseTally()
- controller = MagicMock()
- controller.seconds_since_activity.return_value = 2.0
- assert assess_idle(_probe(9999.0), controller, RULES, tally, 5.0) == (2.0, 2.0)
- assert tally.causes == []
-
- def test_a_failed_probe_bills_and_drops_the_connection(self) -> None:
- tally = CauseTally()
- probe = _probe()
- probe.idle_seconds.side_effect = XProbeError("no display")
- controller = MagicMock()
- controller.seconds_since_activity.return_value = 7.0
- assert assess_idle(probe, controller, RULES, tally, 5.0) == (None, 7.0)
- assert tally.causes == []
- assert tally.degraded == ["idle"]
- probe.close.assert_called_once()
-
-
-class TestFocusQualifies:
- def test_nothing_focused_does_not_qualify(self) -> None:
- assert focus_qualifies(None, {1234}) is False
-
- def test_the_process_itself_qualifies(self) -> None:
- assert focus_qualifies(1234, {1234}) is True
-
- def test_a_descendant_window_qualifies(self) -> None:
- # Proton games commonly own their window from a child process.
- with patch(f"{EP}._read_ppid", side_effect=[500, 42]):
- assert focus_qualifies(9000, {42}) is True
-
- def test_reaching_init_does_not_qualify(self) -> None:
- with patch(f"{EP}._read_ppid", return_value=1):
- assert focus_qualifies(9000, {42}) is False
-
- def test_an_unreadable_parent_does_not_qualify(self) -> None:
- with patch(f"{EP}._read_ppid", return_value=None):
- assert focus_qualifies(9000, {42}) is False
-
- def test_a_pathological_chain_terminates(self) -> None:
- with patch(f"{EP}._read_ppid", side_effect=lambda pid: pid + 1):
- assert focus_qualifies(9000, {42}) is False
diff --git a/steam_backlog_enforcer/tests/test_engagement_types.py b/steam_backlog_enforcer/tests/test_engagement_types.py
deleted file mode 100644
index 7b56f42..0000000
--- a/steam_backlog_enforcer/tests/test_engagement_types.py
+++ /dev/null
@@ -1,50 +0,0 @@
-"""Tests for the engagement verdict value object."""
-
-from __future__ import annotations
-
-from steam_backlog_enforcer._engagement_types import (
- CAUSE_FOCUS,
- CAUSE_IDLE,
- STATE_ENGAGED,
- STATE_NOT_APPLICABLE,
- STATE_PAUSED,
- EngagementVerdict,
-)
-
-
-class TestEngaged:
- def test_engaged_state_bills(self) -> None:
- assert EngagementVerdict(state=STATE_ENGAGED).engaged is True
-
- def test_nothing_qualifying_still_bills(self) -> None:
- # Nothing accrues anyway; calling it "paused" would fill the audit log
- # with a pause reason during ordinary desktop use.
- assert EngagementVerdict(state=STATE_NOT_APPLICABLE).engaged is True
-
- def test_paused_state_does_not_bill(self) -> None:
- assert EngagementVerdict(state=STATE_PAUSED).engaged is False
-
-
-class TestReason:
- def test_falls_back_to_the_state_when_there_are_no_causes(self) -> None:
- assert EngagementVerdict(state=STATE_ENGAGED).reason == STATE_ENGAGED
-
- def test_joins_every_cause(self) -> None:
- verdict = EngagementVerdict(
- state=STATE_PAUSED, causes=(CAUSE_IDLE, CAUSE_FOCUS)
- )
- assert verdict.reason == "idle+focus"
-
-
-class TestIdleOnly:
- def test_true_for_a_sole_idle_cause(self) -> None:
- assert EngagementVerdict(state=STATE_PAUSED, causes=(CAUSE_IDLE,)).idle_only()
-
- def test_false_when_something_else_also_paused_the_tick(self) -> None:
- verdict = EngagementVerdict(
- state=STATE_PAUSED, causes=(CAUSE_IDLE, CAUSE_FOCUS)
- )
- assert verdict.idle_only() is False
-
- def test_false_when_engaged(self) -> None:
- assert EngagementVerdict(state=STATE_ENGAGED).idle_only() is False
diff --git a/steam_backlog_enforcer/tests/test_playtime_attribution.py b/steam_backlog_enforcer/tests/test_playtime_attribution.py
index 9d905f6..d449896 100644
--- a/steam_backlog_enforcer/tests/test_playtime_attribution.py
+++ b/steam_backlog_enforcer/tests/test_playtime_attribution.py
@@ -176,37 +176,14 @@ class TestQualifyingPids:
class TestAttributedKey:
"""Deciding which single game a tick belongs to."""
- _PKG = "steam_backlog_enforcer._playtime_procs"
-
- def test_focused_pid_wins(self) -> None:
- assert attributed_key({7: "app:440", 8: "proc:osu"}, 8) == "proc:osu"
-
- def test_walks_up_to_the_owning_process(self) -> None:
- """A Proton game's window belongs to a child of the SteamAppId process."""
- with patch(f"{self._PKG}._read_ppid", side_effect=[900, 7]):
- assert attributed_key({7: "app:440"}, 999) == "app:440"
-
- def test_gives_up_when_the_chain_ends(self) -> None:
- with patch(f"{self._PKG}._read_ppid", return_value=None):
- assert attributed_key({7: "app:440", 8: "app:1"}, 999) == ""
-
- def test_stops_at_init(self) -> None:
- with patch(f"{self._PKG}._read_ppid", return_value=1):
- assert attributed_key({7: "app:440", 8: "app:1"}, 999) == ""
-
- def test_stops_after_the_depth_limit(self) -> None:
- """A ppid cycle must not spin the enforce loop."""
- with patch(f"{self._PKG}._read_ppid", return_value=500):
- assert attributed_key({7: "app:440", 8: "app:1"}, 500) == ""
-
def test_falls_back_to_the_only_game_running(self) -> None:
- """Covers no X, or a toolkit that omits _NET_WM_PID."""
- assert attributed_key({7: "app:440", 8: "app:440"}, None) == "app:440"
+ assert attributed_key({7: "app:440", 8: "app:440"}) == "app:440"
- def test_two_games_and_no_focus_is_unattributable(self) -> None:
- # There is no honest answer, so the tick still bills but the gap shows
- # up as Unattributed rather than being charged to a guess.
- assert attributed_key({7: "app:440", 8: "app:1"}, None) == ""
+ def test_two_games_is_unattributable(self) -> None:
+ # There is no honest way to say which one earned the tick, so the
+ # tick still bills but the gap shows up as Unattributed rather than
+ # being charged to a guess.
+ assert attributed_key({7: "app:440", 8: "app:1"}) == ""
def test_nothing_qualifying(self) -> None:
- assert attributed_key({}, None) == ""
+ assert attributed_key({}) == ""
diff --git a/steam_backlog_enforcer/tests/test_playtime_engagement.py b/steam_backlog_enforcer/tests/test_playtime_engagement.py
deleted file mode 100644
index 7a00a04..0000000
--- a/steam_backlog_enforcer/tests/test_playtime_engagement.py
+++ /dev/null
@@ -1,242 +0,0 @@
-"""Tests for the per-tick engagement verdict and the idle backdate.
-
-The backdate is deliberately hard to trigger: it is the only place the budget
-counter ever moves backwards, so every guard around it is tested here.
-"""
-
-from __future__ import annotations
-
-from dataclasses import replace
-from pathlib import Path
-from unittest.mock import MagicMock, patch
-
-from steam_backlog_enforcer._engagement_types import (
- CAUSE_FOCUS,
- CAUSE_IDLE,
- STATE_ENGAGED,
- STATE_NOT_APPLICABLE,
- STATE_PAUSED,
- CauseTally,
- EngagementVerdict,
-)
-from steam_backlog_enforcer._playtime_engagement import EngagementTracker
-from steam_backlog_enforcer._playtime_state import PlaytimeRules, PlaytimeState
-
-PE = "steam_backlog_enforcer._playtime_engagement"
-
-RULES = PlaytimeRules(
- budget_seconds=28800.0,
- warn_at=(3600,),
- sigkill_after=30.0,
- count_launchers=True,
- enforcement=True,
- demo=False,
- engagement_gate=True,
- idle_grace_seconds=300.0,
- require_game_focus=True,
-)
-
-
-def _tracker(**kwargs: object) -> EngagementTracker:
- return EngagementTracker(
- uid=1000,
- probe=MagicMock(name="XProbe"),
- controller=MagicMock(name="ControllerActivity"),
- holder_path=Path("/nonexistent/holder.lock"),
- **kwargs,
- )
-
-
-def _engaged() -> EngagementVerdict:
- return EngagementVerdict(state=STATE_ENGAGED)
-
-
-def _idle_paused() -> EngagementVerdict:
- return EngagementVerdict(state=STATE_PAUSED, causes=(CAUSE_IDLE,))
-
-
-class TestAssess:
- def test_nothing_qualifying_is_not_applicable(self) -> None:
- verdict = _tracker().assess(RULES, qualifying=set(), now_monotonic=1.0)
- assert verdict.state == STATE_NOT_APPLICABLE
- assert verdict.engaged is True
-
- def test_a_disabled_gate_bills_without_probing(self) -> None:
- tracker = _tracker()
- with patch(f"{PE}.assess_screen") as screen:
- verdict = tracker.assess(
- replace(RULES, engagement_gate=False),
- qualifying={7},
- now_monotonic=1.0,
- )
- assert verdict.state == STATE_ENGAGED
- assert verdict.qualifying == (7,)
- screen.assert_not_called()
-
- def test_every_cause_is_recorded_not_just_the_first(self) -> None:
- # The log has to be able to answer "was the screen ALSO locked?", and
- # the backdate must be able to tell an idle-only pause from a compound.
- tracker = _tracker()
- with (
- patch(f"{PE}.assess_screen", side_effect=_add("screen_held", (True, 5))),
- patch(f"{PE}.assess_focus", side_effect=_add_focus("focus", 9)),
- patch(f"{PE}.assess_idle", side_effect=_add_idle("idle", (900.0, None))),
- ):
- verdict = tracker.assess(RULES, qualifying={7}, now_monotonic=1.0)
- assert verdict.state == STATE_PAUSED
- assert set(verdict.causes) == {"screen_held", "focus", "idle"}
- assert verdict.holder_pid == 5
- assert verdict.focus_pid == 9
-
- def test_no_causes_means_engaged(self) -> None:
- tracker = _tracker()
- with (
- patch(f"{PE}.assess_screen", return_value=(False, None)),
- patch(f"{PE}.assess_focus", return_value=7),
- patch(f"{PE}.assess_idle", return_value=(1.0, None)),
- ):
- verdict = tracker.assess(RULES, qualifying={7}, now_monotonic=1.0)
- assert verdict.state == STATE_ENGAGED
-
-
-class TestClose:
- def test_releases_both_resources(self) -> None:
- probe = MagicMock()
- controller = MagicMock()
- tracker = EngagementTracker(
- uid=1000, probe=probe, controller=controller, holder_path=Path("x")
- )
- tracker.close()
- probe.close.assert_called_once()
- controller.close.assert_called_once()
-
-
-class TestBackdate:
- def _state(self, seconds: float = 1000.0) -> PlaytimeState:
- return PlaytimeState(day_key="2026-08-28", seconds=seconds)
-
- def test_refunds_the_grace_on_the_engaged_to_idle_edge(self) -> None:
- tracker = _tracker()
- state = tracker.backdate(self._state(), _engaged(), rules=RULES)
- state = tracker.backdate(state, _idle_paused(), rules=RULES)
- assert state.seconds == 700.0
-
- def test_refunds_only_once_per_walk_away(self) -> None:
- tracker = _tracker()
- state = tracker.backdate(self._state(), _engaged(), rules=RULES)
- state = tracker.backdate(state, _idle_paused(), rules=RULES)
- state = tracker.backdate(state, _idle_paused(), rules=RULES)
- assert state.seconds == 700.0
-
- def test_debits_the_refund_from_the_credited_game(self) -> None:
- """Otherwise the parts drift above the whole on every walk-away.
-
- This edge fires many times a day, so leaving `per_game` untouched would
- make stacked segments overflow their bar within minutes.
- """
- tracker = _tracker()
- state = PlaytimeState(
- day_key="2026-08-28",
- seconds=1000.0,
- per_game={"app:440": 1000.0},
- last_credited_key="app:440",
- )
- state = tracker.backdate(state, _engaged(), rules=RULES)
- state = tracker.backdate(state, _idle_paused(), rules=RULES)
- assert state.seconds == 700.0
- assert state.per_game == {"app:440": 700.0}
- assert sum(state.per_game.values()) <= state.seconds
-
- def test_a_refund_larger_than_the_key_holds_floors_at_zero(self) -> None:
- tracker = _tracker()
- state = PlaytimeState(
- day_key="2026-08-28",
- seconds=1000.0,
- per_game={"app:440": 100.0},
- last_credited_key="app:440",
- )
- state = tracker.backdate(state, _engaged(), rules=RULES)
- state = tracker.backdate(state, _idle_paused(), rules=RULES)
- assert state.per_game == {"app:440": 0.0}
-
- def test_an_unattributed_refund_leaves_the_breakdown_alone(self) -> None:
- """Nothing was credited, so there is nothing to take back."""
- tracker = _tracker()
- state = PlaytimeState(
- day_key="2026-08-28", seconds=1000.0, per_game={"app:440": 100.0}
- )
- state = tracker.backdate(state, _engaged(), rules=RULES)
- state = tracker.backdate(state, _idle_paused(), rules=RULES)
- assert state.per_game == {"app:440": 100.0}
-
- def test_never_refunds_below_zero(self) -> None:
- tracker = _tracker()
- state = tracker.backdate(self._state(seconds=10.0), _engaged(), rules=RULES)
- state = tracker.backdate(state, _idle_paused(), rules=RULES)
- assert state.seconds == 0.0
-
- def test_no_refund_on_the_first_tick_after_a_restart(self) -> None:
- # With no previous verdict there is no edge to recognise, and inventing
- # one would hand out a free refund on every daemon restart.
- tracker = _tracker()
- state = tracker.backdate(self._state(), _idle_paused(), rules=RULES)
- assert state.seconds == 1000.0
-
- def test_no_refund_across_a_day_rollover(self) -> None:
- tracker = _tracker()
- tracker.backdate(self._state(), _engaged(), rules=RULES)
- tomorrow = PlaytimeState(day_key="2026-08-29", seconds=1000.0)
- assert tracker.backdate(tomorrow, _idle_paused(), rules=RULES).seconds == 1000.0
-
- def test_no_refund_when_something_else_also_paused_the_tick(self) -> None:
- tracker = _tracker()
- state = tracker.backdate(self._state(), _engaged(), rules=RULES)
- compound = EngagementVerdict(
- state=STATE_PAUSED, causes=(CAUSE_IDLE, CAUSE_FOCUS)
- )
- assert tracker.backdate(state, compound, rules=RULES).seconds == 1000.0
-
- def test_no_refund_while_still_engaged(self) -> None:
- tracker = _tracker()
- state = tracker.backdate(self._state(), _engaged(), rules=RULES)
- assert tracker.backdate(state, _engaged(), rules=RULES).seconds == 1000.0
-
- def test_reports_the_measured_idle_time(self) -> None:
- tracker = _tracker()
- tracker.backdate(self._state(), _engaged(), rules=RULES)
- verdict = EngagementVerdict(
- state=STATE_PAUSED, causes=(CAUSE_IDLE,), idle_seconds=301.0
- )
- assert tracker.backdate(self._state(), verdict, rules=RULES).seconds == 700.0
-
-
-def _add(cause: str, result: tuple[bool | None, int | None]) -> object:
- def impl(_path: object, tally: CauseTally) -> object:
- tally.causes.append(cause)
- return result
-
- return impl
-
-
-def _add_focus(cause: str, pid: int) -> object:
- def impl(
- _probe: object, _rules: object, _qualifying: object, tally: CauseTally
- ) -> int:
- tally.causes.append(cause)
- return pid
-
- return impl
-
-
-def _add_idle(cause: str, result: tuple[float | None, float | None]) -> object:
- def impl(
- _probe: object,
- _controller: object,
- _rules: object,
- tally: CauseTally,
- _now: float,
- ) -> object:
- tally.causes.append(cause)
- return result
-
- return impl
diff --git a/steam_backlog_enforcer/tests/test_playtime_log.py b/steam_backlog_enforcer/tests/test_playtime_log.py
index e20498a..7700741 100644
--- a/steam_backlog_enforcer/tests/test_playtime_log.py
+++ b/steam_backlog_enforcer/tests/test_playtime_log.py
@@ -14,15 +14,7 @@ from unittest.mock import patch
import pytest
from steam_backlog_enforcer import _playtime_log as log_mod
-from steam_backlog_enforcer._engagement_types import (
- CAUSE_IDLE,
- STATE_ENGAGED,
- STATE_NOT_APPLICABLE,
- STATE_PAUSED,
- EngagementVerdict,
-)
from steam_backlog_enforcer._playtime_log import (
- EVENT_DETECTOR_FAILURE,
EVENT_HEARTBEAT,
EVENT_VERDICT_CHANGE,
BudgetLog,
@@ -142,32 +134,28 @@ class TestTickJournal:
for log in self._logs:
log.close()
- def _observe(
- self, journal: TickJournal, verdict: EngagementVerdict, at: float
- ) -> None:
- journal.observe(verdict, STATE, rules=RULES, now_monotonic=at)
+ def _observe(self, journal: TickJournal, qualifying: set[int], at: float) -> None:
+ journal.observe(qualifying, STATE, rules=RULES, now_monotonic=at)
def test_a_changed_verdict_is_recorded(self, tmp_path: Path) -> None:
journal, target = self._journal(tmp_path)
- self._observe(journal, EngagementVerdict(state=STATE_ENGAGED), 0.0)
+ self._observe(journal, {11}, 0.0)
events = [r["event"] for r in _records(target)]
assert events == [EVENT_VERDICT_CHANGE]
def test_an_unchanged_verdict_is_not_repeated(self, tmp_path: Path) -> None:
journal, target = self._journal(tmp_path, heartbeat=300.0)
- verdict = EngagementVerdict(state=STATE_ENGAGED)
for tick in range(5):
- self._observe(journal, verdict, float(tick) * 3.0)
+ self._observe(journal, {11}, float(tick) * 3.0)
assert len(_records(target)) == 1
def test_a_heartbeat_is_written_once_the_interval_passes(
self, tmp_path: Path
) -> None:
journal, target = self._journal(tmp_path, heartbeat=10.0)
- verdict = EngagementVerdict(state=STATE_ENGAGED)
- self._observe(journal, verdict, 0.0)
- self._observe(journal, verdict, 5.0)
- self._observe(journal, verdict, 50.0)
+ self._observe(journal, {11}, 0.0)
+ self._observe(journal, {11}, 5.0)
+ self._observe(journal, {11}, 50.0)
assert [r["event"] for r in _records(target)] == [
EVENT_VERDICT_CHANGE,
EVENT_HEARTBEAT,
@@ -175,32 +163,16 @@ class TestTickJournal:
def test_ordinary_desktop_use_produces_no_heartbeat(self, tmp_path: Path) -> None:
journal, target = self._journal(tmp_path, heartbeat=0.0)
- verdict = EngagementVerdict(state=STATE_NOT_APPLICABLE)
- self._observe(journal, verdict, 0.0)
- self._observe(journal, verdict, 1000.0)
+ self._observe(journal, set(), 0.0)
+ self._observe(journal, set(), 1000.0)
assert len(_records(target)) == 1
- def test_a_degraded_probe_is_always_recorded(self, tmp_path: Path) -> None:
- journal, target = self._journal(tmp_path)
- verdict = EngagementVerdict(state=STATE_ENGAGED, degraded=("idle",))
- self._observe(journal, verdict, 0.0)
- self._observe(journal, verdict, 3.0)
- events = [r["event"] for r in _records(target)]
- assert events.count(EVENT_DETECTOR_FAILURE) == 2
- assert all(r.get("billed", True) for r in _records(target))
-
def test_the_snapshot_names_the_qualifying_processes(self, tmp_path: Path) -> None:
# Without these, accrual from an orphaned helper process cannot be
# attributed after the fact.
journal, target = self._journal(tmp_path)
- verdict = EngagementVerdict(
- state=STATE_PAUSED,
- causes=(CAUSE_IDLE,),
- idle_seconds=310.0,
- qualifying=(11, 22),
- )
- self._observe(journal, verdict, 0.0)
+ self._observe(journal, {22, 11}, 0.0)
record = _records(target)[0]
assert record["qualifying"] == [11, 22]
- assert record["reason"] == "idle"
+ assert record["state"] == "engaged"
assert record["remaining_seconds"] == 28700.0
diff --git a/steam_backlog_enforcer/tests/test_playtime_session.py b/steam_backlog_enforcer/tests/test_playtime_session.py
index d9cb39a..565cb33 100644
--- a/steam_backlog_enforcer/tests/test_playtime_session.py
+++ b/steam_backlog_enforcer/tests/test_playtime_session.py
@@ -2,45 +2,20 @@
from __future__ import annotations
-from unittest.mock import patch
-
from steam_backlog_enforcer import _playtime_log as log_mod
-from steam_backlog_enforcer._playtime_engagement import EngagementTracker
-from steam_backlog_enforcer._playtime_log import (
- TickJournal,
-)
+from steam_backlog_enforcer._playtime_history import HistoryWriter
+from steam_backlog_enforcer._playtime_log import TickJournal
from steam_backlog_enforcer._playtime_session import new_session
-PS = "steam_backlog_enforcer._playtime_session"
-
class TestNewSession:
- def test_builds_a_tracker_and_a_journal(self) -> None:
- with (
- patch(f"{PS}.resolve_desktop_user", return_value="kuhy"),
- patch(f"{PS}.desktop_uid", return_value=1000) as uid,
- ):
- session = new_session()
- assert isinstance(session.tracker, EngagementTracker)
+ def test_builds_a_journal_and_history(self) -> None:
+ session = new_session()
assert isinstance(session.journal, TickJournal)
- uid.assert_called_once_with("kuhy")
-
- def test_binds_the_tracker_to_the_desktop_users_runtime_dir(self) -> None:
- # Root's own /run/user/0 would be the wrong place to look for the
- # gatelock holder file.
- with (
- patch(f"{PS}.resolve_desktop_user", return_value="kuhy"),
- patch(f"{PS}.desktop_uid", return_value=1000),
- ):
- session = new_session()
- assert "/run/user/1000/" in str(session.tracker._holder_path)
+ assert isinstance(session.history, HistoryWriter)
def test_demo_journals_away_from_the_production_trail(self) -> None:
- with (
- patch(f"{PS}.resolve_desktop_user", return_value="kuhy"),
- patch(f"{PS}.desktop_uid", return_value=1000),
- ):
- live = new_session()
- demo = new_session(demo=True)
+ live = new_session()
+ demo = new_session(demo=True)
assert demo.journal._log._path == log_mod.BUDGET_DEMO_LOG_FILE
assert live.journal._log._path == log_mod.BUDGET_LOG_FILE
diff --git a/steam_backlog_enforcer/tests/test_screen_hold.py b/steam_backlog_enforcer/tests/test_screen_hold.py
deleted file mode 100644
index 446b59b..0000000
--- a/steam_backlog_enforcer/tests/test_screen_hold.py
+++ /dev/null
@@ -1,111 +0,0 @@
-"""Tests for observing a gatelock screen hold through ``/proc/locks``.
-
-The probe must never take the lock itself, so every case here is driven by
-synthetic ``/proc/locks`` text rather than by acquiring anything.
-"""
-
-from __future__ import annotations
-
-import os
-from pathlib import Path
-from unittest.mock import patch
-
-import pytest
-
-from steam_backlog_enforcer._screen_hold import (
- ScreenHoldError,
- holder_lock_path,
- screen_hold,
-)
-
-SH = "steam_backlog_enforcer._screen_hold"
-
-
-def _device_field(path: Path) -> str:
- stat = path.stat()
- return f"{os.major(stat.st_dev):02x}:{os.minor(stat.st_dev):02x}:{stat.st_ino}"
-
-
-class TestHolderLockPath:
- def test_uses_the_runtime_dir_of_the_session_owner(self) -> None:
- assert holder_lock_path(1000) == Path("/run/user/1000/gatelock/holder.lock")
-
- def test_differs_per_uid(self) -> None:
- assert holder_lock_path(1000) != holder_lock_path(1001)
-
-
-class TestScreenHold:
- def test_missing_file_is_not_held_and_not_an_error(self, tmp_path: Path) -> None:
- result = screen_hold(tmp_path / "never-created.lock")
- assert result.held is False
- assert result.holder_pid is None
-
- def test_reports_held_with_the_holding_pid(self, tmp_path: Path) -> None:
- lock = tmp_path / "holder.lock"
- lock.touch()
- locks = tmp_path / "locks"
- locks.write_text(
- f"1: FLOCK ADVISORY WRITE 4242 {_device_field(lock)} 0 EOF\n"
- )
- with patch(f"{SH}._PROC_LOCKS", locks):
- result = screen_hold(lock)
- assert result.held is True
- assert result.holder_pid == 4242
-
- def test_reports_free_when_another_file_is_locked(self, tmp_path: Path) -> None:
- lock = tmp_path / "holder.lock"
- lock.touch()
- locks = tmp_path / "locks"
- locks.write_text("1: FLOCK ADVISORY WRITE 4242 00:19:999999 0 EOF\n")
- with patch(f"{SH}._PROC_LOCKS", locks):
- assert screen_hold(lock).held is False
-
- def test_a_waiter_row_is_not_a_holder(self, tmp_path: Path) -> None:
- lock = tmp_path / "holder.lock"
- lock.touch()
- locks = tmp_path / "locks"
- locks.write_text(
- f"1: -> FLOCK ADVISORY WRITE 4242 {_device_field(lock)} 0 EOF\n"
- )
- with patch(f"{SH}._PROC_LOCKS", locks):
- assert screen_hold(lock).held is False
-
- def test_rows_without_a_device_field_are_skipped(self, tmp_path: Path) -> None:
- lock = tmp_path / "holder.lock"
- lock.touch()
- locks = tmp_path / "locks"
- locks.write_text(
- "garbage row with no device\n"
- f"2: FLOCK ADVISORY READ 7 {_device_field(lock)} 0 EOF\n"
- )
- with patch(f"{SH}._PROC_LOCKS", locks):
- assert screen_hold(lock).held is True
-
- def test_short_row_yields_no_pid(self, tmp_path: Path) -> None:
- lock = tmp_path / "holder.lock"
- lock.touch()
- locks = tmp_path / "locks"
- locks.write_text(f"1: FLOCK {_device_field(lock)}\n")
- with patch(f"{SH}._PROC_LOCKS", locks):
- result = screen_hold(lock)
- assert result.held is True
- assert result.holder_pid is None
-
- def test_non_numeric_pid_yields_no_pid(self, tmp_path: Path) -> None:
- lock = tmp_path / "holder.lock"
- lock.touch()
- locks = tmp_path / "locks"
- locks.write_text(
- f"1: FLOCK ADVISORY WRITE nope {_device_field(lock)} 0 EOF\n"
- )
- with patch(f"{SH}._PROC_LOCKS", locks):
- assert screen_hold(lock).holder_pid is None
-
- def test_unreadable_proc_locks_raises(self, tmp_path: Path) -> None:
- lock = tmp_path / "holder.lock"
- lock.touch()
- with (
- patch(f"{SH}._PROC_LOCKS", tmp_path / "absent"),
- pytest.raises(ScreenHoldError),
- ):
- screen_hold(lock)
diff --git a/steam_backlog_enforcer/tests/test_x_focus.py b/steam_backlog_enforcer/tests/test_x_focus.py
deleted file mode 100644
index 19c5189..0000000
--- a/steam_backlog_enforcer/tests/test_x_focus.py
+++ /dev/null
@@ -1,187 +0,0 @@
-"""Tests for attributing the focused window to a process.
-
-The XRes fallback is not a nicety: measured on this machine, Aseprite's window
-carries no ``_NET_WM_PID`` at all, and treating that as "cannot tell" would
-make the focus criterion useless for every application that behaves the same.
-"""
-
-from __future__ import annotations
-
-import ctypes
-from typing import TYPE_CHECKING, cast
-from unittest.mock import MagicMock
-
-import pytest
-
-from steam_backlog_enforcer._x_focus import _XResValue, focused_pid, read_cardinal
-from steam_backlog_enforcer._x_probe import Conn, XProbeError
-from steam_backlog_enforcer.tests._fake_xlib import fake_x11, property_writer
-
-if TYPE_CHECKING:
- from collections.abc import Callable
-
-
-def _conn(x11: MagicMock, xres: MagicMock | None = None) -> Conn:
- """Wrap fake handles in a Conn, casting only at this one seam."""
- return Conn(
- display=ctypes.c_void_p(1),
- x11=cast("ctypes.CDLL", x11),
- xss=cast("ctypes.CDLL", MagicMock()),
- xres=None if xres is None else cast("ctypes.CDLL", xres),
- )
-
-
-def _xres(
- *,
- pids: list[int] | None = None,
- entries: list[tuple[int, int, int | None]] | None = None,
- status: int = 0,
- null: bool = False,
-) -> MagicMock:
- """Build a libXRes stand-in.
-
- Args:
- pids: Shorthand for well-formed PID entries.
- entries: Raw ``(mask, length, pid)`` rows; ``pid=None`` means a NULL
- value pointer, which the server can legitimately return.
- status: Return code; non-zero means the query failed.
- null: Whether to leave the results pointer NULL.
- """
- rows = (
- entries
- if entries is not None
- else [(1 << 1, 4, pid) for pid in (pids if pids is not None else [])]
- )
- lib = MagicMock(name="libXRes")
- array = (_XResValue * max(len(rows), 1))()
- keepalive: list[ctypes.c_uint32] = []
- for index, (mask, length, pid) in enumerate(rows):
- array[index].spec.mask = mask
- array[index].length = length
- if pid is None:
- array[index].value = None
- else:
- holder = ctypes.c_uint32(pid)
- keepalive.append(holder)
- array[index].value = ctypes.cast(
- ctypes.byref(holder), ctypes.c_void_p
- ).value
-
- def impl(
- _display: object,
- _n: object,
- _spec: object,
- count_ref: object,
- values_ref: object,
- ) -> int:
- count_ref._obj.value = len(rows)
- if not null:
- values_ref._obj.contents = array[0]
- return status
-
- lib.XResQueryClientIds.side_effect = impl
- lib._keepalive = (array, keepalive)
- return lib
-
-
-class TestReadCardinal:
- def test_returns_the_first_value(self) -> None:
- x11 = fake_x11()
- x11.XGetWindowProperty.side_effect = property_writer(value=99)
- assert read_cardinal(_conn(x11), 0x1, b"_NET_WM_PID") == 99
-
- def test_a_missing_atom_is_none(self) -> None:
- assert read_cardinal(_conn(fake_x11(atom=0)), 0x1, b"_NOPE") is None
-
- def test_a_failed_request_is_none(self) -> None:
- x11 = fake_x11()
- x11.XGetWindowProperty.side_effect = property_writer(status=1)
- assert read_cardinal(_conn(x11), 0x1, b"_NET_WM_PID") is None
-
- def test_a_null_property_is_none(self) -> None:
- x11 = fake_x11()
- x11.XGetWindowProperty.side_effect = property_writer(null=True)
- assert read_cardinal(_conn(x11), 0x1, b"_NET_WM_PID") is None
-
- def test_an_empty_property_is_none_and_still_freed(self) -> None:
- x11 = fake_x11()
- x11.XGetWindowProperty.side_effect = property_writer(nitems=0)
- assert read_cardinal(_conn(x11), 0x1, b"_NET_WM_PID") is None
- x11.XFree.assert_called_once()
-
-
-class TestFocusedPid:
- def test_no_focused_window_is_none(self) -> None:
- x11 = fake_x11()
- x11.XGetWindowProperty.side_effect = property_writer(value=0)
- assert focused_pid(_conn(x11)) is None
-
- def test_uses_net_wm_pid_when_present(self) -> None:
- x11 = fake_x11()
- x11.XGetWindowProperty.side_effect = property_writer(value=555)
- assert focused_pid(_conn(x11)) == 555
-
- def test_falls_back_to_xres(self) -> None:
- x11 = fake_x11()
- # The active window resolves, then _NET_WM_PID comes back absent.
- x11.XGetWindowProperty.side_effect = _sequence(
- property_writer(value=0x400001), property_writer(nitems=0)
- )
- assert focused_pid(_conn(x11, _xres(pids=[8080]))) == 8080
-
- def test_raises_when_neither_source_can_attribute_the_window(self) -> None:
- x11 = fake_x11()
- x11.XGetWindowProperty.side_effect = _sequence(
- property_writer(value=0x400001), property_writer(nitems=0)
- )
- with pytest.raises(XProbeError, match="XRes"):
- focused_pid(_conn(x11, None))
-
-
-class TestXResFallback:
- def _focus_without_wm_pid(self) -> MagicMock:
- x11 = fake_x11()
- x11.XGetWindowProperty.side_effect = _sequence(
- property_writer(value=0x400001), property_writer(nitems=0)
- )
- return x11
-
- def test_a_failed_query_gives_no_pid(self) -> None:
- with pytest.raises(XProbeError):
- focused_pid(_conn(self._focus_without_wm_pid(), _xres(status=1)))
-
- def test_a_null_result_gives_no_pid(self) -> None:
- with pytest.raises(XProbeError):
- focused_pid(_conn(self._focus_without_wm_pid(), _xres(null=True)))
-
- def test_no_entries_gives_no_pid(self) -> None:
- with pytest.raises(XProbeError):
- focused_pid(_conn(self._focus_without_wm_pid(), _xres(pids=[])))
-
- def test_a_non_pid_entry_is_skipped(self) -> None:
- # XRes can return XID rows alongside PID rows; only the PID row counts.
- xres = _xres(entries=[(1 << 0, 4, 111), (1 << 1, 4, 222)])
- assert focused_pid(_conn(self._focus_without_wm_pid(), xres)) == 222
-
- def test_a_short_entry_is_skipped(self) -> None:
- xres = _xres(entries=[(1 << 1, 0, 111), (1 << 1, 4, 333)])
- assert focused_pid(_conn(self._focus_without_wm_pid(), xres)) == 333
-
- def test_a_null_value_is_skipped(self) -> None:
- xres = _xres(entries=[(1 << 1, 4, None), (1 << 1, 4, 444)])
- assert focused_pid(_conn(self._focus_without_wm_pid(), xres)) == 444
-
- def test_the_result_is_destroyed(self) -> None:
- xres = _xres(pids=[4242])
- focused_pid(_conn(self._focus_without_wm_pid(), xres))
- xres.XResClientIdsDestroy.assert_called_once()
-
-
-def _sequence(*writers: Callable[..., int]) -> Callable[..., int]:
- """Chain property writers so successive calls use successive fakes."""
- calls = iter(writers)
-
- def impl(*args: object) -> int:
- return next(calls)(*args)
-
- return impl
diff --git a/steam_backlog_enforcer/tests/test_x_probe.py b/steam_backlog_enforcer/tests/test_x_probe.py
deleted file mode 100644
index a0a797c..0000000
--- a/steam_backlog_enforcer/tests/test_x_probe.py
+++ /dev/null
@@ -1,120 +0,0 @@
-"""Tests for the cached X connection and the input-idle query.
-
-Every case runs against fake library handles, so the suite never needs a
-display and never depends on whether the developer happens to be at the
-keyboard.
-"""
-
-from __future__ import annotations
-
-from unittest.mock import MagicMock, patch
-
-import pytest
-
-from steam_backlog_enforcer._x_probe import (
- XProbe,
- XProbeError,
- _ignore_x_error,
- load_libraries,
- root_window,
-)
-from steam_backlog_enforcer.tests._fake_xlib import fake_x11, fake_xss
-
-XP = "steam_backlog_enforcer._x_probe"
-
-
-class TestLoadLibraries:
- def test_returns_all_three_when_present(self) -> None:
- x11, xss, xres = MagicMock(), MagicMock(), MagicMock()
- with patch(f"{XP}.ctypes.CDLL", side_effect=[x11, xss, xres]):
- loaded = load_libraries()
- assert loaded[0] is x11
- assert loaded[1] is xss
- assert loaded[2] is xres
-
- def test_missing_xres_is_tolerated(self) -> None:
- x11, xss = MagicMock(), MagicMock()
- with patch(f"{XP}.ctypes.CDLL", side_effect=[x11, xss, OSError("no")]):
- loaded = load_libraries()
- assert loaded[0] is x11
- assert loaded[2] is None
-
- def test_missing_core_libraries_raise(self) -> None:
- with (
- patch(f"{XP}.ctypes.CDLL", side_effect=OSError("no libX11")),
- pytest.raises(XProbeError),
- ):
- load_libraries()
-
-
-class TestConnect:
- def test_opens_once_and_caches(self) -> None:
- x11 = fake_x11()
- probe = XProbe(libraries=(x11, fake_xss(), None))
- first = probe.connect()
- assert probe.connect() is first
- assert x11.XOpenDisplay.call_count == 1
-
- def test_loads_libraries_when_none_were_injected(self) -> None:
- libs = (fake_x11(), fake_xss(), None)
- with patch(f"{XP}.load_libraries", return_value=libs) as loader:
- XProbe().connect()
- loader.assert_called_once_with()
-
- def test_a_null_display_raises(self) -> None:
- probe = XProbe(libraries=(fake_x11(display=0), fake_xss(), None))
- with pytest.raises(XProbeError, match="XOpenDisplay"):
- probe.connect()
-
- def test_an_error_handler_is_installed(self) -> None:
- # Xlib's default handler calls exit(1); a window vanishing mid-query
- # must not be able to take the daemon down.
- x11 = fake_x11()
- XProbe(libraries=(x11, fake_xss(), None)).connect()
- x11.XSetErrorHandler.assert_called_once()
-
-
-class TestClose:
- def test_closing_an_open_connection_releases_it(self) -> None:
- x11 = fake_x11()
- probe = XProbe(libraries=(x11, fake_xss(), None))
- probe.connect()
- probe.close()
- x11.XCloseDisplay.assert_called_once()
- probe.connect()
- assert x11.XOpenDisplay.call_count == 2
-
- def test_closing_an_unopened_connection_is_a_no_op(self) -> None:
- x11 = fake_x11()
- XProbe(libraries=(x11, fake_xss(), None)).close()
- x11.XCloseDisplay.assert_not_called()
-
-
-class TestIdleSeconds:
- def test_converts_milliseconds_to_seconds(self) -> None:
- probe = XProbe(libraries=(fake_x11(), fake_xss(idle_ms=4500), None))
- assert probe.idle_seconds() == 4.5
-
- def test_a_failed_allocation_raises(self) -> None:
- probe = XProbe(libraries=(fake_x11(), fake_xss(allocated=False), None))
- with pytest.raises(XProbeError, match="AllocInfo"):
- probe.idle_seconds()
-
- def test_a_failed_query_raises_and_still_frees(self) -> None:
- x11 = fake_x11()
- probe = XProbe(libraries=(x11, fake_xss(ok=False), None))
- with pytest.raises(XProbeError, match="QueryInfo"):
- probe.idle_seconds()
- x11.XFree.assert_called_once()
-
-
-class TestErrorHandler:
- def test_swallows_the_error_and_reports_success(self) -> None:
- assert _ignore_x_error(None, None) == 0
-
-
-class TestRootWindow:
- def test_returns_the_default_root(self) -> None:
- conn = MagicMock()
- conn.x11.XDefaultRootWindow.return_value = 0x99
- assert root_window(conn) == 0x99
diff --git a/web/src/components/BudgetLiveCard.test.tsx b/web/src/components/BudgetLiveCard.test.tsx
index a276413..a7d278f 100644
--- a/web/src/components/BudgetLiveCard.test.tsx
+++ b/web/src/components/BudgetLiveCard.test.tsx
@@ -12,36 +12,11 @@ describe('BudgetLiveCard', () => {
expect(screen.getByText(/Billing to/)).toBeInTheDocument()
expect(screen.getAllByText('Hollow Knight')).toHaveLength(2)
expect(screen.getByText(/3 qualifying processes/)).toBeInTheDocument()
- expect(screen.getByText(/Idle 2s/)).toBeInTheDocument()
- expect(screen.getByText(/Screen held: no/)).toBeInTheDocument()
})
- it('explains why a session is paused', () => {
- render(
- ,
- )
- expect(screen.getByText(/Not billing — paused/)).toBeInTheDocument()
- expect(
- screen.getByText(/the game window is not focused, no input for longer/),
- ).toBeInTheDocument()
- expect(screen.getByText(/Screen held: yes/)).toBeInTheDocument()
- })
-
- it('falls back to the raw cause and verdict when unrecognised', () => {
- render(
- ,
- )
+ it('falls back to the raw verdict when unrecognised', () => {
+ render()
expect(screen.getByText('weird')).toBeInTheDocument()
- expect(screen.getByText(/gremlins/)).toBeInTheDocument()
})
it('omits the game line when nothing qualifies', () => {
@@ -51,14 +26,11 @@ describe('BudgetLiveCard', () => {
state: 'not_applicable',
qualifying_count: 0,
processes: [],
- idle_seconds: null,
- screen_held: null,
})}
/>,
)
expect(screen.getByText(/no game running/)).toBeInTheDocument()
expect(screen.queryByText(/qualifying processes/)).toBeNull()
- expect(screen.queryByText(/Idle/)).toBeNull()
})
it('handles a qualifying session with no assigned game name', () => {
diff --git a/web/src/components/BudgetLiveCard.tsx b/web/src/components/BudgetLiveCard.tsx
index 58662ce..e326a04 100644
--- a/web/src/components/BudgetLiveCard.tsx
+++ b/web/src/components/BudgetLiveCard.tsx
@@ -1,4 +1,4 @@
-import { fmtAgo, fmtDuration } from '../format'
+import { fmtAgo } from '../format'
import type { BudgetSession } from '../types'
interface Props {
@@ -7,20 +7,9 @@ interface Props {
const VERDICT_LABELS: Record = {
engaged: 'Billing — you are playing',
- paused: 'Not billing — paused',
not_applicable: 'Not billing — no game running',
}
-const CAUSE_LABELS: Record = {
- idle: 'no input for longer than the idle grace',
- focus: 'the game window is not focused',
- screen_held: 'the screen is locked or held',
-}
-
-function describe(values: string[], labels: Record): string[] {
- return values.map((value) => labels[value] ?? value)
-}
-
export function BudgetLiveCard({ session }: Props) {
if (!session.available) {
return (
@@ -54,17 +43,13 @@ export function BudgetLiveCard({ session }: Props) {
{/* The assignment above is what the enforcer told you to play; this
is what the budget charged. A counted non-Steam game is never the
assignment, so the two legitimately differ. The key is the *last*
- one credited, so it must not claim to be live while paused. */}
+ one credited, so it must not claim to be live once nothing
+ qualifies any more. */}
{session.state === 'engaged' ? 'Billing to ' : 'Last billed to '}
{session.billing_label}
)}
- {session.causes.length > 0 && (
- Paused because {describe(session.causes, CAUSE_LABELS).join(', ')}.
- )}
- {session.idle_seconds !== null && <>Idle {fmtDuration(session.idle_seconds)} · >}
- {session.screen_held !== null && <>Screen held: {session.screen_held ? 'yes' : 'no'} · >}
{/* The daemon logs on change or a 5-minute heartbeat, so this reading
can legitimately be minutes old. Saying so beats implying "now". */}
as of {fmtAgo(session.observed_at)}
diff --git a/web/src/components/BudgetRulesCard.test.tsx b/web/src/components/BudgetRulesCard.test.tsx
index 9c0b903..28528e7 100644
--- a/web/src/components/BudgetRulesCard.test.tsx
+++ b/web/src/components/BudgetRulesCard.test.tsx
@@ -8,8 +8,6 @@ describe('BudgetRulesCard', () => {
render()
expect(screen.getByText('8h 0m')).toBeInTheDocument()
expect(screen.getByText('on')).toBeInTheDocument()
- expect(screen.getByText(/idle grace 5m/)).toBeInTheDocument()
- expect(screen.getByText(/game must be focused/)).toBeInTheDocument()
expect(screen.getByText('yes')).toBeInTheDocument()
expect(screen.getByText(/1h 0m, 30m, 10m, 5m remaining/)).toBeInTheDocument()
expect(screen.queryByText(/demo/)).toBeNull()
@@ -22,8 +20,6 @@ describe('BudgetRulesCard', () => {
rules={makeBudgetRules({
enforcement: false,
counts_launchers: false,
- engagement_gate: false,
- require_game_focus: false,
demo: true,
masked_launchers: ['/usr/bin/steam'],
})}
@@ -32,6 +28,5 @@ describe('BudgetRulesCard', () => {
expect(screen.getByText(/demo \(short budget/)).toBeInTheDocument()
expect(screen.getByText('/usr/bin/steam')).toBeInTheDocument()
expect(screen.getByText('no')).toBeInTheDocument()
- expect(screen.queryByText(/game must be focused/)).toBeNull()
})
})
diff --git a/web/src/components/BudgetRulesCard.tsx b/web/src/components/BudgetRulesCard.tsx
index 6eebcfa..a4787fe 100644
--- a/web/src/components/BudgetRulesCard.tsx
+++ b/web/src/components/BudgetRulesCard.tsx
@@ -18,11 +18,6 @@ export function BudgetRulesCard({ rules }: Props) {
{fmtDuration(rules.budget_seconds)}
Enforcement
{onOff(rules.enforcement)}
- Engagement gate
-
- {onOff(rules.engagement_gate)} · idle grace {fmtDuration(rules.idle_grace_seconds)}
- {rules.require_game_focus ? ' · game must be focused' : ''}
-
Counts launchers
{rules.counts_launchers ? 'yes' : 'no'}
Warnings at
diff --git a/web/src/index.css b/web/src/index.css
index 57fdb03..0716efa 100644
--- a/web/src/index.css
+++ b/web/src/index.css
@@ -623,9 +623,6 @@ td.proton {
.budget-verdict--engaged {
color: var(--accent-2);
}
-.budget-verdict--paused {
- color: var(--warn);
-}
.budget-rules-list {
display: grid;
grid-template-columns: max-content 1fr;
diff --git a/web/src/test/factories.ts b/web/src/test/factories.ts
index a058fd9..c84a725 100644
--- a/web/src/test/factories.ts
+++ b/web/src/test/factories.ts
@@ -126,10 +126,6 @@ export function makeBudgetSession(over: Partial = {}): BudgetSess
available: true,
observed_at: new Date().toISOString(),
state: 'engaged',
- reason: 'engaged',
- causes: [],
- idle_seconds: 2,
- screen_held: false,
game_name: 'Hollow Knight',
billing_label: 'Hollow Knight',
qualifying_count: 3,
@@ -143,9 +139,6 @@ export function makeBudgetRules(over: Partial = {}): BudgetRules {
budget_seconds: 28800,
enforcement: true,
counts_launchers: true,
- engagement_gate: true,
- idle_grace_seconds: 300,
- require_game_focus: true,
warn_at: [3600, 1800, 600, 300],
demo: false,
masked_launchers: [],
diff --git a/web/src/types.ts b/web/src/types.ts
index 2083aff..23ed307 100644
--- a/web/src/types.ts
+++ b/web/src/types.ts
@@ -139,10 +139,6 @@ export interface BudgetSession {
/** ISO-8601 timestamp the daemon recorded; may be minutes old. */
observed_at: string
state: string
- reason: string
- causes: string[]
- idle_seconds: number | null
- screen_held: boolean | null
game_name: string
/** Game the budget is actually charging; differs from `game_name`, which
* is the backlog assignment. Empty when nothing has billed yet. */
@@ -174,9 +170,6 @@ export interface BudgetRules {
budget_seconds: number
enforcement: boolean
counts_launchers: boolean
- engagement_gate: boolean
- idle_grace_seconds: number
- require_game_focus: boolean
warn_at: number[]
demo: boolean
masked_launchers: string[]