cctally 1.47.0 → 1.49.0

package/CHANGELOG.md

@@ -5,6 +5,22 @@ based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [1.49.0] - 2026-06-17
+
+### Added
+- **Dashboard conversation viewer — Browse-list filters.** The Browse rail gains a compact `Filters ▾` popover that narrows the conversation list by four axes: date (This month / Last month / Last 7d presets, or an arbitrary from→to range), project (a multi-select matching any of the chosen projects, with per-project conversation counts), cost (an optional minimum and/or maximum USD with quick `≥$1` / `≥$5` / `≥$10` presets), and number of cache rebuilds (a `≥1` / `≥3` / `≥5` or custom threshold). Axes combine with AND, active filters show as removable chips under the search box, and filtering is server-side so pagination and counts stay correct. The date filter matches each session's last activity — the same instant the rail now sorts and groups by — so the date sections, the recent order, and the filter all agree. When a filter set matches nothing the rail shows a distinct "No conversations match these filters." message with a one-click "Clear filters" button (separate from the generic "No conversations." copy for an empty install). Filters apply to Browse only (disabled while a full-text search is active, which also dismisses the popover so the reader's keyboard navigation stays live) and are session-only (reset on reload). Each row's displayed cost is the live, pricing-immediate recompute (consistent with the detail and report views), while the cost filter compares the stored per-session rollup — the two agree except in the brief window after a pricing-table edit, before the next sync re-derives the stored value.
+- **Dashboard conversation viewer — jump to the latest turn.** A `Latest ↓` action in the reader header (and the `End` key) pages the open conversation forward to its end and lands on the most recent turn with the usual flash, reusing the existing jump pipeline with an uncapped pager so it reaches the last turn even in very long conversations — and now correctly waits out a page-load that happens to be in flight when you trigger it, rather than stopping short. Landing at the bottom parks the reader in its stick-to-bottom position, so a live session keeps following new turns automatically.
+
+## [1.48.0] - 2026-06-16
+
+### Fixed
+- **Dashboard conversation viewer — Claude Code's new subagent transcript format:** restored correct rendering after Claude Code moved subagent transcripts to `subagents/agent-*.jsonl` with `Agent`-renamed spawns and null cross-file parent links. Background (async) subagent cards now show completion (✓) with token/duration/tool counts — derived from the subagent's own thread and marked with a `~` when Claude Code provided none; nested subagents render as recursive nested cards, each shown exactly once with the spawning tool chip merged in (a grandchild no longer renders as a detached title-only card plus a stray `Agent` chip); and a skill invoked inside a live-watched subagent now appears without a manual page refresh (the live-tail re-fetches a small overlap window and upserts folded-in content). All read-time over the existing cache — no migration, no re-ingest.
+- **Dashboard conversation viewer — a message you typed while the agent was still working now renders.** When you send a message while the main agent (or a subagent) is busy, Claude Code queues it and persists it as a `queued_command` *attachment* — with the text in `attachment.prompt` rather than a normal `user` turn — so the transcript reader silently dropped it: the prompt was right there in the session's JSONL but never appeared in the rendered conversation. The reader now ingests those queued prompts (`commandMode: "prompt"`) as ordinary "you" turns in their chronological place, while harness-injected queued items such as background `task-notification`s stay excluded. New conversations show queued messages immediately; existing history is re-derived once by a flag-only cache migration (`014_conversation_queued_prompt_reingest`) — the cache is fully re-derivable, so there is nothing to do on upgrade.
+- **Dashboard conversation viewer — jumping to a deeply-nested subagent now lands the card aligned to the top.** Clicking an outline-rail entry for a *grandchild* subagent (a thread nested inside another subagent card) scrolled the target to the *center* of the viewport — fine for an ordinary message, but a subagent card is often much taller than the screen, so centering it pushed its head well above the fold (roughly 250px up, and more on a large window). A subagent-card jump now aligns the card's head to the top of the viewport instead of centering it (and re-aims on the next animation frame once the force-opened ancestor cards have settled), so a deeply-nested target lands head-first at the top (#204).
+
+### Security
+- **Internal (build/test-time only, no user-facing change): bumped the dashboard's dev dependencies to clear three Dependabot advisories** — `vite` 8.0.10 → 8.0.16 (fixes a `server.fs.deny` bypass and an NTLMv2 hash disclosure, both Windows + dev-server only) and the test-only transitive `form-data` 4.0.5 → 4.0.6 (CRLF injection via unescaped multipart field names). None of these packages ship to installed users — the npm/brew artifacts carry only the Python CLI plus the pre-built `dashboard/static/` bundle, never `node_modules` — so there is no runtime exposure; the bundle was rebuilt against the new `vite` and all dashboard tests pass.
+
 ## [1.47.0] - 2026-06-16
 
 ### Added

package/bin/_cctally_cache.py

@@ -594,6 +594,7 @@ _TARGETED_DECLINE_FLAGS = (
     "conversation_search_split_pending",
     "conversation_promote_command_args_pending",
     "conversation_sessions_backfill_pending",
+    "conversation_queued_prompt_reingest_pending",   # migration 014
 )
 
 
@@ -725,12 +726,19 @@ def sync_cache(
             # media[] placeholders + user-content media index + web_search/
             # web_fetch captures); the same offset-0 walk re-derives them, so drop
             # that flag here as well.
+            # Migration 014 sets the DISTINCT
+            # conversation_queued_prompt_reingest_pending flag (to land queued-
+            # while-busy user prompts persisted as queued_command attachments); the
+            # same offset-0 walk re-derives them through the current parser, so drop
+            # that flag here too — MISSING this site re-arms the flag on every
+            # cache-sync --rebuild.
             conn.execute(
                 "DELETE FROM cache_meta WHERE key IN "
                 "('conversation_reingest_pending',"
                 " 'conversation_source_tool_use_reingest_pending',"
                 " 'conversation_reingest_enrichment_pending',"
                 " 'conversation_media_reingest_pending',"
+                " 'conversation_queued_prompt_reingest_pending',"
                 " 'conversation_reingest_cursor',"
                 " 'conversation_reingest_cursor_gen')")
             # #177 S6: a rebuild repopulates search_tool/search_thinking via the
@@ -874,16 +882,20 @@ def sync_cache(
             # ANOTHER distinct flag ``conversation_media_reingest_pending`` to land
             # the tool_result media[] placeholders + user-content media index +
             # web_search/web_fetch captures; same offset-0 re-parse, same reason
-            # for a distinct flag. We trigger the SAME clear + offset-0 backfill on
-            # ANY of these flags and clear them ALL atomically here under the held
-            # flock.
+            # for a distinct flag. Migration 014 uses ANOTHER distinct flag
+            # ``conversation_queued_prompt_reingest_pending`` to land queued-while-
+            # busy user prompts (queued_command attachments the parser now promotes
+            # to HUMAN); same offset-0 re-parse, same distinct-flag reason. We
+            # trigger the SAME clear + offset-0 backfill on ANY of these flags and
+            # clear them ALL atomically here under the held flock.
             try:
                 _reingest = conn.execute(
                     "SELECT 1 FROM cache_meta WHERE key IN "
                     "('conversation_reingest_pending',"
                     " 'conversation_source_tool_use_reingest_pending',"
                     " 'conversation_reingest_enrichment_pending',"
-                    " 'conversation_media_reingest_pending')"
+                    " 'conversation_media_reingest_pending',"
+                    " 'conversation_queued_prompt_reingest_pending')"
                 ).fetchone() is not None
             except sqlite3.OperationalError:
                 _reingest = False
@@ -1473,6 +1485,7 @@ _REINGEST_FLAG_KEYS = (
     "conversation_source_tool_use_reingest_pending",
     "conversation_reingest_enrichment_pending",
     "conversation_media_reingest_pending",   # #177 S4 (migration 009)
+    "conversation_queued_prompt_reingest_pending",   # migration 014
 )
 
 
@@ -1554,6 +1567,7 @@ def _resumable_reingest_conversation_messages(conn):
         " 'conversation_source_tool_use_reingest_pending',"
         " 'conversation_reingest_enrichment_pending',"
         " 'conversation_media_reingest_pending',"
+        " 'conversation_queued_prompt_reingest_pending',"
         " 'conversation_reingest_cursor',"
         " 'conversation_reingest_cursor_gen')")
     conn.commit()
@@ -1623,6 +1637,7 @@ def _recompute_conversation_sessions(conn, session_ids=None) -> None:
             "(session_id, msg_count, started_utc, last_activity_utc) "
             + _CONV_SESSIONS_SELECT + " GROUP BY session_id"
         )
+        _fill_conversation_sessions_filter_columns(conn, None)
         return
     ids = [s for s in session_ids if s is not None]
     for i in range(0, len(ids), 400):
@@ -1639,6 +1654,49 @@ def _recompute_conversation_sessions(conn, session_ids=None) -> None:
             + f" AND session_id IN ({placeholders}) GROUP BY session_id",
             chunk,
         )
+    _fill_conversation_sessions_filter_columns(conn, ids)
+
+
+def _fill_conversation_sessions_filter_columns(conn, session_ids):
+    """Fill the rollup's browse-FILTER columns (project_label / cost_usd /
+    cache_rebuild_count, migration 015) for the given sessions, or ALL when
+    ``session_ids is None``. The structural COUNT/MIN/MAX columns are filled by
+    the INSERT in _recompute_conversation_sessions; this is the second pass that
+    materializes the three filter axes so the rail's date/project/cost/rebuild
+    filters are pure-SQL predicates.
+
+    project_label + cost reuse the query kernel's batch maps (the SAME
+    _project_label / _session_cost_map the rail's per-page Python path used), so
+    a filtered/displayed value equals what the live rail produced. cost is
+    rounded to 6dp to match list_conversations' per-row rounding.
+    cache_rebuild_count is a per-session assemble via the query kernel's
+    single-source-of-truth helper (whole-session property — recompute, never
+    increment).
+
+    No-op when the columns are absent (a pre-migration-015 cache.db being
+    re-derived before its 015 ALTER lands), so an early/partial sync never
+    raises ``no such column``. The CALLER owns the commit (this never commits)."""
+    cols = {r[1] for r in conn.execute("PRAGMA table_info(conversation_sessions)")}
+    if "cache_rebuild_count" not in cols:
+        return
+    lq = _load_lib("_lib_conversation_query")
+    if session_ids is None:
+        ids = [r[0] for r in conn.execute(
+            "SELECT session_id FROM conversation_sessions")]
+    else:
+        ids = [s for s in session_ids if s is not None]
+    if not ids:
+        return
+    cost = lq._session_cost_map(conn, ids)
+    meta = lq._session_latest_meta_map(conn, ids)
+    for sid in ids:
+        proj = lq._project_label(meta.get(sid, (None, None))[0])
+        rebuilds = lq.session_cache_rebuild_count(conn, sid)
+        conn.execute(
+            "UPDATE conversation_sessions SET project_label=?, cost_usd=?, "
+            "cache_rebuild_count=? WHERE session_id=?",
+            (proj, round(cost.get(sid, 0.0), 6), rebuilds, sid),
+        )
 
 
 def _consume_search_split(conn) -> None:

package/bin/_cctally_dashboard.py

@@ -5276,6 +5276,13 @@ def _qs_str(q: dict, key: str, default: str | None) -> str | None:
 _CONV_SEARCH_KINDS = ("all", "prompts", "assistant", "tools", "thinking")
 
 
