@shundoo-ai/dsh-cosmic 1.0.21 → 1.0.22

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

@@ -1,65 +1,274 @@
+"""Typed report filter editors, against the platform's typed report filter API.
+
+The API ships as a platform patch and this skill ships with the client, so every test here is
+one of three platforms: one with the patch (it answers with a per-filter receipt), one without
+it (it accepts the request, ignores the editor part and renders the legacy control), and one
+with an older patch (it refuses an editor type it does not offer, before saving anything).
+"""
 import sys
 from pathlib import Path
+
 import pytest
 
 sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
 from _core import report_ops
 
 
-def request():
-    return report_ops.normalize_report_filters_input([{
-        "fieldPath": "flt_supplier", "displayName": "Supplier", "compare": "in",
-        "source": {"formNumber": "purchase", "fieldKey": "supplier"},
-    }])
+def _filters(*items):
+    return report_ops.normalize_report_filters_input(list(items))
 
 
-def test_source_is_typed_input_and_not_an_arbitrary_field_selector():
-    item = request()[0]
-    assert report_ops._build_filters_payload([item])[0]["source"] == item["source"]
-    with pytest.raises(ValueError):
-        report_ops.normalize_report_filters_input([{**item, "source": {"formNumber": "purchase", "fieldType": "TextField"}}])
+SUPPLIER = {"fieldPath": "flt_supplier", "displayName": "Supplier", "compare": "in",
+            "fieldType": "MulBasedataField", "basedataNumber": "bd_supplier"}
+PERIOD = {"fieldPath": "flt_period", "displayName": "Period", "compare": "between",
+          "fieldType": "DateField"}
+STATUS = {"fieldPath": "flt_status", "displayName": "Status", "compare": "=",
+          "fieldType": "combo", "comboItems": [{"value": 0, "caption": "Draft"},
+                                               {"value": "01", "caption": "Audited"}]}
 
 
-def test_legacy_platform_rejected_before_write_and_never_falls_back(monkeypatch):
-    writes = []
-    monkeypatch.setattr(report_ops, "_get_schema", lambda *args: {"data": {"schemaText": "legacy"}})
-    monkeypatch.setattr(report_ops, "_set_complex", lambda *args: writes.append(args))
-    with pytest.raises(RuntimeError, match="PLATFORM_UNSUPPORTED"):
-        report_ops.set_report_filters({}, "token", "report", request(), form_number="report")
-    assert writes == []
+def _receipt(*rows):
+    return {"errorCode": "0", "status": True, "data": {
+        "success": True, "errorCode": "0",
+        "data": {"filters": [{"fieldPath": key, "fieldType": field_type, "fieldId": "ID",
+                              "action": "created"} for key, field_type in rows],
+                 "removed": []}}}
 
 
-def test_typed_source_uses_dedicated_route(monkeypatch):
+def _write(monkeypatch, responses, filters):
     calls = []
