prizmkit 1.1.21 → 1.1.23

package/bundled/VERSION.json

@@ -1,5 +1,5 @@
 {
-  "frameworkVersion": "1.1.21",
-  "bundledAt": "2026-04-11T11:23:13.654Z",
-  "bundledFrom": "5137496"
+  "frameworkVersion": "1.1.23",
+  "bundledAt": "2026-04-11T14:45:05.180Z",
+  "bundledFrom": "fbba566"
 }

package/bundled/dev-pipeline/reset-bug.sh

@@ -139,22 +139,20 @@ fi
 BUG_IDS=()
 
 if [[ -n "$FILTER_MODE" ]]; then
-    # Filter by status from .prizmkit/state/bugfix/bugs/*/status.json
+    # Filter by status from bug-fix-list.json (single source of truth)
     while IFS= read -r bid; do
         [[ -n "$bid" ]] && BUG_IDS+=("$bid")
     done < <(python3 -c "
-import json, os, sys
-state_dir = '$STATE_DIR'
+import json, sys
 filter_mode = '$FILTER_MODE'
-bugs_dir = os.path.join(state_dir, 'bugs')
-if not os.path.isdir(bugs_dir):
-    sys.exit(0)
-for bid in sorted(os.listdir(bugs_dir)):
-    status_file = os.path.join(bugs_dir, bid, 'status.json')
-    if not os.path.isfile(status_file):
+bug_list = '$BUG_LIST'
+with open(bug_list) as f:
+    data = json.load(f)
+for bug in data.get('bugs', []):
+    if not isinstance(bug, dict):
         continue
-    with open(status_file) as f:
-        status = json.load(f).get('status', '')
+    bid = bug.get('id', '')
+    status = bug.get('status', '')
     if filter_mode == 'auto_skipped' and status == 'auto_skipped':
         print(bid)
     elif filter_mode == 'failed' and status == 'failed':
@@ -244,13 +242,23 @@ sys.exit(1)
     echo -e "${BOLD}════════════════════════════════════════════════════${NC}"
 
     STATUS_FILE="$STATE_DIR/bugs/$CUR_BUG_ID/status.json"
+    # Read status from bug-fix-list.json (single source of truth)
+    CURRENT_STATUS=$(python3 -c "
+import json, sys
+with open('$BUG_LIST') as f:
+    data = json.load(f)
+for bug in data.get('bugs', []):
+    if isinstance(bug, dict) and bug.get('id') == '$CUR_BUG_ID':
+        print(bug.get('status', '?'))
+        sys.exit(0)
+print('?')
+" 2>/dev/null || echo "?")
     if [[ -f "$STATUS_FILE" ]]; then
-        CURRENT_STATUS=$(python3 -c "import json; d=json.load(open('$STATUS_FILE')); print(d.get('status','?'))")
         CURRENT_RETRY=$(python3 -c "import json; d=json.load(open('$STATUS_FILE')); print(d.get('retry_count',0))")
         SESSION_COUNT=$(python3 -c "import json; d=json.load(open('$STATUS_FILE')); print(len(d.get('sessions',[])))")
         log_info "Current status: $CURRENT_STATUS (retry $CURRENT_RETRY, $SESSION_COUNT sessions)"
     else
-        log_info "No status file found (never executed)"
+        log_info "Current status: $CURRENT_STATUS (no runtime state file)"
     fi
 
     BUGFIX_DIR="$PROJECT_ROOT/.prizmkit/bugfix/$CUR_BUG_ID"

package/bundled/dev-pipeline/reset-feature.sh

@@ -139,22 +139,20 @@ fi
 FEATURE_IDS=()
 
 if [[ -n "$FILTER_MODE" ]]; then
-    # Filter by status from state/features/*/status.json
+    # Filter by status from feature-list.json (single source of truth)
     while IFS= read -r fid; do
         [[ -n "$fid" ]] && FEATURE_IDS+=("$fid")
     done < <(python3 -c "
-import json, os, sys
-state_dir = '$STATE_DIR'
+import json, sys
 filter_mode = '$FILTER_MODE'
-features_dir = os.path.join(state_dir, 'features')
-if not os.path.isdir(features_dir):
-    sys.exit(0)
-for fid in sorted(os.listdir(features_dir)):
-    status_file = os.path.join(features_dir, fid, 'status.json')
-    if not os.path.isfile(status_file):
+feature_list = '$FEATURE_LIST'
+with open(feature_list) as f:
+    data = json.load(f)
+for feat in data.get('features', []):
+    if not isinstance(feat, dict):
         continue
-    with open(status_file) as f:
-        status = json.load(f).get('status', '')
+    fid = feat.get('id', '')
+    status = feat.get('status', '')
     if filter_mode == 'auto_skipped' and status == 'auto_skipped':
         print(fid)
     elif filter_mode == 'failed' and status == 'failed':
@@ -253,13 +251,23 @@ sys.exit(1)
     echo -e "${BOLD}════════════════════════════════════════════════════${NC}"
 
     STATUS_FILE="$STATE_DIR/features/$CUR_FEATURE_ID/status.json"
+    # Read status from feature-list.json (single source of truth)
+    CURRENT_STATUS=$(python3 -c "
+import json, sys
+with open('$FEATURE_LIST') as f:
+    data = json.load(f)
+for feat in data.get('features', []):
+    if isinstance(feat, dict) and feat.get('id') == '$CUR_FEATURE_ID':
+        print(feat.get('status', '?'))
+        sys.exit(0)
+print('?')
+" 2>/dev/null || echo "?")
     if [[ -f "$STATUS_FILE" ]]; then
-        CURRENT_STATUS=$(python3 -c "import json; d=json.load(open('$STATUS_FILE')); print(d.get('status','?'))")
         CURRENT_RETRY=$(python3 -c "import json; d=json.load(open('$STATUS_FILE')); print(d.get('retry_count',0))")
         SESSION_COUNT=$(python3 -c "import json; d=json.load(open('$STATUS_FILE')); print(len(d.get('sessions',[])))")
         log_info "Current status: $CURRENT_STATUS (retry $CURRENT_RETRY, $SESSION_COUNT sessions)"
     else
-        log_info "No status file found (never executed)"
+        log_info "Current status: $CURRENT_STATUS (no runtime state file)"
     fi
 
     SPECS_DIR="$PROJECT_ROOT/.prizmkit/specs/$FEATURE_SLUG"

package/bundled/dev-pipeline/reset-refactor.sh

@@ -129,22 +129,20 @@ fi
 REFACTOR_IDS=()
 
 if [[ -n "$FILTER_MODE" ]]; then
-    # Filter by status from .prizmkit/state/refactor/refactors/*/status.json
+    # Filter by status from refactor-list.json (single source of truth)
     while IFS= read -r rid; do
         [[ -n "$rid" ]] && REFACTOR_IDS+=("$rid")
     done < <(python3 -c "
-import json, os, sys
-state_dir = '$STATE_DIR'
+import json, sys
 filter_mode = '$FILTER_MODE'
-refactors_dir = os.path.join(state_dir, 'refactors')
-if not os.path.isdir(refactors_dir):
-    sys.exit(0)
-for rid in sorted(os.listdir(refactors_dir)):
-    status_file = os.path.join(refactors_dir, rid, 'status.json')
-    if not os.path.isfile(status_file):
+refactor_list = '$REFACTOR_LIST'
+with open(refactor_list) as f:
+    data = json.load(f)
+for r in data.get('refactors', []):
+    if not isinstance(r, dict):
         continue
-    with open(status_file) as f:
-        status = json.load(f).get('status', '')
+    rid = r.get('id', '')
+    status = r.get('status', '')
     if filter_mode == 'auto_skipped' and status == 'auto_skipped':
         print(rid)
     elif filter_mode == 'failed' and status == 'failed':
@@ -242,13 +240,23 @@ sys.exit(1)
     echo -e "${BOLD}════════════════════════════════════════════════════${NC}"
 
     STATUS_FILE="$STATE_DIR/refactors/$CUR_REFACTOR_ID/status.json"
+    # Read status from refactor-list.json (single source of truth)
+    CURRENT_STATUS=$(python3 -c "
+import json, sys
+with open('$REFACTOR_LIST') as f:
+    data = json.load(f)
+for r in data.get('refactors', []):
+    if isinstance(r, dict) and r.get('id') == '$CUR_REFACTOR_ID':
+        print(r.get('status', '?'))
+        sys.exit(0)
+print('?')
+" 2>/dev/null || echo "?")
     if [[ -f "$STATUS_FILE" ]]; then
-        CURRENT_STATUS=$(python3 -c "import json; d=json.load(open('$STATUS_FILE')); print(d.get('status','?'))")
         CURRENT_RETRY=$(python3 -c "import json; d=json.load(open('$STATUS_FILE')); print(d.get('retry_count',0))")
         SESSION_COUNT=$(python3 -c "import json; d=json.load(open('$STATUS_FILE')); print(len(d.get('sessions',[])))")
         log_info "Current status: $CURRENT_STATUS (retry $CURRENT_RETRY, $SESSION_COUNT sessions)"
     else
-        log_info "No status file found (never executed)"
+        log_info "Current status: $CURRENT_STATUS (no runtime state file)"
     fi
 
     SPECS_DIR="$PROJECT_ROOT/.prizmkit/specs/$REFACTOR_SLUG"

package/bundled/dev-pipeline/scripts/detect-stuck.py

@@ -226,15 +226,16 @@ def check_stuck_checkpoint(item_dir):
     return None
 
 
-def check_stale_heartbeat(item_id, item_status, state_dir, items_subdir, stale_threshold):
+def check_stale_heartbeat(item_id, item_status, state_dir, items_subdir, stale_threshold, task_list_status=None):
     """Check 3: Is the heartbeat stale or missing for an in_progress item?
 
     Only applies to items whose status indicates active work.
-    Uses last_session_id from the item's own status to find the active session.
+    Status is read from task_list_status (task list JSON, single source of truth).
+    Uses last_session_id from the item's own status.json to find the active session.
 
     Returns a stuck-report dict or None.
     """
-    status = item_status.get("status")
+    status = task_list_status
     # All pipelines now use "in_progress" as the active status
     in_progress_statuses = {"in_progress"}
     if status not in in_progress_statuses:
@@ -287,6 +288,8 @@ def check_stale_heartbeat(item_id, item_status, state_dir, items_subdir, stale_t
 def check_dependency_deadlock(item_id, task_list_data, state_dir, items_subdir, items_key):
     """Check 4: Does this item depend on a failed item?
 
+    Reads dependency status from task list JSON (single source of truth).
+
     Returns a stuck-report dict or None.
     """
     if task_list_data is None:
@@ -296,6 +299,12 @@ def check_dependency_deadlock(item_id, task_list_data, state_dir, items_subdir,
     if not isinstance(items, list):
         return None
 
+    # Build status map from task list
+    status_map = {}
+    for item in items:
+        if isinstance(item, dict) and item.get("id"):
+            status_map[item["id"]] = item.get("status", "pending")
+
     # Find this item in the list to get its dependencies
     deps = None
     for item in items:
@@ -308,15 +317,9 @@ def check_dependency_deadlock(item_id, task_list_data, state_dir, items_subdir,
     if not deps or not isinstance(deps, list):
         return None
 
-    # Check each dependency's status in state
+    # Check each dependency's status from the task list
     for dep_id in deps:
-        dep_status_path = os.path.join(
-            state_dir, items_subdir, dep_id, "status.json"
-        )
-        dep_status = load_json(dep_status_path)
-        if dep_status is None:
-            continue
-        dep_state = dep_status.get("status")
+        dep_state = status_map.get(dep_id)
         if dep_state == "failed":
             return {
                 "reason": "dependency_failed",
@@ -376,8 +379,16 @@ def check_item(item_id, state_dir, items_subdir, items_key, task_list_data, max_
     item_status = load_json(status_path)
 
     if item_status is None:
-        # Cannot read status — skip silently
-        return []
+        # Create a minimal runtime dict so checks can proceed
+        item_status = {}
+
+    # Look up item status from task list (single source of truth)
+    task_list_status = None
+    if task_list_data:
+        for item in task_list_data.get(items_key, []):
+            if isinstance(item, dict) and item.get("id") == item_id:
+                task_list_status = item.get("status", "pending")
+                break
 
     reports = []
 
@@ -392,7 +403,7 @@ def check_item(item_id, state_dir, items_subdir, items_key, task_list_data, max_
         reports.append(result)
 
     # Check 3: Stale heartbeat
-    result = check_stale_heartbeat(item_id, item_status, state_dir, items_subdir, stale_threshold)
+    result = check_stale_heartbeat(item_id, item_status, state_dir, items_subdir, stale_threshold, task_list_status)
     if result is not None:
         reports.append(result)
 

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

@@ -249,13 +249,8 @@ def create_state_directory(state_dir, bug_list_path, bugs):
         sessions_dir = os.path.join(bug_dir, "sessions")
         os.makedirs(sessions_dir, exist_ok=True)
 
-        # Respect existing terminal status from bug-fix-list.json
-        bl_status = bug.get("status", "pending")
-        init_status = bl_status if bl_status in TERMINAL_STATUSES else "pending"
-
         bug_status = {
             "bug_id": bid,
-            "status": init_status,
             "retry_count": 0,
             "max_retries": 3,
             "sessions": [],

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

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

@@ -96,11 +96,10 @@ def now_iso():
 
 
 def _default_status(refactor_id):
-    """Create a default refactor status object."""
+    """Create a default refactor runtime status object (no status field)."""
     now = now_iso()
     return {
         "refactor_id": refactor_id,
-        "status": "pending",
         "retry_count": 0,
         "max_retries": 3,
         "sessions": [],
@@ -112,20 +111,42 @@ def _default_status(refactor_id):
 
 
 def load_refactor_status(state_dir, refactor_id):
+    """Load runtime state from status.json for a refactor.
+
+    Returns runtime fields only (retry_count, sessions, etc.).
+    The 'status' field is NOT included — status lives exclusively
+    in refactor-list.json.
+    """
     status_path = os.path.join(state_dir, "refactors", refactor_id, "status.json")
     if not os.path.isfile(status_path):
         return _default_status(refactor_id)
     data, err = load_json_file(status_path)
     if err:
         return _default_status(refactor_id)
+    # Defensively remove status if present (legacy data)
+    data.pop("status", None)
     return data
 
 
 def save_refactor_status(state_dir, refactor_id, status_data):
+    """Write the status.json for a refactor (runtime fields only)."""
+    # Defensively strip status — it belongs in refactor-list.json
+    status_data.pop("status", None)
     status_path = os.path.join(state_dir, "refactors", refactor_id, "status.json")
     return write_json_file(status_path, status_data)
 
 
+def get_refactor_status_from_list(refactor_list_path, refactor_id):
+    """Read a single refactor's status from refactor-list.json."""
+    data, err = load_json_file(refactor_list_path)
+    if err:
+        return "pending"
+    for r in data.get("refactors", []):
+        if isinstance(r, dict) and r.get("id") == refactor_id:
+            return r.get("status", "pending")
+    return "pending"
+
+
 def update_refactor_in_list(refactor_list_path, refactor_id, new_status):
     data, err = load_json_file(refactor_list_path)
     if err:
@@ -179,7 +200,7 @@ def action_get_next(refactor_list_data, state_dir):
         print("PIPELINE_COMPLETE")
         return
 
-    # Build status map and completed set
+    # Build status map from refactor-list.json (single source of truth)
     status_map = {}
     status_data_map = {}
     for r in refactors:
@@ -188,8 +209,8 @@ def action_get_next(refactor_list_data, state_dir):
         rid = r.get("id")
         if not rid:
             continue
+        status_map[rid] = r.get("status", "pending")
         rs = load_refactor_status(state_dir, rid)
-        status_map[rid] = rs.get("status", "pending")
         status_data_map[rid] = rs
 
     completed_set = {rid for rid, st in status_map.items() if st in TERMINAL_STATUSES}
@@ -270,35 +291,30 @@ def action_update(args, refactor_list_path, state_dir):
 
     rs = load_refactor_status(state_dir, refactor_id)
 
+    # Track what status we write to refactor-list.json
+    new_status = get_refactor_status_from_list(refactor_list_path, refactor_id)
+
     if session_status == "success":
-        rs["status"] = "completed"
+        new_status = "completed"
         rs["resume_from_phase"] = None
         err = update_refactor_in_list(refactor_list_path, refactor_id, "completed")
         if err:
             error_out("Failed to update .prizmkit/plans/refactor-list.json: {}".format(err))
             return
     elif session_status in ("commit_missing", "docs_missing", "merge_conflict"):
-        # Degraded outcome: keep artifacts for retry.
-        # Write schema-valid status to refactor-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).
         rs["retry_count"] = rs.get("retry_count", 0) + 1
 
         if rs["retry_count"] >= max_retries:
-            rs["status"] = "failed"
-            target_status = "failed"
+            new_status = "failed"
         else:
-            # status.json keeps the granular degraded reason for diagnostics
-            rs["status"] = session_status
-            # refactor-list.json gets schema-valid "pending" (will be retried)
-            target_status = "pending"
+            new_status = "pending"
 
         rs["degraded_reason"] = session_status
         rs["resume_from_phase"] = None
         rs["sessions"] = []
         rs["last_session_id"] = None
 
-        err = update_refactor_in_list(refactor_list_path, refactor_id, target_status)
+        err = update_refactor_in_list(refactor_list_path, refactor_id, new_status)
         if err:
             error_out("Failed to update .prizmkit/plans/refactor-list.json: {}".format(err))
             return
@@ -312,17 +328,15 @@ def action_update(args, refactor_list_path, state_dir):
         )
 
         if rs["retry_count"] >= max_retries:
-            rs["status"] = "failed"
-            target_status = "failed"
+            new_status = "failed"
         else:
-            rs["status"] = "pending"
-            target_status = "pending"
+            new_status = "pending"
 
         rs["resume_from_phase"] = None
         rs["sessions"] = []
         rs["last_session_id"] = None
 
-        err = update_refactor_in_list(refactor_list_path, refactor_id, target_status)
+        err = update_refactor_in_list(refactor_list_path, refactor_id, new_status)
         if err:
             error_out("Failed to update .prizmkit/plans/refactor-list.json: {}".format(err))
             return
@@ -343,7 +357,7 @@ def action_update(args, refactor_list_path, state_dir):
 
     # Auto-skip downstream refactors when this refactor is marked as failed or skipped
     auto_skipped_refactors = []
-    if rs["status"] in ("failed", "skipped"):
+    if new_status in ("failed", "skipped"):
         auto_skipped_refactors = auto_skip_blocked_refactors(
             refactor_list_path, state_dir, refactor_id
         )
@@ -352,7 +366,7 @@ def action_update(args, refactor_list_path, state_dir):
         "action": "update",
         "refactor_id": refactor_id,
         "session_status": session_status,
-        "new_status": rs["status"],
+        "new_status": new_status,
         "retry_count": rs["retry_count"],
         "resume_from_phase": rs.get("resume_from_phase"),
         "updated_at": rs["updated_at"],
@@ -496,10 +510,9 @@ def auto_skip_blocked_refactors(refactor_list_path, state_dir, failed_refactor_i
             r["status"] = "auto_skipped"
     write_json_file(refactor_list_path, data)
 
-    # Sync status.json for each auto-skipped refactor
+    # Update timestamps in status.json for each auto-skipped refactor
     for rid in to_skip:
         rs = load_refactor_status(state_dir, rid)
-        rs["status"] = "auto_skipped"
         rs["updated_at"] = now_iso()
         save_refactor_status(state_dir, rid, rs)
 
@@ -589,8 +602,8 @@ def action_status(refactor_list_data, state_dir):
         if not rid:
             continue
 
+        rstatus = r.get("status", "pending")
         rs = load_refactor_status(state_dir, rid)
-        rstatus = rs.get("status", "pending")
         retry_count = rs.get("retry_count", 0)
         max_retries_val = rs.get("max_retries", 3)
         resume_phase = rs.get("resume_from_phase")
@@ -688,10 +701,9 @@ def action_reset(args, refactor_list_path, state_dir):
         return
 
     rs = load_refactor_status(state_dir, refactor_id)
-    old_status = rs.get("status", "unknown")
+    old_status = get_refactor_status_from_list(refactor_list_path, refactor_id)
     old_retry = rs.get("retry_count", 0)
 
-    rs["status"] = "pending"
     rs["retry_count"] = 0
     rs["sessions"] = []
     rs["last_session_id"] = None
@@ -760,10 +772,9 @@ def action_clean(args, refactor_list_path, state_dir):
 
     # 4. Reset status
     rs = load_refactor_status(state_dir, refactor_id)
-    old_status = rs.get("status", "unknown")
+    old_status = get_refactor_status_from_list(refactor_list_path, refactor_id)
     old_retry = rs.get("retry_count", 0)
 
-    rs["status"] = "pending"
     rs["retry_count"] = 0
     rs["sessions"] = []
     rs["last_session_id"] = None
@@ -834,9 +845,8 @@ def action_start(args, refactor_list_path, state_dir):
         return
 
     rs = load_refactor_status(state_dir, refactor_id)
-    old_status = rs.get("status", "pending")
+    old_status = get_refactor_status_from_list(refactor_list_path, refactor_id)
 
-    rs["status"] = "in_progress"
     rs["updated_at"] = now_iso()
 
     err = save_refactor_status(state_dir, refactor_id, rs)
@@ -988,10 +998,9 @@ def action_unskip(args, refactor_list_path, state_dir):
         error_out("Failed to write .prizmkit/plans/refactor-list.json: {}".format(err))
         return
 
-    # Reset status.json for each refactor
+    # Reset runtime fields in status.json for each refactor
     for rid in to_reset:
         rs = load_refactor_status(state_dir, rid)
-        rs["status"] = "pending"
         rs["retry_count"] = 0
         rs["sessions"] = []
         rs["last_session_id"] = None

package/bundled/dev-pipeline/tests/test_auto_skip.py

@@ -122,8 +122,13 @@ class TestAutoSkipLinearChain:
 
         auto_skip_blocked_features(fl_path, state_dir, "F-001")
 
+        # status lives in feature-list.json, not status.json
+        statuses = _read_statuses(fl_path)
+        assert statuses["F-002"] == "auto_skipped"
+        # status.json should have updated_at but no status field
         fs = load_feature_status(state_dir, "F-002")
-        assert fs["status"] == "auto_skipped"
+        assert "status" not in fs
+        assert "updated_at" in fs
 
     def test_failing_mid_skips_only_downstream(self, tmp_path):
         features = [
@@ -434,7 +439,6 @@ class TestAutoSkipIntegration:
         with open(fs_path) as f:
             fs = json.load(f)
         fs["retry_count"] = 3
-        fs["status"] = "failed"
         with open(fs_path, "w") as f:
             json.dump(fs, f)
 
@@ -443,4 +447,7 @@ class TestAutoSkipIntegration:
         with open(fs_path) as f:
             fs = json.load(f)
         assert fs["retry_count"] == 0
-        assert fs["status"] == "pending"
+        # status lives in feature-list.json, not status.json
+        assert "status" not in fs
+        statuses = _read_statuses(fl_path)
+        assert statuses["F-001"] == "pending"

package/bundled/skills/_metadata.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.1.21",
+  "version": "1.1.23",
   "skills": {
     "prizm-kit": {
       "description": "Full-lifecycle dev toolkit. Covers spec-driven development, Prizm context docs, code quality, debugging, deployment, and knowledge management.",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prizmkit",
-  "version": "1.1.21",
+  "version": "1.1.23",
   "description": "Create a new PrizmKit-powered project with clean initialization — no framework dev files, just what you need.",
   "type": "module",
   "bin": {