prizmkit 1.1.21 → 1.1.24

package/bundled/dev-pipeline/scripts/init-pipeline.py

@@ -283,13 +283,8 @@ def create_state_directory(state_dir, feature_list_path, features):
         sessions_dir = os.path.join(feature_dir, "sessions")
         os.makedirs(sessions_dir, exist_ok=True)
 
-        # Respect existing terminal status from .prizmkit/plans/feature-list.json
-        fl_status = feature.get("status", "pending")
-        init_status = fl_status if fl_status in TERMINAL_STATUSES else "pending"
-
         feature_status = {
             "feature_id": fid,
-            "status": init_status,
             "retry_count": 0,
             "max_retries": 3,
             "sessions": [],

package/bundled/dev-pipeline/scripts/init-refactor-pipeline.py

@@ -325,13 +325,8 @@ def create_state_directory(state_dir, refactor_list_path, refactors):
         sessions_dir = os.path.join(refactor_dir, "sessions")
         os.makedirs(sessions_dir, exist_ok=True)
 
-        # Respect existing terminal status from refactor-list.json
-        rl_status = refactor.get("status", "pending")
-        init_status = rl_status if rl_status in TERMINAL_STATUSES else "pending"
-
         refactor_status = {
             "refactor_id": rid,
-            "status": init_status,
             "retry_count": 0,
             "max_retries": 3,
             "sessions": [],

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

@@ -84,12 +84,17 @@ def now_iso():
 
 
 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, "bugs", bug_id, "status.json")
     if not os.path.isfile(status_path):
         now = now_iso()
         return {
             "bug_id": bug_id,
-            "status": "pending",
             "retry_count": 0,
             "max_retries": 3,
             "sessions": [],
@@ -103,7 +108,6 @@ def load_bug_status(state_dir, bug_id):
         now = now_iso()
         return {
             "bug_id": bug_id,
-            "status": "pending",
             "retry_count": 0,
             "max_retries": 3,
             "sessions": [],
@@ -112,14 +116,30 @@ def load_bug_status(state_dir, bug_id):
             "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, "bugs", 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:
@@ -153,7 +173,7 @@ def action_get_next(bug_list_data, state_dir):
         print("PIPELINE_COMPLETE")
         return
 
-    # Build status map
+    # Build status map from bug-fix-list.json (single source of truth)
     status_map = {}
     status_data_map = {}
     for bug in bugs:
@@ -162,8 +182,8 @@ def action_get_next(bug_list_data, state_dir):
         bid = bug.get("id")
         if not bid:
             continue
+        status_map[bid] = bug.get("status", "pending")
         bs = load_bug_status(state_dir, bid)
-        status_map[bid] = bs.get("status", "pending")
         status_data_map[bid] = bs
 
     # Check if all bugs are terminal
@@ -237,35 +257,30 @@ def action_update(args, bug_list_path, state_dir):
 
     bs = load_bug_status(state_dir, bug_id)
 
+    # Track what status we write to bug-fix-list.json
+    new_status = get_bug_status_from_list(bug_list_path, bug_id)
+
     if session_status == "success":
-        bs["status"] = "completed"
+        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"):
-        # Degraded outcome: keep artifacts for retry (branch preserves work).
-        # Write schema-valid status to bug-fix-list.json ("pending" for retry,
-        # "failed" if max retries exceeded). Store the granular degraded reason
-        # in status.json only (internal pipeline state, not schema-bound).
         bs["retry_count"] = bs.get("retry_count", 0) + 1
 
         if bs["retry_count"] >= max_retries:
-            bs["status"] = "failed"
-            target_status = "failed"
+            new_status = "failed"
         else:
-            # status.json keeps the granular degraded reason for diagnostics
-            bs["status"] = session_status
-            # bug-fix-list.json gets schema-valid "pending" (will be retried)
-            target_status = "pending"
+            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, target_status)
+        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
@@ -279,17 +294,15 @@ def action_update(args, bug_list_path, state_dir):
         )
 
         if bs["retry_count"] >= max_retries:
-            bs["status"] = "failed"
-            target_status = "failed"
+            new_status = "failed"
         else:
-            bs["status"] = "pending"
-            target_status = "pending"
+            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, target_status)
+        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
@@ -312,7 +325,7 @@ def action_update(args, bug_list_path, state_dir):
         "action": "update",
         "bug_id": bug_id,
         "session_status": session_status,