-    monkeypatch.setattr(report_ops, "_get_schema", lambda *args: {"data": {"fieldSchemas": [
-        {"fieldPath": "supplier", "fieldType": "BasedataField", "referenceEntityId": "bd_supplier"}]}})
-    monkeypatch.setattr(report_ops, "_assert_report_entity_writable", lambda *args, **kwargs: None)
-    monkeypatch.setattr(report_ops, "_set_complex", lambda *args: calls.append(args) or {"success": True})
-    report_ops.set_report_filters({}, "token", "report", request(), form_number="report")
-    assert calls[0][3] == "ReportFilters.typed"
-
-
-def test_readback_compares_fresh_source_reference_and_enum_configuration(monkeypatch):
-    source = {"fieldPath": "supplier", "fieldType": "BasedataField", "referenceEntityId": "bd_supplier", "displayProp": "name"}
-    monkeypatch.setattr(report_ops, "_get_schema", lambda *args: {"data": {"fieldSchemas": [source]}})
-    schema = {"readBackAvailable": True, "readBackSource": "formLayout", "typedFiltersReadBack": True,
-        "undecidableFilterProperties": ["compare", "defaultValue", "visible"],
-        "filterSourceExpectations": report_ops.report_filter_source_expectations({}, "token", request()),
-        "reportFilters": [{**source, "fieldPath": "flt_supplier", "displayName": "Supplier"}]}
-    assert report_ops.report_readback_verification("filters", request(), schema)["verified"]
-    schema["reportFilters"][0]["referenceEntityId"] = "wrong-reference"
-    assert not report_ops.report_readback_verification("filters", request(), schema)["verified"]
-    schema["reportFilters"][0]["referenceEntityId"] = "bd_supplier"
-    del schema["typedFiltersReadBack"]
-    assert not report_ops.report_readback_verification("filters", request(), schema)["verified"]
-
-
-def test_date_range_and_ambiguous_source_fail_closed(monkeypatch):
-    items = [{"fieldPath": "flt_date", "compare": "between", "source": {"formNumber": "purchase", "fieldKey": "date"}}]
-    monkeypatch.setattr(report_ops, "_get_schema", lambda *args: {"data": {"fieldSchemas": [
-        {"fieldPath": "date", "fieldType": "DateField", "timeZoneTransType": 0}]}})
-    assert report_ops.report_filter_source_expectations({}, "token", items)["flt_date"]["fieldType"] == "DateRangeField"
-    monkeypatch.setattr(report_ops, "_get_schema", lambda *args: {"data": {"fieldSchemas": [
-        {"fieldPath": "date", "fieldType": "TextField"}]}})
-    with pytest.raises(ValueError, match="RANGE_TYPE_UNSUPPORTED"):
-        report_ops.report_filter_source_expectations({}, "token", items)
+
+    def set_complex(*args):
+        calls.append(args)
+        return responses[min(len(calls), len(responses)) - 1]
+
+    monkeypatch.setattr(report_ops, "_assert_report_entity_writable", lambda *a, **k: None)
+    monkeypatch.setattr(report_ops, "_set_complex", set_complex)
+    outcome = {}
+    ids = report_ops.set_report_filters({}, "token", "FID", filters, form_number="kdtest_rpt",
+                                        outcome=outcome)
+    return ids, outcome, calls
+
+
+# ── input contract: the patch's own rules, enforced before the write ──────────────────────
+
+def test_aliases_normalize_and_a_single_date_editor_becomes_a_range_for_between():
+    supplier, period, status = _filters(
+        {**SUPPLIER, "fieldType": "mulbasedata"}, PERIOD, STATUS)
+    assert supplier["fieldType"] == "MulBasedataField"
+    assert period["fieldType"] == "DateRangeField"
+    assert status["fieldType"] == "ComboField"
+    # Stored dropdown values are kept exactly: 0 and leading zeros are values.
+    assert [row["value"] for row in status["comboItems"]] == ["0", "01"]
+
+
+@pytest.mark.parametrize("item, message", [
+    ({**SUPPLIER, "basedataNumber": None}, "basedataNumber is required"),
+    ({**SUPPLIER, "compare": "between"}, "needs a range editor"),
+    ({"fieldPath": "flt_d", "displayName": "D", "compare": "=", "fieldType": "DateRangeField"},
+     "needs compare=between"),
+    ({"fieldPath": "flt_o", "displayName": "O", "compare": "=", "fieldType": "OrgField",
+      "basedataNumber": "bos_org"}, "does not apply to fieldType OrgField"),
+    ({"fieldPath": "flt_s", "displayName": "S", "compare": "=",
+      "comboItems": [{"value": "A", "caption": "A"}]}, "needs fieldType"),
+    ({**SUPPLIER, "fieldType": "AmountField"}, "not a report filter editor type"),
+    ({"fieldPath": "flt_u", "displayName": "U", "compare": "=", "fieldType": "UserField",
+      "defaultValue": "1"}, "defaultValue is not supported on UserField"),
+    ({**STATUS, "comboItems": [{"value": "A", "caption": "A"}, {"value": "A", "caption": "B"}]},
+     "duplicate"),
+    ({**SUPPLIER, "mustInput": True, "visible": False}, "mustInput and visible:false"),
+    ({"fieldPath": "flt_a", "displayName": "A", "compare": "=", "fieldType": "AssistantField",
+      "asstTypeId": "group-a"}, "numeric id"),
+])
+def test_editor_rules_fail_before_any_write(item, message):
+    with pytest.raises(ValueError, match=message):
+        _filters({k: v for k, v in item.items() if v is not None})
+
+
+def test_the_retired_source_and_a_raw_id_are_refused_with_the_replacement():
+    with pytest.raises(ValueError, match="source is retired: declare fieldType"):
+        _filters({"fieldPath": "flt_supplier", "displayName": "S", "compare": "in",
+                  "source": {"formNumber": "pm_purorderbill", "fieldKey": "supplier"}})
+    with pytest.raises(ValueError, match="pass basedataNumber"):
+        _filters({**SUPPLIER, "baseEntityId": "1234567890"})
+
+
+def test_an_item_class_editor_names_its_type_filter_in_the_same_request():
+    kind = {"fieldPath": "flt_kind", "displayName": "Kind", "compare": "=",
+            "fieldType": "ItemClassTypeField",
+            "itemClassTypes": [{"basedataNumber": "bd_customer"}, {"basedataNumber": "bd_supplier"}]}
+    party = {"fieldPath": "flt_party", "displayName": "Party", "compare": "=",
+             "fieldType": "ItemClassField", "typeFieldKey": "flt_kind"}
+    assert _filters(kind, party)[1]["typeFieldKey"] == "flt_kind"
+    with pytest.raises(ValueError, match="must name an ItemClassTypeField filter"):
+        _filters(party)
+
+
+def test_the_editor_part_travels_only_with_its_field_type():
+    payload = report_ops._build_filters_payload(_filters(SUPPLIER, PERIOD))
+    assert payload[0] == {"fieldPath": "flt_supplier", "displayName": "Supplier", "compare": "9",
+                          "fieldType": "MulBasedataField", "basedataNumber": "bd_supplier"}
+    assert payload[1]["fieldType"] == "DateRangeField" and payload[1]["compare"] == "13"
+    plain = report_ops._build_filters_payload(_filters(
+        {"fieldPath": "flt_text", "displayName": "T", "compare": "="}))[0]
+    assert "fieldType" not in plain
+
+
+def test_dry_run_names_each_typed_editor_and_its_legacy_fallback():
+    result = report_ops.set_report_filters({}, None, "FID", _filters(SUPPLIER, PERIOD), dry_run=True)
+    assert result["typedFilterEditors"] == [
+        {"fieldPath": "flt_supplier", "fieldType": "MulBasedataField", "legacyFieldType": "TextField"},
+        {"fieldPath": "flt_period", "fieldType": "DateRangeField", "legacyFieldType": "DateRangeField"},
+    ]
+
+
+# ── the write against each kind of platform ───────────────────────────────────────────────
+
+def test_a_patched_platform_proves_every_editor_with_its_receipt(monkeypatch):
+    ids, outcome, calls = _write(monkeypatch, [_receipt(
+        ("flt_supplier", "MulBasedataField"), ("flt_period", "DateRangeField"))],
+        _filters(SUPPLIER, PERIOD))
+    assert ids == ["flt_supplier", "flt_period"]
+    assert len(calls) == 1 and calls[0][3] == "ReportFilters"
+    assert outcome["platformReceipt"] is True
+    assert outcome["typedFilterSupport"] == "available"
+    assert [row["status"] for row in outcome["editors"]] == ["typed", "typed"]
+
+
+def test_an_unpatched_platform_is_not_a_failed_write(monkeypatch):
+    """No receipt: the platform ignored fieldType. The write stands; the read-back decides."""
+    ids, outcome, calls = _write(monkeypatch, [{"errorCode": "0", "status": True,
+                                                "data": {"success": True}}],
+                                 _filters(SUPPLIER, PERIOD))
+    assert len(calls) == 1
+    assert outcome["platformReceipt"] is False
+    assert outcome["typedFilterSupport"] == "unconfirmed"
+    resolved, mismatches = report_ops.resolve_filter_editors(outcome, [
+        {"fieldPath": "flt_supplier", "fieldType": "TextField"},
+        {"fieldPath": "flt_period", "fieldType": "DateRangeField"}])
+    assert mismatches == []
+    assert [row["status"] for row in resolved["editors"]] == ["degraded", "typed"]
+    assert resolved["typedFilterSupport"] == "partial"
+    assert resolved["degradedFilters"] == ["flt_supplier"]
+
+
+def test_an_older_patch_refusing_an_editor_type_gets_that_filter_resent_without_it(monkeypatch):
+    refused = {"errorCode": "META_SAVE_FAIL", "status": False, "message": (
+        "过滤字段 flt_supplier 的 fieldType 不支持: MulBasedataField。可选值: TextField, "
+        "DateField, DateRangeField, ComboField, BasedataField。")}
+    ids, outcome, calls = _write(monkeypatch, [refused, _receipt(
+        ("flt_supplier", "TextField"), ("flt_period", "DateRangeField"))],
+        _filters(SUPPLIER, PERIOD))
+    assert len(calls) == 2
+    first, second = calls[0][4]["filters"], calls[1][4]["filters"]
+    assert first[0]["fieldType"] == "MulBasedataField"
+    assert "fieldType" not in second[0] and "basedataNumber" not in second[0]
+    assert second[1]["fieldType"] == "DateRangeField"
+    assert outcome["typedFilterSupport"] == "partial"
+    assert outcome["platformFieldTypes"] == [
+        "BasedataField", "ComboField", "DateField", "DateRangeField", "TextField"]
+    assert outcome["editors"][0]["status"] == "degraded"
+    assert "does not offer MulBasedataField" in outcome["editors"][0]["reason"]
+
+
+def test_any_other_refusal_fails_the_write_without_a_retry(monkeypatch):
+    refused = {"errorCode": "META_SAVE_FAIL", "status": False,
+               "message": "过滤字段 flt_supplier：基础资料实体不存在: bd_nothing。"}
+    with pytest.raises(RuntimeError, match="setReportFilters failed"):
+        _write(monkeypatch, [refused], _filters({**SUPPLIER, "basedataNumber": "bd_nothing"}))
+
+
+def test_a_receipt_showing_neither_editor_is_a_mismatch(monkeypatch):
+    _ids, outcome, _calls = _write(monkeypatch, [_receipt(
+        ("flt_supplier", "ComboField"), ("flt_period", "DateRangeField"))],
+        _filters(SUPPLIER, PERIOD))
+    assert outcome["typedFilterSupport"] == "mismatch"
+    _resolved, mismatches = report_ops.resolve_filter_editors(outcome, [])
+    assert mismatches and mismatches[0]["actual"] == "ComboField"
+
+
+# ── read-back ─────────────────────────────────────────────────────────────────────────────
+
+def _derived_schema(rows, outcome=None):
+    schema = {"readBackAvailable": True, "readBackSource": "formLayout",
+              "undecidableFilterProperties": ["compare", "mustInput", "visible", "defaultValue"],
+              "reportFilters": rows}
+    if outcome:
+        schema["filterEditorOutcome"] = outcome
+    return schema
+
+
+def test_read_back_holds_a_typed_editor_to_what_the_receipt_claimed():
+    filters = _filters(SUPPLIER)
+    outcome = report_ops.build_filter_editor_outcome(
+        filters, {"filters": [{"fieldPath": "flt_supplier", "fieldType": "MulBasedataField"}]})
+    row = {"fieldPath": "flt_supplier", "displayName": "Supplier", "controlType": "FieldAp"}
+    proven = report_ops.report_readback_verification(
+        "filters", filters, _derived_schema([{**row, "fieldType": "MulBasedataField"}], outcome))
+    assert proven["verified"], proven["mismatches"]
+    assert proven["filterEditors"]["typedFilterSupport"] == "available"
+    wrong = report_ops.report_readback_verification(
+        "filters", filters, _derived_schema([{**row, "fieldType": "TextField"}], outcome))
+    assert not wrong["verified"]
+
+
+def test_read_back_without_a_write_outcome_still_tells_degraded_from_wrong():
+    filters = _filters(SUPPLIER)
+    row = {"fieldPath": "flt_supplier", "displayName": "Supplier", "controlType": "FieldAp"}
+    degraded = report_ops.report_readback_verification(
+        "filters", filters, _derived_schema([{**row, "fieldType": "TextField"}]))
+    assert degraded["verified"]
+    assert degraded["filterEditors"]["typedFilterSupport"] == "unavailable"
+    unseen = report_ops.report_readback_verification("filters", filters, _derived_schema([row]))
+    assert unseen["verified"] and "fieldType" in unseen["unverifiableRequestedProperties"]
+    wrong = report_ops.report_readback_verification(
+        "filters", filters, _derived_schema([{**row, "fieldType": "ComboField"}]))
+    assert not wrong["verified"]
+
+
+def test_a_basedata_editor_is_held_to_its_base_data():
+    filters = _filters({**SUPPLIER, "fieldType": "BasedataField", "compare": "="})
+    row = {"fieldPath": "flt_supplier", "displayName": "Supplier", "controlType": "FieldAp",
+           "fieldType": "BasedataField"}
+    assert report_ops.report_readback_verification(
+        "filters", filters, _derived_schema([{**row, "referenceNumber": "bd_supplier"}]))["verified"]
+    assert not report_ops.report_readback_verification(
+        "filters", filters, _derived_schema([{**row, "referenceNumber": "bd_customer"}]))["verified"]
+
+
+# ── plugin contract ───────────────────────────────────────────────────────────────────────
+
+def test_the_plugin_contract_names_both_editors_and_what_this_report_rendered():
+    filters = _filters(SUPPLIER, PERIOD, STATUS)
+    editors, _ = report_ops.resolve_filter_editors(
+        report_ops.build_filter_editor_outcome(filters), [
+            {"fieldPath": "flt_supplier", "fieldType": "TextField"},
+            {"fieldPath": "flt_period", "fieldType": "DateRangeField"},
+            {"fieldPath": "flt_status", "fieldType": "ComboField"}])
+    contract = report_ops.compile_report_plugin_contract(
+        {"reportFilters": filters}, "kdtest_rpt", filter_editors=editors)
+    supplier, period, status = contract["filterValueContracts"]
+    assert supplier["editorFieldType"] == "MulBasedataField"
+    assert supplier["valueAccessor"] == 'ReportQueryParam.getFilter().getDynamicObjectCollection("flt_supplier")'
+    assert supplier["legacyEditor"]["fieldType"] == "TextField"
+    assert supplier["legacyEditor"]["valueAccessor"] == 'ReportQueryParam.getFilter().getString("flt_supplier")'
+    assert supplier["editorStatus"] == "degraded" and supplier["renderedFieldType"] == "TextField"
+    assert supplier["basedataNumber"] == "bd_supplier" and supplier["multiValue"] is True
+    assert period["rangeItemKeys"] == {"start": "flt_period_startdate", "end": "flt_period_enddate"}
+    assert "legacyEditor" not in period
+    assert status["comboValues"] == ["0", "01"] and status["valueEvidence"] == "measured"
+    assert contract["filterEditorSupport"] == "partial"
+
+
+def test_a_time_range_editor_reads_its_own_item_keys():
+    contract = report_ops.compile_report_plugin_contract({"reportFilters": _filters(
+        {"fieldPath": "flt_shift", "displayName": "Shift", "compare": "between",
+         "fieldType": "TimeField"},
+        {"fieldPath": "flt_stay", "displayName": "Stay", "compare": "between",
+         "fieldType": "DateRangeField", "startDateFieldKey": "stay_from", "endDateFieldKey": "stay_to"},
+    )}, "kdtest_rpt")
+    shift, stay = contract["filterValueContracts"]
+    assert shift["editorFieldType"] == "TimeRangeField"
+    assert shift["rangeItemKeys"] == {"start": "flt_shift_starttime", "end": "flt_shift_endtime"}
+    assert shift["legacyEditor"]["fieldType"] == "DateRangeField"
+    assert stay["rangeItemKeys"] == {"start": "stay_from", "end": "stay_to"}

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

