cctally 1.36.0 → 1.37.1

package/CHANGELOG.md

@@ -5,6 +5,16 @@ based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [1.37.1] - 2026-06-11
+
+### Fixed
+- Conversation viewer: the `TaskCreate`/`TaskUpdate`/`TaskList` checklist card rendered an empty "0 / 0" for tasks created inside subagents. Subagent Task tools record their result as a plain string (`Task #N created successfully: …`) rather than the structured shape main-session tools use, so the reader couldn't recover the task ids; it now parses both shapes. The running checklist is also reconstructed per-subagent, so parallel subagents no longer bleed their tasks into one another's cards, and a Task run whose results can't be parsed now falls back to plain tool chips instead of a misleading empty card. Existing transcripts pick this up on the next `cache-sync --rebuild`.
+
+## [1.37.0] - 2026-06-11
+
+### Added
+- Conversation viewer: Claude Code's live to-do tools (`TaskCreate`/`TaskUpdate`/`TaskList`) now render as a single checklist card with a progress bar — the same card the retired `TodoWrite` used — reconstructed at read time from the create/update/delete stream so the task list evolves turn by turn, instead of separate raw JSON tool chips. Additive; the legacy `TodoWrite` path is unchanged and no database migration is required.
+
 ## [1.36.0] - 2026-06-11
 
 ### Added

package/bin/_lib_conversation.py

