@shundoo-ai/dsh-cosmic 1.0.19 → 1.0.21

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

@@ -0,0 +1,195 @@
+"""Behavioral tests for the L0 plugin corpus tools (parser, index build, API usage measurement).
+
+The fixtures are real class files compiled by javac into small bos/biz/trd JARs. Platform class
+names deliberately match the type registry and API pages, so the measurement runs against the
+same registry and pages it uses on the real corpus.
+"""
+
+from __future__ import annotations
+
+import shutil
+import sqlite3
+import subprocess
+import sys
+import zipfile
+from pathlib import Path
+
+import pytest
+
+SCRIPTS = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(SCRIPTS))
+sys.path.insert(0, str(SCRIPTS / "plugin_corpus"))
+
+import build_index  # noqa: E402
+import jvm_classfile  # noqa: E402
+import measure_api_usage  # noqa: E402
+
+PLATFORM_SOURCES = {
+    "kd/sdk/annotation/SdkPlugin.java": """package kd.sdk.annotation;
+import java.lang.annotation.*;
+@Retention(RetentionPolicy.RUNTIME) @Target(ElementType.TYPE)
+public @interface SdkPlugin { String name() default ""; }
+""",
+    "kd/sdk/annotation/SdkInternal.java": """package kd.sdk.annotation;
+import java.lang.annotation.*;
+@Retention(RetentionPolicy.RUNTIME) @Target({ElementType.TYPE, ElementType.METHOD})
+public @interface SdkInternal { String[] reasons() default {}; }
+""",
+    "kd/bos/entity/plugin/AbstractOperationServicePlugIn.java": """package kd.bos.entity.plugin;
+@kd.sdk.annotation.SdkPlugin(name = "operation")
+public abstract class AbstractOperationServicePlugIn {
+    public Object[] getDataEntities() { return new Object[0]; }
+    public void onPreparePropertys(Object e) { }
+    @kd.sdk.annotation.SdkInternal(reasons = {"platform only"})
+    public void hidden() { }
+}
+""",
+    "kd/bos/servicehelper/Helper.java": """package kd.bos.servicehelper;
+public class Helper { public static void run() { } }
+""",
+}
+BUSINESS_SOURCES = {
+    "kd/fi/demo/DemoOp.java": """package kd.fi.demo;
+import kd.bos.entity.plugin.AbstractOperationServicePlugIn;
+import kd.bos.servicehelper.Helper;
+public class DemoOp extends AbstractOperationServicePlugIn {
+    @Override
+    public void onPreparePropertys(Object e) {
+        super.onPreparePropertys(e);
+        Object[] rows = getDataEntities();
+        hidden();
+        Helper.run();
+        Runnable later = new Runnable() { public void run() { getDataEntities(); } };
+        later.run();
+        try { Class.forName("kd.fi.demo.Registered"); } catch (ClassNotFoundException ignored) { }
+    }
+}
+""",
+    "kd/fi/demo/Util.java": """package kd.fi.demo;
+public class Util { public static void call() { kd.bos.servicehelper.Helper.run(); } }
+""",
+}
+THIRD_PARTY_SOURCES = {"org/demo/Lib.java": "package org.demo;\npublic class Lib { public int size() { return 1; } }\n"}
+
+
+def _jar(tmp: Path, name: str, sources: dict[str, str], classpath: list[Path] | None = None) -> Path:
+    source_root = tmp / f"src-{name}"
+    classes = tmp / f"classes-{name}"
+    files = []
+    for relative, text in sources.items():
+        path = source_root / relative
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(text, encoding="utf-8")
+        files.append(str(path))
+    classes.mkdir()
+    command = ["javac", "-d", str(classes)]
+    if classpath:
+        command += ["-cp", ":".join(str(item) for item in classpath)]
+    subprocess.run(command + files, check=True, capture_output=True)
+    jar = tmp / f"{name}.jar"
+    with zipfile.ZipFile(jar, "w") as archive:
+        archive.writestr("META-INF/MANIFEST.MF", "Manifest-Version: 1.0\nImplementation-Version: 9.9\n")
+        for path in sorted(classes.rglob("*.class")):
+            archive.write(path, path.relative_to(classes).as_posix())
+    return jar
+
+
+@pytest.fixture
+def library(tmp_path):
+    if not shutil.which("javac"):
+        pytest.skip("javac unavailable")
+    platform = _jar(tmp_path, "platform", PLATFORM_SOURCES)
+    business = _jar(tmp_path, "business", BUSINESS_SOURCES, [platform])
+    third = _jar(tmp_path, "lib", THIRD_PARTY_SOURCES)
+    root = tmp_path / "lib"
+    for layer, jar in (("bos", platform), ("biz", business), ("trd", third)):
+        (root / layer).mkdir(parents=True)
+        shutil.copy(jar, root / layer / jar.name)
+    return root
+
+
+def _class_bytes(jar: Path, entry: str) -> bytes:
+    with zipfile.ZipFile(jar) as archive:
+        return archive.read(entry)
+
+
+def test_class_file_reports_hierarchy_annotations_and_references(library):
+    parsed = jvm_classfile.parse_class(_class_bytes(library / "biz" / "business.jar", "kd/fi/demo/DemoOp.class"))
+    platform = jvm_classfile.parse_class(_class_bytes(
+        library / "bos" / "platform.jar", "kd/bos/entity/plugin/AbstractOperationServicePlugIn.class"))
+
+    assert parsed["name"] == "kd.fi.demo.DemoOp"
+    assert parsed["super"] == "kd.bos.entity.plugin.AbstractOperationServicePlugIn"
+    assert ("M", "kd.bos.entity.plugin.AbstractOperationServicePlugIn", "onPreparePropertys",
+            "(Ljava/lang/Object;)V") in parsed["memberRefs"]
+    assert ("M", "kd.bos.servicehelper.Helper", "run", "()V") in parsed["memberRefs"]
+    assert parsed["dynamicClassNames"] == ["kd.fi.demo.Registered"]
+    assert "kd.fi.demo.DemoOp$1" in parsed["classRefs"]
+    assert platform["annotations"] == ["kd.sdk.annotation.SdkPlugin"]
+    assert {name: annotations for name, _, _, annotations, _ in platform["methods"]}["hidden"] == (
+        "kd.sdk.annotation.SdkInternal",)
+
+
+def test_descriptors_convert_to_the_parameter_types_pages_write():
+    params, returned = jvm_classfile.descriptor_types("(Ljava/lang/String;[ILkd/bos/algo/DataSet$Listener;)V")
+
+    assert params == ["java.lang.String", "int[]", "kd.bos.algo.DataSet$Listener"]
+    assert returned == "void"
+    assert [jvm_classfile.simple_type(item) for item in params] == ["String", "int[]", "Listener"]
+    with pytest.raises(jvm_classfile.ClassFormatError):
+        jvm_classfile.parse_class(b"not a class")
+
+
+def test_index_rebuild_reuses_unchanged_jars_and_replaces_changed_ones(library, tmp_path):
+    workspace = tmp_path / "workspace"
+    first = build_index.build(str(library), [], str(workspace), ["biz"], workers=0)
+
+    assert first["jars"] == {"new": 3, "changed": 0, "unchanged": 0, "removed": 0}
+    assert {layer: data["classes"] for layer, data in first["layers"].items()} == {"biz": 3, "bos": 4, "trd": 1}
+    db = sqlite3.connect(str(workspace / build_index.DB_NAME))
+    refs_by_layer = dict(db.execute(
+        "SELECT j.layer, COUNT(r.class_id) FROM jars j JOIN classes c ON c.jar_id = j.id "
+        "LEFT JOIN refs r ON r.class_id = c.id GROUP BY j.layer"))
+    db.close()
+    assert refs_by_layer["biz"] > 0 and refs_by_layer["bos"] == 0 and refs_by_layer["trd"] == 0
+
+    assert build_index.build(str(library), [], str(workspace), ["biz"], workers=0)["jars"]["unchanged"] == 3
+
+    extra = dict(BUSINESS_SOURCES, **{"kd/fi/demo/More.java": "package kd.fi.demo;\npublic class More { }\n"})
+    rebuilt = _jar(tmp_path, "business2", extra, [library / "bos" / "platform.jar"])
+    shutil.copy(rebuilt, library / "biz" / "business.jar")
+    (library / "trd" / "lib.jar").unlink()
+    (library / "trd").rmdir()
+    second = build_index.build(str(library), [], str(workspace), ["biz"], workers=0)
+
+    assert second["jars"] == {"new": 0, "changed": 1, "unchanged": 1, "removed": 1}
+    assert second["layers"]["biz"]["classes"] == 4
+    assert "trd" not in second["layers"]
+
+
+def test_workspace_inside_the_skill_package_is_rejected(library):
+    with pytest.raises(build_index.CorpusIndexError) as error:
+        build_index.build(str(library), [], str(SCRIPTS / "plugin_corpus" / "workspace"), ["biz"], workers=0)
+
+    assert error.value.code == "CORPUS_WORKSPACE_INSIDE_REPOSITORY"
+    assert not (SCRIPTS / "plugin_corpus" / "workspace").exists()
+
+
+def test_measurement_labels_platform_references_and_checks_the_api_pages(library, tmp_path):
+    workspace = tmp_path / "workspace"
+    build_index.build(str(library), [], str(workspace), ["biz"], workers=0)
+    result = measure_api_usage.measure(str(workspace), top=10, platform_layers=["bos"], extra_roots=[])
+
+    assert result["population"]["pluginClasses"] == 1
+    assert result["population"]["pluginClassesByRegistryType"] == {"operation": 1}
+    assert result["population"]["classesIncludingNested"] == 2
+    members = {row["signature"]: row for key in ("topUndocumentedPublicMembers", "topNonPublicMembers",
+                                                 "topPublicConstructors") for row in result[key]}
+    assert members["void kd.bos.entity.plugin.AbstractOperationServicePlugIn.hidden()"]["label"] == "internal"
+    assert members["void kd.bos.servicehelper.Helper.run()"]["label"] == "unmarked"
+    assert members["void kd.bos.entity.plugin.AbstractOperationServicePlugIn.onPreparePropertys(java.lang.Object)"][
+        "documentation"] == "member-missing"
+    # getDataEntities() is on the real AbstractOperationServicePlugIn page, from both DemoOp and DemoOp$1.
+    assert result["measurements"]["publicReferenceDocumentation"]["documented"] == 2
+    assert result["measurements"]["pluginsUsingOnlyPublicPlatformMembers"] == 0
+    assert result["measurements"]["pluginsWithPlatformReferences"] == 1

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

