cctally 1.41.0 → 1.42.0

package/CHANGELOG.md

@@ -5,6 +5,16 @@ 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

package/bin/_lib_conversation.py

@@ -16,6 +16,55 @@ 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
+
+
+# #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 +192,19 @@ 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 _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 +258,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 +273,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,15 @@ from _lib_conversation import _stringify
 # #177 S4: the media-route reader walks a content array with the SAME ordinal
 # generator the ingest placeholders used, so "media item N" addresses one item.
 from _lib_conversation import iter_media_items
-
-
-# Mirror of dashboard/web/src/conversations/systemMarkers.ts::MARKER_RE — anchored
-# whole-string (fullmatch), unrolled-lazy body for linear time (no ReDoS), \1
-# backref forces each close tag to match its open tag. Used to SKIP slash-command
-# plumbing when deriving a conversation title (#165 Q2). MUST stay equivalent to
-# the TS predicate over ASCII whitespace (parity-tested); exotic Unicode/control
-# whitespace is an explicit non-goal. See docs/dashboard-gotchas.md.
-_MARKER_TAGS = ("command-name", "command-message", "command-args", "local-command-caveat")
-_MARKER_RE = re.compile(
-    r"\s*(?:<(" + "|".join(_MARKER_TAGS) + r")>(?:(?!</\1>)[\s\S])*</\1>\s*)+"
-)
-
-
-def _is_system_marker(text) -> bool:
-    """True iff `text` is ONLY concatenated command-marker wrappers (slash-command
-    plumbing) — the title-derivation skip predicate. `fullmatch` reproduces the TS
-    `^\\s*…\\s*$` anchor (no `$`-before-trailing-`\\n` foot-gun)."""
-    return bool(text) and _MARKER_RE.fullmatch(text) is not None
+# #186: the marker predicate moved DOWN to the parser layer (the parser now
+# classifies command-marker user rows as META at ingest). Re-export the names
+# here for back-compat so existing `from _lib_conversation_query import
+# _is_system_marker` importers (and the title-skip path below) keep resolving.
+from _lib_conversation import _MARKER_TAGS, _MARKER_RE, _is_system_marker
+# #186: read-time ANSI strip for rows already indexed with raw SGR (no forced
+# re-ingest). Scoped to prose/thinking/title/label — NEVER tool_result (Bash
+# AnsiText boundary). Shares the parser's regex so ingest and read-time agree.
+from _lib_conversation import _strip_ansi
 
 
 _TITLE_MAX = 120
@@ -58,7 +48,7 @@ def _title_from_text(text) -> str:
     trailing '…' ONLY when truncated (rstrip before the ellipsis). '' if none.
     Semantics IDENTICAL to the client deriveReaderTitle (#165 P2.5)."""
     for line in (text or "").split("\n"):
-        s = line.strip()
+        s = _strip_ansi(line).strip()   # #186: strip SGR from pre-fix dirty rows
         if s:
             return (s[:_TITLE_MAX].rstrip() + "…") if len(s) > _TITLE_MAX else s
     return ""
@@ -126,22 +116,56 @@ def _meta_classify(item, allow_human_fallback):
       pre-reingest window — see _reingest_pending). After the reingest a 'human'
       row keeping the preamble is a real user prompt, so it stays a "You" turn
       rather than being hidden in a collapsed skill pill (Codex code-review P1).
-    - command/context: ONLY for a true 'meta' row (slash-command plumbing vs the
-      rest). A 'human' row that is not a skill body stays human — generic injected
-      context can't be recovered read-time without isMeta; it lands on the next
+    - command: a true 'meta' row ALWAYS, plus — the #186 read-time fallback — a
+      'human' row whose body is command plumbing AND whose blocks are all text.
+      The marker regex is self-identifying (no read-time-recovery hazard, unlike
+      generic injected context), so command recovery for a pre-fix human row is
+      ungated by ``allow_human_fallback``. The all-text guard mirrors the ingest
+      branch (Codex P1b) so an attachment-bearing row is never folded.
+    - context: ONLY for a true 'meta' row (the remaining injected-content case).
+      A non-skill, non-command 'human' row stays human — generic injected context
+      can't be recovered read-time without isMeta; it lands on the next
       sync-triggered reingest."""
     is_meta = item["kind"] == "meta"
     body = item.get("text") or _join_text_blocks(item.get("blocks"))
     first = _first_nonblank_line(body)
     if first.startswith(_SKILL_PREAMBLE) and (is_meta or allow_human_fallback):
         return ("skill", _skill_name_from_preamble(first), body)
+    # Command plumbing: self-identifying, so safe to recover for a pre-fix human
+    # row too — but only when ALL blocks are text (mirror the ingest all-text
+    # guard so an attachment-bearing row is never folded). Runs ABOVE the
+    # not-is_meta guard precisely so a stale entry_type='human' command echo
+    # reclassifies read-time (#186).
+    all_text = all(b.get("kind") == "text" for b in (item.get("blocks") or []))
+    if _is_system_marker(body) and (is_meta or all_text):
+        return ("command", None, body)
     if not is_meta:
         return None
-    if _is_system_marker(body):
-        return ("command", None, body)
     return ("context", None, body)
 
 
+# #186 belt-and-suspenders, title-only: a deliberately-broader skip predicate
+# that drops a title candidate wrapped entirely in `command-*` / `local-command-*`
+# plumbing — a tag-name PREFIX shape, NOT the strict known-tag list. The \1
+# backref forces each close tag to match its open tag; the unrolled-lazy body is
+# linear-time (no ReDoS). Used ONLY in title selection, where being liberal is
+# safe: the worst case is the title falls back to the next line or the project
+# label — never hiding content (that fold-to-pill decision keeps strict
+# `_is_system_marker`, where a false positive WOULD hide real user text). A
+# future unrecognized `local-command-foo` tag thus degrades to "skip the title"
+# rather than "poison the title."
+_CMD_FAMILY_RE = re.compile(
+    r"\s*(?:<((?:local-)?command-[a-z-]+)>(?:(?!</\1>)[\s\S])*</\1>\s*)+"
+)
+
+
+def _looks_like_command_plumbing(text) -> bool:
+    """Title-only liberal skip: the whole text is one or more
+    command-*/local-command-* wrappers (prefix shape). `fullmatch` anchors the
+    whole string. See `_CMD_FAMILY_RE`."""
+    return bool(text) and _CMD_FAMILY_RE.fullmatch(text) is not None
+
+
 def _session_titles_map(conn, session_ids):
     """{sid: title} for the first non-marker, non-blank MAIN-session human line
     per session (read-time, no migration). Windowed to the earliest 12 human
@@ -178,7 +202,7 @@ def _session_titles_map(conn, session_ids):
     for sid, text in rows:
         if sid in titles:
             continue                 # already resolved to the first non-marker
-        if _is_system_marker(text):
+        if _is_system_marker(text) or _looks_like_command_plumbing(text):
             continue
         if skip_skill_titles and _first_nonblank_line(text).startswith(_SKILL_PREAMBLE):
             continue
@@ -745,8 +769,17 @@ def get_conversation(conn, session_id, *, after=None, limit=500):
     # Stamp the session_id into each anchor (spec anchor is (session_id, uuid);
     # the dict literals are built session-agnostic, so fill it here where the
     # session id is known). NOT a no-op — the endpoint/clients rely on it.
+    # #186: ALSO strip ANSI from the displayed prose/thinking text of each page
+    # item before emit, so a pre-fix row already indexed with raw SGR renders
+    # clean (the read-time half of the no-forced-reingest contract). tool_result
+    # blocks are EXCLUDED — Bash AnsiText (#177 S3) renders their SGR colors.
     for it in page:
         it["anchor"]["session_id"] = session_id
+        if it.get("text"):
+            it["text"] = _strip_ansi(it["text"])
+        for b in it["blocks"]:
+            if b.get("kind") in ("text", "thinking") and b.get("text"):
+                b["text"] = _strip_ansi(b["text"])
 
     first = logical[0]
     last = logical[-1]
@@ -769,9 +802,10 @@ _OUTLINE_LABEL_CAP = 120
 
 
 def _outline_label(text):
-    """First non-blank line, capped at _OUTLINE_LABEL_CAP chars ('' when none)."""
+    """First non-blank line, capped at _OUTLINE_LABEL_CAP chars ('' when none).
+    Read-time ANSI strip (#186) so a pre-fix dirty row's label is clean."""
     for ln in (text or "").splitlines():
-        s = ln.strip()
+        s = _strip_ansi(ln).strip()
         if s:
             return s[:_OUTLINE_LABEL_CAP]
     return ""