@qingflow-tech/qingflow-app-builder-mcp 1.0.7 → 1.0.9

package/src/qingflow_mcp/builder_facade/service.py

@@ -44,17 +44,21 @@ from .models import (
     AppReadSummaryResponse,
     AppViewsReadResponse,
     AssociatedResourcesApplyRequest,
+    AssociatedResourcePartialPatch,
     AssociatedResourceUpsertPatch,
     AssociatedResourceViewConfigPatch,
     ChartApplyRequest,
+    ChartPartialPatch,
     ChartUpsertPatch,
     CustomButtonsApplyRequest,
+    CustomButtonPartialPatch,
     CustomButtonViewButtonBindingPatch,
     CustomButtonViewConfigPatch,
     CustomButtonMatchRulePatch,
     CustomButtonPatch,
     CustomButtonRemovePatch,
     CustomButtonUpsertPatch,
+    FieldMatchMappingPatch,
     FieldPatch,
     FieldRemovePatch,
     FieldSelector,
@@ -85,6 +89,7 @@ from .models import (
     VisibilityPatch,
     ViewAssociatedResourcesPatch,
     ViewButtonBindingPatch,
+    ViewPartialPatch,
     ViewUpsertPatch,
     ViewFilterOperator,
     ViewGetResponse,
@@ -2397,6 +2402,140 @@ class AiBuilderFacade:
             **button_style_catalog_payload(),
         }
 
+    def _expand_custom_button_partial_patches(
+        self,
+        *,
+        profile: str,
+        app_key: str,
+        existing_by_id: dict[int, dict[str, Any]],
+        existing_by_text: dict[str, list[dict[str, Any]]],
+        patch_buttons: list[CustomButtonPartialPatch],
+    ) -> tuple[list[CustomButtonUpsertPatch], list[dict[str, Any]], list[dict[str, Any]]]:
+        expanded: list[CustomButtonUpsertPatch] = []
+        issues: list[dict[str, Any]] = []
+        results: list[dict[str, Any]] = []
+        for index, patch in enumerate(patch_buttons):
+            selector_id = _coerce_positive_int(patch.button_id)
+            selector_text = str(patch.button_text or "").strip()
+            button_id: int | None = None
+            if selector_id is not None:
+                if selector_id not in existing_by_id:
+                    issue = {
+                        "error_code": "CUSTOM_BUTTON_NOT_FOUND",
+                        "reason_path": f"patch_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",
+                    }
+                    issues.append(issue)
+                    results.append({"index": index, "status": "failed", **issue})
+                    continue
+                button_id = selector_id
+            else:
+                matches = existing_by_text.get(selector_text, [])
+                if len(matches) != 1:
+                    issue = {
+                        "error_code": "AMBIGUOUS_CUSTOM_BUTTON" if matches else "CUSTOM_BUTTON_NOT_FOUND",
+                        "reason_path": f"patch_buttons[{index}].button_text",
+                        "button_text": selector_text,
+                        "candidate_button_ids": [
+                            item.get("button_id")
+                            for item in matches
+                            if _coerce_positive_int(item.get("button_id")) is not None
+                        ],
+                        "message": "patch_buttons[] must target a single existing button; use button_id when names are duplicated",
+                    }
+                    issues.append(issue)
+                    results.append({"index": index, "status": "failed", **issue})
+                    continue
+                button_id = _coerce_positive_int(matches[0].get("button_id"))
+                if button_id is None:
+                    issue = {
+                        "error_code": "CUSTOM_BUTTON_ID_MISSING",
+                        "reason_path": f"patch_buttons[{index}].button_text",
+                        "button_text": selector_text,
+                        "message": "matched button has no readable button_id",
+                    }
+                    issues.append(issue)
+                    results.append({"index": index, "status": "failed", **issue})
+                    continue
+            try:
+                detail_response = self.buttons.custom_button_get(
+                    profile=profile,
+                    app_key=app_key,
+                    button_id=button_id,
+                    being_draft=True,
+                    include_raw=False,
+                )
+                detail = _normalize_custom_button_detail(detail_response.get("result") if isinstance(detail_response.get("result"), dict) else {})
+            except (QingflowApiError, RuntimeError) as error:
+                api_error = _coerce_api_error(error)
+                issue = {
+                    "error_code": "CUSTOM_BUTTON_PATCH_DETAIL_READ_FAILED",
+                    "reason_path": f"patch_buttons[{index}]",
+                    "button_id": button_id,
+                    "message": api_error.message,
+                    "transport_error": _transport_error_payload(api_error),
+                }
+                issues.append(issue)
+                results.append({"index": index, "status": "failed", **issue})
+                continue
+            patch_payload = _custom_button_upsert_payload_from_detail(
+                detail,
+                button_id=button_id,
+                client_key=str(patch.client_key or "").strip() or None,
+            )
+            normalized_set, set_issues = _normalize_custom_button_partial_set(patch.set, reason_path=f"patch_buttons[{index}].set")
+            normalized_unset, unset_issues = _normalize_custom_button_partial_unset(patch.unset, reason_path=f"patch_buttons[{index}].unset")
+            if set_issues or unset_issues:
+                patch_issues = [*set_issues, *unset_issues]
+                issues.extend(patch_issues)
+                results.append({"index": index, "status": "failed", "button_id": button_id, "issues": patch_issues})
+                continue
+            for key, value in normalized_set.items():
+                if key in {"trigger_add_data_config", "external_qrobot_config", "trigger_wings_config"} and isinstance(value, dict):
+                    if key == "trigger_add_data_config" and _custom_button_add_data_config_has_semantic_inputs(value):
+                        existing_config = patch_payload.get(key) if isinstance(patch_payload.get(key), dict) else {}
+                        merged_value: dict[str, Any] = {}
+                        for preserve_key in ("related_app_key", "related_app_name"):
+                            if preserve_key in existing_config:
+                                merged_value[preserve_key] = deepcopy(existing_config[preserve_key])
+                        _deep_merge_public_config(merged_value, value)
+                    else:
+                        merged_value = deepcopy(patch_payload.get(key) if isinstance(patch_payload.get(key), dict) else {})
+                        _deep_merge_public_config(merged_value, value)
+                    if key == "trigger_add_data_config":
+                        merged_value = _normalize_custom_button_add_data_config_for_public(merged_value)
+                    patch_payload[key] = merged_value
+                else:
+                    patch_payload[key] = value
+            for key in normalized_unset:
+                patch_payload.pop(key, None)
+            try:
+                expanded_patch = CustomButtonUpsertPatch.model_validate(patch_payload)
+            except Exception as error:
+                issue = {
+                    "error_code": "CUSTOM_BUTTON_PATCH_HYDRATION_FAILED",
+                    "reason_path": f"patch_buttons[{index}]",
+                    "button_id": button_id,
+                    "message": str(error),
+                    "hydrated_payload": _compact_dict(patch_payload),
+                }
+                issues.append(issue)
+                results.append({"index": index, "status": "failed", **issue})
+                continue
+            expanded.append(expanded_patch)
+            results.append(
+                {
+                    "index": index,
+                    "status": "expanded",
+                    "button_id": button_id,
+                    "set_paths": sorted(normalized_set),
+                    "unset_paths": sorted(normalized_unset),
+                }
+            )
+        return expanded, issues, results
+
     def app_custom_buttons_apply(self, *, profile: str, request: CustomButtonsApplyRequest) -> JSONObject:
         normalized_args = request.model_dump(mode="json")
         app_key = request.app_key
@@ -2437,10 +2576,33 @@ class AiBuilderFacade:
             if text:
                 existing_by_text.setdefault(text, []).append(item)
 
+        upsert_buttons = list(request.upsert_buttons)
+        if request.patch_buttons:
+            expanded_buttons, patch_issues, patch_results = self._expand_custom_button_partial_patches(
+                profile=profile,
+                app_key=app_key,
+                existing_by_id=existing_by_id,
+                existing_by_text=existing_by_text,
+                patch_buttons=request.patch_buttons,
+            )
+            if patch_issues:
+                return finalize(
+                    _failed(
+                        "CUSTOM_BUTTON_PATCH_HYDRATION_FAILED",
+                        "one or more custom button partial patches could not be hydrated; no write was executed",
+                        normalized_args=normalized_args,
+                        details={"patch_results": patch_results, "blocking_issues": patch_issues},
+                        suggested_next_call={"tool_name": "app_get", "arguments": {"profile": profile, "app_key": app_key}},
+                    )
+                )
+            upsert_buttons.extend(expanded_buttons)
+            normalized_args["upsert_buttons"] = [patch.model_dump(mode="json") for patch in upsert_buttons]
+            normalized_args["patch_results"] = patch_results
+
         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,
+            patches=upsert_buttons,
         )
         upsert_ops: list[dict[str, Any]] = []
         remove_ops: list[dict[str, Any]] = []
@@ -2449,7 +2611,7 @@ class AiBuilderFacade:
         touched_existing_ids: set[int] = set()
         used_client_keys: set[str] = set()
 
-        for index, patch in enumerate(request.upsert_buttons):
+        for index, patch in enumerate(upsert_buttons):
             patch_payload = patch.model_dump(mode="json", exclude_none=True)
             client_key = str(patch.client_key or "").strip()
             if client_key:
@@ -2832,6 +2994,10 @@ class AiBuilderFacade:
                 "edit_version_no": edit_version_no,
                 "button_ids_by_client_key": client_key_map,
                 "readback_failed": readback_failed,
+                "compiled_match_rules": {
+                    str(index): _summarize_compiled_match_rules(config.get("que_relation") or [])
+                    for index, config in compiled_add_data_configs.items()
+                },
             },
             "request_id": None,
             "suggested_next_call": None if verified else {"tool_name": "app_get", "arguments": {"profile": profile, "app_key": app_key}},
@@ -3234,6 +3400,241 @@ class AiBuilderFacade:
             )
         )
 
