@shundoo-ai/dsh-cosmic 1.0.21 → 1.0.22

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

@@ -6,7 +6,35 @@ from pathlib import Path
 SCRIPTS = Path(__file__).resolve().parents[1]
 sys.path.insert(0, str(SCRIPTS))
 
-from plugin_source_gate import gate_path, read_state, write_state  # noqa: E402
+from plugin_source_gate import gate_path, read_state, write_state, validate_registration_entry  # noqa: E402
+
+
+def test_registration_rechecks_legacy_operation_receipts(tmp_path):
+    import hashlib
+    import pytest
+
+    source = tmp_path / "DeleteFlock.java"
+    for call, status, error in (
+        ('"demo_flock", "delete", ids, option', "passed", "PLUGIN_SOURCE_OPERATION_ARGUMENT_ORDER"),
+        ('"demo_flock", "delete", ids, option', "skipped-by-config", "PLUGIN_SOURCE_OPERATION_ARGUMENT_ORDER"),
+        ('"delete", "demo_flock", ids', "skipped-by-config", "PLUGIN_SOURCE_OPERATION_OVERLOAD_UNVERIFIED"),
+        ('"delete", "demo_flock", ids, option', "skipped-by-config", None),
+        # 未收录重载但已有实际编译证据，不凭文档缺失否认它。
+        ('"delete", "demo_flock", ids', "passed", None),
+    ):
+        source.write_text('''import kd.bos.entity.plugin.AbstractOperationServicePlugIn;
+import kd.bos.servicehelper.operation.OperationServiceHelper;
+class DeleteFlock extends AbstractOperationServicePlugIn {
+    void run() { OperationServiceHelper.executeOperate(''' + call + '''); }
+}''', encoding="utf-8")
+        entry = {"className": "DeleteFlock", "type": "operation", "formNumber": "demo_flock",
+                 "filePath": str(source.resolve()), "compileStatus": status,
+                 "sourceHash": hashlib.sha256(source.read_bytes()).hexdigest()}
+        if error:
+            with pytest.raises(ValueError, match=error):
+                validate_registration_entry(entry, "OPERATION")
+            continue
+        assert validate_registration_entry(entry, "OPERATION")["compileStatus"] == status
 
 
 def test_gate_advances_from_coding_to_source_ready_without_consuming_proof(tmp_path, capsys):
@@ -21,7 +49,7 @@ def test_gate_advances_from_coding_to_source_ready_without_consuming_proof(tmp_p
     read_state(project_root, "CouponPlugin")
     result = json.loads(capsys.readouterr().out.splitlines()[-1])
 
-    assert result == {"state": "source_ready", "verdict": "compile_backed_pass"}
+    assert result == {"state": "source_ready", "verdict": "source_ready_only"}
     assert Path(gate_path(project_root, "CouponPlugin")).exists()
 
 

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

@@ -68,3 +68,24 @@ def test_unmapped_module_and_explicit_source_only_are_distinct(target):
     result = verify_target_sdk(str(project), {})
     assert result['status'] == 'not-run'
     assert 'unverified' in result['evidenceScope']
+
+
+def test_source_only_still_validates_sdk_usage_shape(tmp_path, monkeypatch):
+    config = tmp_path / 'appconfig.json'
+    config.write_text('{"compile":false}')
+    monkeypatch.setenv('KD_APPCONFIG', str(config))
+    with pytest.raises(TargetSdkError) as error:
+        verify_target_sdk(str(tmp_path), {}, [{'class': 'kd.bos.entity.report.ReportColumn', 'members': 'getFieldKey'}])
+    assert error.value.error_code == 'PLUGIN_SDK_USAGE_INVALID'
+    result = verify_target_sdk(str(tmp_path), {}, [{'class': 'kd.bos.entity.report.ReportColumn'}])
+    assert result['status'] == 'not-run' and result['compile'] is False
+    assert 'classes' not in result
+
+
+def test_unselected_guide_parameter_does_not_block_target_sdk(target):
+    result = verify_target_sdk(str(target[0]), {
+        "baseContract": {"class": "kd.bos.probe.Probe"},
+        "signatureTypes": [{"class": "kd.bos.probe.UnusedLifecycleEvent"}],
+    })
+    assert result["status"] == "verified"
+    assert [item["class"] for item in result["classes"]] == ["kd.bos.probe.Probe"]

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

@@ -124,3 +124,168 @@ def test_contract_load_failure_is_loud() -> None:
             raise AssertionError("契约缺失时应当抛错，而不是返回空表")
     finally:
         pr._PROPERTY_NAMES, pr._CONTRACT = saved_names, saved_contract
+
+
+def test_known_and_unknown_properties_do_not_partially_reroute():
+    op = _entity_modify(value={"mustInput": True, "notAProperty": 1})
+    structural, calls, unresolved = plan_property_reroute([op])
+    assert structural == [op] and calls == [] and unresolved
+
+
+def test_empty_property_map_is_unresolved():
+    assert plan_property_reroute([_entity_modify(value={})])[2]
+
+
+def test_modify_preflight_never_writes_a_partial_request(monkeypatch):
+    import pytest
+    from _core import cmd_metaops
+    writes = []
+    monkeypatch.setattr(cmd_metaops, "_api_call", lambda *a, **k: writes.append(a))
+    monkeypatch.setattr(cmd_metaops, "do_set_properties_verified", lambda *a, **k: writes.append(a))
+    for ops, code in [
+        ([_entity_modify(value={"mustInput": True, "unknown": 1})], "PROPERTY_REROUTE_UNRESOLVED"),
+        ([_entity_modify(path="mustInput", value=True),
+          {"op": "add", "target": {"treeType": "form", "elementType": "control", "value": "p"},
+           "value": {"name": "Panel", "containerType": "FlexPanelAp"}}], "validation failed"),
+        ([_entity_modify(path="mustInput", value=True),
+          {"op": "remove", "target": {"treeType": "entity", "elementType": "field", "value": "f1"}}],
+         "NON_ATOMIC_PROPERTY_OP"),
+    ]:
+        with pytest.raises(ValueError, match=code):
+            cmd_metaops.do_modify_meta({}, "token", "FID", ops, "demo")
+    with pytest.raises(ValueError, match="PROPERTY_REROUTE_FORM_REQUIRED"):
+        cmd_metaops.do_modify_meta({}, "token", "FID", [_entity_modify(path="mustInput", value=True)])
+    assert writes == []
+
+
+def test_modify_property_failure_stops_and_is_not_reported_as_success(monkeypatch):
+    from _core import cmd_metaops
+    writes = []
+    def write(*args):
+        writes.append(args)
+        return {"status": False, "errorCode": "FAIL", "verification": {"verified": False}}
+    monkeypatch.setattr(cmd_metaops, "do_set_properties_verified", write)
+    result = cmd_metaops.do_modify_meta({}, "token", "FID", [
+        _entity_modify(path="mustInput", value=True),
+        _entity_modify(key="f2", path="name", value="名称"),
+    ], "demo")
+    assert result["status"] is False and result["errorCode"] == "PROPERTY_REROUTE_INCOMPLETE"
+    assert len(writes) == 1 and result["data"]["pending"][0]["elementKey"] == "f2"
+    assert result["retryAdvice"] == "reconcile_before_retry"
+
+
+def test_property_exception_retains_prior_receipts_and_stops(monkeypatch):
+    from _core import cmd_metaops
+    writes = []
+    def write(*args):
+        writes.append(args)
+        if len(writes) == 2:
+            raise RuntimeError("readback unavailable after dispatch")
+        return {"status": True, "errorCode": "0", "verification": {"verified": True}}
+    monkeypatch.setattr(cmd_metaops, "do_set_properties_verified", write)
+    result = cmd_metaops.do_modify_meta({}, "token", "FID", [
+        _entity_modify(key=key, path="mustInput", value=True) for key in ("f1", "f2", "f3")], "demo")
+    assert result["status"] is False and len(writes) == 2
+    assert result["data"]["rerouted"][0]["result"]["verification"]["verified"]
+    assert result["data"]["rerouted"][1]["result"]["errorCode"] == "PROPERTY_REROUTE_EXCEPTION"
+    assert result["data"]["pending"][0]["elementKey"] == "f3"
+
+
+def test_property_success_requires_independent_verification(monkeypatch):
+    from _core import cmd_metaops
+    for verified in (False, True):
+        monkeypatch.setattr(cmd_metaops, "do_set_properties_verified", lambda *a, **k: {
+            "status": True, "errorCode": "0", "verification": {"verified": verified}})
+        result = cmd_metaops.do_modify_meta({}, "token", "FID", [
+            _entity_modify(path="mustInput", value=True)], "demo")
+        assert result["status"] is verified
+
+
+def test_combo_null_values_and_boolean_add_contract():
+    from _core.validators import _validate_ops
+    for value in (None, [None], [{"value": None, "caption": "选项"}], [{"caption": "选项"}]):
+        assert _validate_ops([_entity_modify(path="comboItems.add", value=value)])
+    assert _validate_ops([_entity_modify(path="comboItems.remove", value=[None])])
+    assert _validate_ops([_entity_modify(path="comboItems.add", value=[
+        {"value": 0, "caption": "零"}, {"value": "01", "caption": "一"}])]) == []
+    op = {"op": "add", "target": {"treeType": "entity", "elementType": "field", "value": "amount"},
+          "value": {"fieldType": "DecimalField", "bizWord": "amount", "name": "金额", "mustInput": True}}
+    assert _validate_ops([op]) == []
+    assert _validate_ops([{**op, "value": {**op["value"], "mustInput": "true"}}])
+
+
+def test_combo_create_validates_every_supplied_alias_and_effective_label():
+    from _core.validators import _validate_ops
+    op = {"op": "add", "target": {"treeType": "entity", "elementType": "field", "value": "mode"},
+          "value": {"fieldType": "ComboField", "bizWord": "mode", "name": "模式"}}
+    rows = [{"value": 0, "caption": "零"}, {"value": "01", "label": "一"}]
+    for options in ({"items": rows}, {"comboOptions": rows}, {"items": rows, "comboOptions": rows}):
+        assert _validate_ops([{**op, "value": {**op["value"], **options}}]) == []
+    for options in (
+        {}, {"items": None}, {"items": []}, {"items": {"value": "a"}},
+        {"items": [None]}, {"items": [{"value": None, "caption": "空"}]},
+        {"items": rows, "comboOptions": [{"value": "a", "caption": "甲"}]},
+        {"items": None, "comboOptions": rows}, {"items": rows, "comboOptions": None},
+        {"items": [{"value": "a", "label": " ", "caption": "不会被使用"}]},
+        {"items": [{"value": "a", "label": 1, "caption": "不会被使用"}]},
+        {"items": [{"value": 0, "caption": "零"}, {"value": "0", "caption": "重复"}]},
+    ):
+        assert _validate_ops([{**op, "value": {**op["value"], **options}}]), options
+
+
+def test_combo_modify_aliases_use_only_backend_supported_shapes():
+    from _core.validators import _validate_ops
+    for prefix in ("comboItems", "comboOptions"):
+        for path in (prefix, prefix + ".add"):
+            for rows in ([{"value": "01", "caption": "一"}], [{"value": 0, "label": None, "caption": "零"}]):
+                assert _validate_ops([_entity_modify(path=path, value=rows)]) == []
+            for rows in (None, "a", [None], [0], [{"value": None, "caption": "空"}],
+                         [{"value": "a", "label": "", "caption": "不会被使用"}],
+                         [{"value": "a", "caption": "甲"}, {"value": "a", "caption": "重复"}]):
+                assert _validate_ops([_entity_modify(path=path, value=rows)]), (path, rows)
+        for rows in ("01", ["01", "0"], [{"value": 0}, {"value": "01"}]):
+            assert _validate_ops([_entity_modify(path=prefix + ".remove", value=rows)]) == []
+        for rows in (None, [None], [0], [False], [{"value": None}], [{"value": ""}], ["a", "a"]):
+            assert _validate_ops([_entity_modify(path=prefix + ".remove", value=rows)]), rows
+        for path in (prefix + ".unknown", prefix + ".add.extra", prefix + "."):
+            assert _validate_ops([_entity_modify(path=path, value=[])]), path
+
+
+def test_invalid_modify_paths_and_combo_inputs_never_dispatch(monkeypatch):
+    import pytest
+    from _core import cmd_metaops
+    from _core.validators import _validate_ops
+    writes = []
+    monkeypatch.setattr(cmd_metaops, "_api_call", lambda *a, **k: writes.append(a))
+    monkeypatch.setattr(cmd_metaops, "do_set_properties_verified", lambda *a, **k: writes.append(a))
+    for path in (False, 0, 1, [], {}, "", "   "):
+        op = _entity_modify(path=path, value={"mustInput": True})
+        structural, calls, unresolved = plan_property_reroute([op])
+        assert structural == [op] and calls == [] and unresolved
+        form_op = {**op, "target": {**op["target"], "treeType": "form"}}
+        assert _validate_ops([form_op])
+        with pytest.raises(ValueError, match="validation failed"):
+            cmd_metaops.do_modify_meta({}, "token", "FID", [form_op], "demo")
+        with pytest.raises(ValueError, match="PROPERTY_REROUTE_UNRESOLVED"):
+            cmd_metaops.do_modify_meta({}, "token", "FID", [op], "demo")
+    for prefix in ("comboItems", "comboOptions"):
+        for suffix, value in (("", None), (".add", [None]), (".remove", [0]), (".unknown", [])):
+            with pytest.raises(ValueError, match="validation failed"):
+                cmd_metaops.do_modify_meta({}, "token", "FID", [
+                    _entity_modify(path=prefix + suffix, value=value)], "demo")
+    op = {"op": "add", "target": {"treeType": "entity", "elementType": "field", "value": "mode"},
+          "value": {"fieldType": "ComboField", "name": "模式", "bizWord": "mode",
+                    "items": None, "comboOptions": [{"value": "a", "caption": "甲"}]}}
+    with pytest.raises(ValueError, match="validation failed"):
+        cmd_metaops.do_modify_meta({}, "token", "FID", [op], "demo")
+    assert writes == []
+
+
+def test_verify_guidance_requires_reconciliation_not_write_replay():
+    guide = (APP_BUILD / "skills/cosmic-meta-api/modules/verify/SKILL.md").read_text(encoding="utf-8")
+    assert "reconcile_before_retry" in guide
+    assert "只重试验证读取，禁止重放写入" in guide
+    assert "不得重放整个 artifact / ops 数组" in guide
+    assert "WARN 不能证明本次写入未发生" in guide
+    assert "自动切换到建议的替代 API 重新执行" not in guide
+    assert "automatically switch to the suggested alternative API, re-execute" not in guide

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

@@ -997,3 +997,38 @@ def test_element_resolver_collapses_field_and_fieldap_with_same_key() -> None:
         {"key": "uhyl_text_field", "name": "文本", "type": "FieldAp"},
     ]
     assert MODULE.resolve_element_rows(rows, "文本", "demo") == "uhyl_text_field"
