@shundoo-ai/dsh-cosmic 1.0.21 → 1.0.22

package/skills/cosmic-build/skills/cosmic-meta-api/scripts/field_decorator.py

@@ -86,7 +86,7 @@ def _is_standard(isv: str, standard: bool | None = None) -> bool:
     """Determine whether to use standard naming rules (no ISV prefix).
 
     本地补丁 #16：命名规则强制标准模式（preset 作者 2026-08-27）——原判定整段停用。
-    上游逻辑（按参数/身份判定）保留在下方注释，便于对照与回退。
+    上游逻辑保留在下方注释，便于对照与回退。
     """
     # 上游原逻辑（已停用）：
     # if standard is not None:

package/skills/cosmic-build/skills/cosmic-meta-api/scripts/meta_export.py

@@ -39,7 +39,7 @@ if str(_ROOT_SCRIPTS) not in sys.path:
     sys.path.insert(0, str(_ROOT_SCRIPTS))
 
 from kd_env_loader import load_effective_skill_config, get_locale
-from kd_auth import get_token
+from kd_auth import get_token, make_auth_headers
 from _http_client import DEFAULT_USER_AGENT, with_default_user_agent, get_ssl_context
 
 
@@ -64,14 +64,11 @@ def do_auth(cfg):
     return token
 
 
-def _api_get(base_url, path, access_token):
-    url = base_url.rstrip("/") + path
-    req = urllib.request.Request(url, headers={
-        "access_token": access_token,
-        "api": "true",
-        "Content-Type": "application/json",
-        "User-Agent": DEFAULT_USER_AGENT,
-    })
+def _api_get(cfg, path, access_token):
+    url = cfg["base_url"].rstrip("/") + path
+    headers = make_auth_headers(cfg, access_token, style="legacy_api",
+                                content_type="application/json")
+    req = urllib.request.Request(url, headers=headers)
     with urllib.request.urlopen(req, timeout=60, context=get_ssl_context()) as resp:
         return json.loads(resp.read().decode("utf-8"))
 
@@ -84,13 +81,17 @@ def _resolve_cfg(raw, env="server"):
     """Compatible with nested config (server/pdm sub-nodes) and flat config"""
     section = raw.get(env, raw)
     return {
+        # Pass the whole section through: kd_auth routes on normalAccessToken and also
+        # reads loginUser / userType / acgwIdentity
+        **section,
         "base_url": section.get("base_url") or section.get("baseUrl", ""),
         "app_id": section.get("app_id") or section.get("appId", ""),
         "app_secret": section.get("app_secret") or section.get("appSecret", ""),
         "tenant_id": section.get("tenant_id") or section.get("tenantId", ""),
         "account_id": section.get("account_id") or section.get("accountId", ""),
         "login_user": section.get("login_user") or section.get("user", ""),
-        "user_type": section.get("user_type") or section.get("usertype", "Mobile"),
+        "user_type": section.get("user_type") or section.get("userType") or "Mobile",
+        "normalAccessToken": section.get("normalAccessToken") is True,
         "language": section.get("language", "zh_CN"),
     }
 
@@ -114,7 +115,7 @@ class MetaExportClient:
         query = "&".join(f"{k}={v}" for k, v in params.items())
         path = f"/kapi/v2/devportal/ai-meta/getMetadataExportFiles?{query}"
 
-        resp = _api_get(self._cfg["base_url"], path, self._get_token())
+        resp = _api_get(self._cfg, path, self._get_token())
         error_code = resp.get("errorCode")
         if error_code and error_code != "0":
             raise RuntimeError(

package/skills/cosmic-build/skills/cosmic-meta-api/scripts/meta_verifier.py

@@ -176,6 +176,12 @@ class SpecDeriver:
                             "op": "fieldProperty",
                         },
                     ))
+                if field_key and fld.get("comboOptions"):
+                    specs.append(AssertionSpec(type="combo_options_equal", target=field_key,
+                        expected=fld["comboOptions"], metadata={"fieldType": field_type}))
+                if field_key and fld.get("unitFieldKey"):
+                    specs.append(AssertionSpec(type="unit_binding_equals", target=field_key,
+                        expected=fld["unitFieldKey"], metadata={"fieldType": field_type}))
         for setting in artifact.get("propertySettings") or []:
             if not isinstance(setting, dict):
                 continue
@@ -460,6 +466,8 @@ class Verifier:
             "field_exists": self._check_field_exists,
             "field_not_exists": self._check_field_not_exists,
             "property_equals": self._check_property_equals,
+            "combo_options_equal": self._check_field_configuration,
+            "unit_binding_equals": self._check_field_configuration,
             "element_exists": self._check_element_exists,
             "element_not_exists": self._check_element_not_exists,
             "element_parent": self._check_element_parent,
@@ -765,6 +773,40 @@ class Verifier:
             message=f"Field '{target}' still exists in the form structure (expected to be deleted)",
         )
 
+    def _check_field_configuration(self, spec, form_id, form_number):
+        metadata = self._get_full_metadata(form_number)
+        if "_error" in metadata:
+            return VerifyResult(spec, None, "error", f"loadFullMetadata failed: {metadata['_error']}")
+        items = (metadata.get("entitymeta") or {}).get("Items") or []
+        matches = [item for item in items if isinstance(item, dict) and item.get("Key") == spec.target]
+        if len(matches) != 1:
+            return VerifyResult(spec, None, "error", f"Expected one exact field {spec.target}, found {len(matches)}")
+        field = matches[0]
+        if spec.type == "unit_binding_equals":
+            units = [item for item in items if isinstance(item, dict) and item.get("_Type_") == "UnitField"
+                     and item.get("Id") == field.get("UnitFieldId") and field.get("UnitFieldId")]
+            actual = units[0].get("Key") if len(units) == 1 else None
+            matches = actual == spec.expected and units[0].get("ParentId") == field.get("ParentId") if units else False
+        else:
+            if spec.metadata.get("fieldType") == "RadioField":
+                groups = [item for item in items if isinstance(item, dict) and item.get("Id") == field.get("Group") and field.get("Group")]
+                if len(groups) != 1:
+                    return VerifyResult(spec, None, "error", f"Radio group for {spec.target} is unresolved")
+                field = groups[0]
+            actual = []
+            for index, option in enumerate(field.get("Items") or []):
+                if not isinstance(option, dict):
+                    return VerifyResult(spec, None, "error", f"Invalid option readback for {spec.target}")
+                caption = option.get("Caption")
+                if isinstance(caption, dict):
+                    expected_label = spec.expected[index].get("label") if index < len(spec.expected) else None
+                    caption = expected_label if expected_label in caption.values() else next(iter(caption.values()), "")
+                actual.append({"label": str(caption if caption is not None else ""),
+                               "value": str(option["Value"]) if option.get("Value") is not None else ""})
+            matches = actual == spec.expected
+        return VerifyResult(spec, actual, "pass" if matches else "fail",
+                            f"{spec.target}: {spec.type} {'verified' if matches else 'differs from requested configuration'}")
+
     def _check_property_equals(self, spec, form_id, form_number):
         if not form_number:
             return VerifyResult(

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

@@ -18,9 +18,9 @@ import cosmic_api  # noqa: E402
 
 @pytest.mark.parametrize("batch", [False, True])
 def test_serve_add_field_uses_verified_destination(batch):
-    args = {"formName": "form", "fieldName": "Field", "bizWord": "field", "panel": "panel"}
+    args = {"formName": "form", "fieldName": "Field", "bizWord": "field", "fieldType": "TextField", "panel": "panel"}
     if batch:
-        args = {"formName": "form", "fields": [{"name": "Field", "bizWord": "field", "panel": "panel"}]}
+        args = {"formName": "form", "fields": [{"name": "Field", "bizWord": "field", "fieldType": "TextField", "panel": "panel"}]}
     prepared = {"status": True}
     placements = [{"panel": "resolved_panel"}]
     created = _field_result("field")
@@ -39,7 +39,7 @@ def test_serve_missing_destination_stops_creation():
         "cosmic_api.do_add_fields",
     ) as create:
         result = cosmic_api._dispatch_serve({}, "token", "addField", {
-            "formName": "form", "fields": [{"name": "Field", "bizWord": "field", "panel": "missing"}],
+            "formName": "form", "fields": [{"name": "Field", "bizWord": "field", "fieldType": "TextField", "panel": "missing"}],
         })
     assert result is blocked
     create.assert_not_called()
