@shundoo-ai/dsh-cosmic 1.0.19 → 1.0.21

package/skills/cosmic-build/scripts/preview_url.py

@@ -1,15 +1,16 @@
 #!/usr/bin/env python3
-"""Resolve the platform-authoritative preview URL for one form number."""
+"""Resolve platform form and verified standard list preview URLs."""
 
 from __future__ import annotations
 
-from urllib.parse import urljoin, urlparse
+from urllib.parse import parse_qs, urlencode, urljoin, urlparse, urlunparse
 
 import kd_api
 
 
 PREVIEW_URL_PATH = "/kapi/v2/devportal/ai-meta/getPreviewUrl"
 FORM_LOOKUP_PATH = "/kapi/v2/devportal/ai-meta/queryForms"
+FORM_SCHEMA_PATH = "/kapi/v2/devportal/ai-meta/getFormSchema"
 
 
 class PreviewUrlError(RuntimeError):
@@ -51,8 +52,11 @@ def _response_preview_url(response: object, base_url: str) -> str:
     return candidate
 
 
-def get_preview_url(config: dict, base_url: str, form_number: str, view_type: str = "") -> str:
-    """调 getPreviewUrl；绝不回退到拼凑的 ``?formId=`` URL。
+def get_preview_url(
+    config: dict, base_url: str, form_number: str, view_type: str = "",
+    form_preview_url: str = "",
+) -> str:
+    """获取平台预览地址；仅在列表元数据已验证时恢复标准列表入口。
 
     ``view_type`` 选择预览面：留空保持平台默认的表单视图；
     ``"list"`` 请求列表预览 URL。
@@ -70,7 +74,32 @@ def get_preview_url(config: dict, base_url: str, form_number: str, view_type: st
         config,
         params,
     )
-    return _response_preview_url(response, base_url)
+    candidate = _response_preview_url(response, base_url)
+    if view != "list":
+        return candidate
+    editor = form_preview_url or get_preview_url(config, base_url, number)
+    if candidate != editor:
+        return candidate
+
+    schema = kd_api.get(base_url, FORM_SCHEMA_PATH, config, {"formId": number})
+    data = schema.get("data") if isinstance(schema, dict) and schema.get("status") is True else None
+    if (
+        not isinstance(data, dict)
+        or data.get("formNumber") not in (None, "", number)
+        or not isinstance(data.get("listLayout"), dict)
+        or not isinstance(data.get("listConfig"), dict)
+        or data["listConfig"].get("entityId") != number
+        or not isinstance(data.get("listColumns"), list)
+        or not data["listColumns"]
+    ):
+        raise PreviewUrlError("LIST_PREVIEW_METADATA_UNAVAILABLE: platform returned the editor URL for list")
+    parsed = urlparse(editor)
+    if parse_qs(parsed.query).get("formId") != [number]:
+        raise PreviewUrlError("LIST_PREVIEW_EDITOR_URL_UNEXPECTED")
+    # 标准 bos_list 路由来自平台先前返回的列表地址，且已在当前表单验证。
+    return urlunparse(parsed._replace(query=urlencode({
+        "formId": "bos_list", "type": "list", "billFormId": number,
+    }), fragment=""))
 
 
 def get_form_name(config: dict, base_url: str, form_number: str) -> str:
@@ -92,6 +121,6 @@ def get_form_name(config: dict, base_url: str, form_number: str) -> str:
 
 
 __all__ = [
-    "PREVIEW_URL_PATH", "FORM_LOOKUP_PATH", "PreviewUrlError",
+    "PREVIEW_URL_PATH", "FORM_LOOKUP_PATH", "FORM_SCHEMA_PATH", "PreviewUrlError",
     "get_preview_url", "get_form_name",
 ]

package/skills/cosmic-build/scripts/query_plugin_handoff.py

