@qingflow-tech/qingflow-app-user-mcp 1.0.5 → 1.0.7

package/src/qingflow_mcp/builder_facade/service.py

@@ -43,10 +43,18 @@ from .models import (
     AppLayoutReadResponse,
     AppReadSummaryResponse,
     AppViewsReadResponse,
+    AssociatedResourcesApplyRequest,
+    AssociatedResourceUpsertPatch,
+    AssociatedResourceViewConfigPatch,
     ChartApplyRequest,
     ChartUpsertPatch,
+    CustomButtonsApplyRequest,
+    CustomButtonViewButtonBindingPatch,
+    CustomButtonViewConfigPatch,
     CustomButtonMatchRulePatch,
     CustomButtonPatch,
+    CustomButtonRemovePatch,
+    CustomButtonUpsertPatch,
     FieldPatch,
     FieldRemovePatch,
     FieldSelector,
@@ -67,6 +75,7 @@ from .models import (
     PublicFieldType,
     PublicRelationMode,
     PublicChartType,
+    PublicButtonPlacement,
     PublicButtonTriggerAction,
     PublicVisibilityMode,
     PublicViewType,
@@ -74,6 +83,7 @@ from .models import (
     PublicViewButtonType,
     SchemaPlanRequest,
     VisibilityPatch,
+    ViewAssociatedResourcesPatch,
     ViewButtonBindingPatch,
     ViewUpsertPatch,
     ViewFilterOperator,
@@ -140,6 +150,7 @@ INTEGRATION_OUTPUT_TARGET_FIELD_TYPES: tuple[str, ...] = (
 )
 
 MATCH_TYPE_ACCURACY = 1
+MATCH_TYPE_QUESTION = 2
 JUDGE_EQUAL = 0
 JUDGE_UNEQUAL = 1
 JUDGE_GREATER_OR_EQUAL = 5
@@ -158,6 +169,18 @@ INCLUDE_ANY_FLOW_FIELD_TYPES = {
     FieldType.department.value,
 }
 
+QUERY_CONDITION_UNSUPPORTED_FIELD_TYPES = {
+    FieldType.address.value,
+    FieldType.attachment.value,
+    FieldType.code_block.value,
+    FieldType.q_linker.value,
+    FieldType.relation.value,
+    FieldType.subtable.value,
+}
+
+ASSOCIATED_RESOURCE_LIMIT_TYPE_ALL = 1
+ASSOCIATED_RESOURCE_LIMIT_TYPE_SELECT = 2
+
 STABLE_PUBLIC_FLOW_NODE_TYPES = {"start", "approve", "fill", "copy", "webhook", "end"}
 DISABLED_PUBLIC_FLOW_NODE_TYPES = {"branch", "condition"}
 
@@ -2374,6 +2397,469 @@ class AiBuilderFacade:
             **button_style_catalog_payload(),
         }
 
+    def app_custom_buttons_apply(self, *, profile: str, request: CustomButtonsApplyRequest) -> JSONObject:
+        normalized_args = request.model_dump(mode="json")
+        app_key = request.app_key
+        permission_outcomes: list[PermissionCheckOutcome] = []
+        permission_outcome = self._guard_app_permission(
+            profile=profile,
+            app_key=app_key,
+            required_permission="edit_app",
+            normalized_args=normalized_args,
+        )
+        if permission_outcome.block is not None:
+            return permission_outcome.block
+        permission_outcomes.append(permission_outcome)
+
+        def finalize(response: JSONObject) -> JSONObject:
+            return _apply_permission_outcomes(response, *permission_outcomes)
+
+        try:
+            existing_buttons = self._load_custom_buttons_for_builder(profile=profile, app_key=app_key)
+        except (QingflowApiError, RuntimeError) as error:
+            api_error = _coerce_api_error(error)
+            return finalize(_failed_from_api_error(
+                "CUSTOM_BUTTON_LIST_FAILED",
+                api_error,
+                normalized_args=normalized_args,
+                details=_with_state_read_blocked_details({"app_key": app_key}, resource="custom_buttons", error=api_error),
+                suggested_next_call={"tool_name": "app_get", "arguments": {"profile": profile, "app_key": app_key}},
+            ))
+
+        existing_by_id = {
+            button_id: item
+            for item in existing_buttons
+            if (button_id := _coerce_positive_int(item.get("button_id"))) is not None
+        }
+        existing_by_text: dict[str, list[dict[str, Any]]] = {}
+        for item in existing_buttons:
+            text = str(item.get("button_text") or "").strip()
+            if text:
+                existing_by_text.setdefault(text, []).append(item)
+
+        compiled_add_data_configs, add_data_issues = self._compile_custom_button_semantic_add_data_configs(
+            profile=profile,
+            app_key=app_key,
+            patches=request.upsert_buttons,
+        )
+        upsert_ops: list[dict[str, Any]] = []
+        remove_ops: list[dict[str, Any]] = []
+        blocking_issues: list[dict[str, Any]] = []
+        blocking_issues.extend(add_data_issues)
+        touched_existing_ids: set[int] = set()
+        used_client_keys: set[str] = set()
+
+        for index, patch in enumerate(request.upsert_buttons):
+            patch_payload = patch.model_dump(mode="json", exclude_none=True)
+            client_key = str(patch.client_key or "").strip()
+            if client_key:
+                if client_key in used_client_keys:
+                    blocking_issues.append(
+                        {
+                            "error_code": "DUPLICATE_CLIENT_KEY",
+                            "reason_path": f"upsert_buttons[{index}].client_key",
+                            "client_key": client_key,
+                            "message": "client_key must be unique within one button apply call",
+                        }
+                    )
+                used_client_keys.add(client_key)
+            button_id = _coerce_positive_int(patch.button_id)
+            if button_id is not None:
+                if button_id not in existing_by_id:
+                    blocking_issues.append(
+                        {
+                            "error_code": "CUSTOM_BUTTON_NOT_FOUND",
+                            "reason_path": f"upsert_buttons[{index}].button_id",
+                            "button_id": button_id,
+                            "message": "button_id does not exist in the current app draft",
+                            "next_action": "call app_get and use custom_buttons[].button_id",
+                        }
+                    )
+                    continue
+                if button_id in touched_existing_ids:
+                    blocking_issues.append(
+                        {
+                            "error_code": "DUPLICATE_CUSTOM_BUTTON_OPERATION",
+                            "reason_path": f"upsert_buttons[{index}]",
+                            "button_id": button_id,
+                            "message": "the same button is targeted more than once",
+                        }
+                    )
+                    continue
+                touched_existing_ids.add(button_id)
+                upsert_ops.append({"operation": "update", "button_id": button_id, "patch": patch, "index": index})
+                continue
+            text = str(patch.button_text or "").strip()
+            matches = existing_by_text.get(text, [])
+            if len(matches) > 1:
+                blocking_issues.append(
+                    {
+                        "error_code": "AMBIGUOUS_CUSTOM_BUTTON",
+                        "reason_path": f"upsert_buttons[{index}].button_text",
+                        "button_text": text,
+                        "candidate_button_ids": [
+                            item.get("button_id")
+                            for item in matches
+                            if _coerce_positive_int(item.get("button_id")) is not None
+                        ],
+                        "message": "button_text matches multiple existing custom buttons; pass button_id",
+                    }
+                )
+                continue
+            if len(matches) == 1:
+                matched_id = _coerce_positive_int(matches[0].get("button_id"))
+                if matched_id is None:
+                    blocking_issues.append(
+                        {
+                            "error_code": "CUSTOM_BUTTON_ID_MISSING",
+                            "reason_path": f"upsert_buttons[{index}].button_text",
+                            "button_text": text,
+                            "message": "matched button has no readable button_id",
+                        }
+                    )
+                    continue
+                if matched_id in touched_existing_ids:
+                    blocking_issues.append(
+                        {
+                            "error_code": "DUPLICATE_CUSTOM_BUTTON_OPERATION",
+                            "reason_path": f"upsert_buttons[{index}]",
+                            "button_id": matched_id,
+                            "message": "the same button is targeted more than once",
+                        }
+                    )
+                    continue
+                touched_existing_ids.add(matched_id)
+                upsert_ops.append({"operation": "update", "button_id": matched_id, "patch": patch, "index": index})
+            else:
+                upsert_ops.append({"operation": "create", "button_id": None, "patch": patch, "index": index})
+
+        for index, selector in enumerate(request.remove_buttons):
+            selector_id = _coerce_positive_int(selector.button_id)
+            if selector_id is not None:
+                if selector_id not in existing_by_id:
+                    blocking_issues.append(
+                        {
+                            "error_code": "CUSTOM_BUTTON_NOT_FOUND",
+                            "reason_path": f"remove_buttons[{index}].button_id",
+                            "button_id": selector_id,
+                            "message": "button_id does not exist in the current app draft",
+                            "next_action": "call app_get and use custom_buttons[].button_id",
+                        }
+                    )
+                    continue
+                if selector_id in touched_existing_ids:
+                    blocking_issues.append(
+                        {
+                            "error_code": "DUPLICATE_CUSTOM_BUTTON_OPERATION",
+                            "reason_path": f"remove_buttons[{index}]",
+                            "button_id": selector_id,
+                            "message": "the same button is targeted more than once",
+                        }
+                    )
+                    continue
+                touched_existing_ids.add(selector_id)
+                remove_ops.append({"operation": "remove", "button_id": selector_id, "selector": selector, "index": index})
+                continue
+            text = str(selector.button_text or "").strip()
+            matches = existing_by_text.get(text, [])
+            if not matches:
+                blocking_issues.append(
+                    {
+                        "error_code": "CUSTOM_BUTTON_NOT_FOUND",
+                        "reason_path": f"remove_buttons[{index}].button_text",
+                        "button_text": text,
+                        "message": "button_text does not match any existing custom button",
+                    }
+                )
+                continue
+            if len(matches) > 1:
+                blocking_issues.append(
+                    {
+                        "error_code": "AMBIGUOUS_CUSTOM_BUTTON",
+                        "reason_path": f"remove_buttons[{index}].button_text",
+                        "button_text": text,
+                        "candidate_button_ids": [
+                            item.get("button_id")
+                            for item in matches
+                            if _coerce_positive_int(item.get("button_id")) is not None
+                        ],
+                        "message": "button_text matches multiple existing custom buttons; pass button_id",
+                    }
+                )
+                continue
+            matched_id = _coerce_positive_int(matches[0].get("button_id"))
+            if matched_id is None:
+                blocking_issues.append(
+                    {
+                        "error_code": "CUSTOM_BUTTON_ID_MISSING",
+                        "reason_path": f"remove_buttons[{index}].button_text",
+                        "button_text": text,
+                        "message": "matched button has no readable button_id",
+                    }
+                )
+                continue
+            if matched_id in touched_existing_ids:
+                blocking_issues.append(
+                    {
+                        "error_code": "DUPLICATE_CUSTOM_BUTTON_OPERATION",
+                        "reason_path": f"remove_buttons[{index}]",
+                        "button_id": matched_id,
+                        "message": "the same button is targeted more than once",
+                    }
+                )
+                continue
+            touched_existing_ids.add(matched_id)
+            remove_ops.append({"operation": "remove", "button_id": matched_id, "selector": selector, "index": index})
+
+        if blocking_issues:
+            return finalize(
+                _failed(
+                    "CUSTOM_BUTTON_APPLY_BLOCKED",
+                    "custom button apply has blocking issues; no write was executed",
+                    normalized_args=normalized_args,
+                    details={"blocking_issues": blocking_issues},
+                    suggested_next_call={"tool_name": "app_get", "arguments": {"profile": profile, "app_key": app_key}},
+                )
+            )
+
+        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_APPLY_FAILED",
+        )
+        if edit_context_error is not None:
+            return finalize(edit_context_error)
+
+        created: list[dict[str, Any]] = []
+        updated: list[dict[str, Any]] = []
+        removed: list[dict[str, Any]] = []
+        failed: list[dict[str, Any]] = []
+        client_key_map: dict[str, int] = {}
+        write_executed = False
+
+        for op in upsert_ops:
+            patch = cast(CustomButtonUpsertPatch, op["patch"])
+            patch_payload = _serialize_custom_button_payload(patch, add_data_config_override=compiled_add_data_configs.get(int(op["index"])))
+            try:
+                if op["operation"] == "create":
+                    write_executed = True
+                    result = self.buttons.custom_button_create(profile=profile, app_key=app_key, payload=patch_payload)
+                    button_id = _extract_custom_button_id(result.get("result"))
+                    if button_id is None:
+                        try:
+                            readback_buttons = self._load_custom_buttons_for_builder(profile=profile, app_key=app_key)
+                            matches = [
+                                item
+                                for item in readback_buttons
+                                if str(item.get("button_text") or "").strip() == str(patch.button_text or "").strip()
+                                and _coerce_positive_int(item.get("button_id")) is not None
+                            ]
+                            if len(matches) == 1:
+                                button_id = _coerce_positive_int(matches[0].get("button_id"))
+                        except (QingflowApiError, RuntimeError):
+                            button_id = None
+                    entry = {
+                        "index": op["index"],
+                        "operation": "create",
+                        "status": "success" if button_id is not None else "unverified",
+                        "button_id": button_id,
+                        "button_text": patch.button_text,
+                    }
+                    created.append(entry)
+                    if button_id is not None and patch.client_key:
+                        client_key_map[str(patch.client_key)] = button_id
+                else:
+                    button_id = int(op["button_id"])
+                    write_executed = True
+                    self.buttons.custom_button_update(profile=profile, app_key=app_key, button_id=button_id, payload=patch_payload)
+                    updated.append(
+                        {
+                            "index": op["index"],
+                            "operation": "update",
+                            "status": "success",
+                            "button_id": button_id,
+                            "button_text": patch.button_text,
+                        }
+                    )
+                    if patch.client_key:
+                        client_key_map[str(patch.client_key)] = button_id
+            except (QingflowApiError, RuntimeError) as error:
+                api_error = _coerce_api_error(error)
+                failed.append(
+                    {
+                        "index": op["index"],
+                        "operation": op["operation"],
+                        "button_id": op.get("button_id"),
+                        "button_text": patch.button_text,
+                        "status": "failed",
+                        "error_code": "CUSTOM_BUTTON_WRITE_FAILED",
+                        "message": api_error.message,
+                        "transport_error": _transport_error_payload(api_error),
+                    }
+                )
+
+        for op in remove_ops:
+            selector = cast(CustomButtonRemovePatch, op["selector"])
+            button_id = int(op["button_id"])
+            try:
+                write_executed = True
+                self.buttons.custom_button_delete(profile=profile, app_key=app_key, button_id=button_id)
+                removed.append(
+                    {
+                        "index": op["index"],
+                        "operation": "remove",
+                        "status": "success",
+                        "button_id": button_id,
+                        "button_text": selector.button_text or (existing_by_id.get(button_id) or {}).get("button_text"),
+                    }
+                )
+            except (QingflowApiError, RuntimeError) as error:
+                api_error = _coerce_api_error(error)
+                failed.append(
+                    {
+                        "index": op["index"],
+                        "operation": "remove",
+                        "button_id": button_id,
+                        "button_text": selector.button_text,
+                        "status": "failed",
+                        "error_code": "CUSTOM_BUTTON_WRITE_FAILED",
+                        "message": api_error.message,
+                        "transport_error": _transport_error_payload(api_error),
+                    }
+                )
+
+        readback_buttons: list[dict[str, Any]] = []
+        readback_failed = False
+        try:
+            readback_buttons = self._load_custom_buttons_for_builder(profile=profile, app_key=app_key)
+        except (QingflowApiError, RuntimeError):
+            readback_failed = True
+        readback_ids = {
+            button_id
+            for item in readback_buttons
+            if (button_id := _coerce_positive_int(item.get("button_id"))) is not None
+        }
+        created_ids = [
+            int(item["button_id"])
+            for item in created
+            if _coerce_positive_int(item.get("button_id")) is not None
+        ]
+        updated_ids = [
+            int(item["button_id"])
+            for item in updated
+            if _coerce_positive_int(item.get("button_id")) is not None
+        ]
+        removed_ids = [
+            int(item["button_id"])
+            for item in removed
+            if _coerce_positive_int(item.get("button_id")) is not None
+        ]
+        verified = (
+            not readback_failed
+            and all(button_id in readback_ids for button_id in created_ids + updated_ids)
+            and all(button_id not in readback_ids for button_id in removed_ids)
+            and not failed
+            and all(_coerce_positive_int(item.get("button_id")) is not None for item in created)
+        )
+        custom_buttons_verified = verified
+        view_config_results: list[dict[str, Any]] = []
+        view_config_failed: list[dict[str, Any]] = []
+        view_config_warnings: list[dict[str, Any]] = []
+        view_config_verified = True
+        view_config_write_executed = False
+        view_config_write_succeeded = False
+        if request.view_configs:
+            view_config_result = self._apply_custom_button_view_configs(
+                profile=profile,
+                app_key=app_key,
+                view_configs=request.view_configs,
+                client_key_map=client_key_map,
+                existing_buttons=existing_buttons,
+                readback_buttons=readback_buttons,
+                created_ids=created_ids,
+                updated_ids=updated_ids,
+                removed_ids=removed_ids,
+            )
+            view_config_results = list(view_config_result.get("view_configs") or [])
+            view_config_failed = list(view_config_result.get("failed") or [])
+            view_config_warnings = list(view_config_result.get("warnings") or [])
+            view_config_verified = bool(view_config_result.get("verified", False))
+            view_config_write_executed = bool(view_config_result.get("write_executed", False))
+            view_config_write_succeeded = bool(view_config_result.get("write_succeeded", False))
+            write_executed = write_executed or view_config_write_executed
+            if view_config_failed:
+                failed.extend(view_config_failed)
+            if view_config_warnings:
+                if not isinstance(view_config_warnings, list):
+                    view_config_warnings = []
+        verified = custom_buttons_verified and view_config_verified
+        write_succeeded = bool(created or updated or removed or view_config_write_succeeded)
+        status = "success" if verified else ("partial_success" if write_succeeded else "failed")
+        error_code = None if verified else (
+            "CUSTOM_BUTTON_READBACK_PENDING" if readback_failed else "CUSTOM_BUTTON_APPLY_PARTIAL" if write_succeeded else "CUSTOM_BUTTON_APPLY_FAILED"
+        )
+        message = (
+            "applied custom button patch"
+            if verified
+            else "custom button apply completed with partial verification"
+            if write_succeeded
+            else "custom button apply failed; no successful write was confirmed"
+        )
+        warnings = []
+        warnings.extend(view_config_warnings)
+        if not verified:
+            warnings.append(
+                _warning(
+                    "CUSTOM_BUTTON_APPLY_PARTIAL" if write_succeeded else "CUSTOM_BUTTON_APPLY_FAILED",
+                    "custom button write landed but verification is partial; inspect created/updated/removed/failed"
+                    if write_succeeded
+                    else "custom button writes all failed or produced no confirmed result; application was not published",
+                )
+            )
+        response = {
+            "status": status,
+            "error_code": error_code,
+            "recoverable": not verified,
+            "message": message,
+            "normalized_args": normalized_args,
+            "missing_fields": [],
+            "allowed_values": {
+                "trigger_action": [member.value for member in PublicButtonTriggerAction],
+                "style_preset": [item["key"] for item in button_style_catalog_payload()["presets"]],
+            },
+            "details": {
+                "edit_version_no": edit_version_no,
+                "button_ids_by_client_key": client_key_map,
+                "readback_failed": readback_failed,
+            },
+            "request_id": None,
+            "suggested_next_call": None if verified else {"tool_name": "app_get", "arguments": {"profile": profile, "app_key": app_key}},
+            "noop": False,
+            "warnings": warnings,
+            "verification": {
+                "custom_buttons_verified": custom_buttons_verified,
+                "readback_loaded": not readback_failed,
+                "created_verified": not readback_failed and all(button_id in readback_ids for button_id in created_ids),
+                "updated_verified": not readback_failed and all(button_id in readback_ids for button_id in updated_ids),
+                "removed_verified": not readback_failed and all(button_id not in readback_ids for button_id in removed_ids),
+                "view_button_bindings_verified": view_config_verified,
+            },
+            "verified": verified,
+            "app_key": app_key,
+            "mode": "apply",
+            "created": created,
+            "updated": updated,
+            "removed": removed,
+            "failed": failed,
+            "view_configs": view_config_results,
+            "button_ids_by_client_key": client_key_map,
+            "write_executed": write_executed,
+            "write_succeeded": write_succeeded,
+            "safe_to_retry": not write_executed,
+        }
+        return finalize(self._append_publish_result(profile=profile, app_key=app_key, publish=write_succeeded, response=response, edit_version_no=edit_version_no))
+
     def app_custom_button_list(self, *, profile: str, app_key: str) -> JSONObject:
         normalized_args = {"app_key": app_key}
         permission_outcomes: list[PermissionCheckOutcome] = []
@@ -2748,45 +3234,541 @@ class AiBuilderFacade:
             )
         )
 
-    def _resolve_app_matches_in_visible_apps(
-        self,
-        *,
-        profile: str,
-        app_name: str,
-        package_tag_id: int,
-    ) -> list[JSONObject]:
+    def app_associated_resources_apply(self, *, profile: str, request: AssociatedResourcesApplyRequest) -> JSONObject:
+        normalized_args = request.model_dump(mode="json", exclude_none=True)
+        app_key = request.app_key
+        permission_outcomes: list[PermissionCheckOutcome] = []
+        permission_outcome = self._guard_app_permission(
+            profile=profile,
+            app_key=app_key,
+            required_permission="data_manage",
+            normalized_args=normalized_args,
+        )
+        if permission_outcome.block is not None:
+            return permission_outcome.block
+        permission_outcomes.append(permission_outcome)
+
+        def finalize(response: JSONObject) -> JSONObject:
+            return _apply_permission_outcomes(response, *permission_outcomes)
+
         try:
-            listing = self.apps.app_list(profile=profile, ship_auth=False)
-        except (QingflowApiError, RuntimeError):
-            return []
-        items = listing.get("items") if isinstance(listing.get("items"), list) else []
-        matches: list[JSONObject] = []
-        seen_app_keys: set[str] = set()
-        for item in items:
-            if not isinstance(item, dict):
+            existing_resources = self._load_associated_resources_for_builder(profile=profile, app_key=app_key)
+        except (QingflowApiError, RuntimeError) as error:
+            api_error = _coerce_api_error(error)
+            return finalize(_failed_from_api_error(
+                "ASSOCIATED_RESOURCES_READ_FAILED",
+                api_error,
+                normalized_args=normalized_args,
+                details=_with_state_read_blocked_details({"app_key": app_key}, resource="associated_resources", error=api_error),
+                suggested_next_call={"tool_name": "app_get", "arguments": {"profile": profile, "app_key": app_key}},
+            ))
+
+        existing_by_id = _associated_resource_index(existing_resources)
+        blocking_issues: list[dict[str, Any]] = []
+        upsert_ops: list[dict[str, Any]] = []
+        touched_ids: set[int] = set()
+        client_key_to_patch: dict[str, AssociatedResourceUpsertPatch] = {}
+        client_key_to_id: dict[str, int] = {}
+        used_client_keys: set[str] = set()
+
+        for index, patch in enumerate(request.upsert_resources):
+            client_key = str(patch.client_key or "").strip()
+            if client_key:
+                if client_key in used_client_keys:
+                    blocking_issues.append({"error_code": "DUPLICATE_CLIENT_KEY", "reason_path": f"upsert_resources[{index}].client_key", "client_key": client_key})
+                used_client_keys.add(client_key)
+                client_key_to_patch[client_key] = patch
+            validation_issue = _validate_associated_resource_patch(patch, reason_path=f"upsert_resources[{index}]")
+            if validation_issue is not None:
+                blocking_issues.append(validation_issue)
                 continue
-            title = str(item.get("title") or item.get("app_name") or "").strip()
-            if title != app_name:
+            associated_item_id = _coerce_positive_int(patch.associated_item_id)
+            if associated_item_id is not None:
+                if associated_item_id not in existing_by_id:
+                    blocking_issues.append(_associated_resource_not_found_issue(f"upsert_resources[{index}].associated_item_id", associated_item_id, existing_by_id))
+                    continue
+                if associated_item_id in touched_ids:
+                    blocking_issues.append(_duplicate_associated_resource_issue(f"upsert_resources[{index}]", associated_item_id))
+                    continue
+                touched_ids.add(associated_item_id)
+                if client_key:
+                    client_key_to_id[client_key] = associated_item_id
+                operation = "unchanged" if _associated_resource_matches_patch(existing_by_id[associated_item_id], patch) else "update"
+                upsert_ops.append({"operation": operation, "associated_item_id": associated_item_id, "patch": patch, "index": index})
                 continue
-            candidate_key = str(item.get("app_key") or item.get("appKey") or "").strip()
-            if not candidate_key or candidate_key in seen_app_keys:
+            matches = [
+                item
+                for item in existing_resources
+                if _associated_resource_matches_patch(item, patch)
+                and _coerce_positive_int(item.get("associated_item_id")) is not None
+            ]
+            if len(matches) > 1:
+                blocking_issues.append(
+                    {
+                        "error_code": "AMBIGUOUS_ASSOCIATED_RESOURCE",
+                        "reason_path": f"upsert_resources[{index}]",
+                        "candidate_associated_item_ids": [
+                            item.get("associated_item_id")
+                            for item in matches
+                            if _coerce_positive_int(item.get("associated_item_id")) is not None
+                        ],
+                        "message": "resource identity matches multiple associated resources; pass associated_item_id",
+                    }
+                )
                 continue
-            tag_ids = _coerce_int_list(item.get("tag_ids"))
-            tag_id = _coerce_positive_int(item.get("tag_id"))
-            if tag_id is not None and tag_id not in tag_ids:
-                tag_ids.append(tag_id)
-            if package_tag_id not in tag_ids:
+            if len(matches) == 1:
+                matched_id = _coerce_positive_int(matches[0].get("associated_item_id"))
+                if matched_id is None:
+                    blocking_issues.append({"error_code": "ASSOCIATED_RESOURCE_ID_MISSING", "reason_path": f"upsert_resources[{index}]"})
+                    continue
+                if matched_id in touched_ids:
+                    blocking_issues.append(_duplicate_associated_resource_issue(f"upsert_resources[{index}]", matched_id))
+                    continue
+                touched_ids.add(matched_id)
+                if client_key:
+                    client_key_to_id[client_key] = matched_id
+                upsert_ops.append({"operation": "unchanged", "associated_item_id": matched_id, "patch": patch, "index": index})
+            else:
+                upsert_ops.append({"operation": "create", "associated_item_id": None, "patch": patch, "index": index})
+
+        remove_ids = [
+            item_id
+            for item_id in (_coerce_positive_int(raw_id) for raw_id in request.remove_associated_item_ids)
+            if item_id is not None
+        ]
+        for raw_id in request.remove_associated_item_ids:
+            item_id = _coerce_positive_int(raw_id)
+            if item_id is None:
+                blocking_issues.append({"error_code": "ASSOCIATED_RESOURCE_NOT_FOUND", "reason_path": "remove_associated_item_ids", "received": raw_id})
                 continue
-            seen_app_keys.add(candidate_key)
-            matches.append({"app_key": candidate_key, "app_name": title, "tag_ids": tag_ids})
-        return matches
+            if item_id not in existing_by_id:
+                blocking_issues.append(_associated_resource_not_found_issue("remove_associated_item_ids", item_id, existing_by_id))
+            elif item_id in touched_ids:
+                blocking_issues.append(_duplicate_associated_resource_issue("remove_associated_item_ids", item_id))
+            else:
+                touched_ids.add(item_id)
 
-    def _resolve_app_matches_in_package(
-        self,
-        *,
-        profile: str,
-        app_name: str,
-        package_tag_id: int,
+        reorder_ids = [
+            item_id
+            for item_id in (_coerce_positive_int(raw_id) for raw_id in request.reorder_associated_item_ids)
+            if item_id is not None
+        ]
+        for raw_id in request.reorder_associated_item_ids:
+            item_id = _coerce_positive_int(raw_id)
+            if item_id is None:
+                blocking_issues.append({"error_code": "ASSOCIATED_RESOURCE_NOT_FOUND", "reason_path": "reorder_associated_item_ids", "received": raw_id})
+            elif item_id not in existing_by_id:
+                blocking_issues.append(_associated_resource_not_found_issue("reorder_associated_item_ids", item_id, existing_by_id))
+
+        for index, view_config in enumerate(request.view_configs):
+            refs = [str(ref or "").strip() for ref in view_config.associated_item_refs if str(ref or "").strip()]
+            missing_refs = [ref for ref in refs if ref not in client_key_to_patch]
+            if missing_refs:
+                blocking_issues.append(
+                    {
+                        "error_code": "ASSOCIATED_RESOURCE_REF_NOT_FOUND",
+                        "reason_path": f"view_configs[{index}].associated_item_refs",
+                        "missing_refs": missing_refs,
+                        "message": "associated_item_refs must reference client_key values from upsert_resources in the same apply call",
+                    }
+                )
+            invalid_ids = [
+                item_id
+                for item_id in view_config.associated_item_ids
+                if _coerce_positive_int(item_id) is None or _coerce_positive_int(item_id) not in existing_by_id
+            ]
+            if invalid_ids:
+                blocking_issues.append(
+                    {
+                        "error_code": "ASSOCIATED_RESOURCE_NOT_FOUND",
+                        "reason_path": f"view_configs[{index}].associated_item_ids",
+                        "invalid_associated_item_ids": invalid_ids,
+                        "available_associated_item_ids": sorted(existing_by_id),
+                        "message": "view_configs.associated_item_ids must use app-level associated_item_id values from app_get",
+                    }
+                )
+            raw_limit_type = str(view_config.limit_type or ("all" if view_config.visible else "")).strip().lower()
+            if view_config.visible and raw_limit_type and raw_limit_type not in {"all", "select"}:
+                blocking_issues.append(
+                    {
+                        "error_code": "INVALID_ASSOCIATED_RESOURCE_LIMIT_TYPE",
+                        "reason_path": f"view_configs[{index}].limit_type",
+                        "received": view_config.limit_type,
+                        "expected_values": ["all", "select"],
+                    }
+                )
+
+        if blocking_issues:
+            return finalize(
+                _failed(
+                    "ASSOCIATED_RESOURCES_APPLY_BLOCKED",
+                    "associated resources apply has blocking issues; no write was executed",
+                    normalized_args=normalized_args,
+                    details={"blocking_issues": blocking_issues},
+                    suggested_next_call={"tool_name": "app_get", "arguments": {"profile": profile, "app_key": app_key}},
+                )
+            )
+
+        has_write_intent = (
+            any(str(op.get("operation") or "") != "unchanged" for op in upsert_ops)
+            or bool(remove_ids)
+            or bool(reorder_ids)
+            or bool(request.view_configs)
+        )
+        if not has_write_intent:
+            unchanged: list[dict[str, Any]] = []
+            for op in upsert_ops:
+                patch = cast(AssociatedResourceUpsertPatch, op["patch"])
+                item_id = int(op["associated_item_id"])
+                unchanged.append(_associated_resource_result_entry("unchanged", op["index"], patch, associated_item_id=item_id))
+                if patch.client_key:
+                    client_key_to_id[str(patch.client_key)] = item_id
+            response = {
+                "status": "success",
+                "error_code": None,
+                "recoverable": False,
+                "message": "associated resources already match requested state; no write was executed",
+                "normalized_args": normalized_args,
+                "missing_fields": [],
+                "allowed_values": {"graph_type": ["chart", "view"], "report_source": ["app", "dataset"], "view_config.limit_type": ["all", "select"]},
+                "details": {"edit_version_no": None, "associated_item_ids_by_client_key": client_key_to_id, "readback_failed": False},
+                "request_id": None,
+                "suggested_next_call": None,
+                "noop": True,
+                "warnings": [],
+                "verification": {"associated_resources_verified": True, "associated_resource_view_configs_verified": True, "readback_loaded": True, "published": False},
+                "verified": True,
+                "app_key": app_key,
+                "mode": "apply",
+                "created": [],
+                "updated": [],
+                "unchanged": unchanged,
+                "removed": [],
+                "reordered_associated_item_ids": [],
+                "view_configs": [],
+                "failed": [],
+                "associated_item_ids_by_client_key": client_key_to_id,
+                "write_executed": False,
+                "write_succeeded": False,
+                "safe_to_retry": True,
+                "publish_requested": False,
+                "published": False,
+                "associated_resources": existing_resources,
+            }
+            return finalize(response)
+
+        edit_version_no, edit_context_error = self._ensure_app_edit_context(
+            profile=profile,
+            app_key=app_key,
+            normalized_args=normalized_args,
+            failure_code="ASSOCIATED_RESOURCES_APPLY_FAILED",
+        )
+        if edit_context_error is not None:
+            return finalize(edit_context_error)
+
+        created: list[dict[str, Any]] = []
+        updated: list[dict[str, Any]] = []
+        unchanged: list[dict[str, Any]] = []
+        removed: list[dict[str, Any]] = []
+        reordered: list[int] = []
+        view_config_results: list[dict[str, Any]] = []
+        failed: list[dict[str, Any]] = []
+        write_executed = False
+
+        for op in upsert_ops:
+            patch = cast(AssociatedResourceUpsertPatch, op["patch"])
+            try:
+                if op["operation"] == "unchanged":
+                    item_id = int(op["associated_item_id"])
+                    unchanged.append(_associated_resource_result_entry("unchanged", op["index"], patch, associated_item_id=item_id))
+                    if patch.client_key:
+                        client_key_to_id[str(patch.client_key)] = item_id
+                elif op["operation"] == "create":
+                    write_executed = True
+                    self._associated_resource_create(profile=profile, app_key=app_key, patch=patch)
+                    readback_resources = self._load_associated_resources_for_builder(profile=profile, app_key=app_key)
+                    matches = [
+                        item
+                        for item in readback_resources
+                        if _associated_resource_matches_patch(item, patch)
+                        and _coerce_positive_int(item.get("associated_item_id")) is not None
+                    ]
+                    created_id = _coerce_positive_int(matches[0].get("associated_item_id")) if len(matches) == 1 else None
+                    created.append(_associated_resource_result_entry("create", op["index"], patch, associated_item_id=created_id))
+                    if created_id is not None and patch.client_key:
+                        client_key_to_id[str(patch.client_key)] = created_id
+                else:
+                    item_id = int(op["associated_item_id"])
+                    write_executed = True
+                    self._associated_resource_update(profile=profile, app_key=app_key, associated_item_id=item_id, patch=patch)
+                    updated.append(_associated_resource_result_entry("update", op["index"], patch, associated_item_id=item_id))
+                    if patch.client_key:
+                        client_key_to_id[str(patch.client_key)] = item_id
+            except (QingflowApiError, RuntimeError) as error:
+                api_error = _coerce_api_error(error)
+                failed.append(
+                    {
+                        "index": op["index"],
+                        "operation": op["operation"],
+                        "associated_item_id": op.get("associated_item_id"),
+                        "status": "failed",
+                        "error_code": "ASSOCIATED_RESOURCE_WRITE_FAILED",
+                        "message": api_error.message,
+                        "transport_error": _transport_error_payload(api_error),
+                    }
+                )
+
+        for item_id in remove_ids:
+            try:
+                write_executed = True
+                self._associated_resource_delete(profile=profile, app_key=app_key, associated_item_id=item_id)
+                removed.append({"associated_item_id": item_id, "status": "success"})
+            except (QingflowApiError, RuntimeError) as error:
+                api_error = _coerce_api_error(error)
+                failed.append({"operation": "remove", "associated_item_id": item_id, "status": "failed", "error_code": "ASSOCIATED_RESOURCE_WRITE_FAILED", "message": api_error.message, "transport_error": _transport_error_payload(api_error)})
+
+        if reorder_ids:
+            try:
+                write_executed = True
+                self._associated_resource_reorder(profile=profile, app_key=app_key, associated_item_ids=reorder_ids)
+                reordered = list(reorder_ids)
+            except (QingflowApiError, RuntimeError) as error:
+                api_error = _coerce_api_error(error)
+                failed.append({"operation": "reorder", "associated_item_ids": reorder_ids, "status": "failed", "error_code": "ASSOCIATED_RESOURCE_REORDER_FAILED", "message": api_error.message, "transport_error": _transport_error_payload(api_error)})
+
+        try:
+            resources_after = self._load_associated_resources_for_builder(profile=profile, app_key=app_key)
+        except (QingflowApiError, RuntimeError):
+            resources_after = []
+
+        for index, view_config in enumerate(request.view_configs):
+            selected_ids = [
+                item_id
+                for item_id in (
+                    _coerce_positive_int(raw_id)
+                    for raw_id in [
+                        *view_config.associated_item_ids,
+                        *[client_key_to_id.get(str(ref or "").strip()) for ref in view_config.associated_item_refs],
+                    ]
+                )
+                if item_id is not None
+            ]
+            view_payload, expected_config, issues = _build_view_associated_resources_payload(
+                associated_resources={"visible": view_config.visible, "limit_type": view_config.limit_type or ("all" if view_config.visible else None), "associated_item_ids": selected_ids},
+                available_resources=resources_after,
+            )
+            if issues:
+                failed.append({"operation": "view_config", "index": index, "view_key": view_config.view_key, "status": "failed", "issues": issues})
+                continue
+            try:
+                write_executed = True
+                self._update_view_associated_resources_config(profile=profile, view_key=view_config.view_key, associated_resources_payload=view_payload)
+                try:
+                    config = self.views.view_get_config(profile=profile, viewgraph_key=view_config.view_key).get("result") or {}
+                    actual_config = _extract_view_associated_resources_config(config if isinstance(config, dict) else {}, available_resources=resources_after)
+                    verified_config = expected_config is not None and _associated_resources_config_matches(expected_config, actual_config)
+                    if not verified_config and expected_config is not None:
+                        self._update_view_associated_resources_config(profile=profile, view_key=view_config.view_key, associated_resources_payload=view_payload)
+                        refreshed_resources = self._load_associated_resources_for_builder(profile=profile, app_key=app_key)
+                        refreshed_config = self.views.view_get_config(profile=profile, viewgraph_key=view_config.view_key).get("result") or {}
+                        actual_config = _extract_view_associated_resources_config(
+                            refreshed_config if isinstance(refreshed_config, dict) else {},
+                            available_resources=refreshed_resources,
+                        )
+                        verified_config = _associated_resources_config_matches(expected_config, actual_config)
+                except (QingflowApiError, RuntimeError):
+                    actual_config = {}
+                    verified_config = False
+                view_config_results.append({"index": index, "view_key": view_config.view_key, "status": "success" if verified_config else "partial_success", "associated_resources_verified": verified_config, "expected": expected_config, "actual": actual_config})
+            except (QingflowApiError, RuntimeError) as error:
+                api_error = _coerce_api_error(error)
+                failed.append({"operation": "view_config", "index": index, "view_key": view_config.view_key, "status": "failed", "error_code": "VIEW_ASSOCIATED_RESOURCES_WRITE_FAILED", "message": api_error.message, "transport_error": _transport_error_payload(api_error)})
+
+        final_resources: list[dict[str, Any]] = []
+        readback_failed = False
+        try:
+            final_resources = self._load_associated_resources_for_builder(profile=profile, app_key=app_key)
+        except (QingflowApiError, RuntimeError):
+            readback_failed = True
+        final_by_id = _associated_resource_index(final_resources)
+        created_ids = [int(item["associated_item_id"]) for item in created if _coerce_positive_int(item.get("associated_item_id")) is not None]
+        updated_ids = [int(item["associated_item_id"]) for item in updated if _coerce_positive_int(item.get("associated_item_id")) is not None]
+        unchanged_ids = [int(item["associated_item_id"]) for item in unchanged if _coerce_positive_int(item.get("associated_item_id")) is not None]
+        removed_ids = [int(item["associated_item_id"]) for item in removed if _coerce_positive_int(item.get("associated_item_id")) is not None]
+        pool_verified = (
+            not readback_failed
+            and all(item_id in final_by_id for item_id in created_ids + updated_ids + unchanged_ids)
+            and all(item_id not in final_by_id for item_id in removed_ids)
+            and not failed
+            and all(_coerce_positive_int(item.get("associated_item_id")) is not None for item in created)
+        )
+        view_configs_verified = all(bool(item.get("associated_resources_verified")) for item in view_config_results) and not any(
+            item.get("operation") == "view_config" for item in failed
+        )
+        verified = pool_verified and view_configs_verified
+        write_succeeded = bool(created or updated or removed or reordered or view_config_results)
+        operation_succeeded = write_succeeded or bool(unchanged)
+        status = "success" if verified else ("partial_success" if operation_succeeded else "failed")
+        error_code = None if verified else (
+            "ASSOCIATED_RESOURCES_READBACK_PENDING"
+            if readback_failed
+            else "ASSOCIATED_RESOURCES_APPLY_PARTIAL"
+            if operation_succeeded
+            else "ASSOCIATED_RESOURCES_APPLY_FAILED"
+        )
+        message = (
+            "applied associated resources patch"
+            if verified
+            else "associated resources apply completed with partial verification"
+            if operation_succeeded
+            else "associated resources apply failed; no successful write was confirmed"
+        )
+        warnings = []
+        if not verified:
+            warnings.append(
+                _warning(
+                    "ASSOCIATED_RESOURCES_APPLY_PARTIAL" if operation_succeeded else "ASSOCIATED_RESOURCES_APPLY_FAILED",
+                    "associated resource write landed but verification is partial; inspect created/updated/removed/failed/view_configs"
+                    if operation_succeeded
+                    else "associated resource writes all failed or produced no confirmed result; application was not published",
+                )
+            )
+        response = {
+            "status": status,
+            "error_code": error_code,
+            "recoverable": not verified,
+            "message": message,
+            "normalized_args": normalized_args,
+            "missing_fields": [],
+            "allowed_values": {"graph_type": ["chart", "view"], "report_source": ["app", "dataset"], "view_config.limit_type": ["all", "select"]},
+            "details": {"edit_version_no": edit_version_no, "associated_item_ids_by_client_key": client_key_to_id, "readback_failed": readback_failed},
+            "request_id": None,
+            "suggested_next_call": None if verified else {"tool_name": "app_get", "arguments": {"profile": profile, "app_key": app_key}},
+            "noop": False,
+            "warnings": warnings,
+            "verification": {"associated_resources_verified": pool_verified, "associated_resource_view_configs_verified": view_configs_verified, "readback_loaded": not readback_failed},
+            "verified": verified,
+            "app_key": app_key,
+            "mode": "apply",
+            "created": created,
+            "updated": updated,
+            "unchanged": unchanged,
+            "removed": removed,
+            "reordered_associated_item_ids": reordered,
+            "view_configs": view_config_results,
+            "failed": failed,
+            "associated_item_ids_by_client_key": client_key_to_id,
+            "write_executed": write_executed,
+            "write_succeeded": write_succeeded,
+            "safe_to_retry": not write_executed,
+            "associated_resources": final_resources,
+        }
+        response = self._append_publish_result(profile=profile, app_key=app_key, publish=write_succeeded, response=response, edit_version_no=edit_version_no)
+        if response.get("published") and view_config_results:
+            try:
+                post_publish_resources = self._load_associated_resources_for_builder(profile=profile, app_key=app_key)
+            except (QingflowApiError, RuntimeError):
+                post_publish_resources = final_resources
+            if post_publish_resources:
+                response["associated_resources"] = post_publish_resources
+            post_publish_verified_any = False
+            for result in view_config_results:
+                if result.get("associated_resources_verified"):
+                    continue
+                expected_config = result.get("expected") if isinstance(result.get("expected"), dict) else None
+                view_key = str(result.get("view_key") or "").strip()
+                if expected_config is None or not view_key:
+                    continue
+                try:
+                    config = self.views.view_get_config(profile=profile, viewgraph_key=view_key).get("result") or {}
+                    actual_config = _extract_view_associated_resources_config(
+                        config if isinstance(config, dict) else {},
+                        available_resources=post_publish_resources,
+                    )
+                except (QingflowApiError, RuntimeError):
+                    continue
+                if _associated_resources_config_matches(expected_config, actual_config):
+                    result["status"] = "success"
+                    result["associated_resources_verified"] = True
+                    result["actual"] = actual_config
+                    result["post_publish_verified"] = True
+                    post_publish_verified_any = True
+            verification = response.get("verification")
+            if not isinstance(verification, dict):
+                verification = {}
+                response["verification"] = verification
+            post_view_configs_verified = all(bool(item.get("associated_resources_verified")) for item in view_config_results) and not any(
+                item.get("operation") == "view_config" for item in failed
+            )
+            verification["associated_resource_view_configs_verified"] = post_view_configs_verified
+            if post_publish_verified_any:
+                warnings = response.get("warnings")
+                if not isinstance(warnings, list):
+                    warnings = []
+                    response["warnings"] = warnings
+                warnings[:] = [
+                    warning
+                    for warning in warnings
+                    if not (
+                        isinstance(warning, dict)
+                        and warning.get("code") in {"ASSOCIATED_RESOURCES_APPLY_PARTIAL", "ASSOCIATED_RESOURCES_APPLY_FAILED"}
+                    )
+                ]
+                warnings.append(
+                    _warning(
+                        "VIEW_ASSOCIATED_RESOURCE_POST_PUBLISH_VERIFIED",
+                        "view associated resources were verified after publish because immediate draft readback lagged",
+                    )
+                )
+            post_verified = bool(verification.get("associated_resources_verified")) and post_view_configs_verified and response.get("published") and not failed
+            response["verified"] = post_verified
+            if post_verified:
+                response["status"] = "success"
+                response["error_code"] = None
+                response["recoverable"] = False
+                response["message"] = "applied associated resources patch"
+                response["suggested_next_call"] = None
+        return finalize(response)
+
+    def _resolve_app_matches_in_visible_apps(
+        self,
+        *,
+        profile: str,
+        app_name: str,
+        package_tag_id: int,
+    ) -> list[JSONObject]:
+        try:
+            listing = self.apps.app_list(profile=profile, ship_auth=False)
+        except (QingflowApiError, RuntimeError):
+            return []
+        items = listing.get("items") if isinstance(listing.get("items"), list) else []
+        matches: list[JSONObject] = []
+        seen_app_keys: set[str] = set()
+        for item in items:
+            if not isinstance(item, dict):
+                continue
+            title = str(item.get("title") or item.get("app_name") or "").strip()
+            if title != app_name:
+                continue
+            candidate_key = str(item.get("app_key") or item.get("appKey") or "").strip()
+            if not candidate_key or candidate_key in seen_app_keys:
+                continue
+            tag_ids = _coerce_int_list(item.get("tag_ids"))
+            tag_id = _coerce_positive_int(item.get("tag_id"))
+            if tag_id is not None and tag_id not in tag_ids:
+                tag_ids.append(tag_id)
+            if package_tag_id not in tag_ids:
+                continue
+            seen_app_keys.add(candidate_key)
+            matches.append({"app_key": candidate_key, "app_name": title, "tag_ids": tag_ids})
+        return matches
+
+    def _resolve_app_matches_in_package(
+        self,
+        *,
+        profile: str,
+        app_name: str,
+        package_tag_id: int,
     ) -> list[JSONObject]:
         try:
             package_result = self.packages.package_get(profile=profile, tag_id=package_tag_id, include_raw=True)
@@ -3093,6 +4075,26 @@ class AiBuilderFacade:
             tolerate_404=True,
             tolerate_permission_restricted=True,
         )
+        view_summaries = _summarize_views(views)
+        charts_unavailable = False
+        try:
+            chart_items, _chart_source = self._load_chart_list_for_builder(profile=profile, app_key=app_key)
+            chart_summaries = _summarize_charts(chart_items)
+        except (QingflowApiError, RuntimeError):
+            charts_unavailable = True
+            chart_summaries = []
+        associated_resources_unavailable = False
+        try:
+            associated_resources = self._load_associated_resources_for_builder(profile=profile, app_key=app_key)
+        except (QingflowApiError, RuntimeError):
+            associated_resources_unavailable = True
+            associated_resources = []
+        custom_buttons_unavailable = False
+        try:
+            custom_buttons = self._load_custom_buttons_for_builder(profile=profile, app_key=app_key)
+        except (QingflowApiError, RuntimeError):
+            custom_buttons_unavailable = True
+            custom_buttons = []
         workflow, workflow_unavailable = self._load_workflow_result(
             profile=profile,
             app_key=app_key,
@@ -3103,14 +4105,28 @@ class AiBuilderFacade:
             tag_ids=_coerce_int_list(base_result.get("tagIds")),
             fields=parsed["fields"],
             layout=parsed["layout"],
-            views=_summarize_views(views),
+            views=view_summaries,
         )
         if schema_unavailable:
             verification_hints.append("schema_read_unavailable")
         if views_unavailable:
             verification_hints.append("views_read_unavailable")
+        if charts_unavailable:
+            verification_hints.append("charts_read_unavailable")
+        if associated_resources_unavailable:
+            verification_hints.append("associated_resources_read_unavailable")
+        if custom_buttons_unavailable:
+            verification_hints.append("custom_buttons_read_unavailable")
         if workflow_unavailable:
             verification_hints.append("workflow_read_unavailable")
