cctally 1.10.3 → 1.11.1

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)

package/bin/_lib_share_templates.py

@@ -21,6 +21,18 @@ from collections.abc import Callable, Mapping
 from dataclasses import dataclass
 from typing import Any
 
+# NOTE: ``_cctally_core`` is imported lazily inside ``_release_version()``
+# (the sole consumer in this module) so that loading this file directly
+# via ``importlib.util.spec_from_file_location`` — the established
+# pattern used by ``_render_share_v2_fixture.py``,
+# ``_compose_share_v2_fixture.py``, and ``tests/test_lib_share_templates.py``
+# — does NOT depend on ``bin/`` being on ``sys.path`` at module-import
+# time. A module-top ``import _cctally_core`` would raise
+# ``ModuleNotFoundError`` for any standalone loader that hasn't already
+# arranged for ``_cctally_core`` to be importable, regressing the
+# parallel-loader pattern this module uses for ``_lib_share`` itself
+# (see ``_import_share_lib`` below).
+
 
 # --- Panel set ---
 #
@@ -288,22 +300,28 @@ def _utc_now() -> _dt.datetime:
 def _release_version() -> str:
     """Read CHANGELOG-stamped latest version.
 
-    Honors `CCTALLY_TEST_CHANGELOG_PATH` override (the documented test pattern
-    at `bin/cctally:86`). Falls back to `"dev"` when CHANGELOG is unreadable
-    or has no stamped release entry yet (pre-release dev builds).
+    Resolves through ``_cctally_core.CHANGELOG_PATH`` so the kernel's
+    env override (``CCTALLY_TEST_CHANGELOG_PATH``) and any test-side
+    ``monkeypatch.setattr(_cctally_core, "CHANGELOG_PATH", ...)`` both
+    propagate transparently. Falls back to ``"dev"`` when CHANGELOG is
+    unreadable or has no stamped release entry yet (pre-release dev
+    builds).
 
-    Parallel to `_lib_changelog._read_latest_changelog_version`
-    (re-exported on `bin/cctally` under the historical
-    `_release_read_latest_release_version` name) — intentionally
+    Parallel to ``_lib_changelog._read_latest_changelog_version``
+    (re-exported on ``bin/cctally`` under the historical
+    ``_release_read_latest_release_version`` name) — intentionally
     duplicated so the template module stays free of any
-    `bin/cctally` import. If CHANGELOG header format changes, update both.
+    ``bin/cctally`` import. If CHANGELOG header format changes, update both.
+
+    ``_cctally_core`` is imported lazily here (rather than at module top)
+    so that standalone loaders — see the note at the top of this file
+    and the ``_import_share_lib`` pattern below — can exec this module
+    without ``bin/`` already being on ``sys.path``. By the time
+    ``_release_version()`` is actually called, the caller (CLI boot,
+    dashboard, or fixture driver) has resolved the sibling layout.
     """
-    from pathlib import Path
-    p = os.environ.get("CCTALLY_TEST_CHANGELOG_PATH")
-    if p:
-        path = Path(p)
-    else:
-        path = Path(__file__).resolve().parent.parent / "CHANGELOG.md"
+    import _cctally_core  # noqa: PLC0415 — lazy by design (see module-top NOTE)
+    path = _cctally_core.CHANGELOG_PATH
     try:
         for line in path.read_text(encoding="utf-8").splitlines():
             if line.startswith("## [") and "Unreleased" not in line: