cctally 1.90.1 → 1.92.0

package/bin/_lib_codex_segments.py

@@ -0,0 +1,259 @@
+"""#463 S1 — the pure segmentation kernel for Codex conversation turns.
+
+A **segment** is a run of consecutive fold groups inside one ``klass ==
+"response"`` canonical item, taken greedily from the start of the turn, closed
+when the block budget is reached, and closed earlier when a semantic boundary
+falls inside the budget window. Items whose class is not ``response`` already
+contain a single row; each is exactly one segment and its key does not change.
+
+**The unit is a fold group, not a row, and that is not a detail.**
+``_item_blocks_with_rows`` folds a ``tool_output`` into a preceding ``tool_call``
+whenever the call identifier is non-empty, owned by exactly one call in the item,
+and already seen — with **no adjacency requirement**. Patch, web-search and MCP
+completion events fold the same way. A boundary drawn between a call and its
+folded output would make the page-local builder emit a different block structure
+than the whole-turn builder does, so a fold group is atomic here. Because folds
+are non-adjacent a group can span intervening blocks, so a group that exceeds the
+budget becomes its own segment: the budget is a target with fold-group atomicity
+as a hard floor, and the ceiling is the budget plus at most one maximal group.
+
+This module is deliberately pure — no SQLite, no I/O, and no import from the
+query layer. The caller derives fold groups and the turn-scoped
+``call_owner_count`` and passes them in.
+"""
+from __future__ import annotations
+
+import dataclasses
+from typing import Any
+
+# Per-segment block budget (spec section 2). At the measured 27.5 DOM nodes per
+# block that is roughly 1,100 nodes, close to the 776 nodes per mounted row the
+# Claude control paints in 449 ms.
+SEGMENT_BLOCK_BUDGET = 40
+
+# Per-page block budget, applied alongside ``limit`` (spec section 2). Roughly
+# fifty full segments, in the same range as the Claude control's 2.58 MB page.
+# The per-page bound is not optional: the profiled response was
+# ``total: 78, returned: 78, has_after: false`` — 13.3 MB in one page, because
+# 78 is fewer than the requested 500 — so a change that capped items alone would
+# not bound that conversation at all.
+PAGE_BLOCK_BUDGET = 2000
+
+# Per-page SOURCE-byte budget, applied alongside ``limit`` and
+# ``PAGE_BLOCK_BUDGET``; the first bound reached closes the page. It bounds
+# TRANSFER and PARSE cost, which is a byte cost the block budget does not
+# express, because a Codex block is far heavier than a Claude block.
+#
+# It is not redundant with PAGE_BLOCK_BUDGET. After segmentation the profiled
+# conversation is 128 segments carrying 1,906 blocks, so a whole-conversation
+# page holds 1,713 blocks — BELOW the 2,000-block budget. The block bound never
+# fires on it, and without this one the response is still 13.24 MB in one page.
+#
+# CALIBRATED BY MEASUREMENT, not by arithmetic, on 2026-08-02 against a
+# read-only copy of the production store. At 3,000,000 source bytes the
+# profiled conversation serves 16 of its 128 segments, 274 blocks and 2.54 MB
+# on the wire — the 2 to 3 MB target, and effectively the Claude control's
+# 2.58 MB page. Across the six heaviest conversations the served page at this
+# budget ranges from 0.75 MB to 2.54 MB of wire. At 4,000,000 the maximum rises
+# to 3.16 MB; at 2,000,000 the profiled conversation falls to 1.45 MB.
+#
+# Do NOT re-derive this figure by dividing a wire target by the
+# whole-conversation source-to-wire ratio. That ratio is not uniform and not
+# even close: the profiled conversation is 6.91x source-to-wire taken whole
+# (91.52 MB source, 13.24 MB wire), but only 1.11x over the segments a 3 MB page
+# actually serves (2.83 MB source, 2.54 MB wire), because its heaviest rows sit
+# in the tail and are clipped hardest. Re-calibrate by measuring served pages.
+PAGE_SOURCE_BYTE_BUDGET = 3_000_000
+
+# Fraction of the budget the boundary snap may give up. Bounding it at a quarter
+# guarantees a segment is never smaller than 75 percent of the budget, so the
+# rule cannot produce a run of very small segments, and it preserves the ceiling
+# because it only ever closes a segment EARLIER than the budget would.
+LOOKBACK_FRACTION = 0.25
+
+
+# Both dataclasses below are ``frozen=True`` with ``eq=True``, which makes
+# Python synthesize a ``__hash__`` — and that synthesized hash raises TypeError
+# here, because every instance carries a ``list`` field. Nothing hashes a
+# FoldGroup or a Segment today and nothing should: they are records passed
+# between two functions in one call, never dict keys or set members, and their
+# identity is positional rather than structural. ``unsafe_hash`` is deliberately
+# NOT set, and ``__hash__`` is set to None so the failure is an explicit
+# "unhashable type" at the call site rather than a TypeError from inside a
+# generated method.
+
+
+@dataclasses.dataclass(frozen=True)
+class FoldGroup:
+    """A ``tool_call`` together with every row that folds into it, or a single
+    non-folding row. Never divided across segments.
+
+    ``is_title_boundary`` is true when the group's first row is a reasoning row
+    whose stored projection produces a ``title``. ``is_tool_transition`` is true
+    when it is the first ``tool_call`` following a run of assistant or reasoning
+    rows. Those are the two semantic boundaries, in that priority order.
+
+    ``first_pos`` and ``last_pos`` are the group's physical row positions inside
+    its item. Because folds are non-adjacent, ``last_pos`` can be far past
+    ``first_pos`` and can bracket a LATER group entirely, which is what
+    ``plan_segments`` uses to keep a segment physically contiguous. ``None``
+    disables that extension, for callers that have no positional information.
+    """
+
+    rows: list
+    block_count: int
+    source_bytes: int
+    is_title_boundary: bool = False
+    is_tool_transition: bool = False
+    first_pos: int | None = None
+    last_pos: int | None = None
+
+    __hash__ = None
+
+
+@dataclasses.dataclass(frozen=True)
+class Segment:
+    """One bounded run of fold groups inside a turn."""
+
+    ordinal: int
+    groups: list
+    block_count: int
+    source_bytes: int
+    anchor_row: Any
+
+    __hash__ = None
+
+
+def _boundary_rank(group: FoldGroup) -> int:
+    """Priority of the boundary a cut before this group would land on.
+
+    Lower is better. 0 = a reasoning title, 1 = a tool transition, 2 = not a
+    boundary at all.
+    """
+    if group.is_title_boundary:
+        return 0
+    if group.is_tool_transition:
+        return 1
+    return 2
+
+
+def _extend_to_contiguous(groups: list, start: int, end: int, total: int) -> int:
+    """Grow ``end`` until the segment covers a CONTIGUOUS physical row range.
+
+    Fold-group atomicity alone does not give this (spec section 1). Because
+    folds are non-adjacent, a group's rows can bracket a later group's rows —
+    a native patch completion event sits between its call and that call's
+    output, for instance. Cutting between the two groups would then produce
+    segments whose physical ranges overlap: the earlier segment would render
+    rows out of physical order, and the later segment's rows would fall inside
+    the earlier one's time span.
+
+    Groups are created in the physical order of their FIRST row, so ``first_pos``
+    increases across the list. A cut before group ``end`` is therefore legal
+    exactly when every chosen group ends before ``groups[end]`` begins; if it
+    does not, that group is absorbed and the test repeats.
+
+    The extension only ever GROWS a segment, so the 75 percent lookback floor is
+    preserved. The ceiling becomes the budget plus the physical span of one
+    maximal fold group, which is what spec section 2 states.
+    """
+    ends = [groups[i].last_pos for i in range(start, end)
+            if groups[i].last_pos is not None]
+    if not ends:
+        return end
+    max_last = max(ends)
+    while end < total:
+        nxt = groups[end].first_pos
+        if nxt is None or nxt > max_last:
+            break
+        if groups[end].last_pos is not None:
+            max_last = max(max_last, groups[end].last_pos)
+        end += 1
+    return end
+
+
+def plan_segments(
+    fold_groups: list,
+    *,
+    block_budget: int | None = None,
+    lookback_fraction: float | None = None,
+) -> list[Segment]:
+    """Divide a turn's fold groups into ordered segments.
+
+    Fills greedily from index 0. A segment closes at the last group that fits
+    inside ``block_budget``, or earlier at the highest-priority semantic
+    boundary whose cut point falls inside the lookback window — the range from
+    ``(1 - lookback_fraction) * block_budget`` blocks up to the budget. A group
+    that does not fit even into an empty segment becomes its own segment.
+
+    **Greedy-from-start is the mechanism, not a convenience.** Every segment
+    depends only on the groups before it, so appending groups to a growing turn
+    leaves earlier segments — and therefore earlier segment keys — untouched.
+    Computing boundaries from the end would renumber a conversation's history on
+    every append. Segment keys 1..N remain durable only under that tail append;
+    inserting or deleting a row before a boundary shifts every later boundary in
+    the turn, and a former anchor becomes an interior row.
+
+    ``block_budget`` and ``lookback_fraction`` resolve to the module constants
+    at CALL time when omitted. They are deliberately not default ARGUMENT values:
+    a default argument binds once at import, so a test that lowers or raises
+    ``SEGMENT_BLOCK_BUDGET`` would silently keep the imported figure and pass
+    vacuously.
+    """
+    if block_budget is None:
+        block_budget = SEGMENT_BLOCK_BUDGET
+    if lookback_fraction is None:
+        lookback_fraction = LOOKBACK_FRACTION
+    if block_budget <= 0:
+        raise ValueError("block_budget must be positive")
+    if not 0.0 <= lookback_fraction < 1.0:
+        raise ValueError("lookback_fraction must be in [0.0, 1.0)")
+
+    groups = list(fold_groups)
+    total = len(groups)
+    floor_blocks = block_budget - int(block_budget * lookback_fraction)
+
+    segments: list[Segment] = []
+    start = 0
+    while start < total:
+        # How far the budget alone reaches. At least one group always fits, so a
+        # single oversized group becomes its own segment rather than stalling.
+        end = start
+        blocks = 0
+        while end < total:
+            candidate = blocks + groups[end].block_count
+            if end > start and candidate > block_budget:
+                break
+            blocks = candidate
+            end += 1
+
+        # Look for a boundary inside the window. A cut happens BEFORE group
+        # ``cut``, so that group must exist and must itself be a boundary, and
+        # the blocks kept must already clear the lookback floor.
+        best_cut = None
+        best_rank = 2
+        kept = 0
+        for cut in range(start, end):
+            if cut > start and kept >= floor_blocks and cut < total:
+                rank = _boundary_rank(groups[cut])
+                if rank < best_rank:
+                    best_rank = rank
+                    best_cut = cut
+                    if rank == 0:
+                        break
+            kept += groups[cut].block_count
+        if best_cut is not None:
+            end = best_cut
+
+        end = _extend_to_contiguous(groups, start, end, total)
+
+        chosen = groups[start:end]
+        segments.append(Segment(
+            ordinal=len(segments),
+            groups=chosen,
+            block_count=sum(group.block_count for group in chosen),
+            source_bytes=sum(group.source_bytes for group in chosen),
+            anchor_row=chosen[0].rows[0] if chosen and chosen[0].rows else None,
+        ))
+        start = end
+    return segments

