@shundoo-ai/dsh-cosmic 1.0.21 → 1.0.22

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

@@ -11,7 +11,7 @@ import json
 import copy
 import os
 from .cmd_forms import _resolve_form_id, do_query_forms
-from .cmd_properties import do_set_properties
+from .cmd_properties import do_set_properties_verified
 from .cmd_result import _effected_metadata_change, _is_backend_npe
 from .config import _api_call
 from .formatters import _extract_error_message, _is_api_success
@@ -87,6 +87,37 @@ def validate_batch_manifest(manifest):
                 + "; ".join(validation_errors)
             )
     return manifest
+
+def _metaops_receipt_problem(data, form_id, ops):
+    """逐 op 回执必须覆盖本次请求；submitted 不是逐项持久化证明。"""
+    receipts = data.get("opResults")
+    if not isinstance(receipts, list) or len(receipts) != len(ops):
+        return "逐项回执缺失或数量不完整"
+    if data.get("formId") != form_id or data.get("opsCount") != len(ops):
+        return "回执表单或操作数量不匹配"
+    by_index = {}
+    for receipt in receipts:
+        if not isinstance(receipt, dict) or type(receipt.get("opIndex")) is not int:
+            return "逐项回执或索引类型非法"
+        index = receipt["opIndex"]
+        if index in by_index or not 0 <= index < len(ops):
+            return "逐项索引重复或越界"
+        by_index[index] = receipt
+    for index, op in enumerate(ops):
+        receipt = by_index[index]
+        target = op.get("target") or {}
+        for name, value in (("op", op.get("op")), ("treeType", target.get("treeType")),
+                            ("elementType", target.get("elementType"))):
+            if str(receipt.get(name) or "").lower() != str(value or "").lower():
+                return f"ops[{index}] 的操作或目标类型不匹配"
+        if receipt.get("target") != target.get("value") or receipt.get("path") != op.get("path"):
+            return f"ops[{index}] 的目标或属性路径不匹配"
+        if receipt.get("status") not in {"applied", "no_op", "submitted"}:
+            return f"ops[{index}] 未落实：{receipt.get('status')}"
+        if receipt.get("errorCode") not in (None, "", "0"):
+            return f"ops[{index}] 包含错误：{receipt['errorCode']}"
+    return None
+
 def do_modify_meta(cfg, token, form_id, ops, form_number=None):
     """Execute one non-empty structural MetaOps transaction on an exact form."""
     # Auto-resolve when formId is missing but formNumber is provided (improves CLI/capability caller robustness)
@@ -102,63 +133,49 @@ def do_modify_meta(cfg, token, form_id, ops, form_number=None):
             "NON_ATOMIC_PROPERTY_OP: modifyMeta accepts structural MetaOps only; "
             "use the dedicated property command with its own recovery evidence"
         )
-    # 字段/实体的属性型 modify 由 S5a 判为不可靠（camelCase/PascalCase 静默空转、索引 NPE）。
-    # 此前只是报错让调用方自己改写，而改写所需的信息全在 op 里：
-    #   target.value → elementKey，path → 属性名，value → 属性值
-    # 所以这里直接改道到 Property API，少一个「该用哪个命令」的决策点。
-    # 只改道 entity 树的属性 modify：form 树的 modify 确实可用，而且整个 ops 数组在
-    # MetaOpsApplier 里是单事务单次 save，拆成 N 次 setProperties 会牺牲原子性
-    # （实测一次 modifyMeta 改 3 个控件 833ms，等价的 3 次 setProperties 是 1734ms 且无法整体回滚）。
+    # 所有本地校验先于写入；属性请求必须完整解析，不能静默丢弃未知属性。
     structural_ops, property_calls, unresolved = plan_property_reroute(ops)
-
     if unresolved:
