@shundoo-ai/dsh-cosmic 1.0.19 → 1.0.21

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

@@ -10,9 +10,150 @@ sys.path.insert(0, str(ROOT / "skills/cosmic-meta-modeling/scripts"))
 sys.path.insert(0, str(ROOT / "skills/cosmic-meta-api/scripts"))
 import data_model_emit as emitter
 import cosmic_api as cli
+from _core import cmd_forms
 from _core.number_validator import validate_page_number
 
 
+def test_emitter_resolves_template_name_before_preset_read(monkeypatch, tmp_path):
+    entity = {"type": "BillEntity", "bizName": "order", "templateKey": "单据带组织模版"}
+    section = {"artifact": {"entities": [entity]}}
+    calls = []
+    def run(_path, command, args, *, app_root):
+        calls.append((command, args))
+        rows = ([{"number": "vendor_org_template", "name": "单据带组织模板",
+                  "modelType": "BillFormModel"}]
+                if command == "queryPublicTemplates" and args["modelType"] == "BillFormModel" else [])
+        return {"status": True, "data": {"success": True, "templates": rows}}
+    monkeypatch.setattr(emitter, "_run_cosmic_api", run)
+    class Logs:
+        def info(self, *args, **kwargs): pass
+        def warn(self, *args, **kwargs): pass
+        def err(self, *args, **kwargs): raise AssertionError(args)
+    assert emitter._validate_template_keys(section, Logs(), "cosmic_api.py", app_root=tmp_path)
+    assert entity["templateKey"] == "vendor_org_template"
+    assert calls == [("queryPublicTemplates", {"modelType": "BillFormModel"})]
+
+
+def test_emitter_rejects_unknown_template_before_batch(monkeypatch, tmp_path):
+    section = {"artifact": {"entities": [{
+        "type": "BillEntity", "bizName": "order", "templateKey": "bill_template",
+    }]}}
+    class Logs:
+        errors = []
+        def info(self, *args, **kwargs): pass
+        def warn(self, *args, **kwargs): pass
+        def err(self, code, message, **kwargs): self.errors.append((code, message))
+    def run(_path, command, args, *, app_root):
+        if command == "getEntityFields":
+            return {"status": False, "data": None}
+        return {"status": True, "data": {"success": True, "templates": [
+            {"number": "bos_billtpl", "name": "单据模板", "modelType": "BillFormModel"},
+            {"number": "blankPage", "name": "空白页面", "modelType": "BillFormModel"},
+        ]}}
+    monkeypatch.setattr(emitter, "_run_cosmic_api", run)
+    logs = Logs()
+    assert not emitter._validate_template_keys(section, logs, "cosmic_api.py", app_root=tmp_path)
+    assert logs.errors[0][0] == "INVALID-TEMPLATEKEY"
+    assert "bos_billtpl" in logs.errors[0][1]
+
+
+def test_emitter_checks_exact_template_when_catalog_is_unavailable(monkeypatch, tmp_path):
+    section = {"artifact": {"entities": [{
+        "type": "BillEntity", "bizName": "order", "templateKey": "bos_billtpl",
+    }]}}
+    class Logs:
+        errors = []
+        warnings = []
+        def info(self, *args, **kwargs): pass
+        def warn(self, code, message, **kwargs): self.warnings.append(code)
+        def err(self, code, message, **kwargs): self.errors.append(code)
+    def run(_path, command, args, *, app_root):
+        if command == "getEntityFields":
+            return {"status": True, "data": {"headerFields": {
+                "headerKey": args["formNumber"], "fields": [],
+            }}}
+        return None
+    monkeypatch.setattr(emitter, "_run_cosmic_api", run)
+    logs = Logs()
+    assert emitter._validate_template_keys(section, logs, "cosmic_api.py", app_root=tmp_path)
+    assert "TEMPLATE-NOT-LISTED" in logs.warnings
+    assert logs.errors == []
+
+
+def test_catalog_failure_cannot_approve_unverified_template(monkeypatch, tmp_path):
+    section = {"artifact": {"entities": [{
+        "type": "BillEntity", "bizName": "order", "templateKey": "bill_template",
+    }]}}
+    class Logs:
+        errors = []
+        def info(self, *args, **kwargs): pass
+        def warn(self, *args, **kwargs): pass
+        def err(self, code, message, **kwargs): self.errors.append(code)
+    monkeypatch.setattr(emitter, "_run_cosmic_api", lambda *args, **kwargs: None)
+    logs = Logs()
+    assert not emitter._validate_template_keys(section, logs, "cosmic_api.py", app_root=tmp_path)
+    assert logs.errors == ["TEMPLATE-LOOKUP-UNAVAILABLE"]
+
+
+def test_template_subprocess_keeps_app_binding_when_cwd_is_project_root(tmp_path, monkeypatch):
+    project = tmp_path / "project"
+    app_root = project / "app" / "demo"
+    runtime = app_root / "_runtime"
+    runtime.mkdir(parents=True)
+    (app_root / "archive.json").write_text(json.dumps({
+        "type": "cosmic", "appCode": "demo", "appId": "APP-ID",
+    }))
+    (runtime / "context.json").write_text(json.dumps({
+        "appCode": "demo", "appRoot": str(app_root), "projectRoot": str(project),
+    }))
+    # Real subprocess and path initialization, with transport isolated from the platform.
+    script = tmp_path / "template_cli.py"
+    script.write_text(
+        "import json, sys\n"
+        f"sys.path.insert(0, {str(ROOT / 'skills/cosmic-meta-api/scripts')!r})\n"
+        "from _core import config\n"
+        "config._init_paths(app_root=sys.argv[sys.argv.index('--app-root') + 1])\n"
+        "rows = [] if sys.argv[2] == 'queryBizTemplates' else "
+        "[{'number': 'bos_billtpl', 'name': 'Bill', 'modelType': 'BillFormModel'}]\n"
+        "print(json.dumps({'status': True, 'data': {'success': True, 'templates': rows}}))\n"
+    )
+    monkeypatch.chdir(project)
+    section = {"artifact": {"entities": [{
+        "type": "BillEntity", "bizName": "order", "templateKey": "bos_billtpl",
+    }]}}
+    logs = emitter._Logs(app_root)
+    assert "_section_io" not in section
+    assert emitter._validate_template_keys(section, logs, str(script), app_root=app_root)
+    assert not logs.errors
+    assert (runtime / "cosmic-metadata" / "workspace.json").is_file()
+    assert not (project / "_runtime").exists()
+    assert not (project / "metadata").exists()
+    assert not (project / "modify").exists()
+    assert not (project / "app" / "_runtime").exists()
+
+
+def test_failed_child_query_preserves_underlying_error(tmp_path, capsys):
+    script = tmp_path / "failed_cli.py"
+    script.write_text(
+        "import json, sys\n"
+        "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 "APP_ROOT_IDENTITY_INVALID" in capsys.readouterr().err
+
+
+def test_template_query_normalizes_legacy_model_type(monkeypatch):
+    calls = []
+    monkeypatch.setattr(cmd_forms, "_api_call", lambda *args, **kwargs: calls.append(args) or {
+        "status": True, "data": {"templates": []},
+    })
+    cmd_forms.do_query_public_templates({}, "token", "FormModel_Bill")
+    cmd_forms.do_query_biz_templates({}, "token", "FormModel_Base", biz_app_number="demo")
+    assert calls[0][3] == {"modelType": "BillFormModel"}
+    assert calls[1][3] == {"modelType": "BaseFormModel", "bizAppNumber": "demo"}
+
+
 @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}]}}

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

