cctally 1.40.0 → 1.42.0

package/bin/_lib_conversation_query.py

@@ -29,25 +29,15 @@ from _lib_conversation import _stringify
 # #177 S4: the media-route reader walks a content array with the SAME ordinal
 # generator the ingest placeholders used, so "media item N" addresses one item.
 from _lib_conversation import iter_media_items
-
-
-# Mirror of dashboard/web/src/conversations/systemMarkers.ts::MARKER_RE — anchored
-# whole-string (fullmatch), unrolled-lazy body for linear time (no ReDoS), \1
-# backref forces each close tag to match its open tag. Used to SKIP slash-command
-# plumbing when deriving a conversation title (#165 Q2). MUST stay equivalent to
-# the TS predicate over ASCII whitespace (parity-tested); exotic Unicode/control
-# whitespace is an explicit non-goal. See docs/dashboard-gotchas.md.
-_MARKER_TAGS = ("command-name", "command-message", "command-args", "local-command-caveat")
-_MARKER_RE = re.compile(
-    r"\s*(?:<(" + "|".join(_MARKER_TAGS) + r")>(?:(?!</\1>)[\s\S])*</\1>\s*)+"
-)
-
-
-def _is_system_marker(text) -> bool:
-    """True iff `text` is ONLY concatenated command-marker wrappers (slash-command
-    plumbing) — the title-derivation skip predicate. `fullmatch` reproduces the TS
-    `^\\s*…\\s*$` anchor (no `$`-before-trailing-`\\n` foot-gun)."""
-    return bool(text) and _MARKER_RE.fullmatch(text) is not None
+# #186: the marker predicate moved DOWN to the parser layer (the parser now
+# classifies command-marker user rows as META at ingest). Re-export the names
+# here for back-compat so existing `from _lib_conversation_query import
+# _is_system_marker` importers (and the title-skip path below) keep resolving.
+from _lib_conversation import _MARKER_TAGS, _MARKER_RE, _is_system_marker
+# #186: read-time ANSI strip for rows already indexed with raw SGR (no forced
+# re-ingest). Scoped to prose/thinking/title/label — NEVER tool_result (Bash
+# AnsiText boundary). Shares the parser's regex so ingest and read-time agree.
+from _lib_conversation import _strip_ansi
 
 
 _TITLE_MAX = 120
@@ -58,7 +48,7 @@ def _title_from_text(text) -> str:
     trailing '…' ONLY when truncated (rstrip before the ellipsis). '' if none.
     Semantics IDENTICAL to the client deriveReaderTitle (#165 P2.5)."""
     for line in (text or "").split("\n"):
-        s = line.strip()
+        s = _strip_ansi(line).strip()   # #186: strip SGR from pre-fix dirty rows
         if s:
             return (s[:_TITLE_MAX].rstrip() + "…") if len(s) > _TITLE_MAX else s
     return ""
@@ -126,22 +116,56 @@ def _meta_classify(item, allow_human_fallback):
       pre-reingest window — see _reingest_pending). After the reingest a 'human'
       row keeping the preamble is a real user prompt, so it stays a "You" turn
       rather than being hidden in a collapsed skill pill (Codex code-review P1).
