cctally 1.43.2 → 1.44.0

package/CHANGELOG.md

@@ -5,6 +5,21 @@ based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [1.44.0] - 2026-06-14
+
+### Changed
+- Conversation viewer: the dashboard conversation browse-rail is now served from a `conversation_sessions` rollup (a small per-session COUNT/MIN/MAX table maintained inside `sync_cache` under the cache lock, indexed for the recent ordering) instead of a full-table `GROUP BY` over every message on each page load, so the rail stays fast as your history grows and when a backgrounded tab refocuses after queuing SSE ticks; the rollup is re-derivable like the rest of `cache.db` (a one-time backfill arms automatically on the next sync via cache migration `013`, with a live `GROUP BY` fallback until it lands, so the rail's output is byte-identical either way), and the rail now pauses its per-tick page-1 refetch while the tab is hidden, firing exactly one refetch on the hidden→visible transition so a freshly-revealed reader is current without re-querying every five seconds while idle.
+
+## [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
@@ -691,6 +714,15 @@ def sync_cache(
                 "DELETE FROM cache_meta WHERE key IN "
                 "('conversation_promote_command_args_pending',"
                 " 'conversation_promote_command_args_cursor')")
+            # Browse-rail rollup: a rebuild re-derives conversation_messages from
+            # offset 0, so wipe the rollup here (in the same destructive txn,
+            # alongside clear_conversation_messages, so a crash-recovery read
+            # can't surface ghost rows) and arm the durable backfill flag. The
+            # post-walk recompute (after the per-file loop, still under the
+            # flock) consumes the flag and rebuilds the rollup from the freshly
+            # re-ingested messages, then drops it last (crash-safe).
+            conn.execute("DELETE FROM conversation_sessions")
+            _set_cache_meta(conn, "conversation_sessions_backfill_pending", "1")
             conn.commit()
             eprint("[cache-sync] rebuild: cleared Claude cached entries")
 
@@ -724,6 +756,33 @@ def sync_cache(
                     "DELETE FROM cache_meta "
                     "WHERE key='conversation_backfill_pending'"
                 )
+                # Browse-rail rollup: a #139 offset-0 backfill bulk-inserts
+                # history into conversation_messages, so arm the durable
+                # recompute flag (idempotent; covers a partial-migration state
+                # where the rollup is empty but messages just landed). The
+                # post-walk recompute rebuilds it and drops the flag last.
+                _set_cache_meta(conn, "conversation_sessions_backfill_pending", "1")
+                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.
@@ -781,6 +840,13 @@ def sync_cache(
                 # three flags + cursor + gen atomically on completion. Never on the rebuild
                 # path (which already wipes + repopulates id-aware via the normal walk).
                 _resumable_reingest_conversation_messages(conn)
+                # Browse-rail rollup: a #179 reingest DELETEs + re-inserts every
+                # file's conversation_messages rows (bumping autoincrement ids and
+                # potentially MIN/MAX), so arm the durable recompute flag
+                # (idempotent; covers a partial-migration state). The post-walk
+                # recompute rebuilds the rollup and drops the flag last.
+                _set_cache_meta(conn, "conversation_sessions_backfill_pending", "1")
+                conn.commit()
 
             # #177 S6: consume the migration-010 search-column split under the
             # SAME held flock, AFTER the reingest so any just-re-ingested rows
@@ -905,6 +971,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
@@ -926,6 +997,13 @@ def sync_cache(
             conn.execute(
                 "UPDATE session_files SET size_bytes = 0, last_byte_offset = 0"
             )
+            # Browse-rail rollup: truncation escalates to a full offset-0
+            # re-ingest of conversation_messages, so wipe the rollup here (in the
+            # same destructive txn, alongside clear_conversation_messages) and
+            # arm the durable backfill flag. The post-walk recompute rebuilds it
+            # from the re-ingested messages and drops the flag last (crash-safe).
+            conn.execute("DELETE FROM conversation_sessions")
+            _set_cache_meta(conn, "conversation_sessions_backfill_pending", "1")
             conn.commit()
             stats.files_reset_truncated += len(truncated_paths)
             # Force every file to re-ingest from offset 0: clearing the
@@ -935,6 +1013,14 @@ def sync_cache(
             # avoids a redundant per-file DELETE that would be a no-op).
             existing = {}
 
+        # Browse-rail rollup: accumulate the session_ids whose
+        # conversation_messages this walk touched, so the post-walk recompute can
+        # scope its DELETE+INSERT re-derive to just those sessions (steady
+        # state). Pure Python —
+        # updated only AFTER each per-file conn.commit() below, never inside the
+        # zero-write-lock read/parse region, so it adds no DML there.
+        touched_sessions: set = set()
+
         for jp in paths:
             path_str = str(jp)
             # Backfill session_id/project_path for A2 `session` subcommand.
@@ -976,6 +1062,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 +1074,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 +1102,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 +1207,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.
@@ -1134,6 +1230,12 @@ def sync_cache(
                 )
                 conn.commit()
                 stats.files_processed += 1
+                # Browse-rail rollup: record the session_ids this file just
+                # committed so the post-walk recompute can scope its DELETE+INSERT
+                # re-derive to them. cr[0] is session_id per _conv_row_tuple's
+                # column order. Lands
+                # AFTER the commit (pure Python; no DML, no extra write lock).
+                touched_sessions.update(cr[0] for cr in conv_rows if cr[0] is not None)
             except sqlite3.DatabaseError as exc:
                 eprint(f"[cache] db error on {jp}: {exc}")
                 conn.rollback()
@@ -1146,6 +1248,31 @@ def sync_cache(
         if progress is not None:
             progress(stats)
 
+        # Browse-rail rollup maintenance (single post-walk recompute, under the
+        # still-held flock, after every per-file commit and before the
+        # walk-complete marker). Keyed on the DURABLE flag, not an in-memory
+        # bool: a crash between a destructive path's commit (rebuild /
+        # truncation / #139 backfill / #179 reingest, each of which armed the
+        # flag in its own committed txn) and this recompute leaves the flag set,
+        # so the next sync full-recomputes — never strands stale rollup rows
+        # (Codex gate BLOCKER 1). Flag set -> full GROUP BY over all sessions
+        # (rare, ~90ms), then drop the flag LAST (drop-it-last contract). Else ->
+        # scoped re-derive (DELETE+INSERT, not a SQL UPSERT) over just the
+        # sessions this walk touched (steady state,
+        # ~1 session/tick). Both recomputes derive COUNT/MIN/MAX from the same
+        # rows the rail's old live aggregate read, so the rollup stays
+        # byte-identical to that aggregate.
+        if _conversation_sessions_backfill_pending(conn):
+            _recompute_conversation_sessions(conn)
+            conn.execute(
+                "DELETE FROM cache_meta "
+                "WHERE key='conversation_sessions_backfill_pending'"
+            )
+            conn.commit()
+        elif touched_sessions:
+            _recompute_conversation_sessions(conn, touched_sessions)
+            conn.commit()
+
         # Walk-complete sentinel write (cctally-dev#93, D5a). Still inside the
         # held fcntl lock, before the finally-unlock. Only when the entire walk
         # was clean AND cache 001 was already applied at the start of this run
@@ -1226,6 +1353,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",
@@ -1317,6 +1484,88 @@ def _resumable_reingest_conversation_messages(conn):
     conn.commit()
 
 
+# === Browse-rail rollup (conversation_sessions) maintenance =================
+# Keeps conversation_sessions — the four structural aggregates the old live
+# GROUP BY produced — in lockstep with conversation_messages so
+# GET /api/conversations renders a page without scanning the whole message
+# table. Maintained entirely inside sync_cache under the cache.db.lock flock:
+# the steady-state per-file loop is insert-only, so a scoped re-derive
+# (DELETE+INSERT, not a SQL UPSERT) over the touched sessions suffices; the
+# rare heavy/destructive paths (rebuild,
+# truncation-escalation, #139 backfill, #179 reingest) set the durable
+# ``conversation_sessions_backfill_pending`` cache_meta flag (migration 013
+# arms it too) which forces one full recompute, crash-safe across a
+# destructive-commit/recompute crash window. The CALLER owns the commit.
+
+# All non-null sessions, recomputed from conversation_messages. Shared by the
+# full and scoped recompute so both paths derive byte-identical aggregates.
+_CONV_SESSIONS_SELECT = (
+    "SELECT session_id, COUNT(*), MIN(timestamp_utc), MAX(timestamp_utc) "
+    "FROM conversation_messages WHERE session_id IS NOT NULL"
+)
+
+
+def _conversation_sessions_backfill_pending(conn) -> bool:
+    """True while the durable ``conversation_sessions_backfill_pending`` flag is
+    set — the signal that the rollup needs one full GROUP BY recompute (armed by
+    migration 013 and by every heavy/destructive conversation_messages path).
+    Tolerates a missing cache_meta table (path-less / schema-not-applied conn) by
+    degrading to False, like the sibling reingest/backfill predicates."""
+    try:
+        return conn.execute(
+            "SELECT 1 FROM cache_meta "
+            "WHERE key='conversation_sessions_backfill_pending'"
+        ).fetchone() is not None
+    except sqlite3.OperationalError:
+        return False
+
+
+def _recompute_conversation_sessions(conn, session_ids=None) -> None:
+    """Recompute the ``conversation_sessions`` browse-rail rollup from
+    ``conversation_messages``. The caller holds the cache.db.lock flock and owns
+    the commit (this helper never commits).
+
+    ``session_ids is None`` -> FULL: wipe the whole rollup and rebuild it from a
+    single GROUP BY over every non-null session — the rare, flag-gated path
+    (rebuild / truncation / backfill / reingest / migration-013 history).
+
+    ``session_ids={...}`` -> SCOPED: for each <=400-id chunk, DELETE those rows
+    then re-INSERT the GROUP BY restricted to the chunk — the steady-state path
+    keyed on the per-file loop's touched set. DELETE+INSERT (NOT
+    INSERT…SELECT…ON CONFLICT, which trips SQLite's upsert-on-SELECT parse
+    ambiguity) also correctly drops a session whose rows all vanished — though in
+    steady state conversation_messages only gains rows, so that branch is just
+    belt-and-suspenders. The chunking keeps the ``session_id IN (…)`` parameter
+    list well under SQLite's variable limit.
+
+    The recomputed COUNT/MIN/MAX are byte-identical to the rail's prior live
+    aggregate over the same rows — that is the load-bearing invariant
+    (assert_rollup_matches_live in the maintenance test pins it)."""
+    if session_ids is None:
+        conn.execute("DELETE FROM conversation_sessions")
+        conn.execute(
+            "INSERT INTO conversation_sessions "
+            "(session_id, msg_count, started_utc, last_activity_utc) "
+            + _CONV_SESSIONS_SELECT + " GROUP BY session_id"
+        )
+        return
+    ids = [s for s in session_ids if s is not None]
+    for i in range(0, len(ids), 400):
+        chunk = ids[i:i + 400]
+        placeholders = ",".join("?" for _ in chunk)
+        conn.execute(
+            f"DELETE FROM conversation_sessions WHERE session_id IN ({placeholders})",
+            chunk,
+        )
+        conn.execute(
+            "INSERT INTO conversation_sessions "
+            "(session_id, msg_count, started_utc, last_activity_utc) "
+            + _CONV_SESSIONS_SELECT
+            + f" AND session_id IN ({placeholders}) GROUP BY session_id",
+            chunk,
+        )
+
+
 def _consume_search_split(conn) -> None:
     """#177 S6: flock-held consumer for ``conversation_search_split_pending``
     (set by cache migration 010). Cursor-resumable: backfills

package/bin/_cctally_dashboard.py

@@ -251,6 +251,32 @@ from typing import Any
 from zoneinfo import ZoneInfo, ZoneInfoNotFoundError
 
 
+class _QuietThreadingHTTPServer(ThreadingHTTPServer):
+    """`ThreadingHTTPServer` that swallows client-disconnect tracebacks.
+
+    A backgrounded/closed/reloaded dashboard tab hangs up mid-response, so the
+    per-request thread's socket write raises one of the "peer went away"
+    exceptions, which `socketserver` routes through `handle_error`. On a local
+    dashboard that is expected and benign — dumping a socket-write stack trace
+    to the user's console for every such disconnect is pure noise (the original
+    report was repeated `BrokenPipeError` spam after hours idle). Everything
+    else still gets the full traceback via `super().handle_error`.
+
+    `daemon_threads = True` is folded in here (was an inline `srv.*` assignment):
+    SSE handler threads may block up to 15s on the keep-alive timeout — let them
+    die with the process.
+    """
+
+    daemon_threads = True
+
+    def handle_error(self, request, client_address):
+        exc = sys.exc_info()[1]
+        if isinstance(exc, (BrokenPipeError, ConnectionResetError, ConnectionAbortedError)):
+            # Client hung up mid-response; benign on a local dashboard.
+            return
+        super().handle_error(request, client_address)
+
+
 def _cctally():
     """Resolve the current ``cctally`` module at call-time (spec §5.5)."""
     return sys.modules["cctally"]
@@ -8251,8 +8277,9 @@ def cmd_dashboard(args: argparse.Namespace) -> int:
     update_check_thread.start()
 
     # HTTP server on its own thread so the main thread can block on signal.
-    srv = ThreadingHTTPServer((args.host, args.port), DashboardHTTPHandler)
-    srv.daemon_threads = True  # SSE handler threads may block up to 15s on keep-alive timeout — let them die with the process.
+    # `_QuietThreadingHTTPServer` folds in `daemon_threads = True` and silences
+    # client-disconnect tracebacks (spec §5).
+    srv = _QuietThreadingHTTPServer((args.host, args.port), DashboardHTTPHandler)
 
     bind_host = args.host
     bind_port = srv.server_address[1]

package/bin/_cctally_db.py

@@ -2349,6 +2349,38 @@ 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
+        );
+
+        -- Browse-rail rollup (conversation_sessions). Materializes exactly the
+        -- four structural aggregates the rail's old live GROUP BY produced
+        -- (COUNT/MIN/MAX over conversation_messages per session_id) so
+        -- GET /api/conversations no longer scans the whole message table to
+        -- render a 50-row page. The explicit NOT NULL on the non-INTEGER PK
+        -- matters (SQLite's legacy NULL-in-PK bug); the rail keys on a concrete
+        -- session_id and the recompute's GROUP BY already filters nulls. The
+        -- index lets the only paginated ordering (recent) early-terminate at
+        -- LIMIT with no temp B-tree. Re-derivable like the rest of cache.db;
+        -- sync_cache keeps it honest (scoped DELETE+INSERT re-derive +
+        -- flag-gated full recompute) — migration 013 arms the one-time
+        -- history backfill.
+        CREATE TABLE IF NOT EXISTS conversation_sessions (
+            session_id        TEXT NOT NULL PRIMARY KEY,
+            msg_count         INTEGER NOT NULL DEFAULT 0,
+            started_utc       TEXT,
+            last_activity_utc TEXT
+        );
+        CREATE INDEX IF NOT EXISTS idx_conv_sessions_recent
+            ON conversation_sessions(last_activity_utc DESC, session_id DESC);
+
         CREATE TABLE IF NOT EXISTS codex_session_files (
             path             TEXT PRIMARY KEY,
             size_bytes       INTEGER NOT NULL,
@@ -3383,6 +3415,33 @@ 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()
+
+
+@cache_migration("013_create_conversation_sessions")
+def _013_create_conversation_sessions(conn: sqlite3.Connection) -> None:
+    """Flag-only arm for the conversation_sessions browse-rail rollup. The table
+    is created by _apply_cache_schema (every open); this sets
+    conversation_sessions_backfill_pending so sync_cache does the one-time full
+    GROUP BY recompute 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 running the handler, so the flag is NOT set there, which is
+    correct (empty messages -> empty rollup; the incremental DELETE+INSERT
+    re-derive fills both in lockstep). Mirrors 012."""
+    _set_cache_meta(conn, "conversation_sessions_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):