@shundoo-ai/dsh-cosmic 1.0.19 → 1.0.21

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

@@ -65,6 +65,7 @@ from naming_rules import (  # type: ignore
     MAX_FIELD_KEY_LEN,
     MAX_COLUMN_NAME_LEN,
     MAX_TABLE_NAME_LEN,
+    MAX_ENTITY_KEY_LEN,
     compute_budgets,
     trim_identifiers,
     validate_dynamic_form_number,
@@ -83,17 +84,16 @@ _standard_flag: bool | None = None
 
 def _is_standard(isv: str, standard: bool | None = None) -> bool:
     """Determine whether to use standard naming rules (no ISV prefix).
-    Prefer the explicitly passed standard parameter; otherwise read the module-level
-    _standard_flag; finally fall back to the isv=='kingdee' compatibility logic.
+
+    本地补丁 #16：命名规则强制标准模式（preset 作者 2026-08-27）——原判定整段停用。
+    上游逻辑（按参数/身份判定）保留在下方注释，便于对照与回退。
     """
-    # 原逻辑（按参数/身份判定是否标准模式）已注释，强制统一 True：
+    # 上游原逻辑（已停用）：
     # if standard is not None:
     #     return bool(standard)
     # if _standard_flag is not None:
     #     return bool(_standard_flag)
     # return isv.lower() == "kingdee" if isv else False
-
-    # 命名规则强制标准模式（无 ISV 前缀，preset 作者 2026-08-27）
     return True
 
 
@@ -187,11 +187,10 @@ def make_entity_key_map(
         biz_name = str(entity.get("bizName") or "").strip()
         if not biz_name:
             continue
-        entity_key = str(entity.get("logicalName") or "").strip() or (
-            biz_name
-            if _is_standard(isv, standard)
-            else (f"{isv}_{biz_name}" if isv else biz_name)
-        )
+        logical = str(entity.get("logicalName") or "").strip()
+        entity_key = _make_namespaced_key(logical or biz_name, isv, standard=standard)
+        if logical:
+            result[logical] = entity_key
         result[biz_name] = entity_key
         result[entity_key] = entity_key
         result[_make_entity_key(biz_name, isv)] = entity_key
@@ -236,10 +235,10 @@ def _consume_physical_name(item: dict, generated: str) -> str:
     return physical or generated
 
 
-def _consume_logical_name(item: dict, generated: str) -> str:
+def _consume_logical_name(item: dict, generated: str, isv: str = "") -> str:
     """Consume one optional exact persisted logical identifier."""
     logical = str(item.pop("logicalName", "") or "").strip()
-    return logical or generated
+    return _make_namespaced_key(logical, isv) if logical else generated
 
 
 def _make_mul_basedata_table_name(entity_key: str, column_name: str) -> str:
@@ -376,7 +375,16 @@ def _check_lengths(entities: list) -> None:
     """在自动名与精确约束汇合后校验最终落库标识。"""
     identifier = re.compile(r"^[a-z][a-z0-9_]*$")
     seen_tables: set[str] = set()
+    seen_entities: set[str] = set()
+    seen_fields: set[str] = set()
     for ent in entities:
+        entity_key = str(ent.get("entityKey") or "")
+        limit = 36 if ent.get("type") == "MainEntity" else MAX_ENTITY_KEY_LEN
+        if len(entity_key) > limit:
+            raise ValueError(f"entityKey '{entity_key}' exceeds {limit} characters including developer prefix")
+        if entity_key in seen_entities:
+            raise ValueError(f"duplicate entityKey '{entity_key}'")
+        seen_entities.add(entity_key)
         tname = ent.get("tableName", "")
         if tname and not identifier.fullmatch(tname):
             raise ValueError(f"tableName '{tname}' is not a lowercase identifier")
@@ -390,6 +398,10 @@ def _check_lengths(entities: list) -> None:
         seen_columns: set[str] = set()
         for fld in ent.get("fields", []):
             fk = fld.get("fieldKey", "")
+            if fk and fk in seen_fields:
+                raise ValueError(f"duplicate fieldKey '{fk}'")
+            if fk:
+                seen_fields.add(fk)
             cn = fld.get("columnName", "")
             if fk and len(fk) > MAX_FIELD_KEY_LEN:
                 raise ValueError(
@@ -522,6 +534,21 @@ def _replace_references(artifact: dict, mapping: dict) -> None:
                 )
             properties["FireUpdEvt"] = True
 
+    # Operation parameter reference slots carry logical keys; message text,
+    # runtime IDs and arbitrary parameter values remain untouched.
+    def map_parameter_references(value):
+        if isinstance(value, list):
+            for item in value:
+                map_parameter_references(item)
+        if isinstance(value, dict):
+            for key, item in value.items():
+                if key.casefold() in {"fieldkey", "entitykey", "entrykey", "formnumber"} and isinstance(item, str):
+                    value[key] = mapping.get(item, item)
+                else:
+                    map_parameter_references(item)
+    for operation in artifact.get("operations", []):
+        map_parameter_references(operation.get("parameter"))
+
     # propertySettings
     field_keys_by_id = {
         str(field.get("id") or ""): str(field.get("fieldKey") or "")
@@ -644,9 +671,12 @@ def decorate_artifact(raw_artifact: dict, isv: str, app_number: str,
                 f"The run command requires artifact in bizWord/bizName format, "
                 f"not fieldKey/entityKey format."
             )
+        logical_entity = str(ent.get("logicalName") or "").strip()
         entity_key = _consume_logical_name(
-            ent, _make_entity_key(biz_name, isv)
+            ent, _make_entity_key(biz_name, isv), isv
         )
+        if logical_entity:
+            mapping[logical_entity] = entity_key
         table_name = _consume_physical_name(
             ent, _make_table_name(entity_key, isv, biz_name)
         )
@@ -675,9 +705,12 @@ def decorate_artifact(raw_artifact: dict, isv: str, app_number: str,
                 )
             # Collision detection (must pass max_bw, otherwise numeric suffix would exceed the 0.2 truncation budget)
             resolved = _resolve_collision(biz_word, reserved, seen, max_len=max_bw)
+            logical_field = str(fld.get("logicalName") or "").strip()
             field_key = _consume_logical_name(
-                fld, _make_field_key(resolved, isv, app_number)
+                fld, _make_field_key(resolved, isv, app_number), isv
             )
+            if logical_field:
+                mapping[logical_field] = field_key
             column_name = _consume_physical_name(
                 fld, _make_column_name(resolved, isv)
             )

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

@@ -0,0 +1,374 @@
+import json
+import builtins
+from contextlib import contextmanager, ExitStack
+from pathlib import Path
+import subprocess
+import sys
+from unittest.mock import patch
+
+import pytest
+
+SCRIPTS = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(SCRIPTS))
+import cosmic_api
+from _core.build_receipts import BuildReceipts
+from _core import cmd_metaops
+from _core.execution_errors import attach_execution_error
+from execution_binding import execution_binding, validate_execution_binding
+
+
+@contextmanager
+def _isolated_cli():
+    from _core import config, formatters
+    with ExitStack() as stack:
+        stack.enter_context(patch.object(builtins, "print", builtins.print))
+        for owner, names in [(cosmic_api, ("_CLI_MACHINE_MODE", "_CLI_DELIVERY_ARGS", "_CLI_RESULT_EMITTED")),
+                             (formatters, ("_stdout_mode", "_output_file", "_current_cmd", "_current_arg_hash"))]:
+            for name in names:
+                stack.enter_context(patch.object(owner, name, getattr(owner, name)))
+        for owner in (config, cosmic_api):
+            for name in ("RUNTIME_DIR", "TOKEN_CACHE", "BIZ_CACHE", "CONTEXT_MD", "CONFIG_MD",
+                         "ARTIFACTS_DIR", "BATCH_MANIFESTS_DIR", "TEMP_ARTIFACT", "WORKSPACE_JSON", "_BOUND_APP_ROOT"):
+                stack.enter_context(patch.object(owner, name, getattr(owner, name, None), create=True))
+        yield
+
+
+def _artifacts(tmp_path):
+    a = tmp_path / "base.json"
+    b = tmp_path / "bill.json"
+    data = {str(a): {"entities": [{"entityKey": "vendor_base"}]},
+            str(b): {"entities": [{"entityKey": "vendor_bill", "fields": [{"refBillNumber": "vendor_base"}]}]}}
+    for source, artifact in data.items():
+        Path(source).write_text(json.dumps(artifact), encoding="utf-8")
+    return data
+
+
+def test_verified_dependency_receipt_survives_restart_and_only_pending_target_runs(tmp_path):
+    artifacts = _artifacts(tmp_path)
+    base, bill = artifacts
+    progress = BuildReceipts(tmp_path, "APP", {"baseUrl": "test"}, artifacts)
+    progress.start(base)
+    progress.finish(base, {"ok": True, "phase": "verify", "writeAttempted": True,
+                           "verification": {"status": "pass"},
+                           "result": {"data": {"entityResults": [{"formNumber": "vendor_base", "formId": "EXACT"}]}}})
+    progress.finish(bill, {"ok": False, "phase": "resolveRefBill", "writeAttempted": False})
+    resumed = BuildReceipts(tmp_path, "APP", {"baseUrl": "test"}, artifacts, resume_result=progress.result_path)
+    assert resumed.reused(base)["result"]["data"]["entityResults"][0]["formId"] == "EXACT"
+    assert resumed.reused(bill) is None
+    resumed.start(bill)
+    persisted = json.loads(resumed.result_path.read_text())
+    assert persisted["results"][1]["phase"] == "writeUnknown"
+    assert persisted["results"][1]["targetNumbers"] == ["vendor_bill"]
+
+
+def test_unknown_write_cannot_be_replayed_or_adopted(tmp_path):
+    artifacts = _artifacts(tmp_path)
+    base = next(iter(artifacts))
+    progress = BuildReceipts(tmp_path, "APP", {}, artifacts)
+    progress.start(base)
+    with pytest.raises(ValueError, match="RECONCILIATION_REQUIRED"):
+        BuildReceipts(tmp_path, "APP", {}, artifacts, resume_result=progress.result_path)
+    copied = tmp_path / "regenerated.json"
+    copied.write_text(Path(base).read_text())
+    other = BuildReceipts(tmp_path, "APP", {}, {str(copied): artifacts[base]})
+    with pytest.raises(ValueError, match="RECONCILIATION_REQUIRED"):
+        other.start(str(copied))
+
+
+def test_zero_write_failure_allows_corrected_input(tmp_path):
+    artifacts = _artifacts(tmp_path)
+    source = next(iter(artifacts))
+    progress = BuildReceipts(tmp_path, "APP", {}, artifacts)
+    progress.start(source)
+    progress.finish(source, {"ok": False, "phase": "preflight", "writeAttempted": False})
+    artifacts[source]["entities"][0]["entityKey"] = "vendor_renamed"
+    Path(source).write_text(json.dumps(artifacts[source]))
+    resumed = BuildReceipts(tmp_path, "APP", {}, artifacts, resume_result=progress.result_path)
+    resumed.start(source)
+    assert json.loads(resumed.result_path.read_text())["results"][0]["targetNumbers"] == ["vendor_renamed"]
+
+
+def test_saved_input_and_environment_changes_require_narrow_repair(tmp_path):
+    artifacts = _artifacts(tmp_path)
+    source = next(iter(artifacts))
+    progress = BuildReceipts(tmp_path, "APP", {}, artifacts)
+    progress.start(source)
+    progress.finish(source, {"ok": True, "writeAttempted": True, "verification": {"status": "pass"}})
+    with pytest.raises(ValueError, match="IDENTITY_CHANGED"):
+        BuildReceipts(tmp_path, "OTHER", {}, artifacts, resume_result=progress.result_path)
+    Path(source).write_text(Path(source).read_text() + "\n")
+    with pytest.raises(ValueError, match="SAVED_TARGET_CHANGED"):
+        BuildReceipts(tmp_path, "APP", {}, artifacts, resume_result=progress.result_path)
+
+
+def test_source_binding_rejects_old_copy_and_changed_revision(tmp_path):
+    context = tmp_path / "_runtime" / "context.json"
+    context.parent.mkdir()
+    context.write_text(json.dumps({"rootDir": str(tmp_path / "old-copy")}))
+    with pytest.raises(ValueError, match="SOURCE_MISMATCH"):
+        validate_execution_binding(tmp_path)
+    binding = execution_binding()
+    context.write_text(json.dumps({"executionBinding": {**binding, "revision": "old"}}))
+    with pytest.raises(ValueError, match="REVISION_MISMATCH"):
+        validate_execution_binding(tmp_path)
+    context.write_text(json.dumps({"executionBinding": binding}))
+    validate_execution_binding(tmp_path)
+
+
+@pytest.mark.parametrize("code,category", [
+    ("REF_BILL_TARGET_UNRESOLVED", "identity_resolution"),
+    ("RULE_FIELD_UNRESOLVED", "identity_resolution"),
+    ("CONDITIONAL_CARRY_SOURCE_PROPERTY_UNAVAILABLE", "identity_resolution"),
+    ("RULE_SET_COMMAND_UNSUPPORTED", "input"),
+    ("FULL_METADATA_API_UNAVAILABLE", "capability_limit"),
+    ("HTTP_ERROR", "environment"),
+])
+def test_reference_or_input_errors_do_not_claim_platform_limit(code, category):
+    result = attach_execution_error({"status": False, "errorCode": code, "writeAttempted": False})
+    assert result["errorCategory"] == category
+    assert result["capabilityLimitConfirmed"] == (category == "capability_limit")
+
+
+@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),
+                             "describeCommand", "runBatch"], capture_output=True, text=True)
+    assert result.returncode == 0, result.stderr
+    assert json.loads(result.stdout) == json.loads(output.read_text())
+    assert "--resume-result" in result.stdout
+    assert "argvPrefix" in result.stdout
+
+
+@pytest.mark.parametrize("lookup,code", [
+    ({"status": True, "data": [{"formNumber": "vendor_bill", "formId": "OTHER", "appId": "OTHER_APP"}]}, "TARGET_ALREADY_EXISTS"),
+    ({"status": False, "message": "connection closed"}, "TARGET_LOOKUP_UNCONFIRMED"),
+])
+def test_creation_conflict_and_network_failure_prevent_writes(lookup, code):
+    with patch("_core.cmd_forms.resolve_template_input", return_value="bos_billtpl"), \
+         patch.object(cmd_metaops, "do_query_forms", return_value=lookup), \
+         patch.object(cmd_metaops, "_api_call") as write:
+        result = cmd_metaops.do_build_meta({}, "token", {"entities": [{"entityKey": "vendor_bill"}]}, "APP", "UNIT")
+    assert result["errorCode"] == code
+    assert result["writeAttempted"] is False
+    write.assert_not_called()
+
+
+def test_real_batch_entry_resumes_only_unwritten_dependent_and_binds_saved_id(tmp_path, monkeypatch):
+    from contextlib import ExitStack
+    import copy
+    import kd_env_loader
+    from _core import formatters
+    from _core import config
+    (tmp_path / "archive.json").write_text(json.dumps({"appCode": "test", "appId": "APP", "type": "cosmic"}))
+    artifacts = {}
+    for name in ("base", "bill"):
+        source = tmp_path / (name + ".json")
+        artifact = {"templateNumber": "bos_billtpl", "entities": [{
+            "id": name, "type": "BillEntity", "entityKey": "vendor_" + name,
+            "tableName": "t_" + name, "fields": [],
+        }]}
+        if name == "bill":
+            artifact["entities"][0]["fields"] = [{"fieldKey": "vendor_ref", "columnName": "fref",
+                "displayName": "Reference", "dataType": "RefBillField", "refBillTargetNumber": "vendor_base"}]
+        source.write_text(json.dumps(artifact))
+        artifacts[str(source)] = artifact
+    base, bill = artifacts
+    prior = BuildReceipts(tmp_path, "APP", {}, artifacts, options=["--bizAppId", "APP"])
+    prior.start(base)
+    saved = {"status": True, "data": {"entityResults": [{"entityId": "base", "formId": "SAVED-EXACT-ID",
+              "formNumber": "vendor_base", "entityKey": "vendor_base", "success": True}], "successCount": 1}}
+    prior.finish(base, {"ok": True, "phase": "verify", "writeAttempted": True,
+                       "result": saved, "verification": {"status": "pass"},
+                       "summary": cosmic_api._summarize_build_meta_result(saved)})
+    prior.finish(bill, {"ok": False, "phase": "dependency", "writeAttempted": False})
+    emitted = []
+    build_inputs = []
+    modification_inputs = []
+
+    def build(cfg, token, artifact, **kwargs):
+        build_inputs.append(copy.deepcopy(artifact))
+        return {"status": True, "data": {"entityResults": [{"entityId": "bill", "formId": "NEW-BILL-ID",
+            "formNumber": "vendor_bill", "entityKey": "vendor_bill", "success": True}], "successCount": 1}}
+
+    def modify(cfg, token, **kwargs):
+        modification_inputs.append(kwargs)
+        return {"status": True, "verification": {"verified": True}}
+
+    monkeypatch.setattr(sys, "argv", [str(SCRIPTS / "cosmic_api.py"), "--stdout", "runBatch", "--app-root", str(tmp_path),
+        "--resume-result", str(prior.result_path), "--verify", "--no-sync-dym", "--artifacts", base, bill])
+    monkeypatch.setenv("PROJECT_ROOT", str(tmp_path))
+    with _isolated_cli(), ExitStack() as stack:
+        for owner, name, value in [
+            (cosmic_api, "load_config", lambda: {}),
+            (cosmic_api, "_load_workspace_for_write", lambda *a, **k: {"isv": "vendor", "appNumber": "test", "bizAppId": "APP"}),
+            (cosmic_api, "do_auth", lambda *a, **k: "test-token"),
+            (cosmic_api, "do_build_meta", build),
+            (cosmic_api, "do_modify_meta", modify),
+            (cosmic_api, "do_get_properties", lambda *a, **k: {"status": True, "data": {"billEntityId": "SAVED-EXACT-ID"}}),
+            (cosmic_api, "_verify_build_meta_readback", lambda *a: {"status": "pass"}),
+            (cosmic_api, "_append_meta_event", lambda *a, **k: None),
+            (cosmic_api, "_archive_finalize_metadata", lambda *a, **k: None),
+            (cosmic_api, "_attach_available_form_numbers", lambda c, t, r: r),
+            (cosmic_api, "pjson", emitted.append),
+            (kd_env_loader, "load_environment_identity", lambda: {}),
+        ]:
+            stack.enter_context(patch.object(owner, name, value))
+        stack.enter_context(patch.object(cosmic_api, "do_query_forms", side_effect=AssertionError("The saved identity must come from its receipt")))
+        # Isolate mutable process paths and stdout mode from subsequent tests.
+        stack.enter_context(patch.object(config, "RUNTIME_DIR", str(tmp_path / "_runtime")))
+        stack.enter_context(patch.object(config, "_BOUND_APP_ROOT", str(tmp_path), create=True))
+        stack.enter_context(patch.object(formatters, "_stdout_mode", False))
+        cosmic_api._main_impl()
+    assert len(build_inputs) == 1
+    assert build_inputs[0]["entities"][0]["entityKey"] == "vendor_bill"
+    assert len(modification_inputs) == 1
+    assert modification_inputs[0]["ops"][0]["value"]["billEntityId"] == "SAVED-EXACT-ID"
+    assert emitted[-1]["success"] == 2
+    assert emitted[-1]["results"][0]["reusedReceipt"] is True
+    assert json.loads(Path(emitted[-1]["resultPath"]).read_text())["success"] == 2
+
+
+@pytest.mark.parametrize("present", [False, True])
+def test_read_only_reconciliation_releases_only_proven_absent_target(tmp_path, monkeypatch, present):
+    from contextlib import ExitStack
+    import kd_env_loader
+    from _core.build_receipts import _atomic_json
+    artifact = {"templateNumber": "bos_billtpl", "entities": [{"id": "root", "type": "BillEntity",
+                "entityKey": "vendor_unknown", "tableName": "t_unknown", "fields": []}]}
+    source = tmp_path / "unknown.json"
+    source.write_text(json.dumps(artifact))
+    (tmp_path / "archive.json").write_text(json.dumps({"appCode": "test", "appId": "APP", "type": "cosmic"}))
+    progress = BuildReceipts(tmp_path, "APP", {}, {str(source): artifact}, options=["--bizAppId", "APP"])
+    progress.start(str(source))
+    # Simulate a completed command that received no trustworthy write response.
+    progress.receipt["executionFinished"] = True
+    _atomic_json(progress.result_path, progress.receipt)
+    emitted = []
+    monkeypatch.setattr(sys, "argv", [str(SCRIPTS / "cosmic_api.py"), "--stdout", "runBatch", "--app-root", str(tmp_path),
+        "--resume-result", str(progress.result_path), "--reconcile-only", "--verify", "--artifacts", str(source)])
+    monkeypatch.setenv("PROJECT_ROOT", str(tmp_path))
+    with _isolated_cli(), ExitStack() as stack:
+        for owner, name, value in [
+            (cosmic_api, "load_config", lambda: {}),
+            (cosmic_api, "_load_workspace_for_write", lambda *a, **k: {"isv": "vendor", "appNumber": "test", "bizAppId": "APP"}),
+            (cosmic_api, "do_auth", lambda *a, **k: "test-token"),
+            (cosmic_api, "do_query_forms", lambda *a, **k: {"status": True, "data": [{"formNumber": "vendor_unknown", "formId": "UNRELATED"}] if present else []}),
+            (cosmic_api, "_append_meta_event", lambda *a, **k: None),
+            (cosmic_api, "pjson", emitted.append),
+            (kd_env_loader, "load_environment_identity", lambda: {}),
+        ]:
+            stack.enter_context(patch.object(owner, name, value))
+        build = stack.enter_context(patch.object(cosmic_api, "do_build_meta"))
+        with pytest.raises(SystemExit):
+            cosmic_api._main_impl()
+        build.assert_not_called()
+    result = emitted[-1]
+    assert result["resume"]["ready"] is (not present)
+    assert result["results"][0]["phase"] == ("writeUnknown" if present else "reconciledAbsent")
+    if not present:
+        assert result["results"][0]["writeAttempted"] is False
+        resumed = BuildReceipts(tmp_path, "APP", {}, {str(source): artifact},
+                                options=["--bizAppId", "APP"], resume_result=result["resultPath"])
+        resumed.start(str(source))
+    else:
+        assert result["results"][0].get("ok") is False
+        assert not result.get("forms")
+
+
+def test_reconciliation_refuses_an_active_original_process(tmp_path):
+    artifacts = _artifacts(tmp_path)
+    progress = BuildReceipts(tmp_path, "APP", {}, artifacts)
+    progress.start(next(iter(artifacts)))
+    with pytest.raises(ValueError, match="still active"):
+        BuildReceipts(tmp_path, "APP", {}, artifacts, resume_result=progress.result_path, reconcile_only=True)
+
+
+def test_bootstrap_machine_failure_stays_parseable(tmp_path):
+    result = subprocess.run([sys.executable, str(SCRIPTS.parents[2] / "scripts" / "bootstrap_cosmic_context.py"),
+                             "--stdout", "--project-root", str(tmp_path)], capture_output=True, text=True)
+    assert result.returncode != 0
+    assert json.loads(result.stdout)["status"] is False
+    assert "executionBinding" in result.stdout
+
+
+def test_serve_keeps_protocol_stdout_when_diagnostics_are_routed(capsys):
+    import io
+    with _isolated_cli(), patch.object(cosmic_api, "do_auth", return_value="test-token"), \
+         patch.object(sys, "stdin", io.StringIO('{"cmd":"ping"}\n{"cmd":"exit"}\n')):
+        cosmic_api._route_unstructured_prints_to_stderr()
+        cosmic_api._serve_loop({})
+    lines = capsys.readouterr().out.splitlines()
+    assert lines[0] == "###SERVE_READY###"
+    assert json.loads(lines[1]) == {"success": True, "data": "pong"}
+
+
+def test_root_identity_is_persisted_before_independent_readback(tmp_path):
+    artifacts = _artifacts(tmp_path)
+    source = next(iter(artifacts))
+    progress = BuildReceipts(tmp_path, "APP", {}, artifacts)
+    progress.start(source)
+    response = {"status": True, "data": {"entityResults": [{"entityKey": "vendor_base",
+                "formId": "SAVED-BEFORE-READ", "success": True}]}}
+    with patch("_core.cmd_forms.resolve_template_input", return_value="bos_billtpl"), \
+         patch.object(cmd_metaops, "do_query_forms", return_value={"status": True, "data": []}), \
+         patch.object(cmd_metaops, "_api_call", return_value=response), \
+         patch("_core.cmd_forms.do_get_form_schema", side_effect=RuntimeError("read interrupted")):
+        result = cmd_metaops.do_build_meta({}, "token", artifacts[source], "APP", "UNIT",
+            on_write_result=lambda received: progress.finish(source, {
+                "ok": False, "phase": "rootReceipt", "writeAttempted": True, "result": received}))
+    persisted = json.loads(progress.result_path.read_text())
+    assert persisted["results"][0]["result"]["data"]["entityResults"][0]["formId"] == "SAVED-BEFORE-READ"
+    assert result["status"] is False
+    assert persisted["resume"]["ready"] is False
+
+
+@pytest.mark.parametrize("reader", ["_core.cmd_forms.resolve_template_input", "_core.cmd_metaops.do_query_forms"])
+def test_precreate_read_exception_is_confirmed_unwritten(reader):
+    with patch("_core.cmd_forms.resolve_template_input", return_value="bos_billtpl"), \
+         patch("_core.cmd_metaops.do_query_forms", return_value={"status": True, "data": []}), \
+         patch(reader, side_effect=ConnectionResetError("injected pre-write network failure")), \
+         patch.object(cmd_metaops, "_api_call") as write:
+        result = cmd_metaops.do_build_meta({}, "token", {"entities": [{"entityKey": "vendor_probe"}]}, "APP", "UNIT")
+    assert result["writeAttempted"] is False
+    assert attach_execution_error(result)["errorCategory"] == "environment"
+    write.assert_not_called()
+
+
+def test_verified_receipt_clears_intermediate_error_category(tmp_path):
+    artifacts = _artifacts(tmp_path)
+    source = next(iter(artifacts))
+    progress = BuildReceipts(tmp_path, "APP", {}, artifacts)
+    progress.start(source)
+    progress.finish(source, {"ok": False, "phase": "rootReceipt", "writeAttempted": True})
+    final = progress.finish(source, {"ok": True, "phase": "verify", "verification": {"status": "pass"}})
+    assert "errorCategory" not in final
+    assert "capabilityLimitConfirmed" not in final
+
+
+@pytest.mark.parametrize("attempts,expected", [([False], False), ([True, False], True), ([None, False], None)])
+def test_batch_summary_preserves_actual_write_boundary(attempts, expected):
+    result = cosmic_api._summarize_run_batch({"failed": len(attempts), "success": 0, "results": [
+        {"ok": False, "writeAttempted": value, "summary": {"ok": False, "targetConflicts": [
+            {"formNumber": "vendor_existing"}], "writeAttempted": value}}
+        for value in attempts
+    ]})
+    assert result["writeAttempted"] is expected
+
+
+def test_execution_revision_includes_root_payload_schemas(tmp_path):
+    import execution_binding as binding_module
+    (tmp_path / "scripts").mkdir()
+    (tmp_path / "schemas").mkdir()
+    (tmp_path / "SKILL.md").write_text("fixture")
+    schema = tmp_path / "schemas" / "payload.json"
+    schema.write_text('{"required":["first"]}')
+    binding_module.execution_binding.cache_clear()
+    try:
+        with patch.object(binding_module, "__file__", str(tmp_path / "scripts" / "execution_binding.py")):
+            first = binding_module.execution_binding()["revision"]
+            schema.write_text('{"required":["second"]}')
+            binding_module.execution_binding.cache_clear()
+            assert binding_module.execution_binding()["revision"] != first
+    finally:
+        binding_module.execution_binding.cache_clear()

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

