cctally 1.41.0 → 1.43.0

package/CHANGELOG.md

@@ -5,6 +5,24 @@ based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [1.43.0] - 2026-06-13
+
+### Fixed
+- Conversation viewer: a slash command you typed with a real prompt in its arguments (e.g. `/frontend-design <your task>`) is no longer hidden as a "System marker" and dropped from the outline — its arguments now render as your "You" bubble with a small command badge, drive the conversation title, and are searchable; bare control commands (`/clear`, `/compact`, `/model`, the `local-command-*` echoes) and empty-argument invocations still fold into hidden system-marker pills. Recognized at ingest plus a read-time fallback that fixes already-recorded history, with a cache migration (`011`) that backfills the search index for past commands (#188).
+- Conversation viewer: clicking an outline entry now selects and highlights exactly that entry instead of one a turn or two above it, and the forward jump-to-next chips/keys (`u`/`e`/`b`/`p`) reliably advance to the next landmark instead of re-selecting the same one — the outline tracks an explicit selection you set by clicking or jumping, which takes precedence over the scroll position until you next scroll (#188, #187).
+- Conversation viewer: clicking a subagent in the outline now flashes its collapsed card in place and marks the subagent as the current selection, instead of silently force-expanding the thread, flashing a buried inner message, and highlighting the most-recent prompt above it (#188).
+- Conversation viewer: the floating "↓ N new" live-update pill no longer counts messages streamed into a collapsed subagent thread you have not expanded — it counts only turns that actually become visible (top-level messages, a newly appearing subagent card, or messages inside an expanded thread) (#188).
+
+## [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

package/bin/_cctally_cache.py

@@ -681,6 +681,16 @@ def sync_cache(
                 "DELETE FROM cache_meta WHERE key IN "
                 "('conversation_search_split_pending',"
                 " 'conversation_search_split_cursor')")
+            # #188 bug 4: a rebuild repopulates conversation_messages via the
+            # offset-0 walk through the parser, which now classifies a
+            # command-args invocation as entry_type='human' at INGEST (A2) — so
+            # the migration-011 backfill is redundant. Drop its flag + cursor so
+            # the post-rebuild sync runs no redundant promotion pass. MISSING
+            # this site re-arms the flag on every cache-sync --rebuild.
+            conn.execute(
+                "DELETE FROM cache_meta WHERE key IN "
+                "('conversation_promote_command_args_pending',"
+                " 'conversation_promote_command_args_cursor')")
             conn.commit()
             eprint("[cache-sync] rebuild: cleared Claude cached entries")
 
@@ -780,6 +790,15 @@ def sync_cache(
             # old search keeps working until the final swap.
             _consume_search_split(conn)
 
+            # #188 bug 4: consume the migration-011 command-args promotion under
+            # the SAME held flock, AFTER the search split so a row flipped to
+            # entry_type='human' here keeps the fresh search_tool/search_thinking
+            # the split just wrote (the consumer recomputes them anyway, but
+            # ordering keeps the two passes independent + idempotent). Flips
+            # legacy META command rows carrying a real <command-args> prompt to
+            # HUMAN(text=args); the split-FTS UPDATE triggers re-index the args.
+            _consume_promote_command_args(conn)
+
         paths: list[pathlib.Path] = list(_iter_claude_jsonl_files())
         stats.files_total = len(paths)
 
@@ -1357,6 +1376,68 @@ def _consume_search_split(conn) -> None:
     conn.commit()
 
 
+def _consume_promote_command_args(conn) -> None:
+    """#188 bug 4: flock-held consumer for ``conversation_promote_command_args_pending``
+    (set by cache migration 011). Cursor-resumable walk of
+    ``conversation_messages WHERE entry_type='meta'``: a row whose ``blocks_json``
+    is a pure slash-command marker with a NON-EMPTY ``<command-args>`` is a real
+    user turn, so flip it to ``entry_type='human'`` with ``text=args`` and
+    recompute ``search_tool``/``search_thinking`` via the SHARED
+    ``_lib_conversation._derive_search_columns`` chokepoint (byte-identical to
+    live ingest). ``/clear`` and stdout-only markers (``_extract_command_invocation``
+    returns None) stay META untouched.
+
+    The split-FTS ``AFTER UPDATE OF text, search_tool, search_thinking`` triggers
+    keep the external-content index in sync, so we never hand-write FTS rows.
+    FTS5-unavailable (``fts5_unavailable`` set): no triggers exist, so the
+    base-column UPDATE alone is correct (the index lands later via the
+    rebuild-on-availability path). Checkpoints
+    ``conversation_promote_command_args_cursor`` per 500-row batch; clears both
+    keys when the cursor is exhausted. Interrupted ⇒ resumes from the cursor on
+    the next locked sync; a fresh install never sets the flag → cheap no-op."""
+    if conn.execute(
+        "SELECT 1 FROM cache_meta "
+        "WHERE key='conversation_promote_command_args_pending'"
+    ).fetchone() is None:
+        return
+    row = conn.execute(
+        "SELECT value FROM cache_meta "
+        "WHERE key='conversation_promote_command_args_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 > ? AND entry_type='meta' ORDER BY id LIMIT 500",
+            (last_id,)).fetchall()
+        if not batch:
+            break
+        ups = []
+        for rid, bj in batch:
+            last_id = rid
+            try:
+                blocks = json.loads(bj) if bj else []
+            except (TypeError, ValueError):
+                blocks = []
+            inv = _lib_conversation._extract_command_invocation(
+                blocks, _lib_conversation._join_text_blocks(blocks))
+            if inv is None:
+                continue
+            st, sth = _lib_conversation._derive_search_columns(blocks)
+            ups.append((inv["args"], st, sth, rid))
+        if ups:
+            conn.executemany(
+                "UPDATE conversation_messages SET entry_type='human', text=?, "
+                "search_tool=?, search_thinking=? WHERE id=?", ups)
+        _cctally_db_sib._set_cache_meta(
+            conn, "conversation_promote_command_args_cursor", str(last_id))
+        conn.commit()
+    conn.execute(
+        "DELETE FROM cache_meta WHERE key IN "
+        "('conversation_promote_command_args_pending',"
+        " 'conversation_promote_command_args_cursor')")
+    conn.commit()
+
+
 def iter_entries(
     conn: sqlite3.Connection,
     range_start: dt.datetime,

package/bin/_cctally_db.py

@@ -821,7 +821,12 @@ def _run_pending_migrations(
                 "projected_milestones",
                 "codex_budget_milestones",
             ),
-            "cache.db": ("session_entries",),
+            # conversation_messages joins session_entries as a fresh-install
+            # signal (#188): a transcript-populated cache whose cost rows are
+            # absent must still be treated as non-fresh so a flag-only
+            # conversation migration's consumer actually runs (e.g. 011's
+            # command-args promotion) instead of being stamped without it.
+            "cache.db": ("session_entries", "conversation_messages"),
         }.get(db_label, ())
         for probe_table in probe_tables:
             # _probe_table_nonempty centralizes the "is there data here?"
@@ -3359,6 +3364,25 @@ def conversation_search_depth(conn: sqlite3.Connection) -> str:
     return "prose-only" if pending else "full"
 
 
+@cache_migration("011_conversation_promote_command_args")
+def _011_conversation_promote_command_args(conn: sqlite3.Connection) -> None:
+    """Flag-only arm for #188 bug 4. Sets
+    ``conversation_promote_command_args_pending``; sync_cache consumes it under
+    the cache.db.lock flock (cursor-resumable: flip legacy ``entry_type='META'``
+    command-marker rows whose ``<command-args>`` carry a real user prompt to
+    ``entry_type='human'`` with ``text=args``, recomputing the split search
+    columns so the args enter the entry_type='human' list-title/prompts facet and
+    the FTS index — see _cctally_cache._consume_promote_command_args). 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
+    rows are already promoted at ingest, so the consumer finds nothing to flip).
+    DISPLAY is already fixed read-time (no migration needed); the migration's
+    sole job is FTS-searchability + the list-title facet on legacy data. Mirrors
+    the flag-only pattern of 002/003/007/009/010."""
+    _set_cache_meta(conn, "conversation_promote_command_args_pending", "1")
+    conn.commit()
+
+
 # === Region 7d: Stats migration 008_recompute_weekly_cost_snapshots_dedup_fix ===
 
 @stats_migration("008_recompute_weekly_cost_snapshots_dedup_fix")

package/bin/_lib_conversation.py

@@ -16,6 +16,102 @@ ASSISTANT = "assistant"
 TOOL_RESULT = "tool_result"
 META = "meta"
 
+# 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) AND — at the parser layer
+# (#186) — to classify a slash-command echo carried as a plain user line as META
+# at ingest. MUST stay equivalent to the TS predicate over ASCII whitespace
+# (parity-tested); exotic Unicode/control whitespace is an explicit non-goal.
+# The query kernel re-exports these names for back-compat. See
+# docs/dashboard-gotchas.md.
+_MARKER_TAGS = ("command-name", "command-message", "command-args",
+                "local-command-caveat", "local-command-stdout",
+                "local-command-stderr")
+_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 AND the parser-layer ingest
+    classifier (#186). `fullmatch` reproduces the TS `^\\s*…\\s*$` anchor (no
+    `$`-before-trailing-`\\n` foot-gun)."""
+    return bool(text) and _MARKER_RE.fullmatch(text) is not None
+
+
+# #188: a slash-command invocation carries the user's real prompt inside
+# <command-args>. The <command-name>/<command-message> wrappers are plumbing.
+# Anchored mid-string is fine — _is_system_marker already proved the whole text
+# is ONLY markers before these run, so the first match is the lone occurrence.
+_CMD_NAME_RE = re.compile(r"<command-name>([\s\S]*?)</command-name>")
+_CMD_ARGS_RE = re.compile(r"<command-args>([\s\S]*?)</command-args>")
+
+
+def _join_text_blocks(blocks):
+    """'\\n'-join the text-block bodies of a normalized blocks list (mirrors
+    _blocks_and_text's prose join + the query kernel's _join_text_blocks). The
+    migration-011 consumer rebuilds the marker text from blocks_json to feed
+    _extract_command_invocation, so this lives in the parser kernel (the one
+    _cctally_cache already imports) to keep the two derivations identical."""
+    if not blocks:
+        return ""
+    return "\n".join(b.get("text", "") or ""
+                     for b in blocks if b.get("kind") == "text")
+
+
+def _extract_command_invocation(blocks, text):
+    """If a row is a pure slash-command marker whose <command-args> is non-empty
+    (after strip), return ``{"name": <command-name or "">, "args": <args>}``;
+    else ``None`` (#188 bug 4).
+
+    Block-aware: promotes ONLY when every block is text (mirrors the all-text
+    guard in ``_normalize`` / ``_meta_classify`` so a marker text block PLUS an
+    attachment — e.g. an image — is never promoted) AND ``text`` is a pure
+    command-marker block (``_is_system_marker``) AND ``<command-args>`` holds a
+    real prompt. ``/clear``, ``/exit``, ``/compact``, ``/model`` (empty args) and
+    stdout-only markers all return ``None`` so they stay hidden as system
+    markers. ``name`` is taken from ``<command-name>`` for the reader's command
+    badge; it is purely cosmetic (``""`` when the marker omits the name tag)."""
+    if not blocks or not all(b.get("kind") == "text" for b in blocks):
+        return None
+    if not _is_system_marker(text):
+        return None
+    am = _CMD_ARGS_RE.search(text)
+    if am is None:
+        return None
+    args = am.group(1).strip()
+    if not args:
+        return None
+    nm = _CMD_NAME_RE.search(text)
+    return {"name": (nm.group(1).strip() if nm else ""), "args": args}
+
+
+# #186: strip ANSI terminal control sequences from captured prose/thinking so a
+# slash-command stdout echo (which keeps its SGR styling, e.g. `\x1b[1mFable
+# 5\x1b[22m`) never leaks literal `^[[1m` control codes into a title, an outline
+# label, or body text — and so FTS indexes clean tokens (`Fable`, not
+# `1mFable`). Three alternatives: CSI (covers all SGR `…m`), OSC (BEL- or
+# ST-terminated, or unterminated), and a lone/truncated ESC. Ordinary `[`,
+# digits, `m` in prose are untouched — they match only as part of a real
+# `\x1b[`-led sequence. Conceptually mirrors the client `parseAnsi` cleanup.
+# Deliberately NOT applied in `_stringify` / tool_result text: `AnsiText` (#177
+# S3) renders Bash stdout/stderr SGR colors, so that path keeps raw ANSI.
+_ANSI_RE = re.compile(
+    r"\x1b\[[0-9;:?]*[ -/]*[@-~]"           # CSI (covers all SGR …m)
+    r"|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)?"  # OSC (BEL/ST terminated or unterminated)
+    r"|\x1b"                                # lone/truncated ESC
+)
+
+
+def _strip_ansi(text):
+    """Remove ANSI control sequences (terminal SGR/CSI/OSC). Ordinary '[',
+    digits, 'm' in prose are untouched — they match only inside a real \\x1b[
+    run. Empty / None passes through unchanged. (#186)"""
+    return _ANSI_RE.sub("", text) if text else text
+
+
 _TOOL_RESULT_CAP = 16000   # was 4000; full text always re-derivable from JSONL
 _INPUT_LEAF_CAP = 8000     # max chars per string leaf in a bounded tool input
 _INPUT_TOTAL_CAP = 32000   # honesty backstop on the serialized bounded input
@@ -143,6 +239,33 @@ def _normalize(obj, t, offset):
         # tool_result block still folds as a result.
         entry_type = META
         text = ""
+    elif (blocks and all(b["kind"] == "text" for b in blocks)
+          and (_inv := _extract_command_invocation(blocks, text)) is not None):
+        # #188: a slash-command invocation carrying a real user prompt in
+        # <command-args> IS a user turn — the wrapper is plumbing but the args
+        # are what the user typed. Promote it (entry_type=HUMAN, text=args) so it
+        # enters FTS / title derivation / the entry_type='human' prompts facet.
+        # blocks_json is UNTOUCHED (still the raw <command-name>…), so the read
+        # path derives the command-name badge from the blocks. Ordered BEFORE the
+        # empty-args/stdout-only system-marker fold below — /clear, /exit,
+        # /compact and friends (empty args) fall through to META there. The
+        # all-text guard mirrors the marker fold so a marker+attachment row is
+        # never folded NOR promoted (it stays a plain HUMAN turn in the else).
+        entry_type = HUMAN
+        text = _inv["args"]
+    elif blocks and all(b["kind"] == "text" for b in blocks) and _is_system_marker(text):
+        # A slash-command echo carried as a plain user line (NOT isMeta): the
+        # user did not type it. `<local-command-stdout>…</local-command-stdout>`
+        # & friends arrive as ordinary user content, so without this branch they
+        # render as a "YOU" prompt and poison the conversation title (#186).
+        # Classify META + text="" exactly like the isMeta branch above so the
+        # body stays out of FTS, title derivation, and the entry_type='human'
+        # prompts facet; the body survives in blocks_json for rendering as a
+        # "System marker" pill. The all-text guard mirrors the tool_result
+        # block-shape gate (Codex P1b) so an attachment-bearing row — a marker
+        # text block PLUS an image — is never folded.
+        entry_type = META
+        text = ""
     else:
         entry_type = HUMAN
     is_asst = t == "assistant"
@@ -196,6 +319,9 @@ def _blocks_and_text(content):
     ingest==backfill parity invariant, so the derivation moved to the
     post-augment chokepoint."""
     if isinstance(content, str):
+        # #186: strip ANSI on the str-content path (the slash-command-stdout
+        # carrier) so neither the indexed prose nor the rendered block leaks SGR.
+        content = _strip_ansi(content)
         return (([{"kind": "text", "text": content}] if content else []), content)
     blocks, texts = [], []
     if isinstance(content, list):
@@ -208,11 +334,11 @@ def _blocks_and_text(content):
                 continue
             bt = b.get("type")
             if bt == "text":
-                txt = b.get("text", "") or ""
+                txt = _strip_ansi(b.get("text", "") or "")   # #186: strip SGR
                 blocks.append({"kind": "text", "text": txt})
                 texts.append(txt)
             elif bt == "thinking":
-                think = b.get("thinking", "") or ""
+                think = _strip_ansi(b.get("thinking", "") or "")  # #186: strip SGR
                 blocks.append({"kind": "thinking", "text": think})  # FULL text for render
             elif bt == "tool_use":
                 bounded, input_trunc = _bound_input(b.get("input"))

package/bin/_lib_conversation_query.py

@@ -29,25 +29,20 @@ 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
+# #188: the slash-command-with-args promotion helper. Used at read time to
+# present a legacy/ingested command-marker row carrying a real <command-args>
+# prompt as a "You" turn (text=args, command_name badge). Re-exported for the
+# back-compat import surface + the consumer in _cctally_cache.py.
+from _lib_conversation import _extract_command_invocation
+# #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 +53,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 +121,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 +207,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
@@ -622,6 +651,23 @@ def _assemble_session(conn, session_id):
     allow_human_fallback = _reingest_pending(conn)
     for it in items:
         if it["kind"] in ("meta", "human"):
+            # #188: a slash-command invocation carrying a real prompt in
+            # <command-args> is a USER turn. Promote it BEFORE _meta_classify so
+            # it never folds into a command-marker pill. Run on the BLOCK-joined
+            # text (NOT it["text"]: '' for a legacy META row, args post-migration
+            # — neither is the raw marker the command_name parses from). When it
+            # yields non-empty args, present kind='human', text=args, and attach
+            # the command_name badge (derived from the blocks). Idempotent: a
+            # migrated entry_type='human' row re-derives the same badge. /clear &
+            # empty-args/stdout markers yield None and fall through to
+            # _meta_classify's command/skill/context fold unchanged.
+            inv = _extract_command_invocation(
+                it.get("blocks"), _join_text_blocks(it.get("blocks")))
+            if inv is not None:
+                it["kind"] = "human"
+                it["text"] = inv["args"]
+                it["command_name"] = inv["name"] or None
+                continue
             cls = _meta_classify(it, allow_human_fallback)
             if cls is not None:
                 meta_kind, skill_name, body = cls
@@ -745,8 +791,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 +824,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 ""