cctally 1.40.0 → 1.42.0

package/CHANGELOG.md

@@ -5,6 +5,21 @@ based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [1.42.0] - 2026-06-13
+
+### Fixed
+- Conversation viewer: system and slash-command messages (`/clear`, `/model`, the `local-command-stdout`/`local-command-stderr` echoes, and the caveats) were being attributed to you as "You" turns, and the first such line became the whole conversation's title; they now fold into collapsed "System marker" pills and the title falls back to your real first prompt. Such rows are recognized at ingest (stored as meta and kept out of search and the prompts facet) with a read-time fallback that also cleans already-recorded history, plus a belt-and-suspenders title skip that degrades unknown `command-*`/`local-command-*` tags to "skip" rather than letting them poison the title (#186).
+- Conversation viewer: terminal ANSI escape codes (for example the bold `^[[1m…^[[22m` wrapping "Fable 5") no longer leak into titles, outline labels, or message and command body text — they are stripped at ingest (which also keeps the search index clean for new rows) and again at the render chokepoints (which cleans already-recorded history without a re-ingest), while Bash tool output keeps its intentional terminal colors (#186).
+
+### Changed
+- Conversation viewer: the outline rail is redesigned from a flat wall of ~200 truncated prose lines into a bold prompt spine (your prompts, each with a divider above it) with curated landmarks demoted beneath each prompt — section headings, plans, questions, errors (red), and subagent spawns (magenta) — where a turn's thinking blocks collapse to a single `🧠 ×N` badge on its prompt instead of doubling the list, session-start plumbing rows are gone, role glyphs are color-coded for at-a-glance scanning, and the scroll-sync highlight tracks the enclosing prompt (#186).
+- Conversation viewer: the outline header is merged into one "session at a glance" card — time, tokens, and cost become labeled stat tiles, models/tools/errors become labeled rows, the formerly cryptic unlabeled glyph jump-chips gain text labels and move into the card under a "Jump to" row, and the error count reconciles to one phrase ("14 errors in 13 turns") so the previously-disagreeing 13 and 14 no longer read as two competing numbers (#186).
+
+## [1.41.0] - 2026-06-13
+
+### Added
+- Conversation viewer: search now reaches past prose into commands, file paths, error strings, and the assistant's thinking, with exact kind facets and a browser-style in-conversation find bar — the rail gains an `All · Prompts · Assistant · Tools · Thinking` chip row, a result count line, match badges (`tool`, `thinking`), and a `Load N more` button, while pressing `/` over an open conversation opens a floating find pill (`Enter`/`Shift+Enter` and `n`/`N` step matches, `Esc` closes, wrap-around, exact `k / N` counter, `<mark>` term highlighting in prose) backed by a new `GET /api/conversation/<id>/find` endpoint and a `kind` param on `/api/conversation/search`; the tool/thinking facets light up after a one-time, lossless search-index split (cache migration `010`) runs automatically under the cache lock on the next sync, reporting `search_depth: "prose-only"` (with the Tools/Thinking chips disabled and an `indexing…` hint) until it completes, and degrading to a basic substring scan on hosts without FTS5 (#177 S6).
+
 ## [1.40.0] - 2026-06-12
 
 ### Added

package/bin/_cctally_cache.py

@@ -184,8 +184,9 @@ _CONV_INSERT_SQL = (
     "(session_id,uuid,parent_uuid,source_path,byte_offset,"
     " timestamp_utc,entry_type,text,blocks_json,model,msg_id,"
     " req_id,cwd,git_branch,is_sidechain,source_tool_use_id,"
-    " stop_reason,attribution_skill,attribution_plugin,search_aux)"
-    " VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)"
+    " stop_reason,attribution_skill,attribution_plugin,"
+    " search_tool,search_thinking,search_aux)"
+    " VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)"
 )
 
 
@@ -193,15 +194,19 @@ def _conv_row_tuple(m, path_str):
     """Flatten a ``MessageRow`` into the ``_CONV_INSERT_SQL`` column order.
 
     The #177 enrichment fields (stop_reason / attribution_skill /
-    attribution_plugin / search_aux) are TAIL-APPENDED after source_tool_use_id
-    — same order as the SQL column list — so both ingest paths (fused per-file
-    walk + backfill_conversation_messages) carry them through this one tuple."""
+    attribution_plugin / search_tool / search_thinking / search_aux) are
+    TAIL-APPENDED after source_tool_use_id — same order as the SQL column list —
+    so both ingest paths (fused per-file walk + backfill_conversation_messages)
+    carry them through this one tuple. #177 S6: ``search_aux`` is always written
+    as ``''`` (documented-dead); the split ``search_tool``/``search_thinking``
+    columns carry the non-prose index."""
     return (
         m.session_id, m.uuid, m.parent_uuid, path_str, m.byte_offset,
         m.timestamp_utc, m.entry_type, m.text, m.blocks_json, m.model,
         m.msg_id, m.req_id, m.cwd, m.git_branch, m.is_sidechain,
         m.source_tool_use_id,
-        m.stop_reason, m.attribution_skill, m.attribution_plugin, m.search_aux,
+        m.stop_reason, m.attribution_skill, m.attribution_plugin,
+        m.search_tool, m.search_thinking, m.search_aux,
     )
 
 
@@ -651,6 +656,31 @@ def sync_cache(
                 " 'conversation_media_reingest_pending',"
                 " 'conversation_reingest_cursor',"
                 " 'conversation_reingest_cursor_gen')")
+            # #177 S6: a rebuild repopulates search_tool/search_thinking via the
+            # offset-0 walk (the parser derives them), so the migration-010
+            # backfill is redundant. But a LEGACY-shape DB still carries the old
+            # prose+aux FTS pair that the split triggers can't write — swap to the
+            # split shape NOW (the table is empty post-clear, so the walk below
+            # populates it through the new triggers), then drop the pending flag +
+            # cursor so the post-rebuild sync runs no redundant backfill/swap.
+            # MISSING this site re-arms the flag on every cache-sync --rebuild.
+            try:
+                _split_pending = conn.execute(
+                    "SELECT 1 FROM cache_meta "
+                    "WHERE key='conversation_search_split_pending'"
+                ).fetchone() is not None
+            except sqlite3.OperationalError:
+                _split_pending = False
+            if _split_pending:
+                _fts_off = conn.execute(
+                    "SELECT 1 FROM cache_meta WHERE key='fts5_unavailable'"
+                ).fetchone() is not None
+                if not _fts_off and not _cctally_db_sib._conversation_fts_is_split(conn):
+                    _cctally_db_sib._swap_conversation_fts_to_split(conn)
+            conn.execute(
+                "DELETE FROM cache_meta WHERE key IN "
+                "('conversation_search_split_pending',"
+                " 'conversation_search_split_cursor')")
             conn.commit()
             eprint("[cache-sync] rebuild: cleared Claude cached entries")
 
@@ -742,6 +772,14 @@ def sync_cache(
                 # path (which already wipes + repopulates id-aware via the normal walk).
                 _resumable_reingest_conversation_messages(conn)
 
+            # #177 S6: consume the migration-010 search-column split under the
+            # SAME held flock, AFTER the reingest so any just-re-ingested rows
+            # already carry fresh search_tool/search_thinking before the backfill
+            # touches the tail. Cursor-resumable; the legacy triggers are blind to
+            # the search_tool/search_thinking UPDATEs (they fire on text only), so
+            # old search keeps working until the final swap.
+            _consume_search_split(conn)
+
         paths: list[pathlib.Path] = list(_iter_claude_jsonl_files())
         stats.files_total = len(paths)
 
@@ -1260,6 +1298,65 @@ def _resumable_reingest_conversation_messages(conn):
     conn.commit()
 
 
+def _consume_search_split(conn) -> None:
+    """#177 S6: flock-held consumer for ``conversation_search_split_pending``
+    (set by cache migration 010). Cursor-resumable: backfills
+    search_tool/search_thinking from each row's ``blocks_json`` via the SHARED
+    ``_lib_conversation._derive_search_columns`` chokepoint (so the values are
+    byte-identical to live ingest), checkpointing
+    ``conversation_search_split_cursor`` per 500-row batch. These UPDATEs are
+    INVISIBLE to the LEGACY triggers (which fire on text/search_aux only), so the
+    old prose search keeps working untouched until the final swap (spec F5).
+
+    When the cursor completes, swap the legacy two-table FTS to the consolidated
+    split shape + rebuild (one short transaction), then delete the pending +
+    cursor meta keys. FTS5-unavailable (``fts5_unavailable`` set): the base-column
+    backfill still runs (it is FTS-independent), the vtable swap is SKIPPED, the
+    flag still clears, and the rebuild-on-availability recovery path
+    (_apply_cache_schema) lands the split shape later (spec F6). Interrupted at
+    any point ⇒ resumes from the cursor on the next locked sync; a fresh install
+    never sets the flag so this is a cheap no-op there."""
+    if conn.execute(
+        "SELECT 1 FROM cache_meta WHERE key='conversation_search_split_pending'"
+    ).fetchone() is None:
+        return
+    row = conn.execute(
+        "SELECT value FROM cache_meta WHERE key='conversation_search_split_cursor'"
+    ).fetchone()
+    last_id = int(row[0]) if row else 0
+    while True:
+        batch = conn.execute(
+            "SELECT id, blocks_json FROM conversation_messages "
+            "WHERE id > ? ORDER BY id LIMIT 500",
+            (last_id,)).fetchall()
+        if not batch:
+            break
+        ups = []
+        for rid, bj in batch:
+            try:
+                blocks = json.loads(bj) if bj else []
+            except (TypeError, ValueError):
+                blocks = []
+            st, sth = _lib_conversation._derive_search_columns(blocks)
+            ups.append((st, sth, rid))
+            last_id = rid
+        conn.executemany(
+            "UPDATE conversation_messages SET search_tool=?, search_thinking=? "
+            "WHERE id=?", ups)
+        _cctally_db_sib._set_cache_meta(
+            conn, "conversation_search_split_cursor", str(last_id))
+        conn.commit()
+    fts_off = conn.execute(
+        "SELECT 1 FROM cache_meta WHERE key='fts5_unavailable'"
+    ).fetchone() is not None
+    if not fts_off:
+        _cctally_db_sib._swap_conversation_fts_to_split(conn)
+    conn.execute(
+        "DELETE FROM cache_meta WHERE key IN "
+        "('conversation_search_split_pending','conversation_search_split_cursor')")
+    conn.commit()
+
+
 def iter_entries(
     conn: sqlite3.Connection,
     range_start: dt.datetime,

package/bin/_cctally_dashboard.py

@@ -5218,6 +5218,12 @@ def _qs_str(q: dict, key: str, default: str | None) -> str | None:
     return vals[0] if vals else default
 
 
+# #177 S6: valid kind facets for the conversation search / find routes. Kept in
+# lockstep with ``_lib_conversation_query._SEARCH_KINDS`` (the kernel re-raises
+# ValueError on an unknown kind; the handlers reject with a 400 before the call).
+_CONV_SEARCH_KINDS = ("all", "prompts", "assistant", "tools", "thinking")
+
+
 class DashboardHTTPHandler(BaseHTTPRequestHandler):
     """Routes:
         GET /                       → dashboard.html
@@ -5352,6 +5358,10 @@ class DashboardHTTPHandler(BaseHTTPRequestHandler):
             # #177 S5: full-session outline skeleton + stats. Matched BEFORE
             # the <id> reader catch-all (Codex F2 — same precedence as /payload).
             self._handle_get_conversation_outline(path)
+        elif path.startswith("/api/conversation/") and path.endswith("/find"):
+            # #177 S6: in-conversation find → rendered-turn anchors. Matched
+            # BEFORE the <id> reader catch-all (same precedence as /outline).
+            self._handle_get_conversation_find(path)
         elif path.startswith("/api/conversation/"):
             self._handle_get_conversation_detail(path)
         else:
@@ -7254,6 +7264,19 @@ class DashboardHTTPHandler(BaseHTTPRequestHandler):
         """Lazy-load the pure conversation query kernel (Plan 2, §3)."""
         return sys.modules["cctally"]._load_sibling("_lib_conversation_query")
 
+    def _parse_search_kind(self, q):
+        """Read + validate the ``kind`` facet shared by the conversation search
+        and find routes (#177 S6). Returns the kind on success, or ``None`` after
+        having ALREADY sent a 400 — callers just ``return`` on ``None``. Kept in
+        lockstep with the kernel's ``_SEARCH_KINDS`` via ``_CONV_SEARCH_KINDS``
+        (the kernel module is resolved lazily per-request, so the handler keeps a
+        literal tuple rather than reaching across that import edge for a nit)."""
+        kind = _qs_str(q, "kind", "all")
+        if kind not in _CONV_SEARCH_KINDS:
+            self._respond_json(400, {"error": f"unknown kind: {kind}"})
+            return None
+        return kind
+
     def _run_conversation_query(self, kernel_call, log_label):
         """Open cache.db, run ``kernel_call(conn)``, close — with the uniform
         500 envelopes the three conversation routes share (#151).
@@ -7337,8 +7360,10 @@ class DashboardHTTPHandler(BaseHTTPRequestHandler):
         self._respond_json(200, body)
 
     def _handle_get_conversation_search(self) -> None:
-        """``GET /api/conversation/search?q=...`` — cross-session FTS/LIKE
-        search (spec §3.3). Matched BEFORE the ``<id>`` reader in ``do_GET``.
+        """``GET /api/conversation/search?q=...&kind=...`` — cross-session
+        FTS/LIKE search (spec §3.3). Matched BEFORE the ``<id>`` reader in
+        ``do_GET``. ``kind`` (#177 S6) is validated to ``_CONV_SEARCH_KINDS``
+        (else 400) before the kernel call.
         """
         if not self._require_transcripts_allowed():
             return
@@ -7347,9 +7372,12 @@ class DashboardHTTPHandler(BaseHTTPRequestHandler):
         query = _qs_str(q, "q", "")
         limit = _qs_int(q, "limit", 50)
         offset = _qs_int(q, "offset", 0)
+        kind = self._parse_search_kind(q)
+        if kind is None:
+            return
         ok, body = self._run_conversation_query(
             lambda conn: self._conversation_query().search_conversations(
-                conn, query, limit=limit, offset=offset),
+                conn, query, limit=limit, offset=offset, kind=kind),
             "/api/conversation/search")
         if not ok:
             return
