@josephyan/qingflow-cli 0.2.0-beta.73 → 0.2.0-beta.75

package/src/qingflow_mcp/builder_facade/service.py

@@ -57,6 +57,7 @@ from .models import (
     PortalListResponse,
     PortalReadSummaryResponse,
     PortalSectionPatch,
+    PublicDepartmentScopeMode,
     PublicFieldType,
     PublicRelationMode,
     PublicChartType,
@@ -379,6 +380,61 @@ class AiBuilderFacade:
             "tag_icon": tag_icon,
         }
 
+    def solution_install(
+        self,
+        *,
+        profile: str,
+        solution_key: str,
+        being_copy_data: bool = True,
+        solution_source: str = "solutionDetail",
+    ) -> JSONObject:
+        requested_solution_key = str(solution_key or "").strip()
+        requested_solution_source = str(solution_source or "").strip() or "solutionDetail"
+        normalized_args = {
+            "solution_key": requested_solution_key,
+            "being_copy_data": bool(being_copy_data),
+            "solution_source": requested_solution_source,
+        }
+        if not requested_solution_key:
+            return _failed(
+                "SOLUTION_KEY_REQUIRED",
+                "solution_key is required",
+                normalized_args=normalized_args,
+                suggested_next_call=None,
+            )
+        try:
+            created = self.apps.app_create(
+                profile=profile,
+                payload={
+                    "solutionKey": requested_solution_key,
+                    "beingCopyData": bool(being_copy_data),
+                    "solutionSource": requested_solution_source,
+                },
+            )
+        except (QingflowApiError, RuntimeError) as error:
+            api_error = _coerce_api_error(error)
+            return _failed_from_api_error(
+                "SOLUTION_INSTALL_FAILED",
+                api_error,
+                normalized_args=normalized_args,
+                details={"solution_key": requested_solution_key},
+                suggested_next_call={"tool_name": "solution_install", "arguments": {"profile": profile, **normalized_args}},
+            )
+        return {
+            "status": "success",
+            "error_code": None,
+            "recoverable": False,
+            "message": "installed solution",
+            "normalized_args": normalized_args,
+            "missing_fields": [],
+            "allowed_values": {},
+            "details": {},
+            "request_id": created.get("request_id"),
+            "suggested_next_call": None,
+            "noop": False,
+            "verification": {},
+        }
+
     def package_list(self, *, profile: str, trial_status: str = "all") -> JSONObject:
         listed = self.packages.package_list(profile=profile, trial_status=trial_status, include_raw=False)
         return {
@@ -1544,29 +1600,34 @@ class AiBuilderFacade:
                         transport_error=api_error,
                     ),
                 )
-            return finalize(response)
+            return finalize(self._append_publish_result(profile=profile, app_key=app_key, publish=True, response=response))
         button = _normalize_custom_button_detail(readback.get("result") if isinstance(readback.get("result"), dict) else {})
         return finalize(
-            {
-                "status": "success",
-                "error_code": None,
-                "recoverable": False,
-                "message": "created custom button",
-                "normalized_args": normalized_args,
-                "missing_fields": [],
-                "allowed_values": {},
-                "details": {},
-                "request_id": None,
-                "suggested_next_call": None,
-                "noop": False,
-                "warnings": [],
-                "verification": {"custom_button_verified": True},
-                "verified": True,
-                "app_key": app_key,
-                "button_id": button_id,
-                "edit_version_no": edit_version_no,
-                "button": button,
-            }
+            self._append_publish_result(
+                profile=profile,
+                app_key=app_key,
+                publish=True,
+                response={
+                    "status": "success",
+                    "error_code": None,
+                    "recoverable": False,
+                    "message": "created custom button",
+                    "normalized_args": normalized_args,
+                    "missing_fields": [],
+                    "allowed_values": {},
+                    "details": {},
+                    "request_id": None,
+                    "suggested_next_call": None,
+                    "noop": False,
+                    "warnings": [],
+                    "verification": {"custom_button_verified": True},
+                    "verified": True,
+                    "app_key": app_key,
+                    "button_id": button_id,
+                    "edit_version_no": edit_version_no,
+                    "button": button,
+                },
+            )
         )
 
     def app_custom_button_update(
@@ -1652,29 +1713,34 @@ class AiBuilderFacade:
                         transport_error=api_error,
                     ),
                 )
-            return finalize(response)
+            return finalize(self._append_publish_result(profile=profile, app_key=app_key, publish=True, response=response))
         button = _normalize_custom_button_detail(readback.get("result") if isinstance(readback.get("result"), dict) else {})
         return finalize(
-            {
-                "status": "success",
-                "error_code": None,
-                "recoverable": False,
-                "message": "updated custom button",
-                "normalized_args": normalized_args,
-                "missing_fields": [],
-                "allowed_values": {},
-                "details": {},
-                "request_id": None,
-                "suggested_next_call": None,
-                "noop": False,
-                "warnings": [],
-                "verification": {"custom_button_verified": True},
-                "verified": True,
-                "app_key": app_key,
-                "button_id": button_id,
-                "edit_version_no": edit_version_no,
-                "button": button,
-            }
+            self._append_publish_result(
+                profile=profile,
+                app_key=app_key,
+                publish=True,
+                response={
+                    "status": "success",
+                    "error_code": None,
+                    "recoverable": False,
+                    "message": "updated custom button",
+                    "normalized_args": normalized_args,
+                    "missing_fields": [],
+                    "allowed_values": {},
+                    "details": {},
+                    "request_id": None,
+                    "suggested_next_call": None,
+                    "noop": False,
+                    "warnings": [],
+                    "verification": {"custom_button_verified": True},
+                    "verified": True,
+                    "app_key": app_key,
+                    "button_id": button_id,
+                    "edit_version_no": edit_version_no,
+                    "button": button,
+                },
+            )
         )
 
     def app_custom_button_delete(self, *, profile: str, app_key: str, button_id: int) -> JSONObject:
@@ -1693,27 +1759,42 @@ class AiBuilderFacade:
         def finalize(response: JSONObject) -> JSONObject:
             return _apply_permission_outcomes(response, *permission_outcomes)
 
