@shundoo-ai/dsh-cosmic 1.0.19 → 1.0.21

package/skills/cosmic-build/scripts/test/test_control_authoring.py

@@ -73,7 +73,7 @@ def test_every_screenshot_control_has_one_published_status() -> None:
     assert not released & deferred
     assert not specialized & deferred
     assert released | specialized | deferred == SCREENSHOT_TYPES
-    assert len(released) == 25
+    assert len(released) == 26
 
 
 def test_aliases_compile_to_deterministic_keys_and_closed_properties() -> None:
@@ -104,6 +104,99 @@ def test_aliases_compile_to_deterministic_keys_and_closed_properties() -> None:
         "parent": "基本信息",
         "controls": [{"type": "按钮", "name": "普通按钮"}],
     })["controls"][0]["type"] == "ButtonAp"
+    assert cmd_controls.validate_control_batch_input({
+        "parent": "uhyl_test09",
+        "controls": [{"type": "通用过滤", "name": "通用过滤"}],
+    })["controls"][0]["type"] == "FilterGridAp"
+    assert cmd_controls.validate_control_batch_input({
+        "parent": "uhyl_test09",
+        "controls": [{"type": "Common Filter", "name": "Common Filter"}],
+    })["controls"][0]["type"] == "FilterGridAp"
+
+
+@pytest.mark.parametrize("locale", ["", ".locales/zh"])
+def test_command_description_contains_complete_control_input(locale) -> None:
+    cli = ROOT / locale / "skills/cosmic-meta-api/scripts/cosmic_api.py"
+    completed = subprocess.run(
+        [sys.executable, str(cli), "--stdout", "describeCommand", "addControls"],
+        capture_output=True, text=True, check=True,
+    )
+    schema = json.loads(completed.stdout)["action"]["payloadSchema"]
+
+    assert schema["required"] == ["controls"]
+    assert schema["$defs"]["control"]["required"] == ["type", "name"]
+    assert schema["$defs"]["panel"]["required"] == ["name"]
+    assert "live form root" in schema["properties"]["parent"]["description"]
+    assert set(schema["x-controlTypes"]) == set(cmd_controls.control_catalog()["data"]["releasedTypes"])
+    assert "通用过滤" in schema["x-controlTypes"]["FilterGridAp"]["aliases"]
+    assert schema["x-commonProperties"]["width"]["type"] == "string"
+    assert schema["x-controlTypes"]["LabelAp"]["properties"]["autoTextWrap"]["type"] == "boolean"
+
+
+@pytest.mark.parametrize("intent, missing_fields", [
+    ({"panel": {}, "controls": [{}, {"type": "LabelAp"}]},
+     ["controls[0].type", "controls[0].name", "controls[1].name", "panel.name"]),
+    ({"panel": {}}, ["controls", "panel.name"]),
+])
+def test_cli_reports_all_missing_fields_before_authentication(intent, missing_fields) -> None:
+    completed = subprocess.run(
+        [sys.executable, str(CLI), "--stdout", "addControls", "--formNumber", "demo",
+         "--input", json.dumps(intent)],
+        capture_output=True, text=True, check=False,
+    )
+    result = json.loads(completed.stdout)
+
+    assert completed.returncode != 0
+    assert result["errorCode"] == "CONTROL_INPUT_INVALID"
+    assert result["recovery"]["missingFields"] == missing_fields
+    assert result["recovery"]["describeCommand"] == "describeCommand addControls"
+    assert "[auth]" not in completed.stderr
+
+
+@pytest.mark.parametrize("control_type", sorted(cmd_controls.control_catalog()["data"]["releasedTypes"]))
+def test_default_root_creation_and_exact_key_retry(control_type) -> None:
+    before = _schema()
+    before["data"]["formLayout"]["children"].append({
+        "key": "manual_control", "name": "Control", "type": control_type,
+    })
+    after = json.loads(json.dumps(before))
+    after["data"]["formLayout"]["children"].append({
+        "key": "new_control", "name": "Control", "type": control_type,
+    })
+    intent = {"controls": [{"key": "new_control", "type": control_type, "name": "Control"}]}
+    with (
+        mock.patch.object(cmd_controls, "do_get_form_schema", side_effect=[before, after, after, after]) as reader,
+        mock.patch.object(cmd_controls, "do_modify_meta", return_value={"status": True}) as writer,
+    ):
+        created = cmd_controls.do_add_controls({}, "token", "FORM-ID", "demo", intent)
+        retried = cmd_controls.do_add_controls({}, "token", "FORM-ID", "demo", intent)
+
+    writer.assert_called_once()
+    assert writer.call_args.args[3][0]["target"]["parentScope"] == "demo"
+    assert reader.call_count == 4
+    assert created["data"]["createdCount"] == 1
+    assert created["data"]["changed"] is True
+    assert retried["data"]["alreadyPresentCount"] == 1
+    assert retried["data"]["changed"] is False
+    assert created["verification"]["verified"] is True
+    assert retried["verification"]["verified"] is True
+
+
+@pytest.mark.parametrize("parent", [None, "unknown_container"])
+def test_unresolved_parent_never_falls_back_to_another_container(parent) -> None:
+    before = _schema()
+    if parent is None:
+        before["data"]["formLayout"].pop("key")
+    with (
+        mock.patch.object(cmd_controls, "do_get_form_schema", return_value=before),
+        mock.patch.object(cmd_controls, "do_modify_meta") as writer,
+    ):
+        with pytest.raises(ValueError, match="CONTROL_PARENT_UNRESOLVED"):
+            cmd_controls.do_add_controls({}, "token", "FORM-ID", "demo", {
+                **({"parent": parent} if parent is not None else {}),
+                "controls": [{"type": "LabelAp", "name": "Control"}],
+            })
+    writer.assert_not_called()
 
 
 @pytest.mark.parametrize(
@@ -247,10 +340,35 @@ def test_existing_key_conflict_blocks_the_complete_batch() -> None:
     writer.assert_not_called()
 
 
-def test_titled_panel_and_palette_button_compile_as_one_verified_batch() -> None:
+def test_common_filter_tile_uses_form_control_writer_not_list_filters() -> None:
+    before = {"status": True, "data": {"formLayout": {
+        "key": "uhyl_test09", "type": "FormAp", "name": "test09", "children": [],
+    }}}
+    after = {"status": True, "data": {"formLayout": {
+        "key": "uhyl_test09", "type": "FormAp", "name": "test09", "children": [
+            {"key": "ctl_filter", "type": "FilterGridAp", "name": "通用过滤"},
+        ],
+    }}}
+    with (
+        mock.patch.object(cmd_controls, "do_get_form_schema", side_effect=[before, after]),
+        mock.patch.object(cmd_controls, "do_modify_meta", return_value={"status": True, "errorCode": "0"}) as writer,
+    ):
+        result = cmd_controls.do_add_controls({}, "token", "FORM-ID", "uhyl_test09", {
+            "parent": "uhyl_test09",
+            "controls": [{"key": "ctl_filter", "type": "通用过滤", "name": "通用过滤"}],
+        })
+
+    assert result["verification"] == {"verified": True, "controlCount": 1}
+    operation = writer.call_args.args[3][0]
+    assert operation["target"]["parentScope"] == "uhyl_test09"
+    assert operation["value"]["controlType"] == "FilterGridAp"
+
+
+@pytest.mark.parametrize("parent", [None, "Content"])
+def test_titled_panel_and_palette_button_compile_as_one_verified_batch(parent) -> None:
     before = _schema()
     after = _schema()
-    content = after["data"]["formLayout"]["children"][0]
+    content = after["data"]["formLayout"] if parent is None else after["data"]["formLayout"]["children"][0]
     content["children"].append({
         "key": "panel_general", "name": "识别控件", "type": "FlexPanelAp",
         "children": [
@@ -316,7 +434,7 @@ def test_titled_panel_and_palette_button_compile_as_one_verified_batch() -> None
             {}, "token", "FORM-ID", "demo", {
                 "panel": {
                     "key": "panel_general", "name": "识别控件",
-                    "parent": "Content",
+                    **({"parent": parent} if parent is not None else {}),
                 },
                 "controls": [
                     {"key": "ctl_button", "type": "按钮", "name": "按钮"},
@@ -328,6 +446,7 @@ def test_titled_panel_and_palette_button_compile_as_one_verified_batch() -> None
     assert result["status"] is True
     assert result["verification"] == {"verified": True, "controlCount": 2}
     assert result["data"]["panel"]["verified"] is True
+    assert result["data"]["panel"]["parent"] == ("demo" if parent is None else "contentpanel")
     assert result["data"]["panel"]["presentation"] == "auto"
     assert result["data"]["runtimeVerification"] == {
         "performed": False,

package/skills/cosmic-build/scripts/test/test_cosmic_sdk_examples.py

@@ -0,0 +1,141 @@
+"""Compile the Cosmic SDK examples and run the time adapter's value assertions."""
+
+import os
+import shutil
+import shlex
+import subprocess
+from pathlib import Path
+
+import pytest
+
+
+EXAMPLE = Path(__file__).resolve().parents[2] / "examples" / "java-rules"
+SDK_JAR = os.environ.get("COSMIC_SDK_DATAENTITY_JAR", "")
+QUERY_CLASSPATH = os.environ.get("COSMIC_SDK_QUERY_CLASSPATH", "")
+OPERATION_CLASSPATH = os.environ.get("COSMIC_SDK_OPERATION_CLASSPATH", "")
+
+
+@pytest.mark.skipif(not shutil.which("javac") or not shutil.which("java") or not Path(SDK_JAR).is_file(),
+                    reason="target SDK JAR or JDK unavailable")
+def test_cosmic_time_adapter_compiles_against_target_sdk_and_rejects_bad_values(tmp_path):
+    subprocess.run([
+        "javac", "-source", "8", "-target", "8", "-cp", SDK_JAR, "-d", str(tmp_path),
+        str(EXAMPLE / "CosmicTimeAdapter.java"),
+        str(EXAMPLE / "CosmicTimeAdapterCheck.java"),
+    ], check=True, capture_output=True, text=True)
+    result = subprocess.run(
+        ["java", "-cp", os.pathsep.join([str(tmp_path), SDK_JAR]), "CosmicTimeAdapterCheck"],
+        check=True, capture_output=True, text=True,
+    )
+    assert result.stdout.strip() == "CosmicTimeAdapter: 6 cases passed"
+
+
+@pytest.mark.skipif(not shutil.which("javac") or not QUERY_CLASSPATH,
+                    reason="target query SDK classpath unavailable")
+def test_cosmic_entry_query_compiles_against_the_target_sdk(tmp_path):
+    subprocess.run([
+        "javac", "-source", "8", "-target", "8", "-cp", QUERY_CLASSPATH, "-d", str(tmp_path),
+        str(EXAMPLE / "CosmicEntryQuery.java"),
+    ], check=True, capture_output=True, text=True)
+    assert (tmp_path / "CosmicEntryQuery.class").is_file()
+
+
+def _compile_report_filter_check(tmp_path, example=EXAMPLE):
+    check = tmp_path / "ReportFilterCheck.java"
+    check.write_text('''
+import kd.bos.entity.report.FilterInfo;
+import kd.bos.dataentity.entity.DynamicObject;
+import kd.bos.dataentity.entity.DynamicObjectCollection;
+import kd.bos.dataentity.metadata.dynamicobject.DynamicObjectType;
+import java.util.Arrays;
+import java.util.Date;
+public class ReportFilterCheck {
+    static void reject(Runnable call) {
+        try { call.run(); } catch (IllegalArgumentException expected) { return; }
+        throw new AssertionError("invalid value accepted");
+    }
+    public static void main(String[] args) {
+        FilterInfo filter = new FilterInfo();
+        filter.addFilterItem("shfz_mode", "0");
+        if (!"0".equals(CosmicReportFilters.value(filter, "flt_mode", "shfz_mode"))) throw new AssertionError("zero enum");
+        if (CosmicReportFilters.value(filter, "unknown") != null) throw new AssertionError("missing key");
+        filter.addFilterItem("flt_mode", "2");
+        reject(() -> CosmicReportFilters.value(filter, "flt_mode", "shfz_mode"));
+        Date start = new Date(1000L);
+        filter.addFilterItem("flt_date_startdate", start, ">=");
+        if (CosmicReportFilters.value(filter, "flt_date") != null) throw new AssertionError("unsplit key");
+        if (!start.equals(CosmicReportFilters.date(filter, "flt_date_startdate"))) throw new AssertionError("split Date");
+        if (!start.equals(filter.getValue("flt_date_startdate"))) throw new AssertionError("getValue delegates to item");
+        if (CosmicReportFilters.date(filter, "flt_date_enddate") != null) throw new AssertionError("open end");
+        filter.addFilterItem("bad_date", "2026-10-01");
+        reject(() -> CosmicReportFilters.date(filter, "bad_date"));
+        reject(() -> CosmicReportFilters.numbers(10L));
+        if (!CosmicReportFilters.numbers(null).isEmpty()) throw new AssertionError("empty F7");
+        if (args.length == 0) { System.out.println("report filter SDK checks passed"); return; }
+        DynamicObjectType type = new DynamicObjectType("supplier");
+        type.registerProperty("number", String.class, null, false);
+        type.registerProperty("id", Long.class, null, false);
+        DynamicObject first = new DynamicObject(type);
+        first.set("number", "0012"); first.set("id", 10L);
+        DynamicObject second = new DynamicObject(type);
+        second.set("number", "0012"); second.set("id", 20L);
+        if (!CosmicReportFilters.numbers(first).equals(Arrays.asList("0012"))) throw new AssertionError("single F7");
+        DynamicObjectCollection values = new DynamicObjectCollection(type, null);
+        values.add(first); values.add(second);
+        if (!CosmicReportFilters.numbers(values).equals(Arrays.asList("0012"))) throw new AssertionError("assigned ids differ");
+        second.set("number", "0034");
+        if (!CosmicReportFilters.numbers(values).equals(Arrays.asList("0012", "0034"))) throw new AssertionError("multi F7");
+        second.set("number", ""); reject(() -> CosmicReportFilters.numbers(values));
+        System.out.println("report filter SDK checks passed");
+    }
+}
+''')
+    subprocess.run(["javac", "-source", "8", "-target", "8", "-cp", QUERY_CLASSPATH, "-d", str(tmp_path),
+                    str(example / "CosmicReportFilters.java"), str(check)], check=True, capture_output=True, text=True)
+
+
+@pytest.mark.skipif(not shutil.which("javac") or not QUERY_CLASSPATH,
+                    reason="target query SDK classpath unavailable")
+@pytest.mark.parametrize("example", [EXAMPLE, EXAMPLE.parents[1] / ".locales" / "zh" / "examples" / "java-rules"])
+def test_report_filter_adapter_against_real_sdk_objects(tmp_path, example):
+    _compile_report_filter_check(tmp_path, example)
+    result = subprocess.run(["java", "-cp", os.pathsep.join([str(tmp_path), QUERY_CLASSPATH]), "ReportFilterCheck"],
+                            cwd=tmp_path, timeout=20, check=True, capture_output=True, text=True)
+    assert result.stdout.strip() == "report filter SDK checks passed"
+
+
+@pytest.mark.skipif(not shutil.which("javac") or not QUERY_CLASSPATH
+                    or not os.environ.get("COSMIC_SDK_RUNTIME_JAVA_OPTIONS"),
+                    reason="F7 metadata runtime needs the authorized target configuration/logging service")
+def test_report_f7_records_with_target_runtime_configuration(tmp_path):
+    _compile_report_filter_check(tmp_path)
+    result = subprocess.run(["java", *shlex.split(os.environ["COSMIC_SDK_RUNTIME_JAVA_OPTIONS"]), "-cp",
+        os.pathsep.join([str(tmp_path), QUERY_CLASSPATH]), "ReportFilterCheck", "f7"],
+        cwd=tmp_path, timeout=20, check=True, capture_output=True, text=True)
+    assert "report filter SDK checks passed" in result.stdout
+
+
+@pytest.mark.skipif(not shutil.which("javac") or not OPERATION_CLASSPATH,
+                    reason="target operation SDK classpath unavailable")
+def test_operation_receivers_expose_their_own_keys_in_the_target_sdk(tmp_path):
+    source = tmp_path / "OperationAccessorCheck.java"
+    source.write_text('''
+import kd.bos.entity.plugin.args.BeginOperationTransactionArgs;
+import kd.bos.entity.validate.AbstractValidator;
+public class OperationAccessorCheck {
+    public static void main(String[] args) {
+        BeginOperationTransactionArgs event = new BeginOperationTransactionArgs("test.confirm", null);
+        if (!"test.confirm".equals(event.getOperationKey())) throw new AssertionError("event key");
+        AbstractValidator validator = new AbstractValidator() { public void validate() {} };
+        validator.setOperateKey("test.validate");
+        if (!"test.validate".equals(validator.getOperateKey())) throw new AssertionError("validator key");
+        if ("test.confirm".equals(validator.getOperateKey())) throw new AssertionError("receiver keys mixed");
+        System.out.println("operation accessor contracts passed");
+    }
+}
+''')
+    subprocess.run(["javac", "-source", "8", "-target", "8", "-cp", OPERATION_CLASSPATH,
+                    "-d", str(tmp_path), str(source)], check=True, capture_output=True, text=True)
+    result = subprocess.run(["java", "-cp", os.pathsep.join([str(tmp_path), OPERATION_CLASSPATH]),
+                             "OperationAccessorCheck"], cwd=tmp_path, timeout=15, check=True, capture_output=True, text=True)
+    assert result.stdout.strip() == "operation accessor contracts passed"

package/skills/cosmic-build/scripts/test/test_data_model_contract.py

@@ -180,6 +180,17 @@ def test_section_singleton_row_requires_explicit_full_line() -> None:
     ]
 
 
+@pytest.mark.parametrize("row", [
+    {"fields": ["Description"], "fullLine": True},
+    {"field": "Description", "fullLine": True},
+])
+def test_ui_composition_rejects_row_level_full_line_with_nested_shape(row: dict) -> None:
+    with pytest.raises(ValueError, match=r'fullLine inside a fields\[\] item'):
+        _normalize_ui_composition_contract({
+            "sections": [{"caption": "Details", "rows": [row]}],
+        })
+
+
 def test_ui_composition_flattens_one_anonymous_tab_section() -> None:
     authored = {
         "tabs": [{
@@ -350,6 +361,17 @@ def test_dynamic_template_conflict_fails_without_rewriting_to_blank(
     assert any("DYN-CROSS-TPL" in error for error in logs.errors)
 
 
+def test_authoring_rejects_base_owned_bill_reference_before_emit():
+    data = _valid_authoring()
+    root = data["artifact"]["entities"][0]
+    root["type"] = "BaseEntity"
+    root["templateKey"] = "bos_basetpl"
+    root["fields"].append({"bizWord": "bill", "displayName": "单据", "dataType": "RefBillField",
+                           "reference": {"mode": "platform", "formNumber": "sample_bill"}})
+    issues = validate_authoring_contract(data, known_field_types={"ComboField", "TextField", "RefBillField"})
+    assert any(issue.code == "REF_BILL_OWNER_UNSUPPORTED" for issue in issues)
+
+
 def _valid_authoring() -> dict:
     return {
         "artifact": {
@@ -1685,14 +1707,17 @@ def test_direct_basedata_delegated_authoring_contract() -> None:
     ) == []
 
 
-def test_authoring_reports_stable_path_and_code() -> None:
+def test_authoring_allows_omitted_default_template_but_rejects_empty_explicit_value() -> None:
     data = _valid_authoring()
     del data["artifact"]["entities"][0]["templateKey"]
-    issues = validate_authoring_contract(data)
+    assert not any(
+        issue.path == "$.artifact.entities[0].templateKey"
+        for issue in validate_authoring_contract(data)
+    )
+    data["artifact"]["entities"][0]["templateKey"] = ""
     assert any(
-        issue.code == "DM_SCHEMA_REQUIRED"
-        and issue.path == "$.artifact.entities[0].templateKey"
-        for issue in issues
+        issue.path == "$.artifact.entities[0].templateKey"
+        for issue in validate_authoring_contract(data)
     )
 
 

package/skills/cosmic-build/scripts/test/test_delivery_stage_boundary.py

@@ -33,7 +33,7 @@ def test_execution_skills_preserve_the_terminal_menu_boundary() -> None:
     assert "Do not configure a menu or render artifact cards here" in java
 
 
-def test_plugin_delivery_uses_the_package_root_and_clean_schema_files() -> None:
+def test_plugin_delivery_uses_the_package_root() -> None:
     for relative in (
         "references/java-plugin-delivery.md",
         ".locales/zh/references/java-plugin-delivery.md",
@@ -44,14 +44,6 @@ def test_plugin_delivery_uses_the_package_root_and_clean_schema_files() -> None:
         assert "APP_BUILD_ROOT" in text
         assert "{ROOT_DIR}" not in text
 
-    for relative in (
-        "references/java-plugin-delivery.md",
-        ".locales/zh/references/java-plugin-delivery.md",
-    ):
-        text = _read(relative)
-        assert '--output "{entity.schema.json}" getFormSchema' in text
-        assert '--output "{operations.json}" listOperations' in text
-        assert "--stdout getFormSchema" not in text
 
 
 def test_chinese_delivery_reference_is_mirrored() -> None:
@@ -63,7 +55,7 @@ def test_chinese_delivery_reference_is_mirrored() -> None:
 
     assert "references/delivery.md" in root
     assert "只有所选元数据入口无法表达" in root
-    assert "每个本轮目标分别传一次" in delivery
+    assert "每个本轮可交付目标分别传一次" in delivery
     assert "最后一次写入后执行一次" in delivery
     assert "只出现在工具结果中不代表已经" in delivery
     assert "原样放进最终答复" in delivery

package/skills/cosmic-build/scripts/test/test_dym_sync_background.py

@@ -43,3 +43,14 @@ def test_worker_refuses_changed_app_identity(tmp_path):
     with mock.patch("render_output_cards.sync_existing_dym_at_session_close") as sync:
         assert run_request(pending["requestPath"])["status"] == "failed"
     sync.assert_not_called()
+
+
+def test_worker_passes_all_current_forms_to_sync(tmp_path):
+    (tmp_path / "archive.json").write_text(json.dumps({"appId": "APP"}))
+    pending = enqueue_dym_sync(str(tmp_path), ["created", "changed", "created"], {"appId": "APP"})
+    with mock.patch("render_output_cards.sync_existing_dym_at_session_close",
+                    return_value={"status": "synced", "formNumbers": ["created", "changed"]}) as sync:
+        result = run_request(pending["requestPath"])
+    assert result["status"] == "succeeded"
+    assert result["formNumbers"] == ["created", "changed"]
+    assert sync.call_args.args[1] == ["created", "changed"]

package/skills/cosmic-build/scripts/test/test_dynamic_form_metadata_only_contract.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import copy
+import json
 import runpy
 import sys
 from pathlib import Path
@@ -20,6 +21,63 @@ from field_decorator import decorate_artifact  # noqa: E402
 from dynamic_form_validator import validate_dynamic_form  # noqa: E402
 
 
+def test_dynamic_reference_targets_use_the_entity_resolver_and_preserve_field_types():
+    from cosmic_api import _resolve_dynamic_reference_fields
+    queries = []
+    def query(selector):
+        queries.append(selector)
+        return [{"formNumber": "uhyl_drug", "formName": "药品档案", "modelType": "BaseFormModel"}]
+    artifact = _artifact()
+    artifact["entities"][0]["fields"] = [
+        {"bizWord": "imm", "displayName": "疫苗/药品", "dataType": "BasedataField",
+         "reference": {"mode": "platform", "formNumber": "uhyl_drug"}},
+        {"bizWord": "drugs", "dataType": "MulBasedataField", "prdRef": "uhyl_drug"},
+    ]
+    assert _resolve_dynamic_reference_fields(artifact, isv="uhyl", query_forms=query, entity_exists=lambda _: False) is None
+    fields = artifact["entities"][0]["fields"]
+    assert [field["basedataNumber"] for field in fields] == ["uhyl_drug", "uhyl_drug"]
+    assert [field["dataType"] for field in fields] == ["BasedataField", "MulBasedataField"]
+    assert queries == ["uhyl_drug"]
+
+
+def test_unresolved_dynamic_reference_stops_before_creation_without_removing_the_field():
+    from cosmic_api import _resolve_dynamic_reference_fields
+    artifact = _artifact()
+    artifact["entities"][0]["fields"] = [{"bizWord": "imm", "dataType": "BasedataField", "prdRef": "不存在的药品"}]
+    failure = _resolve_dynamic_reference_fields(artifact, query_forms=lambda _: [], entity_exists=lambda _: False)
+    assert failure["writeAttempted"] is False
+    assert failure["errorCode"] == "DYNAMIC_REFERENCE_TARGET_UNRESOLVED"
+    assert failure["data"]["unresolvedReferences"][0]["selector"] == "不存在的药品"
+    assert artifact["entities"][0]["fields"][0]["dataType"] == "BasedataField"
+
+
+def test_retained_dynamic_creation_rejects_a_changed_artifact_before_auth_or_another_build(tmp_path, monkeypatch):
+    from unittest import mock
+    import cosmic_api
+    source = tmp_path / "page.json"
+    source.write_text(json.dumps(_artifact()), encoding="utf-8")
+    retained = {"status": False, "metadataRetained": True, "writeAttempted": True,
+                "data": {"entityResults": [{"formId": "retained-id", "formNumber": "uhyl_task_register"}]}}
+    cosmic_api._dynamic_creation_receipt(str(tmp_path), str(source), retained)
+    assert cosmic_api._dynamic_creation_receipt(str(tmp_path), str(tmp_path / "another-page.json")) is None
+    assert cosmic_api._dynamic_creation_receipt(str(tmp_path), str(source))["data"]["entityResults"][0]["formId"] == "retained-id"
+    source.write_text(json.dumps({**_artifact(), "propertySettings": []}), encoding="utf-8")
+    monkeypatch.setattr(sys, "argv", ["cosmic_api.py", "--stdout", "run", "--app-root", str(tmp_path), "--artifact", str(source)])
+    with mock.patch.object(cosmic_api, "load_config", return_value={}), \
+         mock.patch.object(cosmic_api, "_retarget_runtime_dir"), \
+         mock.patch.object(cosmic_api, "pjson") as emit, \
+         mock.patch.object(cosmic_api, "do_auth") as auth, \
+         mock.patch.object(cosmic_api, "do_build_meta") as build:
+        assert cosmic_api._main_impl() == 3
+    failure = emit.call_args.args[0]
+    assert failure["errorCode"] == "DYNAMIC_FORM_RECOVERY_REQUIRED"
+    assert failure["writeAttempted"] is False
+    assert failure["metadataRetained"] is True
+    assert failure["reconciliation"][0]["arguments"][-2:] == ["--formId", "retained-id"]
+    auth.assert_not_called()
+    build.assert_not_called()
+
+
 def _artifact() -> dict:
     return {
         "status": "REVIEW_PENDING",
@@ -150,7 +208,7 @@ def test_dynamic_explicit_form_number_over_limit_requires_user_input() -> None:
 
 def test_dynamic_explicit_form_number_at_limit_is_preserved() -> None:
     artifact = _artifact()
-    exact = "x" * 36
+    exact = "uhyl_" + "x" * 31
     artifact["entities"][0]["logicalName"] = exact
 
     for locale_root in (APP_BUILD, APP_BUILD / ".locales/zh"):