package/bin/_lib_codex_title_clean.py

@@ -0,0 +1,116 @@
+"""Read-time cleaning of harness markup out of a Codex title (#463 S4 §5).
+
+Pure kernel: one entry point, ``clean_codex_title(text) -> str``, and a CLOSED
+allowlist of the grammars a census of the real store actually found.
+
+**Read time, not ingest (D5).** The title is stored —
+``codex_conversation_rollups.title`` is written at ingest and ``_rollup_fields``
+returns it on its fast path — so repairing ``derive_title`` would heal nothing
+for the conversations that are already wrong. Cleaning on the read path heals
+all history with no migration and no reingest flag.
+
+**The allowlist is a measurement, not a guess (§5.4).** Over the 438 stored
+Codex rollup titles in the production store on 2026-08-04:
+
+===========================================  =====  ===========
+grammar                                      count  disposition
+===========================================  =====  ===========
+``[$name](<abs path>/SKILL.md) <rest>``        165  unwrap
+``<command-name>…</command-name> …``            40  see below
+``<recommended_plugins> …``                      6  strip
+``<command-message>…</command-message> …``       1  see below
+===========================================  =====  ===========
+
+Nothing else occurred. No title carried a tag anywhere but at its head (0 of
+438), and the two ``CODEX_TITLE_SKIP_PREFIXES`` wrappers
+(``<environment_context>``, ``<user_instructions>``) appeared 0 times, because
+they are skipped at ingest by a different mechanism that stays where it is
+(§5.3).
+
+Within the command wrapper the three tags are dispositioned separately, from
+what their content actually looks like: ``command-name`` is the slash command
+and is STRIPPED, while ``command-message`` and ``command-args`` carry the human
+text and are UNWRAPPED. On the corpus that turns
+``<command-name>/model</command-name> <command-message>model</command-message>
+<command-args>fable</command-args>`` into ``model fable``.
+
+``recommended_plugins`` never closes in the data: titles are capped at 120
+characters, so the stored value is the head of a plugin catalogue. Stripping it
+leaves nothing, and ``_display_chain`` falls through to the project label and
+then to a short native thread id, which the chain already does.
+
+**Closed, and deliberately so.** A general tag stripper would eat user-authored
+angle brackets in a title. An unrecognized construct passes through BYTE for
+byte — the function returns its input unchanged when no rule fires, so the 226
+titles the census found clean, and every prose label this is applied to, cannot
+move.
+"""
+from __future__ import annotations
+
+import re
+
+# `[$skill-name](/abs/path/to/SKILL.md)` — the Codex skill invocation. The
+# prompt text after it is real, and the link target is a private filesystem path
+# that leaks into every title surface. Byte-identical to the client's
+# `cleanQualifiedTitle` regex, so the two agree on the same input and applying
+# both is a no-op.
+#
+# NO trailing lookahead. The first version required whitespace or end of string
+# after the closing paren, so `…/SKILL.md)Task B of issue #450.` — prompt text
+# written straight against the paren — did not match and the whole link,
+# absolute path included, reached the reader header and the outline rail. Two of
+# 300 served titles in the test store carry that form. Nothing is lost by
+# dropping the lookahead: the pattern is head-anchored (`pattern.match`) and its
+# target is the literal `/SKILL.md)`, so it cannot start matching mid-title or
+# consume any other Markdown link.
+_SKILL_LINK_RE = re.compile(
+    r"\[((?:\$)[^\]\r\n]+)\]\([^)\r\n]*/SKILL\.md\)")
+
+_STRIP, _UNWRAP = "strip", "unwrap"
+
+# Head-anchored, in match order. Each entry is (pattern, disposition, group) —
+# `group` names the capture an `unwrap` keeps.
+_GRAMMARS: tuple[tuple[re.Pattern, str, int], ...] = (
+    (_SKILL_LINK_RE, _UNWRAP, 1),
+    (re.compile(r"<command-name>(.*?)</command-name>", re.S), _STRIP, 1),
+    (re.compile(r"<command-message>(.*?)</command-message>", re.S), _UNWRAP, 1),
+    (re.compile(r"<command-args>(.*?)</command-args>", re.S), _UNWRAP, 1),
+    # The closing form first: alternation is ordered, and the open-ended arm
+    # would otherwise swallow a closed construct's tail.
+    (re.compile(r"<recommended_plugins>.*?</recommended_plugins>"
+                r"|<recommended_plugins>.*", re.S), _STRIP, 0),
+)
+
+
+def clean_codex_title(text) -> str:
+    """The title with recognized leading harness markup removed or unwrapped.
+
+    Returns the input unchanged when no grammar in the allowlist matches its
+    head, including for a non-string or empty input, which keeps every
+    untouched title and every prose label byte-stable.
+
+    A construct that strips to nothing yields ``""``, and the caller's fallback
+    chain takes over (§5.3).
+    """
+    if not isinstance(text, str) or not text:
+        return text if isinstance(text, str) else ""
+    kept: list[str] = []
+    rest = text
+    matched = False
+    while rest:
+        head = rest.lstrip()
+        for pattern, disposition, group in _GRAMMARS:
+            found = pattern.match(head)
+            if found is None:
+                continue
+            matched = True
+            if disposition == _UNWRAP:
+                kept.append(found.group(group))
+            rest = head[found.end():]
+            break
+        else:
+            kept.append(head)
+            break
+    if not matched:
+        return text
+    return " ".join(" ".join(part.split()) for part in kept if part.strip()).strip()