+class _BadConversationFilter(Exception):
+    """Internal sentinel: a browse-filter query param failed validation. The
+    parse helper has ALREADY sent the 400 response when this is raised, so the
+    caller just unwinds and returns (the conversation routes all 400 on bad
+    input, consistent with the search ``kind`` facet). Module-private."""
+
+
 def _cached_file_sigs(conn, paths):
     """{path: size_bytes} from session_files for the given paths — the cache's
     own view of how far each file is ingested. Size-only by design, matching the
@@ -5419,6 +5426,8 @@ class DashboardHTTPHandler(BaseHTTPRequestHandler):
             self._handle_share_history_get()
         elif path == "/api/doctor":
             self._handle_get_doctor()
+        elif path == "/api/conversations/facets":
+            self._handle_get_conversations_facets()
         elif path == "/api/conversations":
             self._handle_get_conversations()
         elif path == "/api/conversation/search":
@@ -7462,12 +7471,90 @@ class DashboardHTTPHandler(BaseHTTPRequestHandler):
             conn.close()
         return True, body
 
+    def _parse_conversation_filters(self, q):
+        """Parse the browse-list filter params (spec §2) from a ``parse_qs``
+        mapping. On any malformed value this sends a **400** and returns
+        ``None`` — the caller just ``return``s (the conversation routes all 400
+        on bad input). On success returns a dict of ``list_conversations``
+        kwargs: ``date_from``/``date_to`` (UTC-ISO bounds), ``projects``
+        (list[str] | None), ``cost_min``/``cost_max`` (float | None),
+        ``rebuild_min`` (int | None). Empty/blank params drop to ``None``.
+
+        Numeric axes validate strictly (a non-numeric cost / non-integer
+        rebuild threshold is a hard 400). Date bounds route through the pure
+        ``_lib_dashboard_dates.parse_filter_date_range`` helper, which resolves
+        naive date-only bounds in ``display.tz`` and raises ``ValueError`` (→
+        400) on a malformed date. Projects accept BOTH repeated
+        ``?projects=a&projects=b`` and a single comma-joined ``?projects=a,b``.
+        """
+        def _float(name):
+            v = _qs_str(q, name, "")
+            if v is None or v == "":
+                return None
+            try:
+                return float(v)
+            except ValueError:
+                self._respond_json(400, {"error": f"bad {name}: {v}"})
+                raise _BadConversationFilter
+
+        def _int(name):
+            v = _qs_str(q, name, "")
+            if v is None or v == "":
+                return None
+            try:
+                return int(v)
+            except ValueError:
+                self._respond_json(400, {"error": f"bad {name}: {v}"})
+                raise _BadConversationFilter
+
+        try:
+            cost_min = _float("cost_min")
+            cost_max = _float("cost_max")
+            rebuild_min = _int("rebuild_min")
+        except _BadConversationFilter:
+            return None  # 400 already sent
+
+        projects = [p for p in q.get("projects", []) if p] or None
+        # Single comma-joined value -> split (the client may send either form).
+        if projects and len(projects) == 1 and "," in projects[0]:
+            projects = [s for s in projects[0].split(",") if s] or None
+
+        date_from = _qs_str(q, "date_from", "") or None
+        date_to = _qs_str(q, "date_to", "") or None
+        if date_from or date_to:
+            from importlib import import_module
+            tz = _resolve_display_tz_obj(
+                _apply_display_tz_override(
+                    load_config(), type(self).display_tz_pref_override
+                )
+            ).key
+            try:
+                df, dtt = import_module(
+                    "_lib_dashboard_dates"
+                ).parse_filter_date_range(date_from, date_to, tz_name=tz)
+            except ValueError as exc:
+                self._respond_json(400, {"error": str(exc)})
+                return None
+        else:
+            df = dtt = None
+
+        return {
+            "date_from": df,
+            "date_to": dtt,
+            "projects": projects,
+            "cost_min": cost_min,
+            "cost_max": cost_max,
+            "rebuild_min": rebuild_min,
+        }
+
     def _handle_get_conversations(self) -> None:
         """``GET /api/conversations`` — the browse rail (spec §3.1).
 
         Gated first (loopback / Host allowlist). ``sort``/``limit``/``offset``
