cctally 1.31.1 → 1.33.0

package/CHANGELOG.md

@@ -5,6 +5,22 @@ based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [1.33.0] - 2026-06-11
+
+### Added
+- Dashboard conversation reader: URL deep-linking — selecting a conversation or landing a turn jump now reflects into the address-bar hash (`#/conversations/<id>/<turn>`), reloads and Back/Forward restore that state, and every conversation turn gains a permalink button that copies a link straight to that turn (local-first; the link only resolves for someone who can already reach your dashboard). Closes #169, #174.
+
+### Fixed
+- **The dashboard conversation reader now nests a skill's content inside its Skill tool call.** Previously a Skill invocation's loaded markdown body rendered as a separate collapsed "Skill content" pill below the assistant turn (visually detached from the Skill tool chip that produced it). The body now folds into the Skill tool chip itself as its expandable, rich-Markdown content (the redundant "Launching skill: <name>" line is dropped); SessionStart-injected skills, which have no Skill tool call, still render the standalone pill. 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).
+
+## [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

@@ -183,8 +183,8 @@ _CONV_INSERT_SQL = (
     "INSERT OR IGNORE INTO conversation_messages"
     "(session_id,uuid,parent_uuid,source_path,byte_offset,"
     " timestamp_utc,entry_type,text,blocks_json,model,msg_id,"
-    " req_id,cwd,git_branch,is_sidechain)"
-    " VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)"
+    " req_id,cwd,git_branch,is_sidechain,source_tool_use_id)"
+    " VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)"
 )
 
 
@@ -194,6 +194,7 @@ def _conv_row_tuple(m, path_str):
         m.session_id, m.uuid, m.parent_uuid, path_str, m.byte_offset,
         m.timestamp_utc, m.entry_type, m.text, m.blocks_json, m.model,
         m.msg_id, m.req_id, m.cwd, m.git_branch, m.is_sidechain,
+        m.source_tool_use_id,
     )
 
 
@@ -615,9 +616,17 @@ 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. Migration 006
+            # sets the DISTINCT conversation_source_tool_use_reingest_pending
+            # flag (to land source_tool_use_id); the same offset-0 walk re-derives
+            # it, so drop that flag here as well to avoid a redundant pass.
             conn.execute(
-                "DELETE FROM cache_meta WHERE key='conversation_reingest_pending'")
+                "DELETE FROM cache_meta WHERE key IN "
+                "('conversation_reingest_pending',"
+                " 'conversation_source_tool_use_reingest_pending')")
             conn.commit()
             eprint("[cache-sync] rebuild: cleared Claude cached entries")
 
@@ -666,11 +675,25 @@ 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). Migration 006 uses a DISTINCT
+            # flag ``conversation_source_tool_use_reingest_pending`` (NOT the
+            # shared one) to land the message-level ``source_tool_use_id`` — the
+            # shared flag also gates the kernel's 005 human-fallback, so re-arming
+            # it for 006 could misclassify a genuine human prompt during the
+            # pre-reingest window. We trigger the SAME clear + offset-0 backfill on
+            # EITHER flag and clear BOTH atomically here under the held flock.
             try:
                 _reingest = conn.execute(
-                    "SELECT 1 FROM cache_meta "
-                    "WHERE key='conversation_reingest_pending'"
+                    "SELECT 1 FROM cache_meta WHERE key IN "
+                    "('conversation_reingest_pending',"
+                    " 'conversation_source_tool_use_reingest_pending')"
                 ).fetchone() is not None
             except sqlite3.OperationalError:
                 _reingest = False
@@ -678,8 +701,9 @@ def sync_cache(
                 clear_conversation_messages(conn)
                 backfill_conversation_messages(conn)
                 conn.execute(
-                    "DELETE FROM cache_meta "
-                    "WHERE key='conversation_reingest_pending'"
+                    "DELETE FROM cache_meta WHERE key IN "
+                    "('conversation_reingest_pending',"
+                    " 'conversation_source_tool_use_reingest_pending')"
                 )
                 conn.commit()
 

package/bin/_cctally_db.py

@@ -2331,6 +2331,7 @@ def _apply_cache_schema(conn: sqlite3.Connection) -> None:
             cwd           TEXT,
             git_branch    TEXT,
             is_sidechain  INTEGER NOT NULL DEFAULT 0,
+            source_tool_use_id TEXT,
             UNIQUE(source_path, byte_offset)
         );
         CREATE INDEX IF NOT EXISTS idx_conv_session_ts
@@ -2383,6 +2384,11 @@ def _apply_cache_schema(conn: sqlite3.Connection) -> None:
     # populated lazily in sync_cache() / _ensure_session_files_row().
     add_column_if_missing(conn, "session_files", "session_id", "TEXT")
     add_column_if_missing(conn, "session_files", "project_path", "TEXT")
+    # Existing-DB guard for the skill-content fold link (cctally-dev
+    # skill-content-nesting): the message-level sourceToolUseID. Idempotent
+    # column-add (no marker, no version); cache migration 006 then re-ingests
+    # so the value actually lands on historical rows.
+    add_column_if_missing(conn, "conversation_messages", "source_tool_use_id", "TEXT")
     conn.execute(
         "CREATE INDEX IF NOT EXISTS idx_session_files_session_id "
         "ON session_files(session_id)"
@@ -3009,6 +3015,65 @@ 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()
+
+
+@cache_migration("006_conversation_reingest_source_tool_use_id")
+def _006_conversation_reingest_source_tool_use_id(conn: sqlite3.Connection) -> None:
+    """Flag-only re-ingest of conversation_messages so the message-level
+    ``sourceToolUseID`` lands on existing history as the new
+    ``source_tool_use_id`` column — the link the reader uses to fold a
+    Skill-invoked skill body into its Skill tool chip.
+
+    Sets a DISTINCT flag, ``conversation_source_tool_use_reingest_pending``,
+    NOT the shared ``conversation_reingest_pending``. The shared flag also gates
+    migration 005's read-time *human*-fallback (``_reingest_pending`` in the
+    query kernel); re-arming it here would re-enable that fallback after it was
+    consumed and could misclassify a genuine human prompt that happens to start
+    with the skill preamble as a collapsed skill pill during 006's pre-reingest
+    window. sync_cache consumes EITHER flag (clear + offset-0 backfill under the
+    cache.db.lock flock) and the offset-0 walk re-parses every JSONL through the
+    sourceToolUseID-aware parser, so the column lands with zero new consumption
+    code. A distinct ``schema_migrations`` marker is what triggers this reingest
+    on installs already at 005. 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_source_tool_use_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
 
@@ -33,6 +34,7 @@ class MessageRow:
     cwd: "str | None"
     git_branch: "str | None"
     is_sidechain: int
+    source_tool_use_id: "str | None" = None
 
 
 def iter_message_rows(fh, path_str):
@@ -91,11 +93,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"
@@ -114,6 +131,7 @@ def _normalize(obj, t, offset):
         cwd=obj.get("cwd"),
         git_branch=obj.get("gitBranch"),
         is_sidechain=1 if obj.get("isSidechain") else 0,
+        source_tool_use_id=obj.get("sourceToolUseID"),
     )
 
 
@@ -135,10 +153,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 +175,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
@@ -289,7 +377,8 @@ def get_conversation(conn, session_id, *, after=None, limit=500):
     # uuid, so the first occurrence in ascending order is canonical.
     raw = conn.execute(
         "SELECT id, uuid, timestamp_utc, entry_type, text, blocks_json, model, "
-        "       msg_id, req_id, is_sidechain, cwd, git_branch, source_path, parent_uuid "
+        "       msg_id, req_id, is_sidechain, cwd, git_branch, source_path, parent_uuid, "
+        "       source_tool_use_id "
         "FROM conversation_messages WHERE session_id=? "
         "ORDER BY timestamp_utc, id", (session_id,)).fetchall()
 
@@ -333,7 +422,7 @@ def get_conversation(conn, session_id, *, after=None, limit=500):
 
     for row in logical:
         (rid, u, ts, etype, text, blocks, model, msg_id, req_id,
-         is_sc, cwd, branch, source_path, parent_uuid) = row
+         is_sc, cwd, branch, source_path, parent_uuid, source_tool_use_id) = row
         if etype == "assistant" and msg_id is not None:
             key = (msg_id, req_id)
             idx = turn_index.get(key)
@@ -355,6 +444,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 +518,57 @@ 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
+
+    # ---- 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
+    # _source_tool_use_id). Resolve it against the SAME tooluse_index the Phase 2
+    # tool_result fold uses (ids unique per session; last-writer-wins). The index
+    # value is (item, block) holding the LIVE block dict — Phase 3 mutated that
+    # same dict in place to a `tool_call`, so block["skill_body"]=… mutates the
+    # live chip. On a hit: the body becomes the chip's expandable content
+    # (skill_body/skill_name), the trivial "Launching skill" result is dropped
+    # (result=None), the body uuid joins the owner's member_uuids (#160 jump
+    # anchor), and the standalone item is removed. NO hit (SessionStart skills;
+    # pre-006 NULL column; orphan id) -> the standalone pill stays. NULL-driven
+    # and flag-INDEPENDENT (it does NOT key on _reingest_pending). Runs before
+    # pagination so a match never depends on page boundaries.
+    _skill_drop = set()
+    for it in items:
+        if it.get("meta_kind") != "skill":
+            continue
+        stid = it.get("_source_tool_use_id")
+        if not stid:
+            continue
+        hit = tooluse_index.get(stid)
+        if hit is None:
+            continue
+        owner, block = hit
+        block["skill_body"] = it["text"]
+        block["skill_name"] = it.get("skill_name")
+        block["result"] = None
+        owner["member_uuids"].append(it["anchor"]["uuid"])
+        _skill_drop.add(id(it))
+    if _skill_drop:
+        items = [it for it in items if id(it) not in _skill_drop]
+
     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
@@ -416,6 +587,12 @@ def get_conversation(conn, session_id, *, after=None, limit=500):
             it.pop("_has_prose", None)
     header_cost = round(header_cost, 6)
 
+    # Strip the internal Phase-4b threading key from EVERY item (meta/human items
+    # carry it too, not just assistant turns) so it never surfaces in the public
+    # item JSON.
+    for it in items:
+        it.pop("_source_tool_use_id", None)
+
     # Cursor pagination over the item list (anchored to each item's canonical id).
     # A non-None `after` that matches no item's anchor (stale/deleted cursor)
     # yields an EMPTY page — never silently re-serves the head (M1).
@@ -436,6 +613,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 +638,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},
     }
 
@@ -497,6 +676,10 @@ def _build_turn(members):
         "parent_uuid": first[13],
         "_msg_id": first[7],
         "_req_id": first[8],
+        # Internal threading for the Phase 4b skill-body fold (analogous to
+        # _msg_id/_req_id); consumed + del'd before items are returned, never in
+        # the public JSON. Meaningful only on meta skill items, harmless here.
+        "_source_tool_use_id": first[14],
         "_has_prose": False,
     }
     _fold_fragment(item, first)
@@ -543,7 +726,7 @@ def _build_simple(row):
     internal _msg_id/_req_id keys, so the cost loop's KeyError path can never fire
     (I2). The model is preserved for assistant rows."""
     (rid, u, ts, etype, text, blocks, model, msg_id, req_id, is_sc, cwd, branch,
-     source_path, parent_uuid) = row
+     source_path, parent_uuid, source_tool_use_id) = row
     try:
         parsed = _json.loads(blocks or "[]")
     except (ValueError, TypeError):
@@ -558,6 +741,10 @@ def _build_simple(row):
         "is_sidechain": bool(is_sc),
         "subagent_key": _subagent_key(source_path),
         "parent_uuid": parent_uuid,
+        # Internal threading for the Phase 4b skill-body fold (consumed + del'd
+        # before return). Carried on every simple item; meaningful only on the
+        # meta skill body row.
+        "_source_tool_use_id": source_tool_use_id,
     }
     if etype == "assistant":
         item["model"] = model