cctally 1.76.0 → 1.78.0

package/bin/_cctally_dashboard_conversation.py

@@ -20,9 +20,9 @@ What lives here (spec §6):
   (``_require_transcripts_allowed`` / ``_transcript_gate`` / …) STAY on the
   class and are reached via the ``handler`` parameter (spec §6).
 
-Late-binding (spec §6): the two bare ``open_cache_db`` calls (in
+Late-binding (spec §6): the conversation DB opener calls (in
 ``_run_conversation_query_impl`` + the events handler) reach
-``sys.modules["_cctally_dashboard"].open_cache_db(...)`` — patched on the
+``sys.modules["_cctally_dashboard"].open_conversations_db(...)`` — patched on the
 dashboard module object at ``tests/test_conversation_endpoints.py:674``.
 
 Cross-module reaches (spec §2.1 "fully-qualify cross-module refs"): the
@@ -38,13 +38,19 @@ edits — the forwarders hit ``sys.modules["_cctally_dashboard"]`` at call time
 """
 from __future__ import annotations
 
-import json
 import re
 import socket
 import sqlite3
 import sys
 
-from _cctally_cache import sync_cache, sync_codex_cache, _codex_provider_roots
+from _cctally_cache import (
+    open_cache_db,
+    sync_codex_cache,
+    sync_claude_conversations,
+    sync_codex_conversations,
+    _codex_provider_roots,
+)
+from _lib_dashboard_json import encode_dashboard_json
 
 # Live-tail watch-loop tuning — used ONLY by _handle_get_conversation_events_impl
 # below, so moved here with the events handler (spec §4.1 / §6).
@@ -91,7 +97,7 @@ class _BadConversationFilter(Exception):
 
 
 def _cached_file_sigs(conn, paths):
-    """{path: size_bytes} from session_files for the given paths — the cache's
+    """{path: size_bytes} from conversation_source_files for the given paths — the transcript cache's
     own view of how far each file is ingested. Size-only by design, matching the
     watch kernel's size-only signature (`file_sig`) and sync_cache's size-only
     delta signal: mtime is NOT consulted, because a size-unchanged ingest does
@@ -105,7 +111,7 @@ def _cached_file_sigs(conn, paths):
     placeholders = ",".join("?" for _ in paths)
     try:
         rows = conn.execute(
-            f"SELECT path, size_bytes FROM session_files "
+            f"SELECT path, size_bytes FROM conversation_source_files "
             f"WHERE path IN ({placeholders})", list(paths)).fetchall()
     except sqlite3.OperationalError:
         return out
@@ -115,7 +121,7 @@ def _cached_file_sigs(conn, paths):
 
 
 def _codex_cached_file_sigs(conn, paths):
-    """{path: size_bytes} from ``codex_session_files`` for the given paths — the
+    """{path: size_bytes} from ``codex_conversation_source_files`` for the given paths — the
     Codex analogue of ``_cached_file_sigs`` (spec §5.2). Size-only, matching the
     watch kernel's size-only signature and ``sync_codex_cache``'s size-only
     delta. Paths with no row are absent → treated as changed. Baselines the
@@ -129,7 +135,7 @@ def _codex_cached_file_sigs(conn, paths):
     placeholders = ",".join("?" for _ in paths)
     try:
         rows = conn.execute(
-            f"SELECT path, size_bytes FROM codex_session_files "
+            f"SELECT path, size_bytes FROM codex_conversation_source_files "
             f"WHERE path IN ({placeholders})", list(paths)).fetchall()
     except sqlite3.OperationalError:
         return out
@@ -144,7 +150,7 @@ def _codex_all_committed_sizes(conn):
     baseline. A plain SELECT (no lock), so it never widens the SSE lock scope."""
     try:
         rows = conn.execute(
-            "SELECT path, size_bytes FROM codex_session_files").fetchall()
+            "SELECT path, size_bytes FROM codex_conversation_source_files").fetchall()
     except sqlite3.OperationalError:
         return {}
     return {p: size for (p, size) in rows}