-    - command/context: ONLY for a true 'meta' row (slash-command plumbing vs the
-      rest). A 'human' row that is not a skill body stays human — generic injected
-      context can't be recovered read-time without isMeta; it lands on the next
+    - command: a true 'meta' row ALWAYS, plus — the #186 read-time fallback — a
+      'human' row whose body is command plumbing AND whose blocks are all text.
+      The marker regex is self-identifying (no read-time-recovery hazard, unlike
+      generic injected context), so command recovery for a pre-fix human row is
+      ungated by ``allow_human_fallback``. The all-text guard mirrors the ingest
+      branch (Codex P1b) so an attachment-bearing row is never folded.
+    - context: ONLY for a true 'meta' row (the remaining injected-content case).
+      A non-skill, non-command 'human' row stays human — generic injected context
+      can't be recovered read-time without isMeta; it lands on the next
       sync-triggered reingest."""
     is_meta = item["kind"] == "meta"
     body = item.get("text") or _join_text_blocks(item.get("blocks"))
     first = _first_nonblank_line(body)
     if first.startswith(_SKILL_PREAMBLE) and (is_meta or allow_human_fallback):
         return ("skill", _skill_name_from_preamble(first), body)
+    # Command plumbing: self-identifying, so safe to recover for a pre-fix human
+    # row too — but only when ALL blocks are text (mirror the ingest all-text
+    # guard so an attachment-bearing row is never folded). Runs ABOVE the
+    # not-is_meta guard precisely so a stale entry_type='human' command echo
+    # reclassifies read-time (#186).
+    all_text = all(b.get("kind") == "text" for b in (item.get("blocks") or []))
+    if _is_system_marker(body) and (is_meta or all_text):
+        return ("command", None, body)
     if not is_meta:
         return None
-    if _is_system_marker(body):
-        return ("command", None, body)
     return ("context", None, body)
 
 
+# #186 belt-and-suspenders, title-only: a deliberately-broader skip predicate
+# that drops a title candidate wrapped entirely in `command-*` / `local-command-*`
+# plumbing — a tag-name PREFIX shape, NOT the strict known-tag list. The \1
+# backref forces each close tag to match its open tag; the unrolled-lazy body is
+# linear-time (no ReDoS). Used ONLY in title selection, where being liberal is
+# safe: the worst case is the title falls back to the next line or the project
+# label — never hiding content (that fold-to-pill decision keeps strict
+# `_is_system_marker`, where a false positive WOULD hide real user text). A
+# future unrecognized `local-command-foo` tag thus degrades to "skip the title"
+# rather than "poison the title."
+_CMD_FAMILY_RE = re.compile(
+    r"\s*(?:<((?:local-)?command-[a-z-]+)>(?:(?!</\1>)[\s\S])*</\1>\s*)+"
+)
+
+
+def _looks_like_command_plumbing(text) -> bool:
+    """Title-only liberal skip: the whole text is one or more
+    command-*/local-command-* wrappers (prefix shape). `fullmatch` anchors the
+    whole string. See `_CMD_FAMILY_RE`."""
+    return bool(text) and _CMD_FAMILY_RE.fullmatch(text) is not None
+
+
 def _session_titles_map(conn, session_ids):
     """{sid: title} for the first non-marker, non-blank MAIN-session human line
     per session (read-time, no migration). Windowed to the earliest 12 human
@@ -178,7 +202,7 @@ def _session_titles_map(conn, session_ids):
     for sid, text in rows:
         if sid in titles:
             continue                 # already resolved to the first non-marker
-        if _is_system_marker(text):
+        if _is_system_marker(text) or _looks_like_command_plumbing(text):
             continue
         if skip_skill_titles and _first_nonblank_line(text).startswith(_SKILL_PREAMBLE):
             continue
@@ -745,8 +769,17 @@ def get_conversation(conn, session_id, *, after=None, limit=500):
     # Stamp the session_id into each anchor (spec anchor is (session_id, uuid);
     # the dict literals are built session-agnostic, so fill it here where the
     # session id is known). NOT a no-op — the endpoint/clients rely on it.
+    # #186: ALSO strip ANSI from the displayed prose/thinking text of each page
+    # item before emit, so a pre-fix row already indexed with raw SGR renders
+    # clean (the read-time half of the no-forced-reingest contract). tool_result
+    # blocks are EXCLUDED — Bash AnsiText (#177 S3) renders their SGR colors.
     for it in page:
         it["anchor"]["session_id"] = session_id
+        if it.get("text"):
+            it["text"] = _strip_ansi(it["text"])
+        for b in it["blocks"]:
+            if b.get("kind") in ("text", "thinking") and b.get("text"):
+                b["text"] = _strip_ansi(b["text"])
 
     first = logical[0]
     last = logical[-1]
@@ -769,9 +802,10 @@ _OUTLINE_LABEL_CAP = 120
 
 
 def _outline_label(text):
-    """First non-blank line, capped at _OUTLINE_LABEL_CAP chars ('' when none)."""
+    """First non-blank line, capped at _OUTLINE_LABEL_CAP chars ('' when none).
+    Read-time ANSI strip (#186) so a pre-fix dirty row's label is clean."""
     for ln in (text or "").splitlines():
-        s = ln.strip()
+        s = _strip_ansi(ln).strip()
         if s:
             return s[:_OUTLINE_LABEL_CAP]
     return ""
@@ -1083,38 +1117,74 @@ def _fts_flag_unavailable(conn) -> bool:
     return bool(row and row[0])
 
 
