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

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,44 @@ 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()
 
-        for index, patch in enumerate(request.upsert_resources):
+        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(upsert_resources):
             client_key = str(patch.client_key or "").strip()
             if client_key:
                 if client_key in used_client_keys:
@@ -3282,6 +3719,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 +3732,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,7 +3773,8 @@ 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})
 
@@ -3398,6 +3845,13 @@ class AiBuilderFacade:
                     }
                 )
 
+        blocking_issues.extend(
+            [
+                {key: value for key, value in issue.items() if key != "_patch_index"}
+                for issue in resource_match_issues
+            ]
+        )
+
         if blocking_issues:
             return finalize(
                 _failed(
@@ -3453,7 +3907,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 +3939,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 +3959,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
@@ -3641,7 +4107,15 @@ 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()
+                },
+            },
             "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 +5309,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 +5317,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 +5344,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 +5472,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 +5490,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 +5525,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 +5842,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 +5866,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 +5895,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 +6141,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 +6150,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 +6177,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 +6661,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 +8124,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 +8201,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 +8389,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 +8411,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 +8440,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 +8469,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 +8946,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 +9447,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,13 +9626,36 @@ 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:
                 config_update_requested = _chart_patch_updates_chart_config(patch)
                 chart_visible_auth = (
@@ -10154,6 +11007,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 +11112,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 +11197,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 +11211,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:
@@ -10222,45 +11241,244 @@ def _resolve_custom_button_schema_field(
     }
 
 
-def _custom_button_mapping_type_issue(
+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],
-    reason_path: str,
-) -> dict[str, Any] | None:
+    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 +11503,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)
@@ -10450,7 +11698,7 @@ def _normalize_custom_button_detail(item: dict[str, Any]) -> dict[str, Any]:
     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)
+        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")
@@ -10464,6 +11712,148 @@ def _normalize_custom_button_detail(item: dict[str, Any]) -> dict[str, Any]:
     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(
     error_code: str,
     message: str,
@@ -10956,6 +12346,125 @@ def _map_public_chart_type_to_backend(chart_type: PublicChartType) -> str:
     }[chart_type]
 
 
+_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:
     return {
         "single_select": "singleSelect",
@@ -11117,6 +12626,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", []))
@@ -17350,7 +18866,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 +18954,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 +18989,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 +19164,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 +19317,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)
@@ -18663,7 +20215,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 +20236,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 +20246,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 +20277,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 +20307,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 +20450,117 @@ 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 _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",
@@ -18907,14 +20581,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 +20617,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 +20717,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 +20929,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 +21127,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 +21235,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 +21304,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 +21323,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 +21622,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: