cctally 1.31.1 → 1.32.0

package/CHANGELOG.md

@@ -5,6 +5,14 @@ based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [1.32.0] - 2026-06-10
+
+### Added
+- Conversation reader: subagent thread cards now show the subagent's kind (`SUBAGENT · <kind>`) and its result meta (tokens, duration, tool count, status) on modern transcripts; old transcripts keep the title-only card (#166).
+
+### Fixed
+- **The dashboard conversation reader no longer attributes injected content to you.** When an assistant turn invoked a skill (via the `Skill` tool), the skill's full markdown body rendered as a large **"You"** prompt, as if you had typed the entire skill into the conversation — and the same applied to other harness-injected (`isMeta`) lines (git-context blocks, "Continue from where you left off.", pasted-image placeholders, slash-command plumbing). These now render as quiet, collapsed-by-default disclosures attributed correctly: a skill body becomes a `Skill content · <name>` pill (still rendered with full Markdown — headings, lists, syntax-highlighted code — when expanded), and other injected content becomes a neutral `Injected context` pill. Nothing injected is ever shown as a "You" turn, and these bodies no longer pollute conversation titles or full-text search. The fix lands on existing history automatically the next time the dashboard syncs the conversation cache (a one-time re-ingest); the cache is re-derivable, so nothing is lost.
+
 ## [1.31.1] - 2026-06-09
 
 ### Added

package/bin/_cctally_cache.py

@@ -615,7 +615,10 @@ def sync_cache(
             # Issue #164: a rebuild also clears + repopulates the message index
             # id-aware via the normal offset-0 walk, so drop the 003 reingest
             # flag too — the post-rebuild sync must not run a redundant
-            # (idempotent but wasteful) clear+backfill pass.
+            # (idempotent but wasteful) clear+backfill pass. #166 migration 004
+            # also sets this same flag (to land the subagent kind/meta fields);
+            # the rebuild re-derives those fields via the same offset-0 walk, so
+            # dropping the flag here covers the 004 reingest too.
             conn.execute(
                 "DELETE FROM cache_meta WHERE key='conversation_reingest_pending'")
             conn.commit()
@@ -666,7 +669,14 @@ def sync_cache(
             # storm-free (#138); the offset-0 backfill walks every JSONL from 0;
             # the flag is dropped LAST so a crash mid-walk re-runs cleanly on the
             # next sync. Never on the rebuild path (which already wipes +
-            # repopulates the index id-aware via the normal walk).
+            # repopulates the index id-aware via the normal walk). #166 migration
+            # 004 reuses this SAME flag (to land the spawn subagent_type + the
+            # record-level toolUseResult agentId/meta on existing history): the
+            # offset-0 backfill re-parses every JSONL through the current parser,
+            # so those fields land here with zero new consumption code. Migration
+            # 005 reuses it again to reclassify injected isMeta rows from
+            # entry_type='human' to 'meta' (so the reader stops attributing skill
+            # bodies / git-context to the user).
             try:
                 _reingest = conn.execute(
                     "SELECT 1 FROM cache_meta "

package/bin/_cctally_db.py

@@ -3009,6 +3009,41 @@ def _003_conversation_reingest_tool_ids(conn: sqlite3.Connection) -> None:
     conn.commit()
 
 
+@cache_migration("004_conversation_reingest_subagent_kind")
+def _004_conversation_reingest_subagent_kind(conn: sqlite3.Connection) -> None:
+    """Flag-only re-ingest of conversation_messages so the spawn ``subagent_type``
+    and the record-level ``toolUseResult`` agentId/meta land on existing history
+    (#166). REUSES 003's ``conversation_reingest_pending`` flag — sync_cache
+    already consumes it (clear + offset-0 backfill under the cache.db.lock flock),
+    and the offset-0 walk re-parses every JSONL through the current parser, so the
+    new fields land with zero new consumption code. A distinct ``schema_migrations``
+    marker is what triggers this reingest on an existing install that already has
+    003 applied; the flag is the generic 'conversation index needs a full
+    clear+reingest' signal. Central stamp via the dispatcher (issue #140); a fresh
+    install stamps it without running (empty table -> the flag, if ever set, is a
+    harmless no-op)."""
+    _set_cache_meta(conn, "conversation_reingest_pending", "1")
+    conn.commit()
+
+
+@cache_migration("005_conversation_reingest_meta")
+def _005_conversation_reingest_meta(conn: sqlite3.Connection) -> None:
+    """Flag-only re-ingest of conversation_messages so injected ``isMeta`` user
+    lines (skill bodies, git-context, "Continue…", image placeholders,
+    slash-command caveats) are reclassified from ``entry_type='human'`` to the
+    new ``'meta'`` value and stop rendering as "YOU" prompts in the reader.
+    REUSES 003's ``conversation_reingest_pending`` flag exactly like 004 — the
+    offset-0 walk in sync_cache (clear + backfill under the cache.db.lock flock)
+    re-parses every JSONL through the now-meta-aware parser, so the new
+    classification lands with zero new consumption code. A distinct
+    ``schema_migrations`` marker is what triggers this reingest on installs that
+    already have 003/004 applied. Central stamp via the dispatcher (issue #140);
+    a fresh install stamps it without running (empty table -> the flag, if ever
+    set, is a harmless no-op)."""
+    _set_cache_meta(conn, "conversation_reingest_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

@@ -13,6 +13,7 @@ from dataclasses import dataclass
 HUMAN = "human"
 ASSISTANT = "assistant"
 TOOL_RESULT = "tool_result"
+META = "meta"
 
 _TOOL_RESULT_CAP = 4000  # chars; full text always re-derivable from JSONL
 
@@ -91,11 +92,26 @@ def _normalize(obj, t, offset):
         entry_type = ASSISTANT
     elif any(b["kind"] == "tool_result" for b in blocks):
         entry_type = TOOL_RESULT
+        _attach_subagent_result(blocks, obj)   # #166: record-level toolUseResult
         # tool_result rows are stored but NOT indexed as prose (spec §2). A
         # user line that mixes a text block with a tool_result block must not
         # leak that text into the FTS index; the full content stays in
         # blocks_json for rendering.
         text = ""
+    elif obj.get("isMeta"):
+        # Injected, harness-authored content carried as a user line: skill
+        # bodies (Skill tool + SessionStart), git-context blocks, "Continue
+        # from where you left off.", pasted-image placeholders, slash-command
+        # caveats, check-review "## Task" blocks. The user did NOT type these,
+        # so the reader must not render them as a "YOU" prompt. We classify
+        # them META here; text="" keeps the body out of the FTS index and out
+        # of title derivation (which filters entry_type='human'), exactly like
+        # tool_result. The body survives in blocks_json; the skill-vs-context
+        # discrimination is a read-time concern (the query kernel, keyed on the
+        # body). Ordered AFTER tool_result so an isMeta line that also carries a
+        # tool_result block still folds as a result.
+        entry_type = META
+        text = ""
     else:
         entry_type = HUMAN
     is_asst = t == "assistant"
@@ -135,10 +151,15 @@ def _blocks_and_text(content):
             elif bt == "thinking":
                 blocks.append({"kind": "thinking", "text": b.get("thinking", "") or ""})
             elif bt == "tool_use":
-                blocks.append({"kind": "tool_use", "name": b.get("name"),
-                               "input_summary": _summarize(b.get("input")),
-                               "id": b.get("id"),
-                               "preview": tool_preview(b.get("name"), b.get("input"))})
+                block = {"kind": "tool_use", "name": b.get("name"),
+                         "input_summary": _summarize(b.get("input")),
+                         "id": b.get("id"),
+                         "preview": tool_preview(b.get("name"), b.get("input"))}
+                inp = b.get("input")
+                st = inp.get("subagent_type") if isinstance(inp, dict) else None
+                if isinstance(st, str) and st:        # #166: spawn kind (Agent/Task)
+                    block["subagent_type"] = st
+                blocks.append(block)
             elif bt == "tool_result":
                 raw = _stringify(b.get("content"))
                 blocks.append({"kind": "tool_result", "text": raw[:_TOOL_RESULT_CAP],
@@ -152,6 +173,43 @@ def _blocks_and_text(content):
     return blocks, "\n".join(t for t in texts if t)
 
 
+_SUBAGENT_META_KEYS = (
+    ("totalTokens", "total_tokens"),
+    ("totalDurationMs", "total_duration_ms"),
+    ("totalToolUseCount", "total_tool_use_count"),
+    ("status", "status"),
+)
+
+
+def _attach_subagent_result(blocks, obj):
+    """Attach the record-level ``toolUseResult`` agentId + meta (#166) onto the
+    tool_result block, but ONLY when the record carries exactly one tool_result
+    block — the unambiguous subagent-spawn result shape. Zero or >1 tool_result
+    blocks: no-op (the kernel then degrades that subagent card to title-only).
+    The kind (subagent_type) is captured separately on the spawn tool_use block;
+    the kernel joins the two on tool_use_id. ``agentId`` == the subagent file's
+    ``_subagent_key``. Meta keys are normalized to snake_case here so the kernel
+    stays a pure pass-through (same posture as is_error / tool_use_id)."""
+    tur = obj.get("toolUseResult")
+    if not isinstance(tur, dict):
+        return
+    agent_id = tur.get("agentId")
+    if not isinstance(agent_id, str) or not agent_id:
+        return
+    results = [b for b in blocks if b.get("kind") == "tool_result"]
+    if len(results) != 1:
+        return
+    block = results[0]
+    block["agent_id"] = agent_id
+    meta = {}
+    for src, dst in _SUBAGENT_META_KEYS:
+        v = tur.get(src)
+        if v is not None:
+            meta[dst] = v
+    if meta:
+        block["subagent_meta"] = meta
+
+
 def _stringify(c):
     if isinstance(c, str):
         return c

package/bin/_lib_conversation_query.py

@@ -55,6 +55,84 @@ def _title_from_text(text) -> str:
     return ""
 
 
+# Every Claude Code skill body (Skill-tool-invoked AND SessionStart-injected)
+# opens with this preamble line — the entry_type-independent skill discriminator.
+_SKILL_PREAMBLE = "Base directory for this skill:"
+
+
+def _first_nonblank_line(text) -> str:
+    """First non-blank, stripped line of `text` ('' if none). Skill detection
+    keys on this (NOT a strict body.startswith) so a leading blank text block
+    can't hide the preamble (Codex P2.2)."""
+    for line in (text or "").split("\n"):
+        s = line.strip()
+        if s:
+            return s
+    return ""
+
+
+def _skill_name_from_preamble(first_line) -> "str | None":
+    """`brainstorming` from `Base directory for this skill: …/skills/brainstorming`.
+    Basename of the path after the first ':'; None on an empty/degenerate path
+    (Codex P2.2) so the client renders a name-less 'Skill content' rather than a
+    dangling separator."""
+    _, _, rest = first_line.partition(":")
+    path = rest.strip().rstrip("/")
+    return os.path.basename(path) or None if path else None
+
+
+def _join_text_blocks(blocks) -> str:
+    """Rejoin a row's text-block bodies the way the parser's _blocks_and_text did
+    ('\\n'-joined). A true meta row carries text='' (parser) with the body here in
+    blocks; a not-yet-reingested human row carries the body in its text column —
+    _meta_classify reads whichever is populated."""
+    if not blocks:
+        return ""
+    return "\n".join(b.get("text", "") or "" for b in blocks if b.get("kind") == "text")
+
+
+def _reingest_pending(conn) -> bool:
+    """True iff migration 005's ``conversation_reingest_pending`` flag is still
+    set — i.e. existing history has NOT yet been re-ingested under the meta-aware
+    parser. While pending, a stale ``human`` row may actually be an injected
+    skill body, so the read-time skill fallback (rendering + title-skip) is
+    active. Once sync consumes the flag (skill bodies become true ``meta`` rows),
+    the fallback turns OFF — so a genuine human prompt that merely *starts with*
+    the skill preamble is never misclassified as a collapsed skill pill (Codex
+    code-review P1). Missing table / degraded DB -> treated as not pending."""
+    try:
+        return conn.execute(
+            "SELECT 1 FROM cache_meta WHERE key='conversation_reingest_pending'"
+        ).fetchone() is not None
+    except sqlite3.OperationalError:
+        return False
+
+
+def _meta_classify(item, allow_human_fallback):
+    """Classify an injected item by its BODY, returning ``(meta_kind, skill_name,
+    body)`` or ``None`` to leave it a genuine human turn.
+
+    - skill: first non-blank line is the skill preamble. Fires for a true 'meta'
+      row ALWAYS; for a 'human' row ONLY when ``allow_human_fallback`` is set (the
+      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
+      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)
+    if not is_meta:
+        return None
+    if _is_system_marker(body):
+        return ("command", None, body)
+    return ("context", None, body)
+
+
 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
@@ -68,6 +146,14 @@ def _session_titles_map(conn, session_ids):
     if not session_ids:
         return {}
     titles = {}
+    # While 005's reingest is pending, a stale `human` row may actually be an
+    # injected skill body (a SessionStart skill can even lead the transcript) —
+    # skip those as title candidates so the rail never shows "Base directory for
+    # this skill: …" until the next sync reclassifies them to `meta` (which the
+    # entry_type='human' filter below then excludes). Gated on the flag for the
+    # same reason as the render fallback: a genuine post-reingest human prompt
+    # starting with the preamble stays a normal title (Codex code-review P2).
+    skip_skill_titles = _reingest_pending(conn)
     ph = ",".join("?" for _ in session_ids)
     rows = conn.execute(
         "SELECT session_id, text FROM ("
@@ -85,6 +171,8 @@ def _session_titles_map(conn, session_ids):
             continue                 # already resolved to the first non-marker
         if _is_system_marker(text):
             continue
+        if skip_skill_titles and _first_nonblank_line(text).startswith(_SKILL_PREAMBLE):
+            continue
         t = _title_from_text(text)
         if t:
             titles[sid] = t
@@ -355,6 +443,37 @@ def get_conversation(conn, session_id, *, after=None, limit=500):
             if etype == "assistant":             # null-msg_id assistant: index its uses too
                 _index_tool_uses(it)
 
+    # ---- Subagent-kind correlation (#166); MUST run before Phase 2 fold ----
+    # Reads AND strips (pop) the parser-only keys in one pass, so the returned
+    # tool_call/tool_result block shapes are unchanged — the only new output is
+    # the top-level subagent_meta map (no undocumented block keys leak). Join is
+    # spawn tool_use id <-> tool_result tool_use_id; agent_id == subagent_key.
+    spawn_kind = {}     # tool_use id -> subagent_type
+    agent_link = {}     # tool_use id -> (agent_id, raw_meta)
+    for it in items:
+        for b in it["blocks"]:
+            k = b.get("kind")
+            if k == "tool_use":
+                st = b.pop("subagent_type", None)
+                if st and b.get("id") is not None:
+                    spawn_kind[b["id"]] = st
+            elif k == "tool_result":
+                aid = b.pop("agent_id", None)
+                meta = b.pop("subagent_meta", None)
+                if aid and b.get("tool_use_id") is not None:
+                    agent_link[b["tool_use_id"]] = (aid, meta or {})
+    subagent_meta = {}
+    for _tuid, _kind in spawn_kind.items():
+        _link = agent_link.get(_tuid)
+        if _link is None:
+            continue                       # spawn with no (yet) result -> title-only
+        _aid, _raw = _link
+        _entry = {"kind": _kind}
+        for _f in ("total_tokens", "total_duration_ms", "total_tool_use_count", "status"):
+            if _raw.get(_f) is not None:
+                _entry[_f] = _raw[_f]
+        subagent_meta[_aid] = _entry       # agent_id == subagent_key
+
     # ---- Phase 2: fold each tool_result item into its owning assistant item ----
     drop = set()                                 # id() of folded placeholder items
     for tr in tool_result_items:
@@ -398,6 +517,24 @@ def get_conversation(conn, session_id, *, after=None, limit=500):
                     b["tool_use_id"] = b.pop("id", None)
                     b.setdefault("result", None)
 
+    # ---- Phase 4: classify injected meta items (skill / command / context) ----
+    # `meta` rows (the parser's isMeta classification) AND — only while the 005
+    # reingest is still pending — not-yet-reingested `human` rows whose body is a
+    # skill preamble (the read-time fallback) become kind='meta' with a meta_kind
+    # + skill_name, so the client renders a collapsed skill/system-marker/context
+    # disclosure instead of a "YOU" prompt. `text` is set to the rendered body
+    # (the DB text column stays '' for FTS); genuine human turns are untouched.
+    allow_human_fallback = _reingest_pending(conn)
+    for it in items:
+        if it["kind"] in ("meta", "human"):
+            cls = _meta_classify(it, allow_human_fallback)
+            if cls is not None:
+                meta_kind, skill_name, body = cls
+                it["kind"] = "meta"
+                it["meta_kind"] = meta_kind
+                it["skill_name"] = skill_name
+                it["text"] = body
+
     costs = _turn_cost_map(conn, list(turn_index))
     # Stamp per-item cost first, then derive the header from the SUM of the
     # ROUNDED per-item assistant costs (M2) — so the §6.5 invariant
@@ -436,6 +573,7 @@ def get_conversation(conn, session_id, *, after=None, limit=500):
                 "cost_usd": header_cost,
                 "models": sorted({r[6] for r in logical if r[6]}),
                 "items": [],
+                "subagent_meta": subagent_meta,
                 "page": {"next_after": None, "has_more": False},
             }
     page = items[start:start + limit]
@@ -460,6 +598,7 @@ def get_conversation(conn, session_id, *, after=None, limit=500):
         "cost_usd": header_cost,
         "models": models,
         "items": page,
+        "subagent_meta": subagent_meta,
         "page": {"next_after": next_after, "has_more": has_more},
     }