prizmkit 1.1.119 → 1.1.121

package/bundled/dev-pipeline/scripts/parse-stream-progress.py

@@ -15,6 +15,7 @@ The script runs until:
 """
 
 import argparse
+import hashlib
 import json
 import os
 import re
@@ -169,6 +170,34 @@ def detect_api_error_code(text, require_error_context=False, structured_code=Fal
     return ""
 
 
+TERMINAL_SUBAGENT_STATUSES = {
+    "completed",
+    "failed",
+    "cancelled",
+    "canceled",
+    "killed",
+    "stopped",
+    "success",
+    "error",
+}
+
+
+def _stable_subagent_digest(*parts):
+    """Return a short stable digest for provider events without durable ids."""
+    canonical = json.dumps(parts, ensure_ascii=False, sort_keys=True, default=str)
+    return hashlib.sha1(canonical.encode("utf-8")).hexdigest()[:16]
+
+
+def _normalize_status(status, default="unknown"):
+    """Normalize provider status values while preserving provider-specific names."""
+    text = str(status or "").strip().lower()
+    if not text:
+        return default
+    if text == "cancelled":
+        return "canceled"
+    return text
+
+
 class ProgressTracker:
     """Tracks progress state from stream-json events."""
 
@@ -195,6 +224,11 @@ class ProgressTracker:
         self.active_subagent_count = 0
         self.subagent_status_counts = Counter()
         self._subagent_spawn_count = 0
+        self.subagent_records = {}
+        self.subagent_aliases = {}
+        self.subagent_source_providers = set()
+        self.subagent_source_events = Counter()
+        self.parent_subagent_activity_ids = set()
         self.codex_child_thread_ids = set()
         self.cb_session_id = ""
         self.result_subtype = ""
@@ -219,6 +253,7 @@ class ProgressTracker:
         self._text_buffer = ""
         self._in_tool_use = False
         self._current_tool_input_parts = []
+        self._current_tool_id = ""
 
     def process_event(self, event):
         """Process a single stream-json event and update state.
@@ -236,6 +271,22 @@ class ProgressTracker:
             self.event_type_counts[str(event_type)] += 1
         self._detect_structured_terminal_fields(event)
         self._record_usage_and_permission_metadata(event)
+        parent_tool_use_id = event.get("parent_tool_use_id")
+        if isinstance(parent_tool_use_id, str) and parent_tool_use_id.strip():
+            parent_tool_use_id = parent_tool_use_id.strip()
+            self.parent_subagent_activity_ids.add(parent_tool_use_id)
+            self._record_subagent_event(
+                "claude",
+                "parent_tool_use_id",
+                identifier=parent_tool_use_id,
+                aliases=[parent_tool_use_id],
+                status="running",
+                active=True,
+                spawn=False,
+                metadata={"parent_tool_use_id": parent_tool_use_id},
+            )
+
+        self._record_structured_subagent_metadata(event)
 
         # ── Codex exec --json JSONL format ──────────────────────────
         if event_type in (
@@ -260,9 +311,6 @@ class ProgressTracker:
 
                 elif item_type == "collab_tool_call":
                     tool_name = item.get("tool", "collab")
-                    self._record_codex_child_thread_ids(
-                        item.get("receiver_thread_ids")
-                    )
                     if event_type == "item.started":
                         self.current_tool = tool_name
                         self.tool_call_counts[tool_name] += 1
@@ -270,9 +318,6 @@ class ProgressTracker:
                     elif item.get("status") == "completed":
                         self.current_tool = None
                     self._extract_tool_summary_from_dict(item)
-                    self._update_subagent_status_counts(
-                        item.get("agents_states", {})
-                    )
 
                     prompt = item.get("prompt")
                     if prompt:
@@ -346,8 +391,13 @@ class ProgressTracker:
                                 json.dumps(tool_input, ensure_ascii=False)[:500]
                             )
                             # Track CodeBuddy Agent/Task tool invocations as
-                            # potential sub-agent spawns (Gap 3 fix).
-                            self._record_cb_agent_tool_call(tool_name, tool_input)
+                            # session-log authoritative sub-agent spawns.
+                            self._record_cb_agent_tool_call(
+                                tool_name,
+                                tool_input,
+                                event_id=str(block.get("id") or block.get("tool_use_id") or block.get("call_id") or ""),
+                                source_event="message.tool_use",
+                            )
                         elif block_type == "text":
                             text = block.get("text", "")
                             if text.strip():
@@ -378,8 +428,13 @@ class ProgressTracker:
                 if isinstance(raw_args, str) and raw_args.strip():
                     self._extract_tool_summary(raw_args)
                     self._detect_phase(raw_args[:500])
-                    # Track Agent/Task tool invocations as sub-agent spawns
-                    self._record_cb_agent_tool_call(tool_name, raw_args)
+                    # Track Agent/Task tool invocations as session-log sub-agent spawns.
+                    self._record_cb_agent_tool_call(
+                        tool_name,
+                        raw_args,
+                        event_id=str(event.get("id") or event.get("call_id") or event.get("callId") or ""),
+                        source_event="function_call",
+                    )
             elif event_type == "function_call_result":
                 self.current_tool = None
                 # Check result text for phase / error hints
@@ -411,6 +466,13 @@ class ProgressTracker:
                     if isinstance(tool_input, dict):
                         self._extract_tool_summary_from_dict(tool_input)
                     self._detect_phase(json.dumps(tool_input, ensure_ascii=False)[:500])
+                    self._record_agent_tool_call(
+                        "claude",
+                        tool_name,
+                        tool_input,
+                        source_event="assistant.tool_use",
+                        event_id=str(block.get("id") or block.get("tool_use_id") or ""),
+                    )
                 elif block_type == "text":
                     text = block.get("text", "")
                     if text.strip():
@@ -572,6 +634,7 @@ class ProgressTracker:
             self.current_tool_input_summary = ""
             self._in_tool_use = False
             self._current_tool_input_parts = []
+            self._current_tool_id = ""
 
         elif event_type == "content_block_start":
             content_block = event.get("content_block", {})
@@ -585,10 +648,12 @@ class ProgressTracker:
                 self.total_tool_calls += 1
                 self._in_tool_use = True
                 self._current_tool_input_parts = []
+                self._current_tool_id = str(content_block.get("id") or content_block.get("tool_use_id") or "")
 
             elif block_type == "text":
                 self._text_buffer = ""
                 self._in_tool_use = False
+                self._current_tool_id = ""
 
         elif event_type == "content_block_delta":
             delta = event.get("delta", {})
@@ -618,6 +683,13 @@ class ProgressTracker:
                 full_input = "".join(self._current_tool_input_parts)
                 self._extract_tool_summary(full_input)
                 self._detect_phase(full_input)
+                self._record_agent_tool_call(
+                    "claude",
+                    self.current_tool,
+                    full_input,
+                    source_event="content_block.tool_use",
+                    event_id=self._current_tool_id,
+                )
             else:
                 # Text block finished - detect phase and terminal errors from accumulated text
                 if self._text_buffer:
@@ -628,6 +700,7 @@ class ProgressTracker:
                     )
             self._in_tool_use = False
             self._current_tool_input_parts = []
+            self._current_tool_id = ""
 
         elif event_type == "error":
             self.event_format = self.event_format or "stream-json"
@@ -644,10 +717,173 @@ class ProgressTracker:
 
         # Check for subagent indicator
         if event.get("parent_tool_use_id"):
-            # This is a sub-agent event; tool name is still tracked normally
+            # Already recorded as child activity metadata near the top of process_event.
             pass
 
 
+    def _canonical_subagent_key(self, provider, identifier, aliases=()):
+        """Return the existing canonical key for any alias, otherwise a new key."""
+        provider = str(provider or "unknown").strip() or "unknown"
+        keys = []
+        if identifier:
+            keys.append(f"{provider}:{identifier}")
+        for alias in aliases or ():
+            if alias:
+                alias_text = str(alias).strip()
+                if alias_text:
+                    keys.append(f"{provider}:{alias_text}")
+        for key in keys:
+            canonical = self.subagent_aliases.get(key)
+            if canonical:
+                return canonical
+        return keys[0] if keys else f"{provider}:unknown:{len(self.subagent_records) + 1}"
+
+    def _record_subagent_event(
+        self,
+        provider,
+        source_event,
+        *,
+        identifier="",
+        aliases=(),
+        status="unknown",
+        active=None,
+        spawn=False,
+        metadata=None,
+    ):
+        """Record authoritative session-log-derived subagent statistics."""
+        provider = str(provider or "unknown").strip() or "unknown"
+        source_event = str(source_event or "unknown").strip() or "unknown"
+        identifier = str(identifier or "").strip()
+        alias_values = [str(alias).strip() for alias in aliases or () if str(alias or "").strip()]
+        canonical = self._canonical_subagent_key(provider, identifier, alias_values)
+        record = self.subagent_records.setdefault(
+            canonical,
+            {
+                "id": identifier or canonical.split(":", 1)[-1],
+                "provider": provider,
+                "source_events": set(),
+                "aliases": set(),
+                "status": "unknown",
+                "active": False,
+                "spawned": False,
+                "metadata": {},
+            },
+        )
+        for alias in [identifier, *alias_values]:
+            if alias:
+                alias_key = f"{provider}:{alias}"
+                self.subagent_aliases[alias_key] = canonical
+                record["aliases"].add(alias)
+        if identifier:
+            if not record.get("id") or str(record.get("id", "")).startswith("unknown:"):
+                record["id"] = identifier
+            record.setdefault("observed_ids", set()).add(identifier)
+        for alias in alias_values:
+            record.setdefault("observed_ids", set()).add(alias)
+        record["source_events"].add(source_event)
+        self.subagent_source_providers.add(provider)
+        self.subagent_source_events[f"{provider}:{source_event}"] += 1
+        existing_status = _normalize_status(record.get("status"), default="unknown")
+        normalized_status = _normalize_status(status, default=existing_status)
+        if (
+            source_event == "parent_tool_use_id"
+            and existing_status in TERMINAL_SUBAGENT_STATUSES
+        ):
+            normalized_status = existing_status
+            active = False
+        if normalized_status:
+            record["status"] = normalized_status
+        if active is None:
+            record["active"] = record["status"] not in TERMINAL_SUBAGENT_STATUSES
+        else:
+            record["active"] = bool(active)
+        if spawn:
+            record["spawned"] = True
+        if isinstance(metadata, dict):
+            for key, value in metadata.items():
+                if value not in (None, "", [], {}):
+                    record["metadata"][str(key)] = str(value)[:200]
+        self._refresh_normalized_subagent_totals()
+        return canonical
+
+    def _refresh_normalized_subagent_totals(self):
+        """Mirror normalized records into legacy progress fields."""
+        counts = Counter()
+        active = 0
+        spawned = 0
+        for record in self.subagent_records.values():
+            status = _normalize_status(record.get("status"), default="unknown")
+            counts[status] += 1
+            if bool(record.get("active")):
+                active += 1
+            if bool(record.get("spawned")):
+                spawned += 1
+        self.subagent_status_counts = counts
+        self.active_subagent_count = active
+        self._subagent_spawn_count = spawned
+
+    def _subagent_statistics(self):
+        """Return additive normalized subagent statistics for progress.json."""
+        records = []
+        for key, record in sorted(self.subagent_records.items()):
+            records.append(
+                {
+                    "key": key,
+                    "id": str(record.get("id") or ""),
+                    "provider": str(record.get("provider") or "unknown"),
+                    "status": _normalize_status(record.get("status"), default="unknown"),
+                    "active": bool(record.get("active")),
+                    "spawned": bool(record.get("spawned")),
+                    "source_events": sorted(record.get("source_events") or []),
+                    "aliases": sorted(record.get("aliases") or []),
+                    "observed_ids": sorted(record.get("observed_ids") or []),
+                    "metadata": dict(record.get("metadata") or {}),
+                }
+            )
+        observed_ids = []
+        for record in records:
+            identifier = record.get("id") or record.get("key")
+            if identifier:
+                observed_ids.append(str(identifier))
+            for observed in record.get("observed_ids") or []:
+                observed_ids.append(str(observed))
+        states = [
+            {"status": status, "count": count}
+            for status, count in self.subagent_status_counts.most_common()
+        ]
+        return {
+            "source": "session_log",
+            "providers": sorted(self.subagent_source_providers),
+            "spawned": self._subagent_spawn_count,
+            "active": self.active_subagent_count,
+            "status_counts": dict(self.subagent_status_counts),
+            "states": states,
+            "observed_ids": sorted(set(observed_ids)),
+            "source_events": dict(sorted(self.subagent_source_events.items())),
+            "parent_activity_ids": sorted(self.parent_subagent_activity_ids),
+            "records": records,
+            "child_activity_source": "filesystem_liveness_only",
+        }
+
+    def _record_structured_subagent_metadata(self, event):
+        """Extract provider-specific subagent metadata when fields appear anywhere."""
+        if not isinstance(event, dict):
+            return
+        receiver_ids = event.get("receiver_thread_ids")
+        if isinstance(receiver_ids, list):
+            self._record_codex_child_thread_ids(receiver_ids)
+        agents_states = event.get("agents_states")
+        if isinstance(agents_states, dict):
+            self._update_subagent_status_counts(agents_states)
+        item = event.get("item")
+        if isinstance(item, dict):
+            nested_receivers = item.get("receiver_thread_ids")
+            if isinstance(nested_receivers, list):
+                self._record_codex_child_thread_ids(nested_receivers)
+            nested_states = item.get("agents_states")
+            if isinstance(nested_states, dict):
+                self._update_subagent_status_counts(nested_states)
+
     def _record_usage_and_permission_metadata(self, event):
         """Record additive metadata required by Python runtime parity tests."""
         if not isinstance(event, dict):
@@ -740,42 +976,57 @@ class ProgressTracker:
         if not self.errors or self.errors[-1] != normalized_code:
             self.errors.append(normalized_code)
 
-    def _record_cb_agent_tool_call(self, tool_name, raw_args):
-        """Record a CodeBuddy Agent/Task* tool invocation for sub-agent tracking.
-
-        CodeBuddy spawns sub-agents via:
-        - Agent(prompt=..., run_in_background=True/False) — synchronous or bg fork
-        - TaskCreate(subject=..., description=...) — scheduled task
-
-        (TaskUpdate/TaskOutput exist but are lifecycle-only — they track
-        existing tasks rather than creating new sub-agents, so we don't
-        count them as spawns.)
-
-        We don't get child session ids from these tool calls in the stream,
-        but recording the count lets the heartbeat code in heartbeat.sh apply
-        an extended stale-kill window just as it does for Codex spawn_agent.
-        """
+    def _record_agent_tool_call(self, provider, tool_name, raw_args, *, source_event="tool_use", event_id=""):
+        """Record Agent/TaskCreate tool calls as session-log subagent spawns."""
         if tool_name not in ("Agent", "TaskCreate"):
             return
-        # Both dict (from message events) and str/JSON (from function_call events)
-        # are supported.
         if isinstance(raw_args, dict):
             args = raw_args
         elif isinstance(raw_args, str):
             try:
                 args = json.loads(raw_args)
             except (json.JSONDecodeError, TypeError):
-                return
+                args = {"raw_args": raw_args}
         else:
+            args = {}
+        if tool_name == "Agent" and not any(args.get(key) for key in ("subagent_type", "prompt", "description")):
             return
-        # For Agent tool, subagent_type or run_in_background hints at delegation
-        if tool_name == "Agent":
-            subagent_type = args.get("subagent_type", "")
-            prompt = args.get("prompt", "")
-            if subagent_type or prompt:
-                self._subagent_spawn_count += 1
-        elif tool_name == "TaskCreate":
-            self._subagent_spawn_count += 1
+        explicit_ids = []
+        for key in ("id", "tool_use_id", "call_id", "callId", "task_id", "taskId"):
+            value = args.get(key) if isinstance(args, dict) else None
+            if value:
+                explicit_ids.append(str(value))
+        if event_id:
+            explicit_ids.append(str(event_id))
+        fallback = _stable_subagent_digest(provider, tool_name, args)
+        identifier = explicit_ids[0] if explicit_ids else f"{tool_name}:{fallback}"
+        aliases = [*explicit_ids, f"{tool_name}:{fallback}"]
+        metadata = {
+            "tool": tool_name,
+            "subagent_type": args.get("subagent_type", "") if isinstance(args, dict) else "",
+            "description": args.get("description", "") if isinstance(args, dict) else "",
+            "run_in_background": args.get("run_in_background", "") if isinstance(args, dict) else "",
+        }
+        self._record_subagent_event(
+            provider,
+            source_event,
+            identifier=identifier,
+            aliases=aliases,
+            status="running",
+            active=True,
+            spawn=True,
+            metadata=metadata,
+        )
+
+    def _record_cb_agent_tool_call(self, tool_name, raw_args, *, event_id="", source_event="tool_use"):
+        """Record a CodeBuddy Agent/TaskCreate tool invocation for sub-agent tracking."""
+        self._record_agent_tool_call(
+            "codebuddy",
+            tool_name,
+            raw_args,
+            source_event=source_event,
+            event_id=event_id,
+        )
 
     def _record_terminal_result(self, text="", is_error=False, api_error_status=None, api_error_code="", stop_reason=""):
         """Record a Claude Code terminal result event."""
@@ -889,31 +1140,52 @@ class ProgressTracker:
                 self.current_tool_input_summary = str(data["prompt"])[:100]
 
     def _update_subagent_status_counts(self, agents_states):
-        """Track Codex subagent state counts from collab_tool_call items."""
-        counts = Counter()
-        active = 0
-        if isinstance(agents_states, dict):
-            for state in agents_states.values():
-                if not isinstance(state, dict):
-                    continue
-                status = str(state.get("status", "unknown"))
-                counts[status] += 1
-                if status not in ("completed", "failed", "cancelled", "canceled"):
-                    active += 1
-                message = state.get("message")
-                if message:
-                    self.last_text_snippet = str(message).strip()[:120]
-                    self._detect_phase(str(message))
-        self.subagent_status_counts = counts
-        self.active_subagent_count = active
+        """Track Codex subagent state counts from session-log collab items."""
+        if not isinstance(agents_states, dict):
+            return
+        for agent_id, state in agents_states.items():
+            if not isinstance(state, dict):
+                continue
+            status = _normalize_status(state.get("status"), default="unknown")
+            message = state.get("message")
+            if message:
+                self.last_text_snippet = str(message).strip()[:120]
+                self._detect_phase(str(message))
+            identifier = str(state.get("thread_id") or state.get("id") or agent_id or "")
+            aliases = [agent_id, state.get("thread_id", ""), state.get("id", "")]
+            self._record_subagent_event(
+                "codex",
+                "agents_states",
+                identifier=identifier,
+                aliases=aliases,
+                status=status,
+                active=status not in TERMINAL_SUBAGENT_STATUSES,
+                spawn=True,
+                metadata={
+                    "message": message or "",
+                    "name": state.get("name", ""),
+                    "role": state.get("role", ""),
+                },
+            )
 
     def _record_codex_child_thread_ids(self, thread_ids):
-        """Remember Codex child thread IDs reported by collab tool calls."""
+        """Remember Codex child thread IDs reported by session-log collab tool calls."""
         if not isinstance(thread_ids, list):
             return
         for thread_id in thread_ids:
             if isinstance(thread_id, str) and thread_id.strip():
-                self.codex_child_thread_ids.add(thread_id.strip())
+                thread_id = thread_id.strip()
+                self.codex_child_thread_ids.add(thread_id)
+                self._record_subagent_event(
+                    "codex",
+                    "receiver_thread_ids",
+                    identifier=thread_id,
+                    aliases=[thread_id],
+                    status="running",
+                    active=True,
+                    spawn=True,
+                    metadata={"thread_id": thread_id},
+                )
 
     def _codex_sessions_dir(self):
         """Return the Codex sessions directory for the current environment."""
@@ -970,32 +1242,30 @@ class ProgressTracker:
         )
 
     def _update_claude_subagent_status_counts(self):
-        """Track Claude Code in-process teammate task state counts."""
-        counts = Counter()
-        active = 0
-        inactive_statuses = {
-            "completed",
-            "failed",
-            "cancelled",
-            "canceled",
-            "killed",
-            "stopped",
-            "success",
-            "error",
-        }
-        for state in self.claude_task_states.values():
+        """Track Claude Code in-process teammate task state counts from session.log."""
+        for task_id, state in self.claude_task_states.items():
             if not self._is_tracked_claude_subagent_state(state):
                 continue
-            status = str(state.get("status") or "unknown")
-            counts[status] += 1
-            if status.lower() not in inactive_statuses:
-                active += 1
+            status = _normalize_status(state.get("status"), default="unknown")
             summary = state.get("summary") or state.get("subagent_type")
             if summary:
                 self.last_text_snippet = str(summary).strip()[:120]
                 self._detect_phase(str(summary))
-        self.subagent_status_counts = counts
-        self.active_subagent_count = active
+            self._record_subagent_event(
+                "claude",
+                "system.task",
+                identifier=str(task_id),
+                aliases=[state.get("tool_use_id", "")],
+                status=status,
+                active=status not in TERMINAL_SUBAGENT_STATUSES,
+                spawn=True,
+                metadata={
+                    "task_type": state.get("task_type", ""),
+                    "subagent_type": state.get("subagent_type", ""),
+                    "summary": state.get("summary", ""),
+                    "tool_use_id": state.get("tool_use_id", ""),
+                },
+            )
 
     def _claude_projects_dir(self):
         """Return the Claude Code projects directory for transcript lookup."""
@@ -1162,6 +1432,9 @@ class ProgressTracker:
             self._cb_child_session_files = self._find_cb_child_session_files()
             self._last_child_scan_at = now
 
+        # Filesystem scanning below is intentionally liveness-only.  The
+        # session-log-derived subagent_* fields are updated exclusively by
+        # process_event()/record helpers and are not inferred from file counts.
         files = []
         signature_parts = []
         total_bytes = 0
@@ -1229,6 +1502,7 @@ class ProgressTracker:
             {"status": status, "count": count}
             for status, count in self.subagent_status_counts.most_common()
         ]
+        subagent_stats = self._subagent_statistics()
         return {
             "updated_at": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
             "event_format": self.event_format,
@@ -1249,7 +1523,21 @@ class ProgressTracker:
             "active_subagent_count": self.active_subagent_count,
             "subagent_states": subagent_states,
             "subagent_spawn_count": self._subagent_spawn_count,
+            "subagent_stats_source": "session_log",
+            "subagent_provider": ",".join(subagent_stats["providers"]),
+            "subagent_observed_ids": subagent_stats["observed_ids"],
+            "subagent_source_metadata": {
+                "source": subagent_stats["source"],
+                "providers": subagent_stats["providers"],
+                "source_events": subagent_stats["source_events"],
+                "parent_activity_ids": subagent_stats["parent_activity_ids"],
+                "child_activity_source": subagent_stats["child_activity_source"],
+            },
+            "subagent_statistics": subagent_stats,
+            "child_activity_source": "filesystem_liveness_only",
             "child_thread_ids": sorted(self.codex_child_thread_ids),
+            # Filesystem child activity is a heartbeat liveness fallback only.
+            # Authoritative subagent counts/statuses above come from session.log.
             "child_session_files": self.child_session_files,
             "child_total_bytes": self.child_total_bytes,
             "child_activity_signature": self.child_activity_signature,