@shundoo-ai/dsh-cosmic 1.0.21 → 1.0.22

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

@@ -8,12 +8,16 @@ not verified" even though ``data.formLayout`` carried the exact control tree tha
 These tests pin the derived projection and the honest accounting of what it cannot prove.
 """
 
+import copy
+import json
 import os
 import sys
 import unittest
+from unittest import mock
 
 sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 
+from _core import report_ops  # noqa: E402
 from _core.report_ops import (  # noqa: E402
     _columns_from_layout,
     _filters_from_layout,
@@ -313,7 +317,10 @@ class TestDerivedVerification(unittest.TestCase):
         ):
             result = report_readback_verification(section, expected, _derived_schema())
             self.assertFalse(result["verified"], section)
-            self.assertIn("not carried by readBackSource", result["mismatches"][0]["actual"])
+            if section == "sorts":
+                self.assertEqual(result["errorCode"], "REPORT_SORTS_API_UNSAFE")
+            else:
+                self.assertIn("not carried by readBackSource", result["mismatches"][0]["actual"])
 
     def test_no_read_back_source_reports_unavailable(self):
         result = report_readback_verification(
@@ -322,5 +329,175 @@ class TestDerivedVerification(unittest.TestCase):
         self.assertEqual("unavailable", result["source"])
 
 
+def _projection_response():
+    """bos1030 字节码确认的投影形状；fixture 不模拟查询生效。"""
+    layout = _layout()
+    controls = layout["children"][1]["children"][0]["children"]
+    controls[0].update(id="date-control", fieldId="date-field", type="FieldAp")
+    controls[1].update(id="supplier-control", fieldId="supplier-field", type="FieldAp")
+    return {"data": {"formLayout": layout, "reportFilters": {
+        "available": True,
+        "filterPanel": {"commFilterPanelFound": True, "filterMustInput": True,
+                        "showFilterFields": {"format": "json-array",
+                            "raw": '["sup_number","biz_date"]', "parsed": ["sup_number", "biz_date"]}},
+        "filters": [
+            {"fieldPath": "sup_number", "registered": True, "controlFound": True,
+             "duplicateControlCount": 1, "controlId": "supplier-control", "fieldId": "supplier-field",
+             "fieldType": "MulBasedataField", "mustInput": True, "visibleEffective": False,
+             "reference": {"kind": "mulbasedata", "baseEntityId": "supplier-uuid",
+                           "baseEntityNumber": "bd_supplier"}, "rangeKeys": None,
+             "compare": {"source": "ReportFilterFieldConfig", "compareTypeId": "1",
+                         "dataSourceId": "query-source", "fieldName": "supplier"}, "unknown": []},
+            {"fieldPath": "biz_date", "registered": True, "controlFound": True,
+             "duplicateControlCount": 1, "controlId": "date-control", "fieldId": "date-field",
+             "fieldType": "DateRangeField", "mustInput": False, "visibleEffective": True,
+             "reference": {"kind": "none"}, "rangeKeys": {"start": "date_from", "end": "date_to"},
+             "compare": {"source": "unconfigured", "compareTypeId": None,
+                         "unknown": ["compareTypeId", "fieldName"]}, "unknown": []}],
+        "orphanRegistrations": [], "unmanagedControls": [], "nonFilterChildren": []}}}
+
+
+def _projection_schema(response):
+    with mock.patch.object(report_ops, "_get_schema", return_value=response):
+        return report_ops.get_report_schema({}, "token", "report-id")
+
+
+def _projection_request():
+    return [
+        {"fieldPath": "sup_number", "displayName": "Supplier Number", "compare": "in",
+         "fieldType": "MulBasedataField", "basedataNumber": "bd_supplier", "mustInput": True},
+        {"fieldPath": "biz_date", "displayName": "Order Date", "compare": "between",
+         "fieldType": "DateRangeField", "startDateFieldKey": "date_from", "endDateFieldKey": "date_to"}]
+
+
+class TestStructuredFilterProjection(unittest.TestCase):
+    def test_new_projection_verifies_identity_required_and_custom_range_not_query(self):
+        response = _projection_response()
+        before = copy.deepcopy(response)
+        schema = _projection_schema(response)
+        result = report_readback_verification("filters", _projection_request(), schema)
+        self.assertTrue(result["verified"], result)
+        self.assertEqual(result["source"], "reportFilterProjection")
+        self.assertNotIn("mustInput", result["unverifiedProperties"])
+        self.assertNotIn("basedataNumber", result.get("unverifiableRequestedProperties", []))
+        self.assertIn("compare", result["unverifiedProperties"])
+        self.assertEqual(schema["reportFilters"][0]["compareConfig"]["fieldName"], "supplier")
+        self.assertNotIn("compare", schema["reportFilters"][0])
+        self.assertEqual(response, before)
+        self.assertEqual(schema["reportColumns"], _columns_from_layout(response["data"]["formLayout"]))
+        self.assertIn("reportPlugins", schema["unverifiableSections"])
+
+    def test_wrong_multiselect_reference_is_a_mismatch(self):
+        response = _projection_response()
+        response["data"]["reportFilters"]["filters"][0]["reference"]["baseEntityNumber"] = "bd_customer"
+        result = report_readback_verification("filters", _projection_request(), _projection_schema(response))
+        self.assertFalse(result["verified"])
+        self.assertTrue(any(row["path"].endswith("/basedataNumber") for row in result["mismatches"]))
+
+    def test_custom_range_and_combo_values_are_compared(self):
+        response = _projection_response()
+        response["data"]["reportFilters"]["filters"][1]["rangeKeys"]["start"] = "wrong"
+        result = report_readback_verification("filters", _projection_request(), _projection_schema(response))
+        self.assertFalse(result["verified"])
+        self.assertTrue(any("/rangeKeys/start" in row["path"] for row in result["mismatches"]))
+        response = _projection_response()
+        row = response["data"]["reportFilters"]["filters"][0]
+        row.update(fieldType="ComboField", comboItems=[{"value": "0", "caption": "Zero", "seq": 0},
+                                                     {"value": "001", "caption": "Code", "seq": 1}])
+        requested = _projection_request()
+        requested[0] = {"fieldPath": "sup_number", "displayName": "Supplier Number", "compare": "in",
+                        "fieldType": "ComboField", "comboItems": [{"value": "0", "caption": "Zero"},
+                                                                  {"value": "001", "caption": "Code"}]}
+        self.assertTrue(report_readback_verification("filters", requested, _projection_schema(response))["verified"])
+        row["comboItems"][1]["value"] = "1"
+        self.assertFalse(report_readback_verification("filters", requested, _projection_schema(response))["verified"])
+
+    def test_unknown_is_not_false_and_known_false_is_a_mismatch(self):
+        response = _projection_response()
+        row = response["data"]["reportFilters"]["filters"][0]
+        row.update(mustInput=False, unknown=["mustInput"])
+        result = report_readback_verification("filters", _projection_request(), _projection_schema(response))
+        self.assertTrue(result["verified"], result)
+        self.assertIn("mustInput", result["unverifiableRequestedProperties"])
+        row["unknown"] = []
+        result = report_readback_verification("filters", _projection_request(), _projection_schema(response))
+        self.assertFalse(result["verified"])
+
+    def test_visible_and_explicit_default_flags_use_observed_booleans(self):
+        response = _projection_response()
+        requested = _projection_request()
+        requested[0]["visible"] = True
+        result = report_readback_verification("filters", requested, _projection_schema(response))
+        self.assertFalse(result["verified"])
+        response["data"]["reportFilters"]["filters"][0]["visibleEffective"] = None
+        result = report_readback_verification("filters", requested, _projection_schema(response))
+        self.assertTrue(result["verified"])
+        self.assertIn("visible", result["unverifiableRequestedProperties"])
+
+    def test_orphan_and_duplicate_controls_do_not_pass_structure(self):
+        for value in (0, 2):
+            response = _projection_response()
+            row = response["data"]["reportFilters"]["filters"][0]
+            row.update(controlFound=value != 0, duplicateControlCount=value)
+            response["data"]["reportFilters"]["orphanRegistrations"] = ["sup_number"] if value == 0 else []
+            result = report_readback_verification("filters", _projection_request(), _projection_schema(response))
+            self.assertFalse(result["verified"])
+            self.assertIn("orphanRegistrations", result["projectionDiagnostics"])
+
+    def test_no_name_evidence_does_not_reuse_request_or_unrelated_control(self):
+        response = _projection_response()
+        response["data"]["reportFilters"]["filters"][0]["controlId"] = "unrelated-control"
+        schema = _projection_schema(response)
+        self.assertNotIn("displayName", schema["reportFilters"][0])
+        result = report_readback_verification("filters", _projection_request(), schema)
+        self.assertIn("displayName", result["unverifiableRequestedProperties"])
+
+    def test_unavailable_missing_panel_and_bad_json_cannot_use_legacy_fallback(self):
+        for condition in ("unavailable", "panel", "bad-json", "malformed", "legacy-comma"):
+            response = _projection_response()
+            projection = response["data"]["reportFilters"]
+            if condition == "unavailable":
+                projection.update(available=False, reason="missing filter")
+            elif condition == "panel":
+                projection["filterPanel"]["commFilterPanelFound"] = False
+            elif condition == "bad-json":
+                projection["filterPanel"]["showFilterFields"]["raw"] = "[bad"
+            elif condition == "legacy-comma":
+                projection["filterPanel"]["showFilterFields"].update(format="legacy-comma", raw="sup_number,biz_date")
+            else:
+                response["data"]["reportFilters"] = []
+            schema = _projection_schema(response)
+            result = report_readback_verification("filters", _projection_request(), schema)
+            self.assertFalse(result["verified"], condition)
+            self.assertIn("reportFilters", schema["unverifiableSections"])
+
+    def test_empty_and_projection_only_do_not_prove_other_sections(self):
+        response = _projection_response()
+        response["data"].pop("formLayout")
+        projection = response["data"]["reportFilters"]
+        projection["filters"] = []
+        projection["filterPanel"]["showFilterFields"].update(format="empty", raw="", parsed=[])
+        schema = _projection_schema(response)
+        self.assertTrue(report_readback_verification("filters", [], schema)["verified"])
+        self.assertFalse(report_readback_verification("columns", [], schema)["verified"])
+
+    def test_canonical_other_sections_and_dym_do_not_overwrite_projection(self):
+        response = _projection_response()
+        response["data"]["reportSchema"] = {"readBackAvailable": True, "reportColumns": [],
+            "reportFilters": [], "reportPlugins": [], "reportSorts": []}
+        schema = _projection_schema(response)
+        self.assertEqual(schema["readBackSource"], "canonical")
+        self.assertTrue(report_readback_verification("filters", _projection_request(), schema)["verified"])
+        response["data"].pop("reportSchema")
+        schema = _projection_schema(response)
+        report_ops.attach_dym_evidence(schema, {"reportFilters": [
+            {"fieldPath": "sup_number", "mustInput": False, "visible": True},
+            {"fieldPath": "biz_date", "mustInput": True, "visible": False}],
+            "reportPlugins": [{"className": "kd.example.P", "enabled": True}]})
+        self.assertTrue(schema["reportFilters"][0]["mustInput"])
+        self.assertFalse(schema["reportFilters"][0]["visible"])
+        self.assertNotIn("reportPlugins", schema["unverifiableSections"])
+
+
 if __name__ == "__main__":
     unittest.main(verbosity=2)

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

@@ -1,11 +1,10 @@
 # -*- coding: utf-8 -*-
-"""Changing a report's column set has one supported route, and it is planned before it runs.
+"""不可原位完成的报表列变更必须先规划重建。
 
-Verified live: ReportColumns appends report-entity fields instead of replacing them, and
-the platform exposes no update or field-removal path, so a column change means recreating the
-report. That is irreversible — the new form gets a new formId — which is why the route is
-planned, backed up and diffed first, and why deletion stays on deleteForm and its own two-step
-confirmation instead of being re-implemented here.
+ReportColumns 全量写入会追加实体字段，不能用于修改既有列。追加使用 addReportColumns，
+单叶子删除在已发布补丁的后端使用 removeReportColumn；分组删除、重排、改类型等未覆盖的
+变更仍需另行授权重建。重建不可逆，新表单会获得新 formId，因此必须先备份和比较，
+整个报表的删除继续使用 deleteForm 自身的两步确认，而不在规划器中重新实现。
 
 These tests pin the planner: it is read-only, it names what recreating loses, it refuses an
 artifact that would build a different form, and it never claims a fuller diff than the
@@ -87,7 +86,7 @@ class PlanShapeTest(unittest.TestCase):
 
     def test_steps_put_deletion_on_delete_form_with_its_own_confirmation(self):
         steps = {step["order"]: step for step in report_ops.plan_report_recreate(_schema())["steps"]}
-        self.assertEqual(sorted(steps), [1, 2, 3, 4])
+        self.assertEqual(sorted(steps), [1, 2, 3, 4, 5])
         self.assertIn("deleteForm", steps[2]["command"])
         self.assertIn("DESTRUCTIVE_CONFIRMATION_REQUIRED", steps[2]["detail"])
         self.assertIn("6+MZ9NOTMY9R", steps[2]["command"])
@@ -96,7 +95,7 @@ class PlanShapeTest(unittest.TestCase):
     def test_menu_repointing_comes_after_the_recreate_that_mints_the_new_form_id(self):
         # A menu cannot be re-pointed before the recreated form exists.
         steps = {step["order"]: step for step in report_ops.plan_report_recreate(_schema())["steps"]}
-        self.assertIn("updateMenu", steps[4]["command"])
+        self.assertIn("updateMenu", steps[5]["command"])
 
     def test_menu_repointing_comes_after_the_recreate(self):
         """The new formId only exists once the report is recreated, so menus cannot go first."""
@@ -177,6 +176,84 @@ class MenuBindingTest(unittest.TestCase):
         self.assertIn("no menu entry", menu_step["detail"])
 
 
+def _plugin_rows(*rows):
+    return [{"className": name, "location": location, "pluginType": kind, "enabled": True}
+            for name, location, kind in rows]
+
+
+class ReportFormPluginTest(unittest.TestCase):
+    """deleteForm takes the report form's own plugins with it, and run does not register them.
+
+    run registers the data plugins the artifact carries. A reportform plugin sits on the form's
+    own plugin list, which queryEditablePlugins reads back as location BILL_FORM, so the plan has
+    to name it before deletion or the recreated report silently loses its interaction.
+    """
+
+    def _step(self, plan):
+        return next(step for step in plan["steps"] if "formPlugins" in step["action"])
+
+    def test_the_losses_name_the_report_form_plugins(self):
+        joined = " ".join(report_ops.plan_report_recreate(_schema())["lostOnRecreate"])
+        self.assertIn("reportform", joined)
+        self.assertIn("BILL_FORM", joined)
+
+    def test_form_plugins_are_captured_and_named_in_their_own_step(self):
+        plan = report_ops.plan_report_recreate(_schema(), plugin_rows=_plugin_rows(
+            ("kd.kdtest.report.KpiDrillPlugin", "BILL_FORM", "JAVA"),
+            ("kd.kdtest.report.P", "REPORT_QUERY_PLUGIN", "JAVA"),
+        ))
+        self.assertEqual([item["className"] for item in plan["current"]["formPlugins"]],
+                         ["kd.kdtest.report.KpiDrillPlugin"])
+        step = self._step(plan)
+        self.assertIn("register_plugins.py", step["command"])
+        self.assertIn("--verify", step["command"])
+        self.assertIn("kd.kdtest.report.KpiDrillPlugin", step["detail"])
+        self.assertIn("BILL_FORM", step["detail"])
+        # The data plugin is the artifact's, and run registers it again by itself.
+        self.assertIn("1 Java plugin(s)", step["detail"])
+
+    def test_the_plugins_come_back_after_the_recreate_and_before_the_menus(self):
+        steps = {step["action"]: step["order"] for step in
+                 report_ops.plan_report_recreate(_schema(), plugin_rows=[])["steps"]}
+        recreate = next(order for action, order in steps.items() if "recreate" in action)
+        plugins = next(order for action, order in steps.items() if "formPlugins" in action)
+        menu = next(order for action, order in steps.items() if "menu" in action)
+        self.assertLess(recreate, plugins)
+        self.assertLess(plugins, menu)
+
+    def test_an_unread_plugin_list_is_not_reported_as_empty(self):
+        plan = report_ops.plan_report_recreate(_schema())
+        self.assertIsNone(plan["current"]["formPlugins"])
+        detail = self._step(plan)["detail"]
+        self.assertIn("not read", detail)
+        self.assertIn("queryEditablePlugins --formNumber kdtest_sup_pur_sum_rpt", detail)
+
+    def test_a_read_list_without_form_plugins_says_nothing_to_re_register(self):
+        plan = report_ops.plan_report_recreate(_schema(), plugin_rows=_plugin_rows(
+            ("kd.kdtest.report.P", "REPORT_QUERY_PLUGIN", "JAVA"),
+        ))
+        self.assertEqual(plan["current"]["formPlugins"], [])
+        self.assertIn("nothing to re-register", self._step(plan)["detail"])
+
+    def test_a_script_plugin_is_routed_to_register_plugin(self):
+        plan = report_ops.plan_report_recreate(_schema(), plugin_rows=_plugin_rows(
+            ("kdtest_rpt_script", "BILL_FORM", "KINGSCRIPT"),
+        ))
+        detail = self._step(plan)["detail"]
+        self.assertIn("kdtest_rpt_script", detail)
+        self.assertIn("registerPlugin", detail)
+        self.assertIn("Java classes only", detail)
+
+    def test_a_data_plugin_on_the_form_list_is_not_re_registered_there(self):
+        plan = report_ops.plan_report_recreate(_schema(), plugin_rows=_plugin_rows(
+            ("kd.kdtest.report.P", "BILL_FORM", "JAVA"),
+        ))
+        self.assertEqual(plan["current"]["formPlugins"], [])
+        detail = self._step(plan)["detail"]
+        self.assertIn("kd.kdtest.report.P is the report's data plugin", detail)
+        self.assertIn("do not register it on the form again", detail)
+
+
 class BackupTest(unittest.TestCase):
     """A failed recreate must not be a lost report."""
 
@@ -210,12 +287,18 @@ class RecreatePlanCommandTest(unittest.TestCase):
     dispatch so the ownership gate, the design-state sync and that read-only promise are pinned.
     """
 