-        "new_status": bs["status"],
+        "new_status": new_status,
         "retry_count": bs["retry_count"],
         "resume_from_phase": bs.get("resume_from_phase"),
         "updated_at": bs["updated_at"],
@@ -432,8 +445,8 @@ def action_status(bug_list_data, state_dir):
         if not bid:
             continue
 
+        bstatus = bug.get("status", "pending")
         bs = load_bug_status(state_dir, bid)
-        bstatus = bs.get("status", "pending")
         retry_count = bs.get("retry_count", 0)
         max_retries_val = bs.get("max_retries", 3)
         resume_phase = bs.get("resume_from_phase")
@@ -537,10 +550,9 @@ def action_reset(args, bug_list_path, state_dir):
         return
 
     bs = load_bug_status(state_dir, bug_id)
-    old_status = bs.get("status", "unknown")
+    old_status = get_bug_status_from_list(bug_list_path, bug_id)
     old_retry = bs.get("retry_count", 0)
 
-    bs["status"] = "pending"
     bs["retry_count"] = 0
     bs["sessions"] = []
     bs["last_session_id"] = None
@@ -613,10 +625,9 @@ def action_clean(args, bug_list_path, state_dir):
 
     # 5. Reset status
     bs = load_bug_status(state_dir, bug_id)
-    old_status = bs.get("status", "unknown")
+    old_status = get_bug_status_from_list(bug_list_path, bug_id)
     old_retry = bs.get("retry_count", 0)
 
-    bs["status"] = "pending"
     bs["retry_count"] = 0
     bs["sessions"] = []
     bs["last_session_id"] = None
@@ -687,9 +698,8 @@ def action_start(args, bug_list_path, state_dir):
         return
 
     bs = load_bug_status(state_dir, bug_id)
-    old_status = bs.get("status", "pending")
+    old_status = get_bug_status_from_list(bug_list_path, bug_id)
 
-    bs["status"] = "in_progress"
     bs["updated_at"] = now_iso()
 
     err = save_bug_status(state_dir, bug_id, bs)
@@ -779,10 +789,9 @@ def action_unskip(args, bug_list_path, state_dir):
         error_out("Failed to write .prizmkit/plans/bug-fix-list.json: {}".format(err))
         return
 
-    # Reset status.json for each bug
+    # Reset runtime fields in status.json for each bug
     for bid in to_reset:
         bs = load_bug_status(state_dir, bid)
-        bs["status"] = "pending"
         bs["retry_count"] = 0
         bs["sessions"] = []
         bs["last_session_id"] = None

package/bundled/dev-pipeline/scripts/update-feature-status.py

@@ -153,24 +153,20 @@ def now_iso():
     return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
 
 
-def load_feature_status(state_dir, feature_id, feature_list_status=None):
-    """Load the status.json for a feature.
+def load_feature_status(state_dir, feature_id):
+    """Load the runtime state from status.json for a feature.
 