@@ -162,7 +168,7 @@ def _codex_classified_paths(conn, paths):
     placeholders = ",".join("?" for _ in paths)
     try:
         rows = conn.execute(
-            f"SELECT path FROM codex_session_files "
+            f"SELECT path FROM codex_conversation_source_files "
             f"WHERE path IN ({placeholders}) AND last_conversation_key IS NOT NULL",
             list(paths)).fetchall()
     except sqlite3.OperationalError:
@@ -444,12 +450,12 @@ def _run_conversation_query_impl(handler, kernel_call, log_label):
     has ALREADY been sent and the caller must just ``return``; ``ok=True``
     carries the kernel result (which may itself be ``None`` — the reader's
     404 sentinel — so the explicit flag, not ``body is None``, signals
-    failure). An ``open_cache_db`` failure is a ``cache unavailable:`` 500;
+    failure). An ``open_conversations_db`` failure is a ``cache unavailable:`` 500;
     a kernel exception is logged as ``<log_label> failed: %r`` and returned
     as a ``{type}: {msg}`` 500 — byte-identical to the inlined handlers.
     """
     try:
-        conn = sys.modules["_cctally_dashboard"].open_cache_db()  # late-binding: patched at test_conversation_endpoints.py:674
+        conn = sys.modules["_cctally_dashboard"].open_conversations_db()
     except (sqlite3.DatabaseError, OSError) as exc:
         handler._respond_json(500, {"error": f"cache unavailable: {exc}"})
         return False, None
@@ -703,7 +709,8 @@ def _run_conversation_events_stream(
     import time as _time
     watch = sys.modules["cctally"]._load_sibling("_lib_conversation_watch")
     tail_frame = (
-        "event: tail\ndata: " + json.dumps(tail_data) + "\n\n").encode("utf-8")
+        "event: tail\ndata: " + encode_dashboard_json(tail_data) + "\n\n"
+    ).encode("utf-8")
 
     if passive:
         # Frozen-data contract: no ingest, no emit. Keep-alive only.
@@ -785,7 +792,7 @@ def _bare_conversation_events(handler, session_id: str) -> None:
     _send_sse_headers(handler)
     passive = bool(type(handler).no_sync)
     try:
-        conn = sys.modules["_cctally_dashboard"].open_cache_db()  # late-binding: patched at test_conversation_endpoints.py:674
+        conn = sys.modules["_cctally_dashboard"].open_conversations_db()
     except (sqlite3.DatabaseError, OSError):
         # Cache unavailable — degrade to keep-alive only; client backstop
         # tick still surfaces turns. (Headers already sent; can't 500.)
@@ -796,7 +803,7 @@ def _bare_conversation_events(handler, session_id: str) -> None:
         return cq.session_source_paths(conn, session_id) if conn else []
 
     def _ingest(changed):
-        return sync_cache(conn, only_paths=set(changed))
+        return sync_claude_conversations(conn, only_paths=set(changed))
 
     try:
         _run_conversation_events_stream(
@@ -840,7 +847,24 @@ def _make_codex_discovery_step(handler, conn, conversation_key, cq_codex):
         if not to_ingest:
             return files, False
         try:
-            sync_codex_cache(conn, only_paths=set(to_ingest))
+            # A newly discovered child has no compact thread row yet. Advance
+            # the independent core cursor first so transcript normalization can
+            # link the child through the read-only attached cache, then commit
+            # the transcript cursor. Neither lock is held across the other.
+            core = open_cache_db()
+            try:
+                core_stats = sync_codex_cache(
+                    core, only_paths=set(to_ingest)
+                )
+            finally:
+                core.close()
+            if not core_stats.targeted_clean:
+                return files, False
+            transcript_stats = sync_codex_conversations(
+                conn, only_paths=set(to_ingest)
+            )
+            if not transcript_stats.targeted_clean:
+                return files, False
         except sqlite3.DatabaseError:
             return files, False
         # Reap the now-classified candidates (child → already widened; non-child
@@ -866,7 +890,7 @@ def _qualified_conversation_events(handler, key: str) -> None:
     targeted ingest + the directory-frontier child discovery."""
     disp = _conversation_dispatch_impl()
     try:
-        conn = sys.modules["_cctally_dashboard"].open_cache_db()  # late-binding: patched at test_conversation_endpoints.py:674
+        conn = sys.modules["_cctally_dashboard"].open_conversations_db()
     except (sqlite3.DatabaseError, OSError):
         conn = None
 
@@ -921,7 +945,7 @@ def _qualified_conversation_events(handler, key: str) -> None:
             return cq_codex.codex_conversation_source_paths(conn, key)
 
         def _ingest(changed):
-            return sync_codex_cache(conn, only_paths=set(changed))
+            return sync_codex_conversations(conn, only_paths=set(changed))
 
         cached = lambda paths: _codex_cached_file_sigs(conn, paths)
         discovery = _make_codex_discovery_step(handler, conn, key, cq_codex)
@@ -932,7 +956,7 @@ def _qualified_conversation_events(handler, key: str) -> None:
             return cq.session_source_paths(conn, native)
 
         def _ingest(changed):
-            return sync_cache(conn, only_paths=set(changed))
+            return sync_claude_conversations(conn, only_paths=set(changed))
 
         cached = lambda paths: _cached_file_sigs(conn, paths)
         discovery = None

package/bin/_cctally_dashboard_sources.py

@@ -49,7 +49,10 @@ from _lib_jsonl import CodexEntry, codex_model_scoped_quota_pool
 from _lib_fmt import stable_sum
 from _lib_aggregators import _aggregate_codex_buckets
 from _lib_five_hour import _FIVE_HOUR_JITTER_FLOOR_SECONDS
