prizmkit 1.1.153 → 1.1.155

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

@@ -10,12 +10,12 @@ Handles nine actions:
   - reset: Reset a feature to pending (status + retry count)
   - clean: Reset + delete session history + delete prizmkit artifacts
   - complete: Shortcut for manually marking a feature as completed
-  - unskip: Recover auto-skipped features (reset failed/skipped upstream + auto_skipped downstream)
+  - reset_state: Recover blocking roots and causally recoverable auto-skipped descendants
 
 Usage:
     python3 update-feature-status.py \
         --feature-list <path> --state-dir <path> \
-        --action <get_next|start|update|status|pause|reset|clean|complete|unskip> \
+        --action <get_next|start|update|status|pause|reset|clean|complete|reset_state> \
         [--feature-id <id>] [--session-status <status>] \
         [--session-id <id>] [--max-retries <n>] [--max-infra-retries <n>] \
         [--features <filter>]
@@ -37,6 +37,7 @@ from utils import (
     _build_progress_bar,
     read_checkpoint_cursor,
     dependency_rank_map,
+    causal_reset_selection,
 )
 
 
@@ -58,6 +59,7 @@ SESSION_STATUS_VALUES = [
 ]
 
 TERMINAL_STATUSES = {"completed", "failed", "skipped", "auto_skipped", "split"}
+RESET_BLOCKING_ROOT_STATUSES = {"failed", "skipped"}
 
 
 def parse_args():
