cctally 1.72.0 → 1.73.0

package/bin/_lib_conversation_query.py

@@ -2540,6 +2540,94 @@ def build_anon_plan_for_db(conn, *, home_dir):
         home_dirs=sorted(home_dirs), usernames=sorted(usernames))
 
 
+def build_anon_plan_for_sources(conn, *, home_dir, sources):
+    """Provider-aware :class:`AnonPlan` for QUALIFIED conversation surfaces
+    (#294 S7, §3.6). A SEPARATE builder from :func:`build_anon_plan_for_db`, which
+    stays byte-untouched together with every bare-Claude call site — unioning Codex
+    roots into the legacy builder would renumber its ``project-N`` tokens and change
+    bare-Claude anonymized bytes. This builder is used ONLY by ``v1.``-qualified
+    requests (both providers), which are new and carry no byte-compat debt.
+
+    ``sources`` selects the provider legs to include (e.g. ``{"codex"}`` or
+    ``{"claude"}``). The Codex leg draws ONLY from the authoritative tables:
+    provider root dirs from ``codex_source_roots.canonical_root_path``, observed
+    project paths from validated ``codex_conversation_threads.cwd`` (absolute paths
+    only), display labels from ``codex_conversation_rollups.project_label``.
+    ``git_json`` is NOT a path source (its fields are branch/repository metadata,
+    not filesystem roots). The existing home-dir/username machinery and
+    ``SECRET_PATTERNS`` apply unchanged; coverage stays best-effort-over-known-tokens
+    and the per-token replacement stays fail-closed."""
+    from _lib_conversation_anon import build_anon_plan
+    want = set(sources or ())
+    project_roots: dict = {}
+    paths: set = set()
+    if "claude" in want:
+        cwds: set = set()
+        try:
+            for (cwd,) in conn.execute(
+                    "SELECT DISTINCT cwd FROM conversation_messages "
+                    "WHERE cwd IS NOT NULL AND cwd != ''"):
+                if cwd:
+                    cwds.add(cwd)
+        except sqlite3.OperationalError:
+            pass
+        try:
+            for (pp,) in conn.execute(
+                    "SELECT DISTINCT project_path FROM session_files "
+                    "WHERE project_path IS NOT NULL AND project_path != ''"):
+                if pp:
+                    cwds.add(pp)
+        except sqlite3.OperationalError:
+            pass
+        for c in cwds:
+            project_roots[c] = _project_label(c)
+            paths.add(c)
+    if "codex" in want:
+        labels: dict = {}
+        try:
+            for ck, pl in conn.execute(
+                    "SELECT conversation_key, project_label FROM codex_conversation_rollups "
+                    "WHERE project_label IS NOT NULL AND project_label != ''"):
+                labels[ck] = pl
+        except sqlite3.OperationalError:
+            pass
+        try:
+            for ck, cwd in conn.execute(
+                    "SELECT conversation_key, cwd FROM codex_conversation_threads "
+                    "WHERE cwd IS NOT NULL AND cwd != ''"):
+                if isinstance(cwd, str) and cwd and os.path.isabs(cwd):
+                    project_roots[cwd] = labels.get(ck) or _project_label(cwd)
+                    paths.add(cwd)
+        except sqlite3.OperationalError:
+            pass
+        try:
+            for (root_path,) in conn.execute(
+                    "SELECT canonical_root_path FROM codex_source_roots "
+                    "WHERE canonical_root_path IS NOT NULL AND canonical_root_path != ''"):
+                if isinstance(root_path, str) and root_path and os.path.isabs(root_path):
+                    project_roots.setdefault(root_path, _project_label(root_path))
+                    paths.add(root_path)
+        except sqlite3.OperationalError:
+            pass
+    home_dirs: set = set()
+    usernames: set = set()
+    if home_dir:
+        home_dirs.add(home_dir)
+        u = os.path.basename(home_dir.rstrip("/"))
+        if u:
+            usernames.add(u)
+    for p in paths:
+        for prefix in ("/Users/", "/home/"):
+            if p.startswith(prefix):
+                user = p[len(prefix):].split("/", 1)[0]
+                if user:
+                    home_dirs.add(prefix + user)
+                    usernames.add(user)
+    return build_anon_plan(
+        project_roots=project_roots,
+        home_dirs=sorted(home_dirs), usernames=sorted(usernames))
+
+
 _TASK_TRIO = ("TaskCreate", "TaskUpdate", "TaskList")
 
 