@@ -0,0 +1,29 @@
+from pathlib import Path
+import sys
+from unittest.mock import patch
+
+SCRIPTS = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(SCRIPTS))
+from _core import cmd_rules
+
+
+def test_copy_rule_reuses_field_inventory_only_within_each_write():
+    rows = {
+        "entity": [{"key": "demo", "name": "主实体", "id": "E", "type": "BillEntity"}],
+        "field": [
+            {"key": "billno", "name": "单据编号", "parentKey": "demo", "type": "TextField", "category": "field"},
+            {"key": "workno", "name": "工单编号", "parentKey": "demo", "type": "TextField", "category": "field"},
+        ],
+    }
+    with (patch.object(cmd_rules, "do_list_elements", side_effect=lambda *a, **kw: {"status": True, "data": rows[kw["category"]]}) as list_elements,
+          patch.object(cmd_rules, "do_load_full_metadata", return_value={"status": True, "data": {"entitymeta": {"Items": []}}}),
+          patch.object(cmd_rules, "_ensure_rule_trigger_events", return_value=[]),
+          patch.object(cmd_rules, "do_add_rule", return_value={"status": True, "data": {"ruleId": "rule"}}) as write,
+          patch.object(cmd_rules, "_attach_rule_readback", side_effect=lambda cfg, token, form, rule, result: {**result, "verification": {"verified": True}})):
+        for _ in range(2):
+            result = cmd_rules.do_ensure_conditional_copy_field_value(
+                {}, "token", "demo", "主实体", "单据编号", "not-empty", None, "单据编号", "工单编号")
+            assert result["verification"]["verified"]
+        assert write.call_count == 2
+        assert [call.kwargs["category"] for call in list_elements.call_args_list] == ["entity", "field", "entity", "field"]
+        assert cmd_rules._RULE_BATCH_INVENTORY.get() is None

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

