cctally 1.117.2 → 1.118.0

package/bin/_cctally_update.py

@@ -2882,12 +2882,17 @@ class _DashboardUpdateCheckThread(threading.Thread):
         hub: "SSEHub | None" = None,
         snapshot_ref: "_SnapshotRef | None" = None,
         runtime_bind: "str | None" = None,
+        sync_lock: "threading.Lock | None" = None,
     ) -> None:
         super().__init__(name="cctally-update-check")
         self._stop_event = stop_event
         self._hub = hub
         self._ref = snapshot_ref
         self._runtime_bind = runtime_bind
+        # #932 §4.2: the dashboard's publisher lock, so this republish cannot
+        # land after (and supersede) a newer locked publish. ``None`` keeps
+        # the unserialized behaviour for callers that publish nothing else.
+        self._sync_lock = sync_lock
 
     def run(self) -> None:
         c = _cctally()
@@ -2953,24 +2958,38 @@ class _DashboardUpdateCheckThread(threading.Thread):
         because a full sync can publish while the precomputes above are being
         gathered; writing a whole snapshot read before that sync would regress
         every data field and can restore a partial hydration seed.
+
+        #932 §4.2: the precomputes stay outside ``sync_lock``; the patch and
+        its publish run inside it (blocking), so they are serialized with every
+        snapshot publisher. The hub's latest delivery is what ``/api/data`` and
+        new subscribers read, and without the lock a republish of an older
+        deferred object could land after the settle publish that replaced it.
         """
+        import contextlib
         c = _cctally()
+        tui = c._cctally_tui
         c._load_sibling("_lib_snapshot_cache").reset_doctor_memo()
-        doctor_payload = c._cctally_tui._tui_precompute_doctor_payload(
+        doctor_payload = tui._tui_precompute_doctor_payload(
             _now_utc(), self._runtime_bind,
         )
-        fresh = self._ref.replace_fields(
-            envelope_precompute=(
-                c._cctally_tui._tui_precompute_envelope_config(load_config())
-            ),
-            doctor_payload=doctor_payload,
-            # #278 §1.4.1: a version-banner refresh republishes complete data;
-            # force the hydration latch clear so a republish that happens to
-            # carry a prior hydrating seed/partial doesn't freeze the client's
-            # loading skeletons.
-            hydrating=False,
-        )
-        self._hub.publish(fresh)
+        envelope_precompute = tui._tui_precompute_envelope_config(load_config())
+        lock = (self._sync_lock if self._sync_lock is not None
+                else contextlib.nullcontext())
+        with lock:
+            held = self._ref.get()
+            fresh = self._ref.replace_fields(
+                envelope_precompute=envelope_precompute,
+                doctor_payload=doctor_payload,
+                # #278 §1.4.1: a version-banner refresh republishes complete
+                # data; force the hydration latch clear so a republish that
+                # happens to carry a prior hydrating seed/partial doesn't
+                # freeze the client's loading skeletons. #932 §4.2: except
+                # over an explicit stats deferral, which is still loading.
+                hydrating=(held.hydrating
+                           if tui._tui_snapshot_is_stats_deferral(held)
+                           else False),
+            )
+            self._hub.publish(fresh)
 
 
 def cmd_update(args) -> int:

package/bin/_lib_codex_conversation_query.py

@@ -52,12 +52,14 @@ from _lib_codex_find_projection import (
 from _lib_codex_metadata import (
     codex_metadata_is_malformed,
     decode_codex_project_metadata,
+    derive_codex_git_branch,
     resolve_codex_threads_table,
 )
 from _lib_codex_title_clean import clean_codex_title
 from _lib_conversation import _strip_ansi
 from _lib_conversation_query import (
-    _FULL_PAYLOAD_CEILING, _first_nonblank_line, _parse_outline_ts)
+    _FULL_PAYLOAD_CEILING, _first_nonblank_line, _parse_outline_ts,
+    plain_snippet_parts)
 from _lib_pricing import _calculate_codex_entry_cost
 from _lib_retained_size import retained_size_bytes
 
@@ -1648,15 +1650,38 @@ def _display_chain(fields: dict) -> str:
             or _short_native(fields.get("native_thread_id")) or "")
 
 
-def _conversation_display_title(
+def _conversation_header_fields(
     conn: sqlite3.Connection, conversation_key: str, rows: list | None = None,
     *, undecodable_keys: "frozenset[str]" = frozenset(),
-) -> str:
+) -> "tuple[str, str | None]":
+    """``(display title, project_label)`` from ONE ``_rollup_fields`` resolution
+    (#1037): the project label is the value the rail shows (stored rollup or the
+    identical live recompute, under the request's undecodable-key exclusion)."""
     fields = _rollup_fields(
         conn, conversation_key, rows=rows, undecodable_keys=undecodable_keys)
     if fields is None:
-        return ""
-    return _display_chain(fields)
+        return "", None
+    return _display_chain(fields), fields.get("project_label")
+
+
+def _conversation_display_title(
+    conn: sqlite3.Connection, conversation_key: str, rows: list | None = None,
+    *, undecodable_keys: "frozenset[str]" = frozenset(),
+) -> str:
+    return _conversation_header_fields(
+        conn, conversation_key, rows=rows, undecodable_keys=undecodable_keys)[0]
+
+
+def _conversation_branch(
+    conn: sqlite3.Connection, conversation_key: str,
+) -> "tuple[str | None, str]":
+    """``(git_branch, git_branch_status)`` from the conversation's own thread row
+    in the request's thread view (scoped, last-good), decoded field by field.
+    Independent of the project attribution exclusion (#1037 R-P1)."""
+    row = conn.execute(_THREAD_FACTS_SQL, (conversation_key,)).fetchone()
+    if row is None:
+        return derive_codex_git_branch(None)
+    return derive_codex_git_branch(decode_codex_project_metadata(row[4], row[5]))
 
 
 def _conversation_hit_fields(
@@ -2491,15 +2516,22 @@ def get_codex_conversation(
         built.append(item)
     _attach_spawn_child_links(conn, conversation_key, built)
     page_items = built
+    # NOT the Phase A rows: those carry no ``text``, and the live-recompute
+    # fallback inside _rollup_fields derives the title from it. Passing None
+    # keeps the stored fast path unchanged and lets the rare no-rollup case
+    # do its own wide read rather than titling the conversation "".
+    title, project_label = _conversation_header_fields(
+        conn, conversation_key, undecodable_keys=undecodable_keys)
+    git_branch, git_branch_status = _conversation_branch(conn, conversation_key)
     return {
         "status": "ok",
         "conversation_key": conversation_key,
-        # NOT the Phase A rows: those carry no ``text``, and the live-recompute
-        # fallback inside _rollup_fields derives the title from it. Passing None
-        # keeps the stored fast path unchanged and lets the rare no-rollup case
-        # do its own wide read rather than titling the conversation "".
-        "title": _conversation_display_title(
-            conn, conversation_key, undecodable_keys=undecodable_keys),
+        "title": title,
+        # #1037: the reader header's project slot (the rail's label) and branch
+        # slot (the thread's own retained git_json, with its status).
+        "project_label": project_label,
+        "git_branch": git_branch,
+        "git_branch_status": git_branch_status,
         "items": page_items,
         "page": page,
         "session_index": session_index,
@@ -4354,7 +4386,9 @@ def _collapse_message_hits(
                 hit["snippet"] = _search_excerpt(disp, query)
     return [
         {"conversation_key": h["conversation_key"], "item_key": h["item_key"],
-         "title": h["title"], "snippet": h["snippet"], "badges": sorted(h["_badges"]),
+         "title": h["title"], "snippet": h["snippet"],
+         "snippet_parts": plain_snippet_parts(h["snippet"]),
+         "badges": sorted(h["_badges"]),
          "last_activity_utc": h["last_activity_utc"], "project_label": h["project_label"]}
         for h in collapsed.values()
     ]
@@ -4379,9 +4413,11 @@ def _search_title(
             "SELECT conversation_key, title, last_activity_utc, project_label "
             "FROM codex_conversation_rollups WHERE title LIKE ?", (like,)):
         cleaned = clean_codex_title(title)
+        snippet = _excerpt(cleaned)
         hits.append(
             {"conversation_key": ck, "item_key": None, "title": cleaned,
-             "snippet": _excerpt(cleaned), "badges": ["title"],
+             "snippet": snippet, "snippet_parts": plain_snippet_parts(snippet),
+             "badges": ["title"],
              "last_activity_utc": last_act,
              "project_label": (
                  None if ck in undecodable_keys else project_label)})
@@ -4414,10 +4450,12 @@ def _search_files(
                 conn, ck, undecodable_keys=undecodable_keys)
         item_key = pos_cache[ck].get((member[0], member[1]))
         title, last_act, project_label = fields_cache[ck]
+        snippet = _excerpt(file_path)
         hit = collapsed.setdefault(
             (ck, item_key),
             {"conversation_key": ck, "item_key": item_key, "title": title,
-             "snippet": _excerpt(file_path), "badges": ["files"],
+             "snippet": snippet, "snippet_parts": plain_snippet_parts(snippet),
+             "badges": ["files"],
              "last_activity_utc": last_act, "project_label": project_label})
     return list(collapsed.values())
 

package/bin/_lib_codex_drain_admission.py

@@ -1,5 +1,10 @@
 """Waiting requests and the drain-admission gate (#968 spec 5.7, 5.12).
 
+Drain workers yield to two signals, both reported by ``fresh_requests``:
+immutable Codex requests that end only by expiry (below), and one
+process-owned Claude waiter whose expiring record bounds it (#1055, after the
+Codex request section).
+
 A Codex hook never waits for a lock. When it meets cache contention it
 publishes a uniquely named, immutable request record under the data
 directory (outside every SQLite store, because a contended hook cannot write
@@ -19,8 +24,24 @@ monotonic clock. A worker observing a request, or restarting, never renews it;
 a wall-clock jump cannot extend it (the wall age only shortens freshness, and
 a NEGATIVE wall age — an mtime ahead of the wall clock after a backward step —
 counts as fresh, bounded by the monotonic lifetime); a malformed record or one
-from an incompatible clock is expired and removed. Stdlib only; no cctally
-imports.
+from an incompatible clock is expired and removed.
+
+The Claude waiter (#1055 spec 4.1-4.3). A Claude hook whose single attempt on
+``cache.db.lock`` is refused while it sees an admitted drain unit (the Codex
+provider lock and the gate both busy) registers on ``claude-cache-waiter.lock``:
+one ``LOCK_EX | LOCK_NB`` attempt, never retried, then an owner-written
+record ``cctally-claude-waiter v1 <pid> <expiry_ns>`` (expiry on this module's
+monotonic clock). The record is written at registration (expiry: the hook's
+acquisition deadline) and once on acquiring the writer lock (expiry: now plus
+the hold allowance); nothing else renews it, least of all an observation.
+Drains probe the file read-only with ``LOCK_SH | LOCK_NB``: the waiter is
+fresh only while the probe is refused AND the record parses, is unexpired and
+is at most ``max(T, hold allowance)`` ahead. A fresh waiter is reported as the
+reserved sentinel after the Codex ids, so every admission check, recheck and
+backoff yields to it unchanged; with no fresh waiter the value is exactly the
+Codex ids. The release truncates the record before unlocking; a killed hook's
+lock is released by the kernel; the file is never unlinked. Stdlib only; no
+cctally imports.
 """
 from __future__ import annotations
 
@@ -39,6 +60,24 @@ GATE_FILE_NAME = "codex-drain-admission.lock"
 POLL_SECONDS = 5.0
 _RECORD_VERSION = 1
 
+# #1055: the Claude waiter. Module constants read at call time (monkeypatchable,
+# not configuration).
+CLAUDE_WAITER_FILE_NAME = "claude-cache-waiter.lock"
+#: Reserved id; a generated Codex id is ``<mono>-<pid>-<hex>``, never this.
+CLAUDE_WAITER_SENTINEL = "claude-waiter"
+#: T: how long a refused Claude hook may wait for ``cache.db.lock``.
+CLAUDE_HOOK_DRAIN_WAIT_SECONDS = 5.0
+CLAUDE_HOOK_DRAIN_POLL_SECONDS = 0.05
+#: How long the waiter stays fresh once its hook holds ``cache.db.lock``.
+CLAUDE_WAITER_HOLD_ALLOWANCE_SECONDS = 15.0
+#: The drain's step while only the Claude waiter is fresh.
+SHORT_POLL_SECONDS = 0.05
+#: How recent an observed waiter must be for ``_drain_backoff``'s short step.
+CLAUDE_WAITER_RECENT_SECONDS = 1.0
+_WAITER_MAGIC = "cctally-claude-waiter"
+_WAITER_VERSION = "v1"
+_WAITER_RECORD_MAX = 128
+
 # Module attributes so tests can drive a deterministic schedule.
 _monotonic_ns: Callable[[], int] = time.monotonic_ns
 _sleep: Callable[[float], None] = time.sleep
@@ -46,6 +85,17 @@ _sleep: Callable[[float], None] = time.sleep
 #: are released. Production leaves it None; the fairness test synchronizes on
 #: it instead of sleeping (review P2-7).
 _after_finish: Optional[Callable[[], None]] = None
+#: Per-process hint: ``os.path.realpath(app_dir)`` -> the ``_monotonic_ns``
+#: time of the last probe that found a fresh waiter. It selects a sleep
+#: interval only; empty checks never renew it.
+_claude_waiter_observed: "dict[str, int]" = {}
+
+
+def _clear_claude_waiter_hint() -> None:
+    _claude_waiter_observed.clear()
+
+
+os.register_at_fork(after_in_child=_clear_claude_waiter_hint)
 
 
 def _request_dir(app_dir) -> pathlib.Path:
@@ -97,7 +147,18 @@ def _is_fresh(path: pathlib.Path, now_mono: int, now_wall: float) -> bool:
 
 
 def fresh_requests(app_dir) -> "list[str]":
-    """Ids of fresh requests; expired or malformed records are removed one by one."""
+    """Ids of fresh requests; expired or malformed records are removed one by one.
+
+    A fresh Claude waiter follows the Codex ids as ``CLAUDE_WAITER_SENTINEL``;
+    it is probed even when the request directory is missing or unreadable.
+    """
+    fresh = _fresh_codex_requests(app_dir)
+    if claude_waiter_fresh(app_dir):
+        fresh.append(CLAUDE_WAITER_SENTINEL)
+    return fresh
+
+
+def _fresh_codex_requests(app_dir) -> "list[str]":
     directory = _request_dir(app_dir)
     try:
         entries = sorted(directory.iterdir())
@@ -127,6 +188,154 @@ def fresh_requests(app_dir) -> "list[str]":
     return fresh
 
 
+def _waiter_path(app_dir) -> pathlib.Path:
+    return pathlib.Path(app_dir) / CLAUDE_WAITER_FILE_NAME
+
+
+def _hint_key(app_dir) -> str:
+    return os.path.realpath(os.fspath(app_dir))
+
+
+def _waiter_bound_ns() -> int:
+    return round(max(CLAUDE_HOOK_DRAIN_WAIT_SECONDS,
+                     CLAUDE_WAITER_HOLD_ALLOWANCE_SECONDS) * 1e9)
+
+
+def _parse_waiter_expiry(data: bytes) -> "int | None":
+    try:
+        text = data.decode("ascii")
+    except UnicodeDecodeError:
+        return None
+    if not text.endswith("\n"):
+        return None
+    parts = text[:-1].split(" ")
+    if (len(parts) != 4 or parts[0] != _WAITER_MAGIC
+            or parts[1] != _WAITER_VERSION
+            or not parts[2].isdigit() or not parts[3].isdigit()):
+        return None
+    return int(parts[3])
+
+
+class ClaudeWaiter:
+    """The one process-owned Claude waiter (#1055 spec 4.1)."""
+
+    def __init__(self, fd: int):
+        self._fd: "int | None" = fd
+
+    @classmethod
+    def register(cls, app_dir, *, deadline_ns: int) -> "ClaudeWaiter | None":
+        """One non-blocking exclusive attempt; None when another waiter or a
+        drain probe holds the file at that instant (never retried)."""
+        try:
+            fd = os.open(_waiter_path(app_dir), os.O_RDWR | os.O_CREAT, 0o600)
+        except OSError:
+            return None
+        try:
+            fcntl.flock(fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
+        except OSError:
+            os.close(fd)
+            return None
+        waiter = cls(fd)
+        try:
+            waiter._write(deadline_ns)
+        except OSError:
+            waiter.release()
+            return None
+        return waiter
+
+    def _write(self, expiry_ns: int) -> None:
+        record = (f"{_WAITER_MAGIC} {_WAITER_VERSION} {os.getpid()} "
+                  f"{int(expiry_ns)}\n").encode("ascii")
+        os.pwrite(self._fd, record, 0)
+        os.ftruncate(self._fd, len(record))
+
+    def mark_holding(self) -> None:
+        """Rewrite the record once the hook holds ``cache.db.lock``: fresh for
+        the hold allowance from now. A failed write leaves the registration
+        record, which only ends the yield sooner."""
+        if self._fd is None:
+            return
+        try:
+            self._write(int(_monotonic_ns())
+                        + round(CLAUDE_WAITER_HOLD_ALLOWANCE_SECONDS * 1e9))
+        except OSError:
+            pass
+
+    def release(self) -> None:
+        """Truncate the record, unlock, close. Idempotent; never raises
+        ``OSError``."""
+        fd, self._fd = self._fd, None
+        if fd is None:
+            return
+        for step in (lambda: os.ftruncate(fd, 0),
+                     lambda: fcntl.flock(fd, fcntl.LOCK_UN),
+                     lambda: os.close(fd)):
+            try:
+                step()
+            except OSError:
+                pass
+
+
+def claude_waiter_fresh(app_dir) -> bool:
+    """The drain-side probe: never creates the file, holds no lock past the
+    call, and stamps the observation hint when the waiter is fresh."""
+    try:
+        fd = os.open(_waiter_path(app_dir), os.O_RDONLY)
+    except OSError:
+        return False
+    try:
+        try:
+            fcntl.flock(fd, fcntl.LOCK_SH | fcntl.LOCK_NB)
+        except BlockingIOError:
+            pass
+        except OSError:
+            return False
+        else:
+            return False                # no waiter; close releases the probe
+        try:
+            data = os.pread(fd, _WAITER_RECORD_MAX, 0)
+        except OSError:
+            return False
+    finally:
+        os.close(fd)
+    expiry = _parse_waiter_expiry(data)
+    if expiry is None:
+        return False
+    now = int(_monotonic_ns())
+    if not (now < expiry and expiry - now <= _waiter_bound_ns()):
+        return False
+    _claude_waiter_observed[_hint_key(app_dir)] = now
+    return True
+
+
+def claude_waiter_recently_observed(app_dir) -> bool:
+    """True when this process found a fresh waiter less than
+    ``CLAUDE_WAITER_RECENT_SECONDS`` ago (a sleep-interval hint only)."""
+    stamp = _claude_waiter_observed.get(_hint_key(app_dir))
+    if stamp is None:
+        return False
+    age = int(_monotonic_ns()) - stamp
+    return 0 <= age < round(CLAUDE_WAITER_RECENT_SECONDS * 1e9)
+
+
+def lock_busy(path) -> bool:
+    """A shared non-blocking probe on its own descriptor, closed at once.
+    A missing file or any non-contention error is no evidence (False)."""
+    try:
+        fd = os.open(path, os.O_RDONLY)
+    except OSError:
+        return False
+    try:
+        fcntl.flock(fd, fcntl.LOCK_SH | fcntl.LOCK_NB)
+    except BlockingIOError:
+        return True
+    except OSError:
+        return False
+    finally:
+        os.close(fd)
+    return False
+
+
 class DrainGate:
     """The one global, non-blocking drain-admission flock."""
 
@@ -207,8 +416,17 @@ def finish(admission: Admission,
 
 def wait_until_no_fresh_requests(
         app_dir, *, should_continue: Optional[Callable[[], bool]] = None) -> None:
-    """Sleep in bounded steps until no request is fresh (requests expire)."""
-    while fresh_requests(app_dir):
+    """Sleep in bounded steps until nothing is fresh (requests expire; the
+    Claude waiter's record bounds it). The set is re-classified after every
+    sleep: the Claude sentinel alone takes ``SHORT_POLL_SECONDS``, any set
+    holding a Codex request ``POLL_SECONDS``."""
+    while True:
+        fresh = fresh_requests(app_dir)
+        if not fresh:
+            return
         if should_continue is not None and not should_continue():
             return
-        _sleep(POLL_SECONDS)
+        if fresh == [CLAUDE_WAITER_SENTINEL]:
+            _sleep(SHORT_POLL_SECONDS)
+        else:
+            _sleep(POLL_SECONDS)

package/bin/_lib_codex_metadata.py

@@ -22,6 +22,7 @@ implementation of the rule without an import cycle.
 from __future__ import annotations
 
 import dataclasses
+import json
 import sqlite3
 import threading
 from collections import OrderedDict
@@ -102,6 +103,44 @@ def decode_codex_project_metadata(
     )
 
 
+#: The reader header's branch statuses (#1037). ``not_recorded`` is a readable
+#: record that names no branch; ``unreadable`` is metadata the store holds but
+#: cannot read (or no thread row at all).
+GIT_BRANCH_RECORDED = "recorded"
+GIT_BRANCH_NOT_RECORDED = "not_recorded"
+GIT_BRANCH_UNREADABLE = "unreadable"
+
+
+def derive_codex_git_branch(
+    decoded: "DecodedCodexProjectMetadata | None",
+) -> "tuple[str | None, str]":
+    """``(git_branch, git_branch_status)`` for one thread row's OWN ``git_json``
+    (#1037), first match wins: no thread row (``None``) or undecodable
+    ``git_json`` bytes → unreadable; NULL or empty → not recorded; invalid JSON
+    or not an object → unreadable; a string ``branch`` with a non-empty
+    ``strip()`` → that string, unmodified; anything else → not recorded.
+
+    ``cwd`` is never consulted, and neither is a parent's or root's metadata:
+    the project attribution exclusion governs the project label only, so a
+    corrupt ``cwd`` beside a readable branch still shows the branch (R-P1).
+    """
+    if decoded is None or "git_json" in decoded.undecodable_fields:
+        return None, GIT_BRANCH_UNREADABLE
+    raw = decoded.git_json
+    if raw is None or raw == "":
+        return None, GIT_BRANCH_NOT_RECORDED
+    try:
+        value = json.loads(raw)
+    except (ValueError, RecursionError):
+        return None, GIT_BRANCH_UNREADABLE
+    if not isinstance(value, dict):
+        return None, GIT_BRANCH_UNREADABLE
+    branch = value.get("branch")
+    if isinstance(branch, str) and branch.strip():
+        return branch, GIT_BRANCH_RECORDED
+    return None, GIT_BRANCH_NOT_RECORDED
+
+
 def _absent(metadata: "DecodedCodexProjectMetadata | None", field: str) -> bool:
     """Whether the resolver would move past this field.
 

package/bin/_lib_conversation_anon.py

@@ -120,11 +120,15 @@ def _dash_encode(path: str) -> str:
 def build_anon_plan(*, project_roots, home_dirs, usernames) -> AnonPlan:
     """Build an :class:`AnonPlan` from injected identity sources.
 
-    ``project_roots`` maps root path -> label. Numbering is deterministic,
-    lexical by root path (``project-1..N``), so CLI and HTTP builds from the same
-    DB produce identical plans (byte-parity depends on this). Duplicate basenames
-    map the bare label to the LOWEST-numbered of their ``project-N`` targets
-    (``setdefault`` over the sorted roots).
+    ``project_roots`` maps root path -> label, or -> a collection of labels
+    (#972 O6: a relabeled Codex root keeps both its repository label and its
+    folder name). Numbering is deterministic, lexical by root path
+    (``project-1..N``), so CLI and HTTP builds from the same DB produce
+    identical plans (byte-parity depends on this). Every label of a root
+    targets that root's ``project-N``; a bare label several roots carry maps to
+    the LOWEST-numbered of their targets (``setdefault`` over the sorted
+    roots), so an added label can move a colliding word to a lower-numbered
+    root. String-only inputs build exactly the plan they always built.
     """
     tokens: dict = {}          # (text, bounded) -> replacement
     label_target: dict = {}    # label -> project-N (lowest-N wins)
@@ -134,9 +138,12 @@ def build_anon_plan(*, project_roots, home_dirs, usernames) -> AnonPlan:
         rep = f"project-{n}"
         tokens[(root, False)] = rep
         tokens[(_dash_encode(root), False)] = f"-{rep}"
-        label = project_roots[root]
-        if label:
-            label_target.setdefault(label, rep)   # lowest-N claims the label
+        labels = project_roots[root]
+        if labels is None or isinstance(labels, str):
+            labels = (labels,)
+        # A None or empty label (alone or inside a collection) names nothing.
+        for label in sorted({label for label in labels if label}):
+            label_target.setdefault(label, rep)   # lowest-N claims it
     for label, rep in label_target.items():
         tokens[(label, True)] = rep
     for h in home_dirs:

package/bin/_lib_conversation_dispatch.py

@@ -445,6 +445,10 @@ def _claude_detail(
         "status": "ok",
         "conversation_key": conversation_key,
         "title": res["title"],
+        # #1037 twin: the reader header's project and branch slots, as the
+        # native Claude detail carries them (no branch status for Claude).
+        "project_label": res.get("project_label"),
+        "git_branch": res.get("git_branch"),
         "items": neutral_items,
         "page": page,
         "subagent_meta": _map_claude_subagent_meta(
@@ -621,6 +625,9 @@ def _claude_search(
             "item_key": _claude_item_key(sid, uuid) if (sid and uuid) else None,
             "title": h.get("title"),
             "snippet": h.get("snippet"),
+            # #1036: the structured excerpt the viewer renders (the qualified
+            # All-providers rail has nothing else that marks only real matches).
+            "snippet_parts": h.get("snippet_parts", []),
             "badges": list(h.get("match_kinds") or []),
             "last_activity_utc": last_act,
             "project_label": project_label,