cctally 1.39.0 → 1.41.0

package/CHANGELOG.md

@@ -5,6 +5,17 @@ based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [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
+- Conversation viewer: a full-session navigation layer — a collapsible outline sidebar (toggle `o`) listing every turn as a landmark with nested thinking entries and scroll-sync highlighting, a stats overview (turn counts, duration, tokens, cost, models, tool histogram, and an error row that jumps to the first error), jump-to-next keys with no wrap-around (`e`/`E` errors, `u`/`U` prompts, `b`/`B` subagents, `p`/`P` plans/questions) mirrored by a clickable glyph cluster with counts, and focus modes (`v` cycles All → Chat → Prompts → Errors; hidden turns coalesce into a clickable `· N hidden ·` marker, and a jump whose target the mode would hide resets to All before landing) (#177 Session 5).
+- Conversation viewer: per-turn timestamps and inter-turn markers — each turn header shows a quiet `· HH:mm` in your `display.tz` (precise instant in a tooltip), with a `⏸ 42 min later` gap rule between turns ten or more minutes apart, a `— Jun 13 —` rule when the calendar day changes, and a combined `⏸ 9.5 h later · Jun 13` when both apply — plus per-turn token footers that extend the assistant cost line to `$0.0214 · in 1.2k · out 4.8k · cache 310k` (tokens-only when a turn has usage but no attributable cost, cost-only for un-reingested turns) (#177 Session 5).
+
 ## [1.39.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
@@ -5348,6 +5354,14 @@ class DashboardHTTPHandler(BaseHTTPRequestHandler):
         elif path.startswith("/api/conversation/") and path.endswith("/media"):
             # #177 S4: on-demand media bytes. Matched BEFORE the <id> reader.
             self._handle_get_conversation_media(path)
+        elif path.startswith("/api/conversation/") and path.endswith("/outline"):
+            # #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:
@@ -7250,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).
@@ -7333,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
@@ -7343,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
@@ -7391,6 +7423,56 @@ class DashboardHTTPHandler(BaseHTTPRequestHandler):
             return
         self._respond_json(200, payload)
 
+    def _handle_get_conversation_outline(self, path: str) -> None:
+        """``GET /api/conversation/<sid>/outline`` — full-session skeleton +
+        session stats (#177 S5). Same fail-closed privacy gate; unknown id → 404.
+        """
+        if not self._require_transcripts_allowed():
+            return
+        import urllib.parse as _u
+        session_id = _u.unquote(path[len("/api/conversation/"):-len("/outline")])
+        if not session_id:
+            self.send_error(404, "conversation not found")
+            return
+        ok, body = self._run_conversation_query(
+            lambda conn: self._conversation_query().get_conversation_outline(conn, session_id),
+            "/api/conversation/outline")
+        if not ok:
+            return
+        if body is None:
+            self.send_error(404, "conversation not found")
+            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")