@@ -2452,6 +2452,26 @@ class RuleWriteClosureTest(unittest.TestCase):
         self.assertFalse(repeated["writeAttempted"])
         add_verified.assert_not_called()
 
+    @patch.object(cmd_rules, "do_add_rule_verified")
+    @patch.object(cmd_rules, "do_load_full_metadata")
+    @patch.object(cmd_rules, "do_list_elements")
+    def test_document_number_not_empty_copies_to_work_order(self, list_elements, load_full, add_verified):
+        list_elements.side_effect = lambda *args, **kwargs: {"status": True, "data": (
+            [{"key": "demo", "name": "主实体", "id": "entity-id", "type": "BillEntity"}]
+            if kwargs["category"] == "entity" else [
+                {"key": "billno", "name": "单据编号", "parentKey": "demo", "type": "TextField", "category": "field"},
+                {"key": "work_no", "name": "工单编号", "parentKey": "demo", "type": "TextField", "category": "field"},
+            ])}
+        load_full.return_value = {"status": True, "data": {"entitymeta": {"Items": []}}}
+        add_verified.return_value = {"status": True, "data": {"ruleId": "copy"}, "verification": {"verified": True}}
+        result = cmd_rules.do_ensure_conditional_copy_field_value(
+            {}, "token", "demo", "主实体", "单据编号", "not-empty", None, "单据编号", "工单编号")
+        requested = add_verified.call_args.args[3]
+        self.assertEqual("(billno <> null and billno <> '')", requested["preCondition"])
+        self.assertEqual("单据编号 not-empty 时把单据编号复制到工单编号", requested["preDescription"])
+        self.assertEqual([{"TargetField": "work_no", "SrcField": "billno"}], requested["trueActions"][0]["expression"])
+        self.assertTrue(result["verification"]["verified"])
+
     @patch.object(cmd_rules, "do_add_rule_verified")
     @patch.object(cmd_rules, "do_load_full_metadata")
     @patch.object(cmd_rules, "do_get_properties")

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

