@shundoo-ai/dsh-cosmic 1.0.19 → 1.0.21

package/skills/cosmic-build/skills/cosmic-meta-api/scripts/test/test_rule_write_closure.py

@@ -126,7 +126,862 @@ def _biz_rule(action):
     }
 
 
+class RuleEventMergeTest(unittest.TestCase):
+    def test_creation_and_value_update_names_do_not_select_after_events(self):
+        self.assertEqual(5, rule_contract.select_action_events(
+            "TakeBaseProAction", ["创建", "值更新"],
+        ))
+        self.assertEqual(5, rule_contract.select_action_events(
+            "TakeBaseProAction", ["create", "update"],
+        ))
+        self.assertEqual(256, rule_contract.select_action_events(
+            "TakeBaseProAction", ["创建后"],
+        ))
+
+    def test_semantic_events_compile_for_business_and_interface_services(self):
+        biz = rule_contract.normalize_biz_rule_action({
+            "actionType": "FormulaAction", "expression": "amount = qty * price",
+            "events": ["AfterCreate", "FieldChange"],
+        })
+        self.assertEqual(257, biz["RET"])
+        self.assertNotIn("events", biz)
+        form = rule_contract.normalize_form_rule_action({
+            "actionType": "HideFieldAction", "fields": ["price"],
+            "events": ["AfterCreate", "FieldChange"],
+        })
+        self.assertEqual(257, form["RET"])
+        self.assertNotIn("events", form)
+        with self.assertRaisesRegex(ValueError, "RULE_EVENT_BASE_RET_REQUIRED"):
+            rule_contract.normalize_biz_rule_action({
+                "actionType": "FormulaAction", "expression": "amount = qty * price",
+                "addEvents": ["AfterCopy"],
+            })
+
+    @patch.object(cmd_rules, "do_ensure_conditional_clear_fields")
+    def test_batch_forwards_named_events(self, writer):
+        item = cmd_rules._validate_rule_set_request({"rules": [{
+            "command": "ensureConditionalClearFields",
+            "args": {"conditionField": "数量", "operator": "greater-than", "value": "2",
+                     "targets": ["单价"], "addEvents": ["AfterCopy"]},
+        }]})[0]
+        cmd_rules._execute_rule_set_item({}, "token", "demo", item)
+        self.assertEqual(["AfterCopy"], writer.call_args.args[-2])
+
+    def test_batch_accepts_exact_events_for_every_rule_service(self):
+        samples = {
+            "ensureRuleFunctionFormula": {"target": "金额", "call": {"functionId": "round", "args": []}},
+            "ensureConditionalControlState": {"conditionField": "状态", "operator": "equals", "value": "A", "targetControl": "按钮", "behavior": "hide"},
+            "ensureConditionalClearFields": {"conditionField": "数量", "operator": "greater-than", "value": "10", "targets": ["单价"]},
+            "ensureConditionalFieldChange": {"conditionField": "物料", "operator": "not-empty", "target": "单价"},
+            "ensureConditionalCopyFieldValue": {"conditionField": "状态", "operator": "equals", "value": "A", "source": "来源", "target": "目标"},
+            "ensureConditionalCalculation": {"conditionField": "状态", "operator": "equals", "value": "A", "target": "金额", "left": "数量", "calculation": "multiply", "right": "单价"},
+            "ensureConditionalCarryReferenceProperty": {"sourceReference": "客户", "sourceProperty": "名称", "target": "客户名"},
+            "ensureQuantityConversion": {"sourceQty": "数量", "targetQty": "换算数量"},
+        }
+        for command, args in samples.items():
+            with self.subTest(command=command):
+                item = cmd_rules._validate_rule_set_request({"rules": [{
+                    "command": command, "args": {**args, "events": ["AfterCreate", "FieldChange"]},
+                }]})[0]
+                self.assertEqual(["AfterCreate", "FieldChange"], item["args"]["events"])
+        client = cmd_rules._validate_rule_set_request({"rules": [{
+            "command": "ensureConditionalClientAppearance",
+            "args": {"request": {"clientMount": "list", "conditionField": "状态",
+                                 "operator": "equals", "value": "A",
+                                 "effects": [{"kind": "rowStyle", "background": "#FFFFFF"}],
+                                 "events": ["AfterCreate", "FieldChange"]}},
+        }]})[0]
+        self.assertEqual(["AfterCreate", "FieldChange"], client["args"]["request"]["events"])
+
+    def test_batch_forwards_timings_to_formula_copy_and_control_services(self):
+        for command, writer, args in (
+            ("ensureConditionalCalculation", "do_ensure_conditional_calculation",
+             {"conditionField": "状态", "operator": "equals", "value": "A",
+              "target": "金额", "left": "数量", "calculation": "multiply", "right": "单价"}),
+            ("ensureConditionalCopyFieldValue", "do_ensure_conditional_copy_field_value",
+             {"conditionField": "状态", "operator": "equals", "value": "A",
+              "source": "来源", "target": "目标"}),
+            ("ensureConditionalControlState", "do_ensure_conditional_control_state",
+             {"conditionField": "状态", "operator": "equals", "value": "A",
+              "targetControl": "按钮", "behavior": "hide"}),
+        ):
+            with self.subTest(command=command), patch.object(cmd_rules, writer) as write:
+                item = cmd_rules._validate_rule_set_request({"rules": [{
+                    "command": command, "args": {**args, "events": ["AfterCopy"]},
+                }]})[0]
+                cmd_rules._execute_rule_set_item({}, "token", "demo", item)
+                self.assertEqual(["AfterCopy"], write.call_args.args[-1])
+
+    def test_existing_generic_service_adds_timing_without_replacing_actions(self):
+        rule = {
+            "_Type_": "BizRule", "Id": "rule-1", "Description": "计算金额",
+            "TrueActions": [{"Id": "action-1", "ActionType": "FormulaAction",
+                             "Expression": "amount = qty * price", "RET": 253}],
+            "FalseActions": [],
+        }
+        with patch.object(cmd_rules, "do_update_rule_verified", return_value={
+            "status": True, "data": {},
+        }) as write, patch.object(cmd_rules, "do_load_full_metadata", return_value={
+            "status": True, "data": {"Rules": [{
+                **rule, "TrueActions": [{**rule["TrueActions"][0],
+                                         "Id": "new-action-id", "RET": 1277}],
+            }]},
+        }):
+            result = cmd_rules._reconcile_existing_rule_events(
+                {}, "token", "demo", rule, "bizRule", add_events=["AfterCopy"],
+            )
+        self.assertTrue(result["verification"]["preservationVerified"])
+        self.assertEqual(1277, write.call_args.args[-1]["trueActions"][0]["RET"])
+        self.assertEqual(253, rule["TrueActions"][0]["RET"])
+
+    def test_existing_generic_service_refuses_implicit_timing_replacement(self):
+        rule = {"Id": "rule-1", "TrueActions": [{"ActionType": "FormulaAction", "RET": 253}],
+                "FalseActions": []}
+        result = cmd_rules._reconcile_existing_rule_events(
+            {}, "token", "demo", rule, "bizRule", events=["AfterCopy"],
+        )
+        self.assertEqual("RULE_EVENT_REPLACE_REQUIRES_RULE_ID", result["errorCode"])
+        self.assertFalse(result["writeAttempted"])
+
+
+class ReferenceCardinalityTest(unittest.TestCase):
+    def test_department_entry_is_rejected_before_any_write_in_both_carry_routes(self):
+        def api(_cfg, _token, endpoint, payload, method="GET"):
+            if endpoint == "getFormSchema":
+                return {"status": True, "data": {"formNumber": "bos_user"}}
+            if endpoint == "getEntityFields":
+                return {"status": True, "data": {
+                    "headerFields": {"headerKey": "bos_user", "fields": []},
+                    "entryFields": {"entryentity": {"entryKey": "entryentity", "fields": [
+                        {"key": "dpt", "name": "部门", "type": "OrgField"},
+                    ]}},
+                }}
+            raise AssertionError(endpoint)
+
+        def elements(*args, **kwargs):
+            return {"status": True, "data": (
+                [{"key": "demo", "name": "单据头", "id": "header-id", "type": "BillEntity"}]
+                if kwargs["category"] == "entity" else [
+                    {"key": "applicant", "name": "申请人", "type": "UserField", "parentKey": "demo"},
+                    {"key": "dept", "name": "申请部门", "type": "OrgField", "parentKey": "demo"},
+                ])}
+
+        for declared in ([], [{"name": "dpt"}]):
+            for batch in (False, True):
+                with self.subTest(declared=declared, batch=batch), patch.object(
+                    cmd_rules, "_api_call", side_effect=api,
+                ), patch.object(cmd_rules, "do_list_elements", side_effect=elements), patch.object(
+                    cmd_rules, "do_get_properties", return_value={"status": True, "data": {
+                        "baseEntityId": "user-id", "refProps": declared,
+                    }},
+                ), patch.object(cmd_rules, "do_set_ref_props") as ref_write, patch.object(
+                    cmd_rules, "do_add_rule_verified",
+                ) as rule_write:
+                    with self.assertRaisesRegex(ValueError, "CARRY_REFERENCE_COLLECTION_UNSUPPORTED.*entryentity"):
+                        if batch:
+                            cmd_rules.do_ensure_carry_reference_mappings({}, "token", "demo", {"mappings": [{
+                                "sourceReference": "申请人", "sourceProperty": "dpt", "target": "申请部门",
+                            }]})
+                        else:
+                            cmd_rules.do_ensure_conditional_carry_reference_property(
+                                {}, "token", "demo", None, None, None, None, "申请人", "dpt", "申请部门",
+                            )
+                    ref_write.assert_not_called()
+                    rule_write.assert_not_called()
+
+
+class MultiMappingRuleTest(unittest.TestCase):
+    def test_mapping_cli_accepts_condition_flags_alongside_input(self):
+        from types import SimpleNamespace
+        from cosmic_api import _load_mapping_request
+
+        args = SimpleNamespace(
+            input_file='{"mappings":[{"sourceReference":"物料","sourceProperty":"分类","target":"原分类"}]}',
+            entity=None, condition_field="是否启用带出", operator="equals",
+            value="true", events=["create", "update"], add_events=None,
+        )
+        request = _load_mapping_request(args)
+        self.assertEqual("是否启用带出", request["conditionField"])
+        self.assertEqual(["create", "update"], request["events"])
+        args.input_file = '{"mappings":[],"conditionField":"另一个条件"}'
+        with self.assertRaisesRegex(ValueError, "conflicts"):
+            _load_mapping_request(args)
+
+    @patch.object(cmd_rules, "do_add_rule_verified")
+    @patch.object(cmd_rules, "do_load_full_metadata")
+    @patch.object(cmd_rules, "do_set_ref_props")
+    @patch.object(cmd_rules, "_reference_entity_field_candidates")
+    @patch.object(cmd_rules, "do_get_properties")
+    @patch.object(cmd_rules, "do_list_elements")
+    def test_same_reference_multiple_missing_properties_are_prepared_once(
+        self, list_elements, get_properties, reference_fields, set_ref_props,
+        load_full, add_verified,
+    ):
+        list_elements.side_effect = lambda *args, **kwargs: {
+            "status": True,
+            "data": ([{"key": "demo", "name": "验证单", "id": "entity-id", "type": "BillEntity"}]
+                     if kwargs["category"] == "entity" else [
+                         {"key": key, "name": key, "parentKey": "demo", "type": "TextField"}
+                         for key in ("material", "old_group", "new_group", "old_name", "new_name")
+                     ]),
+        }
+        get_properties.return_value = {"status": True, "data": {
+            "refProps": "[]", "baseEntityId": "material-id",
+        }}
+        reference_fields.return_value = [
+            {"key": "groupid", "name": "分类"},
+            {"key": "name", "name": "名称"},
+        ]
+        set_ref_props.return_value = {"status": True, "verification": {"verified": True}}
+        load_full.return_value = {"status": True, "data": {"entitymeta": {"Items": []}}}
+        add_verified.return_value = {"status": True, "data": {"ruleId": "rule-1"},
+                                     "verification": {"verified": True}}
+        request = {"events": ["create", "update"], "mappings": [
+            {"sourceReference": "material", "sourceProperty": "分类", "target": "old_group"},
+            {"sourceReference": "material", "sourceProperty": "分类", "target": "new_group"},
+            {"sourceReference": "material", "sourceProperty": "名称", "target": "old_name"},
+            {"sourceReference": "material", "sourceProperty": "名称", "target": "new_name"},
+        ]}
+        result = cmd_rules.do_ensure_carry_reference_mappings({}, "token", "demo", request)
+        self.assertTrue(result["status"])
+        reference_fields.assert_called_once_with({}, "token", "material-id")
+        get_properties.assert_called_once_with({}, "token", "demo", "material", ["RefProps", "BaseEntityId"])
+        self.assertEqual(4, len(add_verified.call_args.args[3]["trueActions"][0]["expression"]))
+        self.assertEqual(5, add_verified.call_args.args[3]["trueActions"][0]["ret"])
+        set_ref_props.assert_called_once_with(
+            {}, "token", "demo", "material", [{"name": "groupid"}, {"name": "name"}],
+        )
+
+        set_ref_props.reset_mock()
+        add_verified.reset_mock()
+        request["mappings"][2]["sourceProperty"] = "核心名称"
+        with self.assertRaisesRegex(ValueError, "CONDITIONAL_CARRY_SOURCE_PROPERTY_UNAVAILABLE"):
+            cmd_rules.do_ensure_carry_reference_mappings({}, "token", "demo", request)
+        set_ref_props.assert_not_called()
+        add_verified.assert_not_called()
+
+    def test_raw_carry_action_keeps_multiple_mapping_rows(self):
+        action = rule_contract.normalize_biz_rule_action({
+            "actionType": "TakeBaseProAction",
+            "expression": [
+                {"targetField": "old_category", "srcField": "material.category"},
+                {"targetField": "new_category", "srcField": "material.category"},
+            ],
+            "fieldName": [
+                {"targetFieldName": "原分类", "srcFieldName": "物料.分类"},
+                {"targetFieldName": "新分类", "srcFieldName": "物料.分类"},
+            ],
+        })
+        self.assertEqual(2, len(action["Expression"]))
+        self.assertEqual(2, len(action["FieldName"]))
+        with self.assertRaisesRegex(ValueError, "LENGTH_MISMATCH"):
+            rule_contract.normalize_biz_rule_action({
+                "actionType": "TakeBaseProAction",
+                "expression": [
+                    {"targetField": "old_category", "srcField": "material.category"},
+                    {"targetField": "new_category", "srcField": "material.category"},
+                ],
+                "fieldName": [{"targetFieldName": "原分类", "srcFieldName": "物料.分类"}],
+            })
+
+    @patch.object(cmd_rules, "do_list_elements")
+    def test_copy_scope_checks_every_mapping_row(self, list_elements):
+        list_elements.return_value = {"status": True, "data": [
+            {"key": "source", "parentKey": "uhyl_demo"},
+            {"key": "target", "parentKey": "uhyl_demo"},
+        ]}
+        requested = _biz_rule({
+            "actionType": "SetEqutionAction",
+            "expression": [{"targetField": "target", "srcField": "source"},
+                           {"targetField": "missing_target", "srcField": "source"}],
+            "fieldName": [{"targetFieldName": "目标(target)", "srcFieldName": "来源(source)"},
+                          {"targetFieldName": "缺失(missing_target)", "srcFieldName": "来源(source)"}],
+        })
+        with self.assertRaisesRegex(ValueError, "RULE_SET_EQUATION_FIELD_UNRESOLVED.*missing_target"):
+            cmd_rules._validate_set_equation_action_scope({}, "token", "demo", requested)
+        with self.assertRaisesRegex(ValueError, "DUPLICATE_TARGET"):
+            rule_contract.normalize_biz_rule_action({
+                "actionType": "SetEqutionAction",
+                "expression": [
+                    {"targetField": "target", "srcField": "first"},
+                    {"targetField": "target", "srcField": "second"},
+                ],
+                "fieldName": [
+                    {"targetFieldName": "目标一", "srcFieldName": "来源一"},
+                    {"targetFieldName": "目标二", "srcFieldName": "来源二"},
+                ],
+            })
+
+    @patch.object(cmd_rules, "do_add_rule_verified")
+    @patch.object(cmd_rules, "do_load_full_metadata")
+    @patch.object(cmd_rules, "do_list_elements")
+    def test_semantic_copy_writes_one_service_with_two_mapping_rows(
+        self, list_elements, load_full, add_verified,
+    ):
+        list_elements.side_effect = lambda *args, **kwargs: {
+            "status": True,
+            "data": ([{"key": "demo", "name": "主实体", "id": "entity-id", "type": "MainEntity"}]
+                     if kwargs["category"] == "entity" else [
+                         {"key": key, "name": key, "parentKey": "demo", "type": "TextField"}
+                         for key in ("old_value", "new_value", "old_target", "new_target")
+                     ]),
+        }
+        load_full.return_value = {"status": True, "data": {"entitymeta": {"Items": []}}}
+        add_verified.return_value = {"status": True, "data": {"ruleId": "copy-rule"},
+                                     "verification": {"verified": True}}
+        request = {"mappings": [
+            {"source": "old_value", "target": "old_target"},
+            {"source": "new_value", "target": "new_target"},
+        ]}
+        result = cmd_rules.do_ensure_copy_field_mappings({}, "token", "demo", request)
+        self.assertTrue(result["writeAttempted"])
+        action = add_verified.call_args.args[3]["trueActions"][0]
+        self.assertEqual("SetEqutionAction", action["actionType"])
+        self.assertEqual(2, len(action["expression"]))
+        self.assertEqual(2, len(action["fieldName"]))
+        payload = add_verified.call_args.args[3]
+        false_result = cmd_rules.do_ensure_copy_field_mappings(
+            {}, "token", "demo", {**request, "branch": "false"},
+        )
+        self.assertTrue(false_result["writeAttempted"])
+        false_payload = add_verified.call_args.args[3]
+        self.assertEqual([], false_payload["trueActions"])
+        self.assertEqual(1, len(false_payload["falseActions"]))
+        cmd_rules._validate_rule_write_input(false_payload, command="addRule")
+        compiled = cmd_rules.normalize_rule_config(payload)
+        split = {"_Type_": "BizRule", "Id": "copy-rule", "ItemId": "entity-id",
+                 "PreCondition": payload["preCondition"], "TriggerField": payload["triggerField"],
+                 "TrueActions": [
+                     {**compiled["trueActions"][0], "Expression": [mapping],
+                      "FieldName": [compiled["trueActions"][0]["FieldName"][index]]}
+                     for index, mapping in enumerate(compiled["trueActions"][0]["Expression"])
+                 ], "FalseActions": []}
+        load_full.return_value = {"status": True, "data": {"entitymeta": {"Items": [split]}}}
+        with patch.object(cmd_rules, "do_update_rule_verified", return_value={
+            "status": True, "data": {}, "verification": {"verified": True},
+        }) as update:
+            consolidated = cmd_rules.do_ensure_copy_field_mappings(
+                {}, "token", "demo", {**request, "ruleId": "copy-rule"},
+            )
+        self.assertTrue(consolidated["writeAttempted"])
+        self.assertEqual(1, len(update.call_args.args[3]["trueActions"]))
+        self.assertEqual(2, len(update.call_args.args[3]["trueActions"][0]["expression"]))
+        false_compiled = cmd_rules.normalize_rule_config(false_payload)
+        false_split = {**split, "TrueActions": [], "FalseActions": [
+            {**false_compiled["falseActions"][0], "Expression": [mapping],
+             "FieldName": [false_compiled["falseActions"][0]["FieldName"][index]]}
+            for index, mapping in enumerate(false_compiled["falseActions"][0]["Expression"])
+        ]}
+        load_full.return_value = {"status": True, "data": {"entitymeta": {"Items": [false_split]}}}
+        with patch.object(cmd_rules, "do_update_rule_verified", return_value={
+            "status": True, "data": {}, "verification": {"verified": True},
+        }) as update:
+            cmd_rules.do_ensure_copy_field_mappings(
+                {}, "token", "demo", {**request, "branch": "false", "ruleId": "copy-rule"},
+            )
+        self.assertEqual(1, len(update.call_args.args[3]["falseActions"]))
+        self.assertEqual(2, len(update.call_args.args[3]["falseActions"][0]["expression"]))
+        load_full.return_value = {"status": True, "data": {"entitymeta": {"Items": [
+            {**split, "TrueActions": [split["TrueActions"][0]]},
+        ]}}}
+        overlap = cmd_rules.do_ensure_copy_field_mappings({}, "token", "demo", request)
+        self.assertEqual("COPY_MAPPINGS_TARGET_OVERLAP", overlap["errorCode"])
+        with self.assertRaisesRegex(ValueError, "COPY_MAPPINGS_TARGET_CONFLICT"):
+            cmd_rules.do_ensure_copy_field_mappings({}, "token", "demo", {
+                "mappings": [{"source": "old_value", "target": "old_target"},
+                             {"source": "new_value", "target": "old_target"}],
+            })
+
+    def test_rule_set_forwards_mapping_arrays_as_one_service_request(self):
+        for command, writer, mappings in (
+            ("ensureConditionalCarryReferenceProperty", "do_ensure_carry_reference_mappings",
+             [{"sourceReference": "物料", "sourceProperty": "分类", "target": "原分类"},
+              {"sourceReference": "物料", "sourceProperty": "分类", "target": "新分类"}]),
+            ("ensureConditionalCopyFieldValue", "do_ensure_copy_field_mappings",
+             [{"source": "旧值", "target": "原值"},
+              {"source": "新值", "target": "变更后值"}]),
+        ):
+            with self.subTest(command=command), patch.object(cmd_rules, writer) as write:
+                item = cmd_rules._validate_rule_set_request({"rules": [{
+                    "command": command, "args": {"mappings": mappings},
+                }]})[0]
+                cmd_rules._execute_rule_set_item({}, "token", "demo", item)
+                self.assertEqual(mappings, write.call_args.args[-1]["mappings"])
+
+    @patch.object(cmd_rules, "do_add_rule_verified")
+    @patch.object(cmd_rules, "do_load_full_metadata")
+    @patch.object(cmd_rules, "do_get_properties")
+    @patch.object(cmd_rules, "do_list_elements")
+    @patch.object(cmd_rules, "_reference_entity_field_candidates", return_value=[{
+        "key": "linkman", "name": "联系人", "type": "TextField", "referenceCollection": False,
+    }, {"key": "number", "name": "编码", "type": "TextField", "referenceCollection": False},
+       {"key": "category", "name": "分类", "type": "BasedataField", "referenceCollection": False}])
+    def test_semantic_carry_writes_one_service_with_two_mapping_rows(
+        self, reference_fields, list_elements, get_properties, load_full, add_verified,
+    ):
+        list_elements.side_effect = lambda *args, **kwargs: {
+            "status": True,
+            "data": ([{"key": "demo", "name": "主实体", "id": "entity-id", "type": "MainEntity"}]
+                     if kwargs["category"] == "entity" else [
+                         {"key": key, "name": key, "parentKey": "demo", "type": "TextField"}
+                         for key in ("material", "item", "old_category", "new_category")
+                     ]),
+        }
+        get_properties.return_value = {"status": True, "data": {"refProps": '[{"name":"category"}]', "baseEntityId": "reference-id"}}
+        load_full.return_value = {"status": True, "data": {"entitymeta": {"Items": []}}}
+        add_verified.return_value = {"status": True, "data": {"ruleId": "rule-1"},
+                                     "verification": {"verified": True}}
+        request = {"mappings": [
+            {"sourceReference": "material", "sourceProperty": "category", "target": "old_category"},
+            {"sourceReference": "item", "sourceProperty": "category", "target": "new_category"},
+        ]}
+        created = cmd_rules.do_ensure_carry_reference_mappings({}, "token", "demo", request)
+        self.assertTrue(created["writeAttempted"])
+        payload = add_verified.call_args.args[3]
+        self.assertEqual(1, len(payload["trueActions"]))
+        self.assertEqual(2, len(payload["trueActions"][0]["expression"]))
+        self.assertEqual(2, len(payload["trueActions"][0]["fieldName"]))
+        self.assertEqual("material(material);item(item)", payload["triggerField"])
+        false_result = cmd_rules.do_ensure_carry_reference_mappings(
+            {}, "token", "demo", {**request, "branch": "false"},
+        )
+        self.assertTrue(false_result["writeAttempted"])
+        false_payload = add_verified.call_args.args[3]
+        self.assertEqual([], false_payload["trueActions"])
+        self.assertEqual(2, len(false_payload["falseActions"][0]["expression"]))
+        cmd_rules._validate_rule_write_input(false_payload, command="addRule")
+
+        compiled = cmd_rules.normalize_rule_config(payload)
+        stored = {"_Type_": "BizRule", "Id": "rule-1", "ItemId": "entity-id",
+                  "PreCondition": payload["preCondition"], "TriggerField": payload["triggerField"],
+                  "TrueActions": compiled["trueActions"], "FalseActions": []}
+        load_full.return_value = {"status": True, "data": {"entitymeta": {"Items": [stored]}}}
+        add_verified.reset_mock()
+        repeated = cmd_rules.do_ensure_carry_reference_mappings({}, "token", "demo", request)
+        self.assertFalse(repeated["writeAttempted"])
+        add_verified.assert_not_called()
+
+        stored["TrueActions"] = [
+            {**compiled["trueActions"][0], "Expression": [mapping],
+             "FieldName": [compiled["trueActions"][0]["FieldName"][index]]}
+            for index, mapping in enumerate(compiled["trueActions"][0]["Expression"])
+        ]
+        load_full.return_value = {"status": True, "data": {"entitymeta": {"Items": [stored]}}}
+        blocked = cmd_rules.do_ensure_carry_reference_mappings({}, "token", "demo", request)
+        self.assertEqual("CARRY_MAPPINGS_CONSOLIDATION_REQUIRES_RULE_ID", blocked["errorCode"])
+        with patch.object(cmd_rules, "do_update_rule_verified", return_value={
+            "status": True, "data": {}, "verification": {"verified": True},
+        }) as update:
+            consolidated = cmd_rules.do_ensure_carry_reference_mappings(
+                {}, "token", "demo", {**request, "ruleId": "rule-1"},
+            )
+        self.assertTrue(consolidated["writeAttempted"])
+        self.assertEqual(1, len(update.call_args.args[3]["trueActions"]))
+        self.assertEqual(2, len(update.call_args.args[3]["trueActions"][0]["expression"]))
+        load_full.return_value = {"status": True, "data": {"entitymeta": {"Items": [
+            {**stored, "TrueActions": [stored["TrueActions"][0]]},
+        ]}}}
+        overlap = cmd_rules.do_ensure_carry_reference_mappings({}, "token", "demo", request)
+        self.assertEqual("CARRY_MAPPINGS_TARGET_OVERLAP", overlap["errorCode"])
+
+    @patch.object(cmd_rules, "do_ensure_conditional_field_change")
+    def test_batch_forwards_field_change_request(self, writer):
+        item = cmd_rules._validate_rule_set_request({"rules": [{
+            "command": "ensureConditionalFieldChange",
+            "args": {"conditionField": "物料", "operator": "not-empty",
+                     "target": "单价", "addEvents": ["AfterCopy"]},
+        }]})[0]
+        cmd_rules._execute_rule_set_item({}, "token", "demo", item)
+        self.assertEqual(["AfterCopy"], writer.call_args.args[-2])
+        exact = cmd_rules._validate_rule_set_request({"rules": [{
+            "command": "ensureConditionalFieldChange",
+            "args": {"conditionField": "物料", "operator": "not-empty",
+                     "target": "单价", "events": ["FieldChanged", "AfterCopy"]},
+        }]})[0]
+        cmd_rules._execute_rule_set_item({}, "token", "demo", exact)
+        self.assertEqual(["FieldChanged", "AfterCopy"], writer.call_args.args[-1])
+        with self.assertRaisesRegex(ValueError, "RULE_EVENTS_INVALID"):
+            cmd_rules._validate_rule_set_request({"rules": [{
+                "command": "ensureConditionalFieldChange",
+                "args": {"conditionField": "物料", "operator": "not-empty",
+                         "target": "单价", "addEvents": "AfterCopy"},
+            }]})
+        with self.assertRaisesRegex(ValueError, "mixes events and addEvents"):
+            cmd_rules._validate_rule_set_request({"rules": [{
+                "command": "ensureConditionalFieldChange",
+                "args": {"conditionField": "物料", "operator": "not-empty",
+                         "target": "单价", "events": ["FieldChanged"],
+                         "addEvents": ["AfterCopy"]},
+            }]})
+        self.assertEqual(2, writer.call_count)
+
+    @patch.object(cmd_rules, "do_add_rule_verified")
+    def test_related_field_change_condition_requires_rule_selection(self, add_verified):
+        self.rules.append({
+            "_Type_": "BizRule", "Id": "other-rule", "ItemId": "entity-id",
+            "PreCondition": "qty <> null", "TriggerField": "数量(qty)",
+            "TrueActions": [{"ActionType": "CallFieldChangeAction",
+                             "Expression": "price", "RET": 773}],
+            "FalseActions": [],
+        })
+        result = cmd_rules.do_ensure_conditional_field_change(
+            {}, "token", "demo", None, "数量", "greater-than", "2",
+            "单价", ["AfterCopy"],
+        )
+        self.assertEqual("RULE_CONDITION_UPDATE_REQUIRES_RULE_ID", result["errorCode"])
+        self.assertEqual("other-rule", result["data"]["candidates"][0]["ruleId"])
+        add_verified.assert_not_called()
+
+    @patch.object(cmd_rules, "_api_call")
+    def test_tagged_field_change_rule_is_renamed_in_place(self, api_call):
+        description = "数量 greater-than 2时调用单价字段值更新服务"
+        digest = hashlib.sha1("demo:demo:qty > 2:price".encode("utf-8")).hexdigest()[:12]
+        action = {"ActionType": "CallFieldChangeAction", "Expression": "price",
+                  "RET": 773, "Id": "action-id", "IsvFlag": "owner", "Seq": 1}
+        self.rules.append({
+            "_Type_": "BizRule", "Id": "rule-id", "ItemId": "entity-id",
+            "Description": f"{description} [CFC_{digest}]",
+            "PreDescription": description, "PreCondition": "qty > 2",
+            "TriggerField": "数量(qty)", "Enabled": True,
+            "TrueActions": [action], "FalseActions": [],
+        })
+        def write(_cfg, _token, command, payload, **kwargs):
+            self.assertEqual("updateRule", command)
+            self.rules[0]["Description"] = payload["description"]
+            return {"status": True, "data": {"ruleId": "rule-id"}}
+        api_call.side_effect = write
+
+        result = cmd_rules.do_ensure_conditional_field_change(
+            {}, "token", "demo", None, "数量", "greater-than", "2", "单价",
+        )
+        self.assertTrue(result["verification"]["preservationVerified"])
+        self.assertEqual(description, self.rules[0]["Description"])
+        self.assertEqual("rule-id", self.rules[0]["Id"])
+        self.assertEqual("action-id", self.rules[0]["TrueActions"][0]["Id"])
+        api_call.assert_called_once()
+
+    def setUp(self):
+        self.rules = []
+        self.context = {
+            "entityKey": "demo", "entityId": "entity-id",
+            "expression": "qty > 2", "conditionName": "数量",
+            "conditionKey": "qty", "conditionEntityKey": "demo",
+            "targetKey": "price", "targetName": "单价",
+            "operator": "greater-than", "requestedValue": "2",
+            "legacyBooleanExpression": None, "legacyEmptyExpression": None,
+            "fieldRows": [{"key": "price", "name": "单价", "parentKey": "demo"}],
+        }
+        self.context_patch = patch.object(
+            cmd_rules, "_resolve_conditional_context", return_value=self.context,
+        )
+        self.context_patch.start()
+        self.addCleanup(self.context_patch.stop)
+        reader = patch.object(cmd_rules, "do_load_full_metadata", side_effect=lambda *a: {
+            "status": True, "data": {"entitymeta": {"Items": copy.deepcopy(self.rules)}},
+        })
+        reader.start()
+        self.addCleanup(reader.stop)
+
+    def create(self, events=None):
+        def add(_cfg, _token, _form, requested):
+            compiled = rule_contract.normalize_rule_config(requested)
+            self.rules.append({
+                "_Type_": "BizRule", "Id": "rule-id", "ISV": "original-isv",
+                "Description": requested["description"],
+                "PreDescription": requested["preDescription"],
+                "PreCondition": requested["preCondition"],
+                "TriggerField": requested["triggerField"], "Enabled": True,
+                "TrueActions": compiled["trueActions"], "FalseActions": [],
+            })
+            self.rules[0]["TrueActions"][0].update({"Id": "action-id", "ISV": "owner"})
+            return {"status": True, "data": {"ruleId": "rule-id"},
+                    "verification": {"verified": True}}
+        with patch.object(cmd_rules, "do_add_rule_verified", side_effect=add):
+            return self.run_clear(events)
+
+    def run_clear(self, events=None):
+        return cmd_rules.do_ensure_conditional_clear_fields(
+            {}, "token", "demo", None, "数量", "greater-than", "2", ["单价"], events,
+        )
+
+    def create_form_rule(self, events=None, exact_events=None):
+        def add(_cfg, _token, _form, requested, **kwargs):
+            compiled = rule_contract.normalize_rule_config(requested)
+            self.rules.append({
+                "_Type_": "FormRule", "Id": "form-rule-id",
+                "Description": requested["description"],
+                "PreDescription": requested["preDescription"],
+                "PreCondition": requested["preCondition"],
+                "TriggerField": requested["triggerField"], "Enabled": True,
+                "TrueActions": compiled["trueActions"],
+                "FalseActions": compiled["falseActions"],
+            })
+            for branch in ("TrueActions", "FalseActions"):
+                self.rules[0][branch][0]["Id"] = branch + "-old-id"
+            return {"status": True, "data": {"ruleId": "form-rule-id"},
+                    "verification": {"verified": True}}
+        with patch.object(cmd_rules, "do_add_rule_verified", side_effect=add):
+            return self.run_form_rule(events, exact_events)
+
+    def run_form_rule(self, events=None, exact_events=None):
+        return cmd_rules.do_ensure_conditional_field_state(
+            {}, "token", "demo", None, "数量", "greater-than", "2",
+            "单价", "hide", events, exact_events,
+        )
+
+    def test_form_rule_add_event_compiles_both_branches_in_one_write(self):
+        self.create_form_rule(["复制后"])
+        self.assertEqual(1275, self.rules[0]["TrueActions"][0]["RET"])
+        self.assertEqual(1275, self.rules[0]["FalseActions"][0]["RET"])
+
+    def test_new_form_rule_exact_events_match_requested_timings(self):
+        self.create_form_rule(exact_events=["加载", "字段值变化", "复制后"])
+        self.assertEqual(1027, self.rules[0]["TrueActions"][0]["RET"])
+        self.assertEqual(1027, self.rules[0]["FalseActions"][0]["RET"])
+
+    def test_existing_form_rule_appends_event_with_one_update(self):
+        self.create_form_rule()
+        original = copy.deepcopy(self.rules[0])
+        def write(_cfg, _token, command, payload, **kwargs):
+            self.assertEqual("updateRule", command)
+            self.assertEqual("form-rule-id", payload["ruleId"])
+            for branch in ("TrueActions", "FalseActions"):
+                self.rules[0][branch] = copy.deepcopy(payload[branch[0].lower() + branch[1:]])
+                self.rules[0][branch][0]["Id"] = branch + "-new-id"
+            return {"status": True, "data": {"ruleId": "form-rule-id"}}
+        with patch.object(cmd_rules, "_api_call", side_effect=write) as writer:
+            result = self.run_form_rule(["AfterCopy"])
+            self.assertTrue(result["verification"]["preservationVerified"])
+            self.assertEqual(1, writer.call_count)
+            self.assertFalse(self.run_form_rule(["AfterCopy"])["writeAttempted"])
+            self.assertEqual(1, writer.call_count)
+        self.assertEqual(original["Id"], self.rules[0]["Id"])
+        for branch in ("TrueActions", "FalseActions"):
+            self.assertEqual(1275, self.rules[0][branch][0]["RET"])
+            self.assertEqual(original[branch][0]["Fields"], self.rules[0][branch][0]["Fields"])
+
+    def test_new_clear_rule_compiles_named_after_copy(self):
+        self.create(["复制后"])
+        self.assertEqual(1277, self.rules[0]["TrueActions"][0]["RET"])
+        self.assertIn("数量", self.rules[0]["Description"])
+        self.assertTrue(self.rules[0]["Description"].endswith("时清空单价"))
+        self.assertNotIn("[CCF_", self.rules[0]["Description"])
+
+    def test_legacy_hash_description_is_renamed_without_recreating_rule(self):
+        for events, tagged in ((None, False), (["AfterCopy"], True)):
+            with self.subTest(events=events, tagged=tagged):
+                self.rules.clear()
+                self.create()
+                readable = self.rules[0]["Description"]
+                digest = hashlib.sha1("demo:demo:qty > 2:price".encode("utf-8")).hexdigest()[:12]
+                self.rules[0]["Description"] = (
+                    f"{readable} [CCF_{digest}]" if tagged
+                    else f"ConditionalClearFields_{digest}"
+                )
+                original_action = copy.deepcopy(self.rules[0]["TrueActions"][0])
+
+                def write(_cfg, _token, command, payload, **kwargs):
+                    self.assertEqual("updateRule", command)
+                    self.assertEqual("rule-id", payload["ruleId"])
+                    if "description" in payload:
+                        self.rules[0]["Description"] = payload["description"]
+                    if "trueActions" in payload:
+                        self.rules[0]["TrueActions"] = copy.deepcopy(payload["trueActions"])
+                    return {"status": True, "data": {"ruleId": "rule-id"}}
+
+                with patch.object(cmd_rules, "_api_call", side_effect=write) as writer:
+                    result = self.run_clear(events)
+                    self.assertTrue(result["status"])
+                    self.assertTrue(result["verification"]["preservationVerified"])
+                    self.assertEqual(1, writer.call_count)
+                    self.assertFalse(self.run_clear(events)["writeAttempted"])
+                    self.assertEqual(1, writer.call_count)
+                self.assertEqual(readable, self.rules[0]["Description"])
+                self.assertEqual("rule-id", self.rules[0]["Id"])
+                self.assertEqual(original_action["Id"], self.rules[0]["TrueActions"][0]["Id"])
+                self.assertEqual(
+                    1277 if events else original_action["RET"],
+                    self.rules[0]["TrueActions"][0]["RET"],
+                )
+
+    def test_existing_rule_appends_event_preserving_full_rule_and_is_idempotent(self):
+        self.create()
+        self.rules[0]["TrueActions"][0]["RET"] = 1021
+        original = copy.deepcopy(self.rules[0])
+
+        def write(_cfg, _token, command, payload, **kwargs):
+            self.assertEqual("updateRule", command)
+            self.assertEqual("rule-id", payload["ruleId"])
+            self.rules[0]["TrueActions"] = copy.deepcopy(payload["trueActions"])
+            self.rules[0]["TrueActions"][0]["Id"] = "platform-new-action-id"
+            return {"status": True, "data": {"ruleId": "rule-id"}}
+
+        with patch.object(cmd_rules, "_api_call", side_effect=write) as writer:
+            result = self.run_clear(["AfterCopy"])
+            self.assertTrue(result["status"])
+            self.assertTrue(result["verification"]["preservationVerified"])
+            expected = copy.deepcopy(original)
+            expected["TrueActions"][0]["RET"] = 2045
+            expected["TrueActions"][0]["Id"] = "platform-new-action-id"
+            self.assertEqual(expected, self.rules[0])
+            self.assertEqual(1, writer.call_count)
+            self.assertFalse(self.run_clear(["复制后"])["writeAttempted"])
+            self.assertFalse(self.run_clear()["writeAttempted"])
+            self.assertEqual(1, writer.call_count)
+
+    def test_readback_rejects_lost_event_or_unrelated_rule_changes(self):
+        for corruption in ("event", "condition"):
+            with self.subTest(corruption=corruption):
+                self.rules.clear()
+                self.create()
+
+                def write(_cfg, _token, command, payload, **kwargs):
+                    self.rules[0]["TrueActions"] = copy.deepcopy(payload["trueActions"])
+                    if corruption == "event":
+                        self.rules[0]["TrueActions"][0]["RET"] = 253
+                    else:
+                        self.rules[0]["PreCondition"] = "qty > 100"
+                    return {"status": True, "data": {"ruleId": "rule-id"}}
+
+                with patch.object(cmd_rules, "_api_call", side_effect=write) as writer:
+                    result = self.run_clear(["AfterCopy"])
+                    self.assertFalse(result["status"])
+                    self.assertFalse(result["verification"]["verified"])
+                    self.assertEqual(1, writer.call_count)
+
+
 class RuleWriteClosureTest(unittest.TestCase):
