cctally 1.32.0 → 1.34.0

package/CHANGELOG.md

@@ -5,6 +5,24 @@ based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [1.34.0] - 2026-06-11
+
+### Added
+- Dashboard conversation reader: the open conversation now updates live — once you've paged to the end, new turns from an active session appear on each refresh tick with no manual reload, sticking to the newest turn if you're already at the bottom or surfacing a floating "↓ N new" pill (click to jump to the latest) if you've scrolled up. The cost and model totals update along with the new turns (#175).
+
+### Changed
+- Dashboard conversation reader: the loading state now shows an animated spinner instead of a static glyph (reduced-motion aware) (#175).
+- Dashboard conversation reader: long-turn headers — assistant/human turns, tool-result runs, and subagent groups — now pin to the top while you scroll inside them, and clicking an assistant/human turn header scrolls back to that turn's start (#175).
+- Dashboard conversation reader: the assistant model is now shown as a colored chip (matching the rest of the dashboard) instead of plain text; turns with no known model render no chip (#175).
+
+## [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

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,
     )
 
 
@@ -618,9 +619,14 @@ def sync_cache(
             # (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.
+            # 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")
 
@@ -676,11 +682,18 @@ def sync_cache(
             # 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).
+            # 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
@@ -688,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)"
@@ -3044,6 +3050,30 @@ def _005_conversation_reingest_meta(conn: sqlite3.Connection) -> None:
     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

@@ -34,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):
@@ -130,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"),
     )
 
 

package/bin/_lib_conversation_query.py

@@ -377,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()
 
@@ -421,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)
@@ -535,6 +536,39 @@ def get_conversation(conn, session_id, *, after=None, limit=500):
                 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
@@ -553,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).
@@ -636,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)
@@ -682,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):
@@ -697,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