@@ -40,6 +40,24 @@ def test_unknown_root_does_not_fabricate_a_retained_identity(tmp_path):
     assert actual == {"ok": False}
 
 
+def test_known_configuration_difference_reuses_readback_and_unknowns_still_reconcile(tmp_path):
+    payload = {"data": {"entityResults": [{"formId": "SAVED", "formNumber": "example"}]}}
+    issue = {"type": "combo_options_equal", "target": "mode", "status": "fail",
+             "expected": [{"label": "Ready", "value": "ready"}], "actual": [{"label": "Ready", "value": "generated"}]}
+    summary = cosmic_api._attach_post_build_phase_failure({}, payload, phase="verify", app_root=str(tmp_path),
+        artifact_path=str(tmp_path / "artifact.json"), verification={"summary": {"failed": 1, "errors": 0}, "issues": [issue]})
+    assert summary["reconciliation"] == []
+    assert summary["repairPlans"][0]["observedIssues"] == [issue]
+    assert summary["doNotRetryBuildMeta"] is True
+    assert summary["retryable"] is False
+    unknown = cosmic_api._attach_post_build_phase_failure({}, payload, phase="verify", app_root=str(tmp_path),
+        artifact_path=str(tmp_path / "artifact.json"), verification={"issues": [{**issue, "status": "error", "actual": None}]})
+    assert unknown["reconciliation"][0]["command"] == "getFormSchema"
+    truncated = cosmic_api._attach_post_build_phase_failure({}, payload, phase="verify", app_root=str(tmp_path),
+        artifact_path=str(tmp_path / "artifact.json"), verification={"summary": {"failed": 1, "errors": 1}, "issues": [issue]})
+    assert truncated["reconciliation"][0]["command"] == "getFormSchema"
+
+
 def test_batch_keeps_post_failure_separate_from_verified_and_unwritten_targets(tmp_path):
     saved = {"ok": True, "formNumbers": [{"number": "uhyl_check_in"}]}
     cosmic_api._attach_post_build_phase_failure(

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

@@ -31,6 +31,27 @@ def test_compact_verified_targets_exposes_only_successful_exact_assertions():
     ]
 
 