@@ -4,6 +4,7 @@ from __future__ import annotations
 import builtins
 import ast
 import json
+import os
 import subprocess
 import sys
 from contextlib import redirect_stderr, redirect_stdout
@@ -69,7 +70,8 @@ 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": "source", "fieldType": "ComboField", "combo": "线上,电话"},
+        {"name": "来源", "bizWord": "source", "fieldType": "ComboField",
+         "comboOptions": [{"label": "线上", "value": "online"}, {"label": "电话", "value": "phone"}]},
     ]), encoding="utf-8")
     result = subprocess.run([sys.executable, str(COSMIC_SCRIPTS / "cosmic_api.py"),
         "--stdout", "addField", "--form-name", "missing_form", "--project-root", str(tmp_path),
@@ -561,6 +563,7 @@ def test_rule_domain_binding_rejects_two_form_selectors() -> None:
 def test_rule_domain_catalog_exposes_form_name_and_optional_entity() -> None:
     commands = (
         "ensureFieldCalculation",
+        "ensureTimeDifferenceCalculation",
         "ensureConditionalFieldState",
         "ensureConditionalEntryStyle",
         "ensureConditionalControlState",
@@ -1495,9 +1498,32 @@ def test_catalog_invoke_rejects_effects_and_runtime_override(tmp_path: Path) ->
         raise AssertionError("unavailable action must not be invoked")
 
 
+@pytest.mark.parametrize("root_name", ["project", "app"])
+def test_project_or_app_container_cannot_be_used_as_app_root(tmp_path, root_name):
+    root = tmp_path / root_name
+    root.mkdir()
+    previous = cosmic_config.RUNTIME_DIR
+    with pytest.raises(ValueError, match="APP_ROOT_IDENTITY_INVALID"):
+        cosmic_config._init_paths(app_root=root)
+    assert cosmic_config.RUNTIME_DIR == previous
+    assert list(root.iterdir()) == []
+
+
+def test_unbound_session_does_not_create_application_artifact_directories(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+    with mock.patch.dict(vars(cosmic_config)):
+        cosmic_config._init_paths(temp_dir=str(tmp_path / "session"))
+        assert Path(cosmic_config.WORKSPACE_JSON).exists()
+        assert not Path(cosmic_config.ARTIFACTS_DIR).exists()
+        assert not Path(cosmic_config.BATCH_MANIFESTS_DIR).exists()
+
+
 def test_explicit_app_root_controls_every_runtime_path(tmp_path: Path) -> None:
     app_root = tmp_path / "app" / "kdtest_demo"
     app_root.mkdir(parents=True)
+    (app_root / "archive.json").write_text(json.dumps({
+        "type": "cosmic", "appCode": "kdtest_demo", "appId": "APP-ID",
+    }))
     names = (
         "RUNTIME_DIR",
         "TOKEN_CACHE",
@@ -1510,11 +1536,14 @@ def test_explicit_app_root_controls_every_runtime_path(tmp_path: Path) -> None:
         "WORKSPACE_JSON",
     )
     previous = {name: getattr(cosmic_config, name) for name in names}
+    previous_binding = getattr(cosmic_config, "_BOUND_APP_ROOT", None)
+    previous_project_root = os.environ.get("PROJECT_ROOT")
     try:
-        cosmic_config._init_paths(app_root=app_root)
+        cosmic_api._retarget_runtime_dir(app_root)
         assert Path(cosmic_config.RUNTIME_DIR) == (
             app_root / "_runtime" / "cosmic-metadata"
         )
+        assert os.environ["PROJECT_ROOT"] == str(app_root.resolve())
         assert Path(cosmic_config.ARTIFACTS_DIR) == app_root / "metadata"
         assert Path(cosmic_config.BATCH_MANIFESTS_DIR) == app_root / "modify"
         assert Path(cosmic_config._get_temp_dir()) == Path(
@@ -1522,6 +1551,11 @@ def test_explicit_app_root_controls_every_runtime_path(tmp_path: Path) -> None:
         )
         assert not (app_root / "app").exists()
     finally:
+        if previous_project_root is None:
+            os.environ.pop("PROJECT_ROOT", None)
+        else:
+            os.environ["PROJECT_ROOT"] = previous_project_root
+        cosmic_config._BOUND_APP_ROOT = previous_binding
         for name, value in previous.items():
             setattr(cosmic_config, name, value)
 

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

@@ -18,7 +18,79 @@ 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,
     unverified_import_issues, unverified_member_issues,
+    describe_api, plugin_coding_evidence, scene_misuse_issues,
 )
+sys.path.append(str(SCRIPTS.parents[2] / "scripts" if SCRIPTS.parent.parent.name == ".locales" else SCRIPTS))
+
+
+def test_api_lookup_distinguishes_same_named_members_by_receiver():
+    plugin = describe_api("AbstractOperationServicePlugIn", ["getDataEntities"])
+    validator = describe_api("AbstractValidator", ["getDataEntities"])
+    event = describe_api("BeforeOperationArgs", ["getDataEntities", "setCancel"])
+    assert plugin["members"][0]["deprecated"] is True
+    assert "DynamicObject[]" in plugin["members"][0]["signature"]
+    assert all(not item["deprecated"] for item in validator["members"])
+    assert any("ExtendedDataEntity[]" in item["signature"] for item in validator["members"])
+    assert {item["name"] for item in event["members"]} == {"getDataEntities", "setCancel"}
+    assert describe_api("BeforeOperationArgs", ["missingExport"])["undocumentedMembers"] == ["missingExport"]
+
+
+def test_mistyped_platform_package_suggests_only_a_registered_candidate():
+    result = describe_api("kd.bos.service.BusinessDataServiceHelper", ["loadSingle"])
+    assert result["status"] is False
+    assert result["errorCode"] == "API_CLASS_NOT_DOCUMENTED"
+    assert result["candidateClass"] == "kd.bos.servicehelper.BusinessDataServiceHelper"
+    assert Path(result["candidateReference"]).is_file()
+    assert Path(result["sdkLookup"]["script"]).is_file()
+
+
+def test_coding_evidence_uses_registered_type_and_exact_argument_references():
+    evidence = plugin_coding_evidence("operation")
+    assert evidence["baseContract"]["class"] == "kd.bos.entity.plugin.AbstractOperationServicePlugIn"
+    assert any("beforeExecuteOperationTransaction" in signature for signature in evidence["guideSignatures"])
+    assert any(item["class"] == "kd.bos.entity.plugin.args.BeforeOperationArgs" for item in evidence["parameterTypes"])
+    assert all(Path(item["reference"]).is_file() for item in evidence["parameterTypes"])
+    assert evidence["operationDispatch"]["transactionEvent"]["accessor"] == "event.getOperationKey()"
+    assert evidence["operationDispatch"]["validator"]["accessor"] == "this.getOperateKey()"
+
+
+def test_validator_in_same_file_does_not_hide_operation_receiver_misuse():
+    source = '''
+import kd.bos.entity.plugin.AbstractOperationServicePlugIn;
+import kd.bos.entity.validate.AbstractValidator;
+public class SamplePlugin extends AbstractOperationServicePlugIn {
+    public void onAddValidators(AddValidatorsEventArgs e) {
+        e.addValidator(new AbstractValidator() {
+            public void validate() {
+                this.getDataEntities();
+                SamplePlugin.this.getDataEntities();
+            }
+        });
+    }
+    private void inspect() { this.getDataEntities(); }
+    public void beginOperationTransaction(BeginOperationTransactionArgs e) { e.getDataEntities(); }
+}
+'''
+    issues = scene_misuse_issues(source)
+    assert len(issues) == 2
+    assert {source.splitlines()[issue["line"] - 1].strip() for issue in issues} == {
+        "SamplePlugin.this.getDataEntities();", "private void inspect() { this.getDataEntities(); }",
+    }
+
+
+def test_named_validator_and_an_unrelated_class_keep_their_own_receiver():
+    source = '''
+import kd.bos.entity.plugin.AbstractOperationServicePlugIn;
+import kd.bos.entity.validate.AbstractValidator;
+public class SamplePlugin extends kd.bos.entity.plugin.AbstractOperationServicePlugIn {
+    private void inspect() { getDataEntities(); }
+}
+class Validator extends AbstractValidator { public void validate() { this.getDataEntities(); } }
+class Other { public void inspect() { this.getDataEntities(); } }
+'''
+    issues = scene_misuse_issues(source)
+    assert len(issues) == 1
+    assert issues[0]["line"] == 5
 
 
 def _source(body: str, imports: str = "") -> str:
@@ -207,6 +279,32 @@ def test_a_string_operator_names_the_qcp_constant_to_use():
     assert "QCP.not_in" in issues[0]["message"]
 
 
+def test_recorded_qcp_equal_typo_returns_the_verified_constant_before_javac():
+    source = _filter_source('        QFilter f = new QFilter("id", QCP.equal, id);\n').replace(
+        "import kd.bos.orm.query.QFilter;", "import kd.bos.orm.query.QFilter;\nimport kd.bos.orm.query.QCP;")
+    issues = filter_operator_issues(source)
+    assert len(issues) == 1
+    assert issues[0]["constant"] == "QCP.equals"
+    assert '"="' not in issues[0]["message"]
+    assert filter_operator_issues(source.replace("QCP.equal,", "QCP.equals,")) == []
+
+
+def test_a_project_qcp_class_is_not_judged_against_platform_constants():
+    source = _filter_source('        QFilter f = new QFilter("id", QCP.equal, id);\n').replace(
+        "import kd.bos.orm.query.QCP;\n", "")
+    assert filter_operator_issues(source) == []
+
+
+def test_pre_post_scene_provides_query_load_save_and_filter_evidence():
+    evidence = plugin_coding_evidence("operation", ["operation/custom-validator", "operation/pre-post-operation"])
+    assert Path(evidence["codingEntry"]).is_file()
+    classes = {item["class"]: item for item in evidence["apiContracts"]}
+    assert "kd.bos.servicehelper.QueryServiceHelper" in classes
+    assert any(item["name"] == "loadSingle" for item in classes["kd.bos.servicehelper.BusinessDataServiceHelper"]["members"])
+    assert any(item["name"] == "update" for item in classes["kd.bos.servicehelper.operation.SaveServiceHelper"]["members"])
+    assert next(item for item in evidence["filterOperators"] if item["literal"] == "=")["constant"] == "QCP.equals"
+
+
 def test_an_operator_with_a_public_helper_is_told_to_use_the_helper():
     """`"is null"` used to be reported as QCP.is_null, an @SdkInternal constant the same page tells
     the coding step to avoid in favour of QFilter.isNull."""
@@ -694,6 +792,38 @@ def test_a_jdk_root_member_on_a_platform_receiver_is_exempt():
     )) == []
 
 
+def test_generic_methods_on_the_pages_are_registered():
+    """`public <T extends Control> T getControl(String key)` declares its type parameters before
+    the return type. The signature pattern used to skip such lines, so IFormView.getControl and
+    IDataModel.getContextVariable looked unregistered: describe-class sent the coding step to the
+    SDK for a documented member, and an ordinary call was reported as a remembered spelling."""
+    view = _page("kd.bos.form.IFormView")
+    model = _page("kd.bos.entity.datamodel.IDataModel")
+
+    assert ("String",) in view["signatures"]["getControl"]
+    assert "getControl" in view["genericReturns"]
+    assert ("String",) in model["signatures"]["getContextVariable"]
+    assert [item["name"] for item in describe_api("kd.bos.form.IFormView", ["getControl"])["members"]] == ["getControl"]
+
+
+def test_ordinary_calls_to_generic_members_are_not_findings():
+    source = (
+        "package demo;\n"
+        "import kd.bos.form.control.Button;\n"
+        "import kd.bos.form.plugin.AbstractFormPlugin;\n"
+        "public class DemoPlugin extends AbstractFormPlugin {\n"
+        "    @Override\n"
+        "    public void registerListener(java.util.EventObject e) {\n"
+        "        Button ok = this.getView().getControl(\"btnok\");\n"
+        "        Object value = this.getModel().getContextVariable(\"key\");\n"
+        "    }\n"
+        "}\n"
+    )
+
+    assert unverified_member_issues(source) == []
+    assert return_type_issues(source) == []
+
+
 def test_a_real_service_lookup_is_not_a_truncated_name():
     """`getService(Class)` is IView's generic service lookup — the scenes call it — while the
     page registers only `getServiceAppId(String)`. A pure truncation is deliberately not a
@@ -805,7 +935,7 @@ def test_the_generated_index_reports_no_drift():
     import subprocess
 
     result = subprocess.run(
-        [sys.executable, str(SCRIPTS / "gen_api_index.py"), "--check"],
+        [sys.executable, str((SCRIPTS.parents[2] / "scripts" if SCRIPTS.parent.parent.name == ".locales" else SCRIPTS) / "gen_api_index.py"), "--check"],
         capture_output=True, text=True)
 
     assert result.returncode == 0, result.stdout + result.stderr
@@ -824,3 +954,33 @@ def test_the_scenes_verified_block_holds_only_pageless_imports():
     assert pageless, "the exemption block is empty, so the contract is vacuous"
     assert all(_page(fqcn) is None for fqcn in pageless)
     assert _scenes_verified_imports() == _registered_fqcns() | pageless
+
+
+def test_selected_scene_expands_data_service_signatures_and_real_paths():
+    evidence = plugin_coding_evidence("operation", ["operation/cross-entity-aggregate-writeback"])
+    contracts = {entry["class"]: entry for entry in evidence["apiContracts"]}
+    assert "kd.bos.servicehelper.operation.SaveServiceHelper" in contracts
+    query = contracts["kd.bos.servicehelper.QueryServiceHelper"]
+    assert any("DynamicObjectCollection" in item["signature"] for item in query["members"] if item["name"] == "query")
+    load = contracts["kd.bos.servicehelper.BusinessDataServiceHelper"]
+    assert any("Object pk, String entityName" in item["signature"] for item in load["members"] if item["name"] == "loadSingle")
+    assert all(Path(entry["reference"]).is_file() for entry in contracts.values())
+    assert all(Path(scene).is_file() for scene in evidence["scenes"])
+
+
+def test_scene_return_types_provide_verified_imports_for_validator_entities():
+    evidence = plugin_coding_evidence("operation", ["operation/custom-validator"])
+    types = {entry["class"]: entry for entry in evidence["signatureTypes"]}
+    extended = types["kd.bos.entity.ExtendedDataEntity"]
+    assert extended["import"] == "import kd.bos.entity.ExtendedDataEntity;"
+    assert Path(extended["reference"]).is_file()
+    validator = next(entry for entry in evidence["apiContracts"] if entry["class"] == "kd.bos.entity.validate.AbstractValidator")
+    assert any("ExtendedDataEntity[]" in member["signature"] for member in validator["members"])
+    assert len(types) == len(evidence["signatureTypes"])
+    assert all(Path(entry["reference"]).is_file() for entry in types.values())
+
+
+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"])

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

@@ -3,6 +3,8 @@ from __future__ import annotations
 import importlib
 import json
 import sys
+import tempfile
+import hashlib
 import unittest
 from pathlib import Path
 
@@ -12,6 +14,8 @@ API_SCRIPTS = APP_BUILD_ROOT / "skills" / "cosmic-meta-api" / "scripts"
 if str(API_SCRIPTS) not in sys.path:
     sys.path.insert(0, str(API_SCRIPTS))
 
+sys.path.insert(0, str(APP_BUILD_ROOT / "scripts"))
+
 cmd_plugins = importlib.import_module("_core.cmd_plugins")
 
 
@@ -100,5 +104,92 @@ class PluginBusinessContractTest(unittest.TestCase):
         self.assertEqual("fpk-1", verification["fpk"])
 
 
+class LocalJavaRegistrationTest(unittest.TestCase):
+    def check(self, source, archived_type, requested_target, *, declared_path=None):
+        with tempfile.TemporaryDirectory() as tmp:
+            file = Path(tmp, "Example.java")
+            file.write_text(source, encoding="utf-8")
+            Path(tmp, "archive.json").write_text(json.dumps({"javas": [{
+                "className": "example.Example", "type": archived_type,
+                "filePath": declared_path or str(file),
+                "sourceHash": hashlib.sha256(file.read_bytes()).hexdigest(), "compileStatus": "passed",
+            }]}), encoding="utf-8")
+            # Invalid inputs must fail before _api_call can access these absent credentials.
+            return cmd_plugins.validate_local_java_registration(tmp, {
+                "className": "example.Example", "targetType": requested_target,
+            })
+
+    def test_form_plugin_cannot_be_retargeted_to_save_to_bypass_registration_failure(self):
+        with self.assertRaisesRegex(ValueError, "PLUGIN_REGISTRATION_TYPE_MISMATCH"):
+            self.check("public class Example extends AbstractFormPlugin {}", "form", "OPERATION")
+
+    def test_removing_the_plugin_base_to_pass_javac_does_not_allow_registration(self):
+        with self.assertRaisesRegex(ValueError, "PLUGIN_SOURCE_BASE_CLASS_MISSING"):
+            self.check("public class Example { public void beginOperationTransaction() {} }",
+                       "operation", "OPERATION")
+
+    def test_source_and_registration_target_must_agree_even_if_archive_type_was_changed(self):
+        with self.assertRaisesRegex(ValueError, "PLUGIN_SOURCE_TARGET_MISMATCH"):
+            self.check("public class Example extends AbstractFormPlugin {}", "operation", "OPERATION")
+
+    def test_direct_registration_does_not_bypass_a_missing_archive_source(self):
+        with self.assertRaisesRegex(ValueError, "PLUGIN_LOCAL_SOURCE_UNVERIFIED"):
+            self.check("public class Example extends AbstractFormPlugin {}", "form", "BILL_FORM",
+                       declared_path="example/Example.java")
+
+    def test_valid_form_and_operation_sources_pass_the_local_consistency_check(self):
+        self.assertEqual(self.check("public class Example extends AbstractFormPlugin {}", "form", "BILL_FORM")["compileStatus"], "passed")
+        self.assertEqual(self.check("public class Example extends AbstractOperationServicePlugIn {}", "operation", "OPERATION")["compileStatus"], "passed")
+
+    def test_existing_deployed_class_without_local_declaration_remains_supported(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            Path(tmp, "archive.json").write_text('{"javas": []}', encoding="utf-8")
+            self.assertIsNone(cmd_plugins.validate_local_java_registration(tmp, {
+                "className": "existing.Plugin", "targetType": "BILL_FORM",
+            }))
+
+
 if __name__ == "__main__":
     unittest.main()
+
+
+def test_both_registration_entries_reject_manual_and_stale_archive(tmp_path, monkeypatch, capsys):
+    import hashlib
+    import register_plugins
+    source = tmp_path / "Example.java"
+    source.write_text("public class Example extends AbstractFormPlugin {}")
+    entry = {"className": "example.Example", "type": "form", "filePath": str(source),
+             "formNumber": "example", "description": "example", "operationKey": ""}
+    config = {"className": "example.Example", "targetType": "BILL_FORM"}
+    monkeypatch.setattr(sys, "argv", ["register_plugins.py", "--app-root", str(tmp_path)])
+    def no_auth(*a, **k):
+        raise AssertionError("invalid source must be rejected before credentials or platform calls")
+    monkeypatch.setattr(register_plugins, "_load_config", no_auth)
+    for expected in ["PLUGIN_SOURCE_NOT_READY", "PLUGIN_SOURCE_CHANGED"]:
+        (tmp_path / "archive.json").write_text(json.dumps({"javas": [entry]}))
+        with unittest.TestCase().assertRaisesRegex(ValueError, expected):
+            cmd_plugins.do_register_plugin({}, None, "example", config, app_root=str(tmp_path))
+        assert register_plugins.main() == 2
+        assert json.loads(capsys.readouterr().out)["errorCode"] == expected
+        entry.update(compileStatus="passed", sourceHash=hashlib.sha256(source.read_bytes()).hexdigest())
+        source.write_text(source.read_text() + "\n// changed after compilation")
+
+
+def test_explicit_compile_skip_is_reported_as_skip_not_compile_pass(tmp_path):
+    import hashlib
+    source = tmp_path / "Example.java"
+    source.write_text("public class Example extends AbstractFormPlugin {}")
+    (tmp_path / "archive.json").write_text(json.dumps({"javas": [{
+        "className": "example.Example", "type": "form", "filePath": str(source),
+        "sourceHash": hashlib.sha256(source.read_bytes()).hexdigest(), "compileStatus": "skipped-by-config",
+    }]}))
+    result = cmd_plugins.validate_local_java_registration(str(tmp_path), {"className": "example.Example", "targetType": "BILL_FORM"})
+    assert result["compileStatus"] == "skipped-by-config"
+
+
+def test_serve_registration_requires_application_context_before_platform_access():
+    import cosmic_api
+    with unittest.TestCase().assertRaisesRegex(ValueError, "SERVE_APP_ROOT_REQUIRED"):
+        cosmic_api._dispatch_serve({}, None, "registerPlugin", {
+            "formNumber": "example", "pluginConfig": {"className": "example.Plugin", "targetType": "BILL_FORM"},
+        })