cctally 1.11.0 → 1.12.0

package/bin/_cctally_record.py

@@ -158,6 +158,7 @@ def _cctally():
 
 # === Honest imports from extracted homes ===================================
 # Spec 2026-05-17-cctally-core-kernel-extraction.md §3.3.
+import _cctally_core
 from _cctally_core import (
     eprint,
     now_utc_iso,
@@ -312,18 +313,17 @@ _logged_window_key_coerce_failure = False
 
 
 # === BEGIN MOVED REGIONS ===
-# Path constants (APP_DIR, HOOK_TICK_*) are accessed via the
-# `c = _cctally()` call-time accessor inside each function that needs
-# them — so ``monkeypatch.setitem(ns, "APP_DIR", tmp)`` in tests
-# resolves on every read (no stale module-level binding).
+# Path constants (APP_DIR, HOOK_TICK_*) moved to _cctally_core
+# 2026-05-22 (#84). Reads use call-time ``_cctally_core.X``; tests
+# patch via ``monkeypatch.setattr(_cctally_core, "X", v)``.
 #
-# Constants pulled from cctally at call time:
+# Constants pulled at call time:
+#   _cctally_core.APP_DIR
+#   _cctally_core.HOOK_TICK_LOG_DIR / _PATH / _ROTATED_PATH / _ROTATE_BYTES
+#   _cctally_core.HOOK_TICK_THROTTLE_PATH / _LOCK_PATH
 #   c._FIVE_HOUR_JITTER_FLOOR_SECONDS — _lib_five_hour.* re-export
 #   c._RESET_PCT_DROP_THRESHOLD       — bin/cctally module-level constant
-#   c.HOOK_TICK_LOG_DIR / _PATH / _ROTATED_PATH / _ROTATE_BYTES
-#   c.HOOK_TICK_THROTTLE_PATH / _LOCK_PATH
 #   c.HOOK_TICK_DEFAULT_THROTTLE_SECONDS
-#   c.APP_DIR
 
 
 def _normalize_percent(value: "float | int | None") -> "float | None":
@@ -1521,7 +1521,7 @@ def cmd_record_usage(args: argparse.Namespace) -> int:
                         # record-usage reader doesn't see the new HWM
                         # before the event row is durable.
                         try:
-                            (c.APP_DIR / "hwm-7d").write_text(
+                            (_cctally_core.APP_DIR / "hwm-7d").write_text(
                                 f"{week_start_date} {weekly_percent}\n"
                             )
                         except OSError:
@@ -1731,7 +1731,7 @@ def cmd_record_usage(args: argparse.Namespace) -> int:
                             # matches the canonical writer:
                             # ``<key> <percent>\n``.
                             try:
-                                (c.APP_DIR / "hwm-5h").write_text(
+                                (_cctally_core.APP_DIR / "hwm-5h").write_text(
                                     f"{int(five_hour_window_key)} "
                                     f"{float(five_hour_percent)}\n"
                                 )
@@ -2096,7 +2096,7 @@ def cmd_record_usage(args: argparse.Namespace) -> int:
     # Write high-water mark so the status line never displays a regression.
     # The file contains "week_start_date weekly_percent" on one line.
     try:
-        hwm_path = c.APP_DIR / "hwm-7d"
+        hwm_path = _cctally_core.APP_DIR / "hwm-7d"
         existing_hwm = 0.0
         try:
             parts = hwm_path.read_text().strip().split()
@@ -2119,7 +2119,7 @@ def cmd_record_usage(args: argparse.Namespace) -> int:
     ):
         try:
             five_resets_key = five_hour_window_key
-            hwm5_path = c.APP_DIR / "hwm-5h"
+            hwm5_path = _cctally_core.APP_DIR / "hwm-5h"
             existing_hwm5 = 0.0
             try:
                 parts5 = hwm5_path.read_text().strip().split()
@@ -2143,8 +2143,8 @@ def _hook_tick_log_line(line: str) -> None:
     """
     c = _cctally()
     try:
-        c.HOOK_TICK_LOG_DIR.mkdir(parents=True, exist_ok=True)
-        fd = os.open(c.HOOK_TICK_LOG_PATH, os.O_WRONLY | os.O_CREAT | os.O_APPEND, 0o644)
+        _cctally_core.HOOK_TICK_LOG_DIR.mkdir(parents=True, exist_ok=True)
+        fd = os.open(_cctally_core.HOOK_TICK_LOG_PATH, os.O_WRONLY | os.O_CREAT | os.O_APPEND, 0o644)
         try:
             os.write(fd, (line.rstrip("\n") + "\n").encode("utf-8", errors="replace"))
         finally:
@@ -2157,7 +2157,7 @@ def _hook_tick_log_rotate_if_needed() -> None:
     """If hook-tick.log exceeds the size cap, atomic-rename to .1 (overwriting)."""
     c = _cctally()
     try:
-        size = c.HOOK_TICK_LOG_PATH.stat().st_size
+        size = _cctally_core.HOOK_TICK_LOG_PATH.stat().st_size
     except FileNotFoundError:
         return
     except OSError:
@@ -2165,7 +2165,7 @@ def _hook_tick_log_rotate_if_needed() -> None:
     if size <= c.HOOK_TICK_LOG_ROTATE_BYTES:
         return
     try:
-        os.replace(c.HOOK_TICK_LOG_PATH, c.HOOK_TICK_LOG_ROTATED_PATH)
+        os.replace(_cctally_core.HOOK_TICK_LOG_PATH, _cctally_core.HOOK_TICK_LOG_ROTATED_PATH)
     except OSError:
         pass
 
@@ -2174,7 +2174,7 @@ def _hook_tick_throttle_age_seconds() -> float:
     """Return seconds since last successful OAuth fetch; +inf if never."""
     c = _cctally()
     try:
-        mtime = c.HOOK_TICK_THROTTLE_PATH.stat().st_mtime
+        mtime = _cctally_core.HOOK_TICK_THROTTLE_PATH.stat().st_mtime
     except FileNotFoundError:
         return float("inf")
     except OSError:
@@ -2186,9 +2186,9 @@ def _hook_tick_throttle_touch() -> None:
     """Update mtime to now (creating the file if missing)."""
     c = _cctally()
     try:
-        c.APP_DIR.mkdir(parents=True, exist_ok=True)
-        c.HOOK_TICK_THROTTLE_PATH.touch(exist_ok=True)
-        os.utime(c.HOOK_TICK_THROTTLE_PATH, None)
+        _cctally_core.APP_DIR.mkdir(parents=True, exist_ok=True)
+        _cctally_core.HOOK_TICK_THROTTLE_PATH.touch(exist_ok=True)
+        os.utime(_cctally_core.HOOK_TICK_THROTTLE_PATH, None)
     except OSError:
         pass
 
@@ -2313,9 +2313,9 @@ def cmd_hook_tick(args: argparse.Namespace) -> int:
     # immediately after Step 7, so the leak is bounded.
     if not explain:
         try:
-            c.HOOK_TICK_LOG_DIR.mkdir(parents=True, exist_ok=True)
+            _cctally_core.HOOK_TICK_LOG_DIR.mkdir(parents=True, exist_ok=True)
             log_fd = os.open(
-                c.HOOK_TICK_LOG_PATH,
+                _cctally_core.HOOK_TICK_LOG_PATH,
                 os.O_WRONLY | os.O_CREAT | os.O_APPEND, 0o644,
             )
             os.dup2(log_fd, 1)  # stdout
@@ -2350,7 +2350,7 @@ def cmd_hook_tick(args: argparse.Namespace) -> int:
             cache_conn = open_cache_db()
             try:
                 stats = sync_cache(cache_conn)
-                ingested = int(stats.rows_inserted)
+                ingested = int(stats.rows_changed)
             finally:
                 try:
                     cache_conn.close()
@@ -2368,10 +2368,10 @@ def cmd_hook_tick(args: argparse.Namespace) -> int:
 
         # Throttle check + OAuth (under flock)
         if not no_oauth:
-            c.APP_DIR.mkdir(parents=True, exist_ok=True)
+            _cctally_core.APP_DIR.mkdir(parents=True, exist_ok=True)
             try:
                 lock_fd = os.open(
-                    c.HOOK_TICK_THROTTLE_LOCK_PATH,
+                    _cctally_core.HOOK_TICK_THROTTLE_LOCK_PATH,
                     os.O_WRONLY | os.O_CREAT, 0o644,
                 )
             except OSError:
@@ -2437,7 +2437,7 @@ def cmd_hook_tick(args: argparse.Namespace) -> int:
     print("[1/4] Local sync (sync_cache)")
     print(f"      → ingested {max(0, ingested)} new entries")
     print("[2/4] Throttle check")
-    print(f"      → throttle file: {c.HOOK_TICK_THROTTLE_PATH}")
+    print(f"      → throttle file: {_cctally_core.HOOK_TICK_THROTTLE_PATH}")
     if pre_age == float("inf"):
         print("      → mtime: (file absent)")
     else:
@@ -2445,7 +2445,7 @@ def cmd_hook_tick(args: argparse.Namespace) -> int:
     print(f"      → threshold: {int(throttle_seconds)}s → {decision}")
     print("[3/4] OAuth refresh")
     print(f"      → status: {oauth_status}")
-    print(f"[4/4] Log written → {c.HOOK_TICK_LOG_PATH}")
+    print(f"[4/4] Log written → {_cctally_core.HOOK_TICK_LOG_PATH}")
     print(f"\nDone in {dur_ms} ms.")
     return rc
 

package/bin/_cctally_setup.py

@@ -64,11 +64,13 @@ def _cctally():
 
 
 # === Honest imports from extracted homes ===================================
-# Spec 2026-05-17-cctally-core-kernel-extraction.md §3.3: kernel symbols
-# import from _cctally_core. Path constants (`APP_DIR`,
-# `CLAUDE_SETTINGS_PATH`, `HOOK_TICK_LOG_PATH`) plus the extensive
-# out-of-scope setup-specific helpers (legacy migration, hook surgery,
-# OAuth token, sync_cache, …) stay on the _cctally() accessor.
+# Spec 2026-05-17 §3.3: kernel symbols import from _cctally_core. Path
+# constants (APP_DIR, CLAUDE_SETTINGS_PATH, HOOK_TICK_LOG_PATH, etc.)
+# moved to _cctally_core 2026-05-22 (#84) and are accessed via call-time
+# ``_cctally_core.X``. The setup-specific helpers (legacy migration, hook
+# surgery, OAuth token, sync_cache, …) that live in bin/cctally itself
+# stay on the _cctally() accessor.
+import _cctally_core
 from _cctally_core import (
     eprint,
     _command_as_of,
@@ -863,7 +865,7 @@ def _setup_count_hook_entries(settings: dict) -> dict[str, int]:
 
 
 def _setup_data_dir_size_bytes() -> int:
-    app_dir = _cctally().APP_DIR
+    app_dir = _cctally_core.APP_DIR
     total = 0
     if not app_dir.exists():
         return 0
@@ -891,7 +893,7 @@ def _setup_recent_log_stats(seconds: float = 24 * 3600) -> dict:
     counts = {"fires": 0, "by_event": {}, "oauth_ok": 0, "throttled": 0,
               "errors": 0, "last_fire_ago_s": None}
     last_ts = 0.0
-    for path in (c.HOOK_TICK_LOG_ROTATED_PATH, c.HOOK_TICK_LOG_PATH):
+    for path in (_cctally_core.HOOK_TICK_LOG_ROTATED_PATH, _cctally_core.HOOK_TICK_LOG_PATH):
         if not path.exists():
             continue
         try:
@@ -1041,7 +1043,7 @@ def _setup_status(args: argparse.Namespace) -> int:
                     "files": bespoke["files"],
                 },
             },
-            "data": {"path": str(c.APP_DIR), "size_bytes": data_bytes},
+            "data": {"path": str(_cctally_core.APP_DIR), "size_bytes": data_bytes},
         }
         print(json.dumps(envelope, indent=2))
         return 0
@@ -1057,7 +1059,7 @@ def _setup_status(args: argparse.Namespace) -> int:
         out.append("                 run `cctally setup` to remove")
     out.append(f"  PATH includes  {'yes' if on_path else 'no'}                                   "
                f"{'✓' if on_path else '⚠'}")
-    out.append(f"Hooks ({c.CLAUDE_SETTINGS_PATH})")
+    out.append(f"Hooks ({_cctally_core.CLAUDE_SETTINGS_PATH})")
     for ev in c.SETUP_HOOK_EVENTS:
         marker = "✓" if hook_counts[ev] >= 1 else "✗"
         word = "installed" if hook_counts[ev] >= 1 else "missing"
@@ -1093,7 +1095,7 @@ def _setup_status(args: argparse.Namespace) -> int:
         )
         out.append("                       run `cctally setup --migrate-legacy-hooks` to migrate")
     out.append("Data")
-    out.append(f"  {c.APP_DIR}/    {_setup_format_bytes(data_bytes)}")
+    out.append(f"  {_cctally_core.APP_DIR}/    {_setup_format_bytes(data_bytes)}")
     _setup_emit_text(out)
     return 0
 
@@ -1115,9 +1117,9 @@ def _setup_uninstall(args: argparse.Namespace) -> int:
         try:
             c._write_claude_settings_atomic(settings)
         except OSError as exc:
-            eprint(f"setup: failed to write {c.CLAUDE_SETTINGS_PATH}: {exc}")
+            eprint(f"setup: failed to write {_cctally_core.CLAUDE_SETTINGS_PATH}: {exc}")
             return 2
-    out.append(f"Removed {removed} hook entries from {c.CLAUDE_SETTINGS_PATH}")
+    out.append(f"Removed {removed} hook entries from {_cctally_core.CLAUDE_SETTINGS_PATH}")
 
     repo_root = _setup_resolve_repo_root()
     dst_dir = _setup_local_bin_dir()
@@ -1201,7 +1203,7 @@ def _setup_uninstall(args: argparse.Namespace) -> int:
                     "hooks_removed": removed,
                     "symlinks_removed": sym_removed,
                     "purged": False,
-                    "data_path": str(c.APP_DIR),
+                    "data_path": str(_cctally_core.APP_DIR),
                     "data_size_bytes": data_bytes,
                     "legacy": {
                         "statusline_snippet_path": str(legacy[0]) if legacy else None,
@@ -1213,7 +1215,7 @@ def _setup_uninstall(args: argparse.Namespace) -> int:
                 try:
                     resp = input(
                         f"Wipe {_setup_format_bytes(data_bytes)} of usage history at "
-                        f"{c.APP_DIR}/? [y/N] "
+                        f"{_cctally_core.APP_DIR}/? [y/N] "
                     )
                 except EOFError:
                     resp = "n"
@@ -1221,10 +1223,10 @@ def _setup_uninstall(args: argparse.Namespace) -> int:
                     out.append("Purge declined.")
                     _setup_emit_text(out)
                     return 3
-        if c.APP_DIR.exists():
+        if _cctally_core.APP_DIR.exists():
             try:
-                shutil.rmtree(c.APP_DIR)
-                out.append(f"Wiped {c.APP_DIR}/")
+                shutil.rmtree(_cctally_core.APP_DIR)
+                out.append(f"Wiped {_cctally_core.APP_DIR}/")
             except OSError as exc:
                 if is_json:
                     print(json.dumps({
@@ -1233,7 +1235,7 @@ def _setup_uninstall(args: argparse.Namespace) -> int:
                         "result": "err",
                         "reason": "rmtree_failed",
                         "error": str(exc),
-                        "data_path": str(c.APP_DIR),
+                        "data_path": str(_cctally_core.APP_DIR),
                         "data_size_bytes": data_bytes,
                         "legacy": {
                             "statusline_snippet_path": str(legacy[0]) if legacy else None,
@@ -1241,11 +1243,11 @@ def _setup_uninstall(args: argparse.Namespace) -> int:
                         "exit_code": 1,
                     }, indent=2))
                 else:
-                    eprint(f"setup: failed to wipe {c.APP_DIR}: {exc}")
+                    eprint(f"setup: failed to wipe {_cctally_core.APP_DIR}: {exc}")
                 return 1
     else:
         out.append(
-            f"Note: usage history kept at {c.APP_DIR}/ "
+            f"Note: usage history kept at {_cctally_core.APP_DIR}/ "
             f"({_setup_format_bytes(data_bytes)}). Use --purge to remove."
         )
     if is_json:
@@ -1256,7 +1258,7 @@ def _setup_uninstall(args: argparse.Namespace) -> int:
             "hooks_removed": removed,
             "symlinks_removed": sym_removed,
             "purged": purge,
-            "data_path": str(c.APP_DIR),
+            "data_path": str(_cctally_core.APP_DIR),
             "data_size_bytes": data_bytes,
             "legacy": {
                 "statusline_snippet_path": str(legacy[0]) if legacy else None,
@@ -1305,7 +1307,7 @@ def _setup_dry_run(args: argparse.Namespace) -> int:
         out.append(f"⚠ Blocked (non-symlink files exist): {', '.join(blocked)}")
         out.append("  Remove them manually then re-run.")
 
-    out.append(f"Would add {len(c.SETUP_HOOK_EVENTS)} hook entries to {c.CLAUDE_SETTINGS_PATH}:")
+    out.append(f"Would add {len(c.SETUP_HOOK_EVENTS)} hook entries to {_cctally_core.CLAUDE_SETTINGS_PATH}:")
     abs_path = str(_setup_resolve_hook_target(repo_root))
     import shlex
     quoted = shlex.quote(abs_path)
@@ -1391,7 +1393,7 @@ def _setup_dry_run(args: argparse.Namespace) -> int:
                     }
                     for ev in c.SETUP_HOOK_EVENTS
                 ],
-                "settings_path": str(c.CLAUDE_SETTINGS_PATH),
+                "settings_path": str(_cctally_core.CLAUDE_SETTINGS_PATH),
             },
             # Sibling parity with `_setup_status` and `_setup_install`
             # JSON envelopes (`legacy.bespoke_hooks` shape). Lets the same
@@ -1614,7 +1616,7 @@ def _setup_install(args: argparse.Namespace) -> int:
     try:
         c._write_claude_settings_atomic(settings)
     except OSError as exc:
-        eprint(f"setup: failed to write {c.CLAUDE_SETTINGS_PATH}: {exc}")
+        eprint(f"setup: failed to write {_cctally_core.CLAUDE_SETTINGS_PATH}: {exc}")
         return 2
 
     # ── Post-write migration apply (spec §2 steps 6a, 6b) ──
@@ -1674,7 +1676,7 @@ def _setup_install(args: argparse.Namespace) -> int:
     # The "✓ Wrote …" line follows any migrate-summary line so the
     # narrative reads "we did the migration, then wrote the new entries"
     # — matches the spec's success-path sample (Section 2).
-    out.append(f"✓ Wrote {len(c.SETUP_HOOK_EVENTS)} hook entries to {c.CLAUDE_SETTINGS_PATH}")
+    out.append(f"✓ Wrote {len(c.SETUP_HOOK_EVENTS)} hook entries to {_cctally_core.CLAUDE_SETTINGS_PATH}")
 
     if decision == "skip" and reason in {"user_declined", "no_migrate_flag"}:
         files_str = "{record-usage-stop,usage-poller{,-start,-stop}}.py"
@@ -1714,13 +1716,23 @@ def _setup_install(args: argparse.Namespace) -> int:
         cache_conn = c.open_cache_db()
         try:
             stats = c.sync_cache(cache_conn)
-            rows = int(stats.rows_inserted)
+            rows = int(stats.rows_changed)
         finally:
             try:
                 cache_conn.close()
             except Exception:
                 pass
         bootstrap_rows = rows
+        # `rows` counts both genuine INSERTs and ccusage-parity DO UPDATE
+        # replacements (see IngestStats.rows_changed). On first install
+        # this is always 0-vs-N pure inserts (cache is empty), so "N new
+        # entries" is exactly accurate. On a re-install / upgrade path
+        # with active sessions, `rows` also counts UPSERT replacements
+        # (streaming-vs-final tiebreaker swaps), so the count is more
+        # accurately "ingest activity" than "rows newly added" — but
+        # we keep "new entries" because (a) it's still a useful signal
+        # to the operator that the cache is alive, and (b) the dominant
+        # case (first install) reads literally.
         out.append(f"✓ Synced session cache ({rows} new entries)")
     except Exception as exc:
         out.append(f"⚠ sync_cache during bootstrap failed: {exc}")
@@ -1773,7 +1785,7 @@ def _setup_install(args: argparse.Namespace) -> int:
             },
             "hooks": {
                 "events_added": list(c.SETUP_HOOK_EVENTS),
-                "settings_path": str(c.CLAUDE_SETTINGS_PATH),
+                "settings_path": str(_cctally_core.CLAUDE_SETTINGS_PATH),
             },
             "auth": {
                 "oauth_token_present": oauth,

package/bin/_cctally_tui.py

@@ -204,6 +204,7 @@ def _cctally():
 
 # === Honest imports from extracted homes ===================================
 # Spec 2026-05-17-cctally-core-kernel-extraction.md §3.3.
+import _cctally_core
 from _cctally_core import (
     eprint,
     parse_iso_datetime,
@@ -2036,7 +2037,7 @@ def _tui_build_snapshot(
         projects_envelope_block: dict | None = None
         try:
             c = _cctally()
-            cache_db_path = c.CACHE_DB_PATH
+            cache_db_path = _cctally_core.CACHE_DB_PATH
             conn.execute(
                 "ATTACH DATABASE ? AS cache_db",
                 (str(cache_db_path),),

package/bin/_cctally_update.py

@@ -102,12 +102,19 @@ worker / polling thread:
   accessor; eager re-export from this sibling means the cctally
   namespace exposes them unchanged.
 
+What lives in bin/_cctally_core (promoted 2026-05-22, #84):
+- All ``UPDATE_*`` path constants: ``UPDATE_STATE_PATH``,
+  ``UPDATE_SUPPRESS_PATH``, ``UPDATE_LOCK_PATH``, ``UPDATE_LOG_PATH``,
+  ``UPDATE_LOG_ROTATED_PATH``, ``UPDATE_CHECK_LAST_FETCH_PATH``.
+  Moved bodies in this sibling read them via call-time
+  ``_cctally_core.UPDATE_STATE_PATH`` etc. Tests patch via
+  ``monkeypatch.setattr(_cctally_core, "UPDATE_STATE_PATH", tmp)`` —
+  the conftest helper ``redirect_paths()`` covers this for the full
+  set, ``tests/test_update.py:update_paths`` covers it for the
+  UPDATE_* subset. The legacy ``setitem(ns, …)`` pattern is forbidden
+  by ``test_no_old_style_test_patches_for_promoted_globals``.
+
 What stays in bin/cctally:
-- All ``UPDATE_*`` path constants (source-of-truth at L2001-2023);
-  consumed via ``c = _cctally(); c.UPDATE_STATE_PATH`` etc. in moved
-  code so ``monkeypatch.setitem(ns, "UPDATE_STATE_PATH", tmp)`` in
-  ``tests/test_update.py`` propagates transparently — no sibling-side
-  patches needed. Mirrors Phase D #17/#18 precedent.
 - ``ORIGINAL_SYS_ARGV`` / ``ORIGINAL_ENTRYPOINT`` /
   ``_UPDATE_WORKER`` — module-level globals written by
   ``cmd_dashboard`` at boot (``global`` statement at L23205);
@@ -200,6 +207,7 @@ def _cctally():
 
 # === Honest imports from extracted homes ===================================
 # Spec 2026-05-17-cctally-core-kernel-extraction.md §3.3.
+import _cctally_core
 from _cctally_core import eprint, _now_utc
 from _cctally_config import save_config
 
@@ -405,7 +413,7 @@ def _load_update_state() -> dict[str, Any] | None:
     """
     c = _cctally()
     try:
-        text = c.UPDATE_STATE_PATH.read_text(encoding="utf-8")
+        text = _cctally_core.UPDATE_STATE_PATH.read_text(encoding="utf-8")
     except FileNotFoundError:
         return None
     try:
@@ -437,12 +445,12 @@ def _save_update_state(state: dict[str, Any]) -> None:
     writers via ``UPDATE_LOCK_PATH`` (spec §5.3).
     """
     c = _cctally()
-    c.UPDATE_STATE_PATH.parent.mkdir(parents=True, exist_ok=True)
+    _cctally_core.UPDATE_STATE_PATH.parent.mkdir(parents=True, exist_ok=True)
     payload = (
         json.dumps(state, indent=2, sort_keys=True) + "\n"
     ).encode("utf-8")
-    tmp = c.UPDATE_STATE_PATH.with_name(
-        f"{c.UPDATE_STATE_PATH.name}.tmp.{os.getpid()}"
+    tmp = _cctally_core.UPDATE_STATE_PATH.with_name(
+        f"{_cctally_core.UPDATE_STATE_PATH.name}.tmp.{os.getpid()}"
     )
     fd = os.open(str(tmp), os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o644)
     try:
@@ -450,7 +458,7 @@ def _save_update_state(state: dict[str, Any]) -> None:
         os.fsync(fd)
     finally:
         os.close(fd)
-    os.replace(str(tmp), str(c.UPDATE_STATE_PATH))
+    os.replace(str(tmp), str(_cctally_core.UPDATE_STATE_PATH))
 
 
 def _load_update_suppress() -> dict[str, Any]:
@@ -462,7 +470,7 @@ def _load_update_suppress() -> dict[str, Any]:
     c = _cctally()
     default = {"_schema": 1, "skipped_versions": [], "remind_after": None}
     try:
-        text = c.UPDATE_SUPPRESS_PATH.read_text(encoding="utf-8")
+        text = _cctally_core.UPDATE_SUPPRESS_PATH.read_text(encoding="utf-8")
     except FileNotFoundError:
         return default
     try:
@@ -489,12 +497,12 @@ def _save_update_suppress(suppress: dict[str, Any]) -> None:
     """Persist ``update-suppress.json`` atomically. Same idiom as
     :func:`_save_update_state`."""
     c = _cctally()
-    c.UPDATE_SUPPRESS_PATH.parent.mkdir(parents=True, exist_ok=True)
+    _cctally_core.UPDATE_SUPPRESS_PATH.parent.mkdir(parents=True, exist_ok=True)
     payload = (
         json.dumps(suppress, indent=2, sort_keys=True) + "\n"
     ).encode("utf-8")
-    tmp = c.UPDATE_SUPPRESS_PATH.with_name(
-        f"{c.UPDATE_SUPPRESS_PATH.name}.tmp.{os.getpid()}"
+    tmp = _cctally_core.UPDATE_SUPPRESS_PATH.with_name(
+        f"{_cctally_core.UPDATE_SUPPRESS_PATH.name}.tmp.{os.getpid()}"
     )
     fd = os.open(str(tmp), os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o644)
     try:
@@ -502,7 +510,7 @@ def _save_update_suppress(suppress: dict[str, Any]) -> None:
         os.fsync(fd)
     finally:
         os.close(fd)
-    os.replace(str(tmp), str(c.UPDATE_SUPPRESS_PATH))
+    os.replace(str(tmp), str(_cctally_core.UPDATE_SUPPRESS_PATH))
 
 
 def _read_lock_pid(fd: int) -> int | None:
@@ -543,9 +551,9 @@ def _acquire_update_lock() -> int:
         COMMAND=cctally update
     """
     c = _cctally()
-    c.UPDATE_LOCK_PATH.parent.mkdir(parents=True, exist_ok=True)
+    _cctally_core.UPDATE_LOCK_PATH.parent.mkdir(parents=True, exist_ok=True)
     fd = os.open(
-        str(c.UPDATE_LOCK_PATH), os.O_CREAT | os.O_RDWR, 0o644
+        str(_cctally_core.UPDATE_LOCK_PATH), os.O_CREAT | os.O_RDWR, 0o644
     )
     try:
         fcntl.flock(fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
@@ -622,16 +630,16 @@ def _rotate_update_log_if_needed() -> None:
     """
     c = _cctally()
     try:
-        size = c.UPDATE_LOG_PATH.stat().st_size
+        size = _cctally_core.UPDATE_LOG_PATH.stat().st_size
     except FileNotFoundError:
         return
     if size < c.UPDATE_LOG_ROTATE_BYTES:
         return
     try:
-        c.UPDATE_LOG_ROTATED_PATH.unlink()
+        _cctally_core.UPDATE_LOG_ROTATED_PATH.unlink()
     except FileNotFoundError:
         pass
-    c.UPDATE_LOG_PATH.rename(c.UPDATE_LOG_ROTATED_PATH)
+    _cctally_core.UPDATE_LOG_PATH.rename(_cctally_core.UPDATE_LOG_ROTATED_PATH)
 
 
 def _log_update_event(log_fd, event: str, **kv: Any) -> None:
@@ -892,7 +900,7 @@ def _self_heal_current_version() -> None:
     """
     c = _cctally()
     try:
-        if (c.CHANGELOG_PATH.parent / ".git").exists():
+        if (_cctally_core.CHANGELOG_PATH.parent / ".git").exists():
             return
         fresh = _release_read_latest_release_version()
         if fresh is None:
@@ -1029,7 +1037,7 @@ def _is_update_check_due(config: dict) -> bool:
         return False
     ttl_hours = check_cfg.get("ttl_hours", c.UPDATE_DEFAULT_TTL_HOURS)
     try:
-        mtime = c.UPDATE_CHECK_LAST_FETCH_PATH.stat().st_mtime
+        mtime = _cctally_core.UPDATE_CHECK_LAST_FETCH_PATH.stat().st_mtime
     except FileNotFoundError:
         return True
     return (time.time() - mtime) >= ttl_hours * 3600
@@ -1052,8 +1060,8 @@ def _do_update_check() -> None:
     c = _cctally()
     # Touch marker FIRST — crash safety: a dead process mid-fetch must
     # not trigger another fetch within the TTL window.
-    c.UPDATE_CHECK_LAST_FETCH_PATH.parent.mkdir(parents=True, exist_ok=True)
-    c.UPDATE_CHECK_LAST_FETCH_PATH.touch()
+    _cctally_core.UPDATE_CHECK_LAST_FETCH_PATH.parent.mkdir(parents=True, exist_ok=True)
+    _cctally_core.UPDATE_CHECK_LAST_FETCH_PATH.touch()
 
     method = c._detect_install_method(mutate=True)
 
@@ -1143,15 +1151,15 @@ def cmd_update_check_internal(args) -> int:
     """
     c = _cctally()
     # Ensure APP_DIR exists so log + state writes succeed on first run.
-    c.UPDATE_LOG_PATH.parent.mkdir(parents=True, exist_ok=True)
+    _cctally_core.UPDATE_LOG_PATH.parent.mkdir(parents=True, exist_ok=True)
     try:
-        with open(c.UPDATE_LOG_PATH, "a", encoding="utf-8") as log_fd:
+        with open(_cctally_core.UPDATE_LOG_PATH, "a", encoding="utf-8") as log_fd:
             _log_update_event(log_fd, "CHECK_START")
             c._do_update_check()
             _log_update_event(log_fd, "CHECK_EXIT", rc=0)
     except Exception as e:
         try:
-            with open(c.UPDATE_LOG_PATH, "a", encoding="utf-8") as log_fd:
+            with open(_cctally_core.UPDATE_LOG_PATH, "a", encoding="utf-8") as log_fd:
                 _log_update_event(log_fd, "CHECK_EXIT", rc=1, error=str(e)[:200])
         except Exception:
             pass
@@ -1615,10 +1623,10 @@ def _do_update_install(
                 quoted = " ".join(shlex.quote(c2) for c2 in cmd)
                 print(f"Would run: {quoted}")
         return 0
-    c.UPDATE_LOG_PATH.parent.mkdir(parents=True, exist_ok=True)
+    _cctally_core.UPDATE_LOG_PATH.parent.mkdir(parents=True, exist_ok=True)
     lock_fd = c._acquire_update_lock()
     try:
-        with open(c.UPDATE_LOG_PATH, "a", encoding="utf-8") as log_fd:
+        with open(_cctally_core.UPDATE_LOG_PATH, "a", encoding="utf-8") as log_fd:
             _log_update_event(log_fd, "INSTALL_START", method=method.method)
             for step_name, cmd in steps:
                 _log_update_event(log_fd, "STEP_START", name=step_name)
@@ -1790,9 +1798,9 @@ class UpdateWorker:
         try:
             method = c._detect_install_method(mutate=True)
             c._preflight_install(method, version)
-            c.UPDATE_LOG_PATH.parent.mkdir(parents=True, exist_ok=True)
+            _cctally_core.UPDATE_LOG_PATH.parent.mkdir(parents=True, exist_ok=True)
             lock_fd = c._acquire_update_lock()
-            log_fd = open(c.UPDATE_LOG_PATH, "a", encoding="utf-8")
+            log_fd = open(_cctally_core.UPDATE_LOG_PATH, "a", encoding="utf-8")
             _log_update_event(log_fd, "INSTALL_START", method=method.method)
             for step_name, cmd in c._build_update_steps(method, version):
                 self._emit(run_id, {"type": "step", "name": step_name})
@@ -1923,8 +1931,8 @@ class _DashboardUpdateCheckThread(threading.Thread):
                 # silently disable the polling cadence for the rest
                 # of the dashboard's lifetime.
                 try:
-                    c.UPDATE_LOG_PATH.parent.mkdir(parents=True, exist_ok=True)
-                    with open(c.UPDATE_LOG_PATH, "a", encoding="utf-8") as log_fd:
+                    _cctally_core.UPDATE_LOG_PATH.parent.mkdir(parents=True, exist_ok=True)
+                    with open(_cctally_core.UPDATE_LOG_PATH, "a", encoding="utf-8") as log_fd:
                         _log_update_event(
                             log_fd, "CHECK_FAILED", error=str(e)[:200]
                         )

package/bin/_lib_changelog.py

@@ -13,6 +13,8 @@ from __future__ import annotations
 
 import sys
 
+import _cctally_core
+
 
 def _cctally():
     """Call-time accessor for the ``cctally`` module (project memory
@@ -35,7 +37,7 @@ def _read_latest_changelog_version() -> tuple[str, str] | None:
     """
     c = _cctally()
     try:
-        text = c.CHANGELOG_PATH.read_text(encoding="utf-8")
+        text = _cctally_core.CHANGELOG_PATH.read_text(encoding="utf-8")
     except FileNotFoundError:
         return None
     m = c.RELEASE_HEADER_RE.search(text)