+        edit_version_no, edit_context_error = self._ensure_app_edit_context(
+            profile=profile,
+            app_key=app_key,
+            normalized_args=normalized_args,
+            failure_code="CUSTOM_BUTTON_DELETE_FAILED",
+        )
+        if edit_context_error is not None:
+            return finalize(edit_context_error)
+
         self.buttons.custom_button_delete(profile=profile, app_key=app_key, button_id=button_id)
         return finalize(
-            {
-                "status": "success",
-                "error_code": None,
-                "recoverable": False,
-                "message": "deleted custom button",
-                "normalized_args": normalized_args,
-                "missing_fields": [],
-                "allowed_values": {},
-                "details": {},
-                "request_id": None,
-                "suggested_next_call": None,
-                "noop": False,
-                "warnings": [],
-                "verification": {"custom_button_deleted": True},
-                "verified": True,
-                "app_key": app_key,
-                "button_id": button_id,
-                "deleted": True,
-            }
+            self._append_publish_result(
+                profile=profile,
+                app_key=app_key,
+                publish=True,
+                response={
+                    "status": "success",
+                    "error_code": None,
+                    "recoverable": False,
+                    "message": "deleted custom button",
+                    "normalized_args": normalized_args,
+                    "missing_fields": [],
+                    "allowed_values": {},
+                    "details": {},
+                    "request_id": None,
+                    "suggested_next_call": None,
+                    "noop": False,
+                    "warnings": [],
+                    "verification": {"custom_button_deleted": True},
+                    "verified": True,
+                    "app_key": app_key,
+                    "button_id": button_id,
+                    "edit_version_no": edit_version_no,
+                    "deleted": True,
+                },
+            )
         )
 
     def _resolve_app_matches_in_visible_apps(
@@ -2088,6 +2169,280 @@ class AiBuilderFacade:
             result["message"] = "read app field config"
         return result
 
+    def app_repair_code_blocks(
+        self,
+        *,
+        profile: str,
+        app_key: str,
+        field: str | None = None,
+        apply: bool = False,
+    ) -> JSONObject:
+        try:
+            state = self._load_base_schema_state(profile=profile, app_key=app_key)
+        except (QingflowApiError, RuntimeError) as error:
+            api_error = _coerce_api_error(error)
+            return _failed_from_api_error(
+                "FIELDS_READ_FAILED",
+                api_error,
+                normalized_args={"app_key": app_key, "field": field, "apply": apply},
+                details={"app_key": app_key},
+                suggested_next_call={"tool_name": "app_get_fields", "arguments": {"profile": profile, "app_key": app_key}},
+            )
+        parsed_fields = cast(list[dict[str, Any]], state["parsed"].get("fields") or [])
+        field_lookup = _build_public_field_lookup(parsed_fields)
+        selected_fields: list[dict[str, Any]]
+        requested_selector = str(field or "").strip()
+        if requested_selector:
+            try:
+                selected_field = _resolve_public_field(requested_selector, field_lookup=field_lookup)
+            except ValueError:
+                return _failed(
+                    "FIELD_NOT_FOUND",
+                    "field selector did not match any existing field",
+                    normalized_args={"app_key": app_key, "field": requested_selector, "apply": apply},
+                    details={"app_key": app_key, "field": requested_selector},
+                    suggested_next_call={"tool_name": "app_get_fields", "arguments": {"profile": profile, "app_key": app_key}},
+                )
+            if str(selected_field.get("type") or "") != FieldType.code_block.value:
+                return _failed(
+                    "CODE_BLOCK_FIELD_REQUIRED",
+                    "selected field is not a code_block field",
+                    normalized_args={"app_key": app_key, "field": requested_selector, "apply": apply},
+                    details={"app_key": app_key, "field": requested_selector, "field_type": selected_field.get("type")},
+                    suggested_next_call={"tool_name": "app_get_fields", "arguments": {"profile": profile, "app_key": app_key}},
+                )
+            selected_fields = [selected_field]
+        else:
+            selected_fields = [field_item for field_item in parsed_fields if str(field_item.get("type") or "") == FieldType.code_block.value]
+        plans: list[dict[str, Any]] = []
+        update_fields: list[FieldUpdatePatch] = []
+        applied_fields: list[str] = []
+        for code_block_field in selected_fields:
+            field_name = _code_block_field_display_name(code_block_field)
+            normalized_binding = _normalize_code_block_binding(code_block_field.get("code_block_binding"))
+            normalized_config = _normalize_code_block_config(code_block_field.get("code_block_config") or code_block_field.get("config") or {}) or None
+            raw_binding = code_block_field.get("code_block_binding") if isinstance(code_block_field.get("code_block_binding"), dict) else None
+            preserved_output_targets = [
+                str((output.get("target_field") or {}).get("name") or "").strip()
+                for output in cast(list[dict[str, Any]], (normalized_binding or {}).get("outputs") or [])
+                if isinstance(output.get("target_field"), dict) and str((output.get("target_field") or {}).get("name") or "").strip()
+            ]
+            detected_issues: list[str] = []
+            warnings: list[dict[str, Any]] = []
+            normalized_code_preview: str | None = None
+            normalized_binding_code = None
+            normalized_config_code = None
+            if normalized_binding is not None:
+                raw_code = str(normalized_binding.get("code") or "")
+                normalized_binding_code = _normalize_code_block_output_assignment(raw_code)
+                if normalized_binding_code != raw_code:
+                    detected_issues.append("CONST_OR_LET_QF_OUTPUT_ASSIGNMENT")
+                    normalized_code_preview = normalized_binding_code
+            if normalized_config is not None:
+                raw_code_content = str(normalized_config.get("code_content") or "")
+                normalized_config_code = _normalize_code_block_output_assignment(raw_code_content)
+                if normalized_code_preview is None and normalized_config_code != raw_code_content:
+                    normalized_code_preview = normalized_config_code
+            try:
+                _validate_code_block_alias_config(
+                    field_name=field_name,
+                    raw_binding=raw_binding,
+                    normalized_config=normalized_config,
+                )
+            except _CodeBlockValidationError as error:
+                detected_issues.append(error.error_code)
+                warnings.append(_warning(error.error_code, error.message))
+            has_outputs = bool((normalized_binding or {}).get("outputs")) or bool((normalized_config or {}).get("result_alias_path"))
+            effective_code = ""
+            if normalized_binding is not None:
+                effective_code = str(normalized_binding_code if normalized_binding_code is not None else normalized_binding.get("code") or "")
+            elif normalized_config is not None:
+                code_content = str(normalized_config_code if normalized_config_code is not None else normalized_config.get("code_content") or "")
+                effective_code = _strip_code_block_generated_input_prelude(code_content)
+            if has_outputs and not _code_block_has_effective_output_assignment(effective_code):
+                detected_issues.append("CODE_BLOCK_OUTPUT_ASSIGNMENT_MISSING")
+                warnings.append(
+                    _warning(
+                        "CODE_BLOCK_OUTPUT_ASSIGNMENT_MISSING",
+                        "configured outputs require qf_output assignment before runtime writeback can succeed",
+                    )
+                )
+            target_relation_default_verified = True
+            binding_has_target_bindings = False
+            for output in cast(list[dict[str, Any]], (normalized_binding or {}).get("outputs") or []):
+                target_payload = output.get("target_field")
+                if not isinstance(target_payload, dict):
+                    continue
+                if any(target_payload.values()):
+                    binding_has_target_bindings = True
+                try:
+                    target_field = _resolve_field_selector_with_uniqueness(
+                        fields=parsed_fields,
+                        selector_payload=target_payload,
+                        location="repair.target_field",
+                    )
+                except ValueError:
+                    target_relation_default_verified = False
+                    detected_issues.append("CODE_BLOCK_TARGET_DEFAULT_INVALID")
+                    warnings.append(_warning("CODE_BLOCK_TARGET_DEFAULT_INVALID", "bound output target could not be resolved during repair scan"))
+                    break
+                if _coerce_any_int(target_field.get("default_type")) == DEFAULT_TYPE_RELATION:
+                    continue
+                target_relation_default_verified = False
+                detected_issues.append("CODE_BLOCK_TARGET_DEFAULT_INVALID")
+                warnings.append(
+                    _warning(
+                        "CODE_BLOCK_TARGET_DEFAULT_INVALID",
+                        "bound output target is not stored as relation default and should be rebuilt through repair",
+                        target_field_name=_code_block_field_display_name(target_field),
+                    )
+                )
+            alias_issue_detected = "CODE_BLOCK_ALIAS_REQUIRED" in detected_issues
+            assignment_missing_detected = "CODE_BLOCK_OUTPUT_ASSIGNMENT_MISSING" in detected_issues
+            can_auto_repair = not alias_issue_detected and not assignment_missing_detected
+            repair_mode = "none"
+            patch_payload: dict[str, Any] | None = None
+            safe_auto_fix = False
+            if can_auto_repair and normalized_binding is not None and binding_has_target_bindings and (
+                (normalized_binding_code is not None and normalized_binding_code != str(normalized_binding.get("code") or ""))
+                or not target_relation_default_verified
+            ):
+                patch_payload = {
+                    "selector": _field_selector_payload_for_field(code_block_field),
+                    "set": {
+                        "code_block_binding": _public_code_block_binding_payload(
+                            {**normalized_binding, "code": normalized_binding_code if normalized_binding_code is not None else str(normalized_binding.get("code") or "")}
+                        )
+                    },
+                }
+                repair_mode = "binding"
+                safe_auto_fix = True
+            elif (
+                can_auto_repair
+                and normalized_config is not None
+                and normalized_config_code is not None
+                and normalized_config_code != str(normalized_config.get("code_content") or "")
+            ):
+                patch_payload = {
+                    "selector": _field_selector_payload_for_field(code_block_field),
+                    "set": {"code_block_config": {**normalized_config, "code_content": normalized_config_code}},
+                }
+                repair_mode = "config"
+                safe_auto_fix = True
+            if not detected_issues:
+                detected_issues.append("NO_REPAIR_NEEDED")
+            plan = {
+                "field_name": field_name,
+                "field_id": str(code_block_field.get("field_id") or "").strip() or None,
+                "que_id": _coerce_positive_int(code_block_field.get("que_id")),
+                "detected_issues": sorted(set(detected_issues)),
+                "normalized_code_preview": normalized_code_preview,
+                "would_update": bool(patch_payload and safe_auto_fix),
+                "applied": False,
+                "repair_mode": repair_mode,
+                "preserved_output_targets": preserved_output_targets,
+                "warnings": warnings,
+            }
+            if patch_payload and safe_auto_fix:
+                update_fields.append(FieldUpdatePatch.model_validate(patch_payload))
+            plans.append(plan)
+        if not apply:
+            return {
+                "status": "success",
+                "error_code": None,
+                "recoverable": False,
+                "message": "planned code block repair",
+                "normalized_args": {"app_key": app_key, "field": requested_selector or None, "apply": False},
+                "missing_fields": [],
+                "allowed_values": {},
+                "details": {},
+                "request_id": None,
+                "suggested_next_call": None,
+                "noop": not bool(update_fields),
+                "warnings": [],
+                "verification": {
+                    "app_exists": True,
+                    "code_block_fields_scanned": len(plans),
+                    "would_update": bool(update_fields),
+                },
+                "verified": True,
+                "app_key": app_key,
+                "apply": False,
+                "repair_plan": plans,
+                "would_update_fields": [plan["field_name"] for plan in plans if plan["would_update"]],
+            }
+        if not update_fields:
+            return {
+                "status": "success",
+                "error_code": None,
+                "recoverable": False,
+                "message": "no safe code block repairs were required",
+                "normalized_args": {"app_key": app_key, "field": requested_selector or None, "apply": True},
+                "missing_fields": [],
+                "allowed_values": {},
+                "details": {},
+                "request_id": None,
+                "suggested_next_call": None,
+                "noop": True,
+                "warnings": [],
+                "verification": {
+                    "app_exists": True,
+                    "code_block_fields_scanned": len(plans),
+                    "would_update": False,
+                    "applied": False,
+                },
+                "verified": True,
+                "app_key": app_key,
+                "apply": True,
+                "repair_plan": plans,
+                "applied_fields": [],
+            }
+        apply_result = self.app_schema_apply(
+            profile=profile,
+            app_key=app_key,
+            package_tag_id=None,
+            app_name="",
+            publish=True,
+            add_fields=[],
+            update_fields=update_fields,
+            remove_fields=[],
+        )
+        if apply_result.get("status") == "failed":
+            return apply_result
+        try:
+            reread = self._load_base_schema_state(profile=profile, app_key=app_key)
+            verified_fields = cast(list[dict[str, Any]], reread["parsed"].get("fields") or [])
+            verified_lookup = _build_public_field_lookup(verified_fields)
+            for plan in plans:
+                selector = plan["field_id"] or plan["field_name"] or plan["que_id"]
+                if selector is None:
+                    continue
+                try:
+                    verified_field = _resolve_public_field(selector, field_lookup=verified_lookup)
+                except ValueError:
+                    continue
+                verified_binding = _normalize_code_block_binding(verified_field.get("code_block_binding"))
+                verified_config = _normalize_code_block_config(verified_field.get("code_block_config") or verified_field.get("config") or {}) or {}
+                verified_code = str((verified_binding or {}).get("code") or "")
+                verified_content = str(verified_config.get("code_content") or "")
+                if "const qf_output =" not in verified_code and "let qf_output =" not in verified_code and "const qf_output =" not in verified_content and "let qf_output =" not in verified_content:
+                    if plan["would_update"]:
+                        plan["applied"] = True
+                        applied_fields.append(plan["field_name"])
+        except (QingflowApiError, RuntimeError):
+            pass
+        apply_result["message"] = "repaired code block fields"
+        apply_result["apply"] = True
+        apply_result["repair_plan"] = plans
+        apply_result["applied_fields"] = applied_fields
+        apply_result["verification"] = {
+            **(apply_result.get("verification") if isinstance(apply_result.get("verification"), dict) else {}),
+            "code_block_fields_scanned": len(plans),
+            "would_update": bool(update_fields),
+            "applied": bool(applied_fields),
+        }
+        return apply_result
+
     def app_get_layout(self, *, profile: str, app_key: str) -> JSONObject:
         result = self.app_read_layout_summary(profile=profile, app_key=app_key)
         if result.get("status") == "success":
@@ -3264,6 +3619,7 @@ class AiBuilderFacade:
             existing_field = next((field for field in current_fields if str(field.get("name") or "") == patch.name), None)
             if existing_field is not None:
                 if _field_matches_patch(existing_field, patch):
+                    _merge_existing_field_with_patch(existing_field, patch)
                     continue
                 return _failed(
                     "DUPLICATE_FIELD",
@@ -3338,18 +3694,33 @@ class AiBuilderFacade:
                 suggested_next_call={"tool_name": "app_get_fields", "arguments": {"profile": profile, "app_key": target.app_key}},
             )
 
+        normalized_code_block_fields: list[str] = []
         try:
+            current_fields, normalized_code_block_fields = _normalize_and_validate_code_block_fields_for_write(fields=current_fields)
             current_fields, compiled_question_relations = _compile_code_block_binding_fields(
                 fields=current_fields,
                 current_schema=schema_result,
             )
+            _ensure_code_block_targets_compiled_as_relation_defaults(fields=current_fields)
+        except _CodeBlockValidationError as error:
+            return _failed(
+                error.error_code,
+                error.message,
+                normalized_args=normalized_args,
+                details={"app_key": target.app_key, **error.details},
+                suggested_next_call=_code_block_repair_suggested_next_call(
+                    profile=profile,
+                    app_key=target.app_key,
+                    field_name=str(error.details.get("field_name") or "").strip() or None,
+                ),
+            )
         except ValueError as error:
             return _failed(
                 "CODE_BLOCK_BINDING_INVALID",
                 str(error),
                 normalized_args=normalized_args,
                 details={"app_key": target.app_key},
-                suggested_next_call={"tool_name": "app_get_fields", "arguments": {"profile": profile, "app_key": target.app_key}},
+                suggested_next_call=_code_block_repair_suggested_next_call(profile=profile, app_key=target.app_key),
             )
 
         q_linker_schema_context = deepcopy(schema_result)
@@ -3375,8 +3746,19 @@ class AiBuilderFacade:
             if not relation_limit_verified
             else []
         )