@@ -66,13 +66,13 @@ def _field_result(*keys):
 
 def test_batch_contract_accepts_per_field_placement_and_rejects_two_anchors():
     cosmic_api.validate_add_fields_input([
-        {"name": "验收字段A", "bizWord": "acceptanceFieldA", "required": True},
-        {"name": "验收字段B", "bizWord": "acceptanceFieldB", "panel": "高级信息"},
+        {"name": "验收字段A", "bizWord": "acceptanceFieldA", "fieldType": "TextField", "required": True},
+        {"name": "验收字段B", "bizWord": "acceptanceFieldB", "fieldType": "TextField", "panel": "高级信息"},
     ])
 
     try:
         cosmic_api.validate_add_fields_input([{
-            "name": "验收字段B", "bizWord": "acceptanceFieldB",
+            "name": "验收字段B", "bizWord": "acceptanceFieldB", "fieldType": "TextField",
             "before": "字段一", "after": "字段二",
         }])
     except ValueError as exc:
@@ -84,8 +84,8 @@ def test_batch_contract_accepts_per_field_placement_and_rejects_two_anchors():
 def test_mixed_batch_does_not_apply_shared_panel_to_unplaced_fields():
     args = SimpleNamespace(
         fields=[
-            {"name": "验收字段A", "bizWord": "acceptanceFieldA", "required": True},
-            {"name": "验收字段B", "bizWord": "acceptanceFieldB", "panel": "高级信息"},
+            {"name": "验收字段A", "bizWord": "acceptanceFieldA", "fieldType": "TextField", "required": True},
+            {"name": "验收字段B", "bizWord": "acceptanceFieldB", "fieldType": "TextField", "panel": "高级信息"},
         ],
         panel=None, before=None, after=None,
     )

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

