cctally 1.43.2 → 1.44.0

package/bin/_lib_conversation_query.py

@@ -196,6 +196,19 @@ def _session_titles_map(conn, session_ids):
     if not session_ids:
         return {}
     titles = {}
+    # #193: AI title wins when present. Query the dedicated table first; the
+    # existing first-prompt scan below fills only sessions WITHOUT one (its
+    # ``if sid in titles: continue`` guard skips ai-title sessions for free).
+    try:
+        ph0 = ",".join("?" for _ in session_ids)
+        for sid, at in conn.execute(
+            f"SELECT session_id, ai_title FROM conversation_ai_titles "
+            f"WHERE session_id IN ({ph0})", tuple(session_ids)
+        ).fetchall():
+            if at:
+                titles[sid] = at
+    except sqlite3.OperationalError:
+        pass  # table absent (pre-migration / :memory:) -> fall through to first-prompt
     # While 005's reingest is pending, a stale `human` row may actually be an
     # injected skill body (a SessionStart skill can even lead the transcript) —
     # skip those as title candidates so the rail never shows "Base directory for
@@ -339,18 +352,73 @@ def _session_latest_meta_map(conn, session_ids):
     return meta
 
 
+# Rail sort keys, in the rollup table's STRUCTURAL columns (Task A). ``recent``
+# rides idx_conv_sessions_recent(last_activity_utc DESC, session_id DESC) and
+# early-terminates at LIMIT with no temp B-tree; ``oldest`` scan-sorts the few
+# thousand rollup rows (microseconds). The live fallback re-expresses the SAME
+# orderings over conversation_messages aggregates via _SORTS_LIVE below.
+# When adding a sort key, add it to BOTH _SORTS and _SORTS_LIVE and exercise it
+# in test_conversation_rail_rollup_reconcile.py (its _dump asserts the test's
+# sort list covers exactly _SORTS.keys(), so a one-sided add fails loud).
 _SORTS = {
+    "recent": "last_activity_utc DESC, session_id DESC",
+    "oldest": "started_utc ASC, session_id ASC",
+}
+
+# The matching ORDER BY for the live GROUP BY fallback: the rollup's
+# last_activity_utc IS MAX(timestamp_utc) and started_utc IS MIN(timestamp_utc),
+# so the two branches paginate in byte-identical order (the load-bearing
+# invariant). Keep this table in lockstep with _SORTS.
+_SORTS_LIVE = {
     "recent": "MAX(timestamp_utc) DESC, session_id DESC",
     "oldest": "MIN(timestamp_utc) ASC, session_id ASC",
 }
 
 