+        code_block_normalization_warnings = (
+            [
+                _warning(
+                    "CODE_BLOCK_OUTPUT_ASSIGNMENT_NORMALIZED",
+                    "normalized code block qf_output assignment before schema write",
+                    field_names=normalized_code_block_fields,
+                )
+            ]
+            if normalized_code_block_fields
+            else []
+        )
 
-        if not added and not updated and not removed and not bool(resolved.get("created")):
+        if not added and not updated and not removed and not normalized_code_block_fields and not bool(resolved.get("created")):
             tag_ids_after = _coerce_int_list((self.apps.app_get_base(profile=profile, app_key=target.app_key, include_raw=True).get("result") or {}).get("tagIds"))
             package_attached = None if package_tag_id is None else package_tag_id in tag_ids_after
             response = {
@@ -3391,7 +3773,7 @@ class AiBuilderFacade:
                 "request_id": None,
                 "suggested_next_call": None if package_attached is not False else {"tool_name": "package_attach_app", "arguments": {"profile": profile, "tag_id": package_tag_id, "app_key": target.app_key}},
                 "noop": not bool(visual_result.get("updated")),
-                "warnings": relation_warnings,
+                "warnings": relation_warnings + code_block_normalization_warnings,
                 "verification": {
                     "fields_verified": True,
                     "relation_field_limit_verified": relation_limit_verified,
@@ -3407,6 +3789,9 @@ class AiBuilderFacade:
                 "package_attached": package_attached,
             }
             response["details"]["relation_field_count"] = relation_field_count
+            if normalized_code_block_fields:
+                response["normalized_code_block_output_assignment"] = True
+                response["normalized_code_block_fields"] = normalized_code_block_fields
             response = _apply_permission_outcomes(response, relation_permission_outcome)
             return finalize(self._append_publish_result(profile=profile, app_key=target.app_key, publish=publish, response=response))
 
@@ -3473,16 +3858,30 @@ class AiBuilderFacade:
                 rebound_layout = cast(dict[str, Any], rebound_parsed.get("layout") or {"root_rows": [], "sections": []})
                 _overlay_code_block_binding_fields(target_fields=rebound_fields, source_fields=current_fields)
                 _overlay_q_linker_binding_fields(target_fields=rebound_fields, source_fields=current_fields)
+                rebound_fields, _normalized_rebound_code_blocks = _normalize_and_validate_code_block_fields_for_write(fields=rebound_fields)
                 rebound_fields, compiled_question_relations = _compile_code_block_binding_fields(
                     fields=rebound_fields,
                     current_schema=rebound_schema,
                 )
+                _ensure_code_block_targets_compiled_as_relation_defaults(fields=rebound_fields)
                 rebound_q_linker_schema = deepcopy(rebound_schema)
                 rebound_q_linker_schema["questionRelations"] = deepcopy(compiled_question_relations)
                 rebound_fields, compiled_question_relations = _compile_q_linker_binding_fields(
                     fields=rebound_fields,
                     current_schema=rebound_q_linker_schema,
                 )
+            except _CodeBlockValidationError as error:
+                return _failed(
+                    error.error_code,
+                    error.message,
+                    normalized_args=normalized_args,
+                    details={"app_key": target.app_key, **error.details},
+                    suggested_next_call=_code_block_repair_suggested_next_call(
+                        profile=profile,
+                        app_key=target.app_key,
+                        field_name=str(error.details.get("field_name") or "").strip() or None,
+                    ),
+                )
             except ValueError as error:
                 return _failed(
                     "Q_LINKER_BINDING_INVALID" if "q_linker" in str(error) else "CODE_BLOCK_BINDING_INVALID",
@@ -3544,7 +3943,7 @@ class AiBuilderFacade:
             "request_id": None,
             "suggested_next_call": None,
             "noop": False,
-            "warnings": relation_warnings,
+            "warnings": relation_warnings + code_block_normalization_warnings,
             "verification": {
                 "fields_verified": False,
                 "package_attached": None,
@@ -3565,6 +3964,9 @@ class AiBuilderFacade:
             "package_attached": None,
         }
         response["details"]["relation_field_count"] = relation_field_count
+        if normalized_code_block_fields:
+            response["normalized_code_block_output_assignment"] = True
+            response["normalized_code_block_fields"] = normalized_code_block_fields
         if schema_readback_delayed:
             response["verification"]["schema_readback_delayed"] = True
         response = _apply_permission_outcomes(response, relation_permission_outcome)
@@ -7770,6 +8172,133 @@ def _normalize_relation_mode(value: Any) -> str:
     return _relation_mode_from_optional_data_num(value)
 
 
+def _normalize_department_scope_mode(value: Any) -> str | None:
+    if value is None:
+        return None
+    if isinstance(value, int):
+        if value == 1:
+            return PublicDepartmentScopeMode.all.value
+        if value == 2:
+            return PublicDepartmentScopeMode.custom.value
+        return None
+    normalized = str(value).strip().lower()
+    if normalized in {"all", "workspace_all", "workspace-all", "default", "default_all", "default-all", "1"}:
+        return PublicDepartmentScopeMode.all.value
+    if normalized in {"custom", "explicit", "selected", "2"}:
+        return PublicDepartmentScopeMode.custom.value
+    return normalized or None
+
+
+def _normalize_department_scope(value: Any) -> dict[str, Any] | None:
+    if not isinstance(value, dict):
+        return None
+    raw_departments = value.get("departments", value.get("depart", value.get("departs")))
+    departments: list[dict[str, Any]] = []
+    if isinstance(raw_departments, list):
+        for item in raw_departments:
+            if isinstance(item, dict):
+                dept_id = _coerce_positive_int(item.get("dept_id", item.get("deptId", item.get("id"))))
+                dept_name = str(
+                    item.get("dept_name", item.get("deptName", item.get("name", item.get("value")))) or ""
+                ).strip() or None
+            else:
+                dept_id = _coerce_positive_int(item)
+                dept_name = None
+            if dept_id is None and dept_name is None:
+                continue
+            entry: dict[str, Any] = {}
+            if dept_id is not None:
+                entry["dept_id"] = dept_id
+            if dept_name is not None:
+                entry["dept_name"] = dept_name
+            departments.append(entry)
+    normalized_mode = _normalize_department_scope_mode(value.get("mode"))
+    if normalized_mode is None:
+        normalized_mode = PublicDepartmentScopeMode.custom.value if departments else PublicDepartmentScopeMode.all.value
+    return {
+        "mode": normalized_mode,
+        "departments": departments,
+        "include_sub_departs": (
+            None
+            if value.get("include_sub_departs", value.get("includeSubDeparts")) is None
+            else bool(value.get("include_sub_departs", value.get("includeSubDeparts")))
+        ),
+    }
+
+
+def _normalize_department_scope_from_question(question: dict[str, Any]) -> dict[str, Any] | None:
+    scope_type = _coerce_positive_int(question.get("deptSelectScopeType"))
+    scope = question.get("deptSelectScope") if isinstance(question.get("deptSelectScope"), dict) else {}
+    if not isinstance(scope, dict):
+        scope = {}
+    if isinstance(scope.get("dynamic"), list) and scope.get("dynamic"):
+        return None
+    if isinstance(scope.get("externalDepartList"), list) and scope.get("externalDepartList"):
+        return None
+    if scope_type == 1:
+        return {
+            "mode": PublicDepartmentScopeMode.all.value,
+            "departments": [],
+            "include_sub_departs": None
+            if scope.get("includeSubDeparts") is None
+            else bool(scope.get("includeSubDeparts")),
+        }
+    if scope_type == 2:
+        departments: list[dict[str, Any]] = []
+        for item in cast(list[Any], scope.get("depart") or []):
+            if not isinstance(item, dict):
+                continue
+            dept_id = _coerce_positive_int(item.get("deptId", item.get("id")))
+            dept_name = str(item.get("deptName", item.get("name", item.get("value"))) or "").strip() or None
+            if dept_id is None and dept_name is None:
+                continue
+            entry: dict[str, Any] = {}
+            if dept_id is not None:
+                entry["dept_id"] = dept_id
+            if dept_name is not None:
+                entry["dept_name"] = dept_name
+            departments.append(entry)
+        return {
+            "mode": PublicDepartmentScopeMode.custom.value,
+            "departments": departments,
+            "include_sub_departs": None
+            if scope.get("includeSubDeparts") is None
+            else bool(scope.get("includeSubDeparts")),
+        }
+    return None
+
+
+def _serialize_department_scope_for_question(value: Any) -> tuple[int, dict[str, Any]]:
+    normalized = _normalize_department_scope(value)
+    if normalized is None or normalized.get("mode") == PublicDepartmentScopeMode.all.value:
+        scope: dict[str, Any] = {"depart": [], "dynamic": []}
+        if normalized is not None and normalized.get("include_sub_departs") is not None:
+            scope["includeSubDeparts"] = bool(normalized.get("include_sub_departs"))
+        return 1, scope
+    departments = []
+    for item in cast(list[Any], normalized.get("departments") or []):
+        if not isinstance(item, dict):
+            continue
+        dept_id = _coerce_positive_int(item.get("dept_id"))
+        dept_name = str(item.get("dept_name") or "").strip() or None
+        if dept_id is None and dept_name is None:
+            continue
+        entry: dict[str, Any] = {}
+        if dept_id is not None:
+            entry["deptId"] = dept_id
+        if dept_name is not None:
+            entry["deptName"] = dept_name
+        departments.append(entry)
+    scope = {"depart": departments, "dynamic": []}
+    if normalized.get("include_sub_departs") is not None:
+        scope["includeSubDeparts"] = bool(normalized.get("include_sub_departs"))
+    return 2, scope
+
+
+def _department_scope_equal(left: Any, right: Any) -> bool:
+    return _normalize_department_scope(left) == _normalize_department_scope(right)
+
+
 def _is_relation_target_metadata_read_restricted_api_error(error: QingflowApiError) -> bool:
     return error.backend_code in {40002, 40027, 40161}
 
@@ -7936,8 +8465,10 @@ def _hydrate_relation_field_configs(
         field["config"] = config
         display_selector = field.get("display_field") if isinstance(field.get("display_field"), dict) else None
         visible_selector_payloads = [item for item in cast(list[Any], field.get("visible_fields") or []) if isinstance(item, dict)]
-        if display_selector is None and not visible_selector_payloads:
-            continue
+        if display_selector is None:
+            raise ValueError("relation field requires display_field")
+        if not visible_selector_payloads:
+            raise ValueError("relation field requires visible_fields")
         target_fields = target_field_cache.get(target_app_key)
         if target_fields is None:
             try:
@@ -7974,7 +8505,31 @@ def _hydrate_relation_field_configs(
                 )
                 continue
         if not target_fields:
-            raise ValueError(f"target relation app '{target_app_key}' has no readable fields")
+            display_field = _normalize_relation_target_stub(
+                display_selector,
+                fallback_name=str((display_selector or {}).get("name") or "").strip() or None,
+            )
+            visible_fields = [
+                _normalize_relation_target_stub(item, fallback_name=str(item.get("name") or "").strip() or None)
+                for item in visible_selector_payloads
+            ]
+            _apply_relation_target_selection(
+                field=field,
+                config=config,
+                display_field=display_field,
+                visible_fields=visible_fields,
+            )
+            degraded_entries.append(
+                {
+                    "field_name": field.get("name"),
+                    "target_app_key": target_app_key,
+                    "display_field": deepcopy(field.get("display_field") or {}),
+                    "visible_fields": deepcopy(field.get("visible_fields") or []),
+                    "relation_mode": field.get("relation_mode"),
+                    "transport_error": None,
+                }
+            )
+            continue
         display_field = _resolve_relation_target_field(
             target_fields=target_fields,
             selector_payload=display_selector,
@@ -8079,6 +8634,10 @@ def _parse_field(question: dict[str, Any], *, field_id_hint: str | None = None)
         }
         field["visible_fields"] = visible_fields
         field["field_name_show"] = bool(reference.get("fieldNameShow", True))
+    if field_type == FieldType.department:
+        department_scope = _normalize_department_scope_from_question(question)
+        if department_scope is not None:
+            field["department_scope"] = department_scope
     if field_type == FieldType.code_block:
         code_block_config = question.get("codeBlockConfig") if isinstance(question.get("codeBlockConfig"), dict) else {}
         field["code_block_config"] = {
@@ -8700,6 +9259,8 @@ def _compact_public_field_read(*, field: dict[str, Any], layout: dict[str, Any])
         payload["relation_mode"] = _normalize_relation_mode(field.get("relation_mode"))
         payload["display_field"] = deepcopy(field.get("display_field"))
         payload["visible_fields"] = deepcopy(field.get("visible_fields") or [])
+    if field.get("type") == FieldType.department.value and field.get("department_scope") is not None:
+        payload["department_scope"] = deepcopy(field.get("department_scope"))
     if field.get("type") == FieldType.code_block.value:
         payload["code_block_config"] = deepcopy(field.get("code_block_config") or {})
         if field.get("auto_trigger") is not None:
@@ -8780,11 +9341,13 @@ def _field_patch_to_internal(patch: FieldPatch) -> dict[str, Any]:
         "display_field": patch.display_field.model_dump(mode="json", exclude_none=True) if patch.display_field is not None else None,
         "visible_fields": [selector.model_dump(mode="json", exclude_none=True) for selector in patch.visible_fields],
         "relation_mode": patch.relation_mode.value if patch.relation_mode is not None else None,
+        "department_scope": patch.department_scope.model_dump(mode="json", exclude_none=True) if patch.department_scope is not None else None,
         "remote_lookup_config": remote_lookup_config,
         "_explicit_remote_lookup_config": remote_lookup_config is not None,
         "q_linker_binding": q_linker_binding,
         "code_block_config": code_block_config,
         "code_block_binding": code_block_binding,
+        "_explicit_code_block_binding": code_block_binding is not None,
         "config": deepcopy(remote_lookup_config) if remote_lookup_config is not None else (deepcopy(code_block_config) if code_block_config is not None else {}),
         "auto_trigger": patch.auto_trigger,
         "custom_button_text_enabled": patch.custom_button_text_enabled,
@@ -8797,6 +9360,23 @@ def _field_patch_to_internal(patch: FieldPatch) -> dict[str, Any]:
 
 
 def _field_matches_patch(field: dict[str, Any], patch: FieldPatch) -> bool:
+    field_display_selector = field.get("display_field")
+    patch_display_selector = patch.display_field.model_dump(mode="json", exclude_none=True) if patch.display_field is not None else None
+    field_visible_selectors = field.get("visible_fields")
+    patch_visible_selectors = [selector.model_dump(mode="json", exclude_none=True) for selector in patch.visible_fields]
+    if (
+        str(field.get("type") or "") == FieldType.relation.value
+        and patch.type == PublicFieldType.relation
+        and (field.get("target_app_key") or None) == patch.target_app_key
+        and field_display_selector is None
+        and not list(field_visible_selectors or [])
+    ):
+        relation_selector_match = True
+    else:
+        relation_selector_match = (
+            _field_selector_payload_equal(field_display_selector, patch_display_selector)
+            and _field_selector_list_equal(field_visible_selectors, patch_visible_selectors)
+        )
     return (
         str(field.get("name") or "") == patch.name
         and str(field.get("type") or "") == patch.type.value
@@ -8804,9 +9384,12 @@ def _field_matches_patch(field: dict[str, Any], patch: FieldPatch) -> bool:
         and (field.get("description") or None) == patch.description
         and list(field.get("options") or []) == list(patch.options)
         and (field.get("target_app_key") or None) == patch.target_app_key
-        and _field_selector_payload_equal(field.get("display_field"), patch.display_field.model_dump(mode="json", exclude_none=True) if patch.display_field is not None else None)
-        and _field_selector_list_equal(field.get("visible_fields"), [selector.model_dump(mode="json", exclude_none=True) for selector in patch.visible_fields])
+        and relation_selector_match
         and _normalize_relation_mode(field.get("relation_mode")) == _normalize_relation_mode(patch.relation_mode.value if patch.relation_mode is not None else None)
+        and (
+            patch.department_scope is None
+            or _department_scope_equal(field.get("department_scope"), patch.department_scope.model_dump(mode="json", exclude_none=True))
+        )
         and _remote_lookup_config_equal(field.get("remote_lookup_config"), patch.remote_lookup_config.model_dump(mode="json", exclude_none=True) if patch.remote_lookup_config is not None else None)
         and _q_linker_binding_equal(field.get("q_linker_binding"), patch.q_linker_binding.model_dump(mode="json", exclude_none=True) if patch.q_linker_binding is not None else None)
         and _code_block_config_equal(field.get("code_block_config"), patch.code_block_config.model_dump(mode="json", exclude_none=True) if patch.code_block_config is not None else None)
@@ -8818,6 +9401,24 @@ def _field_matches_patch(field: dict[str, Any], patch: FieldPatch) -> bool:
     )
 
 
+def _merge_existing_field_with_patch(field: dict[str, Any], patch: FieldPatch) -> None:
+    if str(field.get("type") or "") == FieldType.relation.value and patch.type == PublicFieldType.relation:
+        if not str(field.get("target_app_key") or "").strip() and patch.target_app_key:
+            field["target_app_key"] = patch.target_app_key
+        if not isinstance(field.get("display_field"), dict) and patch.display_field is not None:
+            field["display_field"] = patch.display_field.model_dump(mode="json", exclude_none=True)
+        if not list(field.get("visible_fields") or []) and patch.visible_fields:
+            field["visible_fields"] = [
+                selector.model_dump(mode="json", exclude_none=True)
+                for selector in patch.visible_fields
+            ]
+        if field.get("relation_mode") is None and patch.relation_mode is not None:
+            field["relation_mode"] = patch.relation_mode.value
+    if str(field.get("type") or "") == FieldType.department.value and patch.type == PublicFieldType.department:
+        if field.get("department_scope") is None and patch.department_scope is not None:
+            field["department_scope"] = patch.department_scope.model_dump(mode="json", exclude_none=True)
+
+
 def _field_selector_payload_equal(left: Any, right: Any) -> bool:
     if left is None and right is None:
         return True
@@ -8998,6 +9599,8 @@ def _apply_field_mutation(field: dict[str, Any], mutation: Any) -> None:
         field["visible_fields"] = list(payload["visible_fields"])
     if "relation_mode" in payload:
         field["relation_mode"] = payload["relation_mode"]
+    if "department_scope" in payload:
+        field["department_scope"] = payload["department_scope"]
     if "remote_lookup_config" in payload:
         field["remote_lookup_config"] = payload["remote_lookup_config"]
         field["config"] = deepcopy(payload["remote_lookup_config"])
@@ -9011,6 +9614,7 @@ def _apply_field_mutation(field: dict[str, Any], mutation: Any) -> None:
         field["config"] = deepcopy(payload["code_block_config"])
     if "code_block_binding" in payload:
         field["code_block_binding"] = payload["code_block_binding"]
+        field["_explicit_code_block_binding"] = True
     if "auto_trigger" in payload:
         field["auto_trigger"] = payload["auto_trigger"]
     if "custom_button_text_enabled" in payload:
@@ -9087,7 +9691,225 @@ def _strip_code_block_generated_input_prelude(code_content: str) -> str:
 
 
 def _normalize_code_block_output_assignment(code_content: str) -> str:
-    return re.sub(r"(?m)^(\s*)(?:const|let)\s+qf_output\s*=", r"\1qf_output =", code_content)
+    return re.sub(r"(?<![A-Za-z0-9_$])(?:const|let)\s+qf_output\s*=", "qf_output =", code_content)
+
+
+@dataclass
+class _CodeBlockValidationError(ValueError):
+    error_code: str
+    message: str
+    details: JSONObject = field(default_factory=dict)
+
+    def __str__(self) -> str:
+        return self.message
+
+
+def _code_block_has_effective_output_assignment(code_content: str) -> bool:
+    return bool(re.search(r"(?<![A-Za-z0-9_$])qf_output\s*=", str(code_content or "")))
+
+
+def _field_selector_payload_for_field(field: dict[str, Any]) -> dict[str, Any]:
+    payload: dict[str, Any] = {}
+    field_id = str(field.get("field_id") or "").strip()
+    que_id = _coerce_positive_int(field.get("que_id"))
+    name = str(field.get("name") or "").strip()
+    if field_id:
+        payload["field_id"] = field_id
+    elif que_id is not None:
+        payload["que_id"] = que_id
+    elif name:
+        payload["name"] = name
+    return payload
+
+
+def _field_selector_payload_for_selector(value: Any) -> dict[str, Any]:
+    if isinstance(value, dict):
+        payload = {
+            "field_id": str(value.get("field_id") or "").strip() or None,
+            "que_id": _coerce_positive_int(value.get("que_id")),
+            "name": str(value.get("name") or "").strip() or None,
+        }
+        return {key: item for key, item in payload.items() if item is not None}
+    if isinstance(value, str) and value.strip():
+        return {"name": value.strip()}
+    return {}
+
+
+def _code_block_field_display_name(field: dict[str, Any]) -> str:
+    name = str(field.get("name") or "").strip()
+    if name:
+        return name
+    field_id = str(field.get("field_id") or "").strip()
+    if field_id:
+        return field_id
+    que_id = _coerce_positive_int(field.get("que_id"))
+    if que_id is not None:
+        return str(que_id)
+    return "未命名代码块"
+
+
+def _public_code_block_binding_payload(binding: dict[str, Any]) -> dict[str, Any]:
+    return {
+        "inputs": [
+            {
+                "field": _field_selector_payload_for_selector(input_item.get("field")),
+                "var": input_item.get("var"),
+            }
+            for input_item in cast(list[dict[str, Any]], binding.get("inputs") or [])
+            if _field_selector_payload_for_selector(input_item.get("field"))
+        ],
+        "code": str(binding.get("code") or ""),
+        "auto_trigger": binding.get("auto_trigger"),
+        "custom_button_text_enabled": binding.get("custom_button_text_enabled"),
+        "custom_button_text": binding.get("custom_button_text"),
+        "outputs": [
+            {
+                "alias": str(output.get("alias") or "").strip(),
+                "path": str(output.get("path") or "").strip(),
+                "target_field": _field_selector_payload_for_selector(output.get("target_field")),
+            }
+            for output in cast(list[dict[str, Any]], binding.get("outputs") or [])
+            if str(output.get("alias") or "").strip()
+            and str(output.get("path") or "").strip()
+            and _field_selector_payload_for_selector(output.get("target_field"))
+        ],
+    }
+
+
+def _raw_field_selector_present(value: Any) -> bool:
+    if isinstance(value, str):
+        return bool(value.strip())
+    if not isinstance(value, dict):
+        return False
+    return bool(
+        str(value.get("field_id") or "").strip()
+        or _coerce_positive_int(value.get("que_id"))
+        or str(value.get("name") or value.get("title") or value.get("label") or "").strip()
+    )
+
+
+def _validate_code_block_alias_config(
+    *,
+    field_name: str,
+    raw_binding: dict[str, Any] | None,
+    normalized_config: dict[str, Any] | None,
+) -> None:
+    raw_outputs = raw_binding.get("outputs") if isinstance(raw_binding, dict) and isinstance(raw_binding.get("outputs"), list) else []
+    for index, raw_output in enumerate(cast(list[Any], raw_outputs)):
+        if not isinstance(raw_output, dict):
+            continue
+        raw_target = raw_output.get("target_field", raw_output.get("targetField"))
+        if not _raw_field_selector_present(raw_target):
+            continue
+        alias = str(raw_output.get("alias", raw_output.get("alias_name", raw_output.get("aliasName", ""))) or "").strip()
+        path = str(raw_output.get("path", raw_output.get("alias_path", raw_output.get("aliasPath", ""))) or "").strip()
+        if alias and path:
+            continue
+        raise _CodeBlockValidationError(
+            "CODE_BLOCK_ALIAS_REQUIRED",
+            f"code_block field '{field_name}' requires non-empty alias and path for output target binding",
+            details={"field_name": field_name, "output_index": index},
+        )
+    normalized_aliases = cast(list[dict[str, Any]], (normalized_config or {}).get("result_alias_path") or [])
+    for index, alias_item in enumerate(normalized_aliases):
+        alias_name = str(alias_item.get("alias_name") or "").strip()
+        alias_path = str(alias_item.get("alias_path") or "").strip()
+        if alias_name and alias_path:
+            continue
+        raise _CodeBlockValidationError(
+            "CODE_BLOCK_ALIAS_REQUIRED",
+            f"code_block field '{field_name}' contains an empty output alias configuration",
+            details={"field_name": field_name, "alias_index": index},
+        )
+
+
+def _normalize_and_validate_code_block_fields_for_write(
+    *,
+    fields: list[dict[str, Any]],
+) -> tuple[list[dict[str, Any]], list[str]]:
+    next_fields = deepcopy(fields)
+    normalized_fields: list[str] = []
+    for field in next_fields:
+        if not isinstance(field, dict) or field.get("type") != FieldType.code_block.value:
+            continue
+        field_name = _code_block_field_display_name(field)
+        raw_binding = field.get("code_block_binding") if isinstance(field.get("code_block_binding"), dict) else None
+        binding = _normalize_code_block_binding(raw_binding)
+        current_config = _normalize_code_block_config(field.get("code_block_config") or field.get("config") or {}) or None
+        _validate_code_block_alias_config(field_name=field_name, raw_binding=raw_binding, normalized_config=current_config)
+        normalized = False
+        if binding is not None:
+            raw_code = str(binding.get("code") or "")
+            normalized_code = _normalize_code_block_output_assignment(raw_code)
+            if normalized_code != raw_code:
+                normalized = True
+            binding["code"] = normalized_code
+            field["code_block_binding"] = binding
+        if current_config is not None:
+            raw_code_content = str(current_config.get("code_content") or "")
+            normalized_code_content = _normalize_code_block_output_assignment(raw_code_content)
+            if normalized_code_content != raw_code_content:
+                normalized = True
+            current_config["code_content"] = normalized_code_content
+            field["code_block_config"] = current_config
+            field["config"] = deepcopy(current_config)
+        conflicting_binding_and_config = False
+        if binding is not None and current_config is not None:
+            current_config_code = str(current_config.get("code_content") or "")
+            compiled_body = _strip_code_block_generated_input_prelude(current_config_code)
+            if current_config_code.strip() and compiled_body != str(binding.get("code") or ""):
+                conflicting_binding_and_config = True
+        has_outputs = bool((binding or {}).get("outputs")) or bool((current_config or {}).get("result_alias_path"))
+        effective_code = ""
+        if binding is not None:
+            effective_code = str(binding.get("code") or "")
+        elif current_config is not None:
+            effective_code = _strip_code_block_generated_input_prelude(str(current_config.get("code_content") or ""))
+        if has_outputs and not conflicting_binding_and_config and not _code_block_has_effective_output_assignment(effective_code):
+            raise _CodeBlockValidationError(
+                "CODE_BLOCK_OUTPUT_ASSIGNMENT_MISSING",
+                f"code_block field '{field_name}' must assign to qf_output when outputs are configured",
+                details={"field_name": field_name},
+            )
+        if normalized:
+            normalized_fields.append(field_name)
+    return next_fields, sorted(set(normalized_fields))
+
+
+def _ensure_code_block_targets_compiled_as_relation_defaults(*, fields: list[dict[str, Any]]) -> None:
+    for field in fields:
+        if not isinstance(field, dict) or field.get("type") != FieldType.code_block.value:
+            continue
+        field_name = _code_block_field_display_name(field)
+        binding = _normalize_code_block_binding(field.get("code_block_binding"))
+        if binding is None:
+            continue
+        for output_index, output in enumerate(cast(list[dict[str, Any]], binding.get("outputs") or [])):
+            target_payload = output.get("target_field")
+            if not isinstance(target_payload, dict):
+                continue
+            target_field = _resolve_field_selector_with_uniqueness(
+                fields=fields,
+                selector_payload=target_payload,
+                location=f"code_block_binding.outputs[{output_index}].target_field",
+            )
+            if _coerce_any_int(target_field.get("default_type")) == DEFAULT_TYPE_RELATION:
+                continue
+            raise _CodeBlockValidationError(
+                "CODE_BLOCK_TARGET_DEFAULT_INVALID",
+                f"code_block field '{field_name}' output target '{_code_block_field_display_name(target_field)}' is not compiled as relation default",
+                details={
+                    "field_name": field_name,
+                    "target_field_name": _code_block_field_display_name(target_field),
+                },
+            )
+
+
+def _code_block_repair_suggested_next_call(*, profile: str, app_key: str, field_name: str | None = None) -> JSONObject:
+    arguments: JSONObject = {"profile": profile, "app_key": app_key}
+    if field_name:
+        arguments["field"] = field_name
+    return {"tool_name": "app_repair_code_blocks", "arguments": arguments}
 
 
 def _ensure_field_temp_ids(fields: list[dict[str, Any]]) -> None:
@@ -9122,12 +9944,21 @@ def _compile_code_block_binding_fields(
         binding = _normalize_code_block_binding(field.get("code_block_binding"))
         if binding is None:
             continue
+        explicit_binding = bool(field.get("_explicit_code_block_binding"))
+        binding_outputs = cast(list[dict[str, Any]], binding.get("outputs") or [])
+        binding_has_target_bindings = any(
+            isinstance(output.get("target_field"), dict) and any(cast(dict[str, Any], output.get("target_field") or {}).values())
+            for output in binding_outputs
+        )
         current_config = _normalize_code_block_config(field.get("code_block_config") or field.get("config") or {}) or {
             "config_mode": 1,
             "code_content": "",
             "being_hide_on_form": False,
             "result_alias_path": [],
         }
+        if binding_outputs and not binding_has_target_bindings and not explicit_binding:
+            field["code_block_binding"] = None
+            continue
         low_level_code = _strip_code_block_generated_input_prelude(str(current_config.get("code_content") or ""))
         if str(current_config.get("code_content") or "").strip() and low_level_code != str(binding.get("code") or ""):
             raise ValueError(f"code_block field '{field.get('name')}' has conflicting code_block_config.code_content and code_block_binding.code")
@@ -10280,6 +11111,10 @@ def _field_to_question(field: dict[str, Any], *, temp_id: int) -> dict[str, Any]
             reference["referQueId"] = field.get("target_field_que_id")
         reference["optionalDataNum"] = _relation_mode_to_optional_data_num(field.get("relation_mode"))
         question["referenceConfig"] = reference
+    if field.get("type") == FieldType.department.value:
+        scope_type, scope_payload = _serialize_department_scope_for_question(field.get("department_scope"))
+        question["deptSelectScopeType"] = scope_type
+        question["deptSelectScope"] = scope_payload
     if field.get("type") == FieldType.code_block.value:
         code_block_config = _normalize_code_block_config(field.get("code_block_config") or field.get("config") or {}) or {
             "config_mode": 1,