-    If the file does not exist, return a default pending status.
-
-    If feature_list_status is a terminal status (completed, failed, skipped),
-    it overrides the status field from status.json. This makes .prizmkit/plans/feature-list.json
-    the single source of truth for terminal statuses, while all other fields
-    (retry_count, sessions, etc.) still come from status.json.
+    Returns runtime fields only (retry_count, sessions, etc.).
+    The 'status' field is NOT included — status lives exclusively
+    in feature-list.json.
     """
     status_path = os.path.join(
         state_dir, "features", feature_id, "status.json"
     )
     if not os.path.isfile(status_path):
         now = now_iso()
-        data = {
+        return {
             "feature_id": feature_id,
-            "status": feature_list_status if feature_list_status else "pending",
             "retry_count": 0,
             "max_retries": 3,
             "sessions": [],
@@ -179,14 +175,11 @@ def load_feature_status(state_dir, feature_id, feature_list_status=None):
             "created_at": now,
             "updated_at": now,
         }
-        return data
     data, err = load_json_file(status_path)
     if err:
-        # If we can't read it, treat as pending
         now = now_iso()
-        data = {
+        return {
             "feature_id": feature_id,
-            "status": feature_list_status if feature_list_status else "pending",
             "retry_count": 0,
             "max_retries": 3,
             "sessions": [],
@@ -195,20 +188,32 @@ def load_feature_status(state_dir, feature_id, feature_list_status=None):
             "created_at": now,
             "updated_at": now,
         }
-    # .prizmkit/plans/feature-list.json wins for terminal statuses
-    if feature_list_status in TERMINAL_STATUSES:
-        data["status"] = feature_list_status
+    # Defensively remove status if present (legacy data)
+    data.pop("status", None)
     return data
 
 
 def save_feature_status(state_dir, feature_id, status_data):
-    """Write the status.json for a feature."""
+    """Write the status.json for a feature (runtime fields only)."""
+    # Defensively strip status — it belongs in feature-list.json
+    status_data.pop("status", None)
     status_path = os.path.join(
         state_dir, "features", feature_id, "status.json"
     )
     return write_json_file(status_path, status_data)
 
 
+def get_feature_status_from_list(feature_list_path, feature_id):
+    """Read a single feature's status from feature-list.json."""
+    data, err = load_json_file(feature_list_path)
+    if err:
+        return "pending"
+    for f in data.get("features", []):
+        if isinstance(f, dict) and f.get("id") == feature_id:
+            return f.get("status", "pending")
+    return "pending"
+
+
 def update_feature_in_list(feature_list_path, feature_id, new_status):
     """Update a feature's status field in .prizmkit/plans/feature-list.json.
 
@@ -389,10 +394,9 @@ def auto_skip_blocked_features(feature_list_path, state_dir, failed_feature_id):
             f["status"] = "auto_skipped"
     write_json_file(feature_list_path, data)
 
-    # Sync status.json for each auto-skipped feature
+    # Update timestamps in status.json for each auto-skipped feature
     for fid in to_skip:
         fs = load_feature_status(state_dir, fid)
-        fs["status"] = "auto_skipped"
         fs["updated_at"] = now_iso()
         save_feature_status(state_dir, fid, fs)
 
@@ -454,18 +458,19 @@ def action_get_next(feature_list_data, state_dir, feature_filter=None):
         return
 
     # Build status map from ALL features (for dependency checking).
+    # Status comes from feature-list.json (the single source of truth).
     # This must happen BEFORE the feature filter is applied, because
     # filtered features may depend on features outside the filter.
     status_map = {}  # feature_id -> status string
-    status_data_map = {}  # feature_id -> full status data
+    status_data_map = {}  # feature_id -> runtime status data (retry_count, etc.)
     for feature in features:
         if not isinstance(feature, dict):
             continue
         fid = feature.get("id")
         if not fid:
             continue
-        fs = load_feature_status(state_dir, fid, feature.get("status"))
-        status_map[fid] = fs.get("status", "pending")
+        status_map[fid] = feature.get("status", "pending")
+        fs = load_feature_status(state_dir, fid)
         status_data_map[fid] = fs
 
     # Apply feature filter: only consider these features as candidates
@@ -576,12 +581,16 @@ def action_update(args, feature_list_path, state_dir):
         return
 
     fs = load_feature_status(state_dir, feature_id)
+    current_list_status = get_feature_status_from_list(feature_list_path, feature_id)
+
+    # Track what status we write to feature-list.json
+    new_status = current_list_status
 
     if session_status == "success":
         # No-op guard: if this exact successful session was already recorded,
         # avoid rewriting state files again (prevents post-commit dirty changes).
         existing_sessions = fs.get("sessions", [])
-        already_completed = fs.get("status") == "completed" and fs.get("resume_from_phase") is None
+        already_completed = current_list_status == "completed" and fs.get("resume_from_phase") is None
         same_session_already_recorded = (
             session_id
             and session_id in existing_sessions
@@ -592,7 +601,7 @@ def action_update(args, feature_list_path, state_dir):
                 "action": "update",
                 "feature_id": feature_id,
                 "session_status": session_status,
-                "new_status": fs.get("status", "completed"),
+                "new_status": "completed",
                 "retry_count": fs.get("retry_count", 0),
                 "resume_from_phase": fs.get("resume_from_phase"),
                 "updated_at": fs.get("updated_at"),
@@ -601,7 +610,7 @@ def action_update(args, feature_list_path, state_dir):
             print(json.dumps(summary, indent=2, ensure_ascii=False))
             return
 
-        fs["status"] = "completed"
+        new_status = "completed"
         fs["resume_from_phase"] = None
         err = update_feature_in_list(feature_list_path, feature_id, "completed")
         if err:
@@ -614,42 +623,33 @@ def action_update(args, feature_list_path, state_dir):
         fs["retry_count"] = fs.get("retry_count", 0) + 1
 
         if fs["retry_count"] >= max_retries:
-            fs["status"] = "failed"
-            target_status = "failed"
+            new_status = "failed"
         else:
-            # status.json keeps the granular degraded reason for diagnostics
-            fs["status"] = session_status
             # feature-list.json gets schema-valid "pending" (will be retried)
-            target_status = "pending"
+            new_status = "pending"
 
         fs["degraded_reason"] = session_status
         fs["resume_from_phase"] = None
         fs["sessions"] = []
         fs["last_session_id"] = None
 
-        err = update_feature_in_list(feature_list_path, feature_id, target_status)
+        err = update_feature_in_list(feature_list_path, feature_id, new_status)
         if err:
             error_out("Failed to update .prizmkit/plans/feature-list.json: {}".format(err))
             return
     else:
         # crashed / failed / timed_out — preserve all artifacts for debugging.
-        # Previous behavior deleted everything via cleanup_feature_artifacts(),
-        # making it impossible to diagnose why the session failed.
         fs["retry_count"] = fs.get("retry_count", 0) + 1
 
         if fs["retry_count"] >= max_retries:
-            fs["status"] = "failed"
-            target_status = "failed"
+            new_status = "failed"
         else:
-            fs["status"] = "pending"
-            target_status = "pending"
+            new_status = "pending"
 
         fs["resume_from_phase"] = None
         # Keep sessions list and last_session_id for debugging
-        # fs["sessions"] = []
-        # fs["last_session_id"] = None
 
-        err = update_feature_in_list(feature_list_path, feature_id, target_status)
+        err = update_feature_in_list(feature_list_path, feature_id, new_status)
         if err:
             error_out("Failed to update .prizmkit/plans/feature-list.json: {}".format(err))
             return
@@ -670,7 +670,7 @@ def action_update(args, feature_list_path, state_dir):
 
     # Auto-skip downstream features when this feature is marked as failed or skipped
     auto_skipped_features = []
-    if fs["status"] in ("failed", "skipped"):
+    if new_status in ("failed", "skipped"):
         auto_skipped_features = auto_skip_blocked_features(
             feature_list_path, state_dir, feature_id
         )
@@ -679,7 +679,7 @@ def action_update(args, feature_list_path, state_dir):
         "action": "update",
         "feature_id": feature_id,
         "session_status": session_status,
-        "new_status": fs["status"],
+        "new_status": new_status,
         "retry_count": fs["retry_count"],
         "resume_from_phase": fs.get("resume_from_phase"),
         "updated_at": fs["updated_at"],
@@ -776,12 +776,12 @@ def _estimate_remaining_time(features, state_dir, counts, feature_list_data=None
     # Complexity weights (used for estimation when no historical data is available)
     COMPLEXITY_WEIGHT = {"low": 1.0, "medium": 2.0, "high": 4.0}
 
-    # Build feature-list status map for terminal status override
+    # Build feature-list status map (status lives in feature-list.json)
     fl_status_map = {}
     if feature_list_data:
         for f in feature_list_data.get("features", []):
             if isinstance(f, dict) and f.get("id"):
-                fl_status_map[f["id"]] = f.get("status")
+                fl_status_map[f["id"]] = f.get("status", "pending")
 
     # Collect completed feature durations grouped by complexity
     duration_by_complexity = {}  # complexity -> [duration_seconds]
@@ -803,8 +803,7 @@ def _estimate_remaining_time(features, state_dir, counts, feature_list_data=None
         fid = feature.get("id")
         if not fid:
             continue
-        fs = load_feature_status(state_dir, fid, fl_status_map.get(fid))
-        if fs.get("status") != "completed":
+        if fl_status_map.get(fid) != "completed":
             continue
         duration = _calc_feature_duration(state_dir, fid)
         if duration is None:
@@ -833,8 +832,7 @@ def _estimate_remaining_time(features, state_dir, counts, feature_list_data=None
         fid = feature.get("id")
         if not fid:
             continue
-        fs = load_feature_status(state_dir, fid, fl_status_map.get(fid))
-        fstatus = fs.get("status", "pending")
+        fstatus = fl_status_map.get(fid, "pending")
         if fstatus in TERMINAL_STATUSES:
             continue
         remaining_count += 1
@@ -910,7 +908,7 @@ def action_status(feature_list_data, state_dir, feature_filter=None):
         fid = feature.get("id")
         if not fid:
             continue
-        fs = load_feature_status(state_dir, fid, feature.get("status"))
+        fs = load_feature_status(state_dir, fid)
         dr = fs.get("degraded_reason")
         if dr:
             degraded_reason_map[fid] = dr
@@ -1089,9 +1087,8 @@ def action_start(args, feature_list_path, state_dir):
         return
 
     fs = load_feature_status(state_dir, feature_id)
-    old_status = fs.get("status", "pending")
+    old_status = get_feature_status_from_list(feature_list_path, feature_id)
 
-    fs["status"] = "in_progress"
     fs["updated_at"] = now_iso()
 
     err = save_feature_status(state_dir, feature_id, fs)
@@ -1121,7 +1118,7 @@ def action_start(args, feature_list_path, state_dir):
 def action_reset(args, feature_list_path, state_dir):
     """Reset a feature to pending state.
 