@@ -25,6 +25,30 @@ from _core import number_validator  # noqa: E402
 from _core import cmd_rules  # noqa: E402
 
 
+def test_combo_read_failure_preserves_cause_and_does_not_claim_options_absent():
+    from _core import cmd_fields
+    failure = {"status": False, "errorCode": "406",
+               "message": "kd.bos.designer.build.FullMetadataApiService not find"}
+    with mock.patch.object(cmd_fields, "_api_call", return_value=failure):
+        result = cmd_fields._combo_verify_after_modify(
+            {}, "token", "uhyl_dish", "uhyl_dish_status",
+            [{"label": "供应中", "value": "available"}], None,
+        )
+    assert result["status"] == "readback_failed"
+    assert result["cause"] == failure
+    assert "FullMetadataApiService not find" in result["message"]
+    assert "absent" not in result["message"]
+
+
+def test_combo_remove_read_failure_cannot_report_success():
+    from _core import cmd_fields
+    with mock.patch.object(cmd_fields, "_api_call", return_value={"status": False}):
+        result = cmd_fields._combo_verify_after_modify(
+            {}, "token", "uhyl_dish", "uhyl_dish_status", [], "sold_out",
+        )
+    assert result["status"] == "readback_failed"
+
+
 @pytest.mark.parametrize("readback", [
     {"status": False, "message": "read unavailable"},
     {"status": True, "data": {"Items": [{"_Type_": "BizRule", "Id": "r", "PreCondition": "amount > 200"}]}},

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

@@ -30,7 +30,9 @@ def test_build_uses_observed_identity_and_schema_aware_trigger_writer():
                 "propertySettings": [{"elementKey": "field", "settingType": "simple", "properties": {"FireUpdEvt": True}}]}
     original = copy.deepcopy(artifact)
     result = {"status": True, "data": {"entityResults": [{"entityId": "e1", "entityKey": "vendor_Mixed", "formId": "id", "success": True}]}}
-    with patch("_core.cmd_metaops._api_call", return_value=result) as build, patch(
+    with patch("_core.cmd_forms.resolve_template_input", return_value="bos_billtpl"), patch(
+        "_core.cmd_metaops.do_query_forms", return_value={"status": True, "data": []},
+    ), patch("_core.cmd_metaops._api_call", return_value=result) as build, patch(
         "_core.cmd_forms.do_get_form_schema", return_value={"status": True, "data": {"formNumber": "vendor_mixed"}},
     ), patch("_core.cmd_properties.do_set_properties_verified", return_value={"status": True, "verification": {"verified": True}}) as setter:
         actual = do_build_meta({}, "token", artifact, "app", "unit")
@@ -42,7 +44,7 @@ def test_build_uses_observed_identity_and_schema_aware_trigger_writer():
 
 def test_partial_build_exposes_observed_fields_and_does_not_write_more():
     result = {"status": True, "data": {"entityResults": [{"formId": "id", "success": False}]}}
-    with patch("_core.cmd_metaops._api_call", return_value=result), patch(
+    with patch("_core.cmd_forms.resolve_template_input", return_value="bos_billtpl"), patch("_core.cmd_metaops._api_call", return_value=result), patch(
         "_core.cmd_forms.do_get_form_schema", return_value={"status": True, "data": {"formNumber": "existing", "entities": [{"fields": [{"fieldKey": "field"}]}]}},
     ), patch("_core.cmd_properties.do_set_properties_verified") as setter:
         actual = do_build_meta({}, "token", {"entities": []}, "app", "unit")