-        are read from the query string; the kernel clamps bounds. Cache-open
-        failures are 500s, never 5xx-with-stacktrace.
+        are read from the query string; the kernel clamps bounds. The browse
+        filters (date/project/cost/rebuild — spec §2) are parsed/validated here
+        (malformed → 400) and threaded into the kernel. Cache-open failures are
+        500s, never 5xx-with-stacktrace.
         """
         if not self._require_transcripts_allowed():
             return
@@ -7476,14 +7563,33 @@ class DashboardHTTPHandler(BaseHTTPRequestHandler):
         sort = _qs_str(q, "sort", "recent")
         limit = _qs_int(q, "limit", 50)
         offset = _qs_int(q, "offset", 0)
+        filters = self._parse_conversation_filters(q)
+        if filters is None:
+            return  # a 400 has already been sent
         ok, body = self._run_conversation_query(
             lambda conn: self._conversation_query().list_conversations(
-                conn, sort=sort, limit=limit, offset=offset),
+                conn, sort=sort, limit=limit, offset=offset, **filters),
             "/api/conversations")
         if not ok:
             return
         self._respond_json(200, body)
 
+    def _handle_get_conversations_facets(self) -> None:
+        """``GET /api/conversations/facets`` — distinct project labels + their
+        conversation counts, for the browse filter's project multi-select (spec
+        §2). Behind the SAME loopback/Host privacy gate as the list route; a
+        cheap indexed GROUP BY over the rollup. The popover loads its options
+        once from here (deriving from a paginated page would be incomplete).
+        """
+        if not self._require_transcripts_allowed():
+            return
+        ok, body = self._run_conversation_query(
+            lambda conn: self._conversation_query().list_conversation_facets(conn),
+            "/api/conversations/facets")
+        if not ok:
+            return
+        self._respond_json(200, body)
+
     def _handle_get_conversation_detail(self, path: str) -> None:
         """``GET /api/conversation/<session-id>`` — the reader (spec §3.2).
 
@@ -7594,6 +7700,20 @@ class DashboardHTTPHandler(BaseHTTPRequestHandler):
                              + "\n\n").encode("utf-8"))
                         self.wfile.flush()
                         idle = 0.0
+                        # §6 P2-H — a brand-new subagent file's FIRST content was
+                        # just ingested by this emitting cycle, so the session's
+                        # source-path set may have grown. Re-resolve it now (vs
+                        # waiting up to _LIVE_TAIL_FILE_RESET_EVERY cycles) so the
+                        # new thread (incl. a skill invoked inside it) live-tails
+                        # promptly. A new path seeds seen=None (cur lacks a row),
+                        # so changed_paths flags it next cycle → it ingests + emits.
+                        # setdefault never disturbs an existing cursor.
+                        new_files = _resolve()
+                        if set(new_files) != set(files):
+                            files = new_files
+                            cur = _cached_file_sigs(conn, files)
+                            for p in files:
+                                seen.setdefault(p, cur.get(p))
                         continue
                 idle += _LIVE_TAIL_POLL_INTERVAL
                 if idle >= _LIVE_TAIL_KEEPALIVE:

package/bin/_cctally_db.py

@@ -2360,11 +2360,18 @@ def _apply_cache_schema(conn: sqlite3.Connection) -> None:
             byte_offset INTEGER NOT NULL
         );
 
-        -- Browse-rail rollup (conversation_sessions). Materializes exactly the
-        -- four structural aggregates the rail's old live GROUP BY produced
+        -- Browse-rail rollup (conversation_sessions). Materializes the four
+        -- structural aggregates the rail's old live GROUP BY produced
         -- (COUNT/MIN/MAX over conversation_messages per session_id) so
         -- GET /api/conversations no longer scans the whole message table to