@@ -1,12 +1,13 @@
 import json
 import sys
+import pytest
 from pathlib import Path
 
 
 SCRIPTS = Path(__file__).resolve().parents[1]
 sys.path.insert(0, str(SCRIPTS))
 
-from prepare_plugin_handoff import HandoffError, prepare_handoff  # noqa: E402
+from prepare_plugin_handoff import HandoffError, prepare_handoff, manifest_artifacts  # noqa: E402
 from resolve_output_path import resolve_output_path  # noqa: E402
 
 
@@ -31,6 +32,43 @@ def _artifact(form_name, form_key, entry_name, entry_key, fields):
     }
 
 
+def test_legacy_artifact_receipt_preserves_verified_peer_fields(tmp_path):
+    app_root = tmp_path / "app" / "sample_demo"
+    _write(app_root / "archive.json", {"appCode": "sample_demo"})
+    _java_project(tmp_path)
+    artifact = tmp_path / "emit" / "source.json"
+    _write(artifact, {"entities": [
+        {"id": "root", "displayName": "来源单", "type": "BillEntity", "entityKey": "sample_source", "fields": []},
+    ]})
+    peer = tmp_path / "emit" / "peer.json"
+    _write(peer, {"entities": [
+        {"id": "root", "displayName": "关联资料", "type": "BaseEntity", "entityKey": "sample_peer",
+         "fields": [{"displayName": "余额", "fieldKey": "sample_balance", "dataType": "AmountField"}]},
+    ]})
+    manifest = tmp_path / "emit" / "_emit_manifest.json"
+    _write(manifest, {"artifacts": [{"path": "source.json"}, {"path": str(peer)}]})
+    assert manifest_artifacts(str(manifest)) == [str(artifact), str(peer)]
+    result = tmp_path / "write.json"
+    _write(result, {"appRoot": str(app_root), "artifactPaths": [str(artifact), str(peer)], "results": [
+        {"artifact": path.name, "ok": True, "verification": {"status": "pass"},
+         "result": {"data": {"entityResults": [{"formNumber": number, "formName": name}]}}}
+        for path, number, name in [(artifact, "sample_source", "来源单"), (peer, "sample_peer", "关联资料")]
+    ]})
+    operations = tmp_path / "operations.json"
+    _write(operations, {"status": True, "data": [{"operationKey": "process"}]})
+    intent = {"form": "来源单", "trigger": "处理前", "operationKeys": ["process"],
+              "coreLogic": ["检查关联资料余额"],
+              "specialized": {"unresolvedDependencies": [], "externalContracts": [{"entity": "关联资料", "fields": ["余额"]}]}}
+    handoff = prepare_handoff(app_root=str(app_root), project_root=str(tmp_path), plugin_type="operation",
+        artifact_paths=[str(artifact), str(peer)], run_result=json.loads(result.read_text()), intent=intent,
+        operation_result=json.loads(operations.read_text()))["handoff"]
+    assert handoff["specialized"]["externalContracts"][0]["verifiedFields"][0]["fieldKey"] == "sample_balance"
+    assert handoff["fqcn"].endswith("." + handoff["className"])
+    assert Path(handoff["sourcePath"]).name == handoff["className"] + ".java"
+    assert not Path(handoff["sourcePath"]).exists()
+    assert handoff["codingEvidence"]["baseContract"]["status"] is True
+
+
 def test_resolve_output_path_uses_same_app_package_not_project_common_prefix(tmp_path):
     app_root = tmp_path / "app" / "uhyl_demo"
     _write(app_root / "archive.json", {"appCode": "uhyl_demo"})
