@shundoo-ai/dsh-cosmic 1.0.19 → 1.0.21

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

@@ -0,0 +1,70 @@
+import json
+import shutil
+import subprocess
+import sys
+import zipfile
+from pathlib import Path
+
+import pytest
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+from plugin_target_sdk import TargetSdkError, verify_target_sdk
+
+
+@pytest.fixture
+def target(tmp_path, monkeypatch):
+    if not shutil.which('javac') or not shutil.which('javap'):
+        pytest.skip('JDK tools unavailable')
+    project = tmp_path / 'gradle' / 'code' / 'probe'
+    project.mkdir(parents=True)
+    gradle = project.parents[1]
+    (gradle / 'settings.gradle').write_text("include(':probe')\nproject(':probe').projectDir=new File('code/probe')\n")
+    (gradle / 'gradlew').touch()
+    sdk = tmp_path / 'sdk'
+    bos = sdk / 'mservice-cosmic' / 'lib' / 'bos'
+    bos.mkdir(parents=True)
+    (gradle / 'gradle.properties').write_text(f'systemProp.cosmic_home={sdk}\n')
+    (gradle / 'config.gradle').write_text('cosmic_libs_path="${cosmic_home}/mservice-cosmic/lib"\nbos="${cosmic_libs_path}/bos"')
+    source = tmp_path / 'Probe.java'
+    source.write_text('package kd.bos.probe; public class Probe { public void trigger() {} }')
+    subprocess.run(['javac', '-d', str(tmp_path), str(source)], check=True, capture_output=True)
+    with zipfile.ZipFile(bos / 'probe.jar', 'w') as jar:
+        jar.write(tmp_path / 'kd/bos/probe/Probe.class', 'kd/bos/probe/Probe.class')
+    config = tmp_path / 'appconfig.json'
+    config.write_text(json.dumps({'compile': True, 'GRADLE_ROOT': str(gradle),
+                                 'JAVA_HOME': str(Path(shutil.which('java')).parent.parent)}))
+    monkeypatch.setenv('KD_APPCONFIG', str(config))
+    return project, config
+
+
+def test_bound_target_uses_real_sdk_declarations_without_config_changes(target):
+    project, config = target
+    before = config.read_bytes()
+    result = verify_target_sdk(str(project), {'baseContract': {'class': 'kd.bos.probe.Probe'}},
+                               [{'class': 'kd.bos.probe.Probe', 'members': ['trigger']}])
+    assert result['status'] == 'verified' and result['module'] == ':probe'
+    assert result['classes'][0]['jarSha256']
+    assert result['contracts'][0]['members'][0]['declaration'] == 'public void trigger();'
+    assert config.read_bytes() == before
+
+
+@pytest.mark.parametrize('usage,code', [
+    ([{'class': 'kd.bos.probe.Absent'}], 'SDK_CLASS_NOT_FOUND'),
+    ([{'class': 'kd.bos.probe.Probe', 'members': ['absent']}], 'PLUGIN_SDK_MEMBER_UNVERIFIED'),
+    ([{'class': 'kd.bos.probe.Probe', 'members': 'trigger'}], 'PLUGIN_SDK_USAGE_INVALID'),
+])
+def test_unproven_sdk_selectors_fail_before_generation(target, usage, code):
+    with pytest.raises(TargetSdkError) as error:
+        verify_target_sdk(str(target[0]), {}, usage)
+    assert error.value.error_code == code
+
+
+def test_unmapped_module_and_explicit_source_only_are_distinct(target):
+    project, config = target
+    with pytest.raises(TargetSdkError) as error:
+        verify_target_sdk(str(project.parent / 'stale'), {})
+    assert error.value.error_code == 'PLUGIN_MODULE_UNRESOLVED'
+    config.write_text('{"compile":false}')
+    result = verify_target_sdk(str(project), {})
+    assert result['status'] == 'not-run'
+    assert 'unverified' in result['evidenceScope']

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

