prizmkit 1.1.57 → 1.1.60

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

@@ -0,0 +1,9 @@
+#!/usr/bin/env pwsh
+. "$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

@@ -0,0 +1,9 @@
+#!/usr/bin/env pwsh
+. "$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

@@ -0,0 +1,9 @@
+#!/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

@@ -0,0 +1,9 @@
+#!/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

@@ -0,0 +1,76 @@
+#!/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'
+  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"
+    }
+  }
+}
+
+$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'
+$promptPath = Join-Path $paths.PrizmkitDir 'state\recovery-bootstrap-prompt.md'
+$logPath = Join-Path $paths.PrizmkitDir 'state\recovery-session.log'
+
+Invoke-PrizmPythonText $python @($recoveryDetectScript, '--project-root', $paths.ProjectRoot) | Set-Content -Path $detectionPath -Encoding UTF8
+if ($command -eq 'detect') { Get-Content $detectionPath; exit 0 }
+
+Invoke-PrizmPythonText $python @((Join-Path $paths.ScriptsDir 'generate-recovery-prompt.py'), '--detection-json', $detectionPath, '--project-root', $paths.ProjectRoot, '--session-id', (New-PrizmSessionId 'recovery'), '--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
+$pidPath = Join-Path $paths.PrizmkitDir 'state\recovery-session.pid'
+$exitCode = Invoke-PrizmAiSession -CliCommand $cli -PromptPath $promptPath -LogPath $logPath -ProjectRoot $paths.ProjectRoot -Model $model -PidPath $pidPath
+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

@@ -0,0 +1,9 @@
+#!/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

@@ -0,0 +1,228 @@
+#!/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")
+
+
+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.
+    """
+    status = data.get("status", "")
+
+    if status == "success":
+        return "success"
+    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)

package/bundled/dev-pipeline-windows/scripts/cleanup-logs.py

@@ -0,0 +1,192 @@
+#!/usr/bin/env python3
+"""Clean up pipeline session logs by age and total size.
+
+Targets files under any `.../sessions/.../logs/` directory inside a state dir.
+
+Policies:
+1) Remove files older than retention window.
+2) If total remaining size still exceeds max threshold, remove oldest files first
+   until within threshold.
+
+Usage:
+  python3 cleanup-logs.py --state-dir .prizmkit/state/features
+  python3 cleanup-logs.py --state-dir .prizmkit/state/bugfix --retention-days 30 --max-total-mb 2048
+"""
+
+import argparse
+import json
+import os
+import time
+
+from utils import error_out, setup_logging
+
+LOGGER = setup_logging("cleanup-logs")
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Cleanup pipeline logs by age and total size.")
+    parser.add_argument("--state-dir", required=True, help="State directory to scan")
+    parser.add_argument(
+        "--retention-days",
+        type=int,
+        default=14,
+        help="Delete logs older than this many days (default: 14)",
+    )
+    parser.add_argument(
+        "--max-total-mb",
+        type=int,
+        default=1024,
+        help="Target max total log size in MB after cleanup (default: 1024)",
+    )
+    parser.add_argument("--dry-run", action="store_true", help="Report actions without deleting")
+    return parser.parse_args()
+
+
+def iter_log_files(state_dir):
+    """Yield absolute paths of files inside .../sessions/.../logs/ directories."""
+    for root, _dirs, files in os.walk(state_dir):
+        if os.path.basename(root) != "logs":
+            continue
+
+        normalized = root.replace("\\", "/")
+        if "/sessions/" not in normalized:
+            continue
+
+        for name in files:
+            if name == ".DS_Store":
+                continue
+            yield os.path.join(root, name)
+
+
+def file_info(path):
+    """Return file metadata dict with path, size, and mtime."""
+    st = os.stat(path)
+    return {"path": path, "size": st.st_size, "mtime": st.st_mtime}
+
+
+def remove_file(path, dry_run=False):
+    if dry_run:
+        return True
+    try:
+        os.remove(path)
+        return True
+    except OSError:
+        return False
+
+
+def cleanup_empty_dirs(state_dir, dry_run=False):
+    """Remove empty logs directories bottom-up."""
+    removed = 0
+    for root, dirs, _files in os.walk(state_dir, topdown=False):
+        for d in dirs:
+            full = os.path.join(root, d)
+            if os.path.basename(full) != "logs":
+                continue
+            try:
+                if not os.listdir(full):
+                    if not dry_run:
+                        os.rmdir(full)
+                    removed += 1
+            except OSError:
+                continue
+    return removed
+
+
+def main():
+    args = parse_args()
+    state_dir = os.path.abspath(args.state_dir)
+
+    if not os.path.isdir(state_dir):
+        error_out("State directory not found: {}".format(state_dir), code=2)
+
+    if args.retention_days < 0:
+        error_out("retention-days must be >= 0", code=2)
+    if args.max_total_mb < 0:
+        error_out("max-total-mb must be >= 0", code=2)
+
+    now = time.time()
+    retention_cutoff = now - (args.retention_days * 86400)
+    max_total_bytes = args.max_total_mb * 1024 * 1024
+
+    files = []
+    for path in iter_log_files(state_dir):
+        try:
+            files.append(file_info(path))
+        except OSError:
+            continue
+
+    initial_total = sum(f["size"] for f in files)
+
+    deleted_files = []
+    kept_files = []
+
+    # Step 1: age-based cleanup
+    for f in files:
+        if f["mtime"] < retention_cutoff:
+            if remove_file(f["path"], dry_run=args.dry_run):
+                deleted_files.append({**f, "reason": "retention"})
+            else:
+                kept_files.append(f)
+        else:
+            kept_files.append(f)
+
+    # Step 2: size-based cleanup (oldest first)
+    current_total = sum(f["size"] for f in kept_files)
+    if current_total > max_total_bytes:
+        kept_files.sort(key=lambda x: x["mtime"])  # oldest first
+        still_kept = []
+        for f in kept_files:
+            if current_total <= max_total_bytes:
+                still_kept.append(f)
+                continue
+
+            if remove_file(f["path"], dry_run=args.dry_run):
+                deleted_files.append({**f, "reason": "size"})
+                current_total -= f["size"]
+            else:
+                still_kept.append(f)
+
+        kept_files = still_kept
+
+    removed_empty_log_dirs = cleanup_empty_dirs(state_dir, dry_run=args.dry_run)
+
+    final_total = sum(f["size"] for f in kept_files)
+    reclaimed = initial_total - final_total
+
+    report = {
+        "success": True,
+        "state_dir": state_dir,
+        "dry_run": args.dry_run,
+        "retention_days": args.retention_days,
+        "max_total_mb": args.max_total_mb,
+        "initial_files": len(files),
+        "deleted_files": len(deleted_files),
+        "deleted_by_reason": {
+            "retention": sum(1 for f in deleted_files if f["reason"] == "retention"),
+            "size": sum(1 for f in deleted_files if f["reason"] == "size"),
+        },
+        "removed_empty_log_dirs": removed_empty_log_dirs,
+        "initial_total_bytes": initial_total,
+        "final_total_bytes": final_total,
+        "reclaimed_bytes": reclaimed,
+    }
+
+    LOGGER.info(
+        "cleanup complete: deleted=%s reclaimed=%sKB",
+        report["deleted_files"],
+        int(report["reclaimed_bytes"] / 1024),
+    )
+
+    print(json.dumps(report, indent=2, ensure_ascii=False))
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except KeyboardInterrupt:
+        error_out("cleanup-logs interrupted", code=130)
+    except SystemExit:
+        raise
+    except Exception as exc:
+        LOGGER.exception("Unhandled exception in cleanup-logs")
+        error_out("cleanup-logs failed: {}".format(str(exc)), code=1)