cctally 1.11.0 → 1.11.1

package/CHANGELOG.md

@@ -5,6 +5,11 @@ based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [1.11.1] - 2026-05-22
+
+### Changed
+- Promote 23 path globals (`APP_DIR`, `LEGACY_APP_DIR`, `LOG_DIR`, `DB_PATH`, `CACHE_DB_PATH`, `CACHE_LOCK_PATH`, `CACHE_LOCK_CODEX_PATH`, `CONFIG_PATH`, `CONFIG_LOCK_PATH`, `MIGRATION_ERROR_LOG_PATH`, `CHANGELOG_PATH`, all five `HOOK_TICK_*` paths, all six `UPDATE_*` paths, and `CLAUDE_SETTINGS_PATH`) from `bin/cctally` into `bin/_cctally_core.py`; `_cctally_core` is now the single source of truth and the single legal monkeypatch target for these names. `bin/cctally` keeps eager re-exports so external `cctally.X` references (ad-hoc REPL, scripts) still resolve, but internal `bin/cctally` reads (~28 sites) and every `bin/_*.py` sibling read (149 sites across 11 siblings) now go through `_cctally_core.X` at call time. `tests/conftest.py:redirect_paths()` patches `_cctally_core` directly (with an `ns["X"]` introspection mirror); the 80 historical `monkeypatch.setitem(ns, "<NAME>", v)` / `monkeypatch.setattr(cctally, "<NAME>", v)` test sites are migrated to `monkeypatch.setattr(_cctally_core, "<NAME>", v)`. `bin/_cctally_alerts.py` drops its `_cctally()` accessor helper (its only data-global use was `LOG_DIR`); other siblings keep the helper for legitimate non-data deps (validators, threshold constants, `PUBLIC_REPO`, `RELEASE_HEADER_RE`, etc.). The 2026-05-17 kernel-extraction spec's §2.3 path-constant accessor carve-out is retired. `tests/test_kernel_extraction_invariants.py` gains four new AST regression guards that lock the new invariants going forward (`test_promoted_globals_live_in_core`, `test_no_sibling_accessor_reads_promoted_globals`, `test_no_old_style_test_patches_for_promoted_globals`, `test_no_value_imports_of_promoted_globals_in_siblings`). (#84)
+
 ## [1.11.0] - 2026-05-22
 
 ### Added

package/bin/_cctally_alerts.py

@@ -24,11 +24,11 @@ in `bin/_lib_alerts_payload.py` (Phase A extraction); this module
 imports them directly via `_load_lib`, which keeps the dispatch path
 free of an extra bounce through cctally's re-exports.
 