-        -- render a 50-row page. The explicit NOT NULL on the non-INTEGER PK
+        -- render a 50-row page, PLUS three filter columns
+        -- (project_label/cost_usd/cache_rebuild_count, migration 015) so the
+        -- Browse list's date/project/cost/cache-rebuild filters are pure-SQL
+        -- predicates. The structural columns are recomputed by a COUNT/MIN/MAX
+        -- GROUP BY; the filter columns are filled per-session by
+        -- _fill_conversation_sessions_filter_columns in the same flock-held
+        -- recompute (cost via the query kernel's batch maps, cache_rebuild_count
+        -- via a per-session assemble). The explicit NOT NULL on the non-INTEGER PK
         -- matters (SQLite's legacy NULL-in-PK bug); the rail keys on a concrete
         -- session_id and the recompute's GROUP BY already filters nulls. The
         -- index lets the only paginated ordering (recent) early-terminate at
@@ -2373,10 +2380,13 @@ def _apply_cache_schema(conn: sqlite3.Connection) -> None:
         -- flag-gated full recompute) — migration 013 arms the one-time
         -- history backfill.
         CREATE TABLE IF NOT EXISTS conversation_sessions (
-            session_id        TEXT NOT NULL PRIMARY KEY,
-            msg_count         INTEGER NOT NULL DEFAULT 0,
-            started_utc       TEXT,
-            last_activity_utc TEXT
+            session_id          TEXT NOT NULL PRIMARY KEY,
+            msg_count           INTEGER NOT NULL DEFAULT 0,
+            started_utc         TEXT,
+            last_activity_utc   TEXT,
+            project_label       TEXT,
+            cost_usd            REAL NOT NULL DEFAULT 0,
+            cache_rebuild_count INTEGER NOT NULL DEFAULT 0
         );
         CREATE INDEX IF NOT EXISTS idx_conv_sessions_recent
             ON conversation_sessions(last_activity_utc DESC, session_id DESC);
@@ -3442,6 +3452,56 @@ def _013_create_conversation_sessions(conn: sqlite3.Connection) -> None:
     conn.commit()
 
 