@@ -0,0 +1,94 @@
+import copy
+import sys
+from pathlib import Path
+
+import pytest
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+import meta_verifier as verifier
+import cosmic_api
+
+
+def artifact():
+    return {"entities": [{"entityKey": "example", "fields": [
+        {"fieldKey": "mode", "dataType": "ComboField", "comboOptions": [
+            {"label": "Pending", "value": "0"}, {"label": "Accepted", "value": "accepted"}]},
+        {"fieldKey": "quantity", "dataType": "QtyField", "unitFieldKey": "measure"},
+        {"fieldKey": "measure", "dataType": "UnitField"},
+    ]}]}
+
+
+def metadata():
+    return {"entitymeta": {"Items": [
+        {"Key": "mode", "_Type_": "ComboField", "Items": [
+            {"Caption": {"zh_CN": "待处理", "en_US": "Pending"}, "Value": 0},
+            {"Caption": "Accepted", "Value": "accepted"}]},
+        {"Key": "quantity", "_Type_": "QtyField", "UnitFieldId": "UNIT", "ParentId": "ENTRY"},
+        {"Key": "measure", "_Type_": "UnitField", "Id": "UNIT", "ParentId": "ENTRY"},
+    ]}}
+
+
+def configuration_specs():
+    return [spec for spec in verifier.SpecDeriver.from_build_artifact(artifact())
+            if spec.type in {"combo_options_equal", "unit_binding_equals"}]
+
+
+def test_configuration_receipts_use_one_shared_native_read(monkeypatch):
+    calls = []
+    def read(*args):
+        calls.append(args)
+        return {"status": True, "data": metadata()}
+    monkeypatch.setattr(verifier, "do_load_full_metadata", read)
+    report = verifier.Verifier({}, "test").verify("FORM", "example", configuration_specs())
+    assert report.status == "pass"
+    assert len(calls) == 1
+    receipt = cosmic_api._compact_verified_targets(report)
+    assert receipt[0]["actual"] == artifact()["entities"][0]["fields"][0]["comboOptions"]
+    assert receipt[1]["expected"] == receipt[1]["actual"] == "measure"
+
+
+@pytest.mark.parametrize("change", ["stored-value", "label", "order", "extra", "wrong-unit", "other-entry"])
+def test_mismatched_configuration_never_becomes_verified(monkeypatch, change):
+    data = metadata()
+    items = data["entitymeta"]["Items"]
+    if change == "stored-value":
+        items[0]["Items"][0]["Value"] = "generated_1"
+    if change == "label":
+        items[0]["Items"][0]["Caption"] = "Different"
+    if change == "order":
+        items[0]["Items"].reverse()
+    if change == "extra":
+        items[0]["Items"].append({"Caption": "Extra", "Value": "extra"})
+    if change == "wrong-unit":
+        items[1]["UnitFieldId"] = "MISSING"
+    if change == "other-entry":
+        items[2]["ParentId"] = "OTHER"
+    monkeypatch.setattr(verifier, "do_load_full_metadata", lambda *args: {"status": True, "data": data})
+    report = verifier.Verifier({}, "test").verify("FORM", "example", configuration_specs())
+    assert report.status == "fail"
+    assert report.summary["failed"] == 1
+    assert len(cosmic_api._compact_verified_targets(report)) == 1
+    assert any(result.actual != result.spec.expected or change == "other-entry"
+               for result in report.results if result.status == "fail")
+
+
+def test_unavailable_readback_is_an_error_and_never_a_pass(monkeypatch):
+    monkeypatch.setattr(verifier, "do_load_full_metadata", lambda *args: {"status": False, "message": "Unavailable"})
+    report = verifier.Verifier({}, "test").verify("FORM", "example", configuration_specs())
+    assert report.status == "partial"
+    assert report.summary["errors"] == 2
+    assert cosmic_api._compact_verified_targets(report) == []
+
+
+def test_requested_shared_unit_is_legal_and_preserved(monkeypatch):
+    data = artifact()
+    second = copy.deepcopy(data["entities"][0]["fields"][1])
+    second["fieldKey"] = "other_quantity"
+    data["entities"][0]["fields"].append(second)
+    observed = metadata()
+    observed["entitymeta"]["Items"].append({"Key": "other_quantity", "_Type_": "QtyField", "UnitFieldId": "UNIT", "ParentId": "ENTRY"})
+    monkeypatch.setattr(verifier, "do_load_full_metadata", lambda *args: {"status": True, "data": observed})
+    specs = [spec for spec in verifier.SpecDeriver.from_build_artifact(data) if spec.type == "unit_binding_equals"]
+    report = verifier.Verifier({}, "test").verify("FORM", "example", specs)
+    assert report.status == "pass"
+    assert len(report.results) == 2

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

@@ -9,6 +9,9 @@ from unittest.mock import patch
 import pytest
 
 SCRIPTS = Path(__file__).resolve().parents[1]
+PACKAGE = SCRIPTS.parents[2]
+if PACKAGE.parent.name == ".locales":
+    PACKAGE = PACKAGE.parent.parent
 sys.path.insert(0, str(SCRIPTS))
 import cosmic_api
 from _core.build_receipts import BuildReceipts
@@ -17,6 +20,32 @@ from _core.execution_errors import attach_execution_error
 from execution_binding import execution_binding, validate_execution_binding
 
 