+def test_verified_property_receipt_names_the_property_and_readback():
+    report = SimpleNamespace(results=[SimpleNamespace(status="pass", actual=False,
+        spec=SimpleNamespace(type="property_equals", target="field", expected=False,
+                             metadata={"property": "MustInput"}))])
+    assert cosmic_api._compact_verified_targets(report) == [{"type": "property_equals", "target": "field",
+        "property": "MustInput", "expected": False, "actual": False}]
+
+
+def test_auto_file_summary_retains_verification_details(tmp_path, monkeypatch, capsys):
+    from _core import formatters
+    monkeypatch.setattr(formatters, "_stdout_mode", False)
+    monkeypatch.setattr(formatters, "_output_file", str(tmp_path / "result.json"))
+    verification = {"status": "pass", "summary": {"passed": 1}, "verifiedTargets": [
+        {"type": "unit_binding_equals", "target": "quantity", "expected": "unit", "actual": "unit"}]}
+    formatters.pjson({"results": [{"ok": True, "verification": verification}]})
+    import json
+    summary = json.loads(capsys.readouterr().out.split("RESULT_SUMMARY=", 1)[1])
+    assert summary["results"][0]["verification"] == verification
+    assert Path(summary["resultPath"]).is_file()
+
+
 def test_batch_receipt_persists_raw_verified_results_and_artifact_paths(tmp_path):
     import json
     from _core.formatters import save_run_batch_result
