@shundoo-ai/dsh-cosmic 1.0.19 → 1.0.21

package/skills/cosmic-build/skills/cosmic-meta-api/scripts/_core/cmd_rules.py

@@ -32,6 +32,9 @@ from .mutation_contract import mutation_contract, combine_mutation_evidence, cla
 from .rule_contract import (
     FORM_RULE_DEFAULT_RET,
     normalize_rule_config,
+    merge_action_events,
+    select_action_events,
+    runtime_action_warnings,
     trigger_field_selectors,
 )
 
@@ -665,8 +668,10 @@ def _validate_rule_write_input(rule_config, *, command):
     if rule_type not in {"formRule", "bizRule"}:
         raise ValueError("RULE_TYPE_INVALID: ruleType must be formRule or bizRule")
     if command == "addRule":
-        missing = [field for field in ("description", "preDescription", "preCondition", "trueActions")
+        missing = [field for field in ("description", "preDescription", "preCondition")
                    if rule_config.get(field) in (None, "", [])]
+        if not (rule_config.get("trueActions") or rule_config.get("falseActions")):
+            missing.append("trueActions or falseActions")
         if missing:
             raise ValueError(
                 f"RULE_INPUT_REQUIRED: {', '.join('addRule.' + field for field in missing)}; "
@@ -1078,6 +1083,61 @@ def _validate_clear_value_action_scope(cfg, token, form_number, rule_config):
     return rule_config
 
 
+def _resolve_call_field_change_targets(cfg, token, form_number, rule_config):
+    if rule_config.get("ruleType") != "bizRule":
+        return rule_config
+    normalized = normalize_rule_config(rule_config)
+    if not any(
+        action.get("ActionType") == "CallFieldChangeAction"
+        for branch in ("trueActions", "falseActions")
+        for action in (normalized.get(branch) or [])
+    ):
+        return rule_config
+    listed = do_list_elements(cfg, token, form_number=form_number, category="field")
+    rows = listed.get("data") if isinstance(listed, dict) else None
+    if not _is_api_success(listed) or not isinstance(rows, list):
+        raise RuntimeError(
+            "RULE_CALL_FIELD_INVENTORY_UNAVAILABLE: listElements returned no field list"
+        )
+    mounted = str(rule_config.get("mountPoint") or "").strip()
+    resolved = copy.deepcopy(rule_config)
+    for branch in ("trueActions", "falseActions"):
+        for action in resolved.get(branch) or []:
+            kind = action.get("actionType") or action.get("ActionType")
+            if kind != "CallFieldChangeAction":
+                continue
+            slot = "expression" if "expression" in action else "Expression"
+            wanted = str(action.get(slot) or "").strip()
+            candidates = [
+                row for row in rows
+                if isinstance(row, dict)
+                and wanted in {
+                    str(row.get("key") or "").strip(),
+                    str(row.get("name") or "").strip(),
+                    str(row.get("id") or "").strip(),
+                }
+            ]
+            exact = [row for row in candidates if row.get("key") == wanted]
+            if exact:
+                candidates = exact
+            if mounted:
+                candidates = [
+                    row for row in candidates
+                    if not str(row.get("parentKey") or "").strip()
+                    or str(row.get("parentKey") or "").strip() == mounted
+                ]
+            if len(candidates) != 1:
+                code = "UNRESOLVED" if not candidates else "AMBIGUOUS"
+                raise ValueError(
+                    f"RULE_CALL_FIELD_TARGET_{code}: {wanted!r}; "
+                    "provide an exact field key and entity when names repeat"
+                )
+            for alias in ("expression", "Expression"):
+                if alias in action:
+                    action[alias] = str(candidates[0].get("key") or "").strip()
+    return resolved
+
+
 def _validate_set_equation_action_scope(cfg, token, form_number, rule_config):
     if rule_config.get("ruleType") != "bizRule":
         return rule_config
@@ -1103,24 +1163,24 @@ def _validate_set_equation_action_scope(cfg, token, form_number, rule_config):
         for row in rows if isinstance(row, dict) and str(row.get("key") or "").strip()
     }
     for action in actions:
-        mapping = (action.get("Expression") or [])[0]
-        for slot in ("TargetField", "SrcField"):
-            field_key = str(mapping.get(slot) or "").strip()
-            if "." in field_key:
-                raise ValueError(
-                    f"RULE_SET_EQUATION_CROSS_ENTITY_UNSUPPORTED: {slot}={field_key!r}"
-                )
-            row = by_key.get(field_key)
-            if row is None:
-                raise ValueError(
-                    f"RULE_SET_EQUATION_FIELD_UNRESOLVED: {field_key!r}"
-                )
-            owner = str(row.get("parentKey") or "").strip()
-            if mounted and owner and owner != mounted:
-                raise ValueError(
-                    "RULE_SET_EQUATION_ENTITY_MISMATCH: "
-                    f"field {field_key!r} belongs to {owner!r}, rule mount is {mounted!r}"
-                )
+        for mapping in action.get("Expression") or []:
+            for slot in ("TargetField", "SrcField"):
+                field_key = str(mapping.get(slot) or "").strip()
+                if "." in field_key:
+                    raise ValueError(
+                        f"RULE_SET_EQUATION_CROSS_ENTITY_UNSUPPORTED: {slot}={field_key!r}"
+                    )
+                row = by_key.get(field_key)
+                if row is None:
+                    raise ValueError(
+                        f"RULE_SET_EQUATION_FIELD_UNRESOLVED: {field_key!r}"
+                    )
+                owner = str(row.get("parentKey") or "").strip()
+                if mounted and owner and owner != mounted:
+                    raise ValueError(
+                        "RULE_SET_EQUATION_ENTITY_MISMATCH: "
+                        f"field {field_key!r} belongs to {owner!r}, rule mount is {mounted!r}"
+                    )
     return rule_config
 
 
@@ -1716,6 +1776,11 @@ def _attach_rule_readback(cfg, token, form_number, rule_config, result, preserve
     metadata = (read_back or {}).get("data")
     observed = _find_rule_projection(metadata, rule_id)
     expected = normalize_rule_config(rule_config)
+    if rule_config.get("ruleId"):
+        for branch in ("trueActions", "falseActions"):
+            for action in expected.get(branch) or []:
+                if isinstance(action, dict):
+                    action.pop("Id", None)
     mismatches = rule_readback_mismatches(expected, observed, metadata)
     preserved_mismatches = []
     if preserved_rule is not None and isinstance(observed, dict):
@@ -1838,6 +1903,9 @@ def do_add_rule_verified(
     resolved = _validate_clear_value_action_scope(
         cfg, token, form_number, resolved
     )
+    resolved = _resolve_call_field_change_targets(
+        cfg, token, form_number, resolved
+    )
     resolved = _validate_set_equation_action_scope(
         cfg, token, form_number, resolved
     )
@@ -1855,12 +1923,15 @@ def do_add_rule_verified(
     result = do_add_rule(cfg, token, form_number, resolved)
     if _is_api_success(result):
         result = _attach_rule_readback(cfg, token, form_number, resolved, result)
+        warnings = runtime_action_warnings(resolved)
+        if _is_api_success(result) and warnings:
+            result["runtimeVerification"] = {"verified": False, "warnings": warnings}
     if isinstance(result, dict) and trigger_results:
         result["triggerPropertyResults"] = trigger_results
     return result
 
 
-def _resolve_calculation_field(rows, entity_key, selector):
+def _resolve_same_entity_field(rows, entity_key, selector, error_prefix):
     wanted = str(selector or "").strip()
     matches = [
         row for row in rows
@@ -1881,15 +1952,37 @@ def _resolve_calculation_field(rows, entity_key, selector):
     if len(matches) != 1:
         error = "UNRESOLVED" if not matches else "AMBIGUOUS"
         raise ValueError(
-            f"FIELD_CALCULATION_FIELD_{error}: {wanted!r} in entity {entity_key!r}"
+            f"{error_prefix}_FIELD_{error}: {wanted!r} in entity {entity_key!r}"
         )
-    field_type = str(matches[0].get("type") or "").strip()
+    return matches[0]
+
+
+def _resolve_calculation_field(rows, entity_key, selector):
+    row = _resolve_same_entity_field(
+        rows, entity_key, selector, "FIELD_CALCULATION",
+    )
+    wanted = str(selector or "").strip()
+    field_type = str(row.get("type") or "").strip()
     if field_type not in _CALCULATION_NUMERIC_FIELD_TYPES:
         raise ValueError(
             "FIELD_CALCULATION_NUMERIC_FIELD_REQUIRED: "
             f"{wanted!r} is {field_type or 'unknown'}"
         )
-    return matches[0]
+    return row
+
+
+def _resolve_time_difference_operand(rows, entity_key, selector):
+    row = _resolve_same_entity_field(
+        rows, entity_key, selector, "TIME_DIFFERENCE",
+    )
+    wanted = str(selector or "").strip()
+    field_type = str(row.get("type") or "").strip()
+    if field_type != "TimeField":
+        raise ValueError(
+            "TIME_DIFFERENCE_TIME_FIELD_REQUIRED: "
+            f"{wanted!r} is {field_type or 'unknown'}"
+        )
+    return row
 
 
 def _front_value_action_matches(expected, actual):
@@ -2051,6 +2144,145 @@ def do_ensure_field_calculation(
     }
 
 
+def do_ensure_time_difference_calculation(
+    cfg, token, form_number, entity, target, start, end,
+):
+    """Ensure a same-entity TimeField difference expressed in decimal hours."""
+    entity_row, rows = _resolve_rule_entity_context(
+        cfg, token, form_number, entity, [target, start, end]
+    )
+    entity_key = str(entity_row.get("key") or "").strip()
+    entity_id = str(entity_row.get("id") or "").strip()
+    target_row = _resolve_calculation_field(rows, entity_key, target)
+    start_row = _resolve_time_difference_operand(rows, entity_key, start)
+    end_row = _resolve_time_difference_operand(rows, entity_key, end)
+    target_key = str(target_row.get("key") or "").strip()
+    start_key = str(start_row.get("key") or "").strip()
+    end_key = str(end_row.get("key") or "").strip()
+    if len({target_key, start_key, end_key}) != 3:
+        raise ValueError(
+            "TIME_DIFFERENCE_DISTINCT_FIELDS_REQUIRED: target, start and end "
+            "must be different fields"
+        )
+    target_name = str(target_row.get("name") or target_key).strip()
+    start_name = str(start_row.get("name") or start_key).strip()
+    end_name = str(end_row.get("name") or end_key).strip()
+    formula = f"{target_key} = ({end_key} - {start_key}) / 3600.0"
+    condition = f"{start_key} >= 0 and {end_key} >= 0"
+    trigger_field = f"{start_name}({start_key});{end_name}({end_key})"
+    description = f"{start_name}、{end_name}非空时计算{target_name}"
+    requested = {
+        "ruleType": "bizRule",
+        "itemId": entity_id,
+        "mountPoint": entity_key,
+        "description": description,
+        "preDescription": description,
+        "preCondition": condition,
+        "triggerField": trigger_field,
+        "enabled": True,
+        "trueActions": [{
+            "actionType": "FormulaAction",
+            "description": f"{target_name} = ({end_name} - {start_name}) / 3600.0",
+            "expression": formula,
+            "ret": 1021,
+        }],
+        "falseActions": [{
+            "actionType": "ClearValueAction",
+            "description": f"时间不完整时清空{target_name}",
+            "expression": target_key,
+            "ret": 1021,
+        }],
+    }
+    current = do_load_full_metadata(cfg, token, form_number)
+    if not _is_api_success(current):
+        raise RuntimeError(
+            "TIME_DIFFERENCE_READ_FAILED: "
+            + (_extract_error_message(current) or "loadFullMetadata failed")
+        )
+    metadata = current.get("data")
+    target_paths = {target_key, f"{entity_key}.{target_key}"}
+    for row in rows:
+        if str(row.get("parentKey") or "") != entity_key:
+            continue
+        for item in _metadata_items_by_key(metadata, str(row.get("key") or "")):
+            actions = item.get("ExecuteActions") or {}
+            if isinstance(actions, str):
+                actions = json.loads(actions)
+            if isinstance(actions, dict) and any(
+                isinstance(action, dict)
+                and action.get("action") == "updateField"
+                and action.get("target") in target_paths
+                for action in actions.get("valueChange") or []
+            ):
+                raise ValueError(
+                    f"TIME_DIFFERENCE_TARGET_CONFLICT: {target_key!r} already has "
+                    "a field value-change calculation"
+                )
+    semantic = [
+        rule for rule in _all_rule_projections(metadata, "BizRule")
+        if _rule_function_formula_matches(rule, entity_key, formula)
+    ]
+    conflicts = [
+        rule for rule in _all_rule_projections(metadata, "BizRule")
+        if _rule_function_formula_conflicts(rule, entity_key, target_key, formula)
+    ]
+    if len(semantic) > 1:
+        raise ValueError("TIME_DIFFERENCE_DUPLICATE_RULES")
+    if conflicts:
+        raise ValueError(
+            "TIME_DIFFERENCE_TARGET_CONFLICT: "
+            f"target={target_key!r}, candidateRuleIds="
+            f"{[str(rule.get('Id') or '') for rule in conflicts]!r}"
+        )
+    changed = True
+    if semantic:
+        expected = normalize_rule_config(requested)
+        mismatches = rule_readback_mismatches(expected, semantic[0], metadata)
+        if not mismatches:
+            return {
+                "status": True,
+                "errorCode": "0",
+                "message": "Time difference calculation already matches",
+                "writeAttempted": False,
+                "data": {
+                    "changed": False,
+                    "ruleId": str(semantic[0].get("Id") or ""),
+                    "entityKey": entity_key,
+                    "targetField": target_key,
+                    "sourceFields": [start_key, end_key],
+                    "unit": "hours",
+                    "formula": formula,
+                },
+                "verification": {"verified": True, "mismatches": []},
+            }
+        result = do_update_rule_verified(cfg, token, form_number, {
+            "ruleType": "bizRule",
+            "ruleId": str(semantic[0].get("Id") or ""),
+            "description": requested["description"],
+            "preDescription": requested["preDescription"],
+            "preCondition": requested["preCondition"],
+            "triggerField": requested["triggerField"],
+            "enabled": True,
+            "trueActions": requested["trueActions"],
+            "falseActions": requested["falseActions"],
+        })
+    else:
+        result = do_add_rule_verified(cfg, token, form_number, requested)
+    if isinstance(result, dict):
+        result["writeAttempted"] = changed
+        data = result.setdefault("data", {})
+        if isinstance(data, dict):
+            data.update({
+                "changed": changed,
+                "entityKey": entity_key,
+                "targetField": target_key,
+                "sourceFields": [start_key, end_key],
+                "unit": "hours",
+                "formula": formula,
+            })
+    return result
+
+
 def _resolve_rule_function_field(rows, entity_key, selector):
     wanted = str(selector or "").strip()
     matches = [
@@ -2133,7 +2365,9 @@ def _rule_function_formula_conflicts(rule, entity_key, target_key, formula):
     )
 
 
-def do_ensure_rule_function_formula(cfg, token, form_number, entity, target, call):
+def do_ensure_rule_function_formula(
+    cfg, token, form_number, entity, target, call, add_events=None, events=None,
+):
     """Compile one released FX call into a same-entity FormulaAction.
 
     The call tree has no raw-expression escape hatch: function IDs resolve against
@@ -2200,15 +2434,19 @@ def do_ensure_rule_function_formula(cfg, token, form_number, entity, target, cal
             "actionType": "FormulaAction",
             "description": f"{target_key} = {expression}",
             "expression": formula,
-            "ret": 253,
+            "ret": _requested_action_ret("FormulaAction", 253, events, add_events),
         }],
         "falseActions": ([{
             "actionType": "ClearValueAction",
             "description": f"clear {target_key} when an input is null",
             "expression": target_key,
-            "ret": 253,
+            "ret": _requested_action_ret("ClearValueAction", 253, events, add_events),
         }] if guarded_source_keys else []),
     }
+    legacy_description = description
+    tagged_description = f"{requested['preDescription']} [RFF_{legacy_description.rsplit('_', 1)[1]}]"
+    description = requested["preDescription"]
+    requested["description"] = description
     current = do_load_full_metadata(cfg, token, form_number)
     if not _is_api_success(current):
         raise RuntimeError(
@@ -2253,10 +2491,29 @@ def do_ensure_rule_function_formula(cfg, token, form_number, entity, target, cal
             f"{[str(rule.get('Id') or '') for rule in conflicts]!r}"
         )
     if semantic:
+        timing_result = _reconcile_existing_rule_events(
+            cfg, token, form_number, semantic[0], "bizRule", events, add_events,
+        )
+        if timing_result is not None:
+            return timing_result
+        expected = normalize_rule_config(requested)
+        if events is not None or add_events is not None:
+            for branch, stored_branch in (("trueActions", "TrueActions"),
+                                          ("falseActions", "FalseActions")):
+                for action, stored_action in zip(
+                    expected.get(branch) or [], semantic[0].get(stored_branch) or [],
+                ):
+                    action["RET"] = stored_action["RET"]
         mismatches = rule_readback_mismatches(
-            normalize_rule_config(requested), semantic[0], metadata
+            expected, semantic[0], metadata
         )
         if mismatches:
+            if (str(semantic[0].get("Description") or "") in {legacy_description, tagged_description}
+                    and all(item.get("path") == "description" for item in mismatches)):
+                return _upgrade_generated_rule_description(
+                    cfg, token, form_number, semantic[0],
+                    (legacy_description, tagged_description), description,
+                )
             if str(semantic[0].get("Description") or "") != description:
                 raise ValueError(
                     "RULE_FUNCTION_FORMULA_CONFLICT: "
@@ -2344,6 +2601,47 @@ def _rule_projections_by_description(value, description):
     return matches
 
 
+def _upgrade_generated_rule_description(
+    cfg, token, form_number, rule, legacy_description, readable_description,
+):
+    """Rename one exact legacy generated rule without replacing its actions."""
+    names = ({legacy_description} if isinstance(legacy_description, str)
+             else set(legacy_description))
+    if str(rule.get("Description") or "") not in names:
+        return None
+    rule_id = str(rule.get("Id") or "").strip()
+    if not rule_id:
+        raise ValueError("RULE_DESCRIPTION_LEGACY_ID_UNAVAILABLE")
+    result = do_update_rule_verified(cfg, token, form_number, {
+        "ruleType": "bizRule", "ruleId": rule_id,
+        "description": readable_description,
+    })
+    if isinstance(result, dict):
+        result["writeAttempted"] = True
+        data = result.setdefault("data", {})
+        if isinstance(data, dict):
+            data.update({
+                "changed": True if _is_api_success(result) else None,
+                "ruleId": rule_id,
+                "renamedGeneratedRule": True if _is_api_success(result) else None,
+            })
+    return result
+
+
+def _rule_matches_except_generated_action_ids(expected, observed):
+    """A rule update may regenerate action IDs while retaining its behavior."""
+    if not isinstance(expected, dict) or not isinstance(observed, dict):
+        return False
+    def comparable(rule):
+        result = copy.deepcopy(rule)
+        for branch in ("TrueActions", "FalseActions"):
+            for action in result.get(branch) or []:
+                if isinstance(action, dict):
+                    action.pop("Id", None)
+        return result
+    return comparable(expected) == comparable(observed)
+
+
 def _all_rule_projections(value, rule_type=None):
     matches = []
     stack = [value]
@@ -2461,11 +2759,18 @@ def _resolve_rule_entity_context(
         str(value or "").strip()
         for value in condition_selectors if value not in (None, "")
     ]
+    action_selectors = [str(value or "").strip() for value in selectors if value not in (None, "")]
+    owner_sets = [{str(row.get("parentKey") or "").strip()
+                   for row in _match_field_selector(scoped_field_rows, selector)} for selector in action_selectors]
+    # A unique amount/quantity target can select the entry that owns a repeated price caption.
+    # Infer only when all participating action fields prove the same single owner.
+    common_owners = set.intersection(*owner_sets) if owner_sets and all(owner_sets) else set()
+    if len(common_owners) == 1:
+        scoped_field_rows = [row for row in scoped_field_rows
+                            if str(row.get("parentKey") or "").strip() in common_owners]
     selected_rows = [
         resolve_scoped(selector)
-        for selector in [
-            str(value or "").strip() for value in selectors if value not in (None, "")
-        ]
+        for selector in action_selectors
     ]
     if not selected_rows:
         # No action target names the mount, so the condition field selects it.
@@ -2683,11 +2988,13 @@ def _repair_legacy_boolean_rule(cfg, token, form_number, metadata, requested,
 def _repair_first_option_rule(
     cfg, token, form_number, metadata, requested, *, rule_type, family,
     entity_id, trigger_field, markers, replacement_exists=False,
+    family_marker=None,
 ):
     """Replace one legacy @first rule occupying the same semantic slot."""
     matches = [
         rule for rule in _all_rule_projections(metadata, rule_type)
-        if str(rule.get("Description") or "").startswith(family)
+        if (str(rule.get("Description") or "").startswith(family)
+            or (family_marker and family_marker in str(rule.get("Description") or "")))
         and "@first" in str(rule.get("PreDescription") or "")
         and (
             not str(rule.get("ItemId") or "").strip()
@@ -2741,10 +3048,78 @@ def _repair_first_option_rule(
     return result
 
 
+def _requested_action_ret(action_type, default_ret, events=None, add_events=None):
+    if events is not None and add_events is not None:
+        raise ValueError("RULE_EVENTS_CONFLICT: choose events or addEvents")
+    if events is not None:
+        return select_action_events(action_type, events)
+    if add_events is not None:
+        return merge_action_events(action_type, default_ret, add_events)
+    return default_ret
+
+
+def _reconcile_existing_rule_events(
+    cfg, token, form_number, rule, rule_type, events=None, add_events=None,
+):
+    """Apply a timing-only update without reconstructing any service or rule metadata."""
+    if events is None and add_events is None:
+        return None
+    if events is not None and add_events is not None:
+        raise ValueError("RULE_EVENTS_CONFLICT: choose events or addEvents")
+    stored = copy.deepcopy(rule)
+    rule_id = str(stored.get("Id") or "").strip()
+    if not rule_id:
+        raise ValueError("RULE_EVENT_RULE_ID_MISSING")
+    for branch in ("TrueActions", "FalseActions"):
+        for action in stored.get(branch) or []:
+            current = action.get("RET")
+            kind = action.get("ActionType")
+            if events is not None:
+                requested = select_action_events(kind, events)
+                if current != requested:
+                    return {
+                        "status": False, "errorCode": "RULE_EVENT_REPLACE_REQUIRES_RULE_ID",
+                        "message": "Replacing timings on an existing rule requires an exact ruleId",
+                        "writeAttempted": False,
+                        "data": {"ruleId": rule_id, "actionType": kind,
+                                 "currentRET": current, "requestedRET": requested},
+                    }
+            if add_events is not None:
+                action["RET"] = merge_action_events(kind, current, add_events)
+    if _rule_matches_except_generated_action_ids(rule, stored):
+        return None
+    patch = {"ruleType": rule_type, "ruleId": rule_id,
+             "trueActions": stored.get("TrueActions") or [],
+             "falseActions": stored.get("FalseActions") or []}
+    result = do_update_rule_verified(cfg, token, form_number, patch)
+    if not _is_api_success(result):
+        return result
+    try:
+        readback = do_load_full_metadata(cfg, token, form_number)
+    except Exception as exc:
+        readback = {"status": False, "message": str(exc)}
+    observed = (_find_rule_projection(readback.get("data"), rule_id)
+                if _is_api_success(readback) else None)
+    if not _rule_matches_except_generated_action_ids(stored, observed):
+        return {
+            "status": False, "errorCode": "RULE_EVENT_READBACK_MISMATCH",
+            "message": "Timing update could not verify preservation of the complete rule",
+            "writeAttempted": True, "retryable": False,
+            "data": {"changed": None, "ruleId": rule_id},
+            "verification": {"verified": False, "preservationVerified": False},
+        }
+    result.setdefault("data", {}).update({"changed": True, "ruleId": rule_id})
+    result["writeAttempted"] = True
+    result.setdefault("verification", {}).update({
+        "verified": True, "preservationVerified": True,
+    })
+    return result
+
+
 @mutation_contract
 def do_ensure_conditional_field_state(
     cfg, token, form_number, entity, condition_field, operator, value,
-    target, behavior,
+    target, behavior, add_events=None, events=None,
 ):
     """Ensure one reversible conditional rule for one or many same-entity fields."""
     action_pair = _CONDITIONAL_STATE_ACTIONS.get(
@@ -2754,6 +3129,8 @@ def do_ensure_conditional_field_state(
         raise ValueError(
             "CONDITIONAL_FIELD_STATE_BEHAVIOR_UNSUPPORTED: use show, hide, lock, or unlock"
         )
+    if events is not None and add_events is not None:
+        raise ValueError("RULE_EVENTS_CONFLICT: choose exact events or add-events")
     targets = [target] if isinstance(target, str) else list(target or [])
     if not targets or any(not str(item or "").strip() for item in targets):
         raise ValueError("CONDITIONAL_FIELD_STATE_TARGET_REQUIRED")
@@ -2784,6 +3161,12 @@ def do_ensure_conditional_field_state(
     ))
     digest = hashlib.sha1(identity.encode("utf-8")).hexdigest()[:12]
     true_action, false_action = action_pair
+    true_ret = (select_action_events(true_action, events) if events is not None
+                else merge_action_events(true_action, 251, add_events)
+                if add_events is not None else 251)
+    false_ret = (select_action_events(false_action, events) if events is not None
+                 else merge_action_events(false_action, 251, add_events)
+                 if add_events is not None else 251)
     condition_phrase = (
         f"{condition_name} {'为空' if compiled_operator == 'empty' else '不为空'}"
         if compiled_operator in {"empty", "not-empty"}
@@ -2811,11 +3194,13 @@ def do_ensure_conditional_field_state(
             "actionType": true_action,
             "description": f"{behavior_label}{target_phrase}",
             "fields": target_keys,
+            "ret": true_ret,
         }],
         "falseActions": [{
             "actionType": false_action,
             "description": f"{inverse_label}{target_phrase}",
             "fields": target_keys,
+            "ret": false_ret,
         }],
     }
 
@@ -2834,6 +3219,12 @@ def do_ensure_conditional_field_state(
         )
     expected = normalize_rule_config(requested)
     if matches:
+        if add_events is not None:
+            for branch, stored_branch in (("trueActions", "TrueActions"),
+                                          ("falseActions", "FalseActions")):
+                actions = matches[0].get(stored_branch) or []
+                if len(actions) == 1 and "RET" in actions[0]:
+                    expected[branch][0]["RET"] = actions[0]["RET"]
         mismatches = rule_readback_mismatches(expected, matches[0], metadata)
         if mismatches:
             raise ValueError(
@@ -2841,6 +3232,47 @@ def do_ensure_conditional_field_state(
                 f"already exists with different metadata; mismatches="
                 f"{json.dumps(mismatches, ensure_ascii=False)}"
             )
+        if add_events is not None:
+            stored = copy.deepcopy(matches[0])
+            rule_id = str(stored.get("Id") or "").strip()
+            if not rule_id:
+                raise ValueError("RULE_EVENT_RULE_ID_MISSING")
+            for branch in ("TrueActions", "FalseActions"):
+                action = stored[branch][0]
+                action["RET"] = merge_action_events(
+                    action["ActionType"], action["RET"], add_events,
+                )
+            if _rule_matches_except_generated_action_ids(matches[0], stored):
+                return {"status": True, "writeAttempted": False,
+                        "data": {"changed": False, "ruleId": rule_id},
+                        "verification": {"verified": True, "preservationVerified": True}}
+            result = do_update_rule_verified(cfg, token, form_number, {
+                "ruleType": "formRule", "ruleId": rule_id,
+                "trueActions": stored["TrueActions"],
+                "falseActions": stored["FalseActions"],
+            })
+            if not _is_api_success(result):
+                return result
+            try:
+                readback = do_load_full_metadata(cfg, token, form_number)
+            except Exception as exc:
+                readback = {"status": False, "message": str(exc)}
+            observed = (_find_rule_projection(readback.get("data"), rule_id)
+                        if _is_api_success(readback) else None)
+            if not _rule_matches_except_generated_action_ids(stored, observed):
+                return {"status": False, "errorCode": "RULE_EVENT_READBACK_MISMATCH",
+                        "message": "Event update could not verify preservation of the complete rule",
+                        "writeAttempted": True, "retryable": False,
+                        "data": {"changed": None, "ruleId": rule_id},
+                        "verification": {"verified": False, "preservationVerified": False}}
+            result.setdefault("data", {}).update({"changed": True, "ruleId": rule_id})
+            result["writeAttempted"] = True
+            result.setdefault("verification", {}).update({
+                "verified": True, "preservationVerified": True,
+                "trueRET": stored["TrueActions"][0]["RET"],
+                "falseRET": stored["FalseActions"][0]["RET"],
+            })
+            return result
         cleaned = _repair_first_option_rule(
             cfg, token, form_number, metadata, requested,
             rule_type="FormRule", family="ConditionalFieldState_",
@@ -2966,7 +3398,7 @@ def do_ensure_conditional_field_state(
 
 def do_ensure_conditional_control_state(
     cfg, token, form_number, entity, condition_field, operator, value,
-    target_control, behavior,
+    target_control, behavior, add_events=None, events=None,
 ):
     """Ensure one reversible conditional control hide/lock rule."""
     action_pair = _CONDITIONAL_CONTROL_ACTIONS.get(
@@ -3003,6 +3435,8 @@ def do_ensure_conditional_control_state(
         identity.encode("utf-8")
     ).hexdigest()[:12]
     true_action, false_action = action_pair
+    true_ret = _requested_action_ret(true_action, 251, events, add_events)
+    false_ret = _requested_action_ret(false_action, 251, events, add_events)
     requested = {
         "ruleType": "formRule",
         "itemId": context["entityId"],
@@ -3019,11 +3453,13 @@ def do_ensure_conditional_control_state(
             "actionType": true_action,
             "description": f"{str(behavior).strip().casefold()} {control_name}",
             "fields": [control_key],
+            "ret": true_ret,
         }],
         "falseActions": [{
             "actionType": false_action,
             "description": f"restore {control_name}",
             "fields": [control_key],
+            "ret": false_ret,
         }],
     }
     current = do_load_full_metadata(cfg, token, form_number)
@@ -3041,6 +3477,15 @@ def do_ensure_conditional_control_state(
         )
     expected = normalize_rule_config(requested)
     if matches:
+        timing_result = _reconcile_existing_rule_events(
+            cfg, token, form_number, matches[0], "formRule", events, add_events,
+        )
+        if timing_result is not None:
+            return timing_result
+        if events is not None or add_events is not None:
+            for branch, stored_branch in (("trueActions", "TrueActions"),
+                                          ("falseActions", "FalseActions")):
+                expected[branch][0]["RET"] = matches[0][stored_branch][0]["RET"]
         mismatches = rule_readback_mismatches(expected, matches[0], metadata)
         if mismatches:
             raise ValueError(
@@ -3312,6 +3757,7 @@ def do_ensure_conditional_client_appearance(cfg, token, form_number, request):
         raise ValueError("CONDITIONAL_CLIENT_APPEARANCE_INPUT_INVALID: input must be an object")
     allowed = {
         "clientMount", "entity", "conditionField", "operator", "value", "effects",
+        "events", "addEvents",
     }
     unknown = sorted(set(request) - allowed)
     if unknown:
@@ -3352,6 +3798,10 @@ def do_ensure_conditional_client_appearance(cfg, token, form_number, request):
     description = "ConditionalClientAppearance_" + hashlib.sha1(
         identity.encode("utf-8")
     ).hexdigest()[:12]
+    for action in actions:
+        action["ret"] = _requested_action_ret(
+            action["actionType"], 251, request.get("events"), request.get("addEvents"),
+        )
     requested = {
         "ruleType": "formRule",
         "clientMount": client_mount,
@@ -3382,9 +3832,19 @@ def do_ensure_conditional_client_appearance(cfg, token, form_number, request):
         cfg, token, form_number, requested
     )
     if matches:
-        mismatches = rule_readback_mismatches(
-            normalize_rule_config(resolved_requested), matches[0], metadata
+        timing_result = _reconcile_existing_rule_events(
+            cfg, token, form_number, matches[0], "formRule",
+            request.get("events"), request.get("addEvents"),
         )
+        if timing_result is not None:
+            return timing_result
+        expected = normalize_rule_config(resolved_requested)
+        if request.get("events") is not None or request.get("addEvents") is not None:
+            for action, stored_action in zip(
+                expected.get("trueActions") or [], matches[0].get("TrueActions") or [],
+            ):
+                action["RET"] = stored_action["RET"]
+        mismatches = rule_readback_mismatches(expected, matches[0], metadata)
         if not mismatches:
             return {
                 "status": True, "errorCode": "0",
@@ -3416,11 +3876,159 @@ def do_ensure_conditional_client_appearance(cfg, token, form_number, request):
     return result
 
 
+def do_ensure_conditional_field_change(
+    cfg, token, form_number, entity, condition_field, operator, value,
+    target, add_events=None, events=None,
+):
+    """Ensure one conditional field-change service action with typed selectors."""
+    if events is not None and add_events is not None:
+        raise ValueError("RULE_EVENTS_CONFLICT: choose exact events or add-events")
+    event_ret = (select_action_events("CallFieldChangeAction", events)
+                 if events is not None else
+                 merge_action_events("CallFieldChangeAction", 773, add_events)
+                 if add_events is not None else 773)
+    context = _resolve_conditional_context(
+        cfg, token, form_number, entity, condition_field, operator, value,
+        target=target,
+    )
+    target_key = context["targetKey"]
+    target_name = context["targetName"]
+    condition_key = context["conditionKey"]
+    condition_name = context["conditionName"]
+    condition_phrase = (
+        f"{condition_name}{'为空' if context['operator'] == 'empty' else '不为空'}"
+        if context["operator"] in {"empty", "not-empty"}
+        else f"{condition_name} {context['operator']} {context['requestedValue']}"
+    )
+    pre_description = f"{condition_phrase}时调用{target_name}字段值更新服务"
+    identity = ":".join((form_number, context["entityKey"], context["expression"], target_key))
+    tagged_description = pre_description + " [CFC_" + hashlib.sha1(
+        identity.encode("utf-8")
+    ).hexdigest()[:12] + "]"
+    description = pre_description
+    requested = {
+        "ruleType": "bizRule", "itemId": context["entityId"],
+        "mountPoint": context["entityKey"], "description": description,
+        "preDescription": pre_description,
+        "preCondition": context["expression"],
+        "triggerField": f"{condition_name}({condition_key})",
+        "enabled": True,
+        "trueActions": [{
+            "actionType": "CallFieldChangeAction", "expression": target_key,
+            "description": f"调用{target_name}字段值更新服务", "ret": event_ret,
+        }], "falseActions": [],
+    }
+    current = do_load_full_metadata(cfg, token, form_number)
+    if not _is_api_success(current):
+        raise RuntimeError("CONDITIONAL_FIELD_CHANGE_READ_FAILED: "
+                           + (_extract_error_message(current) or "loadFullMetadata failed"))
+    metadata = current.get("data")
+    related = [
+        rule for rule in _all_rule_projections(metadata, "BizRule")
+        if str(rule.get("TriggerField") or "") == requested["triggerField"]
+        and str(rule.get("ItemId") or context["entityId"]) == context["entityId"]
+        and not (rule.get("FalseActions") or [])
+        and len(rule.get("TrueActions") or []) == 1
+        and (rule.get("TrueActions") or [{}])[0].get("ActionType") == "CallFieldChangeAction"
+        and str((rule.get("TrueActions") or [{}])[0].get("Expression") or "") == target_key
+    ]
+    matches = [rule for rule in related
+               if str(rule.get("PreCondition") or "") == requested["preCondition"]]
+    if len(matches) > 1:
+        raise ValueError("CONDITIONAL_FIELD_CHANGE_DUPLICATE_RULES: select the intended ruleId")
+    if not matches and related:
+        return {
+            "status": False, "errorCode": "RULE_CONDITION_UPDATE_REQUIRES_RULE_ID",
+            "message": "A rule already calls the same field from this trigger; select the existing ruleId before changing its condition",
+            "writeAttempted": False,
+            "data": {"candidates": [{"ruleId": rule.get("Id"),
+                                     "preCondition": rule.get("PreCondition")}
+                                    for rule in related]},
+        }
+    if matches:
+        stored = copy.deepcopy(matches[0])
+        rule_id = str(stored.get("Id") or "").strip()
+        if not rule_id:
+            raise ValueError("CONDITIONAL_FIELD_CHANGE_RULE_ID_MISSING")
+        generated_name = stored.get("Description") == tagged_description
+        if generated_name:
+            stored["Description"] = description
+        if events is not None and stored["TrueActions"][0].get("RET") != event_ret:
+            return {"status": False, "errorCode": "RULE_EVENT_REPLACE_REQUIRES_RULE_ID",
+                    "message": "Replacing timings on an existing rule requires an exact ruleId",
+                    "writeAttempted": False,
+                    "data": {"ruleId": rule_id, "currentRET": stored["TrueActions"][0].get("RET"),
+                             "requestedRET": event_ret}}
+        if add_events is not None:
+            action = stored["TrueActions"][0]
+            action["RET"] = merge_action_events(
+                "CallFieldChangeAction", action["RET"], add_events,
+            )
+        if not _rule_matches_except_generated_action_ids(matches[0], stored):
+            patch = {"ruleType": "bizRule", "ruleId": rule_id}
+            if generated_name:
+                patch["description"] = description
+            if stored["TrueActions"] != matches[0].get("TrueActions"):
+                patch["trueActions"] = stored["TrueActions"]
+            result = do_update_rule_verified(cfg, token, form_number, patch)
+            if not _is_api_success(result):
+                return result
+            try:
+                readback = do_load_full_metadata(cfg, token, form_number)
+            except Exception as exc:
+                readback = {"status": False, "message": str(exc)}
+            observed = (_find_rule_projection(readback.get("data"), rule_id)
+                        if _is_api_success(readback) else None)
+            if not _rule_matches_except_generated_action_ids(stored, observed):
+                return {"status": False, "errorCode": "RULE_EVENT_READBACK_MISMATCH",
+                        "message": "Field-change event update could not verify the complete rule",
+                        "writeAttempted": True, "retryable": False,
+                        "data": {"changed": None, "ruleId": rule_id},
+                        "verification": {"verified": False, "preservationVerified": False}}
+            result.setdefault("data", {}).update({
+                "changed": True, "ruleId": rule_id,
+                "targetField": target_key, "condition": context["expression"],
+            })
+            result["writeAttempted"] = True
+            result.setdefault("verification", {}).update({
+                "verified": True, "preservationVerified": True,
+                "ret": stored["TrueActions"][0]["RET"],
+            })
+            return result
+        return {
+            "status": True, "errorCode": "0", "writeAttempted": False,
+            "data": {"changed": False, "ruleId": rule_id,
+                     "targetField": target_key, "condition": context["expression"]},
+            "verification": {"scope": "design-metadata", "verified": True,
+                             "preservationVerified": True},
+            "runtimeVerification": {"verified": False,
+                                    "warnings": runtime_action_warnings(requested)},
+        }
+    result = do_add_rule_verified(cfg, token, form_number, requested)
+    if isinstance(result, dict):
+        result["writeAttempted"] = True
+        data = result.setdefault("data", {})
+        if isinstance(data, dict):
+            data.update({"changed": True if _is_api_success(result) else None,
+                         "entityKey": context["entityKey"],
+                         "condition": context["expression"],
+                         "targetField": target_key})
+    return result
+
+
 def do_ensure_conditional_clear_fields(
     cfg, token, form_number, entity, condition_field, operator, value,
-    targets,
+    targets, add_events=None, events=None,
 ):
     """Ensure one entity-scoped conditional ClearValueAction rule."""
+    if events is not None and add_events is not None:
+        raise ValueError("RULE_EVENTS_CONFLICT: choose exact events or add-events")
+    event_ret = (
+        select_action_events("ClearValueAction", events)
+        if events is not None else
+        merge_action_events("ClearValueAction", 253, add_events)
+        if add_events is not None else 253
+    )
     selectors = [str(item or "").strip() for item in (targets or [])]
     selectors = [item for item in selectors if item]
     if not selectors:
@@ -3445,18 +4053,20 @@ def do_ensure_conditional_clear_fields(
     identity = ":".join((
         form_number, context["entityKey"], context["expression"], expression,
     ))
-    description = "ConditionalClearFields_" + hashlib.sha1(
-        identity.encode("utf-8")
-    ).hexdigest()[:12]
+    digest = hashlib.sha1(identity.encode("utf-8")).hexdigest()[:12]
+    legacy_description = "ConditionalClearFields_" + digest
+    pre_description = (
+        f"{context['conditionName']} {context['operator']} "
+        f"{context['requestedValue']} 时清空{'、'.join(target_names)}"
+    )
+    tagged_description = f"{pre_description} [CCF_{digest}]"
+    description = pre_description
     requested = {
         "ruleType": "bizRule",
         "itemId": context["entityId"],
         "mountPoint": context["entityKey"],
         "description": description,
-        "preDescription": (
-            f"{context['conditionName']} {context['operator']} "
-            f"{context['requestedValue']} 时清空{'、'.join(target_names)}"
-        ),
+        "preDescription": pre_description,
         "preCondition": context["expression"],
         "triggerField": f"{context['conditionName']}({context['conditionKey']})",
         "enabled": True,
@@ -3464,7 +4074,7 @@ def do_ensure_conditional_clear_fields(
             "actionType": "ClearValueAction",
             "description": "清除指定字段值",
             "expression": expression,
-            "ret": 253,
+            "ret": event_ret,
         }],
         "falseActions": [],
     }
@@ -3473,7 +4083,8 @@ def do_ensure_conditional_clear_fields(
         requested_targets = set(target_keys)
         predecessors = []
         for rule in _all_rule_projections(metadata, "BizRule"):
-            if not str(rule.get("Description") or "").startswith("ConditionalClearFields_"):
+            text = str(rule.get("Description") or "")
+            if not (text.startswith("ConditionalClearFields_") or " [CCF_" in text):
                 continue
             if str(rule.get("PreCondition") or "") != requested["preCondition"]:
                 continue
@@ -3506,7 +4117,16 @@ def do_ensure_conditional_clear_fields(
             + (_extract_error_message(current) or "loadFullMetadata failed")
         )
     metadata = current.get("data")
-    matches = _rule_projections_by_description(metadata, description)
+    matches = [
+        rule for rule in _all_rule_projections(metadata, "BizRule")
+        if str(rule.get("PreCondition") or "") == requested["preCondition"]
+        and str(rule.get("TriggerField") or "") == requested["triggerField"]
+        and str(rule.get("ItemId") or context["entityId"]) == context["entityId"]
+        and not (rule.get("FalseActions") or [])
+        and len(rule.get("TrueActions") or []) == 1
+        and (rule.get("TrueActions") or [{}])[0].get("ActionType") == "ClearValueAction"
+        and str((rule.get("TrueActions") or [{}])[0].get("Expression") or "") == expression
+    ]
     if len(matches) > 1:
         raise ValueError(
             "CONDITIONAL_CLEAR_FIELDS_DUPLICATE_RULES: "
@@ -3514,6 +4134,22 @@ def do_ensure_conditional_clear_fields(
         )
     expected = normalize_rule_config(requested)
     if matches:
+        current_ret = (matches[0].get("TrueActions") or [{}])[0].get("RET")
+        if events is not None and current_ret != event_ret:
+            return {
+                "status": False, "errorCode": "RULE_EVENT_REPLACE_REQUIRES_RULE_ID",
+                "message": "Replacing timings on an existing rule requires an exact ruleId",
+                "writeAttempted": False,
+                "data": {"ruleId": matches[0].get("Id"),
+                         "currentRET": current_ret, "requestedRET": event_ret},
+            }
+        expected["description"] = matches[0].get("Description")
+        expected["preDescription"] = matches[0].get("PreDescription")
+        current_actions = matches[0].get("TrueActions") or []
+        if len(current_actions) == 1 and "RET" in current_actions[0]:
+            expected["trueActions"][0]["RET"] = current_actions[0]["RET"]
+            expected["trueActions"][0]["Description"] = current_actions[0].get("Description")
+            expected["trueActions"][0]["Seq"] = current_actions[0].get("Seq", 1)
         mismatches = rule_readback_mismatches(expected, matches[0], metadata)
         if mismatches:
             raise ValueError(
@@ -3521,11 +4157,64 @@ def do_ensure_conditional_clear_fields(
                 f"already exists with different metadata; mismatches="
                 f"{json.dumps(mismatches, ensure_ascii=False)}"
             )
+        generated_name = matches[0].get("Description") in {
+            legacy_description, tagged_description,
+        }
+        if add_events is not None or generated_name:
+            stored = copy.deepcopy(matches[0])
+            rule_id = str(stored.get("Id") or "").strip()
+            if not rule_id:
+                raise ValueError("RULE_EVENT_RULE_ID_MISSING")
+            if generated_name:
+                stored["Description"] = description
+            if add_events is not None:
+                action = stored["TrueActions"][0]
+                action["RET"] = merge_action_events(
+                    "ClearValueAction", action["RET"], add_events,
+                )
+            if stored == matches[0]:
+                return {
+                    "status": True, "writeAttempted": False,
+                    "data": {"changed": False, "ruleId": rule_id},
+                    "verification": {"verified": True, "preservationVerified": True},
+                }
+            patch = {"ruleType": "bizRule", "ruleId": rule_id}
+            if generated_name:
+                patch["description"] = description
+            if stored["TrueActions"] != matches[0].get("TrueActions"):
+                patch["trueActions"] = stored["TrueActions"]
+            result = do_update_rule_verified(cfg, token, form_number, patch)
+            if not _is_api_success(result):
+                return result
+            try:
+                readback = do_load_full_metadata(cfg, token, form_number)
+            except Exception as exc:
+                readback = {"status": False, "message": str(exc)}
+            observed = (
+                _find_rule_projection(readback.get("data"), rule_id)
+                if _is_api_success(readback) else None
+            )
+            if not _rule_matches_except_generated_action_ids(stored, observed):
+                return {
+                    "status": False, "errorCode": "RULE_EVENT_READBACK_MISMATCH",
+                    "message": "Event update could not verify preservation of the complete rule",
+                    "writeAttempted": True, "retryable": False,
+                    "data": {"changed": None, "ruleId": rule_id},
+                    "verification": {"verified": False, "preservationVerified": False},
+                }
+            result.setdefault("data", {}).update({"changed": True, "ruleId": rule_id})
+            result["writeAttempted"] = True
+            result.setdefault("verification", {}).update({
+                "verified": True, "preservationVerified": True,
+                "ret": stored["TrueActions"][0]["RET"],
+            })
+            return result
         cleaned = _repair_first_option_rule(
             cfg, token, form_number, metadata, requested,
             rule_type="BizRule", family="ConditionalClearFields_",
             entity_id=context["entityId"], trigger_field=requested["triggerField"],
             markers=["清空", *target_names], replacement_exists=True,
+            family_marker=" [CCF_",
         )
         if cleaned is not None:
             return cleaned
@@ -3560,7 +4249,7 @@ def do_ensure_conditional_clear_fields(
         cfg, token, form_number, metadata, requested,
         rule_type="BizRule", family="ConditionalClearFields_",
         entity_id=context["entityId"], trigger_field=requested["triggerField"],
-        markers=["清空", *target_names],
+        markers=["清空", *target_names], family_marker=" [CCF_",
     )
     if migrated is not None:
         return migrated
@@ -3594,7 +4283,7 @@ def do_ensure_conditional_clear_fields(
 
 def do_ensure_conditional_calculation(
     cfg, token, form_number, entity, condition_field, operator, value,
-    target, left, calculation, right,
+    target, left, calculation, right, add_events=None, events=None,
 ):
     """Ensure one conditional same-entity binary FormulaAction."""
     symbol = _CALCULATION_OPERATORS.get(
@@ -3664,10 +4353,14 @@ def do_ensure_conditional_calculation(
             "actionType": "FormulaAction",
             "description": f"{target_name} = {left_name} {symbol} {right_name}",
             "expression": formula,
-            "ret": 253,
+            "ret": _requested_action_ret("FormulaAction", 253, events, add_events),
         }],
         "falseActions": [],
     }
+    legacy_description = description
+    tagged_description = f"{requested['preDescription']} [CALC_{legacy_description.rsplit('_', 1)[1]}]"
+    description = requested["preDescription"]
+    requested["description"] = description
     current = do_load_full_metadata(cfg, token, form_number)
     if not _is_api_success(current):
         raise RuntimeError(
@@ -3675,17 +4368,41 @@ def do_ensure_conditional_calculation(
             + (_extract_error_message(current) or "loadFullMetadata failed")
         )
     metadata = current.get("data")
-    matches = _rule_projections_by_description(metadata, description)
+    matches = [
+        rule for rule in _all_rule_projections(metadata, "BizRule")
+        if str(rule.get("PreCondition") or "") == requested["preCondition"]
+        and str(rule.get("TriggerField") or "") == requested["triggerField"]
+        and str(rule.get("ItemId") or context["entityId"]) == context["entityId"]
+        and not (rule.get("FalseActions") or [])
+        and len(rule.get("TrueActions") or []) == 1
+        and (rule.get("TrueActions") or [{}])[0].get("ActionType") == "FormulaAction"
+        and str((rule.get("TrueActions") or [{}])[0].get("Expression") or "") == formula
+    ]
     if len(matches) > 1:
         raise ValueError("CONDITIONAL_CALCULATION_DUPLICATE_RULES")
     expected = normalize_rule_config(requested)
     if matches:
+        timing_result = _reconcile_existing_rule_events(
+            cfg, token, form_number, matches[0], "bizRule", events, add_events,
+        )
+        if timing_result is not None:
+            return timing_result
+        if events is not None or add_events is not None:
+            expected["trueActions"][0]["RET"] = matches[0]["TrueActions"][0]["RET"]
+        expected["description"] = matches[0].get("Description")
+        expected["preDescription"] = matches[0].get("PreDescription")
         mismatches = rule_readback_mismatches(expected, matches[0], metadata)
         if mismatches:
             raise ValueError(
                 "CONDITIONAL_CALCULATION_CONFLICT: "
                 + json.dumps(mismatches, ensure_ascii=False)
             )
+        renamed = _upgrade_generated_rule_description(
+            cfg, token, form_number, matches[0],
+            (legacy_description, tagged_description), description,
+        )
+        if renamed is not None:
+            return renamed
         return {
             "status": True, "errorCode": "0",
             "message": "Conditional calculation already matches",
@@ -3777,6 +4494,7 @@ def _quantity_conversion_rule_matches(rule, source_key, target_keys):
 
 def do_ensure_quantity_conversion(
     cfg, token, form_number, entity, source_qty, target_qty,
+    add_events=None, events=None,
 ):
     """Ensure one FillQtyAction from a source QtyField to one or more targets."""
     raw_targets = [target_qty] if isinstance(target_qty, str) else (target_qty or [])
@@ -3852,11 +4570,18 @@ def do_ensure_quantity_conversion(
             "actionType": "FillQtyAction",
             "description": "根据数量关联的单位自动计算目标数量",
             "expression": expression,
-            "ret": 249,
+            "ret": _requested_action_ret("FillQtyAction", 249, events, add_events),
         }],
         "falseActions": [],
     }
-    descriptions = _rule_projections_by_description(metadata, description)
+    legacy_description = description
+    tagged_description = f"{requested['preDescription']} [QCV_{legacy_description.rsplit('_', 1)[1]}]"
+    description = requested["preDescription"]
+    requested["description"] = description
+    descriptions = [
+        *_rule_projections_by_description(metadata, legacy_description),
+        *_rule_projections_by_description(metadata, tagged_description),
+    ]
     semantic = [
         rule for rule in _all_rule_projections(metadata, "BizRule")
         if _quantity_conversion_rule_matches(rule, source_key, target_keys)
@@ -3866,6 +4591,17 @@ def do_ensure_quantity_conversion(
     if descriptions and not semantic:
         raise ValueError("QUANTITY_CONVERSION_CONFLICT")
     if semantic:
+        timing_result = _reconcile_existing_rule_events(
+            cfg, token, form_number, semantic[0], "bizRule", events, add_events,
+        )
+        if timing_result is not None:
+            return timing_result
+        renamed = _upgrade_generated_rule_description(
+            cfg, token, form_number, semantic[0],
+            (legacy_description, tagged_description), description,
+        )
+        if renamed is not None:
+            return renamed
         return {
             "status": True, "errorCode": "0",
             "message": "Quantity conversion already matches",
@@ -3939,25 +4675,32 @@ def _reference_entity_field_candidates(cfg, token, base_entity_id):
     data = inventory.get("data") or {}
     header = data.get("headerFields") or {}
     entries = data.get("entryFields") or {}
-    groups = [header, *(entries.values() if isinstance(entries, dict) else [])]
+    groups = [(header, False), *((group, True) for group in (entries.values() if isinstance(entries, dict) else []))]
     return [
-        field for group in groups if isinstance(group, dict)
+        {**field, "referenceCollection": collection,
+         "referenceEntityKey": group.get("entryKey") or group.get("headerKey")}
+        for group, collection in groups if isinstance(group, dict)
         for field in (group.get("fields") or []) if isinstance(field, dict)
     ]
 
 
 def _ensure_reference_property_for_carry(
-    cfg, token, form_number, source_key, requested_property,
+    cfg, token, form_number, source_key, requested_property, write=True,
+    target_row=None, source_row=None, inventory_cache=None,
 ):
-    state = do_get_properties(
-        cfg, token, form_number, source_key, ["RefProps", "BaseEntityId"]
-    )
+    cache = inventory_cache if inventory_cache is not None else {}
+    state_key = ("properties", source_key)
+    if state_key not in cache:
+        cache[state_key] = do_get_properties(
+            cfg, token, form_number, source_key, ["RefProps", "BaseEntityId"]
+        )
+    state = cache[state_key]
     ref_props = _parse_ref_props_value(state)
     existing = [
         name for name in ref_props
         if name.casefold() == requested_property.casefold()
     ]
-    if len(existing) == 1:
+    if len(existing) == 1 and target_row is None:
         return existing[0], None
     data = state.get("data") or {}
     base_entity_id = str(
@@ -3969,12 +4712,13 @@ def _ensure_reference_property_for_carry(
             f"requested={requested_property!r}, available={ref_props!r}; the "
             "source reference does not expose one BaseEntityId for exact discovery"
         )
-    candidates = _reference_entity_field_candidates(
-        cfg, token, base_entity_id
-    )
+    if base_entity_id not in cache:
+        cache[base_entity_id] = _reference_entity_field_candidates(cfg, token, base_entity_id)
+    candidates = cache[base_entity_id]
+    property_selector = existing[0] if len(existing) == 1 else requested_property
     exact_key = [
         row for row in candidates
-        if str(row.get("key") or "").strip() == requested_property
+        if str(row.get("key") or "").strip() == property_selector
     ]
     matches = exact_key or [
         row for row in candidates
@@ -3987,7 +4731,23 @@ def _ensure_reference_property_for_carry(
             f"{json.dumps([{'key': row.get('key'), 'name': row.get('name'), 'type': row.get('type')} for row in candidates], ensure_ascii=False)}"
         )
     property_key = str(matches[0].get("key") or "").strip()
+    if target_row is not None:
+        collection = (matches[0].get("referenceCollection")
+                      or str(matches[0].get("type") or "").startswith("Mul")
+                      or str((source_row or {}).get("type") or "").startswith("Mul"))
+        if collection:
+            raise ValueError(
+                "CARRY_REFERENCE_COLLECTION_UNSUPPORTED: "
+                f"source={source_key}.{property_key}, sourceEntity={matches[0].get('referenceEntityKey')!r}, "
+                f"target={target_row.get('key')!r}, targetType={target_row.get('type')!r}; "
+                "the source projects a collection, not one scalar value. No RefProps or rule was written. "
+                "Use a plugin with an explicit business selection/aggregation policy; do not take the first row implicitly."
+            )
+    if property_key in ref_props:
+        return property_key, None
     updated = [{"name": name} for name in [*ref_props, property_key]]
+    if not write:
+        return property_key, updated
     written = do_set_ref_props(
         cfg, token, form_number, source_key, updated
     )
@@ -4036,6 +4796,7 @@ def _take_base_rule_matches(
 def do_ensure_conditional_carry_reference_property(
     cfg, token, form_number, entity, condition_field, operator, value,
     source_reference, source_property, target, only_empty_target=False,
+    add_events=None, events=None,
 ):
     """Ensure one conditional TakeBaseProAction from an existing RefProps declaration."""
     if condition_field in (None, ""):
@@ -4060,12 +4821,13 @@ def do_ensure_conditional_carry_reference_property(
     requested_property = str(source_property or "").strip()
     if not requested_property:
         raise ValueError("CONDITIONAL_CARRY_SOURCE_PROPERTY_REQUIRED")
-    property_key, ref_props_write = _ensure_reference_property_for_carry(
-        cfg, token, form_number, source_key, requested_property
-    )
     by_key = {
         str(row.get("key") or "").strip(): row for row in context["fieldRows"]
     }
+    property_key, ref_props_write = _ensure_reference_property_for_carry(
+        cfg, token, form_number, source_key, requested_property,
+        target_row=by_key[target_key], source_row=by_key[source_key],
+    )
     source_name = str((by_key.get(source_key) or {}).get("name") or source_key).strip()
     target_name = str((by_key.get(target_key) or {}).get("name") or target_key).strip()
     source_path = f"{source_key}.{property_key}"
@@ -4102,10 +4864,14 @@ def do_ensure_conditional_carry_reference_property(
             "description": "携带基础资料属性到目标字段",
             "expression": [physical_mapping],
             "fieldName": [display_mapping],
-            "ret": 253,
+            "ret": _requested_action_ret("TakeBaseProAction", 253, events, add_events),
         }],
         "falseActions": [],
     }
+    legacy_description = description
+    tagged_description = f"{requested['preDescription']} [CARRY_{legacy_description.rsplit('_', 1)[1]}]"
+    description = requested["preDescription"]
+    requested["description"] = description
     current = do_load_full_metadata(cfg, token, form_number)
     if not _is_api_success(current):
         raise RuntimeError(
@@ -4113,7 +4879,10 @@ def do_ensure_conditional_carry_reference_property(
             + (_extract_error_message(current) or "loadFullMetadata failed")
         )
     metadata = current.get("data")
-    descriptions = _rule_projections_by_description(metadata, description)
+    descriptions = [
+        *_rule_projections_by_description(metadata, legacy_description),
+        *_rule_projections_by_description(metadata, tagged_description),
+    ]
     semantic = [
         rule for rule in _all_rule_projections(metadata, "BizRule")
         if _take_base_rule_matches(
@@ -4125,6 +4894,21 @@ def do_ensure_conditional_carry_reference_property(
     if descriptions and not semantic:
         raise ValueError("CONDITIONAL_CARRY_CONFLICT")
     if semantic:
+        timing_result = _reconcile_existing_rule_events(
+            cfg, token, form_number, semantic[0], "bizRule", events, add_events,
+        )
+        if timing_result is not None:
+            if ref_props_write is not None and isinstance(timing_result, dict):
+                timing_result["refPropsResult"] = ref_props_write
+            return timing_result
+        renamed = _upgrade_generated_rule_description(
+            cfg, token, form_number, semantic[0],
+            (legacy_description, tagged_description), description,
+        )
+        if renamed is not None:
+            if ref_props_write is not None and isinstance(renamed, dict):
+                renamed["refPropsResult"] = ref_props_write
+            return renamed
         result = {
             "status": True, "errorCode": "0",
             "message": "Conditional carry reference property already matches",
@@ -4173,9 +4957,235 @@ def do_ensure_conditional_carry_reference_property(
     return result
 
 
+@mutation_contract
+def do_ensure_carry_reference_mappings(cfg, token, form_number, request):
+    """Write one TakeBaseProAction whose mapping table has several rows."""
+    if not isinstance(request, dict):
+        raise ValueError("CARRY_MAPPINGS_INPUT_INVALID: expected an object")
+    allowed = {"entity", "conditionField", "operator", "value", "mappings", "branch",
+               "events", "addEvents", "ruleId"}
+    unknown = sorted(set(request) - allowed)
+    mappings = request.get("mappings")
+    if unknown or not isinstance(mappings, list) or not 1 <= len(mappings) <= 50:
+        raise ValueError(
+            f"CARRY_MAPPINGS_INPUT_INVALID: unknown={unknown}; mappings need 1..50 rows. "
+            'Use {"mappings":[{"sourceReference":"<reference>","sourceProperty":"<property>","target":"<target>"}]}; '
+            "all three selectors belong inside each mappings row. For one mapping with source-not-empty default, use --source-reference/--source-property/--target without --input."
+        )
+    branch = str(request.get("branch") or "true").strip().casefold()
+    if branch not in {"true", "false"}:
+        raise ValueError("CARRY_MAPPINGS_BRANCH_INVALID: use true or false")
+    selected_branch = "TrueActions" if branch == "true" else "FalseActions"
+    opposite_branch = "FalseActions" if branch == "true" else "TrueActions"
+    selected_input = "trueActions" if branch == "true" else "falseActions"
+    required = {"sourceReference", "sourceProperty", "target"}
+    for index, mapping in enumerate(mappings):
+        if not isinstance(mapping, dict) or required - set(mapping) or set(mapping) - (required | {"onlyEmptyTarget"}):
+            raise ValueError(f"CARRY_MAPPINGS_ROW_INVALID: mappings[{index}]")
+        if any(not str(mapping[key] or "").strip() for key in required):
+            raise ValueError(f"CARRY_MAPPINGS_ROW_INVALID: mappings[{index}] needs non-empty selectors")
+        if "onlyEmptyTarget" in mapping and not isinstance(mapping["onlyEmptyTarget"], bool):
+            raise ValueError(f"CARRY_MAPPINGS_ROW_INVALID: mappings[{index}].onlyEmptyTarget must be boolean")
+    condition_field = request.get("conditionField")
+    if condition_field in (None, "") and (request.get("operator") not in (None, "") or request.get("value") is not None):
+        raise ValueError("CARRY_MAPPINGS_CONDITION_INVALID: operator/value need conditionField")
+    if condition_field not in (None, "") and not str(request.get("operator") or "").strip():
+        raise ValueError("CARRY_MAPPINGS_CONDITION_INVALID: conditionField needs operator")
+    action_ret = _requested_action_ret(
+        "TakeBaseProAction", 253, request.get("events"), request.get("addEvents"),
+    )
+    selectors = [selector for mapping in mappings
+                 for selector in (mapping["sourceReference"], mapping["target"])]
+    entity_row, rows = _resolve_rule_entity_context(
+        cfg, token, form_number, request.get("entity"), selectors,
+        condition_selectors=[condition_field] if condition_field else [],
+    )
+    entity_key = str(entity_row.get("key") or "").strip()
+    by_key = {str(row.get("key") or "").strip(): row for row in rows if isinstance(row, dict)}
+    resolved = []
+    seen_targets = set()
+    for index, mapping in enumerate(mappings):
+        source_key = resolve_element_rows(rows, mapping["sourceReference"], form_number)
+        target_key = resolve_element_rows(rows, mapping["target"], form_number)
+        if source_key == target_key or target_key in seen_targets:
+            raise ValueError(f"CARRY_MAPPINGS_TARGET_CONFLICT: mappings[{index}] target={target_key!r}")
+        seen_targets.add(target_key)
+        resolved.append((source_key, target_key, str(mapping["sourceProperty"]).strip(),
+                         bool(mapping.get("onlyEmptyTarget"))))
+    if condition_field:
+        context = _resolve_conditional_context(
+            cfg, token, form_number, request.get("entity"), condition_field,
+            request["operator"], request.get("value"), participants=selectors,
+        )
+        condition = context["expression"]
+        condition_key = context["conditionKey"]
+    else:
+        condition = "1 = 1"
+        condition_key = None
+    physical = []
+    display = []
+    ref_props_results = []
+    pending_ref_props = {}
+    inventory_cache = {}
+    for source_key, target_key, source_property, only_empty in resolved:
+        property_key, pending = _ensure_reference_property_for_carry(
+            cfg, token, form_number, source_key, source_property, write=False,
+            target_row=by_key[target_key], source_row=by_key[source_key],
+            inventory_cache=inventory_cache,
+        )
+        if pending is not None:
+            existing_names = pending_ref_props.get(source_key)
+            if existing_names is None:
+                existing_names = [item["name"] for item in pending]
+            pending_ref_props[source_key] = list(dict.fromkeys([
+                *existing_names, property_key,
+            ]))
+        source_name = str((by_key.get(source_key) or {}).get("name") or source_key).strip()
+        target_name = str((by_key.get(target_key) or {}).get("name") or target_key).strip()
+        physical.append({"TargetField": target_key, "SrcField": f"{source_key}.{property_key}",
+                         **({"OnlyEmptyRow": True} if only_empty else {})})
+        display.append({"TargetFieldName": f"{target_name}({target_key})",
+                        "SrcFieldName": f"{source_name}.{property_key}({source_key}.{property_key})",
+                        **({"OnlyEmptyRow": True} if only_empty else {})})
+    trigger_keys = list(dict.fromkeys([
+        *([condition_key] if condition_key else []),
+        *(source_key for source_key, _, _, _ in resolved),
+    ]))
+    trigger_field = ";".join(
+        f"{str((by_key.get(key) or {}).get('name') or key).strip()}({key})"
+        for key in trigger_keys
+    )
+    description = "带出" + "、".join(
+        str((by_key.get(target_key) or {}).get("name") or target_key).strip()
+        for _, target_key, _, _ in resolved
+    )
+    requested = {
+        "ruleType": "bizRule", "itemId": str(entity_row.get("id") or "").strip(),
+        "mountPoint": entity_key, "description": description,
+        "preDescription": description, "preCondition": condition,
+        "triggerField": trigger_field, "enabled": True,
+        "trueActions": [], "falseActions": [],
+    }
+    requested[selected_input] = [{"actionType": "TakeBaseProAction",
+                                  "description": "携带基础资料属性到目标字段",
+                                  "expression": physical, "fieldName": display,
+                                  "ret": action_ret}]
+
+    def write_ref_props():
+        for source_key, names in pending_ref_props.items():
+            written = do_set_ref_props(
+                cfg, token, form_number, source_key,
+                [{"name": name} for name in names],
+            )
+            if not _is_api_success(written) or not bool(
+                (written.get("verification") or {}).get("verified")
+            ):
+                raise RuntimeError("CARRY_MAPPINGS_REFPROPS_WRITE_FAILED: " +
+                                   (_extract_error_message(written) or str(written)))
+            ref_props_results.append(written)
+    current = do_load_full_metadata(cfg, token, form_number)
+    if not _is_api_success(current):
+        raise RuntimeError("CARRY_MAPPINGS_READ_FAILED: " + (_extract_error_message(current) or "loadFullMetadata failed"))
+    metadata = current.get("data")
+    selected_id = str(request.get("ruleId") or "").strip()
+    candidates = [rule for rule in _all_rule_projections(metadata, "BizRule")
+                  if str(rule.get("PreCondition") or "") == condition
+                  and str(rule.get("ItemId") or str(entity_row.get("id") or "")) == str(entity_row.get("id") or "")
+                  and not (rule.get(opposite_branch) or [])
+                  and (rule.get(selected_branch) or [])
+                  and all(isinstance(action, dict) and action.get("ActionType") == "TakeBaseProAction"
+                          for action in rule[selected_branch])]
+    requested_pairs = [(item["TargetField"], item["SrcField"], bool(item.get("OnlyEmptyRow")))
+                       for item in physical]
+    matching = [rule for rule in candidates
+                if sorted((str(item.get("TargetField") or ""), str(item.get("SrcField") or ""),
+                           bool(item.get("OnlyEmptyRow")))
+                          for action in rule[selected_branch]
+                          for item in (action.get("Expression") or [])) == sorted(requested_pairs)
+                and all(len(action.get("Expression") or []) == len(action.get("FieldName") or [])
+                        for action in rule[selected_branch])]
+    overlap = [rule for rule in candidates if rule not in matching and seen_targets.intersection({
+        str(item.get("TargetField") or "")
+        for action in rule[selected_branch]
+        for item in (action.get("Expression") or [])
+    })]
+    if overlap and not selected_id:
+        return {"status": False, "writeAttempted": False,
+                "errorCode": "CARRY_MAPPINGS_TARGET_OVERLAP",
+                "message": "Existing rules already carry part of these targets; inspect the candidate and update its complete mapping list explicitly",
+                "data": {"candidateRuleIds": [rule.get("Id") for rule in overlap]}}
+    if matching and not selected_id and any(
+        str(rule.get("TriggerField") or "") != trigger_field for rule in matching
+    ):
+        return {"status": False, "writeAttempted": bool(ref_props_results),
+                "errorCode": "CARRY_MAPPINGS_EXISTING_RULE_REQUIRES_ID",
+                "message": "Matching mappings already exist with different trigger metadata; select the exact ruleId",
+                "data": {"candidateRuleIds": [rule.get("Id") for rule in matching]}}
+    if selected_id:
+        matching = [rule for rule in matching if str(rule.get("Id") or "") == selected_id]
+        if not matching:
+            raise ValueError("CARRY_MAPPINGS_RULE_ID_MISMATCH: selected rule does not match all mappings")
+    if len(matching) > 1:
+        raise ValueError("CARRY_MAPPINGS_AMBIGUOUS: select one exact ruleId")
+    if matching:
+        rule = matching[0]
+        actions = rule.get(selected_branch) or []
+        if len(actions) == 1:
+            if len(actions[0].get("Expression") or []) == len(physical):
+                if not selected_id and request.get("events") is not None and actions[0].get("RET") != action_ret:
+                    return {"status": False, "writeAttempted": False,
+                            "errorCode": "RULE_EVENT_REPLACE_REQUIRES_RULE_ID",
+                            "message": "Replacing existing timings requires the exact ruleId",
+                            "data": {"candidateRuleId": rule.get("Id")}}
+                write_ref_props()
+                if selected_id and request.get("events") is not None:
+                    patch = {"ruleType": "bizRule", "ruleId": selected_id,
+                             selected_input: [{**actions[0], "RET": action_ret}]}
+                    if actions[0].get("RET") != action_ret:
+                        return do_update_rule_verified(cfg, token, form_number, patch)
+                timing_result = _reconcile_existing_rule_events(
+                    cfg, token, form_number, rule, "bizRule",
+                    None if selected_id else request.get("events"),
+                    request.get("addEvents"),
+                )
+                if timing_result is not None:
+                    return timing_result
+                return {"status": True, "writeAttempted": bool(ref_props_results),
+                        "data": {"changed": bool(ref_props_results), "ruleId": rule.get("Id"),
+                                 "mappingCount": len(physical)},
+                        "verification": {"verified": True, "preservationVerified": True}}
+        if not selected_id:
+            return {"status": False, "writeAttempted": bool(ref_props_results),
+                    "errorCode": "CARRY_MAPPINGS_CONSOLIDATION_REQUIRES_RULE_ID",
+                    "message": "Matching mappings exist as separate services; select their ruleId before consolidation",
+                    "data": {"candidateRuleId": rule.get("Id")}}
+        if len({action.get("RET") for action in actions}) != 1:
+            raise ValueError("CARRY_MAPPINGS_TIMING_CONFLICT: existing services have different timings")
+        requested[selected_input][0]["ret"] = _requested_action_ret(
+            "TakeBaseProAction", actions[0]["RET"],
+            request.get("events"), request.get("addEvents"),
+        )
+        patch = {"ruleType": "bizRule", "ruleId": selected_id,
+                 selected_input: requested[selected_input]}
+        write_ref_props()
+        result = do_update_rule_verified(cfg, token, form_number, patch)
+    else:
+        if selected_id:
+            raise ValueError("CARRY_MAPPINGS_RULE_ID_NOT_FOUND")
+        write_ref_props()
+        result = do_add_rule_verified(cfg, token, form_number, requested)
+    if isinstance(result, dict):
+        result["writeAttempted"] = True
+        result.setdefault("data", {}).update({"changed": _is_api_success(result),
+                                              "mappingCount": len(physical)})
+        if ref_props_results:
+            result["refPropsResults"] = ref_props_results
+    return result
+
+
 def do_ensure_conditional_copy_field_value(
     cfg, token, form_number, entity, condition_field, operator, value,
-    source, target, only_empty_target=False,
+    source, target, only_empty_target=False, add_events=None, events=None,
 ):
     """Ensure one conditional same-entity SetEqutionAction mapping."""
     context = _resolve_conditional_context(
@@ -4226,10 +5236,14 @@ def do_ensure_conditional_copy_field_value(
             "description": "携带字段值到目标字段",
             "expression": [physical_mapping],
             "fieldName": [display_mapping],
-            "ret": 1021,
+            "ret": _requested_action_ret("SetEqutionAction", 1021, events, add_events),
         }],
         "falseActions": [],
     }
+    legacy_description = description
+    tagged_description = f"{requested['preDescription']} [COPY_{legacy_description.rsplit('_', 1)[1]}]"
+    description = requested["preDescription"]
+    requested["description"] = description
     current = do_load_full_metadata(cfg, token, form_number)
     if not _is_api_success(current):
         raise RuntimeError(
@@ -4237,7 +5251,10 @@ def do_ensure_conditional_copy_field_value(
             + (_extract_error_message(current) or "loadFullMetadata failed")
         )
     metadata = current.get("data")
-    descriptions = _rule_projections_by_description(metadata, description)
+    descriptions = [
+        *_rule_projections_by_description(metadata, legacy_description),
+        *_rule_projections_by_description(metadata, tagged_description),
+    ]
     semantic = [
         rule for rule in _all_rule_projections(metadata, "BizRule")
         if _set_equation_rule_matches(
@@ -4249,6 +5266,17 @@ def do_ensure_conditional_copy_field_value(
     if descriptions and not semantic:
         raise ValueError("CONDITIONAL_COPY_FIELD_CONFLICT")
     if semantic:
+        timing_result = _reconcile_existing_rule_events(
+            cfg, token, form_number, semantic[0], "bizRule", events, add_events,
+        )
+        if timing_result is not None:
+            return timing_result
+        renamed = _upgrade_generated_rule_description(
+            cfg, token, form_number, semantic[0],
+            (legacy_description, tagged_description), description,
+        )
+        if renamed is not None:
+            return renamed
         return {
             "status": True, "errorCode": "0",
             "message": "Conditional copy field value already matches",
@@ -4274,12 +5302,219 @@ def do_ensure_conditional_copy_field_value(
     return result
 
 
+@mutation_contract
+def do_ensure_copy_field_mappings(cfg, token, form_number, request):
+    """Write one SetEqutionAction with parallel source/target mapping rows."""
+    if not isinstance(request, dict):
+        raise ValueError("COPY_MAPPINGS_INPUT_INVALID: expected an object")
+    allowed = {"entity", "conditionField", "operator", "value", "mappings", "branch",
+               "events", "addEvents", "ruleId"}
+    mappings = request.get("mappings")
+    if set(request) - allowed or not isinstance(mappings, list) or not 1 <= len(mappings) <= 50:
+        raise ValueError("COPY_MAPPINGS_INPUT_INVALID: expected 1..50 mapping rows")
+    branch = str(request.get("branch") or "true").strip().casefold()
+    if branch not in {"true", "false"}:
+        raise ValueError("COPY_MAPPINGS_BRANCH_INVALID: use true or false")
+    selected_branch = "TrueActions" if branch == "true" else "FalseActions"
+    opposite_branch = "FalseActions" if branch == "true" else "TrueActions"
+    selected_input = "trueActions" if branch == "true" else "falseActions"
+    for index, mapping in enumerate(mappings):
+        if not isinstance(mapping, dict) or {"source", "target"} - set(mapping) or set(mapping) - {"source", "target", "onlyEmptyTarget"}:
+            raise ValueError(f"COPY_MAPPINGS_ROW_INVALID: mappings[{index}]")
+        if not str(mapping["source"] or "").strip() or not str(mapping["target"] or "").strip():
+            raise ValueError(f"COPY_MAPPINGS_ROW_INVALID: mappings[{index}] needs source and target")
+        if "onlyEmptyTarget" in mapping and not isinstance(mapping["onlyEmptyTarget"], bool):
+            raise ValueError(f"COPY_MAPPINGS_ROW_INVALID: mappings[{index}].onlyEmptyTarget must be boolean")
+    condition_field = request.get("conditionField")
+    if condition_field in (None, "") and (request.get("operator") not in (None, "") or request.get("value") is not None):
+        raise ValueError("COPY_MAPPINGS_CONDITION_INVALID: operator/value need conditionField")
+    if condition_field not in (None, "") and not str(request.get("operator") or "").strip():
+        raise ValueError("COPY_MAPPINGS_CONDITION_INVALID: conditionField needs operator")
+    selectors = [selector for mapping in mappings for selector in (mapping["source"], mapping["target"])]
+    entity_row, rows = _resolve_rule_entity_context(
+        cfg, token, form_number, request.get("entity"), selectors,
+        condition_selectors=[condition_field] if condition_field else [],
+    )
+    by_key = {str(row.get("key") or "").strip(): row for row in rows if isinstance(row, dict)}
+    physical = []
+    display = []
+    source_keys = []
+    targets = set()
+    for index, mapping in enumerate(mappings):
+        source_key = resolve_element_rows(rows, mapping["source"], form_number)
+        target_key = resolve_element_rows(rows, mapping["target"], form_number)
+        if source_key == target_key or target_key in targets:
+            raise ValueError(f"COPY_MAPPINGS_TARGET_CONFLICT: mappings[{index}] target={target_key!r}")
+        targets.add(target_key)
+        source_keys.append(source_key)
+        only_empty = bool(mapping.get("onlyEmptyTarget"))
+        physical.append({"TargetField": target_key, "SrcField": source_key,
+                         **({"OnlyEmptyRow": True} if only_empty else {})})
+        display.append({"TargetFieldName": f"{str((by_key.get(target_key) or {}).get('name') or target_key).strip()}({target_key})",
+                        "SrcFieldName": f"{str((by_key.get(source_key) or {}).get('name') or source_key).strip()}({source_key})",
+                        **({"OnlyEmptyRow": True} if only_empty else {})})
+    if condition_field:
+        context = _resolve_conditional_context(
+            cfg, token, form_number, request.get("entity"), condition_field,
+            request["operator"], request.get("value"), participants=selectors,
+        )
+        condition = context["expression"]
+        trigger_keys = [context["conditionKey"], *source_keys]
+    else:
+        condition = "1 = 1"
+        trigger_keys = source_keys
+    trigger_field = ";".join(
+        f"{str((by_key.get(key) or {}).get('name') or key).strip()}({key})"
+        for key in dict.fromkeys(trigger_keys)
+    )
+    description = "携带" + "、".join(
+        str((by_key.get(item["TargetField"]) or {}).get("name") or item["TargetField"]).strip()
+        for item in physical
+    )
+    requested = {
+        "ruleType": "bizRule", "itemId": str(entity_row.get("id") or "").strip(),
+        "mountPoint": str(entity_row.get("key") or "").strip(),
+        "description": description, "preDescription": description,
+        "preCondition": condition, "triggerField": trigger_field, "enabled": True,
+        "trueActions": [], "falseActions": [],
+    }
+    requested[selected_input] = [{"actionType": "SetEqutionAction",
+                                  "description": "携带字段值到目标字段",
+                                  "expression": physical, "fieldName": display,
+                                  "ret": _requested_action_ret(
+                                      "SetEqutionAction", 1021,
+                                      request.get("events"), request.get("addEvents"),
+                                  )}]
+    current = do_load_full_metadata(cfg, token, form_number)
+    if not _is_api_success(current):
+        raise RuntimeError("COPY_MAPPINGS_READ_FAILED: " + (_extract_error_message(current) or "loadFullMetadata failed"))
+    requested_pairs = sorted((item["TargetField"], item["SrcField"], bool(item.get("OnlyEmptyRow")))
+                             for item in physical)
+    matches = [rule for rule in _all_rule_projections(current.get("data"), "BizRule")
+               if str(rule.get("PreCondition") or "") == condition
+               and str(rule.get("ItemId") or requested["itemId"]) == requested["itemId"]
+               and not (rule.get(opposite_branch) or [])
+               and (rule.get(selected_branch) or [])
+               and all(isinstance(action, dict) and action.get("ActionType") == "SetEqutionAction"
+                       for action in rule[selected_branch])
+               and sorted((str(item.get("TargetField") or ""), str(item.get("SrcField") or ""),
+                           bool(item.get("OnlyEmptyRow")))
+                          for action in rule[selected_branch]
+                          for item in (action.get("Expression") or [])) == requested_pairs
+               and all(len(action.get("Expression") or []) == len(action.get("FieldName") or [])
+                       for action in rule[selected_branch])]
+    selected_id = str(request.get("ruleId") or "").strip()
+    overlapping = [rule for rule in _all_rule_projections(current.get("data"), "BizRule")
+                   if rule not in matches
+                   and str(rule.get("PreCondition") or "") == condition
+                   and str(rule.get("ItemId") or requested["itemId"]) == requested["itemId"]
+                   and not (rule.get(opposite_branch) or [])
+                   and (rule.get(selected_branch) or [])
+                   and all(isinstance(action, dict) and action.get("ActionType") == "SetEqutionAction"
+                           for action in rule[selected_branch])
+                   and targets.intersection({
+                       str(item.get("TargetField") or "")
+                       for action in rule[selected_branch]
+                       for item in (action.get("Expression") or [])
+                   })]
+    if overlapping and not selected_id:
+        return {"status": False, "writeAttempted": False,
+                "errorCode": "COPY_MAPPINGS_TARGET_OVERLAP",
+                "message": "Existing rules already copy into part of these targets; inspect the candidate and update its complete mapping list explicitly",
+                "data": {"candidateRuleIds": [rule.get("Id") for rule in overlapping]}}
+    if selected_id:
+        matches = [rule for rule in matches if str(rule.get("Id") or "") == selected_id]
+        if not matches:
+            raise ValueError("COPY_MAPPINGS_RULE_ID_MISMATCH: selected rule does not match all mappings")
+    elif matches and any(str(rule.get("TriggerField") or "") != trigger_field for rule in matches):
+        return {"status": False, "writeAttempted": False,
+                "errorCode": "COPY_MAPPINGS_EXISTING_RULE_REQUIRES_ID",
+                "message": "Matching mappings exist with different trigger metadata; select the exact ruleId",
+                "data": {"candidateRuleIds": [rule.get("Id") for rule in matches]}}
+    if len(matches) > 1:
+        raise ValueError("COPY_MAPPINGS_AMBIGUOUS: select one exact ruleId")
+    if matches:
+        rule = matches[0]
+        actions = rule[selected_branch]
+        if len(actions) == 1 and len(actions[0].get("Expression") or []) == len(physical):
+            if selected_id and request.get("events") is not None and actions[0].get("RET") != requested[selected_input][0]["ret"]:
+                return do_update_rule_verified(cfg, token, form_number, {
+                    "ruleType": "bizRule", "ruleId": selected_id,
+                    selected_input: [{**actions[0], "RET": requested[selected_input][0]["ret"]}],
+                })
+            timing = _reconcile_existing_rule_events(
+                cfg, token, form_number, rule, "bizRule",
+                None if selected_id else request.get("events"), request.get("addEvents"),
+            )
+            if timing is not None:
+                return timing
+            return {"status": True, "writeAttempted": False,
+                    "data": {"changed": False, "ruleId": rule.get("Id"), "mappingCount": len(physical)},
+                    "verification": {"verified": True, "preservationVerified": True}}
+        if not selected_id:
+            return {"status": False, "writeAttempted": False,
+                    "errorCode": "COPY_MAPPINGS_CONSOLIDATION_REQUIRES_RULE_ID",
+                    "message": "Matching mappings exist as separate services; select their ruleId",
+                    "data": {"candidateRuleId": rule.get("Id")}}
+        if len({action.get("RET") for action in actions}) != 1:
+            raise ValueError("COPY_MAPPINGS_TIMING_CONFLICT: existing services have different timings")
+        requested[selected_input][0]["ret"] = _requested_action_ret(
+            "SetEqutionAction", actions[0]["RET"], request.get("events"), request.get("addEvents"),
+        )
+        result = do_update_rule_verified(cfg, token, form_number, {
+            "ruleType": "bizRule", "ruleId": selected_id, selected_input: requested[selected_input],
+        })
+    else:
+        if selected_id:
+            raise ValueError("COPY_MAPPINGS_RULE_ID_NOT_FOUND")
+        result = do_add_rule_verified(cfg, token, form_number, requested)
+    if isinstance(result, dict):
+        result["writeAttempted"] = True
+        result.setdefault("data", {}).update({"changed": _is_api_success(result),
+                                              "mappingCount": len(physical)})
+    return result
+
+
+def _rule_set_action_types(command, args):
+    if command == "ensureConditionalFieldState":
+        pair = _CONDITIONAL_STATE_ACTIONS.get(str(args.get("behavior") or "").casefold())
+        if pair is None:
+            raise ValueError("RULE_SET_ARGS_INVALID: unsupported field-state behavior")
+        return [(kind, 251) for kind in pair]
+    if command == "ensureConditionalControlState":
+        pair = _CONDITIONAL_CONTROL_ACTIONS.get(str(args.get("behavior") or "").casefold())
+        if pair is None:
+            raise ValueError("RULE_SET_ARGS_INVALID: unsupported control-state behavior")
+        return [(kind, 251) for kind in pair]
+    if command == "ensureRuleFunctionFormula":
+        return [("FormulaAction", 253), ("ClearValueAction", 253)]
+    if command == "ensureTimeDifferenceCalculation":
+        return [("FormulaAction", 1021), ("ClearValueAction", 1021)]
+    return [{
+        "ensureConditionalClearFields": ("ClearValueAction", 253),
+        "ensureConditionalFieldChange": ("CallFieldChangeAction", 773),
+        "ensureConditionalCopyFieldValue": ("SetEqutionAction", 1021),
+        "ensureConditionalCalculation": ("FormulaAction", 253),
+        "ensureConditionalCarryReferenceProperty": ("TakeBaseProAction", 253),
+        "ensureQuantityConversion": ("FillQtyAction", 249),
+    }[command]]
+
+
 _RULE_SET_COMMANDS = {
+    "ensureConditionalClientAppearance": (
+        {"request"}, set(),
+    ),
+    "ensureRuleFunctionFormula": (
+        {"target", "call"}, {"entity", "events", "addEvents"},
+    ),
     "ensureFieldCalculation": (
         {"target", "left", "operator", "right"}, {"entity"},
     ),
+    "ensureTimeDifferenceCalculation": (
+        {"target", "start", "end"}, {"entity"},
+    ),
     "ensureConditionalFieldState": (
-        {"conditionField", "operator", "target", "behavior"}, {"entity", "value"},
+        {"conditionField", "operator", "target", "behavior"}, {"entity", "value", "addEvents", "events"},
     ),
     "ensureConditionalEntryStyle": (
         {"conditionField", "operator", "value", "scope"},
@@ -4287,25 +5522,30 @@ _RULE_SET_COMMANDS = {
     ),
     "ensureConditionalControlState": (
         {"conditionField", "operator", "value", "targetControl", "behavior"},
-        {"entity"},
+        {"entity", "events", "addEvents"},
     ),
     "ensureConditionalClearFields": (
-        {"conditionField", "operator", "value", "targets"}, {"entity"},
+        {"conditionField", "operator", "value", "targets"}, {"entity", "addEvents", "events"},
+    ),
+    "ensureConditionalFieldChange": (
+        {"conditionField", "operator", "target"}, {"entity", "value", "addEvents", "events"},
     ),
     "ensureConditionalCopyFieldValue": (
-        {"conditionField", "operator", "value", "source", "target"},
-        {"entity", "onlyEmptyTarget"},
+        set(),
+        {"conditionField", "operator", "value", "source", "target", "mappings", "ruleId",
+         "entity", "onlyEmptyTarget", "events", "addEvents", "branch"},
     ),
     "ensureConditionalCalculation": (
         {"conditionField", "operator", "value", "target", "left", "calculation", "right"},
-        {"entity"},
+        {"entity", "events", "addEvents"},
     ),
     "ensureConditionalCarryReferenceProperty": (
-        {"sourceReference", "sourceProperty", "target"},
-        {"entity", "conditionField", "operator", "value", "onlyEmptyTarget"},
+        set(),
+        {"sourceReference", "sourceProperty", "target", "mappings", "ruleId",
+         "entity", "conditionField", "operator", "value", "onlyEmptyTarget", "events", "addEvents", "branch"},
     ),
     "ensureQuantityConversion": (
-        {"sourceQty", "targetQty"}, {"entity"},
+        {"sourceQty", "targetQty"}, {"entity", "events", "addEvents"},
     ),
 }
 
@@ -4346,7 +5586,42 @@ def _validate_rule_set_request(request):
             )
         if "onlyEmptyTarget" in args and not isinstance(args["onlyEmptyTarget"], bool):
             raise ValueError(f"RULE_SET_ARGS_INVALID: rules[{index}].onlyEmptyTarget must be boolean")
-        if command == "ensureConditionalFieldState":
+        if command == "ensureConditionalCarryReferenceProperty":
+            single = {"sourceReference", "sourceProperty", "target"}
+            if "mappings" in args:
+                if single.intersection(args) or "onlyEmptyTarget" in args:
+                    raise ValueError(f"RULE_SET_ARGS_INVALID: rules[{index}] mixes mappings with single-row arguments")
+                if not isinstance(args["mappings"], list) or not args["mappings"]:
+                    raise ValueError(f"RULE_SET_ARGS_INVALID: rules[{index}].mappings requires rows")
+            elif single - set(args) or "ruleId" in args or "branch" in args:
+                raise ValueError(f"RULE_SET_ARGS_INVALID: rules[{index}] needs one sourceReference/sourceProperty/target")
+        if command == "ensureConditionalCopyFieldValue":
+            single = {"conditionField", "operator", "value", "source", "target"}
+            if "mappings" in args:
+                if {"source", "target", "onlyEmptyTarget"}.intersection(args):
+                    raise ValueError(f"RULE_SET_ARGS_INVALID: rules[{index}] mixes mappings with single-row arguments")
+                if not isinstance(args["mappings"], list) or not args["mappings"]:
+                    raise ValueError(f"RULE_SET_ARGS_INVALID: rules[{index}].mappings requires rows")
+            elif single - set(args) or "ruleId" in args or "branch" in args:
+                raise ValueError(f"RULE_SET_ARGS_INVALID: rules[{index}] needs condition/source/target")
+        if command == "ensureConditionalClientAppearance":
+            if not isinstance(args["request"], dict):
+                raise ValueError(f"RULE_SET_ARGS_INVALID: rules[{index}].request must be an object")
+            allowed_request = {"clientMount", "entity", "conditionField", "operator",
+                               "value", "effects", "events", "addEvents"}
+            missing_request = {"clientMount", "conditionField", "operator", "effects"} - set(args["request"])
+            unknown_request = set(args["request"]) - allowed_request
+            if missing_request or unknown_request:
+                raise ValueError(
+                    f"RULE_SET_ARGS_INVALID: rules[{index}].request "
+                    f"missing={sorted(missing_request)}, unknown={sorted(unknown_request)}"
+                )
+            if "events" in args["request"] or "addEvents" in args["request"]:
+                _requested_action_ret(
+                    "ClientSetFieldAction", 251,
+                    args["request"].get("events"), args["request"].get("addEvents"),
+                )
+        if command in {"ensureConditionalFieldState", "ensureConditionalFieldChange"}:
             blank = str(args.get("operator") or "").strip() in {"empty", "not-empty"}
             if blank and args.get("value") is not None:
                 raise ValueError(
@@ -4358,6 +5633,15 @@ def _validate_rule_set_request(request):
                     f"RULE_SET_ARGS_INVALID: rules[{index}].value is required with "
                     f"operator {args.get('operator')!r}"
                 )
+        if "addEvents" in args:
+            if "events" in args:
+                raise ValueError(f"RULE_SET_ARGS_INVALID: rules[{index}] mixes events and addEvents")
+        if "events" in args or "addEvents" in args:
+            action_types = _rule_set_action_types(command, args)
+            for action_type, default_ret in action_types:
+                _requested_action_ret(
+                    action_type, default_ret, args.get("events"), args.get("addEvents"),
+                )
         normalized.append({
             "id": str(item.get("id") or f"rule-{index + 1}").strip(),
             "command": command,
@@ -4365,7 +5649,10 @@ def _validate_rule_set_request(request):
         })
     calculations = [
         item for item in normalized
-        if item["command"] in {"ensureFieldCalculation", "ensureConditionalCalculation"}
+        if item["command"] in {
+            "ensureFieldCalculation", "ensureTimeDifferenceCalculation",
+            "ensureConditionalCalculation",
+        }
     ]
     for item in normalized:
         if item["command"] != "ensureConditionalClearFields":
@@ -4378,7 +5665,11 @@ def _validate_rule_set_request(request):
                 item["args"].get("entity") or ""
             ).casefold():
                 continue
-            operands = {calculation["args"]["left"], calculation["args"]["right"]}
+            operands = (
+                {calculation["args"]["start"], calculation["args"]["end"]}
+                if calculation["command"] == "ensureTimeDifferenceCalculation"
+                else {calculation["args"]["left"], calculation["args"]["right"]}
+            )
             target = calculation["args"]["target"]
             if operands.intersection(targets) and target not in targets:
                 targets.append(target)
@@ -4393,15 +5684,30 @@ def _execute_rule_set_item(cfg, token, form_number, item):
     args = item["args"]
     entity = args.get("entity")
     command = item["command"]
+    if command == "ensureConditionalClientAppearance":
+        return do_ensure_conditional_client_appearance(
+            cfg, token, form_number, args["request"],
+        )
+    if command == "ensureRuleFunctionFormula":
+        return do_ensure_rule_function_formula(
+            cfg, token, form_number, entity, args["target"], args["call"],
+            args.get("addEvents"), args.get("events"),
+        )
     if command == "ensureFieldCalculation":
         return do_ensure_field_calculation(
             cfg, token, form_number, entity, args["target"], args["left"],
             args["operator"], args["right"],
         )
+    if command == "ensureTimeDifferenceCalculation":
+        return do_ensure_time_difference_calculation(
+            cfg, token, form_number, entity, args["target"],
+            args["start"], args["end"],
+        )
     if command == "ensureConditionalFieldState":
         return do_ensure_conditional_field_state(
             cfg, token, form_number, entity, args["conditionField"],
             args["operator"], args.get("value"), args["target"], args["behavior"],
+            args.get("addEvents"), args.get("events"),
         )
     if command == "ensureConditionalEntryStyle":
         return do_ensure_conditional_entry_style(
@@ -4413,6 +5719,7 @@ def _execute_rule_set_item(cfg, token, form_number, item):
         return do_ensure_conditional_control_state(
             cfg, token, form_number, entity, args["conditionField"],
             args["operator"], args["value"], args["targetControl"], args["behavior"],
+            args.get("addEvents"), args.get("events"),
         )
     if command == "ensureConditionalClearFields":
         targets = args["targets"]
@@ -4420,28 +5727,40 @@ def _execute_rule_set_item(cfg, token, form_number, item):
             targets = [targets]
         return do_ensure_conditional_clear_fields(
             cfg, token, form_number, entity, args["conditionField"],
-            args["operator"], args["value"], targets,
+            args["operator"], args["value"], targets, args.get("addEvents"), args.get("events"),
+        )
+    if command == "ensureConditionalFieldChange":
+        return do_ensure_conditional_field_change(
+            cfg, token, form_number, entity, args["conditionField"],
+            args["operator"], args.get("value"), args["target"],
+            args.get("addEvents"), args.get("events"),
         )
     if command == "ensureConditionalCopyFieldValue":
+        if "mappings" in args:
+            return do_ensure_copy_field_mappings(cfg, token, form_number, args)
         return do_ensure_conditional_copy_field_value(
             cfg, token, form_number, entity, args["conditionField"],
             args["operator"], args["value"], args["source"], args["target"],
-            bool(args.get("onlyEmptyTarget")),
+            bool(args.get("onlyEmptyTarget")), args.get("addEvents"), args.get("events"),
         )
     if command == "ensureConditionalCalculation":
         return do_ensure_conditional_calculation(
             cfg, token, form_number, entity, args["conditionField"],
             args["operator"], args["value"], args["target"], args["left"],
-            args["calculation"], args["right"],
+            args["calculation"], args["right"], args.get("addEvents"), args.get("events"),
         )
     if command == "ensureConditionalCarryReferenceProperty":
+        if "mappings" in args:
+            return do_ensure_carry_reference_mappings(cfg, token, form_number, args)
         return do_ensure_conditional_carry_reference_property(
             cfg, token, form_number, entity, args.get("conditionField"),
             args.get("operator"), args.get("value"), args["sourceReference"],
             args["sourceProperty"], args["target"], bool(args.get("onlyEmptyTarget")),
+            args.get("addEvents"), args.get("events"),
         )
     return do_ensure_quantity_conversion(
         cfg, token, form_number, entity, args["sourceQty"], args["targetQty"],
+        args.get("addEvents"), args.get("events"),
     )
 
 
@@ -4477,8 +5796,11 @@ def _apply_rule_set_items(cfg, token, form_number, items):
             inventory = _RULE_BATCH_INVENTORY.get()
             if inventory is not None:
                 inventory["rows"].clear()
+        from .execution_errors import attach_execution_error
+        error = attach_execution_error(result)
         results.append({
             "id": item["id"], "command": item["command"], "result": result,
+            **({key: error[key] for key in ("errorCategory", "capabilityLimitConfirmed")} if error.get("status") is False else {}),
             **({"derivedTargets": item["derivedTargets"]} if item.get("derivedTargets") else {}),
         })
         if not _is_api_success(result):
@@ -4836,9 +6158,12 @@ def do_update_rule_verified(cfg, token, form_number, rule_config):
                 },
             }
         preserved_rule = copy.deepcopy(preserved_rule)
-    resolved = _validate_fill_qty_action_scope(
+    resolved = _resolve_call_field_change_targets(
         cfg, token, form_number, rule_config
     )
+    resolved = _validate_fill_qty_action_scope(
+        cfg, token, form_number, resolved
+    )
     resolved = _validate_set_field_fmt_targets(cfg, token, form_number, resolved)
     resolved = _resolve_row_fmt_targets(cfg, token, form_number, resolved)
     resolved = _resolve_form_control_targets(cfg, token, form_number, resolved)
@@ -4852,6 +6177,9 @@ def do_update_rule_verified(cfg, token, form_number, rule_config):
     if _is_api_success(result):
         try:
             result = _attach_rule_readback(cfg, token, form_number, resolved, result, preserved_rule=preserved_rule)
+            warnings = runtime_action_warnings(resolved)
+            if _is_api_success(result) and warnings:
+                result["runtimeVerification"] = {"verified": False, "warnings": warnings}
         except Exception as exc:
             result.update({"status": False, "errorCode": "RULE_READBACK_FAILED", "message": str(exc),
                            "writeAttempted": True, "metadataRetained": True,