+def _search_depth(conn) -> str:
+    """'prose-only' while migration 010's column split is pending, else 'full'
+    (#177 S6). Mirrors ``_cctally_db.conversation_search_depth`` but reads the
+    flag inline (the kernel never imports the db sibling — same pattern as
+    ``_fts_flag_unavailable``). An OperationalError (no cache_meta) → 'full'."""
+    try:
+        pending = conn.execute(
+            "SELECT 1 FROM cache_meta "
+            "WHERE key='conversation_search_split_pending'").fetchone()
+    except sqlite3.OperationalError:
+        return "full"
+    return "prose-only" if pending else "full"
+
+
 def search_conversations(conn, query, *, limit=50, offset=0,
-                         fts_available=None) -> dict:
+                         kind="all", fts_available=None) -> dict:
     """Cross-session search (spec §3.3). Uses FTS5 when available (bm25 rank +
     snippet); else a LIKE scan with a manual snippet. Hits deduped by
     (session_id, uuid); each carries the turn's cost. `fts_available` overrides
-    detection (test seam / explicit LIKE)."""
+    detection (test seam / explicit LIKE).
+
+    #177 S6: ``kind`` (one of ``_SEARCH_KINDS``) scopes the search to a column
+    family — ``all`` is unfiltered, ``prompts``/``assistant`` filter the prose
+    column + entry_type, ``tools``/``thinking`` filter the split index columns.
+    Every hit gains ``match_kinds`` (sorted ``['tool', 'thinking']`` badges;
+    prose never badges). The response carries additive ``kind`` + ``search_depth``
+    so the client can degrade the Tools/Thinking facets during the one-time
+    column split (``search_depth == 'prose-only'`` short-circuits those two
+    kinds to empty). An unknown ``kind`` raises ``ValueError`` (route → 400)."""
+    if kind not in _SEARCH_KINDS:
+        raise ValueError(f"unknown kind: {kind}")
     q = (query or "").strip()
     limit = max(1, min(int(limit), 200))
     offset = max(0, int(offset))
     if fts_available is None:
         fts_available = not _fts_flag_unavailable(conn)
-    if not q:
-        return {"query": q, "mode": "fts" if fts_available else "like",
-                "hits": [], "total": 0}
+    depth = _search_depth(conn)
+    mode = "fts" if fts_available else "like"
+    base = {"query": q, "mode": mode, "hits": [], "total": 0,
+            "kind": kind, "search_depth": depth}
+    # Prose-only interim: the split columns are not yet indexed, so tools /
+    # thinking can't match — short-circuit them to empty (spec §1 interim).
+    if not q or (depth == "prose-only" and kind in ("tools", "thinking")):
+        return base
     if fts_available:
         try:
-            return _search_fts(conn, q, limit, offset)
+            out = _search_fts(conn, q, limit, offset, kind, depth)
+            out.update(kind=kind, search_depth=depth)
+            return out
         except sqlite3.OperationalError:
             pass   # corrupt/missing FTS at query time → fall through to LIKE
-    return _search_like(conn, q, limit, offset)
+    out = _search_like(conn, q, limit, offset, kind, depth)
+    out.update(kind=kind, mode="like", search_depth=depth)
+    return out
 
 
-def _row_to_hit(uuid_, sid, ts, cwd, snippet, msg_id, req_id):
+def _row_to_hit(uuid_, sid, ts, cwd, snippet, msg_id, req_id, match_kinds=None):
     """Build one hit WITHOUT cost — cost is batched onto the FINAL page in
     _attach_costs (I1: no per-hit _turn_cost_map round-trip). The turn key rides
-    on the private `_turn_key` field until the batch maps it to `cost_usd`."""
+    on the private `_turn_key` field until the batch maps it to `cost_usd`.
+    #177 S6: ``match_kinds`` (sorted non-prose badges) is attached per hit."""
     return {
         "session_id": sid,
         "uuid": uuid_,
         "project_label": _project_label(cwd),
         "ts": ts,
         "snippet": snippet,
+        "match_kinds": match_kinds or [],
         "_turn_key": (msg_id, req_id) if msg_id is not None and req_id is not None
                      else None,
     }
@@ -1154,16 +1224,18 @@ def _like_pattern(q):
             + "%")
 
 