+    def _expand_associated_resource_partial_patches(
+        self,
+        *,
+        existing_by_id: dict[int, dict[str, Any]],
+        patch_resources: list[AssociatedResourcePartialPatch],
+    ) -> tuple[list[AssociatedResourceUpsertPatch], list[dict[str, Any]], list[dict[str, Any]]]:
+        expanded: list[AssociatedResourceUpsertPatch] = []
+        issues: list[dict[str, Any]] = []
+        results: list[dict[str, Any]] = []
+        for index, patch in enumerate(patch_resources):
+            item_id = _coerce_positive_int(patch.associated_item_id)
+            if item_id is None or item_id not in existing_by_id:
+                issue = _associated_resource_not_found_issue(f"patch_resources[{index}].associated_item_id", int(patch.associated_item_id), existing_by_id)
+                issues.append(issue)
+                results.append({"index": index, "status": "failed", **issue})
+                continue
+            patch_payload = _associated_resource_upsert_payload_from_existing_item(
+                existing_by_id[item_id],
+                associated_item_id=item_id,
+                client_key=str(patch.client_key or "").strip() or None,
+            )
+            normalized_set, set_issues = _normalize_associated_resource_partial_set(patch.set, reason_path=f"patch_resources[{index}].set")
+            normalized_unset, unset_issues = _normalize_associated_resource_partial_unset(patch.unset, reason_path=f"patch_resources[{index}].unset")
+            if set_issues or unset_issues:
+                patch_issues = [*set_issues, *unset_issues]
+                issues.extend(patch_issues)
+                results.append({"index": index, "status": "failed", "associated_item_id": item_id, "issues": patch_issues})
+                continue
+            for key, value in normalized_set.items():
+                patch_payload[key] = value
+                if key == "match_mappings":
+                    patch_payload["match_rules"] = []
+                elif key == "match_rules":
+                    patch_payload["match_mappings"] = []
+            for key in normalized_unset:
+                if key == "match_rules":
+                    patch_payload["match_rules"] = []
+                    patch_payload["match_mappings"] = []
+                if key == "match_mappings":
+                    patch_payload["match_rules"] = []
+                    patch_payload["match_mappings"] = []
+            try:
+                expanded_patch = AssociatedResourceUpsertPatch.model_validate(patch_payload)
+            except Exception as error:
+                issue = {
+                    "error_code": "ASSOCIATED_RESOURCE_PATCH_HYDRATION_FAILED",
+                    "reason_path": f"patch_resources[{index}]",
+                    "associated_item_id": item_id,
+                    "message": str(error),
+                    "hydrated_payload": _compact_dict(patch_payload),
+                }
+                issues.append(issue)
+                results.append({"index": index, "status": "failed", **issue})
+                continue
+            validation_issue = _validate_associated_resource_patch(expanded_patch, reason_path=f"patch_resources[{index}]")
+            if validation_issue is not None:
+                issues.append(validation_issue)
+                results.append({"index": index, "status": "failed", "associated_item_id": item_id, "issues": [validation_issue]})
+                continue
+            expanded.append(expanded_patch)
+            results.append(
+                {
+                    "index": index,
+                    "status": "expanded",
+                    "associated_item_id": item_id,
+                    "set_paths": sorted(normalized_set),
+                    "unset_paths": sorted(normalized_unset),
+                }
+            )
+        return expanded, issues, results
+
+    def _compile_associated_resource_semantic_match_mappings(
+        self,
+        *,
+        profile: str,
+        app_key: str,
+        patches: list[AssociatedResourceUpsertPatch],
+    ) -> tuple[dict[int, list[dict[str, Any]]], list[dict[str, Any]]]:
+        compiled_by_index: dict[int, list[dict[str, Any]]] = {}
+        issues: list[dict[str, Any]] = []
+        semantic_patches = [
+            (index, patch)
+            for index, patch in enumerate(patches)
+            if patch.match_mappings or (patch.match_rules and patch.match_mappings)
+        ]
+        if not semantic_patches:
+            return compiled_by_index, issues
+        try:
+            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": "ASSOCIATED_RESOURCE_SOURCE_SCHEMA_READ_FAILED",
+                    "reason_path": "upsert_resources[].match_mappings",
+                    "message": api_error.message,
+                    "transport_error": _transport_error_payload(api_error),
+                    "next_action": "retry after app schema is readable",
+                }
+            ]
+        source_fields = list(_parse_schema(source_schema).get("fields") or [])
+        target_schema_cache: dict[str, list[dict[str, Any]]] = {}
+        for index, patch in semantic_patches:
+            reason_base = f"upsert_resources[{index}].match_mappings"
+            if patch.match_mappings and patch.match_rules:
+                issues.append(
+                    {
+                        "_patch_index": index,
+                        "error_code": "MIXED_ASSOCIATED_RESOURCE_MAPPING_MODES",
+                        "reason_path": f"upsert_resources[{index}]",
+                        "message": "match_mappings cannot be used together with raw match_rules",
+                        "next_action": "use semantic match_mappings only, or pass legacy match_rules only",
+                    }
+                )
+                continue
+            if not patch.match_mappings:
+                continue
+            target_app_key = str(patch.target_app_key or "").strip()
+            if not target_app_key:
+                issues.append(
+                    {
+                        "_patch_index": index,
+                        "error_code": "ASSOCIATED_RESOURCE_TARGET_APP_REQUIRED",
+                        "reason_path": f"upsert_resources[{index}].target_app_key",
+                        "message": "match_mappings 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 [])
+                except (QingflowApiError, RuntimeError) as error:
+                    api_error = _coerce_api_error(error)
+                    issues.append(
+                        {
+                            "_patch_index": index,
+                            "error_code": "ASSOCIATED_RESOURCE_TARGET_SCHEMA_READ_FAILED",
+                            "reason_path": f"upsert_resources[{index}].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
+            rules, mapping_issues = self._compile_field_match_mappings(
+                profile=profile,
+                source_app_key=app_key,
+                source_fields=source_fields,
+                target_fields=target_schema_cache[target_app_key],
+                mappings=patch.match_mappings,
+                reason_path=reason_base,
+                type_error_code="ASSOCIATED_RESOURCE_MAPPING_TYPE_MISMATCH",
+                context_label="associated resource match mapping",
+            )
+            if mapping_issues:
+                for issue in mapping_issues:
+                    issue["_patch_index"] = index
+                issues.extend(mapping_issues)
+                continue
+            compiled_by_index[index] = rules
+        return compiled_by_index, issues
+
+    def _compile_field_match_mappings(
+        self,
+        *,
+        profile: str,
+        source_app_key: str,
+        source_fields: list[dict[str, Any]],
+        target_fields: list[dict[str, Any]],
+        mappings: list[FieldMatchMappingPatch],
+        reason_path: str,
+        type_error_code: str,
+        context_label: str,
+    ) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]:
+        issues: list[dict[str, Any]] = []
+        rules: list[dict[str, Any]] = []
+        for mapping_index, mapping in enumerate(mappings):
+            target_field, target_issue = _resolve_custom_button_schema_field(
+                fields=target_fields,
+                selector=mapping.target_field,
+                reason_path=f"{reason_path}[{mapping_index}].target_field",
+                role="match_target",
+            )
+            if target_issue or target_field is None:
+                if target_issue:
+                    issues.append(_retag_associated_resource_match_field_issue(target_issue))
+                continue
+            judge_type, operator_issue = _match_mapping_operator_to_judge_type(
+                mapping.operator,
+                reason_path=f"{reason_path}[{mapping_index}].operator",
+            )
+            if operator_issue:
+                issues.append(operator_issue)
+                continue
+            if mapping.source_field is not None:
+                source_field, source_issue = _resolve_custom_button_schema_field(
+                    fields=source_fields,
+                    selector=mapping.source_field,
+                    reason_path=f"{reason_path}[{mapping_index}].source_field",
+                    role="match_source",
+                )
+                if source_issue or source_field is None:
+                    if source_issue:
+                        issues.append(_retag_associated_resource_match_field_issue(source_issue))
+                    continue
+                type_issue = _custom_button_mapping_type_issue(
+                    source_field=source_field,
+                    target_field=target_field,
+                    reason_path=f"{reason_path}[{mapping_index}]",
+                    source_app_key=source_app_key,
+                    error_code=type_error_code,
+                    context_label=context_label,
+                )
+                if type_issue:
+                    issues.append(type_issue)
+                    continue
+                rule = _custom_button_field_mapping_rule(source_field=source_field, target_field=target_field)
+                rule["judge_type"] = judge_type
+                rules.append(rule)
+                continue
+            rule, value_issue = self._custom_button_default_value_rule(
+                profile=profile,
+                target_field=target_field,
+                value=mapping.value,
+                reason_path=f"{reason_path}[{mapping_index}].value",
+            )
+            if value_issue:
+                issues.append(_retag_associated_resource_static_value_issue(value_issue))
+                continue
+            rule["judge_type"] = judge_type
+            rules.append(rule)
+        return rules, issues
+
     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
@@ -3252,7 +3653,7 @@ class AiBuilderFacade:
             return _apply_permission_outcomes(response, *permission_outcomes)
 
         try:
-            existing_resources = self._load_associated_resources_for_builder(profile=profile, app_key=app_key)
+            existing_resources = self._load_associated_resources_for_builder(profile=profile, app_key=app_key, include_raw=True)
         except (QingflowApiError, RuntimeError) as error:
             api_error = _coerce_api_error(error)
             return finalize(_failed_from_api_error(
@@ -3270,8 +3671,45 @@ class AiBuilderFacade:
         client_key_to_patch: dict[str, AssociatedResourceUpsertPatch] = {}
         client_key_to_id: dict[str, int] = {}
         used_client_keys: set[str] = set()
+        force_update_resource_ids: set[int] = set()
+        resolved_associated_item_refs: dict[str, list[int]] = {}
+
+        upsert_resources = list(request.upsert_resources)
+        if request.patch_resources:
+            expanded_resources, patch_issues, patch_results = self._expand_associated_resource_partial_patches(
+                existing_by_id=existing_by_id,
+                patch_resources=request.patch_resources,
+            )
+            if patch_issues:
+                return finalize(
+                    _failed(
+                        "ASSOCIATED_RESOURCE_PATCH_HYDRATION_FAILED",
+                        "one or more associated resource partial patches could not be hydrated; no write was executed",
+                        normalized_args=normalized_args,
+                        details={"patch_results": patch_results, "blocking_issues": patch_issues},
+                        suggested_next_call={"tool_name": "app_get", "arguments": {"profile": profile, "app_key": app_key}},
+                    )
+                )
+            upsert_resources.extend(expanded_resources)
+            force_update_resource_ids.update(
+                item_id
+                for item_id in (_coerce_positive_int(patch.associated_item_id) for patch in expanded_resources)
+                if item_id is not None
+            )
+            normalized_args["upsert_resources"] = [patch.model_dump(mode="json") for patch in upsert_resources]
+            normalized_args["patch_results"] = patch_results
+
+        compiled_resource_match_rules, resource_match_issues = self._compile_associated_resource_semantic_match_mappings(
+            profile=profile,
+            app_key=app_key,
+            patches=upsert_resources,
+        )
+        normalized_args["compiled_match_rules"] = {
+            str(index): _summarize_compiled_match_rules(rules)
+            for index, rules in compiled_resource_match_rules.items()
+        }
 
-        for index, patch in enumerate(request.upsert_resources):
+        for index, patch in enumerate(upsert_resources):
             client_key = str(patch.client_key or "").strip()
             if client_key:
                 if client_key in used_client_keys:
@@ -3282,6 +3720,8 @@ class AiBuilderFacade:
             if validation_issue is not None:
                 blocking_issues.append(validation_issue)
                 continue
+            if index in {issue.get("_patch_index") for issue in resource_match_issues if isinstance(issue, dict)}:
+                continue
             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:
@@ -3293,7 +3733,14 @@ class AiBuilderFacade:
                 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"
+                operation = (
+                    "update"
+                    if associated_item_id in force_update_resource_ids
+                    or _associated_resource_patch_has_match_config(patch)
+                    else "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
             matches = [
@@ -3327,38 +3774,40 @@ class AiBuilderFacade:
                 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})
+                operation = "update" if _associated_resource_patch_has_match_config(patch) else "unchanged"
+                upsert_ops.append({"operation": operation, "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
-        ]
+        remove_ids: list[int] = []
         for raw_id in request.remove_associated_item_ids:
-            item_id = _coerce_positive_int(raw_id)
+            item_id, issue = _resolve_associated_resource_selector(
+                raw_id,
+                existing_resources=existing_resources,
+                existing_by_id=existing_by_id,
+                reason_path="remove_associated_item_ids",
+            )
             if item_id is None:
-                blocking_issues.append({"error_code": "ASSOCIATED_RESOURCE_NOT_FOUND", "reason_path": "remove_associated_item_ids", "received": raw_id})
+                blocking_issues.append(issue or {"error_code": "ASSOCIATED_RESOURCE_NOT_FOUND", "reason_path": "remove_associated_item_ids", "received": raw_id})
                 continue
-            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:
+            remove_ids.append(item_id)
+            if item_id in touched_ids:
                 blocking_issues.append(_duplicate_associated_resource_issue("remove_associated_item_ids", item_id))
             else:
                 touched_ids.add(item_id)
 
-        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
-        ]
+        reorder_ids: list[int] = []
         for raw_id in request.reorder_associated_item_ids:
-            item_id = _coerce_positive_int(raw_id)
+            item_id, issue = _resolve_associated_resource_selector(
+                raw_id,
+                existing_resources=existing_resources,
+                existing_by_id=existing_by_id,
+                reason_path="reorder_associated_item_ids",
+            )
             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))
+                blocking_issues.append(issue or {"error_code": "ASSOCIATED_RESOURCE_NOT_FOUND", "reason_path": "reorder_associated_item_ids", "received": raw_id})
+                continue
+            reorder_ids.append(item_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()]
@@ -3372,21 +3821,26 @@ class AiBuilderFacade:
                         "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",
-                    }
+            resolved_ids: list[int] = []
+            for raw_id in view_config.associated_item_ids:
+                item_id, issue = _resolve_associated_resource_selector(
+                    raw_id,
+                    existing_resources=existing_resources,
+                    existing_by_id=existing_by_id,
+                    reason_path=f"view_configs[{index}].associated_item_ids",
                 )
+                if item_id is None:
+                    blocking_issues.append(
+                        issue
+                        or {
+                            "error_code": "ASSOCIATED_RESOURCE_NOT_FOUND",
+                            "reason_path": f"view_configs[{index}].associated_item_ids",
+                            "received": raw_id,
+                        }
+                    )
+                    continue
+                resolved_ids.append(item_id)
+            resolved_associated_item_refs[f"view_configs[{index}].associated_item_ids"] = resolved_ids
             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(
@@ -3398,6 +3852,15 @@ class AiBuilderFacade:
                     }
                 )
 
+        blocking_issues.extend(
+            [
+                {key: value for key, value in issue.items() if key != "_patch_index"}
+                for issue in resource_match_issues
+            ]
+        )
+        if resolved_associated_item_refs:
+            normalized_args["resolved_associated_item_refs"] = deepcopy(resolved_associated_item_refs)
+
         if blocking_issues:
             return finalize(
                 _failed(
@@ -3453,7 +3916,7 @@ class AiBuilderFacade:
                 "safe_to_retry": True,
                 "publish_requested": False,
                 "published": False,
-                "associated_resources": existing_resources,
+                "associated_resources": _strip_internal_associated_resource_raw(existing_resources),
             }
             return finalize(response)
 
@@ -3485,7 +3948,12 @@ class AiBuilderFacade:
                         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)
+                    self._associated_resource_create(
+                        profile=profile,
+                        app_key=app_key,
+                        patch=patch,
+                        match_rules_override=compiled_resource_match_rules.get(int(op["index"])),
+                    )
                     readback_resources = self._load_associated_resources_for_builder(profile=profile, app_key=app_key)
                     matches = [
                         item
@@ -3500,7 +3968,14 @@ class AiBuilderFacade:
                 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)
+                    self._associated_resource_update(
+                        profile=profile,
+                        app_key=app_key,
+                        associated_item_id=item_id,
+                        patch=patch,
+                        existing_item=existing_by_id.get(item_id),
+                        match_rules_override=compiled_resource_match_rules.get(int(op["index"])),
+                    )
                     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
@@ -3542,12 +4017,13 @@ class AiBuilderFacade:
             resources_after = []
 
         for index, view_config in enumerate(request.view_configs):
+            resolved_view_config_ids = resolved_associated_item_refs.get(f"view_configs[{index}].associated_item_ids", [])
             selected_ids = [
                 item_id
                 for item_id in (
                     _coerce_positive_int(raw_id)
                     for raw_id in [
-                        *view_config.associated_item_ids,
+                        *resolved_view_config_ids,
                         *[client_key_to_id.get(str(ref or "").strip()) for ref in view_config.associated_item_refs],
                     ]
                 )
@@ -3641,7 +4117,16 @@ class AiBuilderFacade:
             "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},
+            "details": {
+                "edit_version_no": edit_version_no,
+                "associated_item_ids_by_client_key": client_key_to_id,
+                "readback_failed": readback_failed,
+                "compiled_match_rules": {
+                    str(index): _summarize_compiled_match_rules(rules)
+                    for index, rules in compiled_resource_match_rules.items()
+                },
+                "resolved_associated_item_refs": resolved_associated_item_refs,
+            },
             "request_id": None,
             "suggested_next_call": None if verified else {"tool_name": "app_get", "arguments": {"profile": profile, "app_key": app_key}},
             "noop": False,
@@ -4835,7 +5320,7 @@ 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 _load_associated_resources_for_builder(self, *, profile: str, app_key: str) -> list[dict[str, Any]]:
+    def _load_associated_resources_for_builder(self, *, profile: str, app_key: str, include_raw: bool = False) -> list[dict[str, Any]]:
         def runner(_: Any, context: BackendRequestContext) -> list[dict[str, Any]]:
             payload = self.apps.backend.request(
                 "GET",
@@ -4843,12 +5328,19 @@ class AiBuilderFacade:
                 f"/app/{app_key}/asosChart",
                 params={"role": 1, "beingDraft": True},
             )
-            return _normalize_associated_resources_payload(payload)
+            return _normalize_associated_resources_payload(payload, include_raw=include_raw)
 
         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 _associated_resource_create(
+        self,
+        *,
+        profile: str,
+        app_key: str,
+        patch: AssociatedResourceUpsertPatch,
+        match_rules_override: list[dict[str, Any]] | None = None,
+    ) -> JSONObject:
+        payload = _serialize_associated_resource_create_payload(patch, match_rules_override=match_rules_override)
 
         def runner(_: Any, context: BackendRequestContext) -> JSONObject:
             result = self.apps.backend.request("POST", context, f"/app/{app_key}/asosChart", json_body=payload)
@@ -4863,8 +5355,15 @@ class AiBuilderFacade:
         app_key: str,
         associated_item_id: int,
         patch: AssociatedResourceUpsertPatch,
+        existing_item: dict[str, Any] | None = None,
+        match_rules_override: list[dict[str, Any]] | None = None,
     ) -> JSONObject:
-        payload = _serialize_associated_resource_update_payload(patch, associated_item_id=associated_item_id)
+        payload = _serialize_associated_resource_update_payload(
+            patch,
+            associated_item_id=associated_item_id,
+            existing_item=existing_item,
+            match_rules_override=match_rules_override,
+        )
 
         def runner(_: Any, context: BackendRequestContext) -> JSONObject:
             result = self.apps.backend.request("POST", context, f"/app/{app_key}/asosChart/{associated_item_id}", json_body=payload)
@@ -4984,6 +5483,7 @@ class AiBuilderFacade:
                     continue
             compiled_config, config_issues = self._compile_custom_button_add_data_config(
                 profile=profile,
+                source_app_key=app_key,
                 source_fields=list(source_fields),
                 target_fields=target_schema_cache[target_app_key],
                 target_app_key=target_app_key,
@@ -5001,6 +5501,7 @@ class AiBuilderFacade:
         self,
         *,
         profile: str,
+        source_app_key: str,
         source_fields: list[dict[str, Any]],
         target_fields: list[dict[str, Any]],
         target_app_key: str,
@@ -5035,6 +5536,9 @@ class AiBuilderFacade:
                 source_field=source_field,
                 target_field=target_field,
                 reason_path=f"{reason_path}.field_mappings[{mapping_index}]",
+                source_app_key=source_app_key,
+                error_code="CUSTOM_BUTTON_MAPPING_TYPE_MISMATCH",
+                context_label="addData copy mapping",
             )
             if type_issue:
                 issues.append(type_issue)
@@ -5349,19 +5853,19 @@ class AiBuilderFacade:
             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"
+                    _normalize_view_button_config_type(item.get("configType")) == "INSIDE"
                     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"
+                    if _normalize_view_button_config_type(item.get("configType")) != "INSIDE"
                 ]
                 fallback_new_dtos = [
                     item
                     for item in new_dtos
-                    if _normalize_view_button_config_type(item.get("configType")) != "LIST"
+                    if _normalize_view_button_config_type(item.get("configType")) != "INSIDE"
                 ]
                 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)
@@ -5373,12 +5877,12 @@ class AiBuilderFacade:
                             "index": config_index,
                             "operation": "view_config",
                             "status": "failed",
-                            "error_code": "LIST_BUTTON_BACKEND_UNSUPPORTED",
+                            "error_code": "INSIDE_BUTTON_BACKEND_UNSUPPORTED",
                             "view_key": view_key,
