test: verify arrow ZZZ token correctly distinguishes CST and CDT

Add 9 unit tests confirming arrow ZZZ format token produces the
correct timezone abbreviation (CST vs CDT) for America/Chicago across
standard time, daylight saving time, and DST transition boundaries.
No code change needed -- arrow handles this correctly.

Filed TASK-020 for the separate issue of stale module-level time
computation in app/main.py.

Closes TASK-015

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: pythoninthegrass

backlog/tasks/task-015 - Fix-timezone-display-to-distinguish-CST-and-CDT.md

@@ -1,10 +1,10 @@
 ---
 id: TASK-015
 title: Fix timezone display to distinguish CST and CDT
-status: To Do
+status: Done
 assignee: []
 created_date: '2026-02-27 00:54'
-updated_date: '2026-03-17 02:09'
+updated_date: '2026-03-21 01:00'
 labels:
   - bug
 dependencies: []
@@ -22,7 +22,62 @@ The /api/check-schedule endpoint formats times with ZZZ (e.g. "Monday 14:00 CST"
 
 ## Acceptance Criteria
 <!-- AC:BEGIN -->
-- [ ] #1 Verify arrow ZZZ output is correct for both CST and CDT with America/Chicago tz
-- [ ] #2 Add tests covering schedule time display in both standard and daylight saving periods
-- [ ] #3 Document findings if no code change is needed
+- [x] #1 Verify arrow ZZZ output is correct for both CST and CDT with America/Chicago tz
+- [x] #2 Add tests covering schedule time display in both standard and daylight saving periods
+- [x] #3 Document findings if no code change is needed
 <!-- AC:END -->
+
+## Implementation Plan
+
+<!-- SECTION:PLAN:BEGIN -->
+## Findings
+
+Arrow's `ZZZ` token correctly outputs "CST" during standard time and "CDT" during daylight saving time when the Arrow datetime has `America/Chicago` timezone. Verified empirically:
+- January 2026: "CST"
+- June 2026: "CDT"
+- March 8 (DST spring-forward): "CDT"
+- November 1 (DST fall-back): "CST"
+
+No code change needed for the ZZZ formatting itself.
+
+## Plan
+
+1. AC #1: Verified — no code change needed
+2. AC #2: Add unit tests in `tests/test_unit.py` that assert arrow `ZZZ` produces correct abbreviations for CST and CDT periods, including DST transition boundaries
+3. AC #3: Document findings in task notes
+
+## Related issue (out of scope)
+
+`current_time_local` in `app/main.py:49` is computed at module load time, not per-request. This means the check-schedule endpoint uses a stale timestamp. Filed as separate task.
+<!-- SECTION:PLAN:END -->
+
+## Implementation Notes
+
+<!-- SECTION:NOTES:BEGIN -->
+## Findings
+
+Arrow's `ZZZ` format token correctly outputs timezone abbreviations based on the actual DST state of the datetime object. When using `America/Chicago`:
+- Standard time (Nov-Mar): outputs "CST"
+- Daylight saving time (Mar-Nov): outputs "CDT"
+- DST transition days: correctly reflects the post-transition state
+
+No code change was needed. The existing `format("dddd HH:mm ZZZ")` calls in `app/main.py:464-465` work correctly.
+
+A separate issue was identified: `current_time_local` is computed at module load time (TASK-020).
+<!-- SECTION:NOTES:END -->
+
+## Final Summary
+
+<!-- SECTION:FINAL_SUMMARY:BEGIN -->
+Verified that arrow's `ZZZ` format token correctly distinguishes CST and CDT when using `America/Chicago` timezone. No code change needed.
+
+Added 9 unit tests in `TestArrowTimezoneAbbreviation` covering:
+- Standard time months (Jan, Feb, Dec) -> CST
+- Daylight saving months (Jun, Jul) -> CDT
+- Spring-forward transition day (Mar 8) -> CDT
+- Fall-back transition day (Nov 1) -> CST
+- Format string shape matching check-schedule endpoint
+- UTC-to-local conversion preserving correct abbreviation
+
+Filed TASK-020 for the separate issue of stale module-level time computation in `app/main.py`.
+<!-- SECTION:FINAL_SUMMARY:END -->

backlog/tasks/task-020 - Fix-stale-module-level-current_time_local-in-main.py.md

@@ -0,0 +1,27 @@
+---
+id: TASK-020
+title: Fix stale module-level current_time_local in main.py
+status: To Do
+assignee: []
+created_date: '2026-03-21 00:58'
+labels:
+  - bug
+dependencies: []
+references:
+  - 'app/main.py:49-51'
+  - 'app/main.py:435-472'
+priority: medium
+---
+
+## Description
+
+<!-- SECTION:DESCRIPTION:BEGIN -->
+`current_time_local` (line 49), `current_time_utc` (line 50), and `current_day` (line 51) in `app/main.py` are computed once at module load time. The `/api/check-schedule` endpoint uses these values, so it always reflects the server startup time rather than the actual request time. This causes incorrect time comparisons and stale timezone abbreviations if the server runs across a DST boundary.
+<!-- SECTION:DESCRIPTION:END -->
+
+## Acceptance Criteria
+<!-- AC:BEGIN -->
+- [ ] #1 current_time_local, current_time_utc, and current_day are computed per-request in endpoints that use them
+- [ ] #2 Existing tests continue to pass
+- [ ] #3 Add test verifying time values reflect request time, not server startup time
+<!-- AC:END -->

tests/test_unit.py

@@ -1113,14 +1113,16 @@ def test_sort_json_human_readable_year_boundary(tmp_path):
 @pytest.mark.unit
 def test_prepare_events_human_readable_year_boundary():
     """prepare_events with human-readable dates near year boundary should not guess wrong year."""
-    df = pd.DataFrame({
-        "name": ["Group A", "Group B"],
-        "date": ["Thu 1/2 6:00 pm", "Mon 12/30 10:00 am"],
-        "title": ["Jan Event", "Dec Event"],
-        "description": ["desc", "desc"],
-        "city": ["OKC", "OKC"],
-        "eventUrl": ["url1", "url2"],
-    })
+    df = pd.DataFrame(
+        {
+            "name": ["Group A", "Group B"],
+            "date": ["Thu 1/2 6:00 pm", "Mon 12/30 10:00 am"],
+            "title": ["Jan Event", "Dec Event"],
+            "description": ["desc", "desc"],
+            "city": ["OKC", "OKC"],
+            "eventUrl": ["url1", "url2"],
+        }
+    )
     with patch("arrow.now", return_value=arrow.get("2024-12-29")):
         result = prepare_events(df)
 
@@ -1132,14 +1134,16 @@ def test_prepare_events_human_readable_year_boundary():
 @pytest.mark.unit
 def test_prepare_events_year_boundary():
     """prepare_events preserves year from ISO 8601 dates near year boundaries."""
-    df = pd.DataFrame({
-        "name": ["Group A", "Group B"],
-        "date": ["2025-01-02T18:00:00", "2024-12-30T10:00:00"],
-        "title": ["Jan Event", "Dec Event"],
-        "description": ["desc", "desc"],
-        "city": ["OKC", "OKC"],
-        "eventUrl": ["url1", "url2"],
-    })
+    df = pd.DataFrame(
+        {
+            "name": ["Group A", "Group B"],
+            "date": ["2025-01-02T18:00:00", "2024-12-30T10:00:00"],
+            "title": ["Jan Event", "Dec Event"],
+            "description": ["desc", "desc"],
+            "city": ["OKC", "OKC"],
+            "eventUrl": ["url1", "url2"],
+        }
+    )
     with patch("arrow.now", return_value=arrow.get("2024-12-29")):
         result = prepare_events(df)
 
@@ -1367,3 +1371,47 @@ def test_partial_failure(self, group_events_fragment):
     def test_empty_list(self):
         results = send_batched_group_request("fake_token", [])
         assert results == []
+
+
+@pytest.mark.unit
+class TestArrowTimezoneAbbreviation:
+    """Verify arrow ZZZ token produces correct CST/CDT for America/Chicago."""
+
+    @pytest.mark.parametrize(
+        "month, day, expected_abbr",
+        [
+            (1, 15, "CST"),
+            (2, 15, "CST"),
+            (6, 15, "CDT"),
+            (7, 15, "CDT"),
+            (12, 15, "CST"),
+        ],
+        ids=["jan-cst", "feb-cst", "jun-cdt", "jul-cdt", "dec-cst"],
+    )
+    def test_standard_and_daylight_periods(self, month, day, expected_abbr):
+        dt = arrow.Arrow(2026, month, day, 14, 0, tzinfo="America/Chicago")
+        formatted = dt.format("dddd HH:mm ZZZ")
+        assert formatted.endswith(expected_abbr)
+
+    def test_spring_forward_transition(self):
+        """March 8, 2026 is spring-forward day — afternoon is CDT."""
+        dt = arrow.Arrow(2026, 3, 8, 14, 0, tzinfo="America/Chicago")
+        assert dt.format("ZZZ") == "CDT"
+
+    def test_fall_back_transition(self):
+        """November 1, 2026 is fall-back day — afternoon is CST."""
+        dt = arrow.Arrow(2026, 11, 1, 14, 0, tzinfo="America/Chicago")
+        assert dt.format("ZZZ") == "CST"
+
+    def test_format_matches_check_schedule_pattern(self):
+        """The format string used in check-schedule produces expected shape."""
+        dt = arrow.Arrow(2026, 1, 15, 14, 0, tzinfo="America/Chicago")
+        result = dt.format("dddd HH:mm ZZZ")
+        assert result == "Thursday 14:00 CST"
+
+    def test_utc_converted_to_local_preserves_abbr(self):
+        """Converting a UTC time to America/Chicago yields the correct abbreviation."""
+        utc_dt = arrow.Arrow(2026, 6, 15, 19, 0, tzinfo="UTC")
+        local_dt = utc_dt.to("America/Chicago")
+        assert local_dt.format("ZZZ") == "CDT"
+        assert local_dt.format("dddd HH:mm ZZZ") == "Monday 14:00 CDT"