-def _fts_snippets(conn, fts_q, ids):
+def _fts_snippets(conn, fts_q, ids, col=0):
     """{rowid: snippet} for the page rowids ONLY (#149). snippet() needs an
     active MATCH, so it can't be deferred to an outer query over the page CTE;
     a second bounded MATCH restricted to the page rowids generates snippets for
-    at most one page of hits instead of every corpus match."""
+    at most one page of hits instead of every corpus match. #177 S6: ``col``
+    selects which FTS column the snippet is drawn from (0=text, 1=search_tool,
+    2=search_thinking) so a tool/thinking hit shows its matching content."""
     if not ids:
         return {}
     ph = ",".join("?" for _ in ids)
     rows = conn.execute(
-        "SELECT cm.id, snippet(conversation_fts, 0, '[', ']', ' … ', 12) "
+        f"SELECT cm.id, snippet(conversation_fts, {int(col)}, '[', ']', ' … ', 12) "
         "FROM conversation_fts "
         "JOIN conversation_messages cm ON cm.id = conversation_fts.rowid "
         f"WHERE conversation_fts MATCH ? AND cm.id IN ({ph})",
@@ -1186,10 +1258,54 @@ def _texts_for_ids(conn, ids):
     return {r[0]: r[1] for r in rows}
 
 
-def _search_fts(conn, q, limit, offset):
+# #177 S6: FTS-column index → badge label (col 0 = prose = no badge).
+_KIND_PROBE_COLUMNS = (("search_tool", "tool"), ("search_thinking", "thinking"))
+_SNIPPET_COL_PREFERENCE = (("tool", 1), ("thinking", 2))   # prose (0) is default
+
+
+def _match_kinds(conn, fts_q, rids_by_group):
+    """{group -> sorted [badges]} via marker-based column probes (spec F3).
+
+    A column "matched" iff a column-filtered sub-MATCH returns its rowid — NOT
+    iff snippet() is non-empty (snippet returns the column's unmarked text for
+    non-matching columns). Probes aggregate across ALL matched rowids of each
+    page group's ``(session_id, uuid)``, so a multi-row hit badges completely.
+    Prose (col 0) is never a badge. ``fts_q`` is the un-column-filtered term
+    expression (the per-column wrapping is applied here)."""
+    all_rids = sorted({r for rids in rids_by_group.values() for r in rids})
+    if not all_rids:
+        return {grp: [] for grp in rids_by_group}
+    ph = ",".join("?" for _ in all_rids)
+    hits_by_col = {}
+    for col, label in _KIND_PROBE_COLUMNS:
+        got = conn.execute(
+            "SELECT conversation_fts.rowid FROM conversation_fts "
+            f"WHERE conversation_fts MATCH ? AND conversation_fts.rowid IN ({ph})",
+            (f"{{{col}}}: ({fts_q})", *all_rids),
+        ).fetchall()
+        hits_by_col[label] = {r[0] for r in got}
+    return {grp: [lbl for (_c, lbl) in _KIND_PROBE_COLUMNS
+                  if set(rids) & hits_by_col[lbl]]
+            for grp, rids in rids_by_group.items()}
+
+
+def _search_fts(conn, q, limit, offset, kind, depth):
     # All of dedup + paging + total live in SQL (#149) so Python never holds
     # more than one page of hits/snippets, regardless of corpus match count.
-    fts_q = _fts_query(q)
+    #
+    # #177 S6: prose-only interim runs the LEGACY single-column shape (the split
+    # columns are not yet indexed) — no column filter, no badge/snippet probes
+    # against search_tool/search_thinking (those columns aren't in the legacy
+    # FTS table). Full mode applies the kind column filter + entry_type predicate
+    # and the marker-based badges.
+    legacy = depth == "prose-only"
+    fts_q = _fts_query(q, prefix_last=True)
+    # legacy single-column MATCH (prose), no column filter; full mode applies
+    # the kind column filter.
+    match_expr = fts_q if legacy else _kind_match_expr(kind, fts_q)
+    entry_type = _KIND_ENTRY_TYPE.get(kind)
+    et_pred = " AND cm.entry_type = ?" if entry_type is not None else ""
+    et_args = (entry_type,) if entry_type is not None else ()
     # Exact post-dedup logical total — counted in C with no snippet generation
     # and no Python row materialization.
     total = conn.execute(
@@ -1197,8 +1313,8 @@ def _search_fts(conn, q, limit, offset):
         "  SELECT DISTINCT cm.session_id, cm.uuid "
         "  FROM conversation_fts "
         "  JOIN conversation_messages cm ON cm.id = conversation_fts.rowid "
-        "  WHERE conversation_fts MATCH ?)",
-        (fts_q,),
+        f"  WHERE conversation_fts MATCH ?{et_pred})",
+        (match_expr, *et_args),
     ).fetchone()[0]
     # One row per logical (session_id, uuid): ROW_NUMBER()=1 keeps the SAME row
     # the old Python dedup kept as its FIRST occurrence (order: bm25, ts DESC,
@@ -1209,16 +1325,20 @@ def _search_fts(conn, q, limit, offset):
     # bm25 is materialized as a plain `rank` column in the inner `matched` CTE
     # before the window function runs: FTS5 auxiliary functions (bm25/snippet)
     # may only be used directly against the MATCH query, NOT inside a window
-    # ORDER BY ("unable to use function bm25 in the requested context").
+    # ORDER BY ("unable to use function bm25 in the requested context"). Weights
+    # (prose > tool > thinking) only apply to the multi-column (full) shape;
+    # the legacy single-column table takes the plain bm25.
+    bm25_expr = ("bm25(conversation_fts)" if legacy
+                 else "bm25(conversation_fts, 10.0, 3.0, 1.0)")
     page = conn.execute(
         "WITH matched AS ("
         "  SELECT cm.id AS rid, cm.session_id AS sid, cm.uuid AS uuid, "
         "         cm.timestamp_utc AS ts, cm.cwd AS cwd, "
         "         cm.msg_id AS mid, cm.req_id AS rqd, "
-        "         bm25(conversation_fts) AS rank "
+        f"         {bm25_expr} AS rank "
         "  FROM conversation_fts "
         "  JOIN conversation_messages cm ON cm.id = conversation_fts.rowid "
-        "  WHERE conversation_fts MATCH ?), "
+        f"  WHERE conversation_fts MATCH ?{et_pred}), "
         "ranked AS ("
         "  SELECT *, ROW_NUMBER() OVER ("
         "             PARTITION BY sid, uuid ORDER BY rank, ts DESC, rid DESC"
@@ -1226,26 +1346,101 @@ def _search_fts(conn, q, limit, offset):
         "  FROM matched) "
         "SELECT rid, sid, uuid, ts, cwd, mid, rqd FROM ranked WHERE rn = 1 "
         "ORDER BY rank, ts DESC, rid DESC LIMIT ? OFFSET ?",
-        (fts_q, limit, offset),
+        (match_expr, *et_args, limit, offset),
     ).fetchall()
-    snips = _fts_snippets(conn, fts_q, [r[0] for r in page])
-    hits = [_row_to_hit(uuid, sid, ts, cwd, snips.get(rid, ""), mid, rqd)
+    page_groups = {(sid, uuid): rid for (rid, sid, uuid, ts, cwd, mid, rqd) in page}
+    if legacy:
+        badges = {grp: [] for grp in page_groups}
+    else:
+        rids_by_group = _all_matched_rids_by_group(
+            conn, match_expr, et_pred, et_args, list(page_groups))
+        badges = _match_kinds(conn, fts_q, rids_by_group)
+    snips = _fts_snippets(conn, match_expr, [r[0] for r in page], col=0)
+    # For hits badged tool/thinking but with no prose match, draw the snippet
+    # from the matched column instead (prose → tool → thinking preference).
+    if not legacy:
+        snips = _prefer_snippet_columns(conn, fts_q, page, page_groups, badges, snips)
+    hits = [_row_to_hit(uuid, sid, ts, cwd, snips.get(rid, ""), mid, rqd,
+                        match_kinds=badges.get((sid, uuid), []))
             for (rid, sid, uuid, ts, cwd, mid, rqd) in page]
     return {"query": q, "mode": "fts",
             "hits": _attach_titles(conn, _attach_costs(conn, hits)),
             "total": total}
 
 
-def _search_like(conn, q, limit, offset):
+def _all_matched_rids_by_group(conn, match_expr, et_pred, et_args, groups):
+    """{(sid, uuid) -> [rids]} for the page groups: ALL matched physical rows of
+    each group (not just the rank-survivor), so badges aggregate completely."""
+    if not groups:
+        return {}
+    rids_by_group = {g: [] for g in groups}
+    rows = conn.execute(
+        "SELECT cm.id, cm.session_id, cm.uuid FROM conversation_fts "
+        "JOIN conversation_messages cm ON cm.id = conversation_fts.rowid "
+        f"WHERE conversation_fts MATCH ?{et_pred}",
+        (match_expr, *et_args),
+    ).fetchall()
+    for rid, sid, uuid in rows:
+        g = (sid, uuid)
+        if g in rids_by_group:
+            rids_by_group[g].append(rid)
+    return rids_by_group
+
+
+def _prefer_snippet_columns(conn, fts_q, page, page_groups, badges, snips):
+    """Replace a hit's prose snippet with its matched column's snippet when the
+    prose column did NOT match (prose → tool → thinking preference). Probes
+    which column matched the survivor rowid, then re-snippets that column."""
+    by_col = {}   # snippet column index -> [rids needing it]
+    for (rid, sid, uuid, ts, cwd, mid, rqd) in page:
+        grp = (sid, uuid)
+        kinds = badges.get(grp, [])
+        if not kinds:
+            continue   # prose hit (or unbadged) — keep col-0 snippet
+        # Does THIS survivor row match prose? If so keep col 0.
+        prose_hit = conn.execute(
+            "SELECT 1 FROM conversation_fts "
+            "WHERE conversation_fts MATCH ? AND conversation_fts.rowid = ?",
+            (f"{{text}}: ({fts_q})", rid)).fetchone()
+        if prose_hit:
+            continue
+        for label, col in _SNIPPET_COL_PREFERENCE:
+            if label in kinds:
+                by_col.setdefault(col, []).append(rid)
+                break
+    for col, rids in by_col.items():
+        col_fts = _kind_match_expr(
+            "tools" if col == 1 else "thinking", fts_q)
+        alt = _fts_snippets(conn, col_fts, rids, col=col)
+        snips.update(alt)
+    return snips
+
+
+def _search_like(conn, q, limit, offset, kind, depth):
     # SQL-bounded mirror of _search_fts for the no-FTS5 fallback (#149); the
     # COUNT + page each scan the table once (the degraded path already lacks an
-    # index for the substring match).
+    # index for the substring match). #177 S6: kind → column list (single-
+    # substring semantics preserved — a documented degraded divergence from FTS
+    # term-wise AND); badges from per-column LIKE probes on the page rows.
+    legacy = depth == "prose-only"
     like = _like_pattern(q)
+    if legacy:
+        cols = ["text"]
+    else:
+        cols = ({"prompts": ["text"], "assistant": ["text"],
+                 "tools": ["search_tool"], "thinking": ["search_thinking"]}
+                .get(kind, ["text", "search_tool", "search_thinking"]))
+    col_pred = "(" + " OR ".join(
+        f"{c} LIKE ? ESCAPE '\\' AND {c} != ''" for c in cols) + ")"
+    like_args = tuple(like for _ in cols)
+    entry_type = _KIND_ENTRY_TYPE.get(kind)
+    et_pred = " AND entry_type = ?" if entry_type is not None else ""
+    et_args = (entry_type,) if entry_type is not None else ()
     total = conn.execute(
         "SELECT COUNT(*) FROM ("
         "  SELECT DISTINCT session_id, uuid FROM conversation_messages "
-        "  WHERE text LIKE ? ESCAPE '\\' AND text != '')",
-        (like,),
+        f"  WHERE {col_pred}{et_pred})",
+        (*like_args, *et_args),
     ).fetchone()[0]
     page = conn.execute(
         "WITH ranked AS ("
@@ -1256,25 +1451,217 @@ def _search_like(conn, q, limit, offset):
         "           ORDER BY timestamp_utc DESC, id DESC"
         "         ) AS rn "
         "  FROM conversation_messages "
-        "  WHERE text LIKE ? ESCAPE '\\' AND text != '') "
+        f"  WHERE {col_pred}{et_pred}) "
         "SELECT rid, sid, uuid, ts, cwd, mid, rqd FROM ranked WHERE rn = 1 "
         "ORDER BY ts DESC, rid DESC LIMIT ? OFFSET ?",
-        (like, limit, offset),
+        (*like_args, *et_args, limit, offset),
     ).fetchall()
     texts = _texts_for_ids(conn, [r[0] for r in page])
+    if legacy:
+        badges = {(sid, uuid): [] for (rid, sid, uuid, *_r) in page}
+    else:
+        badges = _like_badges(conn, like, list(
+            {(sid, uuid) for (rid, sid, uuid, *_r) in page}))
     hits = [_row_to_hit(uuid, sid, ts, cwd,
-                        _manual_snippet(texts.get(rid, ""), q), mid, rqd)
+                        _manual_snippet(texts.get(rid, ""), q), mid, rqd,
+                        match_kinds=badges.get((sid, uuid), []))
             for (rid, sid, uuid, ts, cwd, mid, rqd) in page]
     return {"query": q, "mode": "like",
             "hits": _attach_titles(conn, _attach_costs(conn, hits)),
             "total": total}
 
 
-def _fts_query(q):
+def _like_badges(conn, like, groups):
+    """{(sid, uuid) -> sorted [badges]} via per-column LIKE probes across all
+    physical rows of each page group (LIKE degraded mode; spec F7)."""
+    if not groups:
+        return {}
+    out = {g: [] for g in groups}
+    ph = " OR ".join("(session_id=? AND uuid=?)" for _ in groups)
+    flat = [v for g in groups for v in g]
+    for col, label in _KIND_PROBE_COLUMNS:
+        rows = conn.execute(
+            f"SELECT DISTINCT session_id, uuid FROM conversation_messages "
+            f"WHERE {col} LIKE ? ESCAPE '\\' AND {col} != '' AND ({ph})",
+            (like, *flat)).fetchall()
+        for sid, uuid in rows:
+            if (sid, uuid) in out:
+                out[(sid, uuid)].append(label)
+    return {g: sorted(v) for g, v in out.items()}
+
+
+# #177 S6: kind facets. `all` is the unfiltered MATCH; `prompts`/`assistant`
+# filter the prose column AND the entry_type; `tools`/`thinking` filter the
+# split index columns. Validated in search_conversations / find_in_conversation
+# (an unknown kind raises ValueError → the route maps it to a 400).
+_SEARCH_KINDS = ("all", "prompts", "assistant", "tools", "thinking")
+_KIND_COLUMN = {"prompts": "text", "assistant": "text",
+                "tools": "search_tool", "thinking": "search_thinking"}
+_KIND_ENTRY_TYPE = {"prompts": "human", "assistant": "assistant"}
+
+
+def _fts_query(q, prefix_last=False):
     """Quote each whitespace term as an FTS5 string literal so punctuation /