-                            "message": "backend rejected list-button placement; header/detail placements were retried without list buttons",
+                            "message": "backend rejected inside/list-button placement; header/detail placements were retried without inside 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",
+                            "next_action": "use placement=header/detail for now, or verify the backend inside-button payload separately",
                         }
                         failed.append(unsupported_list_issue)
                     except (QingflowApiError, RuntimeError) as fallback_error:
@@ -5402,12 +5906,12 @@ class AiBuilderFacade:
                         "index": config_index,
                         "operation": "view_config",
                         "status": "failed",
-                        "error_code": "LIST_BUTTON_BACKEND_UNSUPPORTED",
+                        "error_code": "INSIDE_BUTTON_BACKEND_UNSUPPORTED",
                         "view_key": view_key,
-                        "message": "backend rejected list-button placement",
+                        "message": "backend rejected inside/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",
+                        "next_action": "use placement=header/detail for now, or verify the backend inside-button payload separately",
                     }
                     failed.append(issue)
                     results.append(issue)
@@ -5648,6 +6152,7 @@ class AiBuilderFacade:
             config if isinstance(config, dict) else {},
             available_resources=associated_resources,
         )
+        buttons_config = _extract_view_buttons_config(config if isinstance(config, dict) else {})
 
         response = ViewGetResponse(
             view_key=view_key,
@@ -5656,6 +6161,7 @@ class AiBuilderFacade:
             config=deepcopy(config) if isinstance(config, dict) else {},
             questions=questions,
             associations=associations,
+            buttons_config=buttons_config,
             associated_resources_config=associated_resources_config,
         )
         question_entries = _extract_view_question_entries(config.get("viewgraphQuestions"))
@@ -5682,6 +6188,7 @@ class AiBuilderFacade:
             "verification": verification,
             "verified": all(bool(value) for value in verification.values()),
             "query_conditions": query_conditions,
+            "buttons_config": buttons_config,
             "associated_resources_config": associated_resources_config,
             **response.model_dump(mode="json"),
         }
@@ -6165,6 +6672,173 @@ class AiBuilderFacade:
             "verification": {"field_count": len(field_names)},
         }
 
+    def _expand_view_partial_patches(
+        self,
+        *,
+        profile: str,
+        app_key: str,
+        schema: dict[str, Any],
+        existing_by_key: dict[str, dict[str, Any]],
+        existing_by_name: dict[str, list[dict[str, Any]]],
+        patch_views: list[ViewPartialPatch],
+    ) -> tuple[list[ViewUpsertPatch], list[dict[str, Any]], list[dict[str, Any]]]:
+        parsed_schema = _parse_schema(schema)
+        field_names_by_id = {
+            field_id: str(field.get("name") or "").strip()
+            for field in parsed_schema.get("fields") or []
+            if isinstance(field, dict)
+            and (field_id := _coerce_nonnegative_int(field.get("que_id") or field.get("field_id"))) is not None
+            and str(field.get("name") or "").strip()
+        }
+        expanded: list[ViewUpsertPatch] = []
+        issues: list[dict[str, Any]] = []
+        results: list[dict[str, Any]] = []
+        for index, patch in enumerate(patch_views):
+            view_key = str(patch.view_key or "").strip()
+            name = str(patch.name or "").strip()
+            matched_view: dict[str, Any] | None = None
+            if view_key:
+                matched_view = existing_by_key.get(view_key)
+                if matched_view is None:
+                    issue = {
+                        "error_code": "UNKNOWN_VIEW",
+                        "reason_path": f"patch_views[{index}].view_key",
+                        "view_key": view_key,
+                        "message": "view_key does not exist on this app",
+                    }
+                    issues.append(issue)
+                    results.append({"index": index, "status": "failed", **issue})
+                    continue
+            else:
+                matches = existing_by_name.get(name, [])
+                if len(matches) != 1:
+                    issue = {
+                        "error_code": "AMBIGUOUS_VIEW" if matches else "UNKNOWN_VIEW",
+                        "reason_path": f"patch_views[{index}].name",
+                        "view_name": name,
+                        "matches": [
+                            {"name": _extract_view_name(view), "view_key": _extract_view_key(view), "type": _normalize_view_type_name(view.get("viewgraphType") or view.get("type"))}
+                            for view in matches
+                        ],
+                        "message": "patch_views[] must target a single existing view; use view_key when names are duplicated",
+                    }
+                    issues.append(issue)
+                    results.append({"index": index, "status": "failed", **issue})
+                    continue
+                matched_view = matches[0]
+                view_key = _extract_view_key(matched_view)
+            try:
+                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 {}
+                if not isinstance(config, dict):
+                    config = {}
+            except (QingflowApiError, RuntimeError) as error:
+                api_error = _coerce_api_error(error)
+                issue = {
+                    "error_code": "VIEW_PATCH_CONFIG_READ_FAILED",
+                    "reason_path": f"patch_views[{index}]",
+                    "view_key": view_key,
+                    "message": api_error.message,
+                    "transport_error": _transport_error_payload(api_error),
+                }
+                issues.append(issue)
+                results.append({"index": index, "status": "failed", **issue})
+                continue
+            question_list: list[dict[str, Any]] = []
+            try:
+                question_response = self.views.view_list_questions(profile=profile, viewgraph_key=view_key)
+                raw_questions = question_response.get("result")
+                if isinstance(raw_questions, list):
+                    question_list = [deepcopy(item) for item in raw_questions if isinstance(item, dict)]
+            except (QingflowApiError, RuntimeError):
+                question_list = []
+            base_summary = {
+                "name": _extract_view_name(config) or _extract_view_name(matched_view or {}) or name or view_key,
+                "view_key": view_key,
+                "type": _normalize_view_type_name(config.get("viewgraphType") or (matched_view or {}).get("viewgraphType") or (matched_view or {}).get("type")),
+            }
+            summary = _merge_view_summary_with_config(base_summary, config=config, question_list=question_list)
+            current_payload = _view_upsert_payload_from_existing_view(
+                config=config,
+                summary=summary,
+                view_key=view_key,
+                field_names_by_id=field_names_by_id,
+            )
+            normalized_set, set_issues = _normalize_view_partial_set(patch.set, reason_path=f"patch_views[{index}].set")
+            normalized_unset, unset_issues = _normalize_view_partial_unset(patch.unset, reason_path=f"patch_views[{index}].unset")
+            if set_issues or unset_issues:
+                patch_issues = [*set_issues, *unset_issues]
+                issues.extend(patch_issues)
+                results.append({"index": index, "status": "failed", "view_key": view_key, "issues": patch_issues})
+                continue
+            touched_keys = set(normalized_set) | set(normalized_unset)
+            patch_payload = deepcopy(current_payload)
+            for key, value in normalized_set.items():
+                if key in {"query_conditions", "associated_resources", "visibility"} and isinstance(value, dict):
+                    merged_value = deepcopy(patch_payload.get(key) if isinstance(patch_payload.get(key), dict) else {})
+                    _deep_merge_public_config(merged_value, value)
+                    patch_payload[key] = merged_value
+                else:
+                    patch_payload[key] = value
+            for key in normalized_unset:
+                if key == "filters":
+                    patch_payload["filters"] = []
+                elif key == "buttons":
+                    patch_payload["buttons"] = []
+                elif key == "query_conditions":
+                    patch_payload["query_conditions"] = {"enabled": False, "exact": False, "hide_before_query": False, "rows": []}
+                elif key == "associated_resources":
+                    patch_payload["associated_resources"] = {"visible": False}
+                elif key == "visibility":
+                    patch_payload.pop("visibility", None)
+                else:
+                    issue = {
+                        "error_code": "VIEW_PATCH_UNSET_NOT_SUPPORTED",
+                        "reason_path": f"patch_views[{index}].unset",
+                        "field": key,
+                        "message": f"cannot unset {key}; use set with an explicit replacement value",
+                    }
+                    issues.append(issue)
+            patch_payload["_partial_update"] = True
+            patch_payload["_preserve_filters"] = "filters" not in touched_keys
+            patch_payload["_preserve_buttons"] = "buttons" not in touched_keys
+            patch_payload["_preserve_query_conditions"] = "query_conditions" not in touched_keys
+            patch_payload["_preserve_associated_resources"] = "associated_resources" not in touched_keys
+            try:
+                expanded_patch = ViewUpsertPatch.model_validate(patch_payload)
+            except Exception as error:
+                issue = {
+                    "error_code": "VIEW_PATCH_HYDRATION_FAILED",
+                    "reason_path": f"patch_views[{index}]",
+                    "view_key": view_key,
+                    "message": str(error),
+                    "hydrated_payload": _compact_dict({k: v for k, v in patch_payload.items() if not str(k).startswith("_")}),
+                }
+                issues.append(issue)
+                results.append({"index": index, "status": "failed", **issue})
+                continue
+            expanded.append(expanded_patch)
+            results.append(
+                {
+                    "index": index,
+                    "status": "expanded",
+                    "view_key": view_key,
+                    "set_paths": sorted(normalized_set),
+                    "unset_paths": sorted(normalized_unset),
+                    "preserved_paths": sorted(
+                        key
+                        for key, preserve in {
+                            "filters": expanded_patch.preserve_filters,
+                            "buttons": expanded_patch.preserve_buttons,
+                            "query_conditions": expanded_patch.preserve_query_conditions,
+                            "associated_resources": expanded_patch.preserve_associated_resources,
+                        }.items()
+                        if preserve
+                    ),
+                }
+            )
+        return expanded, issues, results
+
     def app_read(self, *, profile: str, app_key: str, include_raw: bool = False) -> JSONObject:
         state = self._load_app_state(profile=profile, app_key=app_key)
         base_result = state["base"]
@@ -7461,16 +8135,19 @@ class AiBuilderFacade:
         profile: str,
         app_key: str,
         upsert_views: list[ViewUpsertPatch],
+        patch_views: list[ViewPartialPatch] | None = None,
         remove_views: list[str],
         publish: bool = True,
     ) -> JSONObject:
+        patch_views = patch_views or []
         normalized_args = {
             "app_key": app_key,
             "upsert_views": [patch.model_dump(mode="json") for patch in upsert_views],
+            "patch_views": [patch.model_dump(mode="json") for patch in patch_views],
             "remove_views": list(remove_views),
             "publish": publish,
         }
