@shundoo-ai/dsh-cosmic 1.0.21 → 1.0.22

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

@@ -15,6 +15,7 @@ from pathlib import Path
 from typing import Any
 
 from appconfig_load import inspect_config
+from dcs_code_gate import dcs_rule_issues, dcs_rule_warnings
 from java_source import commentless, duplicate_methods, method_bodies, method_signatures, stripped
 from plugin_source_gate import write_state
 from platform_api_contract import (
@@ -22,8 +23,13 @@ from platform_api_contract import (
     filter_operator_issues,
     forbidden_member_issues,
     override_signature_issues,
+    operation_call_findings,
+    report_batch_issues,
+    report_listener_issues,
+    report_source_cast_warnings,
     return_type_issues,
     scene_misuse_issues,
+    sdk_absent_name_warnings,
     unverified_import_issues,
     unverified_member_issues,
 )
@@ -83,6 +89,76 @@ def time_fields_from_handoff(handoff: dict) -> set[str]:
     return {key for key, kinds in types.items() if kinds and kinds <= {"TimeProp", "TimeField"}}
 
 
+def operation_field_issues(source_text: str, context: dict | None) -> list[dict]:
+    """Catch the proven direct-row/explicit-field-list case, not arbitrary Java data flow."""
+    if not context or not isinstance(context.get("formGraph"), dict):
+        return []
+    code = stripped(source_text)
+    source = commentless(source_text)
+    if not re.search(r"\bextends\s+(?:kd\.bos\.entity\.plugin\.)?AbstractOperationServicePlugIn\b", code):
+        return []
+    constants = {}
+    for match in re.finditer(r'\b(?:static\s+)?final\s+String\s+(\w+)\s*=\s*"([^"\\]*)"\s*;', source):
+        if code[match.start():match.start() + 5].strip():
+            constants.setdefault(match[1], set()).add(match[2])
+
+    def value(token):
+        token = token.strip()
+        if re.fullmatch(r'"[^"\\]*"', token):
+            return token[1:-1]
+        values = constants.get(token, set())
+        return next(iter(values)) if len(values) == 1 else None
+
+    prepare = [body for body in method_bodies(source_text) if body["name"] == "onPreparePropertys"]
+    if len(prepare) != 1 or re.search(r"\bpreparePropertys\s*\(", code):
+        return []
+    body = source[prepare[0]["start"]:prepare[0]["end"]]
+    masked = code[prepare[0]["start"]:prepare[0]["end"]]
+    # Helpers, loops and conditional adds need real data-flow analysis. Do not turn an
+    # unproven omission into a delivery block; explicit straight-line declarations suffice here.
+    if re.search(r"\b(if|for|while|switch|return|try)\b|\baddAll\s*\(", masked):
+        return []
+    lists = re.findall(r"\b(\w+)\s*=\s*\w+\.getFieldKeys\s*\(\s*\)", masked)
+    allowed = {"getFieldKeys", "onPreparePropertys", "add"}
+    if not lists or any(name not in allowed for name in re.findall(r"\b(\w+)\s*\(", masked)):
+        return []
+    declared = set()
+    for name in lists:
+        for match in re.finditer(r"\b" + re.escape(name) + r"\.add\s*\(([^()]*)\)", body):
+            key = value(match[1])
+            if key is None:
+                return []
+            declared.add(key)
+    entities = context["formGraph"].get("entities", [])
+    entries = {entity.get("collectionProperty"): entity for entity in entities
+               if entity.get("role") in ("entries", "subentries") and entity.get("collectionProperty")}
+    loaded = set(re.findall(r"\bExtendedDataEntity\s+(\w+)\s*:\s*(?:this\.)?getDataEntities\s*\(\s*\)", code))
+    headers = {match[1] for match in re.finditer(r"\bDynamicObject\s+(\w+)\s*=\s*(\w+)\.getDataEntity\s*\(\s*\)", code)
+               if match[2] in loaded and len(re.findall(r"\bDynamicObject\s+" + re.escape(match[1]) + r"\b", code)) == 1}
+    issues = []
+    for collection in re.finditer(r"\bDynamicObjectCollection\s+(\w+)\s*=\s*(\w+)\.getDynamicObjectCollection\s*\(([^()]*)\)", source):
+        if not code[collection.start():collection.start() + 23].strip():
+            continue
+        entity = entries.get(value(collection[3]))
+        if collection[2] not in headers or not entity or len(re.findall(r"\bDynamicObjectCollection\s+" + re.escape(collection[1]) + r"\b", code)) != 1:
+            continue
+        fields = {field["fieldKey"] for field in entity.get("fields", []) if isinstance(field.get("fieldKey"), str)}
+        rows = re.findall(r"\bDynamicObject\s+(\w+)\s*(?:=\s*" + re.escape(collection[1]) + r"\.get\s*\(|:\s*" + re.escape(collection[1]) + r"\b)", code)
+        for row in rows:
+            if len(re.findall(r"\bDynamicObject\s+" + re.escape(row) + r"\b", code)) != 1:
+                continue
+            for read in re.finditer(r"\b" + re.escape(row) + r"\.get(?:Int|Long|String|BigDecimal|Boolean|Date|DynamicObject)?\s*\(([^()]*)\)", source):
+                if not code[read.start():read.start() + len(row)].strip():
+                    continue
+                key = value(read[1])
+                path = ".".join([*(entity.get("collectionPath") or [entity["collectionProperty"]]), key or ""])
+                if key not in fields or key in declared or path in declared:
+                    continue
+                issues.append({"line": source.count("\n", 0, read.start()) + 1,
+                               "fieldKey": key, "collectionProperty": entity["collectionProperty"],
+                               "message": f"Entry field {key} is read from {entity['collectionProperty']} but absent from the explicit onPreparePropertys field list. Add this field key before list/batch operation loading; declaring only the collection does not load its fields."})
+    return issues
+
 def operation_dispatch_warnings(source_text: str, operation_keys: list[str]) -> list[dict]:
     code = stripped(source_text)
     source = commentless(source_text)
@@ -102,12 +178,91 @@ def operation_dispatch_warnings(source_text: str, operation_keys: list[str]) ->
     return issues
 
 
+_HEAD_FILTER_ON_RE = re.compile(r"\.\s*setFilter\s*\(\s*true\s*\)")
+_HEAD_FILTER_READ_RE = re.compile(r"\b(?:getTableHeadFilterItems|getHeadFilters)\s*\(")
+_REPORT_DATA_TYPES = ("reportlist", "report-plugin")
+
+
+def _enables_head_filter(source_text: str) -> bool:
+    code = stripped(source_text)
+    return any(body["name"] == "setSortAndFilter"
+               and _HEAD_FILTER_ON_RE.search(code[body["start"]:body["end"]])
+               for body in method_bodies(source_text))
+
+
+def _archived_partners(app_root: Path, form_number: str, types: tuple[str, ...],
+                       source_path: Path) -> list[tuple[str, str]]:
+    """(className, source) of each archived plugin of `types` on the same report form."""
+    archive_path = app_root.resolve() / "archive.json"
+    try:
+        entries = json.loads(archive_path.read_text(encoding="utf-8-sig")).get("javas") or []
+    except (OSError, ValueError, AttributeError):
+        return []
+    partners = []
+    for entry in entries:
+        if not isinstance(entry, dict) or entry.get("type") not in types:
+            continue
+        if str(entry.get("formNumber") or "").strip() != form_number.strip():
+            continue
+        path = Path(str(entry.get("filePath") or ""))
+        if not path.is_file() or path.resolve() == source_path.resolve():
+            continue
+        partners.append((str(entry.get("className") or path.stem),
+                         path.read_text(encoding="utf-8-sig", errors="replace")))
+    return partners
+
+
+def report_head_filter_warnings(source_text: str, plugin_type: str, form_number: str,
+                                app_root: Path, source_path: Path) -> list[dict]:
+    """Header filtering switched on for a report whose data plugin never applies it.
+
+    The two halves sit in two plugins of one report: setFilter(true) in the reportform plugin's
+    setSortAndFilter only shows the funnel, and the rows change once the data plugin's query()
+    adds the header conditions. Each side is checked against the other's archived source, so
+    whichever of the two is compiled second reports the gap; a side not archived yet is not judged.
+    """
+    if plugin_type == "reportform" and _enables_head_filter(source_text):
+        partners = _archived_partners(app_root, form_number, _REPORT_DATA_TYPES, source_path)
+        if not partners or any(_HEAD_FILTER_READ_RE.search(stripped(text)) for _, text in partners):
+            return []
+        switched_on, data_plugins = "this plugin", [name for name, _ in partners]
+    elif plugin_type in _REPORT_DATA_TYPES and not _HEAD_FILTER_READ_RE.search(stripped(source_text)):
+        enabling = [name for name, text in _archived_partners(
+            app_root, form_number, ("reportform",), source_path) if _enables_head_filter(text)]
+        if not enabling:
+            return []
+        switched_on, data_plugins = ", ".join(enabling), ["this plugin"]
+    else:
+        return []
+    return [{
+        "severity": "warning",
+        "errorCode": "PLUGIN_REPORT_HEAD_FILTER_UNAPPLIED",
+        "formNumber": form_number,
+        "message": (
+            f"{switched_on} switches header filtering on with setFilter(true) in setSortAndFilter, "
+            f"but {', '.join(data_plugins)} never reads getTableHeadFilterItems() or "
+            "getHeadFilters(): the funnel shows and the rows do not change. Add the header "
+            "conditions in query(), as scenes/report/report-head-filter.md does"
+        ),
+    }]
+
+
 def compile_handoff(filename: str) -> dict:
+    from query_plugin_handoff import QueryError, validate_input_files
     prepared = json.loads(Path(filename).read_text(encoding="utf-8-sig"))
+    try:
+        validate_input_files(prepared)
+    except QueryError as exc:
+        raise CompileError(str(exc), "PLUGIN_HANDOFF_STALE") from exc
     context = prepared.get("handoff") if prepared.get("status") is True else None
     if not isinstance(context, dict) or not all(context.get(key) for key in
-            ("projectRoot", "appRoot", "sourcePath", "className", "type", "formNumber", "description")):
+            ("projectRoot", "appRoot", "sourcePath", "className", "type", "description")):
         raise CompileError("handoff must contain successfully prepared coding context", "PLUGIN_SOURCE_INVALID")