@@ -8,6 +8,7 @@ mid-write tail line. Spec §1, §2.
 """
 from __future__ import annotations
 import json
+import re
 from dataclasses import dataclass
 
 HUMAN = "human"
@@ -105,6 +106,7 @@ def _normalize(obj, t, offset):
         entry_type = TOOL_RESULT
         _attach_subagent_result(blocks, obj)   # #166: record-level toolUseResult
         _attach_ask_answers(blocks, obj)       # #177 S2: AskUserQuestion answers
+        _attach_task_meta(blocks, obj)         # task checklist identity
         # 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
@@ -287,6 +289,70 @@ def _attach_ask_answers(blocks, obj):
         results[0]["ask_annotations"] = bounded_anno
 
 
+# Subagent Task tools record toolUseResult=null and put the identity in the
+# human-readable result text instead; the id is the only thing the fold needs
+# from the result (subject/status come from the call input). Anchored to the
+# line start so unrelated output mentioning a task id mid-sentence never matches.
+# Shapes verified against real subagent transcripts (Claude Code 2.1.173).
+_TASK_CREATE_RESULT_RE = re.compile(r"^Task #(\d+) created\b")
+_TASK_UPDATE_RESULT_RE = re.compile(r"^Updated task #(\d+)\b")
+
+
+def _attach_task_meta(blocks, obj):
+    """Stash a Task* tool's record-level identity onto its single tool_result
+    block so the query-kernel fold has a robust id. Task ids are monotonic +
+    never reused, so the explicit id is the only stable fold key. Two result
+    shapes, both self-identifying off the single tool_result block:
+
+    Structured (MAIN-session Task tools) — toolUseResult carries the identity:
+      TaskCreate -> {"task": {"id": ...}}            -> block["task_id"]
+      TaskUpdate -> {"taskId": ...}                   -> block["task_id"]
+      TaskList   -> {"tasks": [{id,subject,status}]}  -> block["task_list"]
+
+    String-content (SUBAGENT Task tools) — toolUseResult is null and the id
+    lives in the result text ("Task #7 created successfully: ..." / "Updated
+    task #3 status"); we recover the id from block["text"]. Subagent-driven
+    workflows make this the dominant shape, so missing it left every subagent
+    Task run rendering as an empty "0 / 0" card.
+
+    Same exactly-one-result-block guard as _attach_subagent_result. Subjects
+    bounded through _bound_input.
+
+    The ``task.id`` (not ``task.task_id``) gate deliberately ignores the
+    look-alike local_bash spawn result {"task": {"task_id": ..., ...}}, which is
+    a different tool family and carries no checklist id."""
+    results = [b for b in blocks if b.get("kind") == "tool_result"]
+    if len(results) != 1:
+        return
+    block = results[0]
+    tur = obj.get("toolUseResult")
+    if isinstance(tur, dict):
+        task = tur.get("task")
+        if isinstance(task, dict) and task.get("id") is not None:
+            block["task_id"] = str(task["id"])
+            return
+        if tur.get("taskId") is not None:
+            block["task_id"] = str(tur["taskId"])
+            return
+        tasks = tur.get("tasks")
+        if isinstance(tasks, list):
+            snap = []
+            for t in tasks:
+                if not isinstance(t, dict) or t.get("id") is None:
+                    continue
+                bounded, _ = _bound_input({"subject": t.get("subject") or ""})
+                snap.append({"id": str(t["id"]),
+                             "subject": bounded.get("subject", ""),
+                             "status": t.get("status") or "pending"})
+            block["task_list"] = snap
+            return
+    # String-content fallback (subagent Task tools): no structured identity.
+    m = (_TASK_CREATE_RESULT_RE.match(block.get("text") or "")
+         or _TASK_UPDATE_RESULT_RE.match(block.get("text") or ""))
+    if m:
+        block["task_id"] = m.group(1)
+
+
 def _stringify(c):
     if isinstance(c, str):
         return c

package/bin/_lib_conversation_query.py

@@ -484,6 +484,7 @@ def get_conversation(conn, session_id, *, after=None, limit=500):
     spawn_kind = {}     # tool_use id -> subagent_type
     agent_link = {}     # tool_use id -> (agent_id, raw_meta)
     ask_link = {}       # tool_use id -> (answers, annotations)  (#177 S2)
+    task_link = {}      # tool_use id -> {"task_id", "task_list"}  (Task* checklist)
     for it in items:
         for b in it["blocks"]:
             k = b.get("kind")
@@ -500,6 +501,10 @@ def get_conversation(conn, session_id, *, after=None, limit=500):
                 anno = b.pop("ask_annotations", None)
                 if ans is not None and b.get("tool_use_id") is not None:
                     ask_link[b["tool_use_id"]] = (ans, anno)
+                tid_ = b.pop("task_id", None)               # Task* checklist
+                tlist_ = b.pop("task_list", None)
+                if b.get("tool_use_id") is not None and (tid_ is not None or tlist_ is not None):
+                    task_link[b["tool_use_id"]] = {"task_id": tid_, "task_list": tlist_}
     subagent_meta = {}
     for _tuid, _kind in spawn_kind.items():
         _link = agent_link.get(_tuid)
@@ -564,6 +569,9 @@ def get_conversation(conn, session_id, *, after=None, limit=500):
                         if link[1]:
                             b["annotations"] = link[1]
 
+    # ---- Phase 3b: fold the Task* op stream into per-run checklist snapshots ----
+    _fold_task_runs(items, task_link)
+
     # ---- 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
@@ -697,6 +705,83 @@ def get_conversation(conn, session_id, *, after=None, limit=500):
     }
 
 
+_TASK_TRIO = ("TaskCreate", "TaskUpdate", "TaskList")
+
+
+def _fold_task_runs(items, task_link):
+    """Reconstruct the running to-do list from the chronological Task* op stream
+    and stamp the resulting todos[] snapshot onto the FIRST tool_call of each
+    Task* run. Key on the explicit task id (never reused). `deleted` drops a
+    task; a TaskList result reseeds the whole snapshot.
+
+    Scoped PER subagent thread (``subagent_key``): the main session (key None)
+    and each subagent keep INDEPENDENT running checklists, so parallel subagents
+    with disjoint task-id ranges never bleed into one another's cards. Within a
+    thread, state still spans the whole session.
+
+    Degradation guard: a thread's run is stamped only once that thread has
+    recognized a real create/list (``seen``). A Task* run with no recognizable
+    create — a future result shape we don't parse, or pre-fix legacy rows —
+    leaves ``task_snapshot`` ABSENT, so the frontend falls back to generic chips
+    instead of a misleading empty "0 / 0" card.
+
+    Mirrors the ask_answers join: the parser stashed the record-level identity
+    onto the tool_result block, the Phase-1 sweep popped it into ``task_link``
+    keyed by tool_use_id, and this fold joins it back. The frontend stays a pure
+    todos[] renderer — all running-list state lives here."""
+    threads = {}      # subagent_key -> {"order": [...], "state": {...}, "seen": bool}
+
+    def snapshot(th):
+        st, order = th["state"], th["order"]
+        return [dict(content=st[i]["content"], status=st[i]["status"],
+                     **({"activeForm": st[i]["activeForm"]} if st[i].get("activeForm") else {}))
+                for i in order if i in st]
+
+    for it in items:
+        if it.get("kind") != "assistant":
+            continue
+        th = threads.setdefault(it.get("subagent_key"),
+                                {"order": [], "state": {}, "seen": False})
+        first_task_call = None
+        for b in it["blocks"]:
+            if b.get("kind") != "tool_call" or b.get("name") not in _TASK_TRIO:
+                continue
+            if first_task_call is None:
+                first_task_call = b
+            link = task_link.get(b.get("tool_use_id")) or {}
+            inp = b.get("input") if isinstance(b.get("input"), dict) else {}
+            name = b["name"]
+            if name == "TaskCreate":
+                tid = link.get("task_id")
+                if tid is not None:
+                    th["seen"] = True
+                    if tid not in th["state"]:
+                        th["order"].append(tid)
+                    th["state"][tid] = {"content": inp.get("subject") or "", "status": "pending",
+                                        "activeForm": inp.get("activeForm") or ""}
+            elif name == "TaskUpdate":
+                tid = str(inp.get("taskId")) if inp.get("taskId") is not None else link.get("task_id")
+                status = inp.get("status")
+                if tid is not None:
+                    if status == "deleted":
+                        th["state"].pop(tid, None)
+                    elif tid in th["state"] and status:
+                        th["state"][tid]["status"] = status
+            elif name == "TaskList":
+                snap = link.get("task_list")
+                if snap is not None:
+                    th["seen"] = True
+                    th["order"] = []
+                    th["state"] = {}
+                    for t in snap:
+                        tid = t["id"]
+                        th["order"].append(tid)
+                        th["state"][tid] = {"content": t.get("subject") or "",
+                                            "status": t.get("status") or "pending", "activeForm": ""}
+        if first_task_call is not None and th["seen"]:
+            first_task_call["task_snapshot"] = snapshot(th)
+
+
 def _latest(logical, col):
     """Most-recent non-null value in a column across the session (project/branch
     show the latest, matching the dashboard's session posture)."""