@@ -46,3 +67,17 @@ def test_batch_receipt_persists_raw_verified_results_and_artifact_paths(tmp_path
     second = save_run_batch_result(raw, str(tmp_path / "app"), [str(artifact)])
     assert second["resultPath"] != result["resultPath"]
     assert Path(result["resultPath"]).is_file()
+
+
+def test_compact_receipt_preserves_failure_recovery_without_raw_payload(tmp_path):
+    from _core.formatters import result_summary
+    raw = {"resultPath": str(tmp_path / "original.json"), "failed": 1, "doNotRetryBuildMeta": True,
+           "repairPlans": [{"observedIssues": [{"expected": "one", "actual": "other"}]}],
+           "results": [{"ok": False, "phase": "verify", "result": {"largeRawPayload": "not needed"},
+                        "verification": {"status": "fail", "issues": [{"expected": "one", "actual": "other"}]}}]}
+    compact = result_summary(raw, raw["resultPath"])
+    assert compact["doNotRetryBuildMeta"] is True
+    assert compact["repairPlans"] == raw["repairPlans"]
+    assert compact["results"][0]["verification"] == raw["results"][0]["verification"]
+    assert "result" not in compact["results"][0]
+    assert "result" in raw["results"][0]

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

@@ -1081,3 +1081,28 @@ def test_layout_verifies_readback_parentage_and_syncs_archive() -> None:
     assert result["data"]["sourceRelationshipIndependentlyVerified"] is False
     assert result["data"]["unitPlacementIndependentlyVerified"] is False
     archive_sync.assert_called_once_with("/tmp/app", "uhyl_layout", "Layout")
+
+
+def test_explicit_blank_bill_is_distinct_from_missing_template(tmp_path: Path) -> None:
+    artifact = tmp_path / "bill.json"
+    artifact.write_text(json.dumps({"templateNumber": "blankPage", "entities": [{"type": "BillEntity"}]}), encoding="utf-8")
+    template = cosmic_api._resolve_template_number(None, str(artifact), None)
+    assert template == "blankPage"
+    assert cosmic_api._resolve_template_number("BLANK", str(artifact), None) == "blankPage"
+    assert cosmic_api._artifact_file_supports_blank_template(str(artifact), template)
+    assert not cosmic_api._artifact_file_supports_blank_template(str(artifact), "")
+    assert not cosmic_api._artifact_supports_blank_template({"entities": [{"type": "BaseEntity"}]}, template)
+
+
+@pytest.mark.parametrize("operator", ["empty", "not-empty"])
+def test_conditional_copy_cli_accepts_empty_operator_without_value(monkeypatch, operator):
+    calls = []
+    monkeypatch.setattr(sys, "argv", ["cosmic_api", "ensureConditionalCopyFieldValue", "--formNumber", "demo", "--condition-field", "source", "--operator", operator, "--source", "source", "--target", "target"])
+    monkeypatch.setattr(cosmic_api, "load_config", lambda: {})
+    monkeypatch.setattr(cosmic_api, "do_auth", lambda cfg: "test")
+    monkeypatch.setattr(cosmic_api, "_bind_rule_domain_target", lambda *args: None)
+    monkeypatch.setattr(cosmic_api, "_assert_form_number_target_owned", lambda *args: None)
+    monkeypatch.setattr(cosmic_api, "do_ensure_conditional_copy_field_value", lambda *args: calls.append(args) or {"status": True})
+    monkeypatch.setattr(cosmic_api, "_attach_bound_form_identity", lambda result, args: result)
+    assert cosmic_api.main() == 0
+    assert calls[0][5:7] == (operator, None)

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

@@ -0,0 +1,98 @@
+from unittest.mock import patch
+from pathlib import Path
+import sys
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+import pytest
+from _core import cmd_rules
+
+ROWS = [{"key":"hours", "type":"TimeRangeField", "parentKey":"demo"}]
+META = {"status":True, "data":{"entitymeta":{"Key":"demo", "Items":[
+    {"_Type_":"TimeRangeField", "Key":"hours", "StartDateFieldKey":"begin", "EndDateFieldKey":"finish"},
+    {"_Type_":"BizRule", "Id":"r1"},
+]}}}
+
+def rule(value="09:00-18:00"):
+    return {"ruleType":"bizRule", "mountPoint":"demo", "trueActions":[{"actionType":"FormulaAction", "expression":f"hours = '{value}'", "ret":1}], "falseActions":[]}
+
+def test_compile_range_uses_metadata_endpoint_keys():
+    with patch.object(cmd_rules, "do_list_elements", return_value={"status":True,"data":ROWS}), patch.object(cmd_rules, "do_load_full_metadata", return_value=META):
+        got, virtual = cmd_rules._compile_time_range_actions({}, "token", "demo", rule())
+    assert [a["expression"] for a in got["trueActions"]] == ["begin = 32400", "finish = 64800"]
+    assert [a["seq"] for a in got["trueActions"]] == [1,2]
+    assert [a["key"] for a in virtual] == ["begin","finish"]
+    with patch.object(cmd_rules, "do_list_elements", return_value={"status":True,"data":ROWS}):
+        assert cmd_rules._validate_formula_action_scope({}, "token", "demo", got, virtual_fields=virtual) == got
+
+def test_compile_range_preserves_original_and_finds_update_owner():
+    original = rule()
+    original.pop("mountPoint")
+    original["ruleId"] = "r1"
+    original["trueActions"][0]["id"] = "a1"
+    with patch.object(cmd_rules, "do_list_elements", return_value={"status":True,"data":ROWS}), patch.object(cmd_rules, "do_load_full_metadata", return_value=META):
+        got, _ = cmd_rules._compile_time_range_actions({}, "token", "demo", original)
+    assert got["trueActions"][0]["id"] == "a1"
+    assert "id" not in got["trueActions"][1]
+    assert original["trueActions"][0]["expression"] == "hours = '09:00-18:00'"
+
+@pytest.mark.parametrize("value", ["25:00-18:00","09:60-18:00","18:00-09:00"])
+def test_invalid_clock_does_not_compile(value):
+    with patch.object(cmd_rules, "do_list_elements", return_value={"status":True,"data":ROWS}), patch.object(cmd_rules, "do_load_full_metadata", return_value=META), pytest.raises(ValueError):
+        cmd_rules._compile_time_range_actions({}, "token", "demo", rule(value))
+
+def test_ordinary_text_range_is_untouched():
+    with patch.object(cmd_rules, "do_list_elements", return_value={"status":True,"data":[{"key":"hours","type":"TextField"}]}), patch.object(cmd_rules, "do_load_full_metadata") as read:
+        got, virtual = cmd_rules._compile_time_range_actions({}, "token", "demo", rule())
+    assert got == rule()
+    assert not virtual
+    read.assert_not_called()
+
+
+def test_verified_update_sends_encoded_actions():
+    request = rule()
+    request.pop("mountPoint")
+    request["ruleId"] = "r1"
+    with (patch.object(cmd_rules, "do_list_elements", return_value={"status": True, "data": ROWS}),
+          patch.object(cmd_rules, "do_load_full_metadata", return_value=META),
+          patch.object(cmd_rules, "_ensure_rule_trigger_events", return_value=[]),
+          patch.object(cmd_rules, "do_update_rule", return_value={"status": True}) as write,
+          patch.object(cmd_rules, "_attach_rule_readback", side_effect=lambda *a, **k: {"status": True, "verification": {"verified": True}})):
+        result = cmd_rules.do_update_rule_verified({}, "token", "demo", request)
+    assert result["verification"]["verified"]
+    assert [a["expression"] for a in write.call_args.args[3]["trueActions"]] == ["begin = 32400", "finish = 64800"]
+
+def test_missing_endpoint_rejects_before_write():
+    metadata = {"status": True, "data": {"Items": [{"_Type_": "TimeRangeField", "Key": "hours", "StartDateFieldKey": "begin"}]}}
+    with (patch.object(cmd_rules, "do_list_elements", return_value={"status": True, "data": ROWS}),
+          patch.object(cmd_rules, "do_load_full_metadata", return_value=metadata),
+          patch.object(cmd_rules, "do_add_rule") as write,
+          patch.object(cmd_rules, "_resolve_rule_entity", side_effect=lambda *a: a[3])):
+        request = {**rule(), "description": "test", "preDescription": "test", "preCondition": "1=1", "itemId": "entity"}
+        with pytest.raises(ValueError, match="TIME_RANGE_METADATA_AMBIGUOUS"):
+            cmd_rules.do_add_rule_verified({}, "token", "demo", request)
+    write.assert_not_called()
+
+
+def test_existing_same_entity_endpoint_with_extra_metadata_is_accepted():
+    original = rule()
+    with patch.object(cmd_rules, "do_list_elements", return_value={"status": True, "data": ROWS}), patch.object(cmd_rules, "do_load_full_metadata", return_value=META):
+        compiled, virtual = cmd_rules._compile_time_range_actions({}, "token", "demo", original)
+    actual_rows = ROWS + [{"key": "begin", "type": "TimeField", "parentKey": "demo", "id": "start-id", "name": "开始"}]
+    with patch.object(cmd_rules, "do_list_elements", return_value={"status": True, "data": actual_rows}):
+        assert cmd_rules._validate_formula_action_scope({}, "token", "demo", compiled, virtual_fields=virtual) == compiled
+    actual_rows[1]["parentKey"] = "other"
+    with patch.object(cmd_rules, "do_list_elements", return_value={"status": True, "data": actual_rows}), pytest.raises(ValueError, match="TIME_RANGE_ENDPOINT_COLLISION"):
+        cmd_rules._validate_formula_action_scope({}, "token", "demo", compiled, virtual_fields=virtual)
+
+
+def test_update_rejects_endpoint_in_other_entity_before_write():
+    request = rule()
+    request.pop("mountPoint")
+    request["ruleId"] = "r1"
+    rows = ROWS + [{"key": "begin", "type": "TimeField", "parentKey": "other"}]
+    with (patch.object(cmd_rules, "do_list_elements", return_value={"status": True, "data": rows}),
+          patch.object(cmd_rules, "do_load_full_metadata", return_value=META),
+          patch.object(cmd_rules, "do_update_rule") as write,
+          pytest.raises(ValueError, match="TIME_RANGE_ENDPOINT_COLLISION")):
+        cmd_rules.do_update_rule_verified({}, "token", "demo", request)
+    write.assert_not_called()