diff --git a/DOCS-morning-session-pc.md b/DOCS-morning-session-pc.md index 091ffc3..68bac57 100644 --- a/DOCS-morning-session-pc.md +++ b/DOCS-morning-session-pc.md @@ -93,7 +93,35 @@ normal with a WARNING. Status paths never wait; tests pin the retry to 0. hits this: the day starts exempt.) - A session finishing inside ~2 min before 09:30 may be seen as `in_progress` at the 09:30 tick and lock; bounded by the timer cadence. -- No extra stick for a `failed` session beyond losing the carrot. + +## The workday stick (2026-09-23) + +The carrot above only pulls on a day the PC is actually being used to enjoy +it — a weekend. On a workday the user leaves for the office regardless, so +losing/keeping the PC's lock was worth nothing, and powering the phone off +at ring time (which stops the alarm dead — nothing left to sync, no session +ever recorded) cost nothing either. + +On **Tuesday/Wednesday/Thursday** — `wake_alarm._constants.STICK_DAYS`, the +same weekdays screen-locker already calls "relaxed" +(`_weekly_check.is_relaxed_day`) and leetcode-guard already prices as cheap +(`Pricing.doubled_days`) — a genuine miss (`failed`, or `none` past its own +`SESSION_NONE_GRACE`; a *late* `completed` is not a miss, the walk still +happened) costs tomorrow's leniency in both apps instead of just resetting +to normal. `wake_alarm._workday_penalty.maybe_apply()` runs at the end of +every `_session.refresh()` and, when a stick-day miss is detected and today +is not a free day, signs and writes +`~/.local/state/wake_alarm/workday_penalty.json` (`{"penalty_date": +"", "issued_date": ""}`) — deliberately a separate file +from `morning_session.json`, since that one always describes *today* and is +overwritten at the date rollover, so it cannot carry a marker forward. +screen-locker and leetcode-guard each read it with the same HMAC + date +predicate they already use for `morning_session.json`. + +A phone-side stick (locking down distracting apps on the phone itself, +signalled to `phone-focus-mode`'s `focus-owner`) is the other half of this +and lives in `phone_app/`, not here — see its own commit/doc for the exact +signal shape. ## Commands diff --git a/phone_app/android/app/src/main/AndroidManifest.xml b/phone_app/android/app/src/main/AndroidManifest.xml index a7d21d6..0df1047 100644 --- a/phone_app/android/app/src/main/AndroidManifest.xml +++ b/phone_app/android/app/src/main/AndroidManifest.xml @@ -32,6 +32,9 @@ "not at home". --> + + { + RingWatch.markDismissed(context) + result.success(null) + } else -> result.notImplemented() } } diff --git a/phone_app/android/app/src/main/kotlin/com/kuhy/wake_alarm_sync/AlarmReceiver.kt b/phone_app/android/app/src/main/kotlin/com/kuhy/wake_alarm_sync/AlarmReceiver.kt index 366e701..09251d3 100644 --- a/phone_app/android/app/src/main/kotlin/com/kuhy/wake_alarm_sync/AlarmReceiver.kt +++ b/phone_app/android/app/src/main/kotlin/com/kuhy/wake_alarm_sync/AlarmReceiver.kt @@ -32,6 +32,10 @@ class AlarmReceiver : BroadcastReceiver() { AlarmScheduler.rearmFromStorage(context) return } + // The one fresh (non-re-ring) daily alarm. Recorded here, not in + // Dart, so a poweroff mid-ring can never race it: setAlarmClock has + // already woken the CPU by the time this line runs. + RingWatch.markFired(context) AlarmService.start(context) } diff --git a/phone_app/android/app/src/main/kotlin/com/kuhy/wake_alarm_sync/AlarmWatchdog.kt b/phone_app/android/app/src/main/kotlin/com/kuhy/wake_alarm_sync/AlarmWatchdog.kt index 22b32c1..c0e35d7 100644 --- a/phone_app/android/app/src/main/kotlin/com/kuhy/wake_alarm_sync/AlarmWatchdog.kt +++ b/phone_app/android/app/src/main/kotlin/com/kuhy/wake_alarm_sync/AlarmWatchdog.kt @@ -54,6 +54,10 @@ object AlarmWatchdog { fun verify(context: Context) { val rearmed = AlarmScheduler.rearmFromStorage(context) Log.i(TAG, "daily check: rearmed=$rearmed") + // Fallback net for an abandoned ring on a phone that never rebooted + // (BootReceiver already covers the poweroff case): within a day, + // whatever the reason, WorkdayStick catches it here too. + WorkdayStick.checkAndSignal(context) } private fun pendingIntent(context: Context): PendingIntent = diff --git a/phone_app/android/app/src/main/kotlin/com/kuhy/wake_alarm_sync/BootReceiver.kt b/phone_app/android/app/src/main/kotlin/com/kuhy/wake_alarm_sync/BootReceiver.kt index 1d3e7d5..df43401 100644 --- a/phone_app/android/app/src/main/kotlin/com/kuhy/wake_alarm_sync/BootReceiver.kt +++ b/phone_app/android/app/src/main/kotlin/com/kuhy/wake_alarm_sync/BootReceiver.kt @@ -24,6 +24,9 @@ class BootReceiver : BroadcastReceiver() { // has to be re-established here or it silently stops after the first // restart — exactly when a watchdog is most needed. AlarmWatchdog.schedule(context) + // The moment a phone powered off mid-ring comes back is exactly when + // an abandoned ring should be caught -- see WorkdayStick. + WorkdayStick.checkAndSignal(context) } private companion object { diff --git a/phone_app/android/app/src/main/kotlin/com/kuhy/wake_alarm_sync/RingWatch.kt b/phone_app/android/app/src/main/kotlin/com/kuhy/wake_alarm_sync/RingWatch.kt new file mode 100644 index 0000000..ad61a1c --- /dev/null +++ b/phone_app/android/app/src/main/kotlin/com/kuhy/wake_alarm_sync/RingWatch.kt @@ -0,0 +1,53 @@ +package com.kuhy.wake_alarm_sync + +import android.content.Context +import java.text.SimpleDateFormat +import java.util.Calendar +import java.util.Locale + +/** + * Tracks, natively, whether today's ring was ever dismissed. + * + * The dismiss gate (tag1 -> steps -> tag2 -> challenges) lives in Dart, but a + * phone powered off before touching any of it never runs Dart at all that + * morning -- there is no session, no store, nothing to ask. Two dates, set + * from opposite ends of the ring, are enough to answer "was this abandoned" + * with no engine required: + * + * - [markFired] -- called from [AlarmReceiver], the instant a *fresh* + * (non-re-ring) alarm fires. This runs well before a poweroff mid-ring + * could ever prevent it -- setAlarmClock has already woken the CPU. + * - [markDismissed] -- called from Dart over the alarm channel, the instant + * the initial dismiss gate actually completes (`session_handoff.dart`'s + * `afterDismiss`). + * + * [abandonedRingDate] is non-null exactly when a ring fired and nothing + * since has dismissed it -- checked from [BootReceiver] and the daily + * [WatchdogReceiver] tick, both of which run without a Flutter engine. + */ +object RingWatch { + private const val PREFS = "wake_alarm_ring_watch" + private const val KEY_FIRED_DATE = "fired_date" + private const val KEY_DISMISSED_DATE = "dismissed_date" + + fun markFired(context: Context) { + prefs(context).edit().putString(KEY_FIRED_DATE, today()).apply() + } + + fun markDismissed(context: Context) { + prefs(context).edit().putString(KEY_DISMISSED_DATE, today()).apply() + } + + /** The date a ring fired but was never dismissed, or null. */ + fun abandonedRingDate(context: Context): String? { + val fired = prefs(context).getString(KEY_FIRED_DATE, null) ?: return null + val dismissed = prefs(context).getString(KEY_DISMISSED_DATE, null) + return if (fired == dismissed) null else fired + } + + private fun prefs(context: Context) = + context.getSharedPreferences(PREFS, Context.MODE_PRIVATE) + + private fun today(): String = + SimpleDateFormat("yyyy-MM-dd", Locale.US).format(Calendar.getInstance().time) +} diff --git a/phone_app/android/app/src/main/kotlin/com/kuhy/wake_alarm_sync/WorkdayStick.kt b/phone_app/android/app/src/main/kotlin/com/kuhy/wake_alarm_sync/WorkdayStick.kt new file mode 100644 index 0000000..465a80c --- /dev/null +++ b/phone_app/android/app/src/main/kotlin/com/kuhy/wake_alarm_sync/WorkdayStick.kt @@ -0,0 +1,48 @@ +package com.kuhy.wake_alarm_sync + +import android.content.Context +import android.content.Intent +import android.util.Log +import java.text.SimpleDateFormat +import java.util.Calendar +import java.util.Locale + +/** + * Signals `focus-owner` to lock down distracting apps when a + * Tuesday/Wednesday/Thursday ring was abandoned -- see [RingWatch]. + * + * Tue/Wed/Thu is the same set `wake_alarm._constants.STICK_DAYS` uses on the + * PC side for the debt-stacking half of this same stick: both go easy on + * exactly these three days otherwise, which is why skipping one used to cost + * nothing. + */ +object WorkdayStick { + /** [Calendar.DAY_OF_WEEK] values for Tuesday/Wednesday/Thursday. */ + private val STICK_DAYS = + setOf(Calendar.TUESDAY, Calendar.WEDNESDAY, Calendar.THURSDAY) + + private const val ACTION_LOCKDOWN = "com.kuhy.focus_owner.action.LOCKDOWN_UNTIL_EOD" + private const val PERMISSION_SIGNAL = "com.kuhy.focus_owner.permission.SIGNAL_LOCKDOWN" + private const val FOCUS_OWNER_PACKAGE = "com.kuhy.focus_owner" + + private const val TAG = "WakeAlarmWorkdayStick" + + /** Checks for an abandoned stick-day ring and signals focus-owner. */ + fun checkAndSignal(context: Context) { + val abandoned = RingWatch.abandonedRingDate(context) ?: return + if (!isStickDay(abandoned)) return + Log.i(TAG, "abandoned ring on $abandoned: signalling focus-owner lockdown") + context.sendBroadcast( + Intent(ACTION_LOCKDOWN).setPackage(FOCUS_OWNER_PACKAGE), + PERMISSION_SIGNAL, + ) + } + + private fun isStickDay(isoDate: String): Boolean { + val format = SimpleDateFormat("yyyy-MM-dd", Locale.US) + val parsed = runCatching { format.parse(isoDate) }.getOrNull() ?: return false + val calendar = Calendar.getInstance() + calendar.time = parsed + return calendar.get(Calendar.DAY_OF_WEEK) in STICK_DAYS + } +} diff --git a/phone_app/lib/services/alarm_scheduler.dart b/phone_app/lib/services/alarm_scheduler.dart index 924a5b6..1ad609d 100644 --- a/phone_app/lib/services/alarm_scheduler.dart +++ b/phone_app/lib/services/alarm_scheduler.dart @@ -60,6 +60,17 @@ class AlarmScheduler { /// Stops the ring and immediately re-arms for tomorrow. Future dismiss() => _channel.invokeMethod('dismiss'); + /// Tells the native side today's ring was actually dismissed. + /// + /// Called once, from `SessionHandoff.afterDismiss` regardless of outcome — + /// reaching that call at all means the dismiss gate was satisfied. Native + /// pairs this with the fired timestamp it records independently + /// (`RingWatch`), so an abandoned ring (phone powered off before this + /// ever runs) can be told apart from a completed one with no Dart engine + /// required on the next boot. + Future markRingDismissed() => + _channel.invokeMethod('markRingDismissed'); + /// Whether the system will honour the full-screen intent. /// /// False from API 34 unless granted. The caller must treat this as a hard diff --git a/phone_app/lib/services/session_handoff.dart b/phone_app/lib/services/session_handoff.dart index 6999131..ddabb13 100644 --- a/phone_app/lib/services/session_handoff.dart +++ b/phone_app/lib/services/session_handoff.dart @@ -34,6 +34,10 @@ class SessionHandoff { /// as it stands (failed, since it never finished) rather than resumed — /// yesterday's clocks would re-ring the moment the screen came up. Future afterDismiss({required bool away}) async { + // Reaching this call at all means the dismiss gate was satisfied -- + // recorded before anything else so an interrupted await below still + // leaves the native side knowing the ring was answered. + await scheduler.markRingDismissed(); final now = _now(); final today = SessionRules.dateKey(now); final current = await store.loadCurrent(); diff --git a/phone_app/test/services/alarm_scheduler_test.dart b/phone_app/test/services/alarm_scheduler_test.dart index fc62fca..cce8998 100644 --- a/phone_app/test/services/alarm_scheduler_test.dart +++ b/phone_app/test/services/alarm_scheduler_test.dart @@ -49,6 +49,11 @@ void main() { expect(calls.single.method, 'dismiss'); }); + test('markRingDismissed invokes markRingDismissed', () async { + await scheduler.markRingDismissed(); + expect(calls.single.method, 'markRingDismissed'); + }); + test('rearm returns the platform result', () async { reply = true; expect(await scheduler.rearm(), isTrue); diff --git a/phone_app/test/services/session_handoff_test.dart b/phone_app/test/services/session_handoff_test.dart index 1e987fa..d49ce3b 100644 --- a/phone_app/test/services/session_handoff_test.dart +++ b/phone_app/test/services/session_handoff_test.dart @@ -13,14 +13,19 @@ void main() { final now = DateTime(2026, 9, 17, 8, 4); var hasNfc = true; + late List calls; setUp(() { hasNfc = true; + calls = []; SharedPreferences.setMockInitialValues({}); TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger .setMockMethodCallHandler( const MethodChannel(AlarmScheduler.channelName), - (call) async => call.method == 'hasNfc' ? hasNfc : null, + (call) async { + calls.add(call.method); + return call.method == 'hasNfc' ? hasNfc : null; + }, ); }); @@ -50,6 +55,14 @@ void main() { expect(await SessionStore().loadCurrent(), isNull); }); + test( + 'every dismiss tells native the ring was answered, even when away', + () async { + await handoff().afterDismiss(away: true); + expect(calls, contains('markRingDismissed')); + }, + ); + test('a dismiss during a live session is a re-ring', () async { final store = SessionStore(); await store.save( diff --git a/wake_alarm/_constants.py b/wake_alarm/_constants.py index 42327aa..711ed02 100644 --- a/wake_alarm/_constants.py +++ b/wake_alarm/_constants.py @@ -156,3 +156,13 @@ SESSION_COMPLETED_UNTIL: tuple[int, int] = (11, 0) # dismissed (ring -> tags -> steps -> answers -> the start publish reaches the # PC). A phone switched off at the alarm locks this long after it. SESSION_NONE_GRACE: timedelta = timedelta(minutes=15) + + +# --- Workday stick (Tue/Wed/Thu miss -> tomorrow loses its leniency) ------ +# The same weekdays screen-locker calls "relaxed" (_weekly_check.is_relaxed_day) +# and leetcode-guard prices as cheap (Pricing.doubled_days) -- both already go +# easy on exactly these three days, which is why a miss costs nothing today +# without this file. Python weekday(): Mon=0 ... Sun=6. +STICK_DAYS: frozenset[int] = frozenset({1, 2, 3}) # Tue, Wed, Thu + +WORKDAY_PENALTY_FILE: Path = LOG_STATE_DIR / "workday_penalty.json" diff --git a/wake_alarm/_session.py b/wake_alarm/_session.py index f7536f0..6bc6cfc 100644 --- a/wake_alarm/_session.py +++ b/wake_alarm/_session.py @@ -40,6 +40,7 @@ from wake_alarm._session_payload import newest_session from wake_alarm._session_policy import to_entry from wake_alarm._sync import get_alarm from wake_alarm._sync_transport import fetch_firebase_logs +from wake_alarm._workday_penalty import maybe_apply as _maybe_apply_workday_penalty _logger = logging.getLogger(__name__) @@ -101,7 +102,10 @@ def refresh(now: datetime) -> dict[str, object] | None: # than the baseline, so a later synced value never widens the grace. alarm=min((alarm.hour, alarm.minute), (FALLBACK_ALARM_HOUR, 0)), ) - return entry if write_entry(entry) else None + if not write_entry(entry): + return None + _maybe_apply_workday_penalty(entry, now) + return entry def describe(entry: dict[str, object], now: datetime) -> str: diff --git a/wake_alarm/_workday_penalty.py b/wake_alarm/_workday_penalty.py new file mode 100644 index 0000000..dc8b84d --- /dev/null +++ b/wake_alarm/_workday_penalty.py @@ -0,0 +1,98 @@ +"""Tue/Wed/Thu miss -> tomorrow loses its usual leniency. + +The no-lock carrot (``_session_policy``) only motivates finishing the +morning when the PC is around to enjoy it -- true on a weekend, false on a +workday, since the user leaves for work regardless of whether the PC is +locked. On Tuesday/Wednesday/Thursday -- the same set screen-locker calls +"relaxed" (``_weekly_check.is_relaxed_day``) and leetcode-guard prices as +cheap (``Pricing.doubled_days``) -- a miss instead costs tomorrow's leniency +in both, so skipping is never free just because nobody is home to notice. + +Distinct from ``morning_session.json``: that file always describes *today* +and is overwritten at the date rollover, so it cannot carry a marker forward +to tomorrow. This file's only field a consumer checks is ``penalty_date``: +today == penalty_date means "no leniency today," the same shape as +``morning_session.json``'s own ``exempt_until`` predicate. +""" + +from __future__ import annotations + +from datetime import date, datetime, timedelta +import json +import logging + +import freedays +from gatelock.log_integrity import compute_entry_hmac + +from wake_alarm._constants import STICK_DAYS, WORKDAY_PENALTY_FILE +from wake_alarm._session_policy import NONE_OUTCOME + +_logger = logging.getLogger(__name__) + + +def is_stick_day(day: date) -> bool: + """Tuesday/Wednesday/Thursday -- the same set already treated as lenient.""" + return day.weekday() in STICK_DAYS + + +def is_workday_miss(entry: dict[str, object], now: datetime) -> bool: + """Whether today's session entry is a genuine miss, not just late. + + ``failed`` is always a miss. ``none`` is only a miss once its own grace + has expired -- before that the morning could still start. A late + ``completed`` (the walk happened, just after the carrot's cutoff) is + deliberately not a miss: the goal was waking up, and that happened. + """ + outcome = entry.get("outcome") + if outcome == "failed": + return True + if outcome != NONE_OUTCOME: + return False + until = entry.get("exempt_until") + if not isinstance(until, str): + return False + try: + return now >= datetime.fromisoformat(until) + except ValueError: + return False + + +def penalty_entry(*, today: date) -> dict[str, object]: + """The unsigned body: tomorrow loses its leniency.""" + return { + "penalty_date": (today + timedelta(days=1)).isoformat(), + "issued_date": today.isoformat(), + } + + +def write_penalty(entry: dict[str, object]) -> bool: + """Sign and write ``entry``; False when the disk refused.""" + signature = compute_entry_hmac(entry) + if signature is not None: + entry["hmac"] = signature + else: + _logger.warning("HMAC key unavailable — writing unsigned workday penalty") + try: + WORKDAY_PENALTY_FILE.parent.mkdir(parents=True, exist_ok=True) + WORKDAY_PENALTY_FILE.write_text(json.dumps(entry, indent=2)) + except OSError as exc: + _logger.warning("Could not write %s: %s", WORKDAY_PENALTY_FILE, exc) + return False + return True + + +def maybe_apply(entry: dict[str, object], now: datetime) -> bool: + """Write tomorrow's penalty when today is a missed stick-day; else no-op. + + Best-effort: never raises, since the per-refresh caller must not fail on + this. A free day is never penalised even if unsynced state elsewhere + would otherwise have rung the alarm -- the pool is fail-closed the other + direction (a corrupt read is "not free"), which is exactly what is + wanted here too: an unreadable pool means no penalty, never a spurious + one. + """ + if freedays.is_free_day(now.date()) or not is_stick_day(now.date()): + return False + if not is_workday_miss(entry, now): + return False + return write_penalty(penalty_entry(today=now.date())) diff --git a/wake_alarm/tests/conftest.py b/wake_alarm/tests/conftest.py index 18122ee..ccc8a1f 100644 --- a/wake_alarm/tests/conftest.py +++ b/wake_alarm/tests/conftest.py @@ -41,6 +41,10 @@ def _hermetic(tmp_path: Path) -> Generator[None]: "wake_alarm._session.MORNING_SESSION_FILE", tmp_path / "morning_session.json", ), + patch( + "wake_alarm._workday_penalty.WORKDAY_PENALTY_FILE", + tmp_path / "workday_penalty.json", + ), # The shared free-day pool lives under ~/.local/share, outside every # path above. Without this, a real free day on the developer's # machine would silence the alarm in every trigger test here. diff --git a/wake_alarm/tests/test_workday_penalty.py b/wake_alarm/tests/test_workday_penalty.py new file mode 100644 index 0000000..2e1d18b --- /dev/null +++ b/wake_alarm/tests/test_workday_penalty.py @@ -0,0 +1,140 @@ +"""Tue/Wed/Thu miss -> tomorrow's penalty file.""" + +from __future__ import annotations + +from datetime import date, datetime +import json +from pathlib import Path +from unittest.mock import patch + +from wake_alarm import _workday_penalty +from wake_alarm._workday_penalty import ( + is_stick_day, + is_workday_miss, + maybe_apply, + penalty_entry, + write_penalty, +) + +# 2026-09-22 is a Tuesday. +TUESDAY = date(2026, 9, 22) +WEDNESDAY = date(2026, 9, 23) +THURSDAY = date(2026, 9, 24) +MONDAY = date(2026, 9, 21) +FRIDAY = date(2026, 9, 25) +SATURDAY = date(2026, 9, 26) +SUNDAY = date(2026, 9, 27) + + +class TestIsStickDay: + def test_tuesday_wednesday_thursday_are_stick_days(self) -> None: + assert is_stick_day(TUESDAY) + assert is_stick_day(WEDNESDAY) + assert is_stick_day(THURSDAY) + + def test_the_rest_of_the_week_is_not(self) -> None: + for day in (MONDAY, FRIDAY, SATURDAY, SUNDAY): + assert not is_stick_day(day) + + +class TestIsWorkdayMiss: + def test_failed_is_always_a_miss(self) -> None: + now = datetime(2026, 9, 22, 12, 0).astimezone() + assert is_workday_miss({"outcome": "failed"}, now) + + def test_none_before_its_own_grace_is_not_a_miss_yet(self) -> None: + now = datetime(2026, 9, 22, 8, 0).astimezone() + entry = { + "outcome": "none", + "exempt_until": datetime(2026, 9, 22, 8, 15).astimezone().isoformat(), + } + assert not is_workday_miss(entry, now) + + def test_none_past_its_own_grace_is_a_miss(self) -> None: + now = datetime(2026, 9, 22, 8, 16).astimezone() + entry = { + "outcome": "none", + "exempt_until": datetime(2026, 9, 22, 8, 15).astimezone().isoformat(), + } + assert is_workday_miss(entry, now) + + def test_none_without_exempt_until_is_not_a_miss(self) -> None: + now = datetime(2026, 9, 22, 12, 0).astimezone() + assert not is_workday_miss({"outcome": "none"}, now) + + def test_none_with_unreadable_exempt_until_is_not_a_miss(self) -> None: + now = datetime(2026, 9, 22, 12, 0).astimezone() + entry = {"outcome": "none", "exempt_until": "not-a-timestamp"} + assert not is_workday_miss(entry, now) + + def test_late_completed_is_not_a_miss(self) -> None: + """The walk happened, just after the carrot's cutoff -- not a skip.""" + now = datetime(2026, 9, 22, 12, 0).astimezone() + assert not is_workday_miss({"outcome": "completed"}, now) + + def test_in_progress_is_not_a_miss(self) -> None: + now = datetime(2026, 9, 22, 8, 5).astimezone() + assert not is_workday_miss({"outcome": "in_progress"}, now) + + +class TestPenaltyEntry: + def test_penalty_targets_tomorrow(self) -> None: + entry = penalty_entry(today=TUESDAY) + assert entry == { + "penalty_date": "2026-09-23", + "issued_date": "2026-09-22", + } + + +class TestWritePenalty: + def test_round_trip_is_signed(self) -> None: + entry = penalty_entry(today=TUESDAY) + assert write_penalty(entry) + assert "hmac" in entry + on_disk = json.loads(_workday_penalty.WORKDAY_PENALTY_FILE.read_text()) + assert on_disk == entry + + def test_unsigned_when_the_key_is_missing(self) -> None: + with patch("wake_alarm._workday_penalty.compute_entry_hmac", return_value=None): + entry = penalty_entry(today=TUESDAY) + assert write_penalty(entry) + assert "hmac" not in entry + + def test_write_failure_is_false(self) -> None: + with patch.object(Path, "write_text", side_effect=OSError("ro")): + assert not write_penalty(penalty_entry(today=TUESDAY)) + + +class TestMaybeApply: + def _entry(self, outcome: str = "failed") -> dict[str, object]: + return {"outcome": outcome} + + def test_weekend_never_gets_a_penalty(self) -> None: + now = datetime(2026, 9, 26, 12, 0).astimezone() # Saturday + assert not maybe_apply(self._entry(), now) + assert not _workday_penalty.WORKDAY_PENALTY_FILE.exists() + + def test_free_day_never_gets_a_penalty(self) -> None: + now = datetime(2026, 9, 22, 12, 0).astimezone() # Tuesday + with patch( + "wake_alarm._workday_penalty.freedays.is_free_day", return_value=True + ): + assert not maybe_apply(self._entry(), now) + assert not _workday_penalty.WORKDAY_PENALTY_FILE.exists() + + def test_a_completed_stick_day_gets_no_penalty(self) -> None: + now = datetime(2026, 9, 22, 12, 0).astimezone() # Tuesday + with patch( + "wake_alarm._workday_penalty.freedays.is_free_day", return_value=False + ): + assert not maybe_apply(self._entry("completed"), now) + assert not _workday_penalty.WORKDAY_PENALTY_FILE.exists() + + def test_a_missed_stick_day_writes_tomorrows_penalty(self) -> None: + now = datetime(2026, 9, 22, 12, 0).astimezone() # Tuesday + with patch( + "wake_alarm._workday_penalty.freedays.is_free_day", return_value=False + ): + assert maybe_apply(self._entry("failed"), now) + on_disk = json.loads(_workday_penalty.WORKDAY_PENALTY_FILE.read_text()) + assert on_disk["penalty_date"] == "2026-09-23"