+        counts = {
+            "fields": len(parsed["fields"]),
+            "layout_sections": len(parsed["layout"].get("sections", [])),
+            "views": len(view_summaries),
+            "charts": len(chart_summaries),
+            "associated_resources": len(associated_resources),
+            "custom_buttons": len(custom_buttons),
+        }
         response = AppReadSummaryResponse(
             app_key=app_key,
             title=base_result.get("formTitle"),
@@ -3120,9 +4136,18 @@ class AiBuilderFacade:
             publish_status=base_result.get("appPublishStatus"),
             field_count=len(parsed["fields"]),
             layout_section_count=len(parsed["layout"].get("sections", [])),
-            view_count=len(_summarize_views(views)),
+            view_count=len(view_summaries),
+            chart_count=len(chart_summaries),
+            associated_resource_count=len(associated_resources),
+            custom_button_count=len(custom_buttons),
+            counts=counts,
+            views=view_summaries,
+            charts=chart_summaries,
+            associated_resources=associated_resources,
+            custom_buttons=custom_buttons,
             workflow_enabled=bool(workflow),
             verification_hints=verification_hints,
+            form_settings={} if schema_unavailable else _form_settings_from_schema(schema_result, parsed["fields"]),
         )
         return {
             "status": "success",
@@ -3141,9 +4166,17 @@ class AiBuilderFacade:
                 "app_exists": True,
                 "schema_read_unavailable": schema_unavailable,
                 "views_read_unavailable": views_unavailable,
+                "charts_read_unavailable": charts_unavailable,
+                "associated_resources_read_unavailable": associated_resources_unavailable,
+                "custom_buttons_read_unavailable": custom_buttons_unavailable,
                 "workflow_read_unavailable": workflow_unavailable,
             },
-            "verified": not schema_unavailable and not views_unavailable and not workflow_unavailable,
+            "verified": not schema_unavailable
+            and not views_unavailable
+            and not charts_unavailable
+            and not associated_resources_unavailable
+            and not custom_buttons_unavailable
+            and not workflow_unavailable,
             **response.model_dump(mode="json"),
         }
 
@@ -3485,6 +4518,7 @@ class AiBuilderFacade:
             app_key=app_key,
             fields=[_compact_public_field_read(field=field, layout=parsed["layout"]) for field in parsed["fields"]],
             field_count=len(parsed["fields"]),
+            form_settings=_form_settings_from_schema(state["schema"], parsed["fields"]),
         )
         return {
             "status": "success",
@@ -3597,6 +4631,7 @@ class AiBuilderFacade:
             "verification": {
                 "app_exists": True,
                 "view_filters_verified": False,
+                "view_query_conditions_verified": False,
                 "view_display_readback_complete": not config_read_errors,
             },
             "verified": True,
@@ -3800,61 +4835,711 @@ class AiBuilderFacade:
         fallback_items = self.charts.qingbi_report_list(profile=profile, app_key=app_key).get("items") or []
         return list(fallback_items) if isinstance(fallback_items, list) else [], "fallback"
 
-    def portal_get(self, *, profile: str, dash_key: str, being_draft: bool = True) -> JSONObject:
-        try:
-            result = self.portals.portal_get(profile=profile, dash_key=dash_key, being_draft=being_draft).get("result") or {}
-        except (QingflowApiError, RuntimeError) as error:
-            api_error = _coerce_api_error(error)
-            return _failed_from_api_error(
-                "PORTAL_GET_FAILED",
-                api_error,
-                normalized_args={"dash_key": dash_key, "being_draft": being_draft},
-                details={"dash_key": dash_key, "being_draft": being_draft},
-                suggested_next_call={"tool_name": "portal_get", "arguments": {"profile": profile, "dash_key": dash_key, "being_draft": being_draft}},
+    def _load_associated_resources_for_builder(self, *, profile: str, app_key: str) -> list[dict[str, Any]]:
+        def runner(_: Any, context: BackendRequestContext) -> list[dict[str, Any]]:
+            payload = self.apps.backend.request(
+                "GET",
+                context,
+                f"/app/{app_key}/asosChart",
+                params={"role": 1, "beingDraft": True},
             )
-        response = PortalGetResponse(
-            dash_key=dash_key,
-            being_draft=being_draft,
-            dash_name=str(result.get("dashName") or "").strip() or None,
-            package_tag_ids=[
-                tag_id
-                for tag_id in (
-                    _coerce_positive_int((item or {}).get("tagId"))
-                    for item in (result.get("tags") or [])
-                    if isinstance(item, dict)
-                )
-                if tag_id is not None
-            ],
-            dash_icon=str(result.get("dashIcon") or "").strip() or None,
-            hide_copyright=bool(result.get("hideCopyright")) if "hideCopyright" in result else None,
-            visibility=_public_visibility_from_member_auth(result.get("auth")),
-            auth=deepcopy(result.get("auth")) if isinstance(result.get("auth"), dict) else {},
-            config=deepcopy(result.get("config")) if isinstance(result.get("config"), dict) else {},
-            dash_global_config=deepcopy(result.get("dashGlobalConfig")) if isinstance(result.get("dashGlobalConfig"), dict) else {},
-            component_count=len(result.get("components") or []) if isinstance(result.get("components"), list) else 0,
-            components=_normalize_portal_components(result.get("components")),
-        )
-        return {
-            "status": "success",
-            "error_code": None,
-            "recoverable": False,
-            "message": "read portal detail",
-            "normalized_args": {"dash_key": dash_key, "being_draft": being_draft},
-            "missing_fields": [],
-            "allowed_values": {},
-            "details": {},
-            "request_id": None,
-            "suggested_next_call": None,
-            "noop": False,
-            "warnings": [],
-            "verification": {"portal_exists": True, "being_draft": being_draft},
-            "verified": True,
-            **response.model_dump(mode="json"),
-        }
+            return _normalize_associated_resources_payload(payload)
 
-    def portal_read_summary(self, *, profile: str, dash_key: str, being_draft: bool = True) -> JSONObject:
+        return self.apps._run(profile, runner)
+
+    def _associated_resource_create(self, *, profile: str, app_key: str, patch: AssociatedResourceUpsertPatch) -> JSONObject:
+        payload = _serialize_associated_resource_create_payload(patch)
+
+        def runner(_: Any, context: BackendRequestContext) -> JSONObject:
+            result = self.apps.backend.request("POST", context, f"/app/{app_key}/asosChart", json_body=payload)
+            return result if isinstance(result, dict) else {"result": result}
+
+        return self.apps._run(profile, runner)
+
+    def _associated_resource_update(
+        self,
+        *,
+        profile: str,
+        app_key: str,
+        associated_item_id: int,
+        patch: AssociatedResourceUpsertPatch,
+    ) -> JSONObject:
+        payload = _serialize_associated_resource_update_payload(patch, associated_item_id=associated_item_id)
+
+        def runner(_: Any, context: BackendRequestContext) -> JSONObject:
+            result = self.apps.backend.request("POST", context, f"/app/{app_key}/asosChart/{associated_item_id}", json_body=payload)
+            return result if isinstance(result, dict) else {"result": result}
+
+        return self.apps._run(profile, runner)
+
+    def _associated_resource_delete(self, *, profile: str, app_key: str, associated_item_id: int) -> JSONObject:
+        def runner(_: Any, context: BackendRequestContext) -> JSONObject:
+            result = self.apps.backend.request("DELETE", context, f"/app/{app_key}/asosChart/{associated_item_id}")
+            return result if isinstance(result, dict) else {"result": result}
+
+        return self.apps._run(profile, runner)
+
+    def _associated_resource_reorder(self, *, profile: str, app_key: str, associated_item_ids: list[int]) -> JSONObject:
+        def runner(_: Any, context: BackendRequestContext) -> JSONObject:
+            result = self.apps.backend.request("POST", context, f"/app/{app_key}/asosChart/ordinal", json_body=list(associated_item_ids))
+            return result if isinstance(result, dict) else {"result": result}
+
+        return self.apps._run(profile, runner)
+
+    def _update_view_associated_resources_config(
+        self,
+        *,
+        profile: str,
+        view_key: str,
+        associated_resources_payload: dict[str, Any] | None,
+    ) -> JSONObject:
+        config_response = self.views.view_get_config(profile=profile, viewgraph_key=view_key)
+        config = config_response.get("result") if isinstance(config_response.get("result"), dict) else {}
+        payload = _build_view_associated_resources_only_update_payload(config, associated_resources_payload=associated_resources_payload)
+        return self.views.view_update(profile=profile, viewgraph_key=view_key, payload=payload)
+
+    def _load_custom_buttons_for_builder(self, *, profile: str, app_key: str) -> list[dict[str, Any]]:
+        listing = self.buttons.custom_button_list(profile=profile, app_key=app_key, being_draft=True, include_raw=False)
+        return [
+            _normalize_custom_button_summary(item)
+            for item in (listing.get("items") or [])
+            if isinstance(item, dict)
+        ]
+
+    def _compile_custom_button_semantic_add_data_configs(
+        self,
+        *,
+        profile: str,
+        app_key: str,
+        patches: list[CustomButtonUpsertPatch],
+    ) -> tuple[dict[int, dict[str, Any]], list[dict[str, Any]]]:
+        compiled_by_index: dict[int, dict[str, Any]] = {}
+        issues: list[dict[str, Any]] = []
+        semantic_patches = [
+            (index, patch, patch.trigger_add_data_config)
+            for index, patch in enumerate(patches)
+            if patch.trigger_add_data_config is not None
+            and _custom_button_add_data_config_has_semantic_inputs(patch.trigger_add_data_config.model_dump(mode="json", exclude_none=True))
+        ]
+        if not semantic_patches:
+            return compiled_by_index, issues
         try:
-            result = self.portals.portal_get(profile=profile, dash_key=dash_key, being_draft=being_draft).get("result") or {}
+            source_schema, _schema_source = self._read_schema_with_fallback(profile=profile, app_key=app_key)
+        except (QingflowApiError, RuntimeError) as error:
+            api_error = _coerce_api_error(error)
+            return {}, [
+                {
+                    "error_code": "CUSTOM_BUTTON_SOURCE_SCHEMA_READ_FAILED",
+                    "reason_path": "upsert_buttons[].trigger_add_data_config.field_mappings",
+                    "message": api_error.message,
+                    "transport_error": _transport_error_payload(api_error),
+                    "next_action": "retry after app schema is readable",
+                }
+            ]
+        source_fields = _parse_schema(source_schema).get("fields") or []
+        target_schema_cache: dict[str, list[dict[str, Any]]] = {}
+        target_name_cache: dict[str, str | None] = {}
+        for index, patch, config in semantic_patches:
+            config_payload = config.model_dump(mode="json", exclude_none=True)
+            reason_base = f"upsert_buttons[{index}].trigger_add_data_config"
+            if config.que_relation:
+                issues.append(
+                    {
+                        "error_code": "MIXED_CUSTOM_BUTTON_MAPPING_MODES",
+                        "reason_path": reason_base,
+                        "message": "field_mappings/default_values cannot be used together with legacy que_relation",
+                        "next_action": "use field_mappings/default_values only, or pass legacy que_relation only",
+                    }
+                )
+                continue
+            target_app_key = str(config.related_app_key or "").strip()
+            if not target_app_key:
+                issues.append(
+                    {
+                        "error_code": "CUSTOM_BUTTON_TARGET_APP_REQUIRED",
+                        "reason_path": f"{reason_base}.target_app_key",
+                        "missing_fields": ["target_app_key"],
+                        "message": "addData field_mappings/default_values require target_app_key",
+                    }
+                )
+                continue
+            if target_app_key not in target_schema_cache:
+                try:
+                    target_schema, _target_schema_source = self._read_schema_with_fallback(profile=profile, app_key=target_app_key)
+                    target_schema_cache[target_app_key] = list(_parse_schema(target_schema).get("fields") or [])
+                    target_base = self.apps.app_get_base(profile=profile, app_key=target_app_key, include_raw=True).get("result") or {}
+                    target_name_cache[target_app_key] = str(target_base.get("formTitle") or target_base.get("appName") or "").strip() or None
+                except (QingflowApiError, RuntimeError) as error:
+                    api_error = _coerce_api_error(error)
+                    issues.append(
+                        {
+                            "error_code": "CUSTOM_BUTTON_TARGET_SCHEMA_READ_FAILED",
+                            "reason_path": f"{reason_base}.target_app_key",
+                            "target_app_key": target_app_key,
+                            "message": api_error.message,
+                            "transport_error": _transport_error_payload(api_error),
+                            "next_action": "verify target_app_key with app_get",
+                        }
+                    )
+                    continue
+            compiled_config, config_issues = self._compile_custom_button_add_data_config(
+                profile=profile,
+                source_fields=list(source_fields),
+                target_fields=target_schema_cache[target_app_key],
+                target_app_key=target_app_key,
+                target_app_name=config.related_app_name or target_name_cache.get(target_app_key),
+                config=config_payload,
+                reason_path=reason_base,
+            )
+            if config_issues:
+                issues.extend(config_issues)
+                continue
+            compiled_by_index[index] = compiled_config
+        return compiled_by_index, issues
+
+    def _compile_custom_button_add_data_config(
+        self,
+        *,
+        profile: str,
+        source_fields: list[dict[str, Any]],
+        target_fields: list[dict[str, Any]],
+        target_app_key: str,
+        target_app_name: str | None,
+        config: dict[str, Any],
+        reason_path: str,
+    ) -> tuple[dict[str, Any], list[dict[str, Any]]]:
+        issues: list[dict[str, Any]] = []
+        rules: list[dict[str, Any]] = []
+        for mapping_index, mapping in enumerate(config.get("field_mappings") or []):
+            if not isinstance(mapping, dict):
+                continue
+            source_field, source_issue = _resolve_custom_button_schema_field(
+                fields=source_fields,
+                selector=mapping.get("source_field"),
+                reason_path=f"{reason_path}.field_mappings[{mapping_index}].source_field",
+                role="source",
+            )
+            target_field, target_issue = _resolve_custom_button_schema_field(
+                fields=target_fields,
+                selector=mapping.get("target_field"),
+                reason_path=f"{reason_path}.field_mappings[{mapping_index}].target_field",
+                role="target",
+            )
+            if source_issue:
+                issues.append(source_issue)
+            if target_issue:
+                issues.append(target_issue)
+            if source_issue or target_issue or source_field is None or target_field is None:
+                continue
+            type_issue = _custom_button_mapping_type_issue(
+                source_field=source_field,
+                target_field=target_field,
+                reason_path=f"{reason_path}.field_mappings[{mapping_index}]",
+            )
+            if type_issue:
+                issues.append(type_issue)
+                continue
+            rules.append(_custom_button_field_mapping_rule(source_field=source_field, target_field=target_field))
+
+        default_values = config.get("default_values") if isinstance(config.get("default_values"), dict) else {}
+        for field_selector, raw_value in default_values.items():
+            target_field, target_issue = _resolve_custom_button_schema_field(
+                fields=target_fields,
+                selector=field_selector,
+                reason_path=f"{reason_path}.default_values.{field_selector}",
+                role="target",
+            )
+            if target_issue or target_field is None:
+                if target_issue:
+                    issues.append(target_issue)
+                continue
+            rule, value_issue = self._custom_button_default_value_rule(
+                profile=profile,
+                target_field=target_field,
+                value=raw_value,
+                reason_path=f"{reason_path}.default_values.{field_selector}",
+            )
+            if value_issue:
+                issues.append(value_issue)
+                continue
+            rules.append(rule)
+
+        return {
+            "related_app_key": target_app_key,
+            "related_app_name": target_app_name,
+            "que_relation": rules,
+        }, issues
+
+    def _custom_button_default_value_rule(
+        self,
+        *,
+        profile: str,
+        target_field: dict[str, Any],
+        value: Any,
+        reason_path: str,
+    ) -> tuple[dict[str, Any], dict[str, Any] | None]:
+        field_type = str(target_field.get("type") or "")
+        values = value if isinstance(value, list) else [value]
+        details: list[dict[str, Any]] = []
+        for raw_value in values:
+            detail, issue = self._custom_button_default_value_detail(
+                profile=profile,
+                target_field=target_field,
+                value=raw_value,
+                reason_path=reason_path,
+            )
+            if issue:
+                return {}, issue
+            if detail is not None:
+                details.append(detail)
+        if field_type not in {
+            FieldType.text.value,
+            FieldType.long_text.value,
+            FieldType.number.value,
+            FieldType.amount.value,
+            FieldType.date.value,
+            FieldType.datetime.value,
+            FieldType.single_select.value,
+            FieldType.multi_select.value,
+            FieldType.boolean.value,
+            FieldType.member.value,
+            FieldType.department.value,
+            FieldType.phone.value,
+            FieldType.email.value,
+            FieldType.relation.value,
+        }:
+            return {}, _custom_button_default_value_issue(
+                target_field=target_field,
+                reason_path=reason_path,
+                value=value,
+                message="this field type cannot be encoded as a custom button static default value",
+            )
+        return _custom_button_default_value_rule(target_field=target_field, value_details=details), None
+
+    def _custom_button_default_value_detail(
+        self,
+        *,
+        profile: str,
+        target_field: dict[str, Any],
+        value: Any,
+        reason_path: str,
+    ) -> tuple[dict[str, Any] | None, dict[str, Any] | None]:
+        field_type = str(target_field.get("type") or "")
+        if value is None:
+            return None, None
+        if field_type in {FieldType.single_select.value, FieldType.multi_select.value, FieldType.boolean.value}:
+            option = _resolve_custom_button_option_detail(target_field=target_field, value=value)
+            if option is None:
+                return None, _custom_button_default_value_issue(
+                    target_field=target_field,
+                    reason_path=reason_path,
+                    value=value,
+                    message="default value must match an existing option title or option id",
+                    allowed_values={"options": list(target_field.get("options") or [])},
+                )
+            return option, None
+        if field_type == FieldType.member.value:
+            member = self._resolve_custom_button_member_default(profile=profile, value=value)
+            if member is None:
+                return None, _custom_button_default_value_issue(
+                    target_field=target_field,
+                    reason_path=reason_path,
+                    value=value,
+                    message="member default value must resolve to exactly one member or pass {'id': uid, 'value': name}",
+                    next_action="retry with an explicit member uid object",
+                )
+            return member, None
+        if field_type == FieldType.department.value:
+            department = self._resolve_custom_button_department_default(profile=profile, value=value)
+            if department is None:
+                return None, _custom_button_default_value_issue(
+                    target_field=target_field,
+                    reason_path=reason_path,
+                    value=value,
+                    message="department default value must resolve to exactly one department or pass {'id': deptId, 'value': name}",
+                    next_action="retry with an explicit department id object",
+                )
+            return department, None
+        scalar = _stringify_custom_button_default_value(value)
+        return {"value": scalar}, None
+
+    def _resolve_custom_button_member_default(self, *, profile: str, value: Any) -> dict[str, Any] | None:
+        explicit_id = _coerce_positive_int(value.get("id", value.get("uid", value.get("member_id"))) if isinstance(value, dict) else value)
+        if explicit_id is not None:
+            return {"id": explicit_id, "value": str(value.get("value", value.get("name", explicit_id)) if isinstance(value, dict) else explicit_id)}
+        keyword = str(value.get("value", value.get("name", value.get("email", ""))) if isinstance(value, dict) else value or "").strip()
+        if not keyword:
+            return None
+        result = self.member_search(profile=profile, query=keyword, page_num=1, page_size=20)
+        if result.get("status") != "success":
+            return None
+        items = [
+            item
+            for item in result.get("items") or []
+            if isinstance(item, dict)
+            and (
+                str(item.get("name") or "").strip() == keyword
+                or str(item.get("email") or "").strip() == keyword
+            )
+        ]
+        if len(items) != 1:
+            return None
+        return {"id": items[0].get("uid"), "value": items[0].get("name") or items[0].get("email") or str(items[0].get("uid"))}
+
+    def _resolve_custom_button_department_default(self, *, profile: str, value: Any) -> dict[str, Any] | None:
+        explicit_id = _coerce_positive_int(value.get("id", value.get("deptId", value.get("dept_id"))) if isinstance(value, dict) else value)
+        if explicit_id is not None:
+            return {"id": explicit_id, "value": str(value.get("value", value.get("name", value.get("deptName", explicit_id))) if isinstance(value, dict) else explicit_id)}
+        keyword = str(value.get("value", value.get("name", value.get("deptName", ""))) if isinstance(value, dict) else value or "").strip()
+        if not keyword:
+            return None
+        resolved = self._resolve_department_references(profile=profile, dept_ids=[], dept_names=[keyword])
+        if resolved.get("issues"):
+            return None
+        entries = resolved.get("department_entries") or []
+        if len(entries) != 1:
+            return None
+        return {"id": entries[0].get("deptId"), "value": entries[0].get("deptName") or str(entries[0].get("deptId"))}
+
+    def _apply_custom_button_view_configs(
+        self,
+        *,
+        profile: str,
+        app_key: str,
+        view_configs: list[CustomButtonViewConfigPatch],
+        client_key_map: dict[str, int],
+        existing_buttons: list[dict[str, Any]],
+        readback_buttons: list[dict[str, Any]],
+        created_ids: list[int],
+        updated_ids: list[int],
+        removed_ids: list[int],
+    ) -> dict[str, Any]:
+        results: list[dict[str, Any]] = []
+        failed: list[dict[str, Any]] = []
+        warnings: list[dict[str, Any]] = []
+        if not view_configs:
+            return {"verified": True, "write_executed": False, "write_succeeded": False, "view_configs": results, "failed": failed, "warnings": warnings}
+        try:
+            schema, _schema_source = self._read_schema_with_fallback(profile=profile, app_key=app_key)
+            parsed_schema = _parse_schema(schema)
+            current_fields_by_name = {
+                str(field.get("name") or ""): field
+                for field in parsed_schema.get("fields") or []
+                if isinstance(field, dict) and str(field.get("name") or "")
+            }
+            existing_views, _views_unavailable = self._load_views_result(profile=profile, app_key=app_key, tolerate_404=False)
+        except (QingflowApiError, RuntimeError) as error:
+            api_error = _coerce_api_error(error)
+            failed.append(
+                {
+                    "operation": "view_config",
+                    "status": "failed",
+                    "error_code": "CUSTOM_BUTTON_VIEW_CONFIG_READ_FAILED",
+                    "message": api_error.message,
+                    "transport_error": _transport_error_payload(api_error),
+                }
+            )
+            return {"verified": False, "write_executed": False, "write_succeeded": False, "view_configs": results, "failed": failed, "warnings": warnings}
+
+        view_keys = {
+            _extract_view_key(view)
+            for view in (existing_views if isinstance(existing_views, list) else [])
+            if isinstance(view, dict) and _extract_view_key(view)
+        }
+        button_inventory: dict[int, dict[str, Any]] = {}
+        for item in [*existing_buttons, *readback_buttons]:
+            if not isinstance(item, dict):
+                continue
+            button_id = _coerce_positive_int(item.get("button_id"))
+            if button_id is not None:
+                button_inventory[button_id] = item
+        valid_custom_button_ids = (set(button_inventory) | set(created_ids) | set(updated_ids)) - set(removed_ids)
+        write_executed = False
+        write_succeeded = False
+        all_verified = True
+
+        for config_index, config in enumerate(view_configs):
+            view_key = str(config.view_key or "").strip()
+            if not view_key or view_key not in view_keys:
+                issue = {
+                    "index": config_index,
+                    "operation": "view_config",
+                    "status": "failed",
+                    "error_code": "UNKNOWN_VIEW",
+                    "view_key": view_key,
+                    "message": "view_key does not exist on this app",
+                    "next_action": "call app_get and use views[].view_key",
+                }
+                failed.append(issue)
+                results.append(issue)
+                all_verified = False
+                continue
+            try:
+                current_response = self.views.view_get_config(profile=profile, viewgraph_key=view_key)
+                current_config = current_response.get("result") if isinstance(current_response.get("result"), dict) else {}
+            except (QingflowApiError, RuntimeError) as error:
+                api_error = _coerce_api_error(error)
+                issue = {
+                    "index": config_index,
+                    "operation": "view_config",
+                    "status": "failed",
+                    "error_code": "VIEW_CONFIG_READ_FAILED",
+                    "view_key": view_key,
+                    "message": api_error.message,
+                    "transport_error": _transport_error_payload(api_error),
+                }
+                failed.append(issue)
+                results.append(issue)
+                all_verified = False
+                continue
+            existing_dtos = _extract_existing_view_button_dtos(current_config)
+            explicit_buttons = "buttons" in getattr(config, "model_fields_set", set())
+            new_dtos: list[dict[str, Any]] = []
+            config_issues: list[dict[str, Any]] = []
+            for button_index, binding in enumerate(config.buttons):
+                button_id, ref_issue = _resolve_custom_button_view_button_ref(
+                    button_ref=binding.button_ref,
+                    client_key_map=client_key_map,
+                    button_inventory=button_inventory,
+                    valid_custom_button_ids=valid_custom_button_ids,
+                    reason_path=f"view_configs[{config_index}].buttons[{button_index}].button_ref",
+                )
+                if ref_issue:
+                    config_issues.append(ref_issue)
+                    continue
+                if button_id is None:
+                    continue
+                view_binding = _custom_button_view_binding_to_view_button_patch(binding=binding, button_id=button_id)
+                dto, binding_issues = _serialize_view_button_binding(
+                    binding=view_binding,
+                    current_fields_by_name=current_fields_by_name,
+                    valid_custom_button_ids=valid_custom_button_ids,
+                )
+                if binding_issues:
+                    config_issues.extend(binding_issues)
+                    continue
+                new_dtos.append(dto)
+            if config_issues:
+                issue = {
+                    "index": config_index,
+                    "operation": "view_config",
+                    "status": "failed",
+                    "error_code": "CUSTOM_BUTTON_VIEW_CONFIG_BLOCKED",
+                    "view_key": view_key,
+                    "issues": config_issues,
+                    "message": "view button config references invalid buttons or fields; no view write was executed for this view",
+                }
+                failed.append(issue)
+                results.append(issue)
+                all_verified = False
+                continue
+            replace_existing = str(config.mode or "").strip().lower() == "replace" or (explicit_buttons and not config.buttons)
+            merged_dtos = (
+                [deepcopy(item) for item in new_dtos]
+                if replace_existing
+                else _merge_custom_button_view_button_dtos(existing_dtos=existing_dtos, new_dtos=new_dtos)
+            )
+            payload = _build_view_buttons_only_update_payload(current_config, button_config_dtos=merged_dtos)
+            effective_merged_dtos = merged_dtos
+            unsupported_list_issue: dict[str, Any] | None = None
+            try:
+                write_executed = True
+                self.views.view_update(profile=profile, viewgraph_key=view_key, payload=payload)
+                write_succeeded = True
+            except (QingflowApiError, RuntimeError) as error:
+                api_error = _coerce_api_error(error)
+                has_requested_list_buttons = any(
+                    _normalize_view_button_config_type(item.get("configType")) == "LIST"
+                    for item in new_dtos
+                    if isinstance(item, dict)
+                )
+                fallback_dtos = [
+                    item
+                    for item in merged_dtos
+                    if _normalize_view_button_config_type(item.get("configType")) != "LIST"
+                ]
+                fallback_new_dtos = [
+                    item
+                    for item in new_dtos
+                    if _normalize_view_button_config_type(item.get("configType")) != "LIST"
+                ]
+                if has_requested_list_buttons and fallback_new_dtos and fallback_dtos != merged_dtos:
+                    fallback_payload = _build_view_buttons_only_update_payload(current_config, button_config_dtos=fallback_dtos)
+                    try:
+                        self.views.view_update(profile=profile, viewgraph_key=view_key, payload=fallback_payload)
+                        write_succeeded = True
+                        effective_merged_dtos = fallback_dtos
+                        unsupported_list_issue = {
+                            "index": config_index,
+                            "operation": "view_config",
+                            "status": "failed",
+                            "error_code": "LIST_BUTTON_BACKEND_UNSUPPORTED",
+                            "view_key": view_key,
+                            "message": "backend rejected list-button placement; header/detail placements were retried without list buttons",
+                            "backend_message": api_error.message,
+                            "transport_error": _transport_error_payload(api_error),
+                            "next_action": "use placement=header/detail for now, or verify the backend list-button endpoint/payload separately",
+                        }
+                        failed.append(unsupported_list_issue)
+                    except (QingflowApiError, RuntimeError) as fallback_error:
+                        fallback_api_error = _coerce_api_error(fallback_error)
+                        issue = {
+                            "index": config_index,
+                            "operation": "view_config",
+                            "status": "failed",
+                            "error_code": "VIEW_BUTTON_CONFIG_WRITE_FAILED",
+                            "view_key": view_key,
+                            "message": fallback_api_error.message,
+                            "transport_error": _transport_error_payload(fallback_api_error),
+                            "initial_error": _transport_error_payload(api_error),
+                        }
+                        failed.append(issue)
+                        results.append(issue)
+                        all_verified = False
+                        continue
+                elif has_requested_list_buttons:
+                    issue = {
+                        "index": config_index,
+                        "operation": "view_config",
+                        "status": "failed",
+                        "error_code": "LIST_BUTTON_BACKEND_UNSUPPORTED",
+                        "view_key": view_key,
+                        "message": "backend rejected list-button placement",
+                        "backend_message": api_error.message,
+                        "transport_error": _transport_error_payload(api_error),
+                        "next_action": "use placement=header/detail for now, or verify the backend list-button endpoint/payload separately",
+                    }
+                    failed.append(issue)
+                    results.append(issue)
+                    all_verified = False
+                    continue
+                else:
+                    issue = {
+                        "index": config_index,
+                        "operation": "view_config",
+                        "status": "failed",
+                        "error_code": "VIEW_BUTTON_CONFIG_WRITE_FAILED",
+                        "view_key": view_key,
+                        "message": api_error.message,
+                        "transport_error": _transport_error_payload(api_error),
+                    }
+                    failed.append(issue)
+                    results.append(issue)
+                    all_verified = False
+                    continue
+            try:
+                verify_response = self.views.view_get_config(profile=profile, viewgraph_key=view_key)
+                verify_config = verify_response.get("result") if isinstance(verify_response.get("result"), dict) else {}
+                expected_summary = _normalize_expected_view_buttons_for_compare(
+                    effective_merged_dtos,
+                    custom_button_details_by_id=button_inventory,
+                )
+                actual_summary = _normalize_view_buttons_for_compare(verify_config)
+                comparison = _compare_view_button_summaries(
+                    expected=expected_summary,
+                    actual=actual_summary,
+                    pending_custom_button_ids=set(created_ids),
+                )
+                verified = bool(comparison.get("verified")) and unsupported_list_issue is None
+                if not verified:
+                    all_verified = False
+                results.append(
+                    {
+                        "index": config_index,
+                        "operation": "view_config",
+                        "status": "success" if verified else ("partial_success" if unsupported_list_issue is not None else "unverified"),
+                        "view_key": view_key,
+                        "mode": "replace" if replace_existing else "merge",
+                        "buttons_configured": len(new_dtos),
+                        "view_buttons_verified": verified,
+                        "supported_buttons_verified": bool(comparison.get("verified")) if unsupported_list_issue is not None else None,
+                        "unsupported_placements": ["list"] if unsupported_list_issue is not None else [],
+                        "custom_button_readback_pending": bool(comparison.get("custom_button_readback_pending")),
+                        "expected_buttons": expected_summary,
+                        "actual_buttons": actual_summary,
+                    }
+                )
+                if comparison.get("custom_button_readback_pending"):
+                    warnings.append(_warning("VIEW_CUSTOM_BUTTON_READBACK_PENDING", "view config write landed but custom button readback is delayed"))
+            except (QingflowApiError, RuntimeError) as error:
+                api_error = _coerce_api_error(error)
+                all_verified = False
+                warnings.append(_warning("VIEW_BUTTON_CONFIG_READBACK_FAILED", api_error.message))
+                results.append(
+                    {
+                        "index": config_index,
+                        "operation": "view_config",
+                        "status": "unverified",
+                        "view_key": view_key,
+                        "mode": "replace" if replace_existing else "merge",
+                        "buttons_configured": len(new_dtos),
+                        "view_buttons_verified": None,
+                    }
+                )
+        return {
+            "verified": all_verified,
+            "write_executed": write_executed,
+            "write_succeeded": write_succeeded,
+            "view_configs": results,
+            "failed": failed,
+            "warnings": warnings,
+        }
+
+    def portal_get(self, *, profile: str, dash_key: str, being_draft: bool = True) -> JSONObject:
+        try:
+            result = self.portals.portal_get(profile=profile, dash_key=dash_key, being_draft=being_draft).get("result") or {}
+        except (QingflowApiError, RuntimeError) as error:
+            api_error = _coerce_api_error(error)
+            return _failed_from_api_error(
+                "PORTAL_GET_FAILED",
+                api_error,
+                normalized_args={"dash_key": dash_key, "being_draft": being_draft},
+                details={"dash_key": dash_key, "being_draft": being_draft},
+                suggested_next_call={"tool_name": "portal_get", "arguments": {"profile": profile, "dash_key": dash_key, "being_draft": being_draft}},
+            )
+        response = PortalGetResponse(
+            dash_key=dash_key,
+            being_draft=being_draft,
+            dash_name=str(result.get("dashName") or "").strip() or None,
+            package_tag_ids=[
+                tag_id
+                for tag_id in (
+                    _coerce_positive_int((item or {}).get("tagId"))
+                    for item in (result.get("tags") or [])
+                    if isinstance(item, dict)
+                )
+                if tag_id is not None
+            ],
+            dash_icon=str(result.get("dashIcon") or "").strip() or None,
+            hide_copyright=bool(result.get("hideCopyright")) if "hideCopyright" in result else None,
+            visibility=_public_visibility_from_member_auth(result.get("auth")),
+            auth=deepcopy(result.get("auth")) if isinstance(result.get("auth"), dict) else {},
+            config=deepcopy(result.get("config")) if isinstance(result.get("config"), dict) else {},
+            dash_global_config=deepcopy(result.get("dashGlobalConfig")) if isinstance(result.get("dashGlobalConfig"), dict) else {},
+            component_count=len(result.get("components") or []) if isinstance(result.get("components"), list) else 0,
+            components=_normalize_portal_components(result.get("components")),
+        )
+        return {
+            "status": "success",
+            "error_code": None,
+            "recoverable": False,
+            "message": "read portal detail",
+            "normalized_args": {"dash_key": dash_key, "being_draft": being_draft},
+            "missing_fields": [],
+            "allowed_values": {},
+            "details": {},
+            "request_id": None,
+            "suggested_next_call": None,
+            "noop": False,
+            "warnings": [],
+            "verification": {"portal_exists": True, "being_draft": being_draft},
+            "verified": True,
+            **response.model_dump(mode="json"),
+        }
+
+    def portal_read_summary(self, *, profile: str, dash_key: str, being_draft: bool = True) -> JSONObject:
+        try:
+            result = self.portals.portal_get(profile=profile, dash_key=dash_key, being_draft=being_draft).get("result") or {}
         except (QingflowApiError, RuntimeError) as error:
             api_error = _coerce_api_error(error)
             return _failed_from_api_error(
@@ -3921,6 +5606,7 @@ class AiBuilderFacade:
             "base_info_verified": True,
             "questions_verified": True,
             "associations_verified": True,
+            "associated_resources_verified": True,
         }
 
         base_info: dict[str, Any] = {}
@@ -3950,6 +5636,19 @@ class AiBuilderFacade:
             verification["associations_verified"] = False
             warnings.append(_warning("VIEW_ASSOCIATIONS_UNAVAILABLE", "view association list readback is unavailable"))
 
+        app_key = str(_first_present(config, "appKey", "formKey") or _first_present(base_info, "appKey", "formKey") or "").strip()
+        associated_resources: list[dict[str, Any]] = []
+        if app_key:
+            try:
+                associated_resources = self._load_associated_resources_for_builder(profile=profile, app_key=app_key)
+            except (QingflowApiError, RuntimeError):
+                verification["associated_resources_verified"] = False
+                warnings.append(_warning("VIEW_ASSOCIATED_RESOURCES_UNAVAILABLE", "view associated resource pool readback is unavailable"))
+        associated_resources_config = _extract_view_associated_resources_config(
+            config if isinstance(config, dict) else {},
+            available_resources=associated_resources,
+        )
+
         response = ViewGetResponse(
             view_key=view_key,
             base_info=base_info,
@@ -3957,7 +5656,16 @@ class AiBuilderFacade:
             config=deepcopy(config) if isinstance(config, dict) else {},
             questions=questions,
             associations=associations,
+            associated_resources_config=associated_resources_config,
         )
+        question_entries = _extract_view_question_entries(config.get("viewgraphQuestions"))
+        canonical_question_entries = _extract_view_question_entries(questions)
+        question_entries_by_id = {
+            field_id: entry
+            for entry in [*question_entries, *canonical_question_entries]
+            if (field_id := _coerce_nonnegative_int(entry.get("field_id"))) is not None
+        }
+        query_conditions = _extract_view_query_conditions_config(config, question_entries_by_id=question_entries_by_id)
         return {
             "status": "success",
             "error_code": None,
@@ -3973,6 +5681,8 @@ class AiBuilderFacade:
             "warnings": warnings,
             "verification": verification,
             "verified": all(bool(value) for value in verification.values()),
+            "query_conditions": query_conditions,
+            "associated_resources_config": associated_resources_config,
             **response.model_dump(mode="json"),
         }
 
@@ -4414,6 +6124,18 @@ class AiBuilderFacade:
                 )
             if translated_filters:
                 patch["filters"] = [dict(rule) for rule in (patch.get("filters") or [])]
+            _, _, query_condition_issues = _build_view_query_conditions_payload(
+                current_fields_by_name=current_fields_by_name,
+                query_conditions=patch.get("query_conditions"),
+            )
+            if query_condition_issues:
+                blocking_issues.extend(
+                    {
+                        **issue,
+                        "view_name": patch.get("name"),
+                    }
+                    for issue in query_condition_issues
+                )
         normalized_args = {
             "app_key": request.app_key,
             "upsert_views": upsert_views,
@@ -4465,6 +6187,7 @@ class AiBuilderFacade:
                 "fields": parsed["fields"],
                 "field_count": len(parsed["fields"]),
             },
+            "form_settings": _form_settings_from_schema(schema_result, parsed["fields"]),
             "layout": parsed["layout"],
             "flow_summary": {
                 "enabled": bool(state["workflow"]),
@@ -4688,6 +6411,7 @@ class AiBuilderFacade:
             schema_readback_delayed = True
         parsed = _parse_schema(schema_result)
         current_fields = parsed["fields"]
+        original_fields = deepcopy(current_fields)
         layout = parsed["layout"]
         existing_index = {field["field_id"]: index for index, field in enumerate(current_fields)}
         selector_map = _build_selector_map(current_fields)
@@ -4832,6 +6556,45 @@ class AiBuilderFacade:
                 suggested_next_call={"tool_name": "app_get_fields", "arguments": {"profile": profile, "app_key": target.app_key}},
             )
 
+        try:
+            data_display_selection = _collect_data_display_marker_selection(current_fields)
+        except _DataDisplayConfigError as error:
+            return _failed(
+                error.error_code,
+                error.message,
+                normalized_args=normalized_args,
+                details={"app_key": target.app_key, **error.details},
+                suggested_next_call={"tool_name": "app_get_fields", "arguments": {"profile": profile, "app_key": target.app_key}},
+            )
+
+        schema_write_requested = bool(
+            added
+            or updated
+            or removed
+            or normalized_code_block_fields
+            or data_display_selection.has_any
+            or bool(resolved.get("created"))
+        )
+        if schema_write_requested:
+            try:
+                _ensure_required_data_title_config(
+                    current_schema=schema_result,
+                    original_fields=original_fields,
+                    fields=current_fields,
+                    selection=data_display_selection,
+                )
+            except _DataDisplayConfigError as error:
+                return _failed(
+                    error.error_code,
+                    error.message,
+                    normalized_args=normalized_args,
+                    details={"app_key": target.app_key, **error.details},
+                    suggested_next_call={
+                        "tool_name": "app_get_fields",
+                        "arguments": {"profile": profile, "app_key": target.app_key},
+                    },
+                )
+
         relation_field_count = _count_relation_fields(current_fields)
         relation_limit_verified = relation_field_count <= 1
         relation_warnings = (
@@ -4851,7 +6614,7 @@ class AiBuilderFacade:
             else []
         )
 
-        if not added and not updated and not removed and not normalized_code_block_fields and not bool(resolved.get("created")):
+        if not added and not updated and not removed and not normalized_code_block_fields and not data_display_selection.has_any and not bool(resolved.get("created")):
             base_info = self.apps.app_get_base(profile=profile, app_key=target.app_key, include_raw=True).get("result") or {}
             tag_ids_after = _coerce_int_list(base_info.get("tagIds"))
             package_attached = None if package_tag_id is None else package_tag_id in tag_ids_after
@@ -4915,6 +6678,7 @@ class AiBuilderFacade:
                 question_relations=compiled_question_relations,
             )
         )