-    def _dispatch(self, argv, *, schema=None, menus=None, sync=None):
+    def _dispatch(self, argv, *, schema=None, menus=None, sync=None, plugins=None):
         import cosmic_api
 
         emitted = {}
         report_schema = schema if schema is not None else _schema()
+        # --app-root has to be a bound Cosmic app directory, which archive.json identifies.
+        app_root = argv[argv.index("--app-root") + 1]
+        with open(os.path.join(app_root, "archive.json"), "w", encoding="utf-8") as handle:
+            json.dump({"type": "cosmic", "appCode": "kdtest", "appId": "APP-ID"}, handle)
         menu_result = {"data": {"menus": menus if menus is not None else []}}
+        plugin_result = {"status": True, "errorCode": "0",
+                         "data": plugins if plugins is not None else []}
         patches = {
             "load_config": mock.DEFAULT,
             "do_auth": mock.DEFAULT,
@@ -223,6 +306,7 @@ class RecreatePlanCommandTest(unittest.TestCase):
             "do_get_report_schema": mock.DEFAULT,
             "_export_report_dym_evidence": mock.DEFAULT,
             "do_query_menu_tree": mock.DEFAULT,
+            "do_query_editable_plugins": mock.DEFAULT,
             "pjson": mock.DEFAULT,
         }
         with mock.patch.multiple(cosmic_api, **patches) as mocks, \