+    @patch.object(cmd_rules, "do_add_rule_verified")
+    @patch.object(cmd_rules, "do_load_full_metadata")
+    @patch.object(cmd_rules, "do_list_elements")
+    def test_conditional_field_change_compiles_nonempty_and_copy_timing(
+        self, list_elements, load_full, add_verified,
+    ) -> None:
+        list_elements.side_effect = lambda *args, **kwargs: {
+            "status": True,
+            "data": ([{
+                "key": "demo", "name": "测试单", "id": "entity-id", "type": "BillEntity",
+            }] if kwargs["category"] == "entity" else [
+                {"key": "material", "name": "物料", "parentKey": "demo", "type": "MaterielField"},
+                {"key": "price", "name": "单价", "parentKey": "demo", "type": "PriceField"},
+            ]),
+        }
+        load_full.return_value = {"status": True, "data": {"entitymeta": {"Items": []}}}
+        add_verified.return_value = {
+            "status": True, "data": {"ruleId": "rule-id"},
+            "verification": {"verified": True},
+            "runtimeVerification": {"verified": False},
+        }
+        result = cmd_rules.do_ensure_conditional_field_change(
+            {}, "token", "demo", None, "物料", "not-empty", None,
+            "单价", events=["字段值变化", "复制后"],
+        )
+        requested = add_verified.call_args.args[3]
+        self.assertEqual("(material <> null and material <> '')", requested["preCondition"])
+        self.assertEqual("物料(material)", requested["triggerField"])
+        self.assertEqual("price", requested["trueActions"][0]["expression"])
+        self.assertEqual(1025, requested["trueActions"][0]["ret"])
+        self.assertEqual("物料不为空时调用单价字段值更新服务", requested["description"])
+        self.assertTrue(result["writeAttempted"])
+        self.assertFalse(result["runtimeVerification"]["verified"])
+
+    @patch.object(cmd_rules, "_api_call")
+    @patch.object(cmd_rules, "do_add_rule_verified")
+    @patch.object(cmd_rules, "do_load_full_metadata")
+    @patch.object(cmd_rules, "do_list_elements")
+    def test_conditional_field_change_adopts_existing_rule_and_adds_timing_once(
+        self, list_elements, load_full, add_verified, api_call,
+    ) -> None:
+        list_elements.side_effect = lambda *args, **kwargs: {
+            "status": True,
+            "data": ([{"key": "demo", "name": "测试单", "id": "entity-id", "type": "BillEntity"}]
+                     if kwargs["category"] == "entity" else [
+                         {"key": "material", "name": "物料", "parentKey": "demo", "type": "MaterielField"},
+                         {"key": "price", "name": "单价", "parentKey": "demo", "type": "PriceField"},
+                     ]),
+        }
+        stored = []
+        load_full.side_effect = lambda *args: {
+            "status": True, "data": {"entitymeta": {"Items": copy.deepcopy(stored)}},
+        }
+        def add(_cfg, _token, _form, requested):
+            action = rule_contract.normalize_rule_config(requested)["trueActions"][0]
+            action.update({"Id": "original-action", "IsvFlag": "original"})
+            stored.append({
+                "_Type_": "BizRule", "Id": "existing-rule", "ItemId": "entity-id",
+                "Description": "原有规则名称", "PreDescription": requested["preDescription"],
+                "PreCondition": requested["preCondition"],
+                "TriggerField": requested["triggerField"], "Enabled": True,
+                "TrueActions": [action], "FalseActions": [],
+            })
+            return {"status": True, "data": {"ruleId": "existing-rule"},
+                    "verification": {"verified": True},
+                    "runtimeVerification": {"verified": False}}
+        add_verified.side_effect = add
+        def write(_cfg, _token, command, payload, **kwargs):
+            self.assertEqual("updateRule", command)
+            self.assertEqual("existing-rule", payload["ruleId"])
+            stored[0]["TrueActions"] = copy.deepcopy(payload["trueActions"])
+            stored[0]["TrueActions"][0]["Id"] = "replacement-action"
+            return {"status": True, "data": {"ruleId": "existing-rule"}}
+        api_call.side_effect = write
+
+        cmd_rules.do_ensure_conditional_field_change(
+            {}, "token", "demo", None, "物料", "not-empty", None, "单价",
+        )
+        result = cmd_rules.do_ensure_conditional_field_change(
+            {}, "token", "demo", None, "物料", "not-empty", None,
+            "单价", ["AfterCopy"],
+        )
+        self.assertTrue(result["verification"]["preservationVerified"])
+        self.assertEqual("existing-rule", result["data"]["ruleId"])
+        self.assertEqual("原有规则名称", stored[0]["Description"])
+        self.assertEqual(1797, stored[0]["TrueActions"][0]["RET"])
+        self.assertEqual(1, api_call.call_count)
+        repeated = cmd_rules.do_ensure_conditional_field_change(
+            {}, "token", "demo", None, "物料", "not-empty", None,
+            "单价", ["复制后"],
+        )
+        self.assertFalse(repeated["writeAttempted"])
+        self.assertFalse(repeated["runtimeVerification"]["verified"])
+        self.assertEqual(1, api_call.call_count)
+        self.assertEqual(1, add_verified.call_count)
+
+    @patch.object(cmd_rules, "do_load_full_metadata")
+    @patch.object(cmd_rules, "_api_call")
+    def test_generated_business_rule_rename_preserves_actions_and_identity(
+        self, api_call, load_full,
+    ) -> None:
+        stored = {
+            "_Type_": "BizRule", "Id": "rule-id", "IsvFlag": "original",
+            "Description": "QuantityConversion_123456789abc",
+            "PreDescription": "数量变化时换算基本数量",
+            "PreCondition": "qty = qty", "TriggerField": "数量(qty)",
+            "TrueActions": [{
+                "ActionType": "FillQtyAction", "Expression": "[]", "RET": 249,
+                "Id": "action-id", "IsvFlag": "owner",
+            }], "FalseActions": [],
+        }
+        before = copy.deepcopy(stored)
+        load_full.side_effect = lambda *args: {
+            "status": True, "data": {"entitymeta": {"Items": [copy.deepcopy(stored)]}},
+        }
+        def write(_cfg, _token, _command, payload, **kwargs):
+            stored["Description"] = payload["description"]
+            return {"status": True, "data": {"ruleId": "rule-id"}}
+        api_call.side_effect = write
+
+        result = cmd_rules._upgrade_generated_rule_description(
+            {}, "token", "demo", before,
+            before["Description"], "数量变化时换算基本数量",
+        )
+
+        self.assertTrue(result["verification"]["preservationVerified"])
+        self.assertTrue(result["data"]["changed"])
+        self.assertEqual(before["Id"], stored["Id"])
+        self.assertEqual(before["IsvFlag"], stored["IsvFlag"])
+        self.assertEqual(before["TrueActions"], stored["TrueActions"])
+
     @patch.object(cmd_rules, "do_delete_rule_verified")
     def test_first_option_predecessor_is_removed_when_replacement_exists(
         self, delete_verified
@@ -152,6 +1007,29 @@ class RuleWriteClosureTest(unittest.TestCase):
         )
         self.assertTrue(result["data"]["removedFirstOptionRule"])
 