+    source = context.get("sourceContext")
+    if not context.get("formNumber") and not (isinstance(source, dict) and source.get("scope") == "source-only"
+            and source.get("sourcePath") == context.get("sourcePath") and context.get("ownershipMode") == "modify"
+            and context.get("type") != "operation"):
+        raise CompileError("formNumber is required for a bound plugin", "PLUGIN_SOURCE_INVALID")
     return context
 # Scanned over the whole file, comments included: these three are markers of an unresolved
 # dependency, so one sitting in a comment is exactly the case to block.
@@ -124,10 +279,11 @@ CODE_BLOCKERS = (
 
 
 class CompileError(ValueError):
-    def __init__(self, message: str, code: str, phase: str = "preflight") -> None:
+    def __init__(self, message: str, code: str, phase: str = "preflight", *, details: dict | None = None) -> None:
         super().__init__(message)
         self.code = code
         self.phase = phase
+        self.details = details or {}
 
 
 def _settings_file(gradle_root: Path) -> Path:
@@ -160,15 +316,22 @@ def resolve_module(gradle_root: Path, project_root: Path) -> str:
     return matches[0]
 
 
-def inspect_compile_environment(project_root: str) -> dict:
-    config = inspect_config(write_derived=False)
+def inspect_compile_environment(project_root: str, config: dict | None = None) -> dict:
+    config = inspect_config(write_derived=False) if config is None else config
+    facts = {key: config[key] for key in ("configPath", "compile", "autoregister", "missing", "invalid") if key in config}
+    facts["configCommands"] = {
+        "status": [sys.executable, str(Path(__file__).with_name("appconfig_load.py")), "--status"],
+        "help": [sys.executable, str(Path(__file__).with_name("appconfig_load.py")), "--help"],
+    }
     if config.get("status") != "ready":
-        return {"status": config.get("status", "unknown"), "message": config.get("message", "Compile environment unavailable")}
+        return {**facts, **{key: config[key] for key in ("GRADLE_ROOT", "JAVA_HOME") if key in config},
+                "status": config.get("status", "unknown"), "message": config.get("message", "Compile environment unavailable")}
     root = Path(str(config["GRADLE_ROOT"])).resolve()
     try:
         module = resolve_module(root, Path(project_root))
     except CompileError as error:
-        return {"status": "unbound", "code": error.code, "message": str(error)}
+        return {**facts, "status": "unbound", "code": error.code, "message": str(error),
+                "gradleRoot": str(root), "projectRoot": str(Path(project_root).resolve())}
     sdk_paths = []
     properties = root / "gradle.properties"
     scheme = root / "config.gradle"
@@ -190,7 +353,7 @@ def inspect_compile_environment(project_root: str) -> dict:
                     continue
                 if directory.is_dir() and any(directory.glob("*.jar")):
                     sdk_paths.append({"path": str(directory.resolve()), "source": [str(properties), str(scheme)], "property": match[1]})
-    return {"status": "ready", "gradleRoot": str(root), "module": module,
+    return {**facts, "status": "ready", "gradleRoot": str(root), "module": module,
             "wrapperPath": str(root / ("gradlew.bat" if os.name == "nt" else "gradlew")),
             "javaHome": config["JAVA_HOME"], "sdkDirectories": sdk_paths,
             "sdkPathEvidence": "Matched one target Gradle property and config.gradle library expression; ambiguous or unavailable configurations remain unresolved, and Gradle was not executed"}
@@ -233,6 +396,18 @@ def validate_source(source_path: Path, project_root: Path, class_name: str) -> l
     return issues
 
 
+def sample_diagnostics(errors: list[dict], limit: int) -> list[dict]:
+    """Show each file before repeating one file; retain the full log for overflow."""
+    selected = []
+    seen = set()
+    for index, error in enumerate(errors):
+        if error["file"] not in seen and len(selected) < limit:
+            selected.append(index)
+            seen.add(error["file"])
+    selected += [index for index in range(len(errors)) if index not in selected][:max(0, limit - len(selected))]
+    return [errors[index] for index in selected]
+
+
 def collect_compiler_errors(
     output: str, target: str | None = None,
 ) -> tuple[list[dict[str, Any]], list[dict[str, Any]], int]:
@@ -242,14 +417,12 @@ def collect_compiler_errors(
     compile produced diagnostics for a class this run never touched — and once thirty of those were
     collected, the real ones were dropped. `inTargetSource` tells the two apart.
 
-    Only the unrelated errors are capped during collection, and scanning continues past them so a
-    target error appearing afterwards is still found. The drop count is returned so a caller can
-    report how many errors exist rather than how many it chose to show.
+    Scan the entire output before sampling other files, so later target/helper errors survive
+    earlier noise. The drop count reports all errors, not only the displayed sample.
     """
     lines = output.splitlines()
     mine: list[dict[str, Any]] = []
     others: list[dict[str, Any]] = []
-    dropped = 0
     index = 0
     while index < len(lines):
         match = JAVA_ERROR_RE.match(lines[index])
@@ -260,30 +433,28 @@ def collect_compiler_errors(
         index += 1
         while index < len(lines) and not JAVA_ERROR_RE.match(lines[index]):
             stripped = lines[index].strip()
-            if stripped.startswith(("符号:", "位置:", "symbol:", "location:")):
-                detail.append(stripped)
-            if stripped.startswith(("> Task", "FAILURE:", "BUILD FAILED")):
+            if stripped.startswith(("> Task", "FAILURE:", "BUILD FAILED", "BUILD SUCCESSFUL", "* What went wrong:", "* Try:")) or re.fullmatch(r"\d+ (?:errors?|warnings?|个错误|个警告)", stripped):
                 break
+            if stripped:
+                detail.append(stripped)
             index += 1
         error = {
             "file": match.group("file"),
             "line": int(match.group("line")),
             "message": match.group("message").strip(),
-            "detail": detail,
+            "detail": detail[:40],
+            **({"detailTruncated": True} if len(detail) > 40 else {}),
         }
         if target is None:
             others.append(error)
-            if len(others) == DIAGNOSTIC_LIMIT:
-                break
             continue
         error["inTargetSource"] = str(Path(error["file"]).resolve()) == target
         if error["inTargetSource"]:
             mine.append(error)
-        elif len(others) < DIAGNOSTIC_LIMIT:
-            others.append(error)
         else:
-            dropped += 1
-    return mine, others, dropped
+            others.append(error)
+    dropped = max(0, len(others) - DIAGNOSTIC_LIMIT)
+    return mine, sample_diagnostics(others, DIAGNOSTIC_LIMIT), dropped
 
 
 def parse_compiler_errors(output: str, target_source: Path | None = None) -> list[dict[str, Any]]:
@@ -300,7 +471,7 @@ def compile_source(
     project_root: Path, source_path: Path, class_name: str, timeout_sec: int,
     *, app_root: Path, plugin_type: str, form_number: str,
     operation_keys: list[str], description: str, module_runs: dict | None = None,
-    time_fields: set[str] | None = None,
+    time_fields: set[str] | None = None, field_context: dict | None = None, preflight_only: bool = False,
 ) -> dict[str, Any]:
     # Before the source is read: this used to sit just before the Gradle call, so a description one
     # character too long was reported only after all the source gates had run.
@@ -318,13 +489,14 @@ def compile_source(
         }
     source_hash = hashlib.sha256(source_path.read_bytes()).hexdigest()
     source_text = source_path.read_text(encoding="utf-8-sig")
-    archive_path = app_root.resolve() / "archive.json"
-    if archive_path.is_file():
-        previous = json.loads(archive_path.read_text(encoding="utf-8-sig"))
-        for entry in previous.get("javas", []):
-            if (str(entry.get("className", "")).rsplit(".", 1)[-1] == class_name
-                    and Path(str(entry.get("filePath") or "")).resolve() == source_path.resolve()):
-                write_archive(archive_path, javas=[{**entry, "compileStatus": "pending"}])
+    if not preflight_only:
+        archive_path = app_root.resolve() / "archive.json"
+        if archive_path.is_file():
+            previous = json.loads(archive_path.read_text(encoding="utf-8-sig"))
+            for entry in previous.get("javas", []):
+                if (str(entry.get("className", "")).rsplit(".", 1)[-1] == class_name
+                        and Path(str(entry.get("filePath") or "")).resolve() == source_path.resolve()):
+                    write_archive(archive_path, javas=[{**entry, "compileStatus": "pending"}])
     # Independent source checks share one response so a repair can address them together.
     checks = [
         ("PLUGIN_SOURCE_DUPLICATE_METHOD", duplicate_methods),
@@ -336,12 +508,22 @@ def compile_source(
         ("PLUGIN_SOURCE_UNVERIFIED_API", unverified_import_issues),
         ("PLUGIN_SOURCE_UNVERIFIED_API", unverified_member_issues),
         ("PLUGIN_SOURCE_LIFECYCLE_MISUSE", scene_misuse_issues),
+        ("PLUGIN_SOURCE_LISTENER_UNREGISTERED", report_listener_issues),
+        ("PLUGIN_SOURCE_BATCH_NOT_NARROWED", report_batch_issues),
+        # The rules DCS rejects a deployment for, caught here so the package passes it first time.
+        ("PLUGIN_SOURCE_DCS_RULE_VIOLATION", lambda text: dcs_rule_issues(text, source_path.resolve())),
     ]
-    findings = [{**issue, "errorCode": code} for code, check in checks for issue in check(source_text)]
-    warnings = [{**issue, "errorCode": "PLUGIN_SOURCE_FIELD_ACCESSOR_MISMATCH"}
+    operation_issues, operation_warnings = operation_call_findings(source_text, (form_number,))
+    findings = operation_issues + [{**issue, "errorCode": code} for code, check in checks for issue in check(source_text)]
+    warnings = operation_warnings + [{**issue, "errorCode": "PLUGIN_SOURCE_FIELD_ACCESSOR_MISMATCH"}
                 for issue in time_accessor_issues(source_text, time_fields or set())]
+    warnings += sdk_absent_name_warnings(source_text) + report_source_cast_warnings(source_text)
+    warnings += report_head_filter_warnings(source_text, plugin_type, form_number, app_root, source_path)
+    warnings += dcs_rule_warnings(source_text, source_path.resolve())
     if plugin_type == "operation":
         warnings += operation_dispatch_warnings(source_text, operation_keys)
+        findings += [{**issue, "errorCode": "PLUGIN_SOURCE_OPERATION_FIELD_NOT_PREPARED"}
+                     for issue in operation_field_issues(source_text, field_context)]
     if findings:
         return {
             "status": False, "errorCode": findings[0]["errorCode"], "phase": "source_validation",
@@ -350,6 +532,8 @@ def compile_source(
             "issues": findings,
             "sourceWarnings": warnings,
         }
+    if preflight_only:
+        return {"status": True, "phase": "source_validation", "sourceWarnings": warnings}
     build_context = None
     def close_out(module: str, elapsed: float | None, compile_skipped: bool) -> dict[str, Any]:
         archive_path = app_root.resolve() / "archive.json"
@@ -432,12 +616,20 @@ def compile_source(
     config = inspect_config(write_derived=False)
     config_status = config.get("status")
     if config_status == "disabled":
+        unverified_overloads = [item for item in operation_warnings
+                               if item["errorCode"] == "PLUGIN_SOURCE_OPERATION_OVERLOAD_UNVERIFIED"]
+        if unverified_overloads:
+            return {"status": False, "errorCode": unverified_overloads[0]["errorCode"],
+                    "errorCodes": [unverified_overloads[0]["errorCode"]], "phase": "source_validation",
+                    "message": "操作重载未被已收录签名覆盖，且编译已关闭；改用已验证签名或绑定目标 SDK 并启用编译后重试，不能标记源码就绪。",
+                    "issues": unverified_overloads, "sourceWarnings": warnings}
         # appconfig says compilation is not needed here. Treating that as a hard failure
         # left the archive entry and the source_ready gate permanently unreachable, which
         # also blocked register_plugins.py — it only reads archived class entries.
         return close_out(module=":", elapsed=None, compile_skipped=True)
     if config_status != "ready":
-        raise CompileError(str(config.get("message") or "compile config is not ready"), "PLUGIN_COMPILE_CONFIG_UNAVAILABLE")
+        raise CompileError(str(config.get("message") or "compile config is not ready"), "PLUGIN_COMPILE_CONFIG_UNAVAILABLE",
+                           details={"buildEnvironment": inspect_compile_environment(str(project_root), config)})
     gradle_root = Path(str(config["GRADLE_ROOT"]))
     module = resolve_module(gradle_root, project_root)
     wrapper = gradle_root / ("gradlew.bat" if os.name == "nt" else "gradlew")
@@ -445,6 +637,7 @@ def compile_source(
     build_context = {"gradleRoot": str(gradle_root.resolve()), "javaProjectRoot": str(project_root.resolve()),
                      "wrapperPath": str(wrapper.resolve()), "javaHome": str(Path(config["JAVA_HOME"]).resolve()),
                      "compileTask": task, "testTaskCandidate": f"{module}:test" if module else "test",
+                     "testCommand": [sys.executable, str(Path(__file__).with_name("run_java_tests.py")), "--project-root", str(project_root.resolve())],
                      "testTaskEvidence": "Java task convention only; task availability and test results are not verified by this compile receipt"}
     env = os.environ.copy()
     env["JAVA_HOME"] = str(config["JAVA_HOME"])
@@ -491,8 +684,7 @@ def compile_source(
         log_path.write_text(completed.stdout, encoding="utf-8")
         mine, others, dropped = collect_compiler_errors(
             completed.stdout, str(source_path.resolve()))
-        diagnostics = mine[:5]
-        diagnostics += others[: max(0, 5 - len(diagnostics))]
+        diagnostics = sample_diagnostics([*mine, *others], 5)
         # Counted before truncation: reporting the shown subset understated a class with more than
         # DIAGNOSTIC_LIMIT errors, and dropped the "plus N elsewhere" clause exactly when the module
         # carried the most unrelated noise.
@@ -543,6 +735,7 @@ def main() -> int:
     args = parser.parse_args()
     try:
         time_fields = None
+        context = None
         if args.handoff:
             if any([args.project_root, args.app_root, args.sources_file, args.source_path, args.class_name,
                     args.plugin_type, args.form_number, args.description, args.operation_key]):
@@ -570,7 +763,6 @@ def main() -> int:
                 raise CompileError("Batch requires nonempty source records", "PLUGIN_BATCH_INPUT_INVALID")
             module_runs = {}
             results = []
-            reported_logs = set()
             for item in entries:
                 context = item
                 try:
@@ -584,24 +776,40 @@ def main() -> int:
                         app_root=Path(args.app_root), plugin_type=context["type"], form_number=context["formNumber"],
                         operation_keys=context.get("operationKeys", []), description=context["description"], module_runs=module_runs,
                         time_fields=time_fields_from_handoff(context) if item.get("handoffPath") else None,
+                        field_context=context if item.get("handoffPath") else None, preflight_only=True,
                     )
                 except CompileError as exc:
-                    outcome = {"status": False, "errorCode": exc.code, "phase": exc.phase, "message": str(exc)}
-                if outcome.get("logPath") in reported_logs:
-                    outcome.pop("diagnostics", None)
-                if outcome.get("logPath"):
-                    reported_logs.add(outcome["logPath"])
+                    outcome = {"status": False, "errorCode": exc.code, "phase": exc.phase, "message": str(exc), **exc.details}
                 results.append({"className": context.get("className"), **outcome})
+            if all(item.get("status") is True for item in results):
+                results = []
+                for item in entries:
+                    context = compile_handoff(item["handoffPath"]) if item.get("handoffPath") else item
+                    try:
+                        outcome = compile_source(
+                            Path(args.project_root), Path(context["sourcePath"]), context["className"], max(1, args.timeout_sec),
+                            app_root=Path(args.app_root), plugin_type=context["type"], form_number=context["formNumber"],
+                            operation_keys=context.get("operationKeys", []), description=context["description"], module_runs=module_runs,
+                            time_fields=time_fields_from_handoff(context) if item.get("handoffPath") else None,
+                            field_context=context if item.get("handoffPath") else None,
+                        )
+                    except CompileError as exc:
+                        outcome = {"status": False, "errorCode": exc.code, "phase": exc.phase, "message": str(exc), **exc.details}
+                    results.append({"className": context.get("className"), **outcome})
+            else:
+                results = [{**item, "status": False, "errorCode": "PLUGIN_BATCH_PREFLIGHT_BLOCKED",
+                            "message": "Another source has preflight errors; no source was compiled or archived"}
+                           if item.get("status") is True else item for item in results]
             result = {"status": all(item.get("status") is True for item in results), "results": results}
         else:
-            if not all([args.source_path, args.class_name, args.plugin_type, args.form_number, args.description]):
+            if not all([args.source_path, args.class_name, args.plugin_type, args.description]) or (not args.form_number and not context):
                 raise CompileError("Supply single-source arguments or --sources-file", "PLUGIN_SOURCE_INVALID")
             result = compile_source(
                 Path(args.project_root), Path(args.source_path), args.class_name,
                 max(1, args.timeout_sec),
                 app_root=Path(args.app_root), plugin_type=args.plugin_type,
                 form_number=args.form_number, operation_keys=args.operation_key,
-                description=args.description, time_fields=time_fields,
+                description=args.description, time_fields=time_fields, field_context=context,
             )
         print(json.dumps(result, ensure_ascii=False))
         return 0 if result.get("status") is True else 2
@@ -611,6 +819,7 @@ def main() -> int:
             "errorCode": exc.code,
             "phase": exc.phase,
             "message": str(exc),
+            **exc.details,
         }, ensure_ascii=False))
         return 2
     except Exception as exc:

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

@@ -0,0 +1,112 @@
+#!/usr/bin/env python3
+"""Standalone list update plus native card finalization; never replays a write."""
+from __future__ import annotations
+
+import argparse
+import json
+import subprocess
+import sys
+import uuid
+from pathlib import Path
+
+SCRIPTS = Path(__file__).resolve().parent
+API = SCRIPTS.parent / "skills" / "cosmic-meta-api" / "scripts" / "cosmic_api.py"
+
+
+def execute(app_root: str | None, project_root: str | None, form_name: str, input_value: str) -> tuple[int, str]:
+    root = Path(app_root or project_root).resolve()
+    destination = root / "_runtime" / ("list-result-" + uuid.uuid4().hex + ".json")
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    command = [sys.executable, str(API), "--output", str(destination), "configureList",
+               "--app-root" if app_root else "--project-root", str(root), "--form-name", form_name, "--input", input_value]
+    try:
+        configured = subprocess.run(command, capture_output=True, text=True, encoding="utf-8", errors="replace", timeout=240)
+        receipt = json.loads(destination.read_text(encoding="utf-8-sig")) if destination.is_file() else None
+    except (OSError, ValueError, subprocess.TimeoutExpired) as error:
+        return 3, json.dumps({"status": False, "errorCode": "LIST_RESULT_UNAVAILABLE", "message": str(error),
+            "completion": {"nextAction": "reconcile_write_state", "message": "Do not replay a possibly completed write"},
+            "resultPath": str(destination)}, ensure_ascii=False)
+    if not isinstance(receipt, dict):
+        return 3, json.dumps({"status": False, "errorCode": "LIST_RESULT_UNAVAILABLE", "exitCode": configured.returncode,
+            "completion": {"nextAction": "reconcile_write_state", "message": "No structured receipt; do not replay the command"},
+            "resultPath": str(destination)}, ensure_ascii=False)
+    result = {key: receipt[key] for key in ("status", "errorCode", "message", "verification", "mutation", "data", "writeAttempted", "metadataRetained") if key in receipt}
+    result["resultPath"] = str(destination)
+    if (receipt.get("verification") or {}).get("verified") is True:
+        result["verifiedPropertyCount"] = sum(len(column.get("properties") or {}) for column in receipt["verification"].get("columns", []))
+    data = dict(result.get("data")) if isinstance(result.get("data"), dict) else {}
+    result["data"] = data
+    mutation = receipt.get("mutation") or {}
+    result["writeAttempted"] = receipt.get("writeAttempted", mutation.get("writeAttempted"))
+    outcome = mutation.get("outcome")
+    if outcome in {"verified_noop", "failed_preflight"}:
+        result["completion"] = {"outcome": outcome, "requiresArtifactFinalization": False,
+            "nextAction": "respond_no_change" if outcome == "verified_noop" else (data.get("completion") or {}).get("nextAction", "respond_unmet_request"),
+            "message": "End from this receipt. No new or reused card, output_check or source-sync task. Prior card reminders do not apply to this result."}
+        if result["completion"]["nextAction"] == "repair_only_reported_input":
+            result["completion"]["message"] = "Zero writes. Correct only the reported input using its local recovery; no cards, output_check, source sync or global discovery."
+        data["completion"] = result["completion"]
+        return (0 if outcome == "verified_noop" else 3), json.dumps(result, ensure_ascii=False)
+    if receipt.get("status") is not True or outcome != "verified" or (receipt.get("verification") or {}).get("verified") is not True:
+        result["completion"] = {"nextAction": "reconcile_write_state", "message": "No verified completion; do not replay successful fields"}
+        result["configurationVerified"] = (receipt.get("verification") or {}).get("verified") is True
+        result["status"] = False
+        if result.get("errorCode") in (None, "", "0", 0):
+            result["errorCode"] = "LIST_DELIVERY_PENDING" if result["configurationVerified"] else "LIST_CONFIGURATION_UNVERIFIED"
+        data["completion"] = result["completion"]
+        return 3, json.dumps(result, ensure_ascii=False)
+    target_root = data.get("appRoot")
+    number = data.get("formNumber")
+    if not target_root or not number:
+        result["completion"] = {"nextAction": "resolve_delivery_target", "message": "Configuration is verified; do not replay it"}
+        result["configurationVerified"] = (receipt.get("verification") or {}).get("verified") is True
+        result["status"] = False
+        if result.get("errorCode") in (None, "", "0", 0):
+            result["errorCode"] = "LIST_DELIVERY_PENDING" if result["configurationVerified"] else "LIST_CONFIGURATION_UNVERIFIED"
+        data["completion"] = result["completion"]
+        return 3, json.dumps(result, ensure_ascii=False)
+    delivery = [sys.executable, str(SCRIPTS / "render_output_cards.py"), "--app-root", str(target_root), "--forms-only", "--form-number", str(number)]
+    try:
+        rendered = subprocess.run(delivery, capture_output=True, text=True, encoding="utf-8", errors="replace", timeout=120)
+    except (OSError, subprocess.TimeoutExpired) as error:
+        result["completion"] = {"nextAction": "retry_delivery_only", "command": delivery, "message": str(error)}
+        result["configurationVerified"] = (receipt.get("verification") or {}).get("verified") is True
+        result["status"] = False
+        if result.get("errorCode") in (None, "", "0", 0):
+            result["errorCode"] = "LIST_DELIVERY_PENDING" if result["configurationVerified"] else "LIST_CONFIGURATION_UNVERIFIED"
+        data["completion"] = result["completion"]
+        return 3, json.dumps(result, ensure_ascii=False)
+    if rendered.returncode or not rendered.stdout.lstrip().startswith(":::render:"):
+        result["completion"] = {"nextAction": "retry_delivery_only", "command": delivery,
+            "message": "Configuration is verified. Card delivery failed; do not replay the configuration.", "diagnostic": rendered.stderr[-1500:]}
+        result["configurationVerified"] = (receipt.get("verification") or {}).get("verified") is True
+        result["status"] = False
+        if result.get("errorCode") in (None, "", "0", 0):
+            result["errorCode"] = "LIST_DELIVERY_PENDING" if result["configurationVerified"] else "LIST_CONFIGURATION_UNVERIFIED"
+        data["completion"] = result["completion"]
+        return 3, json.dumps(result, ensure_ascii=False)
+    result["completion"] = {"outcome": "verified", "requiresArtifactFinalization": False,
+        "nextAction": "launch_returned_background_request_then_respond" if "DYM_BACKGROUND_REQUEST=" in rendered.stdout else "respond_with_returned_cards",
+        "message": "Preserve exact card blocks. Native render stdout arms the existing host output validation; do not call output_check or rerender. Launch only the returned tracked source-sync request, without waiting."}
+    data["completion"] = result["completion"]
+    return 0, rendered.stdout.rstrip() + "\nRESULT_SUMMARY=" + json.dumps(result, ensure_ascii=False)
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    target = parser.add_mutually_exclusive_group(required=True)
+    target.add_argument("--app-root")
+    target.add_argument("--project-root")
+    parser.add_argument("--form-name", required=True)
+    parser.add_argument("--input", required=True)
+    args = parser.parse_args()
+    code, output = execute(args.app_root, args.project_root, args.form_name, args.input)
+    print(output, flush=True)
+    return code
+
+
+if __name__ == "__main__":
+    for stream in (sys.stdout, sys.stderr):
+        if hasattr(stream, "reconfigure"):
+            stream.reconfigure(encoding="utf-8", errors="replace")
+    raise SystemExit(main())