@@ -592,6 +630,11 @@ def test_report_handoff_carries_filter_requirements_the_platform_dropped(tmp_pat
     # comparison is, so query() has to apply between / in / = itself.
     assert [row["requirement"] for row in enforcement] == ["compare", "mustInput"]
     assert {row["filterKey"] for row in enforcement} == {"flt_period"}
+    values = payload["reportContract"]["filterValueContracts"]
+    assert values[0]["filterKey"] == "flt_period"
+    assert values[0]["valueChannel"] == "getValue"
+    assert values[0]["rangeItemKeys"] is None
+    assert values[0]["runtimeKeysVerified"] is False
 
 
 def test_report_handoff_compiles_the_contract_instead_of_trusting_a_persisted_one(tmp_path):
@@ -871,6 +914,15 @@ def test_modify_carries_the_methods_the_target_class_already_declares(tmp_path):
     assert payload["sourcePath"] == str(source.resolve())
 
 
+def test_modify_fqcn_follows_existing_source_package(tmp_path):
+    source = _existing_plugin(tmp_path, "UhylTargetBillPlugin")
+    source.write_text(source.read_text().replace("package kd.bos.app.uhyl.demo.form;", "package custom.extension;"))
+    payload = _billform_handoff(tmp_path, _modify_intent(source))["handoff"]
+    assert payload["packagePath"] == "custom/extension"
+    assert payload["fqcn"] == "custom.extension.UhylTargetBillPlugin"
+    assert payload["sourcePath"] == str(source.resolve())
+
+
 def test_patch_existing_is_accepted_as_modify_instead_of_losing_the_intent(tmp_path):
     source = _existing_plugin(tmp_path, "UhylTargetBillPlugin")
 
@@ -1013,6 +1065,13 @@ def test_scalar_field_gets_its_java_type_and_no_accessor_advice(tmp_path):
     assert "valueAccessor" not in contract
 
 
+def test_time_only_field_does_not_retype_datetime_field():
+    from prepare_plugin_handoff import _field_java_type
+    assert _field_java_type("TimeProp") == "Integer"
+    assert _field_java_type("TimeField") == "Integer"
+    assert _field_java_type("DateTimeField") == "java.util.Date"
+
+
 def test_a_field_whose_type_the_artifact_omits_gets_no_contract(tmp_path):
     """A report column carries no dataType; an invented accessor would read as verified."""
     app_root = tmp_path / "app" / "kdec_yzxz"
@@ -1036,3 +1095,289 @@ def test_a_field_whose_type_the_artifact_omits_gets_no_contract(tmp_path):
 
     assert handoff["fields"] == {"kdec_remark": "kdec_remark"}
     assert "fieldContracts" not in handoff
+
+
+def test_prepare_reads_only_missing_evidence_and_keeps_operation_state_contract(tmp_path, monkeypatch):
+    import prepare_plugin_handoff as module
+    _java_project(tmp_path)
+    app_root = tmp_path / "app" / "sample_demo"
+    _write(app_root / "archive.json", {"appCode": "sample_demo"})
+    source = tmp_path / "source.json"
+    peer = tmp_path / "peer.json"
+    _write(source, {"entities": [{"displayName": "来源单", "type": "BillEntity", "entityKey": "sample_source", "fields": [
+        {"id": "state-id", "displayName": "阶段", "fieldKey": "sample_phase", "dataType": "ComboField",
+         "comboOptions": [{"label": "待处理", "value": "pending"}]}]}]})
+    _write(peer, {"entities": [{"displayName": "资料", "type": "BaseEntity", "entityKey": "sample_peer", "fields": [
+        {"displayName": "余额", "fieldKey": "sample_balance", "dataType": "AmountField"}]}]})
+    receipt = {"appRoot": str(app_root), "results": [
+        {"artifact": str(p), "ok": True, "verification": {"status": "pass"},
+         "result": {"data": {"entityResults": [{"formName": n, "formNumber": k}]}}}
+        for p, n, k in [(source, "来源单", "sample_source"), (peer, "资料", "sample_peer")]]}
+    operations = {"status": True, "data": {"operations": [{"operationKey": "process", "operationName": "处理",
+                   "parameter": {"StatusFieldId": "state-id", "Value": "B"}}]}}
+    schema = {"status": True, "data": {"formNumber": "sample_external", "formName": "外部资料", "entities": [
+        {"entityKey": "sample_external", "entityName": "外部资料", "fields": [
+            {"fieldKey": "sample_quantity", "fieldName": "数量", "fieldType": "IntegerField"}]}]}}
+    responses = tmp_path / "responses.json"
+    _write(responses, {"listOperations": operations, "getFormSchema": schema})
+    api = tmp_path / "fixture_api.py"
+    calls = tmp_path / "calls.jsonl"
+    # Run a real child CLI; only its remote service response is replaced by local fixtures.
+    api.write_text("import sys,json\nfrom pathlib import Path\n"
+        f"responses=json.loads(Path({str(responses)!r}).read_text())\n"
+        "command=next(v for v in sys.argv if v in responses)\n"
+        f"with Path({str(calls)!r}).open('a') as f: f.write(json.dumps(sys.argv[1:])+'\\n')\n"
+        "Path(sys.argv[sys.argv.index('--output')+1]).write_text(json.dumps(responses[command]))\n")
+    monkeypatch.setattr(module, "COSMIC_API", api)
+    intent = {"form": "来源单", "trigger": "处理前", "operationKeys": ["process"], "fields": {"phase": "阶段"},
+        "coreLogic": ["检查关联资料余额和外部数量，按业务规则处理"],
+        "scenes": ["operation/cross-entity-aggregate-writeback"],
+        "specialized": {"unresolvedDependencies": [], "externalContracts": [
+            {"entity": "资料", "fields": ["余额"]}, {"entity": "sample_external", "fields": ["数量"]}]}}
+    operation_result, schemas = module.prepare_inputs(app_root=str(app_root), intent=intent, plugin_type="operation",
+        artifact_paths=[str(source), str(peer)], run_result=receipt, operation_result=None, external_schemas=[])
+    result = prepare_handoff(app_root=str(app_root), project_root=str(tmp_path), plugin_type="operation", intent=intent,
+        artifact_paths=[str(source), str(peer)], run_result=receipt, operation_result=operation_result, external_schemas=schemas)
+    recorded = [json.loads(line) for line in calls.read_text().splitlines()]
+    assert len(recorded) == 2
+    assert sum("listOperations" in args for args in recorded) == 1
+    assert sum("getFormSchema" in args for args in recorded) == 1
+    assert all(str(app_root.resolve()) == args[args.index("--app-root") + 1] for args in recorded)
+    assert result["handoff"]["operationContracts"][0]["parameter"]["Value"] == "B"
+    assert result["handoff"]["stateWarnings"][0]["code"] == "OPERATION_STATE_VALUE_MISMATCH"
+    assert result["handoff"]["fieldContracts"][0]["comboOptions"][0]["value"] == "pending"
+    assert len(result["handoff"]["description"]) <= 20
+    assert result["handoff"]["codingEvidence"]["apiContracts"]
+
+
+def test_unverified_entity_diagnostics_include_all_missing_targets(tmp_path):
+    import pytest
+    with pytest.raises(HandoffError) as error:
+        _external_handoff(tmp_path, [{"entity": "missing_one", "fields": ["id"]},
+                                     {"entity": "missing_two", "fields": ["id"]}])
+    assert "missing_one" in str(error.value) and "missing_two" in str(error.value)
+
+
+def test_failed_operation_readback_is_never_positive_evidence():
+    import pytest
+    from prepare_plugin_handoff import _verified_operation_keys
+    with pytest.raises(HandoffError, match="did not succeed"):
+        _verified_operation_keys({"status": True, "data": {"success": False, "operations": [{"operationKey": "process"}]}})
+
+
+def test_failed_evidence_child_does_not_accept_its_partial_json(tmp_path, monkeypatch):
+    import pytest
+    import prepare_plugin_handoff as module
+    source = tmp_path / "source.json"
+    _write(source, {"entities": [{"displayName": "来源单", "type": "BillEntity", "entityKey": "sample_source", "fields": []}]})
+    api = tmp_path / "failed_api.py"
+    api.write_text("import sys\nfrom pathlib import Path\n"
+        "Path(sys.argv[sys.argv.index('--output')+1]).write_text('{\"status\":true}')\n"
+        "sys.exit(1)\n")
+    monkeypatch.setattr(module, "COSMIC_API", api)
+    with pytest.raises(HandoffError) as error:
+        module.prepare_inputs(app_root=str(tmp_path), intent={"form": "来源单", "operationKeys": ["process"], "coreLogic": ["校验资料"],
+                "specialized": {"unresolvedDependencies": []}},
+            plugin_type="operation", artifact_paths=[str(source)], run_result=None, operation_result=None, external_schemas=[])
+    assert error.value.error_code == "PLUGIN_EVIDENCE_READ_FAILED"
+
+
+def test_recorded_runtime_graph_resolves_header_entries_and_subentries_without_artifacts(tmp_path):
+    from prepare_plugin_handoff import runtime_catalog
+    native = json.loads((Path(__file__).parent / "fixtures/java_context_booking_native.json").read_text())
+    _java_project(tmp_path)
+    app = tmp_path / "app" / "sample_app"
+    _write(app / "archive.json", {"appCode": "sample_app"})
+    intent = {"form": "定场单", "trigger": "保存时", "operationKeys": ["save"], "coreLogic": ["校验场地时段冲突"],
+        "fields": {"date": {"form": "定场单", "entity": "header", "field": "定场日期"},
+                   "price": {"form": "定场单", "entity": "entries", "field": "单价"},
+                   "servicePrice": {"form": "定场单", "entity": "subentries", "field": "单价"}},
+        "specialized": {"unresolvedDependencies": []}}
+    result = prepare_handoff(app_root=str(app), project_root=str(tmp_path), plugin_type="operation", intent=intent,
+        artifact_paths=[str(tmp_path / "absent-authoring-artifact.json")], runtime_metadata=[native],
+        operation_result={"status": True, "data": [{"operationKey": "save"}]})
+    handoff = result["handoff"]
+    assert handoff["fields"]["date"] == "sample_booking_date"
+    assert handoff["fields"]["price"] == "sample_unit_price"
+    assert handoff["fields"]["servicePrice"] == "sample_svc_price"
+    graph = handoff["formGraph"]["entities"]
+    assert [entity["role"] for entity in graph] == ["header", "entries", "subentries"]
+    assert graph[2]["parentEntityKey"] == graph[1]["entityKey"]
+    # The runtime property differs from the authoring sub-entry key in the observed session.
+    assert graph[2]["collectionProperty"] == "sample_booking_order_e"
+    assert graph[2]["collectionPath"] == ["sample_bookin_order_line", "sample_booking_order_e"]
+    start_time = next(field for field in graph[1]["fields"] if field["fieldKey"] == "sample_start_time")
+    assert start_time["fieldType"] == "TimeProp"
+    assert start_time["javaType"] == "Integer"
+    assert start_time["valueAccessor"] == 'getInt("sample_start_time")'
+    assert start_time["timeValueUnit"] == "seconds-after-midnight"
+    _, _, raw_fields, _ = runtime_catalog([native])
+    assert sum(len(entity["fields"]) for entity in graph) == len(raw_fields) == 37
+    assert all(field["entityKey"] == entity["entityKey"] for entity in graph for field in entity["fields"])
+    assert next(field for field in graph[2]["fields"] if field["fieldKey"] == "sample_svc_price")["fieldPath"] == \
+        "sample_bookin_order_line.sample_booking_order_e.sample_svc_price"
+
+
+def test_runtime_context_without_field_declarations_still_has_the_complete_graph(tmp_path):
+    native = json.loads((Path(__file__).parent / "fixtures/java_context_booking_native.json").read_text())
+    _java_project(tmp_path)
+    app = tmp_path / "app" / "sample_app"
+    _write(app / "archive.json", {"appCode": "sample_app"})
+    result = prepare_handoff(app_root=str(app), project_root=str(tmp_path), plugin_type="operation",
+        intent={"form": "定场单", "trigger": "保存时", "operationKeys": ["save"], "coreLogic": ["校验场地状态"],
+                "specialized": {"unresolvedDependencies": []}}, artifact_paths=[], runtime_metadata=[native],
+        operation_result={"status": True, "data": [{"operationKey": "save"}]})
+    assert len(result["handoff"]["formGraph"]["entities"]) == 3
+    fields = [field for entity in result["handoff"]["formGraph"]["entities"] for field in entity["fields"]]
+    assert any(field["fieldKey"] == "sample_court" for field in fields)
+    assert any(field["fieldKey"] == "sample_member" for field in fields)
+    assert any(field["fieldKey"] == "sample_status" for field in fields)
+    assert result["handoff"]["fields"] == {}  # No keyword-based selection is needed to preserve fields.
+
+
+def test_runtime_collection_property_is_not_assumed_to_be_the_item_entity_name():
+    from prepare_plugin_handoff import runtime_catalog
+    _, entities, fields, _ = runtime_catalog([{"Name": "sample_main", "Properties": [
+        {"Name": "lines", "_Type_": "EntryProp", "ItemType": {"Name": "sample_line_type", "Properties": [
+            {"Name": "qty", "_Type_": "DecimalProp"}]}}]}])
+    assert entities[1]["entityKey"] == "sample_line_type"
+    assert entities[1]["collectionProperty"] == "lines"
+    assert fields[0]["fieldPath"] == "lines.qty"
+
+
+def test_runtime_collection_missing_item_metadata_cannot_be_ready():
+    import pytest
+    from prepare_plugin_handoff import runtime_catalog
+    with pytest.raises(HandoffError) as error:
+        runtime_catalog([{"Name": "sample_main", "Properties": [{"Name": "lines", "_Type_": "EntryProp"}]}])
+    assert error.value.error_code == "PLUGIN_CONTEXT_INCOMPLETE"
+
+
+def test_duplicate_runtime_field_names_return_scoped_candidates(tmp_path):
+    import pytest
+    from prepare_plugin_handoff import runtime_catalog, _resolve_field
+    native = json.loads((Path(__file__).parent / "fixtures/java_context_booking_native.json").read_text())
+    _, _, fields, _ = runtime_catalog([native])
+    with pytest.raises(HandoffError) as error:
+        _resolve_field(fields, {"form": "定场单", "field": "单价"})
+    assert "sample_unit_price" in str(error.value)
+    assert "sample_svc_price" in str(error.value)
+
+
+def test_external_contract_requires_exact_live_field_identity():
+    from prepare_plugin_handoff import _external_field
+    scope = [{"entityKey": "sample_court", "entityName": "场地档案", "fields": {
+        "sample_court_status": {"fieldName": "场地状态"},
+    }}]
+    assert _external_field(scope, "场地状态")[1] == "sample_court_status"
+    assert _external_field(scope, "sample_court_status")[1] == "sample_court_status"
+    with pytest.raises(HandoffError, match="sample_court_status"):
+        _external_field(scope, "court_status")
+
+
+@pytest.mark.parametrize("with_receipt", [False, True])
+@pytest.mark.parametrize("full_output", [False, True])
+def test_independent_cli_reads_native_metadata_without_modeling_receipts(tmp_path, monkeypatch, capsys, with_receipt, full_output):
+    import prepare_plugin_handoff as module
+    native = json.loads((Path(__file__).parent / "fixtures/java_context_booking_native.json").read_text())
+    _java_project(tmp_path)
+    config = tmp_path / "appconfig.json"
+    _write(config, {"compile": False})
+    monkeypatch.setenv("KD_APPCONFIG", str(config))
+    app = tmp_path / "app" / "sample_app"
+    _write(app / "archive.json", {"appCode": "sample_app"})
+    responses = tmp_path / "responses.json"
+    _write(responses, {"getEntityType": {"sample_booking_order": native,
+        "sample_court": {"status": True, "data": {"Name": "sample_court", "DisplayName": {"zh_CN": "场地档案"},
+            "Properties": [{"Name": "sample_court_status", "DisplayName": {"zh_CN": "场地状态"}, "_Type_": "ComboProp"}]}},
+        "sample_member": {"status": True, "data": {"Name": "sample_member", "DisplayName": {"zh_CN": "会员档案"},
+            "Properties": [{"Name": "sample_balance", "DisplayName": {"zh_CN": "余额"}, "_Type_": "AmountProp"}]}}},
+        "listOperations": {"status": True, "data": {"formNumber": "sample_booking_order", "operations": [{"operationKey": "save"}]}}})
+    calls = tmp_path / "calls.jsonl"
+    api = tmp_path / "fixture_api.py"
+    api.write_text("import sys,json\nfrom pathlib import Path\n"
+        f"responses=json.loads(Path({str(responses)!r}).read_text())\n"
+        "command=next(v for v in sys.argv if v in responses)\n"
+        "value=responses[command]\n"
+        "if command=='getEntityType': value=value[sys.argv[sys.argv.index('--entityId')+1]]\n"
+        f"with Path({str(calls)!r}).open('a') as f: f.write(json.dumps(sys.argv[1:])+'\\n')\n"
+        "Path(sys.argv[sys.argv.index('--output')+1]).write_text(json.dumps(value))\n")
+    monkeypatch.setattr(module, "COSMIC_API", api)
+    intent = {"form": "定场单", "trigger": "保存时", "operationKeys": ["save"], "coreLogic": ["校验场地状态"],
+        "fields": {"date": {"form": "定场单", "entity": "header", "field": "定场日期"}},
+        "specialized": {"unresolvedDependencies": [], "externalContracts": [{"entity": "场地档案", "fields": ["场地状态"]}]}}
+    args = ["prepare_plugin_handoff.py", "--app-root", str(app), "--java-project-root", str(tmp_path),
+            "--type", "operation", "--intent-json", json.dumps(intent), "--prepare-source"]
+    if with_receipt:
+        receipt = tmp_path / "old-receipt.json"
+        _write(receipt, {"appRoot": str(app), "artifactPaths": [str(tmp_path / "absent-artifact.json")],
+                        "forms": [{"formNumber": "sample_booking_order", "formName": "定场单"}]})
+        args += ["--run-result", str(receipt)]
+    else:
+        args += ["--form-number", "sample_booking_order"]
+    if full_output:
+        args += ["--full-output"]
+    monkeypatch.setattr(sys, "argv", args)
+    module.main()
+    result = json.loads(capsys.readouterr().out)
+    assert result["status"] is True
+    assert Path(result["handoffPath"]).is_file()
+    saved = json.loads(Path(result["handoffPath"]).read_text())
+    assert len(saved["handoff"]["formGraph"]["entities"]) == 3
+    assert saved["handoff"]["fields"]["date"] == "sample_booking_date"
+    if full_output:
+        assert result["handoff"] == saved["handoff"]
+    else:
+        assert result["contextMode"] == "reference-only"
+        assert "formGraph" not in result["handoff"]
+        assert result["metadata"]["forms"][0]["metadataSource"] == "getEntityType"
+    recorded = [json.loads(line) for line in calls.read_text().splitlines()]
+    assert sum("listOperations" in call for call in recorded) == 1
+    native_reads = [call[call.index("--entityId") + 1] for call in recorded if "getEntityType" in call]
+    assert sorted(native_reads) == ["sample_booking_order", "sample_court", "sample_member"]
+    assert all(str(app.resolve()) == call[call.index("--app-root") + 1] for call in recorded)
+    assert Path(result["handoff"]["sourcePath"]).parent.is_dir()
+    assert not Path(result["handoff"]["sourcePath"]).exists()
+
+
+def test_large_native_coding_context_is_saved_completely_without_truncating_stdout(tmp_path):
+    from prepare_plugin_handoff import handoff_response
+    native = json.loads((Path(__file__).parent / "fixtures/java_context_booking_native.json").read_text())
+    native["data"]["Properties"] += [
+        {"Name": f"sample_extra_{index}", "DisplayName": {"zh_CN": f"补充字段{index}"}, "_Type_": "TextProp"}
+        for index in range(600)
+    ]
+    _java_project(tmp_path)
+    app = tmp_path / "app" / "sample_app"
+    _write(app / "archive.json", {"appCode": "sample_app"})
+    handoff = prepare_handoff(
+        app_root=str(app), project_root=str(tmp_path), plugin_type="operation", artifact_paths=[],
+        runtime_metadata=[native], operation_result={"status": True, "data": [{"operationKey": "save"}]},
+        intent={"form": "sample_booking_order", "trigger": "保存时", "operationKeys": ["save"],
+                "scenes": ["operation/custom-validator"], "coreLogic": ["校验补充字段"],
+                "specialized": {"unresolvedDependencies": [], "externalContracts": []}},
+    )["handoff"]
+    target = tmp_path / "handoff.json"
+    result = {"status": True, "handoffPath": str(target), "handoff": handoff}
+    _write(target, result)
+    stdout = json.dumps(handoff_response(result), ensure_ascii=False).encode("utf-8")
+    assert len(target.read_bytes()) > 50 * 1024
+    assert len(stdout) < 12 * 1024
+    assert json.loads(target.read_text())["handoff"] == handoff
+    assert handoff_response(result, full_output=True)["handoff"] == handoff
+    assert json.loads(stdout)["metadata"]["forms"][0]["fieldCount"] >= 600
+
+
+def test_prepared_class_assignment_cannot_be_silently_overwritten(tmp_path):
+    from prepare_plugin_handoff import assert_handoff_replace, HandoffError
+    target = tmp_path / "handoff.json"
+    result = {"status": True, "handoff": {"fqcn": "sample.Plugin", "operationKeys": ["save"], "coreLogic": ["validate"]}}
+    _write(target, result)
+    original = target.read_bytes()
+    assert_handoff_replace(target, result)
+    revised = {"status": True, "handoff": {**result["handoff"], "operationKeys": ["confirm"]}}
+    with pytest.raises(HandoffError) as error:
+        assert_handoff_replace(target, revised)
+    assert error.value.error_code == "PLUGIN_HANDOFF_CONFLICT"
+    assert target.read_bytes() == original
+    assert_handoff_replace(target, revised, replace=True)