-        print("[modifyMeta] ⚠️ 以下属性无法安全改道，需调用方确认后自行处理：", flush=True)
-        for u in unresolved:
-            print(f"  - {u}", flush=True)
+        raise ValueError("PROPERTY_REROUTE_UNRESOLVED: " + "; ".join(unresolved))
+    validation_errors = _validate_ops(structural_ops) if structural_ops else []
+    if validation_errors:
+        raise ValueError("MetaOps validation failed, API request not sent: "
+                         + "; ".join(validation_errors))
+    if property_calls and not form_number:
+        raise ValueError("PROPERTY_REROUTE_FORM_REQUIRED: 属性改道需要 --formNumber；未发送写入")
+    if property_calls and structural_ops:
+        # 结构重建与属性写入跨事务，调换执行顺序不能普遍保持原 ops 的语义。
+        raise ValueError(
+            "NON_ATOMIC_PROPERTY_OP: 结构变更与属性改道不能混为一次事务；"
+            "先独立完成并回读结构变更，再对实际字段执行 setProperties；未发送写入")
 
     rerouted: list = []
     for call in property_calls:
-        # 改道需要 formNumber（Property API 按编码寻址）。只在调用方已经提供时改道 ——
-        # 与其自己造一条 formId→formNumber 的反查（多一次网络调用、多一处可能出错），
-        # 不如把这种情况如实说清楚，让原来的 S5a 报错继续生效。
-        target_form = form_number
-        if not target_form:
-            print("[modifyMeta] ⚠️ 属性改道需要 --formNumber（Property API 按编码寻址）；"
-                  "本次只提供了 formId，改道跳过，仍按原规则校验", flush=True)
-            property_calls = []
-            rerouted = []
-            structural_ops = ops
-            break
-        outcome = do_set_properties(
-            cfg, token, target_form, call["elementKey"], call["properties"])
+        try:
+            outcome = do_set_properties_verified(
+                cfg, token, form_number, call["elementKey"], call["properties"])
+        except Exception as exc:
+            # 读写可能已发生；保留此前回执，不把异常解释成整批未写入。
+            outcome = {"status": False, "errorCode": "PROPERTY_REROUTE_EXCEPTION",
+                       "message": str(exc), "verification": {"verified": False}}
         rerouted.append({"elementKey": call["elementKey"],
                          "properties": call["properties"],
                          "fromOps": call["ops"],
                          "result": outcome})
+        if not _is_api_success(outcome) or not (outcome.get("verification") or {}).get("verified"):
+            return {"status": False, "errorCode": "PROPERTY_REROUTE_INCOMPLETE",
+                    "message": "属性改道未由独立回读证明；停止后续写入，核对当前状态后再修复",
+                    "writeAttempted": True, "retryAdvice": "reconcile_before_retry",
+                    "data": {"rerouted": rerouted, "pending": property_calls[len(rerouted):]}}
 
-    if rerouted:
-        print("[modifyMeta] ↪ 属性变更已改道 Property API（modifyMeta 对字段/实体属性不可靠）：",
-              flush=True)
+    if property_calls:
         for line in _describe_reroute(property_calls):
-            print(f"  {line}", flush=True)
-
-    # 改道后没有结构性 op 就不必再打扰 modifyMeta
-    if not structural_ops:
-        if not rerouted:
-            raise ValueError(
-                "METAOPS_NOTHING_TO_DO: 所有 op 既非结构变更、也无法改道为属性变更；"
-                "请检查上面列出的未解析项")
+            print(f"[modifyMeta] {line}", flush=True)
         return {"status": True, "errorCode": "0", "data": {
-            "rerouted": rerouted, "unresolved": unresolved,
-            "note": "字段/实体属性变更已由 setProperties 执行，未调用 modifyMeta"}}
+            "rerouted": rerouted, "unresolved": [],
+            "note": "字段/实体属性已由 setProperties 写入并独立回读；未调用 modifyMeta，非跨元素原子事务"}}
 
     ops = structural_ops
-    validation_errors = _validate_ops(ops)
-    if validation_errors:
-        print("[validate] ⚠️ MetaOps validation found issues: ", flush=True)
-        for e in validation_errors:
-            print(f"  - {e}", flush=True)
-        raise ValueError(f"MetaOps validation failed ({len(validation_errors)}  issues), blocked, API request not sent.")
     payload = {"formId": form_id, "ops": ops}
     result = _api_call(cfg, token, "modifyMeta", payload, method="POST")
     if rerouted and isinstance(result, dict):