package/bin/_lib_doctor.py

@@ -15,6 +15,7 @@ import dataclasses
 import datetime as dt
 import hashlib
 import json
+import math
 import pathlib
 import sys
 from typing import Optional
@@ -213,6 +214,10 @@ class DoctorState:
     # never-WARN posture (the hooks.installed / settings warnings already
     # surface a genuinely-unreadable settings.json — no double-WARN here).
     statusline_refresh_state: str = "unavailable"
+    # #318: read-only evidence for the per-session statusline candidate
+    # arbitration pipeline.  None means the gather could not inspect it;
+    # absent transport/tombstones are normal when Claude is closed.
+    statusline_pipeline: Optional[dict] = None
 
 
 @dataclasses.dataclass(frozen=True)
@@ -737,6 +742,62 @@ def _check_data_latest_snapshot_age(s: DoctorState) -> CheckResult:
     )
 
 
+def _check_statusline_pipeline(s: DoctorState) -> CheckResult:
+    """Report transport, selected, control, and authority health separately."""
+    pipeline = s.statusline_pipeline if isinstance(s.statusline_pipeline, dict) else {}
+    tombstones = pipeline.get("tombstones")
+    tombstones = tombstones if isinstance(tombstones, dict) else {}
+    details = {
+        "transport_age_seconds": pipeline.get("transport_age_seconds"),
+        "selected_age_seconds": pipeline.get("selected_age_seconds"),
+        "active_candidate_count": pipeline.get("active_candidate_count", 0),
+        "control_db_agrees": pipeline.get("control_db_agrees"),
+        "tombstones": tombstones,
+    }
+    if any(value in {"invalid", "inflight"} for value in tombstones.values()):
+        return CheckResult(
+            id="data.statusline_pipeline", title="Statusline pipeline",
+            severity="warn", summary="authoritative state needs repair",
+            remediation="Run `cctally refresh-usage`", details=details,
+        )
+    if pipeline.get("control_db_agrees") is False:
+        return CheckResult(
+            id="data.statusline_pipeline", title="Statusline pipeline",
+            severity="warn", summary="selected control disagrees with database",
+            remediation="Run `cctally refresh-usage`, then inspect active sessions",
+            details=details,
+        )
+    transport_age = pipeline.get("transport_age_seconds")
+    selected_age = pipeline.get("selected_age_seconds")
+    transport_age = (
+        float(transport_age)
+        if isinstance(transport_age, (int, float)) and not isinstance(transport_age, bool)
+        else math.inf
+    )
+    selected_age = (
+        float(selected_age)
+        if isinstance(selected_age, (int, float)) and not isinstance(selected_age, bool)
+        else math.inf
+    )
+    if transport_age < 90 and selected_age >= 300:
+        return CheckResult(
+            id="data.statusline_pipeline", title="Statusline pipeline",
+            severity="warn", summary="timer active; selected usage stale",
+            remediation="Run `cctally refresh-usage`, then inspect active sessions",
+            details=details,
+        )
+    if transport_age >= 90:
+        summary = "no recent regular-pool timer observed"
+    elif selected_age < 300:
+        summary = "timer and selected usage fresh"
+    else:
+        summary = "selected usage awaiting next active timer"
+    return CheckResult(
+        id="data.statusline_pipeline", title="Statusline pipeline",
+        severity="ok", summary=summary, remediation=None, details=details,
+    )
+
+
 def _check_data_cache_sync_state(s: DoctorState) -> CheckResult:
     count = s.cache_entries_count or 0
     if count == 0:
@@ -1658,6 +1719,7 @@ _CATEGORY_DEFINITIONS: tuple[tuple[str, str, tuple[tuple[str, str], ...]], ...]
     )),
     ("data", "Data", (
         ("data.latest_snapshot_age", "_check_data_latest_snapshot_age"),
+        ("data.statusline_pipeline", "_check_statusline_pipeline"),
         ("data.cache_sync_state", "_check_data_cache_sync_state"),
         ("data.codex_cache", "_check_data_codex_cache"),
         ("data.codex_quota", "_check_data_codex_quota"),