cctally 1.76.0 → 1.78.0

package/bin/_cctally_quota.py

@@ -279,33 +279,32 @@ def load_codex_quota_observations(
             }
             return required <= columns
 
-        has_conversation_events = has_columns(
-            "codex_conversation_events",
-            {"source_path", "line_offset", "record_type", "payload_json"},
-        )
         has_session_entries = has_columns(
             "codex_session_entries", {"source_path", "line_offset", "model"},
         )
-        if has_conversation_events:
-            model_expr = """
-                (SELECT json_extract(events.payload_json, '$.payload.model')
-                   FROM codex_conversation_events AS events
-                  WHERE events.source_path=quota_window_snapshots.source_path
-                    AND events.line_offset<=quota_window_snapshots.line_offset
-                    AND events.record_type IN ('turn_context','session_meta')
-                    AND json_type(events.payload_json, '$.payload.model')='text'
-                  ORDER BY events.line_offset DESC LIMIT 1) AS observed_model
-            """
-        elif has_session_entries:
-            model_expr = """
-                (SELECT entries.model
-                   FROM codex_session_entries AS entries
-                  WHERE entries.source_path=quota_window_snapshots.source_path
-                    AND entries.line_offset<=quota_window_snapshots.line_offset
-                  ORDER BY entries.line_offset DESC LIMIT 1) AS observed_model
-            """
-        else:
-            model_expr = "NULL AS observed_model"
+        has_observed_model = has_columns(
+            "quota_window_snapshots", {"observed_model"},
+        )
+        entry_lookup = (
+            "(SELECT entries.model FROM codex_session_entries AS entries "
+            "WHERE entries.source_path=quota_window_snapshots.source_path "
+            "AND entries.line_offset<=quota_window_snapshots.line_offset "
+            "ORDER BY entries.line_offset DESC LIMIT 1)"
+        )
+        # A file's terminal model is not evidence for an earlier quota sample:
+        # the model may change later in the rollout. Prefer the compact stamp,
+        # then only a nearest-prior accounting context for legacy rows. If
+        # neither exists, leave the pool unscoped rather than fabricating it.
+        fallback_model = entry_lookup if has_session_entries else "NULL"
+        selected_model = (
+            f"COALESCE(quota_window_snapshots.observed_model,{fallback_model})"
+            if has_observed_model and fallback_model != "NULL"
+            else (
+                "quota_window_snapshots.observed_model"
+                if has_observed_model else fallback_model
+            )
+        )
+        model_expr = f"{selected_model} AS observed_model"
         sql = """
             SELECT source, source_root_key, source_path, line_offset,
                    captured_at_utc, observed_slot, logical_limit_key, limit_id,

package/bin/_cctally_statusline.py

@@ -275,13 +275,22 @@ def cmd_statusline(args: argparse.Namespace) -> int:
     # side effect that runs AFTER the line is printed and is FULLY guarded:
     # persistence must NEVER break or slow rendering, so the whole call is
     # wrapped here (the feeder itself forks detached + swallows its own
-    # errors, but this is belt-and-suspenders). Absence of rate_limits, a
-    # lost persist lock, or the throttle window all degrade to a clean
-    # no-op; the OAuth backfill covers the "no statusline feeding" case.
+    # errors, but this is belt-and-suspenders). Absence of rate_limits or a
+    # lost persist lock degrades to a clean no-op; the authoritative OAuth
+    # confirmation below covers the missing/stale-payload case.
     try:
         _statusline_persist(inp)
     except Exception:
         pass
+    # Claude Code may replay an unchanged rate_limits object across timer
+    # renders even after the provider counters have advanced. Confirm against
+    # the authoritative OAuth surface once per account-wide timer cycle. The
+    # helper is fully detached, shares hook-tick's throttle lock/marker, and
+    # honors the existing selected-freshness and 429-backoff gates.
+    try:
+        c._statusline_oauth_tick()
+    except Exception:
+        pass
     return 0
 
 
@@ -1229,6 +1238,122 @@ def _statusline_persist(parsed, *, sync_for_test: bool = False) -> None:
         c._release_persist_lock(lock_fd)
 
 
+def _try_acquire_statusline_oauth_lock() -> "int | None":
+    """Take hook-tick's account-wide OAuth throttle lock without blocking."""
+    try:
+        _cctally_core.APP_DIR.mkdir(parents=True, exist_ok=True)
+        fd = os.open(
+            _cctally_core.HOOK_TICK_THROTTLE_LOCK_PATH,
+            os.O_WRONLY | os.O_CREAT,
+            0o644,
+        )
+    except OSError:
+        return None
+    try:
+        fcntl.flock(fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
+    except OSError:
+        try:
+            os.close(fd)
+        except OSError:
+            pass
+        return None
+    return fd
+
+
+def _release_statusline_oauth_lock(fd: int) -> None:
+    try:
+        fcntl.flock(fd, fcntl.LOCK_UN)
+    except OSError:
+        pass
+    try:
+        os.close(fd)
+    except OSError:
+        pass
+
+
+def _run_statusline_oauth_refresh() -> None:
+    """Run one already-throttled automatic OAuth confirmation."""
+    c = _cctally()
+    status, _ = c._hook_tick_oauth_refresh(
+        throttle_seconds=float(_cctally_core.STATUSLINE_OAUTH_POLL_SECONDS)
+    )
+    if status.startswith("ok("):
+        c._hook_tick_throttle_touch()
+
+
+def _fork_statusline_oauth_refresh(lock_fd: int) -> bool:
+    """Detach one OAuth confirmation while keeping ``lock_fd`` in the child."""
+    try:
+        pid = os.fork()
+    except OSError:
+        return False
+    if pid > 0:
+        # Do not explicitly unlock: the child inherited the same open file
+        # description and owns the account-wide lock until its refresh ends.
+        try:
+            os.close(lock_fd)
+        except OSError:
+            pass
+        return True
+
+    try:
+        try:
+            os.setsid()
+        except OSError:
+            pass
+        try:
+            devnull = os.open(os.devnull, os.O_RDWR)
+            os.dup2(devnull, 0)
+            os.dup2(devnull, 1)
+            os.dup2(devnull, 2)
+            if devnull > 2:
+                os.close(devnull)
+        except OSError:
+            pass
+        _run_statusline_oauth_refresh()
+    except BaseException:
+        pass
+    finally:
+        _release_statusline_oauth_lock(lock_fd)
+        os._exit(0)
+
+
+def _statusline_oauth_tick(*, sync_for_test: bool = False) -> None:
+    """Schedule one bounded authoritative refresh from a statusline timer.
+
+    Fast prechecks avoid forks while selected data is fresh, a shared 429
+    deadline is active, or another session/hook owns the account-wide poll.
+    Every condition is rechecked under hook-tick's throttle lock before the
+    detached child starts.
+    """
+    c = _cctally()
+    interval = float(_cctally_core.STATUSLINE_OAUTH_POLL_SECONDS)
+    if c._statusline_observe_age_seconds() < interval:
+        return
+    if c._oauth_backoff_remaining_seconds() > 0:
+        return
+    if c._hook_tick_throttle_age_seconds() < interval:
+        return
+    lock_fd = _try_acquire_statusline_oauth_lock()
+    if lock_fd is None:
+        return
+    try:
+        if c._statusline_observe_age_seconds() < interval:
+            return
+        if c._oauth_backoff_remaining_seconds() > 0:
+            return
+        if c._hook_tick_throttle_age_seconds() < interval:
+            return
+        if sync_for_test:
+            _run_statusline_oauth_refresh()
+            return
+        if _fork_statusline_oauth_refresh(lock_fd):
+            lock_fd = -1
+    finally:
+        if lock_fd >= 0:
+            _release_statusline_oauth_lock(lock_fd)
+
+
 def _resolve_context_window(model_id, warn_once) -> "int | None":
     """Look up ``model_id`` in ``CLAUDE_MODEL_CONTEXT_WINDOWS``; fall back
     to a family-substring match against

package/bin/_cctally_transcript.py

@@ -86,7 +86,7 @@ def _cmd_transcript_export(args) -> int:
         eprint(_SPEED_ONLY_CODEX_MSG)
         return 2
 
-    conn = c.open_cache_db()
+    conn = c.open_conversations_db()
     try:
         cq = c._load_sibling("_lib_conversation_query")
         md = cq.get_conversation_export(conn, session_id, scope)
@@ -118,7 +118,7 @@ def _cmd_transcript_export_qualified(
         return 2
     speed = c._resolve_codex_speed(speed_arg or "auto")
 
-    conn = c.open_cache_db()
+    conn = c.open_conversations_db()
     try:
         env = disp.neutral_export(
             conn, session_id, scope=scope, effective_speed=speed)
@@ -189,7 +189,7 @@ def _cmd_transcript_search_claude(args) -> int:
             eprint(f"transcript: {exc}")
             return 2
 
-    conn = c.open_cache_db()
+    conn = c.open_conversations_db()
     try:
         cq = c._load_sibling("_lib_conversation_query")
         try:
@@ -264,7 +264,7 @@ def _cmd_transcript_search_codex(args) -> int:
             eprint("transcript: invalid --cursor")
             return 2
 
-    conn = c.open_cache_db()
+    conn = c.open_conversations_db()
     try:
         result = disp.neutral_search(
             conn, query, source="codex", kind=kind,

package/bin/_cctally_tui.py

@@ -1772,40 +1772,12 @@ def _tui_build_sessions(
             (), now_utc=now_utc, limit=limit, display_tz=None,
             aggregated_override=aggregated_override,
         )
-    rows = list(view.rows)
-    # Attach human-readable titles for the dashboard/TUI Sessions surface.
-    # Reuses the conversation viewer's title derivation (AI title wins, else
-    # first non-marker human line), which reads the CACHE db
-    # (conversation_messages / conversation_ai_titles). Fail-soft: any cache
-    # failure leaves titles ``None`` -> the client renders an em-dash. One
-    # bounded indexed query (<= `limit` session ids, rides idx_conv_session_ts)
-    # per snapshot build. Titles are stashed unconditionally on this
-    # server-internal row; the privacy gate is applied later, at envelope
-    # serialization (``snapshot_to_envelope(transcripts_visible=...)``).
-    if rows:
-        session_ids = [r.session_id for r in rows if r.session_id]
-        try:
-            conn = c.open_cache_db()
-        except (sqlite3.DatabaseError, OSError):
-            conn = None
-        if conn is not None:
-            try:
-                titles = c._load_sibling(
-                    "_lib_conversation_query"
-                )._session_titles_map(conn, session_ids)
-                rows = [
-                    dataclasses.replace(r, title=titles.get(r.session_id))
-                    if r.session_id in titles else r
-                    for r in rows
-                ]
-            except (sqlite3.DatabaseError, OSError):
-                pass  # fail-soft: leave titles None
-            finally:
-                try:
-                    conn.close()
-                except sqlite3.Error:
-                    pass
-    return rows
+    # #320: transcript-derived titles are optional decoration. The core
+    # dashboard/TUI snapshot must never open conversations.db, because even a
+    # fail-soft read pays SQLite's lock timeout before it can fail. Conversation
+    # routes retain title derivation; the accounting Sessions panel renders its
+    # existing em-dash fallback when the independent store is unavailable.
+    return list(view.rows)
 
 
 def _tui_sessions_cached(

package/bin/_lib_codex_conversation_query.py

@@ -71,9 +71,25 @@ _SEARCH_BADGE = {
 
 
 def codex_normalization_authoritative(conn: sqlite3.Connection) -> bool:
-    """True iff migration 025 is stamped applied — i.e. the normalized corpus is
-    authoritative (§3.5). A missing ``schema_migrations`` table (bare
-    ``_apply_cache_schema`` conn, or a pre-migration cache) reads as pending."""
+    """True iff the normalized Codex corpus is authoritative (§3.5).
+
+    Split stores use their provider-local rebuild marker: current schema alone
+    is not authority while migration 028's byte-zero replay is pending. Legacy
+    monolithic/bare connections retain the migration-025 stamp contract.
+    """
+    try:
+        split = conn.execute(
+            "SELECT 1 FROM cache_meta "
+            "WHERE key='conversation_schema_version'"
+        ).fetchone() is not None
+        if split:
+            pending = conn.execute(
+                "SELECT 1 FROM cache_meta "
+                "WHERE key='conversation_rebuild_codex_pending'"
+            ).fetchone() is not None
+            return not pending
+    except sqlite3.OperationalError:
+        pass
     try:
         row = conn.execute(
             "SELECT 1 FROM schema_migrations WHERE name = ?",

package/bin/_lib_conversation_query.py

@@ -2048,7 +2048,9 @@ def _assemble_memo_clear() -> None:
 def _assemble_memo_key(conn, session_id):
     """Return (session_id, msg_count, last_activity_utc, entry_mutation_seq), or
     None to signal 'bypass the memo' — a missing rollup row or an unreadable
-    cache_meta (bare/path-less conn). The caller has already confirmed the
+    accounting ``cache_meta``. Split-store connections read that watermark
+    from the read-only ``cache_db`` attachment; legacy/bare test connections
+    retain the main-schema fallback. The caller has already confirmed the
     rollup is authoritative."""
     try:
         row = conn.execute(
@@ -2059,9 +2061,12 @@ def _assemble_memo_key(conn, session_id):
     if row is None:
         return None
     try:
+        schemas = {row[1] for row in conn.execute("PRAGMA database_list")}
+        meta_schema = "cache_db" if "cache_db" in schemas else "main"
         seq_row = conn.execute(
-            "SELECT value FROM cache_meta "
-            "WHERE key='session_entries_mutation_seq'").fetchone()
+            f"SELECT value FROM {meta_schema}.cache_meta "
+            "WHERE key='session_entries_mutation_seq'"
+        ).fetchone()
     except sqlite3.OperationalError:
         return None
     seq = int(seq_row[0]) if seq_row and seq_row[0] is not None else 0

package/bin/_lib_conversation_retention.py

@@ -277,7 +277,7 @@ def _maybe_prune_conversation_retention(
         core.APP_DIR.mkdir(parents=True, exist_ok=True)
     except OSError:
         return None
-    maint_fh = open(core.CACHE_LOCK_MAINTENANCE_PATH, "w")
+    maint_fh = open(core.CONVERSATIONS_LOCK_MAINTENANCE_PATH, "w")
     try:
         try:
             fcntl.flock(maint_fh, fcntl.LOCK_EX | fcntl.LOCK_NB)
@@ -285,13 +285,13 @@ def _maybe_prune_conversation_retention(
             return None  # another prune holds it; skip cleanly, do NOT stamp
         if not force and not _retention_due(conn, now_utc):
             return None
-        claude_fh = open(core.CACHE_LOCK_PATH, "w")
+        claude_fh = open(core.CONVERSATIONS_LOCK_PATH, "w")
         try:
             try:
                 fcntl.flock(claude_fh, fcntl.LOCK_EX | fcntl.LOCK_NB)
             except (BlockingIOError, OSError):
                 return None  # a Claude sync is mid-flight; retry next cycle
-            codex_fh = open(core.CACHE_LOCK_CODEX_PATH, "w")
+            codex_fh = open(core.CONVERSATIONS_LOCK_CODEX_PATH, "w")
             try:
                 try:
                     fcntl.flock(codex_fh, fcntl.LOCK_EX | fcntl.LOCK_NB)

package/bin/_lib_dashboard_json.py

@@ -0,0 +1,43 @@
+"""Strict outbound JSON contract shared by dashboard HTTP/SSE and Doctor.
+
+Python's ``json.dumps`` defaults to emitting JavaScript-only ``NaN`` and
+``Infinity`` tokens. Browsers reject those tokens in ``JSON.parse`` and
+``Response.json``. Normalize supported JSON containers recursively, then keep
+``allow_nan=False`` as the final fail-loud guard. Unsupported objects and
+non-finite mapping keys are deliberately not coerced.
+"""
+from __future__ import annotations
+
+import json
+import math
+from typing import Any
+
+
+def normalize_dashboard_json(value: Any) -> Any:
+    """Return a non-mutating JSON value with non-finite floats mapped to null."""
+    if isinstance(value, float):
+        return value if math.isfinite(value) else None
+    if isinstance(value, dict):
+        return {
+            key: normalize_dashboard_json(item)
+            for key, item in value.items()
+        }
+    if isinstance(value, list):
+        return [normalize_dashboard_json(item) for item in value]
+    if isinstance(value, tuple):
+        return tuple(normalize_dashboard_json(item) for item in value)
+    return value
+
+
+def encode_dashboard_json(value: Any, **kwargs: Any) -> str:
+    """Serialize one outbound payload with browser-strict JSON semantics."""
+    return json.dumps(
+        normalize_dashboard_json(value),
+        allow_nan=False,
+        **kwargs,
+    )
+
+
+def encode_dashboard_json_bytes(value: Any, **kwargs: Any) -> bytes:
+    """UTF-8 bytes companion for HTTP response bodies."""
+    return encode_dashboard_json(value, **kwargs).encode("utf-8")

package/bin/_lib_doctor.py

@@ -206,6 +206,10 @@ class DoctorState:
     # cache was absent or unreadable; the check degrades to OK.
     cache_db_page_count: Optional[int] = None
     cache_db_freelist_count: Optional[int] = None
+    # #320: the independently large transcript store needs the same reclaim
+    # visibility, with remediation targeted at its own VACUUM surface.
+    conversations_db_page_count: Optional[int] = None
+    conversations_db_freelist_count: Optional[int] = None
     # #294 S2: root-qualified physical Codex quota freshness, per-root native
     # hook state, and lifecycle activity are gathered by _cctally_doctor.
     codex_quota_windows: Optional[list[dict]] = None
@@ -1235,21 +1239,22 @@ def _check_data_conversation_sessions_rollup(s: DoctorState) -> CheckResult:
     row per distinct ``conversation_messages.session_id`` (#217 S1 / U9).
 
     OK when the two counts are equal, when either is ``None`` (pre-rollup or an
-    unreadable cache.db — consistent with the kernel's graceful-degrade posture),
+    unreadable conversations.db — consistent with the kernel's graceful-degrade
+    posture),
     OR when a sync/reingest/backfill is in progress. WARN ONLY on a mismatch
     observed in a QUIESCENT cache.
 
-    False-WARN avoidance (Codex P2): ``sync_cache`` commits
+    False-WARN avoidance (Codex P2): ``sync_claude_conversations`` commits
     ``conversation_messages`` per file *before* the ``conversation_sessions``
     recompute, and resumable reingest commits per file before its rollup
     completes — so an unsynchronized read can transiently mismatch. The
     in-progress signal (``conv_rollup_sync_in_progress``) is set by
-    ``doctor_gather_state`` from a NON-BLOCKING ``cache.db.lock`` flock probe
+    ``doctor_gather_state`` from a NON-BLOCKING ``conversations.db.lock`` flock probe
     (lock held ⇒ a writer is mid-flight) AND the presence of any pending
     ``cache_meta`` reingest/split/backfill flag; if either says in-progress, this
     stays OK. Doctor remains read-only and never blocks on the lock.
 
-    Informational only (no remediation): the next full ``sync_cache`` re-derives
+    Informational only (no remediation): the next conversation sync re-derives
     the rollup via its incremental DELETE+INSERT.
     """
     rollup = s.conv_sessions_rollup_count
@@ -1773,6 +1778,49 @@ def _check_db_reclaimable(s: DoctorState) -> CheckResult:
     )
 
 