@@ -166,6 +183,28 @@ def do_modify_meta(cfg, token, form_id, ops, form_number=None):
         if isinstance(result["data"], dict):
             result["data"]["rerouted"] = rerouted
     if _is_api_success(result):
+        data = result.get("data") if isinstance(result.get("data"), dict) else {}
+        if "opResults" in data:
+            problem = _metaops_receipt_problem(data, form_id, ops)
+            if not problem and (data.get("success") is not True or data.get("stage") != "committed"
+                                or data.get("rolledBack") is not False):
+                problem = "提交或回滚阶段未确认"
+            if problem:
+                return {"status": False, "errorCode": "METADATA_OPS_UNCONFIRMED",
+                        "message": problem + "；核对现场后再重试，不重放整批",
+                        "data": {**data, "platformResult": result},
+                        "retryAdvice": "reconcile_before_retry"}
+            if all(row["status"] == "no_op" for row in data["opResults"]):
+                if data.get("metadataChanged") is not False:
+                    return {"status": False, "errorCode": "METADATA_OPS_UNCONFIRMED",
+                            "message": "no_op 与整体变更标志矛盾；先核对现场",
+                            "data": {**data, "platformResult": result}}
+                confirmed = copy.deepcopy(result)
+                confirmed["data"]["noOp"] = True
+                confirmed["data"]["noOpEvidence"] = {"source": "modifyMeta.opResults",
+                    "scope": "handler", "opIndexes": list(range(len(ops)))}
+                print(f"[modifyMeta] 请求已满足（{len(ops)} 项 no_op）；未报告新变更", flush=True)
+                return confirmed
         if not _effected_metadata_change(result):
             advisory = _extract_error_message(result) or (
                 (result.get("data") or {}).get("message") if isinstance(result.get("data"), dict) else ""
@@ -187,8 +226,11 @@ def do_modify_meta(cfg, token, form_id, ops, form_number=None):
                     "formId": form_id,
                     "formNumber": form_number,
                     "opsCount": len(ops),
-                    "writeAttempted": True,
+                    "writeAttempted": data.get("writeAttempted", True),
                     "metadataChanged": False,
+                    "opResults": data.get("opResults"),
+                    "stage": data.get("stage"),
+                    "rolledBack": data.get("rolledBack"),
                     "platformResult": result,
                 },
             }

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

@@ -1430,6 +1430,27 @@ def _normalize_extension_original_readonly(result):
     return result
 
 
