cctally 1.92.0 → 1.92.2

package/bin/_cctally_tui.py

@@ -2966,7 +2966,22 @@ def _tui_build_snapshot(
         # ``_tui_build_snapshot_once`` closes its live stats connection before
         # this boundary. The replacement-capable hook can therefore satisfy
         # the whole-family drain gate, and the retry opens the published family.
-        _tui_heal_post_query_stats(fault.cause)
+        #
+        # #496 S3 §6: the heal now DEFERS, and its signal is a
+        # `BaseException`. This call sits before the retry's own `except`, so
+        # the shared deferral base is caught AT the heal-call boundary and the
+        # corruption-typed degraded frame is built directly. The retry must not
+        # spin: after deferral the index is still corrupt, so a second attempt
+        # would only fail again, and the frame converges on a later tick.
+        try:
+            _tui_heal_post_query_stats(fault.cause)
+        except _cctally().StatsRebuildDeferred as deferred:
+            return _tui_stats_retry_degraded_snapshot(
+                now_utc=now_utc or dt.datetime.now(dt.timezone.utc),
+                exc=deferred,
+                precompute_envelope=precompute_envelope,
+                runtime_bind=runtime_bind,
+            )
         try:
             return _tui_build_snapshot_once(
                 now_utc=now_utc,
@@ -3279,6 +3294,8 @@ def _tui_build_snapshot_once(
                             runtime_bind=runtime_bind, raw_config=raw_config,
                             display_tz_pref_override=display_tz_pref_override,
                             source_stats_conn=conn,
+                            failures=sync_failures,
+                            stats_heal_attempted=stats_heal_attempted,
                             source_display_tz_name=(
                                 getattr(_build_display_tz, "key", None)
                                 if _build_display_tz is not None else None
@@ -4068,7 +4085,9 @@ def _tui_build_idle_snapshot(prior, *, now_utc, precompute_envelope,
                              codex_ingest_contended=False,
                              codex_ingest_failed=False,
                              claude_ingest_contended=False,
-                             claude_ingest_failed=False):
+                             claude_ingest_failed=False,
+                             failures=None,
+                             stats_heal_attempted=False):
     """Fresh snapshot reusing ``prior``'s heavy rows, re-patching only the
     time-derived fields + the doctor payload / envelope precompute on each idle
     tick (spec §3 idle path).
@@ -4108,6 +4127,7 @@ def _tui_build_idle_snapshot(prior, *, now_utc, precompute_envelope,
             envelope_precompute = _tui_precompute_envelope_config(raw_config)
         except Exception as exc:  # noqa: BLE001 — never crash the rebuild
             errors.append(f"envelope-precompute: {exc}")
+    idle_failures = failures if failures is not None else []
     source_bundle = prior.source_bundle
     if source_bundle is not None:
         try:
@@ -4180,15 +4200,36 @@ def _tui_build_idle_snapshot(prior, *, now_utc, precompute_envelope,
                     prior_bundle=source_bundle,
                     raw_config=raw_config,
                 )
+        except _StatsSnapshotCorruption:
+            raise
         except Exception as exc:  # noqa: BLE001 — retain prior complete bundle
-            errors.append(f"source-clock-refresh: {exc}")
+            # #496 S3 §8 (F16). This branch read stats through
+            # `source_stats_conn` and swallowed the failure into a plain
+            # string, so it built no `SyncFailureAttribution`, never raised
+            # `_StatsSnapshotCorruption`, and never reached the heal — and
+            # `_sync_failure_envelope`, finding no typed attribution, fell to
+            # its raw-text matcher and told the user to run
+            # `cctally cache-sync --rebuild` for a STATS fault. Classify it at
+            # the catch site instead, against the connection that faulted.
+            if source_stats_conn is not None:
+                _tui_capture_sync_failure(
+                    source_stats_conn,
+                    errors,
+                    idle_failures,
+                    leg="source-clock-refresh",
+                    database="stats_or_cache",
+                    exc=exc,
+                    stats_heal_attempted=stats_heal_attempted,
+                )
+            else:
+                errors.append(f"source-clock-refresh: {exc}")
             source_bundle = prior.source_bundle
     return dataclasses.replace(
         prior,
         generated_at=now_utc,
         last_sync_at=time.monotonic(),
         last_sync_error=("; ".join(errors) if errors else None),
-        sync_failures=(),
+        sync_failures=tuple(idle_failures),
         doctor_payload=doctor_payload,
         envelope_precompute=envelope_precompute,
         source_bundle=source_bundle,
@@ -6611,12 +6652,17 @@ def _make_run_sync_now_locked(*, ref, hub, pinned_now, display_tz_pref_override,
             snap = dataclasses.replace(snap, last_sync_at=None, hydrating=False)
             ref.set(snap)
             hub.publish(snap)
-        except _cctally().StatsEpochRebuildDeferred as exc:
+        except _cctally().StatsRebuildDeferred as exc:
             # #453: the first periodic tick runs before HTTP bind. Preserve the
             # initial hydrating/degraded frame while the dedicated replay owns
             # stats maintenance; a generic crash frame would clear the latch
             # before any client could observe it. The loop retries normally on
             # its next cadence and publishes a full frame after convergence.
+            #
+            # #496 S3: the two deferral classes must NOT flatten here. A wrong
+            # EPOCH is a readable index (`corruption=False`); a deferred heal is
+            # an index that could not be read, and reporting that as
+            # non-corruption makes the envelope name the wrong fault.
             prev = ref.get()
             pending = dataclasses.replace(
                 prev,
@@ -6625,7 +6671,9 @@ def _make_run_sync_now_locked(*, ref, hub, pinned_now, display_tz_pref_override,
                     SyncFailureAttribution(
                         leg="stats-open",
                         database="stats",
-                        corruption=False,
+                        corruption=isinstance(
+                            exc, _cctally().StatsHealDeferred
+                        ),
                     ),
                 ),
                 generated_at=dt.datetime.now(dt.timezone.utc),

package/bin/_lib_codex_conversation_query.py

@@ -34,11 +34,13 @@ import _lib_codex_conversation as kern
 import _lib_codex_landmarks as landmarks
 import _lib_codex_segments as segkern
 from _lib_codex_find_projection import (
+    CODEX_FIND_PROJECTION_VERSION,
     ProjectedLeaf,
     RenderLeaf,
     iter_literal_ranges,
     iter_regex_ranges,
     literal_ranges,
+    project_context,
     project_markdown,
     project_plain,
     regex_ranges,
@@ -3006,6 +3008,7 @@ def list_codex_conversations(
     model: str | None = None,
     limit: int = 50,
     cursor: str | None = None,
+    selected: str | None = None,
 ) -> dict:
     """Browse envelope (§5.6 / §6.1): a page of conversation rows ordered by last
     activity, with project/model facets. Dual-branch — the stored rollup fast
@@ -3021,7 +3024,13 @@ def list_codex_conversations(
         page_rows, page = _stored_browse_page(
             conn, effective_speed=effective_speed, project_key=project_key,
             model=model, limit=limit, cursor=cursor)
-        return {"status": "ok", "rows": page_rows, "facets": facets, "page": page}
+        result = {"status": "ok", "rows": page_rows, "facets": facets, "page": page}
+        if selected is not None:
+            fields = _rollup_fields(conn, selected)
+            if fields is not None:
+                result["selected"] = _browse_row(
+                    conn, selected, effective_speed, fields)
+        return result
 
     fields_rows = _live_browse_fields(conn)
     rows = [
@@ -3034,7 +3043,13 @@ def list_codex_conversations(
                 and (model is None or model in (row["models"] or []))]
     filtered.sort(key=_recent_sort_key, reverse=True)
     page_rows, page = _paginate_rows(filtered, cursor=cursor, limit=limit)
-    return {"status": "ok", "rows": page_rows, "facets": facets, "page": page}
+    result = {"status": "ok", "rows": page_rows, "facets": facets, "page": page}
+    if selected is not None:
+        selected_row = next(
+            (row for row in rows if row["conversation_key"] == selected), None)
+        if selected_row is not None:
+            result["selected"] = selected_row
+    return result
 
 
 # ── search (§6.2) ─────────────────────────────────────────────────────────────
@@ -3111,7 +3126,6 @@ def _pos_to_item_key(conn: sqlite3.Connection, conversation_key: str) -> dict:
 
 # ── #482 visible render-leaf projection ─────────────────────────────────────
 
-CODEX_FIND_PROJECTION_VERSION = 1
 _COMPLETION_EVENT_TYPES = {
     "patch_apply_end",
     "web_search_end",
@@ -3120,7 +3134,7 @@ _COMPLETION_EVENT_TYPES = {
 
 
 def _find_surface(row) -> str | None:
-    if row.kind in {"user", "assistant", "reasoning"}:
+    if row.kind in {"user", "assistant", "reasoning", "meta"}:
         return "body"
     if row.kind == "tool_call":
         return "call"
@@ -3252,6 +3266,17 @@ def _project_find_row(row, *, payload: dict | None = None, block: dict | None =
     text = _row_display(row)
     if not text:
         return None
+    if row.kind == "meta":
+        try:
+            detail = json.loads(row.detail_json or "{}")
+        except (TypeError, json.JSONDecodeError):
+            detail = {}
+        meta_kind = detail.get("meta_kind") if isinstance(detail, dict) else None
+        if meta_kind == "command":
+            return project_plain((RenderLeaf("t0", text),))
+        if meta_kind == "context":
+            return project_context(text)
+        return project_markdown(text)
     if row.kind == "reasoning" and isinstance(block, dict):
         detail = block.get("detail")
         reasoning = detail.get("reasoning") if isinstance(detail, dict) else None
@@ -3397,7 +3422,7 @@ def materialize_codex_find_projection(
                 return
             disclosure = (
                 [container_block_key]
-                if row.kind == "reasoning" or surface != "body"
+                if row.kind in {"reasoning", "meta"} or surface != "body"
                 else []
             )
             conn.execute(

package/bin/_lib_codex_find_projection.py

@@ -12,6 +12,9 @@ import re
 from typing import Iterable, Iterator, Sequence
 
 
+CODEX_FIND_PROJECTION_VERSION = 2
+
+
 @dataclass(frozen=True)
 class RenderLeaf:
     key: str
@@ -301,6 +304,148 @@ def project_plain(leaves: Sequence[RenderLeaf]) -> tuple[str, tuple[ProjectedLea
     return builder.value()
 
 
+_CONTEXT_DIFF_GIT_RE = re.compile(r"diff --git a/\S+ b/\S+")
+_CONTEXT_HUNK_RE = re.compile(r"^@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@")
+_CONTEXT_EXTENDED_HEADER_PREFIXES = (
+    "old mode ", "new mode ", "new file mode ", "deleted file mode ",
+    "rename from ", "rename to ", "copy from ", "copy to ",
+    "similarity index ", "dissimilarity index ", "index ",
+)
+
+
+def _context_is_diff_line(line: str) -> bool:
+    if _CONTEXT_DIFF_GIT_RE.search(line):
+        return True
+    if line.startswith(("--- ", "+++ ", "@@")):
+        return True
+    if line.startswith(_CONTEXT_EXTENDED_HEADER_PREFIXES):
+        return True
+    return line == "" or line[0] in "+- \\"
+
+
+def _segment_context_body(text: str) -> list[tuple[str, str]]:
+    """Mirror ``contextDiff.ts::segmentContextBody`` without rendering HTML."""
+    lines = text.split("\n")
+    if lines and lines[-1] == "":
+        lines.pop()
+    segments: list[tuple[str, str]] = []
+    prose: list[str] = []
+    diff: list[str] = []
+    in_diff = False
+
+    def flush(kind: str, values: list[str]) -> None:
+        if values:
+            segments.append((kind, "\n".join(values)))
+            values.clear()
+
+    for line in lines:
+        if not in_diff:
+            match = _CONTEXT_DIFF_GIT_RE.search(line)
+            if match is None:
+                prose.append(line)
+                continue
+            before = line[:match.start()].rstrip()
+            if before:
+                prose.append(before)
+            flush("prose", prose)
+            in_diff = True
+            diff.append(line[match.start():])
+        elif _context_is_diff_line(line):
+            diff.append(line)
+        else:
+            flush("diff", diff)
+            in_diff = False
+            prose.append(line)
+    flush("prose", prose)
+    flush("diff", diff)
+    return segments
+
+
+def _context_diff_rows(text: str) -> list[tuple[int, int, int, str]]:
+    """Mirror the visible row walk in ``contextDiff.ts::parseUnifiedDiff``."""
+    rows: list[tuple[int, int, int, str]] = []
+    file_index = -1
+    hunk_index = -1
+    row_index = 0
+    in_hunk = False
+    for line in text.split("\n"):
+        if _CONTEXT_DIFF_GIT_RE.search(line):
+            file_index += 1
+            hunk_index = -1
+            row_index = 0
+            in_hunk = False
+            continue
+        if _CONTEXT_HUNK_RE.match(line):
+            hunk_index += 1
+            row_index = 0
+            in_hunk = True
+            continue
+        if not in_hunk:
+            continue
+        if line.startswith(("--- ", "+++ ")) or line.startswith(
+            _CONTEXT_EXTENDED_HEADER_PREFIXES
+        ):
+            continue
+        if line == "" or line.startswith("\\"):
+            continue
+        rows.append((file_index, hunk_index, row_index, line[1:]))
+        row_index += 1
+    return rows
+
+
+def _append_projected(
+    builder: _ProjectionBuilder,
+    projected: tuple[str, tuple[ProjectedLeaf, ...]],
+    *,
+    prefix: str,
+) -> None:
+    text, leaves = projected
+    if not text:
+        return
+    start = builder.length
+    builder.parts.append(text)
+    builder.length += len(text)
+    builder.boundary()
+    builder.leaves.extend({
+        "key": f"{prefix}/{leaf.key}",
+        "start": start + leaf.start,
+        "end": start + leaf.end,
+    } for leaf in leaves)
+
+
+def project_context(source: str) -> tuple[str, tuple[ProjectedLeaf, ...]]:
+    """Project visible prose and diff-row leaves from one context body.
+
+    File headers and +/- statistics are derived card chrome, matching #482's
+    rule that only provider-authored render leaves enter the search surface.
+    """
+    builder = _ProjectionBuilder()
+    for segment_index, (kind, text) in enumerate(_segment_context_body(source)):
+        if kind == "prose":
+            projected = project_markdown(text)
+            if not projected[0]:
+                continue
+            if builder.parts:
+                builder.separator("\n")
+            _append_projected(
+                builder, projected, prefix=f"segments.{segment_index}.prose"
+            )
+            continue
+        for file_index, hunk_index, row_index, row_text in _context_diff_rows(text):
+            if not row_text:
+                continue
+            if builder.parts:
+                builder.separator("\n")
+            builder.emit(
+                row_text,
+                key=(
+                    f"segments.{segment_index}.files.{file_index}."
+                    f"hunks.{hunk_index}.rows.{row_index}"
+                ),
+            )
+    return builder.value()
+
+
 def _single_scalar_lower(value: str) -> str:
     return "".join((lowered if len(lowered := scalar.lower()) == 1 else scalar) for scalar in value)
 
@@ -356,6 +501,7 @@ def slice_range_to_leaves(
 
 
 __all__ = [
+    "CODEX_FIND_PROJECTION_VERSION",
     "FindRange",
     "LeafFragment",
     "ProjectedLeaf",
@@ -364,6 +510,7 @@ __all__ = [
     "iter_literal_ranges",
     "iter_regex_ranges",
     "project_markdown",
+    "project_context",
     "project_plain",
     "regex_ranges",
     "slice_range_to_leaves",

package/bin/_lib_conversation_dispatch.py

@@ -266,6 +266,7 @@ def _claude_browse(
     model: str | None = None,
     limit: int = 50,
     cursor: str | None = None,
+    selected: str | None = None,
 ) -> dict:
     """Claude browse envelope (§5.6 / §6.1). Claude is always authoritative — the
     status is always ``ok`` (never ``normalization_pending``). Facets are built
@@ -296,7 +297,13 @@ def _claude_browse(
     ]
     filtered.sort(key=q._recent_sort_key, reverse=True)
     page_rows, page = q._paginate_rows(filtered, cursor=cursor, limit=limit)
-    return {"status": "ok", "rows": page_rows, "facets": facets, "page": page}
+    result = {"status": "ok", "rows": page_rows, "facets": facets, "page": page}
+    if selected is not None:
+        selected_row = next(
+            (row for row in rows if row["conversation_key"] == selected), None)
+        if selected_row is not None:
+            result["selected"] = selected_row
+    return result
 
 
 # ── Claude adapter: detail with cursor translation (§5.6) ─────────────────────
@@ -620,6 +627,13 @@ def neutral_browse(
     migration 025 has not run); Claude routes to the adapter (always ``ok``).
     ``filters``: ``project_key``, ``model``, ``limit``, ``cursor``."""
     speed = effective_speed or _DEFAULT_SPEED
+    selected = filters.pop("selected", None)
+    if selected is not None:
+        selected_ref = resolve_conversation_ref(selected)
+        selected = (selected_ref.conversation_key
+                    if selected_ref is not None and selected_ref.source == source
+                    else None)
+    filters["selected"] = selected
     if source == "codex":
         return q.list_codex_conversations(conn, effective_speed=speed, **filters)
     if source == "claude":

package/bin/_lib_conversation_query.py

@@ -1439,10 +1439,65 @@ def list_conversation_facets(conn) -> dict:
     return {"projects": projects, "models": models}
 
 
+def _selected_conversation_summary(conn, session_id):
+    """One exact browse-row projection, independent of the current page.
+
+    Mirrors ``list_conversations``' authoritative/live shaping so #501 can pin
+    the selected conversation without paging an unbounded corpus.
+    """
+    if _rollup_authoritative(conn):
+        row = conn.execute(
+            "SELECT session_id, msg_count, started_utc, last_activity_utc, "
+            "cost_usd, project_label, git_branch, models_json, title "
+            "FROM conversation_sessions WHERE session_id=?",
+            (session_id,),
+        ).fetchone()
+        if row is None:
+            return None
+        (sid, msg_count, started, last_activity, cost_usd, project_label,
+         git_branch, models_json, rollup_title) = row
+        ai = _session_ai_titles_map(conn, [sid])
+        return {
+            "session_id": sid,
+            "title": ai.get(sid) or rollup_title or project_label or sid,
+            "project_label": project_label,
+            "git_branch": git_branch,
+            "started_utc": started,
+            "last_activity_utc": last_activity,
+            "msg_count": msg_count,
+            "cost_usd": round(cost_usd or 0.0, 6),
+            "models": _json.loads(models_json) if models_json else [],
+        }
+    row = conn.execute(
+        "SELECT session_id, COUNT(*), MIN(timestamp_utc), MAX(timestamp_utc) "
+        "FROM conversation_messages WHERE session_id=? GROUP BY session_id",
+        (session_id,),
+    ).fetchone()
+    if row is None:
+        return None
+    sid, msg_count, started, last_activity = row
+    costs = _session_cost_map(conn, [sid])
+    models = _session_models_map(conn, [sid])
+    meta = _session_latest_meta_map(conn, [sid])
+    titles = _session_titles_map(conn, [sid])
+    project_label = _project_label(meta.get(sid, (None, None))[0])
+    return {
+        "session_id": sid,
+        "title": titles.get(sid) or project_label or sid,
+        "project_label": project_label,
+        "git_branch": meta.get(sid, (None, None))[1],
+        "started_utc": started,
+        "last_activity_utc": last_activity,
+        "msg_count": msg_count,
+        "cost_usd": round(costs.get(sid, 0.0), 6),
+        "models": models.get(sid, []),
+    }
+
+
 def list_conversations(conn, *, sort="recent", limit=50, offset=0,
                        date_from=None, date_to=None, projects=None,
                        cost_min=None, cost_max=None, rebuild_min=None,
-                       models=None) -> dict:
+                       models=None, selected=None) -> 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 —
@@ -1565,10 +1620,15 @@ def list_conversations(conn, *, sort="recent", limit=50, offset=0,
         # The rail surfaces this: cost/project ordering becomes available once
         # the rollup finishes indexing; this page fell back to recent order.
         page["sort_degraded"] = True
-    return {
+    result = {
         "conversations": conversations,
         "page": page,
     }
+    if selected is not None:
+        selected_row = _selected_conversation_summary(conn, selected)
+        if selected_row is not None:
+            result["selected"] = selected_row
+    return result
 
 
 def _turn_cost_map(conn, turn_keys):