+    @patch.object(cmd_rules, "do_delete_rule_verified")
+    def test_readable_clear_rule_keeps_first_option_repair_path(self, delete_verified):
+        delete_verified.return_value = {
+            "status": True, "data": {}, "verification": {"verified": True},
+        }
+        metadata = {"entitymeta": {"Items": [{
+            "_Type_": "BizRule", "Id": "old-rule",
+            "Description": "状态为第一项时清空备注 [CCF_123456789abc]",
+            "PreDescription": "状态 = @first 时清空备注",
+            "TriggerField": "状态(status)",
+        }]}}
+        result = cmd_rules._repair_first_option_rule(
+            {}, "token", "demo", metadata, {"description": "new"},
+            rule_type="BizRule", family="ConditionalClearFields_",
+            family_marker=" [CCF_", entity_id="entity-id",
+            trigger_field="状态(status)", markers=["清空", "备注"],
+            replacement_exists=True,
+        )
+        delete_verified.assert_called_once_with(
+            {}, "token", "demo", "bizRule", "old-rule",
+        )
+        self.assertTrue(result["data"]["removedFirstOptionRule"])
+
     def test_set_visible_action_is_rejected_as_a_schema_only_alias(self) -> None:
         with self.assertRaisesRegex(
             ValueError,
@@ -900,8 +1778,12 @@ class RuleWriteClosureTest(unittest.TestCase):
     @patch.object(cmd_rules, "do_get_properties")
     @patch.object(cmd_rules, "do_load_full_metadata")
     @patch.object(cmd_rules, "do_list_elements")
+    @patch.object(cmd_rules, "_reference_entity_field_candidates", return_value=[{
+        "key": "linkman", "name": "联系人", "type": "TextField", "referenceCollection": False,
+    }, {"key": "number", "name": "编码", "type": "TextField", "referenceCollection": False},
+       {"key": "category", "name": "分类", "type": "BasedataField", "referenceCollection": False}])
     def test_reference_carry_defaults_to_source_not_empty(
-        self, list_elements, load_full, get_properties
+        self, reference_fields, list_elements, load_full, get_properties
     ) -> None:
         list_elements.side_effect = lambda *args, **kwargs: {
             "status": True,
@@ -913,7 +1795,7 @@ class RuleWriteClosureTest(unittest.TestCase):
             ]),
         }
         get_properties.return_value = {
-            "status": True, "data": {"refProps": '[{"name":"linkman"}]'},
+            "status": True, "data": {"refProps": '[{"name":"linkman"}]', "baseEntityId": "reference-id"},
         }
         load_full.return_value = {"status": True, "data": {"entitymeta": {"Items": []}}}
         with patch.object(
@@ -936,8 +1818,12 @@ class RuleWriteClosureTest(unittest.TestCase):
     @patch.object(cmd_rules, "do_get_properties")
     @patch.object(cmd_rules, "do_load_full_metadata")
     @patch.object(cmd_rules, "do_list_elements")
+    @patch.object(cmd_rules, "_reference_entity_field_candidates", return_value=[{
+        "key": "linkman", "name": "联系人", "type": "TextField", "referenceCollection": False,
+    }, {"key": "number", "name": "编码", "type": "TextField", "referenceCollection": False},
+       {"key": "category", "name": "分类", "type": "BasedataField", "referenceCollection": False}])
     def test_reference_carry_repairs_legacy_isnull_condition(
-        self, list_elements, load_full, get_properties
+        self, reference_fields, list_elements, load_full, get_properties
     ) -> None:
         list_elements.side_effect = lambda *args, **kwargs: {
             "status": True,
@@ -949,7 +1835,7 @@ class RuleWriteClosureTest(unittest.TestCase):
             ]),
         }
         get_properties.return_value = {
-            "status": True, "data": {"refProps": '[{"name":"linkman"}]'},
+            "status": True, "data": {"refProps": '[{"name":"linkman"}]', "baseEntityId": "reference-id"},
         }
         legacy = "NOT (isNull(supplier) or isEmpty(supplier))"
         identity = ":".join((
@@ -1410,6 +2296,7 @@ class RuleWriteClosureTest(unittest.TestCase):
         requested = add_verified.call_args.args[3]
         action = requested["trueActions"][0]
         self.assertEqual("remark:note", action["expression"])
+        self.assertEqual("数量 > 2 时清空备注、说明", requested["description"])
         self.assertEqual(253, action["ret"])
         self.assertEqual([], requested["falseActions"])
         self.assertTrue(first["writeAttempted"])
@@ -1536,6 +2423,7 @@ class RuleWriteClosureTest(unittest.TestCase):
         requested = add_verified.call_args.args[3]
         action = requested["trueActions"][0]
         self.assertEqual("SetEqutionAction", action["actionType"])
+        self.assertEqual(requested["preDescription"], requested["description"])
         self.assertEqual(
             [{"TargetField": "target", "SrcField": "source", "OnlyEmptyRow": True}],
             action["expression"],
@@ -1568,8 +2456,12 @@ class RuleWriteClosureTest(unittest.TestCase):
     @patch.object(cmd_rules, "do_load_full_metadata")
     @patch.object(cmd_rules, "do_get_properties")
     @patch.object(cmd_rules, "do_list_elements")
+    @patch.object(cmd_rules, "_reference_entity_field_candidates", return_value=[{
+        "key": "linkman", "name": "联系人", "type": "TextField", "referenceCollection": False,
+    }, {"key": "number", "name": "编码", "type": "TextField", "referenceCollection": False},
+       {"key": "category", "name": "分类", "type": "BasedataField", "referenceCollection": False}])
     def test_conditional_carry_reference_property_validates_refprops_and_adopts(
-        self, list_elements, get_properties, load_full, add_verified
+        self, reference_fields, list_elements, get_properties, load_full, add_verified
     ) -> None:
         list_elements.side_effect = lambda *args, **kwargs: {
             "status": True,
@@ -1582,7 +2474,7 @@ class RuleWriteClosureTest(unittest.TestCase):
             ]),
         }
         get_properties.return_value = {
-            "status": True, "data": {"refProps": '[{"name":"number"}]'}
+            "status": True, "data": {"refProps": '[{"name":"number"}]', "baseEntityId": "reference-id"}
         }
         load_full.return_value = {"status": True, "data": {"entitymeta": {"Items": []}}}
         add_verified.return_value = {
@@ -1596,6 +2488,7 @@ class RuleWriteClosureTest(unittest.TestCase):
         requested = add_verified.call_args.args[3]
         action = requested["trueActions"][0]
         self.assertEqual("TakeBaseProAction", action["actionType"])
+        self.assertEqual(requested["preDescription"], requested["description"])
         self.assertEqual(
             [{"TargetField": "org_number", "SrcField": "org.number"}],
             action["expression"],
@@ -1622,7 +2515,7 @@ class RuleWriteClosureTest(unittest.TestCase):
         add_verified.assert_not_called()
 
         get_properties.return_value = {
-            "status": True, "data": {"refProps": '[{"name":"number"}]'}
+            "status": True, "data": {"refProps": '[{"name":"number"}]', "baseEntityId": "reference-id"}
         }
         with self.assertRaisesRegex(
             ValueError, "CONDITIONAL_CARRY_SOURCE_PROPERTY_UNAVAILABLE.*number"
@@ -1885,17 +2778,77 @@ class RuleWriteClosureTest(unittest.TestCase):
         self.assertEqual(1021, written["RET"])
         self.assertEqual(1, written["Seq"])
 
-    @patch.object(cmd_rules, "_api_call")
-    def test_call_field_change_is_blocked_after_runtime_failure(self, api_call) -> None:
+    @patch.object(cmd_rules, "do_list_elements")
+    def test_call_field_change_resolves_target_and_preserves_runtime_boundary(
+        self, list_elements,
+    ) -> None:
+        list_elements.return_value = {"status": True, "data": [
+            {"key": "uhyl_target", "name": "单价", "parentKey": "uhyl_demo"},
+        ]}
         requested = _biz_rule({
             "actionType": "CallFieldChangeAction",
-            "expression": "uhyl_target",
+            "expression": "单价",
         })
-        with self.assertRaisesRegex(
-            ValueError, "RULE_ACTION_CONTRACT_BLOCKED: CallFieldChangeAction"
-        ):
-            cmd_rules.do_add_rule_verified({}, "token", "uhyl_demo", requested)
-        api_call.assert_not_called()
+        resolved = cmd_rules._resolve_call_field_change_targets(
+            {}, "token", "uhyl_demo", requested,
+        )
+        self.assertEqual("单价", requested["trueActions"][0]["expression"])
+        self.assertEqual("uhyl_target", resolved["trueActions"][0]["expression"])
+        action = rule_contract.normalize_rule_config(resolved)["trueActions"][0]
+        self.assertEqual(773, action["RET"])
+        self.assertEqual("uhyl_target", action["Expression"])
+        self.assertEqual("CallFieldChangeAction", rule_contract.runtime_action_warnings(
+            resolved,
+        )[0]["actionType"])
+
+    @patch.object(cmd_rules, "do_list_elements")
+    def test_call_field_change_rejects_ambiguous_or_foreign_target(
+        self, list_elements,
+    ) -> None:
+        list_elements.return_value = {"status": True, "data": [
+            {"key": "head_price", "name": "单价", "parentKey": "uhyl_demo"},
+            {"key": "entry_price", "name": "单价", "parentKey": "entry"},
+        ]}
+        requested = _biz_rule({
+            "actionType": "CallFieldChangeAction", "expression": "entry_price",
+        })
+        with self.assertRaisesRegex(ValueError, "RULE_CALL_FIELD_TARGET_UNRESOLVED"):
+            cmd_rules._resolve_call_field_change_targets(
+                {}, "token", "uhyl_demo", requested,
+            )
+        del requested["mountPoint"]
+        requested["trueActions"][0]["expression"] = "单价"
+        with self.assertRaisesRegex(ValueError, "RULE_CALL_FIELD_TARGET_AMBIGUOUS"):
+            cmd_rules._resolve_call_field_change_targets(
+                {}, "token", "uhyl_demo", requested,
+            )
+
+    @patch.object(cmd_rules, "_ensure_rule_trigger_events", return_value=[])
+    @patch.object(cmd_rules, "_attach_rule_readback")
+    @patch.object(cmd_rules, "do_add_rule")
+    @patch.object(cmd_rules, "do_list_elements")
+    @patch.object(cmd_rules, "_resolve_rule_entity")
+    def test_call_field_change_receipt_does_not_claim_runtime_verified(
+        self, resolve_entity, list_elements, add_rule, readback, _trigger,
+    ) -> None:
+        requested = _biz_rule({
+            "actionType": "CallFieldChangeAction", "expression": "单价",
+        })
+        resolve_entity.return_value = requested
+        list_elements.return_value = {"status": True, "data": [
+            {"key": "uhyl_target", "name": "单价", "parentKey": "uhyl_demo"},
+        ]}
+        add_rule.return_value = {"status": True, "data": {"ruleId": "rule-1"}}
+        readback.return_value = {
+            "status": True, "data": {"ruleId": "rule-1"},
+            "verification": {"verified": True},
+        }
+        result = cmd_rules.do_add_rule_verified(
+            {}, "token", "uhyl_demo", requested,
+        )
+        self.assertEqual("uhyl_target", add_rule.call_args.args[3]["trueActions"][0]["expression"])
+        self.assertTrue(result["verification"]["verified"])
+        self.assertFalse(result["runtimeVerification"]["verified"])
 
     def test_fill_qty_compiles_real_expression_and_ret(self) -> None:
         expression = '[{"distQtyField":"uhyl_base_qty","srcQtyField":"uhyl_qty"}]'
@@ -1956,11 +2909,83 @@ class RuleWriteClosureTest(unittest.TestCase):
             requested["triggerField"],
         )
         action = requested["trueActions"][0]
+        self.assertEqual(requested["preDescription"], requested["description"])
         self.assertEqual(
             "uhyl_result = uhyl_left + uhyl_right", action["expression"]
         )
         self.assertEqual(253, action["ret"])
 
+    @patch.object(cmd_rules, "do_add_rule_verified")
+    @patch.object(cmd_rules, "do_load_full_metadata")
+    @patch.object(cmd_rules, "do_list_elements")
+    def test_time_difference_compiles_decimal_hours_and_empty_branch(
+        self, list_elements, load_full, add_verified,
+    ) -> None:
+        list_elements.side_effect = [
+            {"status": True, "data": [{
+                "key": "uhyl_demo", "name": "演示单", "id": "entity-id",
+                "type": "MainEntity",
+            }]},
+            {"status": True, "data": [
+                {"key": "uhyl_start", "name": "开始时间", "type": "TimeField",
+                 "parentKey": "uhyl_demo"},
+                {"key": "uhyl_end", "name": "结束时间", "type": "TimeField",
+                 "parentKey": "uhyl_demo"},
+                {"key": "uhyl_hours", "name": "时长(小时)", "type": "DecimalField",
+                 "parentKey": "uhyl_demo"},
+            ]},
+        ]
+        load_full.return_value = {"status": True, "data": {"entitymeta": {}}}
+        add_verified.return_value = {
+            "status": True, "data": {"ruleId": "time-rule"},
+            "verification": {"verified": True},
+        }
+
+        result = cmd_rules.do_ensure_time_difference_calculation(
+            {}, "token", "uhyl_demo", "演示单", "时长(小时)",
+            "开始时间", "结束时间",
+        )
+
+        self.assertTrue(result["writeAttempted"])
+        requested = add_verified.call_args.args[3]
+        self.assertEqual(
+            "uhyl_start >= 0 and uhyl_end >= 0", requested["preCondition"]
+        )
+        self.assertEqual(
+            "开始时间(uhyl_start);结束时间(uhyl_end)", requested["triggerField"]
+        )
+        self.assertEqual(
+            "uhyl_hours = (uhyl_end - uhyl_start) / 3600.0",
+            requested["trueActions"][0]["expression"],
+        )
+        self.assertEqual(1021, requested["trueActions"][0]["ret"])
+        self.assertEqual("uhyl_hours", requested["falseActions"][0]["expression"])
+        self.assertEqual("hours", result["data"]["unit"])
+
+    @patch.object(cmd_rules, "do_list_elements")
+    def test_time_difference_requires_time_operands(self, list_elements) -> None:
+        list_elements.side_effect = [
+            {"status": True, "data": [{
+                "key": "uhyl_demo", "name": "演示单", "id": "entity-id",
+                "type": "MainEntity",
+            }]},
+            {"status": True, "data": [
+                {"key": "uhyl_start", "name": "开始时间", "type": "DecimalField",
+                 "parentKey": "uhyl_demo"},
+                {"key": "uhyl_end", "name": "结束时间", "type": "TimeField",
+                 "parentKey": "uhyl_demo"},
+                {"key": "uhyl_hours", "name": "时长", "type": "DecimalField",
+                 "parentKey": "uhyl_demo"},
+            ]},
+        ]
+        with self.assertRaisesRegex(
+            ValueError, "TIME_DIFFERENCE_TIME_FIELD_REQUIRED.*DecimalField"
+        ):
+            cmd_rules.do_ensure_time_difference_calculation(
+                {}, "token", "uhyl_demo", "演示单", "时长",
+                "开始时间", "结束时间",
+            )
+
     def test_fill_qty_rejects_guessed_legacy_mapping_keys(self) -> None:
         with self.assertRaisesRegex(
             ValueError, "RULE_FILL_QTY_MAPPING_INVALID"
@@ -2012,6 +3037,7 @@ class RuleWriteClosureTest(unittest.TestCase):
         self.assertTrue(result["writeAttempted"])
         requested = add_verified.call_args.args[3]
         action = requested["trueActions"][0]
+        self.assertEqual("数量变化时换算基本数量", requested["description"])
         self.assertEqual(249, action["ret"])
         self.assertEqual(
             '[{"distQtyField":"uhyl_base_qty","srcQtyField":"uhyl_qty"}]',