+def _unsafe_report_sort_rejection(complex_type, data):
+    """只拦截排序污染，合法默认显示列配置保持原有写入路径。"""
+    values = ([data] if complex_type == "initField" else
+              [value for key, value in data.items() if key.lower() == "initfield"]
+              if isinstance(data, dict) else [])
+    for value in values:
+        if isinstance(value, str):
+            try:
+                value = json.loads(value)
+            except ValueError:
+                continue
+        rows = value if isinstance(value, list) else [value]
+        if any(isinstance(row, dict) and row.get("purpose") == "sort" for row in rows):
+            complex_type = "ReportSorts"
+    if complex_type != "ReportSorts":
+        return None
+    from _core.report_ops import REPORT_SORTS_API_UNSAFE
+    return {"status": False, "errorCode": "REPORT_SORTS_API_UNSAFE",
+            "message": REPORT_SORTS_API_UNSAFE, "writeAttempted": False}
+
+
 def do_set_properties(cfg, token, form_number, element_key, properties):
     """设置简单属性.
 
@@ -1456,6 +1477,9 @@ def do_set_properties(cfg, token, form_number, element_key, properties):
             ),
             "data": {"receivedType": type(properties).__name__},
         }
+    rejection = _unsafe_report_sort_rejection("setProperties", properties)
+    if rejection is not None:
+        return rejection
     rejection = _assert_asst_type_keys(properties)
     if rejection is not None:
         return rejection
@@ -1512,21 +1536,19 @@ def _resolve_property_declaration(rows, selector):
 
 
 def _option_value(options, value):
-    for option in options or []:
-        if not isinstance(option, dict):
-            continue
-        option_id = option.get("id")
-        option_name = option.get("name")
-        option_key = option.get("key")
-        if value == option_id:
-            return option_id, True
-        aliases = {
-            str(candidate).casefold()
-            for candidate in (option_id, option_name, option_key)
-            if candidate is not None
-        }
-        if str(value).casefold() in aliases:
-            return option_id, True
+    rows = [option for option in options or [] if isinstance(option, dict)]
+    exact = [option for option in rows if value == option.get("id") and option.get("id") is not None]
+    if exact:
+        return exact[0]["id"], True
+    matches = [option for option in rows if str(value).casefold() in {
+        str(candidate).casefold() for candidate in (option.get("id"), option.get("name"), option.get("key"))
+        if candidate is not None
+    }]
+    ids = {str(option.get("id")) for option in matches if option.get("id") is not None}
+    if len(ids) > 1:
+        raise ValueError("ambiguous enum value: %r" % value)
+    if len(ids) == 1:
+        return next(option["id"] for option in matches if option.get("id") is not None), True
     return value, False
 
 
@@ -1535,6 +1557,8 @@ def _normalize_simple_property_value(declaration, value):
     editor = str(declaration.get("editorType") or "").casefold()
     options = declaration.get("options") or []
     constraints = declaration.get("constraints") or {}
+    if editor == "ecombo" and not options and value not in (None, "") and not _field_reference_constraints(declaration):
+        raise ValueError("field selector candidates are unavailable in the live schema")
     if str(declaration.get("propertyName") or "") in {"Width", "Height"}:
         value = _normalize_dimension_value(declaration["propertyName"], value)
     if (
@@ -5156,6 +5180,9 @@ def do_set_complex_property(cfg, token, form_number, complex_type, data, element
     """
 
     rejection = _assert_known_complex_type(complex_type)
+    if rejection is not None:
+        return rejection
+    rejection = _unsafe_report_sort_rejection(complex_type, data)
     if rejection is not None:
         return rejection
     if complex_type == "dropdownItems":

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

@@ -11,6 +11,7 @@ import hashlib
 import json
 import re
 from contextvars import ContextVar
+from functools import wraps
 
 from .config import _api_call
 from .cmd_listui import do_load_full_metadata
@@ -57,6 +58,22 @@ def _rule_element_inventory(cfg, token, form_number, category):
         batch["rows"][category] = copy.deepcopy(result)
     return result
 
+def _single_rule_inventory(fn):
+    """Reuse one form inventory during a single semantic write, never across calls."""
+    @wraps(fn)
+    def run(cfg, token, form_number, *args, **kwargs):
+        existing = _RULE_BATCH_INVENTORY.get()
+        if existing is not None and existing["formNumber"] == form_number:
+            return fn(cfg, token, form_number, *args, **kwargs)
+        inventory = {"formNumber": form_number, "rows": {}, "reads": 0, "hits": 0}
+        scope = _RULE_BATCH_INVENTORY.set(inventory)
+        try:
+            return fn(cfg, token, form_number, *args, **kwargs)
+        finally:
+            _RULE_BATCH_INVENTORY.reset(scope)
+    return run
+
+
 # ─── 规则管理 API ──────────────────────────────────────────────────────────────
 
 _FORM_RULE_DEFAULT_RET = FORM_RULE_DEFAULT_RET
@@ -949,9 +966,105 @@ def _strip_formula_literals(expression):
     return "".join(chars)
 
 