+        _apply_data_display_selection_to_payload(payload, fields=current_fields, selection=data_display_selection)
         payload["editVersionNo"] = self._resolve_form_edit_version(
             profile=profile,
             app_key=target.app_key,
@@ -5033,6 +6797,7 @@ class AiBuilderFacade:
                     question_relations=compiled_question_relations,
                 )
             )
+            _apply_data_display_selection_to_payload(rebound_payload, fields=rebound_fields, selection=data_display_selection)
             rebound_payload["editVersionNo"] = self._resolve_form_edit_version(
                 profile=profile,
                 app_key=target.app_key,
@@ -5106,6 +6871,13 @@ class AiBuilderFacade:
             verified = self.app_read(profile=profile, app_key=target.app_key, include_raw=False)
             verified_field_names = {field["name"] for field in verified["schema"]["fields"]}
             verification_ok = all(name in verified_field_names for name in added + updated) and all(name not in verified_field_names for name in removed)
+            data_display_verification = _verify_data_display_readback(
+                form_settings=verified.get("form_settings"),
+                selection=data_display_selection,
+            )
+            response["verification"].update(data_display_verification)
+            if data_display_verification.get("data_display_config_verified") is False:
+                verification_ok = False
             if relation_degraded_expectations:
                 relation_verified_fields = cast(list[dict[str, Any]], verified["schema"]["fields"])
                 try:
@@ -5706,13 +7478,18 @@ class AiBuilderFacade:
                 "message": "no view changes requested",
                 "normalized_args": normalized_args,
                 "missing_fields": [],
-                "allowed_values": {"view_types": [member.value for member in PublicViewType], "view.filter.operator": [member.value for member in ViewFilterOperator]},
+                "allowed_values": {"view_types": [member.value for member in PublicViewType], "view.filter.operator": [member.value for member in ViewFilterOperator], "view.associated_resources.limit_type": ["all", "select"]},
                 "details": {},
                 "request_id": None,
                 "suggested_next_call": None,
                 "noop": True,
                 "warnings": [],
-                "verification": {"views_verified": True, "view_filters_verified": True},
+                "verification": {
+                    "views_verified": True,
+                    "view_filters_verified": True,
+                    "view_query_conditions_verified": True,
+                    "view_associated_resources_verified": True,
+                },
                 "app_key": app_key,
                 "views_diff": {"created": [], "updated": [], "removed": []},
                 "verified": True,
@@ -5743,7 +7520,7 @@ class AiBuilderFacade:
                 api_error,
                 normalized_args=normalized_args,
                 details=_with_state_read_blocked_details({"app_key": app_key}, resource="views", error=api_error),
-                suggested_next_call={"tool_name": "app_get_views", "arguments": {"profile": profile, "app_key": app_key}},
+                suggested_next_call={"tool_name": "app_get", "arguments": {"profile": profile, "app_key": app_key}},
             ))
         existing_views = existing_views or []
         existing_by_key: dict[str, dict[str, Any]] = {}
@@ -5785,7 +7562,7 @@ class AiBuilderFacade:
                         api_error,
                         normalized_args=normalized_args,
                         details=_with_state_read_blocked_details({"app_key": app_key}, resource="custom_button", error=api_error),
-                        suggested_next_call={"tool_name": "app_custom_button_list", "arguments": {"profile": profile, "app_key": app_key}},
+                        suggested_next_call={"tool_name": "app_get", "arguments": {"profile": profile, "app_key": app_key}},
                     )
                 )
             valid_custom_button_ids = {
@@ -5813,6 +7590,22 @@ class AiBuilderFacade:
                 detail_result = detail.get("result")
                 if isinstance(detail_result, dict):
                     custom_button_details_by_id[button_id] = _normalize_custom_button_detail(detail_result)
+        requires_associated_resource_validation = any(patch.associated_resources is not None for patch in upsert_views)
+        associated_resources: list[dict[str, Any]] = []
+        if requires_associated_resource_validation:
+            try:
+                associated_resources = self._load_associated_resources_for_builder(profile=profile, app_key=app_key)
+            except (QingflowApiError, RuntimeError) as error:
+                api_error = _coerce_api_error(error)
+                return finalize(
+                    _failed_from_api_error(
+                        "ASSOCIATED_RESOURCES_READ_FAILED",
+                        api_error,
+                        normalized_args=normalized_args,
+                        details=_with_state_read_blocked_details({"app_key": app_key}, resource="associated_resources", error=api_error),
+                        suggested_next_call={"tool_name": "app_get", "arguments": {"profile": profile, "app_key": app_key}},
+                    )
+                )
         removed: list[str] = []
         view_results: list[dict[str, Any]] = []
         for name in remove_views:
@@ -5820,7 +7613,7 @@ class AiBuilderFacade:
             if len(matches) > 1:
                 return _failed(
                     "AMBIGUOUS_VIEW",
-                    "multiple views matched remove request; use app_get_views and resolve duplicates before removing by name",
+                    "multiple views matched remove request; use app_get and resolve duplicates before removing by name",
                     normalized_args=normalized_args,
                     details={
                         "app_key": app_key,
@@ -5830,7 +7623,7 @@ class AiBuilderFacade:
                             for view in matches
                         ],
                     },
-                    suggested_next_call={"tool_name": "app_get_views", "arguments": {"profile": profile, "app_key": app_key}},
+                    suggested_next_call={"tool_name": "app_get", "arguments": {"profile": profile, "app_key": app_key}},
                 )
             if len(matches) == 1:
                 key = _extract_view_key(matches[0])
@@ -5924,6 +7717,52 @@ class AiBuilderFacade:
                     allowed_values=first_issue.get("allowed_values") or {"view_types": [member.value for member in PublicViewType], "view.filter.operator": [member.value for member in ViewFilterOperator]},
                     suggested_next_call={"tool_name": "app_get_fields", "arguments": {"profile": profile, "app_key": app_key}},
                 )
+            query_condition_payload, expected_query_conditions, query_condition_issues = _build_view_query_conditions_payload(
+                current_fields_by_name=current_fields_by_name,
+                query_conditions=patch.query_conditions,
+            )
+            if query_condition_issues:
+                first_issue = query_condition_issues[0]
+                return _failed(
+                    str(first_issue.get("error_code") or "INVALID_QUERY_CONDITION_FIELD"),
+                    "view query conditions reference invalid fields or values",
+                    normalized_args=normalized_args,
+                    details={
+                        "app_key": app_key,
+                        "view_name": patch.name,
+                        **first_issue,
+                    },
+                    missing_fields=list(first_issue.get("missing_fields") or []),
+                    allowed_values={
+                        "view_types": [member.value for member in PublicViewType],
+                        "view.query_condition.supported_field_types": sorted(
+                            set(FIELD_TYPE_TO_QUESTION_TYPE) - QUERY_CONDITION_UNSUPPORTED_FIELD_TYPES
+                        ),
+                    },
+                    suggested_next_call={"tool_name": "app_get_fields", "arguments": {"profile": profile, "app_key": app_key}},
+                )
+            associated_resources_payload, expected_associated_resources, associated_resource_issues = _build_view_associated_resources_payload(
+                associated_resources=patch.associated_resources,
+                available_resources=associated_resources,
+            )
+            if associated_resource_issues:
+                first_issue = associated_resource_issues[0]
+                return _failed(
+                    str(first_issue.get("error_code") or "INVALID_ASSOCIATED_RESOURCE"),
+                    "view associated resources reference invalid ids or values",
+                    normalized_args=normalized_args,
+                    details={
+                        "app_key": app_key,
+                        "view_name": patch.name,
+                        **first_issue,
+                    },
+                    missing_fields=list(first_issue.get("missing_fields") or []),
+                    allowed_values={
+                        "view.associated_resources.limit_type": ["all", "select"],
+                        "view.associated_resources.available_associated_item_ids": sorted(_associated_resource_index(associated_resources)),
+                    },
+                    suggested_next_call={"tool_name": "app_get", "arguments": {"profile": profile, "app_key": app_key}},
+                )
             explicit_button_dtos: list[dict[str, Any]] | None = None
             expected_button_summary: list[dict[str, Any]] | None = None
             if patch.buttons is not None:
@@ -5945,7 +7784,7 @@ class AiBuilderFacade:
                         },
                         missing_fields=list(first_issue.get("missing_fields") or []),
                         allowed_values=first_issue.get("allowed_values") or {"view_types": [member.value for member in PublicViewType], "view.filter.operator": [member.value for member in ViewFilterOperator]},