+def _check_db_conversations_reclaimable(s: DoctorState) -> CheckResult:
+    """Surface transcript-store free pages without mutating the DB (#320)."""
+    page_count = s.conversations_db_page_count
+    freelist_count = s.conversations_db_freelist_count
+    ratio = None
+    if (
+        isinstance(page_count, int)
+        and not isinstance(page_count, bool)
+        and page_count > 0
+        and isinstance(freelist_count, int)
+        and not isinstance(freelist_count, bool)
+        and 0 <= freelist_count <= page_count
+    ):
+        ratio = freelist_count / page_count
+    details = {
+        "conversations_db_page_count": page_count,
+        "conversations_db_freelist_count": freelist_count,
+        "conversations_db_free_ratio": ratio,
+        "warn_ratio": DOCTOR_RECLAIMABLE_WARN_RATIO,
+    }
+    if ratio is not None and ratio >= DOCTOR_RECLAIMABLE_WARN_RATIO:
+        return CheckResult(
+            id="db.conversations_reclaimable",
+            title="Reclaimable transcript space",
+            severity="warn",
+            summary=(
+                f"high — {ratio * 100:.1f}% of conversations.db pages are free"
+            ),
+            remediation=(
+                "Run `cctally db vacuum --db conversations` to reclaim disk space."
+            ),
+            details=details,
+        )
+    return CheckResult(
+        id="db.conversations_reclaimable",
+        title="Reclaimable transcript space",
+        severity="ok",
+        summary="below threshold",
+        remediation=None,
+        details=details,
+    )
+
+
 # Each entry is (category_id, category_title, ((check_id, evaluator_fn_name), ...)).
 # The dotted check_id is the stable JSON-contract ID (spec §5.2) AND the
 # fingerprint identity-slice key (spec §5.5). When an evaluator raises,