-def list_conversations(conn, *, sort="recent", limit=50, offset=0) -> dict:
-    """All-history per-session browse rows (spec §3.1). NOT 365-day bounded."""
-    order = _SORTS.get(sort, _SORTS["recent"])
-    limit = max(1, min(int(limit), 200))
-    offset = max(0, int(offset))
-    rows = conn.execute(
+def _rollup_authoritative(conn) -> bool:
+    """True when the conversation_sessions rollup is authoritative — i.e. the
+    durable ``conversation_sessions_backfill_pending`` flag is NOT set, so the
+    rollup has been fully recomputed and the fast read is safe.
+
+    Returns True (authoritative) when the flag is absent, including the case
+    where cache_meta does not exist at all (a path-less / schema-not-applied or
+    in-memory connection). This mirrors Task A's
+    _conversation_sessions_backfill_pending OperationalError degrade-to-False —
+    here that means "no pending flag" -> authoritative -> read the rollup. A
+    populated cache.db always has cache_meta, so this only affects bare conns."""
+    try:
+        pending = conn.execute(
+            "SELECT 1 FROM cache_meta "
+            "WHERE key='conversation_sessions_backfill_pending'"
+        ).fetchone() is not None
+    except sqlite3.OperationalError:
+        return True
+    return not pending
+
+
+def _list_session_rows_rollup(conn, order, limit, offset):
+    """FAST path: read the pre-aggregated rail rows straight from the
+    conversation_sessions rollup (spec §3). No GROUP BY, no temp B-tree for the
+    ``recent`` sort. Returns (session_id, msg_count, started, last_activity)
+    tuples — the same shape the live aggregate yields, so the downstream
+    assembly is identical. No WHERE is needed: the rollup is non-null by
+    construction (PK NOT NULL; the recompute's GROUP BY already drops NULLs)."""
+    return conn.execute(
+        "SELECT session_id, msg_count, "
+        "       started_utc AS started, last_activity_utc AS last_activity "
+        "FROM conversation_sessions "
+        "ORDER BY " + order + " LIMIT ? OFFSET ?",
+        (limit + 1, offset),
+    ).fetchall()
+
+
+def _list_session_rows_live(conn, order, limit, offset):
+    """RETAINED fallback (Codex gate BLOCKER 2): the original live GROUP BY over
+    conversation_messages, used while the rollup is not authoritative (the flag
+    is set — e.g. an existing install before its first sync, or permanently
+    under ``--no-sync``). Byte-identical output to the rollup branch by
+    construction; ``order`` here is the _SORTS_LIVE aggregate expression."""
+    return conn.execute(
         "SELECT session_id, COUNT(*) AS msg_count, "
         "       MIN(timestamp_utc) AS started, MAX(timestamp_utc) AS last_activity "
         "FROM conversation_messages "
@@ -359,6 +427,33 @@ def list_conversations(conn, *, sort="recent", limit=50, offset=0) -> dict:
         "ORDER BY " + order + " LIMIT ? OFFSET ?",
         (limit + 1, offset),
     ).fetchall()
+
+
+def list_conversations(conn, *, sort="recent", limit=50, offset=0) -> dict:
+    """All-history per-session browse rows (spec §3.1). NOT 365-day bounded.
+
+    Reads the conversation_sessions rollup (Task A) when it is authoritative —
+    i.e. the durable ``conversation_sessions_backfill_pending`` flag is clear —
+    which lets the ``recent`` sort early-terminate on idx_conv_sessions_recent
+    with no full-table aggregate. While the flag is set (an existing install
+    before its first sync consumes the backfill, or permanently under
+    ``--no-sync``), it falls back to the RETAINED live GROUP BY over
+    conversation_messages — correct, possibly slower, never an empty rail.
+
+    The two branches are byte-identical for every (sort, limit, offset): the
+    rollup recomputes the same COUNT/MIN/MAX over the same rows, and the
+    fallback IS the old aggregate (pinned by the reconcile test over both
+    branches). Staleness bound: at most one sync tick (~5s) if a session gains
+    messages on the exact tick the rail reads — cosmetic only, and the rail
+    revalidates every visible tick anyway."""
+    limit = max(1, min(int(limit), 200))
+    offset = max(0, int(offset))
+    if _rollup_authoritative(conn):
+        order = _SORTS.get(sort, _SORTS["recent"])
+        rows = _list_session_rows_rollup(conn, order, limit, offset)
+    else:
+        order = _SORTS_LIVE.get(sort, _SORTS_LIVE["recent"])
+        rows = _list_session_rows_live(conn, order, limit, offset)
     has_more = len(rows) > limit
     rows = rows[:limit]
     session_ids = [r[0] for r in rows]
@@ -536,6 +631,7 @@ def _assemble_session(conn, session_id):
     # the top-level subagent_meta map (no undocumented block keys leak). Join is
     # spawn tool_use id <-> tool_result tool_use_id; agent_id == subagent_key.
     spawn_kind = {}     # tool_use id -> subagent_type
+    spawn_desc = {}     # tool_use id -> spawning Task description (#193)
     agent_link = {}     # tool_use id -> (agent_id, raw_meta)
     ask_link = {}       # tool_use id -> (answers, annotations)  (#177 S2)
     bash_link = {}      # tool_use id -> (stderr, interrupted)   (#177 S3)
@@ -549,6 +645,13 @@ def _assemble_session(conn, session_id):
                 st = b.pop("subagent_type", None)
                 if st and b.get("id") is not None:
                     spawn_kind[b["id"]] = st
+                    # #193: harvest the spawning Task description from the
+                    # already-stored bounded input. Guarded on subagent_type, so
+                    # a Bash `description` (no subagent_type) is NEVER picked up.
+                    _inp = b.get("input")
+                    _d = _inp.get("description") if isinstance(_inp, dict) else None
+                    if isinstance(_d, str) and _d.strip():
+                        spawn_desc[b["id"]] = _d
             elif k == "tool_result":
                 aid = b.pop("agent_id", None)
                 meta = b.pop("subagent_meta", None)
@@ -579,6 +682,8 @@ def _assemble_session(conn, session_id):
             continue                       # spawn with no (yet) result -> title-only
         _aid, _raw = _link
         _entry = {"kind": _kind}
+        if spawn_desc.get(_tuid):          # #193: spawning Task description
+            _entry["description"] = spawn_desc[_tuid]
         for _f in ("total_tokens", "total_duration_ms", "total_tool_use_count", "status"):
             if _raw.get(_f) is not None:
                 _entry[_f] = _raw[_f]
@@ -783,6 +888,13 @@ def get_conversation(conn, session_id, *, after=None, limit=500):
     subagent_meta = asm["subagent_meta"]
     header_cost = asm["header_cost"]
 
+    # #193: compute the reader header title ONCE so BOTH return sites (the early
+    # empty/stale-cursor return and the normal return) carry it. Same fallback
+    # chain the rail/search rows use: ai-title -> first human prompt -> project
+    # label -> session_id (matching the list's `titles.get(sid) or pl or sid`).
+    _pl = _project_label(_latest(logical, 10))
+    _title = _session_titles_map(conn, [session_id]).get(session_id) or _pl or session_id
+
     # Cursor pagination over the item list (anchored to each item's canonical id).
     # A non-None `after` that matches no item's anchor (stale/deleted cursor)
     # yields an EMPTY page — never silently re-serves the head (M1).
@@ -796,7 +908,8 @@ def get_conversation(conn, session_id, *, after=None, limit=500):
         if start is None:
             return {
                 "session_id": session_id,
-                "project_label": _project_label(_latest(logical, 10)),
+                "title": _title,
+                "project_label": _pl,
                 "git_branch": _latest(logical, 11),
                 "started_utc": logical[0][2],
                 "last_activity_utc": logical[-1][2],
@@ -830,7 +943,8 @@ def get_conversation(conn, session_id, *, after=None, limit=500):
     models = sorted({r[6] for r in logical if r[6]})
     return {
         "session_id": session_id,
-        "project_label": _project_label(_latest(logical, 10)),
+        "title": _title,
+        "project_label": _pl,
         "git_branch": _latest(logical, 11),
         "started_utc": first[2],
         "last_activity_utc": last[2],

package/bin/cctally

@@ -792,6 +792,7 @@ _progress_stderr = _cctally_cache._progress_stderr
 _ensure_session_files_row = _cctally_cache._ensure_session_files_row
 sync_cache = _cctally_cache.sync_cache
 backfill_conversation_messages = _cctally_cache.backfill_conversation_messages
+backfill_ai_titles = _cctally_cache.backfill_ai_titles
 iter_entries = _cctally_cache.iter_entries
 _collect_entries_direct = _cctally_cache._collect_entries_direct
 _JoinedClaudeEntry = _cctally_cache._JoinedClaudeEntry