+@pytest.mark.parametrize("selected_locale,current_locale", [("", ".locales/zh"), (".locales/zh", "")])
+def test_locale_entry_reuses_exact_selected_source_without_rebinding(tmp_path, selected_locale, current_locale):
+    import execution_binding as binding
+    package = tmp_path / "installed"
+    current = package / current_locale
+    selected = package / selected_locale
+    entry = selected / "skills/cosmic-meta-api/scripts/cosmic_api.py"
+    entry.parent.mkdir(parents=True)
+    entry.write_text("# selected runtime")
+    app = tmp_path / "app"
+    (app / "_runtime").mkdir(parents=True)
+    context = app / "_runtime/context.json"
+    original = json.dumps({"executionBinding": {"rootDir": str(selected), "revision": "unchanged"}})
+    context.write_text(original)
+    with patch.object(binding, "__file__", str(current / "scripts/execution_binding.py")):
+        assert binding.bound_entrypoint(app, "skills/cosmic-meta-api/scripts/cosmic_api.py") == entry
+        with pytest.raises(ValueError, match="SKILL_BOUND_ENTRY_MISSING"):
+            binding.bound_entrypoint(app, "skills/missing.py")
+        context.write_text(json.dumps({"executionBinding": {"rootDir": str(tmp_path / "another-install")}}))
+        assert binding.bound_entrypoint(app, "skills/cosmic-meta-api/scripts/cosmic_api.py") is None
+    context.write_text(original)
+    with patch.object(binding, "__file__", str(selected / "scripts/execution_binding.py")):
+        assert binding.bound_entrypoint(app, "skills/cosmic-meta-api/scripts/cosmic_api.py") is None
+    assert context.read_text() == original
+
+
 @contextmanager
 def _isolated_cli():
     from _core import config, formatters
@@ -43,6 +72,23 @@ def _artifacts(tmp_path):
     return data
 
 
+def test_cli_forwards_once_and_preserves_selected_runtime_failure(tmp_path, capfd):
+    selected = tmp_path / "selected cli.py"
+    selected.write_text('import json,sys\nprint(json.dumps({"status":False,"errorCode":"SKILL_REVISION_MISMATCH","argv":sys.argv[1:]}))\nsys.exit(3)\n')
+    arguments = ["--stdout", "getProperties", "--app-root", str(tmp_path),
+                 "--formNumber", "example", "--elementKey", "amount", "--propertyNames", "Scale"]
+    with _isolated_cli(), patch.object(sys, "argv", ["cosmic_api.py", *arguments]), \
+         patch.object(cosmic_api, "_resolve_app_root_arg", return_value=str(tmp_path)), \
+         patch.object(cosmic_api, "bound_entrypoint", return_value=selected), \
+         patch.object(cosmic_api, "validate_execution_binding", side_effect=AssertionError("must validate in selected runtime")), \
+         patch.object(cosmic_api, "load_config", return_value={}), \
+         patch.object(cosmic_api, "do_auth", side_effect=AssertionError("must not authenticate twice")):
+        assert cosmic_api.main() == 3
+    result = json.loads(capfd.readouterr().out)
+    assert result["errorCode"] == "SKILL_REVISION_MISMATCH"
+    assert result["argv"] == arguments
+
+
 def test_verified_dependency_receipt_survives_restart_and_only_pending_target_runs(tmp_path):
     artifacts = _artifacts(tmp_path)
     base, bill = artifacts
@@ -132,7 +178,7 @@ def test_reference_or_input_errors_do_not_claim_platform_limit(code, category):
 @pytest.mark.parametrize("locale", ["", ".locales/zh"])
 def test_cli_stdout_and_result_file_are_the_same_json_in_path_with_spaces(tmp_path, locale):
     output = tmp_path / "result with spaces.json"