package/bin/_lib_conversation_dispatch.py

@@ -306,14 +306,43 @@ def _map_claude_item(session_id: str, it: dict) -> dict:
     """One Claude assembled item → the neutral detail item shape (§5.6). Claude's
     kinds/blocks pass through untranslated (both vocabularies are provider-truthful
     values of the same required field)."""
+    own_uuid = it["anchor"]["uuid"]
     return {
-        "item_key": _claude_item_key(session_id, it["anchor"]["uuid"]),
+        "item_key": _claude_item_key(session_id, own_uuid),
         "kind": it["kind"],
         "timestamp_utc": it.get("ts"),
         "model": it.get("model"),
         "blocks": it.get("blocks", []),
         "cost_usd": it.get("cost_usd"),
         "tokens": _claude_tokens_union(it.get("tokens")),
+        "member_item_keys": [
+            _claude_item_key(session_id, uuid)
+            for uuid in it.get("member_uuids", []) if uuid != own_uuid
+        ],
+        "subagent_key": it.get("subagent_key"),
+        "parent_item_key": (
+            _claude_item_key(session_id, it["parent_uuid"])
+            if it.get("parent_uuid") is not None else None
+        ),
+        "is_sidechain": bool(it.get("is_sidechain")),
+        "meta_kind": it.get("meta_kind"),
+        "skill_name": it.get("skill_name"),
+        "command_name": it.get("command_name"),
+        "cache_failure": it.get("cache_failure"),
+    }
+
+
+def _map_claude_subagent_meta(session_id: str, values: dict | None) -> dict:
+    """Translate the one identity-bearing field in legacy subagent metadata."""
+    return {
+        key: ({
+            **meta,
+            "spawn_uuid": (
+                _claude_item_key(session_id, meta["spawn_uuid"])
+                if meta.get("spawn_uuid") is not None else None
+            ),
+        } if isinstance(meta, dict) else meta)
+        for key, meta in (values or {}).items()
     }
 
 