-bin/cctally back-references via `_cctally()` (spec §5.5 pattern, same
-as `bin/_cctally_setup.py`):
-- `LOG_DIR` — base dir under which `alerts.log` lives (subject to
-  HOME-redirection by test fixtures via `monkeypatch.setitem(ns,
-  "LOG_DIR", ...)`).
+Kernel reads from `bin/_cctally_core` (call-time module-attribute access):
+- `LOG_DIR` — base dir under which `alerts.log` lives. Promoted to
+  `_cctally_core` 2026-05-22 (#84); test fixtures redirect via
+  `monkeypatch.setattr(_cctally_core, "LOG_DIR", tmp)` (or the
+  conftest `redirect_paths()` helper).
 - `now_utc_iso` — single timestamp source used for both the log-line
   timestamp and the synthetic test payload's `crossed_at_utc`.
 
@@ -50,10 +50,7 @@ import pathlib
 import subprocess
 import sys
 
-
-def _cctally():
-    """Resolve the current `cctally` module at call-time (spec §5.5)."""
-    return sys.modules["cctally"]
+import _cctally_core
 
 
 def _load_lib(name: str):
@@ -77,22 +74,21 @@ _build_alert_payload_five_hour = _lib_alerts_payload._build_alert_payload_five_h
 
 
 # === Honest imports from extracted homes ===================================
-# Spec 2026-05-17-cctally-core-kernel-extraction.md §3.3: kernel symbols
-# import from _cctally_core. `LOG_DIR` stays on the _cctally() accessor
-# per Q1=B (path constants propagate via monkeypatch.setitem against the
-# cctally namespace).
+# Spec 2026-05-17 §3.3: kernel symbols import from _cctally_core.
+# LOG_DIR was promoted to _cctally_core 2026-05-22 (#84) and is read
+# via call-time module-attribute access (this sibling no longer needs
+# the historical _cctally() accessor).
 from _cctally_core import now_utc_iso
 
 
 def _alerts_log_path() -> "pathlib.Path":
     """Return ``~/.local/share/cctally/logs/alerts.log`` (parent dirs created).
 
-    Resolves through the same ``APP_DIR`` / ``LOG_DIR`` derived at module
-    import time from ``Path.home()``, so a HOME override before import (the
-    pattern used elsewhere in this codebase — e.g. ``cctally-config-test``)
-    transparently relocates the log without a separate env-var convention.
+    Reads ``LOG_DIR`` from ``_cctally_core`` at call time. Tests patch via
+    ``monkeypatch.setattr(_cctally_core, "LOG_DIR", tmp)`` (or the
+    conftest ``redirect_paths()`` helper).
     """
-    log_dir = _cctally().LOG_DIR
+    log_dir = _cctally_core.LOG_DIR
     log_dir.mkdir(parents=True, exist_ok=True)
     return log_dir / "alerts.log"
 

package/bin/_cctally_cache.py

@@ -41,21 +41,18 @@ Holds:
 - ``cmd_cache_sync`` — entry point for ``cctally cache-sync
   [--source {claude,codex,all}] [--rebuild]``.
 
-What stays in bin/cctally:
+What lives in bin/_cctally_core (promoted 2026-05-22, #84):
 - Path constants ``APP_DIR``, ``CACHE_DB_PATH``, ``CACHE_LOCK_PATH``,
-  ``CACHE_LOCK_CODEX_PATH``, ``CODEX_SESSIONS_DIR`` — referenced from
-  the moved bodies via the ``c = _cctally()`` call-time accessor
-  pattern (spec §5.5, same as ``bin/_lib_subscription_weeks.py`` and
-  ``bin/_lib_aggregators.py``). The accessor resolves
-  ``sys.modules['cctally'].X`` on every call, so
-  ``monkeypatch.setitem(ns, "CACHE_DB_PATH", tmp)`` and conftest
-  ``redirect_paths`` HOME redirects propagate transparently with NO
-  test-side changes (tests already patch ``ns["CACHE_DB_PATH"]`` etc.
-  by setitem on the dict-as-module bridge). We chose ``c.X`` over the
-  ``_cctally_db.py``-style seed block here because cache tests are
-  widely scattered (record-usage tick, dashboard panels, share render
-  kernel, block tests, every JSONL-reading subcommand fixture) and
-  Phase C-style inline patching would touch dozens of sites.
+  ``CACHE_LOCK_CODEX_PATH``. Moved bodies read these via call-time
+  ``_cctally_core.X`` and tests patch via
+  ``monkeypatch.setattr(_cctally_core, "X", v)`` (or the conftest
+  ``redirect_paths()`` helper). The legacy
+  ``setitem(ns, "CACHE_DB_PATH", …)`` pattern is forbidden by
+  ``test_no_old_style_test_patches_for_promoted_globals``.
+
+What stays in bin/cctally:
+- ``CODEX_SESSIONS_DIR`` — out of scope for #84; still read via the
+  ``c = _cctally()`` call-time accessor (spec §5.5).
 - ``_sum_cost_for_range`` — sits at the cache↔report boundary; 6+
   callers outside cache (forecast, weekly, report, project, doctor),
   so the directive keeps it on the bin/cctally side.
@@ -122,6 +119,7 @@ def _cctally():
 # Spec 2026-05-17-cctally-core-kernel-extraction.md §3.3: kernel symbols
 # (Z-leaf + Z-mid) import from _cctally_core. The legacy shim function
 # for ``eprint`` is deleted.
+import _cctally_core
 from _cctally_core import eprint
 
 
@@ -175,11 +173,12 @@ _CACHE_MIGRATIONS = _cctally_db_sib._CACHE_MIGRATIONS
 
 
 # === BEGIN MOVED REGIONS ===
-# Path constants (APP_DIR, CACHE_DB_PATH, CACHE_LOCK_PATH,
-# CACHE_LOCK_CODEX_PATH, CODEX_SESSIONS_DIR) are accessed via the
-# `c = _cctally()` call-time accessor inside each function that
-# needs them — so ``monkeypatch.setitem(ns, "CACHE_DB_PATH", tmp)``
-# in tests resolves on every read (no stale module-level binding).
+# Path constants APP_DIR / CACHE_DB_PATH / CACHE_LOCK_PATH /
+# CACHE_LOCK_CODEX_PATH live in _cctally_core (promoted 2026-05-22, #84);
+# moved bodies read them via call-time ``_cctally_core.X`` and tests
+# patch via ``monkeypatch.setattr(_cctally_core, "X", v)``.
+# CODEX_SESSIONS_DIR stays in bin/cctally (out of scope for #84) and is
+# still accessed via the ``c = _cctally()`` call-time accessor.
 
 # === Region 1: ProjectKey + _resolve_project_key (was bin/cctally:1994-2069) ===
 
@@ -422,10 +421,10 @@ def sync_cache(
     """
     stats = IngestStats()
     c = _cctally()
-    c.APP_DIR.mkdir(parents=True, exist_ok=True)
-    c.CACHE_LOCK_PATH.touch()
+    _cctally_core.APP_DIR.mkdir(parents=True, exist_ok=True)
+    _cctally_core.CACHE_LOCK_PATH.touch()
 
-    lock_fh = open(c.CACHE_LOCK_PATH, "w")
+    lock_fh = open(_cctally_core.CACHE_LOCK_PATH, "w")
     try:
         try:
             fcntl.flock(lock_fh, fcntl.LOCK_EX | fcntl.LOCK_NB)
@@ -914,10 +913,10 @@ def sync_codex_cache(
     """
     stats = CodexIngestStats()
     c = _cctally()
-    c.APP_DIR.mkdir(parents=True, exist_ok=True)
-    c.CACHE_LOCK_CODEX_PATH.touch()
+    _cctally_core.APP_DIR.mkdir(parents=True, exist_ok=True)
+    _cctally_core.CACHE_LOCK_CODEX_PATH.touch()
 
-    lock_fh = open(c.CACHE_LOCK_CODEX_PATH, "w")
+    lock_fh = open(_cctally_core.CACHE_LOCK_CODEX_PATH, "w")
     try:
         try:
             fcntl.flock(lock_fh, fcntl.LOCK_EX | fcntl.LOCK_NB)
@@ -1263,17 +1262,17 @@ def open_cache_db() -> sqlite3.Connection:
     recreated — the cache is fully re-derivable from JSONL, so this is safe.
     """
     c = _cctally()
-    c.APP_DIR.mkdir(parents=True, exist_ok=True)
+    _cctally_core.APP_DIR.mkdir(parents=True, exist_ok=True)
     try:
-        conn = sqlite3.connect(c.CACHE_DB_PATH)
+        conn = sqlite3.connect(_cctally_core.CACHE_DB_PATH)
         conn.execute("SELECT 1").fetchone()
     except sqlite3.DatabaseError as exc:
         eprint(f"[cache] corrupt cache DB ({exc}); recreating")
         try:
-            c.CACHE_DB_PATH.unlink()
+            _cctally_core.CACHE_DB_PATH.unlink()
         except FileNotFoundError:
             pass
-        conn = sqlite3.connect(c.CACHE_DB_PATH)
+        conn = sqlite3.connect(_cctally_core.CACHE_DB_PATH)
 
     conn.execute("PRAGMA journal_mode=WAL")
     conn.execute("PRAGMA busy_timeout=5000")

package/bin/_cctally_config.py

@@ -9,25 +9,31 @@ predicate, `sync-week`, …) all resolve unchanged. Tests that mock
 work because Python's bare-name lookup inside non-extracted bin/cctally
 callers resolves in bin/cctally's namespace (where the re-export lives).
 
+What lives in bin/_cctally_core (promoted 2026-05-22, #84):
+  - ``CONFIG_PATH`` / ``CONFIG_LOCK_PATH`` path constants. Reads use
+    call-time ``_cctally_core.CONFIG_PATH`` / ``_cctally_core.CONFIG_LOCK_PATH``;
+    tests patch via ``monkeypatch.setattr(_cctally_core, "X", v)`` (or
+    the conftest ``redirect_paths()`` helper). The legacy
+    ``setitem(ns, "CONFIG_PATH", …)`` pattern is forbidden by
+    ``test_no_old_style_test_patches_for_promoted_globals``.
+
 What stays in bin/cctally:
   - ``_ALERTS_BAD_CONFIG_WARNED`` + ``_warn_alerts_bad_config_once`` —
     alerts-coupled warn-once flag/helper; the alerts-config readers
     (``_get_alerts_config`` / ``_AlertsConfigError``) still live in
     bin/cctally and these two travel with that block.
-  - ``CONFIG_PATH`` / ``CONFIG_LOCK_PATH`` path constants (spec §86–92
-    keeps every path constant in bin/cctally so monkeypatched
-    `cctally.CONFIG_PATH = …` redirects propagate everywhere).
   - ``eprint`` / ``ensure_dirs`` / ``DEFAULT_WEEK_START`` ubiquitous
     helpers/constants.
-  - All validator/normalizer primitives (``normalize_display_tz_value``,
-    ``_get_alerts_config``, ``_AlertsConfigError``,
-    ``_normalize_alerts_enabled_value``, ``_validate_dashboard_bind_value``,
+  - Non-path validator/normalizer primitives
+    (``_normalize_alerts_enabled_value``, ``_validate_dashboard_bind_value``,
     ``_normalize_update_check_enabled_value``,
     ``_validate_update_check_ttl_hours_value``,
     ``UPDATE_DEFAULT_TTL_HOURS``, ``get_display_tz_pref``) — these stay
     near the subsystem they belong to; we reach them via the
     ``_cctally()`` accessor (call-time lookup so test monkeypatches on
     bin/cctally's namespace still propagate, per spec §5.2).
+    (``normalize_display_tz_value`` imports directly from
+    ``_lib_display_tz`` — see the import block below.)
 
 Spec: docs/superpowers/specs/2026-05-13-bin-cctally-split-design.md
 """
@@ -49,14 +55,17 @@ def _cctally():
 
 
 # === Honest imports from extracted homes ===================================
-# Spec 2026-05-17-cctally-core-kernel-extraction.md §3.3: kernel symbols
-# import from _cctally_core; the Bucket-X helper `normalize_display_tz_value`
-# imports from `_lib_display_tz`. Path constants (`CONFIG_PATH`,
-# `CONFIG_LOCK_PATH`) plus out-of-scope validators
-# (`_normalize_alerts_enabled_value`, `_validate_dashboard_bind_value`,
-# `_validate_update_check_ttl_hours_value`, `_normalize_update_check_enabled_value`,
-# `get_display_tz_pref`, `UPDATE_DEFAULT_TTL_HOURS`) stay on the
-# _cctally() accessor.
+# Spec 2026-05-17 §3.3: kernel symbols import from _cctally_core; the
+# Bucket-X helper ``normalize_display_tz_value`` imports from
+# ``_lib_display_tz``. Path constants (``CONFIG_PATH``,
+# ``CONFIG_LOCK_PATH``) moved to _cctally_core 2026-05-22 (#84) and are
+# read via call-time ``_cctally_core.CONFIG_PATH`` etc. The out-of-scope
+# non-path validators (``_normalize_alerts_enabled_value``,
+# ``_validate_dashboard_bind_value``,
+# ``_validate_update_check_ttl_hours_value``,
+# ``_normalize_update_check_enabled_value``, ``get_display_tz_pref``,
+# ``UPDATE_DEFAULT_TTL_HOURS``) stay on the _cctally() accessor.
+import _cctally_core
 from _cctally_core import (
     eprint,
     ensure_dirs,
@@ -81,7 +90,7 @@ def _warn_config_corrupt_once(reason: str) -> None:
     _CONFIG_CORRUPT_WARNED = True
     c = _cctally()
     eprint(
-        f"warning: ignoring corrupt {c.CONFIG_PATH} ({reason}); "
+        f"warning: ignoring corrupt {_cctally_core.CONFIG_PATH} ({reason}); "
         "using in-memory defaults"
     )
 
@@ -106,10 +115,10 @@ def _try_read_config() -> "dict[str, Any] | None":
     config writer lock.
     """
     c = _cctally()
-    if not c.CONFIG_PATH.exists():
+    if not _cctally_core.CONFIG_PATH.exists():
         return None
     try:
-        raw = c.CONFIG_PATH.read_text(encoding="utf-8")
+        raw = _cctally_core.CONFIG_PATH.read_text(encoding="utf-8")
     except OSError as exc:
         _warn_config_corrupt_once(f"read failed: {exc}")
         return None
@@ -141,8 +150,8 @@ def config_writer_lock():
     """
     c = _cctally()
     ensure_dirs()
-    c.CONFIG_LOCK_PATH.touch()
-    fh = open(c.CONFIG_LOCK_PATH, "w")
+    _cctally_core.CONFIG_LOCK_PATH.touch()
+    fh = open(_cctally_core.CONFIG_LOCK_PATH, "w")
     try:
         fcntl.flock(fh, fcntl.LOCK_EX)
         try:
@@ -177,7 +186,7 @@ def load_config() -> dict[str, Any]:
     if parsed is not None:
         return parsed
 
-    if c.CONFIG_PATH.exists():
+    if _cctally_core.CONFIG_PATH.exists():
         # Corrupt file: warning already emitted by _try_read_config.
         # Return in-memory defaults; do NOT persist — a transient
         # corruption is recoverable by the next legitimate
@@ -227,14 +236,14 @@ def save_config(data: dict[str, Any]) -> None:
     c = _cctally()
     ensure_dirs()
     payload = (json.dumps(data, indent=2) + "\n").encode("utf-8")
-    tmp = c.CONFIG_PATH.with_name(f"{c.CONFIG_PATH.name}.tmp.{os.getpid()}")
+    tmp = _cctally_core.CONFIG_PATH.with_name(f"{_cctally_core.CONFIG_PATH.name}.tmp.{os.getpid()}")
     fd = os.open(str(tmp), os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o644)
     try:
         os.write(fd, payload)
         os.fsync(fd)
     finally:
         os.close(fd)
-    os.replace(str(tmp), str(c.CONFIG_PATH))
+    os.replace(str(tmp), str(_cctally_core.CONFIG_PATH))
 
 
 ALLOWED_CONFIG_KEYS = (

package/bin/_cctally_core.py

@@ -5,14 +5,15 @@ logging (eprint), datetime helpers, week-name/bounds, time-of-day,
 alerts-config validation, open_db, WeekRef + make_week_ref,
 get_latest_usage_for_week.
 
-Path constants (APP_DIR, DB_PATH, LOG_DIR) intentionally live in
-bin/cctally and are read here via a call-time _cctally() accessor —
-this is the ONLY accessor use inside core. See
-docs/superpowers/specs/2026-05-17-cctally-core-kernel-extraction.md §2.
+Path constants (APP_DIR, DB_PATH, LOG_DIR, etc.) live in this module as
+of 2026-05-22 (issue #84); `_cctally_core` is the single source of truth
+and the only legal monkeypatch target for the 23 promoted globals listed
+below. See docs/superpowers/specs/2026-05-22-cctally-core-data-globals.md.
 """
 from __future__ import annotations
 import datetime as dt
 import os
+import pathlib
 import re
 import sqlite3
 import sys
@@ -25,6 +26,92 @@ def _cctally():
     return sys.modules["cctally"]
 
 
+# === Path constants ==================================================
+#
+# Promoted from bin/cctally per docs/superpowers/specs/2026-05-22-cctally-core-data-globals.md.
+# After this promotion `_cctally_core` is the single source of truth and
+# the only legal monkeypatch target. `bin/cctally` keeps eager re-exports
+# for ad-hoc REPL / scripts; tests MUST target this module directly.
+#
+# Path-constant initialization is wrapped in `_init_paths_from_env()` so
+# `tests/conftest.py:load_script()` can re-derive them from the current
+# HOME env var without re-importing this module (which would invalidate
+# tests' module-top `import _cctally_core` references). The bare module
+# attributes below are populated by the call to _init_paths_from_env()
+# at import time; subsequent load_script calls invoke it again.
+
+
+def _init_paths_from_env() -> None:
+    """(Re)bind the 23 in-scope path globals from the current process env.
+
+    22 of the 23 resolve under ``Path.home()`` (i.e. the ``HOME`` env var).
+    The 23rd, ``CHANGELOG_PATH``, resolves from ``CCTALLY_TEST_CHANGELOG_PATH``
+    when set, else from ``__file__`` (``<repo>/CHANGELOG.md`` relative to
+    this kernel module's location) — independent of ``HOME``. Tests that
+    redirect the changelog (e.g. ``tests/test_release_internals.py``) drive
+    that override and rely on this re-init.
+
+    Called once at module import to populate the defaults, then again
+    by `tests/conftest.py:load_script()` after each `setenv("HOME", …)`
+    or `setenv("CCTALLY_TEST_CHANGELOG_PATH", …)` so the test sees a fresh
+    path set without the cost of re-importing `_cctally_core` (which would
+    break tests that cached the module object via a top-level
+    `import _cctally_core`).
+    """
+    global APP_DIR, LEGACY_APP_DIR, LOG_DIR
+    global DB_PATH, CACHE_DB_PATH
+    global CACHE_LOCK_PATH, CACHE_LOCK_CODEX_PATH, CONFIG_LOCK_PATH
+    global CONFIG_PATH, MIGRATION_ERROR_LOG_PATH, CHANGELOG_PATH
+    global HOOK_TICK_LOG_DIR, HOOK_TICK_LOG_PATH, HOOK_TICK_LOG_ROTATED_PATH
+    global HOOK_TICK_THROTTLE_PATH, HOOK_TICK_THROTTLE_LOCK_PATH
+    global UPDATE_STATE_PATH, UPDATE_SUPPRESS_PATH
+    global UPDATE_LOCK_PATH, UPDATE_LOG_PATH, UPDATE_LOG_ROTATED_PATH
+    global UPDATE_CHECK_LAST_FETCH_PATH, CLAUDE_SETTINGS_PATH
+
+    home = pathlib.Path.home()
+    APP_DIR = home / ".local" / "share" / "cctally"
+    LEGACY_APP_DIR = home / ".local" / "share" / "ccusage-subscription"
+    LOG_DIR = APP_DIR / "logs"
+
+    DB_PATH = APP_DIR / "stats.db"
+    CACHE_DB_PATH = APP_DIR / "cache.db"
+
+    CACHE_LOCK_PATH = APP_DIR / "cache.db.lock"
+    CACHE_LOCK_CODEX_PATH = APP_DIR / "cache.db.codex.lock"
+    CONFIG_LOCK_PATH = APP_DIR / "config.json.lock"
+
+    CONFIG_PATH = APP_DIR / "config.json"
+
+    MIGRATION_ERROR_LOG_PATH = LOG_DIR / "migration-errors.log"
+
+    # CHANGELOG_PATH: honor CCTALLY_TEST_CHANGELOG_PATH env override; otherwise
+    # resolves to <repo>/CHANGELOG.md based on bin/_cctally_core.py's
+    # location (alongside bin/cctally, so the parent chain is the same).
+    override = os.environ.get("CCTALLY_TEST_CHANGELOG_PATH")
+    if override:
+        CHANGELOG_PATH = pathlib.Path(override)
+    else:
+        CHANGELOG_PATH = pathlib.Path(__file__).resolve().parent.parent / "CHANGELOG.md"
+
+    HOOK_TICK_LOG_DIR = APP_DIR / "logs"
+    HOOK_TICK_LOG_PATH = HOOK_TICK_LOG_DIR / "hook-tick.log"
+    HOOK_TICK_LOG_ROTATED_PATH = HOOK_TICK_LOG_DIR / "hook-tick.log.1"
+    HOOK_TICK_THROTTLE_PATH = APP_DIR / "hook-tick.last-fetch"
+    HOOK_TICK_THROTTLE_LOCK_PATH = APP_DIR / "hook-tick.last-fetch.lock"
+
+    UPDATE_STATE_PATH = APP_DIR / "update-state.json"
+    UPDATE_SUPPRESS_PATH = APP_DIR / "update-suppress.json"
+    UPDATE_LOCK_PATH = APP_DIR / "update.lock"
+    UPDATE_LOG_PATH = APP_DIR / "update.log"
+    UPDATE_LOG_ROTATED_PATH = APP_DIR / "update.log.1"
+    UPDATE_CHECK_LAST_FETCH_PATH = APP_DIR / "update-check.last-fetch"
+
+    CLAUDE_SETTINGS_PATH = home / ".claude" / "settings.json"
+
+
+_init_paths_from_env()
+
+
 # === Logging =========================================================
 
 
@@ -240,9 +327,8 @@ def compute_week_bounds(anchor_dt: dt.datetime, week_start_name: str) -> tuple[d
 
 
 def ensure_dirs() -> None:
-    c = _cctally()
-    c.APP_DIR.mkdir(parents=True, exist_ok=True)
-    c.LOG_DIR.mkdir(parents=True, exist_ok=True)
+    APP_DIR.mkdir(parents=True, exist_ok=True)
+    LOG_DIR.mkdir(parents=True, exist_ok=True)
 
 
 # === Alerts validation cluster ======================================
@@ -353,7 +439,7 @@ def open_db() -> sqlite3.Connection:
     _clear_migration_error_log_entries = c._clear_migration_error_log_entries
 
     ensure_dirs()
-    conn = sqlite3.connect(c.DB_PATH)
+    conn = sqlite3.connect(DB_PATH)
     conn.row_factory = sqlite3.Row
     conn.execute("PRAGMA journal_mode=WAL")
     conn.execute("PRAGMA synchronous=NORMAL")

package/bin/_cctally_dashboard.py

@@ -256,6 +256,7 @@ def _cctally():
 # import from _cctally_core; already-decentralized buckets (X = _lib_*,
 # Y = _cctally_*) import from their natural home. These bypass the
 # legacy shim pattern entirely.
+import _cctally_core
 from _cctally_core import (
     eprint,
     now_utc_iso,
@@ -6548,7 +6549,7 @@ class DashboardHTTPHandler(BaseHTTPRequestHandler):
                 c = _cctally()
                 conn.execute(
                     "ATTACH DATABASE ? AS cache_db",
-                    (str(c.CACHE_DB_PATH),),
+                    (str(_cctally_core.CACHE_DB_PATH),),
                 )
                 conn.execute(
                     "CREATE TEMP VIEW IF NOT EXISTS session_entries AS "

package/bin/_cctally_db.py

@@ -34,15 +34,22 @@ Holds:
   ``_db_path_for_label``).
 
 What stays in bin/cctally (reached via the ``_cctally()`` accessor):
-- Path constants ``STATS_DB_PATH``, ``CACHE_DB_PATH``,
-  ``MIGRATION_ERROR_LOG_PATH``, ``LOG_DIR`` (spec §86–92 — every
-  path constant stays so monkeypatched HOME redirects propagate).
 - ``open_db`` / ``open_cache_db`` — DB-open primitives that CALL
   the dispatcher; they're the boundary owners, not internal to the
   migration system.
-- ``now_utc_iso``, ``parse_iso_datetime``, ``_compute_block_totals``,
-  ``eprint``, ``format_local_iso`` — tiny helpers / hot-path entry
-  points consumed by migration handlers + cmd_db_status renderers.
+- ``_compute_block_totals`` — Z-high callable consumed by migration
+  handlers; reached via the back-ref shim at the top of this module.
+
+Path constants reached via ``_cctally_core.X`` at call time:
+``DB_PATH`` / ``CACHE_DB_PATH`` / ``LOG_DIR`` /
+``MIGRATION_ERROR_LOG_PATH``. After the data-globals promotion
+(2026-05-22, issue #84) ``_cctally_core`` is the single source of
+truth and the only legal monkeypatch target; tests redirecting
+``HOME`` via ``redirect_paths`` propagate without a sibling-side
+seed block in ``bin/cctally``.
+
+Kernel helpers (``now_utc_iso``, ``parse_iso_datetime``, ``eprint``)
+are direct-imported from ``_cctally_core`` per spec §3.3.
 
 §5.6 audit: zero monkeypatch sites on any moved symbol — the
 extraction is pure-mechanical. No Option C call-site rewrites
@@ -75,6 +82,7 @@ def _cctally():
 # Spec 2026-05-17-cctally-core-kernel-extraction.md §3.3: kernel symbols
 # import from _cctally_core. The legacy shim functions for these names
 # are deleted.
+import _cctally_core
 from _cctally_core import (
     eprint,
     now_utc_iso,
@@ -89,10 +97,12 @@ from _cctally_core import (
 # _cctally_cache via get_claude_session_entries) and is explicitly listed
 # in spec §3.7's stays-on-shim allowlist.
 #
-# Path constants and rarer helpers (`MIGRATION_ERROR_LOG_PATH`,
-# `LOG_DIR`, `DB_PATH`, `CACHE_DB_PATH`, `format_local_iso`) are
-# accessed via the standard `c = _cctally()` + `c.X` pattern instead
-# (call-time lookup so fixture-HOME redirects propagate).
+# Path constants (`MIGRATION_ERROR_LOG_PATH`, `LOG_DIR`, `DB_PATH`,
+# `CACHE_DB_PATH`) are accessed via `_cctally_core.X` at call time —
+# the canonical sibling pattern after the data-globals promotion
+# (2026-05-22, issue #84). `_cctally_core` is the single source of
+# truth and the only legal monkeypatch target; bin/cctally no longer
+# seeds duplicates into this module's namespace.
 def _compute_block_totals(*args, **kwargs):
     return sys.modules["cctally"]._compute_block_totals(*args, **kwargs)
 
@@ -101,9 +111,11 @@ def _compute_block_totals(*args, **kwargs):
 # Regions below are inserted verbatim from bin/cctally. Bare-name
 # references to `now_utc_iso(...)`, `parse_iso_datetime(...)`,
 # `_compute_block_totals(...)`, and `eprint(...)` resolve to the shims
-# above. Path-constant references (`MIGRATION_ERROR_LOG_PATH`,
-# `LOG_DIR`, `DB_PATH`, `CACHE_DB_PATH`) get rewritten to `c.X` form
-# with a top-of-function `c = _cctally()` binding inserted.
+# / direct imports above. Path-constant references
+# (`MIGRATION_ERROR_LOG_PATH`, `LOG_DIR`, `DB_PATH`, `CACHE_DB_PATH`)
+# are read as `_cctally_core.X` at call time (post-#84 canonical
+# sibling pattern; no `c = _cctally()` binding required for path
+# reads, since `_cctally_core` is direct-imported above).
 
 # === Region 1: add_column_if_missing (was bin/cctally:8584-8621) ===
 
@@ -697,12 +709,12 @@ def _log_migration_error(*, name: str, exc: BaseException, tb: str) -> None:
     # crash). Acceptable per "best effort" design — concurrent migration
     # failures are vanishingly rare since open_db() serializes via WAL.
     try:
-        LOG_DIR.mkdir(parents=True, exist_ok=True)
+        _cctally_core.LOG_DIR.mkdir(parents=True, exist_ok=True)
         ts = now_utc_iso()
         one_line_err = str(exc).replace("\n", " ").strip() or exc.__class__.__name__
         indented_tb = "\n".join("  " + line for line in tb.rstrip().splitlines())
         block = f"[{ts}] {name}\n  {one_line_err}\n{indented_tb}\n\n"
-        with open(MIGRATION_ERROR_LOG_PATH, "a") as fh:
+        with open(_cctally_core.MIGRATION_ERROR_LOG_PATH, "a") as fh:
             fh.write(block)
     except Exception as log_exc:
         eprint(f"[migration-error-log] failed to write: {log_exc}")
@@ -723,9 +735,9 @@ def _clear_migration_error_log_entries(name: str) -> None:
     # extra banner cycle. Not worth fcntl.flock complexity for failure-rare
     # code path.
     try:
-        if not MIGRATION_ERROR_LOG_PATH.exists():
+        if not _cctally_core.MIGRATION_ERROR_LOG_PATH.exists():
             return
-        content = MIGRATION_ERROR_LOG_PATH.read_text()
+        content = _cctally_core.MIGRATION_ERROR_LOG_PATH.read_text()
         # Entries are separated by "\n\n". Each entry's first line is
         # "[ts] <name>".
         blocks = [b for b in content.split("\n\n") if b.strip()]
@@ -737,9 +749,9 @@ def _clear_migration_error_log_entries(name: str) -> None:
                 continue
             kept.append(block)
         if not kept:
-            MIGRATION_ERROR_LOG_PATH.unlink()
+            _cctally_core.MIGRATION_ERROR_LOG_PATH.unlink()
             return
-        MIGRATION_ERROR_LOG_PATH.write_text("\n\n".join(kept) + "\n\n")
+        _cctally_core.MIGRATION_ERROR_LOG_PATH.write_text("\n\n".join(kept) + "\n\n")
     except Exception as exc:
         eprint(
             f"[migration-error-log] failed to clear entries for {name}: {exc}"
@@ -753,10 +765,10 @@ def _render_migration_error_banner() -> str | None:
     Parses the most recent entry's first line for the migration name and
     timestamp. Falls back to a generic message on parse failure.
     """
-    if not MIGRATION_ERROR_LOG_PATH.exists():
+    if not _cctally_core.MIGRATION_ERROR_LOG_PATH.exists():
         return None
     try:
-        content = MIGRATION_ERROR_LOG_PATH.read_text()
+        content = _cctally_core.MIGRATION_ERROR_LOG_PATH.read_text()
     except Exception:
         return None
     if not content.strip():
@@ -774,13 +786,13 @@ def _render_migration_error_banner() -> str | None:
             if ts and name:
                 return (
                     f"⚠ cctally: migration `{name}` failed at {ts}. "
-                    f"See {MIGRATION_ERROR_LOG_PATH}"
+                    f"See {_cctally_core.MIGRATION_ERROR_LOG_PATH}"
                 )
         except Exception:
             pass
     return (
         f"⚠ cctally: migration error logged. "
-        f"See {MIGRATION_ERROR_LOG_PATH}"
+        f"See {_cctally_core.MIGRATION_ERROR_LOG_PATH}"
     )
 
 
@@ -1737,8 +1749,8 @@ def cmd_db_status(args: argparse.Namespace) -> int:
     payload = {
         "schema_version": 1,
         "databases": {
-            "stats.db": _db_status_for(DB_PATH, _STATS_MIGRATIONS, "stats.db"),
-            "cache.db": _db_status_for(CACHE_DB_PATH, _CACHE_MIGRATIONS, "cache.db"),
+            "stats.db": _db_status_for(_cctally_core.DB_PATH, _STATS_MIGRATIONS, "stats.db"),
+            "cache.db": _db_status_for(_cctally_core.CACHE_DB_PATH, _CACHE_MIGRATIONS, "cache.db"),
         },
     }
     if getattr(args, "json", False):
@@ -1828,7 +1840,7 @@ def _db_status_for(
                 "seq": m.seq, "name": m.name,
                 "status": "failed",
                 "last_failure_at": failed_names[m.name],
-                "log_path": str(MIGRATION_ERROR_LOG_PATH),
+                "log_path": str(_cctally_core.MIGRATION_ERROR_LOG_PATH),
             })
         else:
             migrations_out.append({
@@ -1852,11 +1864,11 @@ def _db_status_failed_names_from_log(db_label: str) -> dict[str, str]:
     `merge_5h_block_duplicates_v1` are bootstrap-renamed at next open
     (via Task 4) so they don't accumulate post-PR.
     """
-    if not MIGRATION_ERROR_LOG_PATH.exists():
+    if not _cctally_core.MIGRATION_ERROR_LOG_PATH.exists():
         return {}
     out: dict[str, str] = {}
     try:
-        content = MIGRATION_ERROR_LOG_PATH.read_text()
+        content = _cctally_core.MIGRATION_ERROR_LOG_PATH.read_text()
     except Exception:
         return {}
     blocks = [b for b in content.split("\n\n") if b.strip()]
@@ -1929,9 +1941,9 @@ def _db_resolve_migration_name(name_arg: str) -> tuple[str, str, list[Migration]
 
 def _db_path_for_label(db_label: str) -> pathlib.Path:
     if db_label == "stats.db":
-        return DB_PATH
+        return _cctally_core.DB_PATH
     if db_label == "cache.db":
-        return CACHE_DB_PATH
+        return _cctally_core.CACHE_DB_PATH
     raise ValueError(f"unknown db_label: {db_label}")