-                        suggested_next_call={"tool_name": "app_custom_button_list", "arguments": {"profile": profile, "app_key": app_key}},
+                        suggested_next_call={"tool_name": "app_get", "arguments": {"profile": profile, "app_key": app_key}},
                     )
                 expected_button_summary = _normalize_expected_view_buttons_for_compare(
                     explicit_button_dtos or [],
@@ -5961,7 +7800,7 @@ class AiBuilderFacade:
                         f"view_key '{patch.view_key}' does not exist on this app",
                         normalized_args=normalized_args,
                         details={"app_key": app_key, "view_key": patch.view_key, "view_name": patch.name},
-                        suggested_next_call={"tool_name": "app_get_views", "arguments": {"profile": profile, "app_key": app_key}},
+                        suggested_next_call={"tool_name": "app_get", "arguments": {"profile": profile, "app_key": app_key}},
                     )
                 existing_key = patch.view_key
             else:
@@ -5979,7 +7818,7 @@ class AiBuilderFacade:
                                 for view in name_matches
                             ],
                         },
-                        suggested_next_call={"tool_name": "app_get_views", "arguments": {"profile": profile, "app_key": app_key}},
+                        suggested_next_call={"tool_name": "app_get", "arguments": {"profile": profile, "app_key": app_key}},
                     )
                 if len(name_matches) == 1:
                     matched_existing_view = name_matches[0]
@@ -5987,6 +7826,13 @@ class AiBuilderFacade:
             created_key: str | None = None
             system_view_list_type = _resolve_system_view_list_type(view_key=existing_key, view_name=patch.name) if existing_key else None
             operation_phase = "view_update" if existing_key else "view_create"
+            query_condition_payload_for_apply = deepcopy(query_condition_payload)
+            expected_query_conditions_for_verify = deepcopy(expected_query_conditions)
+            associated_resources_payload_for_apply = deepcopy(associated_resources_payload)
+            expected_associated_resources_for_verify = deepcopy(expected_associated_resources)
+            if not existing_key and query_condition_payload_for_apply is None:
+                query_condition_payload_for_apply = _empty_view_query_conditions_payload()
+                expected_query_conditions_for_verify = _normalize_view_query_conditions_for_compare(query_condition_payload_for_apply)
             try:
                 view_auth_override = (
                     self._compile_visibility_to_member_auth(profile=profile, visibility=patch.visibility)
@@ -6013,6 +7859,8 @@ class AiBuilderFacade:
                         current_fields_by_name=current_fields_by_name,
                         auth_override=view_auth_override,
                         explicit_button_dtos=explicit_button_dtos,
+                        query_condition_payload=query_condition_payload_for_apply,
+                        associated_resources_payload=associated_resources_payload_for_apply,
                     )
                     self.views.view_update(profile=profile, viewgraph_key=existing_key, payload=payload)
                     system_view_sync: dict[str, Any] | None = None
@@ -6062,6 +7910,8 @@ class AiBuilderFacade:
                                 "status": "updated",
                                 "expected_filters": deepcopy(translated_filters),
                                 "expected_buttons": deepcopy(expected_button_summary),
+                                "expected_query_conditions": deepcopy(expected_query_conditions_for_verify),
+                                "expected_associated_resources": deepcopy(expected_associated_resources_for_verify),
                                 "system_view_sync": system_view_sync,
                                 "apply_columns": deepcopy(apply_columns),
                             }
@@ -6082,6 +7932,8 @@ class AiBuilderFacade:
                             current_fields_by_name=current_fields_by_name,
                             auth_override=view_auth_override,
                             explicit_button_dtos=explicit_button_dtos,
+                            query_condition_payload=query_condition_payload_for_apply,
+                            associated_resources_payload=associated_resources_payload_for_apply,
                         )
                         self.views.view_update(profile=profile, viewgraph_key=created_key, payload=payload)
                     else:
@@ -6095,6 +7947,8 @@ class AiBuilderFacade:
                             current_fields_by_name=current_fields_by_name,
                             auth_override=view_auth_override,
                             explicit_button_dtos=explicit_button_dtos,
+                            query_condition_payload=query_condition_payload_for_apply,
+                            associated_resources_payload=associated_resources_payload_for_apply,
                         )
                         create_result = self.views.view_create(profile=profile, payload=payload)
                         raw_created = create_result.get("result")
@@ -6112,6 +7966,8 @@ class AiBuilderFacade:
                                 "status": "created",
                                 "expected_filters": deepcopy(translated_filters),
                                 "expected_buttons": deepcopy(expected_button_summary),
+                                "expected_query_conditions": deepcopy(expected_query_conditions_for_verify),
+                                "expected_associated_resources": deepcopy(expected_associated_resources_for_verify),
                             }
                         )
             except (QingflowApiError, RuntimeError) as error:
@@ -6142,6 +7998,8 @@ class AiBuilderFacade:
                                 current_fields_by_name=current_fields_by_name,
                                 auth_override=view_auth_override,
                                 explicit_button_dtos=fallback_button_dtos,
+                                query_condition_payload=query_condition_payload_for_apply,
+                                associated_resources_payload=associated_resources_payload_for_apply,
                             )
                             self.views.view_update(profile=profile, viewgraph_key=target_key, payload=fallback_payload)
                             system_view_sync: dict[str, Any] | None = None
@@ -6198,6 +8056,8 @@ class AiBuilderFacade:
                                         "fallback_applied": True,
                                         "expected_filters": deepcopy(translated_filters),
                                         "expected_buttons": deepcopy(expected_button_summary),
+                                        "expected_query_conditions": deepcopy(expected_query_conditions_for_verify),
+                                        "expected_associated_resources": deepcopy(expected_associated_resources_for_verify),
                                         "system_view_sync": system_view_sync,
                                         "apply_columns": deepcopy(apply_columns),
                                     }
@@ -6213,6 +8073,8 @@ class AiBuilderFacade:
                                         "fallback_applied": True,
                                         "expected_filters": deepcopy(translated_filters),
                                         "expected_buttons": deepcopy(expected_button_summary),
+                                        "expected_query_conditions": deepcopy(expected_query_conditions_for_verify),
+                                        "expected_associated_resources": deepcopy(expected_associated_resources_for_verify),
                                         "system_view_sync": system_view_sync,
                                         "apply_columns": deepcopy(apply_columns),
                                     }
@@ -6227,6 +8089,8 @@ class AiBuilderFacade:
                             current_fields_by_name=current_fields_by_name,
                             auth_override=view_auth_override,
                             explicit_button_dtos=explicit_button_dtos,
+                            query_condition_payload=query_condition_payload_for_apply,
+                            associated_resources_payload=associated_resources_payload_for_apply,
                         )
                         self.views.view_create(profile=profile, payload=fallback_payload)
                         created.append(patch.name)
@@ -6238,6 +8102,8 @@ class AiBuilderFacade:
                                 "status": "created",
                                 "fallback_applied": True,
                                 "expected_filters": deepcopy(translated_filters),
+                                "expected_query_conditions": deepcopy(expected_query_conditions_for_verify),
+                                "expected_associated_resources": deepcopy(expected_associated_resources_for_verify),
                             }
                         )
                         continue
@@ -6290,7 +8156,7 @@ class AiBuilderFacade:
                 api_error,
                 normalized_args=normalized_args,
                 details=_with_state_read_blocked_details({"app_key": app_key}, resource="views", error=api_error),
-                suggested_next_call={"tool_name": "app_get_views", "arguments": {"profile": profile, "app_key": app_key}},
+                suggested_next_call={"tool_name": "app_get", "arguments": {"profile": profile, "app_key": app_key}},
             ))
         verified_names = {
             _extract_view_name(item)
@@ -6313,6 +8179,10 @@ class AiBuilderFacade:
         verification_by_view: list[dict[str, Any]] = []
         filter_readback_pending = False
         filter_mismatches: list[dict[str, Any]] = []
+        query_condition_readback_pending = False
+        query_condition_mismatches: list[dict[str, Any]] = []
+        associated_resource_readback_pending = False
+        associated_resource_mismatches: list[dict[str, Any]] = []
         button_readback_pending = False
         button_mismatches: list[dict[str, Any]] = []
         custom_button_readback_pending = False
@@ -6340,6 +8210,8 @@ class AiBuilderFacade:
                 if isinstance(system_view_sync, dict):
                     verification_entry["system_view_sync"] = deepcopy(system_view_sync)
                 expected_filters = item.get("expected_filters") or []
+                expected_query_conditions = item.get("expected_query_conditions") if isinstance(item.get("expected_query_conditions"), dict) else None
+                expected_associated_resources = item.get("expected_associated_resources") if isinstance(item.get("expected_associated_resources"), dict) else None
                 expected_buttons = item.get("expected_buttons") if isinstance(item.get("expected_buttons"), list) else None
                 if expected_filters:
                     if verified_views_unavailable or not present_in_readback:
@@ -6396,6 +8268,108 @@ class AiBuilderFacade:
                                 "category": api_error.category,
                             }
                             filter_readback_pending = True
+                if expected_query_conditions is not None:
+                    if verified_views_unavailable or not present_in_readback:
+                        verification_entry["query_conditions_verified"] = None
+                        verification_entry["query_condition_readback_pending"] = True
+                        query_condition_readback_pending = True
+                    else:
+                        verification_key = item_view_key
+                        if not verification_key:
+                            matched_keys = verified_view_keys_by_name.get(name) or []
+                            if len(matched_keys) == 1:
+                                verification_key = matched_keys[0]
+                            else:
+                                verification_entry["query_conditions_verified"] = None
+                                verification_entry["query_condition_readback_pending"] = True
+                                verification_entry["readback_ambiguous"] = True
+                                verification_entry["matching_view_keys"] = matched_keys
+                                query_condition_readback_pending = True
+                                verification_by_view.append(verification_entry)
+                                continue
+                        try:
+                            config_response = self.views.view_get_config(profile=profile, viewgraph_key=verification_key)
+                            config_result = (config_response.get("result") or {}) if isinstance(config_response.get("result"), dict) else {}
+                            actual_query_conditions = _normalize_view_query_conditions_for_compare(config_result)
+                            query_conditions_verified = actual_query_conditions == expected_query_conditions
+                            verification_entry["query_conditions_verified"] = query_conditions_verified
+                            verification_entry["view_key"] = verification_key
+                            verification_entry["expected_query_conditions"] = deepcopy(expected_query_conditions)
+                            verification_entry["actual_query_conditions"] = actual_query_conditions
+                            if not query_conditions_verified:
+                                query_condition_mismatches.append(
+                                    {
+                                        "name": name,
+                                        "type": item.get("type"),
+                                        "expected_query_conditions": deepcopy(expected_query_conditions),
+                                        "actual_query_conditions": actual_query_conditions,
+                                    }
+                                )
+                        except (QingflowApiError, RuntimeError) as error:
+                            api_error = _coerce_api_error(error)
+                            verification_entry["query_conditions_verified"] = None
+                            verification_entry["query_condition_readback_pending"] = True
+                            verification_entry["request_id"] = api_error.request_id
+                            verification_entry["transport_error"] = {
+                                "http_status": api_error.http_status,
+                                "backend_code": api_error.backend_code,
+                                "category": api_error.category,
+                            }
+                            query_condition_readback_pending = True
+                if expected_associated_resources is not None:
+                    if verified_views_unavailable or not present_in_readback:
+                        verification_entry["associated_resources_verified"] = None
+                        verification_entry["associated_resource_readback_pending"] = True
+                        associated_resource_readback_pending = True
+                    else:
+                        verification_key = item_view_key
+                        if not verification_key:
+                            matched_keys = verified_view_keys_by_name.get(name) or []
+                            if len(matched_keys) == 1:
+                                verification_key = matched_keys[0]
+                            else:
+                                verification_entry["associated_resources_verified"] = None
+                                verification_entry["associated_resource_readback_pending"] = True
+                                verification_entry["readback_ambiguous"] = True
+                                verification_entry["matching_view_keys"] = matched_keys
+                                associated_resource_readback_pending = True
+                                verification_by_view.append(verification_entry)
+                                continue
+                        try:
+                            config_response = self.views.view_get_config(profile=profile, viewgraph_key=verification_key)
+                            config_result = (config_response.get("result") or {}) if isinstance(config_response.get("result"), dict) else {}
+                            actual_associated_resources = _extract_view_associated_resources_config(
+                                config_result,
+                                available_resources=associated_resources,
+                            )
+                            associated_resources_verified = _associated_resources_config_matches(
+                                expected_associated_resources,
+                                actual_associated_resources,
+                            )
+                            verification_entry["associated_resources_verified"] = associated_resources_verified
+                            verification_entry["view_key"] = verification_key
+                            verification_entry["expected_associated_resources"] = deepcopy(expected_associated_resources)
+                            verification_entry["actual_associated_resources"] = actual_associated_resources
+                            if not associated_resources_verified:
+                                associated_resource_mismatches.append(
+                                    {
+                                        "name": name,
+                                        "type": item.get("type"),
+                                        "expected_associated_resources": deepcopy(expected_associated_resources),
+                                        "actual_associated_resources": actual_associated_resources,
+                                    }
+                                )
+                        except (QingflowApiError, RuntimeError) as error:
+                            api_error = _coerce_api_error(error)
+                            verification_entry["associated_resources_verified"] = None
+                            verification_entry["associated_resource_readback_pending"] = True
+                            verification_entry["request_id"] = api_error.request_id
+                            verification_entry["transport_error"] = {
+                                "http_status": api_error.http_status,
+                                "backend_code": api_error.backend_code,
+                                "category": api_error.category,
+                            }
+                            associated_resource_readback_pending = True
                 if expected_buttons is not None:
                     if verified_views_unavailable or not present_in_readback:
                         verification_entry["buttons_verified"] = None
@@ -6486,6 +8460,8 @@ class AiBuilderFacade:
             and all(name not in verified_names for name in removed)
         )
         view_filters_verified = verified and not filter_readback_pending and not filter_mismatches
+        view_query_conditions_verified = verified and not query_condition_readback_pending and not query_condition_mismatches
+        view_associated_resources_verified = verified and not associated_resource_readback_pending and not associated_resource_mismatches
         view_buttons_verified = verified and not button_readback_pending and not button_mismatches
         noop = not created and not updated and not removed
         if failed_views:
@@ -6502,6 +8478,8 @@ class AiBuilderFacade:
                 "details": {
                     "per_view_results": view_results,
                     "filter_mismatches": filter_mismatches,
+                    "query_condition_mismatches": query_condition_mismatches,
+                    "associated_resource_mismatches": associated_resource_mismatches,
                     "button_mismatches": button_mismatches,
                     **(
                         {"custom_button_readback_pending": deepcopy(custom_button_readback_pending_entries)}
@@ -6510,7 +8488,7 @@ class AiBuilderFacade:
                     ),
                 },
                 "request_id": first_failure.get("request_id"),
-                "suggested_next_call": {"tool_name": "app_get_views", "arguments": {"profile": profile, "app_key": app_key}},
+                "suggested_next_call": {"tool_name": "app_get", "arguments": {"profile": profile, "app_key": app_key}},
                 "backend_code": first_failure.get("backend_code"),
                 "http_status": first_failure.get("http_status"),
                 "noop": noop,
@@ -6520,6 +8498,16 @@ class AiBuilderFacade:
                         if (filter_readback_pending or filter_mismatches)
                         else []
                     )
+                    + (
+                        [_warning("VIEW_QUERY_CONDITIONS_UNVERIFIED", "view definitions may exist, but query condition behavior is not fully verified")]
+                        if (query_condition_readback_pending or query_condition_mismatches)
+                        else []
+                    )
+                    + (
+                        [_warning("VIEW_ASSOCIATED_RESOURCES_UNVERIFIED", "view definitions may exist, but associated resource visibility is not fully verified")]
+                        if (associated_resource_readback_pending or associated_resource_mismatches)
+                        else []
+                    )
                     + (
                         [_warning("VIEW_BUTTONS_UNVERIFIED", "view definitions may exist, but saved button behavior is not fully verified")]
                         if (button_readback_pending or button_mismatches)
@@ -6534,6 +8522,8 @@ class AiBuilderFacade:
                 "verification": {
                     "views_verified": verified,
                     "view_filters_verified": view_filters_verified,
+                    "view_query_conditions_verified": view_query_conditions_verified,
+                    "view_associated_resources_verified": view_associated_resources_verified,
                     "view_buttons_verified": view_buttons_verified,
                     "views_read_unavailable": verified_views_unavailable,
                     "by_view": verification_by_view,
@@ -6542,12 +8532,16 @@ class AiBuilderFacade:
                 },
                 "app_key": app_key,
                 "views_diff": {"created": created, "updated": updated, "removed": removed, "failed": failed_views},
-                "verified": verified and view_filters_verified and view_buttons_verified,
+                "verified": verified and view_filters_verified and view_query_conditions_verified and view_associated_resources_verified and view_buttons_verified,
             }
             return finalize(self._append_publish_result(profile=profile, app_key=app_key, publish=publish, response=response))
         warnings: list[dict[str, Any]] = []
         if filter_readback_pending or filter_mismatches:
             warnings.append(_warning("VIEW_FILTERS_UNVERIFIED", "view definitions were applied, but saved filter behavior is not fully verified"))
+        if query_condition_readback_pending or query_condition_mismatches:
+            warnings.append(_warning("VIEW_QUERY_CONDITIONS_UNVERIFIED", "view definitions were applied, but query condition behavior is not fully verified"))
+        if associated_resource_readback_pending or associated_resource_mismatches:
+            warnings.append(_warning("VIEW_ASSOCIATED_RESOURCES_UNVERIFIED", "view definitions were applied, but associated resource visibility is not fully verified"))
         if button_readback_pending or button_mismatches:
             warnings.append(_warning("VIEW_BUTTONS_UNVERIFIED", "view definitions were applied, but saved button behavior is not fully verified"))
         if custom_button_readback_pending:
@@ -6557,24 +8551,31 @@ class AiBuilderFacade:
                     "system buttons verified, but draft custom button bindings are not fully visible through view readback yet",
                 )
             )
+        all_verified = verified and view_filters_verified and view_query_conditions_verified and view_associated_resources_verified and view_buttons_verified
         response = {
-            "status": "success" if verified and view_filters_verified and view_buttons_verified else "partial_success",
-            "error_code": None if verified and view_filters_verified and view_buttons_verified else ("VIEW_BUTTON_READBACK_MISMATCH" if button_mismatches else "VIEW_FILTER_READBACK_MISMATCH" if filter_mismatches else "VIEWS_READBACK_PENDING"),
-            "recoverable": not (verified and view_filters_verified and view_buttons_verified),
+            "status": "success" if all_verified else "partial_success",
+            "error_code": None if all_verified else ("VIEW_BUTTON_READBACK_MISMATCH" if button_mismatches else "VIEW_ASSOCIATED_RESOURCE_READBACK_MISMATCH" if associated_resource_mismatches else "VIEW_QUERY_CONDITION_READBACK_MISMATCH" if query_condition_mismatches else "VIEW_FILTER_READBACK_MISMATCH" if filter_mismatches else "VIEWS_READBACK_PENDING"),
+            "recoverable": not all_verified,
             "message": (
                 "applied view patch"
-                if verified and view_filters_verified and view_buttons_verified
+                if all_verified
                 else "applied view patch; buttons did not fully verify"
                 if button_mismatches
+                else "applied view patch; associated resources did not fully verify"
+                if associated_resource_mismatches
+                else "applied view patch; query conditions did not fully verify"
+                if query_condition_mismatches
                 else "applied view patch; filters did not fully verify"
                 if filter_mismatches
                 else "applied view patch; views readback pending"
             ),
             "normalized_args": normalized_args,
             "missing_fields": [],
-            "allowed_values": {"view_types": [member.value for member in PublicViewType], "view.filter.operator": [member.value for member in ViewFilterOperator]},
+            "allowed_values": {"view_types": [member.value for member in PublicViewType], "view.filter.operator": [member.value for member in ViewFilterOperator], "view.associated_resources.limit_type": ["all", "select"]},
             "details": {
                 **({"filter_mismatches": filter_mismatches} if filter_mismatches else {}),
+                **({"query_condition_mismatches": query_condition_mismatches} if query_condition_mismatches else {}),
+                **({"associated_resource_mismatches": associated_resource_mismatches} if associated_resource_mismatches else {}),
                 **({"button_mismatches": button_mismatches} if button_mismatches else {}),
                 **(
                     {"custom_button_readback_pending": deepcopy(custom_button_readback_pending_entries)}
@@ -6583,15 +8584,19 @@ class AiBuilderFacade:
                 ),
             },
             "request_id": None,
-            "suggested_next_call": None if verified and view_filters_verified and view_buttons_verified else {"tool_name": "app_get_views", "arguments": {"profile": profile, "app_key": app_key}},
+            "suggested_next_call": None if all_verified else {"tool_name": "app_get", "arguments": {"profile": profile, "app_key": app_key}},
             "noop": noop,
             "warnings": warnings,
             "verification": {
                 "views_verified": verified,
                 "view_filters_verified": view_filters_verified,
+                "view_query_conditions_verified": view_query_conditions_verified,
+                "view_associated_resources_verified": view_associated_resources_verified,
                 "view_buttons_verified": view_buttons_verified,
                 "views_read_unavailable": verified_views_unavailable,
                 "filter_readback_pending": filter_readback_pending,
+                "query_condition_readback_pending": query_condition_readback_pending,
+                "associated_resource_readback_pending": associated_resource_readback_pending,
                 "button_readback_pending": button_readback_pending,
                 "custom_button_readback_pending": custom_button_readback_pending,
                 "custom_button_readback_pending_entries": deepcopy(custom_button_readback_pending_entries),
@@ -6599,7 +8604,7 @@ class AiBuilderFacade:
             },
             "app_key": app_key,
             "views_diff": {"created": created, "updated": updated, "removed": removed, "failed": []},
-            "verified": verified and view_filters_verified and view_buttons_verified,
+            "verified": all_verified,
         }
         return finalize(self._append_publish_result(profile=profile, app_key=app_key, publish=publish, response=response))
 
@@ -7369,10 +9374,11 @@ class AiBuilderFacade:
             "live_result": live_result,
         })
 
-    def _publish_current_edit_version(self, *, profile: str, app_key: str) -> JSONObject:
+    def _publish_current_edit_version(self, *, profile: str, app_key: str, edit_version_no: int | None = None) -> JSONObject:
         normalized_args = {"app_key": app_key}
-        version_result = self.apps.app_get_edit_version_no(profile=profile, app_key=app_key).get("result") or {}
-        edit_version_no = _coerce_positive_int(version_result.get("editVersionNo") or version_result.get("versionNo")) or 1
+        if edit_version_no is None:
+            version_result = self.apps.app_get_edit_version_no(profile=profile, app_key=app_key).get("result") or {}
+            edit_version_no = _coerce_positive_int(version_result.get("editVersionNo") or version_result.get("versionNo")) or 1
         try:
             self.apps.app_publish(profile=profile, app_key=app_key, payload={"editVersionNo": edit_version_no})
             self.apps.app_edit_finished(profile=profile, app_key=app_key, payload={"editVersionNo": edit_version_no})
@@ -7433,7 +9439,7 @@ class AiBuilderFacade:
         edit_version_no = _coerce_positive_int(version_result.get("editVersionNo") or version_result.get("versionNo")) or 1
         return edit_version_no, None
 
-    def _append_publish_result(self, *, profile: str, app_key: str, publish: bool, response: JSONObject) -> JSONObject:
+    def _append_publish_result(self, *, profile: str, app_key: str, publish: bool, response: JSONObject, edit_version_no: int | None = None) -> JSONObject:
         verification = response.get("verification")
         if not isinstance(verification, dict):
             verification = {}
@@ -7453,7 +9459,7 @@ class AiBuilderFacade:
             response["published"] = False
             verification["published"] = False
             return response
-        publish_result = self._publish_current_edit_version(profile=profile, app_key=app_key)
+        publish_result = self._publish_current_edit_version(profile=profile, app_key=app_key, edit_version_no=edit_version_no)
         response["publish_result"] = publish_result
         response["published"] = bool(publish_result.get("published"))
         verification["published"] = bool(publish_result.get("published"))
@@ -8047,7 +10053,11 @@ def _extract_custom_button_id(value: Any) -> int | None:
     return _coerce_positive_int(value)
 
 
