prizmkit 1.1.100 → 1.1.101

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

@@ -1,121 +0,0 @@
-. "$PSScriptRoot\common.ps1"
-
-function Get-PrizmFeatureSlug {
-  param([string]$ListPath, [string]$FeatureId)
-  $data = Get-Content $ListPath -Raw | ConvertFrom-Json
-  $feature = $data.features | Where-Object { $_.id -eq $FeatureId } | Select-Object -First 1
-  if (-not $feature) { throw "Feature not found in list: $FeatureId" }
-  $numeric = ($FeatureId -replace '^[Ff]-', '').PadLeft(3, '0')
-  $slug = ([string]$feature.title).ToLowerInvariant()
-  $slug = $slug -replace '[^a-z0-9\s-]', ''
-  $slug = ($slug.Trim() -replace '\s+', '-')
-  $slug = ($slug -replace '-+', '-').Trim('-')
-  if (-not $slug) { $slug = 'feature' }
-  return "$numeric-$slug"
-}
-
-function Write-PrizmContinuationResetWarning {
-  param([string]$StatusPath, [string]$ItemId, [string]$Label)
-  if (-not (Test-Path $StatusPath)) { return }
-  try {
-    $status = Get-Content $StatusPath -Raw | ConvertFrom-Json
-  } catch {
-    return
-  }
-  if ($status.continuation_pending -eq $true) {
-    $reason = $status.continuation_reason
-    if (-not $reason) { $reason = 'context_overflow' }
-    Write-PrizmWarn "Continuation pending for $Label $ItemId ($reason). Manual reset will abandon automatic continuation progress."
-    if ($status.active_dev_branch) {
-      Write-PrizmWarn "Pending continuation branch: $($status.active_dev_branch)"
-    }
-  }
-}
-
-function Write-PrizmContinuationResetWarningsForState {
-  param([string]$StateDir, [string]$Label)
-  if (-not (Test-Path $StateDir)) { return }
-  Get-ChildItem -Path $StateDir -Directory -ErrorAction SilentlyContinue | ForEach-Object {
-    Write-PrizmContinuationResetWarning `
-      -StatusPath (Join-Path $_.FullName 'status.json') `
-      -ItemId $_.Name `
-      -Label $Label
-  }
-}
-
-function Invoke-PrizmReset {
-  param(
-    [ValidateSet('feature','bugfix','refactor')][string]$Kind,
-    [string]$ScriptRoot,
-    [string[]]$Args
-  )
-
-  $global:PRIZM_RESET_EXIT_CODE = 0
-  $paths = Initialize-PrizmPaths $ScriptRoot
-  Set-Location $paths.ProjectRoot
-  $python = Resolve-PrizmPython
-
-  $idOption = @{ feature = '--feature-id'; bugfix = '--bug-id'; refactor = '--refactor-id' }[$Kind]
-  $listOption = @{ feature = '--feature-list'; bugfix = '--bug-list'; refactor = '--refactor-list' }[$Kind]
-  $updateScript = @{ feature = 'update-feature-status.py'; bugfix = 'update-bug-status.py'; refactor = 'update-refactor-status.py' }[$Kind]
-  $runScript = @{ feature = 'run-feature.ps1'; bugfix = 'run-bugfix.ps1'; refactor = 'run-refactor.ps1' }[$Kind]
-  $idPattern = @{ feature = '^[Ff]-\d+'; bugfix = '^[Bb]-\d+'; refactor = '^[Rr]-\d+' }[$Kind]
-  $label = @{ feature = 'feature'; bugfix = 'bug'; refactor = 'refactor' }[$Kind]
-  $listPath = Get-PrizmListDefault $Kind $paths.ProjectRoot
-  $stateDir = Get-PrizmStateDir $Kind $paths.ProjectRoot
-  $itemId = $null
-  $clean = $false
-  $runAfterReset = $false
-
-  foreach ($arg in $Args) {
-    switch -Regex ($arg) {
-      '^--clean$' { $clean = $true; continue }
-      '^--run$' { $runAfterReset = $true; continue }
-      '^(--help|-h)$' {
-        Write-Host "Usage: .\reset-$label.ps1 [$($label)-id] [--clean] [--run] [list-path]"
-        Write-Host "  No ID clears the whole $Kind pipeline state."
-        Write-Host "  With an ID, reset only that item. --clean removes item artifacts. --run retries it immediately."
-        return
-      }
-      '^-.*' { Write-PrizmWarn "Ignoring unsupported option: $arg"; continue }
-      default {
-        if (-not $itemId -and $arg -match $idPattern) {
-          $itemId = $arg.ToUpperInvariant()
-        } else {
-          $listPath = $arg
-        }
-      }
-    }
-  }
-
-  if (-not $itemId) {
-    Write-PrizmContinuationResetWarningsForState -StateDir $stateDir -Label $label
-    & (Join-Path $paths.PipelineDir $runScript) reset
-    $global:PRIZM_RESET_EXIT_CODE = $LASTEXITCODE
-    return
-  }
-
-  if (-not (Test-Path $listPath)) { throw "List file not found: $listPath" }
-  New-Item -ItemType Directory -Force -Path $stateDir | Out-Null
-  Write-PrizmContinuationResetWarning `
-    -StatusPath (Join-Path (Join-Path $stateDir $itemId) 'status.json') `
-    -ItemId $itemId `
-    -Label $label
-
-  $action = if ($clean) { 'clean' } else { 'reset' }
-  $resetArgs = @((Join-Path $paths.ScriptsDir $updateScript), $listOption, $listPath, '--state-dir', $stateDir, '--action', $action, $idOption, $itemId)
-  if ($clean) {
-    $resetArgs += @('--project-root', $paths.ProjectRoot)
-    if ($Kind -eq 'feature') {
-      $resetArgs += @('--feature-slug', (Get-PrizmFeatureSlug $listPath $itemId))
-    }
-  }
-
-  Invoke-PrizmPythonText $python $resetArgs
-  Write-PrizmSuccess "Reset $label item: $itemId"
-
-  if ($runAfterReset) {
-    & (Join-Path $paths.PipelineDir $runScript) run $itemId $listPath
-    $global:PRIZM_RESET_EXIT_CODE = $LASTEXITCODE
-  }
-}

package/bundled/dev-pipeline-windows/reset-bug.ps1

@@ -1,10 +0,0 @@
-#!/usr/bin/env pwsh
-# Manual reset entrypoint; shared warning/reset behavior lives in lib/reset.ps1.
-. "$PSScriptRoot\lib\reset.ps1"
-try {
-  Invoke-PrizmReset -Kind bugfix -ScriptRoot $PSScriptRoot -Args $args
-  exit $global:PRIZM_RESET_EXIT_CODE
-} catch {
-  Write-PrizmError $_.Exception.Message
-  exit 1
-}

package/bundled/dev-pipeline-windows/reset-feature.ps1

@@ -1,10 +0,0 @@
-#!/usr/bin/env pwsh
-# Manual reset entrypoint; shared warning/reset behavior lives in lib/reset.ps1.
-. "$PSScriptRoot\lib\reset.ps1"
-try {
-  Invoke-PrizmReset -Kind feature -ScriptRoot $PSScriptRoot -Args $args
-  exit $global:PRIZM_RESET_EXIT_CODE
-} catch {
-  Write-PrizmError $_.Exception.Message
-  exit 1
-}

package/bundled/dev-pipeline-windows/reset-refactor.ps1

@@ -1,10 +0,0 @@
-#!/usr/bin/env pwsh
-# Manual reset entrypoint; shared warning/reset behavior lives in lib/reset.ps1.
-. "$PSScriptRoot\lib\reset.ps1"
-try {
-  Invoke-PrizmReset -Kind refactor -ScriptRoot $PSScriptRoot -Args $args
-  exit $global:PRIZM_RESET_EXIT_CODE
-} catch {
-  Write-PrizmError $_.Exception.Message
-  exit 1
-}

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

@@ -1,9 +0,0 @@
-#!/usr/bin/env pwsh
-. "$PSScriptRoot\lib\pipeline.ps1"
-try {
-  Invoke-PrizmPipeline -Kind bugfix -ScriptRoot $PSScriptRoot -Args $args
-  exit $global:PRIZM_EXIT_CODE
-} catch {
-  Write-PrizmError $_.Exception.Message
-  exit 1
-}

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

@@ -1,9 +0,0 @@
-#!/usr/bin/env pwsh
-. "$PSScriptRoot\lib\pipeline.ps1"
-try {
-  Invoke-PrizmPipeline -Kind feature -ScriptRoot $PSScriptRoot -Args $args
-  exit $global:PRIZM_EXIT_CODE
-} catch {
-  Write-PrizmError $_.Exception.Message
-  exit 1
-}

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

@@ -1,179 +0,0 @@
-#!/usr/bin/env pwsh
-. "$PSScriptRoot\lib\common.ps1"
-$paths = Initialize-PrizmPaths $PSScriptRoot
-Import-PrizmEnv (Join-Path $paths.PrizmkitDir '.env')
-Set-Location $paths.ProjectRoot
-$python = Resolve-PrizmPython
-
-$command = if ($args.Count -gt 0 -and $args[0] -in @('run','detect','help','--help','-h')) { $args[0] } else { 'run' }
-$remaining = if ($args.Count -gt 0 -and $args[0] -in @('run','detect','help','--help','-h')) {
-  if ($args.Count -gt 1) { $args[1..($args.Count - 1)] } else { @() }
-} else {
-  $args
-}
-
-if ($command -in @('help','--help','-h')) {
-  Write-Host 'Usage: .\run-recovery.ps1 [run|detect] [--dry-run] [--yes] [--model <model>]'
-  Write-Host '  run       Auto-detect interrupted workflow and start a recovery AI session'
-  Write-Host '  detect    Print detection report only'
-  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
-}
-
-$dryRun = $false
-$model = $env:MODEL
-for ($i = 0; $i -lt $remaining.Count; $i++) {
-  $arg = $remaining[$i]
-  switch -Regex ($arg) {
-    '^--dry-run$' { $dryRun = $true; continue }
-    '^--yes$' { continue }
-    '^--model$' {
-      if ($i + 1 -ge $remaining.Count) { Write-PrizmError '--model requires a value'; exit 1 }
-      $i++
-      $model = $remaining[$i]
-      continue
-    }
-    default {
-      Write-PrizmWarn "Ignoring unsupported recovery option: $arg"
-    }
-  }
-}
-
-function Get-PrizmRecoveryIntEnv {
-  param([string]$Name, [int]$DefaultValue, [int]$MinimumValue = 0)
-  $value = [Environment]::GetEnvironmentVariable($Name, 'Process')
-  if (-not $value) { return $DefaultValue }
-  $parsed = 0
-  if (-not [int]::TryParse($value, [ref]$parsed) -or $parsed -lt $MinimumValue) {
-    throw "$Name must be an integer >= $MinimumValue`: $value"
-  }
-  return $parsed
-}
-
-$heartbeatInterval = Get-PrizmRecoveryIntEnv 'HEARTBEAT_INTERVAL' 30 1
-$staleKillThreshold = Get-PrizmRecoveryIntEnv 'STALE_KILL_THRESHOLD' 900 0
-$staleKillGraceSeconds = Get-PrizmRecoveryIntEnv 'STALE_KILL_GRACE_SECONDS' 10 0
-
-$recoveryDetectScript = $null
-foreach ($candidate in @(
-  (Join-Path $paths.ProjectRoot '.agents\skills\recovery-workflow\scripts\detect-recovery-state.py'),
-  (Join-Path $paths.ProjectRoot '.claude\command-assets\recovery-workflow\scripts\detect-recovery-state.py'),
-  (Join-Path $paths.ProjectRoot '.codebuddy\skills\recovery-workflow\scripts\detect-recovery-state.py')
-)) {
-  if (Test-Path $candidate) {
-    $recoveryDetectScript = $candidate
-    break
-  }
-}
-if (-not $recoveryDetectScript) {
-  Write-PrizmError 'Recovery detection script not found. Reinstall PrizmKit skills first.'
-  exit 1
-}
-
-$stateDir = Join-Path $paths.PrizmkitDir 'state\recovery'
-New-Item -ItemType Directory -Force -Path $stateDir | Out-Null
-$detectionPath = Join-Path $stateDir 'detection.json'
-
-Invoke-PrizmPythonText $python @($recoveryDetectScript, '--project-root', $paths.ProjectRoot) | Set-Content -Path $detectionPath -Encoding UTF8
-if ($command -eq 'detect') { Get-Content $detectionPath; exit 0 }
-
-$sessionId = New-PrizmSessionId 'recovery'
-$sessionDir = Join-Path $stateDir "sessions\$sessionId"
-$logsDir = Join-Path $sessionDir 'logs'
-New-Item -ItemType Directory -Force -Path $logsDir | Out-Null
-$sessionDetectionPath = Join-Path $sessionDir 'detection.json'
-Copy-Item -Path $detectionPath -Destination $sessionDetectionPath -Force
-$promptPath = Join-Path $sessionDir 'bootstrap-prompt.md'
-$logPath = Join-Path $logsDir 'session.log'
-$progressPath = Join-Path $logsDir 'progress.json'
-$pidPath = Join-Path $logsDir 'ai.pid'
-$staleKillMarker = Join-Path $logsDir 'stale-kill.json'
-
-Invoke-PrizmPythonText $python @((Join-Path $paths.ScriptsDir 'generate-recovery-prompt.py'), '--detection-json', $sessionDetectionPath, '--project-root', $paths.ProjectRoot, '--session-id', $sessionId, '--output', $promptPath)
-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"
-
-$parserProcess = Start-PrizmProgressParser -PythonCommand $python -ScriptsDir $paths.ScriptsDir -SessionLog $logPath -ProgressFile $progressPath -CliCommand $cli
-$job = Start-Job -ScriptBlock {
-  param($commonPath, $cli, $promptPath, $logPath, $projectRoot, $model, $pidPath)
-  . $commonPath
-  Invoke-PrizmAiSession -CliCommand $cli -PromptPath $promptPath -LogPath $logPath -ProjectRoot $projectRoot -Model $model -PidPath $pidPath
-} -ArgumentList (Join-Path $paths.PipelineDir 'lib\common.ps1'), $cli, $promptPath, $logPath, $paths.ProjectRoot, $model, $pidPath
-
-$elapsedSeconds = 0
-$staleSeconds = 0
-$previousLogSize = 0
-$previousProgressSignature = ''
-$previousChildActivitySignature = ''
-$wasStaleKilled = $false
-while ($true) {
-  $completed = Wait-Job $job -Timeout $heartbeatInterval
-  if ($completed) { break }
-
-  $elapsedSeconds += $heartbeatInterval
-  $currentLogSize = 0
-  if (Test-Path $logPath) { $currentLogSize = [int64](Get-Item $logPath).Length }
-  $growth = $currentLogSize - $previousLogSize
-  $previousLogSize = $currentLogSize
-
-  $progressActivity = Get-PrizmProgressActivity -ProgressFile $progressPath
-  $progressSignature = [string]$progressActivity.ProgressSignature
-  $progressAdvanced = ($progressSignature -and $progressSignature -ne $previousProgressSignature)
-  $previousProgressSignature = $progressSignature
-  $childSignature = [string]$progressActivity.ChildSignature
-  $childAdvanced = ($childSignature -and $childSignature -ne $previousChildActivitySignature)
-  $previousChildActivitySignature = $childSignature
-
-  if ($growth -gt 0 -or $childAdvanced -or $progressAdvanced) { $staleSeconds = 0 } else { $staleSeconds += $heartbeatInterval }
-
-  if ($staleKillThreshold -gt 0 -and $staleSeconds -ge $staleKillThreshold) {
-    $wasStaleKilled = $true
-    Write-PrizmWarn "Recovery session stale-killed (no progress for ${staleKillThreshold}s)"
-    Write-PrizmStaleKillMarker $staleKillMarker $staleSeconds $staleKillThreshold
-    Stop-PrizmSessionProcess $pidPath
-    if ($staleKillGraceSeconds -gt 0) { Start-Sleep -Seconds $staleKillGraceSeconds }
-    break
-  }
-}
-
-$exitCode = 0
-if ($wasStaleKilled) {
-  Stop-Job $job
-  Remove-Job $job
-  $exitCode = 143
-} else {
-  try {
-    $exitCode = [int](Receive-Job $job)
-  } catch {
-    Write-PrizmWarn "Recovery session job failed: $($_.Exception.Message)"
-    $exitCode = 1
-  }
-  Remove-Job $job
-}
-Stop-PrizmProgressParser $parserProcess
-
-if (Test-Path $logPath) {
-  $lineCount = (Get-Content $logPath | Measure-Object -Line).Lines
-  $sizeKb = [int](([int64](Get-Item $logPath).Length) / 1024)
-  Write-PrizmInfo "Session log: $lineCount lines, ${sizeKb}KB"
-}
-if ($wasStaleKilled -or (Test-Path $staleKillMarker)) { Write-PrizmWarn "Recovery session was stale-killed." }
-if ($exitCode -eq 0) { Write-PrizmSuccess "Recovery session completed." } else { Write-PrizmError "Recovery session failed. Log: $logPath" }
-exit $exitCode

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

@@ -1,9 +0,0 @@
-#!/usr/bin/env pwsh
-. "$PSScriptRoot\lib\pipeline.ps1"
-try {
-  Invoke-PrizmPipeline -Kind refactor -ScriptRoot $PSScriptRoot -Args $args
-  exit $global:PRIZM_EXIT_CODE
-} catch {
-  Write-PrizmError $_.Exception.Message
-  exit 1
-}

package/bundled/dev-pipeline-windows/scripts/check-session-status.py

@@ -1,301 +0,0 @@
-#!/usr/bin/env python3
-"""Parse a session-status.json file and output a simple status string for the shell runner.
-
-Reads the session status written by an agent at session end, validates required
-fields, and prints a single-line result to stdout. Detailed JSON is written to
-stderr for logging.
-
-Usage:
-    python3 check-session-status.py --status-file <path>
-"""
-
-import argparse
-import json
-import sys
-
-from utils import setup_logging
-
-
-REQUIRED_FIELDS = ["session_id", "status", "timestamp"]
-# At least one of these ID fields must be present (depends on pipeline type)
-ID_FIELDS = ["feature_id", "bug_id", "refactor_id"]
-
-LOGGER = setup_logging("check-session-status")
-
-CONTEXT_OVERFLOW_CODE = "context_overflow"
-CONTEXT_CODE_VALUES = {
-    "context_overflow",
-    "context_too_large",
-    "context_length_exceeded",
-    "model_context_window_exceeded",
-}
-CONTEXT_TEXT_PATTERNS = (
-    "input exceeds the context window",
-    "context window of this model",
-    "context window exceeded",
-    "maximum context length exceeded",
-    "prompt is too long",
-    "too many tokens",
-    "input token count exceeds",
-)
-REQUEST_TOO_LARGE_TEXT = "request too large"
-REQUEST_TOO_LARGE_SEMANTICS = ("context", "token", "tokens", "prompt", "input", "model")
-ERROR_LIKE_STATUSES = {"failed", "crashed", "timed_out", "context_overflow"}
-
-
-def _flatten_values(value):
-    if isinstance(value, dict):
-        values = []
-        for child in value.values():
-            values.extend(_flatten_values(child))
-        return values
-    if isinstance(value, list):
-        values = []
-        for child in value:
-            values.extend(_flatten_values(child))
-        return values
-    if value is None:
-        return []
-    return [str(value)]
-
-
-def _is_error_like_status(data):
-    status = str(data.get("status", "")).lower()
-    if status in ERROR_LIKE_STATUSES:
-        return True
-    if data.get("last_result_is_error") is True or data.get("is_error") is True:
-        return True
-    if data.get("api_error_status") not in (None, ""):
-        return True
-    errors = data.get("errors")
-    return isinstance(errors, list) and len(errors) > 0
-
-
-def has_context_overflow_signal(data):
-    """Return true when session-status data carries a context overflow signal.
-
-    Success remains success: direct status handling happens before this helper.
-    Exact machine codes are accepted only from structured code fields. Natural
-    language context/token phrases require a failed/error-like status or an
-    explicit error field to avoid prompt/documentation false positives.
-    """
-    if not isinstance(data, dict):
-        return False
-    for field in ("fatal_error_code", "api_error_code", "error_code", "stop_reason"):
-        value = data.get(field)
-        if isinstance(value, str) and value.lower() in CONTEXT_CODE_VALUES:
-            return True
-    if not _is_error_like_status(data):
-        return False
-    text = " ".join(_flatten_values(data)).lower()
-    if any(pattern in text for pattern in CONTEXT_TEXT_PATTERNS):
-        return True
-    return REQUEST_TOO_LARGE_TEXT in text and any(
-        semantic in text for semantic in REQUEST_TOO_LARGE_SEMANTICS
-    )
-
-def parse_args():
-    parser = argparse.ArgumentParser(
-        description="Parse session-status.json and output a status string for the shell runner."
-    )
-    parser.add_argument(
-        "--status-file",
-        required=True,
-        help="Path to the session-status.json file",
-    )
-    return parser.parse_args()
-
-
-def load_status_file(path):
-    """Load and parse the session status JSON file.
-
-    Returns (data, error_message). On success error_message is None.
-    """
-    try:
-        with open(path, "r", encoding="utf-8") as f:
-            data = json.load(f)
-    except (IOError, OSError) as e:
-        return None, "Cannot read status file: {}".format(str(e))
-    except (json.JSONDecodeError, ValueError) as e:
-        return None, "Malformed JSON in status file: {}".format(str(e))
-    return data, None
-
-
-def validate_required_fields(data):
-    """Check that all required fields are present and non-empty.
-
-    Returns a list of missing/invalid field names.
-    In addition to the always-required fields, at least one of
-    feature_id / bug_id / refactor_id must be present.
-    """
-    missing = []
-    for field in REQUIRED_FIELDS:
-        if field not in data:
-            missing.append(field)
-        elif not isinstance(data[field], str) or not data[field].strip():
-            missing.append(field)
-
-    # Check that at least one ID field is present and non-empty
-    has_id = any(
-        field in data and isinstance(data[field], str) and data[field].strip()
-        for field in ID_FIELDS
-    )
-    if not has_id:
-        missing.append("feature_id|bug_id|refactor_id")
-
-    return missing
-
-
-def determine_status(data):
-    """Determine the single-line status string from the parsed data.
-
-    Returns one of: success, partial_resumable, partial_not_resumable,
-    failed, commit_missing, docs_missing, merge_conflict, context_overflow.
-    """
-    status = data.get("status", "")
-
-    if status == "success":
-        return "success"
-    if status == "context_overflow" or has_context_overflow_signal(data):
-        return "context_overflow"
-    elif status == "partial":
-        can_resume = data.get("can_resume", False)
-        if can_resume:
-            return "partial_resumable"
-        else:
-            return "partial_not_resumable"
-    elif status == "partial_resumable":
-        return "partial_resumable"
-    elif status == "partial_not_resumable":
-        return "partial_not_resumable"
-    elif status == "failed":
-        return "failed"
-    elif status == "crashed":
-        return "crashed"
-    elif status == "timed_out":
-        return "timed_out"
-    elif status == "commit_missing":
-        return "commit_missing"
-    elif status == "docs_missing":
-        return "docs_missing"
-    elif status == "merge_conflict":
-        return "merge_conflict"
-    else:
-        # Unknown status value — treat as crashed
-        return "crashed"
-
-
-def build_detail_report(data, resolved_status):
-    """Build the detailed JSON report for stderr logging."""
-    errors = data.get("errors", [])
-    error_count = len(errors) if isinstance(errors, list) else 0
-
-    return {
-        "status": resolved_status,
-        "feature_id": data.get("feature_id"),
-        "bug_id": data.get("bug_id"),
-        "refactor_id": data.get("refactor_id"),
-        "completed_phases": data.get("completed_phases", []),
-        "checkpoint_reached": data.get("checkpoint_reached"),
-        "tasks_completed": data.get("tasks_completed", 0),
-        "tasks_total": data.get("tasks_total", 0),
-        "error_count": error_count,
-        "can_resume": data.get("can_resume", False),
-        "resume_from_phase": data.get("resume_from_phase"),
-    }
-
-
-def main():
-    args = parse_args()
-
-    # Load the status file
-    data, load_error = load_status_file(args.status_file)
-    if load_error is not None:
-        # File missing or malformed JSON
-        detail = {
-            "status": "crashed",
-            "feature_id": None,
-            "completed_phases": [],
-            "checkpoint_reached": None,
-            "tasks_completed": 0,
-            "tasks_total": 0,
-            "error_count": 1,
-            "can_resume": False,
-            "resume_from_phase": None,
-            "load_error": load_error,
-        }
-        sys.stderr.write(json.dumps(detail, indent=2, ensure_ascii=False) + "\n")
-        print("crashed")
-        sys.exit(0)
-
-    # Validate required fields
-    missing = validate_required_fields(data)
-    if missing:
-        detail = {
-            "status": "crashed",
-            "feature_id": data.get("feature_id"),
-            "completed_phases": data.get("completed_phases", []),
-            "checkpoint_reached": data.get("checkpoint_reached"),
-            "tasks_completed": data.get("tasks_completed", 0),
-            "tasks_total": data.get("tasks_total", 0),
-            "error_count": 1,
-            "can_resume": False,
-            "resume_from_phase": None,
-            "validation_error": "Missing or invalid required fields: {}".format(
-                ", ".join(missing)
-            ),
-        }
-        sys.stderr.write(json.dumps(detail, indent=2, ensure_ascii=False) + "\n")
-        print("crashed")
-        sys.exit(0)
-
-    # Determine status
-    resolved_status = determine_status(data)
-
-    # Build and emit detail report to stderr
-    detail = build_detail_report(data, resolved_status)
-    sys.stderr.write(json.dumps(detail, indent=2, ensure_ascii=False) + "\n")
-
-    # Emit single-line status to stdout
-    print(resolved_status)
-    sys.exit(0)
-
-
-if __name__ == "__main__":
-    try:
-        main()
-    except KeyboardInterrupt:
-        detail = {
-            "status": "crashed",
-            "feature_id": None,
-            "completed_phases": [],
-            "checkpoint_reached": None,
-            "tasks_completed": 0,
-            "tasks_total": 0,
-            "error_count": 1,
-            "can_resume": False,
-            "resume_from_phase": None,
-            "internal_error": "Interrupted",
-        }
-        sys.stderr.write(json.dumps(detail, indent=2, ensure_ascii=False) + "\n")
-        print("crashed")
-        sys.exit(0)
-    except SystemExit:
-        raise
-    except Exception as exc:
-        LOGGER.exception("Unhandled exception in check-session-status")
-        detail = {
-            "status": "crashed",
-            "feature_id": None,
-            "completed_phases": [],
-            "checkpoint_reached": None,
-            "tasks_completed": 0,
-            "tasks_total": 0,
-            "error_count": 1,
-            "can_resume": False,
-            "resume_from_phase": None,
-            "internal_error": str(exc),
-        }
-        sys.stderr.write(json.dumps(detail, indent=2, ensure_ascii=False) + "\n")
-        print("crashed")
-        sys.exit(0)