prizmkit 1.1.100 → 1.1.102

package/bundled/dev-pipeline-windows/scripts/update-bug-status.py

@@ -1,1121 +0,0 @@
-#!/usr/bin/env python3
-"""Core state machine for updating bug status in the bug-fix pipeline.
-
-Handles eight actions:
-  - get_next: Find the next bug to process based on priority and severity
-  - start: Mark a bug as fixing when a session starts
-  - update: Update a bug's status based on session outcome
-  - status: Print a formatted overview of all bugs
-  - pause: Save pipeline state for graceful shutdown
-  - reset: Reset a bug to pending (status + retry count)
-  - clean: Reset + delete session history + delete bugfix artifacts
-  - unskip: Reset skipped bugs back to pending
-
-Usage:
-    python3 update-bug-status.py \
-        --bug-list <path> --state-dir <path> \
-        --action <get_next|start|update|status|pause|reset|clean|unskip> \
-        [--bug-id <id>] [--session-status <status>] \
-        [--session-id <id>] [--max-retries <n>] [--max-infra-retries <n>]
-"""
-
-import argparse
-import json
-import os
-import shutil
-from datetime import datetime, timezone
-
-from utils import (
-    load_json_file,
-    write_json_file,
-    error_out,
-    pad_right,
-    _build_progress_bar,
-)
-
-
-SESSION_STATUS_VALUES = [
-    "success",
-    "partial_resumable",
-    "partial_not_resumable",
-    "failed",
-    "crashed",
-    "timed_out",
-    "infra_error",
-    "context_overflow",
-    "stalled_context_continuation",
-    "commit_missing",
-    "docs_missing",
-    "merge_conflict",
-]
-
-TERMINAL_STATUSES = {"completed", "failed", "skipped", "needs_info"}
-
-# Severity priority (lower value = higher priority)
-SEVERITY_PRIORITY = {
-    "critical": 0,
-    "high": 1,
-    "medium": 2,
-    "low": 3,
-}
-
-
-def parse_args():
-    parser = argparse.ArgumentParser(
-        description="Core state machine for bug-fix pipeline bug status management."
-    )
-    parser.add_argument("--bug-list", required=True, help="Path to the .prizmkit/plans/bug-fix-list.json file")
-    parser.add_argument("--state-dir", required=True, help="Path to the state directory (default: .prizmkit/state/bugfix)")
-    parser.add_argument(
-        "--action", required=True,
-        choices=["get_next", "start", "update", "status", "pause", "reset", "clean", "unskip", "complete"],
-        help="Action to perform",
-    )
-    parser.add_argument("--bug-id", default=None, help="Bug ID (required for 'update'/'reset'/'clean' actions)")
-    parser.add_argument(
-        "--session-status", default=None, choices=SESSION_STATUS_VALUES,
-        help="Session outcome status (required for 'update' action)",
-    )
-    parser.add_argument("--session-id", default=None, help="Session ID (optional, for 'update' action)")
-    parser.add_argument("--max-retries", type=int, default=3, help="Maximum code retry count (default: 3)")
-    parser.add_argument("--max-infra-retries", type=int, default=3, help="Maximum infrastructure retry count (default: 3)")
-    parser.add_argument("--project-root", default=None, help="Project root directory. Required for 'clean' action.")
-    parser.add_argument("--active-dev-branch", default=None, help="Development branch preserved for continuation after context overflow.")
-    parser.add_argument("--base-branch", default=None, help="Original/base branch for continuation branch reuse.")
-    parser.add_argument("--last-fatal-error-code", default=None, help="Fatal runtime error code associated with continuation.")
-    parser.add_argument("--continuation-summary-path", default=None, help="Optional continuation summary artifact path.")
-    parser.add_argument("--no-progress-count", type=int, default=None, help="Consecutive context-overflow sessions without objective progress.")
-    parser.add_argument("--progress-fingerprint", default=None, help="JSON progress fingerprint captured after the session.")
-    return parser.parse_args()
-
-
-def now_iso():
-    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
-
-
-def load_bug_status(state_dir, bug_id):
-    """Load runtime state from status.json for a bug.
-
-    Returns runtime fields only (retry_count, sessions, etc.).
-    The 'status' field is NOT included — status lives exclusively
-    in bug-fix-list.json.
-    """
-    status_path = os.path.join(state_dir, bug_id, "status.json")
-    if not os.path.isfile(status_path):
-        now = now_iso()
-        return {
-            "bug_id": bug_id,
-            "retry_count": 0,
-            "max_retries": 3,
-            "max_infra_retries": 3,
-            "infra_error_count": 0,
-            "last_infra_error_session_id": None,
-            "sessions": [],
-            "last_session_id": None,
-            "resume_from_phase": None,
-            "created_at": now,
-            "updated_at": now,
-        }
-    data, err = load_json_file(status_path)
-    if err:
-        now = now_iso()
-        return {
-            "bug_id": bug_id,
-            "retry_count": 0,
-            "max_retries": 3,
-            "max_infra_retries": 3,
-            "infra_error_count": 0,
-            "last_infra_error_session_id": None,
-            "sessions": [],
-            "last_session_id": None,
-            "resume_from_phase": None,
-            "created_at": now,
-            "updated_at": now,
-        }
-    # Defensively remove status if present (legacy data)
-    data.pop("status", None)
-    return data
-
-
-def save_bug_status(state_dir, bug_id, status_data):
-    """Write the status.json for a bug (runtime fields only)."""
-    # Defensively strip status — it belongs in bug-fix-list.json
-    status_data.pop("status", None)
-    status_path = os.path.join(state_dir, bug_id, "status.json")
-    return write_json_file(status_path, status_data)
-
-
-def get_bug_status_from_list(bug_list_path, bug_id):
-    """Read a single bug's status from bug-fix-list.json."""
-    data, err = load_json_file(bug_list_path)
-    if err:
-        return "pending"
-    for b in data.get("bugs", []):
-        if isinstance(b, dict) and b.get("id") == bug_id:
-            return b.get("status", "pending")
-    return "pending"
-
-
-def update_bug_in_list(bug_list_path, bug_id, new_status):
-    data, err = load_json_file(bug_list_path)
-    if err:
-        return err
-    bugs = data.get("bugs", [])
-    found = False
-    for bug in bugs:
-        if isinstance(bug, dict) and bug.get("id") == bug_id:
-            bug["status"] = new_status
-            found = True
-            break
-    if not found:
-        return "Bug '{}' not found in .prizmkit/plans/bug-fix-list.json".format(bug_id)
-    return write_json_file(bug_list_path, data)
-
-
-CONTINUATION_PENDING_FIELDS = [
-    "active_dev_branch",
-    "base_branch",
-    "continuation_pending",
-    "continuation_reason",
-    "last_context_overflow_session_id",
-    "previous_session_id",
-    "last_fatal_error_code",
-    "continuation_summary_path",
-    "no_progress_count",
-    "last_progress_fingerprint",
-    "needs_attention",
-    "stalled_context_continuation",
-    "stalled_reason",
-]
-
-CONTINUATION_COUNTER_FIELDS = [
-    "context_overflow_count",
-    "continuation_count",
-]
-
-
-def has_pending_continuation_metadata(status_data):
-    """Return True when runtime state still has pending continuation metadata."""
-    return any(key in status_data for key in CONTINUATION_PENDING_FIELDS)
-
-
-def clear_pending_continuation_metadata(status_data):
-    """Clear branch/pending continuation fields while preserving observability counters."""
-    for key in CONTINUATION_PENDING_FIELDS:
-        status_data.pop(key, None)
-
-
-def reset_continuation_metadata(status_data):
-    """Clear all continuation runtime metadata, including manual-reset counters."""
-    clear_pending_continuation_metadata(status_data)
-    for key in CONTINUATION_COUNTER_FIELDS:
-        status_data.pop(key, None)
-
-
-STALL_REASON = "context_overflow_without_git_checkpoint_or_artifact_progress"
-
-
-def _load_progress_fingerprint(raw):
-    if not raw:
-        return None
-    try:
-        return json.loads(raw)
-    except (TypeError, ValueError):
-        return {"unparsed": str(raw)}
-
-
-def _set_continuation_common(status_data, args, session_id):
-    if args.active_dev_branch:
-        status_data["active_dev_branch"] = args.active_dev_branch
-    if args.base_branch:
-        status_data["base_branch"] = args.base_branch
-    status_data["last_context_overflow_session_id"] = session_id
-    status_data["previous_session_id"] = session_id
-    status_data["last_fatal_error_code"] = args.last_fatal_error_code or "context_overflow"
-    if args.continuation_summary_path:
-        status_data["continuation_summary_path"] = args.continuation_summary_path
-    else:
-        status_data.pop("continuation_summary_path", None)
-    if args.no_progress_count is not None:
-        status_data["no_progress_count"] = max(0, args.no_progress_count)
-    fingerprint = _load_progress_fingerprint(args.progress_fingerprint)
-    if fingerprint is not None:
-        status_data["last_progress_fingerprint"] = fingerprint
-    status_data["last_infra_error_session_id"] = None
-    status_data["resume_from_phase"] = None
-    if session_id:
-        status_data["last_session_id"] = session_id
-
-
-def set_context_overflow_continuation_metadata(status_data, args, session_id):
-    """Record continuation metadata for a context-overflow outcome in status.json."""
-    status_data["context_overflow_count"] = status_data.get("context_overflow_count", 0) + 1
-    status_data["continuation_count"] = status_data.get("continuation_count", 0) + 1
-    status_data["continuation_pending"] = True
-    status_data["continuation_reason"] = "context_overflow"
-    status_data.pop("needs_attention", None)
-    status_data.pop("stalled_context_continuation", None)
-    status_data.pop("stalled_reason", None)
-    _set_continuation_common(status_data, args, session_id)
-
-
-def set_stalled_context_continuation_metadata(status_data, args, session_id):
-    """Record no-progress context-overflow stall without consuming retry budgets."""
-    status_data["context_overflow_count"] = status_data.get("context_overflow_count", 0) + 1
-    status_data["continuation_count"] = status_data.get("continuation_count", 0) + 1
-    _set_continuation_common(status_data, args, session_id)
-    status_data["continuation_pending"] = False
-    status_data["continuation_reason"] = STALL_REASON
-    status_data["needs_attention"] = True
-    status_data["stalled_context_continuation"] = True
-    status_data["stalled_reason"] = STALL_REASON
-    if args.no_progress_count is None or args.no_progress_count < 2:
-        status_data["no_progress_count"] = 2
-
-
-def continuation_metadata_summary(status_data):
-    """Return additive continuation fields for CLI JSON outputs."""
-    return {
-        "active_dev_branch": status_data.get("active_dev_branch"),
-        "base_branch": status_data.get("base_branch"),
-        "continuation_pending": status_data.get("continuation_pending", False),
-        "continuation_reason": status_data.get("continuation_reason"),
-        "last_context_overflow_session_id": status_data.get("last_context_overflow_session_id"),
-        "last_fatal_error_code": status_data.get("last_fatal_error_code"),
-        "previous_session_id": status_data.get("previous_session_id"),
-        "context_overflow_count": status_data.get("context_overflow_count", 0),
-        "continuation_count": status_data.get("continuation_count", 0),
-        "no_progress_count": status_data.get("no_progress_count", 0),
-        "last_progress_fingerprint": status_data.get("last_progress_fingerprint"),
-        "needs_attention": status_data.get("needs_attention", False),
-        "stalled_context_continuation": status_data.get("stalled_context_continuation", False),
-        "stalled_reason": status_data.get("stalled_reason"),
-        "continuation_summary_path": status_data.get("continuation_summary_path"),
-    }
-
-
-# ---------------------------------------------------------------------------
-# Action: get_next
-# ---------------------------------------------------------------------------
-
-def action_get_next(bug_list_data, state_dir):
-    """Find the next bug to process.
-
-    Priority logic:
-    1. Skip terminal statuses (completed, failed, skipped, needs_info)
-    2. Prefer in_progress bugs (interrupted session resume) over pending
-    3. Sort by: severity (critical > high > medium > low), then by priority (high > medium > low)
-    """
-    bugs = bug_list_data.get("bugs", [])
-    if not bugs:
-        print("PIPELINE_COMPLETE")
-        return
-
-    # Build status map from bug-fix-list.json (single source of truth)
-    status_map = {}
-    status_data_map = {}
-    for bug in bugs:
-        if not isinstance(bug, dict):
-            continue
-        bid = bug.get("id")
-        if not bid:
-            continue
-        status_map[bid] = bug.get("status", "pending")
-        bs = load_bug_status(state_dir, bid)
-        status_data_map[bid] = bs
-
-    # Check if all bugs are terminal
-    non_terminal = [
-        b for b in bugs
-        if isinstance(b, dict) and b.get("id")
-        and status_map.get(b["id"], "pending") not in TERMINAL_STATUSES
-    ]
-    if not non_terminal:
-        print("PIPELINE_COMPLETE")
-        return
-
-    # Separate in_progress from pending
-    in_progress_bugs = []
-    pending_bugs = []
-    for bug in non_terminal:
-        bid = bug.get("id")
-        bstatus = status_map.get(bid, "pending")
-        if bstatus == "in_progress":
-            in_progress_bugs.append(bug)
-        elif bstatus == "pending":
-            pending_bugs.append(bug)
-
-    _PRIORITY_ORDER = {"high": 0, "medium": 1, "low": 2}
-
-    def sort_key(b):
-        severity = b.get("severity", "medium")
-        sev_order = SEVERITY_PRIORITY.get(severity, 2)
-        priority = _PRIORITY_ORDER.get(b.get("priority", "low"), 2)
-        return (sev_order, priority)
-
-    if in_progress_bugs:
-        candidates = sorted(in_progress_bugs, key=sort_key)
-    elif pending_bugs:
-        candidates = sorted(pending_bugs, key=sort_key)
-    else:
-        # All remaining bugs are in non-terminal but also non-pending/in_progress states
-        print("PIPELINE_BLOCKED")
-        return
-
-    chosen = candidates[0]
-    chosen_id = chosen["id"]
-    chosen_status_data = status_data_map.get(chosen_id, {})
-
-    result = {
-        "bug_id": chosen_id,
-        "title": chosen.get("title", ""),
-        "severity": chosen.get("severity", "medium"),
-        "retry_count": chosen_status_data.get("retry_count", 0),
-        "infra_error_count": chosen_status_data.get("infra_error_count", 0),
-        "resume_from_phase": chosen_status_data.get("resume_from_phase", None),
-    }
-    result.update(continuation_metadata_summary(chosen_status_data))
-    print(json.dumps(result, indent=2, ensure_ascii=False))
-
-
-# ---------------------------------------------------------------------------
-# Action: update
-# ---------------------------------------------------------------------------
-
-def action_update(args, bug_list_path, state_dir):
-    bug_id = args.bug_id
-    session_status = args.session_status
-    session_id = args.session_id
-    max_retries = args.max_retries
-    max_infra_retries = args.max_infra_retries
-
-    if not bug_id:
-        error_out("--bug-id is required for 'update' action")
-        return
-    if not session_status:
-        error_out("--session-status is required for 'update' action")
-        return
-
-    bs = load_bug_status(state_dir, bug_id)
-
-    current_list_status = get_bug_status_from_list(bug_list_path, bug_id)
-
-    # Track what status we write to bug-fix-list.json
-    new_status = current_list_status
-
-    if session_status == "success":
-        bs["infra_error_count"] = 0
-        bs["last_infra_error_session_id"] = None
-        clear_pending_continuation_metadata(bs)
-        new_status = "completed"
-        bs["resume_from_phase"] = None
-        err = update_bug_in_list(bug_list_path, bug_id, "completed")
-        if err:
-            error_out("Failed to update .prizmkit/plans/bug-fix-list.json: {}".format(err))
-            return
-    elif session_status in ("commit_missing", "docs_missing", "merge_conflict"):
-        bs["retry_count"] = bs.get("retry_count", 0) + 1
-
-        if bs["retry_count"] >= max_retries:
-            new_status = "failed"
-        else:
-            new_status = "pending"
-
-        bs["degraded_reason"] = session_status
-        bs["resume_from_phase"] = None
-        bs["sessions"] = []
-        bs["last_session_id"] = None
-
-        err = update_bug_in_list(bug_list_path, bug_id, new_status)
-        if err:
-            error_out("Failed to update .prizmkit/plans/bug-fix-list.json: {}".format(err))
-            return
-    elif session_status == "infra_error":
-        # AI CLI/provider outage, auth failure, gateway error, etc.
-        # Infra failures do not consume the code retry budget, but they still
-        # need their own bounded budget so a flaky provider cannot loop forever.
-        infra_error_count = bs.get("infra_error_count", 0) + 1
-        bs["infra_error_count"] = infra_error_count
-        bs["last_infra_error_session_id"] = session_id
-        bs["max_infra_retries"] = max_infra_retries
-        bs["degraded_reason"] = session_status
-        if session_id:
-            bs["last_session_id"] = session_id
-        bs["resume_from_phase"] = None
-
-        if infra_error_count >= max_infra_retries:
-            new_status = "failed"
-            if session_id:
-                bs["last_failed_session_id"] = session_id
-        else:
-            new_status = "pending"
-
-        err = update_bug_in_list(bug_list_path, bug_id, new_status)
-        if err:
-            error_out("Failed to update .prizmkit/plans/bug-fix-list.json: {}".format(err))
-            return
-    elif session_status == "context_overflow":
-        # Context overflow is continuation state, not code or infra retry state.
-        set_context_overflow_continuation_metadata(bs, args, session_id)
-        new_status = "in_progress"
-        if current_list_status != "in_progress":
-            err = update_bug_in_list(bug_list_path, bug_id, "in_progress")
-            if err:
-                error_out("Failed to update .prizmkit/plans/bug-fix-list.json: {}".format(err))
-                return
-    elif session_status == "stalled_context_continuation":
-        # No-progress context-overflow stall pauses automation without consuming retry budgets.
-        set_stalled_context_continuation_metadata(bs, args, session_id)
-        new_status = "needs_info"
-        err = update_bug_in_list(bug_list_path, bug_id, new_status)
-        if err:
-            error_out("Failed to update .prizmkit/plans/bug-fix-list.json: {}".format(err))
-            return
-    else:
-        bs["retry_count"] = bs.get("retry_count", 0) + 1
-
-        cleaned = cleanup_bug_artifacts(
-            state_dir=state_dir,
-            bug_id=bug_id,
-            project_root=args.project_root,
-        )
-
-        if bs["retry_count"] >= max_retries:
-            new_status = "failed"
-        else:
-            new_status = "pending"
-
-        bs["resume_from_phase"] = None
-        bs["sessions"] = []
-        bs["last_session_id"] = None
-
-        err = update_bug_in_list(bug_list_path, bug_id, new_status)
-        if err:
-            error_out("Failed to update .prizmkit/plans/bug-fix-list.json: {}".format(err))
-            return
-
-    if session_status == "success" and session_id:
-        sessions = bs.get("sessions", [])
-        if session_id not in sessions:
-            sessions.append(session_id)
-        bs["sessions"] = sessions
-        bs["last_session_id"] = session_id
-
-    bs["updated_at"] = now_iso()
-
-    err = save_bug_status(state_dir, bug_id, bs)
-    if err:
-        error_out("Failed to save bug status: {}".format(err))
-        return
-
-    summary = {
-        "action": "update",
-        "bug_id": bug_id,
-        "session_status": session_status,
-        "new_status": new_status,
-        "retry_count": bs["retry_count"],
-        "infra_error_count": bs.get("infra_error_count", 0),
-        "max_infra_retries": max_infra_retries,
-        "resume_from_phase": bs.get("resume_from_phase"),
-        "updated_at": bs["updated_at"],
-    }
-    if session_status in ("commit_missing", "docs_missing", "merge_conflict"):
-        summary["degraded_reason"] = session_status
-        summary["restart_policy"] = "finalization_retry"
-    elif session_status == "infra_error":
-        summary["restart_policy"] = "infra_retry"
-        summary["infra_error_count"] = bs.get("infra_error_count", 0)
-        summary["artifacts_preserved"] = True
-    elif session_status == "context_overflow":
-        summary["restart_policy"] = "context_overflow_continuation"
-        summary.update(continuation_metadata_summary(bs))
-        summary["artifacts_preserved"] = True
-    elif session_status == "stalled_context_continuation":
-        summary["restart_policy"] = "needs_attention"
-        summary.update(continuation_metadata_summary(bs))
-        summary["artifacts_preserved"] = True
-    elif session_status != "success":
-        summary["restart_policy"] = "full_restart"
-        summary["cleanup_performed"] = cleaned
-
-    print(json.dumps(summary, indent=2, ensure_ascii=False))
-
-
-def _default_project_root():
-    env = os.environ.get("PROJECT_ROOT")
-    if env:
-        return os.path.abspath(env)
-    script_dir = os.path.dirname(os.path.abspath(__file__))
-    pipeline_dir = os.path.dirname(script_dir)
-    pipeline_parent = os.path.dirname(pipeline_dir)
-    if os.path.basename(pipeline_parent) == ".prizmkit":
-        return os.path.dirname(pipeline_parent)
-    return pipeline_parent
-
-
-def cleanup_bug_artifacts(state_dir, bug_id, project_root=None):
-    """Delete intermediate artifacts for a failed bug run."""
-    if not project_root:
-        project_root = _default_project_root()
-
-    cleaned = []
-
-    # 1) Remove all session history
-    sessions_dir = os.path.join(state_dir, bug_id, "sessions")
-    sessions_deleted = 0
-    if os.path.isdir(sessions_dir):
-        for entry in os.listdir(sessions_dir):
-            entry_path = os.path.join(sessions_dir, entry)
-            if os.path.isdir(entry_path):
-                shutil.rmtree(entry_path)
-                sessions_deleted += 1
-        cleaned.append("Deleted {} session(s) from {}".format(sessions_deleted, sessions_dir))
-
-    # 2) Remove transient files under bug dir (keep status.json)
-    bug_dir = os.path.join(state_dir, bug_id)
-    if os.path.isdir(bug_dir):
-        for entry in os.listdir(bug_dir):
-            if entry == "status.json" or entry == "sessions":
-                continue
-            entry_path = os.path.join(bug_dir, entry)
-            if os.path.isdir(entry_path):
-                shutil.rmtree(entry_path)
-                cleaned.append("Deleted directory {}".format(entry_path))
-            elif os.path.isfile(entry_path):
-                os.remove(entry_path)
-                cleaned.append("Deleted file {}".format(entry_path))
-
-    # 3) Remove bugfix artifacts
-    bugfix_dir = os.path.join(project_root, ".prizmkit", "bugfix", bug_id)
-    if os.path.isdir(bugfix_dir):
-        file_count = sum(len(files) for _, _, files in os.walk(bugfix_dir))
-        shutil.rmtree(bugfix_dir)
-        cleaned.append("Deleted {} ({} files)".format(bugfix_dir, file_count))
-
-    # 4) Remove shared dev-team workspace
-    dev_team_dir = os.path.join(project_root, ".dev-team")
-    if os.path.isdir(dev_team_dir):
-        file_count = sum(len(files) for _, _, files in os.walk(dev_team_dir))
-        shutil.rmtree(dev_team_dir)
-        cleaned.append("Deleted {} ({} files)".format(dev_team_dir, file_count))
-
-    # 5) (removed: current-session.json no longer used)
-
-    return cleaned
-
-
-def _resolve_project_file(project_root, path):
-    if not path:
-        return None
-    if os.path.isabs(path):
-        target = os.path.abspath(path)
-    else:
-        target = os.path.abspath(os.path.join(project_root, path))
-    root = os.path.abspath(project_root)
-    try:
-        rel = os.path.relpath(target, root)
-    except ValueError:
-        return None
-    if rel == os.pardir or rel.startswith(os.pardir + os.sep):
-        return None
-    return target
-
-
-def cleanup_continuation_artifacts(project_root, status_data, candidate_paths=None):
-    """Delete durable continuation handoff files for a manual clean reset."""
-    candidates = []
-    if isinstance(status_data, dict):
-        candidates.append(status_data.get("continuation_summary_path"))
-    candidates.extend(candidate_paths or [])
-
-    cleaned = []
-    seen = set()
-    for candidate in candidates:
-        target = _resolve_project_file(project_root, candidate)
-        if not target or target in seen:
-            continue
-        seen.add(target)
-        if os.path.basename(target) != "continuation-summary.md":
-            continue
-        if os.path.isfile(target):
-            os.remove(target)
-            cleaned.append("Deleted continuation artifact {}".format(target))
-    return cleaned
-
-
-def load_session_status(state_dir, bug_id, session_id):
-    session_status_path = os.path.join(state_dir, bug_id, "sessions",
-        session_id, "session-status.json"
-    )
-    data, err = load_json_file(session_status_path)
-    if err:
-        return None, err
-    return data, None
-
-
-# ---------------------------------------------------------------------------
-# Action: status
-# ---------------------------------------------------------------------------
-
-COLOR_GREEN = "\033[92m"
-COLOR_YELLOW = "\033[93m"
-COLOR_RED = "\033[91m"
-COLOR_GRAY = "\033[90m"
-COLOR_MAGENTA = "\033[95m"
-COLOR_BOLD = "\033[1m"
-COLOR_RESET = "\033[0m"
-
-BOX_WIDTH = 68
-
-
-SEVERITY_ICONS = {
-    "critical": COLOR_RED + "🔴" + COLOR_RESET,
-    "high": COLOR_MAGENTA + "🟠" + COLOR_RESET,
-    "medium": COLOR_YELLOW + "🟡" + COLOR_RESET,
-    "low": COLOR_GRAY + "🟢" + COLOR_RESET,
-}
-
-
-def action_status(bug_list_data, state_dir):
-    bugs = bug_list_data.get("bugs", [])
-    project_name = bug_list_data.get("project_name", "Unknown")
-
-    counts = {"completed": 0, "in_progress": 0, "failed": 0, "pending": 0, "needs_info": 0, "skipped": 0}
-    bug_lines = []
-
-    for bug in bugs:
-        if not isinstance(bug, dict):
-            continue
-        bid = bug.get("id")
-        title = bug.get("title", "Untitled")
-        severity = bug.get("severity", "medium")
-        if not bid:
-            continue
-
-        bstatus = bug.get("status", "pending")
-        bs = load_bug_status(state_dir, bid)
-        retry_count = bs.get("retry_count", 0)
-        max_retries_val = bs.get("max_retries", 3)
-        resume_phase = bs.get("resume_from_phase")
-
-        if bstatus in counts:
-            counts[bstatus] += 1
-        else:
-            counts["pending"] += 1
-
-        # Status icon
-        if bstatus == "completed":
-            icon = COLOR_GREEN + "[✓]" + COLOR_RESET
-        elif bstatus == "in_progress":
-            icon = COLOR_YELLOW + "[→]" + COLOR_RESET
-        elif bstatus == "failed":
-            icon = COLOR_RED + "[✗]" + COLOR_RESET
-        elif bstatus == "needs_info":
-            icon = COLOR_MAGENTA + "[?]" + COLOR_RESET
-        elif bstatus == "skipped":
-            icon = COLOR_GRAY + "[—]" + COLOR_RESET
-        else:
-            icon = COLOR_GRAY + "[ ]" + COLOR_RESET
-
-        # Severity badge
-        sev_badge = "[{}]".format(severity[:4].upper())
-
-        # Detail
-        detail = ""
-        if bstatus == "in_progress":
-            parts = []
-            if retry_count > 0:
-                parts.append("retry {}/{}".format(retry_count, max_retries_val))
-            if resume_phase is not None:
-                parts.append("CP-BF-{}".format(resume_phase))
-            if parts:
-                detail = " ({})".format(", ".join(parts))
-        elif bstatus == "failed":
-            detail = " (failed after {} retries)".format(retry_count)
-        elif bstatus == "needs_info":
-            detail = " (needs more info)"
-
-        # Colorize
-        if bstatus == "completed":
-            line_content = "{} {} {} {} {}{}".format(
-                bid, icon, sev_badge, COLOR_GREEN + title + COLOR_RESET, "", detail
-            )
-        elif bstatus == "in_progress":
-            line_content = "{} {} {} {} {}{}".format(
-                bid, icon, sev_badge, COLOR_YELLOW + title + COLOR_RESET, "", detail
-            )
-        elif bstatus == "failed":
-            line_content = "{} {} {} {} {}{}".format(
-                bid, icon, sev_badge, COLOR_RED + title + COLOR_RESET, "", detail
-            )
-        elif bstatus == "needs_info":
-            line_content = "{} {} {} {} {}{}".format(
-                bid, icon, sev_badge, COLOR_MAGENTA + title + COLOR_RESET, "", detail
-            )
-        else:
-            line_content = "{} {} {} {} {}{}".format(
-                bid, icon, sev_badge, COLOR_GRAY + title + COLOR_RESET, "", detail
-            )
-
-        bug_lines.append(line_content)
-
-    total = len(bugs)
-    completed = counts["completed"]
-    percent = round(completed / total * 100, 1) if total > 0 else 0.0
-    progress_bar = _build_progress_bar(percent, width=24)
-
-    summary_line = "Total: {} bugs | Completed: {} | In Progress: {}".format(
-        total, completed, counts["in_progress"]
-    )
-    summary_line2 = "Failed: {} | Pending: {} | Needs Info: {} | Skipped: {}".format(
-        counts["failed"], counts["pending"], counts["needs_info"], counts["skipped"]
-    )
-
-    inner = BOX_WIDTH - 2
-    print("╔" + "═" * BOX_WIDTH + "╗")
-    print("║" + pad_right(COLOR_BOLD + "  Bug-Fix Pipeline Status" + COLOR_RESET, inner) + " ║")
-    print("╠" + "═" * BOX_WIDTH + "╣")
-    print("║" + pad_right("  Project: {}".format(project_name), inner) + " ║")
-    print("║" + pad_right("  {}".format(summary_line), inner) + " ║")
-    print("║" + pad_right("  {}".format(summary_line2), inner) + " ║")
-    print("╠" + "─" * BOX_WIDTH + "╣")
-    print("║" + pad_right("  Progress: {}".format(progress_bar), inner) + " ║")
-    print("╠" + "═" * BOX_WIDTH + "╣")
-    for line in bug_lines:
-        print("║" + pad_right("  {}".format(line), inner) + " ║")
-    print("╚" + "═" * BOX_WIDTH + "╝")
-
-
-# ---------------------------------------------------------------------------
-# Action: reset
-# ---------------------------------------------------------------------------
-
-def action_reset(args, bug_list_path, state_dir):
-    bug_id = args.bug_id
-    if not bug_id:
-        error_out("--bug-id is required for 'reset' action")
-        return
-
-    bs = load_bug_status(state_dir, bug_id)
-    old_status = get_bug_status_from_list(bug_list_path, bug_id)
-    old_retry = bs.get("retry_count", 0)
-
-    bs["retry_count"] = 0
-    bs["infra_error_count"] = 0
-    bs["last_infra_error_session_id"] = None
-    bs["sessions"] = []
-    bs["last_session_id"] = None
-    bs["resume_from_phase"] = None
-    reset_continuation_metadata(bs)
-    bs["updated_at"] = now_iso()
-
-    err = save_bug_status(state_dir, bug_id, bs)
-    if err:
-        error_out("Failed to save bug status: {}".format(err))
-        return
-
-    err = update_bug_in_list(bug_list_path, bug_id, "pending")
-    if err:
-        error_out("Failed to update .prizmkit/plans/bug-fix-list.json: {}".format(err))
-        return
-
-    result = {
-        "action": "reset",
-        "bug_id": bug_id,
-        "old_status": old_status,
-        "old_retry_count": old_retry,
-        "new_status": "pending",
-    }
-    print(json.dumps(result, indent=2, ensure_ascii=False))
-
-
-# ---------------------------------------------------------------------------
-# Action: clean
-# ---------------------------------------------------------------------------
-
-def action_clean(args, bug_list_path, state_dir):
-    bug_id = args.bug_id
-    project_root = args.project_root
-
-    if not bug_id:
-        error_out("--bug-id is required for 'clean' action")
-        return
-    if not project_root:
-        error_out("--project-root is required for 'clean' action")
-        return
-
-    cleaned = []
-
-    # 1. Delete session history
-    sessions_dir = os.path.join(state_dir, bug_id, "sessions")
-    sessions_deleted = 0
-    if os.path.isdir(sessions_dir):
-        for entry in os.listdir(sessions_dir):
-            entry_path = os.path.join(sessions_dir, entry)
-            if os.path.isdir(entry_path):
-                shutil.rmtree(entry_path)
-                sessions_deleted += 1
-        cleaned.append("Deleted {} session(s) from {}".format(sessions_deleted, sessions_dir))
-
-    # 2. Delete bugfix artifacts for this bug
-    bugfix_dir = os.path.join(project_root, ".prizmkit", "bugfix", bug_id)
-    if os.path.isdir(bugfix_dir):
-        file_count = sum(len(files) for _, _, files in os.walk(bugfix_dir))
-        shutil.rmtree(bugfix_dir)
-        cleaned.append("Deleted {} ({} files)".format(bugfix_dir, file_count))
-
-    # 3. Delete shared dev-team workspace
-    dev_team_dir = os.path.join(project_root, ".dev-team")
-    if os.path.isdir(dev_team_dir):
-        file_count = sum(len(files) for _, _, files in os.walk(dev_team_dir))
-        shutil.rmtree(dev_team_dir)
-        cleaned.append("Deleted {} ({} files)".format(dev_team_dir, file_count))
-
-    # 4. (removed: current-session.json no longer used)
-
-    # 5. Reset status
-    bs = load_bug_status(state_dir, bug_id)
-    old_status = get_bug_status_from_list(bug_list_path, bug_id)
-    old_retry = bs.get("retry_count", 0)
-
-    continuation_candidates = [
-        os.path.join(".prizmkit", "bugfix", bug_id, "continuation-summary.md"),
-        os.path.join(".prizmkit", "specs", bug_id, "continuation-summary.md"),
-    ]
-    cleaned.extend(cleanup_continuation_artifacts(project_root, bs, continuation_candidates))
-
-    bs["retry_count"] = 0
-    bs["infra_error_count"] = 0
-    bs["last_infra_error_session_id"] = None
-    bs["sessions"] = []
-    bs["last_session_id"] = None
-    bs["resume_from_phase"] = None
-    reset_continuation_metadata(bs)
-    bs["updated_at"] = now_iso()
-
-    err = save_bug_status(state_dir, bug_id, bs)
-    if err:
-        error_out("Failed to save bug status: {}".format(err))
-        return
-
-    err = update_bug_in_list(bug_list_path, bug_id, "pending")
-    if err:
-        error_out("Failed to update .prizmkit/plans/bug-fix-list.json: {}".format(err))
-        return
-
-    result = {
-        "action": "clean",
-        "bug_id": bug_id,
-        "old_status": old_status,
-        "old_retry_count": old_retry,
-        "new_status": "pending",
-        "sessions_deleted": sessions_deleted,
-        "cleaned": cleaned,
-    }
-    print(json.dumps(result, indent=2, ensure_ascii=False))
-
-
-# ---------------------------------------------------------------------------
-# Action: pause
-# ---------------------------------------------------------------------------
-
-def action_pause(state_dir):
-    pipeline_path = os.path.join(state_dir, "pipeline.json")
-    data, err = load_json_file(pipeline_path)
-    if err:
-        data = {"status": "paused", "paused_at": now_iso()}
-    else:
-        data["status"] = "paused"
-        data["paused_at"] = now_iso()
-
-    err = write_json_file(pipeline_path, data)
-    if err:
-        error_out("Failed to write pipeline.json: {}".format(err))
-        return
-
-    result = {
-        "action": "pause",
-        "status": "paused",
-        "paused_at": data["paused_at"],
-    }
-    print(json.dumps(result, indent=2, ensure_ascii=False))
-
-
-# ---------------------------------------------------------------------------
-# Action: start
-# ---------------------------------------------------------------------------
-
-def action_start(args, bug_list_path, state_dir):
-    """Mark a bug as in_progress when a session starts.
-
-    This keeps bug-fix-list.json/state status in sync during execution,
-    instead of only updating after session end.
-    """
-    bug_id = args.bug_id
-    if not bug_id:
-        error_out("--bug-id is required for 'start' action")
-        return
-
-    bs = load_bug_status(state_dir, bug_id)
-    old_status = get_bug_status_from_list(bug_list_path, bug_id)
-
-    bs["updated_at"] = now_iso()
-
-    err = save_bug_status(state_dir, bug_id, bs)
-    if err:
-        error_out("Failed to save bug status: {}".format(err))
-        return
-
-    if old_status != "in_progress":
-        err = update_bug_in_list(bug_list_path, bug_id, "in_progress")
-        if err:
-            error_out("Failed to update .prizmkit/plans/bug-fix-list.json: {}".format(err))
-            return
-
-    result = {
-        "action": "start",
-        "bug_id": bug_id,
-        "old_status": old_status,
-        "new_status": "in_progress",
-        "retry_count": bs.get("retry_count", 0),
-        "infra_error_count": bs.get("infra_error_count", 0),
-        "updated_at": bs["updated_at"],
-    }
-    print(json.dumps(result, indent=2, ensure_ascii=False))
-
-
-# ---------------------------------------------------------------------------
-# Action: unskip
-# ---------------------------------------------------------------------------
-
-def action_unskip(args, bug_list_path, state_dir):
-    """Reset skipped bugs back to pending.
-
-    Two modes:
-    - --bug-id B-001: Reset the specified skipped bug to pending.
-    - No --bug-id: Reset ALL skipped bugs to pending.
-    """
-    bug_id = args.bug_id
-
-    data, err = load_json_file(bug_list_path)
-    if err:
-        error_out("Cannot load bug fix list: {}".format(err))
-        return
-    bugs = data.get("bugs", [])
-
-    to_reset = set()
-
-    if bug_id:
-        # Find the target bug
-        target = None
-        for b in bugs:
-            if isinstance(b, dict) and b.get("id") == bug_id:
-                target = b
-                break
-        if not target:
-            error_out("Bug '{}' not found in .prizmkit/plans/bug-fix-list.json".format(bug_id))
-            return
-        if target.get("status") not in ("failed", "skipped", "needs_info"):
-            error_out(
-                "Bug '{}' has status '{}', expected 'failed', 'skipped', or 'needs_info'".format(
-                    bug_id, target.get("status", "unknown")
-                )
-            )
-            return
-        to_reset.add(bug_id)
-    else:
-        # No bug-id: reset ALL skipped/failed/needs_info bugs
-        for b in bugs:
-            if isinstance(b, dict) and b.get("id"):
-                if b.get("status") in ("failed", "skipped", "needs_info"):
-                    to_reset.add(b["id"])
-
-    if not to_reset:
-        error_out("No bugs to unskip")
-        return
-
-    # Reset all collected bugs in bug-fix-list.json
-    reset_details = []
-    for b in bugs:
-        if isinstance(b, dict) and b.get("id") in to_reset:
-            old_status = b.get("status", "unknown")
-            b["status"] = "pending"
-            reset_details.append({
-                "bug_id": b["id"],
-                "title": b.get("title", ""),
-                "old_status": old_status,
-            })
-
-    err = write_json_file(bug_list_path, data)
-    if err:
-        error_out("Failed to write .prizmkit/plans/bug-fix-list.json: {}".format(err))
-        return
-
-    # Reset runtime fields in status.json for each bug
-    for bid in to_reset:
-        bs = load_bug_status(state_dir, bid)
-        bs["retry_count"] = 0
-        bs["infra_error_count"] = 0
-        bs["last_infra_error_session_id"] = None
-        bs["sessions"] = []
-        bs["last_session_id"] = None
-        bs["resume_from_phase"] = None
-        reset_continuation_metadata(bs)
-        bs["updated_at"] = now_iso()
-        save_bug_status(state_dir, bid, bs)
-
-    result = {
-        "action": "unskip",
-        "reset_count": len(to_reset),
-        "bugs": reset_details,
-    }
-    print(json.dumps(result, indent=2, ensure_ascii=False))
-
-
-# ---------------------------------------------------------------------------
-# Main
-# ---------------------------------------------------------------------------
-
-def main():
-    args = parse_args()
-
-    if args.action == "update":
-        if not args.bug_id:
-            error_out("--bug-id is required for 'update' action")
-        if not args.session_status:
-            error_out("--session-status is required for 'update' action")
-    if args.action in ("start", "reset", "clean", "complete"):
-        if not args.bug_id:
-            error_out("--bug-id is required for '{}' action".format(args.action))
-    if args.action == "clean":
-        if not args.project_root:
-            error_out("--project-root is required for 'clean' action")
-
-    bug_list_data, err = load_json_file(args.bug_list)
-    if err:
-        error_out("Cannot load bug fix list: {}".format(err))
-
-    if args.action == "get_next":
-        action_get_next(bug_list_data, args.state_dir)
-    elif args.action == "start":
-        action_start(args, args.bug_list, args.state_dir)
-    elif args.action == "update":
-        action_update(args, args.bug_list, args.state_dir)
-    elif args.action == "status":
-        action_status(bug_list_data, args.state_dir)
-    elif args.action == "reset":
-        action_reset(args, args.bug_list, args.state_dir)
-    elif args.action == "clean":
-        action_clean(args, args.bug_list, args.state_dir)
-    elif args.action == "pause":
-        action_pause(args.state_dir)
-    elif args.action == "unskip":
-        action_unskip(args, args.bug_list, args.state_dir)
-    elif args.action == "complete":
-        # Shortcut: 'complete' is equivalent to 'update --session-status success'
-        args.session_status = "success"
-        action_update(args, args.bug_list, args.state_dir)
-
-
-if __name__ == "__main__":
-    main()