cdsl-cad/cadfs_to_cdsl/tests/test_lowering.py

from __future__ import annotations

import json, math, re, tempfile, unittest
from copy import deepcopy
from pathlib import Path
from unittest.mock import patch
from cadfs_to_cdsl.compare import compare_steps
from cadfs_to_cdsl.featurescript_parser import parse_featurescript
from cadfs_to_cdsl.ir import Call
from cadfs_to_cdsl.lowering import (
    UnsupportedCapability, _arc, _contours, _curve_endpoint_tangent,
    _direct_hole_location, _direct_line_angle_axis, _direct_segmented_sketch_wire_path,
    _is_direct_hole_location_query,
    _direct_line_angle_wire_axis, _direct_sketch_wire_path, _direct_spatial_segmented_sketch_wire_path,
    _direct_boolean_intersection_selector, _direct_primary_cut_intersection_selector, _global, _number,
    _multi_source_sketch_region_profile, _record_single_body_successor, _surface_profile_selection_sketch, lower_model,
)
from cadfs_to_cdsl.pipeline import compare_one, convert_one, rebuild_one
from cadfs_to_cdsl.rebuild import rebuild_candidate
from cadfs_to_cdsl.dataset import Sample
from cadfs_to_cdsl.dataset import scan_dataset
from cadfs_to_cdsl.tests.test_parser import SOURCE, TRANSFORM_SOURCE


LINE_ANGLE_TWO_ENTITY_SOURCE = '''FeatureScript 1511;
import(path : "onshape/std/geometry.fs", version : "1511.0");
const mm = millimeter;
const VERTEX = EntityType.VERTEX;
const EDGE = EntityType.EDGE;
const FACE = EntityType.FACE;
function v(x, y){return vector(x, y);}
annotation { "Feature Type Name" : "Feature" }
export const myFeature = defineFeature(function(context is Context, id is Id, definition is map)
precondition{}
{
    { var Q0; Q0=qCreatedBy(makeId("Top.planeOp"),FACE); var sketch=newSketch(context,id+"F0",{"sketchPlane":qUnion([Q0])}); skLineSegment(sketch,"E0",{"start":v(0,0)*mm,"end":v(10,0)*mm}); skLineSegment(sketch,"E1",{"start":v(0,0)*mm,"end":v(0,10)*mm}); skLineSegment(sketch,"E2",{"start":v(0,5)*mm,"end":v(10,5)*mm}); skPoint(sketch,"P0",{"position":v(0,10)*mm}); skPoint(sketch,"P1",{"position":v(10,0)*mm}); skSolve(sketch); }
    { var Q0; Q0=sQuery(id+"F0.wireOp",EDGE,"E0"); var Q1; Q1=sQuery(id+"F0.wireOp",EDGE,"E1"); cPlane(context,id+"F1",{"entities":qUnion([Q0,Q1]),"cplaneType":CPlaneType.LINE_ANGLE,"angle":0*degree}); }
    { var Q0; Q0=sQuery(id+"F0.wireOp",EDGE,"E0"); var Q1; Q1=sQuery(id+"F0.wireOp",EDGE,"E2"); cPlane(context,id+"F2",{"entities":qUnion([Q0,Q1]),"cplaneType":CPlaneType.LINE_ANGLE,"angle":0*degree}); }
    { var Q0; Q0=sQuery(id+"F0.wireOp",EDGE,"E0"); var Q1; Q1=sQuery(id+"F0.wireOp",VERTEX,"P0"); cPlane(context,id+"F3",{"entities":qUnion([Q0,Q1]),"cplaneType":CPlaneType.LINE_ANGLE,"angle":0*degree}); }
    { var Q0; Q0=sQuery(id+"F0.wireOp",VERTEX,"P0"); var Q1; Q1=sQuery(id+"F0.wireOp",EDGE,"E0"); cPlane(context,id+"F4",{"entities":qUnion([Q0,Q1]),"cplaneType":CPlaneType.LINE_ANGLE,"angle":90*degree,"oppositeDirection":true}); }
    { var Q0; Q0=sQuery(id+"F0.wireOp",EDGE,"E0"); var Q1; Q1=sQuery(id+"F0.wireOp",VERTEX,"P1"); cPlane(context,id+"F5",{"entities":qUnion([Q0,Q1]),"cplaneType":CPlaneType.LINE_ANGLE,"angle":0*degree}); }
    { var Q0; Q0=sQuery(id+"F0.wireOp",EDGE,"E0"); var Q1; Q1=qCreatedBy(id+"F1.planeOp",FACE); cPlane(context,id+"F6",{"entities":qUnion([Q0,Q1]),"cplaneType":CPlaneType.LINE_ANGLE,"angle":0*degree}); }
}'''


CAP_VERTEX_UP_TO_VERTEX_SOURCE = '''FeatureScript 1511;
import(path : "onshape/std/geometry.fs", version : "1511.0");
const mm = millimeter;
const EDGE = EntityType.EDGE;
const VERTEX = EntityType.VERTEX;
const FACE = EntityType.FACE;
function v(x, y){return vector(x, y);}
annotation { "Feature Type Name" : "Feature" }
export const myFeature = defineFeature(function(context is Context, id is Id, definition is map)
precondition{}
{
    { var Q0; Q0=qCreatedBy(makeId("Top.planeOp"),FACE); var sketch=newSketch(context,id+"F0",{"sketchPlane":qUnion([Q0])}); skLineSegment(sketch,"E0",{"start":v(0,0)*mm,"end":v(10,0)*mm}); skLineSegment(sketch,"E1",{"start":v(10,0)*mm,"end":v(10,5)*mm}); skLineSegment(sketch,"E2",{"start":v(10,5)*mm,"end":v(0,5)*mm}); skLineSegment(sketch,"E3",{"start":v(0,5)*mm,"end":v(0,0)*mm}); skSolve(sketch); }
    { var Q0; Q0=qSketchRegion(id+"F0",true); extrude(context,id+"F1",{"entities":qUnion([Q0]),"depth":10*mm}); }
    { var Q0; Q0=qSketchRegion(id+"F0",true); var Q1; Q1=makeQuery(id+"F1.opExtrude","CAP_VERTEX",VERTEX,{"disambiguationData":[OSD([sQuery(id+"F0.wireOp",EDGE,"E0"),sQuery(id+"F0.wireOp",EDGE,"E1")])],"isStart":false}); extrude(context,id+"F2",{"entities":qUnion([Q0]),"endBound":BoundingType.UP_TO_VERTEX,"endBoundEntityVertex":qUnion([Q1]),"depth":8*mm}); }
}'''


class LoweringTests(unittest.TestCase):
    def test_multi_source_sketch_region_union_preserves_all_direct_profiles(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test/featurescript_rp"
        source = root / "0001/00011635.txt"
        if not source.exists(): self.skipTest("CADFS sample is not installed")

        result = lower_model(parse_featurescript(source.read_text(encoding="utf-8"), "00011635"), {})
        self.assertEqual({item["id"] for item in result.cdsl["features"]}, {"f_F1", "f_F3", "f_F5", "f_F7", "f_F10"})
        profile = next(
            sketch["profile"] for sketch in result.cdsl["geometry"]["sketches"]
            if sketch["id"] == "sketch_regions_f_F7"
        )
        self.assertEqual(profile["type"], "multi_source_regions")
        self.assertEqual(profile["source_sketch_ids"], ["F6", "F4"])
        self.assertEqual(len(profile["profiles"]), 2)

        # A composed source query outside the strict direct-region contract
        # must defer rather than select the last source sketch as older
        # lowering did.
        text = source.read_text(encoding="utf-8")
        needle = 'qSketchRegion(id + "F4", true)'
        offset = text.rfind(needle)
        invalid = lower_model(parse_featurescript(
            text[:offset] + text[offset:].replace(needle, 'qSketchRegion(id + "F4", false)', 1),
            "00011635-invalid-regions",
        ), {})
        self.assertNotIn("f_F7", {item["id"] for item in invalid.cdsl["features"]})
        self.assertIn(("F7", "unsupported_engine_capability", "extrude qSketchRegion union requires direct executable source profiles on one identical unattached frame"), {
            (item.get("feature_id"), item.get("code"), item.get("message")) for item in invalid.diagnostics
        })

    def test_multi_source_sketch_region_requires_identical_unattached_frames(self):
        def sketch(radius, plane, attachment=None):
            result = {"workplane": plane, "profile": {"type": "circle", "radius_mm": radius}}
            if attachment is not None: result["attachment"] = attachment
            return result

        query = Call("qUnion", [[
            Call("qSketchRegion", ["F0", "true"]), Call("qSketchRegion", ["F1", "true"]),
        ]])
        plane = {"origin_mm": [0, 0, 0], "x_dir": [1, 0, 0], "normal": [0, 0, 1]}
        self.assertIsNotNone(_multi_source_sketch_region_profile(query, {
            "F0": sketch(2, plane), "F1": sketch(3, deepcopy(plane)),
        }, "f_regions"))
        self.assertIsNone(_multi_source_sketch_region_profile(query, {
            "F0": sketch(2, plane), "F1": sketch(3, {**plane, "origin_mm": [0, 0, 1]}),
        }, "f_regions"))
        self.assertIsNone(_multi_source_sketch_region_profile(query, {
            "F0": sketch(2, plane), "F1": sketch(3, plane, {"kind": "face"}),
        }, "f_regions"))

    def test_multi_source_sketch_region_union_flattens_only_nested_union_wrappers(self):
        plane = {"origin_mm": [0, 0, 0], "x_dir": [1, 0, 0], "normal": [0, 0, 1]}
        sources = {
            identifier: {"workplane": deepcopy(plane), "profile": {"type": "circle", "radius_mm": radius}}
            for identifier, radius in (("F0", 2), ("F1", 3), ("F2", 4))
        }
        region = lambda identifier: Call("qSketchRegion", [identifier, "true"])
        nested = Call("qUnion", [[region("F0"), Call("qUnion", [[region("F1"), region("F2")]])]])
        profile = _multi_source_sketch_region_profile(nested, sources, "f_regions")
        self.assertEqual(profile["profile"]["source_sketch_ids"], ["F0", "F1", "F2"])

        # qIntersection has different set semantics and cannot be normalized
        # as a profile union merely because it contains direct region leaves.
        mixed = Call("qUnion", [[region("F0"), Call("qIntersection", [region("F1"), region("F2")])]])
        self.assertIsNone(_multi_source_sketch_region_profile(mixed, sources, "f_regions"))
    def test_cpoint_direct_source_line_is_an_explicit_datum_only(self):
        """A direct source line cPoint feeds cPlane without topology fallback."""
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test/featurescript_rp"
        source = root / "0024/00240949.txt"
        if not source.exists(): self.skipTest("CADFS sample is not installed")

        result = lower_model(parse_featurescript(source.read_text(), "00240949"), {})
        self.assertEqual(result.status, "converted_complete")
        features = {item["id"]: item for item in result.cdsl["features"]}
        self.assertEqual(features["f_F3"], {
            "id": "f_F3", "name": "F3", "atomic_id": "reference_point",
            "depends_on": ["f_F1"], "params": {"point_mm": [15.05, 0.0, 22.985]},
            "execution_status": "supported",
        })
        self.assertEqual(features["f_F4"]["params"]["plane"]["origin_mm"], [15.05, 0.0, 22.985])

        from engine.cdsl_engine.runtime import prepare_cdsl_execution
        from engine.cdsl_engine.semantic_validation import validate_semantic_cdsl
        validate_semantic_cdsl(result.cdsl)
        execution = prepare_cdsl_execution(result.cdsl)
        for _ in range(6):
            execution.execute_next()
        self.assertEqual(list(execution.session.results), ["f_F1", "f_F3", "f_F4", "f_F6", "f_F7", "f_F9"])
        self.assertIsNone(execution.session.results["f_F3"].body_id)

    def test_cpoint_direct_line_boundary_and_rejection_contract(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test/featurescript_rp"
        direct = root / "0050/00503730.txt"
        if not direct.exists(): self.skipTest("CADFS sample is not installed")

        result = lower_model(parse_featurescript(direct.read_text(), "00503730"), {})
        features = {item["id"]: item for item in result.cdsl["features"]}
        self.assertEqual(features["f_F1"]["atomic_id"], "reference_point")
        self.assertEqual(features["f_F1"]["params"]["point_mm"], [0.0, 4.5, 0.0])
        self.assertEqual(features["f_F2"]["params"]["plane"]["origin_mm"], [0.0, 4.5, 0.0])
        self.assertEqual(features["f_F4"]["params"]["end_condition"]["reference"], {
            "kind": "source_vertex", "source_sketch_id": "F0",
            "source_entity_id": "E4.bottom.end", "point_mm": [-1.3, -4.5, 0.0],
        })
        self.assertIn(("F6", "feature_deferred", "swept edge source endpoint provenance is unsupported"), {
            (item.get("feature_id"), item.get("code"), item.get("message")) for item in result.diagnostics
        })

        invalid = lower_model(parse_featurescript(
            direct.read_text().replace('"parameter" : 0.5', '"parameter" : 1.5', 1), "00503730"), {})
        self.assertIn(("F1", "unsupported_engine_capability", "cPoint parameter must be a finite value in [0, 1]"), {
            (item.get("feature_id"), item.get("code"), item.get("message")) for item in invalid.diagnostics
        })

        rejected = root / "0023/00238956.txt"
        if not rejected.exists(): self.skipTest("CADFS sample is not installed")
        outcome = lower_model(parse_featurescript(rejected.read_text(), "00238956"), {})
        self.assertTrue(any(
            item.get("code") == "unsupported_engine_capability"
            and item.get("message") == "cPoint datum source is unsupported"
            for item in outcome.diagnostics
        ))

    def test_cpoint_direct_prism_swept_and_cap_edges_are_source_datums(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test/featurescript_rp"
        source = root / "0028/00289068.txt"
        if not source.exists(): self.skipTest("CADFS sample is not installed")

        text = source.read_text(encoding="utf-8")
        result = lower_model(parse_featurescript(text, "00289068"), {})
        self.assertEqual(result.status, "converted_complete")
        features = {item["id"]: item for item in result.cdsl["features"]}
        self.assertEqual(features["f_F3"]["params"]["point_mm"], [25.85, -42.6, 38.1])
        self.assertEqual(features["f_F4"]["params"]["point_mm"], [25.85, -4.5, 76.2])
        self.assertEqual(features["f_F5"]["params"]["plane"]["origin_mm"], [-12.25, -42.6, 76.2])
        self.assertTrue(all("selectors" not in features[feature_id] for feature_id in ("f_F3", "f_F4")))

        from engine.cdsl_engine.runtime import prepare_cdsl_execution
        execution = prepare_cdsl_execution(result.cdsl)
        execution.execute_all()
        self.assertEqual(list(execution.session.results), ["f_F1", "f_F3", "f_F4", "f_F5", "f_F7"])

        # A source pair without a unique profile vertex cannot describe the
        # physical swept span. A through-all extrusion has no blind cap role.
        mutations = (
            text.replace('sQuery(id+"F0.wireOp",EDGE,"E0.bottom"),sQuery(id+"F0.wireOp",EDGE,"E0.right")',
                         'sQuery(id+"F0.wireOp",EDGE,"E0.bottom"),sQuery(id+"F0.wireOp",EDGE,"E0.top")', 1),
            text.replace('"entities" : qUnion([Q0]), "depth" : 76.2 * mm',
                         '"entities" : qUnion([Q0]), "endBound" : BoundingType.THROUGH_ALL, "depth" : 76.2 * mm', 1),
        )
        for index, mutated in enumerate(mutations):
            with self.subTest(mutation=index):
                candidate = lower_model(parse_featurescript(mutated, f"cpoint-prism-mutation-{index}"), {})
                rejected_feature = "F3" if index == 0 else "F4"
                self.assertIn((rejected_feature, "unsupported_engine_capability", "cPoint datum source is unsupported"), {
                    (item.get("feature_id"), item.get("code"), item.get("message"))
                    for item in candidate.diagnostics
                })

    def test_direct_prism_cap_vertex_up_to_vertex_uses_kernel_history(self):
        result = lower_model(parse_featurescript(CAP_VERTEX_UP_TO_VERTEX_SOURCE), {})
        self.assertEqual(result.status, "converted_complete")
        end = {item["id"]: item for item in result.cdsl["features"]}["f_F2"]["params"]["end_condition"]
        self.assertEqual(end["type"], "up_to_vertex")
        reference = end["reference"]
        self.assertEqual(reference["kind"], "vertex")
        self.assertEqual(reference["owner_feature_id"], "f_F1")
        self.assertEqual(reference["selector_intent"]["query_family"], "CAP_VERTEX")
        self.assertEqual(reference["selector_intent"]["lineage_role"], "extrude.end")
        self.assertEqual(reference["selector_intent"]["derivation_policy"], {
            "allowed": ["boundary"], "multiplicity": "one",
        })
        self.assertEqual(reference["selector_intent"]["source_entities"], [
            {"sketch_id": "F0", "entity_id": "E0"},
            {"sketch_id": "F0", "entity_id": "E1"},
        ])
        from engine.cdsl_engine.runtime import rebuild_cdsl
        with tempfile.TemporaryDirectory() as directory:
            rebuilt = rebuild_cdsl(result.cdsl, Path(directory) / "cap-vertex.step")
        self.assertEqual([item["status"] for item in rebuilt["feature_results"]], ["executed", "executed"])
        resolution = rebuilt["selector_resolution"][-1]
        self.assertEqual(resolution["status"], "resolved")
        self.assertEqual(resolution["resolution_mode"], "kernel_lineage")
        self.assertEqual(resolution["evidence"]["relations"][0]["result_kind"], "vertex")

    def test_direct_source_vertex_up_to_vertex_is_a_datum_not_a_runtime_selector(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        source = root / "featurescript_rp/0044/00444951.txt"
        if not source.exists(): self.skipTest("CADFS sample is not installed")

        result = lower_model(parse_featurescript(source.read_text(encoding="utf-8"), "00444951"), {})
        self.assertEqual(result.status, "converted_complete")
        features = {item["id"]: item for item in result.cdsl["features"]}
        for feature_id, source_entity_id in (("f_F5", "E0.left.end"), ("f_F7", "E6.end"), ("f_F9", "E5.end")):
            reference = features[feature_id]["params"]["end_condition"]["reference"]
            self.assertEqual(reference["kind"], "source_vertex")
            self.assertEqual(reference["source_sketch_id"], "F0")
            self.assertEqual(reference["source_entity_id"], source_entity_id)
            self.assertNotIn("selector_intent", reference)
            self.assertNotIn("stable_id", reference)

        from engine.cdsl_engine.runtime import rebuild_cdsl
        with tempfile.TemporaryDirectory() as directory:
            rebuilt = rebuild_cdsl(result.cdsl, Path(directory) / "source-vertex-extent.step")
        self.assertEqual([item["status"] for item in rebuilt["feature_results"]], ["executed"] * 6)
        self.assertEqual(rebuilt["selector_resolution"], [])

        # The CADFS pipeline uses incremental selector binding before runtime
        # execution.  A source datum must not be handed to that binder.
        with tempfile.TemporaryDirectory() as directory:
            outcome = rebuild_candidate(result.cdsl, Path(directory) / "source-vertex-bound.step")
        self.assertEqual(outcome["status"], "rebuilt")
        self.assertTrue(all(not item["resolved"] for item in outcome["selector_binding"]))

        from engine.cdsl_engine.semantic_validation import validate_semantic_cdsl
        invalid = deepcopy(result.cdsl)
        invalid["features"][3]["params"]["end_condition"]["reference"]["source_sketch_id"] = "missing"
        with self.assertRaisesRegex(ValueError, "invalid source_vertex extent datum"):
            validate_semantic_cdsl(invalid)

        wrapped = source.read_text(encoding="utf-8").replace(
            'Q1=sQuery(id+"F0.wireOp",VERTEX,"E0.left.end");',
            'Q1=qAdjacent(sQuery(id+"F0.wireOp",VERTEX,"E0.left.end"));',
            1,
        )
        rejected = lower_model(parse_featurescript(wrapped, "00444951-wrapped-vertex"), {})
        self.assertIn(("F5", "feature_deferred", "topology query is unresolved"), {
            (item.get("feature_id"), item.get("code"), item.get("message"))
            for item in rejected.diagnostics
        })

    def test_direct_source_vertex_up_to_vertex_real_corpus_matrix(self):
        """Direct source vertices remain datums across one- and two-sided extents."""
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test/featurescript_rp"
        cases = {
            "00383982": ("0038/00383982.txt", "converted_complete", 1),
            "00503730": ("0050/00503730.txt", "converted_partial", 1),
            "00510558": ("0051/00510558.txt", "converted_complete", 4),
            "00753006": ("0075/00753006.txt", "converted_partial", 2),
            "00894150": ("0089/00894150.txt", "converted_complete", 3),
            "00975649": ("0097/00975649.txt", "converted_complete", 1),
        }
        for sample_id, (relative_path, expected_status, expected_count) in cases.items():
            with self.subTest(sample_id=sample_id):
                source = root / relative_path
                if not source.exists():
                    self.skipTest("CADFS sample is not installed")
                result = lower_model(parse_featurescript(source.read_text(encoding="utf-8"), sample_id), {})
                references = [
                    condition["reference"]
                    for feature in result.cdsl["features"]
                    for condition in (
                        (feature.get("params") or {}).get("end_condition"),
                        (feature.get("params") or {}).get("reverse_end_condition"),
                    )
                    if isinstance(condition, dict)
                    and condition.get("type") == "up_to_vertex"
                    and isinstance(condition.get("reference"), dict)
                    and condition["reference"].get("kind") == "source_vertex"
                ]
                self.assertEqual(result.status, expected_status)
                self.assertEqual(len(references), expected_count)
                self.assertTrue(all("selector_intent" not in reference for reference in references))

    def test_cap_vertex_survives_an_exact_independent_body_member_preservation(self):
        """An added independent body may retain an older member only by IsSame."""
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0033/00330726.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")

        result = lower_model(parse_featurescript(feature.read_text(), "00330726"), {})
        features = {item["id"]: item for item in result.cdsl["features"]}
        self.assertTrue({"f_F1", "f_F3", "f_F5"}.issubset(features))
        reference = features["f_F5"]["params"]["end_condition"]["reference"]
        self.assertEqual(reference["selector_intent"]["query_family"], "CAP_VERTEX")
        self.assertEqual(reference["selector_intent"]["derivation_policy"], {
            "allowed": ["boundary", "continuation"], "multiplicity": "one",
        })

        from engine.cdsl_engine.runtime import prepare_cdsl_execution
        execution = prepare_cdsl_execution(result.cdsl)
        for _index in range(3): execution.execute_next()
        resolution = execution.session.selector_resolutions[-1]
        self.assertEqual(resolution["status"], "resolved")
        self.assertEqual(resolution["resolution_mode"], "kernel_lineage")
        self.assertEqual(
            [item["operation"] for item in resolution["evidence"]["relations"]],
            ["extrude", "body_member_preserve"],
        )

    def test_three_point_plane_accepts_only_direct_prism_cap_vertex_source_data(self):
        """CAP vertices used as datum points retain source, not snapshot, semantics."""
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        from engine.cdsl_engine.runtime import prepare_cdsl_execution

        for sample_id in ("00243142", "00245768"):
            feature = root / "featurescript_rp" / sample_id[:4] / f"{sample_id}.txt"
            if not feature.exists(): self.skipTest("CADFS sample is not installed")
            result = lower_model(parse_featurescript(feature.read_text(), sample_id), {})
            plane = next(item for item in result.cdsl["features"] if item["id"] == "f_F2")
            self.assertEqual(plane["atomic_id"], "reference_plane")
            self.assertNotIn("selectors", plane)

            execution = prepare_cdsl_execution(result.cdsl)
            execution.execute_next()
            execution.execute_next()
            self.assertEqual(execution.session.results["f_F2"].atomic_id, "reference_plane")
            execution.execute_all()
            self.assertTrue(all(
                feature_result.status == "executed"
                for feature_result in execution.session.results.values()
            ))

        # This otherwise direct CAP_VERTEX is separated from its prism by a
        # hole. Its source-datum frame must not pretend the pre-hole cap is a
        # currently valid direct-prism point.
        mutated = root / "featurescript_rp/0005/00053942.txt"
        if not mutated.exists(): self.skipTest("CADFS sample is not installed")
        rejected = lower_model(parse_featurescript(mutated.read_text(), "00053942"), {})
        self.assertNotIn("f_F4", {item["id"] for item in rejected.cdsl["features"]})
        self.assertIn(
            ("F4", "feature_deferred", "CAP_VERTEX datum source is unsupported"),
            {(item.get("feature_id"), item.get("code"), item.get("message")) for item in rejected.diagnostics},
        )

    def test_line_angle_source_wire_axis_accepts_one_line_including_construction(self):
        plane = {"origin_mm": [0.0, 0.0, 0.0], "x_dir": [1.0, 0.0, 0.0], "normal": [0.0, 0.0, 1.0]}
        query = Call("qBodyType", [
            Call("qCreatedBy", [Call("__binary__", ["id", "+", "F0"]), "EDGE"]),
            "BodyType.WIRE",
        ])
        source = {"F0": {"workplane": plane}}
        construction_line = {
            "type": "line", "start": [2.0, 3.0], "end": [2.0, 8.0], "construction": True,
        }
        kwargs = {
            "featurescript_version": "1511",
            "standard_library": "onshape/std/geometry.fs",
            "standard_library_version": "1511.0",
        }

        self.assertEqual(
            _direct_line_angle_wire_axis(query, source, {"F0": {"axis": construction_line}}, **kwargs),
            ([2.0, 3.0, 0.0], [0.0, 1.0, 0.0]),
        )
        self.assertIsNone(_direct_line_angle_wire_axis(
            query, source, {"F0": {"axis": construction_line, "extra": {**construction_line, "start": [0.0, 0.0]}}}, **kwargs,
        ))
        self.assertIsNone(_direct_line_angle_wire_axis(
            query, source, {"F0": {"arc": {"type": "arc", "start": [0.0, 0.0], "end": [1.0, 1.0]}}}, **kwargs,
        ))
        self.assertIsNone(_direct_line_angle_wire_axis(
            query, source, {"F0": {"axis": construction_line}},
            **{**kwargs, "featurescript_version": "1512"},
        ))
        filtered = Call("qConstructionFilter", [query, "ConstructionObject.NO"])
        self.assertIsNone(_direct_line_angle_wire_axis(
            filtered, source, {"F0": {"axis": construction_line}}, **kwargs,
        ))
        self.assertEqual(
            _direct_line_angle_wire_axis(
                filtered,
                source,
                {"F0": {"axis": construction_line, "visible": {"type": "line", "start": [5.0, 1.0], "end": [5.0, 4.0]}}},
                **kwargs,
            ),
            ([5.0, 1.0, 0.0], [0.0, 1.0, 0.0]),
        )

    def test_surface_loft_accepts_two_direct_closed_source_wires_without_changing_body_lifecycle(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0017/00174697.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(feature.read_text(), "00174697"), {})
        surface_loft = next(item for item in result.cdsl["features"] if item["id"] == "f_F3")
        self.assertEqual(result.status, "converted_complete")
        self.assertEqual(surface_loft["atomic_id"], "loft_surface")
        self.assertEqual(len(surface_loft["params"]["profile_sketch_ids"]), 2)
        with tempfile.TemporaryDirectory() as directory:
            rebuilt = rebuild_candidate(result.cdsl, Path(directory) / "surface-loft.step")
        self.assertEqual(rebuilt["status"], "rebuilt")
        self.assertEqual(rebuilt["result"]["solid_count"], 0)
        self.assertEqual(rebuilt["result"]["surface_count"], 1)

    def test_surface_loft_defers_when_source_wire_form_has_an_unmodeled_derivative(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0017/00174697.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        source = feature.read_text().replace(
            '"wireProfilesArray" : [{ "wireProfileEntities" : qUnion([Q0]) }, { "wireProfileEntities" : qUnion([Q1]) }]',
            '"startCondition" : LoftEndDerivativeType.NORMAL_TO_PROFILE, "wireProfilesArray" : [{ "wireProfileEntities" : qUnion([Q0]) }, { "wireProfileEntities" : qUnion([Q1]) }]',
        )
        result = lower_model(parse_featurescript(source, "00174697-surface-loft-derivative"), {})
        self.assertIn({
            "code": "unsupported_engine_capability",
            "capability": "loft_surface_wire_profiles",
            "feature_id": "F3",
            "operation": "loft",
            "message": "current CDSL surface loft requires two direct closed source-wire profiles",
        }, result.diagnostics)

    def test_direct_sketch_wire_path_accepts_only_one_nonconstruction_open_curve(self):
        plane = {"origin_mm": [0.0, 0.0, 0.0], "x_dir": [1.0, 0.0, 0.0], "normal": [0.0, 0.0, 1.0]}
        line = {"type": "line", "start": [0.0, 0.0], "end": [10.0, 0.0], "source_entity_id": "E0"}
        query = Call("qUnion", [[
            Call("qConstructionFilter", [
                Call("qBodyType", [
                    Call("qCreatedBy", [Call("__binary__", ["id", "+", "F0"]), "EDGE"]),
                    "BodyType.WIRE",
                ]),
                "ConstructionObject.NO",
            ]),
        ]])
        sketches = {"F0": {"workplane": plane}}
        entities = {"F0": {"E0": line, "axis": {"type": "line", "start": [0.0, 0.0], "end": [0.0, 5.0], "construction": True}}}

        self.assertEqual(
            _direct_sketch_wire_path(
                query, sketches, entities, featurescript_version="1511",
                standard_library="onshape/std/geometry.fs", standard_library_version="1511.0",
            ),
            ("F0", "E0", line, sketches["F0"]),
        )
        self.assertIsNone(_direct_sketch_wire_path(
            query, sketches, entities, featurescript_version="1512",
            standard_library="onshape/std/geometry.fs", standard_library_version="1511.0",
        ))
        self.assertIsNone(_direct_sketch_wire_path(
            query, sketches, entities, featurescript_version="1511",
            standard_library="onshape/std/geometry.fs", standard_library_version="1512.0",
        ))
        self.assertIsNone(_direct_sketch_wire_path(
            query, sketches, {"F0": {"E0": line, "E1": {**line, "source_entity_id": "E1"}}},
            featurescript_version="1511", standard_library="onshape/std/geometry.fs", standard_library_version="1511.0",
        ))
        self.assertIsNone(_direct_sketch_wire_path(
            Call("qBodyType", [Call("qCreatedBy", ["F0", "EDGE"]), "BodyType.WIRE"]),
            sketches, entities, featurescript_version="1511",
            standard_library="onshape/std/geometry.fs", standard_library_version="1511.0",
        ))
        self.assertIsNone(_direct_sketch_wire_path(
            query.args[0][0], sketches, entities, featurescript_version="1511",
            standard_library="onshape/std/geometry.fs", standard_library_version="1511.0",
        ))
        arc = {
            "type": "arc", "start": [0.0, 0.0], "end": [10.0, 0.0],
            "center": [5.0, 5.0], "radius_mm": math.sqrt(50.0), "clockwise": False,
        }
        self.assertEqual(
            _direct_sketch_wire_path(
                query, sketches, {"F0": {"E0": arc}}, featurescript_version="1511",
                standard_library="onshape/std/geometry.fs", standard_library_version="1511.0",
            ),
            ("F0", "E0", arc, sketches["F0"]),
        )
        self.assertIsNone(_direct_sketch_wire_path(
            query, sketches, {"F0": {"E0": {"type": "circle", "center": [0.0, 0.0], "radius_mm": 5.0}}},
            featurescript_version="1511", standard_library="onshape/std/geometry.fs", standard_library_version="1511.0",
        ))

    def test_direct_source_arc_sweep_preserves_cap_source_contract(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        source = root / "featurescript_rp/0000/00007135.txt"
        if not source.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(source.read_text(encoding="utf-8"), "00007135"), {})
        self.assertEqual(result.status, "converted_complete")
        sweep = next(item for item in result.cdsl["features"] if item["id"] == "f_F2")
        self.assertEqual(sweep["params"]["path"]["segment"]["type"], "arc")
        self.assertEqual(sweep["params"]["cap_output_contract"], {
            "profile_source": "F1", "profile_entity": "E1",
            "path_source": "F0", "path_entity": "E0", "path_reversed": False,
        })
        with tempfile.TemporaryDirectory() as directory:
            rebuilt = rebuild_candidate(result.cdsl, Path(directory) / "arc-sweep-shell.step")
        self.assertEqual(rebuilt["status"], "rebuild_failed")
        self.assertEqual(rebuilt["last_executable_prefix"]["last_feature_id"], "f_F2")

        standalone = root / "featurescript_rp/0017/00175627.txt"
        if not standalone.exists(): self.skipTest("CADFS sample is not installed")
        standalone_result = lower_model(parse_featurescript(standalone.read_text(encoding="utf-8"), "00175627"), {})
        self.assertEqual(standalone_result.status, "converted_complete")
        standalone_sweep = next(item for item in standalone_result.cdsl["features"] if item["id"] == "f_F2")
        self.assertEqual(standalone_sweep["params"]["path"]["segment"]["type"], "arc")
        with tempfile.TemporaryDirectory() as directory:
            standalone_rebuilt = rebuild_candidate(standalone_result.cdsl, Path(directory) / "arc-sweep.step")
        self.assertEqual(standalone_rebuilt["status"], "rebuilt")
        self.assertEqual(standalone_rebuilt["result"]["feature_results"][-1]["feature_id"], "f_F2")

    def test_single_arc_source_wire_sweep_uses_the_complete_wire_selection(self):
        """A one-curve qBodyType(WIRE) path is not a parser representative leaf."""
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        for sample_id in ("00071885", "00109840", "00627942"):
            source = root / f"featurescript_rp/{sample_id[:4]}/{sample_id}.txt"
            if not source.exists():
                self.skipTest("CADFS sample is not installed")
            with self.subTest(sample_id=sample_id):
                lowered = lower_model(parse_featurescript(source.read_text(encoding="utf-8"), sample_id), {})
                self.assertNotIn(
                    "sweep_path",
                    [item.get("capability") for item in lowered.diagnostics],
                )
                # This source's profile attachment is independently
                # degenerate. The path is nevertheless no longer classified
                # as an unsupported query, and remains outside CDSL when no
                # executable feature can be retained.
                if lowered.cdsl is None:
                    self.assertIn("reference plane x direction is degenerate", [
                        item.get("message") for item in lowered.diagnostics
                    ])
                    continue
                sweep = next(item for item in lowered.cdsl["features"] if item["id"] == "f_F2")
                self.assertEqual(sweep["params"]["path"]["segment"]["type"], "arc")
                with tempfile.TemporaryDirectory() as directory:
                    rebuilt = rebuild_candidate(lowered.cdsl, Path(directory) / f"{sample_id}-arc-wire.step")
                self.assertIn(rebuilt["status"], {"rebuilt", "rebuild_failed"})
                self.assertNotEqual(
                    rebuilt.get("error", {}).get("message"),
                    "Feature f_F2 is not runtime eligible: sweep_path",
                )

    def test_direct_source_circle_sweep_is_closed_and_has_no_endpoint_roles(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test/featurescript_rp"
        for sample_id, relative_path in (
            ("00232443", "0023/00232443.txt"),
            ("00310959", "0031/00310959.txt"),
        ):
            source = root / relative_path
            if not source.exists():
                self.skipTest("CADFS sample is not installed")
            lowered = lower_model(parse_featurescript(source.read_text(encoding="utf-8"), sample_id), {})
            self.assertEqual(lowered.status, "converted_complete")
            sweep = next(item for item in lowered.cdsl["features"] if item["id"] == "f_F2")
            self.assertEqual(sweep["params"]["path"]["segment"]["type"], "circle")
            self.assertNotIn("initial_output_roles", sweep["params"])
            self.assertNotIn("cap_output_contract", sweep["params"])
            self.assertNotIn("swept_face_contract", sweep["params"])
            self.assertNotIn("swept_edge_contract", sweep["params"])
            with tempfile.TemporaryDirectory() as directory:
                rebuilt = rebuild_candidate(lowered.cdsl, Path(directory) / f"{sample_id}-circle-sweep.step")
            self.assertEqual(rebuilt["status"], "rebuilt")
            self.assertEqual(rebuilt["result"]["solid_count"], 1)

        multi_query_source = (root / "0023/00232443.txt").read_text(encoding="utf-8")
        multi_query_source = multi_query_source.replace(
            'Q1=sQuery(id+"F1.wireOp",EDGE,"E1");',
            'Q1=qUnion([sQuery(id+"F1.wireOp",EDGE,"E1"),sQuery(id+"F1.wireOp",EDGE,"E1")]);',
        )
        rejected = lower_model(parse_featurescript(multi_query_source, "circle-multi-query"), {})
        self.assertEqual(rejected.status, "deferred_no_executable_feature")
        self.assertIsNone(rejected.cdsl)

    def test_single_circle_source_wire_sweep_uses_complete_qbodytype_selection(self):
        """A qBodyType circle needs complete-set proof, not a parser leaf."""
        source = (
            Path(__file__).parents[2]
            / "data/cadfs-sample/CADFS_test/featurescript_rp/0049/00498974.txt"
        )
        if not source.exists():
            self.skipTest("CADFS sample is not installed")
        lowered = lower_model(parse_featurescript(source.read_text(encoding="utf-8"), "00498974"), {})
        self.assertNotIn("sweep_path_query", [item.get("capability") for item in lowered.diagnostics])
        self.assertIsNotNone(lowered.cdsl)
        assert lowered.cdsl is not None
        sweep = next(item for item in lowered.cdsl["features"] if item["id"] == "f_F2")
        self.assertEqual(sweep["params"]["path"]["segment"]["type"], "circle")
        self.assertNotIn("initial_output_roles", sweep["params"])
        self.assertNotIn("cap_output_contract", sweep["params"])
        self.assertNotIn("swept_face_contract", sweep["params"])
        self.assertNotIn("swept_edge_contract", sweep["params"])
        with tempfile.TemporaryDirectory() as directory:
            rebuilt = rebuild_candidate(lowered.cdsl, Path(directory) / "qbodytype-circle-sweep.step")
        self.assertNotEqual(
            rebuilt.get("error", {}).get("message"),
            "Feature f_F2 is not runtime eligible: sweep_path_query",
        )

    def test_direct_segmented_sketch_wire_path_requires_one_open_source_wire(self):
        plane = {"origin_mm": [0.0, 0.0, 0.0], "x_dir": [1.0, 0.0, 0.0], "normal": [0.0, 0.0, 1.0]}
        query = Call("qUnion", [[
            Call("qBodyType", [
                Call("qCreatedBy", [Call("__binary__", ["id", "+", "F0"]), "EDGE"]),
                "BodyType.WIRE",
            ]),
        ]])
        segments = {
            # Creation order is intentionally not wire order.
            "E0": {"type": "line", "start": [0.0, 0.0], "end": [0.0, 4.0]},
            "E1": {"type": "line", "start": [1.0, 6.0], "end": [3.0, 10.0]},
            "E2": {
                "type": "arc", "start": [0.0, 4.0], "end": [1.0, 6.0],
                "center": [-5.0, 4.0], "radius_mm": 5.0, "clockwise": False,
            },
            # qCreatedBy(..., EDGE) does not select this source point.
            "visualSharp": {"type": "point", "point": [0.0, 5.0]},
        }
        result = _direct_segmented_sketch_wire_path(
            query, {"F0": {"workplane": plane}}, {"F0": segments},
            featurescript_version="1511", standard_library="onshape/std/geometry.fs", standard_library_version="1511.0",
        )
        self.assertIsNotNone(result)
        assert result is not None
        self.assertEqual(result[0], "F0")
        self.assertEqual([item["source_entity_id"] for item in result[1]], ["E0", "E2", "E1"])
        self.assertEqual([item["type"] for item in result[1]], ["line", "arc", "line"])

        construction = {**segments, "axis": {"type": "line", "start": [0.0, 0.0], "end": [10.0, 0.0], "construction": True}}
        self.assertIsNone(_direct_segmented_sketch_wire_path(
            query, {"F0": {"workplane": plane}}, {"F0": construction},
            featurescript_version="1511", standard_library="onshape/std/geometry.fs", standard_library_version="1511.0",
        ))
        filtered_query = Call("qUnion", [[Call("qConstructionFilter", [query.args[0][0], "ConstructionObject.NO"])]] )
        self.assertIsNotNone(_direct_segmented_sketch_wire_path(
            filtered_query, {"F0": {"workplane": plane}}, {"F0": construction},
            featurescript_version="1511", standard_library="onshape/std/geometry.fs", standard_library_version="1511.0",
        ))

        branched = {**segments, "branch": {"type": "line", "start": [0.0, 4.0], "end": [-4.0, 5.0]}}
        self.assertIsNone(_direct_segmented_sketch_wire_path(
            query, {"F0": {"workplane": plane}}, {"F0": branched},
            featurescript_version="1511", standard_library="onshape/std/geometry.fs", standard_library_version="1511.0",
        ))

        direct_leaf_union = Call("qUnion", [[
            Call("sQuery", ["F0.wireOp", "EDGE", "E0"]),
            Call("sQuery", ["F0.wireOp", "EDGE", "E2"]),
            Call("sQuery", ["F0.wireOp", "EDGE", "E1"]),
        ]])
        direct_result = _direct_segmented_sketch_wire_path(
            direct_leaf_union, {"F0": {"workplane": plane}}, {"F0": segments},
            featurescript_version="1511", standard_library="onshape/std/geometry.fs", standard_library_version="1511.0",
        )
        self.assertIsNotNone(direct_result)
        assert direct_result is not None
        self.assertEqual([item["source_entity_id"] for item in direct_result[1]], ["E0", "E2", "E1"])

        cross_sketch_union = Call("qUnion", [[
            Call("sQuery", ["F0.wireOp", "EDGE", "E0"]),
            Call("sQuery", ["F1.wireOp", "EDGE", "E1"]),
        ]])
        self.assertIsNone(_direct_segmented_sketch_wire_path(
            cross_sketch_union,
            {"F0": {"workplane": plane}, "F1": {"workplane": plane}},
            {"F0": segments, "F1": {"E1": segments["E1"]}},
            featurescript_version="1511", standard_library="onshape/std/geometry.fs", standard_library_version="1511.0",
        ))
        duplicate_leaf_union = Call("qUnion", [[
            Call("sQuery", ["F0.wireOp", "EDGE", "E0"]),
            Call("sQuery", ["F0.wireOp", "EDGE", "E0"]),
        ]])
        self.assertIsNone(_direct_segmented_sketch_wire_path(
            duplicate_leaf_union, {"F0": {"workplane": plane}}, {"F0": segments},
            featurescript_version="1511", standard_library="onshape/std/geometry.fs", standard_library_version="1511.0",
        ))

    def test_direct_spatial_segmented_sketch_wire_path_requires_connected_source_frames(self):
        top = {"origin_mm": [0.0, 0.0, 0.0], "x_dir": [1.0, 0.0, 0.0], "normal": [0.0, 0.0, 1.0]}
        vertical = {"origin_mm": [10.0, 0.0, 0.0], "x_dir": [0.0, 0.0, 1.0], "normal": [0.0, 1.0, 0.0]}

        def wire(sketch_id):
            return Call("qConstructionFilter", [
                Call("qBodyType", [
                    Call("qCreatedBy", [Call("__binary__", ["id", "+", sketch_id]), "EDGE"]),
                    "BodyType.WIRE",
                ]),
                "ConstructionObject.NO",
            ])

        query = Call("qUnion", [[wire("F0"), wire("F1")]])
        sketches = {"F0": {"workplane": top}, "F1": {"workplane": vertical}}
        entities = {
            "F0": {"E0": {"type": "line", "start": [0.0, 0.0], "end": [10.0, 0.0]}},
            "F1": {"E1": {"type": "line", "start": [0.0, 0.0], "end": [10.0, 0.0]}},
        }
        result = _direct_spatial_segmented_sketch_wire_path(
            query, sketches, entities,
            featurescript_version="1511", standard_library="onshape/std/geometry.fs", standard_library_version="1511.0",
        )
        self.assertIsNotNone(result)
        assert result is not None
        self.assertEqual([item["source_sketch_id"] for item in result], ["F0", "F1"])
        self.assertEqual([item["source_entity_id"] for item in result], ["E0", "E1"])
        self.assertEqual(result[0]["start_mm"], [0.0, 0.0, 0.0])
        self.assertEqual(result[0]["end_mm"], [10.0, 0.0, 0.0])
        self.assertEqual(result[1]["end_mm"], [10.0, 0.0, 10.0])

        disconnected = deepcopy(sketches)
        disconnected["F1"] = {**vertical, "origin_mm": [11.0, 0.0, 0.0]}
        self.assertIsNone(_direct_spatial_segmented_sketch_wire_path(
            query, disconnected, entities,
            featurescript_version="1511", standard_library="onshape/std/geometry.fs", standard_library_version="1511.0",
        ))
        repeated = Call("qUnion", [[wire("F0"), wire("F0")]])
        self.assertIsNone(_direct_spatial_segmented_sketch_wire_path(
            repeated, sketches, entities,
            featurescript_version="1511", standard_library="onshape/std/geometry.fs", standard_library_version="1511.0",
        ))

    def test_unfiltered_source_wire_sweep_rebuilds_its_last_executable_feature(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        source = root / "featurescript_rp/0088/00885126.txt"
        if not source.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(source.read_text(encoding="utf-8"), "00885126"), {})
        self.assertEqual(result.status, "converted_partial")
        features = {item["id"]: item for item in result.cdsl["features"]}
        self.assertEqual(set(features), {"f_F2"})
        path = features["f_F2"]["params"]["path"]
        self.assertEqual([item["source_entity_id"] for item in path["segments"]], ["E0", "E2.filletArc", "E1"])
        self.assertEqual([item["type"] for item in path["segments"]], ["line", "arc", "line"])
        from engine.cdsl_engine.semantic_validation import validate_semantic_cdsl
        self.assertTrue(validate_semantic_cdsl(result.cdsl)["future_rebuild_ready"])
        with tempfile.TemporaryDirectory() as directory:
            outcome = rebuild_candidate(result.cdsl, Path(directory) / "rebuild.step")
        self.assertEqual(outcome["status"], "rebuilt")
        self.assertEqual(outcome["result"]["feature_results"][-1]["feature_id"], "f_F2")

    def test_multi_leaf_arc_wire_sweep_keeps_every_source_segment(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        source = root / "featurescript_rp/0068/00684140.txt"
        if not source.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(source.read_text(encoding="utf-8"), "00684140"), {})
        self.assertEqual(result.status, "converted_complete")
        sweep = next(item for item in result.cdsl["features"] if item["id"] == "f_F2")
        self.assertEqual(
            [segment["source_entity_id"] for segment in sweep["params"]["path"]["segments"]],
            ["E0", "E3.filletArc", "E1"],
        )
        self.assertEqual(
            [segment["type"] for segment in sweep["params"]["path"]["segments"]],
            ["line", "arc", "arc"],
        )
        with tempfile.TemporaryDirectory() as directory:
            outcome = rebuild_candidate(result.cdsl, Path(directory) / "rebuild.step")
        self.assertEqual(outcome["status"], "rebuilt")
        self.assertEqual(outcome["result"]["feature_results"][-1]["feature_id"], "f_F2")

    def test_cross_sketch_source_wire_sweep_rebuilds_its_executable_prefix(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        source = root / "featurescript_rp/0061/00610979.txt"
        if not source.exists(): self.skipTest("CADFS sample is not installed")

        result = lower_model(parse_featurescript(source.read_text(encoding="utf-8"), "00610979"), {})
        self.assertEqual(result.status, "converted_partial")
        sweep = next(item for item in result.cdsl["features"] if item["id"] == "f_F4")
        path = sweep["params"]["path"]
        self.assertNotIn("workplane", path)
        self.assertEqual(
            [(item["source_sketch_id"], item["source_entity_id"]) for item in path["segments"]],
            [("F1", "E1"), ("F1", "E2"), ("F3", "E3"), ("F3", "E4")],
        )
        from engine.cdsl_engine.semantic_validation import validate_semantic_cdsl
        self.assertTrue(validate_semantic_cdsl(result.cdsl)["future_rebuild_ready"])
        with tempfile.TemporaryDirectory() as directory:
            outcome = rebuild_candidate(result.cdsl, Path(directory) / "rebuild.step")
        self.assertEqual(outcome["status"], "rebuilt")
        self.assertEqual(outcome["result"]["feature_results"][-1]["feature_id"], "f_F4")
        self.assertEqual(outcome["result"]["solid_count"], 1)

    def test_direct_hole_location_accepts_only_original_sketch_vertices(self):
        plane = {"origin_mm": [0.0, 0.0, 0.0], "x_dir": [1.0, 0.0, 0.0], "normal": [0.0, 0.0, 1.0]}
        sketches = {"F2": {"workplane": plane}}
        entities = {"F2": {
            "P0": {"type": "point", "point": [1.0, 2.0]},
            "C0": {"type": "circle", "center": [3.0, 4.0], "radius_mm": 1.0},
            "L0": {"type": "line", "start": [5.0, 6.0], "end": [7.0, 8.0]},
            "A0": {"type": "arc", "start": [9.0, 10.0], "end": [11.0, 12.0]},
        }}

        def vertex(token: str) -> Call:
            return Call("sQuery", ["F2.wireOp", "VERTEX", token])

        self.assertEqual(_direct_hole_location(vertex("P0"), sketches, entities), ([1.0, 2.0, 0.0], plane))
        self.assertEqual(_direct_hole_location(vertex("C0.center"), sketches, entities), ([3.0, 4.0, 0.0], plane))
        self.assertEqual(_direct_hole_location(vertex("L0.end"), sketches, entities), ([7.0, 8.0, 0.0], plane))
        self.assertEqual(_direct_hole_location(vertex("A0.start"), sketches, entities), ([9.0, 10.0, 0.0], plane))
        self.assertIsNone(_direct_hole_location(Call("qAdjacent", [vertex("C0.center")]), sketches, entities))
        self.assertIsNone(_direct_hole_location(vertex("C0.center.copy"), sketches, entities))

    def test_hole_location_wrapper_is_not_a_direct_source_vertex_query(self):
        direct = Call("sQuery", ["F2.wireOp", "VERTEX", "P0"])
        self.assertTrue(_is_direct_hole_location_query(direct))
        self.assertFalse(_is_direct_hole_location_query(Call("qAdjacent", [direct])))

    def test_hole_location_accepts_one_direct_source_arc_center(self):
        plane = {"origin_mm": [0.0, 0.0, 0.0], "x_dir": [1.0, 0.0, 0.0], "normal": [0.0, 0.0, 1.0]}
        sketches = {"F2": {"workplane": plane}}
        entities = {"F2": {"A0": {
            "type": "arc", "start": [1.0, 0.0], "end": [-1.0, 0.0], "center": [0.0, 0.0],
        }}}

        self.assertEqual(
            _direct_hole_location(Call("sQuery", ["F2.wireOp", "VERTEX", "A0.center"]), sketches, entities),
            ([0.0, 0.0, 0.0], plane),
        )
        self.assertIsNone(
            _direct_hole_location(Call("sQuery", ["F2.wireOp", "VERTEX", "A0.trim.center"]), sketches, entities)
        )

    def test_hole_location_arc_centers_rebuild_multiple_real_histories(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        for sample_id in ("00392565", "00091356", "00486207"):
            source = next(root.glob(f"featurescript_rp/*/{sample_id}.txt"), None)
            if source is None:
                self.skipTest("CADFS sample is not installed")
            result = lower_model(parse_featurescript(source.read_text(encoding="utf-8"), sample_id), {})
            self.assertFalse(any(
                item.get("capability") == "hole_location_vertex"
                for item in result.diagnostics
            ), sample_id)
            with tempfile.TemporaryDirectory() as directory:
                outcome = rebuild_candidate(result.cdsl, Path(directory) / f"{sample_id}.step")
            self.assertEqual(outcome["status"], "rebuilt", sample_id)

    def test_swept_face_host_uses_closed_contour_orientation_not_vertex_average(self):
        """A valid asymmetric profile can average onto its selected boundary."""
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test/featurescript_rp"
        expected = {
            "00139790": ("f_F6", "rebuilt", "f_F7"),
            "00140109": ("f_F5", "rebuilt", "f_F5"),
            # F4 is independently an open, disconnected cut profile. The
            # rebuilt prefix must nevertheless retain the new F3 hole.
            "00140261": ("f_F3", "runtime_ineligible", "f_F3"),
        }
        for sample_id, (hole_id, status, last_feature_id) in expected.items():
            with self.subTest(sample_id=sample_id):
                source = next(root.glob(f"*/{sample_id}.txt"), None)
                if source is None:
                    self.skipTest("CADFS sample is not installed")
                lowered = lower_model(parse_featurescript(source.read_text(encoding="utf-8"), sample_id), {})
                self.assertNotIn("swept face interior is degenerate", [
                    item.get("message") for item in lowered.diagnostics
                ])
                self.assertIn(hole_id, {feature["id"] for feature in lowered.cdsl["features"]})
                with tempfile.TemporaryDirectory() as directory:
                    outcome = rebuild_candidate(lowered.cdsl, Path(directory) / "rebuild.step")
                self.assertEqual(outcome["status"], status)
                if status == "rebuilt":
                    self.assertEqual(outcome["result"]["feature_results"][-1]["feature_id"], last_feature_id)
                else:
                    self.assertEqual(outcome["last_executable_prefix"]["last_feature_id"], last_feature_id)

    def test_hole_reports_an_unavailable_source_sketch_before_vertex_rejection(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        source = root / "featurescript_rp/0054/00548761.txt"
        if not source.exists(): self.skipTest("CADFS sample is not installed")

        result = lower_model(parse_featurescript(source.read_text(encoding="utf-8"), "00548761"), {})
        diagnostics = [
            item for item in result.diagnostics
            if item.get("feature_id") == "F5" and item.get("operation") == "hole"
        ]
        self.assertEqual(result.status, "converted_partial")
        self.assertEqual(len(diagnostics), 1)
        self.assertEqual(diagnostics[0]["capability"], "hole_location_sketch_unavailable")
        self.assertEqual(diagnostics[0]["message"], "hole location source sketch is not executable")

    def test_hole_wrapper_with_an_unavailable_nested_sketch_stays_a_vertex_rejection(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        source = root / "featurescript_rp/0054/00548761.txt"
        if not source.exists(): self.skipTest("CADFS sample is not installed")

        history = source.read_text(encoding="utf-8").replace(
            'Q0=sQuery(id+"F4.wireOp",VERTEX,"E8.center");',
            'Q0=qAdjacent(sQuery(id+"F4.wireOp",VERTEX,"E8.center"));',
        )
        result = lower_model(parse_featurescript(history, "00548761-wrapped-location"), {})
        diagnostics = [
            item for item in result.diagnostics
            if item.get("feature_id") == "F5" and item.get("operation") == "hole"
        ]
        self.assertEqual(result.status, "converted_partial")
        self.assertEqual(len(diagnostics), 1)
        self.assertEqual(diagnostics[0]["capability"], "hole_location_vertex")
        self.assertEqual(diagnostics[0]["message"], "hole location requires one direct original sketch vertex")

    def test_hole_scope_keeps_one_explicit_live_member_among_multiple_bodies(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0021/00219259.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")

        result = lower_model(parse_featurescript(feature.read_text(encoding="utf-8"), "00219259"), {})

        hole = next(item for item in result.cdsl["features"] if item["id"] == "f_F6")
        self.assertEqual(result.status, "converted_complete")
        self.assertEqual(hole["atomic_id"], "hole_wizard")
        self.assertEqual(hole["params"]["scope_feature_id"], "f_F1")
        self.assertFalse(any(
            item.get("feature_id") == "F6" and item.get("capability") == "hole_scope_body_source"
            for item in result.diagnostics
        ))
        with tempfile.TemporaryDirectory() as directory:
            outcome = rebuild_candidate(result.cdsl, Path(directory) / "rebuild.step")
        self.assertEqual(outcome["status"], "rebuilt")
        self.assertEqual(
            [item["feature_id"] for item in outcome["result"]["feature_results"]],
            ["f_F1", "f_F3", "f_F6"],
        )

    def test_strict_comparison_status_is_not_labeled_approximate(self):
        with tempfile.TemporaryDirectory() as tmp:
            output = Path(tmp); directory = output / "samples" / "strict-status"; directory.mkdir(parents=True)
            sample = Sample("strict-status", {"step": str(directory / "gold.step")}, {}, {}, [])
            (directory / "rebuild.step").touch(); (directory / "gold.step").touch()
            (directory / "status.json").write_text(json.dumps({
                "sample_id": sample.sample_id, "rebuild_status": "rebuilt",
                "comparison_error": {"type": "TimeoutError", "message": "stale"},
            }), encoding="utf-8")
            (directory / "comparison.json").write_text(json.dumps({"decision": "strict_pass", "strict": {"passed": True}, "rp": {"passed": True}}), encoding="utf-8")
            status = compare_one(sample, output, compare_mode="strict")
        self.assertEqual(status["status"], "rebuilt_strict")
        self.assertNotIn("comparison_error", status)

    def test_missing_dataset_fails_explicitly(self):
        with tempfile.TemporaryDirectory() as tmp:
            with self.assertRaises(FileNotFoundError): scan_dataset(Path(tmp) / "missing")

    def test_circle_extrude_is_valid_cdsl_11(self):
        result = lower_model(parse_featurescript(SOURCE, "00000173"), {})
        self.assertEqual(result.status, "converted_complete")
        self.assertEqual(result.cdsl["schema_version"], "1.1.0")
        self.assertEqual(result.cdsl["geometry"]["sketches"][0]["profile"]["radius_mm"], 9.53)
        from engine.cdsl_engine.semantic_validation import validate_semantic_cdsl
        self.assertTrue(validate_semantic_cdsl(result.cdsl)["future_rebuild_ready"])

    def test_rectilinear_fillet_arc_recovers_its_exact_endpoint_radius(self):
        arc = _arc([38.1, 63.5], [34.38, 72.48], [25.4, 76.2])
        self.assertEqual(arc["center"], [25.4, 63.5])
        self.assertAlmostEqual(arc["radius_mm"], 12.7)
        self.assertFalse(arc["clockwise"])

    def test_general_three_point_arc_remains_circumcircle_defined(self):
        arc = _arc([0, 0], [2, 3], [5, 0])
        self.assertAlmostEqual(arc["center"][0], 2.5)
        self.assertAlmostEqual(arc["center"][1], 0.5)
        self.assertAlmostEqual(arc["radius_mm"], math.hypot(2.5, 0.5))

    def test_direct_extrude_lineage_succeeds_and_unregistered_loft_query_preserves_prefix(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        cases = {
            "00000715": ("f_F2", 2, True),
            "00005267": ("f_F4", 4, False),
        }
        for sample_id, (fillet_id, selector_count, line_type) in cases.items():
            with self.subTest(sample_id=sample_id):
                feature = root / "featurescript_rp" / sample_id[:4] / f"{sample_id}.txt"
                result = lower_model(parse_featurescript(feature.read_text(), sample_id), {})
                self.assertEqual(result.status, "converted_complete")
                fillet = next(item for item in result.cdsl["features"] if item["id"] == fillet_id)
                if sample_id == "00000715":
                    self.assertEqual(len(fillet["selectors"]), 1)
                    selector = fillet["selectors"][0]
                    self.assertEqual(selector["selector_intent"]["query_family"], "QUERY_SET")
                    self.assertEqual(selector["selector_intent"]["query_set_contract"], "proven_operand_union")
                    self.assertEqual(len(selector["query_operands"]), selector_count)
                    self.assertTrue(all(
                        item["selector_intent"]["query_family"] == "SWEPT_EDGE"
                        and item["selector_intent"]["derivation_policy"] == {
                            "allowed": ["boundary", "continuation"], "multiplicity": "one",
                        }
                        and len(item["selector_intent"]["source_entities"]) == 2
                        and item["owner_feature_id"] == fillet["depends_on"][0]
                        and "geometry" not in item
                        for item in selector["query_operands"]
                    ))
                else:
                    self.assertEqual(len(fillet["selectors"]), selector_count)
                    self.assertTrue(all(item["owner_feature_id"] == fillet["depends_on"][0] for item in fillet["selectors"]))
                    self.assertTrue(all("bbox_mm" in item["geometry"] for item in fillet["selectors"]))
                    self.assertEqual(["curve_type" in item["geometry"] for item in fillet["selectors"]], [line_type] * selector_count)
                    self.assertTrue(all(
                        item["selector_intent"]["query_family"] == "SWEPT_EDGE"
                        and item["selector_intent"]["evidence"] == "feature_script_query"
                        and item["selector_intent"]["derivation_policy"] == {"allowed": ["continuation"], "multiplicity": "none"}
                        and item["selector_intent"]["source_query"]["featurescript_version"] == "1793"
                        for item in fillet["selectors"]
                    ))
                with tempfile.TemporaryDirectory() as directory:
                    rebuilt = Path(directory) / "rebuild.step"
                    outcome = rebuild_candidate(result.cdsl, rebuilt)
                    if sample_id == "00005267":
                        self.assertEqual(outcome["status"], "rebuild_failed")
                        self.assertEqual(outcome["error"]["message"], "f_F4: selector_query_unsupported during incremental replay")
                        self.assertTrue(rebuilt.exists())
                        self.assertEqual(outcome["last_executable_prefix"]["failed_feature_id"], "f_F4")
                        self.assertEqual(outcome["last_executable_prefix"]["last_feature_id"], "f_F3")
                    else:
                        self.assertEqual(outcome["status"], "rebuilt")
                        comparison = compare_steps(root / "step_abc" / sample_id[:4] / f"{sample_id}.step", rebuilt)
                        self.assertTrue(comparison["strict"]["passed"])

    def test_swept_edge_requires_one_direct_shared_source_endpoint(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0000/00000715.txt"
        source = feature.read_text(encoding="utf-8").replace(
            'sQuery(id+"F0.wireOp",EDGE,"E8")',
            'sQuery(id+"F0.wireOp",EDGE,"E1")',
            1,
        )
        result = lower_model(parse_featurescript(source, "swept-edge-ambiguous"), {})
        self.assertEqual(result.status, "converted_partial")
        self.assertEqual(result.diagnostics, [{
            "code": "feature_deferred",
            "feature_id": "F2",
            "operation": "fillet",
            "message": "swept edge source endpoint provenance is unsupported",
        }])

    def test_direct_query_intersection_and_subtraction_lower_as_proven_sets(self):
        """Only direct leaf provenance may enter the S0 set-algebra bridge."""
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0000/00000715.txt"
        source = feature.read_text(encoding="utf-8")
        cases = {
            "intersection": source.replace("qUnion([Q0, Q1])", "qIntersection([Q0, Q1])"),
            "subtraction": source.replace("qUnion([Q0, Q1])", "qSubtraction(Q0, Q1)"),
        }
        contracts = {
            "intersection": "proven_operand_intersection",
            "subtraction": "proven_operand_subtraction",
        }
        expected_rebuild_status = {
            "intersection": "rebuild_failed",
            "subtraction": "rebuilt",
        }
        from engine.cdsl_engine.semantic_validation import validate_semantic_cdsl

        for operator, candidate in cases.items():
            with self.subTest(operator=operator):
                result = lower_model(parse_featurescript(candidate, f"set-{operator}"), {})
                self.assertEqual(result.status, "converted_complete")
                fillet = next(item for item in result.cdsl["features"] if item["id"] == "f_F2")
                self.assertEqual(len(fillet["selectors"]), 1)
                selector = fillet["selectors"][0]
                self.assertEqual(selector["selector_intent"]["query_set_contract"], contracts[operator])
                self.assertEqual(selector["selector_intent"]["query_expr"]["root"]["operator"], operator)
                self.assertEqual(len(selector["query_operands"]), 2)
                self.assertTrue(validate_semantic_cdsl(result.cdsl)["future_rebuild_ready"])
                with tempfile.TemporaryDirectory() as directory:
                    rebuilt = Path(directory) / "rebuild.step"
                    outcome = rebuild_candidate(result.cdsl, rebuilt)
                    self.assertTrue(rebuilt.exists())
                self.assertEqual(outcome["status"], expected_rebuild_status[operator])
                if operator == "intersection":
                    self.assertEqual(outcome["error"]["message"], "f_F2: selector_query_empty during incremental replay")
                    self.assertEqual(outcome["last_executable_prefix"]["last_feature_id"], "f_F1")

    def test_nested_query_union_preserves_recursive_set_expression(self):
        from engine.cdsl_engine.semantic_validation import validate_semantic_cdsl
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0000/00000715.txt"
        source = feature.read_text(encoding="utf-8").replace(
            "qUnion([Q0, Q1])", "qUnion([Q0, qUnion([Q1, Q0])])",
        )
        result = lower_model(parse_featurescript(source, "nested-query-union"), {})
        self.assertEqual(result.status, "converted_complete")
        fillet = next(item for item in result.cdsl["features"] if item["id"] == "f_F2")
        self.assertEqual(len(fillet["selectors"]), 1)
        selector = fillet["selectors"][0]
        intent = selector["selector_intent"]
        self.assertEqual(intent["query_set_contract"], "proven_operand_union")
        self.assertEqual(intent["query_expr"]["root"]["operator"], "union")
        self.assertEqual(len(selector["query_operands"]), 2)
        nested = selector["query_operands"][1]
        self.assertEqual(nested["selector_intent"]["query_set_contract"], "proven_operand_union")
        self.assertEqual(nested["selector_intent"]["query_expr"]["root"]["operator"], "union")
        self.assertEqual(len(nested["query_operands"]), 2)
        self.assertTrue(validate_semantic_cdsl(result.cdsl)["future_rebuild_ready"])
        with tempfile.TemporaryDirectory() as directory:
            outcome = rebuild_candidate(result.cdsl, Path(directory) / "rebuild.step")
        self.assertEqual(outcome["status"], "rebuilt")

    def test_1511_full_revolve_swept_edges_use_exact_vertex_history(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        for sample_id, dressup_id in (
            ("00048326", "f_F3"),
            ("00025622", "f_F2"),
        ):
            with self.subTest(sample_id=sample_id):
                feature = root / "featurescript_rp" / sample_id[:4] / f"{sample_id}.txt"
                result = lower_model(parse_featurescript(feature.read_text(), sample_id), {})
                self.assertEqual(result.status, "converted_complete")
                dressup = next(item for item in result.cdsl["features"] if item["id"] == dressup_id)
                self.assertEqual(len(dressup["selectors"]), 1)
                root_selector = dressup["selectors"][0]
                leaves = root_selector.get("query_operands") or [root_selector]
                self.assertTrue(all(
                    "geometry" not in selector
                    and selector["selector_intent"]["query_family"] == "SWEPT_EDGE"
                    and selector["selector_intent"]["evidence"] == "kernel_history"
                    and selector["selector_intent"]["source_query"]["featurescript_version"] == "1511"
                    and selector["selector_intent"]["derivation_policy"] == {
                        "allowed": ["boundary", "continuation"], "multiplicity": "one",
                    }
                    for selector in leaves
                ))
                with tempfile.TemporaryDirectory() as directory:
                    rebuilt = Path(directory) / "rebuild.step"
                    outcome = rebuild_candidate(result.cdsl, rebuilt)
                self.assertEqual(outcome["status"], "rebuilt")
                resolution = next(
                    item for item in outcome["result"]["selector_resolution"]
                    if item["feature_id"] == dressup_id
                )
                if root_selector.get("query_operands"):
                    self.assertEqual(resolution["resolution_mode"], "query_set_union")
                    relations = [
                        relation
                        for operand in resolution["evidence"]["operand_resolutions"]
                        for relation in operand["relations"]
                    ]
                else:
                    self.assertEqual(resolution["resolution_mode"], "kernel_lineage")
                    relations = resolution["evidence"]["relations"]
                self.assertTrue(relations)
                self.assertTrue(all(relation["operation"] == "revolve" for relation in relations))

    def test_1511_full_revolve_accepts_direct_initial_dressup_only(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0040/00407186.txt"
        result = lower_model(parse_featurescript(feature.read_text(), "00407186"), {})
        # Unsupported selectors are retained in the candidate as an explicit
        # non-executable source-query contract.  This does not hide the
        # earlier F1/F2 prefix or turn the later revolve BLEND_EDGE tuple into
        # a geometry selector at lowering time.
        self.assertEqual(result.status, "converted_complete")
        deferred = next(item for item in result.cdsl["features"] if item["id"] == "f_F5")
        intent = deferred["selectors"][0]["selector_intent"]
        self.assertEqual(intent["query_family"], "BLEND_EDGE")
        self.assertEqual(intent["evidence"], "feature_script_query")
        self.assertEqual(intent["derivation_policy"], {"allowed": ["continuation"], "multiplicity": "none"})
        prefix = deepcopy(result.cdsl)
        prefix["features"] = result.cdsl["features"][:2]
        with tempfile.TemporaryDirectory() as directory:
            outcome = rebuild_candidate(prefix, Path(directory) / "rebuild.step")
        self.assertEqual(outcome["status"], "rebuilt")
        resolution = outcome["result"]["selector_resolution"][0]
        self.assertEqual(resolution["resolution_mode"], "kernel_lineage")
        self.assertEqual(resolution["evidence"]["relations"][0]["operation"], "revolve")

    def test_1511_direct_prism_blend_edge_requires_complete_immediate_tuple(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0041/00414347.txt"
        source = feature.read_text(encoding="utf-8")
        result = lower_model(parse_featurescript(source, "00414347"), {})

        self.assertEqual(result.status, "converted_complete")
        fillet = next(item for item in result.cdsl["features"] if item["id"] == "f_F3")
        selector = fillet["selectors"][0]
        intent = selector["selector_intent"]
        self.assertEqual(intent["query_family"], "BLEND_EDGE")
        self.assertEqual(intent["evidence"], "kernel_history")
        self.assertEqual(intent["derivation_policy"], {"allowed": ["boundary"], "multiplicity": "one"})
        self.assertEqual(intent["blend_sources"], {
            "edge": {
                "query_family": "CAP_EDGE", "owner_feature_id": "f_F1",
                "source_entity": {"sketch_id": "F0", "entity_id": "E0.right"},
                "lineage_role": "extrude.end",
            },
            "face": {
                "query_family": "CAP_FACE", "owner_feature_id": "f_F1",
                "output_role": "extrude.end",
            },
        })
        self.assertFalse(any(key in selector for key in (
            "stable_id", "snapshot_id", "geometry", "binding_feature_id", "output_role",
        )))
        with tempfile.TemporaryDirectory() as directory:
            outcome = rebuild_candidate(result.cdsl, Path(directory) / "rebuild.step")
        self.assertEqual(outcome["status"], "rebuilt")
        resolution = next(
            item for item in outcome["result"]["selector_resolution"]
            if item["feature_id"] == "f_F3"
        )
        self.assertEqual(resolution["resolution_mode"], "blend_boundary")
        self.assertEqual(len(resolution["evidence"]["source_records"]), 2)
        self.assertEqual(len(resolution["evidence"]["result_records"]), 1)

        # One incomplete source cap set, a changed blendedInto role, or an
        # additional blendedFrom member must stay non-executable.  Each
        # mutation remains valid FeatureScript; rejection is contract-based.
        mutations = (
            source.replace('sQuery(id+"F0.wireOp",EDGE,"E0.top"),', "", 1),
            source.replace(
                'sQuery(id+"F0.wireOp",EDGE,"E0.bottom"),sQuery(id+"F0.wireOp",EDGE,"E0.top"),sQuery(id+"F0.wireOp",EDGE,"E0.left"),subQ0])],"isStart":false})]});}',
                'sQuery(id+"F0.wireOp",EDGE,"E0.bottom"),sQuery(id+"F0.wireOp",EDGE,"E0.top"),sQuery(id+"F0.wireOp",EDGE,"E0.left"),subQ0])],"isStart":true})]});}',
                1,
            ),
            source.replace(
                '"isStart":false})],"blendedInto"',
                '"isStart":false}),makeQuery(id+"F1.opExtrude","CAP_EDGE",EDGE,{"disambiguationData":[OSD([subQ0])],"isStart":false})],"blendedInto"',
                1,
            ),
        )
        for index, mutated in enumerate(mutations):
            with self.subTest(mutation=index):
                candidate = lower_model(parse_featurescript(mutated, f"blend-edge-mutation-{index}"), {})
                deferred = next(item for item in candidate.cdsl["features"] if item["id"] == "f_F3")
                deferred_intent = deferred["selectors"][0]["selector_intent"]
                self.assertEqual(deferred_intent["query_family"], "BLEND_EDGE")
                self.assertEqual(deferred_intent["evidence"], "feature_script_query")
                self.assertNotIn("blend_sources", deferred_intent)

    def test_1511_direct_prism_blend_edge_accepts_exact_swept_face_pair_only(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        cases = (("00596552", "f_F5", 2), ("00456146", "f_F4", 1))
        for sample_id, feature_id, expected_blends in cases:
            with self.subTest(sample_id=sample_id):
                source = root / "featurescript_rp" / sample_id[:4] / f"{sample_id}.txt"
                result = lower_model(parse_featurescript(source.read_text(encoding="utf-8"), sample_id), {})
                feature = next(item for item in result.cdsl["features"] if item["id"] == feature_id)
                leaves = feature["selectors"][0].get("query_operands") or feature["selectors"]
                blends = [item for item in leaves if item["selector_intent"]["query_family"] == "BLEND_EDGE"]
                self.assertEqual(len(blends), expected_blends)
                for selector in blends:
                    intent = selector["selector_intent"]
                    self.assertEqual(intent["evidence"], "kernel_history")
                    self.assertEqual(intent["blend_sources"]["face"]["query_family"], "SWEPT_FACE")
                    self.assertEqual(
                        intent["blend_sources"]["face"]["source_entity"],
                        intent["blend_sources"]["edge"]["source_entity"],
                    )

                invalid = deepcopy(result.cdsl)
                invalid_feature = next(item for item in invalid["features"] if item["id"] == feature_id)
                invalid_leaf = next(item for item in (invalid_feature["selectors"][0].get("query_operands") or invalid_feature["selectors"])
                                    if item["selector_intent"]["query_family"] == "BLEND_EDGE")
                invalid_leaf["selector_intent"]["blend_sources"]["face"]["source_entity"] = {
                    "sketch_id": "F0", "entity_id": "unrelated",
                }
                from engine.cdsl_engine.semantic_validation import validate_semantic_cdsl
                with self.assertRaisesRegex(ValueError, "swept-face source must match"):
                    validate_semantic_cdsl(invalid)

    def test_1511_direct_prism_blend_face_sketch_uses_runtime_patch_attachment(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        cases = (("00313870", {"sketch_F3", "sketch_F4"}),)
        for sample_id, expected_sketches in cases:
            with self.subTest(sample_id=sample_id):
                source = root / f"featurescript_rp/{sample_id[:4]}/{sample_id}.txt"
                result = lower_model(parse_featurescript(source.read_text(encoding="utf-8"), sample_id), {})
                attached = {
                    sketch["id"]: sketch["attachment"]
                    for sketch in result.cdsl["geometry"]["sketches"]
                    if isinstance(sketch.get("attachment"), dict)
                    and sketch["attachment"].get("selector_intent", {}).get("query_family") == "BLEND_FACE"
                }
                self.assertEqual(set(attached), expected_sketches)
                for attachment in attached.values():
                    intent = attachment["selector_intent"]
                    self.assertEqual(intent["evidence"], "kernel_history")
                    self.assertEqual(intent["blend_face_source"]["query_family"], "CAP_EDGE")
                    self.assertNotIn("geometry", attachment)
                    self.assertNotIn("stable_id", attachment)
                from engine.cdsl_engine.semantic_validation import validate_semantic_cdsl
                self.assertTrue(validate_semantic_cdsl(result.cdsl)["future_rebuild_ready"])
                tampered = deepcopy(result.cdsl)
                tampered_attachment = next(
                    sketch for sketch in tampered["geometry"]["sketches"]
                    if sketch.get("attachment", {}).get("selector_intent", {}).get("query_family") == "BLEND_FACE"
                )["attachment"]
                tampered_attachment["selector_intent"]["blend_face_source"]["source_entity"]["entity_id"] = "unrelated"
                with self.assertRaisesRegex(ValueError, "direct new-body blind prism"):
                    validate_semantic_cdsl(tampered)

        # F2 is explicit ADD/fuse here, so its CAP edge cannot be promoted to
        # the independent direct-prism BLEND_FACE host contract.
        fused = root / "featurescript_rp/0043/00436592.txt"
        fused_result = lower_model(parse_featurescript(fused.read_text(encoding="utf-8"), "00436592"), {})
        self.assertFalse(any(
            sketch.get("attachment", {}).get("selector_intent", {}).get("query_family") == "BLEND_FACE"
            for sketch in fused_result.cdsl["geometry"]["sketches"]
        ))

        # A symmetric prism uses the same outer query spelling, but it is not
        # the direct blind-prism lifecycle represented by this contract.
        rejected = root / "featurescript_rp/0058/00588828.txt"
        result = lower_model(parse_featurescript(rejected.read_text(encoding="utf-8"), "00588828"), {})
        self.assertFalse(any(
            sketch.get("attachment", {}).get("selector_intent", {}).get("query_family") == "BLEND_FACE"
            for sketch in result.cdsl["geometry"]["sketches"]
        ))

    def test_full_revolve_swept_circle_requires_one_direct_shared_source_endpoint(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0000/00001352.txt"
        source = feature.read_text(encoding="utf-8").replace(
            'sQuery(id+"F0.wireOp",EDGE,"E2")',
            'sQuery(id+"F0.wireOp",EDGE,"E1")',
            1,
        )
        result = lower_model(parse_featurescript(source, "revolve-swept-edge-ambiguous"), {})
        self.assertEqual(result.status, "converted_partial")
        self.assertIn({
            "code": "feature_deferred",
            "feature_id": "F2",
            "operation": "fillet",
            "message": "swept edge source endpoint provenance is unsupported",
        }, result.diagnostics)

    def test_2491_full_revolve_swept_edge_uses_exact_vertex_history(self):
        """A 2491 full revolve must bind from MakeRevol vertex history only."""
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0040/00404735.txt"
        result = lower_model(parse_featurescript(feature.read_text(), "00404735"), {})

        # F2's source pair crosses intervening profile entities and therefore
        # does not identify one direct vertex. F3 independently does, so its
        # executable prefix is retained without weakening that rejection.
        self.assertEqual(result.status, "converted_partial")
        self.assertIn({
            "code": "feature_deferred",
            "feature_id": "F2",
            "operation": "chamfer",
            "message": "swept edge source endpoint provenance is unsupported",
        }, result.diagnostics)
        chamfer = next(item for item in result.cdsl["features"] if item["id"] == "f_F3")
        selector = chamfer["selectors"][0]
        self.assertNotIn("geometry", selector)
        intent = selector["selector_intent"]
        self.assertEqual(intent["query_family"], "SWEPT_EDGE")
        self.assertEqual(intent["evidence"], "kernel_history")
        self.assertEqual(intent["source_query"]["featurescript_version"], "2491")
        self.assertEqual(intent["source_query"]["standard_library_version"], "2491.0")
        self.assertEqual(intent["source_entities"], [
            {"sketch_id": "F0", "entity_id": "E0"},
            {"sketch_id": "F0", "entity_id": "E5"},
        ])
        self.assertEqual(intent["derivation_policy"], {
            "allowed": ["boundary", "continuation"], "multiplicity": "one",
        })
        with tempfile.TemporaryDirectory() as directory:
            outcome = rebuild_candidate(result.cdsl, Path(directory) / "rebuild.step")
        self.assertEqual(outcome["status"], "rebuilt")
        resolution = outcome["result"]["selector_resolution"][0]
        self.assertEqual(resolution["resolution_mode"], "kernel_lineage")
        self.assertEqual(resolution["evidence"]["semantic_anchor"], {
            "type": "source_vertex",
            "source_entities": intent["source_entities"],
        })
        self.assertEqual(resolution["evidence"]["relations"][0]["operation"], "revolve")
        self.assertEqual(resolution["evidence"]["relations"][0]["derivation"], "boundary")

    def test_equivalent_imprint_profile_preserves_but_does_not_bind_full_revolve_queries(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        source = root / "featurescript_rp/0011/00112257.txt"
        result = lower_model(parse_featurescript(source.read_text(), "00112257"), {})
        self.assertEqual(result.status, "converted_complete")
        fillet = next(item for item in result.cdsl["features"] if item["id"] == "f_F2")
        self.assertEqual(len(fillet["selectors"]), 5)
        self.assertTrue(all(
            selector["geometry"].get("curve_type") == "circle"
            and selector["selector_intent"]["query_family"] == "SWEPT_EDGE"
            and selector["selector_intent"]["derivation_policy"]["multiplicity"] == "none"
            for selector in fillet["selectors"]
        ))

        from cadfs_to_cdsl.selector_binding import bind_candidate_selectors
        prefix = dict(result.cdsl)
        prefix["features"] = result.cdsl["features"][:2]
        with self.assertRaisesRegex(ValueError, "f_F2: selector_query_unsupported after prefix rebuild"):
            bind_candidate_selectors(prefix)

    def test_changed_imprint_profile_does_not_inherit_full_revolve_source_edges(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        source = root / "featurescript_rp/0059/00590828.txt"
        result = lower_model(parse_featurescript(source.read_text(), "00590828"), {})
        self.assertEqual(result.status, "converted_partial")
        self.assertIn({
            "code": "feature_deferred",
            "feature_id": "F2",
            "operation": "fillet",
            "message": "swept edge source endpoint provenance is unsupported",
        }, result.diagnostics)

    def test_unsupported_operation_is_audited_not_invented(self):
        source = SOURCE.replace('extrude(context, id + "F1",', 'draft(context, id + "F1",')
        result = lower_model(parse_featurescript(source, "00000173"), {})
        self.assertEqual(result.status, "deferred_no_executable_feature")
        self.assertIsNone(result.cdsl)
        self.assertEqual(result.diagnostics[0]["code"], "unsupported_operation")

    def test_unknown_direct_context_operation_is_reported_not_silently_dropped(self):
        source = SOURCE.replace(
            '\n});\n',
            '\n  unknownOperation(context, id + "F2", {"value":10 * mm});\n});\n',
        )
        result = lower_model(parse_featurescript(source, "assign-variable"), {})
        self.assertEqual(result.status, "converted_partial")
        self.assertIn(
            {"code": "unsupported_operation", "feature_id": "F2", "operation": "unknownOperation"},
            result.diagnostics,
        )

    def test_assign_variable_resolves_ordered_source_get_variable_calls(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0006/00067276.txt"
        if not feature.exists(): self.skipTest("CADFS assignVariable sample is not installed")
        result = lower_model(parse_featurescript(feature.read_text(encoding="utf-8"), "00067276"), {})
        variables = [item for item in result.cdsl["features"] if item["atomic_id"] == "assign_variable"]
        self.assertEqual([item["params"] for item in variables], [
            {"name": "thickness", "value": 4.0, "value_kind": "any"},
            {"name": "nut_height", "value": 3.2, "value_kind": "any"},
        ])
        self.assertFalse(any(diagnostic.get("operation") == "assignVariable" for diagnostic in result.diagnostics))

    def test_assign_variable_rejects_missing_lookup_redeclaration_and_ambiguous_value(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test/featurescript_rp"
        source_path = root / "0006/00067276.txt"
        if not source_path.exists(): self.skipTest("CADFS assignVariable sample is not installed")
        source = source_path.read_text(encoding="utf-8")

        missing = lower_model(parse_featurescript(
            source.replace("getVariable(context, 'thickness')", "getVariable(context, 'missing')", 1), "00067276"), {})
        self.assertIn(("F3", "feature_deferred", "source variable is unavailable: missing"), {
            (item.get("feature_id"), item.get("code"), item.get("message")) for item in missing.diagnostics
        })

        redeclared = lower_model(parse_featurescript(
            source.replace('"name" : "nut_height"', '"name" : "thickness"', 1), "00067276"), {})
        self.assertIn(("F1", "unsupported_engine_capability", "assignVariable redeclares source variable thickness"), {
            (item.get("feature_id"), item.get("code"), item.get("message")) for item in redeclared.diagnostics
        })

        ambiguous = lower_model(parse_featurescript(
            source.replace('"anyValue" : 4', '"anyValue" : 4, "lengthValue" : 4 * mm', 1), "00067276"), {})
        self.assertIn(("F0", "unsupported_engine_capability", "assignVariable requires exactly one anyValue or lengthValue source expression"), {
            (item.get("feature_id"), item.get("code"), item.get("message")) for item in ambiguous.diagnostics
        })

    def test_assign_variable_does_not_break_an_immediate_cap_edge_consumer(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test/featurescript_rp"
        source_path = root / "0002/00021014.txt"
        if not source_path.exists(): self.skipTest("CADFS CAP_EDGE sample is not installed")
        source = source_path.read_text(encoding="utf-8")
        source = source.replace(
            '        {\n            var Q0;\n            Q0=makeQuery(id+"F1.opExtrude",',
            '        { assignVariable(context, id + "F1variable", {"name" : "radius", "anyValue" : 5.08}); }\n'
            '        {\n            var Q0;\n            Q0=makeQuery(id+"F1.opExtrude",',
            1,
        )
        result = lower_model(parse_featurescript(source, "00021014"), {})
        features = {item["id"]: item for item in result.cdsl["features"]}
        self.assertEqual(features["f_F1variable"]["atomic_id"], "assign_variable")
        self.assertEqual(features["f_F2"]["depends_on"], ["f_F1"])

        from engine.cdsl_engine.runtime import prepare_cdsl_execution
        execution = prepare_cdsl_execution(result.cdsl)
        self.assertTrue(execution.analysis.feature_results[-1].executable)

    def test_signed_parenthesized_transform_translation_lowers_without_a_parser_defer(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test/featurescript_rp"
        source_path = root / "0029/00292242.txt"
        if not source_path.exists(): self.skipTest("CADFS signed transform sample is not installed")
        result = lower_model(parse_featurescript(source_path.read_text(encoding="utf-8"), "00292242"), {})
        # This is a non-copy move of the immediately preceding independent
        # source body, so the existing contract bakes it into its sketch
        # frame instead of creating a second body-graph feature.
        self.assertEqual([item["id"] for item in result.cdsl["features"]], ["f_F1"])
        self.assertEqual(result.cdsl["geometry"]["sketches"][0]["workplane"]["origin_mm"], [-69.3, 0.0, 0.0])
        self.assertFalse(any(
            item.get("feature_id") == "F2" and item.get("operation") == "transform"
            for item in result.diagnostics
        ))

    def test_direct_translation_transform_is_baked_into_the_source_feature(self):
        result = lower_model(parse_featurescript(TRANSFORM_SOURCE, "transform"), {})
        self.assertEqual(result.status, "converted_complete")
        self.assertEqual([item["id"] for item in result.cdsl["features"]], ["f_F1"])
        self.assertEqual(result.history[-1]["feature_id"], "F2")
        self.assertFalse(result.diagnostics)
        self.assertEqual(result.cdsl["geometry"]["sketches"][0]["workplane"]["origin_mm"], [10.0, 0.0, 0.0])

    def test_copy_transform_lowers_to_an_explicit_body_operation(self):
        source = TRANSFORM_SOURCE.replace('"makeCopy":false', '"makeCopy":true')
        result = lower_model(parse_featurescript(source, "transform-copy"), {})
        self.assertEqual(result.status, "converted_complete")
        self.assertFalse(result.diagnostics)
        transform = result.cdsl["features"][-1]
        self.assertEqual(transform["atomic_id"], "transform_bodies")
        self.assertEqual(transform["params"], {
            "source_feature_ids": ["f_F1"],
            "transform": {"type": "translation", "translation_mm": [10.0, 0.0, 0.0]},
            "make_copy": True,
        })

    def test_identity_copy_transform_creates_a_distinct_body_member(self):
        source = TRANSFORM_SOURCE.replace(
            '"transformType":TransformType.TRANSLATION_3D, "dx":10 * mm, "dy":0 * mm, "dz":0 * mm, "makeCopy":false',
            '"transformType":TransformType.COPY',
        )
        result = lower_model(parse_featurescript(source, "identity-copy"), {})
        self.assertEqual(result.status, "converted_complete")
        self.assertFalse(result.diagnostics)
        self.assertEqual(result.cdsl["features"][-1]["params"], {
            "source_feature_ids": ["f_F1"],
            "transform": {"type": "translation", "translation_mm": [0.0, 0.0, 0.0]},
            "make_copy": True,
        })

        from engine.cdsl_engine.runtime import rebuild_cdsl
        with tempfile.TemporaryDirectory() as directory:
            rebuilt = rebuild_cdsl(result.cdsl, Path(directory) / "identity-copy.step")
        self.assertEqual([item["feature_id"] for item in rebuilt["feature_results"]], ["f_F1", "f_F2"])
        self.assertEqual(rebuilt["solid_count"], 2)
        self.assertTrue(any(item["operation"] == "translation" for item in rebuilt["topology_deltas"]))

    def test_identity_copy_transform_preserves_direct_source_provenance(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        cases = {
            "00548763": {"f_F2": "f_F1"},
            "00853763": {"f_F6": "f_F5"},
            # F3 is a typed ADD fuse. F4 therefore targets its active F3
            # successor while preserving F1 as an explicit source alias.
            # F11 remains an identity copy of its direct F10 source.
            "00981258": {"f_F4": "f_F1", "f_F11": "f_F10"},
        }
        for sample_id, expected_sources in cases.items():
            with self.subTest(sample_id=sample_id):
                feature = root / "featurescript_rp" / sample_id[:4] / f"{sample_id}.txt"
                if not feature.exists():
                    self.skipTest("CADFS sample is not installed")
                result = lower_model(parse_featurescript(feature.read_text(), sample_id), {})
                transforms = {item["id"]: item for item in result.cdsl["features"] if item["atomic_id"] == "transform_bodies"}
                self.assertFalse(any(
                    item.get("feature_id") in {feature_id[2:] for feature_id in expected_sources}
                    and str(item.get("capability") or "").startswith("transform")
                    for item in result.diagnostics
                ))
                for feature_id, source_feature_id in expected_sources.items():
                    expected = {
                        "source_feature_ids": [source_feature_id],
                        "transform": {"type": "translation", "translation_mm": [0.0, 0.0, 0.0]},
                        "make_copy": True,
                    }
                    if sample_id == "00981258" and feature_id == "f_F4":
                        expected["source_feature_ids"] = ["f_F3"]
                        expected["source_member_aliases"] = [{
                            "source_feature_id": "f_F1",
                            "active_member_feature_id": "f_F3",
                        }]
                    self.assertEqual(transforms[feature_id]["params"], expected)

    def test_transform_lowers_one_proven_mirror_copy_member(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        cases = {
            "00120430": {"f_F5": {"pattern_feature_id": "f_F4", "source_feature_id": "f_F1", "instance_index": 1}},
            "00749755": {"f_F4": {"pattern_feature_id": "f_F3", "source_feature_id": "f_F1", "instance_index": 1}},
        }
        for sample_id, expected in cases.items():
            with self.subTest(sample_id=sample_id):
                feature = root / "featurescript_rp" / sample_id[:4] / f"{sample_id}.txt"
                if not feature.exists():
                    self.skipTest("CADFS sample is not installed")
                result = lower_model(parse_featurescript(feature.read_text(), sample_id), {})
                transforms = {item["id"]: item for item in result.cdsl["features"] if item["atomic_id"] == "transform_bodies"}
                for feature_id, reference in expected.items():
                    self.assertEqual(transforms[feature_id]["params"]["pattern_instance_refs"], [reference])
                self.assertFalse(any(
                    item.get("feature_id") in {feature_id[2:] for feature_id in expected}
                    and item.get("capability") == "transform_pattern_copy"
                    for item in result.diagnostics
                ))

    def test_transform_lowers_source_qualified_multi_source_copy_members(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0069/00699847.txt"
        if not feature.exists():
            self.skipTest("CADFS sample is not installed")

        result = lower_model(parse_featurescript(feature.read_text(), "00699847"), {})
        self.assertEqual(result.status, "converted_complete")
        self.assertFalse(result.diagnostics)
        transforms = {item["id"]: item for item in result.cdsl["features"] if item["atomic_id"] == "transform_bodies"}
        self.assertEqual(transforms["f_F3"]["params"]["source_feature_ids"], ["f_F1", "f_F2"])
        self.assertEqual(transforms["f_F4"]["params"]["transform_copy_refs"], [
            {"transform_feature_id": "f_F3", "source_feature_id": "f_F1"},
            {"transform_feature_id": "f_F3", "source_feature_id": "f_F2"},
        ])
        self.assertEqual(transforms["f_F4"]["depends_on"], ["f_F1", "f_F2", "f_F3"])

    def test_transform_copy_chain_retains_semantic_source_and_active_member(self):
        """COPY owns the original CADFS body while executing its live member."""
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        source = root / "featurescript_rp/0018/00184423.txt"
        if not source.exists():
            self.skipTest("CADFS sample is not installed")

        result = lower_model(parse_featurescript(source.read_text(), "00184423"), {})
        self.assertEqual(result.status, "converted_complete")
        self.assertFalse(result.diagnostics)
        transforms = {item["id"]: item for item in result.cdsl["features"] if item["atomic_id"] == "transform_bodies"}
        self.assertEqual(transforms["f_F3"]["params"]["source_member_aliases"], [{
            "source_feature_id": "f_F1", "active_member_feature_id": "f_F2",
        }])
        self.assertEqual(transforms["f_F4"]["params"]["source_member_aliases"], [{
            "source_feature_id": "f_F1", "active_member_feature_id": "f_F3",
        }])
        self.assertEqual(transforms["f_F5"]["params"]["source_member_aliases"], [{
            "source_feature_id": "f_F1", "active_member_feature_id": "f_F4",
        }])
        # The alias is source provenance. Replacing its selected runtime
        # member cannot silently redirect a transform to another body.
        invalid = deepcopy(result.cdsl)
        invalid_feature = next(item for item in invalid["features"] if item["id"] == "f_F3")
        invalid_feature["params"]["source_member_aliases"][0]["active_member_feature_id"] = "f_F1"
        from engine.cdsl_engine.semantic_validation import validate_semantic_cdsl
        with self.assertRaisesRegex(ValueError, "does not bind one preceding semantic source"):
            validate_semantic_cdsl(invalid)

    def test_uniform_scale_lowers_to_a_non_rigid_body_transform(self):
        source = TRANSFORM_SOURCE.replace(
            '"transformType":TransformType.TRANSLATION_3D, "dx":10 * mm, "dy":0 * mm, "dz":0 * mm, "makeCopy":false',
            '"transformType":TransformType.SCALE_UNIFORMLY, "scale":0.5, '
            '"scalePoint":qCreatedBy(makeId("Origin.pointOp"), VERTEX), "makeCopy":false',
        )
        result = lower_model(parse_featurescript(source, "uniform-scale"), {})
        self.assertEqual(result.status, "converted_complete")
        self.assertFalse(result.diagnostics)
        transform = result.cdsl["features"][-1]
        self.assertEqual(transform["atomic_id"], "transform_bodies")
        self.assertEqual(transform["params"], {
            "source_feature_ids": ["f_F1"],
            "transform": {"type": "uniform_scale", "center_mm": [0.0, 0.0, 0.0], "scale_factor": 0.5},
            "make_copy": False,
        })

        from engine.cdsl_engine.runtime import rebuild_cdsl
        with tempfile.TemporaryDirectory() as directory:
            rebuilt = rebuild_cdsl(result.cdsl, Path(directory) / "uniform-scale.step")
        self.assertEqual(rebuilt["solid_count"], 1)
        self.assertAlmostEqual(rebuilt["volume_mm3"], math.pi * 9.53 ** 2 * 120 / 8)
        self.assertEqual(rebuilt["bbox_mm"], {"min": [-4.765, -4.765, 0.0], "max": [4.765, 4.765, 60.0]})
        self.assertTrue(any(item["operation"] == "uniform_scale" for item in rebuilt["topology_deltas"]))

    def test_uniform_scale_resolves_direct_circle_center_and_rejects_invalid_centers(self):
        source = TRANSFORM_SOURCE.replace(
            '"center":v(0, 0) * mm, "radius":9.53 * mm',
            '"center":v(10, 0) * mm, "radius":9.53 * mm',
        ).replace(
            '"transformType":TransformType.TRANSLATION_3D, "dx":10 * mm, "dy":0 * mm, "dz":0 * mm, "makeCopy":false',
            '"transformType":TransformType.SCALE_UNIFORMLY, "scale":0.5, '
            '"scalePoint":sQuery(id + "F0.wireOp", VERTEX, "E0.center"), "makeCopy":false',
        )
        result = lower_model(parse_featurescript(source, "uniform-scale-circle-center"), {})
        self.assertEqual(result.status, "converted_complete")
        self.assertEqual(result.cdsl["features"][-1]["params"]["transform"], {
            "type": "uniform_scale", "center_mm": [10.0, 0.0, 0.0], "scale_factor": 0.5,
        })

        zero_factor = lower_model(parse_featurescript(source.replace('"scale":0.5', '"scale":0'), "uniform-scale-zero"), {})
        self.assertEqual(zero_factor.status, "converted_partial")
        self.assertEqual(zero_factor.diagnostics[-1]["capability"], "transform_uniform_scale")

        unresolved_center = lower_model(parse_featurescript(source.replace(
            'sQuery(id + "F0.wireOp", VERTEX, "E0.center")',
            'qCreatedBy(id + "F1", VERTEX)',
        ), "uniform-scale-unresolved-center"), {})
        self.assertEqual(unresolved_center.status, "converted_partial")
        self.assertEqual(unresolved_center.diagnostics[-1]["capability"], "transform_uniform_scale_center")

    def test_non_copy_uniform_scale_preserves_a_later_source_owner_alias(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0041/00417936.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(feature.read_text(), "00417936"), {})
        self.assertEqual(result.status, "converted_complete")
        transforms = [item for item in result.cdsl["features"] if item["atomic_id"] == "transform_bodies"]
        self.assertEqual([item["params"]["source_feature_ids"] for item in transforms], [["f_F1"], ["f_F2"]])
        self.assertEqual([item["params"]["transform"]["scale_factor"] for item in transforms], [10.0, 1.5])

        from engine.cdsl_engine.runtime import rebuild_cdsl
        with tempfile.TemporaryDirectory() as directory:
            rebuilt = rebuild_cdsl(result.cdsl, Path(directory) / "sequential-uniform-scale.step")
        self.assertEqual(rebuilt["solid_count"], 1)
        self.assertEqual([item["feature_id"] for item in rebuilt["feature_results"]], ["f_F1", "f_F2", "f_F3"])
        self.assertEqual(
            [item["operation"] for item in rebuilt["topology_deltas"]],
            ["extrude", "uniform_scale", "uniform_scale"],
        )

    def test_single_body_successor_aliases_clear_at_body_graph_boundaries(self):
        for boundary in (
            {"id": "f_copy", "atomic_id": "transform_bodies", "params": {"make_copy": True}},
            {"id": "f_boolean", "atomic_id": "boolean_bodies", "params": {}},
            {"id": "f_pattern", "atomic_id": "pattern_circular", "params": {}},
            {"id": "f_delete", "atomic_id": "delete_bodies", "params": {}},
        ):
            with self.subTest(boundary=boundary["atomic_id"]):
                aliases = {}
                state = {"owner": None, "sources": set()}
                _record_single_body_successor(aliases, state, {
                    "id": "f_base", "atomic_id": "extrude_add_blind",
                    "params": {"result_mode": "new_body"},
                })
                _record_single_body_successor(aliases, state, {
                    "id": "f_add", "atomic_id": "extrude_add_blind", "params": {},
                })
                self.assertEqual(aliases, {"f_base": "f_add"})

                _record_single_body_successor(aliases, state, boundary)
                self.assertEqual(aliases, {})
                self.assertIsNone(state["owner"])
                self.assertEqual(state["sources"], set())

    def test_shell_parts_lowers_to_a_live_member_or_proven_sole_body_alias(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"

        successor = root / "featurescript_rp/0010/00107631.txt"
        result = lower_model(parse_featurescript(successor.read_text(), "00107631"), {})
        shell = next(feature for feature in result.cdsl["features"] if feature["id"] == "f_F3")
        self.assertEqual(shell["params"]["target_feature_id"], "f_F2")
        self.assertFalse(any(
            diagnostic.get("capability") == "shell_parts_body_source"
            for diagnostic in result.diagnostics
        ))

        patterned = root / "featurescript_rp/0054/00542223.txt"
        result = lower_model(parse_featurescript(patterned.read_text(), "00542223"), {})
        self.assertNotIn("f_F7", {feature["id"] for feature in result.cdsl["features"]})
        diagnostic = next(item for item in result.diagnostics if item.get("feature_id") == "F7")
        self.assertEqual(diagnostic["message"], "pattern copy source feature is not replayed by its owner")

    def test_translation_distance_lowers_from_a_linear_sketch_direction(self):
        source = TRANSFORM_SOURCE.replace(
            'skCircle(sketch, "E0", {"center":v(0, 0) * mm, "radius":9.53 * mm}); skSolve(sketch);',
            'skCircle(sketch, "E0", {"center":v(0, 0) * mm, "radius":9.53 * mm}); '
            'skLineSegment(sketch, "E1", {"start":v(0, 0) * mm, "end":v(1, 0) * mm, "construction":true}); skSolve(sketch);',
        ).replace(
            '"transformType":TransformType.TRANSLATION_3D, "dx":10 * mm, "dy":0 * mm, "dz":0 * mm, "makeCopy":false',
            '"transformType":TransformType.TRANSLATION_DISTANCE, "transformDirection":sQuery(id + "F0.wireOp", EDGE, "E1"), '
            '"distance":10 * mm, "oppositeDirection":true, "makeCopy":false',
        )
        moved = lower_model(parse_featurescript(source, "distance-move"), {})
        self.assertEqual(moved.status, "converted_complete")
        self.assertFalse(moved.diagnostics)
        self.assertEqual(moved.cdsl["geometry"]["sketches"][0]["workplane"]["origin_mm"], [-10.0, 0.0, 0.0])

        datum_plane = TRANSFORM_SOURCE.replace(
            '"transformType":TransformType.TRANSLATION_3D, "dx":10 * mm, "dy":0 * mm, "dz":0 * mm, "makeCopy":false',
            '"transformType":TransformType.TRANSLATION_DISTANCE, '
            '"transformDirection":qCreatedBy(makeId("Front.planeOp"), FACE), '
            '"distance":10 * mm, "makeCopy":true',
        )
        datum_result = lower_model(parse_featurescript(datum_plane, "distance-datum-plane"), {})
        self.assertEqual(datum_result.status, "converted_complete")
        self.assertEqual(datum_result.cdsl["features"][-1]["params"], {
            "source_feature_ids": ["f_F1"],
            "transform": {"type": "translation", "translation_mm": [0.0, -10.0, 0.0]},
            "make_copy": True,
        })

        square = (
            'skLineSegment(sketch, "E0", {"start":v(0, 0) * mm, "end":v(10, 0) * mm}); '
            'skLineSegment(sketch, "E1", {"start":v(10, 0) * mm, "end":v(10, 10) * mm}); '
            'skLineSegment(sketch, "E2", {"start":v(10, 10) * mm, "end":v(0, 10) * mm}); '
            'skLineSegment(sketch, "E3", {"start":v(0, 10) * mm, "end":v(0, 0) * mm}); skSolve(sketch);'
        )
        swept_face = TRANSFORM_SOURCE.replace(
            'skCircle(sketch, "E0", {"center":v(0, 0) * mm, "radius":9.53 * mm}); skSolve(sketch);', square,
        ).replace(
            '"transformType":TransformType.TRANSLATION_3D, "dx":10 * mm, "dy":0 * mm, "dz":0 * mm, "makeCopy":false',
            '"transformType":TransformType.TRANSLATION_DISTANCE, '
            '"transformDirection":makeQuery(id + "F1.opExtrude", "SWEPT_FACE", FACE, '
            '{"derivedFrom":sQuery(id + "F0.wireOp", EDGE, "E0")}), '
            '"distance":10 * mm, "makeCopy":true',
        )
        swept_result = lower_model(parse_featurescript(swept_face, "distance-swept-face"), {})
        self.assertEqual(swept_result.status, "converted_complete")
        self.assertEqual(swept_result.cdsl["features"][-1]["params"], {
            "source_feature_ids": ["f_F1"],
            "transform": {"type": "translation", "translation_mm": [0.0, -10.0, 0.0]},
            "make_copy": True,
        })

        copied = lower_model(parse_featurescript(source.replace('"makeCopy":false', '"makeCopy":true'), "distance-copy"), {})
        self.assertEqual(copied.status, "converted_complete")
        self.assertFalse(copied.diagnostics)
        self.assertEqual(copied.cdsl["features"][-1]["params"], {
            "source_feature_ids": ["f_F1"],
            "transform": {"type": "translation", "translation_mm": [-10.0, 0.0, 0.0]},
            "make_copy": True,
        })

        from engine.cdsl_engine.runtime import rebuild_cdsl
        with tempfile.TemporaryDirectory() as directory:
            rebuilt = rebuild_cdsl(copied.cdsl, Path(directory) / "distance-copy.step")
        self.assertEqual(rebuilt["solid_count"], 2)
        self.assertEqual(rebuilt["bbox_mm"]["min"], [-19.53, -9.53, 0.0])
        self.assertEqual(rebuilt["bbox_mm"]["max"], [9.53, 9.53, 120.0])

    def test_translation_distance_cap_edge_uses_its_physical_frame(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0066/00665176.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(feature.read_text(), "00665176"), {})
        transforms = {item["id"]: item for item in result.cdsl["features"] if item["atomic_id"] == "transform_bodies"}
        self.assertEqual(transforms["f_F2"]["params"]["transform"], {"type": "translation", "translation_mm": [0.0, 0.0, 381.0]})
        self.assertEqual(transforms["f_F3"]["params"]["transform"], {"type": "translation", "translation_mm": [127.0, 0.0, 0.0]})
        self.assertEqual(transforms["f_F4"]["params"]["transform"], {"type": "translation", "translation_mm": [-127.0, 0.0, 0.0]})
        self.assertNotIn("F2", [item.get("feature_id") for item in result.diagnostics])
        self.assertNotIn("F3", [item.get("feature_id") for item in result.diagnostics])
        self.assertNotIn("F4", [item.get("feature_id") for item in result.diagnostics])

    def test_translation_distance_cap_face_uses_its_physical_normal(self):
        source = TRANSFORM_SOURCE.replace(
            '"transformType":TransformType.TRANSLATION_3D, "dx":10 * mm, "dy":0 * mm, "dz":0 * mm, "makeCopy":false',
            '"transformType":TransformType.TRANSLATION_DISTANCE, '
            '"transformDirection":makeQuery(id + "F1.opExtrude", "CAP_FACE", FACE, '
            '{"derivedFrom":sQuery(id + "F0.wireOp", EDGE, "E0"), "isStart":false}), '
            '"distance":10 * mm, "makeCopy":true',
        )
        result = lower_model(parse_featurescript(source, "distance-cap-face"), {})
        self.assertEqual(result.status, "converted_complete")
        self.assertFalse(result.diagnostics)
        self.assertEqual(result.cdsl["features"][-1]["params"], {
            "source_feature_ids": ["f_F1"],
            "transform": {"type": "translation", "translation_mm": [0.0, 0.0, 10.0]},
            "make_copy": True,
        })

        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0007/00078650.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        real = lower_model(parse_featurescript(feature.read_text(), "00078650"), {})
        self.assertEqual(real.status, "converted_complete")
        transform = next(item for item in real.cdsl["features"] if item["id"] == "f_F4")
        self.assertEqual(transform["params"], {
            "source_feature_ids": ["f_F1", "f_F2", "f_F3"],
            "transform": {"type": "translation", "translation_mm": [0.0, -431.8, 0.0]},
            "make_copy": True,
        })

    def test_translation_distance_rejects_a_curved_direction(self):
        source = TRANSFORM_SOURCE.replace(
            '"transformType":TransformType.TRANSLATION_3D, "dx":10 * mm, "dy":0 * mm, "dz":0 * mm, "makeCopy":false',
            '"transformType":TransformType.TRANSLATION_DISTANCE, "transformDirection":sQuery(id + "F0.wireOp", EDGE, "E0"), '
            '"distance":10 * mm, "makeCopy":false',
        )
        result = lower_model(parse_featurescript(source, "distance-curve"), {})
        self.assertEqual(result.status, "converted_partial")
        self.assertEqual(result.diagnostics[-1]["capability"], "transform_translation_direction")

        cap_circle = lower_model(parse_featurescript(source.replace(
            'sQuery(id + "F0.wireOp", EDGE, "E0")',
            'makeQuery(id + "F1.opExtrude", "CAP_EDGE", EDGE, {"derivedFrom":sQuery(id + "F0.wireOp", EDGE, "E0"), "isStart":false})',
        ), "distance-cap-circle"), {})
        self.assertEqual(cap_circle.status, "converted_partial")
        self.assertEqual(cap_circle.diagnostics[-1]["capability"], "transform_translation_direction")

    def test_translation_entity_lowers_direct_line_and_vertex_vectors(self):
        sketch = (
            'skCircle(sketch, "E0", {"center":v(0, 0) * mm, "radius":9.53 * mm}); '
            'skLineSegment(sketch, "E1", {"start":v(0, 0) * mm, "end":v(2, 0) * mm, "construction":true}); '
            'skPoint(sketch, "E2", {"position":v(0, 0) * mm}); '
            'skPoint(sketch, "E3", {"position":v(0, 5) * mm}); skSolve(sketch);'
        )
        line_source = TRANSFORM_SOURCE.replace(
            'skCircle(sketch, "E0", {"center":v(0, 0) * mm, "radius":9.53 * mm}); skSolve(sketch);', sketch,
        ).replace(
            '"transformType":TransformType.TRANSLATION_3D, "dx":10 * mm, "dy":0 * mm, "dz":0 * mm, "makeCopy":false',
            '"transformType":TransformType.TRANSLATION_ENTITY, "transformLine":sQuery(id + "F0.wireOp", EDGE, "E1"), '
            '"oppositeDirectionEntity":false, "makeCopy":true',
        )
        copied = lower_model(parse_featurescript(line_source, "entity-line-copy"), {})
        self.assertEqual(copied.status, "converted_complete")
        self.assertEqual(copied.cdsl["features"][-1]["params"], {
            "source_feature_ids": ["f_F1"],
            "transform": {"type": "translation", "translation_mm": [2.0, 0.0, 0.0]},
            "make_copy": True,
        })

        vertex_source = line_source.replace(
            '"transformLine":sQuery(id + "F0.wireOp", EDGE, "E1"), "oppositeDirectionEntity":false, "makeCopy":true',
            '"transformLine":qUnion([sQuery(id + "F0.wireOp", VERTEX, "E2"), sQuery(id + "F0.wireOp", VERTEX, "E3")]), '
            '"oppositeDirectionEntity":false, "makeCopy":false',
        )
        moved = lower_model(parse_featurescript(vertex_source, "entity-vertices-move"), {})
        self.assertEqual(moved.status, "converted_complete")
        self.assertEqual(moved.cdsl["geometry"]["sketches"][0]["workplane"]["origin_mm"], [0.0, 5.0, 0.0])

        curved = lower_model(parse_featurescript(line_source.replace('EDGE, "E1"', 'EDGE, "E0"'), "entity-curve"), {})
        self.assertEqual(curved.status, "converted_partial")
        self.assertEqual(curved.diagnostics[-1]["capability"], "transform_translation_entity")

        cap_circle = lower_model(parse_featurescript(line_source.replace(
            'sQuery(id + "F0.wireOp", EDGE, "E1")',
            'makeQuery(id + "F1.opExtrude", "CAP_EDGE", EDGE, {"derivedFrom":sQuery(id + "F0.wireOp", EDGE, "E0"), "isStart":false})',
        ), "entity-cap-circle"), {})
        self.assertEqual(cap_circle.status, "converted_partial")
        self.assertEqual(cap_circle.diagnostics[-1]["capability"], "transform_translation_entity")

    def test_translation_entity_real_line_cap_and_body_lifecycle_boundaries(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        direct = root / "featurescript_rp/0012/00122249.txt"
        cap_edge = root / "featurescript_rp/0018/00184423.txt"
        absorbed = root / "featurescript_rp/0022/00226751.txt"
        if not all(path.exists() for path in (direct, cap_edge, absorbed)):
            self.skipTest("CADFS samples are not installed")

        direct_result = lower_model(parse_featurescript(direct.read_text(), "00122249"), {})
        self.assertEqual(direct_result.status, "converted_complete")
        moved_sketch = next(item for item in direct_result.cdsl["geometry"]["sketches"] if item["id"] == "sketch_F1__f_F2")
        self.assertEqual(moved_sketch["workplane"]["origin_mm"], [-7.0, 0.0, 0.0])

        cap_result = lower_model(parse_featurescript(cap_edge.read_text(), "00184423"), {})
        transform = next(item for item in cap_result.cdsl["features"] if item["id"] == "f_F2")
        self.assertEqual(transform["params"]["transform"], {"type": "translation", "translation_mm": [12.7, 0.0, 0.0]})
        self.assertEqual(cap_result.status, "converted_complete")
        self.assertFalse(cap_result.diagnostics)
        transforms = {item["id"]: item for item in cap_result.cdsl["features"] if item["atomic_id"] == "transform_bodies"}
        self.assertEqual(
            {feature_id: item["params"]["source_feature_ids"] for feature_id, item in transforms.items()},
            {"f_F2": ["f_F1"], "f_F3": ["f_F2"], "f_F4": ["f_F3"], "f_F5": ["f_F4"], "f_F6": ["f_F4"]},
        )
        self.assertEqual(transforms["f_F5"]["params"]["transform"]["type"], "translation")
        for actual, expected in zip(transforms["f_F5"]["params"]["transform"]["translation_mm"], [0.0, -12.7, 0.0]):
            self.assertAlmostEqual(actual, expected)
        from engine.cdsl_engine.runtime import rebuild_cdsl
        with tempfile.TemporaryDirectory() as directory:
            rebuilt = rebuild_cdsl(cap_result.cdsl, Path(directory) / "transform-copy-chain.step")
        self.assertEqual(rebuilt["solid_count"], 6)
        self.assertEqual([item["feature_id"] for item in rebuilt["feature_results"]], [
            "f_F1", "f_F2", "f_F3", "f_F4", "f_F5", "f_F6",
        ])
        self.assertFalse(rebuilt["runtime_diagnostics"])

        absorbed_result = lower_model(parse_featurescript(absorbed.read_text(), "00226751"), {})
        self.assertEqual(absorbed_result.diagnostics[-1]["capability"], "transform_body_lifecycle")

    def test_direct_swept_body_delete_lowers_to_a_body_graph_operation(self):
        source = SOURCE.replace(
            '\n});\n',
            '''
  { var Q0; Q0=makeQuery(id + "F1.opExtrude", "SWEPT_BODY", BODY, {});
    deleteBodies(context, id + "F2", {"entities":qUnion([Q0])}); }
});
''',
        )
        result = lower_model(parse_featurescript(source, "delete-body"), {})
        self.assertEqual(result.status, "converted_complete")
        delete = result.cdsl["features"][-1]
        self.assertEqual(delete["atomic_id"], "delete_bodies")
        self.assertEqual(delete["params"], {"target_feature_ids": ["f_F1"]})

    def test_symmetric_cut_lowers_to_two_sided_cut(self):
        source = SOURCE.replace('"depth":120 * mm', '"operationType":NewBodyOperationType.REMOVE, "depth":120 * mm, "symmetric":true')
        result = lower_model(parse_featurescript(source, "symmetric-cut"), {})
        self.assertEqual(result.status, "converted_complete")
        feature = result.cdsl["features"][0]
        self.assertEqual(feature["atomic_id"], "extrude_cut_two_sided")
        self.assertEqual(feature["params"]["distance_mm"], 60.0)
        self.assertEqual(feature["params"]["reverse_distance_mm"], 60.0)

    def test_new_body_operation_only_new_emits_new_body_result_mode(self):
        """FeatureScript ADD uses the CDSL fuse path; only NEW creates a member."""
        new = lower_model(parse_featurescript(
            SOURCE.replace('"depth":120 * mm', '"operationType":NewBodyOperationType.NEW, "depth":120 * mm'),
            "explicit-new",
        ), {})
        add = lower_model(parse_featurescript(
            SOURCE.replace('"depth":120 * mm', '"operationType":NewBodyOperationType.ADD, "depth":120 * mm'),
            "explicit-add",
        ), {})
        self.assertEqual(new.cdsl["features"][0]["params"].get("result_mode"), "new_body")
        self.assertNotIn("result_mode", add.cdsl["features"][0]["params"])

    def test_typed_add_sweep_and_revolve_do_not_emit_new_body_result_mode(self):
        """The shared ADD lifecycle rule applies to every additive producer."""
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test/featurescript_rp"
        sweep_source = root / "0000/00007135.txt"
        revolve_source = root / "0004/00048326.txt"
        if not sweep_source.exists() or not revolve_source.exists():
            self.skipTest("CADFS sweep/revolve source samples are not installed")
        sweep = lower_model(parse_featurescript(
            sweep_source.read_text(encoding="utf-8").replace(
                '"path" : qUnion([Q1])',
                '"path" : qUnion([Q1]), "operationType" : NewBodyOperationType.ADD',
                1,
            ),
            "00007135-typed-add",
        ), {})
        revolve = lower_model(parse_featurescript(
            revolve_source.read_text(encoding="utf-8").replace(
                '"revolveType" : RevolveType.FULL',
                '"revolveType" : RevolveType.FULL, "operationType" : NewBodyOperationType.ADD',
                1,
            ),
            "00048326-typed-add",
        ), {})
        sweep_feature = next(item for item in sweep.cdsl["features"] if item["atomic_id"] == "sweep_add")
        revolve_feature = next(item for item in revolve.cdsl["features"] if item["atomic_id"] == "revolve_add")
        self.assertNotIn("result_mode", sweep_feature["params"])
        self.assertNotIn("result_mode", revolve_feature["params"])

    def test_through_all_extrudes_reuse_the_engine_extent_contract(self):
        for operation_type, expected_atomic in [
            ("NewBodyOperationType.NEW", "extrude_add_blind"),
            ("NewBodyOperationType.REMOVE", "extrude_cut_blind"),
        ]:
            with self.subTest(operation_type=operation_type):
                source = SOURCE.replace(
                    '"depth":120 * mm',
                    f'"operationType":{operation_type}, "depth":120 * mm, "endBound":BoundingType.THROUGH_ALL',
                )
                result = lower_model(parse_featurescript(source, f"through-all-{operation_type}"), {})
                self.assertEqual(result.status, "converted_complete")
                feature = result.cdsl["features"][0]
                self.assertEqual(feature["atomic_id"], expected_atomic)
                self.assertEqual(feature["params"]["end_condition"]["type"], "through_all")

    def test_up_to_next_extrudes_reuse_the_engine_extent_contract(self):
        for operation_type, expected_atomic in [
            ("NewBodyOperationType.NEW", "extrude_add_blind"),
            ("NewBodyOperationType.REMOVE", "extrude_cut_blind"),
        ]:
            with self.subTest(operation_type=operation_type):
                source = SOURCE.replace(
                    '"depth":120 * mm',
                    f'"operationType":{operation_type}, "depth":120 * mm, "endBound":BoundingType.UP_TO_NEXT',
                )
                result = lower_model(parse_featurescript(source, f"up-to-next-{operation_type}"), {})
                self.assertEqual(result.status, "converted_complete")
                feature = result.cdsl["features"][0]
                self.assertEqual(feature["atomic_id"], expected_atomic)
                self.assertEqual(feature["params"]["end_condition"]["type"], "through_next")

    def test_implicit_extrude_after_a_body_uses_default_new_body_semantics(self):
        source = SOURCE.replace(
            '\n});\n',
            '''
  { var Q0; Q0=qSketchRegion(id + "F0", true);
    extrude(context, id + "F2", {"entities":qUnion([Q0]), "depth":20 * mm}); }
});
''',
        )
        result = lower_model(parse_featurescript(source, "implicit-add"), {})
        first, second = result.cdsl["features"]
        self.assertEqual(first["params"]["result_mode"], "new_body")
        self.assertEqual(second["params"]["result_mode"], "new_body")

    def test_up_to_body_extrude_captures_target_and_offset(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0069/00694309.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(feature.read_text(), "00694309"), {})
        self.assertEqual(result.status, "converted_complete")
        extrude = next(item for item in result.cdsl["features"] if item["id"] == "f_F3")
        end = extrude["params"]["end_condition"]
        self.assertEqual(end["type"], "up_to_body")
        self.assertEqual(end["offset_mm"], 3.0)
        self.assertEqual(end["reference"]["kind"], "body")
        self.assertEqual(end["reference"]["owner_feature_id"], "f_F1")
        self.assertEqual(end["reference"]["source"], "runtime_snapshot")
        self.assertNotIn("stable_id", end["reference"])
        self.assertEqual(end["reference"]["selector_intent"]["query_family"], "SWEPT_BODY")
        self.assertEqual(end["reference"]["selector_intent"]["evidence"], "active_body_member")
        self.assertEqual(
            end["reference"]["selector_intent"]["derivation_policy"],
            {"allowed": ["boundary"], "multiplicity": "one"},
        )
        fillet = next(item for item in result.cdsl["features"] if item["id"] == "f_F4")
        self.assertEqual(len(fillet["selectors"]), 1)
        self.assertEqual(fillet["selectors"][0]["selector_intent"]["query_family"], "CAP_EDGE")
        self.assertEqual(
            fillet["selectors"][0]["selector_intent"]["derivation_policy"],
            {"allowed": ["boundary", "continuation"], "multiplicity": "one"},
        )
        from engine.cdsl_engine.semantic_validation import validate_semantic_cdsl

        mixed_evidence = deepcopy(result.cdsl)
        mixed_reference = next(
            item for item in mixed_evidence["features"] if item["id"] == "f_F3"
        )["params"]["end_condition"]["reference"]
        mixed_reference["stable_id"] = "body:f_F1"
        with self.assertRaisesRegex(ValueError, "invalid SWEPT_BODY member contract"):
            validate_semantic_cdsl(mixed_evidence)

    def test_primary_cut_copy_cap_edge_chamfer_uses_exact_copy_lineage(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0025/00252195.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(feature.read_text(encoding="utf-8"), "00252195"), {})
        chamfer = next(item for item in result.cdsl["features"] if item["id"] == "f_F4")
        selector = chamfer["selectors"][0]
        self.assertEqual(selector["selector_intent"]["query_family"], "COPY")
        self.assertEqual(selector["selector_intent"]["copy_contract"], "primary_cut_cap_edge")
        self.assertEqual(selector["query_input"]["selector_intent"]["query_family"], "CAP_EDGE")
        self.assertNotIn("stable_id", selector)
        self.assertNotIn("geometry", selector)

        prefix = deepcopy(result.cdsl)
        prefix["features"] = [
            item for item in prefix["features"] if item["id"] in {"f_F1", "f_F3", "f_F4"}
        ]
        with tempfile.TemporaryDirectory() as directory:
            rebuilt = rebuild_candidate(prefix, Path(directory) / "copy-primary-cut-cap-edge.step")
        self.assertEqual(rebuilt["status"], "rebuild_failed")
        self.assertEqual(rebuilt["error"]["type"], "RuntimeExecutionError")
        resolution = rebuilt["error"]["selector_resolutions"][0]
        self.assertEqual(resolution["status"], "resolved")
        self.assertEqual(resolution["resolution_mode"], "copy_lineage")
        self.assertEqual([relation["operation"] for relation in resolution["evidence"]["relations"]], [
            "extrude", "subtract",
        ])

    def test_boolean_copy_face_workplane_does_not_reuse_its_nested_cap_frame(self):
        """COPY(FACE) needs its own runtime provenance, not a nested CAP frame."""
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0025/00252794.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")

        result = lower_model(parse_featurescript(feature.read_text(encoding="utf-8"), "00252794"), {})
        self.assertEqual(result.status, "converted_partial")
        self.assertTrue(any(
            diagnostic["code"] == "sketch_deferred"
            and diagnostic["feature_id"] == "F8"
            and "COPY(FACE) workplane requires a dedicated complete/proven runtime face relation" in diagnostic["message"]
            for diagnostic in result.diagnostics
        ))
        self.assertFalse(any(sketch["id"] == "sketch_F8" for sketch in result.cdsl["geometry"]["sketches"]))
        self.assertFalse(any(feature["id"] == "f_F9" for feature in result.cdsl["features"]))

        # A second primary-cut CAP-face source proves this is an outer COPY
        # contract, rather than a sample-specific F3/F8 coordinate rule.
        second_feature = root / "featurescript_rp/0025/00252895.txt"
        if not second_feature.exists(): self.skipTest("second CADFS sample is not installed")
        second = lower_model(parse_featurescript(second_feature.read_text(encoding="utf-8"), "00252895"), {})
        self.assertEqual(second.status, "converted_partial")
        self.assertTrue(any(
            diagnostic["code"] == "sketch_deferred"
            and diagnostic["feature_id"] == "F4"
            and "COPY(FACE) workplane requires a dedicated complete/proven runtime face relation" in diagnostic["message"]
            for diagnostic in second.diagnostics
        ))

    def test_immediate_primary_cut_copy_cap_face_workplane_uses_runtime_attachment(self):
        """COPY(CAP_FACE) attaches only through the exact cut successor."""
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        cases = (
            ("00573124", "f_F5", "hole_wizard"),
            ("00951631", "f_F5", "extrude_cut_blind"),
        )
        for sample_id, consumer_id, atomic_id in cases:
            with self.subTest(sample_id=sample_id):
                feature = root / f"featurescript_rp/{sample_id[:4]}/{sample_id}.txt"
                if not feature.exists(): self.skipTest("CADFS sample is not installed")
                result = lower_model(parse_featurescript(feature.read_text(encoding="utf-8"), sample_id), {})
                sketch = next(item for item in result.cdsl["geometry"]["sketches"] if item["id"] == "sketch_F4")
                attachment = sketch["attachment"]
                self.assertEqual(attachment["selector_intent"]["copy_contract"], "primary_cut_cap_face_workplane")
                self.assertEqual(attachment["query_input"]["selector_intent"]["query_family"], "CAP_FACE")
                self.assertNotIn("geometry", attachment)
                from engine.cdsl_engine.semantic_validation import validate_semantic_cdsl
                self.assertTrue(validate_semantic_cdsl(result.cdsl)["future_rebuild_ready"])
                tampered = deepcopy(result.cdsl)
                tampered_attachment = next(
                    item for item in tampered["geometry"]["sketches"] if item["id"] == "sketch_F4"
                )["attachment"]
                tampered_attachment["query_input"]["selector_intent"]["source_entities"][0]["entity_id"] = "unrelated"
                with self.assertRaisesRegex(ValueError, "complete direct primary-cut source-profile edge set"):
                    validate_semantic_cdsl(tampered)
                consumer = next(item for item in result.cdsl["features"] if item["id"] == consumer_id)
                self.assertEqual(consumer["atomic_id"], atomic_id)
                if atomic_id == "hole_wizard":
                    self.assertEqual(consumer["params"]["host_face"], attachment)
                prefix = deepcopy(result.cdsl)
                prefix["features"] = [
                    item for item in prefix["features"] if item["id"] in {"f_F1", "f_F3", consumer_id}
                ]
                with tempfile.TemporaryDirectory() as directory:
                    rebuilt = rebuild_candidate(prefix, Path(directory) / f"{sample_id}.step")
                self.assertEqual(rebuilt["status"], "rebuilt")
                resolution = next(
                    item for item in rebuilt["result"]["selector_resolution"]
                    if item["feature_id"] == consumer_id
                )
                self.assertEqual(resolution["resolution_mode"], "copy_lineage")
                self.assertEqual([relation["operation"] for relation in resolution["evidence"]["relations"]], [
                    "extrude", "subtract",
                ])

    def test_direct_prism_cap_face_workplane_stays_runtime_attached_00126630(self):
        """A direct CAP host is not lowered into a static F2 workplane."""
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0012/00126630.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")

        result = lower_model(parse_featurescript(feature.read_text(encoding="utf-8"), "00126630"), {})
        attachment = next(item for item in result.cdsl["geometry"]["sketches"] if item["id"] == "sketch_F2")["attachment"]
        self.assertEqual(attachment["kind"], "face")
        self.assertEqual(attachment["owner_feature_id"], "f_F1")
        self.assertEqual(attachment["output_role"], "extrude.start")
        self.assertEqual(attachment["selector_intent"]["consumer_contract"], "direct_prism_cap_face_workplane")
        self.assertNotIn("geometry", attachment)
        from engine.cdsl_engine.semantic_validation import validate_semantic_cdsl
        self.assertTrue(validate_semantic_cdsl(result.cdsl)["future_rebuild_ready"])

        imprint = next(item for item in result.cdsl["geometry"]["sketches"] if item["id"] == "sketch_F2__f_F3")
        self.assertEqual(imprint["profile"]["type"], "planar_imprint")
        self.assertEqual(imprint["profile"]["selections"][0]["fragment"]["external_anchor_id"], "cap_boundary_0")
        self.assertEqual(imprint["profile"]["external_anchors"][0]["selector"]["selector_intent"]["query_family"], "CAP_EDGE")

        # F1 -> F3 proves the attached CAP-face and its exact CAP-edge
        # boundary resolve before the later independent F4 dress-up gap.
        executable = deepcopy(result.cdsl)
        executable["features"] = [
            item for item in executable["features"] if item["id"] in {"f_F1", "f_F3"}
        ]
        from engine.cdsl_engine.runtime import prepare_cdsl_execution
        execution = prepare_cdsl_execution(executable)
        self.assertTrue(execution.analysis.runtime_eligible)
        execution.execute_all()
        resolutions = [item for item in execution.session.selector_resolutions if item["feature_id"] == "f_F3"]
        self.assertEqual([item["resolution_mode"] for item in resolutions], ["operation_role", "kernel_lineage"])
        self.assertTrue(all(item["status"] == "resolved" for item in resolutions))

        delayed = deepcopy(executable)
        blocker = deepcopy(delayed["features"][0])
        blocker["id"] = "f_blocker"
        blocker["name"] = "blocker"
        delayed["features"] = [delayed["features"][0], blocker, delayed["features"][1]]
        with self.assertRaisesRegex(ValueError, "CAP_FACE attachment must be consumed immediately"):
            validate_semantic_cdsl(delayed)

    def test_attached_cap_edge_imprint_requires_the_attachment_owner_00126630(self):
        """An external CAP edge cannot be substituted from another producer."""
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0012/00126630.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")

        mismatched = feature.read_text(encoding="utf-8").replace(
            'makeQuery(id+"F1.opExtrude","CAP_EDGE"',
            'makeQuery(id+"F99.opExtrude","CAP_EDGE"',
        )
        result = lower_model(parse_featurescript(mismatched, "00126630-owner-mismatch"), {})
        self.assertEqual(result.status, "converted_partial")
        self.assertEqual([item["id"] for item in result.cdsl["features"]], ["f_F1"])
        diagnostic = next(item for item in result.diagnostics if item["feature_id"] == "F3")
        self.assertEqual(diagnostic["capability"], "extrude_profile_topology:cap_edge")

    def test_attached_cap_edge_imprint_rejects_other_fragment_and_consumer_forms(self):
        """The singleton circle/new-body contract does not absorb nearby forms."""
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        cases = ("00612552", "00183004", "00880585")
        for sample_id in cases:
            with self.subTest(sample_id=sample_id):
                feature = root / f"featurescript_rp/{sample_id[:4]}/{sample_id}.txt"
                if not feature.exists(): self.skipTest("CADFS sample is not installed")
                result = lower_model(parse_featurescript(feature.read_text(encoding="utf-8"), sample_id), {})
                self.assertFalse(any(
                    isinstance(sketch, dict) and (sketch.get("profile") or {}).get("external_anchors")
                    for sketch in result.cdsl["geometry"]["sketches"]
                ))
                diagnostic = next(item for item in result.diagnostics if item["feature_id"] == "F3")
                self.assertEqual(diagnostic["capability"], "extrude_profile_topology:cap_edge")

    def test_immediate_primary_cut_copy_swept_face_workplane_uses_runtime_attachment(self):
        """COPY(SWEPT_FACE) follows the exact tool side face, never its frame."""
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        cases = (("00321940", "sketch_F4", "f_F5"), ("00171671", "sketch_F4", "f_F5"))
        for sample_id, sketch_id, consumer_id in cases:
            with self.subTest(sample_id=sample_id):
                feature = root / f"featurescript_rp/{sample_id[:4]}/{sample_id}.txt"
                if not feature.exists(): self.skipTest("CADFS sample is not installed")
                result = lower_model(parse_featurescript(feature.read_text(encoding="utf-8"), sample_id), {})
                attachment = next(item for item in result.cdsl["geometry"]["sketches"] if item["id"] == sketch_id)["attachment"]
                self.assertEqual(attachment["selector_intent"]["copy_contract"], "primary_cut_swept_face_workplane")
                self.assertEqual(attachment["query_input"]["selector_intent"]["query_family"], "SWEPT_FACE")
                self.assertNotIn("geometry", attachment)
                from engine.cdsl_engine.semantic_validation import validate_semantic_cdsl
                self.assertTrue(validate_semantic_cdsl(result.cdsl)["future_rebuild_ready"])
                tampered = deepcopy(result.cdsl)
                tampered_attachment = next(item for item in tampered["geometry"]["sketches"] if item["id"] == sketch_id)["attachment"]
                tampered_attachment["query_input"]["selector_intent"]["source_entity"]["entity_id"] = "unrelated"
                with self.assertRaisesRegex(ValueError, "one direct primary-cut source-profile edge"):
                    validate_semantic_cdsl(tampered)
                prefix = deepcopy(result.cdsl)
                prefix["features"] = [
                    item for item in prefix["features"] if item["id"] in {"f_F1", "f_F3", consumer_id}
                ]
                with tempfile.TemporaryDirectory() as directory:
                    rebuilt = rebuild_candidate(prefix, Path(directory) / f"{sample_id}.step")
                if sample_id == "00321940":
                    self.assertEqual(rebuilt["status"], "rebuilt")
                    resolution = next(item for item in rebuilt["result"]["selector_resolution"] if item["feature_id"] == consumer_id)
                    self.assertEqual(resolution["resolution_mode"], "copy_lineage")
                    self.assertEqual([relation["operation"] for relation in resolution["evidence"]["relations"]], ["extrude", "subtract"])
                else:
                    self.assertEqual(rebuilt["status"], "rebuilt")
                    self.assertEqual(
                        [item["feature_id"] for item in rebuilt["result"]["feature_results"]],
                        ["f_F1", "f_F3"],
                    )
                    self.assertFalse(any(
                        item["feature_id"] == consumer_id
                        for item in rebuilt["result"]["selector_resolution"]
                    ))

    def test_primary_cut_copy_swept_face_requires_a_unique_active_successor(self):
        """A real direct source still rejects when OCC reports no continuation."""
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0032/00326645.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(feature.read_text(encoding="utf-8"), "00326645"), {})
        attachment = next(item for item in result.cdsl["geometry"]["sketches"] if item["id"] == "sketch_F4")["attachment"]
        self.assertEqual(attachment["selector_intent"]["copy_contract"], "primary_cut_swept_face_workplane")
        with tempfile.TemporaryDirectory() as directory:
            rebuilt = rebuild_candidate(result.cdsl, Path(directory) / "00326645.step")
        self.assertEqual(rebuilt["status"], "rebuild_failed")
        resolution = rebuilt["error"]["selector_resolutions"][0]
        self.assertEqual(resolution["diagnostic"]["code"], "selector_copy_kernel_history_missing")

    def test_up_to_body_q_owner_body_projects_a_direct_swept_face(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0069/00694309.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        source = feature.read_text().replace(
            'Q1=makeQuery(id+"F1.opExtrude","SWEPT_BODY",BODY,{"disambiguationData":[OSD([sQuery(id+"F0.wireOp",EDGE,"E0")])]});',
            'Q1=qOwnerBody(makeQuery(id+"F1.opExtrude","SWEPT_FACE",FACE,{"disambiguationData":[OSD([sQuery(id+"F0.wireOp",EDGE,"E0")])]}));',
        ).replace('"endBoundEntityBody" : qUnion([Q1])', '"endBoundEntityBody" : Q1')
        result = lower_model(parse_featurescript(source, "00694309-owner-body"), {})

        self.assertEqual(result.status, "converted_complete")
        reference = next(item for item in result.cdsl["features"] if item["id"] == "f_F3")["params"]["end_condition"]["reference"]
        self.assertEqual(reference["kind"], "body")
        self.assertEqual(reference["selector_intent"]["query_family"], "OWNER_BODY")
        self.assertEqual(reference["selector_intent"]["owner_body_contract"], "exact_input_owner")
        self.assertEqual(reference["selector_intent"]["query_expr"]["root"]["filter"], "owner_body")
        self.assertEqual(reference["query_input"]["selector_intent"]["query_family"], "SWEPT_FACE")

        from engine.cdsl_engine.semantic_validation import validate_semantic_cdsl
        self.assertTrue(validate_semantic_cdsl(result.cdsl)["future_rebuild_ready"])
        with tempfile.TemporaryDirectory() as directory:
            rebuilt = rebuild_candidate(result.cdsl, Path(directory) / "owner-body.step")
        self.assertEqual(rebuilt["status"], "rebuilt")

    def test_up_to_surface_extrude_captures_the_cap_face(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0092/00925274.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(feature.read_text(), "00925274"), {})
        extrude = next(item for item in result.cdsl["features"] if item["id"] == "f_F3")
        end = extrude["params"]["end_condition"]
        self.assertEqual(end["type"], "up_to_surface")
        self.assertEqual(end["reference"]["kind"], "face")
        self.assertEqual(end["reference"]["owner_feature_id"], "f_F1")
        self.assertEqual(end["reference"]["output_role"], "extrude.start")
        self.assertEqual(end["reference"]["source"], "runtime_snapshot")
        self.assertNotIn("geometry", end["reference"])
        self.assertEqual(end["reference"]["selector_intent"]["query_family"], "CAP_FACE")
        self.assertEqual(end["reference"]["selector_intent"]["evidence"], "operation_role")
        swept = next(item for item in result.cdsl["features"] if item["id"] == "f_F6")
        swept_reference = swept["params"]["end_condition"]["reference"]
        self.assertEqual(swept_reference["selector_intent"]["query_family"], "SWEPT_FACE")
        self.assertEqual(
            swept_reference["selector_intent"]["derivation_policy"],
            {"allowed": ["boundary", "continuation"], "multiplicity": "one"},
        )
        self.assertEqual(swept_reference["selector_intent"]["evidence"], "kernel_history")
        self.assertEqual(swept_reference["selector_intent"]["source_entity"], {"sketch_id": "F0", "entity_id": "E0"})
        self.assertEqual(swept_reference["source"], "runtime_snapshot")
        self.assertNotIn("stable_id", swept_reference)
        self.assertNotIn("binding_feature_id", swept_reference)
        self.assertNotIn("geometry", swept_reference)
        mirror = next(item for item in result.cdsl["features"] if item["id"] == "f_F18")
        self.assertTrue(mirror["params"]["mirror_current_body"])

    def test_up_to_surface_can_consume_an_immediate_imprint_prism_retained_wall(self):
        """One unchanged selected source edge may prove its own prism wall."""
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        source_path = root / "featurescript_rp/0040/00408613.txt"
        if not source_path.exists(): self.skipTest("CADFS sample is not installed")
        source = source_path.read_text(encoding="utf-8")
        result = lower_model(parse_featurescript(source, "00408613"), {})
        self.assertEqual(result.status, "converted_complete")
        feature = next(item for item in result.cdsl["features"] if item["id"] == "f_F3")
        reference = feature["params"]["end_condition"]["reference"]
        self.assertEqual(reference["selector_intent"]["query_family"], "SWEPT_FACE")
        self.assertEqual(
            reference["selector_intent"]["consumer_contract"],
            "immediate_retained_source_prism_swept_face_up_to_surface",
        )
        self.assertEqual(
            reference["selector_intent"]["derivation_policy"],
            {"allowed": ["boundary"], "multiplicity": "one"},
        )
        self.assertNotIn("stable_id", reference)
        self.assertNotIn("geometry", reference)

        prefix = deepcopy(result.cdsl)
        prefix["features"] = prefix["features"][:2]
        with tempfile.TemporaryDirectory() as directory:
            rebuilt = rebuild_candidate(prefix, Path(directory) / "00408613-retained-wall.step")
        self.assertEqual(rebuilt["status"], "rebuilt")
        resolution = next(item for item in rebuilt["result"]["selector_resolution"] if item["feature_id"] == "f_F3")
        self.assertEqual(resolution["resolution_mode"], "kernel_lineage")
        self.assertEqual(resolution["record"]["kind"], "face")
        self.assertEqual(resolution["evidence"]["semantic_anchor"], {
            "type": "source_entity", "sketch_id": "F0", "entity_id": "E0.bottom",
        })

        from engine.cdsl_engine.runtime import analyze_cdsl
        from engine.cdsl_engine.semantic_validation import validate_semantic_cdsl

        self.assertTrue(validate_semantic_cdsl(prefix)["future_rebuild_ready"])
        self.assertTrue(analyze_cdsl(prefix).feature_results[-1].executable)

        tampered = deepcopy(prefix)
        tampered_reference = tampered["features"][-1]["params"]["end_condition"]["reference"]
        tampered_reference["selector_intent"]["source_entity"]["entity_id"] = "E1"
        with self.assertRaisesRegex(ValueError, "retained source prism SWEPT_FACE"):
            validate_semantic_cdsl(tampered)
        self.assertIn(
            "unsupported_retained_source_prism_swept_face_extent",
            [blocker.code for blocker in analyze_cdsl(tampered).feature_results[-1].blockers],
        )

        # E1 is an original circle but not part of F1's selected IMPRINT
        # region. A query change must not recover it by geometry or owner.
        rejected = lower_model(parse_featurescript(source.replace(
            'sQuery(id+"F0.wireOp",EDGE,"E0.bottom")])]});\n            extrude(context, id + "F3"',
            'sQuery(id+"F0.wireOp",EDGE,"E1")] )]});\n            extrude(context, id + "F3"',
        ), "00408613-unselected-circle"), {})
        self.assertNotIn("f_F3", {item["id"] for item in rejected.cdsl["features"]})
        self.assertIn(("F3", "extrude_extent_face_selector"), {
            (item.get("feature_id"), item.get("capability")) for item in rejected.diagnostics
        })

    def test_shell_mutated_swept_body_cannot_be_reused_as_an_up_to_body_target(self):
        """A historical prism body is not an active-body fallback after shell."""
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        source_path = root / "featurescript_rp/0041/00415457.txt"
        if not source_path.exists():
            self.skipTest("CADFS sample is not installed")

        result = lower_model(parse_featurescript(source_path.read_text(encoding="utf-8"), "00415457"), {})
        self.assertEqual(result.status, "converted_partial")
        self.assertNotIn("f_F5", {feature["id"] for feature in result.cdsl["features"]})
        self.assertIn({
            "code": "unsupported_engine_capability",
            "capability": "extrude_extent_body_selector",
            "feature_id": "F5",
            "operation": "extrude",
            "message": "current CDSL body extent requires a complete/proven active selector reference",
        }, result.diagnostics)

        with tempfile.TemporaryDirectory() as directory:
            rebuilt = rebuild_candidate(result.cdsl, Path(directory) / "00415457-shell-body-boundary.step")
        self.assertEqual(rebuilt["status"], "rebuilt")
        self.assertEqual(
            [item["feature_id"] for item in rebuilt["result"]["feature_results"]],
            ["f_F1", "f_F2", "f_F3", "f_F7"],
        )

    def test_mirrored_copy_cap_face_uses_the_mirrored_loft_frame(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0061/00612529.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")

        result = lower_model(parse_featurescript(feature.read_text(), "00612529"), {})
        sketch = next(item for item in result.cdsl["geometry"]["sketches"] if item["id"] == "sketch_F6")
        plane = sketch["workplane"]

        self.assertEqual(plane["origin_mm"], [0.0, 50.0, 0.0])
        self.assertEqual(plane["normal"], [0.0, 1.0, 0.0])
        self.assertEqual(plane["x_dir"], [-1.0, 0.0, 0.0])

        spline = sketch["profile"]["contours"][0]["segments"][0]
        first = spline["points"][0]
        self.assertEqual([
            plane["origin_mm"][index]
            + plane["x_dir"][index] * first[0]
            + (plane["normal"][(index + 1) % 3] * plane["x_dir"][(index + 2) % 3]
               - plane["normal"][(index + 2) % 3] * plane["x_dir"][(index + 1) % 3]) * first[1]
            for index in range(3)
        ], [-60.68, 50.0, 66.22])

    def test_line_angle_opposite_direction_preserves_the_sketch_side(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0092/00925274.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(feature.read_text(), "00925274"), {})
        sketch = next(item for item in result.cdsl["geometry"]["sketches"] if item["id"] == "sketch_F8")
        plane = sketch["workplane"]
        y_dir = [
            plane["normal"][1] * plane["x_dir"][2] - plane["normal"][2] * plane["x_dir"][1],
            plane["normal"][2] * plane["x_dir"][0] - plane["normal"][0] * plane["x_dir"][2],
            plane["normal"][0] * plane["x_dir"][1] - plane["normal"][1] * plane["x_dir"][0],
        ]
        center = sketch["profile"]["center"]
        self.assertAlmostEqual(plane["origin_mm"][2] + y_dir[2] * center[1], 25.0)

    def test_line_angle_cylinder_reference_uses_the_surface_generatrix(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0092/00925274.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(feature.read_text(), "00925274"), {})
        sketch = next(item for item in result.cdsl["geometry"]["sketches"] if item["id"] == "sketch_F5")
        plane = sketch["workplane"]
        self.assertAlmostEqual(plane["normal"][0], -0.5)
        self.assertAlmostEqual(plane["normal"][1], -math.sqrt(3) / 2)
        self.assertAlmostEqual(plane["origin_mm"][0], -12.15)
        self.assertAlmostEqual(plane["origin_mm"][1], -24.3 * math.sqrt(3) / 2)

    def test_line_angle_direct_circle_uses_the_featurescript_circle_axis(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0003/00030209.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(feature.read_text(), "00030209"), {})
        self.assertEqual(result.status, "converted_partial")
        planes = {
            item["id"]: item["params"]["plane"]
            for item in result.cdsl["features"]
            if item["atomic_id"] == "reference_plane"
        }
        expected_centers = {
            "f_F1": [45.78, 0.0, 26.2],
            "f_F2": [13.9, 0.0, 26.5],
            "f_F4": [-17.08, 0.0, 23.46],
            "f_F5": [-44.4, 0.0, 19.8],
        }
        self.assertEqual(set(planes), set(expected_centers))
        for feature_id, center in expected_centers.items():
            with self.subTest(feature_id=feature_id):
                plane = planes[feature_id]
                self.assertEqual(plane["origin_mm"], center)
                self.assertEqual(plane["x_dir"], [0.0, -1.0, 0.0])
                self.assertAlmostEqual(plane["normal"][0], 1.0)
                self.assertAlmostEqual(plane["normal"][1], 0.0)
                self.assertAlmostEqual(plane["normal"][2], 0.0)
        self.assertFalse(any(
            diagnostic.get("operation") == "cPlane"
            for diagnostic in result.diagnostics
        ))

        opposite_source = feature.read_text().replace(
            '"angle" : 90 * degree, "width"',
            '"angle" : 90 * degree, "oppositeDirection" : true, "width"',
            1,
        )
        opposite = lower_model(parse_featurescript(opposite_source, "line-angle-circle-opposite"), {})
        opposite_plane = next(
            item for item in opposite.cdsl["features"] if item["id"] == "f_F1"
        )["params"]["plane"]
        self.assertAlmostEqual(opposite_plane["normal"][0], -1.0)
        self.assertAlmostEqual(opposite_plane["normal"][1], 0.0)
        self.assertAlmostEqual(opposite_plane["normal"][2], 0.0)

    def test_line_angle_two_entities_follow_axis_plane_order_and_swap_rules(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        cases = {
            # F8 selects Right plane first, then the direct F7 line. The
            # standard library must swap them before calculating the frame.
            "00298026": ("f_F8", [0.0, -1.0, 0.0], [0.43837114678907757, 0.0, -0.898794046299167]),
            # F1 supplies the direct line first and the default plane second.
            "00586156": ("f_F1", [0.0, 0.0, 1.0], [-math.sqrt(0.5), -math.sqrt(0.5), 0.0]),
        }
        for sample_id, (feature_id, expected_x, expected_normal) in cases.items():
            with self.subTest(sample_id=sample_id):
                source = root / "featurescript_rp" / sample_id[:4] / f"{sample_id}.txt"
                result = lower_model(parse_featurescript(source.read_text(), sample_id), {})
                plane = next(item for item in result.cdsl["features"] if item["id"] == feature_id)["params"]["plane"]
                self.assertEqual(plane["x_dir"], expected_x)
                for actual, expected in zip(plane["normal"], expected_normal):
                    self.assertAlmostEqual(actual, expected)
                self.assertFalse(any(
                    diagnostic.get("operation") == "cPlane"
                    and diagnostic.get("feature_id") == feature_id.removeprefix("f_")
                    for diagnostic in result.diagnostics
                ))

    def test_line_angle_q_body_type_source_wires_keep_one_construction_axis_per_sketch(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0050/00506444.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(feature.read_text(), "00506444"), {})

        self.assertEqual(result.status, "converted_complete")
        self.assertTrue(any(
            item["id"] == "f_F6" and item["atomic_id"] == "reference_plane"
            for item in result.cdsl["features"]
        ))
        self.assertTrue(any(
            item["id"] == "f_F8" and item["atomic_id"] == "extrude_add_blind"
            for item in result.cdsl["features"]
        ))
        self.assertFalse(any(
            diagnostic.get("feature_id") == "F6" and diagnostic.get("operation") == "cPlane"
            for diagnostic in result.diagnostics
        ))
        with tempfile.TemporaryDirectory() as directory:
            rebuilt = rebuild_candidate(result.cdsl, Path(directory) / "wire-axis.step")
        self.assertEqual(rebuilt["status"], "rebuilt")

    def test_line_angle_two_direct_entities_cover_axis_point_and_degenerate_contracts(self):
        result = lower_model(parse_featurescript(LINE_ANGLE_TWO_ENTITY_SOURCE, "line-angle-two-entities"), {})
        self.assertEqual(result.status, "converted_partial")
        planes = {
            item["id"]: item["params"]["plane"]
            for item in result.cdsl["features"]
            if item["atomic_id"] == "reference_plane"
        }
        # Nonparallel axes, parallel offset axes, and an axis plus a direct
        # point each use the exact source direction, rather than a sketch
        # workplane frame.
        for feature_id in ("f_F1", "f_F2", "f_F3"):
            self.assertEqual(planes[feature_id]["x_dir"], [1.0, 0.0, 0.0])
            self.assertEqual(planes[feature_id]["normal"], [0.0, 0.0, 1.0])
        # A point selected before its axis triggers FeatureScript's swap. The
        # signed angle also follows oppositeDirection.
        self.assertEqual(planes["f_F4"]["x_dir"], [1.0, 0.0, 0.0])
        self.assertAlmostEqual(planes["f_F4"]["normal"][0], 0.0)
        self.assertAlmostEqual(planes["f_F4"]["normal"][1], 1.0)
        self.assertAlmostEqual(planes["f_F4"]["normal"][2], 0.0)
        # A cPlane output is represented as qCreatedBy(...planeOp, FACE),
        # not a sketch source. It is accepted only because F1 is an existing
        # reference-plane frame, and it supplies the true zero-angle side.
        self.assertEqual(planes["f_F6"]["x_dir"], [1.0, 0.0, 0.0])
        self.assertEqual(planes["f_F6"]["normal"], [0.0, 0.0, -1.0])
        self.assertIn({
            "code": "feature_deferred",
            "feature_id": "F5",
            "operation": "cPlane",
            "message": "line-angle reference selection is degenerate",
        }, result.diagnostics)

    def test_line_angle_direct_axis_refuses_a_topology_derived_query(self):
        direct = Call("sQuery", ["F0.wireOp", "EDGE", "E0"], 1)
        derived = Call("makeQuery", [
            "F1.opExtrude", "CAP_EDGE", "EDGE",
            {"derivedFrom": direct, "isStart": False},
        ], 2)
        sketch_by_source = {"F0": {"workplane": {
            "origin_mm": [0.0, 0.0, 0.0], "x_dir": [1.0, 0.0, 0.0], "normal": [0.0, 0.0, 1.0],
        }}}
        entity_by_sketch = {"F0": {"E0": {
            "type": "line", "start": [0.0, 0.0], "end": [10.0, 0.0], "source_entity_id": "E0",
        }}}
        self.assertIsNotNone(_direct_line_angle_axis(direct, sketch_by_source, entity_by_sketch))
        self.assertIsNone(_direct_line_angle_axis(derived, sketch_by_source, entity_by_sketch))

    def test_line_angle_direct_prism_swept_edge_is_a_source_datum_axis(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        cases = {
            # One axis-only plane and one axis-plus-default-plane form.  Both
            # source OSDs name the unique profile vertex that the immediately
            # preceding unchanged direct prism sweeps along its blind span.
            "00040198": "f_F2",
            "00722278": "f_F2",
        }
        for sample_id, feature_id in cases.items():
            with self.subTest(sample_id=sample_id):
                source = root / "featurescript_rp" / sample_id[:4] / f"{sample_id}.txt"
                result = lower_model(parse_featurescript(source.read_text(), sample_id), {})
                self.assertEqual(result.status, "converted_complete")
                plane_feature = next(item for item in result.cdsl["features"] if item["id"] == feature_id)
                self.assertEqual(plane_feature["atomic_id"], "reference_plane")
                self.assertFalse(any(
                    diagnostic.get("feature_id") == "F2" and diagnostic.get("operation") == "cPlane"
                    for diagnostic in result.diagnostics
                ))
                self.assertNotIn("selectors", plane_feature)
                with tempfile.TemporaryDirectory() as directory:
                    rebuilt = rebuild_candidate(result.cdsl, Path(directory) / f"{sample_id}.step")
                self.assertEqual(rebuilt["status"], "rebuilt")

        # An immediate derived face alongside the SWEPT_EDGE is not an
        # explicit datum reference plane. It must not inherit this axis-only
        # contract merely because the prism itself is otherwise direct.
        source = root / "featurescript_rp/0064/00644299.txt"
        deferred = lower_model(parse_featurescript(source.read_text(), "00644299"), {})
        self.assertIn({
            "code": "feature_deferred",
            "feature_id": "F2",
            "operation": "cPlane",
            "message": "line-angle reference selection is unsupported",
        }, deferred.diagnostics)

    def test_line_angle_direct_axis_refuses_a_query_wrapper_and_keeps_the_prefix(self):
        direct = Call("sQuery", ["F0.wireOp", "EDGE", "E0"], 1)
        wrapped = Call("qAdjacent", [direct, "VERTEX", "EDGE"], 2)
        sketch_by_source = {"F0": {"workplane": {
            "origin_mm": [0.0, 0.0, 0.0], "x_dir": [1.0, 0.0, 0.0], "normal": [0.0, 0.0, 1.0],
        }}}
        entity_by_sketch = {"F0": {"E0": {
            "type": "line", "start": [0.0, 0.0], "end": [10.0, 0.0], "source_entity_id": "E0",
        }}}
        self.assertIsNone(_direct_line_angle_axis(wrapped, sketch_by_source, entity_by_sketch))

        model = parse_featurescript(LINE_ANGLE_TWO_ENTITY_SOURCE, "line-angle-wrapped-axis")
        plane = next(item for item in model.features if item.feature_id == "F1")
        plane.params["entities"].args[0][0] = wrapped
        result = lower_model(model, {})
        self.assertIn({
            "code": "feature_deferred",
            "feature_id": "F1",
            "operation": "cPlane",
            "message": "line-angle reference selection is unsupported",
        }, result.diagnostics)
        self.assertIn("f_F2", {item["id"] for item in result.cdsl["features"]})

    def test_line_angle_rejects_a_circle_center_vertex_as_an_axis(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0003/00030209.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        source = feature.read_text().replace(
            'Q0=sQuery(id+"F0.wireOp",EDGE,"E0");',
            'Q0=sQuery(id+"F0.wireOp",VERTEX,"E0.center");',
            1,
        )
        result = lower_model(parse_featurescript(source, "line-angle-circle-center"), {})
        self.assertIn({
            "code": "feature_deferred",
            "feature_id": "F1",
            "operation": "cPlane",
            "message": "line-angle reference selection is unsupported",
        }, result.diagnostics)

    def test_open_nonconstruction_geometry_is_preserved_as_reference(self):
        source = SOURCE.replace('skSolve(sketch);', 'skLineSegment(sketch, "open", {"start":v(0, 0) * mm, "end":v(20, 0) * mm}); skSolve(sketch);', 1)
        result = lower_model(parse_featurescript(source, "open-profile"), {})
        self.assertEqual(result.status, "converted_complete")
        profile = result.cdsl["geometry"]["sketches"][0]["profile"]
        self.assertEqual(profile["type"], "analytic_contours")
        self.assertEqual(profile["construction"][0]["type"], "line")

    def test_open_imprint_profiles_and_mixed_sketch_context_lower_for_00789939(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0078/00789939.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(feature.read_text(), "00789939"), {})

        features = {item["id"]: item for item in result.cdsl["features"]}
        sketches = {item["id"]: item for item in result.cdsl["geometry"]["sketches"]}
        self.assertEqual(features["f_F8"]["sketch_id"], "sketch_F7__f_F8")
        self.assertEqual(features["f_F10"]["sketch_id"], "sketch_F9__f_F10")
        self.assertEqual(features["f_F12"]["sketch_id"], "sketch_F11")
        self.assertFalse(sketches["sketch_F7__f_F8"]["profile"]["contours"][0]["closed"])
        self.assertEqual(sketches["sketch_F7__f_F8"]["workplane"]["origin_mm"], [45.7, 0.0, 0.0])
        self.assertEqual(sketches["sketch_F9__f_F10"]["workplane"]["origin_mm"], [-44.3, -0.0, -0.0])
        self.assertEqual(sketches["sketch_F7__f_F8"]["workplane"]["normal"], [1.0, -0.0, -0.0])
        self.assertEqual(sketches["sketch_F9__f_F10"]["workplane"]["normal"], [-1.0, -0.0, -0.0])
        self.assertEqual(sketches["sketch_F9__f_F10"]["workplane"]["x_dir"], [-0.0, -1.0, -0.0])

    def test_offset_face_profile_is_the_proven_linear_extrusion_wall(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0078/00789939.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(feature.read_text(), "00789939"), {})

        features = {item["id"]: item for item in result.cdsl["features"]}
        sketches = {item["id"]: item for item in result.cdsl["geometry"]["sketches"]}
        self.assertEqual(features["f_F15"]["sketch_id"], "sketch_F5__f_F15")
        sketch = sketches["sketch_F5__f_F15"]
        self.assertEqual(sketch["workplane"]["origin_mm"], [-0.0, 52.19, -0.0])
        self.assertEqual(sketch["workplane"]["normal"], [0.0, -1.0, 0.0])
        points = {
            tuple(round(component, 6) for component in endpoint)
            for segment in sketch["profile"]["contours"][0]["segments"]
            for endpoint in (segment["start"], segment["end"])
        }
        self.assertEqual(points, {(-45.0, 2.5), (45.0, 2.5), (45.0, 6.0), (-45.0, 6.0)})

    def test_offset_face_profile_defers_when_query_has_multiple_source_edges(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0078/00789939.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        source = feature.read_text(encoding="utf-8").replace(
            'Q0=makeQuery(id+"F5.opShell","OFFSET_FACE",FACE,{"disambiguationData":[OSD([sQuery(id+"F3.wireOp",EDGE,"E1.bottom")])]});',
            'Q0=makeQuery(id+"F5.opShell","OFFSET_FACE",FACE,{"disambiguationData":[OSD([sQuery(id+"F3.wireOp",EDGE,"E1.bottom"),sQuery(id+"F3.wireOp",EDGE,"E1.top")])]});',
            1,
        )
        result = lower_model(parse_featurescript(source, "00789939-offset-face-multi-source"), {})

        self.assertNotIn("f_F15", {item["id"] for item in result.cdsl["features"]})
        diagnostic = next(item for item in result.diagnostics if item.get("feature_id") == "F15")
        self.assertEqual(diagnostic["capability"], "extrude_profile_topology:offset_face")

    def test_offset_face_profile_uses_the_retained_direct_shell_contract(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0058/00588094.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(feature.read_text(), "00588094"), {})

        profile = next(item for item in result.cdsl["features"] if item["id"] == "f_F14")
        selector = profile["selectors"][0]
        self.assertEqual(profile["atomic_id"], "extrude_from_face")
        self.assertEqual(selector["owner_feature_id"], "f_F13")
        self.assertEqual(selector["output_role"], "shell.offset_face")
        self.assertEqual(selector["output_role_source"], {
            "owner_feature_id": "f_F12", "output_role": "extrude.start",
        })
        self.assertFalse(any(item.get("feature_id") == "F14" for item in result.diagnostics))

    def test_retained_direct_prism_shell_cap_offset_face_is_a_runtime_profile(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0071/00719927.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(feature.read_text(), "00719927"), {})

        self.assertEqual(result.status, "converted_complete")
        features = {item["id"]: item for item in result.cdsl["features"]}
        profile = features["f_F3"]
        self.assertEqual(profile["atomic_id"], "extrude_from_face")
        self.assertEqual(profile["params"]["result_mode"], "new_body")
        self.assertEqual(features["f_F4"]["params"]["source_feature_ids"], ["f_F2"])
        selector = profile["selectors"][0]
        self.assertEqual(selector["output_role"], "shell.offset_face")
        self.assertEqual(selector["output_role_source"], {
            "owner_feature_id": "f_F1", "output_role": "extrude.start",
        })
        self.assertEqual(
            selector["selector_intent"]["consumer_contract"],
            "shell_retained_direct_prism_cap_offset_face_profile",
        )

        from engine.cdsl_engine.runtime import rebuild_cdsl
        with tempfile.TemporaryDirectory() as directory:
            rebuilt = rebuild_cdsl(result.cdsl, Path(directory) / "retained-shell-cap.step")
        resolution = next(item for item in rebuilt["selector_resolution"] if item["feature_id"] == "f_F3")
        self.assertEqual(resolution["status"], "resolved")
        self.assertEqual(resolution["selected"]["owner_feature_ids"], ["f_F2"])
        self.assertEqual(resolution["selected"]["output_roles"], ["shell.offset_face"])
        self.assertEqual(
            resolution["selected"]["output_role_sources"],
            [{"output_role": "shell.offset_face", "owner_feature_id": "f_F1", "source_output_role": "extrude.start"}],
        )
        self.assertEqual([item["status"] for item in rebuilt["feature_results"]], ["executed"] * 4)

    def test_retained_shell_cap_offset_face_rejects_partial_source_profile(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0071/00719927.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        source = feature.read_text(encoding="utf-8").replace(
            'Q0=makeQuery(id+"F2.opShell","OFFSET_FACE",FACE,{"disambiguationData":[OSD([sQuery(id+"F0.wireOp",EDGE,"E0"),sQuery(id+"F0.wireOp",EDGE,"E1"),sQuery(id+"F0.wireOp",EDGE,"E2")])]});',
            'Q0=makeQuery(id+"F2.opShell","OFFSET_FACE",FACE,{"disambiguationData":[OSD([sQuery(id+"F0.wireOp",EDGE,"E0"),sQuery(id+"F0.wireOp",EDGE,"E1")])]} );',
            1,
        )
        result = lower_model(parse_featurescript(source, "00719927-partial-offset-profile"), {})

        self.assertNotIn("f_F3", {item["id"] for item in result.cdsl["features"]})
        diagnostic = next(item for item in result.diagnostics if item.get("feature_id") == "F3")
        self.assertEqual(diagnostic["capability"], "extrude_profile_topology:offset_face")

    def test_retained_shell_cap_offset_face_rejects_the_removed_cap_source(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0071/00719927.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(feature.read_text(), "00719927"), {})
        invalid = deepcopy(result.cdsl)
        invalid["features"][2]["selectors"][0]["output_role_source"]["output_role"] = "extrude.end"

        from engine.cdsl_engine.semantic_validation import validate_semantic_cdsl
        with self.assertRaisesRegex(ValueError, "immediate opposite direct-prism cap removal"):
            validate_semantic_cdsl(invalid)

    def test_offset_edge_tdd_uses_the_retained_direct_prism_cap_continuation(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0065/00650671.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(feature.read_text(), "00650671"), {})

        self.assertEqual(result.status, "converted_complete")
        chamfer = next(item for item in result.cdsl["features"] if item["id"] == "f_F3")
        selector = chamfer["selectors"][0]
        intent = selector["selector_intent"]
        self.assertEqual(selector["owner_feature_id"], "f_F1")
        self.assertEqual(intent["query_family"], "OFFSET_EDGE")
        self.assertEqual(intent["consumer_contract"], "direct_prism_shell_offset_edge_tdd")
        self.assertEqual(intent["lineage_role"], "extrude.start")
        self.assertEqual(intent["derivation_policy"], {
            "allowed": ["boundary", "continuation"], "multiplicity": "one",
        })
        self.assertEqual(intent["disambiguation"], {
            "type": "offset_edge_tdd_cap_continuation",
            "shell_feature_id": "f_F2",
            "outer_owner_feature_id": "f_F2",
            "tdd_cap_owner_feature_id": "f_F1",
            "tdd_cap_role": "extrude.start",
            "source_entity": {"sketch_id": "F0", "entity_id": "E0"},
        })

        with tempfile.TemporaryDirectory() as directory:
            rebuilt = rebuild_candidate(result.cdsl, Path(directory) / "offset-edge-tdd.step")
        self.assertEqual(rebuilt["status"], "rebuild_failed")
        self.assertEqual(rebuilt["last_executable_prefix"]["last_feature_id"], "f_F3")
        binding = next(item for item in rebuilt["selector_binding"] if item["feature_id"] == "f_F3")
        self.assertEqual(binding["resolved"][0]["record_id"], "body:f_F2:edge:1")
        self.assertEqual(binding["resolved"][0]["output_roles"], ["extrude.start"])

    def test_offset_edge_tdd_has_a_second_real_shell_consumer_and_rejects_mixed_set(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0076/00768679.txt"
        mixed_feature = root / "featurescript_rp/0079/00791920.txt"
        if not feature.exists() or not mixed_feature.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(feature.read_text(), "00768679"), {})
        chamfer = next(item for item in result.cdsl["features"] if item["id"] == "f_F8")
        selector = chamfer["selectors"][0]
        self.assertEqual(selector["selector_intent"]["consumer_contract"], "direct_prism_shell_offset_edge_tdd")
        with tempfile.TemporaryDirectory() as directory:
            rebuilt = rebuild_candidate(result.cdsl, Path(directory) / "offset-edge-tdd-second.step")
        self.assertEqual(rebuilt["status"], "rebuilt")
        binding = next(item for item in rebuilt["selector_binding"] if item["feature_id"] == "f_F8")
        self.assertEqual(binding["resolved"][0]["record_id"], "body:f_F7:1:edge:1")

        mixed = lower_model(parse_featurescript(mixed_feature.read_text(), "00791920"), {})
        fillet = next(item for item in mixed.cdsl["features"] if item["id"] == "f_F3")
        contracts = [
            (item.get("selector_intent") or {}).get("consumer_contract")
            for item in fillet["selectors"]
        ]
        self.assertIn("direct_prism_shell_offset_edge_tdd", contracts)
        self.assertIn(None, contracts)
        with tempfile.TemporaryDirectory() as directory:
            rebuilt = rebuild_candidate(mixed.cdsl, Path(directory) / "offset-edge-tdd-mixed.step")
        self.assertEqual(rebuilt["status"], "rebuild_failed")
        self.assertIn("selector_query_unsupported", rebuilt["error"]["message"])

    def test_offset_edge_vertex_uses_the_direct_prism_swept_edge_continuation(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0005/00059593.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(feature.read_text(), "00059593"), {})

        self.assertEqual(result.status, "converted_complete")
        fillet = next(item for item in result.cdsl["features"] if item["id"] == "f_F3")
        operands = fillet["selectors"][0]["query_operands"]
        vertex_selectors = [
            item for item in operands
            if (item.get("selector_intent") or {}).get("consumer_contract")
            == "direct_prism_shell_offset_edge_vertex"
        ]
        self.assertEqual(len(vertex_selectors), 4)
        for selector in vertex_selectors:
            intent = selector["selector_intent"]
            self.assertEqual(intent["query_family"], "OFFSET_EDGE")
            self.assertNotIn("source_entity", intent)
            self.assertEqual(len(intent["source_entities"]), 2)
            self.assertEqual(intent["derivation_policy"], {
                "allowed": ["boundary", "continuation"], "multiplicity": "one",
            })
            self.assertEqual(intent["disambiguation"]["type"], "offset_edge_vertex_continuation")

        with tempfile.TemporaryDirectory() as directory:
            rebuilt = rebuild_candidate(result.cdsl, Path(directory) / "offset-edge-vertex.step")
        self.assertEqual(rebuilt["status"], "rebuilt")
        binding = next(item for item in rebuilt["selector_binding"] if item["feature_id"] == "f_F3")
        self.assertEqual(len(binding["resolved"]), 8)
        self.assertTrue(all(item["record_id"].startswith("body:f_F2:edge:") for item in binding["resolved"]))

    def test_offset_edge_vertex_rejects_mixed_osd_and_tdd_set(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0079/00791920.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(feature.read_text(), "00791920"), {})
        fillet = next(item for item in result.cdsl["features"] if item["id"] == "f_F3")
        contracts = [(item.get("selector_intent") or {}).get("consumer_contract") for item in fillet["selectors"]]
        self.assertIn("direct_prism_shell_offset_edge_tdd", contracts)
        self.assertIn(None, contracts)
        self.assertNotIn("direct_prism_shell_offset_edge_vertex", contracts)
        with tempfile.TemporaryDirectory() as directory:
            rebuilt = rebuild_candidate(result.cdsl, Path(directory) / "offset-edge-vertex-mixed.step")
        self.assertEqual(rebuilt["status"], "rebuild_failed")
        self.assertIn("selector_query_unsupported", rebuilt["error"]["message"])

    def test_offset_edge_swept_edge_tdd_does_not_reuse_the_direct_prism_contracts(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0023/00239888.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(feature.read_text(), "00239888"), {})

        # Its OFFSET_EDGE uses TDD(SWEPT_EDGE), but the producer is an
        # IMPRINT profile and the shell follows a fillet. It cannot inherit
        # either the retained CAP_EDGE or immediate source-vertex contract.
        self.assertEqual(result.status, "converted_partial")
        self.assertNotIn("f_F6", {item["id"] for item in result.cdsl["features"]})
        diagnostic = next(item for item in result.diagnostics if item.get("feature_id") == "F6")
        # The IMPRINT producer F3 is absent from the executable prefix, so
        # owner availability must reject the downstream selector before its
        # TDD(SWEPT_EDGE) source form could be considered.
        self.assertEqual(diagnostic["capability"], "selector_owner_unavailable")
        self.assertEqual(diagnostic["message"], "selector owner F3 has no executable CDSL producer")

    def test_offset_edge_vertex_semantic_validation_rejects_a_mismatched_shell(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0005/00059593.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(feature.read_text(), "00059593"), {})
        invalid = deepcopy(result.cdsl)
        selector = next(
            item for item in invalid["features"]
            if item["id"] == "f_F3"
        )["selectors"][0]["query_operands"][8]
        selector["selector_intent"]["disambiguation"]["removed_cap_role"] = "extrude.start"

        from engine.cdsl_engine.semantic_validation import validate_semantic_cdsl
        with self.assertRaisesRegex(ValueError, "OFFSET_EDGE vertex requires"):
            validate_semantic_cdsl(invalid)

        from engine.cdsl_engine.capabilities import CapabilityAnalyzer
        from engine.cdsl_engine.registry import EXECUTORS
        from engine.cdsl_engine.sketch_solver import CORE_SHAPE_GENERATORS
        analysis = CapabilityAnalyzer(
            atomic_ids=EXECUTORS, profile_types=CORE_SHAPE_GENERATORS,
        ).analyze(invalid)
        f3 = next(item for item in analysis.feature_results if item.feature_id == "f_F3")
        self.assertIn(
            "unsupported_offset_edge_vertex_selector",
            [blocker.code for blocker in f3.blockers],
        )

    def test_offset_edge_tdd_semantic_validation_rejects_a_mismatched_shell(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0065/00650671.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(feature.read_text(), "00650671"), {})
        invalid = deepcopy(result.cdsl)
        selector = next(item for item in invalid["features"] if item["id"] == "f_F3")["selectors"][0]
        selector["selector_intent"]["disambiguation"]["shell_feature_id"] = "f_F1"

        from engine.cdsl_engine.semantic_validation import validate_semantic_cdsl
        with self.assertRaisesRegex(ValueError, "OFFSET_EDGE TDD requires"):
            validate_semantic_cdsl(invalid)

    def test_circular_pattern_uses_the_active_typed_add_successor(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0054/00542223.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(feature.read_text(), "00542223"), {})

        features = {item["id"]: item for item in result.cdsl["features"]}
        # F5 fuses into F1 and becomes the active member. The circular
        # pattern must use that member instead of reviving stale F1.
        self.assertNotIn("result_mode", features["f_F5"]["params"])
        self.assertEqual(features["f_F6"]["params"]["source_feature_ids"], ["f_F5"])

    def test_circular_copy_boolean_uses_the_proven_fused_body_successor(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0025/00253824.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(feature.read_text(), "00253824"), {})

        features = {item["id"]: item for item in result.cdsl["features"]}
        # F7 attaches to an outer MERGE(FACE), not directly to F4's nested
        # CAP_FACE. The selector has no active provenance contract for that
        # merge result, so preserving F1--F6 is preferable to materializing
        # an unproven static workplane for F7/F8.
        self.assertEqual(result.status, "converted_partial")
        # F4 uses typed ADD and therefore fuses into the active member. F5
        # and the targetless union must consume that active successor.
        self.assertNotIn("result_mode", features["f_F4"]["params"])
        self.assertEqual(features["f_F5"]["params"]["source_feature_ids"], ["f_F4"])
        self.assertEqual(features["f_F6"]["params"], {
            "operation": "union",
            "keep_tools": False,
            "targetless_body_set": True,
            "target_feature_ids": ["f_F4"],
            "tool_pattern_instance_refs": [
                {"pattern_feature_id": "f_F5", "source_feature_id": "f_F4", "instance_index": 2},
                {"pattern_feature_id": "f_F5", "source_feature_id": "f_F4", "instance_index": 1},
            ],
        })
        self.assertNotIn("f_F7", features)
        self.assertNotIn("f_F8", features)
        self.assertIn({
            "code": "sketch_deferred",
            "feature_id": "F7",
            "message": "MERGE(FACE) workplane requires a dedicated complete/proven runtime face relation",
        }, result.diagnostics)

    def test_merge_face_workplane_never_reuses_a_nested_swept_face_frame(self):
        """Outer MERGE faces must not inherit one derived SWEPT_FACE plane."""
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        cases = {
            "00013930": ("0001", "F7", "f_F7"),
            "00020631": ("0002", "F4", "f_F4"),
            "00036155": ("0003", "F5", "f_F5"),
        }
        for sample_id, (shard, sketch_id, dependent_feature) in cases.items():
            with self.subTest(sample_id=sample_id):
                feature = root / f"featurescript_rp/{shard}/{sample_id}.txt"
                if not feature.exists():
                    self.skipTest("CADFS sample is not installed")
                result = lower_model(parse_featurescript(feature.read_text(encoding="utf-8"), sample_id), {})
                features = {item["id"] for item in result.cdsl["features"]}
                self.assertEqual(result.status, "converted_partial")
                self.assertNotIn(dependent_feature, features)
                self.assertIn({
                    "code": "sketch_deferred",
                    "feature_id": sketch_id,
                    "message": "MERGE(FACE) workplane requires a dedicated complete/proven runtime face relation",
                }, result.diagnostics)

    def test_boolean_uses_source_qualified_multi_source_transform_copies(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0069/00699847.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        source = feature.read_text(encoding="utf-8")
        # This is a source-history contract variant, not a source STEP
        # comparison: F3 is the real history's two-source makeCopy output.
        boolean = '''        {
            var Q0;
            Q0=makeQuery(id+"F3.opPattern","COPY",BODY,{"derivedFrom":makeQuery(id+"F1.opExtrude","SWEPT_BODY",BODY,{"disambiguationData":[OSD([sQuery(id+"F0.wireOp",EDGE,"E0.bottom"),sQuery(id+"F0.wireOp",EDGE,"E0.top"),sQuery(id+"F0.wireOp",EDGE,"E0.left"),sQuery(id+"F0.wireOp",EDGE,"E0.right")])]}),"instanceName":"1"});
            var Q1;
            Q1=makeQuery(id+"F3.opPattern","COPY",BODY,{"derivedFrom":makeQuery(id+"F2.opPattern","COPY",BODY,{"derivedFrom":makeQuery(id+"F1.opExtrude","SWEPT_BODY",BODY,{"disambiguationData":[OSD([sQuery(id+"F0.wireOp",EDGE,"E0.bottom"),sQuery(id+"F0.wireOp",EDGE,"E0.top"),sQuery(id+"F0.wireOp",EDGE,"E0.left"),sQuery(id+"F0.wireOp",EDGE,"E0.right")])]}),"instanceName":"1"}),"instanceName":"1"});
            booleanBodies(context, id + "F5", {"operationType" : BooleanOperationType.UNION, "targets" : qUnion([Q0]), "tools" : qUnion([Q1])});
        }
'''
        source = source.rsplit("    });", 1)[0] + boolean + "    });"
        result = lower_model(parse_featurescript(source, "00699847-copy-boolean-contract"), {})

        self.assertEqual(result.status, "converted_complete")
        feature = next(item for item in result.cdsl["features"] if item["id"] == "f_F5")
        self.assertEqual(feature["params"], {
            "operation": "union", "keep_tools": False,
            "target_transform_copy_refs": [{"transform_feature_id": "f_F3", "source_feature_id": "f_F1"}],
            "tool_transform_copy_refs": [{"transform_feature_id": "f_F3", "source_feature_id": "f_F2"}],
        })
        with tempfile.TemporaryDirectory() as directory:
            rebuilt = rebuild_candidate(result.cdsl, Path(directory) / "copy-boolean-contract.step")
        self.assertEqual(rebuilt["status"], "rebuilt")
        self.assertEqual([item["feature_id"] for item in rebuilt["result"]["feature_results"]], [
            "f_F1", "f_F2", "f_F3", "f_F4", "f_F5",
        ])

    def test_shared_sketch_edge_produces_each_bounded_region(self):
        segments = [
            {"type": "line", "start": [0, 0], "end": [1, 0]},
            {"type": "line", "start": [1, 0], "end": [2, 0]},
            {"type": "line", "start": [2, 0], "end": [2, 1]},
            {"type": "line", "start": [2, 1], "end": [1, 1]},
            {"type": "line", "start": [1, 1], "end": [0, 1]},
            {"type": "line", "start": [0, 1], "end": [0, 0]},
            {"type": "line", "start": [1, 0], "end": [1, 1]},
        ]
        contours, construction = _contours(segments)
        self.assertEqual(len(contours), 2)
        self.assertFalse(construction)
        self.assertEqual(sorted(len(item["segments"]) for item in contours), [4, 4])

    def test_vertex_on_long_line_is_split_before_region_extraction(self):
        segments = [
            {"type": "line", "start": [0, 0], "end": [2, 0]},
            {"type": "line", "start": [2, 0], "end": [2, 2]},
            {"type": "line", "start": [2, 2], "end": [0, 2]},
            {"type": "line", "start": [0, 2], "end": [0, 0]},
            {"type": "line", "start": [2, 0.5], "end": [3, 0.5]},
            {"type": "line", "start": [3, 0.5], "end": [3, 1.5]},
            {"type": "line", "start": [3, 1.5], "end": [2, 1.5]},
        ]
        contours, construction = _contours(segments)
        self.assertEqual(len(contours), 2)
        self.assertFalse(construction)

    def test_surface_operation_on_a_closed_region_lowers_to_a_solid_revolve(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0095/00957738.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(feature.read_text(), "00957738"), {})
        self.assertEqual(result.status, "converted_complete")
        feature = next(item for item in result.cdsl["features"] if item["id"] == "f_F2")
        self.assertEqual(feature["atomic_id"], "revolve_add")
        self.assertNotIn("result_mode", feature["params"])

    def test_explicit_surface_body_lowers_to_the_surface_revolve_contract(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0078/00784880.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(feature.read_text(), "00784880"), {})
        self.assertEqual(result.status, "converted_complete")
        feature = next(item for item in result.cdsl["features"] if item["id"] == "f_F3")
        self.assertEqual(feature["atomic_id"], "revolve_surface")
        self.assertNotIn("result_mode", feature["params"])

    def test_mixed_extrude_lowers_selected_circular_surface_wires(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0071/00710855.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(feature.read_text(), "00710855"), {})

        self.assertEqual(result.status, "converted_complete")
        features = {item["id"]: item for item in result.cdsl["features"]}
        self.assertEqual(features["f_F1_surface"]["atomic_id"], "extrude_surface")
        self.assertEqual(features["f_F1_surface"]["params"], {
            "distance_mm": 63.5,
            "reverse": False,
            "reverse_distance_mm": 63.5,
        })
        self.assertEqual(features["f_F5_surface"]["atomic_id"], "extrude_surface")
        sketches = {item["id"]: item for item in result.cdsl["geometry"]["sketches"]}
        radii = [
            contour["segments"][0]["radius_mm"]
            for contour in sketches["sketch_F0__f_F1_surface"]["profile"]["contours"]
        ]
        self.assertEqual(radii, [19.0, 16.0])
        profile = sketches[features["f_F5"]["sketch_id"]]["profile"]
        self.assertEqual(profile["type"], "analytic_contours")
        self.assertEqual(
            [(item["role"], item["segments"][0]["radius_mm"]) for item in profile["contours"]],
            [("outer", 25.5), ("inner", 19.0)],
        )

    def test_mixed_extrude_preserves_prefix_when_cap_edge_chamfer_query_is_deferred(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0071/00710855.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(feature.read_text(), "00710855"), {})

        with tempfile.TemporaryDirectory() as tmp:
            from cadfs_to_cdsl.rebuild import rebuild_candidate
            rebuilt = rebuild_candidate(result.cdsl, Path(tmp) / "rebuilt.step")

        self.assertEqual(rebuilt["status"], "rebuild_failed")
        self.assertEqual(rebuilt["error"]["message"], "f_F10: selector_query_unsupported during incremental replay")
        self.assertEqual(rebuilt["last_executable_prefix"]["failed_feature_id"], "f_F10")
        self.assertEqual(rebuilt["last_executable_prefix"]["last_feature_id"], "f_F9")

    def test_pure_surface_extrude_lowers_one_direct_open_line_without_creating_a_body(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0067/00677236.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(feature.read_text(), "00677236"), {})

        self.assertEqual(result.status, "converted_complete")
        first = next(item for item in result.cdsl["features"] if item["id"] == "f_F1")
        self.assertEqual(first["atomic_id"], "extrude_surface")
        sketch = next(item for item in result.cdsl["geometry"]["sketches"] if item["id"] == first["sketch_id"])
        self.assertEqual(sketch["profile"]["contours"], [{
            "role": "open", "closed": False, "surface_wire": True,
            "segments": [{
                "type": "line", "start": [-1012.95, 885.86],
                "end": [-1012.95, -974.14], "source_entity_id": "E0.left",
            }],
        }])

        prefix = deepcopy(result.cdsl)
        prefix["features"] = [first]
        with tempfile.TemporaryDirectory() as directory:
            from cadfs_to_cdsl.rebuild import rebuild_candidate
            rebuilt = rebuild_candidate(prefix, Path(directory) / "pure-surface-line.step")
        self.assertEqual(rebuilt["status"], "rebuilt")
        self.assertEqual(rebuilt["result"]["solid_count"], 0)
        self.assertEqual(rebuilt["result"]["surface_count"], 1)

    def test_pure_surface_extrude_lowers_multiple_direct_open_line_wires(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0041/00414424.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(feature.read_text(), "00414424"), {})

        self.assertEqual(result.status, "converted_complete")
        features = {item["id"]: item for item in result.cdsl["features"]}
        sketches = {item["id"]: item for item in result.cdsl["geometry"]["sketches"]}
        self.assertEqual({features[feature_id]["atomic_id"] for feature_id in ("f_F2", "f_F3", "f_F4")}, {"extrude_surface"})
        self.assertEqual(
            [[segment["source_entity_id"] for segment in contour["segments"]]
             for contour in sketches[features["f_F2"]["sketch_id"]]["profile"]["contours"]],
            [["E26", "E25", "E32"]],
        )
        self.assertEqual(
            [[segment["source_entity_id"] for segment in contour["segments"]]
             for contour in sketches[features["f_F3"]["sketch_id"]]["profile"]["contours"]],
            [["E27"], ["E31"]],
        )
        self.assertEqual(
            [[segment["source_entity_id"] for segment in contour["segments"]]
             for contour in sketches[features["f_F4"]["sketch_id"]]["profile"]["contours"]],
            [["E30", "E29", "E28"]],
        )
        with tempfile.TemporaryDirectory() as directory:
            rebuilt = rebuild_candidate(result.cdsl, Path(directory) / "multi-open-surface-wires.step")
        self.assertEqual(rebuilt["status"], "rebuilt")
        self.assertEqual(rebuilt["result"]["solid_count"], 0)
        self.assertEqual(rebuilt["result"]["surface_count"], 3)
        self.assertEqual(rebuilt["result"]["surface_face_count"], 8)

    def test_pure_surface_extrude_lowers_a_second_real_multiline_open_wire(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0042/00424680.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(feature.read_text(), "00424680"), {})

        self.assertEqual(result.status, "converted_complete")
        surface = next(item for item in result.cdsl["features"] if item["id"] == "f_F1")
        self.assertEqual(surface["atomic_id"], "extrude_surface")
        sketch = next(item for item in result.cdsl["geometry"]["sketches"] if item["id"] == surface["sketch_id"])
        contours = sketch["profile"]["contours"]
        self.assertEqual(len(contours), 1)
        self.assertEqual(len(contours[0]["segments"]), 4)
        self.assertTrue(contours[0]["surface_wire"])
        with tempfile.TemporaryDirectory() as directory:
            rebuilt = rebuild_candidate(result.cdsl, Path(directory) / "second-multi-open-surface-wire.step")
        self.assertEqual(rebuilt["status"], "rebuilt")
        self.assertEqual(rebuilt["result"]["solid_count"], 0)
        self.assertEqual(rebuilt["result"]["surface_count"], 1)
        self.assertEqual(rebuilt["result"]["surface_face_count"], 4)

    def test_pure_surface_extrude_accepts_independent_add_and_symmetric_extent(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0059/00592110.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(feature.read_text(), "00592110"), {})

        surface = next(item for item in result.cdsl["features"] if item["id"] == "f_F3")
        self.assertEqual(surface["atomic_id"], "extrude_surface")
        self.assertEqual(surface["params"], {
            "distance_mm": 12.7, "reverse": False, "reverse_distance_mm": 12.7,
        })
        self.assertFalse([item for item in result.diagnostics if item.get("feature_id") == "F3"])

    def test_pure_surface_extrude_preserves_a_symmetric_direct_circle_shell(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0050/00509429.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(feature.read_text(), "00509429"), {})

        self.assertEqual(result.status, "converted_complete")
        surface = result.cdsl["features"][0]
        self.assertEqual(surface["atomic_id"], "extrude_surface")
        self.assertEqual(surface["params"], {
            "distance_mm": 228.6, "reverse": False, "reverse_distance_mm": 228.6,
        })
        with tempfile.TemporaryDirectory() as directory:
            from cadfs_to_cdsl.rebuild import rebuild_candidate
            rebuilt = rebuild_candidate(result.cdsl, Path(directory) / "pure-surface-circle.step")
        self.assertEqual(rebuilt["status"], "rebuilt")
        self.assertEqual(rebuilt["result"]["solid_count"], 0)
        self.assertEqual(rebuilt["result"]["surface_face_count"], 2)

    def test_pure_surface_extrude_rejects_remove_semantics(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0059/00595418.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(feature.read_text(), "00595418"), {})

        self.assertNotIn("f_F9", {item["id"] for item in result.cdsl["features"]})
        self.assertIn({
            "code": "unsupported_engine_capability",
            "capability": "extrude_surface_operation",
            "feature_id": "F9",
            "operation": "extrude",
            "message": "pure ToolBodyType.SURFACE extrusion supports only an independent ADD surface operation",
        }, result.diagnostics)

    def test_pure_surface_extrude_rejects_cross_sketch_source_wires(self):
        source_sketch = {
            "id": "sketch_F0", "name": "F0",
            "profile": {"type": "analytic_contours", "contours": []},
        }
        source_line = {"type": "line", "start": [0, 0], "end": [10, 0]}
        query = Call("qUnion", [[
            Call("sQuery", ["F0.wireOp", "EDGE", "E0"]),
            Call("sQuery", ["F1.wireOp", "EDGE", "E0"]),
        ]])

        with self.assertRaisesRegex(
            UnsupportedCapability,
            "surface extrude source wires must come from one source sketch",
        ):
            _surface_profile_selection_sketch(
                source_sketch, query, {"E0": source_line}, "f_surface", allow_open_wire=True,
            )

    def test_pure_surface_extrude_rejects_branched_or_closed_open_line_sets(self):
        source_sketch = {
            "id": "sketch_F0", "name": "F0",
            "profile": {"type": "analytic_contours", "contours": []},
        }
        def query(*entity_ids):
            return Call("qUnion", [[
                Call("sQuery", ["F0.wireOp", "EDGE", entity_id]) for entity_id in entity_ids
            ]])

        branched = {
            "E0": {"type": "line", "start": [0, 0], "end": [10, 0]},
            "E1": {"type": "line", "start": [0, 0], "end": [0, 10]},
            "E2": {"type": "line", "start": [0, 0], "end": [-10, 0]},
        }
        closed = {
            "E0": {"type": "line", "start": [0, 0], "end": [10, 0]},
            "E1": {"type": "line", "start": [10, 0], "end": [5, 10]},
            "E2": {"type": "line", "start": [5, 10], "end": [0, 0]},
        }
        for entities in (branched, closed):
            with self.assertRaisesRegex(UnsupportedCapability, "non-branching open chains"):
                _surface_profile_selection_sketch(
                    source_sketch, query(*entities), entities, "f_surface", allow_open_wire=True,
                )

    def test_fit_spline_loft_lowers_to_executable_loft_add(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0061/00612529.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(feature.read_text(), "00612529"), {})
        self.assertIsNotNone(result.cdsl)
        features = {item["id"]: item for item in result.cdsl["features"]}
        self.assertEqual(features["f_F3"]["atomic_id"], "loft_add")
        self.assertEqual(features["f_F3"]["params"]["profile_sketch_ids"], ["sketch_F2", "sketch_F0"])
        self.assertEqual(features["f_F4"]["atomic_id"], "pattern_mirror")
        self.assertEqual(features["f_F4"]["params"]["source_feature_ids"], ["f_F3"])
        sketches = {item["id"]: item for item in result.cdsl["geometry"]["sketches"]}
        self.assertEqual(sketches["sketch_F0"]["profile"]["contours"][0]["segments"][0]["type"], "bspline")
        self.assertNotIn("loft", {item.get("operation") for item in result.diagnostics})

    def test_fit_spline_loft_candidate_rebuilds(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0061/00612529.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(feature.read_text(), "00612529"), {})
        with tempfile.TemporaryDirectory() as tmp:
            from cadfs_to_cdsl.rebuild import rebuild_candidate
            rebuilt = rebuild_candidate(result.cdsl, Path(tmp) / "rebuilt.step")
            self.assertEqual(rebuilt["status"], "rebuilt")
            self.assertGreater(rebuilt["result"]["volume_mm3"], 0)

    def test_initial_direct_loft_shell_cap_uses_osd_profile_role_not_is_start(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        source_path = root / "featurescript_rp/0002/00023963.txt"
        if not source_path.exists(): self.skipTest("CADFS sample is not installed")
        source = source_path.read_text(encoding="utf-8")
        result = lower_model(parse_featurescript(source, "00023963"), {})

        self.assertEqual(result.status, "converted_complete")
        features = {item["id"]: item for item in result.cdsl["features"]}
        self.assertEqual(features["f_F3"]["params"], {
            "profile_sketch_ids": ["sketch_F0", "sketch_F2"],
            "initial_output_roles": True,
            "cap_output_profile_sources": ["F0", "F2"],
        })
        selector = features["f_F4"]["selectors"][0]
        # The source query says isStart:true but its OSD names F2, the second
        # loft input. The output role must follow that profile provenance.
        self.assertEqual(selector["output_role"], "loft.end")
        self.assertEqual(selector["selector_intent"]["disambiguation"], {
            "type": "loft_profile_source", "source_sketch_id": "F2",
        })
        with tempfile.TemporaryDirectory() as directory:
            rebuilt = rebuild_candidate(result.cdsl, Path(directory) / "loft-shell.step")
        self.assertEqual(rebuilt["status"], "rebuilt")
        resolution = next(item for item in rebuilt["result"]["selector_resolution"] if item["feature_id"] == "f_F4")
        self.assertEqual(resolution["resolution_mode"], "operation_role")
        self.assertEqual(resolution["selected"]["output_roles"], ["loft.end"])

        constrained = source.replace(
            '{"sheetProfilesArray"', '{"matchConnections" : true, "sheetProfilesArray"', 1,
        )
        deferred = lower_model(parse_featurescript(constrained, "loft-cap-constrained"), {})
        deferred_selector = next(item for item in deferred.cdsl["features"] if item["id"] == "f_F4")["selectors"][0]
        self.assertNotIn("initial_output_roles", next(item for item in deferred.cdsl["features"] if item["id"] == "f_F3")["params"])
        self.assertNotIn("output_role", deferred_selector)
        self.assertEqual(deferred_selector["selector_intent"]["evidence"], "feature_script_query")

        unsupported_version = source.replace("FeatureScript 1511;", "FeatureScript 1549;", 1).replace(
            'version : "1511.0"', 'version : "1549.0"', 2,
        )
        version_deferred = lower_model(parse_featurescript(unsupported_version, "loft-cap-1549"), {})
        version_loft = next(item for item in version_deferred.cdsl["features"] if item["id"] == "f_F3")
        version_selector = next(item for item in version_deferred.cdsl["features"] if item["id"] == "f_F4")["selectors"][0]
        self.assertNotIn("initial_output_roles", version_loft["params"])
        self.assertNotIn("output_role", version_selector)

    def test_initial_direct_sweep_shell_cap_requires_profile_and_path_endpoint_pair(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        source_path = root / "featurescript_rp/0033/00330012.txt"
        if not source_path.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(source_path.read_text(encoding="utf-8"), "00330012"), {})

        self.assertEqual(result.status, "converted_complete")
        features = {item["id"]: item for item in result.cdsl["features"]}
        self.assertEqual(features["f_F2"]["params"]["cap_output_contract"], {
            "profile_source": "F0", "profile_entity": "E0",
            "path_source": "F1", "path_entity": "E1", "path_reversed": False,
        })
        selector = features["f_F3"]["selectors"][0]
        self.assertNotIn("geometry", selector)
        self.assertNotIn("stable_id", selector)
        self.assertEqual(selector["output_role"], "sweep.end")
        self.assertEqual(selector["selector_intent"]["disambiguation"], {
            "type": "sweep_profile_path_endpoint",
            "profile_source": "F0", "profile_entity": "E0",
            "path_source": "F1", "path_entity": "E1", "path_reversed": False,
            "path_endpoint": "end",
        })
        with tempfile.TemporaryDirectory() as directory:
            rebuilt = rebuild_candidate(result.cdsl, Path(directory) / "sweep-shell.step")
        self.assertEqual(rebuilt["status"], "rebuilt")
        resolution = next(item for item in rebuilt["result"]["selector_resolution"] if item["feature_id"] == "f_F3")
        self.assertEqual(resolution["resolution_mode"], "operation_role")
        self.assertEqual(resolution["selected"]["output_roles"], ["sweep.end"])
        self.assertEqual(resolution["evidence"]["relations"][0]["operation"], "sweep")

        rejected_path = root / "featurescript_rp/0065/00658358.txt"
        if not rejected_path.exists(): self.skipTest("CADFS source-pair rejection sample is not installed")
        rejected = lower_model(parse_featurescript(rejected_path.read_text(encoding="utf-8"), "00658358"), {})
        # F4 is an attached sketch, not the immediate shell consumer allowed
        # by this CAP_FACE tuple. It must not inherit a static sweep cap
        # frame merely because its query contains the producer's endpoint.
        self.assertNotIn("f_F4", {item["id"] for item in rejected.cdsl["features"]})
        self.assertTrue(any(
            item["feature_id"] == "F4"
            and item["code"] == "feature_deferred"
            and item["message"] == "cap face source frame is unresolved"
            for item in rejected.diagnostics
        ))
        with tempfile.TemporaryDirectory() as directory:
            outcome = rebuild_candidate(rejected.cdsl, Path(directory) / "sweep-shell-rejected.step")
        self.assertEqual(outcome["status"], "rebuilt")
        self.assertEqual(outcome["result"]["feature_results"][-1]["feature_id"], "f_F3")

        reversed_path = root / "featurescript_rp/0026/00260523.txt"
        if not reversed_path.exists(): self.skipTest("CADFS path-reversal source sample is not installed")
        reversed_source = reversed_path.read_text(encoding="utf-8").rsplit("    });", 1)[0] + '''
        {
            var Q0;
            Q0=makeQuery(id+"F3.opSweep","CAP_FACE",FACE,{"disambiguationData":[OSD([sQuery(id+"F2.wireOp",EDGE,"E1"),sQuery(id+"F0.wireOp",VERTEX,"E0.end")])],"isStart":false});
            shell(context, id + "F4", {"entities" : qUnion([Q0]), "thickness" : 0.5 * mm});
        }
    });'''
        reversed_result = lower_model(parse_featurescript(reversed_source, "00260523-sweep-cap-reversed"), {})
        reversed_features = {item["id"]: item for item in reversed_result.cdsl["features"]}
        self.assertTrue(reversed_features["f_F3"]["params"]["cap_output_contract"]["path_reversed"])
        reversed_selector = reversed_features["f_F4"]["selectors"][0]
        self.assertEqual(reversed_selector["output_role"], "sweep.start")
        self.assertEqual(reversed_selector["selector_intent"]["disambiguation"]["path_endpoint"], "end")
        with tempfile.TemporaryDirectory() as directory:
            reversed_rebuilt = rebuild_candidate(reversed_result.cdsl, Path(directory) / "sweep-shell-reversed.step")
        self.assertEqual(reversed_rebuilt["status"], "rebuilt")

    def test_initial_direct_sweep_cap_edge_requires_a_single_profile_edge_and_path_endpoint_pair(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        source_path = root / "featurescript_rp/0033/00330012.txt"
        if not source_path.exists(): self.skipTest("CADFS sample is not installed")
        source = source_path.read_text(encoding="utf-8")
        cap_edge_source = source.replace(
            'makeQuery(id+"F2.opSweep","CAP_FACE",FACE,',
            'makeQuery(id+"F2.opSweep","CAP_EDGE",EDGE,',
        ).replace(
            'shell(context, id + "F3", {"entities" : qUnion([Q0]), "thickness" : 1.27 * mm});',
            'fillet(context, id + "F3", {"entities" : qUnion([Q0]), "radius" : 1.27 * mm, "tangentPropagation" : true, "allowEdgeOverflow" : false});',
        )
        result = lower_model(parse_featurescript(cap_edge_source, "00330012-sweep-cap-edge"), {})
        self.assertEqual(result.status, "converted_complete")
        features = {item["id"]: item for item in result.cdsl["features"]}
        selector = features["f_F3"]["selectors"][0]
        self.assertNotIn("geometry", selector)
        self.assertNotIn("stable_id", selector)
        self.assertEqual(selector["selector_intent"]["query_family"], "CAP_EDGE")
        self.assertEqual(selector["selector_intent"]["lineage_role"], "sweep.end")
        self.assertEqual(selector["selector_intent"]["source_entity"], {"sketch_id": "F0", "entity_id": "E0"})
        self.assertEqual(selector["selector_intent"]["disambiguation"]["path_endpoint"], "end")
        with tempfile.TemporaryDirectory() as directory:
            rebuilt = rebuild_candidate(result.cdsl, Path(directory) / "sweep-cap-edge.step")
        self.assertEqual(rebuilt["status"], "rebuilt")
        resolution = next(item for item in rebuilt["result"]["selector_resolution"] if item["feature_id"] == "f_F3")
        self.assertEqual(resolution["resolution_mode"], "kernel_lineage")
        self.assertEqual(resolution["evidence"]["relations"][0]["output_role"], "sweep.end")
        self.assertEqual(resolution["evidence"]["relations"][0]["source_kind"], "edge")
        self.assertEqual(resolution["evidence"]["relations"][0]["result_kind"], "edge")

        mismatched_endpoint = cap_edge_source.replace('E1.end")])],"isStart":false', 'E1.start")])],"isStart":false')
        rejected = lower_model(parse_featurescript(mismatched_endpoint, "00330012-sweep-cap-edge-endpoint-mismatch"), {})
        self.assertEqual(rejected.status, "converted_partial")
        self.assertNotIn("f_F3", {item["id"] for item in rejected.cdsl["features"]})

    def test_initial_direct_sweep_swept_face_requires_profile_and_path_edge_pair(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        source_path = root / "featurescript_rp/0033/00330012.txt"
        if not source_path.exists(): self.skipTest("CADFS sample is not installed")
        source = source_path.read_text(encoding="utf-8")
        swept_face_source = source.replace(
            'makeQuery(id+"F2.opSweep","CAP_FACE",FACE,',
            'makeQuery(id+"F2.opSweep","SWEPT_FACE",FACE,',
        ).replace(
            'sQuery(id+"F1.wireOp",VERTEX,"E1.end")',
            'sQuery(id+"F1.wireOp",EDGE,"E1")',
        ).replace(
            '])],"isStart":false})', '])]})',
        ).replace(
            'shell(context, id + "F3", {"entities" : qUnion([Q0]), "thickness" : 1.27 * mm});',
            'fillet(context, id + "F3", {"entities" : qUnion([Q0]), "radius" : 1.27 * mm, "tangentPropagation" : true, "allowEdgeOverflow" : false});',
        )
        result = lower_model(parse_featurescript(swept_face_source, "00330012-sweep-swept-face"), {})
        self.assertEqual(result.status, "converted_complete")
        selector = next(item for item in result.cdsl["features"] if item["id"] == "f_F3")["selectors"][0]
        self.assertNotIn("geometry", selector)
        self.assertNotIn("stable_id", selector)
        self.assertEqual(selector["selector_intent"]["query_family"], "SWEPT_FACE")
        self.assertEqual(selector["selector_intent"]["source_entity"], {"sketch_id": "F0", "entity_id": "E0"})
        self.assertEqual(selector["selector_intent"]["disambiguation"], {
            "type": "sweep_profile_path",
            "profile_source": "F0", "profile_entities": ["E0"],
            "path_source": "F1", "path_entity": "E1", "path_reversed": False,
        })
        with tempfile.TemporaryDirectory() as directory:
            rebuilt = rebuild_candidate(result.cdsl, Path(directory) / "sweep-swept-face.step")
        self.assertEqual(rebuilt["status"], "rebuilt")
        resolution = next(item for item in rebuilt["result"]["selector_resolution"] if item["feature_id"] == "f_F3")
        self.assertEqual(resolution["resolution_mode"], "kernel_lineage")
        self.assertEqual(resolution["evidence"]["relations"][0]["source_kind"], "edge")
        self.assertEqual(resolution["evidence"]["relations"][0]["result_kind"], "face")
        self.assertEqual(resolution["evidence"]["relations"][0]["coverage"], "complete")

        query_prefix, query_suffix = swept_face_source.rsplit('sQuery(id+"F1.wireOp",EDGE,"E1")', 1)
        mismatched_path = query_prefix + 'sQuery(id+"F0.wireOp",EDGE,"E0")' + query_suffix
        rejected = lower_model(parse_featurescript(mismatched_path, "00330012-sweep-swept-face-path-mismatch"), {})
        rejected_selector = next(item for item in rejected.cdsl["features"] if item["id"] == "f_F3")["selectors"][0]
        self.assertNotIn("geometry", rejected_selector)
        self.assertNotIn("stable_id", rejected_selector)
        self.assertEqual(rejected_selector["selector_intent"]["evidence"], "feature_script_query")

    def test_initial_direct_sweep_swept_face_accepts_complete_direct_multi_edge_profile(self):
        """Generated(profile_edge) remains exact for every edge of one direct contour."""
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        source_path = root / "featurescript_rp/0033/00330012.txt"
        if not source_path.exists(): self.skipTest("CADFS sample is not installed")
        source = source_path.read_text(encoding="utf-8")
        source = source.replace(
            'skCircle(sketch, "E0", {"center": v(0, 0) * mm, "radius": 6.35 * mm});',
            '''skLineSegment(sketch, "E0", {"start": v(-4, -4) * mm, "end": v(4, -4) * mm});
            skLineSegment(sketch, "E1", {"start": v(4, -4) * mm, "end": v(4, 4) * mm});
            skLineSegment(sketch, "E2", {"start": v(4, 4) * mm, "end": v(-4, 4) * mm});
            skLineSegment(sketch, "E3", {"start": v(-4, 4) * mm, "end": v(-4, -4) * mm});''',
        )
        source = re.sub(
            r'skFitSpline\(sketch, "E1", \{.*?\}\);',
            'skLineSegment(sketch, "E1", {"start": v(0, 0) * mm, "end": v(100, 0) * mm});',
            source,
        ).replace(
            'Q0=makeQuery(id+"F0.imprint","IMPRINT",FACE,{"disambiguationData":[TD([[makeQuery(id+"F0.imprint","IMPRINT",EDGE,{"derivedFrom":sQuery(id+"F0.wireOp",EDGE,"E0")}),1.0]])]});',
            'Q0=qSketchRegion(id+"F0",true);',
        ).replace(
            'makeQuery(id+"F2.opSweep","CAP_FACE",FACE,',
            'makeQuery(id+"F2.opSweep","SWEPT_FACE",FACE,',
        ).replace(
            'sQuery(id+"F0.wireOp",EDGE,"E0"),sQuery(id+"F1.wireOp",VERTEX,"E1.end")',
            'sQuery(id+"F0.wireOp",EDGE,"E2"),sQuery(id+"F1.wireOp",EDGE,"E1")',
        ).replace(
            '])],"isStart":false})', '])]})',
        ).replace(
            'shell(context, id + "F3", {"entities" : qUnion([Q0]), "thickness" : 1.27 * mm});',
            'fillet(context, id + "F3", {"entities" : qUnion([Q0]), "radius" : 0.5 * mm, "tangentPropagation" : true, "allowEdgeOverflow" : false});',
        )
        result = lower_model(parse_featurescript(source, "00330012-sweep-swept-face-multi-edge"), {})
        self.assertEqual(result.status, "converted_complete")
        features = {item["id"]: item for item in result.cdsl["features"]}
        contract = features["f_F2"]["params"]["swept_face_contract"]
        self.assertEqual(contract, {
            "profile_source": "F0", "profile_entities": ["E0", "E1", "E2", "E3"],
            "path_source": "F1", "path_entity": "E1", "path_reversed": False,
        })
        self.assertNotIn("cap_output_contract", features["f_F2"]["params"])
        selector = features["f_F3"]["selectors"][0]
        self.assertEqual(selector["selector_intent"]["source_entity"], {"sketch_id": "F0", "entity_id": "E2"})
        self.assertEqual(selector["selector_intent"]["disambiguation"]["profile_entities"], ["E0", "E1", "E2", "E3"])
        with tempfile.TemporaryDirectory() as directory:
            rebuilt = rebuild_candidate(result.cdsl, Path(directory) / "sweep-swept-face-multi-edge.step")
        self.assertEqual(rebuilt["status"], "rebuilt")
        resolution = next(item for item in rebuilt["result"]["selector_resolution"] if item["feature_id"] == "f_F3")
        self.assertEqual(resolution["resolution_mode"], "kernel_lineage")
        self.assertEqual(resolution["evidence"]["relations"][0]["source_kind"], "edge")
        self.assertEqual(resolution["evidence"]["relations"][0]["result_kind"], "face")

        query_prefix, query_suffix = source.rsplit('sQuery(id+"F1.wireOp",EDGE,"E1")', 1)
        source_pair_mismatch = query_prefix + 'sQuery(id+"F0.wireOp",EDGE,"E0")' + query_suffix
        rejected = lower_model(parse_featurescript(source_pair_mismatch, "00330012-sweep-swept-face-multi-edge-mismatch"), {})
        rejected_selector = next(item for item in rejected.cdsl["features"] if item["id"] == "f_F3")["selectors"][0]
        self.assertEqual(rejected_selector["selector_intent"]["evidence"], "feature_script_query")
        self.assertNotIn("geometry", rejected_selector)
        self.assertNotIn("stable_id", rejected_selector)

    def test_initial_direct_sweep_swept_face_rejects_a_multi_segment_path(self):
        """A qUnion path must not inherit an arbitrary representative source edge."""
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        source_path = root / "featurescript_rp/0095/00954785.txt"
        if not source_path.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(source_path.read_text(encoding="utf-8"), "00954785"), {})
        features = {item["id"]: item for item in result.cdsl["features"]}
        self.assertEqual(result.status, "converted_partial")
        self.assertNotIn("swept_face_contract", features["f_F2"]["params"])
        self.assertNotIn("f_F3", features)
        self.assertTrue(any(
            diagnostic["feature_id"] == "F3" and diagnostic["code"] == "feature_deferred"
            for diagnostic in result.diagnostics
        ))
        with tempfile.TemporaryDirectory() as directory:
            rebuilt = rebuild_candidate(result.cdsl, Path(directory) / "sweep-swept-face-segmented-path.step")
        # The complete four-segment source path is preserved instead of
        # falling back to one representative leaf. OCC rejects this actual
        # PipeShell as an invalid solid, which is a modelling/kernel boundary
        # and must remain distinct from selector resolution success.
        self.assertEqual(rebuilt["status"], "rebuild_failed")
        self.assertEqual(rebuilt["error"]["message"], "OCC sweep operation did not produce a valid solid")

    def test_initial_direct_sweep_swept_edge_requires_an_adjacent_profile_vertex_and_path(self):
        """PipeShell Generated(vertex) binds one explicit pair of profile edges."""
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        source_path = root / "featurescript_rp/0033/00330012.txt"
        if not source_path.exists(): self.skipTest("CADFS sample is not installed")
        source = source_path.read_text(encoding="utf-8")
        source = source.replace(
            'skCircle(sketch, "E0", {"center": v(0, 0) * mm, "radius": 6.35 * mm});',
            '''skLineSegment(sketch, "E0", {"start": v(-4, -4) * mm, "end": v(4, -4) * mm});
            skLineSegment(sketch, "E1", {"start": v(4, -4) * mm, "end": v(4, 4) * mm});
            skLineSegment(sketch, "E2", {"start": v(4, 4) * mm, "end": v(-4, 4) * mm});
            skLineSegment(sketch, "E3", {"start": v(-4, 4) * mm, "end": v(-4, -4) * mm});''',
        )
        source = re.sub(
            r'skFitSpline\(sketch, "E1", \{.*?\}\);',
            'skLineSegment(sketch, "E1", {"start": v(0, 0) * mm, "end": v(100, 0) * mm});',
            source,
        ).replace(
            'Q0=makeQuery(id+"F0.imprint","IMPRINT",FACE,{"disambiguationData":[TD([[makeQuery(id+"F0.imprint","IMPRINT",EDGE,{"derivedFrom":sQuery(id+"F0.wireOp",EDGE,"E0")}),1.0]])]});',
            'Q0=qSketchRegion(id+"F0",true);',
        ).replace(
            'Q0=makeQuery(id+"F2.opSweep","CAP_FACE",FACE,{"disambiguationData":[OSD([sQuery(id+"F0.wireOp",EDGE,"E0"),sQuery(id+"F1.wireOp",VERTEX,"E1.end")])],"isStart":false});',
            'Q0=makeQuery(id+"F2.opSweep","SWEPT_EDGE",EDGE,{"disambiguationData":[OSD([sQuery(id+"F0.wireOp",EDGE,"E1"),sQuery(id+"F0.wireOp",EDGE,"E2"),sQuery(id+"F1.wireOp",EDGE,"E1")])]});',
        ).replace(
            'shell(context, id + "F3", {"entities" : qUnion([Q0]), "thickness" : 1.27 * mm});',
            'fillet(context, id + "F3", {"entities" : qUnion([Q0]), "radius" : 0.5 * mm, "tangentPropagation" : true, "allowEdgeOverflow" : false});',
        )
        result = lower_model(parse_featurescript(source, "00330012-sweep-swept-edge"), {})
        self.assertEqual(result.status, "converted_complete")
        features = {item["id"]: item for item in result.cdsl["features"]}
        self.assertEqual(features["f_F2"]["params"]["swept_edge_contract"], {
            "profile_source": "F0", "profile_entities": ["E0", "E1", "E2", "E3"],
            "path_source": "F1", "path_entity": "E1", "path_reversed": False,
        })
        selector = features["f_F3"]["selectors"][0]
        self.assertNotIn("geometry", selector)
        self.assertNotIn("stable_id", selector)
        self.assertEqual(selector["selector_intent"]["source_entities"], [
            {"sketch_id": "F0", "entity_id": "E1"},
            {"sketch_id": "F0", "entity_id": "E2"},
        ])
        self.assertEqual(selector["selector_intent"]["disambiguation"], {
            "type": "sweep_profile_vertex_path",
            "profile_source": "F0", "profile_entities": ["E0", "E1", "E2", "E3"],
            "path_source": "F1", "path_entity": "E1", "path_reversed": False,
            "profile_vertex_entities": ["E1", "E2"],
        })
        with tempfile.TemporaryDirectory() as directory:
            rebuilt = rebuild_candidate(result.cdsl, Path(directory) / "sweep-swept-edge.step")
        self.assertEqual(rebuilt["status"], "rebuilt")
        resolution = next(item for item in rebuilt["result"]["selector_resolution"] if item["feature_id"] == "f_F3")
        self.assertEqual(resolution["resolution_mode"], "kernel_lineage")
        self.assertEqual(resolution["evidence"]["relations"][0]["source_kind"], "vertex")
        self.assertEqual(resolution["evidence"]["relations"][0]["result_kind"], "edge")
        self.assertEqual(resolution["evidence"]["relations"][0]["coverage"], "complete")

        rejected_source = source.replace(
            'sQuery(id+"F0.wireOp",EDGE,"E1"),sQuery(id+"F0.wireOp",EDGE,"E2")',
            'sQuery(id+"F0.wireOp",EDGE,"E0"),sQuery(id+"F0.wireOp",EDGE,"E2")',
            1,
        )
        rejected = lower_model(parse_featurescript(rejected_source, "00330012-sweep-swept-edge-non-adjacent"), {})
        rejected_selector = next(item for item in rejected.cdsl["features"] if item["id"] == "f_F3")["selectors"][0]
        self.assertEqual(rejected_selector["selector_intent"]["evidence"], "feature_script_query")
        self.assertNotIn("geometry", rejected_selector)
        self.assertNotIn("stable_id", rejected_selector)

    def test_direct_prism_swept_edge_dressup_allows_proven_continuation_only(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        source_path = root / "featurescript_rp/0009/00094474.txt"
        if not source_path.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(source_path.read_text(encoding="utf-8"), "00094474"), {})
        selector = next(item for item in result.cdsl["features"] if item["id"] == "f_F3")["selectors"][0]
        self.assertEqual(selector["selector_intent"]["query_family"], "SWEPT_EDGE")
        self.assertEqual(selector["selector_intent"]["derivation_policy"], {
            "allowed": ["boundary", "continuation"], "multiplicity": "one",
        })
        with tempfile.TemporaryDirectory() as directory:
            rebuilt = rebuild_candidate(result.cdsl, Path(directory) / "swept-edge-continuation.step")
        self.assertEqual(rebuilt["status"], "rebuilt")
        resolution = next(item for item in rebuilt["result"]["selector_resolution"] if item["feature_id"] == "f_F3")
        self.assertEqual(resolution["resolution_mode"], "kernel_lineage")
        self.assertTrue(resolution["evidence"]["relations"])

        cut_path = root / "featurescript_rp/0037/00370320.txt"
        if not cut_path.exists(): self.skipTest("CADFS continuation-through-cut sample is not installed")
        cut = lower_model(parse_featurescript(cut_path.read_text(encoding="utf-8"), "00370320"), {})
        with tempfile.TemporaryDirectory() as directory:
            cut_rebuilt = rebuild_candidate(cut.cdsl, Path(directory) / "swept-edge-cut-continuation.step")
        self.assertEqual(cut_rebuilt["status"], "rebuilt")
        cut_resolution = next(
            item for item in cut_rebuilt["result"]["selector_resolution"] if item["feature_id"] == "f_F4"
        )
        self.assertEqual(cut_resolution["resolution_mode"], "kernel_lineage")
        self.assertEqual(
            [relation["derivation"] for relation in cut_resolution["evidence"]["relations"]],
            ["boundary", "continuation"],
        )

        ambiguous_path = root / "featurescript_rp/0002/00027017.txt"
        if not ambiguous_path.exists(): self.skipTest("CADFS continuation boundary sample is not installed")
        ambiguous = lower_model(parse_featurescript(ambiguous_path.read_text(encoding="utf-8"), "00027017"), {})
        with tempfile.TemporaryDirectory() as directory:
            rejected = rebuild_candidate(ambiguous.cdsl, Path(directory) / "swept-edge-ambiguous.step")
        self.assertEqual(rejected["status"], "rebuild_failed")
        self.assertEqual(rejected["error"]["message"], "f_F3: selector_relation_non_unique during incremental replay")
        self.assertEqual(rejected["last_executable_prefix"]["last_feature_id"], "f_F2")

    def test_direct_swept_edge_query_set_uses_its_producer_source_anchors(self):
        """A later use of the same sketch cannot duplicate an F1 source anchor."""
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        source_path = root / "featurescript_rp/0040/00407468.txt"
        if not source_path.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(source_path.read_text(encoding="utf-8"), "00407468"), {})
        selector = next(item for item in result.cdsl["features"] if item["id"] == "f_F3")["selectors"][0]
        self.assertEqual(selector["selector_intent"]["query_family"], "QUERY_SET")
        self.assertEqual(len(selector["query_operands"]), 4)
        self.assertTrue(all(item["owner_feature_id"] == "f_F1" for item in selector["query_operands"]))
        with tempfile.TemporaryDirectory() as directory:
            rebuilt = rebuild_candidate(result.cdsl, Path(directory) / "producer-source-anchor.step")
        self.assertEqual(rebuilt["status"], "rebuilt")
        resolution = next(item for item in rebuilt["result"]["selector_resolution"] if item["feature_id"] == "f_F3")
        self.assertEqual(resolution["resolution_mode"], "query_set_union")
        self.assertEqual(
            [item["record_id"] for item in resolution["records"]],
            ["body:f_F2:edge:19", "body:f_F2:edge:22", "body:f_F2:edge:25", "body:f_F2:edge:28"],
        )

    def test_2491_two_sided_prism_cap_edges_use_exact_far_cap_history(self):
        """The reverse prism's far cap is the FeatureScript start cap."""
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        source_path = root / "featurescript_rp/0004/00049094.txt"
        if not source_path.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(source_path.read_text(encoding="utf-8"), "00049094"), {})
        feature = next(item for item in result.cdsl["features"] if item["id"] == "f_F2")
        self.assertEqual(feature["selectors"][0]["selector_intent"]["query_family"], "QUERY_SET")
        self.assertEqual(len(feature["selectors"][0]["query_operands"]), 4)
        self.assertTrue(all(
            item["selector_intent"]["query_family"] == "CAP_EDGE"
            and item["selector_intent"]["derivation_policy"] == {
                "allowed": ["boundary"], "multiplicity": "one",
            }
            for item in feature["selectors"][0]["query_operands"]
        ))
        with tempfile.TemporaryDirectory() as directory:
            rebuilt = rebuild_candidate(result.cdsl, Path(directory) / "two-sided-cap-edges.step")
        self.assertEqual(rebuilt["status"], "rebuilt")
        resolution = next(item for item in rebuilt["result"]["selector_resolution"] if item["feature_id"] == "f_F2")
        self.assertEqual(resolution["resolution_mode"], "query_set_union")
        self.assertEqual(len(resolution["records"]), 4)
        roles = {
            relation["output_role"]
            for operand in resolution["evidence"]["operand_resolutions"]
            for relation in operand["relations"]
        }
        self.assertEqual(roles, {"extrude.start", "extrude.end"})

        rejected_path = root / "featurescript_rp/0040/00404726.txt"
        if not rejected_path.exists(): self.skipTest("CADFS negative sample is not installed")
        rejected = lower_model(parse_featurescript(rejected_path.read_text(encoding="utf-8"), "00404726"), {})
        selectors = next(item for item in rejected.cdsl["features"] if item["id"] == "f_F2")["selectors"]
        self.assertTrue(all(
            item["selector_intent"]["evidence"] == "feature_script_query"
            and item["selector_intent"]["derivation_policy"] == {
                "allowed": ["continuation"], "multiplicity": "none",
            }
            for item in selectors
        ))

    def test_two_sided_circle_shell_uses_exact_far_cap_roles(self):
        """A symmetric circle shell consumes both far prism caps, not their seam."""
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        for sample_id, producer_id, shell_id, roles in (
            ("00019252", "f_F1", "f_F2", ["extrude.end", "extrude.start"]),
            ("00000316", "f_F2", "f_F3", ["extrude.start", "extrude.end"]),
        ):
            source_path = root / f"featurescript_rp/{sample_id[:4]}/{sample_id}.txt"
            if not source_path.exists():
                self.skipTest("CADFS two-sided circle shell samples are not installed")
            result = lower_model(parse_featurescript(source_path.read_text(encoding="utf-8"), sample_id), {})
            shell = next(item for item in result.cdsl["features"] if item["id"] == shell_id)
            self.assertEqual(
                [item["output_role"] for item in shell["selectors"]],
                roles,
            )
            self.assertTrue(all(
                item["owner_feature_id"] == producer_id
                and item["selector_intent"]["query_family"] == "CAP_FACE"
                and item["selector_intent"]["derivation_policy"] == {
                    "allowed": ["boundary"], "multiplicity": "one",
                }
                for item in shell["selectors"]
            ))
            shell_index = next(
                index for index, item in enumerate(result.cdsl["features"])
                if item["id"] == shell_id
            )
            prefix = deepcopy(result.cdsl)
            prefix["features"] = prefix["features"][:shell_index + 1]
            with tempfile.TemporaryDirectory() as directory:
                rebuilt = rebuild_candidate(prefix, Path(directory) / f"{sample_id}-two-sided-shell.step")
            self.assertEqual(rebuilt["status"], "rebuilt")
            resolutions = [
                item for item in rebuilt["result"]["selector_resolution"]
                if item["feature_id"] == shell_id
            ]
            self.assertEqual(
                [item["record"]["record_id"] for item in resolutions],
                [
                    f"body:{producer_id}:face:{2 if role == 'extrude.end' else 3}"
                    for role in roles
                ],
            )

    def test_typed_new_body_add_cap_edge_uses_exact_union_continuation(self):
        """NewBodyOperationType.ADD resolves only through its exact active union successor."""
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        for sample_id, consumer_id in (("00953397", "f_F7"), ("00957101", "f_F4")):
            with self.subTest(sample_id=sample_id):
                source_path = root / f"featurescript_rp/{sample_id[:4]}/{sample_id}.txt"
                if not source_path.exists(): self.skipTest("CADFS primary-add cap-edge samples are not installed")
                result = lower_model(parse_featurescript(source_path.read_text(encoding="utf-8"), sample_id), {})
                selector = next(item for item in result.cdsl["features"] if item["id"] == consumer_id)["selectors"][0]
                self.assertEqual(selector["selector_intent"]["query_family"], "CAP_EDGE")
                self.assertEqual(selector["selector_intent"]["derivation_policy"], {
                    "allowed": ["boundary", "continuation"], "multiplicity": "one",
                })
                with tempfile.TemporaryDirectory() as directory:
                    outcome = rebuild_candidate(result.cdsl, Path(directory) / f"{sample_id}-primary-add-cap-edge.step")
                self.assertEqual(outcome["status"], "rebuilt")
                resolution = next(item for item in outcome["result"]["selector_resolution"] if item["feature_id"] == consumer_id)
                self.assertEqual(resolution["status"], "resolved")
                self.assertEqual(resolution["resolution_mode"], "kernel_lineage")
                self.assertEqual(
                    [relation["operation"] for relation in resolution["evidence"]["relations"]],
                    ["extrude", "union"],
                )

        rejected_path = root / "featurescript_rp/0040/00406939.txt"
        if not rejected_path.exists(): self.skipTest("CADFS multi-solid primary-add sample is not installed")
        rejected = lower_model(parse_featurescript(rejected_path.read_text(encoding="utf-8"), "00406939"), {})
        selectors = next(item for item in rejected.cdsl["features"] if item["id"] == "f_F3")["selectors"]
        self.assertTrue(all(
            item["selector_intent"]["evidence"] == "feature_script_query"
            and item["selector_intent"]["derivation_policy"]["multiplicity"] == "none"
            for item in selectors[:2]
        ))

    def test_typed_new_body_add_cap_face_shell_uses_exact_union_continuation(self):
        """A typed ADD CAP face needs an exact active union successor for shell use."""
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        for sample_id, consumer_id in (("00074047", "f_F4"), ("00350698", "f_F7")):
            with self.subTest(sample_id=sample_id):
                source_path = root / f"featurescript_rp/{sample_id[:4]}/{sample_id}.txt"
                if not source_path.exists(): self.skipTest("CADFS primary-add cap-face samples are not installed")
                result = lower_model(parse_featurescript(source_path.read_text(encoding="utf-8"), sample_id), {})
                selector = next(item for item in result.cdsl["features"] if item["id"] == consumer_id)["selectors"][0]
                self.assertEqual(selector["selector_intent"]["query_family"], "CAP_FACE")
                self.assertEqual(selector["selector_intent"]["derivation_policy"], {
                    "allowed": ["boundary", "continuation"], "multiplicity": "one",
                })
                with tempfile.TemporaryDirectory() as directory:
                    outcome = rebuild_candidate(result.cdsl, Path(directory) / f"{sample_id}-primary-add-cap-face.step")
                self.assertIn(outcome["status"], {"rebuilt", "rebuild_failed"})
                payload = outcome.get("result") or outcome["error"]
                resolution = next(
                    item for item in payload["selector_resolution" if "result" in outcome else "selector_resolutions"]
                    if item["feature_id"] == consumer_id
                )
                self.assertEqual(resolution["status"], "resolved")
                self.assertEqual(resolution["resolution_mode"], "operation_role")
                self.assertEqual(
                    [relation["operation"] for relation in resolution["evidence"]["relations"]],
                    ["extrude", "union"],
                )

        rejected_path = root / "featurescript_rp/0029/00293014.txt"
        if not rejected_path.exists(): self.skipTest("CADFS primary-add cap-face ambiguity sample is not installed")
        rejected = lower_model(parse_featurescript(rejected_path.read_text(encoding="utf-8"), "00293014"), {})
        with tempfile.TemporaryDirectory() as directory:
            outcome = rebuild_candidate(rejected.cdsl, Path(directory) / "00293014-primary-add-cap-face.step")
        self.assertEqual(outcome["status"], "rebuild_failed")
        self.assertEqual(outcome["error"]["message"], "f_F4: selector_output_role_ambiguous during incremental replay")
        self.assertEqual(outcome["last_executable_prefix"]["last_feature_id"], "f_F3")

        multi_solid_path = root / "featurescript_rp/0059/00590599.txt"
        if not multi_solid_path.exists(): self.skipTest("CADFS multi-solid primary-add cap-face sample is not installed")
        multi_solid = lower_model(parse_featurescript(multi_solid_path.read_text(encoding="utf-8"), "00590599"), {})
        with tempfile.TemporaryDirectory() as directory:
            outcome = rebuild_candidate(multi_solid.cdsl, Path(directory) / "00590599-primary-add-cap-face.step")
        self.assertEqual(outcome["status"], "rebuild_failed")
        self.assertEqual(outcome["error"]["message"], "f_F3: selector_query_unsupported during incremental replay")
        self.assertEqual(outcome["last_executable_prefix"]["last_feature_id"], "f_F2")

    def test_typed_new_body_add_cap_face_up_to_surface_uses_exact_union_continuation(self):
        """A typed ADD CAP face needs its exact active union successor for an extent."""
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        source_path = root / "featurescript_rp/0000/00007973.txt"
        if not source_path.exists(): self.skipTest("CADFS primary-add up-to-surface sample is not installed")
        result = lower_model(parse_featurescript(source_path.read_text(encoding="utf-8"), "00007973"), {})
        target = next(item for item in result.cdsl["features"] if item["id"] == "f_F7")
        selector = target["params"]["end_condition"]["reference"]
        self.assertEqual(
            selector["selector_intent"].get("consumer_contract"),
            "primary_add_up_to_surface_union_continuation",
        )
        with tempfile.TemporaryDirectory() as directory:
            outcome = rebuild_candidate(result.cdsl, Path(directory) / "00007973-primary-add-up-to-surface.step")
        self.assertEqual(outcome["status"], "rebuilt")
        resolution = next(item for item in outcome["result"]["selector_resolution"] if item["feature_id"] == "f_F7")
        self.assertEqual(resolution["status"], "resolved")
        self.assertEqual(resolution["resolution_mode"], "operation_role")
        self.assertEqual(
            [relation["operation"] for relation in resolution["evidence"]["relations"]],
            ["extrude", "union"],
        )

        ambiguous_path = root / "featurescript_rp/0063/00638700.txt"
        if not ambiguous_path.exists(): self.skipTest("CADFS ambiguous primary-add up-to-surface sample is not installed")
        ambiguous = lower_model(parse_featurescript(ambiguous_path.read_text(encoding="utf-8"), "00638700"), {})
        cut_index = next(index for index, item in enumerate(ambiguous.cdsl["features"]) if item["id"] == "f_F5")
        prefix = deepcopy(ambiguous.cdsl)
        prefix["features"] = prefix["features"][:cut_index + 1]
        with tempfile.TemporaryDirectory() as directory:
            outcome = rebuild_candidate(prefix, Path(directory) / "00638700-primary-add-up-to-surface.step")
        self.assertEqual(outcome["status"], "rebuild_failed")
        self.assertEqual(outcome["error"]["message"], "f_F5: selector_output_role_ambiguous during incremental replay")
        self.assertEqual(outcome["last_executable_prefix"]["last_feature_id"], "f_F3")

    def test_two_sided_up_to_surface_requires_one_direct_opposite_cap_pair(self):
        """Symmetric extent targets are admitted only as the two far CAP roles."""
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        source_path = root / "featurescript_rp/0021/00215642.txt"
        if not source_path.exists(): self.skipTest("CADFS two-sided CAP-pair sample is not installed")
        result = lower_model(parse_featurescript(source_path.read_text(encoding="utf-8"), "00215642"), {})
        target_index = next(index for index, item in enumerate(result.cdsl["features"]) if item["id"] == "f_F3")
        target = result.cdsl["features"][target_index]
        forward = target["params"]["end_condition"]["reference"]
        reverse = target["params"]["reverse_end_condition"]["reference"]
        self.assertEqual(forward["owner_feature_id"], "f_F1")
        self.assertEqual(reverse["owner_feature_id"], "f_F1")
        self.assertEqual({forward["output_role"], reverse["output_role"]}, {"extrude.start", "extrude.end"})
        self.assertTrue(all(
            item["selector_intent"]["consumer_contract"] == "symmetric_direct_prism_two_sided_up_to_surface_cap_pair"
            and item["selector_intent"]["derivation_policy"] == {"allowed": ["boundary"], "multiplicity": "one"}
            and item["selector_intent"]["disambiguation"]["source_profile_entity_ids"] == ["E0", "E1", "E2"]
            for item in (forward, reverse)
        ))
        prefix = deepcopy(result.cdsl)
        prefix["features"] = prefix["features"][:target_index + 1]
        with tempfile.TemporaryDirectory() as directory:
            rebuilt = rebuild_candidate(prefix, Path(directory) / "00215642-two-sided-cap-pair.step")
        self.assertEqual(rebuilt["status"], "rebuilt")
        resolutions = [
            item for item in rebuilt["result"]["selector_resolution"]
            if item["feature_id"] == "f_F3"
        ]
        self.assertEqual(len(resolutions), 2)
        self.assertEqual({item["selected"]["output_roles"][0] for item in resolutions}, {"extrude.start", "extrude.end"})

        rejected_path = root / "featurescript_rp/0093/00935255.txt"
        if not rejected_path.exists(): self.skipTest("CADFS different-owner CAP-pair sample is not installed")
        rejected = lower_model(parse_featurescript(rejected_path.read_text(encoding="utf-8"), "00935255"), {})
        self.assertNotIn("f_F7", {item["id"] for item in rejected.cdsl["features"]})
        self.assertIn(("F7", "extrude_extent_face_selector"), {
            (item.get("feature_id"), item.get("capability")) for item in rejected.diagnostics
        })

    def test_two_sided_up_to_surface_can_follow_one_shell_with_proven_swept_faces(self):
        """A paired extent may consume only two retained direct prism walls."""
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        source_path = root / "featurescript_rp/0018/00180262.txt"
        if not source_path.exists(): self.skipTest("CADFS shell swept-face extent sample is not installed")
        result = lower_model(parse_featurescript(source_path.read_text(encoding="utf-8"), "00180262"), {})
        target_index = next(index for index, item in enumerate(result.cdsl["features"]) if item["id"] == "f_F4")
        target = result.cdsl["features"][target_index]
        forward = target["params"]["end_condition"]["reference"]
        reverse = target["params"]["reverse_end_condition"]["reference"]
        self.assertTrue(all(
            item.get("output_role") is None
            and item["owner_feature_id"] == "f_F1"
            and item["selector_intent"]["consumer_contract"] == "symmetric_direct_prism_shell_swept_face_up_to_surface_pair"
            and item["selector_intent"]["derivation_policy"] == {"allowed": ["boundary", "continuation"], "multiplicity": "one"}
            for item in (forward, reverse)
        ))
        self.assertEqual(
            {item["selector_intent"]["source_entity"]["entity_id"] for item in (forward, reverse)},
            {"E0.left", "E0.right"},
        )
        prefix = deepcopy(result.cdsl)
        prefix["features"] = prefix["features"][:target_index + 1]
        with tempfile.TemporaryDirectory() as directory:
            rebuilt = rebuild_candidate(prefix, Path(directory) / "00180262-shell-swept-pair.step")
        self.assertEqual(rebuilt["status"], "rebuilt")
        resolutions = [
            item for item in rebuilt["result"]["selector_resolution"]
            if item["feature_id"] == "f_F4"
        ]
        self.assertEqual(len(resolutions), 2)
        self.assertTrue(all(item["resolution_mode"] == "kernel_lineage" for item in resolutions))
        self.assertEqual(
            {item["selected"]["output_roles"][0] for item in resolutions},
            {"shell.offset_face"},
        )

        # A closing descendant of a removed target side is not an offset
        # face. The source mutation keeps all surrounding feature topology
        # intact while making F2 remove F4's right-side target.
        removed_target_source = source_path.read_text(encoding="utf-8").replace(
            'sQuery(id+"F0.wireOp",EDGE,"E0.bottom")',
            'sQuery(id+"F0.wireOp",EDGE,"E0.right")',
            1,
        )
        rejected = lower_model(parse_featurescript(removed_target_source, "00180262-removed-target"), {})
        self.assertNotIn("f_F4", {item["id"] for item in rejected.cdsl["features"]})
        self.assertIn(("F4", "extrude_extent_face_selector"), {
            (item.get("feature_id"), item.get("capability")) for item in rejected.diagnostics
        })

    def test_typed_new_body_add_cap_face_dressup_uses_exact_union_contract(self):
        """The typed ADD producer is selectable only through exact union lineage."""
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        source_path = root / "featurescript_rp/0005/00051494.txt"
        if not source_path.exists(): self.skipTest("CADFS primary-add CAP_FACE dress-up sample is not installed")
        result = lower_model(parse_featurescript(source_path.read_text(encoding="utf-8"), "00051494"), {})
        target = next(item for item in result.cdsl["features"] if item["id"] == "f_F4")
        selector = target["selectors"][0]
        self.assertEqual(
            selector["selector_intent"].get("consumer_contract"),
            "primary_add_dressup_union_continuation",
        )
        self.assertEqual(
            selector["selector_intent"]["derivation_policy"],
            {"allowed": ["boundary", "continuation"], "multiplicity": "one"},
        )

        ambiguous_path = root / "featurescript_rp/0066/00660816.txt"
        if not ambiguous_path.exists(): self.skipTest("CADFS ambiguous primary-add CAP_FACE dress-up sample is not installed")
        ambiguous = lower_model(parse_featurescript(ambiguous_path.read_text(encoding="utf-8"), "00660816"), {})
        cut_index = next(index for index, item in enumerate(ambiguous.cdsl["features"]) if item["id"] == "f_F4")
        prefix = deepcopy(ambiguous.cdsl)
        prefix["features"] = prefix["features"][:cut_index + 1]
        with tempfile.TemporaryDirectory() as directory:
            outcome = rebuild_candidate(prefix, Path(directory) / "00660816-primary-add-dressup.step")
        self.assertEqual(outcome["status"], "rebuild_failed")
        self.assertEqual(
            outcome["error"]["message"],
            "f_F4: selector_output_role_ambiguous during incremental replay",
        )
        self.assertEqual(outcome["last_executable_prefix"]["last_feature_id"], "f_F3")

    def test_closed_fit_splines_lower_to_periodic_contours_and_join_split_imprints(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0061/00612529.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(feature.read_text(), "00612529"), {})

        self.assertEqual(result.status, "converted_complete")
        self.assertNotIn("F8", {item.get("feature_id") for item in result.diagnostics})
        sketches = {item["id"]: item for item in result.cdsl["geometry"]["sketches"]}
        for sketch_id in ("sketch_F0", "sketch_F2", "sketch_F5", "sketch_F6"):
            segment = sketches[sketch_id]["profile"]["contours"][0]["segments"][0]
            self.assertTrue(segment["periodic"])
            self.assertEqual(segment["parameterization"], "centripetal")
        features = {item["id"]: item for item in result.cdsl["features"]}
        self.assertEqual(features["f_F8"]["sketch_id"], "sketch_F6")

    def test_open_fit_spline_reversal_preserves_parameter_and_tangent_semantics(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0028/00287955.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(feature.read_text(), "00287955"), {})

        sketches = {item["id"]: item for item in result.cdsl["geometry"]["sketches"]}
        spline = sketches["sketch_F13__f_F14"]["profile"]["contours"][0]["segments"][1]
        source_points = [[33.77, 39.06], [38.2, 35.02], [36.58, 30.72], [33.77, 28.66]]
        source_parameters = [0.0]
        for start, end in zip(source_points, source_points[1:]):
            source_parameters.append(source_parameters[-1] + math.sqrt(math.dist(start, end)))
        source_parameters = [value / source_parameters[-1] for value in source_parameters]

        self.assertEqual(spline["points"], list(reversed(source_points)))
        self.assertEqual(spline["start_tangent"], [11.58, -1.2])
        self.assertEqual(spline["end_tangent"], [-14.95, 1.46])
        self.assertEqual(
            spline["parameters"],
            [source_parameters[-1] - value for value in reversed(source_parameters)],
        )

    def test_draft_and_boolean_bodies_preserve_explicit_source_body_selection(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0083/00835610.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(feature.read_text(), "00835610"), {})

        features = {item["id"]: item for item in result.cdsl["features"]}
        self.assertEqual(features["f_F1"]["params"]["draft"], {"angle_deg": 49.0, "pull_direction": True})
        self.assertEqual(features["f_F3"]["sketch_id"], "sketch_F0__f_F3")
        self.assertEqual(features["f_F3"]["params"]["draft"], {"angle_deg": 49.0, "pull_direction": True})
        self.assertEqual(features["f_F4"]["atomic_id"], "boolean_bodies")
        self.assertEqual(features["f_F4"]["params"], {
            "operation": "subtract",
            "target_feature_ids": ["f_F3"],
            "tool_feature_ids": ["f_F2"],
            "keep_tools": False,
        })
        self.assertEqual(features["f_F8"]["atomic_id"], "revolve_add")
        self.assertNotIn("result_mode", features["f_F8"]["params"])

    def test_drafted_cap_face_profile_executes_from_a_builder_proven_boolean_successor(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0083/00835610.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(feature.read_text(), "00835610"), {})

        features = {item["id"]: item for item in result.cdsl["features"]}
        self.assertEqual(result.status, "converted_complete")
        cap_extrude = features["f_F5"]
        self.assertEqual(cap_extrude["atomic_id"], "extrude_from_face")
        self.assertNotIn("sketch_id", cap_extrude)
        selector = cap_extrude["selectors"][0]
        self.assertEqual({key: selector[key] for key in (
            "kind", "owner_feature_id", "output_role", "source", "confidence",
        )}, {
            "kind": "face", "owner_feature_id": "f_F3", "output_role": "extrude.start",
            "source": "runtime_snapshot", "confidence": 1.0,
        })
        self.assertNotIn("selector_intent_version", selector)
        self.assertEqual(selector["selector_intent"]["query_family"], "CAP_FACE")

        from engine.cdsl_engine.runtime import rebuild_cdsl
        with tempfile.TemporaryDirectory() as directory:
            rebuilt = rebuild_cdsl(result.cdsl, Path(directory) / "drafted-cap-face.step")
        resolution = next(item for item in rebuilt["selector_resolution"] if item["feature_id"] == "f_F5")
        self.assertEqual(resolution["status"], "resolved")
        self.assertEqual(resolution["selected"]["owner_feature_ids"], ["f_F3"])
        self.assertEqual(resolution["selected"]["output_roles"], ["extrude.start"])
        self.assertIn("f_F5", [item["feature_id"] for item in rebuilt["feature_results"]])

    def test_drafted_cap_face_with_an_inner_loop_remains_an_explicit_capability_gap(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0026/00268467.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(feature.read_text(), "00268467"), {})

        features = {item["id"]: item for item in result.cdsl["features"]}
        self.assertNotIn("f_F2", features)
        diagnostics = [item for item in result.diagnostics if item.get("feature_id") == "F2"]
        self.assertEqual(len(diagnostics), 1)
        self.assertEqual(diagnostics[0]["capability"], "extrude_profile_topology:cap_face")

    def test_nested_cap_edge_union_preserves_outer_profile_and_runtime_prefix(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0095/00950564.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(feature.read_text(), "00950564"), {})

        self.assertEqual(result.status, "converted_complete")
        self.assertFalse(result.diagnostics)
        features = {item["id"]: item for item in result.cdsl["features"]}
        self.assertEqual(features["f_F3"]["sketch_id"], "sketch_F2")
        self.assertEqual(features["f_F5"]["sketch_id"], "sketch_F4")
        # Typed ADD operations fuse into the one active member. F12 must use
        # that active F11 successor while retaining F1 as a source alias.
        self.assertEqual(features["f_F12"]["params"]["source_feature_ids"], ["f_F11"])
        self.assertEqual(features["f_F12"]["params"]["source_member_aliases"], [{
            "source_feature_id": "f_F1",
            "active_member_feature_id": "f_F11",
        }])
        self.assertIn("f_F11", features["f_F12"]["depends_on"])
        from engine.cdsl_engine.runtime import analyze_cdsl
        f12_analysis = next(item for item in analyze_cdsl(result.cdsl).as_dict()["feature_results"] if item["feature_id"] == "f_F12")
        self.assertEqual(f12_analysis["resolved_status"], "executable")
        self.assertFalse(f12_analysis["blockers"])

        # Later chamfers have a separate selector gap. The retained prefix
        # proves the two CAP_EDGE profile unions themselves execute through
        # their dependent extrusions.
        prefix = deepcopy(result.cdsl)
        prefix["features"] = [item for item in prefix["features"] if item["id"] not in {"f_F10", "f_F11", "f_F12"}]
        from engine.cdsl_engine.runtime import rebuild_cdsl
        with tempfile.TemporaryDirectory() as directory:
            rebuilt = rebuild_cdsl(prefix, Path(directory) / "cap-edge-union-prefix.step")
        self.assertFalse(rebuilt["runtime_diagnostics"])
        self.assertEqual(
            [item["feature_id"] for item in rebuilt["feature_results"]],
            ["f_F1", "f_F3", "f_F5", "f_F7", "f_F9"],
        )

    def test_two_sided_blind_extrude_records_physical_cap_workplanes(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0024/00247322.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(feature.read_text(), "00247322"), {})

        # The CAP_FACE(F4, isStart:true) workplane is the blind cap opposite
        # F4's primary direction, not the source sketch plane. F5 preserves
        # that cap's exact F4 ownership, so its CAP_EDGE can form F7's hole.
        self.assertEqual(result.status, "converted_complete")
        self.assertFalse(result.diagnostics)
        sketches = {item["id"]: item for item in result.cdsl["geometry"]["sketches"]}
        self.assertEqual(sketches["sketch_F3"]["workplane"]["origin_mm"], [0.0, 0.0, 40.0])
        self.assertEqual(sketches["sketch_F6"]["workplane"]["origin_mm"], [0.0, 0.0, 40.3])
        self.assertEqual(sketches["sketch_F6"]["workplane"]["normal"], [0.0, 0.0, 1.0])
        self.assertEqual(sketches["sketch_F8"]["workplane"]["origin_mm"], [0.0, 0.0, 41.8])
        self.assertEqual(sketches["sketch_F10"]["workplane"]["origin_mm"], [0.0, 0.0, 41.8])
        features = {item["id"]: item for item in result.cdsl["features"]}
        self.assertEqual(features["f_F7"]["selectors"][0]["geometry"], {
            "normal": [0.0, 0.0, 1.0], "plane_offset_mm": 40.3,
        })

        # F9 rotates F4 only after F5/F7 have consumed it. It cannot be baked
        # into the earlier F4 sketch. The CAP_EDGE geometry is preserved for
        # diagnostics, but no source-qualified cap-edge lineage exists for
        # this two-sided profile contract.
        prefix = deepcopy(result.cdsl)
        prefix["features"] = [
            item for item in prefix["features"]
            if item["id"] in {"f_F1", "f_F2", "f_F4", "f_F5", "f_F7"}
        ]
        with tempfile.TemporaryDirectory() as directory:
            rebuilt = rebuild_candidate(prefix, Path(directory) / "two-sided-cap-prefix.step")
        self.assertEqual(rebuilt["status"], "rebuild_failed")
        self.assertEqual(rebuilt["error"]["message"], "f_F7: selector_query_unsupported during incremental replay")
        self.assertEqual(rebuilt["last_executable_prefix"]["last_feature_id"], "f_F5")

        from engine.cdsl_engine.runtime import analyze_cdsl
        f9 = next(item for item in analyze_cdsl(result.cdsl).as_dict()["feature_results"] if item["feature_id"] == "f_F9")
        self.assertIn("body_source_unavailable", [item["code"] for item in f9["blockers"]])

    def test_cap_face_profile_executes_from_a_builder_proven_dressup_successor(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0001/00016195.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(feature.read_text(), "00016195"), {})
        self.assertEqual(result.status, "converted_complete")
        feature = next(item for item in result.cdsl["features"] if item["id"] == "f_F3")
        self.assertEqual(feature["atomic_id"], "extrude_from_face")
        self.assertNotIn("sketch_id", feature)

        from engine.cdsl_engine.runtime import rebuild_cdsl
        with tempfile.TemporaryDirectory() as directory:
            rebuilt = rebuild_cdsl(result.cdsl, Path(directory) / "cap-face.step")
        resolution = next(item for item in rebuilt["selector_resolution"] if item["feature_id"] == "f_F3")
        self.assertEqual(resolution["status"], "resolved")
        self.assertEqual(resolution["selected"]["owner_feature_ids"], ["f_F1"])
        self.assertEqual(resolution["selected"]["output_roles"], ["extrude.end"])

    def test_transformed_cap_face_uses_its_attachment_plane_origin(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0083/00835610.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(feature.read_text(), "00835610"), {})

        sketches = {item["id"]: item for item in result.cdsl["geometry"]["sketches"]}
        plane = sketches["sketch_F14"]["workplane"]

        self.assertAlmostEqual(plane["origin_mm"][0], 0.0)
        self.assertAlmostEqual(plane["origin_mm"][1], 0.0)
        self.assertAlmostEqual(plane["origin_mm"][2], -24.08)
        self.assertAlmostEqual(plane["normal"][0], 0.0)
        self.assertAlmostEqual(plane["normal"][1], 0.0)
        self.assertAlmostEqual(plane["normal"][2], 1.0)

    def test_chamfer_tangent_propagation_lowers_to_engine_param(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0000/00002243.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(feature.read_text(), "00002243"), {})
        chamfer = next(item for item in result.cdsl["features"] if item["id"] == "f_F4")
        self.assertTrue(chamfer["params"]["tangent_propagation"])

    def test_imprint_profile_query_selects_one_shared_edge_region(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0003/00035682.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(feature.read_text(), "00035682"), {})
        revolve = next(item for item in result.cdsl["features"] if item["id"] == "f_F1")
        self.assertEqual(revolve["sketch_id"], "sketch_F0__f_F1")
        selected = next(item for item in result.cdsl["geometry"]["sketches"] if item["id"] == revolve["sketch_id"])
        self.assertEqual(len(selected["profile"]["contours"]), 1)
        x_coordinates = {point[0] for segment in selected["profile"]["contours"][0]["segments"] for point in (segment["start"], segment["end"])}
        self.assertEqual(x_coordinates, {11.68, 12.05})

    def test_line_point_plane_uses_the_reference_line_as_its_normal(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0003/00035682.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(feature.read_text(), "00035682"), {})
        self.assertEqual(result.status, "converted_complete")
        features = {item["id"]: item for item in result.cdsl["features"]}
        self.assertEqual(features["f_F5"]["atomic_id"], "reference_plane")
        self.assertEqual(features["f_F8"]["atomic_id"], "reference_plane")
        self.assertEqual(features["f_F7"]["atomic_id"], "extrude_cut_blind")
        self.assertEqual(features["f_F10"]["atomic_id"], "extrude_cut_blind")
        sketches = {item["id"]: item for item in result.cdsl["geometry"]["sketches"]}
        length = math.hypot(10.44, 6.03)
        for actual, expected in zip(sketches["sketch_F6"]["workplane"]["normal"], [-10.44 / length, 6.03 / length, 0.0]):
            self.assertAlmostEqual(actual, expected)
        for actual, expected in zip(sketches["sketch_F6"]["workplane"]["x_dir"], [-6.03 / length, -10.44 / length, 0.0]):
            self.assertAlmostEqual(actual, expected)
        for actual, expected in zip(sketches["sketch_F9"]["workplane"]["normal"], [10.44 / length, 6.03 / length, 0.0]):
            self.assertAlmostEqual(actual, expected)
        for actual, expected in zip(sketches["sketch_F9"]["workplane"]["x_dir"], [-6.03 / length, 10.44 / length, 0.0]):
            self.assertAlmostEqual(actual, expected)

    def test_revolved_swept_face_lowers_to_an_annular_profile(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0005/00054089.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(feature.read_text(), "00054089"), {})
        self.assertEqual(result.status, "converted_complete")
        features = {item["id"]: item for item in result.cdsl["features"]}
        self.assertEqual(features["f_F5"]["atomic_id"], "extrude_add_blind")
        sketches = {item["id"]: item for item in result.cdsl["geometry"]["sketches"]}
        profile = sketches["sketch_F4"]["profile"]
        self.assertEqual(profile["type"], "analytic_contours")
        radii = {contour["role"]: contour["segments"][0]["radius_mm"] for contour in profile["contours"]}
        self.assertEqual(radii, {"outer": 18.0, "inner": 14.0})

    def test_full_revolve_planar_swept_face_lowers_as_a_mirror_plane(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0000/00000385.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        source = feature.read_text(encoding="utf-8")
        result = lower_model(parse_featurescript(source, "00000385"), {})
        features = {item["id"]: item for item in result.cdsl["features"]}

        self.assertEqual(features["f_F5"]["atomic_id"], "pattern_mirror")
        mirror_plane = features["f_F5_plane"]["params"]["plane"]
        self.assertEqual(mirror_plane["origin_mm"], [0.0, 0.0, 0.0])
        self.assertEqual(mirror_plane["x_dir"], [1.0, 0.0, 0.0])
        self.assertEqual(mirror_plane["normal"], [0.0, 0.0, 1.0])
        self.assertFalse([item for item in result.diagnostics if item.get("feature_id") == "F5"])
        boolean = features["f_F6"]
        self.assertEqual(boolean["atomic_id"], "boolean_bodies")
        self.assertEqual(boolean["params"], {
            "operation": "union",
            "target_feature_ids": ["f_F1"],
            "keep_tools": False,
            "targetless_body_set": True,
            "tool_pattern_instance_refs": [{
                "pattern_feature_id": "f_F5",
                "source_feature_id": "f_F1",
                "instance_index": 1,
            }],
        })
        self.assertFalse([item for item in result.diagnostics if item.get("feature_id") == "F6"])

        with tempfile.TemporaryDirectory() as directory:
            rebuilt = rebuild_candidate(result.cdsl, Path(directory) / "rebuild.step")
        self.assertEqual(rebuilt["status"], "rebuilt")
        mirror = next(item for item in rebuilt["result"]["feature_results"] if item["feature_id"] == "f_F5")
        self.assertEqual(mirror["status"], "executed")
        boolean_result = next(item for item in rebuilt["result"]["feature_results"] if item["feature_id"] == "f_F6")
        self.assertEqual(boolean_result["status"], "executed")

        partial = source.replace("RevolveType.FULL", "RevolveType.PARTIAL", 1)
        rejected = lower_model(parse_featurescript(partial, "partial-revolve-mirror-plane"), {})
        self.assertNotIn("f_F5", {item["id"] for item in rejected.cdsl["features"]})
        self.assertEqual(
            [item for item in rejected.diagnostics if item.get("feature_id") == "F5"],
            [{
                "code": "feature_deferred",
                "feature_id": "F5",
                "operation": "mirror",
                "message": "mirror plane is not a default or reference plane",
            }],
        )

    def test_immediate_direct_prism_cap_and_swept_faces_lower_as_mirror_datums(self):
        """A mirror may use only its current direct-prism source face as a datum."""
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test/featurescript_rp"
        cases = {
            "00094392": ("0009/00094392.txt", "CAP_FACE", [0.0, -204.44, 0.0]),
            "00051481": ("0005/00051481.txt", "SWEPT_FACE", [0.0, 0.0, 0.0]),
        }
        for sample_id, (relative_path, family, expected_origin) in cases.items():
            with self.subTest(sample_id=sample_id):
                source = root / relative_path
                if not source.exists(): self.skipTest("CADFS sample is not installed")
                result = lower_model(parse_featurescript(source.read_text(encoding="utf-8"), sample_id), {})
                features = {item["id"]: item for item in result.cdsl["features"]}
                mirror = features["f_F2"]
                plane = features["f_F2_plane"]
                self.assertEqual(mirror["atomic_id"], "pattern_mirror")
                self.assertEqual(mirror["depends_on"], ["f_F1", "f_F2_plane"])
                self.assertEqual(plane["params"]["plane"]["origin_mm"], expected_origin)
                self.assertEqual(
                    mirror["params"]["mirror_plane"]["selector_intent"]["query_family"],
                    "GEOMETRIC",
                )
                self.assertFalse(any(item.get("feature_id") == "F2" for item in result.diagnostics))
                with tempfile.TemporaryDirectory() as directory:
                    rebuilt = rebuild_candidate(result.cdsl, Path(directory) / "mirror.step")
                feature_result = next(item for item in rebuilt["result"]["feature_results"] if item["feature_id"] == "f_F2")
                self.assertEqual(feature_result["status"], "executed")

        # A drafted, non-1511 prism's side plane has no admission under this
        # source-datum contract, even though its query spelling is identical.
        rejected_source = root / "0035/00356398.txt"
        if rejected_source.exists():
            rejected = lower_model(parse_featurescript(rejected_source.read_text(encoding="utf-8"), "00356398"), {})
            self.assertIn(("F2", "mirror plane is not a default or reference plane"), {
                (item.get("feature_id"), item.get("message")) for item in rejected.diagnostics
            })

    def test_targetless_union_partitions_direct_body_queries_in_source_order(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0029/00293508.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(feature.read_text(encoding="utf-8"), "00293508"), {})
        self.assertEqual(result.status, "converted_partial")
        boolean = next(item for item in result.cdsl["features"] if item["id"] == "f_F4")
        self.assertEqual(boolean["atomic_id"], "boolean_bodies")
        self.assertEqual(boolean["params"], {
            "operation": "union",
            "target_feature_ids": ["f_F1"],
            "tool_feature_ids": ["f_F3"],
            "keep_tools": False,
            "targetless_body_set": True,
        })
        self.assertEqual(
            [(item["feature_id"], item["message"]) for item in result.diagnostics],
            [
                ("F7", "MERGE(FACE) workplane requires a dedicated complete/proven runtime face relation"),
                ("F8", "extrude sketch query is unresolved"),
                ("F9", "MERGE(FACE) workplane requires a dedicated complete/proven runtime face relation"),
                ("F10", "extrude sketch query is unresolved"),
            ],
        )
        with tempfile.TemporaryDirectory() as directory:
            rebuilt = rebuild_candidate(result.cdsl, Path(directory) / "rebuild.step")
        self.assertEqual(rebuilt["status"], "rebuilt")
        execution = next(item for item in rebuilt["result"]["feature_results"] if item["feature_id"] == "f_F4")
        self.assertEqual(execution["status"], "executed")

    def test_targetless_direct_body_intersection_preserves_source_order(self):
        """A targetless intersection has an explicit left operand, not current body."""
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0007/00073309.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(feature.read_text(encoding="utf-8"), "00073309"), {})
        self.assertEqual(result.status, "converted_complete")
        boolean = next(item for item in result.cdsl["features"] if item["id"] == "f_F7")
        self.assertEqual(boolean["params"], {
            "operation": "intersect",
            "target_feature_ids": ["f_F5"],
            "tool_feature_ids": ["f_F1"],
            "keep_tools": False,
            "targetless_body_set": True,
        })
        with tempfile.TemporaryDirectory() as directory:
            rebuilt = rebuild_candidate(result.cdsl, Path(directory) / "targetless-intersection.step")
        self.assertEqual(rebuilt["status"], "rebuilt")
        self.assertEqual(
            next(item for item in rebuilt["result"]["feature_results"] if item["feature_id"] == "f_F7")["status"],
            "executed",
        )

    def test_targetless_body_set_keeps_the_chosen_left_member_when_requested(self):
        """keepTools applies to the complete original targetless input set."""
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0021/00215642.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(feature.read_text(encoding="utf-8"), "00215642"), {})
        boolean = next(item for item in result.cdsl["features"] if item["id"] == "f_F6")
        self.assertEqual(boolean["params"], {
            "operation": "union",
            "target_feature_ids": ["f_F3"],
            "tool_feature_ids": ["f_F1"],
            "keep_tools": True,
            "targetless_body_set": True,
        })
        with tempfile.TemporaryDirectory() as directory:
            rebuilt = rebuild_candidate(result.cdsl, Path(directory) / "targetless-keep-tools.step")
        self.assertEqual(rebuilt["status"], "runtime_ineligible")
        prefix = rebuilt["last_executable_prefix"]
        self.assertEqual(prefix["last_feature_id"], "f_F12")
        self.assertIn("f_F6", [item["feature_id"] for item in prefix["result"]["feature_results"]])

        from engine.cdsl_engine.semantic_validation import validate_semantic_cdsl
        invalid = deepcopy(result.cdsl)
        invalid_feature = next(item for item in invalid["features"] if item["id"] == "f_F6")
        invalid_feature["params"]["operation"] = "subtract"
        with self.assertRaisesRegex(ValueError, "targetless_body_set requires one qualified body"):
            validate_semantic_cdsl(invalid)

    def test_intersect_partition_profile_retains_exact_planar_imprint_evidence(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0083/00835610.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(feature.read_text(), "00835610"), {})
        self.assertEqual(result.status, "converted_complete")
        self.assertFalse([item for item in result.diagnostics if item.get("feature_id") == "F5"])
        features = {item["id"]: item for item in result.cdsl["features"]}
        self.assertEqual(features["f_F5"]["atomic_id"], "extrude_from_face")
        sketches = {item["id"]: item for item in result.cdsl["geometry"]["sketches"]}
        first = sketches[features["f_F15"]["sketch_id"]]["profile"]
        second = sketches[features["f_F16"]["sketch_id"]]["profile"]
        self.assertEqual(first["type"], "planar_imprint")
        self.assertEqual(second["type"], "planar_imprint")
        self.assertEqual(
            first["selections"],
            [
                {"source_entity_id": "E11", "face_side": 1.0,
                 "fragment": {"anchor_entity_id": "E15", "side": -1.0, "intersection_index": 0}},
                {"source_entity_id": "E11", "face_side": -1.0,
                 "fragment": {"anchor_entity_id": "E15", "side": -1.0, "intersection_index": 0}},
            ],
        )
        self.assertEqual({item["id"] for item in first["source_entities"]}, {"E11", "E13", "E14", "E15"})
        self.assertEqual(
            [selection["fragment"]["anchor_entity_id"] for selection in second["selections"]],
            ["E14", "E14"],
        )

    def test_direct_imprint_profile_reaches_the_dressup_after_exact_selector_resolution(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0035/00354246.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")

        result = lower_model(parse_featurescript(feature.read_text(), "00354246"), {})
        self.assertEqual(result.status, "converted_complete")
        features = {item["id"]: item for item in result.cdsl["features"]}
        sketches = {item["id"]: item for item in result.cdsl["geometry"]["sketches"]}
        profile = sketches[features["f_F1"]["sketch_id"]]["profile"]
        self.assertEqual(profile["type"], "planar_imprint")
        self.assertEqual(profile["selections"], [
            {"source_entity_id": "E6.MirrorCS", "face_side": -1.0},
            {"source_entity_id": "E0.MirrorCS", "face_side": 1.0},
        ])

        selectors = features["f_F2"]["selectors"]
        self.assertEqual(len(selectors), 1)
        selector = selectors[0]
        self.assertEqual(selector["selector_intent"]["query_family"], "QUERY_SET")
        self.assertEqual(selector["selector_intent"]["query_set_contract"], "proven_operand_union")
        self.assertEqual(selector["selector_intent"]["query_expr"]["root"]["operator"], "union")
        self.assertEqual(len(selector["query_operands"]), 7)
        self.assertTrue(all(
            item["selector_intent"]["query_family"] == "SWEPT_FACE"
            and item["selector_intent"]["derivation_policy"] == {
                "allowed": ["boundary", "fragment"], "multiplicity": "all_fragments",
            }
            and "geometry" not in item
            for item in selector["query_operands"]
        ))

        with tempfile.TemporaryDirectory() as directory:
            rebuilt = Path(directory) / "rebuild.step"
            outcome = rebuild_candidate(result.cdsl, rebuilt)
            self.assertEqual(outcome["status"], "rebuild_failed")
            self.assertIn("Failed creating a fillet with radius of 5.08", outcome["error"]["message"])
            resolutions = outcome["error"].get("selector_resolutions") or []
            self.assertEqual(len(resolutions), 1)
            self.assertEqual(resolutions[0]["feature_id"], "f_F2")
            self.assertEqual(resolutions[0]["status"], "resolved")
            self.assertEqual(resolutions[0]["resolution_mode"], "query_set_union")
            self.assertEqual(len(resolutions[0]["evidence"]["operand_resolutions"]), 7)
            self.assertTrue(rebuilt.exists())
        self.assertEqual(outcome["last_executable_prefix"]["last_feature_id"], "f_F1")

    def test_direct_translation_transform_updates_the_source_revolve(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0011/00111611.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(feature.read_text(), "00111611"), {})
        self.assertNotIn("F10", {item.get("feature_id") for item in result.diagnostics})
        features = {item["id"]: item for item in result.cdsl["features"]}
        sketches = {item["id"]: item for item in result.cdsl["geometry"]["sketches"]}
        self.assertEqual(features["f_F9"]["params"]["result_mode"], "new_body")
        self.assertEqual(sketches[features["f_F9"]["sketch_id"]]["workplane"]["origin_mm"], [77.16, -11.67, -63.0])
        for actual, expected in zip(features["f_F9"]["params"]["axis"]["origin_mm"], [0.13, -11.67, 56.11]):
            self.assertAlmostEqual(actual, expected)

    def test_cap_face_workplane_uses_the_physical_cap_normal(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0011/00111611.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(feature.read_text(), "00111611"), {})
        sketches = {item["id"]: item for item in result.cdsl["geometry"]["sketches"]}

        self.assertEqual(sketches["sketch_F2"]["workplane"]["origin_mm"], [0.0, 25.4, 0.0])
        self.assertEqual(sketches["sketch_F2"]["workplane"]["normal"], [0.0, 1.0, 0.0])
        self.assertEqual(sketches["sketch_F6"]["workplane"]["origin_mm"], [0.0, 0.0, 0.0])
        self.assertEqual(sketches["sketch_F6"]["workplane"]["normal"], [0.0, -1.0, 0.0])

    def test_nested_circle_imprint_selects_its_bounded_annulus(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0011/00111611.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(feature.read_text(), "00111611"), {})
        features = {item["id"]: item for item in result.cdsl["features"]}
        sketches = {item["id"]: item for item in result.cdsl["geometry"]["sketches"]}
        profile = sketches[features["f_F7"]["sketch_id"]]["profile"]

        self.assertEqual(profile["type"], "analytic_contours")
        self.assertEqual(
            [(item["role"], item["segments"][0]["radius_mm"]) for item in profile["contours"]],
            [("outer", 4.48), ("inner", 2.36)],
        )

    def test_ellipse_profiles_unblock_the_00287955_feature_chain(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0028/00287955.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")

        result = lower_model(parse_featurescript(feature.read_text(), "00287955"), {})
        features = {item["id"] for item in result.cdsl["features"]}
        feature_by_id = {item["id"]: item for item in result.cdsl["features"]}
        sketches = {item["id"]: item for item in result.cdsl["geometry"]["sketches"]}

        self.assertTrue({"f_F3", "f_F5", "f_F6", "f_F11"}.issubset(features))
        self.assertEqual(feature_by_id["f_F9"]["atomic_id"], "extrude_add_blind")
        self.assertNotIn("selectors", feature_by_id["f_F9"])
        mid_plane = feature_by_id["f_F12"]["params"]["plane"]
        self.assertAlmostEqual(mid_plane["origin_mm"][0], -18.67, places=5)
        self.assertAlmostEqual(mid_plane["normal"][0], 1.0, places=5)
        self.assertAlmostEqual(mid_plane["normal"][1], 0.0, places=3)
        axis = feature_by_id["f_F14"]["params"]["axis"]
        self.assertAlmostEqual(axis["origin_mm"][0], -18.67, delta=0.01)
        self.assertAlmostEqual(axis["origin_mm"][1], 33.77, delta=0.01)
        for sketch_id in ("sketch_F2", "sketch_F4", "sketch_F7", "sketch_F8"):
            segment = sketches[sketch_id]["profile"]["contours"][0]["segments"][0]
            self.assertEqual(segment["type"], "ellipse")
        self.assertNotIn("sketch_deferred", {item["code"] for item in result.diagnostics})

    def test_circular_pattern_lowers_to_existing_engine_contract(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0042/00423838.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(feature.read_text(), "00423838"), {})
        self.assertIsNotNone(result.cdsl)
        features = {item["id"]: item for item in result.cdsl["features"]}
        pattern = features["f_F4"]
        self.assertEqual(pattern["atomic_id"], "pattern_circular")
        self.assertEqual(pattern["params"]["source_feature_ids"], ["f_F1"])
        self.assertEqual(pattern["params"]["pattern_count"], 6)
        self.assertEqual(pattern["params"]["sweep_angle_deg"], 360.0)
        self.assertEqual(pattern["params"]["axis"]["direction"], [0.0, 0.0, -1.0])
        self.assertNotIn("F2", {item.get("feature_id") for item in result.diagnostics})
        sketches = {item["id"]: item for item in result.cdsl["geometry"]["sketches"]}
        self.assertNotEqual(sketches[features["f_F1"]["sketch_id"]]["workplane"]["normal"], [0.0, 0.0, 1.0])
        self.assertNotIn("circularPattern", {item.get("operation") for item in result.diagnostics})

    def test_static_integral_round_pattern_count_is_lowered_without_guessing_rounding_mode(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        for sample_id, feature_id, count in (
            ("00003011", "f_F5", 8),
            ("00039410", "f_F6", 9),
        ):
            with self.subTest(sample_id=sample_id):
                feature = root / "featurescript_rp" / sample_id[:4] / f"{sample_id}.txt"
                result = lower_model(parse_featurescript(feature.read_text(), sample_id), {})
                features = {item["id"]: item for item in result.cdsl["features"]}
                self.assertEqual(features[feature_id]["atomic_id"], "pattern_circular")
                self.assertEqual(features[feature_id]["params"]["pattern_count"], count)
                self.assertNotIn(feature_id.removeprefix("f_"), {
                    item.get("feature_id") for item in result.diagnostics
                })

        integral_round = Call("round", [8.0])
        fractional_round = Call("round", [8.5])
        self.assertEqual(_number(integral_round), 8.0)
        with self.assertRaisesRegex(ValueError, "not a constant number"):
            _number(fractional_round)

    def test_two_point_fit_spline_requires_endpoint_derivatives_and_lowers_as_bspline(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        source_path = root / "featurescript_rp/0003/00039410.txt"
        source = source_path.read_text(encoding="utf-8")
        result = lower_model(parse_featurescript(source, "00039410"), {})
        sketches = {item["id"]: item for item in result.cdsl["geometry"]["sketches"]}
        profile = sketches["sketch_F4"]["profile"]
        splines = [
            segment
            for contour in profile["contours"]
            for segment in contour["segments"]
            if segment["type"] == "bspline"
        ]
        self.assertEqual(len(splines), 2)
        self.assertTrue(all(len(segment["points"]) == 2 for segment in splines))
        self.assertTrue(all("start_tangent" in segment and "end_tangent" in segment for segment in splines))
        features = {item["id"]: item for item in result.cdsl["features"]}
        self.assertEqual(features["f_F6"]["params"]["pattern_count"], 9)
        self.assertNotIn("F4", {item.get("feature_id") for item in result.diagnostics})
        self.assertNotIn("F6", {item.get("feature_id") for item in result.diagnostics})

        missing_tangent = source.replace(', "endDerivative": vector(4.02, 9.38) * mm', "", 1)
        rejected = lower_model(parse_featurescript(missing_tangent, "two-point-spline-without-tangent"), {})
        self.assertIn({
            "code": "sketch_deferred",
            "feature_id": "F4",
            "message": "two-point fit spline requires both endpoint derivatives",
        }, rejected.diagnostics)

        coincident = source.replace('v(0, 30) * mm', 'v(-1, 19.97) * mm', 1)
        rejected = lower_model(parse_featurescript(coincident, "two-point-spline-with-coincident-endpoints"), {})
        self.assertIn({
            "code": "sketch_deferred",
            "feature_id": "F4",
            "message": "two-point fit spline endpoints must be distinct",
        }, rejected.diagnostics)

    def test_opposed_circle_regions_lower_to_their_union_disk(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0042/00423838.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(feature.read_text(), "00423838"), {})
        features = {item["id"]: item for item in result.cdsl["features"]}
        sketches = {item["id"]: item for item in result.cdsl["geometry"]["sketches"]}
        profile = sketches[features["f_F6"]["sketch_id"]]["profile"]
        self.assertEqual(profile["type"], "circle")
        self.assertEqual(profile["radius_mm"], 30.0)

    def test_reference_plane_variants_lower_to_explicit_frames(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        cases = {
            "00159804": {"F3", "F5"},
            "00192744": {"F3"},
            "00212904": {"F3"},
            "00542223": {"F3"},
        }
        for sample_id, expected in cases.items():
            with self.subTest(sample_id=sample_id):
                feature = root / "featurescript_rp" / sample_id[:4] / f"{sample_id}.txt"
                if not feature.exists(): self.skipTest("CADFS sample is not installed")
                result = lower_model(parse_featurescript(feature.read_text(), sample_id), {})
                features = {item["name"]: item for item in result.cdsl["features"]}
                for feature_id in expected:
                    plane = features[feature_id]
                    self.assertEqual(plane["atomic_id"], "reference_plane")
                    self.assertEqual(set(plane["params"]["plane"]), {"origin_mm", "x_dir", "normal"})
                diagnostics = [item for item in result.diagnostics if item.get("operation") == "cPlane"]
                self.assertFalse(diagnostics)

    def test_cap_vertex_datum_keeps_source_positions_across_a_direct_cap_shell(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0021/00212904.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        source = feature.read_text(encoding="utf-8").replace(
            '"isStart":true});\n            shell(context, id + "F2"',
            '"isStart":false});\n            shell(context, id + "F2"',
            1,
        )
        result = lower_model(parse_featurescript(source, "00212904-shell-removes-datum-cap"), {})
        self.assertIn("f_F3", {item["id"] for item in result.cdsl["features"]})
        self.assertFalse(any(item.get("feature_id") == "F3" for item in result.diagnostics))

    def test_plane_point_distinguishes_direct_cap_face_from_source_vertex(self):
        """PLANE_POINT roles come from query kinds, not qCreatedBy spelling."""
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0022/00228556.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")

        result = lower_model(parse_featurescript(feature.read_text(), "00228556"), {})
        plane = next(item for item in result.cdsl["features"] if item["id"] == "f_F3")
        self.assertEqual(plane["atomic_id"], "reference_plane")
        self.assertEqual(set(plane["params"]["plane"]), {"origin_mm", "x_dir", "normal"})
        self.assertFalse(any(
            item.get("operation") == "cPlane" and item.get("feature_id") == "F3"
            for item in result.diagnostics
        ))

        ambiguous = feature.read_text().replace(
            'Q1=makeQuery(id+"F1.opExtrude","CAP_FACE",FACE,',
            'Q1=sQuery(id+"F2.wireOp",VERTEX,',
            1,
        )
        rejected = lower_model(parse_featurescript(ambiguous, "00228556-ambiguous-plane-point"), {})
        self.assertIn({
            "code": "feature_deferred",
            "feature_id": "F3",
            "operation": "cPlane",
            "message": "plane-point requires exactly one face and one vertex",
        }, rejected.diagnostics)

    def test_curve_point_plane_uses_an_explicit_bspline_endpoint_tangent(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0082/00827798.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(feature.read_text(), "00827798"), {})
        plane = next(item for item in result.cdsl["features"] if item["id"] == "f_F1")
        self.assertEqual(plane["atomic_id"], "reference_plane")
        self.assertFalse(any(
            item.get("operation") == "cPlane" and item.get("feature_id") == "F1"
            for item in result.diagnostics
        ))
        expected = [107.86, 0.0, -176.04]
        magnitude = math.sqrt(sum(value * value for value in expected))
        for actual, value in zip(plane["params"]["plane"]["normal"], expected):
            self.assertAlmostEqual(actual, value / magnitude)

        second_feature = root / "featurescript_rp/0084/00845891.txt"
        if second_feature.exists():
            second = lower_model(parse_featurescript(second_feature.read_text(), "00845891"), {})
            self.assertEqual(
                next(item for item in second.cdsl["features"] if item["id"] == "f_F3")["atomic_id"],
                "reference_plane",
            )
            self.assertFalse(any(
                item.get("operation") == "cPlane" and item.get("feature_id") == "F3"
                for item in second.diagnostics
            ))

        without_end_derivative = feature.read_text().replace(
            ', "endDerivative": vector(107.86, -176.04) * mm', "", 1,
        )
        rejected = lower_model(parse_featurescript(without_end_derivative, "00827798-no-end-derivative"), {})
        self.assertIn({
            "code": "unsupported_engine_capability",
            "capability": "reference_plane:curve_point",
            "feature_id": "F1",
            "operation": "cPlane",
            "message": "CURVE_POINT B-spline endpoint has no exported tangent",
        }, rejected.diagnostics)

    def test_curve_endpoint_tangent_uses_arc_orientation_without_a_chord_fallback(self):
        arc = {
            "type": "arc", "start": [1.0, 0.0], "end": [0.0, 1.0],
            "center": [0.0, 0.0], "clockwise": False,
        }
        self.assertEqual(_curve_endpoint_tangent(arc, "start"), [0.0, 1.0])
        self.assertEqual(_curve_endpoint_tangent(arc, "end"), [-1.0, 0.0])
        with self.assertRaisesRegex(UnsupportedCapability, "direct source-curve endpoint"):
            _curve_endpoint_tangent(arc, "internal")

    def test_curve_point_plane_uses_exact_bspline_interpolation_vertex_tangents(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        cases = {
            "00456498": ("f_F1", "F1", [141.23, 0.0, -13.99]),
            "00812557": ("f_F2", "F2", [0.0, 191.15, -139.74]),
        }
        for sample_id, (cdsl_feature_id, source_feature_id, expected) in cases.items():
            with self.subTest(sample_id=sample_id):
                source = root / "featurescript_rp" / sample_id[:4] / f"{sample_id}.txt"
                if not source.exists():
                    self.skipTest("CADFS sample is not installed")
                result = lower_model(parse_featurescript(source.read_text(), sample_id), {})
                plane = next(item for item in result.cdsl["features"] if item["id"] == cdsl_feature_id)
                self.assertEqual(plane["atomic_id"], "reference_plane")
                magnitude = math.sqrt(sum(value * value for value in expected))
                for actual, value in zip(plane["params"]["plane"]["normal"], expected):
                    self.assertAlmostEqual(actual, value / magnitude, places=8)
                self.assertFalse(any(
                    item.get("operation") == "cPlane" and item.get("feature_id") == source_feature_id
                    for item in result.diagnostics
                ))

        no_derivatives = (root / "featurescript_rp/0045/00456498.txt").read_text().replace(
            ', "startDerivative": vector(0, 64.52) * mm, "endDerivative": vector(141.23, -13.99) * mm', "", 1,
        )
        rejected = lower_model(parse_featurescript(no_derivatives, "00456498-no-derivatives"), {})
        self.assertIn({
            "code": "unsupported_engine_capability",
            "capability": "reference_plane:curve_point",
            "feature_id": "F1",
            "operation": "cPlane",
            "message": "CURVE_POINT B-spline interpolation point has no complete source interpolation data",
        }, rejected.diagnostics)

        derived = (root / "featurescript_rp/0045/00456498.txt").read_text().replace(
            '"E0.2.internal"', '"E0.2.endSnap0"', 1,
        )
        rejected_derived = lower_model(parse_featurescript(derived, "00456498-derived-vertex"), {})
        self.assertIn({
            "code": "unsupported_engine_capability",
            "capability": "reference_plane:curve_point",
            "feature_id": "F1",
            "operation": "cPlane",
            "message": "CURVE_POINT point must name a direct source-curve endpoint or B-spline interpolation vertex",
        }, rejected_derived.diagnostics)

    def test_curve_point_plane_uses_a_direct_arc_endpoint_tangent(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0005/00057273.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        source = feature.read_text().replace(
            'EDGE,"E1"', 'EDGE,"E0"', 1,
        ).replace(
            'VERTEX,"E1.end"', 'VERTEX,"E0.end"', 1,
        )
        result = lower_model(parse_featurescript(source, "00057273-arc-curve-point"), {})
        plane = next(item for item in result.cdsl["features"] if item["id"] == "f_F1")
        self.assertEqual(plane["atomic_id"], "reference_plane")
        self.assertEqual(plane["params"]["plane"]["origin_mm"], [-24.6, 0.0, 0.0])
        self.assertEqual(plane["params"]["plane"]["normal"], [0.0, -1.0, 0.0])
        self.assertFalse(any(
            item.get("operation") == "cPlane" and item.get("feature_id") == "F1"
            for item in result.diagnostics
        ))

    def test_offset_reference_plane_honors_opposite_direction_without_reversing_its_frame(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0077/00777619.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        source = feature.read_text()

        opposite = lower_model(parse_featurescript(source, "00777619"), {})
        opposite_plane = next(item for item in opposite.cdsl["features"] if item["id"] == "f_F2")["params"]["plane"]
        self.assertEqual(opposite_plane, {
            "origin_mm": [-76.2, 0.0, 0.0],
            "x_dir": [0.0, 1.0, 0.0],
            "normal": [1.0, 0.0, 0.0],
        })

        default = lower_model(parse_featurescript(source.replace('"oppositeDirection" : true, ', ""), "00777619-default"), {})
        default_plane = next(item for item in default.cdsl["features"] if item["id"] == "f_F2")["params"]["plane"]
        self.assertEqual(default_plane, {
            "origin_mm": [76.2, 0.0, 0.0],
            "x_dir": [0.0, 1.0, 0.0],
            "normal": [1.0, 0.0, 0.0],
        })

    def test_shell_defers_pattern_copy_cap_faces_without_an_instance_member(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0054/00542223.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")

        result = lower_model(parse_featurescript(feature.read_text(), "00542223"), {})
        features = {item["id"]: item for item in result.cdsl["features"]}
        sketches = {item["id"]: item for item in result.cdsl["geometry"]["sketches"]}
        self.assertEqual(sketches["sketch_F4"]["workplane"]["origin_mm"], [0.0, 0.0, -50.0])
        self.assertEqual(features["f_F5"]["params"]["path"]["segment"]["points"][0], [-40.0, -50.0])
        self.assertEqual(features["f_F5"]["params"]["path"]["segment"]["start_tangent"], [27.94, 92.49])
        self.assertNotIn("f_F7", features)
        self.assertEqual(
            next(item for item in result.diagnostics if item.get("feature_id") == "F7")["message"],
            "pattern copy source feature is not replayed by its owner",
        )

    def test_shell_resolves_direct_prism_swept_faces_through_kernel_lineage(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0059/00594348.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")

        result = lower_model(parse_featurescript(feature.read_text(), "00594348"), {})
        self.assertEqual(result.status, "converted_complete")
        shell_index = next(index for index, item in enumerate(result.cdsl["features"]) if item["id"] == "f_F2")
        shell = result.cdsl["features"][shell_index]
        self.assertEqual(shell["atomic_id"], "shell")
        self.assertEqual([item["owner_feature_id"] for item in shell["selectors"]], ["f_F1", "f_F1"])
        self.assertTrue(all("geometry" not in item and "stable_id" not in item for item in shell["selectors"]))
        self.assertTrue(all(item["selector_intent"]["query_family"] == "SWEPT_FACE" for item in shell["selectors"]))
        self.assertTrue(all(item["selector_intent"]["evidence"] == "kernel_history" for item in shell["selectors"]))
        self.assertTrue(all(
            item["selector_intent"]["derivation_policy"] == {"allowed": ["boundary"], "multiplicity": "one"}
            for item in shell["selectors"]
        ))
        with tempfile.TemporaryDirectory() as directory:
            outcome = rebuild_candidate(result.cdsl, Path(directory) / "swept-face-shell.step")
        self.assertEqual(outcome["status"], "rebuilt")
        resolutions = [
            item for item in outcome["result"]["selector_resolution"]
            if item["feature_id"] == "f_F2"
        ]
        self.assertEqual(len(resolutions), 2)
        self.assertTrue(all(item["resolution_mode"] == "kernel_lineage" for item in resolutions))
        self.assertTrue(all(
            item["evidence"]["relations"][0]["source_kind"] == "edge"
            and item["evidence"]["relations"][0]["result_kind"] == "face"
            for item in resolutions
        ))

    def test_shell_resolves_a_direct_prism_swept_face_after_one_primary_cut(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0002/00020670.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")

        result = lower_model(parse_featurescript(feature.read_text(), "00020670"), {})
        self.assertEqual(result.status, "converted_partial")
        self.assertIn(("F10", "extrude_extent_face_selector"), {
            (item.get("feature_id"), item.get("capability")) for item in result.diagnostics
        })
        shell_index = next(index for index, item in enumerate(result.cdsl["features"]) if item["id"] == "f_F4")
        shell = result.cdsl["features"][shell_index]
        self.assertEqual(shell["atomic_id"], "shell")
        self.assertEqual(len(shell["selectors"]), 1)
        selector = shell["selectors"][0]
        self.assertEqual(selector["owner_feature_id"], "f_F1")
        self.assertEqual(selector["selector_intent"]["query_family"], "SWEPT_FACE")
        self.assertEqual(selector["selector_intent"]["derivation_policy"], {
            "allowed": ["boundary", "continuation"], "multiplicity": "one",
        })
        self.assertNotIn("geometry", selector)
        self.assertNotIn("stable_id", selector)

        prefix = deepcopy(result.cdsl)
        prefix["features"] = prefix["features"][:shell_index + 1]
        with tempfile.TemporaryDirectory() as directory:
            outcome = rebuild_candidate(prefix, Path(directory) / "swept-face-primary-cut-shell.step")
        self.assertEqual(outcome["status"], "rebuilt")
        resolution = next(item for item in outcome["result"]["selector_resolution"] if item["feature_id"] == "f_F4")
        self.assertEqual(resolution["resolution_mode"], "kernel_lineage")
        self.assertEqual(len(resolution["evidence"]["relations"]), 2)
        self.assertEqual(resolution["evidence"]["relations"][1]["operation"], "subtract")

    def test_shell_does_not_treat_an_add_as_a_primary_cut_swept_face_continuation(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0002/00020670.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")

        source = feature.read_text().replace("NewBodyOperationType.REMOVE", "NewBodyOperationType.ADD", 1)
        result = lower_model(parse_featurescript(source, "00020670-no-primary-cut"), {})
        self.assertNotIn("f_F4", {item["id"] for item in result.cdsl["features"]})
        diagnostic = next(item for item in result.diagnostics if item.get("feature_id") == "F4")
        self.assertEqual(diagnostic["capability"], "shell_face_selector")

    def test_shell_resolves_immediate_direct_prism_cap_faces_through_output_roles(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        cases = (("00212904", "extrude.start"), ("00789939", "extrude.end"))
        for sample_id, output_role in cases:
            with self.subTest(sample_id=sample_id):
                feature = root / "featurescript_rp" / sample_id[:4] / f"{sample_id}.txt"
                if not feature.exists(): self.skipTest("CADFS sample is not installed")
                result = lower_model(parse_featurescript(feature.read_text(encoding="utf-8"), sample_id), {})
                expected_status = "converted_complete" if sample_id == "00212904" else "converted_partial"
                self.assertEqual(result.status, expected_status)
                if sample_id == "00789939":
                    self.assertIn(("F14", "extrude_extent_face_selector"), {
                        (item.get("feature_id"), item.get("capability")) for item in result.diagnostics
                    })
                shell_index = next(index for index, item in enumerate(result.cdsl["features"]) if item["id"] == "f_F2")
                shell = result.cdsl["features"][shell_index]
                self.assertEqual(shell["atomic_id"], "shell")
                self.assertEqual(len(shell["selectors"]), 1)
                selector = shell["selectors"][0]
                self.assertEqual(selector["owner_feature_id"], "f_F1")
                self.assertEqual(selector["output_role"], output_role)
                self.assertEqual(selector["selector_intent"]["query_family"], "CAP_FACE")
                self.assertEqual(selector["selector_intent"]["evidence"], "operation_role")
                self.assertNotIn("stable_id", selector)
                self.assertNotIn("binding_feature_id", selector)
                self.assertNotIn("geometry", selector)

                prefix = deepcopy(result.cdsl)
                prefix["features"] = prefix["features"][:shell_index + 1]
                with tempfile.TemporaryDirectory() as directory:
                    outcome = rebuild_candidate(prefix, Path(directory) / f"{sample_id}-cap-face-shell.step")
                self.assertEqual(outcome["status"], "rebuilt")
                resolution = next(
                    item for item in outcome["result"]["selector_resolution"]
                    if item["feature_id"] == "f_F2"
                )
                self.assertEqual(resolution["status"], "resolved")
                self.assertEqual(resolution["resolution_mode"], "operation_role")
                self.assertEqual(resolution["selected"]["output_roles"], [output_role])

    def test_shell_direct_prism_swept_face_rejects_unregistered_source_version(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0059/00594348.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")

        source = feature.read_text(encoding="utf-8").replace("FeatureScript 1511;", "FeatureScript 1793;", 1)
        result = lower_model(parse_featurescript(source, "00594348-version-1793"), {})
        shell = next(item for item in result.cdsl["features"] if item["id"] == "f_F2")
        self.assertTrue(all(
            item["selector_intent"]["evidence"] == "feature_script_query"
            and item["selector_intent"]["derivation_policy"]["multiplicity"] == "none"
            for item in shell["selectors"]
        ))
        with tempfile.TemporaryDirectory() as directory:
            outcome = rebuild_candidate(result.cdsl, Path(directory) / "swept-face-shell-1793.step")
        self.assertEqual(outcome["status"], "rebuild_failed")
        self.assertEqual(outcome["error"]["message"], "f_F2: selector_query_unsupported during incremental replay")
        self.assertEqual(outcome["last_executable_prefix"]["last_feature_id"], "f_F1")

    def test_shell_direct_prism_swept_face_rejects_unregistered_standard_library_revision(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0059/00594348.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")

        source = feature.read_text(encoding="utf-8").replace(
            'import(path : "onshape/std/geometry.fs", version : "1511.0");',
            'import(path : "onshape/std/geometry.fs", version : "1512.0");',
            1,
        )
        result = lower_model(parse_featurescript(source, "00594348-library-1512"), {})
        shell = next(item for item in result.cdsl["features"] if item["id"] == "f_F2")
        self.assertTrue(all(
            item["selector_intent"]["source_query"]["featurescript_version"] == "1511"
            and item["selector_intent"]["source_query"]["standard_library"] == "onshape/std/geometry.fs"
            and item["selector_intent"]["source_query"]["standard_library_version"] == "1512.0"
            for item in shell["selectors"]
        ))
        with tempfile.TemporaryDirectory() as directory:
            outcome = rebuild_candidate(result.cdsl, Path(directory) / "swept-face-shell-library-1512.step")
        self.assertEqual(outcome["status"], "rebuild_failed")
        self.assertEqual(outcome["error"]["message"], "f_F2: selector_query_unsupported during incremental replay")
        self.assertEqual(outcome["last_executable_prefix"]["last_feature_id"], "f_F1")

    def test_shell_offset_face_requires_true_dependency_cap_evidence(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0010/00107631.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        # Keep the same nested CAP_FACE outside a true-dependency relation.
        # It is source-profile evidence only and must not select an OFFSET_FACE.
        source = feature.read_text(encoding="utf-8").replace(
            'TDD([makeQuery(id+"F1.opExtrude","CAP_FACE",FACE,{"disambiguationData":[OSD([subQ0])],"isStart":true})])',
            'OSD([subQ0])',
        )
        result = lower_model(parse_featurescript(source, "00107631-without-tdd"), {})

        diagnostic = next(item for item in result.diagnostics if item.get("feature_id") == "F3")
        self.assertEqual(diagnostic["capability"], "shell_offset_face_selector")
        self.assertIn("true dependency", diagnostic["message"])

    def test_shell_runtime_failure_exports_its_bound_executable_prefix(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0024/00248377.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")

        result = lower_model(parse_featurescript(feature.read_text(), "00248377"), {})
        self.assertEqual(result.status, "converted_complete")
        with tempfile.TemporaryDirectory() as directory:
            rebuilt = Path(directory) / "swept-face-shell-prefix.step"
            outcome = rebuild_candidate(result.cdsl, rebuilt)
            self.assertTrue(rebuilt.exists())
        self.assertEqual(outcome["status"], "rebuilt")
        self.assertEqual(
            [item["feature_id"] for item in outcome["result"]["feature_results"]],
            ["f_F1", "f_F2", "f_F4", "f_F5", "f_F7", "f_F9", "f_F11", "f_F13"],
        )
        resolution = next(item for item in outcome["result"]["selector_resolution"] if item["feature_id"] == "f_F5")
        self.assertEqual(resolution["resolution_mode"], "kernel_lineage")

    def test_pattern_copy_intersection_query_preserves_its_prefix_without_instance_geometry_binding(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0042/00423838.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")

        result = lower_model(parse_featurescript(feature.read_text(), "00423838"), {})
        f6_profile = next(
            sketch for sketch in result.cdsl["geometry"]["sketches"]
            if sketch["id"] == "sketch_F5__f_F6"
        )["profile"]
        # F6 unions the E4 disk with its adjacent annulus. The actual outer
        # boundary is the untouched E5 source circle, not an inferred radius.
        self.assertEqual(f6_profile["source_entity_id"], "E5")
        with tempfile.TemporaryDirectory() as directory:
            rebuilt = Path(directory) / "selector-prefix.step"
            outcome = rebuild_candidate(result.cdsl, rebuilt)
            self.assertTrue(rebuilt.exists())
        self.assertEqual(outcome["status"], "rebuild_failed")
        self.assertEqual(outcome["error"]["message"], "f_F7: selector_query_unsupported during incremental replay")
        self.assertEqual(outcome["last_executable_prefix"]["last_feature_id"], "f_F6")
        cut_delta = next(
            item for item in outcome["last_executable_prefix"]["result"]["topology_deltas"]
            if item["feature_id"] == "f_F6" and item["operation"] == "subtract"
        )
        self.assertEqual(cut_delta["operation"], "subtract")
        self.assertEqual(cut_delta["history_status"], "proven")
        self.assertEqual(cut_delta["history_reason"], "per_member_exact_cut_history")
        # The F6 tool is retained only as direct-prism source evidence. Its
        # transient records cannot be selected as active topology, and F7's
        # three-face vertex INTERSECT remains unsupported below.
        transient_tool_records = [
            item for item in outcome["last_executable_prefix"]["result"]["topology_records"]
            if item["feature_id"] == "f_F6" and item.get("transient")
        ]
        self.assertTrue(transient_tool_records)
        self.assertTrue(any(
            item.get("body_id") == "transient:f_F6" for item in transient_tool_records
        ))
        self.assertTrue(all(
            item.get("body_id") in {None, "transient:f_F6"} for item in transient_tool_records
        ))
        self.assertFalse(any(
            item["feature_id"] == "f_F7" and item["status"] == "resolved"
            for item in outcome["error"].get("selector_resolutions") or ()
        ))
        reference = next(item for item in result.cdsl["features"] if item["id"] == "f_F7")["params"]["end_condition"]["reference"]
        self.assertEqual(reference["selector_intent"]["query_family"], "INTERSECT")
        self.assertEqual(
            [item["selector_intent"]["query_family"] for item in reference["intersection_of"][:2]],
            ["COPY", "COPY"],
        )

    def test_shell_rejects_swept_faces_without_direct_linear_extrude_ownership(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        cases = (("00246716", "F7"), ("00051308", "F3"))
        for sample_id, shell_id in cases:
            with self.subTest(sample_id=sample_id):
                feature = root / "featurescript_rp" / sample_id[:4] / f"{sample_id}.txt"
                if not feature.exists(): self.skipTest("CADFS sample is not installed")
                result = lower_model(parse_featurescript(feature.read_text(), sample_id), {})
                diagnostic = next(item for item in result.diagnostics if item.get("feature_id") == shell_id)
                self.assertEqual(diagnostic["code"], "unsupported_engine_capability")
                self.assertEqual(diagnostic["capability"], "shell_face_selector")
                self.assertIn("direct blind/two-sided linear extrusion", diagnostic["message"])

    def test_curve_point_plane_uses_its_projected_attachment_origin(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0019/00192744.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(feature.read_text(), "00192744"), {})
        sketches = {item["id"]: item for item in result.cdsl["geometry"]["sketches"]}
        plane = sketches["sketch_F4"]["workplane"]
        self.assertEqual(plane["origin_mm"], [0.0, -2000.0, -4000.0])
        self.assertAlmostEqual(_global(plane, [0.0, 8944.27])[1], -10000.0, places=2)
        self.assertAlmostEqual(_global(plane, [0.0, 8944.27])[2], 0.0, places=2)

    def test_delete_pattern_copies_lower_to_explicit_exclusions(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0019/00192744.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(feature.read_text(), "00192744"), {})
        features = {item["id"]: item for item in result.cdsl["features"]}
        self.assertEqual(features["f_F6"]["params"]["excluded_instance_indices"], [2])
        self.assertEqual(features["f_F11"]["params"]["excluded_instance_indices"], [2])
        self.assertEqual(result.status, "converted_complete")
        self.assertFalse(result.diagnostics)
        self.assertEqual(features["f_F15"]["atomic_id"], "transform_bodies")
        self.assertEqual(features["f_F15"]["params"]["source_feature_ids"], ["f_F1", "f_F5"])
        self.assertEqual(features["f_F15"]["params"]["pattern_instance_refs"], [
            {"pattern_feature_id": "f_F6", "source_feature_id": "f_F5", "instance_index": 1},
            {"pattern_feature_id": "f_F6", "source_feature_id": "f_F5", "instance_index": 3},
        ])

    def test_feature_face_profile_is_not_reused_as_original_sketch(self):
        source = SOURCE.replace('qSketchRegion(id + "F0", true)', 'makeQuery(id+"F1.opExtrude","CAP_FACE",FACE,{"isStart":false})')
        result = lower_model(parse_featurescript(source, "face-profile"), {})
        self.assertIsNone(result.cdsl)
        self.assertEqual(result.diagnostics[0]["code"], "unsupported_engine_capability")
        self.assertIn("extrude_profile_topology:cap_face", result.diagnostics[0]["capability"])

    def test_cap_face_selector_retains_versioned_provenance_intent(self):
        source = SOURCE.replace(
            "FeatureScript 1511;",
            'FeatureScript 1511;\nimport(path : "onshape/std/geometry.fs", version : "1511.0");',
            1,
        ).replace(
            '\n});\n',
            '\n  extrude(context, id + "F2", {"entities":makeQuery(id + "F1.opExtrude", "CAP_FACE", FACE, {"isStart":false}), "depth":10 * mm});\n});\n',
        )
        result = lower_model(parse_featurescript(source, "cap-intent"), {})
        self.assertEqual(result.status, "converted_complete")
        selector = next(item for item in result.cdsl["features"] if item["id"] == "f_F2")["selectors"][0]
        self.assertEqual(selector["selector_intent"]["query_family"], "CAP_FACE")
        self.assertNotIn("selector_intent_version", selector)
        self.assertEqual(selector["selector_intent"]["source_query"]["featurescript_version"], "1511")
        self.assertEqual(selector["selector_intent"]["source_query"]["standard_library"], "onshape/std/geometry.fs")
        self.assertEqual(selector["selector_intent"]["source_query"]["standard_library_version"], "1511.0")
        self.assertEqual(selector["selector_intent"]["query_expr"], {
            "version": "1.0",
            "root": {
                "node": "topology_query",
                "owner": {"node": "opaque_call", "name": "__binary__", "arguments": [
                    {"node": "literal", "value": "id"},
                    {"node": "literal", "value": "+"},
                    {"node": "literal", "value": "F1.opExtrude"},
                ]},
                "topology_type": {"node": "literal", "value": "CAP_FACE"},
                "entity_type": {"node": "literal", "value": "FACE"},
                "arguments": [{"node": "map", "entries": [{
                    "key": "isStart", "value": {"node": "literal", "value": "false"},
                }]}],
            },
        })
        self.assertEqual(selector["selector_intent"]["evidence"], "operation_role")
        from engine.cdsl_engine.semantic_validation import validate_semantic_cdsl
        self.assertTrue(validate_semantic_cdsl(result.cdsl)["future_rebuild_ready"])

    def test_direct_boolean_intersection_lowering_keeps_two_source_contract(self):
        base = lower_model(parse_featurescript(SOURCE, "intersection-intent"), {}).cdsl
        sketch = base["geometry"]["sketches"][0]
        direct = {**base["features"][0], "id": "f_F2", "name": "F2"}
        feature_by_id = {
            "f_F1": base["features"][0],
            "f_F2": direct,
            "f_F3": {
                "id": "f_F3", "atomic_id": "boolean_bodies",
                "params": {
                    "operation": "subtract", "target_feature_ids": ["f_F1"],
                    "tool_feature_ids": ["f_F2"], "keep_tools": False,
                },
            },
        }
        cap = Call("makeQuery", ["F1.opExtrude", "CAP_FACE", "EntityType.FACE", {"isStart": False}])
        source_edge = Call("sQuery", ["F0.wireOp", "EntityType.EDGE", "E0"])
        swept = Call("makeQuery", [
            "F2.opExtrude", "SWEPT_FACE", "EntityType.FACE",
            {"disambiguationData": [Call("OSD", [[source_edge]])]},
        ])
        query = Call("makeQuery", [
            "F3.boolean.opBoolean", "INTERSECT", "EntityType.EDGE", {"derivedFrom": [cap, swept]},
        ])
        selector = _direct_boolean_intersection_selector(
            query,
            feature_by_id=feature_by_id,
            feature_frames={"F2": {"profile_source": "F0"}},
            sketch_by_source={"F0": sketch},
            sketches_by_id={sketch["id"]: sketch},
            entity_by_sketch={"F0": {"E0": {"type": "circle", "center": [0, 0], "radius_mm": 9.53}}},
            featurescript_version="1511",
        )

        self.assertIsNotNone(selector)
        self.assertNotIn("stable_id", selector)
        intent = selector["selector_intent"]
        self.assertEqual(intent["derivation_policy"], {"allowed": ["intersection"], "multiplicity": "one"})
        self.assertEqual(intent["intersection_sources"], [
            {"query_family": "CAP_FACE", "owner_feature_id": "f_F1", "output_role": "extrude.end"},
            {"query_family": "SWEPT_FACE", "owner_feature_id": "f_F2", "source_entity": {"sketch_id": "F0", "entity_id": "E0"}},
        ])

    def test_direct_primary_cut_intersection_requires_no_unverified_disambiguation(self):
        base = lower_model(parse_featurescript(SOURCE, "primary-intersection-intent"), {}).cdsl
        target = base["features"][0]
        target_sketch = base["geometry"]["sketches"][0]
        tool_sketch = deepcopy(target_sketch)
        tool_sketch.update({"id": "sketch_F2", "source_sketch_id": "F2"})
        if tool_sketch["profile"].get("type") == "circle":
            tool_sketch["profile"]["source_entity_id"] = "E1"
        else:
            for contour in tool_sketch["profile"]["contours"]:
                for segment in contour["segments"]:
                    segment["source_entity_id"] = "E1"
        tool = {
            "id": "f_F3", "atomic_id": "extrude_cut_blind", "sketch_id": "sketch_F2",
            "params": {"distance_mm": 10, "end_condition": {"type": "blind"}},
        }
        cap = Call("makeQuery", ["F1.opExtrude", "CAP_FACE", "EntityType.FACE", {"isStart": False}])
        tool_edge = Call("sQuery", ["F2.wireOp", "EntityType.EDGE", "E1"])
        swept = Call("makeQuery", [
            "F3.opExtrude", "SWEPT_FACE", "EntityType.FACE",
            {"disambiguationData": [Call("OSD", [[tool_edge]])]},
        ])
        query = Call("makeQuery", [
            "F3.boolean.opBoolean", "INTERSECT", "EntityType.EDGE", {"derivedFrom": [cap, swept]},
        ])
        kwargs = {
            "feature_by_id": {"f_F1": target, "f_F3": tool},
            "feature_frames": {"F3": {"profile_source": "F2"}},
            "sketch_by_source": {"F2": tool_sketch},
            "sketches_by_id": {tool_sketch["id"]: tool_sketch, target_sketch["id"]: target_sketch},
            "entity_by_sketch": {"F2": {"E1": {"type": "circle", "center": [0, 0], "radius_mm": 9.53}}},
            "previous": ["f_F1", "f_F3"],
            "featurescript_version": "1511",
        }
        selector = _direct_primary_cut_intersection_selector(query, **kwargs)

        self.assertIsNotNone(selector)
        self.assertEqual(selector["owner_feature_id"], "f_F3")
        self.assertEqual(selector["selector_intent"]["intersection_sources"][1], {
            "query_family": "SWEPT_FACE", "owner_feature_id": "f_F3",
            "source_entity": {"sketch_id": "F2", "entity_id": "E1"},
        })
        through_all = deepcopy(kwargs)
        through_all["feature_by_id"] = {
            **kwargs["feature_by_id"],
            "f_F3": {
                **tool,
                "params": {"distance_mm": 10, "end_condition": {"type": "through_all"}},
            },
        }
        self.assertIsNone(_direct_primary_cut_intersection_selector(query, **through_all))
        deferred = Call("makeQuery", [
            "F3.boolean.opBoolean", "INTERSECT", "EntityType.EDGE",
            {"derivedFrom": [cap, swept], "disambiguationData": [Call("OD", [0.0])]},
        ])
        self.assertIsNone(_direct_primary_cut_intersection_selector(deferred, **kwargs))

    def test_deferred_blend_edge_preserves_explicit_boolean_intersection_history(self):
        """A later unsupported blend query must not discard the F12 section intent."""
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0078/00789417.txt"
        if not feature.exists():
            self.skipTest("CADFS sample is not installed")

        result = lower_model(parse_featurescript(feature.read_text(encoding="utf-8"), "00789417"), {})

        self.assertEqual(result.status, "converted_partial")
        f12 = next(item for item in result.cdsl["features"] if item["id"] == "f_F12")
        section = f12["selectors"][0]["selector_intent"]
        self.assertEqual(section["query_family"], "INTERSECT")
        self.assertEqual(section["evidence"], "kernel_history")
        self.assertEqual(section["disambiguation"], {"type": "source_qualified_boolean_section"})
        f13 = next(item for item in result.cdsl["features"] if item["id"] == "f_F13")
        deferred = f13["selectors"][0]["selector_intent"]
        self.assertEqual(deferred["query_family"], "BLEND_EDGE")
        self.assertEqual(deferred["evidence"], "feature_script_query")
        self.assertEqual(deferred["derivation_policy"]["multiplicity"], "none")
        self.assertNotIn("blend_sources", deferred)
        from engine.cdsl_engine.semantic_validation import validate_semantic_cdsl
        self.assertTrue(validate_semantic_cdsl(result.cdsl)["future_rebuild_ready"])
        invalid = deepcopy(result.cdsl)
        invalid_f13 = next(item for item in invalid["features"] if item["id"] == "f_F13")
        invalid_f13["selectors"][0]["selector_intent"]["blend_sources"] = {
            "edge": {
                "query_family": "CAP_EDGE",
                "owner_feature_id": "f_F3",
                "source_entity": {"sketch_id": "F2", "entity_id": "E1"},
                "lineage_role": "extrude.end",
            },
            "face": {
                "query_family": "CAP_FACE",
                "owner_feature_id": "f_F3",
                "output_role": "extrude.end",
            },
        }
        with self.assertRaisesRegex(ValueError, "deferred BLEND_EDGE cannot declare transition sources"):
            validate_semantic_cdsl(invalid)

    def test_explicit_boolean_intersect_resolves_from_the_unique_cap_builder_snapshot(self):
        """A propagated CAP role must not shadow its original boolean input face."""
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0078/00789417.txt"
        if not feature.exists():
            self.skipTest("CADFS sample is not installed")

        from cadfs_to_cdsl.selector_binding import _bind_feature_selectors
        from engine.cdsl_engine.runtime import prepare_cdsl_execution

        candidate = lower_model(parse_featurescript(feature.read_text(encoding="utf-8"), "00789417"), {}).cdsl
        execution = prepare_cdsl_execution(candidate)
        self.assertTrue(execution.analysis.runtime_eligible)
        body_ids = {"__current__": None}

        for node in execution.analysis.plan:
            if node.feature_id == "f_F12":
                break
            _bind_feature_selectors(
                node.source_feature,
                registry=execution.session.topology,
                body_id_for_feature=body_ids,
            )
            execution.execute_next(strict=True)
            body_ids[node.feature_id] = execution.session.body_id
            body_ids["__current__"] = execution.session.body_id

        selector = next(feature for feature in candidate["features"] if feature["id"] == "f_F12")["selectors"][0]
        resolution = execution.session.topology.resolve(
            selector,
            active_body_id=body_ids["f_F10"],
        )
        self.assertEqual(resolution.status, "resolved")
        self.assertEqual(resolution.resolution_mode, "kernel_intersection")
        self.assertIsNotNone(resolution.record)
        self.assertEqual(
            len([item for item in resolution.evidence["relations"] if item["derivation"] == "intersection"]),
            1,
        )
        inactive = execution.session.topology.resolve(selector, active_body_id=body_ids["__current__"])
        self.assertEqual(inactive.status, "not_found")
        self.assertEqual(inactive.diagnostic.code, "selector_body_member_inactive")

    def test_deferred_primary_intersect_keeps_the_convertible_f3_checkpoint(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0002/00020311.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")

        result = lower_model(parse_featurescript(feature.read_text(), "00020311"), {})
        f4 = next(item for item in result.cdsl["features"] if item["id"] == "f_F4")
        self.assertTrue(all(
            selector["kind"] == "edge"
            and selector["selector_intent"]["query_family"] == "INTERSECT"
            and selector["selector_intent"]["derivation_policy"]["multiplicity"] == "none"
            for selector in f4["selectors"]
        ))
        from engine.cdsl_engine.semantic_validation import validate_semantic_cdsl
        self.assertTrue(validate_semantic_cdsl(result.cdsl)["future_rebuild_ready"])
        with tempfile.TemporaryDirectory() as directory:
            outcome = rebuild_candidate(result.cdsl, Path(directory) / "00020311.step")
            self.assertTrue((Path(directory) / "00020311.step").exists())
        self.assertEqual(outcome["status"], "rebuild_failed")
        self.assertEqual(outcome["error"]["message"], "f_F4: selector_query_unsupported during incremental replay")
        self.assertEqual(outcome["last_executable_prefix"]["last_feature_id"], "f_F3")

    def test_remove_sweep_lowers_to_a_cut_tool_without_selector_lineage(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        feature = root / "featurescript_rp/0025/00259897.txt"
        if not feature.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(feature.read_text(), "00259897"), {})
        sweep = next(item for item in result.cdsl["features"] if item["id"] == "f_F7")
        self.assertEqual(sweep["atomic_id"], "sweep_cut")
        self.assertNotIn("result_mode", sweep["params"])
        self.assertNotIn("swept_face_contract", sweep["params"])
        self.assertNotIn("swept_edge_contract", sweep["params"])
        self.assertNotIn({
            "code": "unsupported_engine_capability", "capability": "sweep_remove",
            "feature_id": "F7", "operation": "sweep",
            "message": "current CDSL sweep supports additive solid results only",
        }, result.diagnostics)

    def test_conversion_writes_status_and_sidecars(self):
        with tempfile.TemporaryDirectory() as tmp:
            root = Path(tmp); source = root / "00000173.txt"; source.write_text(SOURCE)
            sample = Sample("00000173", {"featurescript": str(source)}, {"featurescript": "x"})
            status = convert_one(sample, root / "out", force=True)
            directory = root / "out/samples/00000173"
            self.assertEqual(status["conversion_status"], "converted_complete")
            for name in ("candidate.cdsl.json", "history.json", "diagnostics.json", "status.json"):
                self.assertTrue((directory / name).exists(), name)
            self.assertEqual(json.loads((directory / "candidate.cdsl.json").read_text())["part_id"], "00000173")

    def test_conversion_separates_semantic_validation_failure_from_parse_failure(self):
        with tempfile.TemporaryDirectory() as tmp:
            root = Path(tmp); source = root / "00000173.txt"; source.write_text(SOURCE)
            sample = Sample("00000173", {"featurescript": str(source)}, {"featurescript": "x"})
            with patch(
                "engine.cdsl_engine.semantic_validation.validate_semantic_cdsl",
                side_effect=ValueError("semantic fixture rejection"),
            ):
                status = convert_one(sample, root / "out", force=True)
            directory = root / "out/samples/00000173"
            self.assertEqual(status["conversion_status"], "semantic_validation_failed")
            self.assertEqual(status["semantic_validation"]["error"]["message"], "semantic fixture rejection")
            self.assertFalse((directory / "candidate.cdsl.json").exists())
            self.assertTrue((directory / "candidate.invalid.cdsl.json").exists())
            self.assertTrue((directory / "history.json").exists())
            diagnostics = json.loads((directory / "diagnostics.json").read_text())
            self.assertIn({
                "code": "semantic_validation_failed",
                "message": "semantic fixture rejection",
                "type": "ValueError",
            }, diagnostics)

    def test_semantic_failure_preserves_and_rebuilds_a_separate_valid_prefix(self):
        from engine.cdsl_engine.semantic_validation import validate_semantic_cdsl

        with tempfile.TemporaryDirectory() as tmp:
            root = Path(tmp)
            source = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test/featurescript_rp/0096/00965724.txt"
            if not source.exists(): self.skipTest("CADFS sample is not installed")
            sample = Sample("00965724", {"featurescript": str(source)}, {"featurescript": "x"})
            validation_calls = 0

            def reject_complete_then_validate(cdsl):
                nonlocal validation_calls
                validation_calls += 1
                if validation_calls == 1:
                    raise ValueError("semantic fixture rejection")
                return validate_semantic_cdsl(cdsl)

            with patch(
                "engine.cdsl_engine.semantic_validation.validate_semantic_cdsl",
                side_effect=reject_complete_then_validate,
            ):
                status = convert_one(sample, root / "out", force=True)
            directory = root / "out/samples/00965724"
            self.assertEqual(status["conversion_status"], "semantic_validation_failed")
            self.assertFalse((directory / "candidate.cdsl.json").exists())
            self.assertTrue((directory / "candidate.invalid.cdsl.json").exists())
            self.assertTrue((directory / "candidate.prefix.cdsl.json").exists())
            self.assertEqual(status["semantic_valid_prefix"]["feature_count"], 1)

            rebuilt = rebuild_one(sample, root / "out")
            self.assertEqual(rebuilt["status"], "semantic_validation_failed")
            self.assertEqual(rebuilt["prefix_rebuild_status"], "rebuilt")
            self.assertTrue((directory / "prefix.rebuild.step").exists())

    def test_direct_blind_cap_face_dressup_role_is_not_misclassified_as_imprint_00998718(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        source = root / "featurescript_rp/0099/00998718.txt"
        if not source.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(source.read_text(), "00998718"), {})
        cap = next(item for item in result.cdsl["features"] if item["id"] == "f_F8")["selectors"][1]
        self.assertEqual(cap["owner_feature_id"], "f_F7")
        self.assertEqual(cap["output_role"], "extrude.end")
        from engine.cdsl_engine.semantic_validation import validate_semantic_cdsl
        self.assertTrue(validate_semantic_cdsl(result.cdsl)["future_rebuild_ready"])

    def test_query_set_cap_face_output_roles_inherit_the_dressup_selector_slot_00965724(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        source = root / "featurescript_rp/0096/00965724.txt"
        if not source.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(source.read_text(), "00965724"), {})
        chamfer = next(item for item in result.cdsl["features"] if item["id"] == "f_F2")
        query_set = chamfer["selectors"][0]
        self.assertEqual(query_set["selector_intent"]["query_family"], "QUERY_SET")
        self.assertEqual(
            [item["output_role"] for item in query_set["query_operands"]],
            ["extrude.start", "extrude.end"],
        )
        from engine.cdsl_engine.semantic_validation import validate_semantic_cdsl
        self.assertTrue(validate_semantic_cdsl(result.cdsl)["future_rebuild_ready"])

        invalid = deepcopy(result.cdsl)
        invalid["features"][1]["selectors"][0]["query_operands"][1]["owner_feature_id"] = "f_missing"
        with self.assertRaisesRegex(ValueError, "forward or missing owner_feature_id"):
            validate_semantic_cdsl(invalid)

    def test_dressup_with_an_omitted_selector_owner_defers_before_semantic_validation_00508029(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        source = root / "featurescript_rp/0050/00508029.txt"
        if not source.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(source.read_text(), "00508029"), {})
        self.assertEqual(result.status, "converted_partial")
        self.assertNotIn("f_F16", {item["id"] for item in result.cdsl["features"]})
        self.assertIn({
            "code": "unsupported_engine_capability",
            "capability": "selector_owner_unavailable",
            "feature_id": "F16",
            "operation": "chamfer",
            "message": "selector owner F14 has no executable CDSL producer",
        }, result.diagnostics)
        from engine.cdsl_engine.semantic_validation import validate_semantic_cdsl
        self.assertTrue(validate_semantic_cdsl(result.cdsl)["future_rebuild_ready"])

    def test_unproven_extent_face_is_deferred_instead_of_stable_id_bound_00002892(self):
        root = Path(__file__).parents[2] / "data/cadfs-sample/CADFS_test"
        source = root / "featurescript_rp/0000/00002892.txt"
        if not source.exists(): self.skipTest("CADFS sample is not installed")
        result = lower_model(parse_featurescript(source.read_text(), "00002892"), {})
        self.assertNotIn("f_F3", {feature["id"] for feature in result.cdsl["features"]})
        self.assertIn({
            "code": "unsupported_engine_capability",
            "capability": "extrude_extent_face_selector",
            "feature_id": "F3",
            "operation": "extrude",
            "message": "current CDSL face extent requires a complete/proven active selector reference",
        }, result.diagnostics)
        from engine.cdsl_engine.semantic_validation import validate_semantic_cdsl
        self.assertTrue(validate_semantic_cdsl(result.cdsl)["future_rebuild_ready"])

    def test_force_rebuild_refreshes_the_candidate_from_source(self):
        with tempfile.TemporaryDirectory() as tmp:
            root = Path(tmp); source = root / "00000173.txt"; source.write_text(SOURCE)
            sample = Sample("00000173", {"featurescript": str(source)}, {"featurescript": "x"})
            directory = root / "out/samples/00000173"; directory.mkdir(parents=True)
            (directory / "candidate.cdsl.json").write_text(json.dumps({"part_id": "stale"}), encoding="utf-8")
            (directory / "status.json").write_text(json.dumps({"sample_id": sample.sample_id}), encoding="utf-8")
            status = rebuild_one(sample, root / "out", force=True)
            self.assertEqual(status["rebuild_status"], "rebuilt")
            self.assertEqual(json.loads((directory / "candidate.cdsl.json").read_text())["part_id"], "00000173")


if __name__ == "__main__": unittest.main()