prizmkit 1.1.74 → 1.1.76

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

@@ -137,7 +137,10 @@ class ProgressTracker:
         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 = {}
@@ -147,6 +150,7 @@ class ProgressTracker:
         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 = ""
@@ -158,10 +162,13 @@ class ProgressTracker:
     def process_event(self, event):
         """Process a single stream-json event and update state.
 
-        Supports two formats:
+        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", "")
 
@@ -233,6 +240,93 @@ class ProgressTracker:
 
             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"
@@ -259,7 +353,10 @@ class ProgressTracker:
                     self._detect_phase(text)
                     self._detect_terminal_error(text, require_error_context=True)
 
-        elif event_type == "tool_result" or event_type == "user":
+        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
@@ -269,11 +366,11 @@ class ProgressTracker:
             # B) Nested user events: event["message"]["content"][] has type=="tool_result" items
             content_candidates = []
 
-            # Format A: top-level tool_result
+            # 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
+            # Format B: nested inside user event (Claude Code, NOT CodeBuddy)
             if event_type == "user":
                 message = event.get("message", {})
                 content_list = message.get("content", [])
@@ -465,15 +562,60 @@ class ProgressTracker:
             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 "")
@@ -757,17 +899,85 @@ class ProgressTracker:
             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 and
-        Claude Code in-process teammate transcripts.
+        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:
+        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 = ""
@@ -788,6 +998,7 @@ class ProgressTracker:
                     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 = []
@@ -826,6 +1037,14 @@ class ProgressTracker:
         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)
@@ -861,11 +1080,14 @@ class ProgressTracker:
             "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,

package/bundled/skills/_metadata.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.1.74",
+  "version": "1.1.76",
   "skills": {
     "prizm-kit": {
       "description": "Full-lifecycle dev toolkit. Covers spec-driven development, Prizm context docs, code quality, debugging, deployment, and knowledge management.",

package/bundled/skills/bugfix-pipeline-launcher/SKILL.md

@@ -189,6 +189,7 @@ Detect user intent from their message, then follow the corresponding workflow:
    | Variable | Default | Purpose |
    |----------|---------|---------|
    | `MODEL` | (none) | AI model override (e.g. `claude-opus-4.6`) |
+   | `PRIZMKIT_EFFORT` | (none) | AI reasoning effort: `low`\|`medium`\|`high`\|`xhigh`\|`max` (max = Claude Code only) |
    | `AUTO_PUSH` | `0` | Auto-push to remote after successful bug fix (`1` to enable) |
    | `DEV_BRANCH` | auto-generated | Custom dev branch name (default: `bugfix/pipeline-{run_id}`) |
    | `HEARTBEAT_INTERVAL` | `30` | Heartbeat log interval in seconds |

package/bundled/skills/feature-pipeline-launcher/SKILL.md

@@ -206,6 +206,7 @@ Detect user intent from their message, then follow the corresponding workflow:
    | Variable | Default | Purpose |
    |----------|---------|---------|
    | `MODEL` | (none) | AI model override (e.g. `claude-opus-4.6`) |
+   | `PRIZMKIT_EFFORT` | (none) | AI reasoning effort: `low`\|`medium`\|`high`\|`xhigh`\|`max` (max = Claude Code only) |
    | `AUTO_PUSH` | `0` | Auto-push to remote after successful feature (`1` to enable) |
    | `DEV_BRANCH` | auto-generated | Custom dev branch name (default: `dev/{feature_id}-YYYYMMDDHHmm`) |
    | `HEARTBEAT_INTERVAL` | `30` | Heartbeat log interval in seconds |

package/bundled/skills/refactor-pipeline-launcher/SKILL.md

@@ -215,6 +215,7 @@ Detect user intent from their message, then follow the corresponding workflow:
    | Variable | Default | Purpose |
    |----------|---------|---------|
    | `MODEL` | (none) | AI model override (e.g. `claude-opus-4.6`) |
+   | `PRIZMKIT_EFFORT` | (none) | AI reasoning effort: `low`\|`medium`\|`high`\|`xhigh`\|`max` (max = Claude Code only) |
    | `AUTO_PUSH` | `0` | Auto-push to remote after successful refactor (`1` to enable) |
    | `DEV_BRANCH` | auto-generated | Custom dev branch name (default: `refactor/pipeline-{run_id}`) |
    | `HEARTBEAT_INTERVAL` | `30` | Heartbeat log interval in seconds |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prizmkit",
-  "version": "1.1.74",
+  "version": "1.1.76",
   "description": "Create a new PrizmKit-powered project with clean initialization — no framework dev files, just what you need.",
   "type": "module",
   "bin": {