@shundoo-ai/dsh-cosmic 1.0.21 → 1.0.22

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

@@ -12,7 +12,8 @@ from unittest import mock
 import pytest
 
 
-SCRIPT = Path(__file__).resolve().parents[1] / "render_output_cards.py"
+ROOT = Path(__file__).resolve().parents[2]
+SCRIPT = (ROOT / ".locales" / "zh" if os.environ.get("APP_BUILD_CARD_TEST_LOCALE") == "zh" else ROOT) / "scripts" / "render_output_cards.py"
 SPEC = importlib.util.spec_from_file_location("render_output_cards", SCRIPT)
 assert SPEC and SPEC.loader
 CARDS = importlib.util.module_from_spec(SPEC)
@@ -116,7 +117,7 @@ def test_cli_does_not_request_output_check_when_rendering_fails(capsys, tmp_path
 
 @pytest.mark.parametrize("locale", ["", ".locales/zh"])
 def test_loaded_skill_exposes_output_check_through_real_host_router(locale):
-    root = SCRIPT.parents[1]
+    root = ROOT
     program = """
 const { skillRelevantToolNames } = await import(process.argv[1] + "/src/tool/router.ts");
 const output = await Bun.file(process.argv[2]).text();
@@ -518,8 +519,68 @@ def test_card_carries_list_preview_url_and_degrades_silently(tmp_path: Path) ->
     assert "listUrl" not in handoff["forms"][0]
 
 
+@pytest.mark.parametrize('failure,status,reuse', [
+    (502, 'archived', True), (503, 'archived', True), (504, 'archived', True),
+    (403, 'unavailable', False), (400, 'unavailable', False),
+])
+def test_preview_fallback_is_scoped_and_has_explicit_evidence(tmp_path, failure, status, reuse):
+    from urllib.error import HTTPError
+    previous = {'title': 'Target', 'url': 'https://example.test/ierp/?formId=target',
+                'metadata': 'https://example.test/ierp/meta?formNumber=target'}
+    archive = tmp_path / 'archive.json'
+    archive.write_text(json.dumps({'formNumbers': [{'number': 'target', 'name': 'Target'}],
+        'artifacts': [previous], 'previewEvidence': {'other': {'status': 'fresh'}}}))
+    with mock.patch('kd_env_loader.load_effective_skill_config', return_value={'server': {'baseUrl': 'https://example.test/ierp'}}), \
+            mock.patch.object(CARDS, 'get_preview_url', side_effect=HTTPError('https://example.test', failure, 'failure', {}, None)) as preview:
+        blocks = CARDS.render(str(tmp_path), target_form_number='target')
+    card = json.loads(blocks[0].splitlines()[1])
+    assert card['url'] == (previous['url'] if reuse else '')
+    preview.assert_called_once()
+    saved = json.loads(archive.read_text())
+    assert saved['previewEvidence']['target']['status'] == status
+    assert saved['previewEvidence']['target']['runtimeVerified'] is False
+    assert saved['previewEvidence']['target']['listStatus'] == 'not-run'
+    assert saved['previewEvidence']['other']['status'] == 'fresh'
+    assert 'status' not in card and 'runtimeVerified' not in card
+
+
+@pytest.mark.parametrize('url', ['https://other.test/ierp/?formId=target',
+    'https://example.test/other/?formId=target', 'https://example.test/ierp-other/?formId=target',
+    'javascript:alert(1)', 'https://user:secret@example.test/ierp/?formId=target'])
+def test_archived_preview_never_crosses_environment_or_accepts_credentials(url):
+    assert CARDS._archived_preview_urls([{'url': url, 'metadata': 'https://example.test/meta?formNumber=target'}],
+                                       'https://example.test/ierp') == {}
+
+
+def test_business_preview_error_does_not_restore_old_link(tmp_path):
+    archive = tmp_path / 'archive.json'
+    archive.write_text(json.dumps({'formNumbers': [{'number': 'target', 'name': 'Target'}],
+        'previewEvidence': [], 'artifacts': [{'url': 'https://example.test/?formId=target',
+            'metadata': 'https://example.test/meta?formNumber=target'}]}))
+    with mock.patch('kd_env_loader.load_effective_skill_config', return_value={'server': {'baseUrl': 'https://example.test'}}), \
+            mock.patch.object(CARDS, 'get_preview_url', side_effect=CARDS.PreviewUrlError('PREVIEW_URL_LOOKUP_FAILED: denied')):
+        blocks = CARDS.render(str(tmp_path), target_form_number='target')
+    assert json.loads(blocks[0].splitlines()[1])['url'] == ''
+    assert json.loads(archive.read_text())['previewEvidence']['target']['status'] == 'unavailable'
+
+
+def test_cli_publishes_preview_evidence_without_leaking_previous_call(capsys, tmp_path):
+    block = ':::render:kdform\n{"title":"Target","url":""}\n:::'
+    def render(*args, **kwargs):
+        CARDS._PREVIEW_EVIDENCE = {'target': {'status': 'archived', 'runtimeVerified': False}}
+        return [block]
+    with mock.patch.object(sys, 'argv', [str(SCRIPT), '--app-root', str(tmp_path)]), \
+            mock.patch.object(CARDS, 'render', side_effect=render), mock.patch.object(CARDS, '_DYM_BACKGROUND_NOTICE', ''):
+        assert CARDS.main() == 0
+    assert 'PREVIEW_EVIDENCE=' in capsys.readouterr().out
+    with mock.patch.object(sys, 'argv', [str(SCRIPT), '--app-root', str(tmp_path)]), \
+            mock.patch.object(CARDS, 'render', return_value=[block]), mock.patch.object(CARDS, '_DYM_BACKGROUND_NOTICE', ''):
+        assert CARDS.main() == 0
+    assert 'PREVIEW_EVIDENCE=' not in capsys.readouterr().out
+
+
 def test_localized_card_cli_keeps_target_filter_contract() -> None:
-    localized = SCRIPT.parents[1] / ".locales" / "zh" / "scripts" / SCRIPT.name
+    localized = ROOT / ".locales" / "zh" / "scripts" / SCRIPT.name
     result = subprocess.run(
         [sys.executable, str(localized), "--help"],
         check=True,
@@ -530,3 +591,14 @@ def test_localized_card_cli_keeps_target_filter_contract() -> None:
     assert "--form-number" in result.stdout
     assert "--form-name" in result.stdout
     assert "repeat for" in result.stdout and "multiple forms" in result.stdout
+
+
+def test_localized_renderer_runs_regressions_in_its_own_process():
+    """中文运行树在独立进程中跑同一组回归，避免复用 canonical 的模块缓存。"""
+    if os.environ.get("APP_BUILD_CARD_TEST_LOCALE") == "zh":
+        pytest.skip("已在中文独立进程中")
+    result = subprocess.run([sys.executable, "-m", "pytest", str(Path(__file__).resolve()),
+        "-q", "-k", "not test_localized_renderer_runs_regressions_in_its_own_process"],
+        cwd=ROOT, env={**os.environ, "APP_BUILD_CARD_TEST_LOCALE": "zh"},
+        capture_output=True, text=True, encoding="utf-8", timeout=60)
+    assert result.returncode == 0, result.stdout + result.stderr

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

@@ -99,6 +99,18 @@ class ReportBusinessContractTest(unittest.TestCase):
                 cosmic_api._execute_report_pipeline({}, "token", artifact, "APP-ID", "UNIT-ID")
         create_page.assert_not_called()
 
+    def test_default_sort_preflight_fails_before_create_page(self):
+        for plugins, sort_key, error in (([], "a", "REPORT_DEFAULT_SORT_PLUGIN_REQUIRED"),
+                                         ([{"className": "kd.test.P", "enabled": False}], "a", "REPORT_DEFAULT_SORT_PLUGIN_REQUIRED"),
+                                         ([{"className": "kd.test.P"}], "missing", "sort columns not found")):
+            artifact = self._dym_artifact()
+            artifact["reportPlugins"] = plugins
+            artifact["reportSorts"][0]["fieldKey"] = sort_key
+            with self.subTest(plugins=plugins, key=sort_key), mock.patch.object(cosmic_api, "do_create_page") as create:
+                with self.assertRaisesRegex(ValueError, error):
+                    cosmic_api._execute_report_pipeline({}, "token", artifact, "APP", "UNIT")
+                create.assert_not_called()
+
     def test_data_source_write_surface_is_gone(self) -> None:
         for name in ("normalize_data_source_input", "add_data_source"):
             self.assertFalse(hasattr(report_ops, name), name)
@@ -251,23 +263,32 @@ class ReportBusinessContractTest(unittest.TestCase):
                 "reportSorts": [{"fieldKey": "a", "direction": "desc"}],
                 "reportPlugins": [{"className": "kd.uhyl.report.P", "enabled": True}],
             }),
+            tempfile.TemporaryDirectory() as root,
         ):
             result = cosmic_api._execute_report_pipeline(
-                {}, "token", self._dym_artifact(), "APP-ID", "UNIT-ID", app_root="/tmp/app")
+                {}, "token", self._dym_artifact(), "APP-ID", "UNIT-ID", app_root=root)
+            persisted = json.loads(Path(result["reportPluginContract"]["path"]).read_text(encoding="utf-8"))
+            self.assertEqual(persisted["defaultSorts"], result["reportDefaultSorts"]["requirements"])
+            self.assertFalse(persisted["defaultSortPolicy"]["runtimeVerified"])
 
         # The invariant is the order, not the exact call list: the export is synced after every
         # write, so it cannot be older than what it is used to prove.
         sync_at = calls.index("syncDym")
-        for write in ("columns", "sorts", "plugin"):
+        self.assertNotIn("sorts", calls)
+        for write in ("columns", "plugin"):
             self.assertLess(calls.index(write), sync_at, f"{write} ran after the sync")
         self.assertEqual("syncDym", calls[-1])
-        # Both sections the layout cannot carry are now proved, so verification is real.
+        # 只证明元数据列和插件；默认排序要求被保留，但运行时仍未验证。
         self.assertEqual("formLayout+dym", result["readBackSource"])
         self.assertTrue(result["verification"]["verified"])
         self.assertEqual(
-            {"reportColumns", "reportSorts", "reportPlugins"},
+            {"reportColumns", "reportPlugins"},
             {check["section"] for check in result["verification"]["checks"]},
         )
+        self.assertEqual(result["reportDefaultSorts"]["requirements"], [
+            {"fieldKey": "a", "dateIndex": "a", "direction": "desc"}])
+        self.assertFalse(result["reportDefaultSorts"]["runtimeVerified"])
+        self.assertFalse(result["reportDefaultSorts"]["metadataWritten"])
 
     def test_pipeline_survives_a_failed_design_state_sync(self) -> None:
         """Design-state evidence is additive; losing it must not fail a successful write."""
@@ -282,9 +303,10 @@ class ReportBusinessContractTest(unittest.TestCase):
                               return_value=self._derived_schema()),
             mock.patch.object(cosmic_api, "_export_report_dym_evidence",
                               side_effect=RuntimeError("sync root not configured")),
+            tempfile.TemporaryDirectory() as root,
         ):
             result = cosmic_api._execute_report_pipeline(
-                {}, "token", self._dym_artifact(), "APP-ID", "UNIT-ID", app_root="/tmp/app")
+                {}, "token", self._dym_artifact(), "APP-ID", "UNIT-ID", app_root=root)
 
         self.assertTrue(result["ok"])
         self.assertEqual("formLayout", result["readBackSource"])

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

@@ -10,8 +10,13 @@ Every failure this file guards against has already happened at least once:
   contract rejects;
 - guidance to call `setFieldType(ReportColumn.TYPE_AMOUNT)`, a constant name that appears
   nowhere in the knowledge base;
-- a documented `id` / `pid` DataSet-column convention for tree reports, which no API page
-  supports.
+- an `id` / `pid` DataSet-column convention for tree reports, where the standard product's tree
+  reports carry `rowid` / `pid` / `isgroupnode`;
+- a left-tree example registering its tree plugin as a second `reportPlugins` entry, which is
+  the report list's data-fetch slot, on a template that has no left tree;
+- a left-tree example created from `bos_grouprpttpl` as if it were a left-tree template. It is
+  the grouped report, and no public template presets a left tree: one exists only after a user
+  adds the report tree control, so a creation Artifact cannot declare `reportProperties.tree`.
 
 Prose is not tested here. What is tested is every place where documentation restates a value
 the implementation owns, because that is where the two silently drift apart.
@@ -25,6 +30,8 @@ import unittest
 from pathlib import Path
 
 APP_BUILD_ROOT = Path(__file__).resolve().parents[2]
+if APP_BUILD_ROOT.name == "zh" and APP_BUILD_ROOT.parent.name == ".locales":
+    APP_BUILD_ROOT = APP_BUILD_ROOT.parent.parent
 ZH_ROOT = APP_BUILD_ROOT / ".locales" / "zh"
 
 VALIDATOR = APP_BUILD_ROOT / "skills/cosmic-meta-modeling/scripts/report_validator.py"
@@ -66,8 +73,8 @@ EMITTED_RULE = re.compile(r'rule="(R-[a-z-]+)"')
 # and in the sentence-boundary pattern below are matcher input, not prose.
 _DENIAL_MARKERS = (
     "no longer exists", "no documented", "not invent", "do not", "does not", "never",
-    "removed", "rejected", "refuse", "cannot",
-    "已不存在", "不存在", "没有", "不要", "禁止", "不再", "无法", "拒绝",
+    "removed", "rejected", "refuse", "cannot", "blocked",
+    "已不存在", "不存在", "没有", "不要", "禁止", "不再", "无法", "拒绝", "阻断",
 )
 
 
@@ -171,12 +178,53 @@ class CommandTableTest(unittest.TestCase):
             table = [line for line in _read(path).splitlines() if line.startswith("| ")]
             referenced = {
                 name for line in table
-                for name in re.findall(r"`(set[A-Za-z]+|register[A-Za-z]+|plan[A-Za-z]+|deleteForm|run)`", line)
+                for name in re.findall(r"`((?:set|add|remove|register|plan)[A-Za-z]+|deleteForm|run)`", line)
             }
             with self.subTest(doc=path.name):
                 self.assertTrue(referenced, f"{path}: no command found in the table")
                 unknown = sorted(referenced - published - routed)
                 self.assertEqual(unknown, [], f"{path} advertises unpublished commands")
+                self.assertIn("addReportColumns", referenced)
+                self.assertIn("removeReportColumn", referenced)
+
+    def test_unsafe_sort_writer_is_only_documented_as_blocked(self):
+        self.assertEqual(self.contracts["commands"]["setReportSorts"]["availability"], "blocked")
+        self.assertEqual(self.contracts["designStateEvidence"]["provenSections"], ["reportPlugins"])
+        checked = 0
+        for path in _report_doc_paths():
+            text = _read(path)
+            for match in re.finditer(r"`setReportSorts`", text):
+                checked += 1
+                with self.subTest(doc=str(path)):
+                    self.assertTrue(_denied_near(text, match.start(), match.end()),
+                                    f"{path} advertises the unsafe sort writer")
+        self.assertGreater(checked, 0)
+        for relative in ("skills/cosmic-meta-modeling/modules/report/SKILL.md",
+                         "skills/cosmic-meta-modifier/modules/report-op/SKILL.md",
+                         "knowledge/cosmic/platform/reportlistdata-plugin.md"):
+            for root in (APP_BUILD_ROOT, ZH_ROOT):
+                with self.subTest(tree=root.name, doc=relative):
+                    text = _read(root / relative)
+                    self.assertIn("defaultSorts", text)
+                    self.assertIn("defaultSortPolicy", text)
+
+    def test_column_removal_has_one_strict_payload_and_release_boundary(self):
+        removal = json.loads(_read(WRITE_SCHEMA))["$defs"]["columnRemoval"]
+        self.assertEqual(removal["required"], ["fieldKey"])
+        self.assertFalse(removal["additionalProperties"])
+        self.assertEqual(set(removal["properties"]), {"fieldKey"})
+        contract = self.contracts["commands"]["removeReportColumn"]
+        self.assertTrue(contract["payloadSchemaRef"].endswith("#/$defs/columnRemoval"))
+        self.assertIn("ReportColumns.remove", contract["writeSemantics"])
+        self.assertIn("REPORT_COLUMN_DELETE_API_UNAVAILABLE", contract["compatibility"])
+        self.assertIn("removeReportColumn", self.contracts["columnChangeRoute"]["remove"])
+        for root in (APP_BUILD_ROOT, ZH_ROOT):
+            for relative in ("skills/cosmic-meta-modifier/modules/report-op/SKILL.md",
+                             "skills/cosmic-meta-modeling/modules/report/SKILL.md"):
+                with self.subTest(tree=root.name, doc=relative):
+                    text = _read(root / relative)
+                    self.assertIn("removeReportColumn", text)
+                    self.assertIn("REPORT_COLUMN_DELETE_API_UNAVAILABLE", text)
 
     def test_a_removed_command_is_only_ever_mentioned_to_warn_against_it(self):
         removed = set(self.contracts.get("removedCommands") or {})
@@ -216,6 +264,7 @@ class CommandTableTest(unittest.TestCase):
         """
         message = _block(_read(REPORT_OPS), "_REPORT_COLUMNS_ALREADY_SET = (")
         self.assertIn("addReportColumns", message)
+        self.assertIn("removeReportColumn", message)
         self.assertIn("planReportRecreate", message)
         self.assertIn("designer", message)
         self.assertTrue(_denied_near(message, message.index("designer"),
@@ -336,7 +385,12 @@ class PresentationContractTest(unittest.TestCase):
 
 
 class TreeSemanticsTest(unittest.TestCase):
-    """Two features are called tree, and neither has an id/pid DataSet convention."""
+    """Two features are called tree, and each has its own plugin shape and slot.
+
+    Collapsible rows are one row set whose DataSet carries rowid / pid / isgroupnode, as the
+    standard product's tree reports build it; an id / pid convention is only ever named to warn
+    against it. Left-tree navigation is a second plugin on the left tree's own slot.
+    """
 
     def test_no_document_claims_an_id_pid_dataset_convention(self):
         pattern = re.compile(r"`id`\s*(?:\+|/|and|与|和)\s*`pid`")
@@ -348,11 +402,49 @@ class TreeSemanticsTest(unittest.TestCase):
                 with self.subTest(doc=path.name):
                     self.assertTrue(
                         _denied_near(text, match.start(), match.end()),
-                        f"{path} states an id/pid DataSet convention without denying it; no "
-                        "API page supports one",
+                        f"{path} states an id/pid DataSet convention without denying it; "
+                        "collapsible tree rows carry rowid / pid / isgroupnode",
                     )
         self.assertGreater(checked, 0, "the id/pid scan matched nothing; the pattern is stale")
 
+    def test_collapsible_rows_name_the_row_columns_in_both_trees(self):
+        for relative in ("references/plugin-runtime-routing.md",
+                         "skills/cosmic-meta-knowledge/generation/report-modeling-guide.md",
+                         "knowledge/cosmic/platform/reportlistdata-plugin.md"):
+            for root in (APP_BUILD_ROOT, ZH_ROOT):
+                text = _read(root / relative)
+                for column in ("`rowid`", "`pid`", "`isgroupnode`"):
+                    with self.subTest(doc=relative, tree=root.name, column=column):
+                        self.assertIn(column, text)
+
+    def test_the_left_tree_example_registers_the_tree_plugin_on_the_tree(self):
+        """reportPlugins is the report list's data-fetch slot, and no template has a left tree."""
+        relative = "skills/cosmic-meta-modeling/modules/report/examples/golden-example-report-tree.md"
+        for root in (APP_BUILD_ROOT, ZH_ROOT):
+            text = _read(root / relative)
+            artifacts = [json.loads(block) for block in re.findall(
+                r"```json\s*\n(.*?)\n```", text, re.DOTALL)]
+            artifact = next(item for item in artifacts if item.get("reportColumns"))
+            with self.subTest(tree=root.name):
+                self.assertEqual(artifact["templateNumber"], "bos_rpttpl")
+                self.assertEqual(len(artifact["reportPlugins"]), 1)
+                self.assertNotIn("tree", artifact.get("reportProperties") or {})
+                # The tree plugin is written after the user adds the report tree control.
+                self.assertIn("--target tree", text)
+                self.assertIn('"ReportPlugin": "kd.kdtest.report.CostAnalysisTreePlugin"', text)
+
+    def test_no_document_calls_the_grouped_template_a_left_tree(self):
+        """bos_grouprpttpl is the grouped report (group panel + group list), not a left tree."""
+        pattern = re.compile(r"left-tree template|左树模板")
+        for path in _report_doc_paths():
+            text = _read(path)
+            for match in pattern.finditer(text):
+                with self.subTest(doc=path.name):
+                    self.assertTrue(
+                        _denied_near(text, match.start(), match.end()),
+                        f"{path} names a left-tree template; none exists",
+                    )
+
     def test_routing_uses_registered_report_types(self):
         routing = _read(APP_BUILD_ROOT / "references/plugin-runtime-routing.md")
         types = {entry["type"] for entry in json.loads(
@@ -432,7 +524,8 @@ class ReadBackTierTest(unittest.TestCase):
 
     def test_contract_documents_every_tier_the_implementation_can_return(self):
         documented = set(json.loads(_read(WRITE_CONTRACTS))["readBackSource"])
-        self.assertEqual(documented, {"canonical", "formLayout", "formLayout+dym", "unavailable"})
+        self.assertEqual(documented, {"canonical", "formLayout", "formLayout+dym",
+                                     "reportFilterProjection", "unavailable"})
         source = _read(REPORT_OPS)
         for tier in documented:
             with self.subTest(tier=tier):
@@ -454,8 +547,7 @@ class PipelineStepCountTest(unittest.TestCase):
         steps = set(re.findall(r"Step (\d)/(\d): ", cli))
         self.assertTrue(steps)
         totals = {total for _index, total in steps}
-        # 7 = the six create-time writes plus the report property section, which is applied
-        # last so it settles ShowFilterFields after the filter write.
+        # 七步包含默认排序契约保留；属性仍最后结算过滤写入后的 ShowFilterFields。
         self.assertEqual(totals, {"7"}, "the report pipeline no longer has exactly 7 steps")
         skill = _read(APP_BUILD_ROOT / "skills/cosmic-meta-modeling/modules/report/SKILL.md")
         ordered = re.search(r"`run` executes the fixed platform dependency order internally:(.+?)\n\n",

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

@@ -35,6 +35,7 @@ import render_output_cards as cards
 
 REPORT = "kdtest_ljbb"
 FQCN = "kd.test.guaner.report.LjbbReportPlugin"
+TREE_FQCN = "kd.test.guaner.report.LjbbTreePlugin"
 
 
 def _write(path: Path, payload) -> None:
@@ -46,7 +47,7 @@ class _Root:
     """An appRoot carrying the defect's exact shape: report archived, plugin registered."""
 
     def __init__(self, stack, *, javas=None, contract=True, plugin_classes=(FQCN,),
-                 source_on_disk=False):
+                 source_on_disk=False, plugin_types=None):
         self.path = Path(stack.enter_context(TemporaryDirectory()))
         self.archive = {"formNumbers": [{"name": "lj report", "number": REPORT}]}
         if javas is not None:
@@ -59,18 +60,18 @@ class _Root:
             self.source = str(source)
         _write(self.path / "archive.json", self.archive)
         if contract:
-            _write(
-                self.path / "_runtime" / f"{REPORT}.report-plugin-contract.json",
-                {
-                    "schemaVersion": "app-build-report-plugin-contract/v1",
-                    "formNumber": REPORT,
-                    "pluginClasses": list(plugin_classes),
-                    "dataSetColumns": ["billno", "createtime", "creator_phone"],
-                    "dataSetColumnTypes": [{"dateIndex": "billno", "javaType": "String"}],
-                    "columnPresentation": [],
-                    "filterEnforcement": [],
-                },
-            )
+            payload = {
+                "schemaVersion": "app-build-report-plugin-contract/v1",
+                "formNumber": REPORT,
+                "pluginClasses": list(plugin_classes),
+                "dataSetColumns": ["billno", "createtime", "creator_phone"],
+                "dataSetColumnTypes": [{"dateIndex": "billno", "javaType": "String"}],
+                "columnPresentation": [],
+                "filterEnforcement": [],
+            }
+            if plugin_types is not None:
+                payload["pluginTypes"] = plugin_types
+            _write(self.path / "_runtime" / f"{REPORT}.report-plugin-contract.json", payload)
 
     def undelivered(self):
         return cards.undelivered_report_plugins(str(self.path), [REPORT], self.archive)
@@ -130,6 +131,22 @@ class GateTest(unittest.TestCase):
         self.assertEqual(
             cards.undelivered_report_plugins(str(root.path), ["kdtest_other"], root.archive), [])
 
+    def test_each_missing_class_names_the_type_its_slot_runs(self):
+        """A left-tree report registers two classes on two slots with two base classes.
+
+        The refusal used to send every missing class to type reportlist, which for the tree class
+        is the wrong base class and the wrong query signature.
+        """
+        missing = _Root(self.stack, plugin_classes=(FQCN, TREE_FQCN), plugin_types={
+            FQCN: "reportlist", TREE_FQCN: "reporttreelist"}).undelivered()
+        self.assertEqual({item["className"]: item["type"] for item in missing},
+                         {FQCN: "reportlist", TREE_FQCN: "reporttreelist"})
+
+    def test_a_contract_without_plugin_types_means_data_fetch_plugins(self):
+        """Contracts written before pluginTypes existed registered reportPlugins entries only."""
+        missing = _Root(self.stack).undelivered()
+        self.assertEqual(missing[0]["type"], "reportlist")
+
 
 class RenderRefusesTest(unittest.TestCase):
     """The gate has to stop the cards, not just be available to callers."""
@@ -148,6 +165,17 @@ class RenderRefusesTest(unittest.TestCase):
         self.assertIn("java-plugin-delivery", message)
         self.assertNotIn(":::render:", message)
 
+    def test_the_refusal_names_the_delivery_type_of_each_class(self):
+        root = _Root(self.stack, plugin_classes=(FQCN, TREE_FQCN), plugin_types={
+            FQCN: "reportlist", TREE_FQCN: "reporttreelist"})
+        with self.assertRaises(cards.ReportPluginSourceMissing) as caught:
+            cards.render(str(root.path))
+        lines = str(caught.exception).splitlines()
+        tree_line = next(line for line in lines if TREE_FQCN in line)
+        self.assertIn("as type reporttreelist", tree_line)
+        list_line = next(line for line in lines if FQCN in line and TREE_FQCN not in line)
+        self.assertIn("as type reportlist", list_line)
+
     def test_refusal_happens_before_the_archive_is_rewritten(self):
         """Failing after writing artifacts back would record a delivery that did not happen."""
         root = _Root(self.stack)
@@ -196,13 +224,15 @@ class MirrorParityTest(unittest.TestCase):
         return ast.dump(tree)
 
     def test_the_gate_is_identical_in_both_trees(self):
-        main = SCRIPTS / "render_output_cards.py"
-        mirror = SCRIPTS.parent / ".locales/zh/scripts/render_output_cards.py"
+        app_root = SCRIPTS.parents[2] if SCRIPTS.parent.parent.name == ".locales" else SCRIPTS.parent
+        main = app_root / "scripts/render_output_cards.py"
+        mirror = app_root / ".locales/zh/scripts/render_output_cards.py"
         self.assertTrue(mirror.is_file(), f"{mirror} is missing")
         self.assertEqual(self._skeleton(main), self._skeleton(mirror))
 
     def test_the_mirror_exposes_the_same_gate_api(self):
-        source = (SCRIPTS.parent / ".locales/zh/scripts/render_output_cards.py").read_text(
+        app_root = SCRIPTS.parents[2] if SCRIPTS.parent.parent.name == ".locales" else SCRIPTS.parent
+        source = (app_root / ".locales/zh/scripts/render_output_cards.py").read_text(
             encoding="utf-8")
         for name in ("ReportPluginSourceMissing", "undelivered_report_plugins",
                      "_refuse_undelivered", "REPORT_PLUGIN_SOURCE_MISSING"):

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

@@ -13,8 +13,8 @@ guard below exists because the platform would not report the mistake:
   persist, so "this source cannot see it" must never be reported as a failed write;
 - the design-state export omits any value equal to the platform default, so an absent node
   proves the default rather than a lost write;
-- ShowFilterFields is written by setReportFilters too, as a comma-joined string the runtime
-  cannot parse, so the repair must not read as a no-op just because the key list is unchanged;
+- 旧部署的 setReportFilters 曾写入运行时无法解析的逗号字符串，当前附件已使用 JSON；
+  修复历史 ShowFilterFields 时，不能因 key 列表相同就把格式迁移判为 no-op；
 - ReportPluginExt is a full replacement whose accessor carries a doubled r, so a merge composed
   without reading rreportPluginExt would silently drop every plugin already registered.
 """
@@ -69,7 +69,6 @@ class TargetResolutionTest(unittest.TestCase):
             "filterPanel": ("reportfilterap", "ReportFilterAp", "ReportFilterPanel"),
             "moreFilterPanel": ("reportmorefilterpanelap", "ReportMoreFilterPanelAp",
                                 "ReportMoreFilterPanel"),
-            "tree": ("reporttreeap", "ReportTreeAp", "ReportTree"),
         }
         for name, (element, host, complex_type) in expected.items():
             spec = _target(name)
@@ -81,6 +80,17 @@ class TargetResolutionTest(unittest.TestCase):
     def test_the_form_target_writes_the_root_control_whose_key_is_the_form_number(self) -> None:
         self.assertEqual(_target("form")["elementKey"], FORM)
 
+    def test_the_tree_target_has_no_fixed_key_because_a_user_names_the_control(self) -> None:
+        spec = _target("tree")
+        self.assertIsNone(spec["elementKey"])
+        self.assertEqual(spec["hostType"], "ReportTreeAp")
+        self.assertEqual(spec["complexType"], "ReportTree")
+        self.assertEqual(_target("tree", "my_tree", "ReportTreeAp")["elementKey"], "my_tree")
+
+    def test_a_tree_element_of_another_type_is_refused(self) -> None:
+        with self.assertRaisesRegex(ValueError, "writes a ReportTreeAp"):
+            _target("tree", "reportlistap", "ReportListAp")
+
     def test_a_column_target_without_an_element_is_refused(self) -> None:
         with self.assertRaisesRegex(ValueError, "needs --element"):
             _target("column")
@@ -164,7 +174,7 @@ class AllowListTest(unittest.TestCase):
             "ReportPluginExt": "registerReportPluginExt",
             "ReportQueryPlugin": "registerReportPlugin",
             "ReportColumns": "addReportColumns",
-            "InitField": "setReportSorts",
+            "InitField": "default column visibility, not sorting",
         }
         for key, owner in cases.items():
             with self.assertRaisesRegex(ValueError, owner):
@@ -174,7 +184,7 @@ class AllowListTest(unittest.TestCase):
         payload = _normalize("filterPanel", {"ShowFilterFields": ["flt_a", "flt_b"]})
         self.assertEqual(json.loads(payload["ShowFilterFields"]), ["flt_a", "flt_b"])
 
-    def test_show_filter_fields_refuses_the_comma_string_the_platform_writes(self) -> None:
+    def test_show_filter_fields_refuses_the_legacy_comma_string_as_write_input(self) -> None:
         with self.assertRaisesRegex(ValueError, "must be a non-empty array"):
             _normalize("filterPanel", {"ShowFilterFields": "flt_a,flt_b"})
 
@@ -192,7 +202,7 @@ class ValueComparisonTest(unittest.TestCase):
         self.assertFalse(report_ops._values_match(report_ops._KIND_BOOL, True, "true"))
 
     def test_both_persisted_forms_of_show_filter_fields_read_as_the_same_key_list(self) -> None:
-        """setReportFilters writes the comma form; this command writes the JSON form."""
+        """读回兼容旧逗号值和 JSON；兼容读取不代表当前 writer 仍写逗号。"""
         self.assertTrue(report_ops._values_match(
             report_ops._KIND_IDENTIFIER_LIST, '["a","b"]', "a,b"))
 
@@ -233,7 +243,13 @@ class ReadBackKeyTest(unittest.TestCase):
         self.assertNotIn("Merge", observed)
 
 
-def _write_backend(before, after, *, expect_complex_type=None, recorder=None):
+_CONTROLS = [
+    {"key": "total_amount", "type": "EntryFieldAp", "category": "control"},
+    {"key": "amt_group", "type": "EntryFieldGroupAp", "category": "control"},
+]
+
+
+def _write_backend(before, after, *, expect_complex_type=None, recorder=None, controls=()):
     """A backend that answers the pre-read, the write and the post-read in that order."""
     state = {"written": False}
 
@@ -251,10 +267,7 @@ def _write_backend(before, after, *, expect_complex_type=None, recorder=None):
             state["written"] = True
             return {"status": True, "errorCode": "0"}
         if endpoint == "listElements":
-            return {"status": True, "errorCode": "0", "data": [
-                {"key": "total_amount", "type": "EntryFieldAp", "category": "control"},
-                {"key": "amt_group", "type": "EntryFieldGroupAp", "category": "control"},
-            ]}
+            return {"status": True, "errorCode": "0", "data": _CONTROLS + list(controls)}
         raise AssertionError(f"unexpected endpoint {endpoint}")
 
     return call
@@ -299,17 +312,63 @@ class WriteVerdictTest(unittest.TestCase):
             with self.assertRaisesRegex(RuntimeError, "REPORT_PROPERTY_MISMATCH"):
                 report_ops.set_report_properties({}, "t", FORM, "list", {"ShowSeq": False})
 
-    def test_a_host_resolving_none_of_the_keys_is_refused_before_the_write(self) -> None:
-        """A report with no left tree would otherwise report a successful no-op."""
+    def test_a_report_without_a_tree_control_is_refused_before_the_write(self) -> None:
+        """No public template presets one; a write would otherwise report a successful no-op."""
         recorder = []
         call = _write_backend({}, {}, recorder=recorder)
         with _platform(call):
-            with self.assertRaisesRegex(ValueError, "REPORT_PROPERTY_ELEMENT_MISMATCH"):
+            with self.assertRaisesRegex(ValueError,
+                                        "REPORT_PROPERTY_ELEMENT_MISMATCH: .* no ReportTreeAp"):
+                report_ops.set_report_properties(
+                    {}, "t", FORM, "tree", {"LeafNodeQuery": False})
+        self.assertEqual([endpoint for endpoint, _ in recorder
+                          if endpoint in ("getProperties", "setComplexProperty")], [])
+
+    def test_a_host_resolving_none_of_the_keys_is_refused_before_the_write(self) -> None:
+        recorder = []
+        call = _write_backend({}, {}, recorder=recorder,
+                              controls=[{"key": "my_tree", "type": "ReportTreeAp"}])
+        with _platform(call):
+            with self.assertRaisesRegex(ValueError, "REPORT_PROPERTY_ELEMENT_MISMATCH: 'my_tree'"):
                 report_ops.set_report_properties(
                     {}, "t", FORM, "tree", {"LeafNodeQuery": False})
         self.assertEqual([endpoint for endpoint, _ in recorder if endpoint == "setComplexProperty"],
                          [])
 
+    def test_a_tree_is_found_by_its_type_whatever_key_the_user_gave_it(self) -> None:
+        recorder = []
+        call = _write_backend({"LeafNodeQuery": True}, {"LeafNodeQuery": False},
+                              expect_complex_type="ReportTree", recorder=recorder,
+                              controls=[{"key": "my_tree", "type": "ReportTreeAp"}])
+        with _platform(call):
+            result = report_ops.set_report_properties(
+                {}, "t", FORM, "tree", {"LeafNodeQuery": False})
+        self.assertTrue(result["verified"])
+        self.assertEqual((result["elementKey"], result["hostType"]), ("my_tree", "ReportTreeAp"))
+        self.assertEqual({p["elementKey"] for e, p in recorder if e == "getProperties"},
+                         {"my_tree"})
+        write = next(p for e, p in recorder if e == "setComplexProperty")
+        self.assertEqual(write["elementKey"], "my_tree")
+
+    def test_several_tree_controls_need_element_to_name_one(self) -> None:
+        trees = [{"key": "tree_a", "type": "ReportTreeAp"},
+                 {"key": "tree_b", "type": "ReportTreeAp"}]
+        call = _write_backend({"LeafNodeQuery": True}, {"LeafNodeQuery": False}, controls=trees)
+        with _platform(call):
+            with self.assertRaisesRegex(ValueError, "several ReportTreeAp controls"):
+                report_ops.set_report_properties(
+                    {}, "t", FORM, "tree", {"LeafNodeQuery": False})
+            result = report_ops.set_report_properties(
+                {}, "t", FORM, "tree", {"LeafNodeQuery": False}, element_key="tree_b")
+        self.assertEqual(result["elementKey"], "tree_b")
+
+    def test_a_tree_element_naming_another_control_is_refused(self) -> None:
+        call = _write_backend({}, {}, controls=[{"key": "my_tree", "type": "ReportTreeAp"}])
+        with _platform(call):
+            with self.assertRaisesRegex(ValueError, "is not a ReportTreeAp"):
+                report_ops.set_report_properties(
+                    {}, "t", FORM, "tree", {"LeafNodeQuery": False}, element_key="total_amount")
+
     def test_a_write_of_only_unobservable_keys_is_not_reported_as_verified(self) -> None:
         """An empty read-back is never a passing one."""
         call = _write_backend({}, {})
@@ -333,7 +392,7 @@ class WriteVerdictTest(unittest.TestCase):
         write = next(p for e, p in recorder if e == "setComplexProperty")
         self.assertEqual(write["elementKey"], "total_amount")
 
-    def test_only_a_column_write_carries_an_element_key(self) -> None:
+    def test_a_fixed_host_write_carries_no_element_key(self) -> None:
         recorder = []
         call = _write_backend({"ShowSeq": True}, {"ShowSeq": False}, recorder=recorder)
         with _platform(call):