-    Resets status.json (status -> pending, retry_count -> 0, clear sessions,
+    Resets status.json runtime fields (retry_count -> 0, clear sessions,
     clear resume_from_phase) and updates .prizmkit/plans/feature-list.json status to pending.
     Does NOT delete any files on disk.
     """
@@ -1132,11 +1129,10 @@ def action_reset(args, feature_list_path, state_dir):
 
     # Load current status to preserve created_at
     fs = load_feature_status(state_dir, feature_id)
-    old_status = fs.get("status", "unknown")
+    old_status = get_feature_status_from_list(feature_list_path, feature_id)
     old_retry = fs.get("retry_count", 0)
 
-    # Reset fields
-    fs["status"] = "pending"
+    # Reset runtime fields
     fs["retry_count"] = 0
     fs["sessions"] = []
     fs["last_session_id"] = None
@@ -1227,10 +1223,9 @@ def action_clean(args, feature_list_path, state_dir):
 
     # 5. Reset status (reuse reset logic)
     fs = load_feature_status(state_dir, feature_id)
-    old_status = fs.get("status", "unknown")
+    old_status = get_feature_status_from_list(feature_list_path, feature_id)
     old_retry = fs.get("retry_count", 0)
 
-    fs["status"] = "pending"
     fs["retry_count"] = 0
     fs["sessions"] = []
     fs["last_session_id"] = None
@@ -1387,10 +1382,9 @@ def action_unskip(args, feature_list_path, state_dir):
         error_out("Failed to write .prizmkit/plans/feature-list.json: {}".format(err))
         return
 
-    # Reset status.json for each feature
+    # Reset runtime fields in status.json for each feature
     for fid in to_reset:
         fs = load_feature_status(state_dir, fid)
-        fs["status"] = "pending"
         fs["retry_count"] = 0
         fs["sessions"] = []
         fs["last_session_id"] = None