@shundoo-ai/dsh-cosmic 1.0.19 → 1.0.21

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

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import argparse
 import importlib
 import json
 import sys
@@ -225,7 +226,7 @@ class AddRuleBusinessContractTest(unittest.TestCase):
         mismatches = cosmic_api._rule_readback_mismatches(expected, observed, metadata)
         self.assertTrue(any(item["path"].endswith(".Fields") for item in mismatches))
 
-    def test_form_rule_rejects_unknown_and_unsupported_ret_bits(self) -> None:
+    def test_rule_ret_accepts_designer_after_copy_and_rejects_unknown_bits(self) -> None:
         with self.assertRaisesRegex(ValueError, "RULE_RET_UNKNOWN_EVENT_BIT"):
             rule_contract.normalize_rule_config(
                 {
@@ -239,19 +240,89 @@ class AddRuleBusinessContractTest(unittest.TestCase):
                     ],
                 }
             )
-        with self.assertRaisesRegex(ValueError, "RULE_RET_UNSUPPORTED"):
-            rule_contract.normalize_rule_config(
-                {
-                    "ruleType": "formRule",
-                    "trueActions": [
-                        {
-                            "actionType": "HideFieldAction",
-                            "fields": ["field_b"],
-                            "RET": 4,
-                        }
-                    ],
-                }
-            )
+        for action_type, original in rule_contract._EVENT_CONTRACT["actionMasks"].items():
+            with self.subTest(action=action_type):
+                for bit in rule_contract._EVENT_CONTRACT["eventBits"]:
+                    rule_contract.validate_action_ret(action_type, int(bit))
+                rule_contract.validate_action_ret(action_type, 2047)
+                merged = rule_contract.merge_action_events(
+                    action_type, original, ["复制后"],
+                )
+                self.assertEqual(original | 1024, merged)
+                self.assertEqual(merged, rule_contract.merge_action_events(
+                    action_type, merged, ["AfterCopy"],
+                ))
+        for action_type, rule_type, target_args, ret in (
+            ("HideFieldAction", "formRule", {"fields": ["field_b"]}, 1275),
+            ("CallFieldChangeAction", "bizRule", {"expression": "field_b"}, 1797),
+        ):
+            result = rule_contract.normalize_rule_config({
+                "ruleType": rule_type,
+                "trueActions": [{"actionType": action_type, "ret": ret, **target_args}],
+            })
+            self.assertEqual(ret, result["trueActions"][0]["RET"])
+        with self.assertRaisesRegex(ValueError, "RULE_ACTION_CONTRACT_BLOCKED"):
+            rule_contract.validate_action_ret("SetVisibleAction", 1024)
+        for invalid in (True, "1024", 0, -1):
+            with self.subTest(invalid=invalid):
+                with self.assertRaisesRegex(ValueError, "RULE_RET_INVALID"):
+                    rule_contract.validate_action_ret("ClearValueAction", invalid)
+        business = rule_contract.normalize_rule_config({
+            "ruleType": "bizRule",
+            "trueActions": [{
+                "actionType": "ClearValueAction", "expression": "field_b",
+                "RET": 1021 | 1024,
+            }],
+        })
+        self.assertEqual(2045, business["trueActions"][0]["RET"])
+        self.assertEqual(2045, rule_contract.merge_action_events(
+            "ClearValueAction", 1021, ["复制后", "AfterCopy"],
+        ))
+        self.assertEqual(1025, rule_contract.select_action_events(
+            "CallFieldChangeAction", ["字段值变化", "复制后"],
+        ))
+        self.assertEqual(1027, rule_contract.select_action_events(
+            "HideFieldAction", ["加载", "字段值变化", "复制后"],
+        ))
+        self.assertEqual(1021, rule_contract.merge_action_events(
+            "ClearValueAction", 253,
+            ["新建", "字段值变化", "创建后", "字段值变化后"],
+        ))
+        self.assertEqual(1021, rule_contract.merge_action_events(
+            "ClearValueAction", 253,
+            ["Create", "FieldChange", "AfterCreate", "AfterFieldChange"],
+        ))
+        with self.assertRaisesRegex(ValueError, "RULE_EVENT_UNKNOWN"):
+            rule_contract.merge_action_events("ClearValueAction", 253, ["typo"])
+        with self.assertRaisesRegex(ValueError, "RULE_EVENTS_INVALID"):
+            rule_contract.merge_action_events("ClearValueAction", 253, "AfterCopy")
+
+    def test_clear_fields_cli_retains_every_repeated_target(self) -> None:
+        class Parsed(Exception):
+            def __init__(self, value):
+                self.value = value
+
+        original = argparse.ArgumentParser.parse_args
+
+        def capture(parser, _args=None, namespace=None):
+            return_value = original(parser, arguments, namespace)
+            raise Parsed(return_value)
+
+        prefix = [
+            "ensureConditionalClearFields", "--formNumber", "demo",
+            "--condition-field", "数量", "--operator", "greater-than", "--value", "10",
+        ]
+        for suffix in (
+            ["--target", "单价", "--target", "备注"],
+            ["--target", "单价", "备注"],
+        ):
+            arguments = prefix + suffix + ["--add-event", "新建"]
+            with self.subTest(suffix=suffix):
+                with mock.patch.object(cosmic_api._CliArgumentParser, "parse_args", capture):
+                    with self.assertRaises(Parsed) as result:
+                        cosmic_api._main_impl()
+                self.assertEqual(["单价", "备注"], result.exception.value.targets)
+                self.assertEqual(["新建"], result.exception.value.add_events)
 
     def test_direct_rule_enables_trigger_field_event_before_write(self) -> None:
         rule = {"triggerField": "字段A(uhyl_field_a);uhyl_field_c"}

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