+def _compile_time_range_actions(cfg, token, form_number, rule_config):
+    """Expand explicit clock ranges using the platform's stored endpoint keys.
+
+    Only a TimeRangeField assigned a quoted HH:MM[-HH:MM] literal is handled.
+    Other FormulaAction expressions are untouched. Never infer an endpoint key.
+    """
+    if rule_config.get("ruleType") != "bizRule":
+        return rule_config, []
+    pattern = re.compile(r"^\s*([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(['\"])(\d{1,2}):(\d{2})(?::(\d{2}))?\s*[-~]\s*(\d{1,2}):(\d{2})(?::(\d{2}))?\2\s*$")
+    candidates = []
+    for branch in ("trueActions", "falseActions"):
+        for action in rule_config.get(branch) or []:
+            if not isinstance(action, dict):
+                continue
+            action_type = next((value for key, value in action.items() if str(key).casefold() == "actiontype"), "")
+            expression = next((value for key, value in action.items() if str(key).casefold() == "expression"), "")
+            match = pattern.fullmatch(str(expression or "")) if action_type == "FormulaAction" else None
+            if match:
+                candidates.append((branch, action, match))
+    if not candidates:
+        return rule_config, []
+    listed = _rule_element_inventory(cfg, token, form_number, "field")
+    rows = listed.get("data") if isinstance(listed, dict) else None
+    if not _is_api_success(listed) or not isinstance(rows, list):
+        raise RuntimeError("TIME_RANGE_FIELD_INVENTORY_UNAVAILABLE")
+    by_key = {str(row.get("key") or "").strip(): row for row in rows if isinstance(row, dict)}
+    for _, _, match in candidates:
+        matching_rows = [row for row in rows if isinstance(row, dict) and str(row.get("key") or "").strip() == match.group(1)]
+        if len(matching_rows) > 1:
+            raise ValueError("TIME_RANGE_FIELD_AMBIGUOUS")
+    range_candidates = [(branch, action, match) for branch, action, match in candidates
+                        if str((by_key.get(match.group(1)) or {}).get("type") or "") == "TimeRangeField"]
+    if not range_candidates:
+        return rule_config, []
+    loaded = do_load_full_metadata(cfg, token, form_number)
+    if not _is_api_success(loaded):
+        raise RuntimeError("TIME_RANGE_METADATA_UNAVAILABLE")
+    from .cmd_listui import _metadata_nodes
+    nodes = list(_metadata_nodes(loaded.get("data")))
+    mount = str(rule_config.get("mountPoint") or "").strip()
+    if rule_config.get("ruleId"):
+        rules = [(node, parent) for node, parent in nodes if isinstance(node, dict)
+                 and node.get("_Type_") == "BizRule" and str(node.get("Id") or "") == str(rule_config["ruleId"])]
+        if len(rules) != 1 or not rules[0][1]:
+            raise ValueError("TIME_RANGE_RULE_OWNER_UNRESOLVED")
+        mount = rules[0][1]
+    compiled = copy.deepcopy(rule_config)
+    virtual = []
+    for branch in {branch for branch, _, _ in range_candidates}:
+        sequences = [next((value for key, value in action.items() if str(key).casefold() == "seq"), None)
+                     for action in rule_config[branch]]
+        if any(value is not None for value in sequences):
+            if any(not isinstance(value, int) for value in sequences) or sequences != sorted(set(sequences)):
+                raise ValueError("TIME_RANGE_ACTION_ORDER_AMBIGUOUS")
+    for branch, original, match in reversed(range_candidates):
+        key = match.group(1)
+        owner = str(by_key[key].get("parentKey") or "").strip()
+        if not owner or not mount or owner != mount:
+            raise ValueError("TIME_RANGE_ENTITY_MISMATCH: range field must belong to the rule entity")
+        fields = [node for node, _ in nodes if isinstance(node, dict)
+                  and str(node.get("_Type_") or node.get("Type") or "") == "TimeRangeField"
+                  and str(node.get("Key") or "") == key
+                  and node.get("StartDateFieldKey") and node.get("EndDateFieldKey")]
+        if len(fields) != 1:
+            raise ValueError("TIME_RANGE_METADATA_AMBIGUOUS: cannot resolve the time range field")
+        endpoints = [str(fields[0].get(name) or "").strip() for name in ("StartDateFieldKey", "EndDateFieldKey")]
+        if len(set(endpoints)) != 2 or any(not re.fullmatch(r"[A-Za-z_][A-Za-z0-9_]*", key) for key in endpoints):
+            raise ValueError("TIME_RANGE_ENDPOINTS_UNRESOLVED")
+        groups = [(match.group(3), match.group(4), match.group(5)), (match.group(6), match.group(7), match.group(8))]
+        times = [(int(hour), int(minute), int(second or 0)) for hour, minute, second in groups]
+        if any(hour > 23 or minute > 59 or second > 59 for hour, minute, second in times):
+            raise ValueError("TIME_RANGE_VALUE_INVALID: clock time must be between 00:00:00 and 23:59:59")
+        values = [hour * 3600 + minute * 60 + second for hour, minute, second in times]
+        if values[0] > values[1]:
+            raise ValueError("TIME_RANGE_OVERNIGHT_UNSUPPORTED: confirm platform semantics before writing")
+        actions = compiled[branch]
+        index = next(i for i, action in enumerate(rule_config[branch]) if action is original)
+        first = actions[index]
+        second = copy.deepcopy(first)
+        expression_key = next(k for k in first if str(k).casefold() == "expression")
+        first[expression_key] = f"{endpoints[0]} = {values[0]}"
+        second[expression_key] = f"{endpoints[1]} = {values[1]}"
+        for field in list(second):
+            if str(field).casefold() == "id":
+                second.pop(field)
+        actions.insert(index + 1, second)
+        virtual.extend({"key": endpoint, "type": "TimeField", "parentKey": owner} for endpoint in endpoints)
+    for branch in {branch for branch, _, _ in range_candidates}:
+        for index, action in enumerate(compiled[branch], 1):
+            for field in list(action):
+                if str(field).casefold() == "seq":
+                    action.pop(field)
+            action["seq"] = index
+    return compiled, virtual
+
+
 def _validate_formula_action_scope(
     cfg, token, form_number, rule_config, allow_scalar_set_functions=False,
-    allowed_dotted_references=(),
+    allowed_dotted_references=(), virtual_fields=(),
 ):
     """Reject FormulaAction expressions that escape the mounted entity.
 
@@ -980,6 +1093,13 @@ def _validate_formula_action_scope(
         str(row.get("key") or "").strip(): row
         for row in rows if isinstance(row, dict) and str(row.get("key") or "").strip()
     }
+    for row in virtual_fields:
+        existing = by_key.get(row["key"])
+        if existing and (str(existing.get("type") or "") != "TimeField"
+                         or str(existing.get("parentKey") or "").strip() != row["parentKey"]):
+            raise ValueError("TIME_RANGE_ENDPOINT_COLLISION")
+        if not existing:
+            by_key[row["key"]] = row
     for action in actions:
         expression = str(action.get("Expression") or "").strip()
         bare = _strip_formula_literals(expression)
@@ -1152,7 +1272,7 @@ def _validate_set_equation_action_scope(cfg, token, form_number, rule_config):
     if not actions:
         return rule_config
     mounted = str(rule_config.get("mountPoint") or "").strip()
-    listed = do_list_elements(cfg, token, form_number=form_number, category="field")
+    listed = _rule_element_inventory(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(
@@ -1896,9 +2016,10 @@ def do_add_rule_verified(
     _validate_rule_write_input(rule_config, command="addRule")
     client_mount = bool(str(rule_config.get("clientMount") or "").strip())
     resolved = _resolve_rule_entity(cfg, token, form_number, rule_config)
+    resolved, virtual_fields = _compile_time_range_actions(cfg, token, form_number, resolved)
     resolved = _validate_formula_action_scope(
         cfg, token, form_number, resolved, allow_scalar_set_functions,
-        allowed_dotted_references,
+        allowed_dotted_references, virtual_fields,
     )
     resolved = _validate_clear_value_action_scope(
         cfg, token, form_number, resolved
@@ -5183,6 +5304,7 @@ def do_ensure_carry_reference_mappings(cfg, token, form_number, request):
     return result
 
 
+@_single_rule_inventory
 def do_ensure_conditional_copy_field_value(
     cfg, token, form_number, entity, condition_field, operator, value,
     source, target, only_empty_target=False, add_events=None, events=None,
@@ -5225,8 +5347,9 @@ def do_ensure_conditional_copy_field_value(
         "mountPoint": context["entityKey"],
         "description": description,
         "preDescription": (
-            f"{context['conditionName']} {context['operator']} "
-            f"{context['requestedValue']} 时把{source_name}复制到{target_name}"
+            f"{context['conditionName']} {context['operator']}"
+            f"{(' ' + context['requestedValue']) if context['requestedValue'] else ''}"
+            f" 时把{source_name}复制到{target_name}"
         ),
         "preCondition": context["expression"],
         "triggerField": f"{context['conditionName']}({context['conditionKey']})",
@@ -6121,6 +6244,13 @@ def do_ensure_conditional_entry_style(
 
 def do_update_rule_verified(cfg, token, form_number, rule_config):
     _validate_rule_write_input(rule_config, command="updateRule")
+    rule_config, virtual_fields = _compile_time_range_actions(cfg, token, form_number, rule_config)
+    if virtual_fields:
+        _validate_formula_action_scope(
+            cfg, token, form_number,
+            {**rule_config, "mountPoint": virtual_fields[0]["parentKey"]},
+            virtual_fields=virtual_fields,
+        )
     preserved_rule = None
     if set(rule_config) <= {"ruleType", "ruleId", "enabled", "preCondition", "preDescription", "description", "triggerField"} and (
         set(rule_config) - {"ruleType", "ruleId"}

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

@@ -371,7 +371,7 @@ _API_PATH = {
     "metalogCompare":          "/kapi/v2/devportal/ai-meta/metalog/compare",
     "metalogRestore":          "/kapi/v2/devportal/ai-meta/metalog/restore",
 
-    # ─── 本地补丁（LOCAL-PATCHES #13 / #14）：上游 0.0.326 仍无这些端点 ───
+    # ─── 本地补丁（LOCAL-PATCHES #13 / #14）：上游 0.0.343 仍无这些端点 ───
     "ksqlListDbRoutes":   "/kapi/v2/devportal/ai-meta/ksql/listDbRoutes",
     "ksqlListDbTypes":    "/kapi/v2/devportal/ai-meta/ksql/listDbTypes",
     "ksqlListTables":     "/kapi/v2/devportal/ai-meta/ksql/listTables",

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

@@ -12,7 +12,7 @@ def classify_execution_error(result):
     if attempted is not False and (result.get("outcome") == "unknown_after_write"
                                   or result.get("phase") == "writeUnknown"):
         return "unknown_write"
-    if code == "FULL_METADATA_API_UNAVAILABLE":
+    if code in ("FULL_METADATA_API_UNAVAILABLE", "REPORT_COLUMN_DELETE_API_UNAVAILABLE"):
         return "capability_limit"
     if code.endswith("LOOKUP_UNCONFIRMED"):
         return "environment"

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

@@ -652,6 +652,22 @@ def save_run_batch_result(result, app_root, artifact_paths):
     return receipt
 
 
+def result_summary(obj, result_path):
+    """Keep continuation evidence inline; the original receipt stays on disk."""
+    summary = {key: obj[key] for key in (
+        "status", "errorCode", "errorCategory", "message", "total", "completed", "success", "failed",
+        "forms", "delivery", "executionFinished", "writeAttempted", "metadataRetained",
+        "doNotRetryBuildMeta", "resume", "reconcile", "reconciliation", "repairPlans", "modelInstruction",
+    ) if key in obj}
+    summary["resultPath"] = os.path.abspath(result_path)
+    if isinstance(obj.get("results"), list):
+        summary["results"] = [{**{key: row[key] for key in ("artifactPath", "ok", "phase", "error", "errors") if key in row},
+            **({"verification": {key: row["verification"][key] for key in ("performed", "status", "verified", "summary", "verifiedTargets", "issues")
+                if key in row["verification"]}} if isinstance(row.get("verification"), dict) else {})}
+            for row in obj["results"] if isinstance(row, dict)]
+    return summary
+
+
 def pjson(obj, force_stdout=False):
     """Output JSON result.
 