-from _lib_source_analytics import build_codex_project_result
+from _lib_source_analytics import (
+    build_codex_project_result,
+    collision_safe_project_label_map,
+)
 from _lib_view_models import (
     CodexWeeklyView,
     build_codex_daily_view,
@@ -733,22 +736,33 @@ def _codex_conversation_metadata(
 
     ``state_5.sqlite.threads.title`` is Codex's persisted user-facing task name.
     Conversation rollup titles are derived from prompt text and therefore must
-    never be substituted for that name on the dashboard. Accounting remains
-    authoritative for totals; conversation rollups only decorate projects.
+    never be substituted for that name on the dashboard. Project attribution
+    is derived from the compact thread ``cwd``/``git_json`` retained in
+    ``cache.db`` so non-conversation panels never open ``conversations.db``.
     """
     metadata: dict[tuple[str, str], dict[str, object]] = {}
     try:
-        rows = tuple(cache_conn.execute(
+        core_rows = tuple(cache_conn.execute(
             "SELECT t.source_root_key, t.source_path, t.native_thread_id, "
             "(SELECT e.session_id FROM codex_session_entries AS e "
             " WHERE e.source_root_key=t.source_root_key AND e.source_path=t.source_path "
             " ORDER BY e.id LIMIT 1) AS accounting_session_id, "
-            "r.project_key, r.project_label, r.started_utc "
+            "t.cwd, t.git_json, t.first_seen_utc, t.last_seen_utc "
             "FROM codex_conversation_threads AS t "
-            "LEFT JOIN codex_conversation_rollups AS r "
-            "ON r.conversation_key=t.conversation_key "
-            "ORDER BY r.last_activity_utc DESC, t.conversation_key DESC"
+            "ORDER BY t.last_seen_utc DESC, t.conversation_key DESC"
         ))
+        from _cctally_cache import _codex_conversation_project_attribution
+        rows = tuple(
+            (
+                root_key, source_path, native_thread_id, accounting_session_id,
+                *_codex_conversation_project_attribution(root_key, cwd, git_json),
+                first_seen_at,
+            )
+            for (
+                root_key, source_path, native_thread_id, accounting_session_id,
+                cwd, git_json, first_seen_at, _last_seen_at,
+            ) in core_rows
+        )
         file_aliases = tuple(cache_conn.execute(
             "SELECT source_root_key, path, last_native_thread_id, last_session_id "
             "FROM codex_session_files "
@@ -1772,12 +1786,17 @@ def _partial_projects_wire(
             model_totals[field] += value
             session_totals[field] += value
 
+    label_map = collision_safe_project_label_map(
+        (f"{root_key}\0{project_key}", str(group["label"]))
+        for (root_key, project_key), group in groups.items()
+    )
     rows = []
     for (root_key, _project_key), group in groups.items():
+        internal_identity = f"{root_key}\0{group['project_key']}"
         rows.append({
             "key": dashboard_resource_key("project", "codex", root_key, group["project_key"]),
             "source": "codex",
-            "label": group["label"],
+            "label": label_map[internal_identity],
             "session_count": len(group["sessions"]),
             "first_seen": group["first_seen"].astimezone(UTC).isoformat(),
             "last_seen": group["last_seen"].astimezone(UTC).isoformat(),

package/bin/_cctally_db.py

@@ -2648,6 +2648,7 @@ def _apply_cache_schema(conn: sqlite3.Connection) -> None:
             plan_type             TEXT,
             individual_limit_json TEXT,
             reached_type          TEXT,
+            observed_model        TEXT,
             UNIQUE(source, source_path, line_offset, logical_limit_key),
             CHECK(source != 'codex' OR source_root_key IS NOT NULL)
         );
@@ -2893,6 +2894,12 @@ def _apply_cache_schema(conn: sqlite3.Connection) -> None:
     add_column_if_missing(conn, "conversation_sessions", "git_branch", "TEXT")
     add_column_if_missing(conn, "conversation_sessions", "models_json", "TEXT")
     add_column_if_missing(conn, "conversation_sessions", "title", "TEXT")
+    # #320: quota pool identity cannot depend on transcript events after the
+    # store split. Stamp the active model directly on each compact physical
+    # quota observation. Existing caches receive the nullable column here; 028
+    # backfills it from the still-present legacy event corpus before dropping
+    # that corpus.
+    add_column_if_missing(conn, "quota_window_snapshots", "observed_model", "TEXT")
     conn.execute(
         "CREATE INDEX IF NOT EXISTS idx_session_files_session_id "
         "ON session_files(session_id)"
@@ -3014,6 +3021,72 @@ def _apply_cache_schema(conn: sqlite3.Connection) -> None:
     conn.commit()
 
 
+def _apply_conversations_schema(conn: sqlite3.Connection) -> None:
+    """Create the #320 transcript/search database schema.
+
+    The historical cache schema remains the migration-fixture source of truth.
+    Reuse it here, then remove the compact accounting families so conversation
+    queries can resolve those names through the read-only ``cache_db``
+    attachment. Empty compatibility tables may still exist in cache.db for old
+    migration handlers, but all live transcript rows belong here.
+    """
+    # The first open projects the historical monolithic schema into the new
+    # store. Avoid repeating that create-then-drop work on every conversation
+    # endpoint: it writes sqlite_schema and WAL pages even when no transcript
+    # data changed. Future conversation schema revisions must bump this marker.
+    try:
+        current = conn.execute(
+            "SELECT value FROM cache_meta "
+            "WHERE key='conversation_schema_version'"
+        ).fetchone()
+    except sqlite3.OperationalError:
+        current = None
+    if current is not None and current[0] == "1":
+        return
+
+    _apply_cache_schema(conn)
+    conn.executescript(
+        """
+        DROP TABLE IF EXISTS session_entries;
+        DROP TABLE IF EXISTS session_files;
+        DROP TABLE IF EXISTS codex_session_entries;
+        DROP TABLE IF EXISTS codex_session_files;
+        DROP TABLE IF EXISTS quota_window_snapshots;
+        DROP TABLE IF EXISTS codex_conversation_threads;
+        DROP TABLE IF EXISTS codex_source_roots;
+
+        CREATE TABLE IF NOT EXISTS conversation_source_files (
+            path             TEXT PRIMARY KEY,
+            size_bytes       INTEGER NOT NULL,
+            mtime_ns         INTEGER NOT NULL,
+            last_byte_offset INTEGER NOT NULL,
+            last_ingested_at TEXT NOT NULL
+        );
+        CREATE TABLE IF NOT EXISTS codex_conversation_source_files (
+            path                         TEXT PRIMARY KEY,
+            size_bytes                   INTEGER NOT NULL,
+            mtime_ns                     INTEGER NOT NULL,
+            last_byte_offset             INTEGER NOT NULL,
+            last_ingested_at             TEXT NOT NULL,
+            source_root_key              TEXT,
+            last_session_id              TEXT,
+            last_model                   TEXT,
+            last_total_tokens            INTEGER,
+            last_native_thread_id        TEXT,
+            last_root_thread_id          TEXT,
+            last_parent_thread_id        TEXT,
+            last_conversation_key        TEXT,
+            last_turn_id                 TEXT
+        );
+        """
+    )
+    conn.execute(
+        "INSERT INTO cache_meta(key,value) VALUES "
+        "('conversation_schema_version','1') "
+        "ON CONFLICT(key) DO UPDATE SET value=excluded.value"
+    )
+
+
 def _fts5_available(conn: sqlite3.Connection) -> bool:
     """True if this sqlite build can create an FTS5 table. Cheap probe on a
     temp table that is created then dropped. Hidden test seam: tests monkeypatch
@@ -4730,6 +4803,118 @@ def _027_codex_fork_preamble_rebuild(conn: sqlite3.Connection) -> None:
             lock_fh.close()
 
 
+@cache_migration("028_split_conversation_store")
+def _028_split_conversation_store(conn: sqlite3.Connection) -> None:
+    """Move the re-derivable transcript corpus out of cache.db (#320).
+
+    The upgrade deliberately does not copy gigabytes of prose/events. It creates
+    the independent current-schema store, arms provider-local byte-zero replay,
+    then drops the legacy transcript tables from the hot cache. Compact Codex
+    thread metadata stays in cache.db because accounting/project attribution
+    joins it directly.
+    """
+    core = _cctally_core
+    lock_paths = (
+        core.CACHE_LOCK_MAINTENANCE_PATH,
+        core.CACHE_LOCK_PATH,
+        core.CACHE_LOCK_CODEX_PATH,
+        core.CONVERSATIONS_LOCK_MAINTENANCE_PATH,
+        core.CONVERSATIONS_LOCK_PATH,
+        core.CONVERSATIONS_LOCK_CODEX_PATH,
+    )
+    held = []
+    try:
+        core.APP_DIR.mkdir(parents=True, exist_ok=True)
+        for path in lock_paths:
+            fh = open(path, "w")
+            try:
+                fcntl.flock(fh, fcntl.LOCK_EX | fcntl.LOCK_NB)
+            except BlockingIOError:
+                fh.close()
+                raise MigrationGateNotMet(
+                    "cache/conversation sync lock held; deferring cache 028 split"
+                )
+            held.append(fh)
+
+        conv = sqlite3.connect(core.CONVERSATIONS_DB_PATH)
+        try:
+            conv.execute("PRAGMA auto_vacuum=INCREMENTAL")
+            conv.execute("PRAGMA journal_mode=WAL")
+            _apply_conversations_schema(conv)
+            _set_cache_meta(conv, "conversation_rebuild_claude_pending", "1")
+            _set_cache_meta(conv, "conversation_rebuild_codex_pending", "1")
+            conv.commit()
+        finally:
+            conv.close()
+
+        conn.execute("BEGIN IMMEDIATE")
+        try:
+            # Preserve exact model-scoped quota-pool identity before discarding
+            # the legacy physical event corpus. The correlated lookup is the
+            # same nearest-prior context rule the quota reader used pre-split.
+            if conn.execute(
+                "SELECT 1 FROM sqlite_master "
+                "WHERE type='table' AND name='codex_conversation_events'"
+            ).fetchone() is not None:
+                conn.execute(
+                    "UPDATE quota_window_snapshots AS q SET observed_model=("
+                    " SELECT json_extract(e.payload_json, '$.payload.model')"
+                    " FROM codex_conversation_events AS e"
+                    " WHERE e.source_path=q.source_path"
+                    "   AND e.line_offset<=q.line_offset"
+                    "   AND e.record_type IN ('turn_context','session_meta')"
+                    "   AND json_valid(e.payload_json)"
+                    "   AND json_type(e.payload_json, '$.payload.model')='text'"
+                    " ORDER BY e.line_offset DESC LIMIT 1)"
+                    " WHERE q.source='codex' AND q.observed_model IS NULL"
+                )
+            for drop in (
+                "DROP TRIGGER IF EXISTS conv_fts_ai",
+                "DROP TRIGGER IF EXISTS conv_fts_ad",
+                "DROP TRIGGER IF EXISTS conv_fts_au",
+                "DROP TRIGGER IF EXISTS conv_fts_aux_ai",
+                "DROP TRIGGER IF EXISTS conv_fts_aux_ad",
+                "DROP TRIGGER IF EXISTS conv_fts_aux_au",
+                "DROP TRIGGER IF EXISTS conv_title_fts_ai",
+                "DROP TRIGGER IF EXISTS conv_title_fts_ad",
+                "DROP TRIGGER IF EXISTS conv_title_fts_au",
+                "DROP TRIGGER IF EXISTS codex_conv_fts_ai",
+                "DROP TRIGGER IF EXISTS codex_conv_fts_ad",
+                "DROP TRIGGER IF EXISTS codex_conv_fts_au",
+                "DROP TABLE IF EXISTS conversation_fts_aux",
+                "DROP TABLE IF EXISTS conversation_fts",
+                "DROP TABLE IF EXISTS conversation_title_fts",
+                "DROP TABLE IF EXISTS codex_conversation_fts",
+                "DROP TABLE IF EXISTS conversation_file_touches",
+                "DROP TABLE IF EXISTS conversation_sessions",
+                "DROP TABLE IF EXISTS conversation_ai_titles",
+                "DROP TABLE IF EXISTS conversation_messages",
+                "DROP TABLE IF EXISTS codex_conversation_file_touches",
+                "DROP TABLE IF EXISTS codex_conversation_rollups",
+                "DROP TABLE IF EXISTS codex_conversation_messages",
+                "DROP TABLE IF EXISTS codex_conversation_events",
+            ):
+                conn.execute(drop)
+            conn.commit()
+        except Exception:
+            conn.rollback()
+            raise
+        try:
+            if conn.execute("PRAGMA auto_vacuum").fetchone()[0] == 2:
+                # Python 3.11/Linux may defer this zero-column PRAGMA until the
+                # cursor is exhausted; fetchall drives it to completion.
+                conn.execute("PRAGMA incremental_vacuum").fetchall()
+        except sqlite3.DatabaseError:
+            pass
+    finally:
+        for fh in reversed(held):
+            try:
+                fcntl.flock(fh, fcntl.LOCK_UN)
+            except OSError:
+                pass
+            fh.close()
+
+
 # === Region 7d: Stats migration 008_recompute_weekly_cost_snapshots_dedup_fix ===
 
 @stats_migration("008_recompute_weekly_cost_snapshots_dedup_fix")
@@ -7006,7 +7191,12 @@ def _vacuum_one_db(path, label: str, provider_locked: bool) -> int:
     # Serialize against the retention prune and concurrent vacuums via the
     # dedicated maintenance flock (F13/F7), then the provider flocks for
     # cache.db. All non-blocking: fail promptly rather than hang.
-    maint_fh = open(core.CACHE_LOCK_MAINTENANCE_PATH, "w")
+    conversation_store = path == core.CONVERSATIONS_DB_PATH
+    maintenance_path = (
+        core.CONVERSATIONS_LOCK_MAINTENANCE_PATH
+        if conversation_store else core.CACHE_LOCK_MAINTENANCE_PATH
+    )
+    maint_fh = open(maintenance_path, "w")
     try:
         try:
             fcntl.flock(maint_fh, fcntl.LOCK_EX | fcntl.LOCK_NB)
@@ -7019,10 +7209,18 @@ def _vacuum_one_db(path, label: str, provider_locked: bool) -> int:
         held = []
         try:
             if provider_locked:
-                for lock_path, lname in (
-                    (core.CACHE_LOCK_PATH, "claude"),
-                    (core.CACHE_LOCK_CODEX_PATH, "codex"),
-                ):
+                provider_locks = (
+                    (
+                        (core.CONVERSATIONS_LOCK_PATH, "claude conversations"),
+                        (core.CONVERSATIONS_LOCK_CODEX_PATH, "codex conversations"),
+                    )
+                    if conversation_store else
+                    (
+                        (core.CACHE_LOCK_PATH, "claude"),
+                        (core.CACHE_LOCK_CODEX_PATH, "codex"),
+                    )
+                )
+                for lock_path, lname in provider_locks:
                     fh = open(lock_path, "w")
                     try:
                         fcntl.flock(fh, fcntl.LOCK_EX | fcntl.LOCK_NB)
@@ -7063,6 +7261,10 @@ def cmd_db_vacuum(args: argparse.Namespace) -> int:
     targets = []
     if which in ("cache", "all"):
         targets.append((_cctally_core.CACHE_DB_PATH, "cache.db", True))
+    if which in ("conversations", "all"):
+        targets.append((
+            _cctally_core.CONVERSATIONS_DB_PATH, "conversations.db", True,
+        ))
     if which in ("stats", "all"):
         targets.append((_cctally_core.DB_PATH, "stats.db", False))
     overall = 0

package/bin/_cctally_doctor.py

@@ -27,6 +27,7 @@ import argparse
 import datetime as dt
 import fcntl
 import json
+import math
 import pathlib
 import shutil
 import sqlite3
@@ -35,6 +36,7 @@ import sys
 import _cctally_core
 import _lib_changelog
 from _cctally_core import _now_utc, eprint, now_utc_iso, parse_iso_datetime
+from _lib_dashboard_json import encode_dashboard_json
 
 
 def _cctally():
@@ -53,11 +55,25 @@ def _gather_statusline_pipeline(c, *, now_utc: dt.datetime) -> dict:
         "tombstones": {"fiveHour": "absent", "sevenDay": "absent"},
     }
     try:
-        result["transport_age_seconds"] = c._statusline_transport_age_seconds()
+        age = c._statusline_transport_age_seconds()
+        result["transport_age_seconds"] = (
+            age
+            if isinstance(age, (int, float))
+            and not isinstance(age, bool)
+            and math.isfinite(float(age))
+            else None
+        )
     except Exception:
         pass
     try:
-        result["selected_age_seconds"] = c._statusline_observe_age_seconds()
+        age = c._statusline_observe_age_seconds()
+        result["selected_age_seconds"] = (
+            age
+            if isinstance(age, (int, float))
+            and not isinstance(age, bool)
+            and math.isfinite(float(age))
+            else None
+        )
     except Exception:
         pass
     try:
@@ -429,16 +445,35 @@ def doctor_gather_state(
     # Conversation-sessions rollup consistency (#217 S1 / U9). Two cheap COUNTs
     # (graceful None on a missing table / unreadable DB) + an in-progress signal
     # so a transient mid-sync mismatch never WARNs. The in-progress signal is a
-    # NON-BLOCKING cache.db.lock flock probe (a writer mid-walk holds it) OR the
+    # NON-BLOCKING conversations flock probe (a writer mid-walk holds it) OR the
     # presence of any pending reingest/split/backfill cache_meta flag — doctor
     # stays read-only and never blocks on the lock.
     conv_sessions_rollup_count = None
     conv_messages_distinct_sessions = None
     conv_rollup_sync_in_progress = False
-    try:
-        if _cctally_core.CACHE_DB_PATH.exists():
-            conn = sqlite3.connect(str(_cctally_core.CACHE_DB_PATH))
+    conversations_db_page_count = None
+    conversations_db_freelist_count = None
+    try:
+        if _cctally_core.CONVERSATIONS_DB_PATH.exists():
+            # This gather also runs inside dashboard snapshot precompute. A
+            # transcript writer may hold an exclusive SQLite lock, so use a
+            # read-only zero-timeout probe: conversation health can degrade,
+            # but it must never delay core snapshot freshness (#320).
+            conv_uri = (
+                _cctally_core.CONVERSATIONS_DB_PATH.resolve().as_uri()
+                + "?mode=ro"
+            )
+            conn = sqlite3.connect(conv_uri, uri=True, timeout=0.0)
             try:
+                try:
+                    row = conn.execute("PRAGMA page_count").fetchone()
+                    if row and row[0] is not None:
+                        conversations_db_page_count = int(row[0])
+                    row = conn.execute("PRAGMA freelist_count").fetchone()
+                    if row and row[0] is not None:
+                        conversations_db_freelist_count = int(row[0])
+                except sqlite3.Error:
+                    pass
                 try:
                     row = conn.execute(
                         "SELECT COUNT(*) FROM conversation_sessions"
@@ -472,12 +507,12 @@ def doctor_gather_state(
                     pass
             finally:
                 conn.close()
-        # Non-blocking flock probe: if a writer (sync_cache / a reingest) holds
-        # the cache.db.lock, the rollup may be mid-recompute → in progress. We
+        # Non-blocking flock probe: if a transcript writer/reingest holds the
+        # conversations.db lock, the rollup may be mid-recompute → in progress. We
         # acquire LOCK_EX|LOCK_NB and immediately release; failure (held) is the
         # signal. Never blocks (LOCK_NB), so doctor stays read-only + prompt.
         if not conv_rollup_sync_in_progress:
-            lock_path = _cctally_core.CACHE_LOCK_PATH
+            lock_path = _cctally_core.CONVERSATIONS_LOCK_PATH
             if lock_path is not None and pathlib.Path(lock_path).exists():
                 import fcntl as _fcntl
                 lock_fh = open(str(lock_path), "w")
@@ -669,6 +704,15 @@ def doctor_gather_state(
         for _name, _lp in (
             ("cache.db.lock", _cctally_core.CACHE_LOCK_PATH),
             ("cache.db.codex.lock", _cctally_core.CACHE_LOCK_CODEX_PATH),
+            ("conversations.db.lock", _cctally_core.CONVERSATIONS_LOCK_PATH),
+            (
+                "conversations.db.codex.lock",
+                _cctally_core.CONVERSATIONS_LOCK_CODEX_PATH,
+            ),
+            (
+                "conversations.db.maintenance.lock",
+                _cctally_core.CONVERSATIONS_LOCK_MAINTENANCE_PATH,
+            ),
         ):
             if not _lp.exists():
                 locks_held[_name] = False
@@ -877,6 +921,8 @@ def doctor_gather_state(
         # #315: read-only cache free-page evidence for the reclaim hint.
         cache_db_page_count=cache_db_page_count,
         cache_db_freelist_count=cache_db_freelist_count,
+        conversations_db_page_count=conversations_db_page_count,
+        conversations_db_freelist_count=conversations_db_freelist_count,
         codex_quota_windows=codex_quota_windows,
         codex_hook_roots=codex_hook_roots,
         codex_lifecycle_activity_24h=codex_lifecycle_activity_24h,
@@ -913,7 +959,7 @@ def cmd_doctor(args: argparse.Namespace) -> int:
     state = c.doctor_gather_state(deep=True)
     report = _lib_doctor.run_checks(state)
     if getattr(args, "json", False):
-        print(json.dumps(
+        print(encode_dashboard_json(
             _lib_doctor.serialize_json(report), indent=2, sort_keys=True,
         ))
     else:

package/bin/_cctally_parser.py

@@ -2924,7 +2924,7 @@ def _build_db_parser(subparsers, name, *, help_text, xref=None):
     )
     db_vacuum.add_argument(
         "--db",
-        choices=("cache", "stats", "all"),
+        choices=("cache", "conversations", "stats", "all"),
         default="cache",
         help="Which DB to VACUUM (default: cache)",
     )