@@ -34,14 +34,23 @@ class GeneratedLocaleAssetsTest(unittest.TestCase):
         result = module.inspect()
         self.assertTrue(result["ok"], result)
         self.assertEqual(
-            {"control-authoring-v1", "data-model-compiler-v1", "entry-write-v1", "existing-form-ui-v1",
+            {"control-authoring-v1", "data-model-compiler-v1", "dym-sync-contract-v2",
+             "entry-write-v1", "existing-form-ui-v1",
+             "kingscript-gate-v1", "mcp-server-v1", "metalog-v1",
              "operation-contract-harvest-v1", "operation-write-v1",
-             "plugin-handoff-v1", "kingscript-gate-v1",
-             "report-tests-v1", "report-write-v1", "rule-write-v1"},
+             "plugin-handoff-v1", "property-policy-contract-v1", "python-runtime-v1",
+             "report-tests-v1", "report-write-v1", "rule-write-v1", "execution-recovery-v1", "plugin-handoff-query-v1"},
             set(result["families"]),
         )
         self.assertEqual(len(result["files"]), result["counts"]["in_sync"])
 
+    def test_execution_recovery_mirrors_are_machine_synced(self) -> None:
+        module = _load_sync_module()
+        result = module.inspect(["execution-recovery-v1"])
+        self.assertTrue(result["ok"], result)
+        self.assertIn("skills/cosmic-meta-api/scripts/_core/build_receipts.py",
+                      module.GENERATED_FAMILIES["execution-recovery-v1"])
+
     def test_report_test_mirrors_are_machine_synced_not_hand_maintained(self) -> None:
         """Of the 37 test mirrors that predate this family, 32 had drifted.
 

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

@@ -23,7 +23,6 @@ from build_meta_order import (  # noqa: E402
     BuildDependencyError,
     bind_ref_bill_ids,
     collect_ref_bill_targets,
-    dependency_blocked_results,
     plan_build_waves,
     split_deferred_ref_bill_writes,
     split_deferred_property_fields,
@@ -461,21 +460,6 @@ class TestBuildMetaOrder(unittest.TestCase):
                 set(map(os.path.abspath, paths)),
             )
 
-    def test_failed_wave_blocks_all_later_writes(self):
-        waves = [
-            ["/tmp/product.json", "/tmp/member.json"],
-            ["/tmp/order.json"],
-            ["/tmp/order_rules.json"],
-        ]
-        blocked = dependency_blocked_results(waves, failed_wave_index=1)
-        self.assertEqual(
-            [item["artifact"] for item in blocked],
-            ["order.json", "order_rules.json"],
-        )
-        self.assertTrue(
-            all(item["errorCode"] == "DEPENDENCY_WAVE_FAILED" for item in blocked)
-        )
-        self.assertTrue(all(item["phase"] == "dependency" for item in blocked))
 
 
 if __name__ == "__main__":

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

@@ -0,0 +1,87 @@
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[2]
+MODELING = ROOT / "skills/cosmic-meta-modeling/scripts"
+
+
+def run(script, *args):
+    return subprocess.run([sys.executable, str(script), *args], capture_output=True, text=True)
+
+
+def test_compiler_describes_the_existing_schema_without_workspace_or_platform(tmp_path):
+    result = run(MODELING / "data_model_emit.py", "--describe")
+    assert result.returncode == 0, result.stderr
+    contract = json.loads(result.stdout)
+    assert contract["inputSchema"] == json.loads((ROOT / "schemas/data-model-authoring.schema.json").read_text())
+    assert {arg["flags"][0] for arg in contract["arguments"] if arg["required"]} == {"--app-root", "--authoring-file"}
+    assert contract["execution"]["argvPrefix"][1] == str(MODELING / "data_model_emit.py")
+    localized = run(ROOT / ".locales/zh/skills/cosmic-meta-modeling/scripts/data_model_emit.py", "--describe")
+    assert localized.returncode == 0, localized.stderr
+    assert json.loads(localized.stdout)["inputSchema"] == contract["inputSchema"]
+    authoring = contract["authoringContract"]
+    assert json.loads(localized.stdout)["authoringContract"] == {
+        **authoring,
+        "templateFieldInspection": {
+            **authoring["templateFieldInspection"],
+            "argv": [sys.executable, str(ROOT / ".locales/zh/skills/cosmic-meta-api/scripts/cosmic_api.py"),
+                     *authoring["templateFieldInspection"]["argv"][2:]],
+        },
+    }
+    assert authoring["callerFieldInputs"] == contract["inputSchema"]["definitions"]["field"]["required"]
+    sys.path.insert(0, str(MODELING))
+    from data_model_emit import _apply_direct_authoring_constraints
+    for kind, template in authoring["defaultTemplates"].items():
+        section = {"artifact": {"entities": [{"type": kind, "fields": []}]}}
+        _apply_direct_authoring_constraints(section)
+        assert section["artifact"]["entities"][0]["templateKey"] == template
+        selected = {"artifact": {"entities": [{"type": kind, "templateKey": "explicit_template", "fields": []}]}}
+        _apply_direct_authoring_constraints(selected)
+        assert selected["artifact"]["entities"][0]["templateKey"] == "explicit_template"
+    inspection = authoring["templateFieldInspection"]["argv"]
+    help_result = run(Path(inspection[1]), "--stdout", "getEntityFields", "--help")
+    assert help_result.returncode == 0, help_result.stderr
+    assert all(flag in help_result.stdout for flag in ("--app-root", "--formNumber"))
+    assert not list(tmp_path.iterdir())
+
+
+def test_catalog_queries_reuse_source_and_unknown_types_fail():
+    script = MODELING / "field_type_registry.py"
+    full = json.loads(run(script, "--catalog").stdout)
+    selected = json.loads(run(script, "--catalog", "--types", "DateField", "BasedataField", "TextField").stdout)
+    assert selected["fieldTypes"] == [x for x in full["fieldTypes"] if x["name"] in {"DateField", "BasedataField", "TextField"}]
+    compact = json.loads(run(script, "--catalog", "--compact").stdout)
+    assert [(x["name"], x["semantics"]) for x in compact["fieldTypes"]] == [(x["name"], x["semantics"]) for x in full["fieldTypes"]]
+    assert len(json.dumps(compact)) < len(json.dumps(full))
+    assert run(script, "--catalog", "--types", "InventedField").returncode != 0
+
+
+def test_saved_receipt_exposes_next_command_without_inventing_verification(tmp_path, capsys):
+    api_scripts = ROOT / "skills/cosmic-meta-api/scripts"
+    sys.path.insert(0, str(api_scripts))
+    from _core import formatters
+
+    output = tmp_path / "receipt.json"
+    receipt = {"success": 1, "failed": 1, "results": [
+        {"ok": True, "phase": "buildMeta", "verification": {"status": "pass"}},
+        {"ok": False, "phase": "unknown", "error": "response lost"},
+    ], "delivery": {"command": ["python", "render.py", "--form-number", "verified-target"]},
+        "doNotRetryBuildMeta": True, "reconcile": {"ready": True}}
+    formatters.set_output_file(str(output))
+    formatters.set_stdout_mode(False)
+    try:
+        formatters.pjson(receipt)
+        summary = json.loads(capsys.readouterr().out.split("RESULT_SUMMARY=", 1)[1])
+        assert json.loads(output.read_text()) == receipt
+        assert summary["delivery"] == receipt["delivery"]
+        assert summary["doNotRetryBuildMeta"] is True
+        assert summary["results"][0]["verification"] == {"status": "pass"}
+        assert "verification" not in summary["results"][1]
+        formatters.set_stdout_mode(True)
+        formatters.pjson(receipt)
+        assert json.loads(capsys.readouterr().out) == receipt
+    finally:
+        formatters.set_stdout_mode(False)
+        formatters.set_output_file(None)

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

@@ -1,4 +1,6 @@
 import json
+import os
+import subprocess
 import sys
 from pathlib import Path
 from types import SimpleNamespace
@@ -23,6 +25,29 @@ def test_resolve_module_uses_project_dir_mapping(tmp_path):
     assert resolve_module(gradle_root, module_root) == ":demo"
 
 
+def test_compile_environment_reports_only_configured_sdk_libraries(tmp_path, monkeypatch):
+    gradle = tmp_path / "gradle"
+    project = gradle / "code" / "demo"
+    project.mkdir(parents=True)
+    (gradle / "settings.gradle").write_text("include(':demo')\nproject(':demo').projectDir = new File('code/demo')\n")
+    sdk = tmp_path / "target-sdk"
+    bos = sdk / "mservice-cosmic" / "lib" / "bos"
+    bos.mkdir(parents=True)
+    (bos / "target.jar").write_bytes(b"")
+    (sdk / "mservice" / "lib" / "bos").mkdir(parents=True)
+    (sdk / "mservice" / "lib" / "bos" / "other.jar").write_bytes(b"")
+    (gradle / "gradle.properties").write_text(f"systemProp.cosmic_home={sdk}\nsecret.password=not-read\n")
+    (gradle / "config.gradle").write_text('cosmic_libs_path = "${cosmic_home}/mservice-cosmic/lib"\npath = [bos : "${cosmic_libs_path}/bos"]\n')
+    monkeypatch.setattr(compile_plugin_source, "inspect_config", lambda write_derived: {
+        "status": "ready", "GRADLE_ROOT": str(gradle), "JAVA_HOME": str(tmp_path / "jdk")})
+    result = compile_plugin_source.inspect_compile_environment(str(project))
+    assert result["status"] == "ready" and result["module"] == ":demo"
+    assert [item["path"] for item in result["sdkDirectories"]] == [str(bos.resolve())]
+    assert "not-read" not in str(result)
+    assert result["sdkDirectories"][0]["source"] == [str((gradle / "gradle.properties").resolve()),
+                                                      str((gradle / "config.gradle").resolve())]
+
+
 def test_validate_source_blocks_unresolved_dependency_markers(tmp_path):
     project_root = tmp_path / "module"
     source = project_root / "src" / "main" / "java" / "demo" / "Task.java"
@@ -39,9 +64,76 @@ def test_validate_source_blocks_unresolved_dependency_markers(tmp_path):
     assert issues == [{"line": 1, "message": "unresolved L3 dependency"}]
 
 
+def test_timeprop_hints_survive_single_and_batch_handoff_without_false_blocking(tmp_path):
+    project_root = tmp_path / "module"
+    source = project_root / "src" / "main" / "java" / "demo" / "Booking.java"
+    source.parent.mkdir(parents=True)
+    source.write_text(
+        'class Booking {\n'
+        '  private static final String START = "start_time";\n'
+        '  void check(DynamicObject row) { row.getDate(START); }\n'
+        '}\n', encoding="utf-8",
+    )
+    handoff = project_root / "app" / "_runtime" / "Booking.json"
+    handoff.parent.mkdir(parents=True)
+    handoff.write_text(json.dumps({"status": True, "handoff": {
+        "projectRoot": str(project_root), "appRoot": str(project_root / "app"),
+        "sourcePath": str(source), "className": "Booking", "type": "operation",
+        "formNumber": "booking", "description": "时段检查", "operationKeys": ["save"],
+        "formGraph": {"entities": [{"fields": [{"fieldKey": "start_time", "fieldType": "TimeProp"}]}]},
+    }}), encoding="utf-8")
+    config = tmp_path / "appconfig.json"
+    config.write_text('{"compile": false}')
+    env = {**os.environ, "KD_APPCONFIG": str(config)}
+    run = subprocess.run([sys.executable, str(SCRIPTS / "compile_plugin_source.py"),
+                          "--handoff", str(handoff)], capture_output=True, text=True, env=env)
+    outcome = json.loads(run.stdout)
+    assert run.returncode == 0
+    assert outcome["compileSkipped"] is True
+    assert outcome["compiledArtifact"] is None
+    assert outcome["loadingVerification"]["runtimeVerified"] is False
+    assert outcome["fieldAccessorCheck"] == "metadata-hints"
+    assert outcome["sourceWarnings"][0]["fieldKeys"] == ["start_time"]
+    batch = tmp_path / "sources.json"
+    batch.write_text(json.dumps([{"handoffPath": str(handoff)}]))
+    run = subprocess.run([sys.executable, str(SCRIPTS / "compile_plugin_source.py"),
+                          "--project-root", str(project_root), "--app-root", str(project_root / "app"),
+                          "--sources-file", str(batch)], capture_output=True, text=True, env=env)
+    result = json.loads(run.stdout)
+    assert run.returncode == 0
+    assert result["results"][0]["sourceWarnings"] == outcome["sourceWarnings"]
+    run = subprocess.run([sys.executable, str(SCRIPTS / "compile_plugin_source.py"),
+                          "--project-root", str(project_root), "--app-root", str(tmp_path / "another-app"),
+                          "--sources-file", str(batch)], capture_output=True, text=True, env=env)
+    assert run.returncode == 2
+    assert json.loads(run.stdout)["results"][0]["errorCode"] == "PLUGIN_BATCH_INPUT_INVALID"
+
+    assert compile_plugin_source.time_accessor_issues(
+        '// row.getDate(START)\nrow.getInt(START); row.getDate("booking_date");', {"start_time"}
+    ) == []
+    assert len(compile_plugin_source.time_accessor_issues('row.getDate("start_time");', {"start_time"})) == 1
+
+
+def test_timeprop_scan_ignores_literals_and_known_other_receivers_and_preserves_ambiguous_constants():
+    assert compile_plugin_source.time_accessor_issues(
+        'class P { static final String START = "start_time"; String note = "Do not use row.getDate(START)"; }',
+        {"start_time"},
+    ) == []
+    assert compile_plugin_source.time_accessor_issues(
+        'class P { void run(java.sql.ResultSet rs) { rs.getDate("start_time"); } }', {"start_time"},
+    ) == []
+    issues = compile_plugin_source.time_accessor_issues(
+        'class P { static final String FIELD = "start_time"; void run(DynamicObject row) { row.getDate(FIELD); } '
+        'static class Other { static final String FIELD = "booking_date"; } }', {"start_time"},
+    )
+    assert len(issues) == 1
+    assert issues[0]["severity"] == "warning"
+    assert issues[0]["fieldKeys"] == ["start_time"]
+
+
 def test_a_chinese_placeholder_word_in_a_comment_is_not_an_unresolved_dependency(tmp_path):
     """The word is ordinary business vocabulary. Scanning comments for it stopped delivery as
-    L3-BLOCK on a correct Chinese comment, while the same word in a literal is a real placeholder."""
+    L3-BLOCK on a correct Chinese comment or a legitimate state/message string."""
     project_root = tmp_path / "module"
     source = project_root / "src" / "main" / "java" / "demo" / "Task.java"
     source.parent.mkdir(parents=True)
@@ -62,8 +154,11 @@ def test_a_chinese_placeholder_word_in_a_comment_is_not_an_unresolved_dependency
         encoding="utf-8",
     )
 
+    assert validate_source(source, project_root, "Task") == []
+
+    source.write_text('class Task { String reason = "待替换"; }', encoding="utf-8")
     assert validate_source(source, project_root, "Task") == [
-        {"line": 2, "message": "unresolved placeholder text"},
+        {"line": 1, "message": "unresolved placeholder text"},
     ]
 
 
@@ -173,10 +268,29 @@ def test_compile_success_archives_before_marking_source_ready(tmp_path, monkeypa
 
     archive = json.loads((app_root / "archive.json").read_text(encoding="utf-8"))
     assert result["status"] is True
+    assert result["buildContext"]["gradleRoot"] == str(gradle_root.resolve())
+    assert result["buildContext"]["testTaskCandidate"] == ":demo:test"
+    assert result["sourceReview"]["businessCoverage"] == "not-established-by-compilation"
     assert archive["javas"][0]["className"] == "Task"
     assert (project_root / ".temp" / ".Task-gate").read_text() == "source_ready"
 
 
+def test_operation_dispatch_preflight_flags_unverified_map_keys_and_unselected_shared_effects():
+    source = '''class Plugin {
+        String operation() { return (String) this.operateMeta.get("operationKey"); }
+        void beginOperationTransaction(Event event) { updateRelatedObject(); }
+    }'''
+    warnings = compile_plugin_source.operation_dispatch_warnings(source, ["save", "confirm"])
+    assert {warning["errorCode"] for warning in warnings} == {
+        "PLUGIN_OPERATION_MAP_KEY_UNVERIFIED", "PLUGIN_OPERATION_SCOPE_UNVERIFIED"}
+    assert all(warning["severity"] == "warning" for warning in warnings)
+    assert compile_plugin_source.operation_dispatch_warnings(
+        'class P { String example="operateMeta.get(\\"operationKey\\")"; '
+        'void beginOperationTransaction(Event event) { if (expected.equals(event.getOperationKey())) updateRelatedObject(); } }',
+        ["save", "confirm"],
+    ) == []
+
+
 def test_compile_refuses_a_method_declared_twice_even_when_compilation_is_disabled(tmp_path, monkeypatch):
     project_root = tmp_path / "module"
     source = project_root / "src" / "main" / "java" / "demo" / "Bill.java"
@@ -563,7 +677,7 @@ def test_a_comment_placeholder_after_a_form_feed_is_still_located(tmp_path):
     source.write_text(
         "class Task {\n"
         "  /* page\x0cbreak */\n"
-        '  void run() { String s = "待确认"; }\n'
+        '  void run() { String s = "占位实现"; }\n'
         "}\n",
         encoding="utf-8",
     )
@@ -649,3 +763,110 @@ def test_compile_refuses_a_drifted_override_even_when_compilation_is_disabled(tm
     assert result["issues"][0]["registeredSignatures"] == ["propertyChanged(PropertyChangedArgs)"]
     assert not (app_root / "archive.json").exists()
     assert not (project_root / ".temp").exists()
+
+
+def test_batch_builds_one_module_once_and_keeps_full_diagnostics_in_one_log(tmp_path, monkeypatch, capsys):
+    project = tmp_path / "module"
+    java = project / "src/main/java/demo"
+    java.mkdir(parents=True)
+    (project / "settings.gradle").write_text("")
+    entries = []
+    for i in range(6):
+        source = java / f"Task{i}.java"
+        source.write_text(f"package demo; public class Task{i} {{}}")
+        entries.append({"sourcePath": str(source), "className": f"Task{i}", "type": "task",
+                        "formNumber": "example", "operationKeys": [], "description": "scheduled task"})
+    batch = tmp_path / "sources.json"
+    batch.write_text(json.dumps(entries))
+    calls = []
+    diagnostics = "\n".join(f"{java / f'Task{i % 6}.java'}:{i+1}: error: missing symbol {i}" for i in range(60))
+    monkeypatch.setattr(compile_plugin_source, "inspect_config", lambda **_: {
+        "status": "ready", "GRADLE_ROOT": str(project), "JAVA_HOME": str(tmp_path / "jdk"),
+    })
+    def build(argv, **kwargs):
+        calls.append(argv)
+        return SimpleNamespace(returncode=1, stdout=diagnostics)
+    monkeypatch.setattr(compile_plugin_source.subprocess, "run", build)
+    monkeypatch.setattr(sys, "argv", ["compile_plugin_source.py", "--project-root", str(project),
+                                     "--app-root", str(tmp_path / "app"), "--sources-file", str(batch)])
+    assert compile_plugin_source.main() == 2
+    result = json.loads(capsys.readouterr().out)
+    assert len(calls) == 1
+    assert "--rerun-tasks" not in calls[0]
+    assert len(result["results"]) == 6
+    assert all(item["status"] is False for item in result["results"])
+    assert sum(len(item.get("diagnostics", [])) for item in result["results"]) == 5
+    paths = {item["logPath"] for item in result["results"]}
+    assert len(paths) == 1
+    assert Path(next(iter(paths))).read_text() == diagnostics
+    assert not (tmp_path / "app/archive.json").exists()
+    # Failures are not cached across invocations, so a recovered environment can be retried.
+    assert compile_plugin_source.main() == 2
+    capsys.readouterr()
+    assert len(calls) == 2
+    monkeypatch.setattr(compile_plugin_source.subprocess, "run",
+                        lambda *a, **k: SimpleNamespace(returncode=0, stdout="BUILD SUCCESSFUL"))
+    assert compile_plugin_source.main() == 0
+    result = json.loads(capsys.readouterr().out)
+    assert all(item["status"] is True for item in result["results"])
+    archive = json.loads((tmp_path / "app/archive.json").read_text())
+    assert len(archive["javas"]) == 6
+    assert all(item["compileStatus"] == "passed" and len(item["sourceHash"]) == 64 for item in archive["javas"])
+
+
+def test_failed_recompile_invalidates_prior_archive_readiness(tmp_path, monkeypatch):
+    project = tmp_path / "module"
+    source = project / "src/main/java/demo/Task.java"
+    source.parent.mkdir(parents=True)
+    source.write_text("package demo; public class Task {}")
+    (project / "settings.gradle").write_text("")
+    app = tmp_path / "app"
+    monkeypatch.setattr(compile_plugin_source, "inspect_config", lambda **_: {"status": "disabled"})
+    args = dict(app_root=app, plugin_type="task", form_number="example", operation_keys=[], description="scheduled task")
+    assert compile_plugin_source.compile_source(project, source, "Task", 30, **args)["status"]
+    assert json.loads((app / "archive.json").read_text())["javas"][0]["compileStatus"] == "skipped-by-config"
+    monkeypatch.setattr(compile_plugin_source, "inspect_config", lambda **_: {
+        "status": "ready", "GRADLE_ROOT": str(project), "JAVA_HOME": str(tmp_path / "jdk"),
+    })
+    monkeypatch.setattr(compile_plugin_source.subprocess, "run", lambda *a, **k: SimpleNamespace(returncode=1, stdout="dependency resolution failed"))
+    assert compile_plugin_source.compile_source(project, source, "Task", 30, **args)["status"] is False
+    assert json.loads((app / "archive.json").read_text())["javas"][0]["compileStatus"] == "pending"
+
+
+def test_compile_reports_independent_source_issues_together(tmp_path):
+    source = tmp_path / "src" / "main" / "java" / "sample" / "Example.java"
+    source.parent.mkdir(parents=True)
+    source.write_text('''package sample;
+import kd.bos.servicehelper.QueryServiceHelper;
+import kd.bos.dataentity.entity.DynamicObject;
+import kd.bos.orm.query.QFilter;
+class Example {
+  void run() {
+    DynamicObject[] values = QueryServiceHelper.query("sample", "id", null);
+    QFilter filter = new QFilter("id", "not in", null);
+  }
+}
+''')
+    result = compile_plugin_source.compile_source(tmp_path, source, "Example", 10, app_root=tmp_path / "app",
+        plugin_type="operation", form_number="sample", operation_keys=["process"], description="check")
+    assert set(result["errorCodes"]) >= {"PLUGIN_SOURCE_RETURN_TYPE_MISMATCH", "PLUGIN_SOURCE_QFILTER_STRING_OPERATOR"}
+    assert all(issue["errorCode"] in result["errorCodes"] for issue in result["issues"])
+    assert not (tmp_path / "app" / "archive.json").exists()
+
+
+def test_compile_consumes_handoff_without_retyped_identity(tmp_path, monkeypatch, capsys):
+    source = tmp_path / "src" / "main" / "java" / "sample" / "Example.java"
+    source.parent.mkdir(parents=True)
+    source.write_text("package sample; public class Example {}")
+    prepared = tmp_path / "handoff.json"
+    prepared.write_text(json.dumps({"status": True, "handoff": {"projectRoot": str(tmp_path),
+        "appRoot": str(tmp_path / "app"), "sourcePath": str(source), "className": "Example", "type": "task",
+        "formNumber": "sample", "operationKeys": [], "description": "check"}}))
+    monkeypatch.setattr(compile_plugin_source, "inspect_config", lambda write_derived: {"status": "disabled", "compile": False})
+    monkeypatch.setattr(sys, "argv", ["compile_plugin_source.py", "--handoff", str(prepared)])
+    assert compile_plugin_source.main() == 0
+    result = json.loads(capsys.readouterr().out)
+    assert result["compileSkipped"] is True
+    archive = json.loads((tmp_path / "app" / "archive.json").read_text())
+    assert archive["javas"][0]["className"] == "Example"
+    assert archive["javas"][0]["filePath"] == str(source.resolve())