-    operators in user input can't error the MATCH or inject FTS syntax."""
+    operators in user input can't error the MATCH or inject FTS syntax. When
+    ``prefix_last`` is set, the final term gets a trailing ``*`` (valid FTS5
+    quoted-prefix syntax) so ``cache.d`` matches ``cache.db`` while typing — a
+    ``*`` INSIDE the quotes is a literal char, so the prefix marker lives
+    outside the closing quote (#177 S6)."""
     terms = [t for t in q.split() if t]
-    return " ".join('"' + t.replace('"', '""') + '"' for t in terms) or '""'
+    if not terms:
+        return '""'
+    quoted = ['"' + t.replace('"', '""') + '"' for t in terms]
+    if prefix_last:
+        quoted[-1] += "*"
+    return " ".join(quoted)
+
+
+def _kind_match_expr(kind, fts_q):
+    """Wrap the term expression in a column filter for the kind (#177 S6).
+    ``all`` stays unfiltered; ``prompts``/``assistant`` filter the prose column
+    (the entry_type split is a separate SQL predicate, applied by the caller)."""
+    col = _KIND_COLUMN.get(kind)
+    return f"{{{col}}}: ({fts_q})" if col else fts_q
+
+
+# ===========================================================================
+# #177 S6: in-conversation find — rendered-turn anchors (spec §2 find endpoint).
+# ===========================================================================
+
+_FIND_ANCHOR_CAP = 500
+
+# Which physical-row columns the find match probes per kind, and the badge label
+# each non-prose column contributes. ``text`` maps to the synthetic ``prose``
+# label so a prose-only match still anchors a turn but never badges.
+_FIND_KIND_COLUMNS = {
+    "all": (("text", "prose"), ("search_tool", "tool"),
+            ("search_thinking", "thinking")),
+    "prompts": (("text", "prose"),),
+    "assistant": (("text", "prose"),),
+    "tools": (("search_tool", "tool"),),
+    "thinking": (("search_thinking", "thinking"),),
+}
+
+
+def find_in_conversation(conn, session_id, query, *, kind="all",
+                         fts_available=None, cap=_FIND_ANCHOR_CAP):
+    """Document-ordered rendered-turn anchors for in-conversation find (#177 S6).
+
+    Anchor identity is rendered-turn identity (spec F1): the FTS/LIKE match for
+    the session yields physical-row uuids, then ``_assemble_session`` (the S5
+    outline precedent — 1:1 grouping parity by construction) maps each matched
+    row onto its rendered item via ``member_uuids``. Matched rows folding into
+    the same item (assistant fragments, owned tool results, skill bodies)
+    collapse to ONE anchor whose ``match_kinds`` aggregates across its matched
+    members; document order = assembly order (bm25 unused here). ``total`` counts
+    rendered-turn anchors PRE-cap; the list caps at ``cap`` with
+    ``anchors_truncated``. Returns None for an unknown session; an unknown
+    ``kind`` raises ValueError (route → 400). Empty/whitespace query → empty;
+    prose-only depth + tools/thinking kinds → empty (the split index is pending)."""
+    if kind not in _SEARCH_KINDS:
+        raise ValueError(f"unknown kind: {kind}")
+    # Cheap existence probe (one indexed SELECT) BEFORE the full assembly, so an
+    # empty/prose-only-blocked query opening the find bar pays nothing — yet the
+    # unknown-session → None contract (the route's 404) is preserved, including
+    # for an empty query (assembly used to run first and gave the same answer).
+    if conn.execute(
+            "SELECT 1 FROM conversation_messages WHERE session_id=? LIMIT 1",
+            (session_id,)).fetchone() is None:
+        return None
+    depth = _search_depth(conn)
+    if fts_available is None:
+        fts_available = not _fts_flag_unavailable(conn)
+    q = (query or "").strip()
+    base = {"total": 0, "anchors": [], "anchors_truncated": False,
+            "search_depth": depth, "kind": kind,
+            "mode": "fts" if fts_available else "like"}
+    if not q or (depth == "prose-only" and kind in ("tools", "thinking")):
+        return base
+    asm = _assemble_session(conn, session_id)
+    if asm is None:
+        return None
+    mode, matched = _find_matched_rows(
+        conn, session_id, q, kind, depth, fts_available)
+    # matched: {uuid -> set of labels in {"prose", "tool", "thinking"}}
+    anchors = []
+    for it in asm["items"]:
+        hit_kinds = set()
+        hit = False
+        for mu in it["member_uuids"]:
+            labels = matched.get(mu)
+            if labels:
+                hit = True
+                hit_kinds |= labels
+        if hit:
+            anchors.append({
+                "uuid": it["anchor"]["uuid"],
+                "match_kinds": sorted(k for k in hit_kinds if k != "prose")})
+    total = len(anchors)
+    return {**base, "mode": mode, "total": total,
+            "anchors": anchors[:cap], "anchors_truncated": total > cap}
+
+
+def _find_matched_rows(conn, session_id, q, kind, depth, fts_available):
+    """({mode}, {uuid -> {labels}}) for one session. Runs a column-scoped MATCH
+    (or LIKE) per relevant column and tags each matched row's uuid with that
+    column's label. Prose-only depth uses the legacy single-column FTS (the
+    split columns aren't indexed yet) for prose-bearing kinds."""
+    if fts_available:
+        try:
+            return "fts", _find_matched_fts(conn, session_id, q, kind, depth)
+        except sqlite3.OperationalError:
+            pass   # corrupt/missing FTS → fall through to LIKE
+    return "like", _find_matched_like(conn, session_id, q, kind, depth)
+
+
+def _find_kind_columns(kind, depth):
+    """The (column, label) probes the find match runs for this (kind, depth).
+    Prose-only depth has only the legacy prose column indexed, so the split
+    tool/thinking columns drop out (a prose-bearing kind keeps its prose probe;
+    tools/thinking yield nothing). Shared by _find_matched_fts / _find_matched_like
+    so the two paths can never disagree on which columns a kind probes."""
+    if depth == "prose-only":
+        return (("text", "prose"),) if kind in ("all", "prompts", "assistant") else ()
+    return _FIND_KIND_COLUMNS[kind]
+
+
+def _find_matched_fts(conn, session_id, q, kind, depth):
+    fts_q = _fts_query(q, prefix_last=True)
+    # entry_type predicate + the prose-only legacy MATCH shape are loop-invariant
+    # — compute once. Legacy single-column FTS indexes prose only, so it MATCHes
+    # the bare term (no column filter); full mode wraps each column.
+    et = _KIND_ENTRY_TYPE.get(kind)
+    et_pred = " AND cm.entry_type = ?" if et is not None else ""
+    et_args = (et,) if et is not None else ()
+    legacy = depth == "prose-only"
+    out = {}
+    for col, label in _find_kind_columns(kind, depth):
+        match_expr = fts_q if legacy else f"{{{col}}}: ({fts_q})"
+        rows = conn.execute(
+            "SELECT cm.uuid FROM conversation_fts "
+            "JOIN conversation_messages cm ON cm.id = conversation_fts.rowid "
+            f"WHERE conversation_fts MATCH ? AND cm.session_id = ?{et_pred}",
+            (match_expr, session_id, *et_args)).fetchall()
+        for (u,) in rows:
+            out.setdefault(u, set()).add(label)
+    return out
+
+
+def _find_matched_like(conn, session_id, q, kind, depth):
+    like = _like_pattern(q)
+    et = _KIND_ENTRY_TYPE.get(kind)
+    et_pred = " AND entry_type = ?" if et is not None else ""
+    et_args = (et,) if et is not None else ()
+    out = {}
+    for col, label in _find_kind_columns(kind, depth):
+        rows = conn.execute(
+            f"SELECT uuid FROM conversation_messages "
+            f"WHERE session_id = ? AND {col} LIKE ? ESCAPE '\\' "
+            f"AND {col} != ''{et_pred}",
+            (session_id, like, *et_args)).fetchall()
+        for (u,) in rows:
+            out.setdefault(u, set()).add(label)
+    return out
 
 
 def _manual_snippet(text, q, width=80):