@@ -386,6 +415,8 @@ def _claude_detail(
         "title": res["title"],
         "items": neutral_items,
         "page": page,
+        "subagent_meta": _map_claude_subagent_meta(
+            session_id, res.get("subagent_meta")),
         "children": [],
         "parent": None,
         "total_cost_usd": res["cost_usd"],
@@ -399,33 +430,98 @@ def _claude_detail(
 def _claude_outline(
     conn: sqlite3.Connection, session_id: str, conversation_key: str,
 ) -> dict:
-    """Claude outline envelope (§5.6). Reuses the existing kernel outline for
-    ``stats``/``files``; the per-turn ``item_key`` + block-kind counts are built
-    from the SAME assembled items the detail pages, so outline and detail item
-    keys align exactly. ``children`` is empty (no native threading)."""
+    """Claude outline envelope (§5.6), without weakening the native outline.
+
+    The legacy kernel is the authority for navigation: it already derives tool
+    failures, subagent topology, cache rebuilds, files, task completion, and the
+    complete turn skeleton from the same assembled items as detail.  This
+    adapter changes only identity-bearing fields from native UUIDs to neutral
+    item keys and names the provider-neutral file fields.  Re-deriving a smaller
+    outline from assembled blocks here previously stripped precisely the facts
+    the qualified reader needs (#491).
+    """
     o = lcq.get_conversation_outline(conn, session_id)
     if o is None:
         return {"status": "not_found", "conversation_key": conversation_key}
-    asm = lcq._assemble_session_memoized(conn, session_id)
+
+    def item_key(uuid):
+        return _claude_item_key(session_id, uuid) if uuid is not None else None
+
     turns = []
-    for it in asm["items"]:
-        kinds: dict[str, int] = {}
-        for b in it.get("blocks", []):
-            bk = b.get("kind")
-            if bk:
-                kinds[bk] = kinds.get(bk, 0) + 1
-        turns.append({
-            "item_key": _claude_item_key(session_id, it["anchor"]["uuid"]),
-            "label": lcq._outline_label(it.get("text", "")),
-            "timestamp_utc": it.get("ts"),
-            "kinds": kinds,
+    for turn in o["turns"]:
+        own_key = item_key(turn["uuid"])
+        neutral = {
+            "item_key": own_key,
+            "kind": turn["kind"],
+            "label": turn["label"],
+            "timestamp_utc": turn.get("ts"),
+            "kinds": {turn["kind"]: 1},
+            "member_item_keys": [
+                item_key(uuid) for uuid in turn.get("member_uuids", [])
+                if uuid != turn["uuid"]
+            ],
+            "subagent_key": turn.get("subagent_key"),
+            "parent_item_key": item_key(turn.get("parent_uuid")),
+            "is_sidechain": bool(turn.get("is_sidechain")),
+        }
+        for field in (
+                "tools", "thinking", "model", "tokens", "meta_kind",
+                "skill_name", "cache_failure"):
+            if field in turn:
+                neutral[field] = turn[field]
+        turns.append(neutral)
+
+    stats = dict(o["stats"])
+    cache_failures = stats.get("cache_failures")
+    if isinstance(cache_failures, dict):
+        cache_failures = dict(cache_failures)
+        cache_failures["rebuilds"] = [
+            {**row, "uuid": item_key(row.get("uuid"))}
+            for row in cache_failures.get("rebuilds", [])
+        ]
+        stats["cache_failures"] = cache_failures
+
+    files = []
+    for file in o.get("files", []):
+        touches = [{
+            "item_key": item_key(touch.get("uuid")),
+            "timestamp_utc": None,
+            "tool_use_id": touch.get("tool_use_id"),
+            "op": touch.get("op"),
+            "added": touch.get("add"),
+            "removed": touch.get("del"),
+        } for touch in file.get("touches", [])]
+        tools = list(dict.fromkeys(
+            touch["op"] for touch in touches if touch.get("op")))
+        files.append({
+            "file_path": file.get("path"),
+            # The count-only neutral file shape requires a tool label.  Rich
+            # Claude entries retain every native operation instead of claiming
+            # that Write/MultiEdit touches were Edit calls.
+            "tool": ",".join(tools),
+            "count": len(touches),
+            "added": file.get("add"),
+            "removed": file.get("del"),
+            "touches": touches,
         })
+
+    subagent_meta = _map_claude_subagent_meta(
+        session_id, o.get("subagent_meta"))
+    task_completion = o.get("task_completion")
+    if isinstance(task_completion, dict):
+        task_completion = {
+            **task_completion,
+            "anchor_uuid": item_key(task_completion.get("anchor_uuid")),
+        }
     return {
         "status": "ok",
         "conversation_key": conversation_key,
         "turns": turns,
-        "stats": o["stats"],
-        "files": o["files"],
+        "subagent_meta": subagent_meta,
+        "subagent_costs": o.get("subagent_costs", {}),
+        "stats": stats,
+        "files": files,
+        "task_completion": task_completion,
         "children": [],
     }
 
@@ -531,6 +627,25 @@ def neutral_browse(
     raise ValueError(f"unknown source: {source!r}")
 
 
+def neutral_facets(
+    conn: sqlite3.Connection, *, source: str, effective_speed: str | None = None,
+) -> dict:
+    """Facet-only collection envelope for one source.
+
+    Codex has a dedicated rollup projection so the facets request never builds
+    or prices a browse page that its transport discards.  Claude retains its
+    established browse-derived facet contract.
+    """
+    speed = effective_speed or _DEFAULT_SPEED
+    if source == "codex":
+        return q.list_codex_conversation_facets(conn)
+    if source == "claude":
+        env = _claude_browse(conn, effective_speed=speed)
+        return {"status": env.get("status"), "facets": env.get("facets") or {
+            "projects": [], "models": []}}
+    raise ValueError(f"unknown source: {source!r}")
+
+
 def neutral_detail(
     conn: sqlite3.Connection, ref: str, *, effective_speed: str | None = None,
     after: str | None = None, before: str | None = None,
@@ -725,6 +840,8 @@ def _claude_export(
 def neutral_find(
     conn: sqlite3.Connection, ref: str, query: str, *, kind: str = "all",
     regex: bool = False, case: bool = False, effective_speed: str | None = None,
+    limit: int = 100, cursor: str | None = None, direction: str = "next",
+    around: str | None = None,
 ) -> dict:
     """In-conversation find for a neutral reference (§3.1). An unknown ``kind``
     raises ``ValueError`` (route → 400); an unknown/garbage ref → ``not_found``.
@@ -736,8 +853,23 @@ def neutral_find(
     if cref is None:
         return {"status": "not_found", "conversation_key": ref}
     if cref.source == "codex":
-        return q.find_in_codex_conversation(
-            conn, cref.conversation_key, query, kind=kind, regex=regex, case=case)
+        try:
+            return q.find_occurrences_in_codex_conversation(
+                conn,
+                cref.conversation_key,
+                query,
+                kind=kind,
+                regex=regex,
+                case_sensitive=case,
+                limit=limit,
+                cursor=cursor,
+                direction=direction,
+                around=around,
+            )
+        except q.InvalidFindCursor:
+            return {"status": "invalid_find_cursor"}
+        except q.StaleFindCursor:
+            return {"status": "stale_find_cursor"}
     return _claude_find(
         conn, cref.native_key, cref.conversation_key, query,
         kind=kind, regex=regex, case=case)

package/bin/_lib_conversation_watch.py

@@ -51,7 +51,9 @@ def watch_step(files, seen, *, stat_fn=file_sig, ingest_fn, committed_sig_fn=Non
     cursor, in session_files, lags the new disk size). committed_sig_fn defaults
     to stat_fn for pure unit tests with no cache. A contended/declined/failed
     ingest leaves `seen` untouched so the next cycle retries (the 5s backstop is
-    the floor)."""
+    the floor). Account-scoped callers may additionally expose
+    ``stats.targeted_visible``: the clean ingest still advances ``seen``, but a
+    false value suppresses the tail frame when only another account changed."""
     committed_sig_fn = committed_sig_fn or stat_fn
     changed = changed_paths(files, seen, stat_fn)
     if not changed:
@@ -64,4 +66,4 @@ def watch_step(files, seen, *, stat_fn=file_sig, ingest_fn, committed_sig_fn=Non
         sig = committed_sig_fn(p)
         if sig is not None:
             new_seen[p] = sig
-    return new_seen, True
+    return new_seen, bool(getattr(stats, "targeted_visible", True))