cctally 1.36.0 → 1.37.0

package/CHANGELOG.md

@@ -5,6 +5,11 @@ based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [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

@@ -105,6 +105,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 +288,47 @@ def _attach_ask_answers(blocks, obj):
         results[0]["ask_annotations"] = bounded_anno
 
 
+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 (NOT a result-string parse).
+    Task ids are monotonic + never reused, so the explicit id is the only stable
+    fold key. Self-identifying by toolUseResult shape:
+      TaskCreate -> {"task": {"id": ...}}            -> block["task_id"]
+      TaskUpdate -> {"taskId": ...}                   -> block["task_id"]
+      TaskList   -> {"tasks": [{id,subject,status}]}  -> block["task_list"]
+    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."""
+    tur = obj.get("toolUseResult")
+    if not isinstance(tur, dict):
+        return
+    results = [b for b in blocks if b.get("kind") == "tool_result"]
+    if len(results) != 1:
+        return
+    block = results[0]
+    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
+
+
 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,68 @@ 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. State spans the whole session; key on the explicit task id (never
+    reused). `deleted` drops a task; a TaskList result reseeds the whole snapshot.
+
+    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."""
+    order = []
+    state = {}
+
+    def snapshot():
+        return [dict(content=state[i]["content"], status=state[i]["status"],
+                     **({"activeForm": state[i]["activeForm"]} if state[i].get("activeForm") else {}))
+                for i in order if i in state]
+
+    for it in items:
+        if it.get("kind") != "assistant":
+            continue
+        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:
+                    if tid not in state:
+                        order.append(tid)
+                    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":
+                        state.pop(tid, None)
+                    elif tid in state and status:
+                        state[tid]["status"] = status
+            elif name == "TaskList":
+                snap = link.get("task_list")
+                if snap is not None:
+                    order = []
+                    state = {}
+                    for t in snap:
+                        tid = t["id"]
+                        order.append(tid)
+                        state[tid] = {"content": t.get("subject") or "",
+                                      "status": t.get("status") or "pending", "activeForm": ""}
+        if first_task_call is not None:
+            first_task_call["task_snapshot"] = snapshot()
+
+
 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)."""