@@ -43,7 +43,8 @@ def test_list_view_type_is_forwarded_as_extra_query_param() -> None:
     config = {"baseUrl": "http://example.test/ierp"}
     with mock.patch.object(preview_url.kd_api, "get", return_value=response) as request:
         preview_url.get_preview_url(
-            config, "http://example.test/ierp", "extension_form_number", view_type="list"
+            config, "http://example.test/ierp", "extension_form_number", view_type="list",
+            form_preview_url="http://example.test/ierp/?formId=extension_form_number",
         )
 
     request.assert_called_once_with(
@@ -54,6 +55,48 @@ def test_list_view_type_is_forwarded_as_extra_query_param() -> None:
     )
 
 
+def test_duplicate_list_response_uses_verified_standard_list_route() -> None:
+    config = {"baseUrl": "http://example.test/ierp"}
+
+    def api(_base, path, _config, params):
+        if path == preview_url.PREVIEW_URL_PATH:
+            assert params == {"formNumber": "cup_request", "viewType": "list"}
+            return {"status": True, "errorCode": "0", "data": "http://example.test/ierp/?formId=cup_request"}
+        assert path == preview_url.FORM_SCHEMA_PATH
+        assert params == {"formId": "cup_request"}
+        return {"status": True, "errorCode": "0", "data": {
+            "listLayout": {"type": "FormAp"},
+            "listConfig": {"entityId": "cup_request"}, "listColumns": [{"key": "billno"}],
+        }}
+
+    with mock.patch.object(preview_url.kd_api, "get", side_effect=api) as request:
+        actual = preview_url.get_preview_url(
+            config, config["baseUrl"], "cup_request", view_type="list",
+            form_preview_url="http://example.test/ierp/?formId=cup_request",
+        )
+
+    assert actual == "http://example.test/ierp/?formId=bos_list&type=list&billFormId=cup_request"
+    assert request.call_count == 2
+
+
+def test_duplicate_list_response_without_list_metadata_is_not_exposed() -> None:
+    config = {"baseUrl": "http://example.test/ierp"}
+
+    def api(_base, path, _config, _params):
+        if path == preview_url.PREVIEW_URL_PATH:
+            return {"status": True, "errorCode": "0", "data": "http://example.test/ierp/?formId=plain_page"}
+        return {"status": True, "errorCode": "0", "data": {
+            "formNumber": "plain_page", "listLayout": None, "listConfig": None,
+        }}
+
+    with mock.patch.object(preview_url.kd_api, "get", side_effect=api):
+        with pytest.raises(preview_url.PreviewUrlError, match="LIST_PREVIEW_METADATA_UNAVAILABLE"):
+            preview_url.get_preview_url(
+                config, config["baseUrl"], "plain_page", view_type="list",
+                form_preview_url="http://example.test/ierp/?formId=plain_page",
+            )
+
+
 def test_relative_platform_preview_url_is_resolved_against_environment() -> None:
     assert preview_url._response_preview_url(
         {"status": True, "errorCode": "0", "data": "/ierp/?formId=source"},

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

@@ -23,6 +23,12 @@ from _core import cmd_properties  # noqa: E402
 from _core import cmd_workspace  # noqa: E402
 
 
+def test_lock_in_complex_policy_reports_the_supported_set_shape():
+    with pytest.raises(ValueError, match="PROPERTY_POLICY_LOCK_SHAPE_INVALID") as raised:
+        cmd_properties._normalize_recorded_complex_properties({"Lock": {"new": "lock"}})
+    assert '"set":{"Lock":"new,edit,submit,audit"}' in str(raised.value)
+
+
 ROWS = [
     {
         "key": "demo",
@@ -73,6 +79,22 @@ ROWS = [
 ]
 
 
+def test_same_caption_entry_fields_use_explicit_entity_scope_for_a_single_target():
+    rows = [
+        {"key": "booking", "name": "定场单", "type": "BillEntity", "category": "entity", "id": "H"},
+        {"key": "details", "name": "订场明细", "type": "EntryEntity", "category": "entity", "id": "E"},
+        {"key": "services", "name": "附加服务", "type": "SubEntryEntity", "category": "entity", "id": "S"},
+        {"key": "booking_price", "name": "单价", "type": "PriceField", "category": "field", "parentKey": "details", "parentId": "E"},
+        {"key": "service_price", "name": "单价", "type": "PriceField", "category": "field", "parentKey": "services", "parentId": "S"},
+    ]
+    bulk = cmd_properties._property_policy_field_rows(rows, {"targets": {"fields": ["单价"], "entities": ["entries"]}}, "booking")
+    assert {row["key"] for row in bulk} == {"booking_price", "service_price"}
+    exact = cmd_properties._property_policy_field_rows(rows, {"targets": {"fields": [{"entity": "订场明细", "field": "单价"}]}}, "booking")
+    assert [row["key"] for row in exact] == ["booking_price"]
+    with pytest.raises(ValueError):
+        cmd_properties._property_policy_field_rows(rows, {"targets": {"fields": [{"field": "单价"}]}}, "booking")
+
+
 def test_lock_policy_uses_verified_form_control_path() -> None:
     from _core import cmd_listui
 

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

@@ -11,6 +11,7 @@ building it and had to be fixed.
 from __future__ import annotations
 
 import json
+import subprocess
 import sys
 from pathlib import Path
 
@@ -226,8 +227,6 @@ def test_both_locales_resolve_the_contract_index() -> None:
     while still returning a well-formed answer - a silent wrong result, which is worse
     than an error. Both locales must load the same index.
     """
-    import importlib.util
-
     loaded = {}
     # 契约解析器已随属性域搬到 _core/cmd_properties.py；按定义位置取，不写死文件。
     import sys as _sys
@@ -237,15 +236,18 @@ def test_both_locales_resolve_the_contract_index() -> None:
     assert len(holders) == 2, sorted(str(x) for x in holders)
     for path in sorted(holders, key=lambda x: ".locales" in str(x)):
         label = "zh" if ".locales" in str(path) else "canonical"
-        source = path.read_text(encoding="utf-8")
-        # exercise the resolver in isolation: no package import, no network, no auth
-        namespace = {"__file__": str(path), "pathlib": __import__("pathlib"),
-                     "json": json}
-        start = source.index("def _contract_dirs():")
-        end = source.index("def _property_input_index():")
-        exec(compile(source[start:end], str(path), "exec"), namespace)  # noqa: S102
-        doc = namespace["_load_json_contract"]("property-input-index.json")
-        loaded[label] = doc
+        scripts = path.parents[1]
+        result = subprocess.run(
+            [
+                sys.executable, "-c",
+                "import json,sys; sys.path.insert(0,sys.argv[1]); "
+                "from _core.cmd_properties import _load_json_contract; "
+                "print(json.dumps(_load_json_contract('property-input-index.json')))",
+                str(scripts),
+            ],
+            check=True, capture_output=True, text=True,
+        )
+        loaded[label] = json.loads(result.stdout)
 
     for label, doc in loaded.items():
         assert doc.get("properties"), f"{label} failed to load the index"

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

@@ -0,0 +1,160 @@
+import hashlib
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+
+SCRIPT = Path(__file__).resolve().parents[1] / "query_plugin_handoff.py"
+
+
+def handoff_file(tmp_path):
+    file = tmp_path / "_runtime" / "plugin-handoffs" / "BookingPlugin.json"
+    file.parent.mkdir(parents=True)
+    document = {
+        "status": True,
+        "handoffPath": str(file),
+        "handoff": {
+            "formGraph": {"formNumber": "booking", "entities": [
+                {"entityKey": "booking_head", "fields": [
+                    {"fieldKey": "quantity", "fieldName": "数量", "comboOptions": ["1", "2"]},
+                    {"fieldKey": "member", "fieldName": "会员", "required": False},
+                ]},
+                {"entityKey": "booking_entry", "role": "entries", "parentEntityKey": "booking_head",
+                 "collectionPath": ["booking_entry"], "fields": [
+                     {"fieldKey": "start_time", "fieldType": "TimeProp", "javaType": "Integer",
+                      "valueAccessor": 'getInt("start_time")', "timeValueUnit": "seconds-after-midnight"}]},
+            ]},
+            "operationContracts": [
+                {"operationKey": "save", "parameter": {"entity": "booking_head"}},
+                {"operationKey": "confirm", "parameter": {"entity": "booking_head"}},
+            ],
+            "codingEvidence": {"signatureTypes": [{"class": "ExtendedDataEntity", "import": "kd.bos.entity.ExtendedDataEntity"}],
+                               "apiContracts": [{"class": "kd.bos.servicehelper.QueryServiceHelper", "import": "import kd.bos.servicehelper.QueryServiceHelper;", "members": [{"name": "query", "signature": "public static DynamicObjectCollection query(String entityName)"}]}],
+                               "guide": "large-evidence-" * 1800},
+        },
+    }
+    file.write_text(json.dumps(document, ensure_ascii=False), encoding="utf-8")
+    return file, document
+
+
+def query(file, operation, *args):
+    result = subprocess.run([sys.executable, str(SCRIPT), operation, "--handoff", str(file), *args],
+                            capture_output=True, text=True, check=False)
+    return result.returncode, json.loads(result.stdout), result.stdout
+
+
+def test_target_readiness_is_bounded_and_missing_evidence_is_not_claimed(tmp_path):
+    file, document = handoff_file(tmp_path)
+    code, context, _ = query(file, "coding-start")
+    assert code == 0 and context['targetSdk']['status'] == 'not-provided'
+    assert 'path' not in context['targetSdk']
+    document['handoff']['targetSdk'] = {'status': 'verified', 'module': ':probe',
+        'evidenceScope': 'SDK declarations only', 'classes': [{'class': 'large-evidence-' * 1800}]}
+    file.write_text(json.dumps(document))
+    for operation in ['coding-start', 'coding-context']:
+        code, context, output = query(file, operation)
+        assert code == 0 and context['targetSdk']['status'] == 'verified'
+        assert context['targetSdk']['path'] == '/handoff/targetSdk'
+        assert 'classes' not in context['targetSdk'] and 'large-evidence-' not in output
+
+
+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()
+    code, root, stdout = query(file, "index")
+    assert code == 0 and len(stdout.encode("utf-8")) <= 8192
+    assert [item["path"] for item in root["items"]] == ["/status", "/handoffPath", "/handoff"]
+    assert "large-evidence" not in stdout
+
+    code, graph, stdout = query(file, "index", "--path", "/handoff/formGraph/entities")
+    assert code == 0 and graph["items"][0]["identity"] == {"entityKey": "booking_head"}
+    code, field, _ = query(file, "find", "--path", "/handoff/formGraph/entities/0/fields",
+                           "--field", "fieldKey", "--equals", "member")
+    assert code == 0 and [item["path"] for item in field["matches"]] == ["/handoff/formGraph/entities/0/fields/1"]
+    code, item, _ = query(file, "get", "--path", field["matches"][0]["path"])
+    assert code == 0 and item["value"] == document["handoff"]["formGraph"]["entities"][0]["fields"][1]
+
+    code, operation, _ = query(file, "find", "--path", "/handoff/operationContracts",
+                               "--field", "operationKey", "--equals", "confirm")
+    assert code == 0 and operation["matches"][0]["path"] == "/handoff/operationContracts/1"
+    code, signature, _ = query(file, "get", "--path", "/handoff/codingEvidence/signatureTypes/0")
+    assert code == 0 and signature["value"] == document["handoff"]["codingEvidence"]["signatureTypes"][0]
+    assert hashlib.sha256(file.read_bytes()).hexdigest() == original
+
+
+def test_large_or_invalid_queries_fail_without_dumping_handoff(tmp_path):
+    file, _ = handoff_file(tmp_path)
+    for operation, arguments, expected in [
+        ("get", ["--path", "/handoff"], "HANDOFF_QUERY_TOO_LARGE"),
+        ("get", ["--path", "/handoff/formGraph/entities/9"], "HANDOFF_POINTER_NOT_FOUND"),
+        ("get", ["--path", "handoff/formGraph"], "HANDOFF_POINTER_INVALID"),
+        ("find", ["--path", "/handoff/formGraph", "--field", "entityKey", "--equals", "booking_head"], "HANDOFF_NOT_RECORD_LIST"),
+        ("index", ["--path", "/handoff/operationContracts", "--offset", "-1"], "HANDOFF_PAGE_INVALID"),
+    ]:
+        code, output, stdout = query(file, operation, *arguments)
+        assert code == 2 and output["errorCode"] == expected
+        assert len(stdout.encode("utf-8")) < 8192 and "large-evidence" not in stdout
+
+    code, page, _ = query(file, "index", "--path", "/handoff/operationContracts", "--limit", "1")
+    assert code == 0 and page["nextOffset"] == 1
+    code, page, _ = query(file, "index", "--path", "/handoff/operationContracts", "--offset", "1", "--limit", "1")
+    assert code == 0 and page["nextOffset"] is None and page["items"][0]["identity"]["operationKey"] == "confirm"
+
+
+def test_query_rejects_unrelated_json_even_when_shape_looks_like_handoff(tmp_path):
+    file, document = handoff_file(tmp_path)
+    document["handoffPath"] = str(tmp_path / "other.json")
+    file.write_text(json.dumps(document), encoding="utf-8")
+    code, output, _ = query(file, "index")
+    assert code == 2 and output["errorCode"] == "HANDOFF_PATH_MISMATCH"
+
+
+def test_coding_context_returns_required_types_once_without_large_guide(tmp_path):
+    file, _ = handoff_file(tmp_path)
+    original = hashlib.sha256(file.read_bytes()).hexdigest()
+    code, context, stdout = query(file, "coding-context")
+    assert code == 0 and context["contextMode"] == "coding-context"
+    assert context["handoffSha256"] == original
+    assert context["formGraph"]["entities"][0]["fields"][0]["fieldKey"] == "quantity"
+    assert context["queryRootEvidence"]["formNumber"] == "booking"
+    assert context["queryRootEvidence"]["nonRootEntityKeys"] == ["booking_entry"]
+    assert "standalone QueryServiceHelper roots" in context["queryRootEvidence"]["boundary"]
+    assert context["formGraph"]["entities"][1]["fields"][0]["valueAccessor"] == 'getInt("start_time")'
+    assert context["formGraph"]["entities"][1]["fields"][0]["timeValueUnit"] == "seconds-after-midnight"
+    assert context["operationContracts"][0]["operationKey"] == "save"
+    assert context["codingEvidence"]["apiContracts"][0]["members"][0]["signature"].startswith("public static DynamicObjectCollection query")
+    assert context["stateWarnings"] == []
+    assert "large-evidence" not in stdout and len(stdout.encode("utf-8")) < 32 * 1024
+    assert hashlib.sha256(file.read_bytes()).hexdigest() == original
+
+
+def test_startup_context_keeps_field_facts_and_exact_paths_without_expanding_api_or_related_forms(tmp_path):
+    file, document = handoff_file(tmp_path)
+    document["handoff"]["relatedForms"] = [{"formNumber": "member", "entities": [{"fields": [{"private": "not needed at startup"}]}]}]
+    document["handoff"]["availableOperations"] = [{"operationKey": "complete"}]
+    document["handoff"]["codingEvidence"]["operationDispatch"] = {"validator": {"accessor": "this.getOperateKey()"}}
+    file.write_text(json.dumps(document), encoding="utf-8")
+    code, result, output = query(file, "coding-start")
+    assert code == 0 and result["contextMode"] == "coding-start"
+    assert result["entities"][1]["fields"][0]["valueAccessor"] == 'getInt("start_time")'
+    assert result["relatedForms"][0]["path"] == "/handoff/relatedForms/0"
+    assert result["availableOperationKeys"] == ["complete"]
+    assert result["availableOperationsPath"] == "/handoff/availableOperations"
+    assert result["codingEvidence"]["operationDispatch"]["validator"]["accessor"] == "this.getOperateKey()"
+    assert result["codingEvidence"]["apiContracts"][0]["members"] == ["query"]
+    assert "large-evidence" not in output and "not needed at startup" not in output
+
+
+def test_large_startup_inventory_is_explicitly_referenced_instead_of_dumped(tmp_path):
+    file, document = handoff_file(tmp_path)
+    document["handoff"]["formGraph"]["entities"][0]["fields"] = [
+        {"fieldKey": f"field_{index}", "fieldName": "A large inventory field", "fieldType": "TextProp"}
+        for index in range(1000)]
+    file.write_text(json.dumps(document), encoding="utf-8")
+    code, result, output = query(file, "coding-start")
+    assert code == 0 and len(output.encode()) <= 16 * 1024
+    assert result["entities"][0]["fieldsOmitted"] is True
+    assert result["entities"][0]["fieldCount"] == 1000
+    assert result["entities"][0]["fieldsPath"] == "/handoff/formGraph/entities/0/fields"
+    assert "fields" not in result["entities"][0]

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

@@ -137,9 +137,28 @@ class BuildRegisterPayloadTest(unittest.TestCase):
             "description": "desc",
             "enabled": True,
             "targetType": "form",
+            "pluginType": "JAVA",
         })
         self.assertNotIn("operationKey", payload)
 
+    def test_application_binding_comes_from_archive(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            Path(tmp, "archive.json").write_text(json.dumps({
+                "appId": "selected-app", "javas": [{
+                    "className": "example.Plugin", "type": "billform",
+                    "filePath": "Plugin.java", "formNumber": "booking",
+                    "description": "booking", "operationKey": "",
+                    "bizAppId": "different-app",
+                }],
+            }))
+            candidate = register_plugins._load_classes_from_archive(tmp)[0]
+            payload = register_plugins._build_register_payload(
+                candidate["formNumber"], candidate["className"], candidate["description"],
+                "BILL_FORM", biz_app_id=candidate["bizAppId"],
+            )
+            self.assertEqual(payload["bizAppId"], "selected-app")
+            self.assertEqual(payload["pluginType"], "JAVA")
+
     def test_operation_key_included_when_truthy(self):
         payload = register_plugins._build_register_payload(
             "sch_job", "com.example.OpPlugin", "desc", "form", operation_key="save",
@@ -334,7 +353,7 @@ class MainTest(unittest.TestCase):
                                          mock_config, mock_post):
         mock_load_classes.return_value = [
             {"className": "com.example.FormPlugin", "type": "form_plugin",
-             "formNumber": "sch_job", "description": "test plugin"},
+             "formNumber": "sch_job", "description": "test plugin", "bizAppId": "selected-app"},
         ]
         mock_registry.return_value = {"form_plugin": "form"}
         mock_config.return_value = {"baseUrl": "https://api.example.com"}
@@ -343,6 +362,10 @@ class MainTest(unittest.TestCase):
         output = self._run()
         self.assertEqual(output["status"], "success")
         self.assertEqual(output["summary"], {"total": 1, "success": 1, "failed": 0})
+        self.assertEqual(output["activation"]["state"], "registration_unverified")
+        self.assertIsNone(output["activation"]["requiresServiceRestart"])
+        self.assertFalse(output["activation"]["runtimeVerified"])
+        self.assertNotIn("nextAction", output["activation"])
 
         # Verify kd_api.post call: legacy_api style + correct payload
         args, kwargs = mock_post.call_args
@@ -354,6 +377,8 @@ class MainTest(unittest.TestCase):
         self.assertEqual(body["className"], "com.example.FormPlugin")
         self.assertEqual(body["targetType"], "form")
         self.assertEqual(body["formNumber"], "sch_job")
+        self.assertEqual(body["bizAppId"], "selected-app")
+        self.assertEqual(body["pluginType"], "JAVA")
 
     @mock.patch("register_plugins.kd_api.post")
     @mock.patch("register_plugins._load_config")
@@ -417,6 +442,11 @@ class MainTest(unittest.TestCase):
 
         self.assertEqual(output["status"], "success")
         self.assertEqual(output["verification"]["status"], "pass")
+        self.assertEqual(output["activation"]["registeredClasses"], ["com.example.OpPlugin"])
+        self.assertEqual(output["activation"]["state"], "runtime_unverified")
+        self.assertNotIn("nextAction", output["activation"])
+        self.assertIsNone(output["activation"]["requiresServiceRestart"])
+        self.assertFalse(output["activation"]["runtimeVerified"])
         mock_get.assert_called_once_with(
             "https://api.example.com", register_plugins.QUERY_PATH,
             {"baseUrl": "https://api.example.com"}, {"formNumber": "sch_job"},

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

@@ -3,6 +3,7 @@ from __future__ import annotations
 import hashlib
 import importlib.util
 import json
+import os
 from pathlib import Path
 import subprocess
 import sys
@@ -67,16 +68,42 @@ def test_cli_delivers_one_block_and_the_output_check_handoff(capsys, tmp_path):
     block = ':::render:kdform\n{"title":"Example","url":"https://example.test"}\n:::'
     with mock.patch.object(sys, "argv", [
         str(SCRIPT), "--app-root", str(tmp_path), "--form-number", "example",
-    ]), mock.patch.object(CARDS, "render", return_value=[block]) as render:
+    ]), mock.patch.object(CARDS, "render", return_value=[block]) as render, mock.patch.object(
+        CARDS, "_DYM_BACKGROUND_NOTICE", ""
+    ):
         assert CARDS.main() == 0
     output = capsys.readouterr()
     assert output.out == block + "\n"
     assert "output_check" in output.err
-    assert "search_tools" in output.err
     assert "Markdown" in output.err
     render.assert_called_once()
 
 
+def test_cli_binds_auth_cache_to_explicit_app_root(tmp_path):
+    block = ':::render:kdform\n{"title":"Example","url":"https://example.test"}\n:::'
+    with mock.patch.dict(os.environ, {}, clear=False), mock.patch.object(sys, "argv", [
+        str(SCRIPT), "--app-root", str(tmp_path), "--form-number", "example",
+    ]), mock.patch.object(CARDS, "render", return_value=[block]), mock.patch.object(
+        CARDS, "_DYM_BACKGROUND_NOTICE", ""
+    ):
+        assert CARDS.main() == 0
+        assert os.environ["PROJECT_ROOT"] == str(tmp_path.resolve())
+
+
+def test_background_handoff_survives_suppressed_stderr(capsys, tmp_path):
+    block = ':::render:kdform\n{"title":"Example","url":"https://example.test"}\n:::'
+    notice = 'DYM_BACKGROUND_REQUEST={"formNumbers":["a","b"]}'
+    with mock.patch.object(sys, "argv", [
+        str(SCRIPT), "--app-root", str(tmp_path), "--form-number", "a", "--form-number", "b",
+    ]), mock.patch.object(CARDS, "render", return_value=[block]), mock.patch.object(
+        CARDS, "_DYM_BACKGROUND_NOTICE", notice
+    ):
+        assert CARDS.main() == 0
+    output = capsys.readouterr()
+    assert output.out == block + "\n" + notice + "\n"
+    assert "Markdown" in output.err
+
+
 def test_cli_does_not_request_output_check_when_rendering_fails(capsys, tmp_path):
     with mock.patch.object(sys, "argv", [
         str(SCRIPT), "--app-root", str(tmp_path), "--form-number", "example",
@@ -149,6 +176,7 @@ def test_existing_form_modification_renders_only_exact_target(tmp_path: Path) ->
             "http://example.test/ierp",
             "target_form",
             view_type="list",
+            form_preview_url="http://example.test/ierp/?formId=platform_original_id",
         ),
     ]
     saved = json.loads((tmp_path / "archive.json").read_text(encoding="utf-8"))
@@ -436,7 +464,7 @@ def test_card_carries_list_preview_url_and_degrades_silently(tmp_path: Path) ->
         json.dumps(archive, ensure_ascii=False), encoding="utf-8"
     )
 
-    def preview_with_list(config, base_url, form_number, view_type=""):
+    def preview_with_list(config, base_url, form_number, view_type="", form_preview_url=""):
         if view_type == "list":
             return "http://example.test/ierp/?formId=list_view_id"
         return "http://example.test/ierp/?formId=form_view_id"
@@ -454,7 +482,7 @@ def test_card_carries_list_preview_url_and_degrades_silently(tmp_path: Path) ->
     saved = json.loads((tmp_path / "archive.json").read_text(encoding="utf-8"))
     assert saved["artifacts"][0]["listUrl"].endswith("formId=list_view_id")
 
-    def preview_without_list(config, base_url, form_number, view_type=""):
+    def preview_without_list(config, base_url, form_number, view_type="", form_preview_url=""):
         if view_type == "list":
             raise RuntimeError("list view unsupported")
         return "http://example.test/ierp/?formId=form_view_id"
@@ -471,6 +499,24 @@ def test_card_carries_list_preview_url_and_degrades_silently(tmp_path: Path) ->
     assert "formId=form_view_id" in degraded[0]
     assert "listUrl" not in degraded[0]
 
+    def preview_with_duplicate_list(config, base_url, form_number, view_type="", form_preview_url=""):
+        return "http://example.test/ierp/?formId=form_view_id"
+
+    with mock.patch(
+        "kd_env_loader.load_effective_skill_config",
+        return_value={"server": {"baseUrl": "http://example.test/ierp"}},
+    ), mock.patch.object(CARDS, "get_preview_url", side_effect=preview_with_duplicate_list):
+        duplicate = CARDS.render(
+            str(tmp_path), include_plan=False, target_form_number="target_form"
+        )
+
+    assert len(duplicate) == 1
+    assert "listUrl" not in duplicate[0]
+    saved = json.loads((tmp_path / "archive.json").read_text(encoding="utf-8"))
+    assert "listUrl" not in saved["artifacts"][0]
+    handoff = json.loads((tmp_path / "_runtime/test-environment.json").read_text(encoding="utf-8"))
+    assert "listUrl" not in handoff["forms"][0]
+
 
 def test_localized_card_cli_keeps_target_filter_contract() -> None:
     localized = SCRIPT.parents[1] / ".locales" / "zh" / "scripts" / SCRIPT.name

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

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import importlib
 import json
+import subprocess
 import sys
 import tempfile
 import unittest
@@ -19,6 +20,32 @@ cosmic_api = importlib.import_module("cosmic_api")
 
 
 class ReportBusinessContractTest(unittest.TestCase):
+    def test_report_schema_cli_contains_all_payload_definitions_locally(self):
+        completed = subprocess.run([
+            sys.executable, str(APP_BUILD_ROOT / "skills/cosmic-meta-modeling/scripts/report_validator.py"), "--schema",
+        ], capture_output=True, text=True, check=True)
+        schema = json.loads(completed.stdout)
+        self.assertEqual(schema["properties"]["reportColumns"]["$ref"], "#/$defs/reportWrite_columns")
+        self.assertIn("kind", schema["$defs"]["reportWrite_column"]["required"])
+        self.assertIn("caption", schema["$defs"]["reportWrite_column"]["required"])
+        self.assertEqual(schema["$defs"]["reportWrite_sort"]["properties"]["direction"]["enum"], ["asc", "desc"])
+
+        def check_references(value):
+            if isinstance(value, list):
+                for item in value:
+                    check_references(item)
+            if not isinstance(value, dict):
+                return
+            if "$ref" in value:
+                self.assertTrue(value["$ref"].startswith("#/"))
+                target = schema
+                for segment in value["$ref"][2:].split("/"):
+                    target = target[segment.replace("~1", "/").replace("~0", "~")]
+            for item in value.values():
+                check_references(item)
+
+        check_references(schema)
+
     def test_report_pipeline_returns_authoritative_readback_form_number(self) -> None:
         artifact = {
             "templateNumber": "bos_rpttpl",

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

@@ -353,13 +353,14 @@ class TreeSemanticsTest(unittest.TestCase):
                     )
         self.assertGreater(checked, 0, "the id/pid scan matched nothing; the pattern is stale")
 
-    def test_routing_and_coding_mapping_agree_on_the_report_types(self):
+    def test_routing_uses_registered_report_types(self):
         routing = _read(APP_BUILD_ROOT / "references/plugin-runtime-routing.md")
-        mapping = _read(APP_BUILD_ROOT / "skills/cosmic-coding-impl/SKILL.md")
+        types = {entry["type"] for entry in json.loads(
+            _read(APP_BUILD_ROOT / "references/type-registry.json"))["types"]}
         for plugin_type in re.findall(r"`(report[a-z]+)`", routing):
             with self.subTest(type=plugin_type):
-                self.assertIn(f"| `{plugin_type}` |", mapping,
-                              f"routing offers type {plugin_type} that the coding mapping lacks")
+                self.assertIn(plugin_type, types,
+                              f"routing offers type {plugin_type} absent from the registry")
 
     def test_left_tree_type_is_described_by_its_real_signature(self):
         routing = _read(APP_BUILD_ROOT / "references/plugin-runtime-routing.md")