@@ -0,0 +1,250 @@
+#!/usr/bin/env python3
+"""Read only the requested portion of a verified plugin handoff snapshot."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import sys
+from pathlib import Path
+
+
+MAX_OUTPUT_BYTES = 8 * 1024
+MAX_CODING_CONTEXT_BYTES = 48 * 1024
+MAX_CODING_START_BYTES = 16 * 1024
+DEFAULT_PAGE_SIZE = 15
+MAX_PAGE_SIZE = 50
+IDENTITY_KEYS = (
+    "formNumber", "entityKey", "operationKey", "fieldKey", "class",
+    "reference", "entityName", "operationName", "fieldName",
+)
+
+
+class QueryError(ValueError):
+    def __init__(self, code: str, message: str):
+        super().__init__(message)
+        self.code = code
+
+
+def encoded(value: object) -> str:
+    return json.dumps(value, ensure_ascii=False, separators=(",", ":"))
+
+
+def pointer_child(parent: str, key: str | int) -> str:
+    return f"{parent}/{str(key).replace('~', '~0').replace('/', '~1')}"
+
+
+def resolve_pointer(document: object, pointer: str) -> object:
+    if not pointer:
+        return document
+    if not pointer.startswith("/"):
+        raise QueryError("HANDOFF_POINTER_INVALID", "path must be an exact JSON pointer beginning with /")
+    value = document
+    for token in pointer[1:].split("/"):
+        key = token.replace("~1", "/").replace("~0", "~")
+        if isinstance(value, dict) and key in value:
+            value = value[key]
+            continue
+        if isinstance(value, list) and key.isdecimal() and str(int(key)) == key and int(key) < len(value):
+            value = value[int(key)]
+            continue
+        raise QueryError("HANDOFF_POINTER_NOT_FOUND", f"path does not exist: {pointer}")
+    return value
+
+
+def describe(value: object, pointer: str) -> dict:
+    kind = "object" if isinstance(value, dict) else "array" if isinstance(value, list) else type(value).__name__
+    result = {"path": pointer, "kind": kind, "bytes": len(encoded(value).encode("utf-8"))}
+    if isinstance(value, (dict, list)):
+        result["count"] = len(value)
+    if isinstance(value, dict):
+        result["identity"] = {
+            key: value[key][:120] for key in IDENTITY_KEYS
+            if isinstance(value.get(key), str)
+        }
+    return result
+
+
+def load_handoff(filename: str) -> tuple[Path, dict]:
+    file = Path(filename)
+    if not file.is_absolute() or file.suffix.lower() != ".json":
+        raise QueryError("HANDOFF_PATH_INVALID", "handoff must be an absolute JSON path returned by preparation")
+    try:
+        document = json.loads(file.read_text(encoding="utf-8"))
+    except (OSError, UnicodeError, json.JSONDecodeError) as error:
+        raise QueryError("HANDOFF_UNAVAILABLE", f"cannot read handoff: {type(error).__name__}") from error
+    if not isinstance(document, dict) or document.get("status") is not True or not isinstance(document.get("handoff"), dict):
+        raise QueryError("HANDOFF_INVALID", "file is not a successful plugin handoff")
+    if not isinstance(document.get("handoffPath"), str) or Path(document["handoffPath"]).resolve() != file.resolve():
+        raise QueryError("HANDOFF_PATH_MISMATCH", "handoffPath does not match the selected file")
+    return file, document
+
+
+def query(document: dict, args: argparse.Namespace) -> dict:
+    if args.operation in ("coding-context", "coding-start"):
+        handoff = document["handoff"]
+        graph = handoff.get("formGraph")
+        evidence = handoff.get("codingEvidence")
+        if not isinstance(graph, dict) or not isinstance(evidence, dict):
+            raise QueryError("HANDOFF_CODING_CONTEXT_INVALID", "formGraph and codingEvidence are required")
+        if not isinstance(handoff.get("relatedForms", []), list) or not isinstance(evidence.get("apiContracts", []), list):
+            raise QueryError("HANDOFF_CODING_CONTEXT_INVALID", "relatedForms and apiContracts must be arrays")
+
+        def pick(record: dict, keys: tuple[str, ...]) -> dict:
+            return {key: record[key] for key in keys if key in record and record[key] is not None}
+
+        def target_sdk() -> dict:
+            if not isinstance(handoff.get("targetSdk"), dict):
+                return {"status": "not-provided", "evidenceScope": "This snapshot does not establish target SDK readiness"}
+            return {**pick(handoff["targetSdk"], ("status", "projectRoot", "module", "evidenceScope")),
+                    "path": "/handoff/targetSdk"}
+
+        if args.operation == "coding-start":
+            from compile_plugin_source import inspect_compile_environment
+            if not isinstance(graph.get("entities"), list):
+                raise QueryError("HANDOFF_CODING_CONTEXT_INVALID", "formGraph entities are required")
+            if any(not isinstance(entity, dict) or not isinstance(entity.get("fields"), list)
+                   or any(not isinstance(field, dict) for field in entity["fields"]) for entity in graph["entities"]):
+                raise QueryError("HANDOFF_CODING_CONTEXT_INVALID", "entities and fields must be objects")
+            start = {
+                "status": True, "contextMode": "coding-start", "handoffPath": document["handoffPath"],
+                "handoffSha256": hashlib.sha256(Path(document["handoffPath"]).read_bytes()).hexdigest(),
+                **pick(handoff, ("appRoot", "projectRoot", "formNumber", "className", "sourcePath", "fqcn", "operationKeys", "coreLogic", "sourceGate")),
+                "entities": [{**pick(entity, ("entityKey", "role", "collectionProperty", "collectionPath")),
+                              "fieldsPath": f"/handoff/formGraph/entities/{index}/fields",
+                              "fields": [pick(field, ("fieldKey", "fieldName", "fieldType", "javaType", "valueAccessor", "idAccessor"))
+                                         for field in entity.get("fields", [])]}
+                             for index, entity in enumerate(graph["entities"])],
+                "relatedForms": [{**pick(form, ("formNumber", "formName", "metadataVersion")),
+                                  "path": f"/handoff/relatedForms/{index}"}
+                                 for index, form in enumerate(handoff.get("relatedForms", []))],
+                "operationContracts": handoff.get("operationContracts", []),
+                "availableOperationKeys": [row["operationKey"] for row in handoff.get("availableOperations", [])
+                                           if isinstance(row, dict) and isinstance(row.get("operationKey"), str)],
+                "availableOperationsPath": "/handoff/availableOperations",
+                "selectedOperations": [pick(row, ("operationKey", "operationName", "operationType"))
+                                       for row in handoff.get("availableOperations", [])
+                                       if isinstance(row, dict) and row.get("operationKey") in handoff.get("operationKeys", [])],
+                "stateWarnings": handoff.get("stateWarnings", []),
+                "stateFields": [pick(field, ("fieldKey", "fieldName", "entityKey", "comboOptions")) for field in handoff.get("stateFields", [])],
+                "buildEnvironment": inspect_compile_environment(handoff["projectRoot"]) if handoff.get("projectRoot") else {"status": "not-provided"},
+                "targetSdk": target_sdk(),
+                "codingEvidence": {**pick(evidence, ("codingEntry", "operationDispatch", "apiLookup", "sdkLookup")),
+                                   "signatureTypes": [pick(item, ("class", "import")) for item in evidence.get("signatureTypes", [])],
+                                   "signatureTypesPath": "/handoff/codingEvidence/signatureTypes",
+                                   **({"guide": evidence["guide"]} if isinstance(evidence.get("guide"), str) and len(evidence["guide"]) <= 512 else {}),
+                                   "apiContracts": [{**pick(contract, ("class",)),
+                                                     "path": f"/handoff/codingEvidence/apiContracts/{index}",
+                                                     "members": list(dict.fromkeys(member["name"] for member in contract.get("members", []) if "name" in member))}
+                                                    for index, contract in enumerate(evidence.get("apiContracts", []))]},
+                "remainingContext": {"stateFields": "/handoff/stateFields", "specialized": "/handoff/specialized", "reportContract": "/handoff/reportContract"},
+                "evidenceScope": "Startup facts and pointers only; collection membership is not proof of a standalone query root, and source compilation does not establish business coverage",
+            }
+            if len(encoded(start).encode("utf-8")) > MAX_CODING_START_BYTES:
+                for entity in start["entities"]:
+                    entity["fieldCount"] = len(entity.pop("fields"))
+                    entity["fieldsOmitted"] = True
+            return start
+
+        def compact_graph(value: dict) -> dict:
+            if not isinstance(value, dict) or not isinstance(value.get("entities"), list):
+                raise QueryError("HANDOFF_CODING_CONTEXT_INVALID", "formGraph entities are required")
+            if any(not isinstance(entity, dict) or not isinstance(entity.get("fields"), list) or any(not isinstance(field, dict) for field in entity["fields"]) for entity in value["entities"]):
+                raise QueryError("HANDOFF_CODING_CONTEXT_INVALID", "entities and fields must be objects")
+            return {
+                **pick(value, ("formNumber", "formName", "metadataVersion")),
+                "entities": [
+                    {
+                        **pick(entity, ("entityKey", "entityName", "entityType", "role", "parentEntityKey", "collectionProperty", "collectionPath")),
+                        "fields": [pick(field, ("fieldKey", "fieldName", "fieldType", "fieldPath", "javaType", "valueAccessor", "timeValueUnit", "refTo", "comboOptions", "reference", "idAccessor", "filterValue")) for field in entity.get("fields", [])],
+                    }
+                    for entity in value["entities"]
+                ],
+            }
+
+        return {
+            "status": True,
+            "contextMode": "coding-context",
+            "handoffPath": document["handoffPath"],
+            "handoffSha256": hashlib.sha256(Path(document["handoffPath"]).read_bytes()).hexdigest(),
+            **pick(handoff, ("appRoot", "projectRoot", "formNumber", "className", "sourcePath", "fqcn", "operationKeys", "coreLogic", "specialized", "sourceGate")),
+            "formGraph": compact_graph(graph),
+            "targetSdk": target_sdk(),
+            "queryRootEvidence": {
+                "formNumber": graph.get("formNumber"),
+                "nonRootEntityKeys": [entity["entityKey"] for entity in graph["entities"]
+                                      if entity.get("role") in ("entries", "subentries") and isinstance(entity.get("entityKey"), str)],
+                "boundary": "EntryType and SubEntryType are collection members here, not evidence of standalone QueryServiceHelper roots; runtime query behavior is unverified by this snapshot.",
+            },
+            "relatedForms": [compact_graph(form) for form in handoff.get("relatedForms", [])],
+            "operationContracts": handoff.get("operationContracts", []),
+            "availableOperations": handoff.get("availableOperations", []),
+            "stateFields": handoff.get("stateFields", []),
+            "stateWarnings": handoff.get("stateWarnings", []),
+            "codingEvidence": {
+                **pick(evidence, ("codingEntry", "signatureTypes", "operationDispatch", "apiLookup", "sdkLookup")),
+                **({"guide": evidence["guide"]} if isinstance(evidence.get("guide"), str) and len(evidence["guide"]) <= 512 else {}),
+                "apiContracts": [
+                    {
+                        **pick(contract, ("class", "import", "reference")),
+                        "members": [pick(member, ("name", "signature", "declaredBy", "deprecated")) for member in contract.get("members", [])],
+                    }
+                    for contract in evidence.get("apiContracts", [])
+                ],
+            },
+        }
+    value = resolve_pointer(document, args.path)
+    if args.operation == "get":
+        return {"status": True, "path": args.path, "value": value}
+    if args.operation == "index":
+        if not isinstance(value, (dict, list)):
+            raise QueryError("HANDOFF_NOT_CONTAINER", "index requires an object or array; use get for a scalar")
+        children = list(value.items()) if isinstance(value, dict) else list(enumerate(value))
+        page = children[args.offset:args.offset + args.limit]
+        return {
+            "status": True, "path": args.path, "kind": "object" if isinstance(value, dict) else "array",
+            "total": len(children), "offset": args.offset,
+            "nextOffset": args.offset + len(page) if args.offset + len(page) < len(children) else None,
+            "items": [describe(child, pointer_child(args.path, key)) for key, child in page],
+        }
+    if not isinstance(value, list) or any(not isinstance(item, dict) for item in value):
+        raise QueryError("HANDOFF_NOT_RECORD_LIST", "find requires an array of objects")
+    matches = [describe(item, pointer_child(args.path, index)) for index, item in enumerate(value) if item.get(args.field) == args.equals]
+    return {"status": True, "path": args.path, "field": args.field, "equals": args.equals, "matches": matches}
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("operation", choices=("index", "find", "get", "coding-context", "coding-start"))
+    parser.add_argument("--handoff", required=True, help="Exact handoffPath returned by prepare_plugin_handoff.py")
+    parser.add_argument("--path", default="", help="JSON pointer, such as /handoff/formGraph/entities")
+    parser.add_argument("--offset", type=int, default=0, help="First child for index")
+    parser.add_argument("--limit", type=int, default=DEFAULT_PAGE_SIZE, help="Children per index page")
+    parser.add_argument("--field", help="Direct object field for exact find")
+    parser.add_argument("--equals", help="Exact value for find")
+    args = parser.parse_args()
+    try:
+        if args.offset < 0 or not 1 <= args.limit <= MAX_PAGE_SIZE:
+            raise QueryError("HANDOFF_PAGE_INVALID", "offset must be nonnegative and limit must be 1–50")
+        if args.operation == "find" and (not args.field or args.equals is None or not args.path):
+            raise QueryError("HANDOFF_FIND_INVALID", "find requires --path, --field and --equals")
+        if args.operation != "find" and (args.field is not None or args.equals is not None):
+            raise QueryError("HANDOFF_FIND_INVALID", "--field and --equals apply only to find")
+        if args.operation in ("coding-context", "coding-start") and (args.path or args.offset or args.limit != DEFAULT_PAGE_SIZE):
+            raise QueryError("HANDOFF_CODING_CONTEXT_ARGUMENT_INVALID", "coding-context accepts only --handoff")
+        _, document = load_handoff(args.handoff)
+        response = query(document, args)
+        output = encoded(response)
+        limit = MAX_CODING_CONTEXT_BYTES if args.operation == "coding-context" else MAX_CODING_START_BYTES if args.operation == "coding-start" else MAX_OUTPUT_BYTES
+        if len(output.encode("utf-8")) > limit:
+            raise QueryError("HANDOFF_QUERY_TOO_LARGE", f"selected result exceeds {limit} bytes; index its children or select a narrower path")
+        print(output)
+        return 0
+    except QueryError as error:
+        print(encoded({"status": False, "errorCode": error.code, "message": str(error)}))
+        return 2
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/skills/cosmic-build/scripts/register_plugins.py

@@ -19,6 +19,7 @@ import urllib.error
 from pathlib import Path
 
 import kd_api
+from plugin_source_gate import validate_registration_entry
 
 REGISTER_PATH = "/kapi/v2/devportal/ai-meta/plugin/register"
 QUERY_PATH = "/kapi/v2/devportal/ai-meta/plugin/queryEditable"
@@ -200,7 +201,8 @@ def _load_classes_from_archive(app_root):
             error_code='JAVA_ARCHIVE_ENTRY_INVALID',
             details=invalid,
         )
-    return entries
+    biz_app_id = str(archive.get('appId') or '').strip()
+    return [{**entry, 'bizAppId': biz_app_id} for entry in entries] if biz_app_id else entries
 
 
 def _validate_candidate_sources(candidates):
@@ -262,7 +264,7 @@ def _filter_candidates(candidates, requested_names):
     ]
 
 
-def _build_register_payload(form_number, class_name, description, target_type, operation_key=None):
+def _build_register_payload(form_number, class_name, description, target_type, operation_key=None, biz_app_id=None):
     """构造注册请求 payload。"""
     payload = {
         'formNumber': form_number,
@@ -270,7 +272,10 @@ def _build_register_payload(form_number, class_name, description, target_type, o
         'description': description,
         'enabled': True,
         'targetType': target_type,
+        'pluginType': 'JAVA',
     }
+    if biz_app_id:
+        payload['bizAppId'] = biz_app_id
     if operation_key:
         payload['operationKey'] = operation_key
     return payload
@@ -389,6 +394,16 @@ def main():
     root_dir = _find_root_dir()
     type_map = _load_type_registry(root_dir)
     type_owners = _load_type_owners(root_dir)
+    source_checks = []
+    try:
+        for candidate in candidates:
+            if candidate.get('filePath') and type_map.get(candidate.get('type')):
+                checked = validate_registration_entry(candidate, type_map[candidate['type']], _resolve_fqcn(candidate))
+                source_checks.append({'className': _resolve_fqcn(candidate), 'compileStatus': checked['compileStatus']})
+    except ValueError as exc:
+        code, _, message = str(exc).partition(':')
+        print(json.dumps(_failure(code, message.strip(), writeAttempted=False), ensure_ascii=False))
+        return 2
     server = _load_config(root_dir)
 
     if not server:
@@ -475,6 +490,7 @@ def main():
                 description=c.get('description', ''),
                 target_type=target_type,
                 operation_key=operation_key,
+                biz_app_id=c.get('bizAppId'),
             )
             try:
                 response = kd_api.post(
@@ -536,8 +552,18 @@ def main():
             'failed': sum(1 for r in results if not r['success']),
         },
     }
+    if source_checks:
+        output['sourceChecks'] = source_checks
     if verification is not None:
         output['verification'] = verification
+    if expected:
+        # Registration read-back does not establish deployment activation or restart needs.
+        output['activation'] = {
+            'requiresServiceRestart': None,
+            'runtimeVerified': False,
+            'state': 'registration_incomplete' if has_failure else 'runtime_unverified' if verification and verification['status'] == 'pass' else 'registration_unverified',
+            'registeredClasses': sorted({item['className'] for item in expected}),
+        }
     print(json.dumps(output, ensure_ascii=False, indent=2))
     return 2 if has_failure else 0
 

package/skills/cosmic-build/scripts/render_output_cards.py

@@ -14,6 +14,7 @@ from __future__ import annotations
 import argparse
 import hashlib
 import json
+import os
 import subprocess
 import sys
 from pathlib import Path
@@ -25,8 +26,10 @@ if str(SCRIPT_DIR) not in sys.path:
     sys.path.insert(0, str(SCRIPT_DIR))
 
 from preview_url import PreviewUrlError, get_form_name, get_preview_url
+from test_environment import export_test_environment
 
 _DYM_BACKGROUND_NOTICE = None
+_TEST_ENVIRONMENT_HANDOFF = None
 
 
 class ReportPluginSourceMissing(Exception):
@@ -343,6 +346,8 @@ def render(
 ) -> list[str]:
     global _DYM_BACKGROUND_NOTICE
     _DYM_BACKGROUND_NOTICE = None
+    global _TEST_ENVIRONMENT_HANDOFF
+    _TEST_ENVIRONMENT_HANDOFF = None
     archive_path = Path(app_root) / "archive.json"
     if not archive_path.exists():
         print(f"Warning: {archive_path} does not exist, skipping kdform cards", file=sys.stderr)
@@ -394,6 +399,7 @@ def render(
 
     blocks: list[str] = []
     deleted_numbers: list[str] = []
+    browser_entries: dict[str, dict[str, str]] = {}
     artifacts: list[dict[str, str]] = archive.get("artifacts", [])
     if not isinstance(artifacts, list):
         artifacts = []
@@ -411,6 +417,9 @@ def render(
         if not base_url:
             print("Warning: server.baseUrl is empty (check ~/.kd/config.json)", file=sys.stderr)
         else:
+            _TEST_ENVIRONMENT_HANDOFF = export_test_environment(
+                app_root, server_config, [number for number, _title in form_entries]
+            )
             archived_urls = _archived_preview_urls(artifacts)
             # 子集渲染不能清掉其他表单已经归档的卡片。
             requested_set = {fn for fn, _title in form_entries}
@@ -444,12 +453,19 @@ def render(
                     url = archived_urls.get(fn, "")
                     fallback = "reusing archived preview link" if url else "rendering card without preview link"
                     print(f"Warning: getPreviewUrl({fn}) failed ({e}); {fallback}", file=sys.stderr)
-                # 列表预览地址（viewType=list）是尽力而为的只读：失败仅省略卡片里的
-                # listUrl 字段，绝不阻塞卡片本身。
+                # 平台忽略 viewType=list 时，由已验证列表元数据恢复标准 bos_list 入口。
                 try:
-                    list_url = get_preview_url(server_config, base_url, fn, view_type="list")
+                    list_url = get_preview_url(
+                        server_config, base_url, fn, view_type="list", form_preview_url=url,
+                    )
                 except Exception:
                     list_url = ""
+                if list_url and list_url == url:
+                    print(
+                        f"Warning: getPreviewUrl({fn}, viewType=list) returned the editor URL; omitted listUrl",
+                        file=sys.stderr,
+                    )
+                    list_url = ""
                 metadata = _join_url(base_url, f"/kapi/v2/devportal/ai-meta/getEntityFields?formNumber={fn}")
                 plugins = _join_url(base_url, f"/kapi/v2/devportal/ai-meta/getFormPlugins?formNumber={fn}")
                 designer = _join_url(base_url, f"/kapi/v2/devportal/ai-meta/getDesignerUrl?formNumber={fn}")
@@ -458,6 +474,7 @@ def render(
                 card = {"title": title, "url": url, "metadata": metadata, "plugins": plugins, "designer": designer}
                 if list_url:
                     card["listUrl"] = list_url
+                browser_entries[fn] = {"formName": title, "previewUrl": url, "listUrl": list_url}
                 if api:
                     card["api"] = api
 
@@ -465,6 +482,12 @@ def render(
                 card_json = json.dumps(card, ensure_ascii=False)
                 blocks.append(f":::render:kdform\n{card_json}\n:::")
 
+            _TEST_ENVIRONMENT_HANDOFF = export_test_environment(
+                app_root, server_config,
+                [number for number, _title in form_entries if number not in deleted_numbers],
+                form_links=browser_entries,
+            )
+
     archive["artifacts"] = artifacts
     _write_json(archive_path, archive)
 
@@ -487,6 +510,8 @@ def render(
 
 
 def main() -> int:
+    global _TEST_ENVIRONMENT_HANDOFF
+    _TEST_ENVIRONMENT_HANDOFF = None
     parser = argparse.ArgumentParser(description="Render output cards")
     parser.add_argument("--app-root", required=True, help="App root directory")
     parser.add_argument("--wait-dym", action="store_true",
@@ -511,6 +536,7 @@ def main() -> int:
         help="Display name paired with --form-number",
     )
     args = parser.parse_args()
+    os.environ["PROJECT_ROOT"] = str(Path(args.app_root).resolve())
 
     if args.form_name and not args.form_numbers:
         parser.error("--form-name requires --form-number")
@@ -536,20 +562,27 @@ def main() -> int:
     except DeletedArtifactNoCard as exc:
         print(str(exc), file=sys.stderr)
         return 0
+    except ValueError as exc:
+        print(f"Error: {exc}", file=sys.stderr)
+        return 1
     if not blocks:
         return 1
 
     for block in blocks:
         print(block, flush=True)
+    if _TEST_ENVIRONMENT_HANDOFF:
+        print("TEST_ENVIRONMENT_HANDOFF=" + json.dumps(_TEST_ENVIRONMENT_HANDOFF, ensure_ascii=False), flush=True)
     if _DYM_BACKGROUND_NOTICE:
-        print(_DYM_BACKGROUND_NOTICE, file=sys.stderr, flush=True)
+        # 后台同步是必须交给宿主执行的动作，不是诊断日志。放在卡片块后的
+        # stdout，避免调用方隐藏 stderr 时把同步请求一起丢弃。
+        print(_DYM_BACKGROUND_NOTICE, flush=True)
 
     print(
-        "DELIVERY: The blocks above are the final answer artifact, not links to summarize. "
-        "Next call output_check once (discover it with search_tools if deferred), then copy "
-        "the blocks according to references/delivery.md. Do not use Markdown links or "
-        "code fences, or rerun creation/rendering. If the host has no output_check, "
-        "copy the blocks directly.",
+        "DELIVERY: Preserve the exact blocks for the final delivery response; do not rerender them. "
+        "These are domain artifacts, not evidence that the whole request or acceptance is complete. "
+        "For delegated implementation, return the blocks and actual results to the owner and continue "
+        "its remaining acceptance work. At whole-request finalization, call output_check once if "
+        "available, then include the blocks without Markdown links or code fences.",
         file=sys.stderr,
         flush=True,
     )

package/skills/cosmic-build/scripts/report_algo_benchmark.py

@@ -0,0 +1,46 @@
+#!/usr/bin/env python3
+"""Run the production Algo examples against a supplied target SDK, without database queries."""
+import argparse
+import json
+import os
+import subprocess
+import tempfile
+from pathlib import Path
+
+
+def main():
+    parser=argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--sdk-classpath", required=True)
+    parser.add_argument("--java-home", required=True)
+    parser.add_argument("--rows", type=int, default=10000)
+    parser.add_argument("--groups", type=int, default=100)
+    parser.add_argument("--iterations", type=int, default=5)
+    parser.add_argument("--output")
+    args=parser.parse_args()
+    if not 1 <= args.groups <= args.rows or args.iterations < 3:
+        parser.error("1 <= groups <= rows and iterations >= 3 are required")
+    root=Path(__file__).resolve().parents[1]
+    suffix=".exe" if os.name=="nt" else ""
+    java=Path(args.java_home)/"bin"/("java"+suffix)
+    javac=Path(args.java_home)/"bin"/("javac"+suffix)
+    with tempfile.TemporaryDirectory(prefix="report-algo-") as directory:
+        compiled=subprocess.run([str(javac),"-source","8","-target","8","-cp",args.sdk_classpath,"-d",directory,
+            str(root/"examples/java-rules/CosmicReportAggregation.java"),
+            str(root/"assets/report-algo-benchmark/ReportBenchmarkLogFactory.java"),
+            str(root/"assets/report-algo-benchmark/ReportAlgoBenchmark.java")],capture_output=True,text=True,timeout=60)
+        if compiled.returncode:
+            print(json.dumps({"status":"blocked","phase":"compile","diagnostics":compiled.stderr[-4000:]}));return 2
+        # Use the verified Java 8 runtime. Newer JVMs may need opens flags for SDK managed threads.
+        run=subprocess.run([str(java),"-DclusterName=report-benchmark","-Dlogfactory.className=ReportBenchmarkLogFactory",
+            "-cp",os.pathsep.join([directory,args.sdk_classpath]),"ReportAlgoBenchmark",str(args.rows),str(args.groups),str(args.iterations)],
+            cwd=directory,capture_output=True,text=True,timeout=75)
+        lines=[line for line in run.stdout.splitlines() if line.startswith('{"rows":')]
+        result={"status":"passed",**json.loads(lines[-1]),"scope":"local Algo computation only; no database, permission or browser latency benchmark"} if run.returncode==0 and lines else {
+            "status":"blocked","phase":"runtime","diagnostics":run.stderr[-4000:]}
+        if args.output: Path(args.output).write_text(json.dumps(result,ensure_ascii=False,indent=2)+"\n",encoding="utf-8")
+        print(json.dumps(result,ensure_ascii=False))
+        return 0 if result["status"]=="passed" else 2
+
+
+if __name__=="__main__":
+    raise SystemExit(main())

package/skills/cosmic-build/scripts/run.py

@@ -1282,8 +1282,8 @@ def parse_entry(prop):
         if not sub_name or sub_type == 'VarcharProp':
             continue
 
-        # 检查子单据体（MulBasedataProp / SubEntryProp 均为子单据体；漏 SubEntryProp 会导致子单据体字段丢失）
-        # Check for sub-entry
+        # Check for sub-entry（本地补丁 #1：MulBasedataProp / SubEntryProp 均为子单据体；
+        # 漏 SubEntryProp 会导致子单据体字段静默丢失）
         if sub_type in ('MulBasedataProp', 'SubEntryProp') and 'ItemType' in sub_prop:
             sub_entry = parse_sub_entry(sub_prop)
             entry['sub_entries'].append(sub_entry)