prizmkit 1.1.83 → 1.1.84

package/bundled/VERSION.json

@@ -1,5 +1,5 @@
 {
-  "frameworkVersion": "1.1.83",
-  "bundledAt": "2026-06-30T06:54:40.455Z",
-  "bundledFrom": "74dab7e"
+  "frameworkVersion": "1.1.84",
+  "bundledAt": "2026-06-30T08:08:52.840Z",
+  "bundledFrom": "3b93824"
 }

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

@@ -403,12 +403,29 @@ prizm_start_ai_session() {
 
     unset CLAUDECODE 2>/dev/null || true
 
-    # Write the prompt to log before launching (defense against stdout truncation)
-    echo "=== PRIZMKIT SESSION START ===" > "$log_path"
-    echo "Prompt: $prompt_path" >> "$log_path"
-    echo "Model: ${model:-default}" >> "$log_path"
-    echo "Started at: $(date -u +%Y-%m-%dT%H:%M:%SZ)" >> "$log_path"
-    echo "--- OUTPUT BELOW ---" >> "$log_path"
+    # Create backup outside project tree. Claude Code subagents can unlink
+    # session.log inside the project, but cannot reach $HOME/.prizmkit/.
+    # tee writes to the backup file while >> redirects to the main log.
+    # If the main log gets severed (unlinked+recreated by subagent),
+    # prizm_recover_session_log copies the backup back when the session ends.
+    local backup_dir="$HOME/.prizmkit/session-backups"
+    mkdir -p "$backup_dir"
+    local session_dir
+    session_dir="$(dirname "$(dirname "$log_path")")"
+    local session_id
+    session_id="$(basename "$session_dir")"
+    local backup_log="$backup_dir/${session_id}.log"
+    PRIZM_BACKUP_LOG="$backup_log"
+
+    # Write preamble to both files
+    {
+        echo "=== PRIZMKIT SESSION START ==="
+        echo "Prompt: $prompt_path"
+        echo "Model: ${model:-default}"
+        echo "Started at: $(date -u +%Y-%m-%dT%H:%M:%SZ)"
+        echo "--- OUTPUT BELOW ---"
+    } > "$log_path"
+    cp "$log_path" "$backup_log"
 
     local session_platform
     session_platform="$(_prizm_session_platform)"
@@ -428,7 +445,7 @@ prizm_start_ai_session() {
             if [[ -n "$model" ]]; then
                 claude_args+=(--model "$model")
             fi
-            "$CLI_CMD" "${claude_args[@]}" >> "$log_path" 2>&1 &
+            "$CLI_CMD" "${claude_args[@]}" 2>&1 | tee -a "$backup_log" >> "$log_path" &
             ;;
         codex)
             local codex_args=(--ask-for-approval never --sandbox danger-full-access)
@@ -447,7 +464,7 @@ prizm_start_ai_session() {
             if [[ -n "${PRIZMKIT_EFFORT:-}" ]]; then
                 codex_args+=(--config "model_reasoning_effort=$PRIZMKIT_EFFORT")
             fi
-            "$CLI_CMD" "${codex_args[@]}" - < "$prompt_path" >> "$log_path" 2>&1 &
+            "$CLI_CMD" "${codex_args[@]}" - < "$prompt_path" 2>&1 | tee -a "$backup_log" >> "$log_path" &
             ;;
         *)
             local cb_args=(--print -y)
@@ -463,7 +480,7 @@ prizm_start_ai_session() {
             if [[ -n "$model" ]]; then
                 cb_args+=(--model "$model")
             fi
-            "$CLI_CMD" "${cb_args[@]}" < "$prompt_path" >> "$log_path" 2>&1 &
+            "$CLI_CMD" "${cb_args[@]}" < "$prompt_path" 2>&1 | tee -a "$backup_log" >> "$log_path" &
             ;;
     esac
     PRIZM_AI_PID=$!
@@ -945,12 +962,25 @@ prizm_run_ai_session() {
 
     unset CLAUDECODE 2>/dev/null || true
 
-    # Write preamble before launching (defense against stdout truncation)
-    echo "=== PRIZMKIT SESSION START ===" > "$log_path"
-    echo "Prompt: $prompt_path" >> "$log_path"
-    echo "Model: ${model:-default}" >> "$log_path"
-    echo "Started at: $(date -u +%Y-%m-%dT%H:%M:%SZ)" >> "$log_path"
-    echo "--- OUTPUT BELOW ---" >> "$log_path"
+    # Create backup outside project tree (same rationale as prizm_start_ai_session)
+    local backup_dir="$HOME/.prizmkit/session-backups"
+    mkdir -p "$backup_dir"
+    local session_dir
+    session_dir="$(dirname "$(dirname "$log_path")")"
+    local session_id
+    session_id="$(basename "$session_dir")"
+    local backup_log="$backup_dir/${session_id}.log"
+    PRIZM_BACKUP_LOG="$backup_log"
+
+    # Write preamble to both files
+    {
+        echo "=== PRIZMKIT SESSION START ==="
+        echo "Prompt: $prompt_path"
+        echo "Model: ${model:-default}"
+        echo "Started at: $(date -u +%Y-%m-%dT%H:%M:%SZ)"
+        echo "--- OUTPUT BELOW ---"
+    } > "$log_path"
+    cp "$log_path" "$backup_log"
 
     local session_platform
     session_platform="$(_prizm_session_platform)"
@@ -964,7 +994,7 @@ prizm_run_ai_session() {
             if [[ -n "$model" ]]; then
                 claude_args+=(--model "$model")
             fi
-            "$CLI_CMD" "${claude_args[@]}" >> "$log_path" 2>&1
+            "$CLI_CMD" "${claude_args[@]}" 2>&1 | tee -a "$backup_log" >> "$log_path"
             ;;
         codex)
             local codex_args=(--ask-for-approval never --sandbox danger-full-access)
@@ -983,7 +1013,7 @@ prizm_run_ai_session() {
             if [[ -n "${PRIZMKIT_EFFORT:-}" ]]; then
                 codex_args+=(--config "model_reasoning_effort=$PRIZMKIT_EFFORT")
             fi
-            "$CLI_CMD" "${codex_args[@]}" - < "$prompt_path" >> "$log_path" 2>&1
+            "$CLI_CMD" "${codex_args[@]}" - < "$prompt_path" 2>&1 | tee -a "$backup_log" >> "$log_path"
             ;;
         *)
             local cb_args=(--print -y)
@@ -993,11 +1023,44 @@ prizm_run_ai_session() {
             if [[ -n "$model" ]]; then
                 cb_args+=(--model "$model")
             fi
-            "$CLI_CMD" "${cb_args[@]}" < "$prompt_path" >> "$log_path" 2>&1
+            "$CLI_CMD" "${cb_args[@]}" < "$prompt_path" 2>&1 | tee -a "$backup_log" >> "$log_path"
             ;;
     esac
 }
 
+# Recover session log from backup if the main log was truncated during execution.
+# Claude Code subagents can unlink session.log at the filesystem level. The backup
+# lives in $HOME/.prizmkit/ — outside the project tree — so it survives.
+#
+# Must be called AFTER the AI CLI process exits and BEFORE the session summary
+# reads session.log. Uses PRIZM_BACKUP_LOG set by prizm_start_ai_session /
+# prizm_run_ai_session.
+prizm_recover_session_log() {
+    local session_log="${1:-}"
+    local backup_log="${PRIZM_BACKUP_LOG:-}"
+
+    if [[ -z "$backup_log" || ! -f "$backup_log" ]]; then
+        return 0
+    fi
+
+    local main_size=0
+    if [[ -f "$session_log" ]]; then
+        main_size=$(wc -c < "$session_log" 2>/dev/null | tr -d ' ')
+    fi
+
+    local backup_size=0
+    backup_size=$(wc -c < "$backup_log" 2>/dev/null | tr -d ' ')
+
+    if [[ "$main_size" -lt 1024 && "$backup_size" -gt "$main_size" ]]; then
+        cp "$backup_log" "$session_log"
+        log_info "Session log recovered from backup (${backup_size}B → $session_log)"
+    fi
+
+    # Clean up backup either way
+    rm -f "$backup_log"
+    return 0
+}
+
 # prizm_detect_subagents <session_log>
 #
 # Scan session log for subagent spawns, count them, and log the result.

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

@@ -139,6 +139,9 @@ spawn_and_wait_session() {
     stop_progress_parser "$parser_pid"
     [[ -n "$watcher_pid" ]] && wait "$watcher_pid" 2>/dev/null || true
 
+    # Recover session log from backup if truncated by subagent stdout redirection
+    prizm_recover_session_log "$session_log"
+
     [[ $exit_code -eq 143 ]] && exit_code=124
 
     # Check for stale-kill marker (heartbeat killed the process due to no progress)
@@ -971,6 +974,9 @@ DEPLOY_PROMPT_EOF
                     prizm_run_ai_session "$deploy_prompt" "$deploy_session_dir/logs/session.log"
                     local deploy_exit=$?
 
+                    # Recover log from backup if truncated
+                    prizm_recover_session_log "$deploy_session_dir/logs/session.log"
+
                     if [[ $deploy_exit -eq 0 ]]; then
                         log_success "Deploy session completed (exit 0)"
                     else

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

@@ -150,6 +150,9 @@ spawn_and_wait_session() {
     stop_progress_parser "$parser_pid"
     [[ -n "$watcher_pid" ]] && wait "$watcher_pid" 2>/dev/null || true
 
+    # Recover session log from backup if truncated by subagent stdout redirection
+    prizm_recover_session_log "$session_log"
+
     # Map SIGTERM (143) to timeout code 124
     if [[ $exit_code -eq 143 ]]; then
         exit_code=124
@@ -1264,6 +1267,9 @@ DEPLOY_PROMPT_EOF
                     prizm_run_ai_session "$deploy_prompt" "$deploy_session_dir/logs/session.log"
                     local deploy_exit=$?
 
+                    # Recover log from backup if truncated
+                    prizm_recover_session_log "$deploy_session_dir/logs/session.log"
+
                     if [[ $deploy_exit -eq 0 ]]; then
                         log_success "Deploy session completed (exit 0)"
                     else

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

@@ -141,6 +141,9 @@ spawn_and_wait_session() {
     stop_progress_parser "$parser_pid"
     [[ -n "$watcher_pid" ]] && wait "$watcher_pid" 2>/dev/null || true
 
+    # Recover session log from backup if truncated by subagent stdout redirection
+    prizm_recover_session_log "$session_log"
+
     [[ $exit_code -eq 143 ]] && exit_code=124
 
     # Check for stale-kill marker (heartbeat killed the process due to no progress)
@@ -1006,6 +1009,9 @@ DEPLOY_PROMPT_EOF
                     prizm_run_ai_session "$deploy_prompt" "$deploy_session_dir/logs/session.log"
                     local deploy_exit=$?
 
+                    # Recover log from backup if truncated
+                    prizm_recover_session_log "$deploy_session_dir/logs/session.log"
+
                     if [[ $deploy_exit -eq 0 ]]; then
                         log_success "Deploy session completed (exit 0)"
                     else

package/bundled/skills/_metadata.json

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

package/package.json

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

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

@@ -1,471 +0,0 @@
-#!/usr/bin/env bash
-# ============================================================
-# dev-pipeline/lib/heartbeat.sh - Shared heartbeat monitoring
-#
-# Provides start_heartbeat / stop_heartbeat functions that read
-# structured progress from progress.json (written by
-# parse-stream-progress.py) and fall back to tail-based monitoring.
-#
-# When stale_kill_threshold is set (>0), the heartbeat monitor will
-# automatically kill the AI CLI process if it shows no progress for
-# the specified duration. This prevents sessions from hanging forever
-# when the AI CLI process doesn't exit after completing its work.
-#
-# Usage:
-#   source "$SCRIPT_DIR/lib/heartbeat.sh"
-#   start_heartbeat "$cli_pid" "$session_log" "$progress_json" "$interval" ["$stale_kill_threshold"]
-#   # ... wait for CLI to finish ...
-#   stop_heartbeat "$_HEARTBEAT_PID"
-#
-# Requires: colors (GREEN, YELLOW, BLUE, NC) and log functions
-# to be defined before sourcing.
-# ============================================================
-
-# Start a heartbeat monitor in the background.
-# Sets _HEARTBEAT_PID to the background process PID.
-#
-# Arguments:
-#   $1 - cli_pid              PID of the AI CLI process to monitor
-#   $2 - session_log          Path to session.log
-#   $3 - progress_json        Path to progress.json (may not exist if stream-json disabled)
-#   $4 - interval             Heartbeat interval in seconds
-#   $5 - stale_kill_threshold (optional) Seconds of no progress before auto-killing the process.
-#                              0 = disabled (default). Recommended: 900 (15 minutes).
-start_heartbeat() {
-    local cli_pid="$1"
-    local session_log="$2"
-    local progress_json="$3"
-    local heartbeat_interval="$4"
-    local stale_kill_threshold="${5:-0}"
-
-    (
-        local elapsed=0
-        local prev_size=0
-        local prev_max_size=0
-        local prev_child_activity_signature=""
-        local stale_seconds=0
-        while kill -0 "$cli_pid" 2>/dev/null; do
-            sleep "$heartbeat_interval"
-            elapsed=$((elapsed + heartbeat_interval))
-            kill -0 "$cli_pid" 2>/dev/null || break
-
-            # Get log file size. If session_log was truncated (e.g. by subagent
-            # stdout redirection severing the file descriptor), detect and flag it.
-            local cur_size=0
-            if [[ -f "$session_log" ]]; then
-                cur_size=$(wc -c < "$session_log" 2>/dev/null || echo 0)
-                cur_size=$(echo "$cur_size" | tr -d ' ')
-            fi
-
-            # Detect log truncation: size dropped to 0 or near-zero after previously
-            # accumulating significant content (>100KB). This indicates the file was
-            # unlinked/truncated by something outside our control while the AI CLI
-            # process is still running.
-            local log_truncated=false
-            if [[ $cur_size -lt 1024 && $prev_max_size -gt 102400 ]]; then
-                log_truncated=true
-            fi
-            # Track the maximum size we've seen for truncation detection
-            local prev_max_size=$prev_max_size
-            if [[ $cur_size -gt $prev_max_size ]]; then
-                prev_max_size=$cur_size
-            fi
-
-            local growth=$((cur_size - prev_size))
-            prev_size=$cur_size
-
-            local child_activity_signature=""
-            local child_total_bytes=0
-            local child_session_count=0
-            if [[ -f "$progress_json" ]]; then
-                local child_activity_data
-                child_activity_data=$(python3 - "$progress_json" <<'PY' 2>/dev/null || true
-import json
-import sys
-
-try:
-    with open(sys.argv[1], "r", encoding="utf-8") as fh:
-        progress = json.load(fh)
-except Exception:
-    sys.exit(0)
-
-signature = str(progress.get("child_activity_signature") or "")
-total_bytes = int(progress.get("child_total_bytes") or 0)
-session_count = len(progress.get("child_session_files") or [])
-print(f"{signature}\t{total_bytes}\t{session_count}")
-PY
-                )
-                if [[ -n "$child_activity_data" ]]; then
-                    IFS=$'\t' read -r child_activity_signature child_total_bytes child_session_count <<< "$child_activity_data"
-                fi
-            fi
-
-            local child_growth=0
-            if [[ -n "$child_activity_signature" && "$child_activity_signature" != "$prev_child_activity_signature" ]]; then
-                child_growth=1
-            fi
-            prev_child_activity_signature="$child_activity_signature"
-
-            local effective_stale_kill_threshold="$stale_kill_threshold"
-            if [[ $stale_kill_threshold -gt 0 && -f "$progress_json" ]]; then
-                local extended_threshold
-                extended_threshold=$(python3 - "$progress_json" "$stale_kill_threshold" <<'PY' 2>/dev/null || true
-import json
-import os
-import sys
-
-progress_path = sys.argv[1]
-base_threshold = int(sys.argv[2])
-
-with open(progress_path, "r", encoding="utf-8") as fh:
-    progress = json.load(fh)
-
-spawn_count = 0
-for tool in progress.get("tool_calls", []):
-    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 (
-    fmt == "codex-json"
-    and progress.get("current_tool") == "wait"
-    and spawn_count > 0
-):
-    configured = os.environ.get("CODEX_WAIT_STALE_KILL_THRESHOLD", "")
-    try:
-        wait_threshold = int(configured)
-    except ValueError:
-        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 [[ "$extended_threshold" =~ ^[0-9]+$ && "$extended_threshold" -gt "$stale_kill_threshold" ]]; then
-                    effective_stale_kill_threshold="$extended_threshold"
-                fi
-            fi
-
-            # Check for error-loop: agent is actively producing output but results are
-            # all read-offset errors or wasted calls. This is a stuck agent that appears
-            # "active" by log growth but is accomplishing nothing.
-            local error_loop_detected=false
-            if [[ $effective_stale_kill_threshold -gt 0 && $growth -gt 0 && -f "$progress_json" ]]; then
-                local error_loop_flag
-                error_loop_flag=$(python3 - "$progress_json" <<'PY' 2>/dev/null || true
-import json, sys
-try:
-    with open(sys.argv[1], encoding="utf-8") as fh:
-        progress = json.load(fh)
-except Exception:
-    raise SystemExit(0)
-errors = progress.get("errors", [])
-if isinstance(errors, list) and len(errors) >= 5:
-    recent = errors[-5:]
-    if all(isinstance(e, dict) and e.get("type") in ("read_offset_overflow", "wasted_call") for e in recent):
-        print("error_loop")
-PY
-                )
-                if [[ "$error_loop_flag" == "error_loop" ]]; then
-                    error_loop_detected=true
-                fi
-            fi
-
-            # Track progress staleness. Parent sessions can sit in a wait/polling
-            # tool while child transcripts keep growing, so child activity counts.
-            # Error loops bypass normal growth-as-progress because the log is only
-            # growing with repeated failed reads or wasted calls.
-            #
-            # When the main session log has been truncated (e.g. by subagent stdout
-            # redirection severing the file descriptor), use child activity as the
-            # primary progress signal — the parent process is still running and children
-            # are still producing output, so this is not a true stall.
-            if [[ "$error_loop_detected" == "true" ]]; then
-                stale_seconds=$effective_stale_kill_threshold
-            elif [[ "$log_truncated" == "true" ]]; then
-                # Log truncated: rely on child growth and CLI process liveness.
-                # Don't increment staleness — the process is still working.
-                if [[ $child_growth -gt 0 ]]; then
-                    stale_seconds=0
-                fi
-                # If neither log nor children grow, this is a real stall
-            elif [[ $growth -le 0 && $child_growth -eq 0 ]]; then
-                stale_seconds=$((stale_seconds + heartbeat_interval))
-            else
-                stale_seconds=0
-            fi
-
-            local size_display
-            if $log_truncated; then
-                size_display="${cur_size}B/TRUNCATED(from ${prev_max_size}B)"
-            elif [[ $cur_size -gt 1048576 ]]; then
-                size_display="$((cur_size / 1048576))MB"
-            elif [[ $cur_size -gt 1024 ]]; then
-                size_display="$((cur_size / 1024))KB"
-            else
-                size_display="${cur_size}B"
-            fi
-            local child_display=""
-            if [[ ${child_total_bytes:-0} -gt 0 ]]; then
-                local child_size_display
-                if [[ $child_total_bytes -gt 1048576 ]]; then
-                    child_size_display="$((child_total_bytes / 1048576))MB"
-                elif [[ $child_total_bytes -gt 1024 ]]; then
-                    child_size_display="$((child_total_bytes / 1024))KB"
-                else
-                    child_size_display="${child_total_bytes}B"
-                fi
-                child_display=" | child: ${child_size_display}"
-                if [[ ${child_session_count:-0} -gt 1 ]]; then
-                    child_display="${child_display}/${child_session_count}"
-                fi
-            fi
-
-            local mins=$((elapsed / 60))
-            local secs=$((elapsed % 60))
-
-            local status_icon
-            if $log_truncated; then
-                status_icon="${RED}⚠${NC}"
-            elif [[ $growth -gt 0 || $child_growth -gt 0 ]]; then
-                status_icon="${GREEN}▶${NC}"
-            else
-                status_icon="${YELLOW}⏸${NC}"
-            fi
-
-            # Fatal provider/runtime errors are terminal; do not wait for the
-            # stale window when progress.json already proves the model cannot
-            # continue (for example context_too_large).
-            if [[ -f "$progress_json" ]]; then
-                local fatal_error_code=""
-                fatal_error_code=$(python3 - "$progress_json" <<'PY' 2>/dev/null || true
-import json
-import sys
-try:
-    with open(sys.argv[1], encoding="utf-8") as fh:
-        progress = json.load(fh)
-except Exception:
-    raise SystemExit(0)
-code = progress.get("fatal_error_code") or ""
-if code:
-    print(code)
-PY
-)
-                if [[ -n "$fatal_error_code" ]]; then
-                    echo -e "  ${RED}[HEARTBEAT]${NC} ${mins}m${secs}s | log: ${size_display} | ${RED}FATAL: ${fatal_error_code}${NC}"
-                    local _marker_dir
-                    _marker_dir="$(dirname "$session_log")"
-                    echo "{\"killed_at\": \"$(date -u +%Y-%m-%dT%H:%M:%SZ)\", \"reason\": \"${fatal_error_code}\", \"fatal_error_code\": \"${fatal_error_code}\", \"stale_seconds\": $stale_seconds, \"threshold\": $effective_stale_kill_threshold}" > "$_marker_dir/fatal-error.json" 2>/dev/null || true
-                    echo "{\"killed_at\": \"$(date -u +%Y-%m-%dT%H:%M:%SZ)\", \"reason\": \"${fatal_error_code}\", \"fatal_error_code\": \"${fatal_error_code}\", \"stale_seconds\": $stale_seconds, \"threshold\": $effective_stale_kill_threshold}" > "$_marker_dir/stale-kill.json" 2>/dev/null || true
-                    kill -TERM "$cli_pid" 2>/dev/null || true
-                    local fatal_kill_grace_seconds="${STALE_KILL_GRACE_SECONDS:-10}"
-                    if [[ $fatal_kill_grace_seconds -gt 0 ]]; then
-                        sleep "$fatal_kill_grace_seconds"
-                    fi
-                    if kill -0 "$cli_pid" 2>/dev/null; then
-                        kill -9 "$cli_pid" 2>/dev/null || true
-                    fi
-                    break
-                fi
-            fi
-
-            # Stale-kill: auto-terminate process if no progress for too long.
-            # 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}"
-                echo -e "  ${RED}[HEARTBEAT]${NC} Killing AI CLI process $cli_pid (stale session)..."
-                # Write the marker before killing. Some CLIs exit quickly, and the
-                # parent runner may stop this heartbeat process immediately after
-                # wait(1) returns.
-                local _marker_dir
-                _marker_dir="$(dirname "$session_log")"
-                echo "{\"killed_at\": \"$(date -u +%Y-%m-%dT%H:%M:%SZ)\", \"reason\": \"stale_session\", \"stale_seconds\": $stale_seconds, \"threshold\": $effective_stale_kill_threshold}" > "$_marker_dir/stale-kill.json" 2>/dev/null || true
-                kill -TERM "$cli_pid" 2>/dev/null || true
-                # Give process 10s to exit gracefully, then force kill
-                local stale_kill_grace_seconds="${STALE_KILL_GRACE_SECONDS:-10}"
-                if [[ $stale_kill_grace_seconds -gt 0 ]]; then
-                    sleep "$stale_kill_grace_seconds"
-                fi
-                if kill -0 "$cli_pid" 2>/dev/null; then
-                    echo -e "  ${RED}[HEARTBEAT]${NC} Process still alive after SIGTERM, sending SIGKILL..."
-                    kill -9 "$cli_pid" 2>/dev/null || true
-                fi
-                break
-            fi
-
-            # Build staleness hint for display
-            local stale_hint=""
-            if [[ $effective_stale_kill_threshold -gt 0 && $stale_seconds -gt 0 ]]; then
-                local stale_mins=$((stale_seconds / 60))
-                local threshold_mins=$((effective_stale_kill_threshold / 60))
-                stale_hint=" | stale: ${stale_mins}m/${threshold_mins}m"
-            fi
-
-            # Try structured progress from progress.json
-            if [[ -f "$progress_json" ]]; then
-                local phase tool msgs tools_total
-                phase=$(python3 -c "
-import json, sys
-try:
-    with open(sys.argv[1]) as f:
-        d = json.load(f)
-    parts = []
-    if d.get('current_phase'):
-        parts.append('phase: ' + d['current_phase'])
-    if d.get('current_tool'):
-        parts.append('tool: ' + d['current_tool'])
-    parts.append('msgs: ' + str(d.get('message_count', 0)))
-    parts.append(str(d.get('total_tool_calls', 0)) + ' tool calls')
-    print(' | '.join(parts))
-except Exception:
-    sys.exit(1)
-" "$progress_json" 2>/dev/null) && {
-                    echo -e "  ${status_icon} ${BLUE}[HEARTBEAT]${NC} ${mins}m${secs}s | log: ${size_display}${child_display} | ${phase}${stale_hint}"
-                    continue
-                }
-            fi
-
-            # Fallback: tail-based activity detection
-            local last_activity=""
-            if [[ -f "$session_log" ]]; then
-                last_activity=$(tail -20 "$session_log" 2>/dev/null | grep -v '^$' | tail -1 | cut -c1-80 || echo "")
-            fi
-
-            echo -e "  ${status_icon} ${BLUE}[HEARTBEAT]${NC} ${mins}m${secs}s elapsed | log: ${size_display}${child_display} (+${growth}B) | ${last_activity}${stale_hint}"
-        done
-    ) &
-    _HEARTBEAT_PID=$!
-}
-
-# Stop a heartbeat monitor process.
-#
-# Arguments:
-#   $1 - heartbeat_pid   PID returned by start_heartbeat
-stop_heartbeat() {
-    local heartbeat_pid="$1"
-    if [[ -n "$heartbeat_pid" ]]; then
-        kill "$heartbeat_pid" 2>/dev/null || true
-        wait "$heartbeat_pid" 2>/dev/null || true
-    fi
-}
-
-# Start the stream-json progress parser as a background process.
-# Sets _PARSER_PID to the background process PID.
-# No-op if USE_STREAM_JSON is not "true".
-#
-# Arguments:
-#   $1 - session_log     Path to session.log
-#   $2 - progress_json   Path to write progress.json
-#   $3 - scripts_dir     Path to scripts/ directory
-start_progress_parser() {
-    local session_log="$1"
-    local progress_json="$2"
-    local scripts_dir="$3"
-
-    _PARSER_PID=""
-
-    if [[ "${USE_STREAM_JSON:-}" != "true" ]]; then
-        return 0
-    fi
-
-    local parser_script="$scripts_dir/parse-stream-progress.py"
-    if [[ ! -f "$parser_script" ]]; then
-        return 0
-    fi
-
-    python3 "$parser_script" \
-        --session-log "$session_log" \
-        --progress-file "$progress_json" &
-    _PARSER_PID=$!
-}
-
-# Stop the progress parser process.
-#
-# Arguments:
-#   $1 - parser_pid   PID returned by start_progress_parser
-stop_progress_parser() {
-    local parser_pid="$1"
-    if [[ -n "$parser_pid" ]]; then
-        kill "$parser_pid" 2>/dev/null || true
-        wait "$parser_pid" 2>/dev/null || true
-    fi
-}
-
-# Detect whether the AI CLI supports structured JSON progress.
-# Sets USE_STREAM_JSON to "true" or "false".
-#
-# Arguments:
-#   $1 - cli_cmd   The AI CLI command
-detect_stream_json_support() {
-    local cli_cmd="$1"
-    USE_STREAM_JSON="false"
-    STREAM_JSON_FORMAT=""
-
-    local session_platform=""
-    session_platform="$(_prizm_known_platform_from_cli "$cli_cmd" 2>/dev/null || true)"
-    if [[ -z "$session_platform" ]]; then
-        case "$(_prizm_normalize_platform "${PRIZMKIT_PLATFORM:-${PLATFORM:-}}")" in
-            codex|claude|codebuddy)
-                session_platform="$(_prizm_normalize_platform "${PRIZMKIT_PLATFORM:-${PLATFORM:-}}")"
-                ;;
-        esac
-    fi
-
-    # CodeBuddy (cbc) always supports stream-json
-    if [[ "$session_platform" == "codebuddy" || "$cli_cmd" == "cbc" ]]; then
-        USE_STREAM_JSON="true"
-        STREAM_JSON_FORMAT="stream-json"
-        export USE_STREAM_JSON STREAM_JSON_FORMAT
-        return 0
-    fi
-
-    # Codex uses `codex exec --json` JSONL, not `--output-format stream-json`.
-    if [[ "$session_platform" == "codex" ]]; then
-        local codex_help
-        codex_help=$("$cli_cmd" exec --help 2>&1) || true
-        if echo "$codex_help" | grep -q -- "--json"; then
-            USE_STREAM_JSON="true"
-            STREAM_JSON_FORMAT="codex-json"
-        fi
-        export USE_STREAM_JSON STREAM_JSON_FORMAT
-        return 0
-    fi
-
-    # For other CLIs, try to detect support via --help output
-    # Use explicit file descriptor to avoid issues in background processes
-    local help_output
-    help_output=$("$cli_cmd" --help 2>&1) || true
-
-    if echo "$help_output" | grep -q "stream-json"; then
-        USE_STREAM_JSON="true"
-        STREAM_JSON_FORMAT="stream-json"
-    fi
-    export USE_STREAM_JSON STREAM_JSON_FORMAT
-}