-        if not upsert_views and not remove_views:
+        if not upsert_views and not patch_views and not remove_views:
             response = {
                 "status": "success",
                 "error_code": None,
@@ -7535,6 +8212,28 @@ class AiBuilderFacade:
                 existing_by_name.setdefault(name, []).append(view)
         parsed_schema = _parse_schema(schema)
         field_names = {field["name"] for field in parsed_schema["fields"]}
+        if patch_views:
+            expanded_views, patch_issues, patch_results = self._expand_view_partial_patches(
+                profile=profile,
+                app_key=app_key,
+                schema=schema,
+                existing_by_key=existing_by_key,
+                existing_by_name=existing_by_name,
+                patch_views=patch_views,
+            )
+            if patch_issues:
+                return finalize(
+                    _failed(
+                        "VIEW_PATCH_HYDRATION_FAILED",
+                        "one or more view partial patches could not be hydrated; no write was executed",
+                        normalized_args=normalized_args,
+                        details={"patch_results": patch_results, "blocking_issues": patch_issues},
+                        suggested_next_call={"tool_name": "view_get", "arguments": {"profile": profile, "view_key": patch_issues[0].get("view_key") or "VIEW_KEY"}},
+                    )
+                )
+            upsert_views = [*upsert_views, *expanded_views]
+            normalized_args["upsert_views"] = [patch.model_dump(mode="json") for patch in upsert_views]
+            normalized_args["patch_results"] = patch_results
         current_fields_by_name = {
             str(field.get("name") or ""): field
             for field in parsed_schema["fields"]
@@ -7701,7 +8400,13 @@ class AiBuilderFacade:
                         missing_fields=[gantt_field_name],
                         suggested_next_call={"tool_name": "app_get_fields", "arguments": {"profile": profile, "app_key": app_key}},
                     )
-            translated_filters, filter_issues = _build_view_filter_groups(current_fields_by_name=current_fields_by_name, filters=patch.filters)
+            translated_filters: list[list[dict[str, Any]]] | None
+            filter_issues: list[dict[str, Any]]
+            if patch.preserve_filters:
+                translated_filters = None
+                filter_issues = []
+            else:
+                translated_filters, filter_issues = _build_view_filter_groups(current_fields_by_name=current_fields_by_name, filters=patch.filters)
             if filter_issues:
                 first_issue = filter_issues[0]
                 return _failed(
@@ -7717,10 +8422,15 @@ 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 patch.preserve_query_conditions:
+                query_condition_payload = None
+                expected_query_conditions = None
+                query_condition_issues = []
+            else:
+                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(
@@ -7741,10 +8451,15 @@ class AiBuilderFacade:
                     },
                     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 patch.preserve_associated_resources:
+                associated_resources_payload = None
+                expected_associated_resources = None
+                associated_resource_issues = []
+            else:
+                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(
@@ -7765,7 +8480,10 @@ class AiBuilderFacade:
                 )
             explicit_button_dtos: list[dict[str, Any]] | None = None
             expected_button_summary: list[dict[str, Any]] | None = None
-            if patch.buttons is not None:
+            if patch.preserve_buttons:
+                explicit_button_dtos = None
+                expected_button_summary = None
+            elif patch.buttons is not None:
                 explicit_button_dtos, button_issues = _build_view_button_dtos(
                     current_fields_by_name=current_fields_by_name,
                     bindings=patch.buttons,
@@ -8239,7 +8957,10 @@ class AiBuilderFacade:
                             expected_filter_summary = _normalize_view_filter_groups_for_compare(expected_filters)
                             expected_data_scope = "CUSTOM" if expected_filter_summary else "ALL"
                             actual_data_scope = str(config_result.get("dataScope") or "").strip().upper() or None
-                            filters_verified = actual_filters == expected_filter_summary and actual_data_scope == expected_data_scope
+                            filters_verified = (
+                                _view_filter_groups_equivalent(expected_filter_summary, actual_filters)
+                                and actual_data_scope == expected_data_scope
+                            )
                             verification_entry["filters_verified"] = filters_verified
                             verification_entry["view_key"] = verification_key
                             verification_entry["expected_filters"] = expected_filter_summary
@@ -8737,6 +9458,126 @@ class AiBuilderFacade:
             "verified": verified,
         }
 
+    def _expand_chart_partial_patches(
+        self,
+        *,
+        profile: str,
+        app_key: str,
+        existing_by_id: dict[str, dict[str, Any]],
+        existing_by_name: dict[str, list[dict[str, Any]]],
+        patch_charts: list[ChartPartialPatch],
+    ) -> tuple[list[ChartUpsertPatch], list[dict[str, Any]], list[dict[str, Any]]]:
+        expanded: list[ChartUpsertPatch] = []
+        issues: list[dict[str, Any]] = []
+        results: list[dict[str, Any]] = []
+        for index, patch in enumerate(patch_charts):
+            chart_id = str(patch.chart_id or "").strip()
+            if chart_id:
+                if chart_id not in existing_by_id:
+                    issue = {
+                        "error_code": "CHART_NOT_FOUND",
+                        "reason_path": f"patch_charts[{index}].chart_id",
+                        "chart_id": chart_id,
+                        "message": "chart_id does not exist under this app",
+                    }
+                    issues.append(issue)
+                    results.append({"index": index, "status": "failed", **issue})
+                    continue
+            else:
+                name = str(patch.name or "").strip()
+                matches = existing_by_name.get(name, [])
+                if len(matches) != 1:
+                    issue = {
+                        "error_code": "AMBIGUOUS_CHART" if matches else "CHART_NOT_FOUND",
+                        "reason_path": f"patch_charts[{index}].name",
+                        "name": name,
+                        "candidate_chart_ids": [
+                            _extract_chart_identifier(item)
+                            for item in matches
+                            if _extract_chart_identifier(item)
+                        ],
+                        "message": "patch_charts[] must target a single existing chart; use chart_id when names are duplicated",
+                    }
+                    issues.append(issue)
+                    results.append({"index": index, "status": "failed", **issue})
+                    continue
+                chart_id = _extract_chart_identifier(matches[0])
+                if not chart_id:
+                    issue = {"error_code": "CHART_ID_MISSING", "reason_path": f"patch_charts[{index}].name", "name": name}
+                    issues.append(issue)
+                    results.append({"index": index, "status": "failed", **issue})
+                    continue
+            try:
+                base = self.charts.qingbi_report_get_base(profile=profile, chart_id=chart_id).get("result") or {}
+                config = self.charts.qingbi_report_get_config(profile=profile, chart_id=chart_id).get("result") or {}
+                if not isinstance(base, dict):
+                    base = {}
+                if not isinstance(config, dict):
+                    config = {}
+            except (QingflowApiError, RuntimeError) as error:
+                api_error = _coerce_api_error(error)
+                issue = {
+                    "error_code": "CHART_PATCH_DETAIL_READ_FAILED",
+                    "reason_path": f"patch_charts[{index}]",
+                    "chart_id": chart_id,
+                    "message": api_error.message,
+                    "transport_error": _transport_error_payload(api_error),
+                }
+                issues.append(issue)
+                results.append({"index": index, "status": "failed", **issue})
+                continue
+            patch_payload = _chart_upsert_payload_from_existing(chart_id=chart_id, base=base, config=config)
+            normalized_set, set_issues = _normalize_chart_partial_set(patch.set, reason_path=f"patch_charts[{index}].set")
+            normalized_unset, unset_issues = _normalize_chart_partial_unset(patch.unset, reason_path=f"patch_charts[{index}].unset")
+            if set_issues or unset_issues:
+                patch_issues = [*set_issues, *unset_issues]
+                issues.extend(patch_issues)
+                results.append({"index": index, "status": "failed", "chart_id": chart_id, "issues": patch_issues})
+                continue
+            explicit_set_paths = set(normalized_set)
+            for key, value in normalized_set.items():
+                if key in {"config", "visibility"} and isinstance(value, dict):
+                    merged_value = deepcopy(patch_payload.get(key) if isinstance(patch_payload.get(key), dict) else {})
+                    _deep_merge_public_config(merged_value, value)
+                    patch_payload[key] = merged_value
+                else:
+                    patch_payload[key] = value
+            for key in normalized_unset:
+                if key == "filters":
+                    patch_payload["filters"] = []
+                    explicit_set_paths.add("filters")
+                elif key in {"question_config", "user_config"}:
+                    patch_payload[key] = []
+                    explicit_set_paths.add(key)
+                elif key == "visibility":
+                    patch_payload.pop("visibility", None)
+            try:
+                expanded_patch = ChartUpsertPatch.model_validate(patch_payload)
+            except Exception as error:
+                issue = {
+                    "error_code": "CHART_PATCH_HYDRATION_FAILED",
+                    "reason_path": f"patch_charts[{index}]",
+                    "chart_id": chart_id,
+                    "message": str(error),
+                    "hydrated_payload": _compact_dict(patch_payload),
+                }
+                issues.append(issue)
+                results.append({"index": index, "status": "failed", **issue})
+                continue
+            # Preserve model_fields_set semantics so config generation knows which public fields were explicitly replaced.
+            expanded_patch.__pydantic_fields_set__ = set(explicit_set_paths)
+            expanded.append(expanded_patch)
+            results.append(
+                {
+                    "index": index,
+                    "status": "expanded",
+                    "chart_id": chart_id,
+                    "set_paths": sorted(normalized_set),
+                    "unset_paths": sorted(normalized_unset),
+                }
+            )
+        return expanded, issues, results
+
     def chart_apply(self, *, profile: str, request: ChartApplyRequest) -> JSONObject:
         normalized_args = request.model_dump(mode="json")
         permission_outcomes: list[PermissionCheckOutcome] = []
@@ -8796,14 +9637,44 @@ class AiBuilderFacade:
                 continue
             existing_by_name.setdefault(item_name, []).append(deepcopy(item))
 
+        upsert_charts = list(request.upsert_charts)
+        if request.patch_charts:
+            expanded_charts, patch_issues, patch_results = self._expand_chart_partial_patches(
+                profile=profile,
+                app_key=app_key,
+                existing_by_id=existing_by_id,
+                existing_by_name=existing_by_name,
+                patch_charts=request.patch_charts,
+            )
+            if patch_issues:
+                return finalize(
+                    _failed(
+                        "CHART_PATCH_HYDRATION_FAILED",
+                        "one or more chart partial patches could not be hydrated; no write was executed",
+                        normalized_args=normalized_args,
+                        details={"patch_results": patch_results, "blocking_issues": patch_issues},
+                        suggested_next_call={"tool_name": "chart_get", "arguments": {"profile": profile, "chart_id": patch_issues[0].get("chart_id") or "CHART_ID"}},
+                    )
+                )
+            upsert_charts.extend(expanded_charts)
+            normalized_args["upsert_charts"] = [patch.model_dump(mode="json") for patch in upsert_charts]
+            normalized_args["patch_results"] = patch_results
+
         chart_results: list[dict[str, Any]] = []
         created_ids: list[str] = []
         updated_ids: list[str] = []
         removed_ids: list[str] = []
         failed_items: list[dict[str, Any]] = []
 
-        for patch in request.upsert_charts:
+        for patch in upsert_charts:
             try:
+                dataset_source = _chart_patch_dataset_source_type(patch)
+                if dataset_source:
+                    raise ValueError(
+                        "app_charts_apply only creates or edits app-source QingBI reports with dataSourceType=qingflow; "
+                        f"dataset report source '{dataset_source}' is not supported for creation/update yet. "
+                        "Create the dataset report in QingBI first, then attach it with app_associated_resources_apply using report_source='dataset'."
+                    )
                 config_update_requested = _chart_patch_updates_chart_config(patch)
                 chart_visible_auth = (
                     self._compile_visibility_to_chart_visible_auth(profile=profile, visibility=patch.visibility)
@@ -8827,6 +9698,13 @@ class AiBuilderFacade:
                 existing_name = str((existing or {}).get("chartName") or "").strip()
                 existing_type = _normalize_backend_chart_type((existing or {}).get("chartType"))
                 target_type = _map_public_chart_type_to_backend(patch.chart_type)
+                existing_source_type = _chart_item_dataset_source_type(existing or {})
+                if existing_source_type:
+                    raise ValueError(
+                        "app_charts_apply only creates or edits app-source QingBI reports with dataSourceType=qingflow; "
+                        f"existing chart '{chart_id or patch.name}' uses dataset report source '{existing_source_type}' and is not supported for update yet. "
+                        "Update it in QingBI directly, then attach the existing report with app_associated_resources_apply using report_source='dataset'."
+                    )
                 if existing is None:
                     temp_chart_id = str(patch.chart_id or f"mcp_{uuid4().hex[:16]}")
                     create_payload = {
@@ -10154,6 +11032,94 @@ def _custom_button_add_data_config_has_semantic_inputs(value: dict[str, Any]) ->
     return bool(value.get("field_mappings") or value.get("fieldMappings") or value.get("default_values") or value.get("defaultValues"))
 
 
+def _normalize_custom_button_add_data_config_for_public(value: dict[str, Any]) -> dict[str, Any]:
+    normalized: dict[str, Any] = {}
+    related_app_key = _first_present(value, "related_app_key", "relatedAppKey", "target_app_key", "targetAppKey")
+    related_app_name = _first_present(value, "related_app_name", "relatedAppName")
+    if related_app_key is not None:
+        normalized["related_app_key"] = related_app_key
+    if related_app_name is not None:
+        normalized["related_app_name"] = related_app_name
+    relation_rules = _first_present(value, "que_relation", "queRelation")
+    if isinstance(relation_rules, list):
+        normalized["que_relation"] = [
+            _normalize_custom_button_match_rule_for_public(rule)
+            for rule in relation_rules
+            if isinstance(rule, dict)
+        ]
+    field_mappings = _first_present(value, "field_mappings", "fieldMappings", "mappings")
+    if isinstance(field_mappings, list):
+        normalized["field_mappings"] = deepcopy(field_mappings)
+    default_values = _first_present(value, "default_values", "defaultValues", "defaults")
+    if isinstance(default_values, dict):
+        normalized["default_values"] = deepcopy(default_values)
+    return _compact_dict(normalized)
+
+
+def _normalize_custom_button_match_rule_for_public(value: dict[str, Any]) -> dict[str, Any]:
+    normalized: dict[str, Any] = {}
+    key_pairs = {
+        "que_id": ("que_id", "queId"),
+        "que_title": ("que_title", "queTitle"),
+        "que_type": ("que_type", "queType"),
+        "date_type": ("date_type", "dateType"),
+        "judge_type": ("judge_type", "judgeType"),
+        "match_type": ("match_type", "matchType"),
+        "judge_que_type": ("judge_que_type", "judgeQueType"),
+        "judge_que_id": ("judge_que_id", "judgeQueId"),
+        "path_value": ("path_value", "pathValue"),
+        "table_update_type": ("table_update_type", "tableUpdateType"),
+        "multi_value": ("multi_value", "multiValue"),
+        "add_rule": ("add_rule", "addRule"),
+        "field_id_prefix": ("field_id_prefix", "fieldIdPrefix"),
+    }
+    for public_key, aliases in key_pairs.items():
+        raw_value = _first_present(value, *aliases)
+        if raw_value is not None:
+            normalized[public_key] = raw_value
+    judge_values = _first_present(value, "judge_values", "judgeValues")
+    if isinstance(judge_values, list):
+        normalized["judge_values"] = [str(item) for item in judge_values if item is not None]
+    elif judge_values is not None:
+        normalized["judge_values"] = [str(judge_values)]
+    judge_que_detail = _first_present(value, "judge_que_detail", "judgeQueDetail")
+    if isinstance(judge_que_detail, dict):
+        normalized["judge_que_detail"] = _compact_dict(
+            {
+                "que_id": _first_present(judge_que_detail, "que_id", "queId"),
+                "que_title": _first_present(judge_que_detail, "que_title", "queTitle"),
+                "que_type": _first_present(judge_que_detail, "que_type", "queType"),
+            }
+        )
+    judge_value_details = _first_present(value, "judge_value_details", "judgeValueDetails")
+    if isinstance(judge_value_details, list):
+        details: list[dict[str, Any]] = []
+        for item in judge_value_details:
+            if not isinstance(item, dict):
+                continue
+            detail = _compact_dict(
+                {
+                    "id": _first_present(item, "id", "opt_id", "optId", "member_id", "memberId"),
+                    "value": _first_present(item, "value", "name", "label", "title"),
+                }
+            )
+            if detail:
+                details.append(detail)
+        normalized["judge_value_details"] = details
+    filter_condition = _first_present(value, "filter_condition", "filterCondition")
+    if isinstance(filter_condition, list):
+        normalized["filter_condition"] = [
+            [
+                _normalize_custom_button_match_rule_for_public(item)
+                for item in group
+                if isinstance(item, dict)
+            ]
+            for group in filter_condition
+            if isinstance(group, list)
+        ]
+    return _compact_dict(normalized)
+
+
 def _custom_button_selector_payload(selector: Any) -> dict[str, Any]:
     if isinstance(selector, dict):
         payload = dict(selector)
@@ -10171,11 +11137,83 @@ def _custom_button_selector_payload(selector: Any) -> dict[str, Any]:
     raw = str(selector or "").strip()
     if not raw:
         return {}
-    if raw.isdigit():
-        return {"que_id": int(raw)}
+    parsed_int = _coerce_any_int(raw)
+    if parsed_int is not None:
+        return {"que_id": parsed_int}
     return {"name": raw}
 
 
+_SYSTEM_MATCH_FIELD_ALIASES: dict[str, int] = {
+    "数据id": -17,
+    "数据ID": -17,
+    "数据_id": -17,
+    "row_record_id": -17,
+    "data_id": -17,
+    "record_id": -17,
+    "apply_id": -17,
+    "_id": -17,
+    "编号": 0,
+    "数据编号": 0,
+    "record_number": 0,
+    "serial_number": 0,
+    "apply_num": 0,
+    "data_num": 0,
+}
+
+
+def _normalize_system_match_alias(value: Any) -> str:
+    raw = str(value or "").strip()
+    if raw.startswith("{{") and raw.endswith("}}"):
+        raw = raw[2:-2].strip()
+    return raw.replace(" ", "").lower()
+
+
+def _system_match_field_from_selector(selector: Any) -> dict[str, Any] | None:
+    if isinstance(selector, dict):
+        for key in ("field_id", "fieldId", "que_id", "queId"):
+            parsed = _coerce_any_int(selector.get(key))
+            if parsed in {-17, 0}:
+                return _system_match_field(parsed)
+        for key in ("name", "title", "label", "value", "field", "source_field", "target_field"):
+            raw = str(selector.get(key) or "").strip()
+            if raw:
+                field = _system_match_field_from_selector(raw)
+                if field is not None:
+                    return field
+        return None
+    parsed = _coerce_any_int(selector)
+    if parsed in {-17, 0}:
+        return _system_match_field(parsed)
+    normalized = _normalize_system_match_alias(selector)
+    if normalized in _SYSTEM_MATCH_FIELD_ALIASES:
+        return _system_match_field(_SYSTEM_MATCH_FIELD_ALIASES[normalized])
+    return None
+
+
+def _system_match_field(que_id: int) -> dict[str, Any] | None:
+    if que_id == -17:
+        return {
+            "field_id": -17,
+            "que_id": -17,
+            "que_type": 8,
+            "name": "数据ID",
+            "type": "system_record_id",
+            "system_field": True,
+            "system_kind": "row_record_id",
+        }
+    if que_id == 0:
+        return {
+            "field_id": 0,
+            "que_id": 0,
+            "que_type": 8,
+            "name": "编号",
+            "type": "system_record_number",
+            "system_field": True,
+            "system_kind": "record_number",
+        }
+    return None
+
+
 def _resolve_custom_button_schema_field(
     *,
     fields: list[dict[str, Any]],
@@ -10184,6 +11222,11 @@ def _resolve_custom_button_schema_field(
     role: str,
 ) -> tuple[dict[str, Any] | None, dict[str, Any] | None]:
     selector_payload = _custom_button_selector_payload(selector)
+    allow_system = role in {"source", "match_source", "match_target"}
+    if allow_system:
+        system_field = _system_match_field_from_selector(selector_payload or selector)
+        if system_field is not None:
+            return system_field, None
     if not selector_payload:
         return None, {
             "error_code": "CUSTOM_BUTTON_MAPPING_FIELD_NOT_FOUND",
@@ -10193,18 +11236,19 @@ def _resolve_custom_button_schema_field(
         }
     matched: list[dict[str, Any]] = []
     field_id = selector_payload.get("field_id")
-    que_id = _coerce_nonnegative_int(selector_payload.get("que_id"))
+    que_id = _coerce_any_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()
+        field_id_int = _coerce_any_int(field_id_text)
         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))
+            or (field_id_int is not None and _coerce_any_int(field.get("que_id")) == field_id_int)
         ]
     elif que_id is not None:
-        matched = [field for field in fields if _coerce_nonnegative_int(field.get("que_id")) == que_id]
+        matched = [field for field in fields if _coerce_any_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:
@@ -10227,40 +11271,239 @@ def _custom_button_mapping_type_issue(
     source_field: dict[str, Any],
     target_field: dict[str, Any],
     reason_path: str,
+    source_app_key: str | None = None,
+    error_code: str = "CUSTOM_BUTTON_MAPPING_TYPE_MISMATCH",
+    context_label: str = "field mapping",
 ) -> dict[str, Any] | None:
     source_type = str(source_field.get("type") or "")
     target_type = str(target_field.get("type") or "")
+    compatible, reason = _match_mapping_types_compatible(
+        source_field=source_field,
+        target_field=target_field,
+        source_app_key=source_app_key,
+    )
+    if compatible:
+        return None
+    if reason == "reference_source_mismatch":
+        target_app_key = _relation_target_app_key(target_field)
+        return {
+            "error_code": "MATCH_RULE_REFERENCE_SOURCE_MISMATCH",
+            "reason_path": reason_path,
+            "source_app_key": source_app_key,
+            "target_relation_app_key": target_app_key,
+            "source_field": _match_field_summary(source_field),
+            "target_field": _match_field_summary(target_field),
+            "message": "数据ID represents the current source record, but the target relation field points to another app",
+            "next_action": "choose a relation field that targets the current source app, or map a compatible non-relation field",
+        }
+    return {
+        "error_code": error_code,
+        "reason_path": reason_path,
+        "source_field": _match_field_summary(source_field),
+        "target_field": _match_field_summary(target_field),
+        "message": f"source and target fields have incompatible types for {context_label}",
+        "compatibility_reason": reason,
+        "next_action": "choose fields with the same type family; use 数据ID only for current-record id/relation matching and use static value/default_values for constants",
+    }
+
+
+def _retag_associated_resource_match_field_issue(issue: dict[str, Any]) -> dict[str, Any]:
+    retagged = dict(issue)
+    code = str(retagged.get("error_code") or "")
+    if code == "CUSTOM_BUTTON_MAPPING_FIELD_NOT_FOUND":
+        retagged["error_code"] = "ASSOCIATED_RESOURCE_MAPPING_FIELD_NOT_FOUND"
+    elif code == "CUSTOM_BUTTON_MAPPING_FIELD_AMBIGUOUS":
+        retagged["error_code"] = "ASSOCIATED_RESOURCE_MAPPING_FIELD_AMBIGUOUS"
+    return retagged
+
+
+def _retag_associated_resource_static_value_issue(issue: dict[str, Any]) -> dict[str, Any]:
+    retagged = dict(issue)
+    if str(retagged.get("error_code") or "") == "CUSTOM_BUTTON_DEFAULT_VALUE_UNSUPPORTED":
+        retagged["error_code"] = "ASSOCIATED_RESOURCE_STATIC_VALUE_UNSUPPORTED"
+        retagged["message"] = str(retagged.get("message") or "static associated resource match value is unsupported")
+        retagged["next_action"] = str(
+            retagged.get("next_action")
+            or "retry match_mappings[].value with a literal value supported by the target field type"
+        )
+    return retagged
+
+
+def _match_field_summary(field: dict[str, Any]) -> dict[str, Any]:
+    return {
+        "title": field.get("name"),
+        "field_id": field.get("field_id"),
+        "que_id": field.get("que_id"),
+        "type": field.get("type"),
+        "system_field": bool(field.get("system_field")),
+    }
+
+
+def _relation_target_app_key(field: dict[str, Any]) -> str | None:
+    for key in ("target_app_key", "targetAppKey", "refer_app_key", "referAppKey"):
+        value = str(field.get(key) or "").strip()
+        if value:
+            return value
+    for container_key in ("relation", "reference", "reference_config", "referenceConfig", "config"):
+        container = field.get(container_key)
+        if not isinstance(container, dict):
+            continue
+        nested = _relation_target_app_key(container)
+        if nested:
+            return nested
+    template = field.get("_reference_config_template")
+    if isinstance(template, dict):
+        nested = _relation_target_app_key(template)
+        if nested:
+            return nested
+    return None
+
+
+def _match_mapping_types_compatible(
+    *,
+    source_field: dict[str, Any],
+    target_field: dict[str, Any],
+    source_app_key: str | None = None,
+) -> tuple[bool, str | None]:
+    source_type = str(source_field.get("type") or "")
+    target_type = str(target_field.get("type") or "")
+    unsupported = {
+        FieldType.attachment.value,
+        FieldType.subtable.value,
+        FieldType.code_block.value,
+        FieldType.q_linker.value,
+        FieldType.address.value,
+    }
+    if source_type in unsupported or target_type in unsupported:
+        return False, "unsupported_field_type"
+
+    if target_type == FieldType.relation.value:
+        if source_type == "system_record_id":
+            target_app_key = _relation_target_app_key(target_field)
+            if source_app_key and target_app_key and str(target_app_key).strip() != str(source_app_key).strip():
+                return False, "reference_source_mismatch"
+            return True, None
+        if source_type == FieldType.relation.value:
+            source_target = _relation_target_app_key(source_field)
+            target_target = _relation_target_app_key(target_field)
+            if source_target and target_target and source_target != target_target:
+                return False, "relation_target_app_mismatch"
+            return True, None
+        return False, "relation_requires_record_id_or_relation"
+    if source_type == FieldType.relation.value:
+        if target_type == "system_record_id":
+            return True, None
+        return False, "relation_only_matches_relation_or_record_id"
+
+    if source_type == "system_record_id":
+        if target_type in {
+            "system_record_id",
+            FieldType.text.value,
+            FieldType.long_text.value,
+            FieldType.number.value,
+            FieldType.amount.value,
+        }:
+            return True, None
+        return False, "record_id_requires_relation_or_id_compatible_target"
+    if target_type == "system_record_id":
+        if source_type in {
+            "system_record_id",
+            FieldType.text.value,
+            FieldType.long_text.value,
+            FieldType.number.value,
+            FieldType.amount.value,
+        }:
+            return True, None
+        return False, "record_id_requires_id_compatible_source"
+
+    if source_type == "system_record_number":
+        if target_type in {
+            "system_record_number",
+            FieldType.text.value,
+            FieldType.long_text.value,
+            FieldType.number.value,
+            FieldType.amount.value,
+        }:
+            return True, None
+        return False, "record_number_requires_text_or_number_target"
+    if target_type == "system_record_number":
+        if source_type in {
+            "system_record_number",
+            FieldType.text.value,
+            FieldType.long_text.value,
+            FieldType.number.value,
+            FieldType.amount.value,
+        }:
+            return True, None
+        return False, "record_number_requires_text_or_number_source"
+
+    exact_only = {FieldType.member.value, FieldType.department.value}
+    if source_type in exact_only or target_type in exact_only:
+        return (source_type == target_type, None if source_type == target_type else "member_department_require_same_type")
+
     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",
+    if source_type == target_type or any(source_type in group and target_type in group for group in compatible_groups):
+        return True, None
+    return False, "different_type_family"
+
+
+def _match_mapping_operator_to_judge_type(operator: Any, *, reason_path: str) -> tuple[int, dict[str, Any] | None]:
+    normalized = str(operator or "eq").strip().lower()
+    aliases = {
+        "eq": JUDGE_EQUAL,
+        "equal": JUDGE_EQUAL,
+        "=": JUDGE_EQUAL,
+        "==": JUDGE_EQUAL,
+        "neq": JUDGE_UNEQUAL,
+        "ne": JUDGE_UNEQUAL,
+        "!=": JUDGE_UNEQUAL,
+        "not_eq": JUDGE_UNEQUAL,
+        "not_equal": JUDGE_UNEQUAL,
+        "gte": JUDGE_GREATER_OR_EQUAL,
+        "ge": JUDGE_GREATER_OR_EQUAL,
+        ">=": JUDGE_GREATER_OR_EQUAL,
+        "greater_or_equal": JUDGE_GREATER_OR_EQUAL,
+        "lte": JUDGE_LESS_OR_EQUAL,
+        "le": JUDGE_LESS_OR_EQUAL,
+        "<=": JUDGE_LESS_OR_EQUAL,
+        "less_or_equal": JUDGE_LESS_OR_EQUAL,
+        "contains": JUDGE_FUZZY_MATCH,
+        "like": JUDGE_FUZZY_MATCH,
+        "fuzzy": JUDGE_FUZZY_MATCH,
+        "fuzzy_match": JUDGE_FUZZY_MATCH,
+        "in": JUDGE_EQUAL_ANY,
+        "any": JUDGE_EQUAL_ANY,
+        "equal_any": JUDGE_EQUAL_ANY,
+        "include_any": JUDGE_INCLUDE_ANY,
+        "includes_any": JUDGE_INCLUDE_ANY,
+    }
+    if normalized in aliases:
+        return aliases[normalized], None
+    return JUDGE_EQUAL, {
+        "error_code": "INVALID_MATCH_MAPPING_OPERATOR",
         "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",
+        "operator": operator,
+        "allowed_values": sorted(aliases),
+        "message": "match_mappings[].operator is not supported",
+        "next_action": "retry with one of the allowed operator values, such as eq, contains, in, gte, or lte",
     }
 
 
 def _custom_button_question_ref(field: dict[str, Any]) -> dict[str, Any]:
     return {
-        "que_id": _coerce_nonnegative_int(field.get("que_id")),
+        "que_id": _coerce_any_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"))
+    source_que_id = _coerce_any_int(source_field.get("que_id"))
     return {
         **_custom_button_question_ref(target_field),
         "match_type": MATCH_TYPE_QUESTION,
@@ -10285,6 +11528,36 @@ def _custom_button_default_value_rule(*, target_field: dict[str, Any], value_det
     }
 
 
+def _summarize_compiled_match_rules(rules: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    return [
+        _compact_dict(
+            {
+                "target_field": {
+                    "title": rule.get("que_title"),
+                    "field_id": rule.get("que_id"),
+                    "que_id": rule.get("que_id"),
+                    "que_type": rule.get("que_type"),
+                },
+                "match_type": rule.get("match_type"),
+                "judge_type": rule.get("judge_type"),
+                "source_field": (
+                    {
+                        "title": (rule.get("judge_que_detail") or {}).get("que_title"),
+                        "field_id": rule.get("judge_que_id"),
+                        "que_id": rule.get("judge_que_id"),
+                        "que_type": rule.get("judge_que_type"),
+                    }
+                    if rule.get("match_type") == MATCH_TYPE_QUESTION
+                    else None
+                ),
+                "static_values": rule.get("judge_value_details") or rule.get("judge_values") if rule.get("match_type") != MATCH_TYPE_QUESTION else None,
+            }
+        )
+        for rule in rules
+        if isinstance(rule, dict)
+    ]
+
+
 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)
@@ -10438,30 +11711,172 @@ def _normalize_custom_button_summary(item: dict[str, Any]) -> dict[str, Any]:
     return normalized
 
 
-def _normalize_custom_button_detail(item: dict[str, Any]) -> dict[str, Any]:
-    normalized = _normalize_custom_button_summary(item)
-    normalized.update(
-        {
-            "trigger_action": str(item.get("trigger_action") or item.get("triggerAction") or "").strip() or None,
-            "trigger_link_url": str(item.get("trigger_link_url") or item.get("triggerLinkUrl") or "").strip() or None,
-        }
-    )
-    trigger_add_data_config = item.get("trigger_add_data_config")
-    if not isinstance(trigger_add_data_config, dict):
-        trigger_add_data_config = item.get("triggerAddDataConfig")
-    if isinstance(trigger_add_data_config, dict):
-        normalized["trigger_add_data_config"] = deepcopy(trigger_add_data_config)
-    external_qrobot_config = item.get("external_qrobot_config")
-    if not isinstance(external_qrobot_config, dict):
-        external_qrobot_config = item.get("customButtonExternalQRobotRelationVO")
-    if isinstance(external_qrobot_config, dict):
-        normalized["external_qrobot_config"] = deepcopy(external_qrobot_config)
-    trigger_wings_config = item.get("trigger_wings_config")
-    if not isinstance(trigger_wings_config, dict):
-        trigger_wings_config = item.get("triggerWingsConfig")
-    if isinstance(trigger_wings_config, dict):
-        normalized["trigger_wings_config"] = deepcopy(trigger_wings_config)
-    return normalized
+def _normalize_custom_button_detail(item: dict[str, Any]) -> dict[str, Any]:
+    normalized = _normalize_custom_button_summary(item)
+    normalized.update(
+        {
+            "trigger_action": str(item.get("trigger_action") or item.get("triggerAction") or "").strip() or None,
+            "trigger_link_url": str(item.get("trigger_link_url") or item.get("triggerLinkUrl") or "").strip() or None,
+        }
+    )
+    trigger_add_data_config = item.get("trigger_add_data_config")
+    if not isinstance(trigger_add_data_config, dict):
+        trigger_add_data_config = item.get("triggerAddDataConfig")
+    if isinstance(trigger_add_data_config, dict):
+        normalized["trigger_add_data_config"] = _normalize_custom_button_add_data_config_for_public(trigger_add_data_config)
+    external_qrobot_config = item.get("external_qrobot_config")
+    if not isinstance(external_qrobot_config, dict):
+        external_qrobot_config = item.get("customButtonExternalQRobotRelationVO")
+    if isinstance(external_qrobot_config, dict):
+        normalized["external_qrobot_config"] = deepcopy(external_qrobot_config)
+    trigger_wings_config = item.get("trigger_wings_config")
+    if not isinstance(trigger_wings_config, dict):
+        trigger_wings_config = item.get("triggerWingsConfig")
+    if isinstance(trigger_wings_config, dict):
+        normalized["trigger_wings_config"] = deepcopy(trigger_wings_config)
+    return normalized
+
+
+_CUSTOM_BUTTON_PARTIAL_PATCH_KEY_ALIASES = {
+    "button_text": "button_text",
+    "buttonText": "button_text",
+    "name": "button_text",
+    "text": "button_text",
+    "background_color": "background_color",
+    "backgroundColor": "background_color",
+    "text_color": "text_color",
+    "textColor": "text_color",
+    "button_icon": "button_icon",
+    "buttonIcon": "button_icon",
+    "style_preset": "style_preset",
+    "stylePreset": "style_preset",
+    "trigger_action": "trigger_action",
+    "triggerAction": "trigger_action",
+    "trigger_link_url": "trigger_link_url",
+    "triggerLinkUrl": "trigger_link_url",
+    "trigger_add_data_config": "trigger_add_data_config",
+    "triggerAddDataConfig": "trigger_add_data_config",
+    "add_data_config": "trigger_add_data_config",
+    "addDataConfig": "trigger_add_data_config",
+    "external_qrobot_config": "external_qrobot_config",
+    "externalQrobotConfig": "external_qrobot_config",
+    "customButtonExternalQRobotRelationVO": "external_qrobot_config",
+    "trigger_wings_config": "trigger_wings_config",
+    "triggerWingsConfig": "trigger_wings_config",
+}
+
+_CUSTOM_BUTTON_PARTIAL_SET_KEYS = {
+    "button_text",
+    "background_color",
+    "text_color",
+    "button_icon",
+    "style_preset",
+    "trigger_action",
+    "trigger_link_url",
+    "trigger_add_data_config",
+    "external_qrobot_config",
+    "trigger_wings_config",
+}
+
+_CUSTOM_BUTTON_PARTIAL_UNSET_KEYS = {
+    "trigger_link_url",
+    "trigger_add_data_config",
+    "external_qrobot_config",
+    "trigger_wings_config",
+}
+
+
+def _canonical_custom_button_partial_patch_key(key: Any) -> str:
+    raw = str(key or "").strip()
+    return _CUSTOM_BUTTON_PARTIAL_PATCH_KEY_ALIASES.get(raw, raw)
+
+
+def _normalize_custom_button_partial_set(raw_set: Any, *, reason_path: str) -> tuple[dict[str, Any], list[dict[str, Any]]]:
+    if not isinstance(raw_set, dict):
+        return {}, [{"error_code": "INVALID_CUSTOM_BUTTON_PATCH_SET", "reason_path": reason_path, "message": "patch_buttons[].set must be an object"}]
+    normalized: dict[str, Any] = {}
+    issues: list[dict[str, Any]] = []
+    for raw_key, value in raw_set.items():
+        key_path = [part for part in str(raw_key or "").strip().split(".") if part]
+        if not key_path:
+            continue
+        root = _canonical_custom_button_partial_patch_key(key_path[0])
+        if root not in _CUSTOM_BUTTON_PARTIAL_SET_KEYS:
+            issues.append(
+                {
+                    "error_code": "UNSUPPORTED_CUSTOM_BUTTON_PATCH_FIELD",
+                    "reason_path": f"{reason_path}.{raw_key}",
+                    "field": raw_key,
+                    "allowed_fields": sorted(_CUSTOM_BUTTON_PARTIAL_SET_KEYS),
+                }
+            )
+            continue
+        if len(key_path) == 1:
+            normalized[root] = value
+            continue
+        target = normalized.setdefault(root, {})
+        if not isinstance(target, dict):
+            issues.append(
+                {
+                    "error_code": "INVALID_CUSTOM_BUTTON_PATCH_PATH",
+                    "reason_path": f"{reason_path}.{raw_key}",
+                    "message": "cannot combine a scalar replacement and nested patch for the same field",
+                }
+            )
+            continue
+        cursor = target
+        for part in key_path[1:-1]:
+            next_value = cursor.setdefault(part, {})
+            if not isinstance(next_value, dict):
+                issues.append({"error_code": "INVALID_CUSTOM_BUTTON_PATCH_PATH", "reason_path": f"{reason_path}.{raw_key}"})
+                break
+            cursor = next_value
+        else:
+            cursor[key_path[-1]] = value
+    return normalized, issues
+
+
+def _normalize_custom_button_partial_unset(raw_unset: Any, *, reason_path: str) -> tuple[set[str], list[dict[str, Any]]]:
+    if not isinstance(raw_unset, list):
+        return set(), [{"error_code": "INVALID_CUSTOM_BUTTON_PATCH_UNSET", "reason_path": reason_path, "message": "patch_buttons[].unset must be a list"}]
+    normalized: set[str] = set()
+    issues: list[dict[str, Any]] = []
+    for index, raw_key in enumerate(raw_unset):
+        root = _canonical_custom_button_partial_patch_key(str(raw_key or "").strip().split(".")[0])
+        if root not in _CUSTOM_BUTTON_PARTIAL_UNSET_KEYS:
+            issues.append(
+                {
+                    "error_code": "UNSUPPORTED_CUSTOM_BUTTON_PATCH_UNSET_FIELD",
+                    "reason_path": f"{reason_path}[{index}]",
+                    "field": raw_key,
+                    "allowed_fields": sorted(_CUSTOM_BUTTON_PARTIAL_UNSET_KEYS),
+                }
+            )
+            continue
+        normalized.add(root)
+    return normalized, issues
+
+
+def _custom_button_upsert_payload_from_detail(
+    detail: dict[str, Any],
+    *,
+    button_id: int,
+    client_key: str | None = None,
+) -> dict[str, Any]:
+    payload = {
+        "button_id": button_id,
+        "client_key": client_key,
+        "button_text": detail.get("button_text"),
+        "background_color": detail.get("background_color"),
+        "text_color": detail.get("text_color"),
+        "button_icon": detail.get("button_icon"),
+        "trigger_action": detail.get("trigger_action"),
+        "trigger_link_url": detail.get("trigger_link_url"),
+        "trigger_add_data_config": deepcopy(detail.get("trigger_add_data_config")) if isinstance(detail.get("trigger_add_data_config"), dict) else None,
+        "external_qrobot_config": deepcopy(detail.get("external_qrobot_config")) if isinstance(detail.get("external_qrobot_config"), dict) else None,
+        "trigger_wings_config": deepcopy(detail.get("trigger_wings_config")) if isinstance(detail.get("trigger_wings_config"), dict) else None,
+    }
+    return _compact_dict(payload)
 
 
 def _failed(
@@ -10947,13 +12362,135 @@ def _bi_field_id_for_field(*, app_key: str, field: dict[str, Any], qingbi_fields
 
 
 def _map_public_chart_type_to_backend(chart_type: PublicChartType) -> str:
-    return {
+    aliases = {
         PublicChartType.target: "indicator",
+        PublicChartType.indicator: "indicator",
         PublicChartType.pie: "pie",
         PublicChartType.bar: "bar",
         PublicChartType.line: "line",
         PublicChartType.table: "detail",
-    }[chart_type]
+        PublicChartType.detail: "detail",
+    }
+    return aliases.get(chart_type, chart_type.value)
+
+
+_CHART_PARTIAL_PATCH_KEY_ALIASES = {
+    "name": "name",
+    "chart_name": "name",
+    "chartName": "name",
+    "type": "chart_type",
+    "chart_type": "chart_type",
+    "chartType": "chart_type",
+    "dimension_fields": "dimension_field_ids",
+    "dimension_field_ids": "dimension_field_ids",
+    "dimensionFieldIds": "dimension_field_ids",
+    "indicator_fields": "indicator_field_ids",
+    "indicator_field_ids": "indicator_field_ids",
+    "indicatorFieldIds": "indicator_field_ids",
+    "metric_field_ids": "indicator_field_ids",
+    "filters": "filters",
+    "question_config": "question_config",
+    "questionConfig": "question_config",
+    "user_config": "user_config",
+    "userConfig": "user_config",
+    "config": "config",
+    "visibility": "visibility",
+}
+
+_CHART_PARTIAL_SET_KEYS = {
+    "name",
+    "chart_type",
+    "dimension_field_ids",
+    "indicator_field_ids",
+    "filters",
+    "question_config",
+    "user_config",
+    "config",
+    "visibility",
+}
+
+_CHART_PARTIAL_UNSET_KEYS = {"filters", "question_config", "user_config", "visibility"}
+
+
+def _canonical_chart_partial_patch_key(key: Any) -> str:
+    raw = str(key or "").strip()
+    return _CHART_PARTIAL_PATCH_KEY_ALIASES.get(raw, raw)
+
+
+def _normalize_chart_partial_set(raw_set: Any, *, reason_path: str) -> tuple[dict[str, Any], list[dict[str, Any]]]:
+    if not isinstance(raw_set, dict):
+        return {}, [{"error_code": "INVALID_CHART_PATCH_SET", "reason_path": reason_path, "message": "patch_charts[].set must be an object"}]
+    normalized: dict[str, Any] = {}
+    issues: list[dict[str, Any]] = []
+    for raw_key, value in raw_set.items():
+        key_path = [part for part in str(raw_key or "").strip().split(".") if part]
+        if not key_path:
+            continue
+        root = _canonical_chart_partial_patch_key(key_path[0])
+        if root not in _CHART_PARTIAL_SET_KEYS:
+            issues.append(
+                {
+                    "error_code": "UNSUPPORTED_CHART_PATCH_FIELD",
+                    "reason_path": f"{reason_path}.{raw_key}",
+                    "field": raw_key,
+                    "allowed_fields": sorted(_CHART_PARTIAL_SET_KEYS),
+                }
+            )
+            continue
+        if len(key_path) == 1:
+            normalized[root] = value
+            continue
+        target = normalized.setdefault(root, {})
+        if not isinstance(target, dict):
+            issues.append({"error_code": "INVALID_CHART_PATCH_PATH", "reason_path": f"{reason_path}.{raw_key}"})
+            continue
+        cursor = target
+        for part in key_path[1:-1]:
+            next_value = cursor.setdefault(part, {})
+            if not isinstance(next_value, dict):
+                issues.append({"error_code": "INVALID_CHART_PATCH_PATH", "reason_path": f"{reason_path}.{raw_key}"})
+                break
+            cursor = next_value
+        else:
+            cursor[key_path[-1]] = value
+    return normalized, issues
+
+
+def _normalize_chart_partial_unset(raw_unset: Any, *, reason_path: str) -> tuple[set[str], list[dict[str, Any]]]:
+    if not isinstance(raw_unset, list):
+        return set(), [{"error_code": "INVALID_CHART_PATCH_UNSET", "reason_path": reason_path, "message": "patch_charts[].unset must be a list"}]
+    normalized: set[str] = set()
+    issues: list[dict[str, Any]] = []
+    for index, raw_key in enumerate(raw_unset):
+        root = _canonical_chart_partial_patch_key(str(raw_key or "").strip().split(".")[0])
+        if root not in _CHART_PARTIAL_UNSET_KEYS:
+            issues.append(
+                {
+                    "error_code": "UNSUPPORTED_CHART_PATCH_UNSET_FIELD",
+                    "reason_path": f"{reason_path}[{index}]",
+                    "field": raw_key,
+                    "allowed_fields": sorted(_CHART_PARTIAL_UNSET_KEYS),
+                }
+            )
+            continue
+        normalized.add(root)
+    return normalized, issues
+
+
+def _chart_upsert_payload_from_existing(
+    *,
+    chart_id: str,
+    base: dict[str, Any],
+    config: dict[str, Any],
+) -> dict[str, Any]:
+    return _compact_dict(
+        {
+            "chart_id": chart_id,
+            "name": str(base.get("chartName") or config.get("chartName") or chart_id).strip() or chart_id,
+            "chart_type": _public_chart_type_from_backend(base.get("chartType") or config.get("chartType")),
+            "config": deepcopy(config),
+        }
+    )
 
 
 def _qingbi_field_type_from_public_field(field_type: str | None) -> str:
@@ -11070,6 +12607,25 @@ def _build_public_metric_fields(
     return metrics or [_default_public_total_metric()]
 
 
+def _split_axis_metric_fields(metrics: list[dict[str, Any]]) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]:
+    if not metrics:
+        default_metric = _default_public_total_metric()
+        return [deepcopy(default_metric)], [deepcopy(default_metric)]
+    if len(metrics) == 1:
+        return [deepcopy(metrics[0])], [deepcopy(metrics[0])]
+    return [deepcopy(metrics[0])], [deepcopy(metrics[1])]
+
+
+def _two_gauge_metric_fields(metrics: list[dict[str, Any]], *, requested_metric_count: int) -> list[dict[str, Any]]:
+    if not metrics:
+        return []
+    if len(metrics) == 1:
+        if requested_metric_count <= 0:
+            return [deepcopy(metrics[0])]
+        return [deepcopy(metrics[0]), _default_public_total_metric()]
+    return [deepcopy(metrics[0]), deepcopy(metrics[1])]
+
+
 def _build_public_chart_filter_matrix(
     rules: list[Any],
     *,
@@ -11117,6 +12673,13 @@ def _build_public_chart_config_payload(
     qingbi_fields_by_id: dict[str, dict[str, Any]],
 ) -> dict[str, Any]:
     config = deepcopy(patch.config)
+    explicit_fields = set(getattr(patch, "model_fields_set", set()) or set())
+    if "dimension_field_ids" in explicit_fields:
+        config.pop("selectedDimensions", None)
+    if "indicator_field_ids" in explicit_fields:
+        config.pop("selectedMetrics", None)
+    if "filters" in explicit_fields:
+        config.pop("beforeAggregationFilterMatrix", None)
     aggregate = str(config.pop("aggregate", "count") or "count").lower()
     before_filters = deepcopy(config.pop("beforeAggregationFilterMatrix", []))
     after_filters = deepcopy(config.pop("afterAggregationFilterMatrix", []))
@@ -11131,23 +12694,28 @@ def _build_public_chart_config_payload(
     for selector in list(config.pop("query_condition_field_ids", []) or []):
         field = _resolve_public_field(selector, field_lookup=field_lookup)
         query_condition_field_ids.append(_bi_field_id_for_field(app_key=app_key, field=field, qingbi_fields_by_id=qingbi_fields_by_id))
+    backend_chart_type = _map_public_chart_type_to_backend(patch.chart_type)
+    if backend_chart_type == "gauge" and not patch.indicator_field_ids and "selectedMetrics" not in config:
+        raise ValueError("gauge charts require at least one indicator_field_ids value; pass one metric and the CLI will pair it with 数据总量")
+    selected_dimensions = _build_public_dimension_fields(
+        patch.dimension_field_ids,
+        app_key=app_key,
+        field_lookup=field_lookup,
+        qingbi_fields_by_id=qingbi_fields_by_id,
+    )
+    selected_metrics = _build_public_metric_fields(
+        patch.indicator_field_ids,
+        app_key=app_key,
+        field_lookup=field_lookup,
+        qingbi_fields_by_id=qingbi_fields_by_id,
+        aggregate=aggregate,
+    )
     payload: dict[str, Any] = {
         "chartName": patch.name,
-        "chartType": _map_public_chart_type_to_backend(patch.chart_type),
+        "chartType": backend_chart_type,
         "dataSource": {"dataSourceId": app_key, "dataSourceType": "qingflow"},
-        "selectedDimensions": _build_public_dimension_fields(
-            patch.dimension_field_ids,
-            app_key=app_key,
-            field_lookup=field_lookup,
-            qingbi_fields_by_id=qingbi_fields_by_id,
-        ),
-        "selectedMetrics": _build_public_metric_fields(
-            patch.indicator_field_ids,
-            app_key=app_key,
-            field_lookup=field_lookup,
-            qingbi_fields_by_id=qingbi_fields_by_id,
-            aggregate=aggregate,
-        ),
+        "selectedDimensions": selected_dimensions,
+        "selectedMetrics": selected_metrics,
         "beforeAggregationFilterMatrix": before_filters,
         "afterAggregationFilterMatrix": after_filters,
         "chartStyleConfigs": deepcopy(config.pop("chartStyleConfigs", [])),
@@ -11163,6 +12731,23 @@ def _build_public_chart_config_payload(
         "queryConditionStatus": bool(config.pop("queryConditionStatus", bool(query_condition_field_ids))),
         "queryConditionExact": bool(config.pop("queryConditionExact", False)),
     }
+    if backend_chart_type == "summary":
+        payload.pop("selectedDimensions", None)
+        payload.setdefault("xDimensions", deepcopy(selected_dimensions))
+        payload.setdefault("yDimensions", [])
+    elif backend_chart_type == "scatter":
+        x_metrics, y_metrics = _split_axis_metric_fields(selected_metrics)
+        payload.pop("selectedMetrics", None)
+        payload.setdefault("xMetrics", x_metrics)
+        payload.setdefault("yMetrics", y_metrics)
+    elif backend_chart_type == "dualaxes":
+        left_metrics, right_metrics = _split_axis_metric_fields(selected_metrics)
+        payload.pop("selectedMetrics", None)
+        payload.setdefault("leftMetrics", left_metrics)
+        payload.setdefault("rightMetrics", right_metrics)
+    elif backend_chart_type == "gauge":
+        payload["selectedDimensions"] = []
+        payload["selectedMetrics"] = _two_gauge_metric_fields(selected_metrics, requested_metric_count=len(patch.indicator_field_ids or []))
     for key in (
         "selectedTime",
         "xDimensions",
@@ -11185,6 +12770,46 @@ def _chart_patch_updates_chart_config(patch: ChartUpsertPatch) -> bool:
     return bool({"dimension_field_ids", "indicator_field_ids", "filters", "config"} & explicit_fields)
 
 
+def _chart_patch_dataset_source_type(patch: ChartUpsertPatch) -> str:
+    config = patch.config if isinstance(patch.config, dict) else {}
+    candidates = [
+        config.get("dataSourceType"),
+        config.get("data_source_type"),
+    ]
+    data_source = config.get("dataSource")
+    if isinstance(data_source, dict):
+        candidates.extend([data_source.get("dataSourceType"), data_source.get("data_source_type"), data_source.get("type")])
+    data_source = config.get("data_source")
+    if isinstance(data_source, dict):
+        candidates.extend([data_source.get("dataSourceType"), data_source.get("data_source_type"), data_source.get("type")])
+    for candidate in candidates:
+        normalized = str(candidate or "").strip().lower()
+        if not normalized:
+            continue
+        if normalized not in {"qingflow", "app"}:
+            return normalized
+    return ""
+
+
+def _chart_item_dataset_source_type(item: dict[str, Any]) -> str:
+    candidates = [
+        item.get("dataSourceType"),
+        item.get("data_source_type"),
+        item.get("sourceType"),
+        item.get("source_type"),
+    ]
+    data_source = item.get("dataSource")
+    if isinstance(data_source, dict):
+        candidates.extend([data_source.get("dataSourceType"), data_source.get("data_source_type"), data_source.get("type")])
+    for candidate in candidates:
+        normalized = str(candidate or "").strip().lower()
+        if not normalized:
+            continue
+        if normalized not in {"qingflow", "app", "bi_qingflow"}:
+            return normalized
+    return ""
+
+
 def _build_public_portal_base_payload(
     *,
     dash_name: str,
@@ -11255,16 +12880,33 @@ def _normalize_backend_chart_type(value: Any) -> str:
         "12": "dualaxes",
         "13": "map",
         "14": "timeline",
+        "15": "area",
+        "16": "stacked_column",
+        "17": "stacked_bar",
+        "18": "rose",
+        "19": "stacked_area",
+        "20": "pct_stack_col",
+        "21": "pct_stack_bar",
+        "22": "pct_stack_area",
+        "23": "waterfall",
+        "24": "gauge",
+        "25": "heatmap",
+        "26": "histogram",
+        "27": "treemap",
+    }
+    aliases = {
+        "percent_stacked_column": "pct_stack_col",
+        "percent_stacked_bar": "pct_stack_bar",
+        "percent_stacked_area": "pct_stack_area",
     }
-    return by_code.get(raw, raw.lower())
+    normalized = by_code.get(raw, raw.lower())
+    return aliases.get(normalized, normalized)
 
 
 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)
 
@@ -17350,7 +18992,9 @@ 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", "LIST"}:
+    if normalized == "LIST":
+        return "INSIDE"
+    if normalized in {"TOP", "DETAIL", "INSIDE"}:
         return normalized
     return None
 
@@ -17436,7 +19080,7 @@ def _extract_view_button_entries(config: dict[str, Any]) -> tuple[list[dict[str,
         if not isinstance(item, dict):
             continue
         entry = deepcopy(item)
-        entry.setdefault("configType", "LIST")
+        entry.setdefault("configType", "INSIDE")
         entries.append(entry)
     return entries, "buttonConfig"
 
@@ -17471,13 +19115,47 @@ def _normalize_view_button_entry(entry: dict[str, Any]) -> dict[str, Any]:
             normalized[public_key] = deepcopy(value)
     trigger_add_data_config = entry.get("triggerAddDataConfig")
     if isinstance(trigger_add_data_config, dict):
-        normalized["trigger_add_data_config"] = deepcopy(trigger_add_data_config)
+        normalized["trigger_add_data_config"] = _normalize_custom_button_add_data_config_for_public(trigger_add_data_config)
     trigger_wings_config = entry.get("triggerWingsConfig")
     if isinstance(trigger_wings_config, dict):
         normalized["trigger_wings_config"] = deepcopy(trigger_wings_config)
     return normalized
 
 
+def _public_view_button_placement(config_type: str | None) -> str | None:
+    normalized = _normalize_view_button_config_type(config_type)
+    if normalized == "TOP":
+        return "header"
+    if normalized == "DETAIL":
+        return "detail"
+    if normalized == "INSIDE":
+        return "list"
+    return None
+
+
+def _extract_view_buttons_config(config: dict[str, Any]) -> dict[str, Any]:
+    entries, source = _extract_view_button_entries(config)
+    placements: dict[str, list[dict[str, Any]]] = {"header": [], "detail": [], "list": []}
+    items: list[dict[str, Any]] = []
+    for entry in entries:
+        normalized = _normalize_view_button_entry(entry)
+        placement = _public_view_button_placement(normalized.get("config_type"))
+        normalized["placement"] = placement
+        items.append(normalized)
+        if placement:
+            placements.setdefault(placement, []).append(normalized)
+    status = "ok" if items else "none"
+    result: dict[str, Any] = {
+        "status": status,
+        "button_count": len(items),
+        "placements": placements,
+        "items": items,
+    }
+    if source:
+        result["read_source"] = source
+    return result
+
+
 def _normalize_view_buttons_for_compare(value: Any) -> list[dict[str, Any]]:
     if isinstance(value, dict):
         entries, _ = _extract_view_button_entries(value)
@@ -17612,7 +19290,7 @@ def _canonicalize_view_button_summary_order(items: list[dict[str, Any]]) -> list
             detail_main_buttons.append(item)
         elif config_type == "DETAIL":
             detail_more_buttons.append(item)
-        elif config_type == "LIST":
+        elif config_type == "INSIDE":
             list_buttons.append(item)
         else:
             other_buttons.append(item)
@@ -17765,7 +19443,7 @@ 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":
+        elif config_type == "INSIDE":
             grouped["listButtonList"].append(item)
         elif being_main:
             grouped["mainButtonDetailList"].append(item)
@@ -18577,7 +20255,7 @@ def _build_view_associated_resources_payload(
                     "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",
+                    "next_action": "prefer app_associated_resources_apply for associated report/view display; it can resolve associated_item_id, chart_id/chart_key, or view_key",
                 }
             ]
         item_ids.append(item_id)
@@ -18591,7 +20269,7 @@ def _build_view_associated_resources_payload(
                 "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",
+                "next_action": "prefer app_associated_resources_apply for associated report/view display; it can resolve associated_item_id, chart_id/chart_key, or view_key",
             }
         ]
     payload = {
@@ -18663,7 +20341,7 @@ def _associated_resources_config_matches(expected: dict[str, Any], actual: dict[
     return True
 
 
-def _normalize_associated_resources_payload(payload: Any) -> list[dict[str, Any]]:
+def _normalize_associated_resources_payload(payload: Any, *, include_raw: bool = False) -> list[dict[str, Any]]:
     if isinstance(payload, dict):
         raw_items = (
             payload.get("associated_resources")
@@ -18684,7 +20362,7 @@ def _normalize_associated_resources_payload(payload: Any) -> list[dict[str, Any]
     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 = _normalize_associated_resource_item(raw_item, include_raw=include_raw)
         item_id = _coerce_positive_int(item.get("associated_item_id"))
         if item_id is None or item_id in seen_ids:
             continue
@@ -18694,7 +20372,7 @@ def _normalize_associated_resources_payload(payload: Any) -> list[dict[str, Any]
     return normalized_items
 
 
-def _normalize_associated_resource_item(raw_item: Any) -> dict[str, Any]:
+def _normalize_associated_resource_item(raw_item: Any, *, include_raw: bool = False) -> dict[str, Any]:
     if not isinstance(raw_item, dict):
         return {}
     item_id = _first_present(raw_item, "associated_item_id", "associatedItemId", "asosChartId", "id")
@@ -18725,7 +20403,10 @@ def _normalize_associated_resource_item(raw_item: Any) -> dict[str, Any]:
         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)
+    item = _compact_dict(item)
+    if include_raw:
+        item["_raw"] = deepcopy(raw_item)
+    return item
 
 
 def _normalize_associated_graph_type(raw_item: dict[str, Any], *, chart_key: Any, view_key: Any) -> str:
@@ -18752,6 +20433,14 @@ def _associated_resource_index(resources: list[dict[str, Any]]) -> dict[int, dic
     return indexed
 
 
+def _strip_internal_associated_resource_raw(resources: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    return [
+        _compact_dict({key: deepcopy(value) for key, value in item.items() if key != "_raw"})
+        for item in resources
+        if isinstance(item, dict)
+    ]
+
+
 def _public_associated_graph_type(value: Any) -> str:
     normalized = str(value or "").strip().lower()
     if normalized in {"view", "viewgraph"}:
@@ -18887,6 +20576,188 @@ def _associated_resource_matches_patch(item: dict[str, Any], patch: AssociatedRe
     return _associated_resource_public_key(item) == _associated_resource_public_key(patch)
 
 
+_ASSOCIATED_RESOURCE_PARTIAL_PATCH_KEY_ALIASES = {
+    "graph_type": "graph_type",
+    "graphType": "graph_type",
+    "resource_type": "graph_type",
+    "resourceType": "graph_type",
+    "target_app_key": "target_app_key",
+    "targetAppKey": "target_app_key",
+    "app_key": "target_app_key",
+    "appKey": "target_app_key",
+    "view_key": "view_key",
+    "viewKey": "view_key",
+    "viewgraphKey": "view_key",
+    "viewGraphKey": "view_key",
+    "chart_key": "chart_key",
+    "chartKey": "chart_key",
+    "report_source": "report_source",
+    "reportSource": "report_source",
+    "match_rules": "match_rules",
+    "matchRules": "match_rules",
+    "match_mappings": "match_mappings",
+    "matchMappings": "match_mappings",
+}
+
+_ASSOCIATED_RESOURCE_PARTIAL_SET_KEYS = {
+    "graph_type",
+    "target_app_key",
+    "view_key",
+    "chart_key",
+    "report_source",
+    "match_rules",
+    "match_mappings",
+}
+
+_ASSOCIATED_RESOURCE_PARTIAL_UNSET_KEYS = {"match_rules", "match_mappings"}
+
+
+def _canonical_associated_resource_partial_patch_key(key: Any) -> str:
+    raw = str(key or "").strip()
+    return _ASSOCIATED_RESOURCE_PARTIAL_PATCH_KEY_ALIASES.get(raw, raw)
+
+
+def _normalize_associated_resource_partial_set(raw_set: Any, *, reason_path: str) -> tuple[dict[str, Any], list[dict[str, Any]]]:
+    if not isinstance(raw_set, dict):
+        return {}, [{"error_code": "INVALID_ASSOCIATED_RESOURCE_PATCH_SET", "reason_path": reason_path, "message": "patch_resources[].set must be an object"}]
+    normalized: dict[str, Any] = {}
+    issues: list[dict[str, Any]] = []
+    for raw_key, value in raw_set.items():
+        root = _canonical_associated_resource_partial_patch_key(raw_key)
+        if root not in _ASSOCIATED_RESOURCE_PARTIAL_SET_KEYS:
+            issues.append(
+                {
+                    "error_code": "UNSUPPORTED_ASSOCIATED_RESOURCE_PATCH_FIELD",
+                    "reason_path": f"{reason_path}.{raw_key}",
+                    "field": raw_key,
+                    "allowed_fields": sorted(_ASSOCIATED_RESOURCE_PARTIAL_SET_KEYS),
+                }
+            )
+            continue
+        normalized[root] = value
+    return normalized, issues
+
+
+def _normalize_associated_resource_partial_unset(raw_unset: Any, *, reason_path: str) -> tuple[set[str], list[dict[str, Any]]]:
+    if not isinstance(raw_unset, list):
+        return set(), [{"error_code": "INVALID_ASSOCIATED_RESOURCE_PATCH_UNSET", "reason_path": reason_path, "message": "patch_resources[].unset must be a list"}]
+    normalized: set[str] = set()
+    issues: list[dict[str, Any]] = []
+    for index, raw_key in enumerate(raw_unset):
+        root = _canonical_associated_resource_partial_patch_key(raw_key)
+        if root not in _ASSOCIATED_RESOURCE_PARTIAL_UNSET_KEYS:
+            issues.append(
+                {
+                    "error_code": "UNSUPPORTED_ASSOCIATED_RESOURCE_PATCH_UNSET_FIELD",
+                    "reason_path": f"{reason_path}[{index}]",
+                    "field": raw_key,
+                    "allowed_fields": sorted(_ASSOCIATED_RESOURCE_PARTIAL_UNSET_KEYS),
+                }
+            )
+            continue
+        normalized.add(root)
+    return normalized, issues
+
+
+def _associated_resource_upsert_payload_from_existing_item(
+    item: dict[str, Any],
+    *,
+    associated_item_id: int,
+    client_key: str | None = None,
+) -> dict[str, Any]:
+    graph_type = str(item.get("graph_type") or item.get("resource_type") or "").strip().lower()
+    payload = {
+        "associated_item_id": associated_item_id,
+        "client_key": client_key,
+        "graph_type": "view" if graph_type == "view" else "chart",
+        "target_app_key": item.get("target_app_key"),
+        "view_key": item.get("view_key"),
+        "chart_key": item.get("chart_key"),
+        "report_source": item.get("report_source"),
+        "match_rules": [],
+    }
+    raw = item.get("_raw") if isinstance(item.get("_raw"), dict) else {}
+    raw_match_rules = raw.get("matchRules") if isinstance(raw, dict) else None
+    if isinstance(raw_match_rules, list):
+        if raw_match_rules and all(isinstance(group, list) for group in raw_match_rules):
+            flattened = [rule for group in raw_match_rules for rule in group if isinstance(rule, dict)]
+            payload["match_rules"] = flattened
+        else:
+            payload["match_rules"] = [rule for rule in raw_match_rules if isinstance(rule, dict)]
+    return _compact_dict(payload)
+
+
+def _resolve_associated_resource_selector(
+    selector: Any,
+    *,
+    existing_resources: list[dict[str, Any]],
+    existing_by_id: dict[int, dict[str, Any]],
+    reason_path: str,
+) -> tuple[int | None, dict[str, Any] | None]:
+    item_id = _coerce_positive_int(selector)
+    if item_id is not None:
+        if item_id in existing_by_id:
+            return item_id, None
+    raw = str(selector or "").strip()
+    if not raw:
+        return None, {
+            "error_code": "ASSOCIATED_RESOURCE_NOT_FOUND",
+            "reason_path": reason_path,
+            "received": selector,
+            "available_associated_item_ids": sorted(existing_by_id),
+            "message": "associated resource selector cannot be empty",
+        }
+    matches: list[dict[str, Any]] = []
+    for resource in existing_resources:
+        if not isinstance(resource, dict):
+            continue
+        candidates = [
+            resource.get("chart_id"),
+            resource.get("chart_key"),
+            resource.get("view_key"),
+            resource.get("associated_item_id"),
+        ]
+        if raw in {str(candidate).strip() for candidate in candidates if candidate not in {None, ""}}:
+            matches.append(resource)
+    if len(matches) == 1:
+        resolved_id = _coerce_positive_int(matches[0].get("associated_item_id"))
+        if resolved_id is not None:
+            return resolved_id, None
+    if len(matches) > 1:
+        return None, {
+            "error_code": "AMBIGUOUS_ASSOCIATED_RESOURCE",
+            "reason_path": reason_path,
+            "received": selector,
+            "candidate_associated_item_ids": [
+                item_id
+                for item_id in (_coerce_positive_int(item.get("associated_item_id")) for item in matches)
+                if item_id is not None
+            ],
+            "message": "selector matches multiple associated resources; pass associated_item_id",
+        }
+    return None, {
+        "error_code": "ASSOCIATED_RESOURCE_NOT_FOUND",
+        "reason_path": reason_path,
+        "received": selector,
+        "available_associated_item_ids": sorted(existing_by_id),
+        "available_chart_ids": sorted(
+            {
+                str(resource.get("chart_id") or resource.get("chart_key") or "").strip()
+                for resource in existing_resources
+                if str(resource.get("chart_id") or resource.get("chart_key") or "").strip()
+            }
+        ),
+        "available_view_keys": sorted(
+            {
+                str(resource.get("view_key") or "").strip()
+                for resource in existing_resources
+                if str(resource.get("view_key") or "").strip()
+            }
+        ),
+        "message": "selector must be an associated_item_id, QingBI chart_id/chart_key, or Qingflow view_key from the app-level associated resource pool",
+    }
+
+
 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",
@@ -18894,7 +20765,7 @@ def _associated_resource_not_found_issue(reason_path: str, associated_item_id: i
         "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",
+        "next_action": "call app_get and use associated_resources[].associated_item_id, chart_id/chart_key, or view_key",
     }
 
 
@@ -18907,14 +20778,33 @@ def _duplicate_associated_resource_issue(reason_path: str, associated_item_id: i
     }
 
 
-def _serialize_associated_resource_match_rules(match_rules: list[CustomButtonMatchRulePatch]) -> list[list[dict[str, Any]]]:
+def _associated_resource_patch_has_match_config(patch: AssociatedResourceUpsertPatch) -> bool:
+    fields_set = getattr(patch, "model_fields_set", set())
+    return bool(patch.match_mappings) or bool(patch.match_rules) or "match_mappings" in fields_set
+
+
+def _serialize_associated_resource_match_rules(match_rules: list[Any]) -> 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]]
+    serialized: list[dict[str, Any]] = []
+    for rule in match_rules:
+        if isinstance(rule, CustomButtonMatchRulePatch):
+            payload = rule.model_dump(mode="json", exclude_none=True)
+        elif isinstance(rule, dict):
+            payload = rule
+        else:
+            continue
+        serialized.append(_serialize_custom_button_match_rule(payload))
+    return [serialized] if serialized else []
 
 
-def _serialize_associated_resource_create_payload(patch: AssociatedResourceUpsertPatch) -> dict[str, Any]:
+def _serialize_associated_resource_create_payload(
+    patch: AssociatedResourceUpsertPatch,
+    *,
+    match_rules_override: list[dict[str, Any]] | None = None,
+) -> dict[str, Any]:
     graph_type = _public_associated_graph_type(patch.graph_type)
+    match_rules = match_rules_override if match_rules_override is not None else patch.match_rules
     return {
         "appKey": patch.target_app_key,
         "chartList": [
@@ -18924,22 +20814,32 @@ def _serialize_associated_resource_create_payload(patch: AssociatedResourceUpser
                 "graphType": _backend_associated_graph_type(graph_type),
             }
         ],
-        "matchRules": _serialize_associated_resource_match_rules(patch.match_rules),
+        "matchRules": _serialize_associated_resource_match_rules(match_rules),
     }
 
 
-def _serialize_associated_resource_update_payload(patch: AssociatedResourceUpsertPatch, *, associated_item_id: int) -> dict[str, Any]:
+def _serialize_associated_resource_update_payload(
+    patch: AssociatedResourceUpsertPatch,
+    *,
+    associated_item_id: int,
+    existing_item: dict[str, Any] | None = None,
+    match_rules_override: list[dict[str, Any]] | None = None,
+) -> dict[str, Any]:
     graph_type = _public_associated_graph_type(patch.graph_type)
-    return _compact_dict(
+    raw = existing_item.get("_raw") if isinstance(existing_item, dict) and isinstance(existing_item.get("_raw"), dict) else None
+    payload = deepcopy(raw) if isinstance(raw, dict) else {}
+    match_rules = match_rules_override if match_rules_override is not None else patch.match_rules
+    payload.update(
         {
             "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),
+            "matchRules": _serialize_associated_resource_match_rules(match_rules),
         }
     )
+    return _compact_dict(payload)
 
 
 def _associated_resource_result_entry(
@@ -19014,6 +20914,204 @@ def _build_view_buttons_only_update_payload(config: Any, *, button_config_dtos:
     return payload
 
 
+_VIEW_PARTIAL_PATCH_KEY_ALIASES = {
+    "view_name": "name",
+    "viewName": "name",
+    "view_key": "view_key",
+    "viewKey": "view_key",
+    "viewgraphKey": "view_key",
+    "type": "type",
+    "view_type": "type",
+    "viewType": "type",
+    "columns": "columns",
+    "column_names": "columns",
+    "columnNames": "columns",
+    "fields": "columns",
+    "group_by": "group_by",
+    "groupBy": "group_by",
+    "filters": "filters",
+    "filter_rules": "filters",
+    "filterRules": "filters",
+    "start_field": "start_field",
+    "startField": "start_field",
+    "end_field": "end_field",
+    "endField": "end_field",
+    "title_field": "title_field",
+    "titleField": "title_field",
+    "buttons": "buttons",
+    "visibility": "visibility",
+    "query_conditions": "query_conditions",
+    "queryConditions": "query_conditions",
+    "query_condition": "query_conditions",
+    "queryCondition": "query_conditions",
+    "associated_resources": "associated_resources",
+    "associatedResources": "associated_resources",
+    "associated_reports": "associated_resources",
+    "associatedReports": "associated_resources",
+}
+
+
+def _canonical_view_partial_patch_key(key: Any) -> str:
+    raw = str(key or "").strip()
+    return _VIEW_PARTIAL_PATCH_KEY_ALIASES.get(raw, raw)
+
+
+def _normalize_view_partial_set(raw_set: Any, *, reason_path: str) -> tuple[dict[str, Any], list[dict[str, Any]]]:
+    if not isinstance(raw_set, dict):
+        return {}, [{"error_code": "INVALID_VIEW_PATCH_SET", "reason_path": reason_path, "message": "patch_views[].set must be an object"}]
+    normalized: dict[str, Any] = {}
+    issues: list[dict[str, Any]] = []
+    for raw_key, value in raw_set.items():
+        key_path = [part for part in str(raw_key or "").strip().split(".") if part]
+        if not key_path:
+            continue
+        root = _canonical_view_partial_patch_key(key_path[0])
+        if root not in _VIEW_PARTIAL_SET_KEYS:
+            issues.append(
+                {
+                    "error_code": "UNSUPPORTED_VIEW_PATCH_FIELD",
+                    "reason_path": f"{reason_path}.{raw_key}",
+                    "field": raw_key,
+                    "allowed_fields": sorted(_VIEW_PARTIAL_SET_KEYS),
+                }
+            )
+            continue
+        if len(key_path) == 1:
+            normalized[root] = value
+            continue
+        target = normalized.setdefault(root, {})
+        if not isinstance(target, dict):
+            issues.append(
+                {
+                    "error_code": "INVALID_VIEW_PATCH_PATH",
+                    "reason_path": f"{reason_path}.{raw_key}",
+                    "message": "cannot combine a scalar replacement and nested patch for the same field",
+                }
+            )
+            continue
+        cursor = target
+        for part in key_path[1:-1]:
+            next_value = cursor.setdefault(part, {})
+            if not isinstance(next_value, dict):
+                issues.append({"error_code": "INVALID_VIEW_PATCH_PATH", "reason_path": f"{reason_path}.{raw_key}"})
+                break
+            cursor = next_value
+        else:
+            cursor[key_path[-1]] = value
+    return normalized, issues
+
+
+def _normalize_view_partial_unset(raw_unset: Any, *, reason_path: str) -> tuple[set[str], list[dict[str, Any]]]:
+    if not isinstance(raw_unset, list):
+        return set(), [{"error_code": "INVALID_VIEW_PATCH_UNSET", "reason_path": reason_path, "message": "patch_views[].unset must be a list"}]
+    normalized: set[str] = set()
+    issues: list[dict[str, Any]] = []
+    for index, raw_key in enumerate(raw_unset):
+        root = _canonical_view_partial_patch_key(str(raw_key or "").strip().split(".")[0])
+        if root not in _VIEW_PARTIAL_UNSET_KEYS:
+            issues.append(
+                {
+                    "error_code": "UNSUPPORTED_VIEW_PATCH_UNSET_FIELD",
+                    "reason_path": f"{reason_path}[{index}]",
+                    "field": raw_key,
+                    "allowed_fields": sorted(_VIEW_PARTIAL_UNSET_KEYS),
+                }
+            )
+            continue
+        normalized.add(root)
+    return normalized, issues
+
+
+_VIEW_PARTIAL_SET_KEYS = {
+    "name",
+    "type",
+    "columns",
+    "group_by",
+    "filters",
+    "start_field",
+    "end_field",
+    "title_field",
+    "buttons",
+    "visibility",
+    "query_conditions",
+    "associated_resources",
+}
+
+_VIEW_PARTIAL_UNSET_KEYS = {"filters", "buttons", "visibility", "query_conditions", "associated_resources"}
+
+
+def _deep_merge_public_config(target: dict[str, Any], patch: dict[str, Any]) -> None:
+    for key, value in patch.items():
+        if isinstance(value, dict) and isinstance(target.get(key), dict):
+            _deep_merge_public_config(cast(dict[str, Any], target[key]), value)
+        else:
+            target[key] = deepcopy(value)
+
+
+def _field_name_by_id(field_names_by_id: dict[int, str], field_id: Any) -> str | None:
+    normalized_id = _coerce_nonnegative_int(field_id)
+    if normalized_id is None:
+        return None
+    name = str(field_names_by_id.get(normalized_id) or "").strip()
+    return name or None
+
+
+def _view_upsert_payload_from_existing_view(
+    *,
+    config: dict[str, Any],
+    summary: dict[str, Any],
+    view_key: str,
+    field_names_by_id: dict[int, str],
+) -> dict[str, Any]:
+    view_type = _normalize_view_type_name(config.get("viewgraphType") or summary.get("type"))
+    configured_columns = [
+        name
+        for name in (_field_name_by_id(field_names_by_id, item) for item in (config.get("viewgraphQueIds") or []))
+        if name and name not in _KNOWN_SYSTEM_VIEW_COLUMNS
+    ]
+    columns = [
+        str(name or "").strip()
+        for name in (summary.get("apply_columns") or summary.get("columns") or [])
+        if str(name or "").strip() and str(name or "").strip() not in _KNOWN_SYSTEM_VIEW_COLUMNS
+    ]
+    if configured_columns and (not columns or len(configured_columns) >= len(columns)):
+        columns = configured_columns
+    display_config = summary.get("display_config") if isinstance(summary.get("display_config"), dict) else {}
+    group_by = str(summary.get("group_by") or display_config.get("group_by") or "").strip() or _field_name_by_id(field_names_by_id, config.get("groupQueId"))
+    title_field = str(display_config.get("title_field") or "").strip() or _field_name_by_id(field_names_by_id, config.get("titleQue"))
+    gantt_config = config.get("viewgraphGanttConfigVO") if isinstance(config.get("viewgraphGanttConfigVO"), dict) else {}
+    start_field = _field_name_by_id(field_names_by_id, gantt_config.get("startTimeQueId")) if isinstance(gantt_config, dict) else None
+    end_field = _field_name_by_id(field_names_by_id, gantt_config.get("endTimeQueId")) if isinstance(gantt_config, dict) else None
+    gantt_title = _field_name_by_id(field_names_by_id, gantt_config.get("titleQueId")) if isinstance(gantt_config, dict) else None
+    query_conditions = _extract_view_query_conditions_config(config)
+    query_conditions.pop("row_field_ids", None)
+    associated_resources = _extract_view_associated_resources_config(config)
+    payload: dict[str, Any] = {
+        "name": str(summary.get("name") or config.get("viewgraphName") or config.get("viewName") or view_key).strip(),
+        "view_key": view_key,
+        "type": view_type or "table",
+        "columns": columns,
+        "group_by": group_by,
+        "filters": [],
+        "query_conditions": query_conditions,
+        "associated_resources": {
+            "visible": bool(associated_resources.get("visible", False)),
+            "limit_type": associated_resources.get("limit_type"),
+            "associated_item_ids": list(associated_resources.get("configured_associated_item_ids") or []),
+        },
+    }
+    if title_field:
+        payload["title_field"] = title_field
+    if view_type == "gantt":
+        if start_field:
+            payload["start_field"] = start_field
+        if end_field:
+            payload["end_field"] = end_field
+        if gantt_title:
+            payload["title_field"] = gantt_title
+    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:
@@ -19028,7 +21126,7 @@ def _build_view_create_payload(
     schema: dict[str, Any],
     patch: ViewUpsertPatch,
     ordinal: int,
-    view_filters: list[list[dict[str, Any]]],
+    view_filters: list[list[dict[str, Any]]] | None,
     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,
@@ -19226,7 +21324,7 @@ def _build_view_update_payload(
     source_viewgraph_key: str,
     schema: dict[str, Any],
     patch: ViewUpsertPatch,
-    view_filters: list[list[dict[str, Any]]],
+    view_filters: list[list[dict[str, Any]]] | None,
     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,
@@ -19334,7 +21432,7 @@ def _build_minimal_view_payload(
     schema: dict[str, Any],
     patch: ViewUpsertPatch,
     ordinal: int,
-    view_filters: list[list[dict[str, Any]]],
+    view_filters: list[list[dict[str, Any]]] | None,
     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,
@@ -19403,9 +21501,14 @@ def _hydrate_view_backend_payload(
     data.setdefault("beingImageAdaption", False)
     data.setdefault("clippingMode", "default")
     data.setdefault("frontCoverQueId", None)
-    data["viewgraphLimitType"] = 1
-    data["viewgraphLimit"] = deepcopy(view_filters) if view_filters else []
-    data["viewgraphLimitFormula"] = ""
+    if view_filters is None:
+        data.setdefault("viewgraphLimitType", 1)
+        data.setdefault("viewgraphLimit", [])
+        data.setdefault("viewgraphLimitFormula", "")
+    else:
+        data["viewgraphLimitType"] = 1
+        data["viewgraphLimit"] = deepcopy(view_filters)
+        data["viewgraphLimitFormula"] = ""
     data.setdefault("sortType", "defaultSort")
     if not data.get("viewgraphSorts"):
         sort_que_id = visible_que_id_values[0] if visible_que_id_values else 1
@@ -19417,8 +21520,11 @@ def _hydrate_view_backend_payload(
     data.setdefault("printTpls", [])
     data.setdefault("beingCommentStatus", False)
     data.setdefault("usages", [])
-    data["dataPermissionType"] = "CUSTOM"
-    data["dataScope"] = "CUSTOM" if view_filters else "ALL"
+    data.setdefault("dataPermissionType", "CUSTOM")
+    if view_filters is None:
+        data.setdefault("dataScope", "ALL")
+    else:
+        data["dataScope"] = "CUSTOM" if view_filters else "ALL"
     data.setdefault("needPass", False)
     data.setdefault("beingWorkflowNodeFutureListVisible", True)
     data.setdefault("asosChartConfig", {"limitType": 1, "asosChartIdList": []})
@@ -19713,6 +21819,44 @@ def _normalize_view_filter_groups_for_compare(groups: Any) -> list[list[dict[str
     return normalized_groups
 
 
+def _view_filter_rule_values_for_signature(rule: dict[str, Any]) -> list[str]:
+    values = [str(value) for value in (rule.get("judgeValues") or [])]
+    if values:
+        return values
+    fallback_values: list[str] = []
+    for detail in rule.get("judgeValueDetails") or []:
+        if not isinstance(detail, dict):
+            continue
+        item_id = detail.get("id")
+        item_value = detail.get("value")
+        if item_id is not None:
+            fallback_values.append(str(item_id))
+        elif item_value is not None:
+            fallback_values.append(str(item_value))
+    return fallback_values
+
+
+def _view_filter_groups_signature(groups: Any) -> list[list[dict[str, Any]]]:
+    signature: list[list[dict[str, Any]]] = []
+    for group in _normalize_view_filter_groups_for_compare(groups):
+        group_signature: list[dict[str, Any]] = []
+        for rule in group:
+            group_signature.append(
+                {
+                    "queId": rule.get("queId"),
+                    "judgeType": rule.get("judgeType"),
+                    "judgeValues": _view_filter_rule_values_for_signature(rule),
+                }
+            )
+        if group_signature:
+            signature.append(group_signature)
+    return signature
+
+
+def _view_filter_groups_equivalent(expected: Any, actual: Any) -> bool:
+    return _view_filter_groups_signature(expected) == _view_filter_groups_signature(actual)
+
+
 def _infer_status_field_id(fields: list[dict[str, Any]]) -> str | None:
     preferred_names = {"status", "状态", "订单状态", "审批状态", "流程状态"}
     for field in fields: