prizmkit 1.1.99 → 1.1.101

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

@@ -1,1232 +0,0 @@
-#!/usr/bin/env python3
-"""
-parse-stream-progress.py - Real-time stream-json progress parser
-
-Continuously reads an AI CLI session log (JSONL from --output-format stream-json),
-extracts tool calls, phase changes, and activity metrics, and writes structured
-progress to a progress.json file for heartbeat monitoring.
-
-Usage:
-    python3 parse-stream-progress.py --session-log <path> --progress-file <path>
-
-The script runs until:
-  - The session log stops growing and the CLI process exits
-  - It receives SIGTERM/SIGINT
-"""
-
-import argparse
-import json
-import os
-import re
-import signal
-import sys
-import tempfile
-import time
-from collections import Counter
-from datetime import datetime, timezone
-from pathlib import Path
-
-
-# Ordered pipeline phases — index defines forward-only progression.
-# Phase detection is monotonic: once a phase is reached, earlier phases
-# cannot be re-entered (prevents false positives from file content mentions).
-PHASE_ORDER = ["plan", "implement", "code-review", "retrospective", "commit"]
-
-# Keywords for phase detection.
-# "strong" keywords are skill invocations — high confidence, but still
-# forward-only (a mention of prizmkit-plan while in commit phase is noise).
-# "weak" keywords are contextual hints — also forward-only, used when no
-# strong keyword matches.
-PHASE_KEYWORDS = {
-    "plan": {
-        "strong": ["prizmkit-plan"],
-        "weak": ["spec.md", "plan.md", "specification", "architecture", "task checklist", "task breakdown", "gathering requirements"],
-    },
-    "implement": {
-        "strong": ["prizmkit-implement"],
-        "weak": ["implement", "writing code", "TDD", "coding"],
-    },
-    "code-review": {
-        "strong": ["prizmkit-code-review"],
-        "weak": ["code review", "review verdict", "reviewing"],
-    },
-    "retrospective": {
-        "strong": ["prizmkit-retrospective"],
-        "weak": ["retrospective", "structural sync", "architecture knowledge", ".prizmkit/prizm-docs/ sync"],
-    },
-    "commit": {
-        "strong": ["prizmkit-committer"],
-        "weak": ["git commit", "committing", "feat(", "fix("],
-    },
-}
-
-CONTEXT_ERROR_PATTERNS = [
-    re.compile(pattern, re.IGNORECASE)
-    for pattern in (
-        r"context_too_large",
-        r"model_context_window_exceeded",
-        r"Your input exceeds the context window",
-        r"input exceeds the context window",
-        r"context window of this model",
-        r"context window exceeded",
-        r"invalid_request_error.*context window",
-        r"context window.*invalid_request_error",
-    )
-]
-
-ERROR_CONTEXT_PATTERNS = [
-    re.compile(pattern, re.IGNORECASE)
-    for pattern in (
-        r"\bapi error\b",
-        r"invalid_request_error",
-        r"\bstatus\s*[:=]?\s*(400|413)\b",
-        r"\bapi_error_status\b",
-        r"\bapi_error_code\b",
-        r"\blast_result_is_error\b\s*[\"':=]*\s*true\b",
-        r"\bis_error\b\s*[\"':=]*\s*true\b",
-    )
-]
-
-
-def _has_error_context(text):
-    """Return true when free text looks like a runtime/provider error."""
-    if not text:
-        return False
-    return any(pattern.search(text) for pattern in ERROR_CONTEXT_PATTERNS)
-
-
-def detect_api_error_code(text, require_error_context=False):
-    """Return a normalized fatal/runtime error code from terminal text.
-
-    Structured terminal result/error events and raw stderr can be matched
-    directly. Ordinary assistant prose is noisier: it may mention the phrase
-    "input exceeds the context window" while explaining a test or recovery
-    rule, so callers can require additional error-like context there.
-    """
-    if not text:
-        return ""
-    if require_error_context and not _has_error_context(text):
-        return ""
-    for pattern in CONTEXT_ERROR_PATTERNS:
-        if pattern.search(text):
-            return "context_too_large"
-    return ""
-
-
-class ProgressTracker:
-    """Tracks progress state from stream-json events."""
-
-    def __init__(self, session_log=None):
-        self.session_log_path = Path(session_log).expanduser() if session_log else None
-        self.message_count = 0
-        self.current_tool = None
-        self.current_tool_input_summary = ""
-        self.current_phase = None
-        self.detected_phases = []
-        self.tool_call_counts = Counter()
-        self.total_tool_calls = 0
-        self.last_text_snippet = ""
-        self.last_result_is_error = False
-        self.api_error_status = None
-        self.api_error_code = ""
-        self.terminal_result_text = ""
-        self.terminal_success_at = ""
-        self.fatal_error_code = ""
-        self.is_active = True
-        self.errors = []
-        self.event_format = ""
-        self.active_subagent_count = 0
-        self.subagent_status_counts = Counter()
-        self._subagent_spawn_count = 0
-        self.codex_child_thread_ids = set()
-        self.cb_session_id = ""
-        self.cb_cwd = ""
-        self.claude_session_id = ""
-        self.claude_cwd = ""
-        self.claude_task_states = {}
-        self.child_session_files = []
-        self.child_total_bytes = 0
-        self.child_activity_signature = ""
-        self.last_child_activity_at = ""
-        self._codex_child_session_paths = {}
-        self._claude_child_session_files = []
-        self._cb_child_session_files = []
-        self._last_child_scan_at = 0.0
-        self._last_claude_fallback_scan_at = 0.0
-        self._last_claude_fallback_scan_key = ""
-        self._claude_fallback_scan_interval_seconds = 10.0
-        self._text_buffer = ""
-        self._in_tool_use = False
-        self._current_tool_input_parts = []
-
-    def process_event(self, event):
-        """Process a single stream-json event and update state.
-
-        Supports three formats:
-        1. Claude API raw stream: message_start, content_block_start, content_block_delta, etc.
-        2. Claude Code verbose stream-json: assistant, user, tool_result, system, etc.
-           (produced by claude/claude-internal --verbose --output-format stream-json)
-        3. CodeBuddy stream-json: message/function_call/function_call_result events
-           (produced by cbc --print -y --output-format stream-json — message type
-           with sessionId/cwd metadata, function_call for tool invocations).
-        """
-        event_type = event.get("type", "")
-
-        # ── Codex exec --json JSONL format ──────────────────────────
-        if event_type in (
-            "thread.started", "turn.started", "turn.completed",
-            "turn.failed", "item.started", "item.completed", "error",
-        ):
-            self.event_format = "codex-json"
-            self.is_active = True
-
-            if event_type == "turn.started":
-                self.message_count += 1
-
-            elif event_type in ("item.started", "item.completed"):
-                item = event.get("item", {})
-                item_type = item.get("type", "")
-
-                if item_type == "agent_message":
-                    text = item.get("text", "")
-                    if text.strip():
-                        self.last_text_snippet = text.strip()[:120]
-                        self._detect_phase(text)
-
-                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
-                        self.total_tool_calls += 1
-                    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:
-                        self._detect_phase(prompt)
-
-                else:
-                    tool_name = item.get("tool") or item.get("name")
-                    if tool_name:
-                        if event_type == "item.started":
-                            self.current_tool = tool_name
-                            self.tool_call_counts[tool_name] += 1
-                            self.total_tool_calls += 1
-                        elif item.get("status") == "completed":
-                            self.current_tool = None
-                        self._extract_tool_summary_from_dict(item)
-
-            elif event_type == "turn.completed":
-                self.current_tool = None
-
-            elif event_type == "turn.failed":
-                error = event.get("error") or event.get("message") or "Codex turn failed"
-                self.errors.append(str(error))
-                self._detect_terminal_error(str(error))
-                self.current_tool = None
-
-            elif event_type == "error":
-                error = event.get("error") or event.get("message") or "Unknown error"
-                self.errors.append(str(error))
-                self._detect_terminal_error(str(error))
-
-            return
-
-        # ── CodeBuddy stream-json format ──────────────────────────────
-        # cbc --print -y --output-format stream-json emits:
-        #   message (role=user/assistant), function_call, function_call_result,
-        #   file-history-snapshot, error.  The first user message carries
-        #   sessionId and cwd metadata; later function_call items carry the
-        #   same fields.
-        # NOTE: cbc emits tool invocations as EITHER tool_use blocks inside a
-        # message (role=assistant) event OR as standalone function_call events,
-        # but not both for the same invocation.  The two handlers are
-        # complementary rather than redundant, so no deduplication is needed.
-        # Detect via event_type=="message" with a "sessionId" field.
-        # Must run before the Claude Code assistant / tool_result branches
-        # because those also accept those types but use different internals.
-        if event_type == "message" and isinstance(event.get("sessionId"), str):
-            self.event_format = self.event_format or "stream-json"
-            role = event.get("role", "")
-            sid = event.get("sessionId", "")
-            cwd = event.get("cwd", "")
-            if sid and not self.cb_session_id:
-                self.cb_session_id = sid.strip()
-            if cwd and not self.cb_cwd:
-                self.cb_cwd = cwd.strip()
-            if role == "assistant":
-                self.message_count += 1
-                self.is_active = True
-                content = event.get("content", [])
-                if isinstance(content, list):
-                    for block in content:
-                        block_type = block.get("type", "")
-                        if block_type == "tool_use":
-                            tool_name = block.get("name", "unknown")
-                            self.current_tool = tool_name
-                            self.tool_call_counts[tool_name] += 1
-                            self.total_tool_calls += 1
-                            tool_input = block.get("input", {})
-                            if isinstance(tool_input, dict):
-                                self._extract_tool_summary_from_dict(tool_input)
-                            self._detect_phase(
-                                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)
-                        elif block_type == "text":
-                            text = block.get("text", "")
-                            if text.strip():
-                                self.last_text_snippet = text.strip()[:120]
-                            self._detect_phase(text)
-                            self._detect_terminal_error(
-                                text, require_error_context=True
-                            )
-            return
-
-        # CodeBuddy function_call / function_call_result in stream-json
-        if event_type in ("function_call", "function_call_result"):
-            self.event_format = self.event_format or "stream-json"
-            sid = event.get("sessionId", "")
-            cwd = event.get("cwd", "")
-            if sid and not self.cb_session_id:
-                self.cb_session_id = sid.strip()
-            if cwd and not self.cb_cwd:
-                self.cb_cwd = cwd.strip()
-            if event_type == "function_call":
-                tool_name = event.get("name", "unknown")
-                self.current_tool = tool_name
-                self.tool_call_counts[tool_name] += 1
-                self.total_tool_calls += 1
-                self.is_active = True
-                # Extract summary from arguments
-                raw_args = event.get("arguments", "")
-                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)
-            elif event_type == "function_call_result":
-                self.current_tool = None
-                # Check result text for phase / error hints
-                result_text = event.get("output") or ""
-                if result_text and isinstance(result_text, str):
-                    stripped = result_text.strip()
-                    if stripped:
-                        self.last_text_snippet = stripped[:120]
-                    self._detect_phase(stripped)
-                    self._detect_terminal_error(stripped, require_error_context=True)
-            return
-
-        # ── Claude Code verbose format ──────────────────────────────
-        if event_type == "assistant":
-            self.event_format = self.event_format or "stream-json"
-            self.message_count += 1
-            self.is_active = True
-            message = event.get("message", {})
-            content_blocks = message.get("content", [])
-            for block in content_blocks:
-                block_type = block.get("type", "")
-                if block_type == "tool_use":
-                    tool_name = block.get("name", "unknown")
-                    self.current_tool = tool_name
-                    self.tool_call_counts[tool_name] += 1
-                    self.total_tool_calls += 1
-                    # Extract summary from input
-                    tool_input = block.get("input", {})
-                    if isinstance(tool_input, dict):
-                        self._extract_tool_summary_from_dict(tool_input)
-                    self._detect_phase(json.dumps(tool_input, ensure_ascii=False)[:500])
-                elif block_type == "text":
-                    text = block.get("text", "")
-                    if text.strip():
-                        self.last_text_snippet = text.strip()[:120]
-                    self._detect_phase(text)
-                    self._detect_terminal_error(text, require_error_context=True)
-
-        elif event_type == "tool_result" or (
-            event_type == "user"
-            and not isinstance(event.get("sessionId"), str)
-        ):
-            # tool_result contains output from tool execution
-            self.event_format = self.event_format or "stream-json"
-            self.is_active = True
-
-            # Check for error patterns in tool_result content (supports both formats):
-            # A) Top-level tool_result events: event["content"] is the result text
-            # B) Nested user events: event["message"]["content"][] has type=="tool_result" items
-            content_candidates = []
-
-            # Format A: top-level tool_result (Claude Code)
-            if event_type == "tool_result":
-                content_candidates.append(str(event.get("content", "")))
-
-            # Format B: nested inside user event (Claude Code, NOT CodeBuddy)
-            if event_type == "user":
-                message = event.get("message", {})
-                content_list = message.get("content", [])
-                if isinstance(content_list, list):
-                    for item in content_list:
-                        if isinstance(item, dict) and item.get("type") == "tool_result":
-                            content_candidates.append(str(item.get("content", "")))
-
-            for result_text in content_candidates:
-                if "shorter than the provided offset" in result_text:
-                    self.errors.append({
-                        "type": "read_offset_overflow",
-                        "tool": self.current_tool,
-                        "at": datetime.now(timezone.utc).isoformat(),
-                    })
-                    break  # one error per event is enough
-                elif "Wasted call" in result_text:
-                    self.errors.append({
-                        "type": "wasted_call",
-                        "tool": self.current_tool,
-                        "at": datetime.now(timezone.utc).isoformat(),
-                    })
-                    break
-
-            # Keep only last 20 errors to prevent unbounded growth in progress.json
-            if len(self.errors) > 20:
-                self.errors = self.errors[-20:]
-
-        elif event_type == "system":
-            # System events (hooks, init, task notifications, etc.) — track but don't count as messages.
-            self.event_format = self.event_format or "stream-json"
-            subtype = event.get("subtype", "")
-            if subtype == "init":
-                self.is_active = True
-                session_id = event.get("session_id")
-                if isinstance(session_id, str) and session_id.strip():
-                    self.claude_session_id = session_id.strip()
-                cwd = event.get("cwd")
-                if isinstance(cwd, str) and cwd.strip():
-                    self.claude_cwd = cwd.strip()
-            elif subtype == "task_started":
-                task_id = event.get("task_id")
-                if isinstance(task_id, str) and task_id.strip():
-                    self.claude_task_states[task_id.strip()] = {
-                        "status": "running",
-                        "summary": str(event.get("description") or "")[:120],
-                        "tool_use_id": str(event.get("tool_use_id") or ""),
-                        "task_type": str(event.get("task_type") or ""),
-                        "subagent_type": str(event.get("subagent_type") or ""),
-                    }
-                    self._update_claude_subagent_status_counts()
-            elif subtype in ("task_updated", "task_progress"):
-                task_id = event.get("task_id")
-                if isinstance(task_id, str) and task_id.strip():
-                    state = self.claude_task_states.setdefault(task_id.strip(), {})
-                    patch = event.get("patch") if isinstance(event.get("patch"), dict) else {}
-                    status = patch.get("status") or event.get("status")
-                    if status:
-                        state["status"] = str(status)
-                    summary = patch.get("summary") or patch.get("description") or event.get("summary") or event.get("description")
-                    if summary:
-                        state["summary"] = str(summary)[:120]
-                    else:
-                        state.setdefault("summary", "")
-                    tool_use_id = patch.get("tool_use_id") or event.get("tool_use_id")
-                    if tool_use_id:
-                        state["tool_use_id"] = str(tool_use_id)
-                    else:
-                        state.setdefault("tool_use_id", "")
-                    task_type = patch.get("task_type") or event.get("task_type")
-                    if task_type:
-                        state["task_type"] = str(task_type)
-                    else:
-                        state.setdefault("task_type", "")
-                    subagent_type = patch.get("subagent_type") or event.get("subagent_type")
-                    if subagent_type:
-                        state["subagent_type"] = str(subagent_type)
-                    else:
-                        state.setdefault("subagent_type", "")
-                    self._update_claude_subagent_status_counts()
-            elif subtype == "task_notification":
-                task_id = event.get("task_id")
-                if isinstance(task_id, str) and task_id.strip():
-                    state = self.claude_task_states.setdefault(task_id.strip(), {})
-                    status = event.get("status") or "completed"
-                    state["status"] = str(status)
-                    state["summary"] = str(event.get("summary") or state.get("summary") or "")[:120]
-                    state.setdefault("tool_use_id", str(event.get("tool_use_id") or ""))
-                    task_type = event.get("task_type")
-                    if task_type:
-                        state["task_type"] = str(task_type)
-                    else:
-                        state.setdefault("task_type", "")
-                    subagent_type = event.get("subagent_type")
-                    if subagent_type:
-                        state["subagent_type"] = str(subagent_type)
-                    else:
-                        state.setdefault("subagent_type", "")
-                    self._update_claude_subagent_status_counts()
-
-        elif event_type == "result":
-            self.event_format = self.event_format or "stream-json"
-            self.is_active = False
-            result_text = event.get("result") or event.get("message") or ""
-            error_obj = event.get("error")
-            if isinstance(error_obj, dict):
-                error_text = " ".join(
-                    str(error_obj.get(key) or "")
-                    for key in ("type", "code", "message")
-                    if error_obj.get(key)
-                )
-                result_text = " ".join(part for part in (str(result_text), error_text) if part)
-            api_error_code = event.get("api_error_code") or event.get("error_code") or ""
-            if isinstance(error_obj, dict) and not api_error_code:
-                api_error_code = error_obj.get("code") or error_obj.get("type") or ""
-            self._record_terminal_result(
-                text=str(result_text or ""),
-                is_error=bool(event.get("is_error")),
-                api_error_status=event.get("api_error_status"),
-                api_error_code=str(api_error_code or ""),
-            )
-
-        # ── Claude API raw stream format ────────────────────────────
-        elif event_type == "message_start":
-            self.event_format = self.event_format or "stream-json"
-            self.message_count += 1
-            self.is_active = True
-
-        elif event_type == "message_stop":
-            self.current_tool = None
-            self.current_tool_input_summary = ""
-            self._in_tool_use = False
-            self._current_tool_input_parts = []
-
-        elif event_type == "content_block_start":
-            content_block = event.get("content_block", {})
-            block_type = content_block.get("type", "")
-
-            if block_type == "tool_use":
-                tool_name = content_block.get("name", "unknown")
-                self.current_tool = tool_name
-                self.current_tool_input_summary = ""
-                self.tool_call_counts[tool_name] += 1
-                self.total_tool_calls += 1
-                self._in_tool_use = True
-                self._current_tool_input_parts = []
-
-            elif block_type == "text":
-                self._text_buffer = ""
-                self._in_tool_use = False
-
-        elif event_type == "content_block_delta":
-            delta = event.get("delta", {})
-            delta_type = delta.get("type", "")
-
-            if delta_type == "text_delta":
-                text = delta.get("text", "")
-                self._text_buffer += text
-                # Keep last meaningful snippet
-                stripped = text.strip()
-                if stripped:
-                    self.last_text_snippet = stripped[:120]
-                # Try to detect phase from text
-                self._detect_phase(text)
-                self._detect_terminal_error(text, require_error_context=True)
-
-            elif delta_type == "input_json_delta":
-                partial = delta.get("partial_json", "")
-                self._current_tool_input_parts.append(partial)
-                # Build a summary from accumulated input
-                accumulated = "".join(self._current_tool_input_parts)
-                self.current_tool_input_summary = accumulated[:150]
-
-        elif event_type == "content_block_stop":
-            if self._in_tool_use:
-                # Try to extract a better summary from complete tool input
-                full_input = "".join(self._current_tool_input_parts)
-                self._extract_tool_summary(full_input)
-                self._detect_phase(full_input)
-            else:
-                # Text block finished - detect phase and terminal errors from accumulated text
-                if self._text_buffer:
-                    self._detect_phase(self._text_buffer)
-                    self._detect_terminal_error(
-                        self._text_buffer,
-                        require_error_context=True,
-                    )
-            self._in_tool_use = False
-            self._current_tool_input_parts = []
-
-        elif event_type == "error":
-            self.event_format = self.event_format or "stream-json"
-            error_msg = event.get("error", {}).get("message", "Unknown error")
-            errors = event.get("errors") or []
-            if isinstance(errors, list) and errors:
-                error_msg = "; ".join(str(e) for e in errors[:3])
-            self.errors.append(error_msg)
-            self._detect_terminal_error(str(error_msg))
-
-        # ── CodeBuddy file-history-snapshot (ignore) ─────────────────
-        elif event_type == "file-history-snapshot":
-            return
-
-        # Check for subagent indicator
-        if event.get("parent_tool_use_id"):
-            # This is a sub-agent event; tool name is still tracked normally
-            pass
-
-    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.
-        """
-        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
-        else:
-            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
-
-    def _record_terminal_result(self, text="", is_error=False, api_error_status=None, api_error_code=""):
-        """Record a Claude Code terminal result event."""
-        terminal_text = str(text or "")
-        self.last_result_is_error = bool(is_error)
-        if api_error_status not in (None, ""):
-            try:
-                self.api_error_status = int(api_error_status)
-            except (TypeError, ValueError):
-                self.api_error_status = api_error_status
-        error_like_result = (
-            self.last_result_is_error
-            or api_error_status not in (None, "")
-            or bool(api_error_code)
-            or _has_error_context(terminal_text)
-        )
-        normalized_code = detect_api_error_code(
-            " ".join([str(api_error_code or ""), terminal_text]),
-            require_error_context=not error_like_result,
-        )
-        if normalized_code:
-            self.api_error_code = normalized_code
-            self.fatal_error_code = normalized_code
-        elif api_error_code:
-            self.api_error_code = str(api_error_code)
-        self.terminal_result_text = terminal_text[:1000]
-        if terminal_text.strip():
-            self.last_text_snippet = terminal_text.strip()[:120]
-        if not self.last_result_is_error and not self.fatal_error_code:
-            self.terminal_success_at = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
-        elif self.fatal_error_code:
-            self.errors.append(self.fatal_error_code)
-
-    def _detect_terminal_error(self, text, require_error_context=False):
-        """Detect fatal context-window errors from unstructured text."""
-        code = detect_api_error_code(
-            str(text or ""),
-            require_error_context=require_error_context,
-        )
-        if not code:
-            return
-        self.last_result_is_error = True
-        self.api_error_code = code
-        self.fatal_error_code = code
-        self.terminal_result_text = str(text or "")[:1000]
-        if text:
-            self.last_text_snippet = str(text).strip()[:120]
-
-    def _detect_phase(self, text):
-        """Detect pipeline phase from text content.
-
-        Uses monotonic (forward-only) progression to avoid false positives.
-        Strong keywords (skill invocations) always trigger; weak keywords
-        only trigger for phases at or ahead of the current position.
-        """
-        text_lower = text.lower()
-        current_idx = (
-            PHASE_ORDER.index(self.current_phase)
-            if self.current_phase in PHASE_ORDER
-            else -1
-        )
-
-        for phase, kw_groups in PHASE_KEYWORDS.items():
-            phase_idx = PHASE_ORDER.index(phase)
-
-            # Check strong keywords — high confidence but still forward-only
-            for keyword in kw_groups.get("strong", []):
-                if keyword.lower() in text_lower:
-                    if phase_idx >= current_idx:
-                        self.current_phase = phase
-                        if phase not in self.detected_phases:
-                            self.detected_phases.append(phase)
-                        return
-                    # Backward strong match — skip this phase but do NOT
-                    # early-return, so forward weak matches can still fire.
-                    break
-
-            # Check weak keywords — only trigger for forward phases
-            if phase_idx >= current_idx:
-                for keyword in kw_groups.get("weak", []):
-                    if keyword.lower() in text_lower:
-                        self.current_phase = phase
-                        if phase not in self.detected_phases:
-                            self.detected_phases.append(phase)
-                        return
-
-    def _extract_tool_summary(self, raw_input):
-        """Extract a human-readable summary from tool input JSON string."""
-        try:
-            data = json.loads(raw_input)
-            self._extract_tool_summary_from_dict(data)
-        except (json.JSONDecodeError, TypeError):
-            # Keep whatever partial summary we had
-            pass
-
-    def _extract_tool_summary_from_dict(self, data):
-        """Extract a human-readable summary from tool input dict."""
-        if isinstance(data, dict):
-            # Common patterns in tool inputs
-            if "description" in data:
-                self.current_tool_input_summary = str(data["description"])[:100]
-            elif "command" in data:
-                self.current_tool_input_summary = str(data["command"])[:100]
-            elif "file_path" in data:
-                self.current_tool_input_summary = str(data["file_path"])[:100]
-            elif "pattern" in data:
-                self.current_tool_input_summary = str(data["pattern"])[:100]
-            elif "query" in data:
-                self.current_tool_input_summary = str(data["query"])[:100]
-            elif "prompt" in data:
-                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
-
-    def _record_codex_child_thread_ids(self, thread_ids):
-        """Remember Codex child thread IDs reported by 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())
-
-    def _codex_sessions_dir(self):
-        """Return the Codex sessions directory for the current environment."""
-        codex_home = os.environ.get("CODEX_HOME")
-        if codex_home:
-            return Path(codex_home).expanduser() / "sessions"
-        return Path.home() / ".codex" / "sessions"
-
-    def _find_codex_child_session_file(self, thread_id):
-        """Find a Codex transcript file for a child thread ID."""
-        sessions_dir = self._codex_sessions_dir()
-        if not sessions_dir.exists():
-            return None
-
-        try:
-            matches = list(sessions_dir.rglob(f"*{thread_id}.jsonl"))
-        except OSError:
-            return None
-
-        if not matches:
-            return None
-
-        try:
-            matches.sort(key=lambda path: path.stat().st_mtime, reverse=True)
-        except OSError:
-            pass
-        return str(matches[0])
-
-    def _is_tracked_claude_subagent_state(self, state):
-        """Return true for Claude Code task events representing in-process agents."""
-        if not isinstance(state, dict):
-            return False
-        task_type = str(state.get("task_type") or "")
-        task_type_lower = task_type.lower()
-        subagent_type = str(state.get("subagent_type") or "")
-        if task_type_lower == "local_bash":
-            return False
-        tracked_types = {"in_process_teammate", "subagent", "agent", "teammate"}
-        if task_type_lower in tracked_types:
-            return True
-        if task_type_lower == "local_agent" and subagent_type:
-            return True
-        summary = str(state.get("summary") or "")
-        return bool(
-            not task_type
-            and summary.lower().startswith(("dev:", "critic:", "reviewer:", "agent:"))
-        )
-
-    def _has_tracked_claude_subagent_task(self):
-        """Return true once a Claude Code local-agent/subagent task has been observed."""
-        return any(
-            self._is_tracked_claude_subagent_state(state)
-            for state in self.claude_task_states.values()
-        )
-
-    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():
-            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
-            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
-
-    def _claude_projects_dir(self):
-        """Return the Claude Code projects directory for transcript lookup."""
-        projects_dir = os.environ.get("CLAUDE_PROJECTS_DIR")
-        if projects_dir:
-            return Path(projects_dir).expanduser()
-        claude_config_dir = os.environ.get("CLAUDE_CONFIG_DIR")
-        if claude_config_dir:
-            return Path(claude_config_dir).expanduser() / "projects"
-        claude_home = os.environ.get("CLAUDE_HOME")
-        if claude_home:
-            return Path(claude_home).expanduser() / "projects"
-        return Path.home() / ".claude" / "projects"
-
-    def _claude_project_key(self):
-        """Encode cwd the same way Claude Code stores project transcript dirs."""
-        cwd = self.claude_cwd
-        if not cwd:
-            return ""
-        return cwd.replace("\\", "-").replace("/", "-").replace(":", "")
-
-    def _find_claude_child_session_files(self):
-        """Find Claude Code subagent transcripts for this parent session."""
-        if not self.claude_session_id:
-            return []
-
-        projects_dir = self._claude_projects_dir()
-        if not projects_dir.exists():
-            return []
-
-        candidates = []
-        project_key = self._claude_project_key()
-        if project_key:
-            candidates.append(
-                projects_dir / project_key / self.claude_session_id / "subagents"
-            )
-
-        for candidate in candidates:
-            if candidate.exists():
-                try:
-                    return sorted(candidate.glob("*.jsonl"))
-                except OSError:
-                    return []
-
-        # Fallback for non-standard cwd encoding or custom Claude homes. Avoid
-        # repeatedly walking every stored transcript before any Agent task exists.
-        if not self._has_tracked_claude_subagent_task():
-            return []
-
-        fallback_scan_key = f"{projects_dir}:{self.claude_session_id}"
-        now = time.monotonic()
-        if (
-            self._last_claude_fallback_scan_key == fallback_scan_key
-            and now - self._last_claude_fallback_scan_at < self._claude_fallback_scan_interval_seconds
-        ):
-            return self._claude_child_session_files
-        self._last_claude_fallback_scan_key = fallback_scan_key
-        self._last_claude_fallback_scan_at = now
-        try:
-            matches = sorted(projects_dir.rglob(f"{self.claude_session_id}/subagents/*.jsonl"))
-        except OSError:
-            return []
-        return matches
-
-    def _cb_projects_dir(self):
-        """Return the CodeBuddy projects directory for transcript lookup.
-
-        CodeBuddy stores per-project session transcripts and sub-agent data
-        under ~/.codebuddy/projects/{projectDir}/{sessionId}/.
-        """
-        cb_config = os.environ.get("CODEBUDDY_CONFIG_DIR")
-        if cb_config:
-            return Path(cb_config).expanduser() / "projects"
-        cb_home = os.environ.get("CODEBUDDY_HOME")
-        if cb_home:
-            return Path(cb_home).expanduser() / "projects"
-        return Path.home() / ".codebuddy" / "projects"
-
-    def _cb_project_key(self):
-        """Encode cwd the same way CodeBuddy stores project subdirs.
-
-        CodeBuddy uses the same sanitisation as Claude Code (\, /, : → -)
-        but strips the leading '-' so "/Users/test/MyProject" becomes
-        "Users-test-MyProject".
-        """
-        cwd = self.cb_cwd
-        if not cwd:
-            return ""
-        return cwd.replace("\\", "-").replace("/", "-").replace(":", "").lstrip("-")
-
-    def _find_cb_child_session_files(self):
-        """Find CodeBuddy subagent transcript data for this parent session.
-
-        CodeBuddy sub-agents store tool-results/{callId}.txt files; conversation
-        transcripts are not (as of 2026) written as agent-*.jsonl files in the
-        subagents/ directory.  We track the tool-results .txt files as a proxy
-        for child activity so the heartbeat monitor can extend the stale-kill
-        window while sub-agents are running.
-        """
-        if not self.cb_session_id:
-            return []
-
-        projects_dir = self._cb_projects_dir()
-        if not projects_dir.exists():
-            return []
-
-        project_key = self._cb_project_key()
-        if not project_key:
-            return []
-
-        subagents_dir = (
-            projects_dir / project_key / self.cb_session_id / "subagents"
-        )
-        if not subagents_dir.exists():
-            return []
-
-        # Collect all files under each agent-{id} subdirectory. These are
-        # currently tool-results/{callId}.txt files, but the glob also picks
-        # up future agent-*.jsonl transcripts should CodeBuddy add them.
-        try:
-            return sorted(
-                p for p in subagents_dir.glob("**/*")
-                if p.is_file()
-            )
-        except OSError:
-            return []
-
-    def refresh_child_session_activity(self, force=False):
-        """Refresh child transcript file stats.
-
-        The heartbeat monitor uses this activity signature to treat subagent
-        transcript growth as real progress while the parent session is blocked
-        waiting for a child agent/tool result. Supports Codex child threads,
-        Claude Code in-process teammate transcripts, and CodeBuddy sub-agent
-        file activity under subagents/.
-        """
-        previous_signature = self.child_activity_signature
-
-        if (
-            not self.codex_child_thread_ids
-            and not self.claude_session_id
-            and not self.cb_session_id
-        ):
-            self.child_session_files = []
-            self.child_total_bytes = 0
-            self.child_activity_signature = ""
-            self.last_child_activity_at = ""
-            return previous_signature != self.child_activity_signature
-
-        now = time.monotonic()
-        should_scan = (
-            force
-            or self._last_child_scan_at == 0.0
-            or (now - self._last_child_scan_at >= 2.0)
-        )
-        if should_scan:
-            for thread_id in sorted(self.codex_child_thread_ids):
-                path = self._codex_child_session_paths.get(thread_id)
-                if not path or not os.path.exists(path):
-                    found = self._find_codex_child_session_file(thread_id)
-                    if found:
-                        self._codex_child_session_paths[thread_id] = found
-            self._claude_child_session_files = self._find_claude_child_session_files()
-            self._cb_child_session_files = self._find_cb_child_session_files()
-            self._last_child_scan_at = now
-
-        files = []
-        signature_parts = []
-        total_bytes = 0
-        max_mtime = 0.0
-
-        def add_file(kind, identifier, path):
-            nonlocal total_bytes, max_mtime
-            try:
-                stat = os.stat(path)
-            except OSError:
-                return
-            path_str = str(path)
-            total_bytes += stat.st_size
-            max_mtime = max(max_mtime, stat.st_mtime)
-            mtime_ns = getattr(stat, "st_mtime_ns", int(stat.st_mtime * 1_000_000_000))
-            signature_parts.append(f"{kind}:{identifier}:{stat.st_size}:{mtime_ns}")
-            files.append(
-                {
-                    "kind": kind,
-                    "thread_id": identifier,
-                    "path": path_str,
-                    "size": stat.st_size,
-                    "mtime": datetime.fromtimestamp(
-                        stat.st_mtime, timezone.utc
-                    ).strftime("%Y-%m-%dT%H:%M:%SZ"),
-                }
-            )
-
-        for thread_id in sorted(self.codex_child_thread_ids):
-            path = self._codex_child_session_paths.get(thread_id)
-            if path:
-                add_file("codex", thread_id, path)
-
-        for path in self._claude_child_session_files:
-            add_file("claude", path.stem, path)
-
-        for path in self._cb_child_session_files:
-            # Identifier for CodeBuddy sub-agent files: use the parent
-            # directory name (agent-{id}) so heartbeat can distinguish
-            # activity across different sub-agent instances.
-            parent_name = path.parent.name if hasattr(path, "parent") else ""
-            identifier = parent_name if parent_name.startswith("agent-") else path.name
-            add_file("codebuddy", identifier, path)
-
-        self.child_session_files = files
-        self.child_total_bytes = total_bytes
-        self.child_activity_signature = "|".join(signature_parts)
-        self.last_child_activity_at = (
-            datetime.fromtimestamp(max_mtime, timezone.utc).strftime(
-                "%Y-%m-%dT%H:%M:%SZ"
-            )
-            if max_mtime
-            else ""
-        )
-        return previous_signature != self.child_activity_signature
-
-    def to_dict(self):
-        """Export current state as a dictionary for JSON serialization."""
-        self.refresh_child_session_activity()
-        tool_calls = [
-            {"name": name, "count": count}
-            for name, count in self.tool_call_counts.most_common()
-        ]
-        subagent_states = [
-            {"status": status, "count": count}
-            for status, count in self.subagent_status_counts.most_common()
-        ]
-        return {
-            "updated_at": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
-            "event_format": self.event_format,
-            "message_count": self.message_count,
-            "current_tool": self.current_tool,
-            "current_tool_input_summary": self.current_tool_input_summary,
-            "current_phase": self.current_phase,
-            "detected_phases": self.detected_phases,
-            "tool_calls": tool_calls,
-            "total_tool_calls": self.total_tool_calls,
-            "active_subagent_count": self.active_subagent_count,
-            "subagent_states": subagent_states,
-            "subagent_spawn_count": self._subagent_spawn_count,
-            "child_thread_ids": sorted(self.codex_child_thread_ids),
-            "child_session_files": self.child_session_files,
-            "child_total_bytes": self.child_total_bytes,
-            "child_activity_signature": self.child_activity_signature,
-            "last_child_activity_at": self.last_child_activity_at,
-            "cb_session_id": self.cb_session_id,
-            "cb_cwd": self.cb_cwd,
-            "last_text_snippet": self.last_text_snippet,
-            "last_result_is_error": self.last_result_is_error,
-            "api_error_status": self.api_error_status,
-            "api_error_code": self.api_error_code,
-            "terminal_result_text": self.terminal_result_text,
-            "terminal_success_at": self.terminal_success_at,
-            "fatal_error_code": self.fatal_error_code,
-            "is_active": self.is_active,
-            "errors": self.errors[-10:],  # Keep last 10 errors
-        }
-
-
-def atomic_write_json(data, filepath):
-    """Write JSON data atomically using tmp file + rename."""
-    dir_path = os.path.dirname(filepath)
-    tmp_path = None
-    try:
-        fd, tmp_path = tempfile.mkstemp(dir=dir_path, suffix=".tmp")
-        with os.fdopen(fd, "w") as f:
-            json.dump(data, f, indent=2)
-            f.write("\n")
-        os.rename(tmp_path, filepath)
-    except OSError:
-        # Best effort - remove tmp file if rename failed
-        if tmp_path:
-            try:
-                os.unlink(tmp_path)
-            except OSError:
-                pass
-
-
-def tail_and_parse(session_log, progress_file, poll_interval=0.5):
-    """Tail session log and parse stream-json events."""
-    tracker = ProgressTracker(session_log)
-    last_write_state = None
-
-    def state_key(state):
-        return (
-            state["message_count"],
-            state["current_tool"],
-            state["current_phase"],
-            state["total_tool_calls"],
-            state.get("child_activity_signature", ""),
-            state.get("last_result_is_error"),
-            state.get("api_error_status"),
-            state.get("api_error_code", ""),
-            state.get("fatal_error_code", ""),
-            state.get("terminal_result_text", ""),
-            tuple(state.get("errors", [])),
-        )
-
-    # Wait for log file to appear
-    wait_count = 0
-    while not os.path.exists(session_log):
-        time.sleep(poll_interval)
-        wait_count += 1
-        if wait_count > 120:  # 60 seconds max wait
-            sys.stderr.write(f"Timeout waiting for {session_log}\n")
-            sys.exit(1)
-
-    with open(session_log, "r") as f:
-        idle_count = 0
-        while True:
-            line = f.readline()
-            if line:
-                idle_count = 0
-                line = line.strip()
-                if not line:
-                    continue
-                try:
-                    event = json.loads(line)
-                    tracker.process_event(event)
-                except json.JSONDecodeError:
-                    # Not a JSON line (could be stderr mixed in). Use it as a
-                    # text snippet and only treat it as terminal when it has a
-                    # strong API/runtime error marker; ordinary assistant prose
-                    # can discuss context limits without being fatal.
-                    stripped = line.strip()
-                    if stripped and len(stripped) > 5:
-                        tracker.last_text_snippet = stripped[:120]
-                        tracker._detect_terminal_error(stripped, require_error_context=True)
-                        current_state = tracker.to_dict()
-                        current_state_key = state_key(current_state)
-                        if current_state_key != last_write_state:
-                            atomic_write_json(current_state, progress_file)
-                            last_write_state = current_state_key
-                    continue
-
-                # Write progress if state changed
-                current_state = tracker.to_dict()
-                current_state_key = state_key(current_state)
-                if current_state_key != last_write_state:
-                    atomic_write_json(current_state, progress_file)
-                    last_write_state = current_state_key
-            else:
-                idle_count += 1
-                # Every 2 seconds of no parent log data, refresh child Codex
-                # transcript stats and write if child activity advanced.
-                if idle_count % 4 == 0:
-                    current_state = tracker.to_dict()
-                    current_state_key = state_key(current_state)
-                    if current_state_key != last_write_state or idle_count == 4:
-                        atomic_write_json(current_state, progress_file)
-                        last_write_state = current_state_key
-
-                # After 3600 idle cycles (30 min), mark inactive and exit
-                if idle_count > 3600:
-                    tracker.is_active = False
-                    atomic_write_json(tracker.to_dict(), progress_file)
-                    break
-
-                time.sleep(poll_interval)
-
-    # Final write
-    tracker.is_active = False
-    atomic_write_json(tracker.to_dict(), progress_file)
-
-
-def main():
-    parser = argparse.ArgumentParser(description="Parse stream-json progress")
-    parser.add_argument("--session-log", required=True, help="Path to session.log (JSONL)")
-    parser.add_argument("--progress-file", required=True, help="Path to write progress.json")
-    args = parser.parse_args()
-
-    # Handle graceful shutdown
-    def handle_signal(signum, frame):
-        sys.exit(0)
-
-    signal.signal(signal.SIGTERM, handle_signal)
-    signal.signal(signal.SIGINT, handle_signal)
-
-    try:
-        tail_and_parse(args.session_log, args.progress_file)
-    except SystemExit:
-        pass
-    except Exception as e:
-        sys.stderr.write(f"parse-stream-progress.py error: {e}\n")
-        sys.exit(1)
-
-
-if __name__ == "__main__":
-    main()