@@ -1808,6 +1856,7 @@ _CATEGORY_DEFINITIONS: tuple[tuple[str, str, tuple[tuple[str, str], ...]], ...]
         ("db.lock_state", "_check_db_lock_state"),
         ("db.wal_size", "_check_db_wal_size"),
         ("db.reclaimable", "_check_db_reclaimable"),
+        ("db.conversations_reclaimable", "_check_db_conversations_reclaimable"),
     )),
     ("data", "Data", (
         ("data.latest_snapshot_age", "_check_data_latest_snapshot_age"),

package/bin/_lib_source_analytics.py

@@ -83,9 +83,26 @@ def assign_collision_safe_project_labels(
     selection the exact string that terminal, JSON, and share emit.
     """
     values = tuple(entries)
+    assigned = collision_safe_project_label_map(
+        (entry.project_key, entry.project_label) for entry in values
+    )
+    return tuple(
+        replace(entry, display_label=assigned.get(entry.project_key, entry.project_label))
+        for entry in values
+    )
+
+
+def collision_safe_project_label_map(
+    identities_and_labels: Iterable[tuple[str, str]],
+) -> dict[str, str]:
+    """Allocate the shared deterministic privacy-safe label contract.
+
+    Callers supply opaque internal identities. Only the returned labels are
+    presentation data; the identity keys must remain inside the adapter.
+    """
     keys_by_label: dict[str, set[str]] = defaultdict(set)
-    for entry in values:
-        keys_by_label[entry.project_label].add(entry.project_key)
+    for identity, label in identities_and_labels:
+        keys_by_label[label].add(identity)
     # Never let an allocator-owned ``label (N)`` shadow a literal project
     # label.  Reserving every raw label also makes a later presentation pass
     # unnecessary, which avoids producing ``label (N) (N)``.
@@ -107,10 +124,7 @@ def assign_collision_safe_project_labels(
             assigned[key] = candidate
             used_labels.add(candidate)
             ordinal += 1
-    return tuple(
-        replace(entry, display_label=assigned.get(entry.project_key, entry.project_label))
-        for entry in values
-    )
+    return assigned
 
 
 def opaque_project_key(source: str, root_key: str, resolved_key: str) -> str:

package/bin/cctally

@@ -558,6 +558,10 @@ _lib_log = _load_sibling("_lib_log")
 _lib_json_envelope = _load_sibling("_lib_json_envelope")
 stamp_schema_version = _lib_json_envelope.stamp_schema_version
 
+# Strict outbound dashboard/Doctor JSON: recursive non-finite normalization
+# followed by allow_nan=False serialization.
+_lib_dashboard_json = _load_sibling("_lib_dashboard_json")
+
 _lib_changelog = _load_sibling("_lib_changelog")
 # Backward-compat re-export: callers and tests reach the helper through
 # ``cctally._release_read_latest_release_version`` (incl. monkeypatch
@@ -1008,6 +1012,9 @@ get_codex_entries = _cctally_cache.get_codex_entries
 _sum_codex_cost_for_range = _cctally_cache._sum_codex_cost_for_range
 get_entries = _cctally_cache.get_entries
 open_cache_db = _cctally_cache.open_cache_db
+open_conversations_db = _cctally_cache.open_conversations_db
+sync_claude_conversations = _cctally_cache.sync_claude_conversations
+sync_codex_conversations = _cctally_cache.sync_codex_conversations
 _reset_orphan_warning_throttle = _cctally_cache._reset_orphan_warning_throttle
 cmd_cache_sync = _cctally_cache.cmd_cache_sync
 
@@ -1333,6 +1340,7 @@ _build_statusline_injections = _cctally_statusline._build_statusline_injections
 # `cctally._statusline_persist` (test surface) + the `_cctally()` accessor
 # resolve them.
 _statusline_persist = _cctally_statusline._statusline_persist
+_statusline_oauth_tick = _cctally_statusline._statusline_oauth_tick
 _fork_persist = _cctally_statusline._fork_persist
 _record_args = _cctally_statusline._record_args
 _try_acquire_persist_lock = _cctally_statusline._try_acquire_persist_lock