@@ -77,7 +79,7 @@ def parse_args():
     parser.add_argument(
         "--action",
         required=True,
-        choices=["get_next", "start", "update", "status", "pause", "reset", "clean", "complete", "unskip"],
+        choices=["get_next", "start", "update", "status", "pause", "reset", "clean", "complete", "reset_state"],
         help="Action to perform",
     )
     parser.add_argument(
@@ -909,6 +911,8 @@ def action_update(args, feature_list_path, state_dir):
 
     fs = load_feature_status(state_dir, feature_id)
     current_list_status = get_feature_status_from_list(feature_list_path, feature_id)
+    fs["max_retries"] = max_retries
+    fs["max_infra_retries"] = max_infra_retries
 
     # Track what status we write to feature-list.json
     new_status = current_list_status
@@ -1394,11 +1398,8 @@ def action_status(feature_list_data, state_dir, feature_filter=None, project_roo
         fstatus = feature.get("status", "pending")
         fs = load_feature_status(state_dir, fid)
         feature_slug = _build_feature_slug(fid, title)
-        # Read phase cursor from checkpoint (authoritative when valid).
+        # Read the authoritative checkpoint cursor without mutating cached runtime state.
         resume_phase = _checkpoint_phase_or_cached(project_root, feature_slug, fs)
-        if resume_phase != fs.get("resume_from_phase"):
-            fs["resume_from_phase"] = resume_phase
-            save_feature_status(state_dir, fid, fs)
         degraded_reason = degraded_reason_map.get(fid)
 
         # Count statuses
@@ -1568,6 +1569,8 @@ def action_start(args, feature_list_path, state_dir):
     fs = load_feature_status(state_dir, feature_id)
     old_status = get_feature_status_from_list(feature_list_path, feature_id)
 
+    fs["max_retries"] = args.max_retries
+    fs["max_infra_retries"] = args.max_infra_retries
     fs["updated_at"] = now_iso()
 
     err = save_feature_status(state_dir, feature_id, fs)
@@ -1749,124 +1752,37 @@ def action_clean(args, feature_list_path, state_dir):
 
 
 # ---------------------------------------------------------------------------
-# Action: unskip
+# Action: reset_state
 # ---------------------------------------------------------------------------
 
-def action_unskip(args, feature_list_path, state_dir):
-    """Recover auto-skipped features by resetting them and their failed upstream.
-
-    Two modes:
-    - --feature-id F-032: Reset the specified failed/skipped feature + all auto_skipped
-      features whose dependency chain includes it.
-    - No --feature-id: Reset ALL failed, skipped, and auto_skipped features to pending.
-    """
-    feature_id = args.feature_id
-
+def action_reset_state(args, feature_list_path, state_dir):
+    """Reset one causal feature closure, or every recoverable closure, to pending."""
     data, err = load_json_file(feature_list_path)
     if err:
         error_out("Cannot load feature list: {}".format(err))
         return
     features = data.get("features", [])
 
-    to_reset = set()
-
-    if feature_id:
-        # Find the target feature
-        target = None
-        for f in features:
-            if isinstance(f, dict) and f.get("id") == feature_id:
-                target = f
-                break
-        if not target:
-            error_out("Feature '{}' not found in .prizmkit/plans/feature-list.json".format(feature_id))
-            return
-        if target.get("status") not in ("failed", "skipped", "auto_skipped"):
-            error_out(
-                "Feature '{}' has status '{}', expected 'failed', 'skipped', or 'auto_skipped'".format(
-                    feature_id, target.get("status", "unknown")
-                )
-            )
-            return
-
-        # If target is failed or skipped, reset it and find all auto_skipped descendants
-        if target.get("status") in ("failed", "skipped"):
-            to_reset.add(feature_id)
-            # Find all auto_skipped features that depend (transitively) on this one
-            changed = True
-            while changed:
-                changed = False
-                for f in features:
-                    if not isinstance(f, dict):
-                        continue
-                    fid = f.get("id")
-                    if not fid or fid in to_reset:
-                        continue
-                    if f.get("status") != "auto_skipped":
-                        continue
-                    deps = f.get("dependencies", [])
-                    if any(d in to_reset for d in deps):
-                        to_reset.add(fid)
-                        changed = True
-
-        # If target is auto_skipped, reset it and its failed upstream + siblings
-        elif target.get("status") == "auto_skipped":
-            to_reset.add(feature_id)
-            # Transitively walk upstream to find ALL failed/auto_skipped ancestors
-            # (e.g., F-001 failed → F-002 auto_skipped → F-003 auto_skipped;
-            #  unskip F-003 must also find and reset F-001)
-            upstream_changed = True
-            while upstream_changed:
-                upstream_changed = False
-                for f in features:
-                    if not isinstance(f, dict):
-                        continue
-                    fid = f.get("id")
-                    if not fid or fid not in to_reset:
-                        continue
-                    for dep_id in f.get("dependencies", []):
-                        if dep_id in to_reset:
-                            continue
-                        for dep_f in features:
-                            if isinstance(dep_f, dict) and dep_f.get("id") == dep_id:
-                                if dep_f.get("status") in ("failed", "skipped", "auto_skipped"):
-                                    to_reset.add(dep_id)
-                                    upstream_changed = True
-            # Also reset downstream auto_skipped features blocked by the same upstreams
-            changed = True
-            while changed:
-                changed = False
-                for f in features:
-                    if not isinstance(f, dict):
-                        continue
-                    fid = f.get("id")
-                    if not fid or fid in to_reset:
-                        continue
-                    if f.get("status") != "auto_skipped":
-                        continue
-                    fdeps = f.get("dependencies", [])
-                    if any(d in to_reset for d in fdeps):
-                        to_reset.add(fid)
-                        changed = True
-    else:
-        # No feature-id: reset ALL failed + skipped + auto_skipped
-        for f in features:
-            if isinstance(f, dict) and f.get("id"):
-                if f.get("status") in ("failed", "skipped", "auto_skipped"):
-                    to_reset.add(f["id"])
-
-    if not to_reset:
-        error_out("No features to unskip")
+    try:
+        recovery_ids = causal_reset_selection(
+            features,
+            selected_id=args.feature_id,
+            blocking_root_statuses=RESET_BLOCKING_ROOT_STATUSES,
+            item_label="Feature",
+        )
+    except ValueError as exc:
+        error_out(str(exc))
         return
 
-    # Reset all collected features in .prizmkit/plans/feature-list.json
+    to_reset = set(recovery_ids)
     reset_details = []
-    for f in features:
-        if isinstance(f, dict) and f.get("id") in to_reset:
-            old_status = f.get("status", "unknown")
-            f["status"] = "pending"
+    for feature in features:
+        if isinstance(feature, dict) and feature.get("id") in to_reset:
+            old_status = feature.get("status", "unknown")
+            feature["status"] = "pending"
             reset_details.append({
-                "feature_id": f["id"],
-                "title": f.get("title", ""),
+                "feature_id": feature["id"],
+                "title": feature.get("title", ""),
                 "old_status": old_status,
             })
 
@@ -1875,22 +1791,31 @@ def action_unskip(args, feature_list_path, state_dir):
         error_out("Failed to write .prizmkit/plans/feature-list.json: {}".format(err))
         return
 
-    # Reset runtime fields in status.json for each feature
-    for fid in to_reset:
-        fs = load_feature_status(state_dir, fid)
+    for feature_id in recovery_ids:
+        fs = load_feature_status(state_dir, feature_id)
+        checkout_identity = {
+            key: fs[key]
+            for key in ("active_dev_branch", "base_branch")
+            if key in fs
+        }
         fs["retry_count"] = 0
         fs["infra_error_count"] = 0
         fs["last_infra_error_session_id"] = None
         fs["sessions"] = []
         fs["last_session_id"] = None
+        fs["last_failed_session_id"] = None
         fs["resume_from_phase"] = None
         reset_continuation_metadata(fs)
+        fs.update(checkout_identity)
         fs["updated_at"] = now_iso()
-        save_feature_status(state_dir, fid, fs)
+        err = save_feature_status(state_dir, feature_id, fs)
+        if err:
+            error_out("Failed to save feature status: {}".format(err))
+            return
 
     result = {
-        "action": "unskip",
-        "reset_count": len(to_reset),
+        "action": "reset_state",
+        "reset_count": len(recovery_ids),
         "features": reset_details,
     }
     print(json.dumps(result, indent=2, ensure_ascii=False))
@@ -1977,8 +1902,8 @@ def main():
         action_update(args, args.feature_list, args.state_dir)
     elif args.action == "pause":
         action_pause(args.state_dir)
-    elif args.action == "unskip":
-        action_unskip(args, args.feature_list, args.state_dir)
+    elif args.action == "reset_state":
+        action_reset_state(args, args.feature_list, args.state_dir)
 
 
 if __name__ == "__main__":

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

@@ -9,12 +9,12 @@ Handles eight actions:
   - pause: Save pipeline state for graceful shutdown
   - reset: Reset a refactor to pending (status + retry count)
   - clean: Reset + delete session history + delete refactor artifacts
-  - unskip: Reset skipped refactors and their downstream dependents back to pending
+  - reset_state: Recover blocking roots and causally recoverable auto-skipped descendants
 
 Usage:
     python3 update-refactor-status.py \
         --refactor-list <path> --state-dir <path> \
-        --action <get_next|start|update|status|pause|reset|clean|unskip> \
+        --action <get_next|start|update|status|pause|reset|clean|reset_state> \
         [--refactor-id <id>] [--session-status <status>] \
         [--session-id <id>] [--max-retries <n>] [--max-infra-retries <n>]
 """
@@ -34,6 +34,7 @@ from utils import (
     _build_progress_bar,
     read_checkpoint_cursor,
     dependency_rank_map,
+    causal_reset_selection,
 )
 
 
@@ -55,6 +56,7 @@ SESSION_STATUS_VALUES = [
 ]
 
 TERMINAL_STATUSES = {"completed", "failed", "skipped", "auto_skipped"}
+RESET_BLOCKING_ROOT_STATUSES = {"failed", "skipped"}
 
 # Artifact directory names (relative to project root)
 REFACTOR_ARTIFACTS_REL = os.path.join(".prizmkit", "refactor")
@@ -84,7 +86,7 @@ def parse_args():
     parser.add_argument("--state-dir", required=True, help="Path to the state directory (default: .prizmkit/state/refactor)")
     parser.add_argument(
         "--action", required=True,
-        choices=["get_next", "start", "update", "status", "pause", "reset", "clean", "unskip", "complete"],
+        choices=["get_next", "start", "update", "status", "pause", "reset", "clean", "reset_state", "complete"],
         help="Action to perform",
     )
     parser.add_argument("--refactor-id", default=None, help="Refactor ID (required for 'update'/'reset'/'clean' actions)")
@@ -517,6 +519,8 @@ def action_update(args, refactor_list_path, state_dir):
     rs = load_refactor_status(state_dir, refactor_id)
 
     current_list_status = get_refactor_status_from_list(refactor_list_path, refactor_id)
+    rs["max_retries"] = max_retries
+    rs["max_infra_retries"] = max_infra_retries
 
     # Track what status we write to refactor-list.json
     new_status = current_list_status
@@ -1006,11 +1010,8 @@ def action_status(refactor_list_data, state_dir, project_root=None):
         rs = load_refactor_status(state_dir, rid)
         retry_count = rs.get("retry_count", 0)
         max_retries_val = rs.get("max_retries", 3)
-        # Read phase cursor from checkpoint (authoritative when valid).
+        # Read the authoritative checkpoint cursor without mutating cached runtime state.
         resume_phase = _checkpoint_phase_or_cached(project_root, rid, rs)
-        if resume_phase != rs.get("resume_from_phase"):
-            rs["resume_from_phase"] = resume_phase
-            save_refactor_status(state_dir, rid, rs)
 
         if rstatus in counts:
             counts[rstatus] += 1
@@ -1263,6 +1264,8 @@ def action_start(args, refactor_list_path, state_dir):
     rs = load_refactor_status(state_dir, refactor_id)
     old_status = get_refactor_status_from_list(refactor_list_path, refactor_id)
 
+    rs["max_retries"] = args.max_retries
+    rs["max_infra_retries"] = args.max_infra_retries
     rs["updated_at"] = now_iso()
 
     err = save_refactor_status(state_dir, refactor_id, rs)
@@ -1289,126 +1292,37 @@ def action_start(args, refactor_list_path, state_dir):
 
 
 # ---------------------------------------------------------------------------
-# Action: unskip
+# Action: reset_state
 # ---------------------------------------------------------------------------
 
-def action_unskip(args, refactor_list_path, state_dir):
-    """Recover skipped/auto_skipped/failed refactors by resetting them and their failed upstream.
-
-    Two modes:
-    - --refactor-id R-001: Reset the specified failed/skipped/auto_skipped refactor + all
-      downstream auto_skipped refactors whose dependency chain includes it.
-      If the target is auto_skipped, also walk upstream to find and reset the
-      failed/skipped ancestor that caused the cascade.
-    - No --refactor-id: Reset ALL failed, skipped, and auto_skipped refactors to pending.
-    """
-    refactor_id = args.refactor_id
-
+def action_reset_state(args, refactor_list_path, state_dir):
+    """Reset one causal refactor closure, or every recoverable closure, to pending."""
     data, err = load_json_file(refactor_list_path)
     if err:
         error_out("Cannot load refactor list: {}".format(err))
         return
     refactors = data.get("refactors", [])
 
-    to_reset = set()
-
-    if refactor_id:
-        # Find the target refactor
-        target = None
-        for r in refactors:
-            if isinstance(r, dict) and r.get("id") == refactor_id:
-                target = r
-                break
-        if not target:
-            error_out("Refactor '{}' not found in .prizmkit/plans/refactor-list.json".format(refactor_id))
-            return
-        if target.get("status") not in ("failed", "skipped", "auto_skipped"):
-            error_out(
-                "Refactor '{}' has status '{}', expected 'failed', 'skipped', or 'auto_skipped'".format(
-                    refactor_id, target.get("status", "unknown")
-                )
-            )
-            return
-
-        # If target is failed or skipped, reset it and find all auto_skipped descendants
-        if target.get("status") in ("failed", "skipped"):
-            to_reset.add(refactor_id)
-            # Find all auto_skipped refactors that depend (transitively) on this one
-            changed = True
-            while changed:
-                changed = False
-                for r in refactors:
-                    if not isinstance(r, dict):
-                        continue
-                    rid = r.get("id")
-                    if not rid or rid in to_reset:
-                        continue
-                    if r.get("status") != "auto_skipped":
-                        continue
-                    deps = r.get("dependencies", [])
-                    if any(d in to_reset for d in deps):
-                        to_reset.add(rid)
-                        changed = True
-
-        # If target is auto_skipped, reset it and its failed upstream + siblings
-        elif target.get("status") == "auto_skipped":
-            to_reset.add(refactor_id)
-            # Transitively walk upstream to find ALL failed/auto_skipped ancestors
-            # (e.g., R-001 failed → R-002 auto_skipped → R-003 auto_skipped;
-            #  unskip R-003 must also find and reset R-001)
-            upstream_changed = True
-            while upstream_changed:
-                upstream_changed = False
-                for r in refactors:
-                    if not isinstance(r, dict):
-                        continue
-                    rid = r.get("id")
-                    if not rid or rid not in to_reset:
-                        continue
-                    for dep_id in r.get("dependencies", []):
-                        if dep_id in to_reset:
-                            continue
-                        for dep_r in refactors:
-                            if isinstance(dep_r, dict) and dep_r.get("id") == dep_id:
-                                if dep_r.get("status") in ("failed", "skipped", "auto_skipped"):
-                                    to_reset.add(dep_id)
-                                    upstream_changed = True
-            # Also reset downstream auto_skipped refactors blocked by the same upstreams
-            changed = True
-            while changed:
-                changed = False
-                for r in refactors:
-                    if not isinstance(r, dict):
-                        continue
-                    rid = r.get("id")
-                    if not rid or rid in to_reset:
-                        continue
-                    if r.get("status") != "auto_skipped":
-                        continue
-                    rdeps = r.get("dependencies", [])
-                    if any(d in to_reset for d in rdeps):
-                        to_reset.add(rid)
-                        changed = True
-    else:
-        # No refactor-id: reset ALL failed + skipped + auto_skipped
-        for r in refactors:
-            if isinstance(r, dict) and r.get("id"):
-                if r.get("status") in ("failed", "skipped", "auto_skipped"):
-                    to_reset.add(r["id"])
-
-    if not to_reset:
-        error_out("No refactors to unskip")
+    try:
+        recovery_ids = causal_reset_selection(
+            refactors,
+            selected_id=args.refactor_id,
+            blocking_root_statuses=RESET_BLOCKING_ROOT_STATUSES,
+            item_label="Refactor",
+        )
+    except ValueError as exc:
+        error_out(str(exc))
         return
 
-    # Reset all collected refactors in refactor-list.json
+    to_reset = set(recovery_ids)
     reset_details = []
-    for r in refactors:
-        if isinstance(r, dict) and r.get("id") in to_reset:
-            old_status = r.get("status", "unknown")
-            r["status"] = "pending"
+    for refactor in refactors:
+        if isinstance(refactor, dict) and refactor.get("id") in to_reset:
+            old_status = refactor.get("status", "unknown")
+            refactor["status"] = "pending"
             reset_details.append({
-                "refactor_id": r["id"],
-                "title": r.get("title", ""),
+                "refactor_id": refactor["id"],
+                "title": refactor.get("title", ""),
                 "old_status": old_status,
             })
 
@@ -1417,22 +1331,31 @@ def action_unskip(args, refactor_list_path, state_dir):
         error_out("Failed to write .prizmkit/plans/refactor-list.json: {}".format(err))
         return
 
-    # Reset runtime fields in status.json for each refactor
-    for rid in to_reset:
-        rs = load_refactor_status(state_dir, rid)
+    for refactor_id in recovery_ids:
+        rs = load_refactor_status(state_dir, refactor_id)
+        checkout_identity = {
+            key: rs[key]
+            for key in ("active_dev_branch", "base_branch")
+            if key in rs
+        }
         rs["retry_count"] = 0
         rs["infra_error_count"] = 0
         rs["last_infra_error_session_id"] = None
         rs["sessions"] = []
         rs["last_session_id"] = None
+        rs["last_failed_session_id"] = None
         rs["resume_from_phase"] = None
         reset_continuation_metadata(rs)
+        rs.update(checkout_identity)
         rs["updated_at"] = now_iso()
-        save_refactor_status(state_dir, rid, rs)
+        err = save_refactor_status(state_dir, refactor_id, rs)
+        if err:
+            error_out("Failed to save refactor status: {}".format(err))
+            return
 
     result = {
-        "action": "unskip",
-        "reset_count": len(to_reset),
+        "action": "reset_state",
+        "reset_count": len(recovery_ids),
         "refactors": reset_details,
     }
     print(json.dumps(result, indent=2, ensure_ascii=False))
@@ -1475,8 +1398,8 @@ def main():
         action_start(args, args.refactor_list, args.state_dir)
     elif args.action == "pause":
         action_pause(args.state_dir)
-    elif args.action == "unskip":
-        action_unskip(args, args.refactor_list, args.state_dir)
+    elif args.action == "reset_state":
+        action_reset_state(args, args.refactor_list, args.state_dir)
     elif args.action == "complete":
         # Shortcut: 'complete' is equivalent to 'update --session-status success'
         args.session_status = "success"

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

@@ -228,6 +228,125 @@ def dependency_rank_map(items, id_key="id", dependencies_key="dependencies", ite
     return {item[id_key]: index for index, item in enumerate(ordered) if id_key in item}, errors
 
 
+def causal_reset_selection(
+    items,
+    selected_id=None,
+    blocking_root_statuses=None,
+    id_key="id",
+    dependencies_key="dependencies",
+    status_key="status",
+    auto_skipped_status="auto_skipped",
+    item_label="Item",
+):
+    """Return the exact state-only recovery closure for one dependency graph.
+
+    A selected terminal root recovers itself and only ``auto_skipped`` items
+    whose complete transitive blocking-root set is contained by that selection.
+    Selecting an ``auto_skipped`` item first expands the selection to every
+    blocking root required by that item. ``selected_id=None`` means recover all
+    supported blocking roots. Invalid graph or target state raises ``ValueError``
+    before callers perform any mutation.
+    """
+    if not isinstance(items, list):
+        raise ValueError("{} list must be an array".format(item_label))
+
+    roots_statuses = set(blocking_root_statuses or ())
+    if not roots_statuses:
+        raise ValueError("Blocking root statuses must not be empty")
+
+    item_by_id = {}
+    ordered_ids = []
+    for index, item in enumerate(items):
+        if not isinstance(item, dict):
+            raise ValueError("{} at index {} is not an object".format(item_label, index))
+        item_id = item.get(id_key)
+        if not isinstance(item_id, str) or not item_id:
+            raise ValueError("{} at index {} has no valid id".format(item_label, index))
+        if item_id in item_by_id:
+            raise ValueError("Duplicate {} id: {}".format(item_label.lower(), item_id))
+        item_by_id[item_id] = item
+        ordered_ids.append(item_id)
+
+    _ordered, graph_errors = stable_topological_order(
+        items,
+        id_key=id_key,
+        dependencies_key=dependencies_key,
+        item_label=item_label,
+    )
+    if graph_errors:
+        raise ValueError(graph_errors[0])
+
+    blocker_cache = {}
+
+    def transitive_blockers(item_id):
+        cached = blocker_cache.get(item_id)
+        if cached is not None:
+            cached_roots, cached_unresolved = cached
+            return set(cached_roots), set(cached_unresolved)
+        item = item_by_id[item_id]
+        roots = set()
+        unresolved = set()
+        item_status = item.get(status_key, "pending")
+        if item_status in roots_statuses:
+            roots.add(item_id)
+        for dependency_id in item.get(dependencies_key, []) or []:
+            dependency_roots, dependency_unresolved = transitive_blockers(dependency_id)
+            roots.update(dependency_roots)
+            unresolved.update(dependency_unresolved)
+        if item_status == auto_skipped_status and not roots and not unresolved:
+            unresolved.add(item_id)
+        blocker_cache[item_id] = (frozenset(roots), frozenset(unresolved))
+        return roots, unresolved
+
+    if selected_id is None:
+        selected_roots = {
+            item_id
+            for item_id in ordered_ids
+            if item_by_id[item_id].get(status_key, "pending") in roots_statuses
+        }
+        if not selected_roots:
+            raise ValueError("No recoverable blocking roots found")
+    else:
+        target = item_by_id.get(selected_id)
+        if target is None:
+            raise ValueError("{} '{}' not found".format(item_label, selected_id))
+        target_status = target.get(status_key, "pending")
+        if target_status in roots_statuses:
+            selected_roots = {selected_id}
+        elif target_status == auto_skipped_status:
+            selected_roots, unresolved = transitive_blockers(selected_id)
+            if unresolved:
+                raise ValueError(
+                    "{} '{}' has unresolved auto_skipped blocker(s): {}".format(
+                        item_label, selected_id, ", ".join(sorted(unresolved))
+                    )
+                )
+            if not selected_roots:
+                raise ValueError(
+                    "{} '{}' is auto_skipped but has no transitive blocking root".format(
+                        item_label, selected_id
+                    )
+                )
+        else:
+            supported = sorted(roots_statuses | {auto_skipped_status})
+            raise ValueError(
+                "{} '{}' has status '{}', which is not recoverable; expected one of {}".format(
+                    item_label, selected_id, target_status, ", ".join(supported)
+                )
+            )
+
+    selected = set(selected_roots)
+    for item_id in ordered_ids:
+        item = item_by_id[item_id]
+        if item.get(status_key, "pending") != auto_skipped_status:
+            continue
+        blockers, unresolved = transitive_blockers(item_id)
+        if blockers and not unresolved and blockers.issubset(selected_roots):
+            selected.add(item_id)
+
+    return tuple(item_id for item_id in ordered_ids if item_id in selected)
+
+
 def setup_logging(name="prizmkit.dev_pipeline", level=None):
     """Configure and return a standard logger for pipeline scripts.