prizmkit 1.1.67 → 1.1.69

package/bundled/VERSION.json

@@ -1,5 +1,5 @@
 {
-  "frameworkVersion": "1.1.67",
-  "bundledAt": "2026-06-09T02:37:28.761Z",
-  "bundledFrom": "d4b8c30"
+  "frameworkVersion": "1.1.69",
+  "bundledAt": "2026-06-09T23:54:02.566Z",
+  "bundledFrom": "7453dba"
 }

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

@@ -418,6 +418,46 @@ prizm_start_ai_session() {
     PRIZM_AI_PID=$!
 }
 
+# Detect AI CLI/provider infrastructure failures that are outside the
+# generated code's control. These should be retried without consuming the
+# item's code retry budget.
+prizm_detect_infra_error() {
+    local session_log="${1:-}"
+    local progress_json="${2:-}"
+
+    local haystack=""
+    if [[ -n "$session_log" && -f "$session_log" ]]; then
+        haystack="$(tail -c 65536 "$session_log" 2>/dev/null || true)"
+    fi
+    if [[ -n "$progress_json" && -f "$progress_json" ]]; then
+        haystack+=$'\n'
+        haystack+="$(cat "$progress_json" 2>/dev/null || true)"
+    fi
+
+    [[ -n "$haystack" ]] || return 1
+
+    if printf '%s' "$haystack" | grep -Eiq \
+        'auth_unavailable|no auth available|502 Bad Gateway|503 Service Unavailable|504 Gateway Timeout|gateway timeout|upstream (connect )?error|connection reset|ECONNRESET|ETIMEDOUT|ENOTFOUND|EAI_AGAIN|rate limit|rate_limit|temporarily unavailable|overloaded'; then
+        return 0
+    fi
+
+    return 1
+}
+
+prizm_extract_update_new_status() {
+    python3 -c "
+import json, sys
+raw = sys.stdin.read()
+try:
+    data = json.loads(raw)
+except Exception:
+    sys.exit(0)
+value = data.get('new_status')
+if value:
+    print(value)
+"
+}
+
 # Run an AI CLI session synchronously.
 # Usage: prizm_run_ai_session <prompt_path> <log_path> <model>
 prizm_run_ai_session() {

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

@@ -90,8 +90,8 @@ PY
             fi
             prev_child_activity_signature="$child_activity_signature"
 
-            # Track progress staleness. A Codex parent can sit in `wait`
-            # while child transcripts keep growing, so child activity counts.
+            # Track progress staleness. Parent sessions can sit in a wait/polling
+            # tool while child transcripts keep growing, so child activity counts.
             if [[ $growth -eq 0 && $child_growth -eq 0 ]]; then
                 stale_seconds=$((stale_seconds + heartbeat_interval))
             else
@@ -174,9 +174,9 @@ PY
             fi
 
             # Stale-kill: auto-terminate process if no progress for too long.
-            # Codex parent sessions can sit on the `wait` tool while a spawned
-            # subagent is still doing useful work. Give that valid wait a longer
-            # stale window; normal single-agent stalls still use the base limit.
+            # Parent sessions can wait on spawned work; child transcript growth
+            # counts as progress above, while silent waits still use the active
+            # stale window to surface stuck agents promptly.
             if [[ $effective_stale_kill_threshold -gt 0 && $stale_seconds -ge $effective_stale_kill_threshold ]]; then
                 local stale_mins=$((stale_seconds / 60))
                 echo -e "  ${RED}[HEARTBEAT]${NC} ${mins}m${secs}s | log: ${size_display} | ${RED}STALE-KILL: no progress for ${stale_mins}m (threshold: ${effective_stale_kill_threshold}s)${NC}"

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

@@ -145,6 +145,11 @@ spawn_and_wait_session() {
         log_warn "Session was stale-killed by heartbeat monitor (no progress for too long)"
     fi
 
+    local was_infra_error=false
+    if [[ $exit_code -ne 0 ]] && prizm_detect_infra_error "$session_log" "$progress_json"; then
+        was_infra_error=true
+    fi
+
     # Session summary
     if [[ -f "$session_log" ]]; then
         local final_size=$(wc -c < "$session_log" 2>/dev/null | tr -d ' ')
@@ -162,6 +167,10 @@ spawn_and_wait_session() {
     if [[ $exit_code -eq 124 ]]; then
         log_warn "Session timed out after ${SESSION_TIMEOUT}s"
         session_status="timed_out"
+    elif [[ "$was_infra_error" == true ]]; then
+        log_warn "Session failed due to AI CLI/provider infrastructure error"
+        log_warn "Infrastructure errors are retried without consuming code retry budget"
+        session_status="infra_error"
     elif [[ "$was_stale_killed" == true ]]; then
         log_warn "Session stale-killed (no progress for ${STALE_KILL_THRESHOLD}s)"
         log_warn "Stale-killed sessions are treated as failed; dev branch is preserved for inspection"
@@ -259,14 +268,20 @@ sys.exit(0)
     prizm_detect_subagents "$session_log"
 
     # Update bug status (do NOT commit on dev branch — commit happens after merge)
-    python3 "$SCRIPTS_DIR/update-bug-status.py" \
+    local update_output
+    update_output=$(python3 "$SCRIPTS_DIR/update-bug-status.py" \
         --bug-list "$bug_list" \
         --state-dir "$STATE_DIR" \
         --bug-id "$bug_id" \
         --session-status "$session_status" \
         --session-id "$session_id" \
         --max-retries "$max_retries" \
-        --action update >/dev/null 2>&1 || true
+        --action update 2>&1) || {
+        log_error "Failed to update bug status: $update_output"
+        update_output=""
+    }
+
+    _SPAWN_ITEM_STATUS="$(printf '%s' "$update_output" | prizm_extract_update_new_status)"
 
     _SPAWN_RESULT="$session_status"
 }
@@ -693,6 +708,7 @@ else:
     trap cleanup_single_bug SIGINT SIGTERM
 
     _SPAWN_RESULT=""
+    _SPAWN_ITEM_STATUS=""
 
     # Branch lifecycle: create and checkout bugfix branch
     local _proj_root
@@ -1078,12 +1094,14 @@ DEPLOY_PROMPT_EOF
         # Spawn session
         log_info "Spawning AI CLI session: $session_id"
         _SPAWN_RESULT=""
+        _SPAWN_ITEM_STATUS=""
 
         spawn_and_wait_session \
             "$bug_id" "$bug_list" "$session_id" \
             "$bootstrap_prompt" "$session_dir" "$MAX_RETRIES" "$bug_model" "$_ORIGINAL_BRANCH"
 
         local session_status="$_SPAWN_RESULT"
+        local item_status_after_session="${_SPAWN_ITEM_STATUS:-}"
 
         # Merge per-bug dev branch back to original on success
         if [[ "$session_status" == "success" && -n "$_DEV_BRANCH_NAME" ]]; then
@@ -1112,15 +1130,18 @@ DEPLOY_PROMPT_EOF
         session_count=$((session_count + 1))
         total_subagent_calls=$((total_subagent_calls + _SUBAGENT_COUNT))
 
-        # Stop-on-failure: abort pipeline if task failed and STOP_ON_FAILURE is enabled
-        if [[ "$session_status" != "success" && "$STOP_ON_FAILURE" == "1" ]]; then
+        # Stop-on-failure: abort only after the task is actually marked failed.
+        # Pending retry outcomes, including infrastructure errors, keep running.
+        if [[ "$session_status" != "success" && "$STOP_ON_FAILURE" == "1" && "$item_status_after_session" == "failed" ]]; then
             echo ""
             log_error "════════════════════════════════════════════════════"
-            log_error "  STOP_ON_FAILURE: Pipeline halted after $bug_id failed."
+            log_error "  STOP_ON_FAILURE: Pipeline halted after $bug_id exhausted retries."
             log_error "  Total sessions completed: $session_count"
             log_error "  Set STOP_ON_FAILURE=0 to continue past failures."
             log_error "════════════════════════════════════════════════════"
             break
+        elif [[ "$session_status" != "success" && "$STOP_ON_FAILURE" == "1" ]]; then
+            log_info "STOP_ON_FAILURE: $bug_id is ${item_status_after_session:-unknown}; retry budget not exhausted, continuing."
         fi
 
         # Stuck detection

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

@@ -153,6 +153,11 @@ spawn_and_wait_session() {
         log_warn "Session was stale-killed by heartbeat monitor (no progress for too long)"
     fi
 
+    local was_infra_error=false
+    if [[ $exit_code -ne 0 ]] && prizm_detect_infra_error "$session_log" "$progress_json"; then
+        was_infra_error=true
+    fi
+
     # Show final session summary
     if [[ -f "$session_log" ]]; then
         local final_size=$(wc -c < "$session_log" 2>/dev/null | tr -d ' ')
@@ -172,6 +177,10 @@ spawn_and_wait_session() {
     if [[ $exit_code -eq 124 ]]; then
         log_warn "Session timed out after ${SESSION_TIMEOUT}s"
         session_status="timed_out"
+    elif [[ "$was_infra_error" == true ]]; then
+        log_warn "Session failed due to AI CLI/provider infrastructure error"
+        log_warn "Infrastructure errors are retried without consuming code retry budget"
+        session_status="infra_error"
     elif [[ "$was_stale_killed" == true ]]; then
         log_warn "Session stale-killed (no progress for ${STALE_KILL_THRESHOLD}s)"
         log_warn "Stale-killed sessions are treated as failed; dev branch is preserved for inspection"
@@ -347,6 +356,8 @@ sys.exit(0)
         log_error ".prizmkit/plans/feature-list.json may be out of sync. Manual intervention needed."
     }
 
+    _SPAWN_ITEM_STATUS="$(printf '%s' "$update_output" | prizm_extract_update_new_status)"
+
     # Return status via global variable (avoids $() swallowing stdout)
     _SPAWN_RESULT="$session_status"
 }
@@ -848,6 +859,7 @@ else:
     trap cleanup_single_feature SIGINT SIGTERM
 
     _SPAWN_RESULT=""
+    _SPAWN_ITEM_STATUS=""
 
     # Branch lifecycle: create and checkout feature branch
     local _proj_root
@@ -1300,11 +1312,13 @@ DEPLOY_PROMPT_EOF
             log_info "Feature model: $feature_model"
         fi
         _SPAWN_RESULT=""
+        _SPAWN_ITEM_STATUS=""
 
         spawn_and_wait_session \
             "$feature_id" "$feature_list" "$session_id" \
             "$bootstrap_prompt" "$session_dir" "$MAX_RETRIES" "$feature_model" "$_ORIGINAL_BRANCH"
         local session_status="$_SPAWN_RESULT"
+        local item_status_after_session="${_SPAWN_ITEM_STATUS:-}"
 
         # Merge per-feature dev branch back to original on success
         if [[ "$session_status" == "success" && -n "$_DEV_BRANCH_NAME" ]]; then
@@ -1333,15 +1347,18 @@ DEPLOY_PROMPT_EOF
         session_count=$((session_count + 1))
         total_subagent_calls=$((total_subagent_calls + _SUBAGENT_COUNT))
 
-        # Stop-on-failure: abort pipeline if task failed and STOP_ON_FAILURE is enabled
-        if [[ "$session_status" != "success" && "$STOP_ON_FAILURE" == "1" ]]; then
+        # Stop-on-failure: abort only after the task is actually marked failed.
+        # Pending retry outcomes, including infrastructure errors, keep running.
+        if [[ "$session_status" != "success" && "$STOP_ON_FAILURE" == "1" && "$item_status_after_session" == "failed" ]]; then
             echo ""
             log_error "════════════════════════════════════════════════════"
-            log_error "  STOP_ON_FAILURE: Pipeline halted after $feature_id failed."
+            log_error "  STOP_ON_FAILURE: Pipeline halted after $feature_id exhausted retries."
             log_error "  Total sessions completed: $session_count"
             log_error "  Set STOP_ON_FAILURE=0 to continue past failures."
             log_error "════════════════════════════════════════════════════"
             break
+        elif [[ "$session_status" != "success" && "$STOP_ON_FAILURE" == "1" ]]; then
+            log_info "STOP_ON_FAILURE: $feature_id is ${item_status_after_session:-unknown}; retry budget not exhausted, continuing."
         fi
 
         # Brief pause before next iteration

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

@@ -147,6 +147,11 @@ spawn_and_wait_session() {
         log_warn "Session was stale-killed by heartbeat monitor (no progress for too long)"
     fi
 
+    local was_infra_error=false
+    if [[ $exit_code -ne 0 ]] && prizm_detect_infra_error "$session_log" "$progress_json"; then
+        was_infra_error=true
+    fi
+
     # Session summary
     if [[ -f "$session_log" ]]; then
         local final_size=$(wc -c < "$session_log" 2>/dev/null | tr -d ' ')
@@ -164,6 +169,10 @@ spawn_and_wait_session() {
     if [[ $exit_code -eq 124 ]]; then
         log_warn "Session timed out after ${SESSION_TIMEOUT}s"
         session_status="timed_out"
+    elif [[ "$was_infra_error" == true ]]; then
+        log_warn "Session failed due to AI CLI/provider infrastructure error"
+        log_warn "Infrastructure errors are retried without consuming code retry budget"
+        session_status="infra_error"
     elif [[ "$was_stale_killed" == true ]]; then
         log_warn "Session stale-killed (no progress for ${STALE_KILL_THRESHOLD}s)"
         log_warn "Stale-killed sessions are treated as failed; dev branch is preserved for inspection"
@@ -286,14 +295,20 @@ sys.exit(0)
     fi
 
     # Update refactor status (do NOT commit on dev branch — commit happens after merge)
-    python3 "$SCRIPTS_DIR/update-refactor-status.py" \
+    local update_output
+    update_output=$(python3 "$SCRIPTS_DIR/update-refactor-status.py" \
         --refactor-list "$refactor_list" \
         --state-dir "$STATE_DIR" \
         --refactor-id "$refactor_id" \
         --session-status "$session_status" \
         --session-id "$session_id" \
         --max-retries "$max_retries" \
-        --action update >/dev/null 2>&1 || true
+        --action update 2>&1) || {
+        log_error "Failed to update refactor status: $update_output"
+        update_output=""
+    }
+
+    _SPAWN_ITEM_STATUS="$(printf '%s' "$update_output" | prizm_extract_update_new_status)"
 
     _SPAWN_RESULT="$session_status"
 }
@@ -723,6 +738,7 @@ else:
     trap cleanup_single_refactor SIGINT SIGTERM
 
     _SPAWN_RESULT=""
+    _SPAWN_ITEM_STATUS=""
 
     # Branch lifecycle: create and checkout refactor branch
     local _proj_root
@@ -1114,6 +1130,7 @@ DEPLOY_PROMPT_EOF
         # Spawn session
         log_info "Spawning AI CLI session: $session_id"
         _SPAWN_RESULT=""
+        _SPAWN_ITEM_STATUS=""
 
         spawn_and_wait_session \
             "$refactor_id" "$refactor_list" "$session_id" \
@@ -1130,6 +1147,7 @@ DEPLOY_PROMPT_EOF
         fi
 
         local session_status="$_SPAWN_RESULT"
+        local item_status_after_session="${_SPAWN_ITEM_STATUS:-}"
 
         # Merge per-refactor dev branch back to original on success
         if [[ "$session_status" == "success" && -n "$_DEV_BRANCH_NAME" ]]; then
@@ -1168,15 +1186,18 @@ DEPLOY_PROMPT_EOF
         session_count=$((session_count + 1))
         total_subagent_calls=$((total_subagent_calls + _SUBAGENT_COUNT))
 
-        # Stop-on-failure: abort pipeline if task failed and STOP_ON_FAILURE is enabled
-        if [[ "$session_status" != "success" && "$STOP_ON_FAILURE" == "1" ]]; then
+        # Stop-on-failure: abort only after the task is actually marked failed.
+        # Pending retry outcomes, including infrastructure errors, keep running.
+        if [[ "$session_status" != "success" && "$STOP_ON_FAILURE" == "1" && "$item_status_after_session" == "failed" ]]; then
             echo ""
             log_error "════════════════════════════════════════════════════"
-            log_error "  STOP_ON_FAILURE: Pipeline halted after $refactor_id failed."
+            log_error "  STOP_ON_FAILURE: Pipeline halted after $refactor_id exhausted retries."
             log_error "  Total sessions completed: $session_count"
             log_error "  Set STOP_ON_FAILURE=0 to continue past failures."
             log_error "════════════════════════════════════════════════════"
             break
+        elif [[ "$session_status" != "success" && "$STOP_ON_FAILURE" == "1" ]]; then
+            log_info "STOP_ON_FAILURE: $refactor_id is ${item_status_after_session:-unknown}; retry budget not exhausted, continuing."
         fi
 
         log_info "Pausing 5s before next refactor..."

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

@@ -63,7 +63,8 @@ PHASE_KEYWORDS = {
 class ProgressTracker:
     """Tracks progress state from stream-json events."""
 
-    def __init__(self):
+    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 = ""
@@ -78,12 +79,19 @@ class ProgressTracker:
         self.active_subagent_count = 0
         self.subagent_status_counts = Counter()
         self.codex_child_thread_ids = set()
+        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._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 = []
@@ -195,11 +203,76 @@ class ProgressTracker:
             self.is_active = True
 
         elif event_type == "system":
-            # System events (hooks, init, etc.) — track but don't count as messages
+            # 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()
 
         # ── Claude API raw stream format ────────────────────────────
         elif event_type == "message_start":
@@ -391,16 +464,135 @@ class ProgressTracker:
             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 refresh_child_session_activity(self, force=False):
-        """Refresh Codex child transcript file stats.
+        """Refresh child transcript file stats.
 
         The heartbeat monitor uses this activity signature to treat subagent
-        transcript growth as real progress while the parent Codex session is
-        blocked in `wait`.
+        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.
         """
         previous_signature = self.child_activity_signature
 
-        if not self.codex_child_thread_ids:
+        if not self.codex_child_thread_ids and not self.claude_session_id:
             self.child_session_files = []
             self.child_total_bytes = 0
             self.child_activity_signature = ""
@@ -420,6 +612,7 @@ class ProgressTracker:
                     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._last_child_scan_at = now
 
         files = []
@@ -427,24 +620,22 @@ class ProgressTracker:
         total_bytes = 0
         max_mtime = 0.0
 
-        for thread_id in sorted(self.codex_child_thread_ids):
-            path = self._codex_child_session_paths.get(thread_id)
-            if not path:
-                continue
+        def add_file(kind, identifier, path):
+            nonlocal total_bytes, max_mtime
             try:
                 stat = os.stat(path)
             except OSError:
-                continue
-
+                return
+            path_str = str(path)
             total_bytes += stat.st_size
             max_mtime = max(max_mtime, stat.st_mtime)
-            signature_parts.append(
-                f"{thread_id}:{stat.st_size}:{getattr(stat, 'st_mtime_ns', int(stat.st_mtime * 1_000_000_000))}"
-            )
+            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(
                 {
-                    "thread_id": thread_id,
-                    "path": path,
+                    "kind": kind,
+                    "thread_id": identifier,
+                    "path": path_str,
                     "size": stat.st_size,
                     "mtime": datetime.fromtimestamp(
                         stat.st_mtime, timezone.utc
@@ -452,6 +643,14 @@ class ProgressTracker:
                 }
             )
 
+        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)
+
         self.child_session_files = files
         self.child_total_bytes = total_bytes
         self.child_activity_signature = "|".join(signature_parts)
@@ -519,7 +718,7 @@ def atomic_write_json(data, filepath):
 
 def tail_and_parse(session_log, progress_file, poll_interval=0.5):
     """Tail session log and parse stream-json events."""
-    tracker = ProgressTracker()
+    tracker = ProgressTracker(session_log)
     last_write_state = None
 
     def state_key(state):