-def _serialize_custom_button_payload(payload: CustomButtonPatch) -> dict[str, Any]:
+def _serialize_custom_button_payload(
+    payload: CustomButtonPatch,
+    *,
+    add_data_config_override: dict[str, Any] | None = None,
+) -> dict[str, Any]:
     data = payload.model_dump(mode="json", exclude_none=True)
     serialized: dict[str, Any] = {
         "buttonText": data["button_text"],
@@ -8058,7 +10068,7 @@ def _serialize_custom_button_payload(payload: CustomButtonPatch) -> dict[str, An
     }
     if str(data.get("trigger_link_url") or "").strip():
         serialized["triggerLinkUrl"] = data["trigger_link_url"]
-    trigger_add_data_config = data.get("trigger_add_data_config")
+    trigger_add_data_config = add_data_config_override if add_data_config_override is not None else data.get("trigger_add_data_config")
     if isinstance(trigger_add_data_config, dict):
         serialized["triggerAddDataConfig"] = _serialize_custom_button_add_data_config(trigger_add_data_config)
     else:
@@ -8140,6 +10150,274 @@ def _serialize_custom_button_match_rule(value: dict[str, Any]) -> dict[str, Any]
     return {key: deepcopy(item) for key, item in serialized.items() if item is not None}
 
 
+def _custom_button_add_data_config_has_semantic_inputs(value: dict[str, Any]) -> bool:
+    return bool(value.get("field_mappings") or value.get("fieldMappings") or value.get("default_values") or value.get("defaultValues"))
+
+
+def _custom_button_selector_payload(selector: Any) -> dict[str, Any]:
+    if isinstance(selector, dict):
+        payload = dict(selector)
+        if "title" in payload and "name" not in payload:
+            payload["name"] = payload.pop("title")
+        if "label" in payload and "name" not in payload:
+            payload["name"] = payload.pop("label")
+        if "fieldId" in payload and "field_id" not in payload:
+            payload["field_id"] = payload.pop("fieldId")
+        if "queId" in payload and "que_id" not in payload:
+            payload["que_id"] = payload.pop("queId")
+        return payload
+    if isinstance(selector, int):
+        return {"que_id": selector}
+    raw = str(selector or "").strip()
+    if not raw:
+        return {}
+    if raw.isdigit():
+        return {"que_id": int(raw)}
+    return {"name": raw}
+
+
+def _resolve_custom_button_schema_field(
+    *,
+    fields: list[dict[str, Any]],
+    selector: Any,
+    reason_path: str,
+    role: str,
+) -> tuple[dict[str, Any] | None, dict[str, Any] | None]:
+    selector_payload = _custom_button_selector_payload(selector)
+    if not selector_payload:
+        return None, {
+            "error_code": "CUSTOM_BUTTON_MAPPING_FIELD_NOT_FOUND",
+            "reason_path": reason_path,
+            "message": f"{role} field selector is empty",
+            "next_action": "pass a field title or {'field_id': ...}",
+        }
+    matched: list[dict[str, Any]] = []
+    field_id = selector_payload.get("field_id")
+    que_id = _coerce_nonnegative_int(selector_payload.get("que_id"))
+    name = str(selector_payload.get("name") or "").strip()
+    if field_id is not None:
+        field_id_text = str(field_id).strip()
+        matched = [
+            field
+            for field in fields
+            if str(field.get("field_id") or "").strip() == field_id_text
+            or (_coerce_nonnegative_int(field_id_text) is not None and _coerce_nonnegative_int(field.get("que_id")) == _coerce_nonnegative_int(field_id_text))
+        ]
+    elif que_id is not None:
+        matched = [field for field in fields if _coerce_nonnegative_int(field.get("que_id")) == que_id]
+    elif name:
+        matched = [field for field in fields if str(field.get("name") or "").strip() == name]
+    if len(matched) == 1:
+        return matched[0], None
+    return None, {
+        "error_code": "CUSTOM_BUTTON_MAPPING_FIELD_NOT_FOUND" if not matched else "CUSTOM_BUTTON_MAPPING_FIELD_AMBIGUOUS",
+        "reason_path": reason_path,
+        "selector": selector,
+        "message": f"{role} field selector did not resolve to exactly one field",
+        "candidates": [
+            {"field_id": item.get("field_id"), "que_id": item.get("que_id"), "title": item.get("name"), "type": item.get("type")}
+            for item in matched[:10]
+        ],
+        "next_action": "call app_get_fields and retry with an exact field title or field_id",
+    }
+
+
+def _custom_button_mapping_type_issue(
+    *,
+    source_field: dict[str, Any],
+    target_field: dict[str, Any],
+    reason_path: str,
+) -> dict[str, Any] | None:
+    source_type = str(source_field.get("type") or "")
+    target_type = str(target_field.get("type") or "")
+    compatible_groups = [
+        {FieldType.text.value, FieldType.long_text.value, FieldType.phone.value, FieldType.email.value},
+        {FieldType.number.value, FieldType.amount.value},
+        {FieldType.date.value, FieldType.datetime.value},
+        {FieldType.single_select.value, FieldType.multi_select.value, FieldType.boolean.value},
+    ]
+    compatible = source_type == target_type or any(source_type in group and target_type in group for group in compatible_groups)
+    if source_type == FieldType.relation.value or target_type == FieldType.relation.value:
+        compatible = source_type == target_type
+    if compatible:
+        return None
+    return {
+        "error_code": "CUSTOM_BUTTON_MAPPING_TYPE_MISMATCH",
+        "reason_path": reason_path,
+        "source_field": {"title": source_field.get("name"), "field_id": source_field.get("field_id"), "type": source_type},
+        "target_field": {"title": target_field.get("name"), "field_id": target_field.get("field_id"), "type": target_type},
+        "message": "source and target fields have incompatible types for addData copy mapping",
+        "next_action": "choose fields with the same type family or use default_values for static text",
+    }
+
+
+def _custom_button_question_ref(field: dict[str, Any]) -> dict[str, Any]:
+    return {
+        "que_id": _coerce_nonnegative_int(field.get("que_id")),
+        "que_title": str(field.get("name") or ""),
+        "que_type": _coerce_nonnegative_int(field.get("que_type")),
+    }
+
+
+def _custom_button_field_mapping_rule(*, source_field: dict[str, Any], target_field: dict[str, Any]) -> dict[str, Any]:
+    source_que_id = _coerce_nonnegative_int(source_field.get("que_id"))
+    return {
+        **_custom_button_question_ref(target_field),
+        "match_type": MATCH_TYPE_QUESTION,
+        "judge_type": JUDGE_EQUAL,
+        "judge_values": [str(source_que_id)] if source_que_id is not None else [],
+        "judge_que_id": source_que_id,
+        "judge_que_type": _coerce_nonnegative_int(source_field.get("que_type")),
+        "judge_que_detail": _custom_button_question_ref(source_field),
+    }
+
+
+def _custom_button_default_value_rule(*, target_field: dict[str, Any], value_details: list[dict[str, Any]]) -> dict[str, Any]:
+    return {
+        **_custom_button_question_ref(target_field),
+        "match_type": MATCH_TYPE_ACCURACY,
+        "judge_type": JUDGE_EQUAL,
+        "judge_values": [
+            str(detail.get("id") if detail.get("id") is not None else detail.get("value", ""))
+            for detail in value_details
+        ],
+        "judge_value_details": value_details,
+    }
+
+
+def _resolve_custom_button_option_detail(*, target_field: dict[str, Any], value: Any) -> dict[str, Any] | None:
+    option_details = [item for item in target_field.get("option_details") or [] if isinstance(item, dict)]
+    value_id = _coerce_positive_int(value.get("id", value.get("opt_id", value.get("optId"))) if isinstance(value, dict) else value)
+    value_text = str(value.get("value", value.get("name", "")) if isinstance(value, dict) else value or "").strip()
+    for item in option_details:
+        opt_id = _coerce_positive_int(item.get("id"))
+        opt_value = str(item.get("value") or "").strip()
+        if (value_id is not None and opt_id == value_id) or (value_text and opt_value == value_text):
+            return {"id": opt_id, "value": opt_value}
+    return None
+
+
+def _custom_button_default_value_issue(
+    *,
+    target_field: dict[str, Any],
+    reason_path: str,
+    value: Any,
+    message: str,
+    allowed_values: dict[str, Any] | None = None,
+    next_action: str | None = None,
+) -> dict[str, Any]:
+    return {
+        "error_code": "CUSTOM_BUTTON_DEFAULT_VALUE_UNSUPPORTED",
+        "reason_path": reason_path,
+        "target_field": {
+            "title": target_field.get("name"),
+            "field_id": target_field.get("field_id"),
+            "que_id": target_field.get("que_id"),
+            "type": target_field.get("type"),
+        },
+        "received_value": deepcopy(value),
+        "allowed_values": allowed_values or {},
+        "message": message,
+        "next_action": next_action or "retry with a literal value supported by the target field type",
+    }
+
+
+def _stringify_custom_button_default_value(value: Any) -> str:
+    if isinstance(value, bool):
+        return "true" if value else "false"
+    if isinstance(value, (int, float)):
+        return str(value)
+    if isinstance(value, dict):
+        if "value" in value:
+            return str(value.get("value") or "")
+        if "name" in value:
+            return str(value.get("name") or "")
+    return str(value or "")
+
+
+def _view_button_config_type_from_placement(placement: PublicButtonPlacement) -> PublicViewButtonConfigType:
+    if placement == PublicButtonPlacement.header:
+        return PublicViewButtonConfigType.top
+    if placement == PublicButtonPlacement.list:
+        return PublicViewButtonConfigType.list
+    return PublicViewButtonConfigType.detail
+
+
+def _custom_button_view_binding_to_view_button_patch(
+    *,
+    binding: CustomButtonViewButtonBindingPatch,
+    button_id: int,
+) -> ViewButtonBindingPatch:
+    config_type = _view_button_config_type_from_placement(binding.placement)
+    being_main = bool(binding.primary) if config_type == PublicViewButtonConfigType.detail else True
+    return ViewButtonBindingPatch.model_validate(
+        {
+            "button_type": PublicViewButtonType.custom.value,
+            "config_type": config_type.value,
+            "button_id": button_id,
+            "being_main": being_main,
+            "button_limit": binding.button_limit,
+            "button_formula": binding.button_formula,
+            "button_formula_type": binding.button_formula_type,
+            "print_tpls": binding.print_tpls,
+        }
+    )
+
+
+def _resolve_custom_button_view_button_ref(
+    *,
+    button_ref: Any,
+    client_key_map: dict[str, int],
+    button_inventory: dict[int, dict[str, Any]],
+    valid_custom_button_ids: set[int],
+    reason_path: str,
+) -> tuple[int | None, dict[str, Any] | None]:
+    explicit_id = _coerce_positive_int(button_ref)
+    if explicit_id is not None:
+        if explicit_id in valid_custom_button_ids:
+            return explicit_id, None
+        return None, {
+            "error_code": "UNKNOWN_CUSTOM_BUTTON",
+            "reason_path": reason_path,
+            "button_ref": button_ref,
+            "message": "button_ref id does not exist in the current app draft or was removed in this apply",
+            "next_action": "call app_get and use custom_buttons[].button_id, or use a client_key from upsert_buttons",
+        }
+    ref_text = str(button_ref or "").strip()
+    if ref_text in client_key_map:
+        return client_key_map[ref_text], None
+    text_matches = [
+        button_id
+        for button_id, item in button_inventory.items()
+        if str(item.get("button_text") or "").strip() == ref_text
+        and button_id in valid_custom_button_ids
+    ]
+    if len(text_matches) == 1:
+        return text_matches[0], None
+    return None, {
+        "error_code": "UNKNOWN_CUSTOM_BUTTON_REF" if not text_matches else "AMBIGUOUS_CUSTOM_BUTTON_REF",
+        "reason_path": reason_path,
+        "button_ref": button_ref,
+        "candidate_button_ids": text_matches[:10],
+        "message": "button_ref must be a button_id, a same-call client_key, or an exact unique existing button_text",
+        "next_action": "use upsert_buttons[].client_key for same-call placement or pass a numeric button_id",
+    }
+
+
+def _merge_custom_button_view_button_dtos(
+    *,
+    existing_dtos: list[dict[str, Any]],
+    new_dtos: list[dict[str, Any]],
+) -> list[dict[str, Any]]:
+    def key(item: dict[str, Any]) -> tuple[int | None, str]:
+        return (_coerce_positive_int(item.get("buttonId")), str(item.get("configType") or "").strip().upper())
+
+    replacement_keys = {key(item) for item in new_dtos}
+    merged = [deepcopy(item) for item in existing_dtos if key(item) not in replacement_keys]
+    merged.extend(deepcopy(item) for item in new_dtos)
+    return merged
+
+
 def _normalize_custom_button_summary(item: dict[str, Any]) -> dict[str, Any]:
     normalized = {
         "button_id": _coerce_positive_int(item.get("button_id") or item.get("buttonId") or item.get("id")),
@@ -8613,6 +10891,8 @@ def _normalize_view_collection(values: Any) -> list[dict[str, Any]]:
             normalized.append(item)
         return normalized
     if isinstance(values, dict):
+        if _extract_view_key(values):
+            return [values]
         for key in ("list", "viewList", "views", "result"):
             candidate = values.get(key)
             if isinstance(candidate, list):
@@ -8979,6 +11259,16 @@ def _normalize_backend_chart_type(value: Any) -> str:
     return by_code.get(raw, raw.lower())
 
 
+def _public_chart_type_from_backend(value: Any) -> str:
+    normalized = _normalize_backend_chart_type(value)
+    return {
+        "indicator": PublicChartType.target.value,
+        "summary": PublicChartType.target.value,
+        "columnar": PublicChartType.bar.value,
+        "detail": PublicChartType.table.value,
+    }.get(normalized, normalized)
+
+
 def _find_charts_by_name(items: Any, *, chart_name: str, chart_type: str | None = None) -> list[dict[str, Any]]:
     target_name = str(chart_name or "").strip()
     target_type = _normalize_backend_chart_type(chart_type)
@@ -10798,63 +13088,259 @@ def _compact_public_field_read(*, field: dict[str, Any], layout: dict[str, Any],
     return payload
 
 
-def _build_selector_map(fields: list[dict[str, Any]]) -> dict[str, int]:
-    mapping: dict[str, int] = {}
-    for index, field in enumerate(fields):
-        field_id = str(field.get("field_id") or "")
-        field_name = str(field.get("name") or "")
-        que_id = _coerce_nonnegative_int(field.get("que_id"))
-        if field_id:
-            mapping[f"field_id:{field_id}"] = index
-        if field_name:
-            mapping[f"name:{field_name}"] = index
-        if que_id is not None:
-            mapping[f"que_id:{que_id}"] = index
-    return mapping
+def _field_public_ref(field: dict[str, Any] | None, *, fallback_que_id: int | None = None) -> dict[str, Any] | None:
+    if not isinstance(field, dict):
+        if fallback_que_id is None:
+            return None
+        return {"field_id": None, "que_id": fallback_que_id, "name": None, "type": None}
+    return {
+        "field_id": field.get("field_id"),
+        "que_id": _coerce_any_int(field.get("que_id")),
+        "name": field.get("name"),
+        "type": field.get("type"),
+    }
 
 
-def _resolve_selector(selector_map: dict[str, int], selector: FieldSelector) -> int | None:
-    if selector.field_id:
-        value = selector_map.get(f"field_id:{selector.field_id}")
-        if value is not None:
-            return value
-    if selector.que_id is not None:
-        value = selector_map.get(f"que_id:{selector.que_id}")
-        if value is not None:
-            return value
-    if selector.name:
-        value = selector_map.get(f"name:{selector.name}")
-        if value is not None:
-            return value
+def _find_top_level_field_by_que_id(fields: list[dict[str, Any]], que_id: int | None) -> dict[str, Any] | None:
+    if que_id is None:
+        return None
+    for field in fields:
+        if _coerce_any_int(field.get("que_id")) == que_id:
+            return field
     return None
 
 
-def _resolve_remove_selector(fields: list[dict[str, Any]], patch: FieldRemovePatch) -> int | None:
-    selector = FieldSelector(field_id=patch.field_id, que_id=patch.que_id, name=patch.name)
-    return _resolve_selector(_build_selector_map(fields), selector)
+def _find_top_level_field_by_name(fields: list[dict[str, Any]], field_name: str | None) -> dict[str, Any] | None:
+    if not field_name:
+        return None
+    for field in fields:
+        if str(field.get("name") or "") == field_name:
+            return field
+    return None
 
 
-def _field_patch_to_internal(patch: FieldPatch) -> dict[str, Any]:
-    field_id = _slugify(patch.name, default=f"field_{uuid4().hex[:8]}")
-    remote_lookup_config = patch.remote_lookup_config.model_dump(mode="json", exclude_none=True) if patch.remote_lookup_config is not None else None
-    q_linker_binding = patch.q_linker_binding.model_dump(mode="json", exclude_none=True) if patch.q_linker_binding is not None else None
-    code_block_config = patch.code_block_config.model_dump(mode="json", exclude_none=True) if patch.code_block_config is not None else None
-    code_block_binding = patch.code_block_binding.model_dump(mode="json", exclude_none=True) if patch.code_block_binding is not None else None
+def _form_settings_from_schema(schema: dict[str, Any], fields: list[dict[str, Any]]) -> dict[str, Any]:
+    data_title_que_id = _coerce_any_int(schema.get("dataTitleQueId", schema.get("data_title_que_id")))
+    data_cover_que_id = _coerce_any_int(schema.get("dataCoverQueId", schema.get("data_cover_que_id")))
     return {
-        "field_id": field_id,
-        "name": patch.name,
-        "type": patch.type.value,
-        "required": patch.required,
-        "description": patch.description,
-        "options": list(patch.options),
-        "target_app_key": patch.target_app_key,
-        "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,
+        "data_title_field": _field_public_ref(
+            _find_top_level_field_by_que_id(fields, data_title_que_id),
+            fallback_que_id=data_title_que_id,
+        ),
+        "data_cover_field": _field_public_ref(
+            _find_top_level_field_by_que_id(fields, data_cover_que_id),
+            fallback_que_id=data_cover_que_id,
+        ),
+    }
+
+
+def _collect_data_display_marker_selection(fields: list[dict[str, Any]]) -> _DataDisplayMarkerSelection:
+    title_fields: list[dict[str, Any]] = []
+    cover_fields: list[dict[str, Any]] = []
+
+    def visit(field: dict[str, Any], *, parent_name: str | None = None) -> None:
+        name = str(field.get("name") or "").strip()
+        field_type = str(field.get("type") or "")
+        if bool(field.get("as_data_title")):
+            if parent_name or field_type == FieldType.subtable.value:
+                raise _DataDisplayConfigError(
+                    "INVALID_DATA_TITLE_FIELD",
+                    "data title must be a top-level non-subtable field",
+                    details={"field_name": name, "parent_field_name": parent_name, "field_type": field_type},
+                )
+            title_fields.append(field)
+        if bool(field.get("as_data_cover")):
+            if parent_name:
+                raise _DataDisplayConfigError(
+                    "INVALID_DATA_COVER_FIELD",
+                    "data cover must be a top-level attachment field",
+                    details={"field_name": name, "parent_field_name": parent_name, "field_type": field_type},
+                )
+            if field_type != FieldType.attachment.value:
+                raise _DataDisplayConfigError(
+                    "INVALID_DATA_COVER_FIELD",
+                    "data cover must be a top-level attachment field",
+                    details={"field_name": name, "field_type": field_type, "expected_type": FieldType.attachment.value},
+                )
+            cover_fields.append(field)
+        for subfield in cast(list[dict[str, Any]], field.get("subfields") or []):
+            if isinstance(subfield, dict):
+                visit(subfield, parent_name=name)
+
+    for field in fields:
+        if isinstance(field, dict):
+            visit(field)
+
+    if len(title_fields) > 1:
+        raise _DataDisplayConfigError(
+            "MULTIPLE_DATA_TITLE_FIELDS",
+            "only one field can be marked as data title",
+            details={"fields": [_field_public_ref(field) for field in title_fields]},
+        )
+    if len(cover_fields) > 1:
+        raise _DataDisplayConfigError(
+            "MULTIPLE_DATA_COVER_FIELDS",
+            "only one field can be marked as data cover",
+            details={"fields": [_field_public_ref(field) for field in cover_fields]},
+        )
+    return _DataDisplayMarkerSelection(
+        data_title_field_name=str(title_fields[0].get("name") or "") if title_fields else None,
+        data_cover_field_name=str(cover_fields[0].get("name") or "") if cover_fields else None,
+    )
+
+
+def _ensure_required_data_title_config(
+    *,
+    current_schema: dict[str, Any],
+    original_fields: list[dict[str, Any]],
+    fields: list[dict[str, Any]],
+    selection: _DataDisplayMarkerSelection,
+) -> None:
+    if selection.data_title_field_name:
+        return
+    current_title_que_id = _coerce_any_int(
+        current_schema.get("dataTitleQueId", current_schema.get("data_title_que_id"))
+    )
+    if _find_top_level_field_by_que_id(fields, current_title_que_id) is not None:
+        return
+    if current_title_que_id is None and original_fields:
+        # Older or mocked schema payloads may omit the form-level title config even
+        # though the app already exists with fields. Avoid blocking unrelated edits
+        # unless we can prove the final title is missing.
+        return
+    suggested_fields = [
+        str(field.get("name") or "").strip()
+        for field in fields
+        if isinstance(field, dict)
+        and str(field.get("name") or "").strip()
+        and str(field.get("type") or "") != FieldType.subtable.value
+    ][:8]
+    raise _DataDisplayConfigError(
+        "MISSING_DATA_TITLE_FIELD",
+        "data title is required; mark exactly one top-level field with as_data_title=true",
+        details={
+            "current_data_title_que_id": current_title_que_id,
+            "suggested_field_names": suggested_fields,
+            "next_action": "mark one top-level field as the data title, for example {'name': '项目名称', 'as_data_title': true}",
+        },
+    )
+
+
+def _field_form_config_identifier(field: dict[str, Any] | None) -> int | None:
+    if not isinstance(field, dict):
+        return None
+    que_id = _coerce_positive_int(field.get("que_id"))
+    if que_id is not None:
+        return que_id
+    que_temp_id = _coerce_any_int(field.get("que_temp_id"))
+    if que_temp_id is not None and que_temp_id != 0:
+        return que_temp_id
+    return None
+
+
+def _apply_data_display_selection_to_payload(
+    payload: dict[str, Any],
+    *,
+    fields: list[dict[str, Any]],
+    selection: _DataDisplayMarkerSelection,
+) -> None:
+    if selection.data_title_field_name:
+        data_title_field = _find_top_level_field_by_name(fields, selection.data_title_field_name)
+        data_title_que_id = _field_form_config_identifier(data_title_field)
+        if data_title_que_id is not None:
+            payload["dataTitleQueId"] = data_title_que_id
+    if selection.data_cover_field_name:
+        data_cover_field = _find_top_level_field_by_name(fields, selection.data_cover_field_name)
+        data_cover_que_id = _field_form_config_identifier(data_cover_field)
+        if data_cover_que_id is not None:
+            payload["dataCoverQueId"] = data_cover_que_id
+
+
+def _verify_data_display_readback(
+    *,
+    form_settings: Any,
+    selection: _DataDisplayMarkerSelection,
+) -> dict[str, Any]:
+    if not selection.has_any:
+        return {
+            "data_title_field_verified": None,
+            "data_cover_field_verified": None,
+            "data_display_config_verified": None,
+        }
+    settings = form_settings if isinstance(form_settings, dict) else {}
+    title_ref = settings.get("data_title_field") if isinstance(settings.get("data_title_field"), dict) else None
+    cover_ref = settings.get("data_cover_field") if isinstance(settings.get("data_cover_field"), dict) else None
+    title_verified = None
+    cover_verified = None
+    if selection.data_title_field_name:
+        title_verified = bool(title_ref and str(title_ref.get("name") or "") == selection.data_title_field_name)
+    if selection.data_cover_field_name:
+        cover_verified = bool(cover_ref and str(cover_ref.get("name") or "") == selection.data_cover_field_name)
+    requested_results = [value for value in (title_verified, cover_verified) if value is not None]
+    return {
+        "data_title_field_verified": title_verified,
+        "data_cover_field_verified": cover_verified,
+        "data_display_config_verified": all(requested_results) if requested_results else None,
+    }
+
+
+def _build_selector_map(fields: list[dict[str, Any]]) -> dict[str, int]:
+    mapping: dict[str, int] = {}
+    for index, field in enumerate(fields):
+        field_id = str(field.get("field_id") or "")
+        field_name = str(field.get("name") or "")
+        que_id = _coerce_nonnegative_int(field.get("que_id"))
+        if field_id:
+            mapping[f"field_id:{field_id}"] = index
+        if field_name:
+            mapping[f"name:{field_name}"] = index
+        if que_id is not None:
+            mapping[f"que_id:{que_id}"] = index
+    return mapping
+
+
+def _resolve_selector(selector_map: dict[str, int], selector: FieldSelector) -> int | None:
+    if selector.field_id:
+        value = selector_map.get(f"field_id:{selector.field_id}")
+        if value is not None:
+            return value
+    if selector.que_id is not None:
+        value = selector_map.get(f"que_id:{selector.que_id}")
+        if value is not None:
+            return value
+    if selector.name:
+        value = selector_map.get(f"name:{selector.name}")
+        if value is not None:
+            return value
+    return None
+
+
+def _resolve_remove_selector(fields: list[dict[str, Any]], patch: FieldRemovePatch) -> int | None:
+    selector = FieldSelector(field_id=patch.field_id, que_id=patch.que_id, name=patch.name)
+    return _resolve_selector(_build_selector_map(fields), selector)
+
+
+def _field_patch_to_internal(patch: FieldPatch) -> dict[str, Any]:
+    field_id = _slugify(patch.name, default=f"field_{uuid4().hex[:8]}")
+    remote_lookup_config = patch.remote_lookup_config.model_dump(mode="json", exclude_none=True) if patch.remote_lookup_config is not None else None
+    q_linker_binding = patch.q_linker_binding.model_dump(mode="json", exclude_none=True) if patch.q_linker_binding is not None else None
+    code_block_config = patch.code_block_config.model_dump(mode="json", exclude_none=True) if patch.code_block_config is not None else None
+    code_block_binding = patch.code_block_binding.model_dump(mode="json", exclude_none=True) if patch.code_block_binding is not None else None
+    return {
+        "field_id": field_id,
+        "name": patch.name,
+        "type": patch.type.value,
+        "required": patch.required,
+        "description": patch.description,
+        "options": list(patch.options),
+        "target_app_key": patch.target_app_key,
+        "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,
@@ -10862,6 +13348,8 @@ def _field_patch_to_internal(patch: FieldPatch) -> dict[str, Any]:
         "auto_trigger": patch.auto_trigger,
         "custom_button_text_enabled": patch.custom_button_text_enabled,
         "custom_button_text": patch.custom_button_text,
+        "as_data_title": patch.as_data_title,
+        "as_data_cover": patch.as_data_cover,
         "subfields": [_field_patch_to_internal(subfield) for subfield in patch.subfields],
         "que_id": None,
         "default_type": 1,
@@ -10928,6 +13416,16 @@ def _merge_existing_field_with_patch(field: dict[str, Any], patch: FieldPatch) -
     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)
+    if patch.as_data_title is not None:
+        if patch.as_data_title:
+            field["as_data_title"] = True
+        else:
+            field.pop("as_data_title", None)
+    if patch.as_data_cover is not None:
+        if patch.as_data_cover:
+            field["as_data_cover"] = True
+        else:
+            field.pop("as_data_cover", None)
 
 
 def _field_selector_payload_equal(left: Any, right: Any) -> bool:
@@ -11090,14 +13588,14 @@ def _code_block_binding_equal(left: Any, right: Any) -> bool:
     return _normalize_code_block_binding(left) == _normalize_code_block_binding(right)
 
 
-_SAFE_SUBFIELD_MUTATION_KEYS = frozenset({"name", "required", "description", "subfield_updates"})
+_SAFE_SUBFIELD_MUTATION_KEYS = frozenset({"name", "required", "description", "subfield_updates", "as_data_title", "as_data_cover"})
 
 
 def _validate_safe_subfield_mutation(*, payload: dict[str, Any], location: str) -> None:
     unsupported = sorted(key for key in payload if key not in _SAFE_SUBFIELD_MUTATION_KEYS)
     if unsupported:
         raise ValueError(
-            f"{location} only supports safe overlay keys: name, required, description, subfield_updates; "
+            f"{location} only supports safe overlay keys: name, required, description, subfield_updates, as_data_title, as_data_cover; "
             f"unsupported keys: {', '.join(unsupported)}"
         )
 
@@ -11184,6 +13682,16 @@ def _apply_field_mutation(field: dict[str, Any], mutation: Any) -> None:
     if "custom_button_text" in payload:
         field["custom_button_text"] = payload["custom_button_text"]
         question_rebuild_required = True
+    if "as_data_title" in payload:
+        if payload["as_data_title"]:
+            field["as_data_title"] = True
+        else:
+            field.pop("as_data_title", None)
+    if "as_data_cover" in payload:
+        if payload["as_data_cover"]:
+            field["as_data_cover"] = True
+        else:
+            field.pop("as_data_cover", None)
     if "subfields" in payload:
         field["subfields"] = [_field_patch_to_internal(item) for item in payload["subfields"]]
         question_rebuild_required = True
@@ -11270,6 +13778,26 @@ def _strip_code_block_generated_input_prelude(code_content: str) -> str:
     return body
 
 
+@dataclass(frozen=True)
+class _DataDisplayMarkerSelection:
+    data_title_field_name: str | None = None
+    data_cover_field_name: str | None = None
+
+    @property
+    def has_any(self) -> bool:
+        return bool(self.data_title_field_name or self.data_cover_field_name)
+
+
+@dataclass
+class _DataDisplayConfigError(ValueError):
+    error_code: str
+    message: str
+    details: JSONObject = field(default_factory=dict)
+
+    def __str__(self) -> str:
+        return self.message
+
+
 def _normalize_code_block_output_assignment(code_content: str) -> str:
     return re.sub(r"(?<![A-Za-z0-9_$])(?:const|let)\s+qf_output\s*=", "qf_output =", code_content)
 
@@ -13100,6 +15628,8 @@ _FORM_SAVE_BASE_KEYS = (
     "formStyle",
     "serialNumType",
     "serialNumConfig",
+    "dataTitleQueId",
+    "dataCoverQueId",
     "attachVisibleOnlyConfig",
     "externalLang",
     "hideCopyright",
@@ -13768,6 +16298,10 @@ def _build_form_save_base_payload(current_schema: dict[str, Any], title: str) ->
     for key in _FORM_SAVE_BASE_KEYS:
         if key in current_schema:
             payload[key] = deepcopy(current_schema.get(key))
+    if "dataTitleQueId" not in payload and "data_title_que_id" in current_schema:
+        payload["dataTitleQueId"] = deepcopy(current_schema.get("data_title_que_id"))
+    if "dataCoverQueId" not in payload and "data_cover_que_id" in current_schema:
+        payload["dataCoverQueId"] = deepcopy(current_schema.get("data_cover_que_id"))
     payload["editVersionNo"] = int(current_schema.get("editVersionNo") or 1)
     payload["formQues"] = []
     payload["questionRelations"] = []
@@ -14633,6 +17167,20 @@ def _merge_view_summary_with_config(
         if not summary.get("group_by") and display_config.get("group_by"):
             summary["group_by"] = display_config.get("group_by")
         config_enriched = True
+    query_question_entries_by_id = dict(question_entries_by_id)
+    for entry in canonical_question_entries:
+        field_id = _coerce_nonnegative_int(entry.get("field_id"))
+        if field_id is not None:
+            query_question_entries_by_id[field_id] = entry
+    if any(key in config for key in ("queryConditionStatus", "queryConditionExact", "hideBeforeQueryCondition", "queryCondition")):
+        summary["query_conditions"] = _extract_view_query_conditions_config(
+            config,
+            question_entries_by_id=query_question_entries_by_id,
+        )
+        config_enriched = True
+    if any(key in config for key in ("asosChartVisible", "asosChartConfig", "asosChartIdList", "limitType")):
+        summary["associated_resources_config"] = _extract_view_associated_resources_config(config)
+        config_enriched = True
     button_entries, button_source = _extract_view_button_entries(config)
     if button_entries:
         summary["buttons"] = [_normalize_view_button_entry(entry) for entry in button_entries]
@@ -14802,7 +17350,7 @@ def _normalize_view_button_type(value: Any) -> str | None:
 
 def _normalize_view_button_config_type(value: Any) -> str | None:
     normalized = str(value or "").strip().upper()
-    if normalized in {"TOP", "DETAIL"}:
+    if normalized in {"TOP", "DETAIL", "LIST"}:
         return normalized
     return None
 
@@ -14884,6 +17432,12 @@ def _extract_view_button_entries(config: dict[str, Any]) -> tuple[list[dict[str,
         entry.setdefault("configType", "DETAIL")
         entry["beingMain"] = False
         entries.append(entry)
+    for item in grouped.get("listButtonList") or []:
+        if not isinstance(item, dict):
+            continue
+        entry = deepcopy(item)
+        entry.setdefault("configType", "LIST")
+        entries.append(entry)
     return entries, "buttonConfig"
 
 
@@ -15044,12 +17598,60 @@ def _partition_view_button_summaries(
     return system_buttons, custom_buttons, other_buttons
 
 
+def _canonicalize_view_button_summary_order(items: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    top_buttons: list[dict[str, Any]] = []
+    detail_main_buttons: list[dict[str, Any]] = []
+    detail_more_buttons: list[dict[str, Any]] = []
+    list_buttons: list[dict[str, Any]] = []
+    other_buttons: list[dict[str, Any]] = []
+    for item in items:
+        config_type = str(item.get("config_type") or "").strip().upper()
+        if config_type == "TOP":
+            top_buttons.append(item)
+        elif config_type == "DETAIL" and bool(item.get("being_main", False)):
+            detail_main_buttons.append(item)
+        elif config_type == "DETAIL":
+            detail_more_buttons.append(item)
+        elif config_type == "LIST":
+            list_buttons.append(item)
+        else:
+            other_buttons.append(item)
+    return [*top_buttons, *detail_main_buttons, *detail_more_buttons, *list_buttons, *other_buttons]
+
+
+def _view_button_compare_signature(item: dict[str, Any]) -> dict[str, Any]:
+    button_type = str(item.get("button_type") or "").strip().upper()
+    signature: dict[str, Any] = {
+        "button_type": button_type,
+        "config_type": str(item.get("config_type") or "").strip().upper(),
+        "button_id": item.get("button_id") if button_type == "CUSTOM" else None,
+        "being_main": bool(item.get("being_main", False)),
+        "print_tpls": list(item.get("print_tpls") or []),
+        "button_formula": str(item.get("button_formula") or ""),
+        "button_formula_type": _coerce_positive_int(item.get("button_formula_type")) or 1,
+        "button_limit": deepcopy(item.get("button_limit") or []),
+    }
+    if button_type == "SYSTEM":
+        signature["trigger_action"] = item.get("trigger_action")
+        signature["button_icon"] = item.get("button_icon")
+        signature["button_text"] = item.get("button_text")
+    return signature
+
+
+def _sorted_view_button_compare_signatures(items: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    signatures = [_view_button_compare_signature(item) for item in items]
+    return sorted(signatures, key=lambda item: json.dumps(item, ensure_ascii=False, sort_keys=True, default=str))
+
+
 def _compare_view_button_summaries(
     *,
     expected: list[dict[str, Any]],
     actual: list[dict[str, Any]],
+    pending_custom_button_ids: set[int] | None = None,
 ) -> dict[str, Any]:
-    if actual == expected:
+    expected = _canonicalize_view_button_summary_order(expected)
+    actual = _canonicalize_view_button_summary_order(actual)
+    if _sorted_view_button_compare_signatures(actual) == _sorted_view_button_compare_signatures(expected):
         return {
             "verified": True,
             "custom_button_readback_pending": False,
@@ -15057,11 +17659,38 @@ def _compare_view_button_summaries(
         }
     expected_system, expected_custom, expected_other = _partition_view_button_summaries(expected)
     actual_system, actual_custom, actual_other = _partition_view_button_summaries(actual)
+    pending_ids = pending_custom_button_ids or set()
+    if pending_ids:
+        actual_custom_signatures = {
+            json.dumps(_view_button_compare_signature(item), ensure_ascii=False, sort_keys=True, default=str)
+            for item in actual_custom
+        }
+        pending_indexes: set[int] = set()
+        pending_custom_buttons: list[dict[str, Any]] = []
+        for index, item in enumerate(expected):
+            if str(item.get("button_type") or "").strip().upper() != "CUSTOM":
+                continue
+            button_id = _coerce_positive_int(item.get("button_id"))
+            if button_id not in pending_ids:
+                continue
+            signature = json.dumps(_view_button_compare_signature(item), ensure_ascii=False, sort_keys=True, default=str)
+            if signature in actual_custom_signatures:
+                continue
+            pending_indexes.add(index)
+            pending_custom_buttons.append(item)
+        if pending_indexes:
+            expected_without_pending = [item for index, item in enumerate(expected) if index not in pending_indexes]
+            if _sorted_view_button_compare_signatures(actual) == _sorted_view_button_compare_signatures(expected_without_pending):
+                return {
+                    "verified": True,
+                    "custom_button_readback_pending": True,
+                    "pending_custom_buttons": deepcopy(pending_custom_buttons),
+                }
     custom_button_readback_pending = (
         bool(expected_custom)
         and not actual_custom
-        and actual_system == expected_system
-        and actual_other == expected_other
+        and _sorted_view_button_compare_signatures(actual_system) == _sorted_view_button_compare_signatures(expected_system)
+        and _sorted_view_button_compare_signatures(actual_other) == _sorted_view_button_compare_signatures(expected_other)
     )
     return {
         "verified": custom_button_readback_pending,
@@ -15127,7 +17756,7 @@ def _resolve_view_button_dtos_for_patch(
 
 
 def _build_grouped_view_button_config(button_config_dtos: list[dict[str, Any]]) -> dict[str, list[dict[str, Any]]]:
-    grouped = {"topButtonList": [], "mainButtonDetailList": [], "moreButtonDetailList": []}
+    grouped = {"topButtonList": [], "mainButtonDetailList": [], "moreButtonDetailList": [], "listButtonList": []}
     for raw_item in button_config_dtos:
         if not isinstance(raw_item, dict):
             continue
@@ -15136,6 +17765,8 @@ def _build_grouped_view_button_config(button_config_dtos: list[dict[str, Any]])
         being_main = bool(item.get("beingMain", False))
         if config_type == "TOP":
             grouped["topButtonList"].append(item)
+        elif config_type == "LIST":
+            grouped["listButtonList"].append(item)
         elif being_main:
             grouped["mainButtonDetailList"].append(item)
         else:
@@ -15252,7 +17883,7 @@ def _summarize_charts(result: Any) -> list[dict[str, Any]]:
             continue
         chart_id = _extract_chart_identifier(chart)
         name = str(chart.get("chartName") or "").strip()
-        chart_type = _normalize_backend_chart_type(chart.get("chartType"))
+        chart_type = _public_chart_type_from_backend(chart.get("chartType"))
         if not any((chart_id, name, chart_type)):
             continue
         items.append(
@@ -15660,6 +18291,736 @@ def _stringify_condition_value(value: Any) -> str:
     return str(value)
 
 
+def _empty_view_query_conditions_payload() -> dict[str, Any]:
+    return {
+        "queryConditionStatus": False,
+        "queryConditionExact": False,
+        "hideBeforeQueryCondition": False,
+        "queryCondition": [],
+    }
+
+
+def _build_view_query_conditions_payload(
+    *,
+    current_fields_by_name: dict[str, dict[str, Any]],
+    query_conditions: Any,
+) -> tuple[dict[str, Any] | None, dict[str, Any] | None, list[dict[str, Any]]]:
+    if query_conditions is None:
+        return None, None, []
+    if isinstance(query_conditions, dict):
+        enabled = bool(query_conditions.get("enabled", True))
+        exact = bool(query_conditions.get("exact", False))
+        hide_before_query = bool(query_conditions.get("hide_before_query", False))
+        raw_rows = query_conditions.get("rows") or []
+    else:
+        enabled = bool(getattr(query_conditions, "enabled", True))
+        exact = bool(getattr(query_conditions, "exact", False))
+        hide_before_query = bool(getattr(query_conditions, "hide_before_query", False))
+        raw_rows = getattr(query_conditions, "rows", []) or []
+    if enabled and not raw_rows:
+        return None, None, [
+            {
+                "error_code": "QUERY_CONDITION_ROWS_REQUIRED",
+                "reason_path": "query_conditions.rows",
+                "missing_fields": [],
+                "message": "query_conditions.enabled=true requires at least one query field",
+            }
+        ]
+    rows: list[list[int]] = []
+    issues: list[dict[str, Any]] = []
+    for row_index, row in enumerate(raw_rows):
+        if not isinstance(row, list):
+            issues.append(
+                {
+                    "error_code": "INVALID_QUERY_CONDITION_ROW",
+                    "reason_path": f"query_conditions.rows[{row_index}]",
+                    "missing_fields": [],
+                    "message": "query condition rows must be lists of field names or ids",
+                }
+            )
+            continue
+        compiled_row: list[int] = []
+        for column_index, selector in enumerate(row):
+            field, issue = _resolve_query_condition_field(
+                current_fields_by_name=current_fields_by_name,
+                selector=selector,
+                reason_path=f"query_conditions.rows[{row_index}][{column_index}]",
+            )
+            if issue:
+                issues.append(issue)
+                continue
+            que_id = _coerce_positive_int(field.get("que_id"))
+            if que_id is not None:
+                compiled_row.append(que_id)
+        if compiled_row:
+            rows.append(compiled_row)
+    if issues:
+        return None, None, issues
+    payload = {
+        "queryConditionStatus": enabled,
+        "queryConditionExact": exact,
+        "hideBeforeQueryCondition": hide_before_query,
+        "queryCondition": rows if enabled else [],
+    }
+    return payload, _normalize_view_query_conditions_for_compare(payload), []
+
+
+def _resolve_query_condition_field(
+    *,
+    current_fields_by_name: dict[str, dict[str, Any]],
+    selector: Any,
+    reason_path: str,
+) -> tuple[dict[str, Any], dict[str, Any] | None]:
+    raw = str(selector or "").strip()
+    if not raw:
+        return {}, {
+            "error_code": "QUERY_CONDITION_FIELD_NOT_FOUND",
+            "reason_path": reason_path,
+            "missing_fields": [],
+            "message": "query condition field selector cannot be empty",
+        }
+    fields = [field for field in current_fields_by_name.values() if isinstance(field, dict)]
+    field = current_fields_by_name.get(raw)
+    if field is None:
+        for candidate in fields:
+            if raw == str(candidate.get("field_id") or "").strip():
+                field = candidate
+                break
+            candidate_que_id = _coerce_positive_int(candidate.get("que_id"))
+            if candidate_que_id is not None and raw == str(candidate_que_id):
+                field = candidate
+                break
+    if field is None:
+        subfield_parent = _find_subtable_subfield_parent(current_fields_by_name=current_fields_by_name, selector=raw)
+        if subfield_parent is not None:
+            return {}, {
+                "error_code": "INVALID_QUERY_CONDITION_FIELD",
+                "reason_path": reason_path,
+                "missing_fields": [],
+                "field": raw,
+                "parent_field": subfield_parent.get("name"),
+                "message": "subtable subfields cannot be used as view query conditions",
+            }
+        return {}, {
+            "error_code": "QUERY_CONDITION_FIELD_NOT_FOUND",
+            "reason_path": reason_path,
+            "missing_fields": [raw],
+            "message": "query condition references an unknown field",
+        }
+    field_type = str(field.get("type") or "")
+    if field_type in QUERY_CONDITION_UNSUPPORTED_FIELD_TYPES:
+        return {}, {
+            "error_code": "INVALID_QUERY_CONDITION_FIELD",
+            "reason_path": reason_path,
+            "missing_fields": [],
+            "field": field.get("name"),
+            "field_type": field_type,
+            "message": "this field type is not supported by the frontend query condition panel",
+        }
+    que_id = _coerce_positive_int(field.get("que_id"))
+    if que_id is None:
+        return {}, {
+            "error_code": "INVALID_QUERY_CONDITION_FIELD",
+            "reason_path": reason_path,
+            "missing_fields": [],
+            "field": field.get("name"),
+            "message": "query condition field has no backend queId",
+        }
+    return field, None
+
+
+def _find_subtable_subfield_parent(
+    *,
+    current_fields_by_name: dict[str, dict[str, Any]],
+    selector: str,
+) -> dict[str, Any] | None:
+    for field in current_fields_by_name.values():
+        if not isinstance(field, dict) or str(field.get("type") or "") != FieldType.subtable.value:
+            continue
+        for subfield in field.get("subfields") or []:
+            if not isinstance(subfield, dict):
+                continue
+            if selector == str(subfield.get("name") or "").strip():
+                return field
+            if selector == str(subfield.get("field_id") or "").strip():
+                return field
+            sub_que_id = _coerce_positive_int(subfield.get("que_id"))
+            if sub_que_id is not None and selector == str(sub_que_id):
+                return field
+    return None
+
+
+def _apply_view_query_conditions_payload(data: dict[str, Any], query_condition_payload: dict[str, Any] | None) -> None:
+    if query_condition_payload is None:
+        return
+    data["queryConditionStatus"] = bool(query_condition_payload.get("queryConditionStatus", False))
+    data["queryConditionExact"] = bool(query_condition_payload.get("queryConditionExact", False))
+    data["hideBeforeQueryCondition"] = bool(query_condition_payload.get("hideBeforeQueryCondition", False))
+    data["queryCondition"] = deepcopy(query_condition_payload.get("queryCondition") or [])
+
+
+def _extract_view_query_conditions_config(
+    config: dict[str, Any],
+    *,
+    question_entries_by_id: dict[int, dict[str, Any]] | None = None,
+) -> dict[str, Any]:
+    question_entries_by_id = question_entries_by_id or {}
+    normalized = _normalize_view_query_conditions_for_compare(config)
+    rows: list[list[str]] = []
+    for row in normalized["rows"]:
+        public_row: list[str] = []
+        for field_id in row:
+            name = str((question_entries_by_id.get(field_id) or {}).get("name") or "").strip()
+            public_row.append(name or str(field_id))
+        rows.append(public_row)
+    public_config = _public_view_query_conditions_from_compare(normalized)
+    public_config["rows"] = rows
+    public_config["row_field_ids"] = deepcopy(normalized["rows"])
+    return public_config
+
+
+def _public_view_query_conditions_from_compare(normalized: dict[str, Any]) -> dict[str, Any]:
+    return {
+        "enabled": bool(normalized.get("enabled", False)),
+        "exact": bool(normalized.get("exact", False)),
+        "hide_before_query": bool(normalized.get("hide_before_query", False)),
+        "rows": deepcopy(normalized.get("rows") or []),
+    }
+
+
+def _normalize_view_query_conditions_for_compare(config: Any) -> dict[str, Any]:
+    if not isinstance(config, dict):
+        config = {}
+    raw_rows = config.get("queryCondition")
+    rows: list[list[int]] = []
+    if isinstance(raw_rows, list):
+        for raw_row in raw_rows:
+            if not isinstance(raw_row, list):
+                continue
+            compiled_row = [
+                field_id
+                for field_id in (_coerce_positive_int(item) for item in raw_row)
+                if field_id is not None
+            ]
+            if compiled_row:
+                rows.append(compiled_row)
+    enabled = bool(config.get("queryConditionStatus", bool(rows)))
+    return {
+        "enabled": enabled,
+        "exact": bool(config.get("queryConditionExact", False)),
+        "hide_before_query": bool(config.get("hideBeforeQueryCondition", False)),
+        "rows": rows,
+    }
+
+
+def _build_view_associated_resources_payload(
+    *,
+    associated_resources: ViewAssociatedResourcesPatch | dict[str, Any] | None,
+    available_resources: list[dict[str, Any]],
+) -> tuple[dict[str, Any] | None, dict[str, Any] | None, list[dict[str, Any]]]:
+    if associated_resources is None:
+        return None, None, []
+    if isinstance(associated_resources, dict):
+        visible = bool(associated_resources.get("visible", associated_resources.get("enabled", True)))
+        raw_limit_type = associated_resources.get("limit_type", associated_resources.get("limitType"))
+        raw_item_ids = (
+            associated_resources.get("associated_item_ids")
+            or associated_resources.get("associatedItemIds")
+            or associated_resources.get("asosChartIdList")
+            or associated_resources.get("items")
+            or []
+        )
+    else:
+        visible = bool(getattr(associated_resources, "visible", True))
+        raw_limit_type = getattr(associated_resources, "limit_type", None)
+        raw_item_ids = getattr(associated_resources, "associated_item_ids", []) or []
+    if not visible:
+        expected = {
+            "visible": False,
+            "limit_type": None,
+            "configured_associated_item_ids": [],
+            "effective_associated_item_ids": [],
+            "items": [],
+        }
+        return {"asosChartVisible": False}, expected, []
+    limit_type = str(raw_limit_type or "all").strip().lower()
+    if limit_type not in {"all", "select"}:
+        return None, None, [
+            {
+                "error_code": "INVALID_ASSOCIATED_RESOURCE_LIMIT_TYPE",
+                "reason_path": "associated_resources.limit_type",
+                "missing_fields": [],
+                "received": raw_limit_type,
+                "expected_values": ["all", "select"],
+                "message": "associated_resources.limit_type must be 'all' or 'select'",
+            }
+        ]
+    available_by_id = _associated_resource_index(available_resources)
+    if limit_type == "all":
+        payload = {
+            "asosChartVisible": True,
+            "asosChartConfig": {
+                "limitType": ASSOCIATED_RESOURCE_LIMIT_TYPE_ALL,
+                "asosChartIdList": [],
+            },
+        }
+        expected = _extract_view_associated_resources_config(payload, available_resources=available_resources)
+        return payload, expected, []
+    item_ids: list[int] = []
+    for index, raw_item_id in enumerate(raw_item_ids):
+        item_id = _coerce_positive_int(raw_item_id)
+        if item_id is None:
+            return None, None, [
+                {
+                    "error_code": "ASSOCIATED_RESOURCE_NOT_FOUND",
+                    "reason_path": f"associated_resources.associated_item_ids[{index}]",
+                    "missing_fields": [],
+                    "received": raw_item_id,
+                    "message": "associated_item_id must be an app-level associated resource id from app_get.associated_resources",
+                    "next_action": "call app_get and use associated_resources[].associated_item_id, not chart_id",
+                }
+            ]
+        item_ids.append(item_id)
+    missing_ids = [item_id for item_id in item_ids if item_id not in available_by_id]
+    if missing_ids:
+        return None, None, [
+            {
+                "error_code": "ASSOCIATED_RESOURCE_NOT_FOUND",
+                "reason_path": "associated_resources.associated_item_ids",
+                "missing_fields": [],
+                "invalid_associated_item_ids": missing_ids,
+                "available_associated_item_ids": sorted(available_by_id),
+                "message": "associated_resource references ids that are not in the app-level associated resource pool",
+                "next_action": "call app_get and use associated_resources[].associated_item_id, not chart_id",
+            }
+        ]
+    payload = {
+        "asosChartVisible": True,
+        "asosChartConfig": {
+            "limitType": ASSOCIATED_RESOURCE_LIMIT_TYPE_SELECT,
+            "asosChartIdList": item_ids,
+        },
+    }
+    expected = _extract_view_associated_resources_config(payload, available_resources=available_resources)
+    return payload, expected, []
+
+
+def _apply_view_associated_resources_payload(data: dict[str, Any], associated_resources_payload: dict[str, Any] | None) -> None:
+    if associated_resources_payload is None:
+        return
+    if "asosChartVisible" in associated_resources_payload:
+        data["asosChartVisible"] = bool(associated_resources_payload.get("asosChartVisible", False))
+    if "asosChartConfig" in associated_resources_payload:
+        data["asosChartConfig"] = deepcopy(associated_resources_payload.get("asosChartConfig") or {})
+
+
+def _extract_view_associated_resources_config(
+    config: dict[str, Any],
+    *,
+    available_resources: list[dict[str, Any]] | None = None,
+) -> dict[str, Any]:
+    available_resources = available_resources or []
+    available_by_id = _associated_resource_index(available_resources)
+    visible = bool(config.get("asosChartVisible", False))
+    raw_config = config.get("asosChartConfig")
+    if not isinstance(raw_config, dict):
+        raw_config = {}
+    raw_limit_type = raw_config.get("limitType", config.get("limitType", ASSOCIATED_RESOURCE_LIMIT_TYPE_ALL))
+    limit_type = "select" if _coerce_positive_int(raw_limit_type) == ASSOCIATED_RESOURCE_LIMIT_TYPE_SELECT else "all"
+    raw_ids = raw_config.get("asosChartIdList", config.get("asosChartIdList", [])) or []
+    configured_ids = [
+        item_id
+        for item_id in (_coerce_positive_int(item) for item in raw_ids)
+        if item_id is not None
+    ]
+    if not visible:
+        effective_ids: list[int] = []
+    elif limit_type == "all":
+        effective_ids = sorted(available_by_id) if available_by_id else []
+    else:
+        effective_ids = configured_ids
+    items = [deepcopy(available_by_id[item_id]) for item_id in effective_ids if item_id in available_by_id]
+    return {
+        "visible": visible,
+        "limit_type": limit_type,
+        "configured_associated_item_ids": configured_ids,
+        "effective_associated_item_ids": effective_ids,
+        "items": items,
+    }
+
+
+def _associated_resources_config_matches(expected: dict[str, Any], actual: dict[str, Any]) -> bool:
+    if bool(expected.get("visible", False)) != bool(actual.get("visible", False)):
+        return False
+    if not bool(expected.get("visible", False)):
+        return True
+    if str(expected.get("limit_type") or "") != str(actual.get("limit_type") or ""):
+        return False
+    if sorted(expected.get("configured_associated_item_ids") or []) != sorted(actual.get("configured_associated_item_ids") or []):
+        return False
+    if sorted(expected.get("effective_associated_item_ids") or []) != sorted(actual.get("effective_associated_item_ids") or []):
+        return False
+    return True
+
+
+def _normalize_associated_resources_payload(payload: Any) -> list[dict[str, Any]]:
+    if isinstance(payload, dict):
+        raw_items = (
+            payload.get("associated_resources")
+            or payload.get("associatedResources")
+            or payload.get("asosCharts")
+            or payload.get("items")
+            or payload.get("list")
+            or payload.get("data")
+            or payload.get("result")
+            or []
+        )
+    else:
+        raw_items = payload or []
+    if isinstance(raw_items, dict):
+        raw_items = raw_items.get("items") or raw_items.get("list") or raw_items.get("data") or []
+    if not isinstance(raw_items, list):
+        return []
+    normalized_items: list[dict[str, Any]] = []
+    seen_ids: set[int] = set()
+    for raw_item in raw_items:
+        item = _normalize_associated_resource_item(raw_item)
+        item_id = _coerce_positive_int(item.get("associated_item_id"))
+        if item_id is None or item_id in seen_ids:
+            continue
+        item["associated_item_id"] = item_id
+        normalized_items.append(item)
+        seen_ids.add(item_id)
+    return normalized_items
+
+
+def _normalize_associated_resource_item(raw_item: Any) -> dict[str, Any]:
+    if not isinstance(raw_item, dict):
+        return {}
+    item_id = _first_present(raw_item, "associated_item_id", "associatedItemId", "asosChartId", "id")
+    chart_key = _first_present(raw_item, "chart_key", "chartKey", "graphKey", "chartId")
+    view_key = _first_present(raw_item, "view_key", "viewKey", "viewgraphKey", "viewGraphKey")
+    graph_type = _normalize_associated_graph_type(raw_item, chart_key=chart_key, view_key=view_key)
+    name = _first_present(raw_item, "name", "chartName", "chart_name", "viewName", "view_name", "title")
+    source_type = _first_present(raw_item, "source_type", "sourceType", "type")
+    target_app_key = _first_present(raw_item, "target_app_key", "targetAppKey", "appKey", "formKey")
+    resource_type = "view" if graph_type == "view" else "report"
+    item: dict[str, Any] = {
+        "associated_item_id": item_id,
+        "resource_type": resource_type,
+        "graph_type": graph_type,
+        "name": name,
+    }
+    if target_app_key is not None:
+        item["target_app_key"] = target_app_key
+    if graph_type == "view":
+        item["view_key"] = view_key or chart_key
+        view_type = _first_present(raw_item, "view_type", "viewType", "viewgraphType", "viewGraphType")
+        if view_type is not None:
+            item["view_type"] = view_type
+    else:
+        item["chart_id"] = _first_present(raw_item, "chart_id", "chartId", "idOfChart")
+        item["chart_key"] = chart_key
+        chart_type = _first_present(raw_item, "chart_type", "chartType", "chartGraphType")
+        if chart_type is not None:
+            item["chart_type"] = _public_chart_type_from_backend(chart_type)
+        item["report_source"] = _public_report_source_from_backend_source(source_type)
+    return _compact_dict(item)
+
+
+def _normalize_associated_graph_type(raw_item: dict[str, Any], *, chart_key: Any, view_key: Any) -> str:
+    raw_graph_type = str(_first_present(raw_item, "graph_type", "graphType", "resourceType", "type") or "").strip().lower()
+    raw_source_type = str(_first_present(raw_item, "source_type", "sourceType") or "").strip().lower()
+    combined = f"{raw_graph_type} {raw_source_type}"
+    if "view" in combined or "viewgraph" in combined:
+        return "view"
+    if "chart" in combined or "report" in combined or "qingbi" in combined:
+        return "chart"
+    if view_key:
+        return "view"
+    if chart_key:
+        return "chart"
+    return "chart"
+
+
+def _associated_resource_index(resources: list[dict[str, Any]]) -> dict[int, dict[str, Any]]:
+    indexed: dict[int, dict[str, Any]] = {}
+    for resource in resources:
+        item_id = _coerce_positive_int(resource.get("associated_item_id"))
+        if item_id is not None:
+            indexed[item_id] = resource
+    return indexed
+
+
+def _public_associated_graph_type(value: Any) -> str:
+    normalized = str(value or "").strip().lower()
+    if normalized in {"view", "viewgraph"}:
+        return "view"
+    if normalized in {"chart", "report", "qingbi"}:
+        return "chart"
+    return normalized
+
+
+def _backend_associated_graph_type(value: Any) -> str:
+    graph_type = _public_associated_graph_type(value)
+    return "VIEW" if graph_type == "view" else "CHART"
+
+
+def _public_report_source_from_backend_source(source_type: Any) -> str:
+    normalized = str(source_type or "").strip().upper()
+    if normalized == "BI_DATASET":
+        return "dataset"
+    return "app"
+
+
+def _backend_source_type_for_associated_resource_patch(patch: AssociatedResourceUpsertPatch) -> str:
+    graph_type = _public_associated_graph_type(patch.graph_type)
+    if graph_type == "view":
+        return "QINGFLOW"
+    raw_source_type = str(patch.source_type or "").strip().upper()
+    if raw_source_type in {"BI_QINGFLOW", "BI_DATASET"}:
+        return raw_source_type
+    report_source = str(patch.report_source or "app").strip().lower()
+    return "BI_DATASET" if report_source == "dataset" else "BI_QINGFLOW"
+
+
+def _backend_source_type_for_associated_resource_item(item: dict[str, Any]) -> str:
+    graph_type = str(item.get("graph_type") or item.get("resource_type") or "").strip().lower()
+    if graph_type == "view":
+        return "QINGFLOW"
+    return "BI_DATASET" if str(item.get("report_source") or "").strip().lower() == "dataset" else "BI_QINGFLOW"
+
+
+def _validate_associated_resource_patch(patch: AssociatedResourceUpsertPatch, *, reason_path: str) -> dict[str, Any] | None:
+    graph_type = _public_associated_graph_type(patch.graph_type)
+    if graph_type not in {"chart", "view"}:
+        return {
+            "error_code": "INVALID_ASSOCIATED_RESOURCE_GRAPH_TYPE",
+            "reason_path": f"{reason_path}.graph_type",
+            "received": patch.graph_type,
+            "expected_values": ["chart", "view"],
+            "message": "graph_type must be 'chart' or 'view'",
+        }
+    source_type = str(patch.source_type or "").strip().upper()
+    if source_type and source_type not in {"QINGFLOW", "BI_QINGFLOW", "BI_DATASET"}:
+        return {
+            "error_code": "INVALID_ASSOCIATED_RESOURCE_SOURCE_TYPE",
+            "reason_path": f"{reason_path}.source_type",
+            "received": patch.source_type,
+            "expected_values": ["BI_QINGFLOW", "BI_DATASET"],
+            "message": "source_type is a legacy compatibility field; use report_source='app' or 'dataset'",
+        }
+    report_source = str(patch.report_source or "").strip().lower()
+    if report_source and report_source not in {"app", "dataset"}:
+        return {
+            "error_code": "INVALID_ASSOCIATED_RESOURCE_REPORT_SOURCE",
+            "reason_path": f"{reason_path}.report_source",
+            "received": patch.report_source,
+            "expected_values": ["app", "dataset"],
+            "message": "report_source must be 'app' or 'dataset'",
+        }
+    if graph_type == "view" and report_source:
+        return {
+            "error_code": "REPORT_SOURCE_ONLY_FOR_REPORT",
+            "reason_path": f"{reason_path}.report_source",
+            "message": "report_source is only valid for graph_type=chart/report; omit it for views",
+        }
+    if graph_type == "chart" and source_type == "QINGFLOW":
+        return {
+            "error_code": "INVALID_ASSOCIATED_RESOURCE_SOURCE_TYPE",
+            "reason_path": f"{reason_path}.source_type",
+            "received": patch.source_type,
+            "expected_values": ["BI_QINGFLOW", "BI_DATASET"],
+            "message": "chart/report associated resources must use BI source; omit source_type or use report_source='app'/'dataset'",
+            "next_action": "remove source_type; the tool will infer BI_QINGFLOW for chart/report resources",
+        }
+    if graph_type == "view" and source_type and source_type != "QINGFLOW":
+        return {
+            "error_code": "INVALID_ASSOCIATED_RESOURCE_SOURCE_TYPE",
+            "reason_path": f"{reason_path}.source_type",
+            "received": patch.source_type,
+            "expected_values": ["QINGFLOW"],
+            "message": "view associated resources use the internal Qingflow view source; omit source_type for views",
+        }
+    if graph_type == "view" and not str(patch.view_key or "").strip():
+        return {
+            "error_code": "ASSOCIATED_RESOURCE_VIEW_KEY_REQUIRED",
+            "reason_path": f"{reason_path}.view_key",
+            "message": "graph_type=view requires view_key",
+        }
+    if graph_type == "chart" and not str(patch.chart_key or "").strip():
+        return {
+            "error_code": "ASSOCIATED_RESOURCE_CHART_KEY_REQUIRED",
+            "reason_path": f"{reason_path}.chart_key",
+            "message": "graph_type=chart requires chart_key",
+        }
+    if not str(patch.target_app_key or "").strip():
+        return {
+            "error_code": "ASSOCIATED_RESOURCE_TARGET_APP_REQUIRED",
+            "reason_path": f"{reason_path}.target_app_key",
+            "message": "target_app_key is required",
+        }
+    return None
+
+
+def _associated_resource_public_key(patch_or_item: Any) -> str:
+    if isinstance(patch_or_item, AssociatedResourceUpsertPatch):
+        graph_type = _public_associated_graph_type(patch_or_item.graph_type)
+        return str(patch_or_item.view_key if graph_type == "view" else patch_or_item.chart_key or "").strip()
+    if isinstance(patch_or_item, dict):
+        graph_type = str(patch_or_item.get("graph_type") or "").strip().lower()
+        return str(patch_or_item.get("view_key") if graph_type == "view" else patch_or_item.get("chart_key") or "").strip()
+    return ""
+
+
+def _associated_resource_matches_patch(item: dict[str, Any], patch: AssociatedResourceUpsertPatch) -> bool:
+    graph_type = _public_associated_graph_type(patch.graph_type)
+    item_graph_type = str(item.get("graph_type") or "").strip().lower()
+    if item_graph_type != graph_type:
+        return False
+    if _backend_source_type_for_associated_resource_item(item) != _backend_source_type_for_associated_resource_patch(patch):
+        return False
+    patch_target_app = str(patch.target_app_key or "").strip()
+    item_target_app = str(item.get("target_app_key") or "").strip()
+    if patch_target_app and item_target_app and patch_target_app != item_target_app:
+        return False
+    return _associated_resource_public_key(item) == _associated_resource_public_key(patch)
+
+
+def _associated_resource_not_found_issue(reason_path: str, associated_item_id: int, existing_by_id: dict[int, dict[str, Any]]) -> dict[str, Any]:
+    return {
+        "error_code": "ASSOCIATED_RESOURCE_NOT_FOUND",
+        "reason_path": reason_path,
+        "associated_item_id": associated_item_id,
+        "available_associated_item_ids": sorted(existing_by_id),
+        "message": "associated_item_id is not in the app-level associated resource pool",
+        "next_action": "call app_get and use associated_resources[].associated_item_id; do not pass chart_id/chart_key",
+    }
+
+
+def _duplicate_associated_resource_issue(reason_path: str, associated_item_id: int) -> dict[str, Any]:
+    return {
+        "error_code": "DUPLICATE_ASSOCIATED_RESOURCE_OPERATION",
+        "reason_path": reason_path,
+        "associated_item_id": associated_item_id,
+        "message": "the same associated resource is targeted more than once",
+    }
+
+
+def _serialize_associated_resource_match_rules(match_rules: list[CustomButtonMatchRulePatch]) -> list[list[dict[str, Any]]]:
+    if not match_rules:
+        return []
+    return [[_serialize_custom_button_match_rule(rule.model_dump(mode="json", exclude_none=True)) for rule in match_rules]]
+
+
+def _serialize_associated_resource_create_payload(patch: AssociatedResourceUpsertPatch) -> dict[str, Any]:
+    graph_type = _public_associated_graph_type(patch.graph_type)
+    return {
+        "appKey": patch.target_app_key,
+        "chartList": [
+            {
+                "chartKey": patch.view_key if graph_type == "view" else patch.chart_key,
+                "sourceType": _backend_source_type_for_associated_resource_patch(patch),
+                "graphType": _backend_associated_graph_type(graph_type),
+            }
+        ],
+        "matchRules": _serialize_associated_resource_match_rules(patch.match_rules),
+    }
+
+
+def _serialize_associated_resource_update_payload(patch: AssociatedResourceUpsertPatch, *, associated_item_id: int) -> dict[str, Any]:
+    graph_type = _public_associated_graph_type(patch.graph_type)
+    return _compact_dict(
+        {
+            "id": associated_item_id,
+            "appKey": patch.target_app_key,
+            "chartKey": patch.view_key if graph_type == "view" else patch.chart_key,
+            "sourceType": _backend_source_type_for_associated_resource_patch(patch),
+            "graphType": _backend_associated_graph_type(graph_type),
+            "matchRules": _serialize_associated_resource_match_rules(patch.match_rules),
+        }
+    )
+
+
+def _associated_resource_result_entry(
+    operation: str,
+    index: int,
+    patch: AssociatedResourceUpsertPatch,
+    *,
+    associated_item_id: int | None,
+) -> dict[str, Any]:
+    graph_type = _public_associated_graph_type(patch.graph_type)
+    return _compact_dict(
+        {
+            "index": index,
+            "operation": operation,
+            "status": "success" if associated_item_id is not None else "unverified",
+            "associated_item_id": associated_item_id,
+            "client_key": patch.client_key,
+            "resource_type": "view" if graph_type == "view" else "report",
+            "graph_type": graph_type,
+            "target_app_key": patch.target_app_key,
+            "report_source": _public_report_source_from_backend_source(_backend_source_type_for_associated_resource_patch(patch)) if graph_type == "chart" else None,
+            "chart_key": patch.chart_key if graph_type == "chart" else None,
+            "view_key": patch.view_key if graph_type == "view" else None,
+        }
+    )
+
+
+def _build_view_associated_resources_only_update_payload(
+    config: Any,
+    *,
+    associated_resources_payload: dict[str, Any] | None,
+) -> dict[str, Any]:
+    payload = deepcopy(config) if isinstance(config, dict) else {}
+    for key in (
+        "appKey",
+        "formId",
+        "wsId",
+        "viewgraphKey",
+        "createTime",
+        "updateTime",
+        "creator",
+        "editor",
+        "queBaseInfo",
+        "buttonConfigVO",
+        "buttonConfigDTOList",
+        "buttonConfig",
+    ):
+        payload.pop(key, None)
+    payload.pop("id", None)
+    payload.setdefault("viewgraphName", str(config.get("viewgraphName") or config.get("viewName") or "") if isinstance(config, dict) else "")
+    payload.setdefault("viewgraphType", str(config.get("viewgraphType") or "tableView") if isinstance(config, dict) else "tableView")
+    payload.setdefault("viewgraphQueIds", list(config.get("viewgraphQueIds") or []) if isinstance(config, dict) else [])
+    payload.setdefault("viewgraphQuestions", deepcopy(config.get("viewgraphQuestions") or []) if isinstance(config, dict) else [])
+    payload.setdefault("auth", deepcopy(config.get("auth") or default_member_auth()) if isinstance(config, dict) else default_member_auth())
+    payload.setdefault("sortType", "defaultSort")
+    payload.setdefault("viewgraphSorts", [{"queId": 0, "beingSortAscend": True, "queType": 8}])
+    payload.setdefault("viewgraphLimitType", 1)
+    payload.setdefault("viewgraphLimit", [])
+    payload.setdefault("viewgraphLimitFormula", "")
+    button_config_dtos = _extract_existing_view_button_dtos(config if isinstance(config, dict) else {})
+    if button_config_dtos:
+        payload["buttonConfigDTOList"] = button_config_dtos
+        payload["buttonConfig"] = _build_grouped_view_button_config(button_config_dtos)
+    _apply_view_associated_resources_payload(payload, associated_resources_payload)
+    return payload
+
+
+def _build_view_buttons_only_update_payload(config: Any, *, button_config_dtos: list[dict[str, Any]]) -> dict[str, Any]:
+    payload = _build_view_associated_resources_only_update_payload(config, associated_resources_payload=None)
+    payload["buttonConfigDTOList"] = deepcopy(button_config_dtos)
+    payload["buttonConfig"] = _build_grouped_view_button_config(button_config_dtos)
+    return payload
+
+
+def _first_present(mapping: dict[str, Any], *keys: str) -> Any:
+    for key in keys:
+        if key in mapping and mapping[key] is not None:
+            return mapping[key]
+    return None
+
+
 def _build_view_create_payload(
     *,
     app_key: str,
@@ -15671,6 +19032,8 @@ def _build_view_create_payload(
     current_fields_by_name: dict[str, dict[str, Any]],
     auth_override: dict[str, Any] | None = None,
     explicit_button_dtos: list[dict[str, Any]] | None = None,
+    query_condition_payload: dict[str, Any] | None = None,
+    associated_resources_payload: dict[str, Any] | None = None,
 ) -> JSONObject:
     entity = _entity_spec_from_app(base_info=base_info, schema=schema, views=None)
     parsed_schema = _parse_schema(schema)
@@ -15712,6 +19075,8 @@ def _build_view_create_payload(
         view_filters=view_filters,
         gantt_payload=gantt_config,
         button_config_dtos=explicit_button_dtos,
+        query_condition_payload=query_condition_payload,
+        associated_resources_payload=associated_resources_payload,
     )
 
 
@@ -15865,6 +19230,8 @@ def _build_view_update_payload(
     current_fields_by_name: dict[str, dict[str, Any]],
     auth_override: dict[str, Any] | None = None,
     explicit_button_dtos: list[dict[str, Any]] | None = None,
+    query_condition_payload: dict[str, Any] | None = None,
+    associated_resources_payload: dict[str, Any] | None = None,
 ) -> JSONObject:
     config_response = views.view_get_config(profile=profile, viewgraph_key=source_viewgraph_key)
     config = config_response.get("result") if isinstance(config_response.get("result"), dict) else {}
@@ -15940,6 +19307,8 @@ def _build_view_update_payload(
         view_filters=view_filters,
         gantt_payload=gantt_payload,
         button_config_dtos=button_config_dtos,
+        query_condition_payload=query_condition_payload,
+        associated_resources_payload=associated_resources_payload,
     )
 
 
@@ -15969,6 +19338,8 @@ def _build_minimal_view_payload(
     current_fields_by_name: dict[str, dict[str, Any]],
     auth_override: dict[str, Any] | None = None,
     explicit_button_dtos: list[dict[str, Any]] | None = None,
+    query_condition_payload: dict[str, Any] | None = None,
+    associated_resources_payload: dict[str, Any] | None = None,
 ) -> JSONObject:
     field_map = extract_field_map(schema)
     parsed_schema = _parse_schema(schema)
@@ -16002,6 +19373,8 @@ def _build_minimal_view_payload(
         view_filters=view_filters,
         gantt_payload=gantt_payload,
         button_config_dtos=explicit_button_dtos,
+        query_condition_payload=query_condition_payload,
+        associated_resources_payload=associated_resources_payload,
     )
 
 
@@ -16014,6 +19387,8 @@ def _hydrate_view_backend_payload(
     view_filters: list[list[dict[str, Any]]] | None = None,
     gantt_payload: dict[str, Any] | None = None,
     button_config_dtos: list[dict[str, Any]] | None = None,
+    query_condition_payload: dict[str, Any] | None = None,
+    associated_resources_payload: dict[str, Any] | None = None,
 ) -> JSONObject:
     data = deepcopy(payload)
     data.setdefault("beingPinNavigate", True)
@@ -16081,6 +19456,8 @@ def _hydrate_view_backend_payload(
         data["viewgraphLimitFormula"] = ""
         data["dataPermissionType"] = "CUSTOM"
         data["dataScope"] = "CUSTOM" if view_filters else "ALL"
+    _apply_view_query_conditions_payload(data, query_condition_payload)
+    _apply_view_associated_resources_payload(data, associated_resources_payload)
     return data