-    result = subprocess.run([sys.executable, str(SCRIPTS.parents[2] / locale / "skills" / "cosmic-meta-api" / "scripts" / "cosmic_api.py"), "--stdout", "--output", str(output),
+    result = subprocess.run([sys.executable, str(PACKAGE / locale / "skills" / "cosmic-meta-api" / "scripts" / "cosmic_api.py"), "--stdout", "--output", str(output),
                              "describeCommand", "runBatch"], capture_output=True, text=True)
     assert result.returncode == 0, result.stderr
     assert json.loads(result.stdout) == json.loads(output.read_text())

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

@@ -37,9 +37,12 @@ so rewording the messages keeps them passing.
 
 from __future__ import annotations
 
+import copy
 import sys
 from pathlib import Path
 
+import pytest
+
 SCRIPTS = Path(__file__).resolve().parents[1]
 if str(SCRIPTS) not in sys.path:
     sys.path.insert(0, str(SCRIPTS))
@@ -121,6 +124,90 @@ def test_change_decision_is_one_function() -> None:
     assert workspace_gate(NOOP_RESULT) is _effected_metadata_change(NOOP_RESULT) is False
 
 
+COMBO_OP = {"op": "modify", "target": {"treeType": "entity", "elementType": "field", "value": "status"},
+            "path": "comboItems.add", "value": [{"value": "A", "caption": "Draft"}]}
+
+
+def _receipt_result(ops, statuses, changed=False):
+    return {"status": True, "errorCode": "0", "data": {
+        "success": True, "formId": "60HJ2YS9I1R5", "opsCount": len(ops), "stage": "committed",
+        "writeAttempted": True, "rolledBack": False, "metadataChanged": changed,
+        "opResults": [{"opIndex": index, "op": op["op"], "treeType": op["target"]["treeType"],
+                       "elementType": op["target"]["elementType"], "target": op["target"]["value"],
+                       "path": op.get("path"), "status": status}
+                      for index, (op, status) in enumerate(zip(ops, statuses))]}}
+
+
+def _run_receipt(monkeypatch, result, ops=None):
+    monkeypatch.setattr(cmd_metaops, "_api_call", lambda *a, **k: result)
+    return cmd_metaops.do_modify_meta({}, "token", "60HJ2YS9I1R5", ops or [COMBO_OP],
+                                      form_number="kdtest_bill")
+
+
+def test_complete_matching_noop_is_success_without_claiming_change(monkeypatch):
+    result = _receipt_result([COMBO_OP], ["no_op"])
+    before = copy.deepcopy(result)
+    outcome = _run_receipt(monkeypatch, result)
+    assert outcome["status"] is True
+    assert outcome["data"]["noOp"] is True
+    assert outcome["data"]["metadataChanged"] is False
+    assert outcome["data"]["noOpEvidence"]["scope"] == "handler"
+    assert _effected_metadata_change(outcome) is False  # 不因合法 no_op 导出/同步 DYM。
+    assert result == before
+
+
+@pytest.mark.parametrize("changes", [
+    {"status": "no_channel"}, {"status": "rejected"}, {"status": "unknown"},
+    {"opIndex": -1}, {"opIndex": True}, {"opIndex": "0"}, {"target": "other"},
+    {"path": "comboItems.remove"}, {"op": "remove"}, {"treeType": "form"},
+    {"errorCode": "META_PATH_NO_CHANNEL"}])
+@pytest.mark.parametrize("changed", [False, True])
+def test_incomplete_or_wrong_op_receipt_fails_even_if_metadata_changed(monkeypatch, changes, changed):
+    result = _receipt_result([COMBO_OP], ["no_op"], changed)
+    result["data"]["opResults"][0].update(changes)
+    outcome = _run_receipt(monkeypatch, result)
+    assert outcome["status"] is False
+    assert outcome["errorCode"] == "METADATA_OPS_UNCONFIRMED"
+    assert outcome["data"]["platformResult"] is result
+
+
+@pytest.mark.parametrize("changes", [
+    {"opResults": []}, {"opResults": None}, {"stage": "precheck"}, {"stage": "post_commit"},
+    {"rolledBack": True}, {"formId": "other"}, {"opsCount": 2}])
+def test_missing_coverage_or_unconfirmed_stage_is_not_noop_success(monkeypatch, changes):
+    result = _receipt_result([COMBO_OP], ["no_op"])
+    result["data"].update(changes)
+    assert _run_receipt(monkeypatch, result)["errorCode"] == "METADATA_OPS_UNCONFIRMED"
+
+
+def test_duplicate_and_partial_receipts_cannot_confirm_whole_batch(monkeypatch):
+    ops = [COMBO_OP, {**COMBO_OP, "target": {**COMBO_OP["target"], "value": "status2"}}]
+    result = _receipt_result(ops, ["no_op", "no_op"])
+    result["data"]["opResults"][1]["opIndex"] = 0
+    assert _run_receipt(monkeypatch, result, ops)["errorCode"] == "METADATA_OPS_UNCONFIRMED"
+    result = _receipt_result(ops, ["no_op", "submitted"])
+    assert _run_receipt(monkeypatch, result, ops)["errorCode"] == "METADATA_UNCHANGED"
+
+
+def test_applied_false_snapshot_stays_unconfirmed_and_real_update_passes(monkeypatch):
+    result = _receipt_result([COMBO_OP], ["applied"])
+    assert _run_receipt(monkeypatch, result)["errorCode"] == "METADATA_UNCHANGED"
+    result["data"]["metadataChanged"] = True
+    assert _run_receipt(monkeypatch, result) is result
+    result = _receipt_result([COMBO_OP], ["no_op"], changed=True)
+    assert _run_receipt(monkeypatch, result)["errorCode"] == "METADATA_OPS_UNCONFIRMED"
+
+
+def test_batch_verified_noop_is_not_unknown_after_write(monkeypatch):
+    result = _receipt_result([COMBO_OP], ["no_op"])
+    monkeypatch.setattr(cmd_metaops, "_api_call", lambda *a, **k: result)
+    batch = cmd_metaops.do_batch_modify({}, "token", [
+        {"formId": "60HJ2YS9I1R5", "formNumber": "kdtest_bill", "ops": [COMBO_OP]}])
+    assert batch["status"] is True
+    assert batch["data"]["results"][0]["outcome"] == "succeeded"
+    assert batch["data"]["results"][0]["response"]["data"]["noOp"] is True
+
+
 # ── layer 2: the MetaOps preflight ──────────────────────────────────────────────────
 
 def _move(extra):

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

@@ -1,15 +1,10 @@
 # -*- coding: utf-8 -*-
 """The platform design-state export is a second read-back source for reports.
 
-Verified live: there is no `data.reportSchema`, and `data.formLayout` carries the
-control tree only. The default sort lives in the ReportListAp `InitField` property and the
-data-fetch plugin lives in `ReportQueryPlugin`, so neither had any observable read-back and
-both were reported as `unverifiableSections`.
-
-syncDym exports the platform's own design-state metadata, and that export does carry both.
-These tests pin the parse and the promotion rules, including the two conservative ones: an
-empty section in the export never proves absence, and a canonical projection is never
-overwritten by a file that may predate the last write.
+formLayout 只提供控件树；syncDym 可以补充 ReportQueryPlugin 和过滤属性证据。
+InitField 是默认显示列配置，其中 purpose:sort 是旧 API 污染，不证明排序持久化或运行生效。
+这些测试保留污染夹具作为负向回归：不解析或晋升排序；空插件不证明不存在；
+旧导出不能覆盖 canonical 数据，而 canonical 排序投影同样不能证明运行排序。
 """
 
 import json
@@ -101,15 +96,12 @@ def _derived_schema(filters=()):
 class ParseDesignStateExportTest(unittest.TestCase):
     """The export is parsed into exactly the sections it can prove."""
 
-    def test_sorts_come_from_init_field_in_order(self):
+    def test_polluted_init_field_is_not_sort_evidence(self):
         with tempfile.TemporaryDirectory() as tmp:
             path = _write_dym(tmp, "kdtest_rpt",
                               _dym(sorts=(("order_date", "desc"), ("order_no", "asc"))))
             evidence = report_ops.parse_report_dym(path)
-        self.assertEqual(evidence["reportSorts"], [
-            {"fieldKey": "order_date", "direction": "desc"},
-            {"fieldKey": "order_no", "direction": "asc"},
-        ])
+        self.assertNotIn("reportSorts", evidence)
 
     def test_non_sort_init_field_entries_are_ignored(self):
         with tempfile.TemporaryDirectory() as tmp:
@@ -118,7 +110,7 @@ class ParseDesignStateExportTest(unittest.TestCase):
                 '"purpose": "freeze", "direction": "desc"')
             path = _write_dym(tmp, "kdtest_rpt", body)
             evidence = report_ops.parse_report_dym(path)
-        self.assertEqual(evidence["reportSorts"], [])
+        self.assertNotIn("reportSorts", evidence)
 
     def test_only_the_report_query_plugin_slot_counts(self):
         with tempfile.TemporaryDirectory() as tmp:
@@ -163,21 +155,20 @@ class PromoteDesignStateEvidenceTest(unittest.TestCase):
         report_ops.attach_dym_evidence(target, evidence)
         return target
 
-    def test_both_sections_become_verifiable(self):
+    def test_only_plugins_become_verifiable(self):
         schema = self._attach(sorts=(("order_date", "desc"),),
                               plugins=(("kd.kdtest.report.P", True, "fetch"),))
         self.assertEqual(schema["readBackSource"], "formLayout+dym")
-        self.assertEqual(schema["unverifiableSections"], [])
-        self.assertEqual(schema["dymEvidence"]["provedSections"],
-                         ["reportSorts", "reportPlugins"])
+        self.assertEqual(schema["unverifiableSections"], ["reportSorts"])
+        self.assertEqual(schema["dymEvidence"]["provedSections"], ["reportPlugins"])
         self.assertEqual(schema["undecidablePluginProperties"],
                          ["type", "bizAppId", "fpk", "description"])
 
     def test_an_empty_section_never_proves_absence(self):
         schema = self._attach(sorts=(("order_date", "desc"),))
         # No plugin in the export: that is missing evidence, not proof of no plugin.
-        self.assertEqual(schema["unverifiableSections"], ["reportPlugins"])
-        self.assertEqual(schema["dymEvidence"]["provedSections"], ["reportSorts"])
+        self.assertEqual(schema["unverifiableSections"], ["reportSorts", "reportPlugins"])
+        self.assertNotIn("dymEvidence", schema)
 
     def test_canonical_projection_is_never_overwritten(self):
         canonical = {
@@ -289,16 +280,25 @@ class VerifyAgainstDesignStateEvidenceTest(unittest.TestCase):
         report_ops.attach_dym_evidence(schema, evidence)
         return schema
 
-    def test_sorts_are_fully_verified(self):
+    def test_matching_pollution_never_verifies_sorting(self):
         result = report_ops.report_readback_verification(
             "sorts",
             [{"fieldKey": "order_date", "direction": "desc"},
              {"fieldKey": "order_no", "direction": "asc"}],
             self._promoted(),
         )
-        self.assertTrue(result["verified"], result)
+        self.assertFalse(result["verified"])
+        self.assertEqual(result["errorCode"], "REPORT_SORTS_API_UNSAFE")
         self.assertEqual(result["source"], "formLayout+dym")
 
+    def test_matching_canonical_sorts_are_still_unverified(self):
+        sorts = [{"fieldKey": "order_date", "direction": "desc"}]
+        result = report_ops.report_readback_verification("sorts", sorts, {
+            "readBackAvailable": True, "readBackSource": "canonical", "reportSorts": sorts,
+        })
+        self.assertFalse(result["verified"])
+        self.assertEqual(result["errorCode"], "REPORT_SORTS_API_UNSAFE")
+
     def test_wrong_sort_direction_is_a_mismatch(self):
         result = report_ops.report_readback_verification(
             "sorts", [{"fieldKey": "order_date", "direction": "asc"}], self._promoted())