cctally 1.42.0 → 1.43.1

package/CHANGELOG.md

@@ -5,6 +5,19 @@ based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [1.43.1] - 2026-06-13
+
+### Fixed
+- Conversation viewer: harness-injected user-role lines — compaction summaries, background task/Bash completion notifications, remote-control "Message sent at …" stamps, and `!`-mode bash echoes — are no longer rendered as your own messages; they now show as labeled system/notification pills (compaction expandable), and a remote-control reply shows just your text. Already-recorded history is corrected at read time with no migration. (#191)
+
+## [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

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

@@ -41,6 +41,53 @@ def _is_system_marker(text) -> bool:
     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
@@ -65,6 +112,64 @@ def _strip_ansi(text):
     return _ANSI_RE.sub("", text) if text else text
 
 
+# ---- #191: harness-injected user-line discriminators (shared with the query
+# kernel via re-export). All key on a SELF-IDENTIFYING body shape so the
+# read-time recovery half can rescue already-ingested `human` rows. ----
+
+# Compaction summary preamble. The ingest authority is the `isCompactSummary`
+# JSONL flag (see _normalize); this body match is the read-time meta_kind label
+# authority (and rescues the rare legacy sentinel-without-flag row).
+_COMPACT_SENTINEL = "This session is being continued from a previous conversation"
+
+
+def _is_compaction_body(text) -> bool:
+    """True iff `text` is a compaction-summary body."""
+    return bool(text) and text.lstrip().startswith(_COMPACT_SENTINEL)
+
+
+# Full open+close-tag wrapper (NOT a bare startswith — Codex P1a): a real prompt
+# that merely begins with the literal tag but isn't a well-formed closed block
+# stays human. Unrolled-lazy body = linear time; \1 backref forces the close tag
+# to match the open. A trailing harness line after the close tag is allowed.
+_NOTIFICATION_RE = re.compile(
+    r"\s*<(task|bash)-notification>(?:(?!</\1-notification>)[\s\S])*</\1-notification>")
+
+
+def _is_notification_body(text) -> bool:
+    """True iff `text` opens with a complete <task-notification>…</task-notification>
+    or <bash-notification>…</bash-notification> background-completion wrapper."""
+    return bool(text) and _NOTIFICATION_RE.match(text) is not None
+
+
+# `!`-mode local shell echoes. A DEDICATED detector, NOT a `_MARKER_TAGS` entry
+# (Codex P1b) — so a bash echo containing a literal <command-args> can never
+# reach the #188 `_extract_command_invocation` promotion path.
+_BASH_ECHO_RE = re.compile(
+    r"\s*<(bash-input|bash-stdout|bash-stderr)>(?:(?!</\1>)[\s\S])*</\1>")
+
+
+def _is_bash_echo_body(text) -> bool:
+    """True iff `text` opens with a complete <bash-input>/<bash-stdout>/
+    <bash-stderr> echo wrapper."""
+    return bool(text) and _BASH_ECHO_RE.match(text) is not None
+
+
+# Remote-control replies (sent from the Claude mobile/remote app) arrive as a
+# real user turn prefixed with a `Message sent at <ts> UTC.` system-reminder
+# stamp. NARROW (Codex / approved decision): only this exact leading shape is
+# stripped; no other <system-reminder> is touched.
+_REMOTE_CONTROL_RE = re.compile(
+    r"\A\s*<system-reminder>Message sent at [^<]*UTC\.</system-reminder>\s*")
+
+
+def _strip_remote_control_prefix(text):
+    """Remove a leading remote-control `Message sent at … UTC.` system-reminder
+    block, returning the real user reply. No-op when absent; None/'' pass through."""
+    if not text:
+        return text
+    return _REMOTE_CONTROL_RE.sub("", text, count=1)
+
+
 _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
@@ -192,6 +297,33 @@ def _normalize(obj, t, offset):
         # tool_result block still folds as a result.
         entry_type = META
         text = ""
+    elif obj.get("isCompactSummary"):
+        # #191: compaction summary injected as a user line — authoritative flag.
+        entry_type = META
+        text = ""
+    elif _is_notification_body(text):
+        # #191: <task-notification>/<bash-notification> background completion.
+        entry_type = META
+        text = ""
+    elif _is_bash_echo_body(text):
+        # #191: <bash-input>/<bash-stdout>/<bash-stderr> `!`-mode echo. Dedicated
+        # branch (NOT _MARKER_TAGS) so it can't reach the #188 promotion path.
+        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>`
@@ -206,7 +338,10 @@ def _normalize(obj, t, offset):
         entry_type = META
         text = ""
     else:
+        # #191: a leading remote-control `Message sent at … UTC.` system-reminder
+        # stamp is stripped from the real user reply (narrow). No-op when absent.
         entry_type = HUMAN
+        text = _strip_remote_control_prefix(text)
     is_asst = t == "assistant"
     # #177 S6: derive the split search columns on the FINAL post-augment blocks
     # (every _attach_* pass above has already merged bash_stderr / answers /

package/bin/_lib_conversation_query.py

@@ -34,10 +34,21 @@ from _lib_conversation import iter_media_items
 # 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
+# #191: harness-injected user-line discriminators — defined in the parser,
+# re-exported here so ingest and read-time recovery share one classification.
+from _lib_conversation import (
+    _is_compaction_body, _is_notification_body, _is_bash_echo_body,
+    _strip_remote_control_prefix,
+)
 
 
 _TITLE_MAX = 120
@@ -139,6 +150,12 @@ def _meta_classify(item, allow_human_fallback):
     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 all_text and _is_compaction_body(body):
+        return ("compaction", None, body)        # #191
+    if all_text and _is_notification_body(body):
+        return ("notification", None, body)      # #191
+    if all_text and _is_bash_echo_body(body):
+        return ("command", None, body)           # #191 (#5 -> System-marker pill)
     if not is_meta:
         return None
     return ("context", None, body)
@@ -204,9 +221,12 @@ def _session_titles_map(conn, session_ids):
             continue                 # already resolved to the first non-marker
         if _is_system_marker(text) or _looks_like_command_plumbing(text):
             continue
+        if (_is_compaction_body(text) or _is_notification_body(text)
+                or _is_bash_echo_body(text)):     # #191: never a title
+            continue
         if skip_skill_titles and _first_nonblank_line(text).startswith(_SKILL_PREAMBLE):
             continue
-        t = _title_from_text(text)
+        t = _title_from_text(_strip_remote_control_prefix(text))   # #191: strip the stamp
         if t:
             titles[sid] = t
     return titles
@@ -646,6 +666,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
@@ -654,6 +691,13 @@ def _assemble_session(conn, session_id):
                 it["skill_name"] = skill_name
                 it["text"] = body
 
+    # #191: strip a leading remote-control `Message sent at … UTC.` stamp from any
+    # turn that remains a genuine human reply. Shared assembly -> covers BOTH the
+    # reader and the outline. No-op on #188-promoted command turns (no stamp).
+    for it in items:
+        if it["kind"] == "human" and it.get("text"):
+            it["text"] = _strip_remote_control_prefix(it["text"])
+
     # ---- Phase 4b: fold a Skill-invoked skill body into its Skill tool chip ----
     # A Skill invocation's injected body (now meta_kind='skill') links to its
     # Skill tool_use via source_tool_use_id (threaded as the internal