@@ -241,6 +325,9 @@ class RecreatePlanCommandTest(unittest.TestCase):
             mocks["_export_report_dym_evidence"].side_effect = sync
             mocks["_export_report_dym_evidence"].return_value = ""
             mocks["do_query_menu_tree"].return_value = menu_result
+            if isinstance(plugins, Exception):
+                mocks["do_query_editable_plugins"].side_effect = plugins
+            mocks["do_query_editable_plugins"].return_value = plugin_result
             mocks["pjson"].side_effect = emitted.update
             cosmic_api._main_impl()
         writes = {
@@ -296,7 +383,35 @@ class RecreatePlanCommandTest(unittest.TestCase):
                  "--app-root", tmp],
                 sync=RuntimeError("sync root not configured"))
         self.assertTrue(emitted["status"])
-        self.assertEqual(4, len(emitted["data"]["steps"]))
+        self.assertEqual(5, len(emitted["data"]["steps"]))
+
+    def test_command_reads_the_report_form_plugins_before_anything_is_deleted(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            emitted, mocks, _writes = self._dispatch(
+                ["planReportRecreate", "--formNumber", "kdtest_sup_pur_sum_rpt",
+                 "--app-root", tmp],
+                plugins=_plugin_rows(
+                    ("kd.kdtest.report.KpiDrillPlugin", "BILL_FORM", "JAVA"),
+                    ("kd.kdtest.report.P", "REPORT_QUERY_PLUGIN", "JAVA"),
+                ))
+            with open(emitted["data"]["backupPath"], encoding="utf-8") as handle:
+                saved = json.load(handle)
+        self.assertEqual("kdtest_sup_pur_sum_rpt",
+                         mocks["do_query_editable_plugins"].call_args.kwargs["form_number"])
+        self.assertEqual(["kd.kdtest.report.KpiDrillPlugin"],
+                         [item["className"] for item in emitted["data"]["current"]["formPlugins"]])
+        # The backup is the record that survives deleteForm, so it carries them too.
+        self.assertEqual("kd.kdtest.report.KpiDrillPlugin",
+                         saved["plan"]["current"]["formPlugins"][0]["className"])
+
+    def test_a_failed_plugin_read_leaves_the_list_unread_instead_of_empty(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            emitted, _mocks, _writes = self._dispatch(
+                ["planReportRecreate", "--formNumber", "kdtest_sup_pur_sum_rpt",
+                 "--app-root", tmp],
+                plugins=RuntimeError("queryEditablePlugins unavailable"))
+        self.assertTrue(emitted["status"])
+        self.assertIsNone(emitted["data"]["current"]["formPlugins"])
 
     def test_command_reports_the_menu_entries_that_break_on_delete(self):
         with tempfile.TemporaryDirectory() as tmp:

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

@@ -15,7 +15,9 @@ reached.
 
 import os
 import sys
+import tempfile
 import unittest
+from pathlib import Path
 from unittest import mock
 
 sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
@@ -117,6 +119,212 @@ class ServeReportContractTest(unittest.TestCase):
                     cmd, {"formNumber": "kdtest_rpt", key: []}, target)
                 self.assertIn("non-empty array", message)
 
+    def test_removal_rejects_non_identifier_and_non_boolean_dry_run(self):
+        for field_key in (None, [], 12, "person.name", "../person", "人物"):
+            with self.subTest(fieldKey=field_key):
+                message = self._dispatch("removeReportColumn", {
+                    "appRoot": "fixture", "formNumber": "kdtest_rpt", "fieldKey": field_key,
+                }, "do_remove_report_column")
+                self.assertIn("REPORT_INPUT_INVALID", message)
+        self.assertIn("dryRun must be boolean", self._dispatch("removeReportColumn", {
+            "appRoot": "fixture", "formNumber": "kdtest_rpt", "fieldKey": "person", "dryRun": "false",
+        }, "do_remove_report_column"))
+
+    def test_removal_requires_owned_scope_and_has_local_only_dry_run(self):
+        for missing in ("appRoot", "formNumber"):
+            with self.subTest(missing=missing):
+                args = {"appRoot": "fixture", "formNumber": "kdtest_rpt", "fieldKey": "person"}
+                args.pop(missing)
+                self.assertIn("requires appRoot", self._dispatch("removeReportColumn", args, "do_remove_report_column"))
+        from _core import report_ops
+        with mock.patch.object(report_ops, "_api_call") as api, \
+                mock.patch.object(cosmic_api, "_resolve_owned_report_target") as resolve:
+            result = cosmic_api._dispatch_serve({}, "fixture", "removeReportColumn", {
+                "appRoot": "fixture", "formNumber": "kdtest_rpt", "fieldKey": "person", "dryRun": True,
+            })
+        api.assert_not_called()
+        resolve.assert_not_called()
+        self.assertTrue(result["dryRun"])
+        self.assertFalse(result["capabilityVerified"])
+        self.assertFalse(result["writeAttempted"])
+        self.assertEqual(result["payload"]["complexType"], "ReportColumns.remove")
+
+    def test_removal_corroborates_form_id_and_report_type_before_write(self):
+        for row in ({"formId": "OTHER", "modelType": "ReportFormModel"},
+                    {"formId": "FID", "modelType": "BillFormModel"}):
+            with self.subTest(row=row), mock.patch.object(cosmic_api, "_assert_form_number_target_owned", return_value=row), \
+                    mock.patch.object(cosmic_api, "do_remove_report_column") as write:
+                with self.assertRaises(RuntimeError):
+                    cosmic_api._dispatch_serve({}, "fixture", "removeReportColumn", {
+                        "appRoot": "fixture", "formNumber": "kdtest_rpt", "formId": "FID", "fieldKey": "person",
+                    })
+                write.assert_not_called()
+
+    def test_removal_describe_command_and_cli_dry_run_are_available_without_auth(self):
+        import io
+        import json
+        from contextlib import ExitStack, redirect_stdout, redirect_stderr
+        from _core import config, report_ops
+        # CLI 会切换运行路径；使用真实绑定夹具，并在测试结束后还原进程全局状态。
+        with tempfile.TemporaryDirectory() as root, ExitStack() as stack:
+            Path(root, "archive.json").write_text(json.dumps({
+                "type": "cosmic", "appCode": "fixture", "appId": "APP",
+            }), encoding="utf-8")
+            stack.enter_context(mock.patch.dict(os.environ))
+            names = ("RUNTIME_DIR", "TOKEN_CACHE", "BIZ_CACHE", "CONTEXT_MD", "CONFIG_MD",
+                     "ARTIFACTS_DIR", "BATCH_MANIFESTS_DIR", "TEMP_ARTIFACT", "WORKSPACE_JSON")
+            for module in (cosmic_api, config):
+                stack.enter_context(mock.patch.multiple(module, **{name: getattr(module, name) for name in names}))
+            stack.enter_context(mock.patch.object(config, "_BOUND_APP_ROOT", getattr(config, "_BOUND_APP_ROOT", None), create=True))
+            for arguments in (["describeCommand", "removeReportColumn"],
+                              ["removeReportColumn", "--app-root", root, "--formNumber", "kdtest_rpt", "--fieldKey", "person", "--dryRun"]):
+                with self.subTest(arguments=arguments), mock.patch.object(sys, "argv", ["cosmic_api.py", "--stdout", *arguments]), \
+                        mock.patch.object(cosmic_api, "do_auth") as auth, \
+                        mock.patch.object(cosmic_api, "_resolve_owned_report_target") as resolve, \
+                        mock.patch.object(report_ops, "_api_call") as api, \
+                        redirect_stdout(io.StringIO()) as output, redirect_stderr(io.StringIO()):
+                    self.assertEqual(cosmic_api.main(), 0)
+                    result = json.loads(output.getvalue())
+                    auth.assert_not_called()
+                    resolve.assert_not_called()
+                    api.assert_not_called()
+                    if arguments[0] == "describeCommand":
+                        self.assertEqual(result["action"]["command"], "removeReportColumn")
+                        self.assertIn("columnRemoval", str(result))
+                    else:
+                        self.assertTrue(result["dryRun"])
+                        self.assertFalse(result["capabilityVerified"])
+
+    def test_valid_sorts_are_blocked_without_any_http(self):
+        import json
+        from _core import report_ops, cmd_properties
+        sorts = [{"fieldKey": "amount", "direction": "desc"}]
+        with mock.patch.object(report_ops, "_api_call") as api:
+            for dry_run in (False, True):
+                with self.subTest(dryRun=dry_run), self.assertRaisesRegex(RuntimeError, "REPORT_SORTS_API_UNSAFE"):
+                    report_ops.set_report_sorts({}, "token", "FID", sorts, dry_run=dry_run)
+            with self.assertRaisesRegex(RuntimeError, "REPORT_SORTS_API_UNSAFE"):
+                cosmic_api._dispatch_serve({}, "token", "setReportSorts", {
+                    "formNumber": "kdtest_rpt", "sorts": sorts})
+            with self.assertRaisesRegex(RuntimeError, "REPORT_SORTS_API_UNSAFE"):
+                report_ops._set_complex({}, "token", "kdtest_rpt", "ReportSorts", {"sorts": sorts})
+            api.assert_not_called()
+        polluted = [{"purpose": "sort", "direction": "desc", "freezelistkey": "amount"}]
+        with mock.patch.object(cmd_properties, "_api_call") as api:
+            for complex_type, data in (("ReportSorts", {"sorts": sorts}),
+                                       ("initField", polluted),
+                                       ("initField", json.dumps(polluted)),
+                                       ("ReportListSettings", {"InitField": polluted}),
+                                       ("ReportListSettings", {"InitField": json.dumps(polluted)})):
+                result = cmd_properties.do_set_complex_property({}, "token", "kdtest_rpt", complex_type, data)
+                self.assertEqual(result["errorCode"], "REPORT_SORTS_API_UNSAFE")
+                self.assertFalse(result["writeAttempted"])
+            result = cmd_properties.do_set_properties({}, "token", "kdtest_rpt", "reportlistap", {"InitField": polluted})
+            self.assertFalse(result["writeAttempted"])
+            api.assert_not_called()
+            cmd_properties.do_set_complex_property({}, "token", "kdtest_rpt", "initField", [
+                {"fieldkey": "amount", "isvisible": "false"}], element_key="reportlistap")
+            api.assert_called_once()
+
+    def test_sort_catalog_and_cli_refuse_before_auth_and_preserve_baseline(self):
+        import io
+        import json
+        from contextlib import ExitStack, redirect_stdout, redirect_stderr
+        from _core import config, report_ops
+        with tempfile.TemporaryDirectory() as root, ExitStack() as stack:
+            Path(root, "archive.json").write_text(json.dumps({
+                "type": "cosmic", "appCode": "fixture", "appId": "APP",
+            }), encoding="utf-8")
+            baseline = report_ops.report_authoring_path(root, "kdtest_rpt")
+            baseline.parent.mkdir(parents=True, exist_ok=True)
+            baseline.write_text('{"status":"current","fixture":"unchanged"}', encoding="utf-8")
+            original = baseline.read_bytes()
+            stack.enter_context(mock.patch.dict(os.environ))
+            names = ("RUNTIME_DIR", "TOKEN_CACHE", "BIZ_CACHE", "CONTEXT_MD", "CONFIG_MD",
+                     "ARTIFACTS_DIR", "BATCH_MANIFESTS_DIR", "TEMP_ARTIFACT", "WORKSPACE_JSON")
+            for module in (cosmic_api, config):
+                stack.enter_context(mock.patch.multiple(module, **{name: getattr(module, name) for name in names}))
+            stack.enter_context(mock.patch.object(config, "_BOUND_APP_ROOT", getattr(config, "_BOUND_APP_ROOT", None), create=True))
+            sorts = [{"fieldKey": "amount", "direction": "desc"}]
+            write_args = ["setReportSorts", "--app-root", root, "--formNumber", "kdtest_rpt", "--sorts", json.dumps(sorts)]
+            for arguments in (["describeCommand", "setReportSorts"], write_args, [*write_args, "--dryRun"]):
+                with self.subTest(arguments=arguments), mock.patch.object(sys, "argv", ["cosmic_api.py", "--stdout", *arguments]), \
+                        mock.patch.object(cosmic_api, "do_auth") as auth, \
+                        mock.patch.object(cosmic_api, "load_config") as load, \
+                        mock.patch.object(cosmic_api, "_resolve_owned_report_target") as resolve, \
+                        mock.patch.object(report_ops, "_api_call") as api, \
+                        redirect_stdout(io.StringIO()) as output, redirect_stderr(io.StringIO()):
+                    code = cosmic_api.main()
+                    result = json.loads(output.getvalue())
+                    auth.assert_not_called()
+                    load.assert_not_called()
+                    resolve.assert_not_called()
+                    api.assert_not_called()
+                    if arguments[0] == "describeCommand":
+                        self.assertEqual(code, 0)
+                        self.assertEqual(result["action"]["availability"], "blocked")
+                        self.assertFalse(result["action"]["available"])
+                    else:
+                        self.assertNotEqual(code, 0)
+                        self.assertEqual(result["errorCode"], "REPORT_SORTS_API_UNSAFE")
+                        self.assertFalse(result["writeAttempted"])
+                    self.assertEqual(baseline.read_bytes(), original)
+            with mock.patch.object(report_ops, "_api_call") as api, \
+                    mock.patch.object(cosmic_api, "_resolve_owned_report_target") as resolve:
+                with self.assertRaisesRegex(RuntimeError, "REPORT_SORTS_API_UNSAFE"):
+                    cosmic_api._dispatch_serve({}, "token", "setReportSorts", {
+                        "appRoot": root, "formNumber": "kdtest_rpt", "sorts": sorts})
+                api.assert_not_called()
+                resolve.assert_not_called()
+                self.assertEqual(baseline.read_bytes(), original)
+
+    def test_dynamic_precision_cli_refuses_before_auth_and_preserves_baseline(self):
+        import io
+        import json
+        from contextlib import ExitStack, redirect_stdout, redirect_stderr
+        from _core import config, report_ops
+        with tempfile.TemporaryDirectory() as root, ExitStack() as stack:
+            Path(root, "archive.json").write_text(json.dumps({
+                "type": "cosmic", "appCode": "fixture", "appId": "APP",
+            }), encoding="utf-8")
+            baseline = report_ops.report_authoring_path(root, "kdtest_rpt")
+            baseline.parent.mkdir(parents=True, exist_ok=True)
+            baseline.write_text('{"status":"current","fixture":"unchanged"}', encoding="utf-8")
+            original = baseline.read_bytes()
+            # 真实 CLI 会绑定运行目录；还原进程全局状态，门禁本身不 mock。
+            stack.enter_context(mock.patch.dict(os.environ))
+            names = ("RUNTIME_DIR", "TOKEN_CACHE", "BIZ_CACHE", "CONTEXT_MD", "CONFIG_MD",
+                     "ARTIFACTS_DIR", "BATCH_MANIFESTS_DIR", "TEMP_ARTIFACT", "WORKSPACE_JSON")
+            for module in (cosmic_api, config):
+                stack.enter_context(mock.patch.multiple(module, **{name: getattr(module, name) for name in names}))
+            stack.enter_context(mock.patch.object(config, "_BOUND_APP_ROOT", getattr(config, "_BOUND_APP_ROOT", None), create=True))
+            for kind in ("amount", "price", "qty"):
+                key = "measureUnitField" if kind == "qty" else "currencyField"
+                columns = [{"kind": "column", "fieldKey": "value", "dateIndex": "value",
+                            "fieldType": "decimal", "caption": "Value", "presentation": {"kind": kind, key: "reference"}},
+                           {"kind": "column", "fieldKey": "reference", "dateIndex": "reference",
+                            "fieldType": "bigint", "caption": "Reference", "hide": True}]
+                for cmd in ("setReportColumns", "addReportColumns"):
+                    for dry_run in (False, True):
+                        arguments = [cmd, "--app-root", root, "--formNumber", "kdtest_rpt", "--columns", json.dumps(columns)]
+                        with self.subTest(kind=kind, cmd=cmd, dryRun=dry_run), \
+                                mock.patch.object(sys, "argv", ["cosmic_api.py", "--stdout", *arguments, *(["--dryRun"] if dry_run else [])]), \
+                                mock.patch.object(cosmic_api, "do_auth") as auth, \
+                                mock.patch.object(cosmic_api, "load_config") as load, \
+                                mock.patch.object(cosmic_api, "_resolve_owned_report_target") as resolve, \
+                                mock.patch.object(cosmic_api, "do_set_report_columns") as write, \
+                                mock.patch.object(cosmic_api, "do_add_report_columns") as append, \
+                                mock.patch.object(report_ops, "_api_call") as http, \
+                                redirect_stdout(io.StringIO()) as output, redirect_stderr(io.StringIO()):
+                            self.assertNotEqual(cosmic_api.main(), 0)
+                            result = json.loads(output.getvalue())
+                            self.assertFalse(result["status"])
+                            self.assertEqual(result["errorCode"], "REPORT_INPUT_INVALID")
+                            self.assertIn("REPORT_PRECISION_REFERENCE_UNVERIFIED", result["message"])
+                            for boundary in (auth, load, resolve, write, append, http):
+                                boundary.assert_not_called()
+                            self.assertEqual(baseline.read_bytes(), original)
+
     def test_valid_payload_reaches_the_write_normalized(self):
         with mock.patch.object(cosmic_api, "do_register_report_plugin") as write:
             write.return_value = "kd.example.report.P"