prizmkit 1.1.74 → 1.1.76

package/bundled/VERSION.json

@@ -1,5 +1,5 @@
 {
-  "frameworkVersion": "1.1.74",
-  "bundledAt": "2026-06-12T13:22:51.065Z",
-  "bundledFrom": "8817522"
+  "frameworkVersion": "1.1.76",
+  "bundledAt": "2026-06-13T04:58:49.240Z",
+  "bundledFrom": "17f8257"
 }

package/bundled/dev-pipeline/.env.example

@@ -44,6 +44,7 @@
 # STALE_KILL_THRESHOLD=900   # Auto-kill after N seconds without parent log progress (0 = disabled)
 # CODEX_WAIT_STALE_KILL_THRESHOLD=3600  # Longer no-log window while Codex waits on subagents
 # CODEX_SUBAGENT_TIMEOUT_SECONDS=3300   # Codex subagent max runtime; defaults to wait threshold - 300
+# CB_SUBAGENT_STALE_KILL_THRESHOLD=3600 # Longer no-log window while CodeBuddy sub-agents are running
 # LOG_CLEANUP_ENABLED=1      # Periodic log cleanup (1=on, 0=off)
 # LOG_RETENTION_DAYS=14      # Delete logs older than N days
 # LOG_MAX_TOTAL_MB=1024      # Keep total logs under N MB via oldest-first cleanup

package/bundled/dev-pipeline/lib/common.sh

@@ -338,6 +338,41 @@ prizm_detect_cli_and_platform() {
     export PRIZMKIT_PLATFORM="$PLATFORM"
 }
 
+# Validate PRIZMKIT_EFFORT against the detected platform's supported values.
+# Exits with a friendly error if the value is unsupported.
+prizm_validate_effort() {
+    [[ -n "${PRIZMKIT_EFFORT:-}" ]] || return 0
+
+    local session_platform
+    session_platform="$(_prizm_session_platform)"
+
+    local allowed_values
+    case "$session_platform" in
+        claude)    allowed_values="low, medium, high, xhigh, max" ;;
+        codex)     allowed_values="low, medium, high, xhigh" ;;
+        *)         allowed_values="low, medium, high, xhigh" ;;
+    esac
+
+    local valid=0
+    local val
+    for val in $allowed_values; do
+        val="${val%,}"
+        [[ "$val" == "$PRIZMKIT_EFFORT" ]] && valid=1 && break
+    done
+
+    if [[ "$valid" -ne 1 ]]; then
+        local platform_label="$session_platform"
+        [[ "$session_platform" == "claude" ]] && platform_label="Claude Code"
+        [[ "$session_platform" == "codebuddy" ]] && platform_label="CodeBuddy"
+        [[ "$session_platform" == "codex" ]] && platform_label="Codex"
+
+        log_error "PRIZMKIT_EFFORT='$PRIZMKIT_EFFORT' is not supported by the detected CLI ($platform_label)."
+        log_error "  Supported values for $platform_label: $allowed_values"
+        log_error "  Set PRIZMKIT_EFFORT to one of the above, or unset it to use the CLI default."
+        exit 1
+    fi
+}
+
 # Start an AI CLI session in the background.
 # Usage: prizm_start_ai_session <prompt_path> <log_path> <model>
 # Sets PRIZM_AI_PID to the spawned process PID. Do not call this function via