@@ -699,17 +715,7 @@ def pjson(obj, force_stdout=False):
             if isinstance(obj, dict) and (obj.get("delivery") or obj.get("results")):
                 # Keep the complete receipt on disk, while exposing the facts
                 # needed to continue. Never infer verification from exit status.
-                summary = {key: obj[key] for key in (
-                    "status", "errorCode", "errorCategory", "message", "total", "completed", "success", "failed",
-                    "forms", "delivery", "executionFinished", "writeAttempted", "metadataRetained",
-                    "doNotRetryBuildMeta", "resume", "reconcile", "reconciliation",
-                ) if key in obj}
-                summary["resultPath"] = os.path.abspath(target_file)
-                if isinstance(obj.get("results"), list):
-                    summary["results"] = [{**{key: row[key] for key in ("artifactPath", "ok", "phase", "error") if key in row},
-                        **({"verification": {key: row["verification"][key] for key in ("performed", "status", "verified")
-                            if key in row["verification"]}} if isinstance(row.get("verification"), dict) else {})}
-                        for row in obj["results"] if isinstance(row, dict)]
+                summary = result_summary(obj, target_file)
                 print("RESULT_SUMMARY=" + json.dumps(summary, ensure_ascii=False, separators=(",", ":")), file=sys.stdout, flush=True)
     else:
         print(text, file=sys.stdout, flush=True)

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

