cctally 1.43.2 → 1.43.3

package/CHANGELOG.md

@@ -5,6 +5,16 @@ based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [1.43.3] - 2026-06-14
+
+### Added
+- Conversation viewer: each conversation is now titled by Claude Code's AI-generated session title — in the sessions rail and as the reader header — instead of the first prompt, falling back in order to the first prompt, the project label, then the session id; a title that Claude rewrites mid-session updates an already-open reader live (#193).
+- Conversation viewer: a subagent thread is now titled by the description from the `Task` that spawned it, in both the thread-card header and the matching outline landmark (falling back to the subagent's first prompt), and a Bash tool call shows its own description on the dimmed chip line (falling back to the command, which always stays in the expanded `$ …` body); older transcripts and tool calls without a stored description keep their prior rendering (#193).
+
+### Fixed
+- Conversation viewer: a short single-line "You" prompt no longer shows an empty gap below its text — the per-message copy/permalink actions (previously an always-reserved but hidden-until-hover row that padded the bottom of the bordered box) now float into the bubble's top-right corner, so the box hugs its prose; assistant turns are unchanged (#192).
+- Conversation viewer: the outline no longer highlights two entries at once when you scroll onto a landmark inside a prompt's section — a subagent card, a section heading, or a plan/question (most visible when a subagent is the last outline entry) — it now marks only that exact landmark instead of also lighting the enclosing "You" prompt, while scrolling onto ordinary prose still highlights its section prompt as before (#192).
+
 ## [1.43.2] - 2026-06-13
 
 ### Added

package/bin/_cctally_cache.py

@@ -189,6 +189,18 @@ _CONV_INSERT_SQL = (
     " VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)"
 )
 
+# #193: last non-null write wins (ai-title carries no timestamp; see spec S1). NO
+# byte_offset guard — it can't order a cross-file resumed session. Ordering is
+# made deterministic by ingest order: backfill_ai_titles walks files
+# mtime-ascending so the newest file's last title is written last; the
+# incremental fused walk appends only new bytes in file order.
+_AI_TITLE_UPSERT_SQL = (
+    "INSERT INTO conversation_ai_titles(session_id,ai_title,source_path,byte_offset) "
+    "VALUES(?,?,?,?) "
+    "ON CONFLICT(session_id) DO UPDATE SET "
+    "ai_title=excluded.ai_title, source_path=excluded.source_path, byte_offset=excluded.byte_offset"
+)
+
 
 def _conv_row_tuple(m, path_str):
     """Flatten a ``MessageRow`` into the ``_CONV_INSERT_SQL`` column order.
@@ -212,19 +224,23 @@ def _conv_row_tuple(m, path_str):
 
 def _iter_sync_entries(fh, path_str):
     """Fused single-pass sync walker (#138). Yields
-    ``(byte_offset, cost_or_None, msgrow_or_None)`` for each JSONL line from
-    ``fh``'s current position that produces a cost entry and/or a conversation
-    message row.
+    ``(byte_offset, cost_or_None, msgrow_or_None, aititle_or_None)`` for each
+    JSONL line from ``fh``'s current position that produces a cost entry, a
+    conversation message row, and/or an ai-title record.
 
     Each line is read once (readline()+tell()) and ``json.loads``-parsed ONCE,
-    then classified by both pure per-line parsers:
+    then classified by the pure per-line parsers (#138 one-parse-per-line stays
+    intact — ``parse_ai_title`` runs on the SAME already-parsed ``obj``):
 
       * ``cost_or_None`` is ``(UsageEntry, msg_id, req_id)`` when the line is a
         billable assistant entry (``_lib_jsonl.parse_cost_entry``), else None.
       * ``msgrow_or_None`` is a ``MessageRow`` when the line is a user/assistant
         turn carrying a uuid (``_lib_conversation.parse_message_row``), else None.
+      * ``aititle_or_None`` is an ``AiTitleRow`` when the line is an ai-title
+        carrying a non-empty sessionId+aiTitle (#193), else None.
 
-    The two are independent — a normal assistant line yields both. This replaces
+    The three are independent — a normal assistant line yields the first two;
+    an ai-title line (a non-user/assistant type) yields only the third. This replaces
     the former cost walk + re-seek-and-walk over the identical byte span: with a
     single walk the "identical span" invariant is structural (one stop point),
     not a prose-enforced ``mrow.byte_offset >= final_offset`` runtime break. A
@@ -252,8 +268,9 @@ def _iter_sync_entries(fh, path_str):
             continue
         cost = _lib_jsonl.parse_cost_entry(obj, path_str)
         mrow = _lib_conversation.parse_message_row(obj, offset)
-        if cost is not None or mrow is not None:
-            yield offset, cost, mrow
+        ai = _lib_conversation.parse_ai_title(obj, offset)
+        if cost is not None or mrow is not None or ai is not None:
+            yield offset, cost, mrow, ai
 
 
 def _iter_claude_jsonl_files():
@@ -616,6 +633,12 @@ def sync_cache(
             # under the lock (#138) — NOT a bare DELETE that fires conv_fts_ad
             # per row.
             clear_conversation_messages(conn)
+            # #193: ai-titles share the message lifecycle on a rebuild — wipe the
+            # table (so a title for a since-deleted session can't linger) and the
+            # pending-backfill flag in lockstep. The per-file fused walk below
+            # repopulates from offset 0, satisfying any deferred backfill.
+            conn.execute("DELETE FROM conversation_ai_titles")
+            conn.execute("DELETE FROM cache_meta WHERE key='ai_titles_backfill_pending'")
             # Clear the walk-complete sentinel atomically with the wipe
             # (cctally-dev#93, D5/D2): a stale "complete" marker must never
             # survive a destructive rebuild. The end-of-loop write below
@@ -726,6 +749,27 @@ def sync_cache(
                 )
                 conn.commit()
 
+            # #193: consume the deferred ai-title backfill. Cache migration 012 is
+            # flag-only (sets ``ai_titles_backfill_pending``); the offset-0 walk
+            # over all history via backfill_ai_titles (mtime-ascending,
+            # last-write-wins) runs HERE under the held flock — same #139
+            # contract as the message backfill above. Touches ONLY
+            # conversation_ai_titles; the flag is dropped LAST so a crash mid-walk
+            # re-runs cleanly. Never on the rebuild path (which already cleared
+            # the flag + repopulates via the normal walk).
+            try:
+                _ai_pending = conn.execute(
+                    "SELECT 1 FROM cache_meta WHERE key='ai_titles_backfill_pending'"
+                ).fetchone() is not None
+            except sqlite3.OperationalError:
+                _ai_pending = False
+            if _ai_pending:
+                backfill_ai_titles(conn)
+                conn.execute(
+                    "DELETE FROM cache_meta WHERE key='ai_titles_backfill_pending'"
+                )
+                conn.commit()
+
             # Issue #164: consume the deferred conversation_messages re-ingest.
             # Cache migration 003 is flag-only — it sets
             # ``conversation_reingest_pending`` rather than clearing inline
@@ -905,6 +949,11 @@ def sync_cache(
             # triggers → truncate → 'delete-all' → recreate, so conv_fts_ad
             # never fires O(rows) inside the held lock.
             clear_conversation_messages(conn)
+            # #193: truncation escalates to a full offset-0 re-ingest, so wipe
+            # conversation_ai_titles too (parallel to the session_entries +
+            # conversation_messages full-reset). The per-file fused walk below
+            # repopulates it from offset 0.
+            conn.execute("DELETE FROM conversation_ai_titles")
             # Clear the walk-complete sentinel atomically with the truncation
             # full-reset (cctally-dev#93, D5/D2): the cache is being wiped, so
             # any "complete" marker is now stale. The end-of-loop write below
@@ -976,6 +1025,7 @@ def sync_cache(
             # so a slow JSONL doesn't hold a SQLite lock.
             rows: list[tuple[Any, ...]] = []
             conv_rows: list[tuple[Any, ...]] = []
+            ai_rows: list[tuple[Any, ...]] = []   # #193: ai-title upserts
             final_offset = start_offset
             try:
                 with open(jp, "r", encoding="utf-8", errors="replace") as fh:
@@ -987,7 +1037,7 @@ def sync_cache(
                     # walk over the identical span — the "identical span"
                     # invariant is now structural (a single stop point) rather
                     # than a prose-enforced ``>= final_offset`` runtime break.
-                    for offset, cost, mrow in _iter_sync_entries(fh, path_str):
+                    for offset, cost, mrow, ai in _iter_sync_entries(fh, path_str):
                         if cost is not None:
                             entry, msg_id, req_id = cost
                             usage = entry.usage
@@ -1015,6 +1065,11 @@ def sync_cache(
                             ))
                         if mrow is not None:
                             conv_rows.append(_conv_row_tuple(mrow, path_str))
+                        if ai is not None:
+                            # #193: accumulate ai-title upserts in file order; the
+                            # executemany below applies them after conv_rows.
+                            ai_rows.append((ai.session_id, ai.ai_title,
+                                            path_str, ai.byte_offset))
                     # ``final_offset`` is the single walk's stop — captured AFTER
                     # the loop drains (or rewinds a partial mid-write tail line).
                     # It is what session_files.last_byte_offset is written from,
@@ -1115,6 +1170,10 @@ def sync_cache(
                 # (parallel to the cost path's lifecycle).
                 if conv_rows:
                     conn.executemany(_CONV_INSERT_SQL, conv_rows)
+                # #193: ai-title upserts for this file, in file order (last wins).
+                # Committed atomically with the session_files cursor below.
+                if ai_rows:
+                    conn.executemany(_AI_TITLE_UPSERT_SQL, ai_rows)
                 # UPSERT preserves session_id / project_path columns populated
                 # by _ensure_session_files_row at the top of this loop. A plain
                 # INSERT OR REPLACE would wipe them on every changed-file sync.
@@ -1226,6 +1285,46 @@ def backfill_conversation_messages(conn: sqlite3.Connection) -> int:
     return inserted
 
 
+def backfill_ai_titles(conn: sqlite3.Connection) -> int:
+    """One-time backfill of ``conversation_ai_titles`` for existing installs
+    (#193). Walks EVERY Claude JSONL from offset 0 via
+    ``_lib_conversation.iter_ai_titles`` and upserts.
+
+    Files are walked MTIME-ASCENDING so that, for a session whose ai-title spans
+    multiple files (a ``--resume``), the most-recently-modified file's last
+    non-null title is written last (last-write-wins; see _AI_TITLE_UPSERT_SQL).
+    Per-file commit; the caller (``sync_cache``, consuming the
+    ``ai_titles_backfill_pending`` flag) holds the ``cache.db.lock`` flock for the
+    duration. Touches ONLY ``conversation_ai_titles`` — the cost/message cursors
+    are untouched. Idempotent: a re-run rewrites the same current title (the
+    last-write-wins ordering is stable under the deterministic mtime walk).
+    Returns rows upserted."""
+    n = 0
+
+    def _mtime(p):
+        try:
+            return p.stat().st_mtime
+        except OSError:
+            return 0.0  # vanished mid-walk; sorts first, the open() below skips it
+
+    files = sorted(_iter_claude_jsonl_files(), key=_mtime)
+    for jp in files:
+        path_str = str(jp)
+        rows: list[tuple[Any, ...]] = []
+        try:
+            with open(jp, "r", encoding="utf-8", errors="replace") as fh:
+                for r in _lib_conversation.iter_ai_titles(fh, path_str):
+                    rows.append((r.session_id, r.ai_title, path_str, r.byte_offset))
+        except OSError as exc:
+            eprint(f"[ai-title-backfill] could not read {jp}: {exc}")
+            continue
+        if rows:
+            conn.executemany(_AI_TITLE_UPSERT_SQL, rows)
+            n += len(rows)
+            conn.commit()
+    return n
+
+
 _REINGEST_FLAG_KEYS = (
     "conversation_reingest_pending",
     "conversation_source_tool_use_reingest_pending",

package/bin/_cctally_db.py

@@ -2349,6 +2349,17 @@ def _apply_cache_schema(conn: sqlite3.Connection) -> None:
         CREATE INDEX IF NOT EXISTS idx_conv_turnkey
             ON conversation_messages(msg_id, req_id);
 
+        -- #193: per-session AI-generated title, isolated from the six places
+        -- that iterate conversation_messages. The explicit NOT NULL on the
+        -- non-INTEGER PRIMARY KEY matters (SQLite's legacy NULL-in-PK bug);
+        -- _session_titles_map can only key on a concrete session_id.
+        CREATE TABLE IF NOT EXISTS conversation_ai_titles (
+            session_id  TEXT NOT NULL PRIMARY KEY,
+            ai_title    TEXT NOT NULL,
+            source_path TEXT,
+            byte_offset INTEGER NOT NULL
+        );
+
         CREATE TABLE IF NOT EXISTS codex_session_files (
             path             TEXT PRIMARY KEY,
             size_bytes       INTEGER NOT NULL,
@@ -3383,6 +3394,19 @@ def _011_conversation_promote_command_args(conn: sqlite3.Connection) -> None:
     conn.commit()
 
 
+@cache_migration("012_create_conversation_ai_titles")
+def _012_create_conversation_ai_titles(conn: sqlite3.Connection) -> None:
+    """Flag-only arm for #193. The conversation_ai_titles table itself is created
+    by _apply_cache_schema (runs on every open, fresh + existing installs); this
+    migration sets ``ai_titles_backfill_pending`` so sync_cache walks all history
+    once via backfill_ai_titles under the cache.db.lock flock. No data work here
+    -> the dispatcher's central stamp (#140) marks a complete handler; a fresh
+    install stamps WITHOUT a populated history (its incremental walk fills the
+    table as it ingests, and the consumed backfill no-ops). Mirrors 002/010/011."""
+    _set_cache_meta(conn, "ai_titles_backfill_pending", "1")
+    conn.commit()
+
+
 # === Region 7d: Stats migration 008_recompute_weekly_cost_snapshots_dedup_fix ===
 
 @stats_migration("008_recompute_weekly_cost_snapshots_dedup_fix")

package/bin/_lib_conversation.py

@@ -263,6 +263,55 @@ def parse_message_row(obj, offset):
     return _normalize(obj, t, offset)
 
 
+@dataclass
+class AiTitleRow:
+    """Pure per-line AI-title record (no I/O). Parallels MessageRow but for the
+    main-session ``{"type":"ai-title","aiTitle":...,"sessionId":...}`` lines that
+    parse_message_row drops (type not in user/assistant). #193."""
+    session_id: "str | None"
+    ai_title: str
+    byte_offset: int
+
+
+def parse_ai_title(obj, offset):
+    """Return an AiTitleRow when ``obj`` is an ai-title line with BOTH a non-empty
+    string sessionId and a non-empty string aiTitle, else None. Skips the null /
+    blank rewrites CC emits as the title evolves, and any malformed line. #193."""
+    if obj.get("type") != "ai-title":
+        return None
+    sid = obj.get("sessionId")
+    title = obj.get("aiTitle")
+    if not (isinstance(sid, str) and sid.strip()):
+        return None
+    if not (isinstance(title, str) and title.strip()):
+        return None
+    return AiTitleRow(sid, title, offset)
+
+
+def iter_ai_titles(fh, path_str):
+    """Yield AiTitleRow for each ai-title line from ``fh``'s current position.
+    Mirrors iter_message_rows: caller owns the open file handle; pure parse.
+    ``path_str`` is accepted for signature-parity (ai-title rows don't use it)."""
+    while True:
+        offset = fh.tell()
+        line = fh.readline()
+        if not line:
+            return
+        if not line.endswith("\n"):
+            fh.seek(offset)
+            return
+        s = line.strip()
+        if not s:
+            continue
+        try:
+            obj = json.loads(s)
+        except json.JSONDecodeError:
+            continue
+        row = parse_ai_title(obj, offset)
+        if row is not None:
+            yield row
+
+
 def _normalize(obj, t, offset):
     msg = obj.get("message")
     if not isinstance(msg, dict):

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
@@ -536,6 +549,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 +563,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 +600,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 +806,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 +826,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 +861,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