@@ -7416,6 +7444,35 @@ class DashboardHTTPHandler(BaseHTTPRequestHandler):
             return
         self._respond_json(200, body)
 
+    def _handle_get_conversation_find(self, path: str) -> None:
+        """``GET /api/conversation/<sid>/find?q=...&kind=...`` — in-conversation
+        find → document-ordered rendered-turn anchors (#177 S6). Same fail-closed
+        privacy gate as the sibling routes; unknown id → 404; an invalid ``kind``
+        → 400. Matched BEFORE the ``<id>`` reader catch-all in ``do_GET``.
+        """
+        if not self._require_transcripts_allowed():
+            return
+        import urllib.parse as _u
+        session_id = _u.unquote(path[len("/api/conversation/"):-len("/find")])
+        if not session_id:
+            self.send_error(404, "conversation not found")
+            return
+        q = _u.parse_qs(self.path.partition("?")[2])
+        query = _qs_str(q, "q", "")
+        kind = self._parse_search_kind(q)
+        if kind is None:
+            return
+        ok, body = self._run_conversation_query(
+            lambda conn: self._conversation_query().find_in_conversation(
+                conn, session_id, query, kind=kind),
+            "/api/conversation/find")
+        if not ok:
+            return
+        if body is None:
+            self.send_error(404, "conversation not found")
+            return
+        self._respond_json(200, body)
+
     _MEDIA_FETCH_SITE_ALLOWED = ("same-origin", "same-site", "none")
 
     def _handle_get_conversation_media(self, path: str) -> None:

