prizmkit 1.1.74 → 1.1.76

package/bundled/dev-pipeline-windows/lib/common.ps1

@@ -531,6 +531,26 @@ function Test-PrizmStreamJsonSupport {
   }
 }
 
+function Test-PrizmEffort {
+  param([string]$CliCommand)
+  if ([string]::IsNullOrEmpty($env:PRIZMKIT_EFFORT)) { return }
+
+  $sessionPlatform = Get-PrizmSessionPlatform $CliCommand
+  $valid = @{
+    claude    = @('low', 'medium', 'high', 'xhigh', 'max')
+    codex     = @('low', 'medium', 'high', 'xhigh')
+    codebuddy = @('low', 'medium', 'high', 'xhigh')
+  }
+
+  $allowed = $valid[$sessionPlatform]
+  if ($env:PRIZMKIT_EFFORT -notin $allowed) {
+    Write-Host "ERROR: PRIZMKIT_EFFORT='$env:PRIZMKIT_EFFORT' is not supported by the detected CLI ($sessionPlatform)." -ForegroundColor Red
+    Write-Host "  Supported values for $($sessionPlatform): $($allowed -join ', ')" -ForegroundColor Red
+    Write-Host "  Set `$env:PRIZMKIT_EFFORT to one of the above, or unset it to use the CLI default." -ForegroundColor Red
+    exit 1
+  }
+}
+
 function Start-PrizmProgressParser {
   param(
     [string[]]$PythonCommand,
@@ -656,6 +676,7 @@ function Invoke-PrizmAiSession {
     $cliArgs += @('-p', '--dangerously-skip-permissions')
     if ($env:VERBOSE -in @('1','true','yes','on') -or $useStreamJson) { $cliArgs += '--verbose' }
     if ($useStreamJson) { $cliArgs += @('--output-format', 'stream-json') }
+    if ($env:PRIZMKIT_EFFORT) { $cliArgs += @('--effort', $env:PRIZMKIT_EFFORT) }
     if ($Model) { $cliArgs += @('--model', $Model) }
   } elseif ($sessionPlatform -eq 'codex') {
     $cliArgs += @('--ask-for-approval', 'never', '--sandbox', 'danger-full-access')
@@ -666,11 +687,13 @@ function Invoke-PrizmAiSession {
     $cliArgs += @('exec', '--cd', $ProjectRoot, '--skip-git-repo-check')
     if ($useStreamJson) { $cliArgs += '--json' }
     if ($Model) { $cliArgs += @('--model', $Model) }
+    if ($env:PRIZMKIT_EFFORT) { $cliArgs += @('--config', "model_reasoning_effort=$env:PRIZMKIT_EFFORT") }
     $cliArgs += '-'
   } else {
     $cliArgs += @('--print', '-y')
     if ($env:VERBOSE -in @('1','true','yes','on')) { $cliArgs += '--verbose' }
     if ($useStreamJson) { $cliArgs += @('--output-format', 'stream-json') }
+    if ($env:PRIZMKIT_EFFORT) { $cliArgs += @('--effort', $env:PRIZMKIT_EFFORT) }
     if ($Model) { $cliArgs += @('--model', $Model) }
   }
   $generatedArgs = (($cliArgs | ForEach-Object { ConvertTo-PrizmProcessArgument $_ }) -join ' ')

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

@@ -0,0 +1,439 @@
+#!/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_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
+            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
+
+            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.
+            if [[ "$error_loop_detected" == "true" ]]; then
+                stale_seconds=$effective_stale_kill_threshold
+            elif [[ $growth -eq 0 && $child_growth -eq 0 ]]; then
+                stale_seconds=$((stale_seconds + heartbeat_interval))
+            else
+                stale_seconds=0
+            fi
+
+            local size_display
+            if [[ $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 [[ $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
+}

package/bundled/dev-pipeline-windows/lib/pipeline.ps1

@@ -38,6 +38,9 @@ function Invoke-PrizmPipeline {
     Write-Host "Usage: .\run-$Kind.ps1 run [item-id] [list-path] [--dry-run] [--mode lite|standard|full] [--critic] [--max-retries N] [--timeout seconds]"
     Write-Host "       .\run-$Kind.ps1 status [list-path]"
     Write-Host "       .\run-$Kind.ps1 reset"
+    Write-Host ""
+    Write-Host "Environment Variables:"
+    Write-Host "  PRIZMKIT_EFFORT       AI reasoning effort (low|medium|high|xhigh|max; max is Claude Code only)"
     $global:PRIZM_EXIT_CODE = 0
     return
   }
@@ -182,6 +185,10 @@ function Invoke-PrizmPipeline {
     Write-PrizmInfo "Effective options: mode=$modeLabel critic=$criticLabel maxRetries=$retryLabel timeoutSeconds=$timeoutSeconds staleKillThreshold=$staleKillThreshold dryRun=$dryRun"
   }
 
+  # Validate PRIZMKIT_EFFORT early (fail-fast before any sessions are spawned)
+  $cli = Resolve-PrizmAiCli $paths.ProjectRoot $paths.PrizmkitDir
+  Test-PrizmEffort $cli
+
   if (-not (Test-Path $listPath)) { throw "List file not found: $listPath" }
   $pipelineStatePath = Join-Path $stateDir 'pipeline.json'
   if (-not $dryRun) {

package/bundled/dev-pipeline-windows/run-recovery.ps1

@@ -19,6 +19,16 @@ if ($command -in @('help','--help','-h')) {
   Write-Host '  --dry-run Generate and print the recovery prompt without starting AI'
   Write-Host '  --yes     Accepted for scripted use; no confirmation prompt is shown'
   Write-Host '  --model   Override MODEL for this recovery session'
+  Write-Host ''
+  Write-Host 'Environment Variables:'
+  Write-Host '  PRIZMKIT_EFFORT       AI reasoning effort (low|medium|high|xhigh|max; max is Claude Code only)'
+  Write-Host ''
+  Write-Host 'Examples:'
+  Write-Host '  .\run-recovery.ps1                      # Auto-detect and recover'
+  Write-Host '  .\run-recovery.ps1 detect               # Show what would be recovered'
+  Write-Host '  .\run-recovery.ps1 run --dry-run         # Generate prompt, don''t execute'
+  Write-Host '  .\run-recovery.ps1 run --yes             # Skip confirmation prompt'
+  Write-Host '  $env:PRIZMKIT_EFFORT=''high''; .\run-recovery.ps1   # Use high reasoning effort'
   exit 0
 }
 
@@ -96,6 +106,7 @@ Invoke-PrizmPythonText $python @((Join-Path $paths.ScriptsDir 'generate-recovery
 if ($dryRun) { Get-Content $promptPath; exit 0 }
 $cli = Resolve-PrizmAiCli $paths.ProjectRoot $paths.PrizmkitDir
 $env:PRIZMKIT_PLATFORM = Get-PrizmPlatformFromProject $paths.ProjectRoot $paths.PrizmkitDir $cli
+Test-PrizmEffort $cli
 Write-PrizmInfo "Starting recovery session: $sessionId"
 Write-PrizmInfo "Prompt: $promptPath"
 Write-PrizmInfo "Log: $logPath"