@@ -380,6 +415,9 @@ prizm_start_ai_session() {
             if [[ "$USE_STREAM_JSON" == "true" ]]; then
                 claude_args+=(--output-format stream-json)
             fi
+            if [[ -n "${PRIZMKIT_EFFORT:-}" ]]; then
+                claude_args+=(--effort "$PRIZMKIT_EFFORT")
+            fi
             if [[ -n "$model" ]]; then
                 claude_args+=(--model "$model")
             fi
@@ -399,6 +437,9 @@ prizm_start_ai_session() {
             if [[ -n "$model" ]]; then
                 codex_args+=(--model "$model")
             fi
+            if [[ -n "${PRIZMKIT_EFFORT:-}" ]]; then
+                codex_args+=(--config "model_reasoning_effort=$PRIZMKIT_EFFORT")
+            fi
             "$CLI_CMD" "${codex_args[@]}" - < "$prompt_path" > "$log_path" 2>&1 &
             ;;
         *)
@@ -409,6 +450,9 @@ prizm_start_ai_session() {
             if [[ "$USE_STREAM_JSON" == "true" ]]; then
                 cb_args+=(--output-format stream-json)
             fi
+            if [[ -n "${PRIZMKIT_EFFORT:-}" ]]; then
+                cb_args+=(--effort "$PRIZMKIT_EFFORT")
+            fi
             if [[ -n "$model" ]]; then
                 cb_args+=(--model "$model")
             fi
@@ -900,6 +944,9 @@ prizm_run_ai_session() {
     case "$session_platform" in
         claude)
             local claude_args=(-p "$(cat "$prompt_path")" --dangerously-skip-permissions)
+            if [[ -n "${PRIZMKIT_EFFORT:-}" ]]; then
+                claude_args+=(--effort "$PRIZMKIT_EFFORT")
+            fi
             if [[ -n "$model" ]]; then
                 claude_args+=(--model "$model")
             fi
@@ -919,10 +966,16 @@ prizm_run_ai_session() {
             if [[ -n "$model" ]]; then
                 codex_args+=(--model "$model")
             fi
+            if [[ -n "${PRIZMKIT_EFFORT:-}" ]]; then
+                codex_args+=(--config "model_reasoning_effort=$PRIZMKIT_EFFORT")
+            fi
             "$CLI_CMD" "${codex_args[@]}" - < "$prompt_path" > "$log_path" 2>&1
             ;;
         *)
             local cb_args=(--print -y)
+            if [[ -n "${PRIZMKIT_EFFORT:-}" ]]; then
+                cb_args+=(--effort "$PRIZMKIT_EFFORT")
+            fi
             if [[ -n "$model" ]]; then
                 cb_args+=(--model "$model")
             fi

package/bundled/dev-pipeline/lib/heartbeat.sh

@@ -92,8 +92,8 @@ PY
 
             local effective_stale_kill_threshold="$stale_kill_threshold"
             if [[ $stale_kill_threshold -gt 0 && -f "$progress_json" ]]; then
-                local codex_wait_threshold
-                codex_wait_threshold=$(python3 - "$progress_json" "$stale_kill_threshold" <<'PY' 2>/dev/null || true
+                local extended_threshold
+                extended_threshold=$(python3 - "$progress_json" "$stale_kill_threshold" <<'PY' 2>/dev/null || true
 import json
 import os
 import sys
@@ -106,14 +106,21 @@ with open(progress_path, "r", encoding="utf-8") as fh:
 
 spawn_count = 0
 for tool in progress.get("tool_calls", []):
-    if isinstance(tool, dict) and tool.get("name") == "spawn_agent":
+    if isinstance(tool, dict) and tool.get("name") in ("spawn_agent", "Agent", "TaskCreate"):
         try:
             spawn_count += int(tool.get("count", 0))
         except (TypeError, ValueError):
             pass
 
+# Also check the subagent_spawn_count field (set by _record_cb_agent_tool_call)
+if not spawn_count:
+    spawn_count = int(progress.get("subagent_spawn_count", 0))
+
+fmt = progress.get("event_format", "")
+
+# Codex: current_tool == "wait" means parent is blocked on spawn_agent completion
 if (
-    progress.get("event_format") == "codex-json"
+    fmt == "codex-json"
     and progress.get("current_tool") == "wait"
     and spawn_count > 0
 ):
@@ -124,10 +131,26 @@ if (
         wait_threshold = max(base_threshold * 4, 3600)
     if wait_threshold > base_threshold:
         print(wait_threshold)
+
+# CodeBuddy: Agent tool blocks synchronously; Task* tools imply bg agents.
+# Extend the stale window when sub-agents have been spawned so the heartbeat
+# doesn't kill the parent while children are still running.
+if (
+    fmt == "stream-json"
+    and spawn_count > 0
+    and progress.get("cb_session_id", "")
+):
+    configured = os.environ.get("CB_SUBAGENT_STALE_KILL_THRESHOLD", "")
+    try:
+        cb_threshold = int(configured)
+    except ValueError:
+        cb_threshold = max(base_threshold * 4, 3600)
+    if cb_threshold > base_threshold:
+        print(cb_threshold)
 PY
                 )
-                if [[ "$codex_wait_threshold" =~ ^[0-9]+$ && "$codex_wait_threshold" -gt "$stale_kill_threshold" ]]; then
-                    effective_stale_kill_threshold="$codex_wait_threshold"
+                if [[ "$extended_threshold" =~ ^[0-9]+$ && "$extended_threshold" -gt "$stale_kill_threshold" ]]; then
+                    effective_stale_kill_threshold="$extended_threshold"
                 fi
             fi
 

package/bundled/dev-pipeline/run-bugfix.sh

@@ -51,6 +51,7 @@ LOG_RETENTION_DAYS=${LOG_RETENTION_DAYS:-14}
 LOG_MAX_TOTAL_MB=${LOG_MAX_TOTAL_MB:-1024}
 VERBOSE=${VERBOSE:-0}
 MODEL=${MODEL:-""}
+PRIZMKIT_EFFORT=${PRIZMKIT_EFFORT:-""}
 DEV_BRANCH=${DEV_BRANCH:-""}
 AUTO_PUSH=${AUTO_PUSH:-0}
 STOP_ON_FAILURE=${STOP_ON_FAILURE:-0}
@@ -59,6 +60,9 @@ ENABLE_DEPLOY=${ENABLE_DEPLOY:-0}
 # Source shared common helpers (CLI/platform detection + logs + deps)
 prizm_detect_cli_and_platform
 
+# Validate PRIZMKIT_EFFORT early (fail-fast before any sessions are spawned)
+prizm_validate_effort
+
 # Source shared heartbeat library
 source "$SCRIPT_DIR/lib/heartbeat.sh"
 
@@ -1197,6 +1201,7 @@ show_help() {
     echo "  MAX_RETRIES           Max retries per bug (default: 3)"
     echo "  SESSION_TIMEOUT       Session timeout in seconds (default: 0 = no limit)"
     echo "  MODEL                 Default AI model (overridden by per-bug model in bug list)"
+    echo "  PRIZMKIT_EFFORT       AI reasoning effort (low|medium|high|xhigh|max; max is Claude Code only)"
     echo "  PIPELINE_MODE         Default pipeline mode: lite|standard|full (overridden by --mode)"
     echo "  ENABLE_CRITIC         Enable/disable critic: true|false|1|0 (overridden by --critic/--no-critic)"
     echo "  AI_CLI                AI CLI command name (auto-detected: cbc, claude, or codex)"

package/bundled/dev-pipeline/run-feature.sh

@@ -54,6 +54,7 @@ LOG_RETENTION_DAYS=${LOG_RETENTION_DAYS:-14}
 LOG_MAX_TOTAL_MB=${LOG_MAX_TOTAL_MB:-1024}
 VERBOSE=${VERBOSE:-0}
 MODEL=${MODEL:-""}
+PRIZMKIT_EFFORT=${PRIZMKIT_EFFORT:-""}
 DEV_BRANCH=${DEV_BRANCH:-""}
 AUTO_PUSH=${AUTO_PUSH:-0}
 STOP_ON_FAILURE=${STOP_ON_FAILURE:-0}
@@ -62,6 +63,9 @@ ENABLE_DEPLOY=${ENABLE_DEPLOY:-0}
 # Source shared common helpers (CLI/platform detection + logs + deps)
 prizm_detect_cli_and_platform
 
+# Validate PRIZMKIT_EFFORT early (fail-fast before any sessions are spawned)
+prizm_validate_effort
+
 # Source shared heartbeat library
 source "$SCRIPT_DIR/lib/heartbeat.sh"
 
@@ -1483,6 +1487,7 @@ show_help() {
     echo "  SESSION_TIMEOUT       Session timeout in seconds (default: 0 = no limit)"
     echo "  AI_CLI                AI CLI command name (auto-detected: cbc, claude, or codex)"
     echo "  MODEL                 AI model ID (e.g. claude-opus-4.6, claude-sonnet-4.6, claude-haiku-4.5)"
+    echo "  PRIZMKIT_EFFORT       AI reasoning effort (low|medium|high|xhigh|max; max is Claude Code only)"
     echo "  HEARTBEAT_INTERVAL    Heartbeat log interval in seconds (default: 30)"
     echo "  STALE_KILL_THRESHOLD  Auto-kill session after N seconds of no progress (default: 900)"
     echo "  HEARTBEAT_STALE_THRESHOLD  Heartbeat stale threshold in seconds (default: 600)"

package/bundled/dev-pipeline/run-recovery.sh

@@ -67,11 +67,15 @@ HEARTBEAT_INTERVAL=${HEARTBEAT_INTERVAL:-30}
 STALE_KILL_THRESHOLD=${STALE_KILL_THRESHOLD:-900}
 VERBOSE=${VERBOSE:-0}
 MODEL=${MODEL:-""}
+PRIZMKIT_EFFORT=${PRIZMKIT_EFFORT:-""}
 AUTO_PUSH=${AUTO_PUSH:-0}
 
 # Source shared common helpers (CLI/platform detection + logs + deps)
 prizm_detect_cli_and_platform
 
+# Validate PRIZMKIT_EFFORT early (fail-fast before any sessions are spawned)
+prizm_validate_effort
+
 # Source shared heartbeat library
 source "$SCRIPT_DIR/lib/heartbeat.sh"
 
@@ -106,6 +110,7 @@ Options (for 'run' command):
 Environment Variables:
   SESSION_TIMEOUT       Session timeout in seconds (default: 0 = no limit)
   MODEL                 AI model to use
+  PRIZMKIT_EFFORT       AI reasoning effort (low|medium|high|xhigh|max; max is Claude Code only)
   VERBOSE               Set to 1 for verbose AI CLI output
   HEARTBEAT_INTERVAL    Heartbeat log interval in seconds (default: 30)
   STALE_KILL_THRESHOLD  Auto-kill after N seconds no progress (default: 900)
@@ -117,6 +122,7 @@ Examples:
   ./run-recovery.sh run --dry-run       # Generate prompt, don't execute
   ./run-recovery.sh run --yes           # Skip confirmation prompt
   ./run-recovery.sh run --model claude-opus-4.6
+  PRIZMKIT_EFFORT=high ./run-recovery.sh   # Use high reasoning effort
 HELP
 }
 

package/bundled/dev-pipeline/run-refactor.sh

@@ -52,6 +52,7 @@ LOG_RETENTION_DAYS=${LOG_RETENTION_DAYS:-14}
 LOG_MAX_TOTAL_MB=${LOG_MAX_TOTAL_MB:-1024}
 VERBOSE=${VERBOSE:-0}
 MODEL=${MODEL:-""}
+PRIZMKIT_EFFORT=${PRIZMKIT_EFFORT:-""}
 DEV_BRANCH=${DEV_BRANCH:-""}
 AUTO_PUSH=${AUTO_PUSH:-0}
 STOP_ON_FAILURE=${STOP_ON_FAILURE:-0}
@@ -61,6 +62,9 @@ ENABLE_DEPLOY=${ENABLE_DEPLOY:-0}
 # Source shared common helpers (CLI/platform detection + logs + deps)
 prizm_detect_cli_and_platform
 
+# Validate PRIZMKIT_EFFORT early (fail-fast before any sessions are spawned)
+prizm_validate_effort
+
 # Source shared heartbeat library
 source "$SCRIPT_DIR/lib/heartbeat.sh"
 
@@ -1232,6 +1236,7 @@ show_help() {
     echo "  MAX_RETRIES              Max retries per refactor (default: 3)"
     echo "  SESSION_TIMEOUT          Session timeout in seconds (default: 0 = no limit)"
     echo "  MODEL                    Default AI model (overridden by per-refactor model in refactor list)"
+    echo "  PRIZMKIT_EFFORT          AI reasoning effort (low|medium|high|xhigh|max; max is Claude Code only)"
     echo "  PIPELINE_MODE            Default pipeline mode: lite|standard|full (overridden by --mode)"
     echo "  ENABLE_CRITIC            Enable/disable critic: true|false|1|0 (overridden by --critic/--no-critic)"
     echo "  AI_CLI                   AI CLI command name (auto-detected: cbc, claude, or codex)"

package/bundled/dev-pipeline/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,