package/bin/_cctally_db.py

@@ -2407,6 +2407,16 @@ def _apply_cache_schema(conn: sqlite3.Connection) -> None:
     add_column_if_missing(conn, "conversation_messages", "attribution_plugin", "TEXT")
     add_column_if_missing(
         conn, "conversation_messages", "search_aux", "TEXT NOT NULL DEFAULT ''")
+    # #177 S6: split the non-prose search index into two columns so kind facets
+    # (Tools / Thinking) are exact in SQL. ``search_aux`` above is documented-dead
+    # — the writer stops populating it (always ''); the consolidated multi-column
+    # conversation_fts(text, search_tool, search_thinking) indexes these instead.
+    # Idempotent column-adds (no marker, no version); migration 010 backfills the
+    # values onto existing history from blocks_json under the cache.db.lock flock.
+    add_column_if_missing(
+        conn, "conversation_messages", "search_tool", "TEXT NOT NULL DEFAULT ''")
+    add_column_if_missing(
+        conn, "conversation_messages", "search_thinking", "TEXT NOT NULL DEFAULT ''")
     conn.execute(
         "CREATE INDEX IF NOT EXISTS idx_session_files_session_id "
         "ON session_files(session_id)"
@@ -2417,6 +2427,23 @@ def _apply_cache_schema(conn: sqlite3.Connection) -> None:
     # would itself error), set a persisted flag, and let search fall back to
     # LIKE. Spec §1. Idempotent (IF NOT EXISTS).
     if _fts5_available(conn):
+        # #177 S6: if a LEGACY conversation_fts(text) shape is already present
+        # (a pre-S6 install whose migration-010 backfill/swap has not yet run),
+        # leave EVERYTHING untouched — the legacy table, the legacy aux table,
+        # and the legacy triggers. The sync-side swap (_swap_conversation_fts_to_
+        # split, under the cache.db.lock flock) owns the transition; re-applying
+        # the schema must NOT race it or partially mutate the shape. A fresh
+        # install (no conversation_fts) and an already-split shape both fall
+        # through to the create/recover path below.
+        legacy_present = (
+            conn.execute(
+                "SELECT 1 FROM sqlite_master "
+                "WHERE type='table' AND name='conversation_fts'"
+            ).fetchone() is not None
+            and not _conversation_fts_is_split(conn))
+        if legacy_present:
+            conn.commit()
+            return
         try:
             # Recovery (spec §1/P2): if a PRIOR run marked FTS unavailable,
             # conversation_messages rows were ingested (by sync_cache / the
@@ -2425,43 +2452,34 @@ def _apply_cache_schema(conn: sqlite3.Connection) -> None:
             # rows. Detect that BEFORE clearing the flag so we can rebuild the
             # external-content index from conversation_messages below. A fresh
             # install never sets the flag, so this stays False and no rebuild
-            # runs (the triggers index rows incrementally as they arrive).
+            # runs (the triggers index rows incrementally as they arrive). This
+            # is ALSO the FTS5-unavailable migration-010 recovery seam: the
+            # backfill ran the base-column UPDATEs but skipped the vtable DDL, so
+            # the first FTS-capable open lands the split shape + rebuilds here.
             recovering = conn.execute(
                 "SELECT 1 FROM cache_meta WHERE key='fts5_unavailable'"
             ).fetchone() is not None
-            conn.execute(
-                "CREATE VIRTUAL TABLE IF NOT EXISTS conversation_fts "
-                "USING fts5(text, content='conversation_messages', content_rowid='id')")
-            # #177: the aux external-content index is ALL-OR-NOTHING with the
-            # prose FTS under the SINGLE fts5_unavailable flag — created in this
-            # SAME try-envelope (via the _create_conversation_fts_aux_table seam,
-            # which tests monkeypatch to simulate an aux-create failure AFTER the
-            # prose create succeeded), so ANY OperationalError below drops BOTH
-            # tables + BOTH trigger sets (the except arm). A live aux trigger over
-            # a missing conversation_fts_aux would roll back the shared
-            # conversation_messages write transaction (which also carries cost
-            # ingest into session_entries). It is NOT given its own guarded block
-            # or its own flag.
-            _create_conversation_fts_aux_table(conn)
-            # Trigger DDL lives in ONE place (_CONV_FTS_TRIGGER_DDL +
-            # _CONV_FTS_AUX_TRIGGER_DDL) so this initial create and the #138
-            # storm-free full-clear (clear_conversation_messages, which drops +
-            # recreates BOTH trigger sets) can never drift.
+            # #177 S6: the single consolidated multi-column external-content
+            # table replaces the old prose + aux pair. Column names match the
+            # content table BY NAME (external-content rule).
+            conn.execute(_CONV_FTS_SPLIT_DDL)
+            # Trigger DDL lives in ONE place (_CONV_FTS_TRIGGER_DDL) so this
+            # initial create and the #138 storm-free full-clear
+            # (clear_conversation_messages, which drops + recreates the trigger
+            # set) can never drift.
             _create_conversation_fts_triggers(conn)
             if recovering:
-                # Repopulate the freshly-(re)created indexes from the base table
+                # Repopulate the freshly-(re)created index from the base table
                 # so pre-recovery history is searchable. Cheap no-op when
                 # conversation_messages is empty.
                 conn.execute(
                     "INSERT INTO conversation_fts(conversation_fts) VALUES('rebuild')")
-                conn.execute(
-                    "INSERT INTO conversation_fts_aux(conversation_fts_aux) VALUES('rebuild')")
             conn.execute("DELETE FROM cache_meta WHERE key='fts5_unavailable'")
         except sqlite3.OperationalError:
-            # partial create cleanup, then mark unavailable. _drop drops BOTH
-            # prose + aux trigger sets (#177), and we drop BOTH vtables, so a
-            # failed aux create can't leave a live aux trigger over a missing
-            # table.
+            # partial create cleanup, then mark unavailable. _drop drops the
+            # split trigger set (and any legacy aux trigger names, harmlessly),
+            # and we drop both possible vtables, so a failed create can't leave a
+            # live trigger over a missing table.
             _drop_conversation_fts_triggers(conn)
             try:
                 conn.execute("DROP TABLE IF EXISTS conversation_fts")
@@ -2507,9 +2525,36 @@ def _set_cache_meta(conn: sqlite3.Connection, key: str, value: str) -> None:
                  "ON CONFLICT(key) DO UPDATE SET value=excluded.value", (key, value))
 
 