@@ -3,10 +3,10 @@
 Why this exists
 ---------------
 `validators.py` rule S5a refuses `modify` on `treeType=entity` with `elementType`
-`field`/`entity`, because that path is unreliable: the modifyMeta whitelist is camelCase
-(`mustInput`) while the Property API is PascalCase (`MustInput`), so a non-whitelisted
-property **reports success and changes nothing**; some combinations also hit an
-index-rebuild NPE.
+`field`/`entity`：处理器对未知 path 或不适用类型只 warning 后返回，可能报告成功
+但没有修改。modifyMeta 白名单使用 camelCase（`mustInput`），Property API 使用
+PascalCase（`MustInput`）；白名单支持的 mustInput 不能概括为一定无效。
+原 combo NPE 缺少完整堆栈，尚不能归因为索引重建。
 
 Refusing is correct but it leaves the caller to translate the call by hand — and the
 information needed for that translation is already in the op:
@@ -102,6 +102,9 @@ def plan_property_reroute(ops: list) -> tuple[list, list, list]:
             structural.append(op)
             continue
         target = op.get("target") or {}
+        if not isinstance(target, dict):
+            structural.append(op)
+            continue
         if (op.get("op") != "modify"
                 or target.get("treeType") != "entity"
                 or target.get("elementType") not in ("field", "entity")):
@@ -109,6 +112,10 @@ def plan_property_reroute(ops: list) -> tuple[list, list, list]:
             continue
 
         path = op.get("path")
+        if path is not None and (not isinstance(path, str) or not path.strip()):
+            unresolved.append(f"ops[{index}]: modify.path 必须是非空字符串；Map 形式应省略 path")
+            structural.append(op)
+            continue
         if _is_combo_path(path):
             structural.append(op)          # S5a 豁免，保持原样
             continue
@@ -144,7 +151,10 @@ def plan_property_reroute(ops: list) -> tuple[list, list, list]:
                 f"ops[{index}]: 属性 {bad} 不在属性契约（property-input-index.json）里，"
                 f"不做名称猜测。确认名字后改用 "
                 f"setProperties --elementKey {element_key} --input '{{...}}'")
-        if not resolved:
+        # 一个请求有未知属性时整体保留并拒绝，不能只写已知部分后报告成功。
+        if bad or not resolved:
+            if not raw:
+                unresolved.append(f"ops[{index}]: 属性 Map 为空，无法改道")
             structural.append(op)
             continue