+
+
+
+def test_currency_binding_requires_live_candidates_before_write() -> None:
+    schema = {"status": True, "data": [{"propertyName": "CurrencyFieldId", "editorType": "ecombo", "complexity": "simple", "editable": True}]}
+    with (patch.object(MODULE, "do_get_property_schema", return_value=schema),
+          patch.object(MODULE, "do_set_properties") as setter):
+        result = MODULE.do_set_properties_verified({}, "token", "demo", "amount", {"CurrencyFieldId": "币别"})
+    assert result["status"] is False
+    assert result["errorCode"] == "PROPERTY_VALUE_INVALID"
+    assert "candidates are unavailable" in result["data"]["errors"][0]["message"]
+    setter.assert_not_called()
+
+
+def test_currency_binding_rejects_ambiguous_live_option_names() -> None:
+    declaration = {"propertyName": "CurrencyFieldId", "editorType": "ecombo", "complexity": "simple", "options": [
+        {"id": "a", "name": "币别"}, {"id": "b", "name": "币别"},
+    ]}
+    compiled, _, rejection = MODULE._compile_simple_property_map([declaration], {"CurrencyFieldId": "币别"})
+    assert compiled is None
+    assert rejection["errorCode"] == "PROPERTY_VALUE_INVALID"
+    assert "ambiguous" in rejection["data"]["errors"][0]["message"]
+    assert MODULE._normalize_simple_property_value(declaration, "a") == "a"
+
+
+def test_field_selector_resolves_declared_child_scope_without_options() -> None:
+    schema = {"status": True, "data": [{"propertyName": "CurrencyFieldId", "editorType": "ecombo", "complexity": "simple", "editable": True, "constraints": {"scope": "child", "types": ["CurrencyField"]}}]}
+    rows = {"status": True, "data": [{"category": "field", "key": "currency", "id": "currency-id", "type": "CurrencyField", "parentKey": "amount"}]}
+    with (patch.object(MODULE, "do_get_property_schema", return_value=schema),
+          patch.object(MODULE, "do_list_elements", return_value=rows),
+          patch.object(MODULE, "do_set_properties", return_value={"status": True}) as setter,
+          patch.object(MODULE, "do_get_properties", return_value={"status": True, "data": {"CurrencyFieldId": "currency-id"}})):
+        result = MODULE.do_set_properties_verified({}, "token", "demo", "amount", {"CurrencyFieldId": "currency"})
+    assert result["verification"]["verified"]
+    assert setter.call_args.args[-1] == {"CurrencyFieldId": "currency-id"}

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

@@ -6,6 +6,7 @@ from pathlib import Path
 
 
 SCRIPT = Path(__file__).resolve().parents[1] / "query_plugin_handoff.py"
+sys.path.insert(0, str(SCRIPT.parent))
 
 
 def handoff_file(tmp_path):
@@ -59,6 +60,44 @@ def test_target_readiness_is_bounded_and_missing_evidence_is_not_claimed(tmp_pat
         assert 'classes' not in context['targetSdk'] and 'large-evidence-' not in output
 
 
+def test_coding_projection_reads_gate_without_repreparing_or_mutating_snapshot(tmp_path):
+    file, document = handoff_file(tmp_path)
+    gate = tmp_path / ".temp" / ".BookingPlugin-gate"
+    document["handoff"].update({"projectRoot": str(tmp_path), "className": "BookingPlugin",
+        "sourceGate": {"requestedState": "coding", "path": str(gate)}})
+    file.write_text(json.dumps(document), encoding="utf-8")
+    original = file.read_bytes()
+    for content, expected, verified in [(None, "missing", False), ("coding:session-123", "coding", True),
+                                       ("source_ready", "source_ready", True), ("invalid", "invalid", False)]:
+        if content is not None:
+            gate.parent.mkdir(exist_ok=True)
+            gate.write_text(content, encoding="utf-8")
+        for operation in ("coding-start", "coding-context"):
+            code, context, _ = query(file, operation)
+            assert code == 0
+            assert context["sourceGate"]["requestedState"] == "coding"
+            assert context["sourceGate"]["path"] == str(gate)
+            assert context["sourceGate"]["state"] == expected
+            assert context["sourceGate"]["verified"] == verified
+            assert context["sourceGate"]["sessionId"] == ("session-123" if content == "coding:session-123" else None)
+            assert "not a compile receipt" in context["sourceGate"]["evidenceScope"]
+        assert file.read_bytes() == original
+        assert (gate.read_text() if gate.exists() else None) == content
+    gate.write_bytes(b"\xff")
+    code, context, _ = query(file, "coding-start")
+    assert code == 2 and context["errorCode"] == "HANDOFF_SOURCE_GATE_UNAVAILABLE"
+
+
+def test_coding_projection_rejects_gate_for_another_class(tmp_path):
+    file, document = handoff_file(tmp_path)
+    document["handoff"].update({"projectRoot": str(tmp_path), "className": "BookingPlugin",
+        "sourceGate": {"requestedState": "coding", "path": str(tmp_path / ".temp" / ".OtherPlugin-gate")}})
+    file.write_text(json.dumps(document), encoding="utf-8")
+    for operation in ("coding-start", "coding-context"):
+        code, context, _ = query(file, operation)
+        assert code == 2 and context["errorCode"] == "HANDOFF_SOURCE_GATE_INVALID"
+
+
 def test_index_find_and_get_return_only_requested_native_context(tmp_path):
     file, document = handoff_file(tmp_path)
     original = hashlib.sha256(file.read_bytes()).hexdigest()
@@ -158,3 +197,185 @@ def test_large_startup_inventory_is_explicitly_referenced_instead_of_dumped(tmp_
     assert result["entities"][0]["fieldCount"] == 1000
     assert result["entities"][0]["fieldsPath"] == "/handoff/formGraph/entities/0/fields"
     assert "fields" not in result["entities"][0]
+
+
+def test_report_context_uses_real_contract_without_fabricating_form_graph(tmp_path):
+    from prepare_plugin_handoff import _compile_report_contract
+    file, document = handoff_file(tmp_path)
+    document['handoff'].pop('formGraph')
+    document['handoff'].update(type='reportlist', formNumber='sample_rpt',
+        reportContract=_compile_report_contract({'reportColumns': [
+            {'kind': 'column', 'fieldKey': 'person_id', 'dateIndex': 'person_id', 'fieldType': 'bigint',
+             'caption': '人员 / Person', 'presentation': {'kind': 'basedata', 'entityId': 'bos_user', 'displayProp': 'name'}}],
+            'reportFilters': [{'fieldPath': 'flt_period', 'displayName': '期间 / Period', 'compare': '='}],
+                    'reportSorts': [{'fieldKey': 'person_id', 'direction': 'desc'}],
+                    'reportPlugins': [{'className': 'kd.test.report.P', 'type': 'Java'}]}, 'sample_rpt'))
+    file.write_text(json.dumps(document, ensure_ascii=False))
+    for operation in ('coding-start', 'coding-context'):
+        code, context, stdout = query(file, operation)
+        assert code == 0 and context['domain'] == 'report'
+        assert 'formGraph' not in context and 'large-evidence-' not in stdout
+        assert context['reportContract']['dataSetColumnTypes'][0]['algoDataType'] == 'DataType.LongType'
+        assert context['reportContract']['columnPresentation'][0]['entityId'] == 'bos_user'
+        assert context['reportContract']['filterValueContracts'][0]['filterKey'] == 'flt_period'
+        assert context['reportContract']['defaultSorts'] == [
+            {'fieldKey': 'person_id', 'dateIndex': 'person_id', 'direction': 'desc'}]
+        assert context['reportContract']['defaultSortPolicy']['priority'] == 'interactiveThenDefault'
+        assert context['reportContract']['sections']['defaultSorts']['path'] == '/handoff/reportContract/defaultSorts'
+        assert context['codingEvidence']['apiContracts'][0]['path'].endswith('/0')
+        assert 'runtime' in context['evidenceScope']
+    document['handoff']['reportContract']['formNumber'] = 'other_rpt'
+    file.write_text(json.dumps(document))
+    assert query(file, 'coding-start')[1]['errorCode'] == 'HANDOFF_CODING_CONTEXT_INVALID'
+    document['handoff']['reportContract']['formNumber'] = 'sample_rpt'
+    document['handoff']['targetSdk'] = ['invalid']
+    file.write_text(json.dumps(document))
+    assert query(file, 'coding-start')[1]['errorCode'] == 'HANDOFF_CODING_CONTEXT_INVALID'
+
+
+def test_large_report_contract_uses_exact_section_pointers(tmp_path):
+    file, document = handoff_file(tmp_path)
+    document['handoff'].update(type='reportform', formNumber='sample_rpt', reportContract={
+        'formNumber': 'sample_rpt', 'dataSetColumns': [f'col_{i}' for i in range(1200)],
+        'dataSetColumnTypes': [{'fieldKey': f'col_{i}', 'algoDataType': 'LongType'} for i in range(1200)],
+        'columnPresentation': [], 'filterEnforcement': [], 'filterValueContracts': []})
+    file.write_text(json.dumps(document))
+    code, context, output = query(file, 'coding-start')
+    assert code == 0 and len(output.encode()) <= 16 * 1024
+    assert context['reportContract']['detailsOmitted'] is True
+    assert context['reportContract']['sections']['dataSetColumnTypes'] == {
+        'path': '/handoff/reportContract/dataSetColumnTypes', 'count': 1200}
+    assert 'formGraph' not in context
+    document['handoff']['reportContract']['dataSetColumnTypes'] = [False]
+    file.write_text(json.dumps(document))
+    assert query(file, 'coding-start')[1]['errorCode'] == 'HANDOFF_CODING_CONTEXT_INVALID'
+
+
+def test_changed_or_missing_prepared_input_rejects_old_success_snapshot(tmp_path):
+    file, document = handoff_file(tmp_path)
+    intent = tmp_path / 'intent.json'
+    intent.write_text('{"coreLogic":["old"]}')
+    document['inputFiles'] = [{'path': str(intent), 'sha256': hashlib.sha256(intent.read_bytes()).hexdigest()}]
+    file.write_text(json.dumps(document))
+    assert query(file, 'coding-start')[0] == 0
+    intent.write_text('{"coreLogic":["new"]}')
+    assert query(file, 'coding-start')[1]['errorCode'] == 'HANDOFF_INPUT_STALE'
+    document['inputFiles'][0]['path'] = str(tmp_path / 'missing.json')
+    file.write_text(json.dumps(document))
+    assert query(file, 'index')[1]['errorCode'] == 'HANDOFF_INPUT_STALE'
+    document['inputFiles'][0]['path'] = 'relative.json'
+    file.write_text(json.dumps(document))
+    assert query(file, 'index')[1]['errorCode'] == 'HANDOFF_INPUT_INVALID'
+
+
+def test_startup_keeps_main_form_enums_without_loading_all_related_form_values(tmp_path):
+    file, document = handoff_file(tmp_path)
+    source = {"fieldKey": "source", "fieldName": "来源", "entityKey": "booking_head",
+              "comboOptions": [{"label": "ERP", "value": "ERP"}, {"label": "BPM 转嫁数据", "value": "opt_2"}]}
+    related = [{"fieldKey": "category_" + str(index), "entityKey": "related_form",
+        "comboOptions": [{"label": "关联枚举" * 100, "value": str(index)}]} for index in range(50)]
+    document["handoff"]["stateFields"] = [source, *related]
+    file.write_text(json.dumps(document, ensure_ascii=False), encoding="utf-8")
+    before = file.read_bytes()
+    code, start, output = query(file, "coding-start")
+    assert code == 0 and len(output.encode("utf-8")) < 16384
+    assert start["stateFields"] == [source]
+    assert start["remainingContext"]["stateFields"] == "/handoff/stateFields"
+    assert "Main form only" in start["stateFieldsScope"]
+    code, value, _ = query(file, "get", "--path", "/handoff/stateFields/50")
+    assert code == 0 and value["value"] == related[-1]
+    assert file.read_bytes() == before
+
+
+def test_runtime_context_cli_reads_the_same_bound_target_and_never_renders_cards(tmp_path):
+    file, document = handoff_file(tmp_path)
+    app = tmp_path / "app/demo"
+    (app / "_runtime").mkdir(parents=True)
+    (app / "_runtime/context.json").write_text(json.dumps({"environment": {"baseUrl": "http://127.0.0.1:8080/ierp"}}))
+    url = "http://127.0.0.1:8080/ierp/?formId=bos_list&type=list&billFormId=booking"
+    archive = app / "archive.json"
+    archive.write_text(json.dumps({"artifacts": [{"formNumber": "booking", "listUrl": url}]}))
+    document["handoff"].update({"appRoot": str(app), "formNumber": "booking"})
+    file.write_text(json.dumps(document))
+    before = archive.read_bytes()
+    code, result, _ = query(file, "runtime-context")
+    assert code == 0 and result["runtime"]["listUrl"] == url
+    assert result["runtime"]["runtimeVerified"] is False
+    assert archive.read_bytes() == before
+    code, result, _ = query(file, "coding-start", "--resolve-entry")
+    assert code == 2 and result["errorCode"] == "HANDOFF_RUNTIME_ARGUMENT_INVALID"
+
+
+def test_startup_supplies_selected_signatures_without_changing_member_inventory(tmp_path):
+    file, document = handoff_file(tmp_path)
+    document["handoff"]["codingEvidence"]["guideSignatures"] = ["public void onPreparePropertys(PreparePropertysEventArgs e)"]
+    file.write_text(json.dumps(document))
+    code, result, output = query(file, "coding-start")
+    assert code == 0
+    contract = result["codingEvidence"]["apiContracts"][0]
+    assert contract["members"] == ["query"]
+    assert contract["signatures"][0]["signature"] == document["handoff"]["codingEvidence"]["apiContracts"][0]["members"][0]["signature"]
+    assert contract["import"] == "import kd.bos.servicehelper.QueryServiceHelper;"
+    assert result["codingEvidence"]["guideSignatures"] == document["handoff"]["codingEvidence"]["guideSignatures"]
+    assert result["entities"][1]["fields"][0]["timeValueUnit"] == "seconds-after-midnight"
+    assert result["runtimeContextCommand"][-1] == str(file)
+    assert len(output.encode()) <= 16 * 1024
+
+
+def test_time_empty_and_zero_contract_reaches_startup_without_another_lookup(tmp_path):
+    from prepare_plugin_handoff import _field_contract
+    file, document = handoff_file(tmp_path)
+    field = _field_contract({"fieldKey": "start_time", "fieldType": "TimeProp"})
+    assert "-1" in field["note"] and "Zero is valid midnight" in field["note"]
+    document["handoff"]["formGraph"]["entities"][1]["fields"] = [field]
+    file.write_text(json.dumps(document))
+    code, start, output = query(file, "coding-start")
+    assert code == 0
+    assert start["entities"][1]["fields"][0]["note"] == field["note"]
+    assert start["compileCommand"][-2:] == ["--handoff", str(file)]
+    assert len(output.encode()) <= 16 * 1024
+
+
+def test_operation_execution_locales_share_the_real_implementation():
+    root = SCRIPT.parents[1]
+    if root.name == "zh" and root.parent.name == ".locales":
+        root = root.parent.parent
+    for name in ["query_plugin_handoff.py", "compile_plugin_source.py", "prepare_plugin_handoff.py", "test_environment.py"]:
+        assert (root / "scripts" / name).read_bytes() == (root / ".locales/zh/scripts" / name).read_bytes()
+
+
+def test_bound_startup_returns_the_actual_target_test_command(tmp_path):
+    file, document = handoff_file(tmp_path)
+    document['handoff']['projectRoot'] = str(tmp_path)
+    file.write_text(json.dumps(document))
+    code, start, _ = query(file, 'coding-start')
+    assert code == 0
+    assert start['testCommand'] == [sys.executable, str(SCRIPT.with_name('run_java_tests.py')), '--project-root', str(tmp_path)]
+    assert Path(start['testCommand'][1]).is_file()
+
+
+def test_large_page_startup_exposes_exact_control_pointer(tmp_path):
+    file, document = handoff_file(tmp_path)
+    handoff = document["handoff"]
+    handoff.pop("formGraph")
+    handoff["formNumber"] = "sample_page"
+    handoff["uiContext"] = {"formNumber": "sample_page", "source": "getFormMetadata", "plugins": [],
+        "controls": [{"key": f"control_{index}", "type": "TextField"} for index in range(2000)]}
+    file.write_text(json.dumps(document), encoding="utf-8")
+    for operation in ("coding-start", "coding-context"):
+        code, result, output = query(file, operation)
+        assert code == 0 and len(output.encode()) < (16 if operation == "coding-start" else 48) * 1024
+        assert result["uiContext"]["controlCount"] == 2000
+        assert result["uiContext"]["controlsPath"] == "/handoff/uiContext/controls"
+    code, result, _ = query(file, "get", "--path", "/handoff/uiContext/controls/1999")
+    assert code == 0 and result["value"]["key"] == "control_1999"
+
+
+def test_selected_entity_metadata_cannot_be_replaced_by_page_context(tmp_path):
+    file, document = handoff_file(tmp_path)
+    document["handoff"].pop("formGraph")
+    document["handoff"].update({"formNumber": "sample_page", "metadataNeeds": ["form", "entity"],
+        "uiContext": {"formNumber": "sample_page", "source": "getFormMetadata", "controls": [], "plugins": []}})
+    file.write_text(json.dumps(document))
+    code, result, _ = query(file, "coding-start")
+    assert code == 2 and result["errorCode"] == "HANDOFF_CODING_CONTEXT_INVALID"

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

@@ -262,8 +262,9 @@ class MainTest(unittest.TestCase):
         mock_config.return_value = {"baseUrl": "https://api.example.com"}
 
         output = self._run()
-        self.assertEqual(output["status"], "success")
-        self.assertEqual(output["summary"]["success"], 1)
+        self.assertEqual(output["status"], "routed")
+        self.assertEqual(output["summary"], {"total": 1, "success": 0, "failed": 0, "deferred": 1})
+        mock_config.assert_not_called()
         self.assertIn("needs no registration call", output["results"][0]["message"])
         self.assertEqual(output["results"][0]["registeredBy"], "platform class discovery")
         self.assertFalse(output["results"][0]["registeredHere"])
@@ -610,10 +611,81 @@ class ReportPluginNotOwnedHereTest(unittest.TestCase):
         self.assertEqual(output["verification"]["status"], "not_run")
         self.assertEqual(output["verification"]["checks"], [])
         self.assertIn("nothing to verify", output["verification"]["reason"])
-        # not_run is not a failure: the class really is registered, elsewhere.
-        self.assertEqual(output["status"], "success")
+        # 转交不证明其他注册器已经执行，不能计入实际注册成功。
+        self.assertEqual(output["status"], "routed")
+        self.assertEqual(output["summary"], {"total": 1, "success": 0, "failed": 0, "deferred": 1})
+        self.assertFalse(output["results"][0]["success"])
+        mock_config.assert_not_called()
         mock_get.assert_not_called()
 
 
+class ReportFormPluginRegisteredHereTest(unittest.TestCase):
+    """A reportform plugin is the report form's own form plugin, registered and verified here.
+
+    The registry used to name the report pipeline as its registrar, and the pipeline writes only the
+    data-fetch slot and the left tree: the class was reported as owned elsewhere and never
+    registered, so the report's hyperlink, toolbar and header-filter handlers did nothing. The
+    plugin service registers a BILL_FORM target on the form's root plugin list, which for a report
+    is the report form, and queryEditable reads that list back as location BILL_FORM. Uses the real
+    registry on purpose: the registry entry is what this test pins.
+    """
+
+    def _run(self, extra_args=None):
+        argv = ["register_plugins.py", "--app-root", "/tmp"] + list(extra_args or [])
+        with mock.patch("builtins.print") as mock_print, mock.patch("sys.argv", argv):
+            register_plugins.main()
+        return json.loads(mock_print.call_args[0][0])
+
+    def test_the_registry_routes_report_form_plugins_to_the_form_plugin_list(self):
+        root = register_plugins._find_root_dir()
+        self.assertEqual(register_plugins._load_type_registry(root)["reportform"], "BILL_FORM")
+        self.assertEqual(register_plugins._load_type_owners(root)["reportform"], "plugin-register-api")
+        # The data-fetch and left-tree types stay with the report pipeline's own slots.
+        self.assertNotIn("reportlist", register_plugins._load_type_registry(root))
+        self.assertNotIn("reporttreelist", register_plugins._load_type_registry(root))
+
+    @mock.patch("register_plugins.kd_api.get")
+    @mock.patch("register_plugins.kd_api.post")
+    @mock.patch("register_plugins._load_config")
+    @mock.patch("register_plugins._load_classes_from_archive")
+    def test_report_form_plugin_registers_on_the_report_and_reads_back(
+        self, mock_load_classes, mock_config, mock_post, mock_get,
+    ):
+        mock_load_classes.return_value = [{
+            "className": "kd.uhyl.report.KpiDrillReportPlugin", "type": "reportform",
+            "formNumber": "uhyl_kpi_rpt", "description": "drill"}]
+        mock_config.return_value = {"baseUrl": "https://api.example.com"}
+        mock_post.return_value = {"status": True, "data": {"success": True, "message": ""}}
+        mock_get.return_value = {"status": True, "data": [
+            {"className": "kd.uhyl.report.KpiReportPlugin", "location": "REPORT_QUERY_PLUGIN"},
+            {"className": "kd.uhyl.report.KpiDrillReportPlugin", "location": "BILL_FORM"},
+        ]}
+
+        output = self._run(["--verify"])
+
+        self.assertEqual(output["status"], "success")
+        body = mock_post.call_args[0][3]
+        self.assertEqual(body["targetType"], "BILL_FORM")
+        self.assertEqual(body["formNumber"], "uhyl_kpi_rpt")
+        self.assertEqual(output["verification"]["status"], "pass")
+        self.assertTrue(output['results'][0]['registeredHere'])
+        self.assertTrue(output['results'][0]['verifiedHere'])
+        self.assertEqual(output["activation"]["registeredClasses"], ["kd.uhyl.report.KpiDrillReportPlugin"])
+
+    def test_mixed_report_delivery_distinguishes_registered_page_from_routed_query(self):
+        candidates = [{"className": "kd.sample.report.Query", "type": "reportlist", "formNumber": "sample_rpt"},
+                      {"className": "kd.sample.report.Page", "type": "reportform", "formNumber": "sample_rpt"}]
+        with mock.patch.object(register_plugins, '_load_classes_from_archive', return_value=candidates), \
+                mock.patch.object(register_plugins, '_load_config', return_value={'baseUrl': 'https://example.test'}), \
+                mock.patch.object(register_plugins.kd_api, 'post', return_value={'status': True, 'data': {'success': True}}), \
+                mock.patch.object(register_plugins.kd_api, 'get', return_value={'status': True, 'data': [
+                    {'className': 'kd.sample.report.Page', 'location': 'BILL_FORM'}]}):
+            output = self._run(['--verify'])
+        self.assertEqual(output['status'], 'partial')
+        self.assertEqual(output['summary'], {'total': 2, 'success': 1, 'failed': 0, 'deferred': 1})
+        self.assertFalse(output['results'][0]['verifiedHere'])
+        self.assertTrue(output['results'][1]['verifiedHere'])
+
+
 if __name__ == "__main__":
     unittest.main()