+@cache_migration("014_conversation_queued_prompt_reingest")
+def _014_conversation_queued_prompt_reingest(conn: sqlite3.Connection) -> None:
+    """Flag-only re-ingest so a message typed while the agent was busy — QUEUED
+    and persisted as an ``attachment`` row (``attachment.type=="queued_command"``,
+    ``commandMode=="prompt"``) rather than a ``type:"user"`` turn — lands on
+    existing history. The parser (``_queued_prompt_row``) now promotes those to a
+    synthetic HUMAN turn at ingest, so the offset-0 re-parse re-derives them with
+    zero new consumption code. Sets the DISTINCT
+    ``conversation_queued_prompt_reingest_pending`` flag (NOT the shared
+    ``conversation_reingest_pending``, which also gates migration 005's read-time
+    human-fallback in the query kernel). Consumption rides the #179 RESUMABLE
+    per-file reingest (_resumable_reingest_conversation_messages) — the flag is
+    wired into _TARGETED_DECLINE_FLAGS + _REINGEST_FLAG_KEYS + both flag SELECTs +
+    the two cleanup DELETE lists in _cctally_cache.py (all five sites; missing one
+    either never triggers or re-arms forever). Central stamp via the dispatcher
+    (#140); a fresh install stamps it WITHOUT running (empty table -> the flag, if
+    ever set, is a harmless no-op). Mirrors 007/009."""
+    _set_cache_meta(conn, "conversation_queued_prompt_reingest_pending", "1")
+    conn.commit()
+
+
+@cache_migration("015_conversation_sessions_filter_columns")
+def _015_conversation_sessions_filter_columns(conn: sqlite3.Connection) -> None:
+    """Add the browse-filter columns to the conversation_sessions rollup
+    (project_label, cost_usd, cache_rebuild_count) so the rail's date/project/
+    cost/cache-rebuild filters are pure-SQL predicates (spec §1). ALTERs are
+    idempotent (duplicate-column tolerated). Arms the SHARED
+    conversation_sessions_backfill_pending flag so the next sync_cache full
+    recompute fills the new columns via the augmented
+    _recompute_conversation_sessions — keeping the heavy per-session assemble
+    (cache_rebuild_count) off the migration's critical path, mirroring 013.
+    Central stamp via the dispatcher (#140); handler does NOT self-stamp.
+
+    A fresh install gets the three columns from _apply_cache_schema's CREATE
+    TABLE and stamps 015 WITHOUT running this handler — the ALTERs no-op there
+    (already present), and the empty rollup needs no backfill (the incremental
+    DELETE+INSERT re-derive fills all columns in lockstep). Mirrors 013."""
+    for ddl in (
+        "ALTER TABLE conversation_sessions ADD COLUMN project_label TEXT",
+        "ALTER TABLE conversation_sessions ADD COLUMN cost_usd REAL NOT NULL DEFAULT 0",
+        "ALTER TABLE conversation_sessions ADD COLUMN cache_rebuild_count INTEGER NOT NULL DEFAULT 0",
+    ):
+        try:
+            conn.execute(ddl)
+        except sqlite3.OperationalError:
+            pass  # idempotent: column already present
+    _set_cache_meta(conn, "conversation_sessions_backfill_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

@@ -263,12 +263,51 @@ def parse_message_row(obj, offset):
     populated by a separate second seek-and-walk over the same byte span."""
     t = obj.get("type")
     if t not in ("user", "assistant"):
-        return None
+        # A message typed while the agent (the main session OR a subagent) is
+        # still working is QUEUED and persisted as an ``attachment`` row, never a
+        # ``type:"user"`` turn — so the user/assistant gate above would drop it and
+        # it would never reach conversation_messages (the reader bug). Promote the
+        # user-typed ones here; everything else stays dropped.
+        return _queued_prompt_row(obj, t, offset)
     if not obj.get("uuid"):
         return None
     return _normalize(obj, t, offset)
 
 
+def _queued_prompt_row(obj, t, offset):
+    """A queued user prompt -> a synthetic HUMAN ``MessageRow``, else ``None``.
+
+    Claude Code persists a message typed while the agent is busy as
+    ``{"type":"attachment","attachment":{"type":"queued_command",
+    "commandMode":"prompt","prompt":<text>}}`` — carrying its OWN
+    uuid/parentUuid/timestamp, with the text in ``attachment.prompt`` rather than
+    ``message.content``. Only ``commandMode=="prompt"`` is promoted: a queued
+    ``task-notification`` (``commandMode=="task-notification"``) is harness-injected
+    background plumbing — the same ``<task-notification>`` content already
+    classifies META when it arrives as a regular line — not something the user
+    typed, so it stays dropped."""
+    if t != "attachment" or not obj.get("uuid"):
+        return None
+    att = obj.get("attachment")
+    if not isinstance(att, dict) or att.get("type") != "queued_command":
+        return None
+    if att.get("commandMode") != "prompt":
+        return None
+    prompt = att.get("prompt")
+    if not isinstance(prompt, str) or not prompt.strip():
+        return None
+    # Route a synthesized user message through _normalize so the queued prompt
+    # gets the SAME classification a typed turn would (HUMAN, the #188
+    # slash-command-args promotion, system-marker / notification folding, the
+    # remote-control prefix strip, and the split search-column derivation). Every
+    # top-level field (uuid / parentUuid / sessionId / timestamp / cwd / gitBranch
+    # / isSidechain) rides along on the shallow copy; _normalize keys off the ``t``
+    # arg, never ``obj["type"]``, so the "attachment" type is inert here.
+    synth = dict(obj)
+    synth["message"] = {"role": "user", "content": prompt}
+    return _normalize(synth, "user", offset)
+
+
 @dataclass
 class AiTitleRow:
     """Pure per-line AI-title record (no I/O). Parallels MessageRow but for the