@shundoo-ai/dsh-cosmic 1.0.21 → 1.0.22

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

@@ -45,6 +45,7 @@ def _readback(
             "menu": {
                 "menuId": "MENU-ID",
                 "name": "测试菜单",
+                "description": "测试菜单",
                 "menuType": entity_type,
                 "formNumber": form_number,
                 "openType": "MainNewTabPage",
@@ -73,6 +74,21 @@ def test_add_menu_defaults_bill_to_list_and_verifies_readback() -> None:
     assert result["data"]["verified"] is True
     add_payload = api.call_args_list[1].args[3]
     assert add_payload["parameterType"] == "ListShowParameter"
+    assert add_payload["description"] == "测试菜单"
+
+
+def test_add_menu_preserves_explicit_description_and_refuses_null_readback():
+    for actual, verified in (("说明", True), (None, False)):
+        readback = _readback(None, form_number=None)
+        readback["data"]["menu"]["description"] = actual
+        with mock.patch.object(APPS, "_api_call", side_effect=[_write(), readback]) as api:
+            result = APPS.do_add_menu({}, "token", "APP-ID", "测试菜单",
+                                      menu_type="category", description="说明")
+        assert api.call_args_list[0].args[3]["description"] == "说明"
+        assert result["status"] is verified
+        if not verified:
+            assert result["errorCode"] == "MENU_WRITE_VERIFY_FAILED"
+            assert any("description" in error for error in result["data"]["errors"])
 
 
 def test_add_menu_defaults_non_list_form_to_form_entry() -> None:

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

@@ -139,10 +139,24 @@ def test_failed_child_query_preserves_underlying_error(tmp_path, capsys):
         "print(json.dumps({'status': False, 'errorCode': 'APP_ROOT_IDENTITY_INVALID'}))\n"
         "sys.exit(2)\n"
     )
-    assert emitter._run_cosmic_api(str(script), "queryPublicTemplates", {}, app_root=tmp_path) is None
+    assert emitter._run_cosmic_api(str(script), "queryPublicTemplates", {}, app_root=tmp_path)["errorCode"] == "APP_ROOT_IDENTITY_INVALID"
     assert "APP_ROOT_IDENTITY_INVALID" in capsys.readouterr().err
 
 
+def test_template_lookup_stops_at_environment_failure_without_mislabeling_input(monkeypatch, tmp_path):
+    calls = []
+    def read(*args, **kwargs):
+        calls.append(args)
+        return {"status": False, "errorCategory": "environment", "errorCode": "SKILL_REVISION_MISMATCH",
+                "message": "Use the current installed source"}
+    monkeypatch.setattr(emitter, "_run_cosmic_api", read)
+    logs = emitter._Logs(tmp_path)
+    section = {"artifact": {"entities": [{"type": "BillEntity", "bizName": "request", "templateKey": "bos_billtpl"}]}}
+    assert emitter._validate_template_keys(section, logs, "cosmic_api.py", app_root=tmp_path) is False
+    assert len(calls) == 1
+    assert logs.error_details[0]["code"] == "SKILL_REVISION_MISMATCH"
+
+
 def test_template_query_normalizes_legacy_model_type(monkeypatch):
     calls = []
     monkeypatch.setattr(cmd_forms, "_api_call", lambda *args, **kwargs: calls.append(args) or {
@@ -154,6 +168,21 @@ def test_template_query_normalizes_legacy_model_type(monkeypatch):
     assert calls[1][3] == {"modelType": "BaseFormModel", "bizAppNumber": "demo"}
 
 
+def test_compiler_forwards_before_generating_files(tmp_path, monkeypatch, capfd):
+    import execution_binding
+    selected = tmp_path / "selected compiler.py"
+    selected.write_text('import json,sys\nprint(json.dumps({"argv":sys.argv[1:]}))\n')
+    source = tmp_path / "request.json"
+    source.write_text('{"artifact":{"entities":[]}}')
+    original = source.read_bytes()
+    arguments = ["--app-root", str(tmp_path), "--authoring-file", str(source)]
+    monkeypatch.setattr(execution_binding, "bound_entrypoint", lambda *args: selected)
+    assert emitter.main(arguments) == 0
+    assert json.loads(capfd.readouterr().out)["argv"] == arguments
+    assert source.read_bytes() == original
+    assert not (tmp_path / "_runtime").exists()
+
+
 @pytest.mark.parametrize("kind,expected", [("BillEntity", "bos_billtpl"), ("BaseEntity", "bos_basetpl"), ("MainEntity", None), ("EntryEntity", None)])
 def test_default_template_only_for_entity_roots(kind, expected):
     data = {"artifact": {"entities": [{"type": kind}]}}
@@ -246,3 +275,28 @@ def test_builtin_carry_uses_declared_target_without_overwriting_explicit_referen
     assert builtin["reference"] == {"mode": "platform", "formNumber": "bd_customer"}
     assert explicit["reference"]["formNumber"] == "user_selected"
     assert "reference" not in plain
+
+
+def test_explicit_blank_bill_preserves_fields_and_emits_blank_template(monkeypatch, tmp_path):
+    entity = {"type": "BillEntity", "bizName": "blankbill", "displayName": "Blank bill", "templateKey": "blankPage", "fields": [
+        {"bizWord": "description", "displayName": "Description", "dataType": "TextField"},
+    ]}
+    section = {"artifact": {"entities": [entity]}, "assumptions": []}
+    (tmp_path / "archive.json").write_text(json.dumps({"isvNumber": "demo", "appCode": "sample", "standard": False}))
+    monkeypatch.setattr(emitter, "_run_cosmic_api", lambda *args, **kwargs: {
+        "status": True, "data": {"success": True, "templates": [{"number": "blankPage", "name": "空白页面", "modelType": "BillFormModel"}]},
+    })
+    logs = emitter._Logs(tmp_path)
+    assert emitter._validate_template_keys(section, logs, "unused", app_root=tmp_path)
+    with patch.object(emitter, "_call_get_entity_fields") as get_preset:
+        emitter._merge_template_fields(section, logs, "unused", app_root=tmp_path)
+    get_preset.assert_not_called()
+    assert entity["fields"][0]["bizWord"] == "description"
+    files, manifest, _ = emitter.assemble_artifact_emit(section, tmp_path, "blank-bill", logs)
+    assert not logs.errors
+    artifact = json.loads(files[0].read_text())
+    assert artifact["templateNumber"] == "blankPage"
+    assert manifest["artifacts"][0]["templateNumber"] == "blankPage"
+    assert len(artifact["entities"][0]["fields"]) == 1
+    assert cli._resolve_template_number(None, str(files[0]), None) == "blankPage"
+    assert cli._artifact_supports_blank_template(artifact, "blankPage")

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

@@ -69,7 +69,7 @@ def test_remove_field_publishes_mutually_exclusive_single_and_batch_selectors():
 def test_add_field_batch_validate_only_runs_without_platform_access(tmp_path):
     source = tmp_path / "fields.json"
     source.write_text(json.dumps([
-        {"name": "说明", "bizWord": "note"},
+        {"name": "说明", "bizWord": "note", "fieldType": "TextField"},
         {"name": "来源", "bizWord": "source", "fieldType": "ComboField",
          "comboOptions": [{"label": "线上", "value": "online"}, {"label": "电话", "value": "phone"}]},
     ]), encoding="utf-8")

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

@@ -0,0 +1,84 @@
+"""Replay task02's real source through the native compiler before registration."""
+import json
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+SCRIPTS = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(SCRIPTS))
+from compile_plugin_source import operation_field_issues
+
+SOURCE = Path(__file__).with_name("fixtures") / "operation-entry-field-prepare.java"
+CONTEXT = {"formGraph": {"entities": [{"role": "entries", "collectionProperty": "uhyl_book_order_detail",
+    "fields": [{"fieldKey": "uhyl_start_time"}, {"fieldKey": "uhyl_end_time"}]}]}}
+
+
+def test_real_batch_failure_identifies_both_missing_fields():
+    issues = operation_field_issues(SOURCE.read_text(), CONTEXT)
+    assert {item["fieldKey"] for item in issues} == {"uhyl_start_time", "uhyl_end_time"}
+    assert all(item["collectionProperty"] == "uhyl_book_order_detail" for item in issues)
+    assert all(item["line"] > 50 for item in issues)
+
+
+@pytest.mark.parametrize("change", [
+    lambda text: text.replace("fieldKeys.add(ENTRY_COLLECTION);", "fieldKeys.add(FIELD_START_TIME); fieldKeys.add(FIELD_END_TIME);"),
+    lambda text: text.replace("fieldKeys.add(ENTRY_COLLECTION);", 'fieldKeys.add("uhyl_start_time"); fieldKeys.add("uhyl_end_time");'),
+    lambda text: text.replace("fieldKeys.add(ENTRY_COLLECTION);", 'fieldKeys.add("uhyl_book_order_detail.uhyl_start_time"); fieldKeys.add("uhyl_book_order_detail.uhyl_end_time");'),
+    lambda text: text.replace("extends AbstractOperationServicePlugIn", "extends ProjectBase"),
+    lambda text: text.replace("fieldKeys.add(ENTRY_COLLECTION);", "prepareFields(e);"),
+    lambda text: text.replace("getDynamicObjectCollection(ENTRY_COLLECTION)", 'getDynamicObjectCollection("unrelated")'),
+    lambda text: text.replace("fieldKeys.add(ENTRY_COLLECTION);", "fieldKeys.addAll(requiredKeys());"),
+    lambda text: text.replace("entity.getDataEntity()", "BusinessDataServiceHelper.loadSingle(id)"),
+])
+def test_correct_or_unresolved_data_flow_is_not_falsely_blocked(change):
+    assert operation_field_issues(change(SOURCE.read_text()), CONTEXT) == []
+
+
+def test_comments_do_not_prepare_fields_and_absent_metadata_is_not_invented():
+    source = SOURCE.read_text().replace("fieldKeys.add(ENTRY_COLLECTION);", "fieldKeys.add(ENTRY_COLLECTION); // fieldKeys.add(FIELD_START_TIME);")
+    assert len(operation_field_issues(source, CONTEXT)) == 2
+    assert operation_field_issues(source, None) == []
+
+
+def test_single_and_batch_native_compilation_reject_before_archiving(tmp_path):
+    module = tmp_path / "module"
+    source = module.joinpath("src", "main", "java", "kd", "bos", "app", "uhyl", "bfy11", "operate",
+                             "UhylBookingOrderOpPlugin.java")
+    source.parent.mkdir(parents=True)
+    source.write_text(SOURCE.read_text())
+    app = module / "app/uhyl_bfy11"
+    app.mkdir(parents=True)
+    handoff = tmp_path / "handoff.json"
+    handoff.write_text(json.dumps({"status": True, "handoff": {**CONTEXT, "projectRoot": str(module),
+        "appRoot": str(app), "sourcePath": str(source), "className": source.stem, "type": "operation",
+        "formNumber": "uhyl_booking_order", "description": "提交时段校验", "operationKeys": ["submit"]}}))
+    config = tmp_path / "appconfig.json"
+    config.write_text('{"compile": false}')
+    env = {**os.environ, "KD_APPCONFIG": str(config)}
+    single = [sys.executable, str(SCRIPTS / "compile_plugin_source.py"), "--handoff", str(handoff)]
+    batch_file = tmp_path / "sources.json"
+    batch_file.write_text(json.dumps([{"handoffPath": str(handoff)}]))
+    batch = [sys.executable, str(SCRIPTS / "compile_plugin_source.py"), "--project-root", str(module),
+             "--app-root", str(app), "--sources-file", str(batch_file)]
+    for args in (single, batch):
+        run = subprocess.run(args, env=env, capture_output=True, text=True)
+        result = json.loads(run.stdout)
+        outcome = result["results"][0] if "results" in result else result
+        assert run.returncode != 0
+        assert outcome["errorCode"] == "PLUGIN_SOURCE_OPERATION_FIELD_NOT_PREPARED"
+        assert outcome["phase"] == "source_validation"
+        assert not (app / "archive.json").exists()
+    source.write_text(SOURCE.read_text().replace("fieldKeys.add(ENTRY_COLLECTION);",
+        "fieldKeys.add(ENTRY_COLLECTION); fieldKeys.add(FIELD_START_TIME); fieldKeys.add(FIELD_END_TIME);"))
+    run = subprocess.run(single, env=env, capture_output=True, text=True)
+    result = json.loads(run.stdout)
+    assert run.returncode == 0, result
+    assert result["compileSkipped"] is True  # source-only proof, not a business pass
+
+
+def test_validator_preparation_is_not_mistaken_for_an_omission():
+    source = SOURCE.read_text().replace("public void validate() {", "public java.util.Set<String> preparePropertys() { return requiredFields(); } public void validate() {")
+    assert operation_field_issues(source, CONTEXT) == []

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

@@ -7,6 +7,7 @@ cases are as load-bearing as the positive ones.
 
 from __future__ import annotations
 
+import json
 import re
 import sys
 from pathlib import Path
@@ -16,13 +17,97 @@ sys.path.insert(0, str(SCRIPTS))
 
 from platform_api_contract import (  # noqa: E402
     _page, _qcp_constants, _scenes_verified_imports, base_class_issues,
-    filter_operator_issues, override_signature_issues, return_type_issues,
+    filter_operator_issues, override_signature_issues, return_type_issues, operation_call_findings,
     unverified_import_issues, unverified_member_issues,
     describe_api, plugin_coding_evidence, scene_misuse_issues,
+    forbidden_member_issues, report_batch_issues, report_listener_issues,
+    report_source_cast_warnings, sdk_absent_name_warnings,
 )
 sys.path.append(str(SCRIPTS.parents[2] / "scripts" if SCRIPTS.parent.parent.name == ".locales" else SCRIPTS))
 
 
+def test_operation_argument_roles_use_entity_evidence_not_identifier_spelling():
+    source = '''
+import kd.bos.servicehelper.BusinessDataServiceHelper;
+import kd.bos.servicehelper.operation.OperationServiceHelper;
+class P {
+    static final String FLOCK_ENTITY = "demo_flock";
+    static final String DELETE = "delete";
+    void run(Object id) {
+        Object flk = BusinessDataServiceHelper.loadSingle(id, FLOCK_ENTITY);
+        OperationServiceHelper.executeOperate((FLOCK_ENTITY), DELETE, new Object[]{id}, option());
+    }
+}
+'''
+    issues, warnings = operation_call_findings(source)
+    assert [item["errorCode"] for item in issues] == ["PLUGIN_SOURCE_OPERATION_ARGUMENT_ORDER"]
+    assert issues[0]["line"] == 9
+    assert len(issues[0]["registeredSignatures"]) == 2
+    assert warnings == []
+    assert operation_call_findings(source.replace('(FLOCK_ENTITY), DELETE', 'DELETE, FLOCK_ENTITY')) == ([], [])
+    # 没有实体证据时只提示，不将合法自定义操作或变量名推断为错误。
+    unknown = source.replace('Object flk = BusinessDataServiceHelper.loadSingle(id, FLOCK_ENTITY);', '')
+    issues, warnings = operation_call_findings(unknown)
+    assert issues == []
+    assert warnings[0]["errorCode"] == "PLUGIN_SOURCE_OPERATION_ARGUMENT_ORDER_UNVERIFIED"
+    assert operation_call_findings(unknown, ("demo_flock",))[0]
+    assert operation_call_findings(source.replace('"delete"', '"custom_delete"')) == ([], [])
+
+
+def test_operation_overloads_do_not_borrow_signatures_from_a_different_helper():
+    source = 'import kd.bos.servicehelper.operation.OperationServiceHelper;\n'
+    issues, warnings = operation_call_findings(source + 'OperationServiceHelper.executeOperate("delete", "demo_flock", new Object[]{id});')
+    assert issues == []
+    assert warnings[0]["argumentCount"] == 3
+    assert warnings[0]["errorCode"] == "PLUGIN_SOURCE_OPERATION_OVERLOAD_UNVERIFIED"
+    assert operation_call_findings(source + 'OperationServiceHelper.executeOperate("delete", "demo_flock", new Object[]{id}, option);') == ([], [])
+    # DeleteServiceHelper 确有 (entityName, pks, option) 三参数签名，不能一律要求四参数。
+    assert operation_call_findings('import kd.bos.servicehelper.operation.DeleteServiceHelper;\n'
+                                  'DeleteServiceHelper.deleteOperate("demo_flock", new Object[]{id}, option);') == ([], [])
+
+
+def test_operation_scan_resolves_qualified_and_static_import_calls():
+    for call, imports in (
+        ('kd.bos.servicehelper.operation.OperationServiceHelper.executeOperate', ''),
+        ('executeOperate', 'import static kd.bos.servicehelper.operation.OperationServiceHelper.executeOperate;\n'),
+        ('DeleteServiceHelper.deleteOperate', 'import kd.bos.servicehelper.operation.DeleteServiceHelper;\n'),
+    ):
+        source = imports + call + '("demo_flock", "delete", new Object[]{id}, option);'
+        issues, warnings = operation_call_findings(source, ("demo_flock",))
+        assert len(issues) == 1
+        assert warnings == []
+    local = '''import static kd.bos.servicehelper.operation.OperationServiceHelper.executeOperate;
+class P {
+    void executeOperate(String entity, String op, Object[] ids, Object option) { use(ids); }
+    void run() { executeOperate("demo_flock", "delete", ids, option); }
+}'''
+    assert operation_call_findings(local, ("demo_flock",)) == ([], [])
+
+
+def test_operation_scan_ignores_literals_comments_other_receivers_and_shadowed_constants():
+    source = '''import kd.bos.servicehelper.operation.OperationServiceHelper;
+class P {
+    final String ENTITY = "demo_flock";
+    void run(String ENTITY) { OperationServiceHelper.executeOperate(ENTITY, "delete", ids, option); }
+    String note = "OperationServiceHelper.executeOperate(ENTITY, delete, ids)";
+    // OperationServiceHelper.executeOperate("demo_flock", "delete", ids);
+}'''
+    assert operation_call_findings(source, ("demo_flock",)) == ([], [])
+    assert operation_call_findings('import demo.OperationServiceHelper;\n'
+                                  'OperationServiceHelper.executeOperate("demo_flock", "delete", ids);', ("demo_flock",)) == ([], [])
+    assert operation_call_findings('import kd.bos.servicehelper.operation.OperationServiceHelper;\n'
+                                  'OperationServiceHelper.executeOperate(operation, entity, ids, option);') == ([], [])
+
+
+def test_operation_scenes_pass_the_new_call_contract():
+    platform = SCRIPTS.parent / "knowledge" / "cosmic" / "platform"
+    for name in ("operation/execute-operate.md", "operation/operation-custom-params.md",
+                 "operation/operation-microservice.md", "data-access/business-data/delete-service.md"):
+        text = (platform / "scenes" / name).read_text(encoding="utf-8-sig")
+        for block in re.findall(r"```java\n(.*?)```", text, re.DOTALL):
+            assert operation_call_findings(block) == ([], []), name
+
+
 def test_api_lookup_distinguishes_same_named_members_by_receiver():
     plugin = describe_api("AbstractOperationServicePlugIn", ["getDataEntities"])
     validator = describe_api("AbstractValidator", ["getDataEntities"])
@@ -984,3 +1069,239 @@ def test_scene_evidence_cannot_read_outside_registered_scene_tree():
     import pytest
     with pytest.raises(ValueError, match="unknown coding scene"):
         plugin_coding_evidence("operation", ["../../../../references/type-registry.json"])
+
+
+def _report_form(body: str, imports: str = "") -> str:
+    return (
+        "package demo;\n"
+        "import java.util.EventObject;\n"
+        "import kd.bos.form.control.events.ItemClickEvent;\n"
+        "import kd.bos.form.events.HyperLinkClickEvent;\n"
+        "import kd.bos.form.events.HyperLinkClickListener;\n"
+        "import kd.bos.report.ReportList;\n"
+        "import kd.bos.report.plugin.AbstractReportFormPlugin;\n"
+        f"{imports}"
+        "public class DrillPlugin extends AbstractReportFormPlugin implements HyperLinkClickListener {\n"
+        f"{body}"
+        "}\n"
+    )
+
+
+_DRILL = (
+    "    @Override\n"
+    "    public void hyperLinkClick(HyperLinkClickEvent evt) {\n"
+    "        String field = evt.getFieldName();\n"
+    "    }\n"
+)
+_REGISTER_DRILL = (
+    "    @Override\n"
+    "    public void registerListener(EventObject e) {\n"
+    "        super.registerListener(e);\n"
+    "        ReportList reportList = this.getControl(\"reportlistap\");\n"
+    "        reportList.addHyperClickListener(this);\n"
+    "    }\n"
+)
+
+
+def test_a_report_drill_down_without_its_listener_is_rejected():
+    """Verified on the 8.0 bytecode: nothing adds a report form plugin to the grid's hyperlink
+    listeners but addHyperClickListener, so this compiles, opens and the link does nothing."""
+    issues = report_listener_issues(_report_form(_DRILL))
+
+    assert len(issues) == 1
+    assert issues[0]["callback"] == "hyperLinkClick"
+    assert issues[0]["requiredCall"] == "addHyperClickListener"
+    assert issues[0]["line"] == 10
+    assert "registerListener" in issues[0]["message"]
+
+
+def test_a_report_drill_down_that_registers_itself_is_accepted():
+    assert report_listener_issues(_report_form(_REGISTER_DRILL + _DRILL)) == []
+
+
+def test_toolbar_and_cell_callbacks_each_need_their_own_listener():
+    issues = report_listener_issues(_report_form(
+        _REGISTER_DRILL + _DRILL
+        + "    @Override\n"
+        "    public void itemClick(ItemClickEvent evt) { super.itemClick(evt); }\n"
+        "    public void cellClick(CellClickEvent evt) { }\n",
+        imports="import kd.bos.form.control.events.CellClickEvent;\n"))
+
+    assert [(issue["callback"], issue["requiredCall"]) for issue in issues] == [
+        ("itemClick", "addItemClickListeners"), ("cellClick", "addCellClickListener")]
+    assert report_listener_issues(_report_form(
+        "    @Override\n"
+        "    public void registerListener(EventObject e) {\n"
+        "        this.addItemClickListeners(\"toolbarap\");\n"
+        "    }\n"
+        "    @Override\n"
+        "    public void itemClick(ItemClickEvent evt) { super.itemClick(evt); }\n")) == []
+
+
+def test_the_listener_rule_judges_only_a_direct_report_form_plugin():
+    """A project base class may register for its subclass, and a bill plugin's toolbar is outside
+    the report evidence, so neither is judged."""
+    assert report_listener_issues(_report_form(_DRILL).replace(
+        "extends AbstractReportFormPlugin", "extends ProjectReportFormPlugin")) == []
+    assert report_listener_issues(
+        "package demo;\n"
+        "import kd.bos.bill.AbstractBillPlugIn;\n"
+        "import kd.bos.form.control.events.ItemClickEvent;\n"
+        "public class Bill extends AbstractBillPlugIn {\n"
+        "    public void itemClick(ItemClickEvent evt) { }\n"
+        "}\n") == []
+
+
+def _report_data(batch_by: str, query: str, helpers: str = "") -> str:
+    return (
+        "package demo;\n"
+        "import kd.bos.algo.DataSet;\n"
+        "import kd.bos.entity.report.AbstractReportListDataPlugin;\n"
+        "import kd.bos.entity.report.ReportQueryParam;\n"
+        "public class BatchPlugin extends AbstractReportListDataPlugin {\n"
+        "    @Override\n"
+        "    public DataSet queryBatchBy(ReportQueryParam queryParam) {\n"
+        f"{batch_by}"
+        "    }\n"
+        "    @Override\n"
+        "    public DataSet query(ReportQueryParam queryParam, Object selectedObj) throws Throwable {\n"
+        f"{query}"
+        "    }\n"
+        f"{helpers}"
+        "}\n"
+    )
+
+
+_BATCH_BY = (
+    "        queryParam.byBatchInfo().setCountPerBatch(100);\n"
+    "        return basis(queryParam);\n"
+)
+
+
+def test_a_batched_query_that_ignores_its_batch_is_rejected():
+    issues = report_batch_issues(_report_data(_BATCH_BY, "        return all(queryParam);\n"))
+
+    assert len(issues) == 1
+    assert issues[0]["method"] == "query"
+    assert issues[0]["line"] == 12
+    assert "selectedObj" in issues[0]["message"]
+    assert "getCurrentBatchRows" in issues[0]["message"]
+
+
+def test_a_batched_query_that_reads_its_batch_is_accepted():
+    assert report_batch_issues(_report_data(
+        _BATCH_BY, "        return byRows(queryParam.byBatchInfo().getCurrentBatchRows());\n")) == []
+    assert report_batch_issues(_report_data(_BATCH_BY, "        return byBasis(selectedObj);\n")) == []
+    # A helper that reads the batch is accepted without being followed.
+    assert report_batch_issues(_report_data(
+        _BATCH_BY, "        return narrowed(queryParam);\n",
+        "    private DataSet narrowed(ReportQueryParam p) { return byRows(p.byBatchInfo()); }\n")) == []
+
+
+def test_a_query_batch_by_that_never_batches_is_not_judged():
+    assert report_batch_issues(_report_data(
+        "        return null;\n", "        return all(queryParam);\n")) == []
+
+
+def test_sdk_absent_report_names_are_warned_with_what_8_0_offers():
+    """No class file in the 8.0 SDK mentions these names, so no 8.0 receiver carries them."""
+    warnings = sdk_absent_name_warnings(_report_form(
+        "    @Override\n"
+        "    public void beforeQuery(kd.bos.entity.report.ReportQueryParam queryParam) {\n"
+        "        ReportList reportList = this.getControl(\"reportlistap\");\n"
+        "        reportList.setAsyncDataCount(true);\n"
+        "        // reportList.setAsyncDataCount(true); is not code\n"
+        "        Object custom = queryParam.getFilter().getCustomFilter();\n"
+        "        Object kept = queryParam.getCustomFilter();\n"
+        "    }\n"))
+
+    assert [item["name"] for item in warnings] == ["setAsyncDataCount", "FilterInfo.getCustomFilter"]
+    assert all(item["severity"] == "warning" for item in warnings)
+    assert "setAsyncTotal" in warnings[0]["message"]
+    assert "queryParam.getCustomFilter()" in warnings[1]["message"]
+
+
+def test_a_name_the_source_declares_itself_is_not_warned():
+    assert sdk_absent_name_warnings(_report_form(
+        "    private void setAsyncDataCount(boolean on) { }\n"
+        "    void run() { setAsyncDataCount(true); }\n")) == []
+
+
+def test_an_unguarded_source_cast_in_package_data_is_warned():
+    package_data = (
+        "    @Override\n"
+        "    public void packageData(PackageDataEvent event) {\n"
+        "        ReportColumn column = (ReportColumn) event.getSource();\n"
+        "    }\n")
+    imports = ("import kd.bos.entity.datamodel.events.PackageDataEvent;\n"
+               "import kd.bos.entity.report.ReportColumn;\n")
+    warnings = report_source_cast_warnings(_report_form(package_data, imports))
+
+    assert [item["errorCode"] for item in warnings] == ["PLUGIN_REPORT_SOURCE_CAST_UNGUARDED"]
+    guarded = package_data.replace(
+        "        ReportColumn column",
+        "        if (!(event.getSource() instanceof ReportColumn)) { return; }\n        ReportColumn column")
+    assert report_source_cast_warnings(_report_form(guarded, imports)) == []
+
+
+def test_the_report_pages_pass_every_blocking_source_gate():
+    """The report scenes and guides are what the coding step copies. A blocking gate that rejects
+    one of their complete classes means either the page teaches a defect or the gate is too wide,
+    and both have to be settled here rather than at a user's compile boundary."""
+    from java_source import duplicate_methods
+
+    platform = SCRIPTS.parent / "knowledge" / "cosmic" / "platform"
+    pages = sorted((platform / "scenes" / "report").glob("*.md")) + [
+        platform / "scenes" / "system-service" / "report-plugin-interface.md",
+        platform / "report-plugin.md", platform / "reportlistdata-plugin.md",
+        platform / "reporttreedata-plugin.md",
+    ]
+    gates = (duplicate_methods, return_type_issues, base_class_issues, override_signature_issues,
+             filter_operator_issues, forbidden_member_issues, unverified_import_issues,
+             unverified_member_issues, scene_misuse_issues, report_listener_issues,
+             report_batch_issues)
+    findings: list[str] = []
+    classes = 0
+    for page in pages:
+        for block in re.findall(r"```java\n(.*?)```",
+                                page.read_text(encoding="utf-8-sig", errors="replace"), re.DOTALL):
+            if not re.search(r"^\s*public\s+(?:(?:final|abstract)\s+)*class\s+\w+[^;{]*\{",
+                             block, re.MULTILINE):
+                continue
+            classes += 1
+            findings += [f"{page.name}: {gate.__name__}: {issue.get('message')}"
+                         for gate in gates for issue in gate(block)]
+
+    assert classes >= 30, "too few complete classes found, so the sweep proves little"
+    assert not findings, "\n".join(findings)
+
+
+def test_exact_api_and_specialized_knowledge_are_selected_without_a_scene():
+    evidence = plugin_coding_evidence("form", core_logic=["QueryServiceHelper.queryOne 查询"],
+                                      hit_modules=["idempotency", "security-input-validation"])
+    contract = next(item for item in evidence["apiContracts"] if item["class"] == "kd.bos.servicehelper.QueryServiceHelper")
+    assert {member["name"] for member in contract["members"]} == {"queryOne"}
+    assert all(Path(path).is_file() for path in evidence["specializedReferences"].values())
+    assert set(evidence["specializedReferences"]) == {"idempotency", "security-input-validation"}
+    assert "apiContracts" not in plugin_coding_evidence("form", core_logic=["按业务规则处理页面"])
+
+
+def test_plugin_type_lookup_returns_exact_registry_guide_without_inventory():
+    import subprocess
+    result = subprocess.run([sys.executable, str(SCRIPTS / "platform_api_contract.py"), "--describe-plugin-type", "operation"], capture_output=True, text=True)
+    assert result.returncode == 0
+    payload = json.loads(result.stdout)
+    assert payload["type"] == "operation"
+    assert Path(payload["guide"]).is_file()
+    assert payload["baseClass"]
+    assert "types" not in payload
+    invalid = subprocess.run([sys.executable, str(SCRIPTS / "platform_api_contract.py"), "--describe-plugin-type", "unknown"], capture_output=True, text=True)
+    assert invalid.returncode == 2 and json.loads(invalid.stdout)["errorCode"] == "PLUGIN_TYPE_UNSUPPORTED"
+
+
+def test_documented_inherited_transaction_event_members_are_available():
+    for name in ["BeginOperationTransactionArgs", "EndOperationTransactionArgs"]:
+        value = describe_api("kd.bos.entity.plugin.args." + name, ["getOperationKey"])
+        assert value["status"] is True
+        assert value["undocumentedMembers"] == []
+        assert any(item["declaredBy"] == "kd.bos.entity.plugin.args.OperationArgs" for item in value["members"])