+# #177 S6: the consolidated multi-column external-content FTS5 table that
+# replaces the old conversation_fts(text) + conversation_fts_aux(search_aux)
+# pair. The three column names MUST match the conversation_messages columns BY
+# NAME (external-content FTS5 resolves columns through the content table by
+# name): a mismatch creates fine but breaks 'rebuild' + iterdump
+# ("no such column"). Fresh installs create this directly; existing installs
+# swap to it under the cache.db.lock flock via _swap_conversation_fts_to_split.
+_CONV_FTS_SPLIT_DDL = (
+    "CREATE VIRTUAL TABLE IF NOT EXISTS conversation_fts USING fts5("
+    "text, search_tool, search_thinking, "
+    "content='conversation_messages', content_rowid='id')"
+)
+
+
+def _conversation_fts_is_split(conn: sqlite3.Connection) -> bool:
+    """True if conversation_fts is the #177 S6 multi-column shape (carries the
+    ``search_tool`` column), False for the legacy single-column ``text`` shape or
+    an absent table."""
+    cols = [r[1] for r in conn.execute("PRAGMA table_info(conversation_fts)")]
+    return "search_tool" in cols
+
+
 def _create_conversation_fts_aux_table(conn: sqlite3.Connection) -> None:
     """Create the #177 aux external-content FTS5 index over the ``search_aux``
-    blob. A standalone module-level seam (NOT inlined in ``_apply_cache_schema``)
+    blob. TEST/FIXTURE STANDUP ONLY — production code (``_apply_cache_schema``)
+    builds the post-#177-S6 SPLIT index directly; this legacy single-aux-column
+    shape is referenced solely by the migration-fixture builder + the swap tests
+    (the migration's by-name DROP list still legitimately uses the trigger-name
+    tuples, but never calls this helper). A standalone module-level seam (NOT
+    inlined in ``_apply_cache_schema``)
     so the all-or-nothing regression test can monkeypatch it to raise
     ``OperationalError`` AFTER the prose ``conversation_fts`` create succeeded —
     proving the shared try-envelope drops BOTH indexes + BOTH trigger sets and a
@@ -2533,16 +2578,26 @@ def _create_conversation_fts_aux_table(conn: sqlite3.Connection) -> None:
 # the initial create in _apply_cache_schema and the #138 storm-free full-clear
 # in clear_conversation_messages (which drops + recreates them) can never drift.
 # conv_fts_ad / conv_fts_au use the external-content `'delete'` idiom.
+# #177 S6: three-column trigger set for the consolidated conversation_fts. Same
+# trigger names (conv_fts_ai/ad/au) as the legacy single-column set so the swap
+# reuses them; the AU trigger now fires AFTER UPDATE OF text, search_tool,
+# search_thinking (the backfill UPDATEs search_tool/search_thinking, which the
+# OLD text-only AU did NOT fire — that invisibility is load-bearing, see
+# _consume_search_split, but it applies only while the legacy triggers are still
+# installed; once swapped, these fire on all three columns).
 _CONV_FTS_TRIGGER_DDL = (
     "CREATE TRIGGER IF NOT EXISTS conv_fts_ai AFTER INSERT ON conversation_messages "
-    "BEGIN INSERT INTO conversation_fts(rowid, text) VALUES (new.id, new.text); END",
+    "BEGIN INSERT INTO conversation_fts(rowid, text, search_tool, search_thinking) "
+    "VALUES (new.id, new.text, new.search_tool, new.search_thinking); END",
     "CREATE TRIGGER IF NOT EXISTS conv_fts_ad AFTER DELETE ON conversation_messages "
-    "BEGIN INSERT INTO conversation_fts(conversation_fts, rowid, text) "
-    "VALUES('delete', old.id, old.text); END",
-    "CREATE TRIGGER IF NOT EXISTS conv_fts_au AFTER UPDATE OF text ON conversation_messages "
-    "BEGIN INSERT INTO conversation_fts(conversation_fts, rowid, text) "
-    "VALUES('delete', old.id, old.text); "
-    "INSERT INTO conversation_fts(rowid, text) VALUES (new.id, new.text); END",
+    "BEGIN INSERT INTO conversation_fts(conversation_fts, rowid, text, search_tool, search_thinking) "
+    "VALUES('delete', old.id, old.text, old.search_tool, old.search_thinking); END",
+    "CREATE TRIGGER IF NOT EXISTS conv_fts_au "
+    "AFTER UPDATE OF text, search_tool, search_thinking ON conversation_messages "
+    "BEGIN INSERT INTO conversation_fts(conversation_fts, rowid, text, search_tool, search_thinking) "
+    "VALUES('delete', old.id, old.text, old.search_tool, old.search_thinking); "
+    "INSERT INTO conversation_fts(rowid, text, search_tool, search_thinking) "
+    "VALUES (new.id, new.text, new.search_tool, new.search_thinking); END",
 )
 # Drop by name (the body is irrelevant to DROP TRIGGER); reverse order is
 # cosmetic — order doesn't matter for independent triggers.
@@ -2567,17 +2622,46 @@ _CONV_FTS_AUX_TRIGGER_DDL = (
 )
 _CONV_FTS_AUX_TRIGGER_NAMES = ("conv_fts_aux_au", "conv_fts_aux_ad", "conv_fts_aux_ai")
 
+# #177 S6: the LEGACY single-column prose trigger set, retained ONLY so a
+# pre-swap install (and the legacy-shape test fixture) can stand up the old
+# conversation_fts(text) shape. Fresh installs + the post-swap shape use the
+# three-column _CONV_FTS_TRIGGER_DDL above. Same trigger names, so the swap's
+# DROP-by-name (_CONV_FTS_TRIGGER_NAMES) covers either generation.
+_CONV_FTS_LEGACY_TRIGGER_DDL = (
+    "CREATE TRIGGER IF NOT EXISTS conv_fts_ai AFTER INSERT ON conversation_messages "
+    "BEGIN INSERT INTO conversation_fts(rowid, text) VALUES (new.id, new.text); END",
+    "CREATE TRIGGER IF NOT EXISTS conv_fts_ad AFTER DELETE ON conversation_messages "
+    "BEGIN INSERT INTO conversation_fts(conversation_fts, rowid, text) "
+    "VALUES('delete', old.id, old.text); END",
+    "CREATE TRIGGER IF NOT EXISTS conv_fts_au AFTER UPDATE OF text ON conversation_messages "
+    "BEGIN INSERT INTO conversation_fts(conversation_fts, rowid, text) "
+    "VALUES('delete', old.id, old.text); "
+    "INSERT INTO conversation_fts(rowid, text) VALUES (new.id, new.text); END",
+)
+
 
 def _create_conversation_fts_triggers(conn: sqlite3.Connection) -> None:
-    """Create BOTH external-content FTS5 sync trigger sets — prose
-    (conversation_fts) + aux (conversation_fts_aux, #177) — idempotent (each is
-    ``IF NOT EXISTS``). Single source of truth for the trigger DDL, shared by
-    ``_apply_cache_schema`` and ``clear_conversation_messages`` (#138). The
-    caller must have already created both ``conversation_fts`` and
-    ``conversation_fts_aux``; one call site creates both sets so they can never
-    drift."""
+    """Create the #177 S6 split conversation_fts(text, search_tool,
+    search_thinking) sync trigger set — idempotent (each is ``IF NOT EXISTS``).
+    Single source of truth for the trigger DDL, shared by ``_apply_cache_schema``
+    and ``clear_conversation_messages`` (#138). The caller must have already
+    created ``conversation_fts`` in the split shape (the consolidated table
+    replaced the old prose+aux pair, so there is no separate aux trigger set to
+    create)."""
     for stmt in _CONV_FTS_TRIGGER_DDL:
         conn.execute(stmt)
+
+
+def _create_conversation_fts_legacy_triggers(conn: sqlite3.Connection) -> None:
+    """Create the LEGACY single-column prose + aux trigger sets over the
+    pre-#177-S6 conversation_fts(text) + conversation_fts_aux(search_aux) pair.
+    TEST/FIXTURE STANDUP ONLY — referenced solely by the migration-fixture
+    builder + the swap tests to materialize the legacy shape the migration then
+    upgrades. Production never calls this (the swap drops these trigger sets BY
+    NAME via the ``_CONV_FTS_*_TRIGGER_NAMES`` tuples and recreates the split
+    set). The caller must have created both legacy tables."""
+    for stmt in _CONV_FTS_LEGACY_TRIGGER_DDL:
+        conn.execute(stmt)
     for stmt in _CONV_FTS_AUX_TRIGGER_DDL:
         conn.execute(stmt)
 
@@ -2639,10 +2723,16 @@ def clear_conversation_messages(conn: sqlite3.Connection) -> None:
     _drop_conversation_fts_triggers(conn)
     conn.execute("DELETE FROM conversation_messages")
     conn.execute("INSERT INTO conversation_fts(conversation_fts) VALUES('delete-all')")
-    # #177: the aux index is created all-or-nothing with the prose FTS, so when
-    # fts_unavailable is False BOTH vtables exist — reset BOTH the same storm-free
-    # way (triggers already dropped above, so the base DELETE touched neither).
-    conn.execute("INSERT INTO conversation_fts_aux(conversation_fts_aux) VALUES('delete-all')")
+    # #177 S6: the consolidated split table is the only FTS vtable on a swapped /
+    # fresh DB. A pre-swap legacy install still carries conversation_fts_aux, so
+    # reset it the same storm-free way ONLY when it physically exists (the swap
+    # drops it; a fresh/split DB never had it). Triggers were dropped above, so
+    # the base DELETE touched neither index.
+    if conn.execute(
+        "SELECT 1 FROM sqlite_master WHERE type='table' AND name='conversation_fts_aux'"
+    ).fetchone() is not None:
+        conn.execute(
+            "INSERT INTO conversation_fts_aux(conversation_fts_aux) VALUES('delete-all')")
     _create_conversation_fts_triggers(conn)
 
 
@@ -3225,6 +3315,50 @@ def _009_conversation_media_reingest(conn: sqlite3.Connection) -> None:
     conn.commit()
 
 
+@cache_migration("010_conversation_search_split")
+def _010_conversation_search_split(conn: sqlite3.Connection) -> None:
+    """Flag-only arm for the #177 S6 search-column split. Sets
+    ``conversation_search_split_pending``; sync_cache consumes it under the
+    cache.db.lock flock (cursor-resumable blocks_json backfill of
+    search_tool/search_thinking, then an atomic legacy->split FTS swap+rebuild —
+    see _cctally_cache._consume_search_split). The handler does NO data work so
+    the dispatcher's central stamp (#140) marks a genuinely-complete handler; a
+    fresh install stamps it WITHOUT running (its schema is already split via
+    _apply_cache_schema, so the consumer finds no flag and no-ops). Mirrors the
+    flag-only reingest pattern of 002/003/007/009."""
+    _set_cache_meta(conn, "conversation_search_split_pending", "1")
+    conn.commit()
+
+
+def _swap_conversation_fts_to_split(conn: sqlite3.Connection) -> None:
+    """Legacy two-table shape -> split multi-column shape, in one transaction.
+    Explicit DROPs of BOTH old tables + triggers (an ``IF NOT EXISTS`` create
+    would silently keep the old same-name single-column conversation_fts — spec
+    F9), then create the split DDL + new triggers and rebuild the index from the
+    base table. Runs under the caller's held cache.db.lock flock (the
+    _consume_search_split end-transaction)."""
+    _drop_conversation_fts_triggers(conn)
+    conn.execute("DROP TABLE IF EXISTS conversation_fts")
+    conn.execute("DROP TABLE IF EXISTS conversation_fts_aux")
+    conn.execute(_CONV_FTS_SPLIT_DDL)
+    _create_conversation_fts_triggers(conn)
+    conn.execute("INSERT INTO conversation_fts(conversation_fts) VALUES('rebuild')")
+
+
+def conversation_search_depth(conn: sqlite3.Connection) -> str:
+    """'prose-only' while migration 010's backfill is pending, else 'full'.
+    Surfaced additively on the search/find responses so the client can degrade
+    the Tools/Thinking facets during the one-time index split. An
+    OperationalError (no cache_meta table yet) degrades to '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"
+
+
 # === Region 7d: Stats migration 008_recompute_weekly_cost_snapshots_dedup_fix ===
 
 @stats_migration("008_recompute_weekly_cost_snapshots_dedup_fix")