feat(cadfs): expand selector provenance coverage

cadfs_to_cdsl/rebuild.py

@@ -49,6 +49,42 @@ def _failed_feature_id(error: Exception) -> str | None:
     return match.group(1) if match else None
 
 
+def _last_preflight_executable_prefix(
+    cdsl: dict[str, Any], analysis: Any, output: Path,
+) -> dict[str, Any] | None:
+    """Persist the contiguous executable prefix rejected by later preflight."""
+    feature_results = list(getattr(analysis, "feature_results", ()) or ())
+    first_blocked = next(
+        (index for index, result in enumerate(feature_results) if not result.executable),
+        None,
+    )
+    if first_blocked in (None, 0):
+        return None
+
+    features = list(cdsl.get("features") or [])
+    if first_blocked > len(features):
+        return None
+    prefix = deepcopy(cdsl)
+    prefix["features"] = features[:first_blocked]
+    try:
+        prefix_result = rebuild_candidate(prefix, output)
+    except Exception:
+        return None
+    if prefix_result.get("status") != "rebuilt":
+        nested_prefix = prefix_result.get("last_executable_prefix")
+        return nested_prefix if isinstance(nested_prefix, dict) else None
+    result = prefix_result.get("result")
+    if not isinstance(result, dict):
+        return None
+    return {
+        "failed_feature_id": feature_results[first_blocked].feature_id,
+        "feature_count": first_blocked,
+        "last_feature_id": features[first_blocked - 1].get("id"),
+        "bound_cdsl": prefix_result.get("bound_cdsl", prefix),
+        "result": result,
+    }
+
+
 def rebuild_candidate(cdsl: dict[str, Any], output: Path) -> dict[str, Any]:
     from engine.cdsl_engine.runtime import analyze_cdsl, finalize_cdsl_execution
     from .selector_binding import bind_and_execute_candidate_selectors
@@ -56,7 +92,11 @@ def rebuild_candidate(cdsl: dict[str, Any], output: Path) -> dict[str, Any]:
     analysis = analyze_cdsl(cdsl)
     analysis_dict = analysis.as_dict() if hasattr(analysis, "as_dict") else {"runtime_eligible": analysis.runtime_eligible}
     if not analysis.runtime_eligible:
-        return {"status": "runtime_ineligible", "analysis": analysis_dict}
+        result = {"status": "runtime_ineligible", "analysis": analysis_dict}
+        prefix = _last_preflight_executable_prefix(cdsl, analysis, output)
+        if prefix is not None:
+            result["last_executable_prefix"] = prefix
+        return result
     try:
         replay = bind_and_execute_candidate_selectors(cdsl)
         result = finalize_cdsl_execution(replay.execution, output)