cctally 1.37.0 → 1.37.1

package/CHANGELOG.md

@@ -5,6 +5,11 @@ 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

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"
@@ -288,45 +289,68 @@ 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 (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:
+    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."""
-    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
+    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):

package/bin/_lib_conversation_query.py

@@ -711,24 +711,37 @@ _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.
+    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."""
-    order = []
-    state = {}
+    threads = {}      # subagent_key -> {"order": [...], "state": {...}, "seen": bool}
 
-    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]
+    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:
@@ -741,30 +754,32 @@ def _fold_task_runs(items, task_link):
             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 ""}
+                    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":
-                        state.pop(tid, None)
-                    elif tid in state and status:
-                        state[tid]["status"] = status
+                        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:
-                    order = []
-                    state = {}
+                    th["seen"] = True
+                    th["order"] = []
+                    th["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()
+                        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):

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cctally",
-  "version": "1.37.0",
+  "version": "1.37.1",
   "description": "Claude Code usage tracker and local dashboard for Pro/Max subscription limits - weekly cost-per-percent trend, quota forecasts, threshold alerts. ccusage-compatible.",
   "homepage": "https://github.com/omrikais/cctally",
   "repository": {