cctally 1.63.0 → 1.65.0

package/bin/_cctally_update.py

@@ -1118,18 +1118,21 @@ def _do_update_check() -> None:
         c._save_update_state(state)
 
 
-def _spawn_background_update_check() -> None:
-    """Fire-and-forget the hidden `_update-check` worker.
-
-    Detached `subprocess.Popen` with `start_new_session=True` so a
-    parent exit (the user closes the shell) doesn't propagate SIGHUP
-    to the child. stdin/stdout/stderr are all `/dev/null` so the child
-    can't accidentally pollute the parent's terminal. Exceptions are
-    swallowed: a failed spawn must not break the parent command.
+def _spawn_detached(command: str) -> None:
+    """Fire-and-forget a hidden self-subcommand as a detached worker.
+
+    Detached `subprocess.Popen` with `start_new_session=True` so a parent
+    exit (the user closes the shell) doesn't propagate SIGHUP to the child;
+    stdin/stdout/stderr all `/dev/null` so the child can't pollute the
+    parent's terminal; exceptions swallowed so a failed spawn can't break
+    the parent command. Shared launch boilerplate for both dedicated
+    background workers below — `_update-check` and `_telemetry-beat` stay
+    deliberately separate spawns (spec review finding #1) and share only
+    this Popen shape.
     """
     try:
         subprocess.Popen(
-            [sys.executable, os.path.realpath(sys.argv[0]), "_update-check"],
+            [sys.executable, os.path.realpath(sys.argv[0]), command],
             stdin=subprocess.DEVNULL,
             stdout=subprocess.DEVNULL,
             stderr=subprocess.DEVNULL,
@@ -1141,6 +1144,11 @@ def _spawn_background_update_check() -> None:
         pass
 
 
+def _spawn_background_update_check() -> None:
+    """Fire-and-forget the hidden ``_update-check`` worker (spec §3.6)."""
+    _spawn_detached("_update-check")
+
+
 def cmd_update_check_internal(args) -> int:
     """Hidden ``_update-check`` subcommand handler (spec §3.6).
 
@@ -1167,6 +1175,37 @@ def cmd_update_check_internal(args) -> int:
     return 0
 
 
+def _spawn_background_telemetry_beat() -> None:
+    """Fire-and-forget the hidden ``_telemetry-beat`` worker.
+
+    A DEDICATED detached worker, deliberately separate from
+    ``_update-check`` (spec review finding #1): the anonymous install-count
+    beat must never share a process, throttle marker, or failure mode with
+    the update check. Only the launch boilerplate is shared, via
+    ``_spawn_detached``."""
+    _spawn_detached("_telemetry-beat")
+
+
+def cmd_telemetry_beat_internal(args) -> int:
+    """Hidden ``_telemetry-beat`` subcommand handler.
+
+    The detached anonymous-install-count worker. It does the beat and
+    NOTHING else — critically it must NOT read or write any update-check
+    state (spec review finding #1: a dedicated worker fully decoupled
+    from ``_update-check``). Always returns 0 so the parent's
+    spawn-and-forget contract holds. The try/except wraps both the
+    ``load_config`` read and ``do_telemetry_beat`` (which only guarantees
+    the network POST is swallowed, not that pure helper defects can't
+    raise), and its return value is unused."""
+    c = _cctally()
+    try:
+        config = c.load_config()
+        c.do_telemetry_beat(config)
+    except Exception:
+        pass
+    return 0
+
+
 # === User-facing `cctally update` (spec §4) ===
 # `cmd_update` routes by mode flag. Mode flags are mutually exclusive
 # (argparse enforces it; the dispatcher's redundant check is defense in
@@ -1976,6 +2015,11 @@ class _DashboardUpdateCheckThread(threading.Thread):
             envelope_precompute=(
                 c._cctally_tui._tui_precompute_envelope_config(load_config())
             ),
+            # #278 §1.4.1: a version-banner refresh republishes complete data;
+            # force the hydration latch clear so a republish that happens to
+            # carry a prior hydrating seed/partial doesn't freeze the client's
+            # loading skeletons.
+            hydrating=False,
         )
         self._ref.set(fresh)
         self._hub.publish(fresh)