@qingflow-tech/qingflow-app-builder-mcp 1.0.8 → 1.0.10

package/src/qingflow_mcp/builder_facade/service.py

@@ -2564,6 +2564,7 @@ class AiBuilderFacade:
                 details=_with_state_read_blocked_details({"app_key": app_key}, resource="custom_buttons", error=api_error),
                 suggested_next_call={"tool_name": "app_get", "arguments": {"profile": profile, "app_key": app_key}},
             ))
+        app_name = self._read_app_name_for_builder_output(profile=profile, app_key=app_key)
 
         existing_by_id = {
             button_id: item
@@ -3013,6 +3014,7 @@ class AiBuilderFacade:
             },
             "verified": verified,
             "app_key": app_key,
+            "app_name": app_name,
             "mode": "apply",
             "created": created,
             "updated": updated,
@@ -3663,6 +3665,7 @@ class AiBuilderFacade:
                 details=_with_state_read_blocked_details({"app_key": app_key}, resource="associated_resources", error=api_error),
                 suggested_next_call={"tool_name": "app_get", "arguments": {"profile": profile, "app_key": app_key}},
             ))
+        app_name = self._read_app_name_for_builder_output(profile=profile, app_key=app_key)
 
         existing_by_id = _associated_resource_index(existing_resources)
         blocking_issues: list[dict[str, Any]] = []
@@ -3671,7 +3674,7 @@ class AiBuilderFacade:
         client_key_to_patch: dict[str, AssociatedResourceUpsertPatch] = {}
         client_key_to_id: dict[str, int] = {}
         used_client_keys: set[str] = set()
-        force_update_resource_ids: set[int] = set()
+        resolved_associated_item_refs: dict[str, list[int]] = {}
 
         upsert_resources = list(request.upsert_resources)
         if request.patch_resources:
@@ -3690,11 +3693,6 @@ class AiBuilderFacade:
                     )
                 )
             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
 
@@ -3732,14 +3730,9 @@ class AiBuilderFacade:
                 touched_ids.add(associated_item_id)
                 if client_key:
                     client_key_to_id[client_key] = associated_item_id
-                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"
-                )
+                has_match_config = _associated_resource_patch_has_match_config(patch)
+                identity_matches = _associated_resource_matches_patch(existing_by_id[associated_item_id], patch)
+                operation = "update" if has_match_config or not identity_matches else "unchanged"
                 upsert_ops.append({"operation": operation, "associated_item_id": associated_item_id, "patch": patch, "index": index})
                 continue
             matches = [
@@ -3778,34 +3771,35 @@ class AiBuilderFacade:
             else:
                 upsert_ops.append({"operation": "create", "associated_item_id": None, "patch": patch, "index": index})
 
-        remove_ids = [
-            item_id
-            for item_id in (_coerce_positive_int(raw_id) for raw_id in request.remove_associated_item_ids)
-            if item_id is not None
-        ]
+        remove_ids: list[int] = []
         for raw_id in request.remove_associated_item_ids:
-            item_id = _coerce_positive_int(raw_id)
+            item_id, issue = _resolve_associated_resource_selector(
+                raw_id,
+                existing_resources=existing_resources,
+                existing_by_id=existing_by_id,
+                reason_path="remove_associated_item_ids",
+            )
             if item_id is None:
-                blocking_issues.append({"error_code": "ASSOCIATED_RESOURCE_NOT_FOUND", "reason_path": "remove_associated_item_ids", "received": raw_id})
+                blocking_issues.append(issue or {"error_code": "ASSOCIATED_RESOURCE_NOT_FOUND", "reason_path": "remove_associated_item_ids", "received": raw_id})
                 continue
-            if item_id not in existing_by_id:
-                blocking_issues.append(_associated_resource_not_found_issue("remove_associated_item_ids", item_id, existing_by_id))
-            elif item_id in touched_ids:
+            remove_ids.append(item_id)
+            if item_id in touched_ids:
                 blocking_issues.append(_duplicate_associated_resource_issue("remove_associated_item_ids", item_id))
             else:
                 touched_ids.add(item_id)
 
-        reorder_ids = [
-            item_id
-            for item_id in (_coerce_positive_int(raw_id) for raw_id in request.reorder_associated_item_ids)
-            if item_id is not None
-        ]
+        reorder_ids: list[int] = []
         for raw_id in request.reorder_associated_item_ids:
-            item_id = _coerce_positive_int(raw_id)
+            item_id, issue = _resolve_associated_resource_selector(
+                raw_id,
+                existing_resources=existing_resources,
+                existing_by_id=existing_by_id,
+                reason_path="reorder_associated_item_ids",
+            )
             if item_id is None:
-                blocking_issues.append({"error_code": "ASSOCIATED_RESOURCE_NOT_FOUND", "reason_path": "reorder_associated_item_ids", "received": raw_id})
-            elif item_id not in existing_by_id:
-                blocking_issues.append(_associated_resource_not_found_issue("reorder_associated_item_ids", item_id, existing_by_id))
+                blocking_issues.append(issue or {"error_code": "ASSOCIATED_RESOURCE_NOT_FOUND", "reason_path": "reorder_associated_item_ids", "received": raw_id})
+                continue
+            reorder_ids.append(item_id)
 
         for index, view_config in enumerate(request.view_configs):
             refs = [str(ref or "").strip() for ref in view_config.associated_item_refs if str(ref or "").strip()]
@@ -3819,21 +3813,26 @@ class AiBuilderFacade:
                         "message": "associated_item_refs must reference client_key values from upsert_resources in the same apply call",
                     }
                 )
-            invalid_ids = [
-                item_id
-                for item_id in view_config.associated_item_ids
-                if _coerce_positive_int(item_id) is None or _coerce_positive_int(item_id) not in existing_by_id
-            ]
-            if invalid_ids:
-                blocking_issues.append(
-                    {
-                        "error_code": "ASSOCIATED_RESOURCE_NOT_FOUND",
-                        "reason_path": f"view_configs[{index}].associated_item_ids",
-                        "invalid_associated_item_ids": invalid_ids,
-                        "available_associated_item_ids": sorted(existing_by_id),
-                        "message": "view_configs.associated_item_ids must use app-level associated_item_id values from app_get",
-                    }
+            resolved_ids: list[int] = []
+            for raw_id in view_config.associated_item_ids:
+                item_id, issue = _resolve_associated_resource_selector(
+                    raw_id,
+                    existing_resources=existing_resources,
+                    existing_by_id=existing_by_id,
+                    reason_path=f"view_configs[{index}].associated_item_ids",
                 )
+                if item_id is None:
+                    blocking_issues.append(
+                        issue
+                        or {
+                            "error_code": "ASSOCIATED_RESOURCE_NOT_FOUND",
+                            "reason_path": f"view_configs[{index}].associated_item_ids",
+                            "received": raw_id,
+                        }
+                    )
+                    continue
+                resolved_ids.append(item_id)
+            resolved_associated_item_refs[f"view_configs[{index}].associated_item_ids"] = resolved_ids
             raw_limit_type = str(view_config.limit_type or ("all" if view_config.visible else "")).strip().lower()
             if view_config.visible and raw_limit_type and raw_limit_type not in {"all", "select"}:
                 blocking_issues.append(
@@ -3851,6 +3850,8 @@ class AiBuilderFacade:
                 for issue in resource_match_issues
             ]
         )
+        if resolved_associated_item_refs:
+            normalized_args["resolved_associated_item_refs"] = deepcopy(resolved_associated_item_refs)
 
         if blocking_issues:
             return finalize(
@@ -4008,12 +4009,33 @@ class AiBuilderFacade:
             resources_after = []
 
         for index, view_config in enumerate(request.view_configs):
+            resolved_view_config_ids = resolved_associated_item_refs.get(f"view_configs[{index}].associated_item_ids", [])
+            view_name = str(view_config.view_key or "").strip()
+            missing_ref_ids = [
+                str(ref or "").strip()
+                for ref in view_config.associated_item_refs
+                if str(ref or "").strip() and str(ref or "").strip() not in client_key_to_id
+            ]
+            if missing_ref_ids:
+                failed.append(
+                    {
+                        "operation": "view_config",
+                        "index": index,
+                        "view_key": view_config.view_key,
+                        "view_name": view_name,
+                        "status": "failed",
+                        "error_code": "ASSOCIATED_RESOURCE_REF_UNRESOLVED",
+                        "missing_refs": missing_ref_ids,
+                        "message": "view_config references associated resources that were not successfully created or resolved; skipped view config write to avoid clearing existing associations",
+                    }
+                )
+                continue
             selected_ids = [
                 item_id
                 for item_id in (
                     _coerce_positive_int(raw_id)
                     for raw_id in [
-                        *view_config.associated_item_ids,
+                        *resolved_view_config_ids,
                         *[client_key_to_id.get(str(ref or "").strip()) for ref in view_config.associated_item_refs],
                     ]
                 )
@@ -4024,19 +4046,21 @@ class AiBuilderFacade:
                 available_resources=resources_after,
             )
             if issues:
-                failed.append({"operation": "view_config", "index": index, "view_key": view_config.view_key, "status": "failed", "issues": issues})
+                failed.append({"operation": "view_config", "index": index, "view_key": view_config.view_key, "view_name": view_name, "status": "failed", "issues": issues})
                 continue
             try:
                 write_executed = True
                 self._update_view_associated_resources_config(profile=profile, view_key=view_config.view_key, associated_resources_payload=view_payload)
                 try:
                     config = self.views.view_get_config(profile=profile, viewgraph_key=view_config.view_key).get("result") or {}
+                    view_name = _extract_view_name(config if isinstance(config, dict) else {}) or view_name
                     actual_config = _extract_view_associated_resources_config(config if isinstance(config, dict) else {}, available_resources=resources_after)
                     verified_config = expected_config is not None and _associated_resources_config_matches(expected_config, actual_config)
                     if not verified_config and expected_config is not None:
                         self._update_view_associated_resources_config(profile=profile, view_key=view_config.view_key, associated_resources_payload=view_payload)
                         refreshed_resources = self._load_associated_resources_for_builder(profile=profile, app_key=app_key)
                         refreshed_config = self.views.view_get_config(profile=profile, viewgraph_key=view_config.view_key).get("result") or {}
+                        view_name = _extract_view_name(refreshed_config if isinstance(refreshed_config, dict) else {}) or view_name
                         actual_config = _extract_view_associated_resources_config(
                             refreshed_config if isinstance(refreshed_config, dict) else {},
                             available_resources=refreshed_resources,
@@ -4045,10 +4069,10 @@ class AiBuilderFacade:
                 except (QingflowApiError, RuntimeError):
                     actual_config = {}
                     verified_config = False
-                view_config_results.append({"index": index, "view_key": view_config.view_key, "status": "success" if verified_config else "partial_success", "associated_resources_verified": verified_config, "expected": expected_config, "actual": actual_config})
+                view_config_results.append({"index": index, "view_key": view_config.view_key, "view_name": view_name, "status": "success" if verified_config else "partial_success", "associated_resources_verified": verified_config, "expected": expected_config, "actual": actual_config})
             except (QingflowApiError, RuntimeError) as error:
                 api_error = _coerce_api_error(error)
-                failed.append({"operation": "view_config", "index": index, "view_key": view_config.view_key, "status": "failed", "error_code": "VIEW_ASSOCIATED_RESOURCES_WRITE_FAILED", "message": api_error.message, "transport_error": _transport_error_payload(api_error)})
+                failed.append({"operation": "view_config", "index": index, "view_key": view_config.view_key, "view_name": view_name, "status": "failed", "error_code": "VIEW_ASSOCIATED_RESOURCES_WRITE_FAILED", "message": api_error.message, "transport_error": _transport_error_payload(api_error)})
 
         final_resources: list[dict[str, Any]] = []
         readback_failed = False
@@ -4115,6 +4139,7 @@ class AiBuilderFacade:
                     str(index): _summarize_compiled_match_rules(rules)
                     for index, rules in compiled_resource_match_rules.items()
                 },
+                "resolved_associated_item_refs": resolved_associated_item_refs,
             },
             "request_id": None,
             "suggested_next_call": None if verified else {"tool_name": "app_get", "arguments": {"profile": profile, "app_key": app_key}},
@@ -4123,6 +4148,7 @@ class AiBuilderFacade:
             "verification": {"associated_resources_verified": pool_verified, "associated_resource_view_configs_verified": view_configs_verified, "readback_loaded": not readback_failed},
             "verified": verified,
             "app_key": app_key,
+            "app_name": app_name,
             "mode": "apply",
             "created": created,
             "updated": updated,
@@ -4601,9 +4627,18 @@ class AiBuilderFacade:
             "associated_resources": len(associated_resources),
             "custom_buttons": len(custom_buttons),
         }
+        app_name = str(
+            base_result.get("formTitle")
+            or base_result.get("title")
+            or base_result.get("appName")
+            or base_result.get("name")
+            or app_key
+        ).strip() or app_key
         response = AppReadSummaryResponse(
             app_key=app_key,
-            title=base_result.get("formTitle"),
+            app_name=app_name,
+            name=app_name,
+            title=app_name,
             app_icon=str(base_result.get("appIcon") or "").strip() or None,
             visibility=_public_visibility_from_member_auth(base_result.get("auth")),
             tag_ids=_coerce_int_list(base_result.get("tagIds")),
@@ -5430,7 +5465,7 @@ class AiBuilderFacade:
         for index, patch, config in semantic_patches:
             config_payload = config.model_dump(mode="json", exclude_none=True)
             reason_base = f"upsert_buttons[{index}].trigger_add_data_config"
-            if config.que_relation:
+            if "que_relation" in config.model_fields_set:
                 issues.append(
                     {
                         "error_code": "MIXED_CUSTOM_BUTTON_MAPPING_MODES",
@@ -5734,11 +5769,12 @@ class AiBuilderFacade:
             )
             return {"verified": False, "write_executed": False, "write_succeeded": False, "view_configs": results, "failed": failed, "warnings": warnings}
 
-        view_keys = {
-            _extract_view_key(view)
+        existing_views_by_key = {
+            _extract_view_key(view): view
             for view in (existing_views if isinstance(existing_views, list) else [])
             if isinstance(view, dict) and _extract_view_key(view)
         }
+        view_keys = set(existing_views_by_key)
         button_inventory: dict[int, dict[str, Any]] = {}
         for item in [*existing_buttons, *readback_buttons]:
             if not isinstance(item, dict):
@@ -5770,6 +5806,7 @@ class AiBuilderFacade:
             try:
                 current_response = self.views.view_get_config(profile=profile, viewgraph_key=view_key)
                 current_config = current_response.get("result") if isinstance(current_response.get("result"), dict) else {}
+                view_name = _extract_view_name(current_config) or _extract_view_name(existing_views_by_key.get(view_key) or {}) or view_key
             except (QingflowApiError, RuntimeError) as error:
                 api_error = _coerce_api_error(error)
                 issue = {
@@ -5778,6 +5815,7 @@ class AiBuilderFacade:
                     "status": "failed",
                     "error_code": "VIEW_CONFIG_READ_FAILED",
                     "view_key": view_key,
+                    "view_name": _extract_view_name(existing_views_by_key.get(view_key) or {}) or view_key,
                     "message": api_error.message,
                     "transport_error": _transport_error_payload(api_error),
                 }
@@ -5868,6 +5906,7 @@ class AiBuilderFacade:
                             "status": "failed",
                             "error_code": "INSIDE_BUTTON_BACKEND_UNSUPPORTED",
                             "view_key": view_key,
+                            "view_name": view_name,
                             "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),
@@ -5880,9 +5919,10 @@ class AiBuilderFacade:
                             "index": config_index,
                             "operation": "view_config",
                             "status": "failed",
-                            "error_code": "VIEW_BUTTON_CONFIG_WRITE_FAILED",
-                            "view_key": view_key,
-                            "message": fallback_api_error.message,
+                        "error_code": "VIEW_BUTTON_CONFIG_WRITE_FAILED",
+                        "view_key": view_key,
+                        "view_name": view_name,
+                        "message": fallback_api_error.message,
                             "transport_error": _transport_error_payload(fallback_api_error),
                             "initial_error": _transport_error_payload(api_error),
                         }
@@ -5897,6 +5937,7 @@ class AiBuilderFacade:
                         "status": "failed",
                         "error_code": "INSIDE_BUTTON_BACKEND_UNSUPPORTED",
                         "view_key": view_key,
+                        "view_name": view_name,
                         "message": "backend rejected inside/list-button placement",
                         "backend_message": api_error.message,
                         "transport_error": _transport_error_payload(api_error),
@@ -5913,6 +5954,7 @@ class AiBuilderFacade:
                         "status": "failed",
                         "error_code": "VIEW_BUTTON_CONFIG_WRITE_FAILED",
                         "view_key": view_key,
+                        "view_name": view_name,
                         "message": api_error.message,
                         "transport_error": _transport_error_payload(api_error),
                     }
@@ -5942,6 +5984,7 @@ class AiBuilderFacade:
                         "operation": "view_config",
                         "status": "success" if verified else ("partial_success" if unsupported_list_issue is not None else "unverified"),
                         "view_key": view_key,
+                        "view_name": view_name,
                         "mode": "replace" if replace_existing else "merge",
                         "buttons_configured": len(new_dtos),
                         "view_buttons_verified": verified,
@@ -5964,6 +6007,7 @@ class AiBuilderFacade:
                         "operation": "view_config",
                         "status": "unverified",
                         "view_key": view_key,
+                        "view_name": view_name,
                         "mode": "replace" if replace_existing else "merge",
                         "buttons_configured": len(new_dtos),
                         "view_buttons_verified": None,
@@ -7044,6 +7088,7 @@ class AiBuilderFacade:
                 },
                 "app_key": target.app_key,
                 "app_icon": str(resolved.get("app_icon") or visual_result.get("app_icon") or "").strip() or None,
+                "app_name": str(visual_result.get("app_name_after") or target.app_name),
                 "app_name_before": str(visual_result.get("app_name_before") or target.app_name),
                 "app_name_after": str(visual_result.get("app_name_after") or target.app_name),
                 "app_base_updated": bool(visual_result.get("updated")),
@@ -7284,7 +7329,8 @@ class AiBuilderFacade:
             actual_app_name = str(base_info.get("formTitle") or effective_app_name).strip() or effective_app_name
             actual_app_icon = str(base_info.get("appIcon") or visual_result.get("app_icon") or "").strip() or None
             expected_app_icon = str(visual_result.get("app_icon") or "").strip() or None
-            app_base_verified = actual_app_name == effective_app_name and actual_app_icon == expected_app_icon
+            app_icon_verified = True if expected_app_icon is None else actual_app_icon == expected_app_icon
+            app_base_verified = actual_app_name == effective_app_name and app_icon_verified
             verified = app_base_verified and relation_target_metadata_verified
             response = {
                 "status": "success" if verified else "partial_success",
@@ -7308,6 +7354,7 @@ class AiBuilderFacade:
                 },
                 "app_key": target.app_key,
                 "app_icon": str(visual_result.get("app_icon") or "").strip() or None,
+                "app_name": effective_app_name,
                 "app_name_before": str(visual_result.get("app_name_before") or target.app_name),
                 "app_name_after": effective_app_name,
                 "app_base_updated": bool(visual_result.get("updated")),
@@ -7505,6 +7552,7 @@ class AiBuilderFacade:
             },
             "app_key": target.app_key,
             "app_icon": str(visual_result.get("app_icon") or resolved.get("app_icon") or "").strip() or None,
+            "app_name": effective_app_name,
             "app_name_before": str(visual_result.get("app_name_before") or target.app_name),
             "app_name_after": effective_app_name,
             "app_base_updated": bool(visual_result.get("updated")),
@@ -7514,6 +7562,13 @@ class AiBuilderFacade:
                 "updated": updated,
                 "removed": removed,
             },
+            "field_diff_details": _schema_field_diff_details(
+                added=added,
+                updated=updated,
+                removed=removed,
+                before_fields=original_fields,
+                after_fields=current_fields,
+            ),
             "verified": False,
             "tag_ids_after": [],
             "package_attached": None,
@@ -7533,6 +7588,13 @@ class AiBuilderFacade:
         try:
             verified = self.app_read(profile=profile, app_key=target.app_key, include_raw=False)
             verified_field_names = {field["name"] for field in verified["schema"]["fields"]}
+            response["field_diff_details"] = _schema_field_diff_details(
+                added=added,
+                updated=updated,
+                removed=removed,
+                before_fields=original_fields,
+                after_fields=cast(list[dict[str, Any]], verified["schema"]["fields"]),
+            )
             verification_ok = all(name in verified_field_names for name in added + updated) and all(name not in verified_field_names for name in removed)
             data_display_verification = _verify_data_display_readback(
                 form_settings=verified.get("form_settings"),
@@ -7564,7 +7626,8 @@ class AiBuilderFacade:
             actual_app_name = str(base_info.get("formTitle") or effective_app_name).strip() or effective_app_name
             actual_app_icon = str(base_info.get("appIcon") or visual_result.get("app_icon") or "").strip() or None
             expected_app_icon = str(visual_result.get("app_icon") or "").strip() or None
-            app_base_verified = actual_app_name == effective_app_name and actual_app_icon == expected_app_icon
+            app_icon_verified = True if expected_app_icon is None else actual_app_icon == expected_app_icon
+            app_base_verified = actual_app_name == effective_app_name and app_icon_verified
         except (QingflowApiError, RuntimeError) as error:
             base_error = _coerce_api_error(error)
             if verification_error is None:
@@ -7658,6 +7721,7 @@ class AiBuilderFacade:
                 details=_with_state_read_blocked_details({"app_key": app_key}, resource="schema", error=api_error),
                 suggested_next_call={"tool_name": "app_get_layout", "arguments": {"profile": profile, "app_key": app_key}},
             ))
+        app_name = str(schema_result.get("formTitle") or schema_result.get("title") or schema_result.get("appName") or app_key).strip() or app_key
         parsed = _parse_schema(schema_result)
         current_fields = parsed["fields"]
         requested_sections, missing_selectors = _resolve_layout_sections_to_names(requested_sections, current_fields)
@@ -7740,6 +7804,7 @@ class AiBuilderFacade:
                 "warnings": [],
                 "verification": {"layout_verified": True, "layout_summary_verified": True},
                 "app_key": app_key,
+                "app_name": app_name,
                 "layout_diff": {
                     "mode": mode.value,
                     "replaced": mode == LayoutApplyMode.replace,
@@ -7828,6 +7893,7 @@ class AiBuilderFacade:
                 "warnings": [],
                 "verification": {"layout_verified": False, "layout_summary_verified": False, "layout_read_unavailable": True},
                 "app_key": app_key,
+                "app_name": app_name,
                 "layout_diff": {
                     "mode": mode.value,
                     "replaced": mode == LayoutApplyMode.replace,
@@ -7884,6 +7950,7 @@ class AiBuilderFacade:
             "warnings": warnings,
             "verification": {"layout_verified": layout_verified, "layout_summary_verified": layout_summary_verified},
             "app_key": app_key,
+            "app_name": app_name,
             "layout_diff": {
                 "mode": mode.value,
                 "replaced": mode == LayoutApplyMode.replace,
@@ -7946,6 +8013,7 @@ class AiBuilderFacade:
                 details=_with_state_read_blocked_details({"app_key": app_key}, resource="workflow", error=api_error),
                 suggested_next_call={"tool_name": "app_get_flow", "arguments": {"profile": profile, "app_key": app_key}},
             ))
+        app_name = str(base.get("formTitle") or base.get("title") or base.get("appName") or app_key).strip() or app_key
         entity = _entity_spec_from_app(base_info=base, schema=schema, views=None)
         current_fields = _parse_schema(schema)["fields"]
         normalized_nodes, resolution_issues = self._normalize_flow_nodes(profile=profile, current_fields=current_fields, nodes=nodes)
@@ -8113,6 +8181,7 @@ class AiBuilderFacade:
                 "workflow_read_unavailable": verified_nodes_unavailable,
             },
             "app_key": app_key,
+            "app_name": app_name,
             "flow_diff": {"mode": "replace", "node_count": desired_node_count},
             "verified": workflow_verified,
         }
@@ -8188,6 +8257,7 @@ class AiBuilderFacade:
                 details=_with_state_read_blocked_details({"app_key": app_key}, resource="views", error=api_error),
                 suggested_next_call={"tool_name": "app_get", "arguments": {"profile": profile, "app_key": app_key}},
             ))
+        app_name = str(base.get("formTitle") or base.get("title") or base.get("appName") or "").strip() or None
         existing_views = existing_views or []
         existing_by_key: dict[str, dict[str, Any]] = {}
         existing_by_name: dict[str, list[dict[str, Any]]] = {}
@@ -8295,9 +8365,15 @@ class AiBuilderFacade:
                     )
                 )
         removed: list[str] = []
+        removed_keys: set[str] = set()
         view_results: list[dict[str, Any]] = []
-        for name in remove_views:
-            matches = existing_by_name.get(name, [])
+        failed_views: list[dict[str, Any]] = []
+        for selector in remove_views:
+            selector_text = str(selector or "").strip()
+            if not selector_text:
+                continue
+            key_match = existing_by_key.get(selector_text)
+            matches = [key_match] if isinstance(key_match, dict) else existing_by_name.get(selector_text, [])
             if len(matches) > 1:
                 return _failed(
                     "AMBIGUOUS_VIEW",
@@ -8305,7 +8381,7 @@ class AiBuilderFacade:
                     normalized_args=normalized_args,
                     details={
                         "app_key": app_key,
-                        "view_name": name,
+                        "view_name": selector_text,
                         "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
@@ -8313,21 +8389,36 @@ class AiBuilderFacade:
                     },
                     suggested_next_call={"tool_name": "app_get", "arguments": {"profile": profile, "app_key": app_key}},
                 )
+            if not matches:
+                failed_view = {
+                    "name": selector_text,
+                    "view_key": selector_text,
+                    "type": None,
+                    "status": "failed",
+                    "error_code": "VIEW_NOT_FOUND",
+                    "message": "remove_views item did not match an existing view name or view_key",
+                }
+                failed_views.append(failed_view)
+                view_results.append(deepcopy(failed_view))
+                continue
             if len(matches) == 1:
                 key = _extract_view_key(matches[0])
+                removed_name = _extract_view_name(matches[0]) or selector_text
                 self.views.view_delete(profile=profile, viewgraph_key=key)
-                removed.append(name)
-                existing_by_name.pop(name, None)
-                existing_by_key.pop(key, None)
-                view_results.append({"name": name, "view_key": key, "type": None, "status": "removed"})
+                removed.append(removed_name)
+                if key:
+                    removed_keys.add(key)
+                    existing_by_key.pop(key, None)
+                existing_by_name.pop(removed_name, None)
+                view_results.append({"name": removed_name, "view_key": key, "type": None, "status": "removed"})
         created: list[str] = []
         updated: list[str] = []
-        failed_views: list[dict[str, Any]] = []
         existing_view_list = [
             view
             for view in (existing_views if isinstance(existing_views, list) else [])
             if isinstance(view, dict)
-            and _extract_view_name(view) not in remove_views
+            and _extract_view_name(view) not in removed
+            and _extract_view_key(view) not in removed_keys
         ]
         for ordinal, patch in enumerate(upsert_views, start=1):
             apply_columns = _resolve_view_visible_field_names(patch)
@@ -8540,6 +8631,11 @@ class AiBuilderFacade:
             if not existing_key and query_condition_payload_for_apply is None:
                 query_condition_payload_for_apply = _empty_view_query_conditions_payload()
                 expected_query_conditions_for_verify = _normalize_view_query_conditions_for_compare(query_condition_payload_for_apply)
+            if not existing_key and associated_resources_payload_for_apply is None:
+                associated_resources_payload_for_apply, _, _ = _build_view_associated_resources_payload(
+                    associated_resources={"visible": True, "limit_type": "all", "associated_item_ids": []},
+                    available_resources=associated_resources,
+                )
             try:
                 view_auth_override = (
                     self._compile_visibility_to_member_auth(profile=profile, visibility=patch.visibility)
@@ -9149,9 +9245,11 @@ class AiBuilderFacade:
                 verification_by_view.append(
                     {
                         "name": name,
+                        "view_key": item.get("view_key"),
                         "type": item.get("type"),
                         "status": "removed",
-                        "present_in_readback": None if verified_views_unavailable else name not in verified_names,
+                        "present_in_readback": None if verified_views_unavailable else name in verified_names,
+                        "removed_verified": None if verified_views_unavailable else name not in verified_names,
                     }
                 )
             else:
@@ -9172,7 +9270,7 @@ class AiBuilderFacade:
         view_filters_verified = verified and not filter_readback_pending and not filter_mismatches
         view_query_conditions_verified = verified and not query_condition_readback_pending and not query_condition_mismatches
         view_associated_resources_verified = verified and not associated_resource_readback_pending and not associated_resource_mismatches
-        view_buttons_verified = verified and not button_readback_pending and not button_mismatches
+        view_buttons_verified = verified and not button_readback_pending and not button_mismatches and not custom_button_readback_pending
         noop = not created and not updated and not removed
         if failed_views:
             successful_changes = bool(created or updated or removed)
@@ -9241,6 +9339,7 @@ class AiBuilderFacade:
                     "custom_button_readback_pending_entries": deepcopy(custom_button_readback_pending_entries),
                 },
                 "app_key": app_key,
+                "app_name": app_name,
                 "views_diff": {"created": created, "updated": updated, "removed": removed, "failed": failed_views},
                 "verified": verified and view_filters_verified and view_query_conditions_verified and view_associated_resources_verified and view_buttons_verified,
             }
@@ -9313,6 +9412,7 @@ class AiBuilderFacade:
                 "by_view": verification_by_view,
             },
             "app_key": app_key,
+            "app_name": app_name,
             "views_diff": {"created": created, "updated": updated, "removed": removed, "failed": []},
             "verified": all_verified,
         }
@@ -9338,6 +9438,7 @@ class AiBuilderFacade:
                 suggested_next_call={"tool_name": "app_get", "arguments": {"profile": profile, "app_key": app_key}},
             )
         tag_ids_before = _coerce_int_list(base_before.get("tagIds"))
+        app_name_before = str(base_before.get("formTitle") or base_before.get("title") or base_before.get("appName") or "").strip() or None
         already_published = bool(base_before.get("appPublishStatus") in {1, 2})
         package_already_attached = None if not expected_package_tag_id else expected_package_tag_id in tag_ids_before
         try:
@@ -9368,6 +9469,7 @@ class AiBuilderFacade:
                 "warnings": [],
                 "verification": {"published": True, "package_attached": package_already_attached, "views_ok": True},
                 "app_key": app_key,
+                "app_name": app_name_before,
                 "published": True,
                 "package_attached": package_already_attached,
                 "tag_ids_after": tag_ids_before,
@@ -9400,6 +9502,7 @@ class AiBuilderFacade:
                 suggested_next_call={"tool_name": "app_get", "arguments": {"profile": profile, "app_key": app_key}},
             )
         tag_ids_after = _coerce_int_list(base.get("tagIds"))
+        app_name_after = str(base.get("formTitle") or base.get("title") or base.get("appName") or app_name_before or "").strip() or None
         package_attached = None if not expected_package_tag_id else expected_package_tag_id in tag_ids_after
         try:
             views, views_unavailable = self._load_views_result(profile=profile, app_key=app_key, tolerate_404=True)
@@ -9440,6 +9543,7 @@ class AiBuilderFacade:
             "warnings": warnings,
             "verification": {"published": bool(base.get("appPublishStatus") in {1, 2}), "package_attached": package_attached, "views_ok": views_ok, "views_read_unavailable": views_unavailable},
             "app_key": app_key,
+            "app_name": app_name_after,
             "published": bool(base.get("appPublishStatus") in {1, 2}),
             "package_attached": package_attached,
             "tag_ids_after": tag_ids_after,
@@ -9577,6 +9681,7 @@ class AiBuilderFacade:
         if resolved_outcome is not None:
             permission_outcomes.append(resolved_outcome)
         app_key = str(app_result.get("app_key") or request.app_key)
+        app_name = str(app_result.get("app_name") or "").strip() or None
         permission_outcome = self._guard_app_permission(
             profile=profile,
             app_key=app_key,
@@ -9657,6 +9762,13 @@ class AiBuilderFacade:
 
         for patch in upsert_charts:
             try:
+                dataset_source = _chart_patch_dataset_source_type(patch)
+                if dataset_source:
+                    raise ValueError(
+                        "app_charts_apply only creates or edits app-source QingBI reports with dataSourceType=qingflow; "
+                        f"dataset report source '{dataset_source}' is not supported for creation/update yet. "
+                        "Create the dataset report in QingBI first, then attach it with app_associated_resources_apply using report_source='dataset'."
+                    )
                 config_update_requested = _chart_patch_updates_chart_config(patch)
                 chart_visible_auth = (
                     self._compile_visibility_to_chart_visible_auth(profile=profile, visibility=patch.visibility)
@@ -9680,6 +9792,13 @@ class AiBuilderFacade:
                 existing_name = str((existing or {}).get("chartName") or "").strip()
                 existing_type = _normalize_backend_chart_type((existing or {}).get("chartType"))
                 target_type = _map_public_chart_type_to_backend(patch.chart_type)
+                existing_source_type = _chart_item_dataset_source_type(existing or {})
+                if existing_source_type:
+                    raise ValueError(
+                        "app_charts_apply only creates or edits app-source QingBI reports with dataSourceType=qingflow; "
+                        f"existing chart '{chart_id or patch.name}' uses dataset report source '{existing_source_type}' and is not supported for update yet. "
+                        "Update it in QingBI directly, then attach the existing report with app_associated_resources_apply using report_source='dataset'."
+                    )
                 if existing is None:
                     temp_chart_id = str(patch.chart_id or f"mcp_{uuid4().hex[:16]}")
                     create_payload = {
@@ -9908,6 +10027,7 @@ class AiBuilderFacade:
                     "chart_list_source": readback_list_source or existing_chart_list_source,
                 },
                 "app_key": app_key,
+                "app_name": app_name,
                 "chart_results": chart_results,
                 "verified": False if failed_items else verified,
             })
@@ -9936,6 +10056,7 @@ class AiBuilderFacade:
                 "chart_list_source": existing_chart_list_source if noop else readback_list_source,
             },
             "app_key": app_key,
+            "app_name": app_name,
             "chart_results": chart_results,
             "verified": result_verified,
         })
@@ -10221,6 +10342,9 @@ class AiBuilderFacade:
                 "publish_failed": publish_failed,
             },
             "dash_key": dash_key,
+            "dash_name": update_payload.get("dashName"),
+            "package_id": target_package_tag_id,
+            "created": creating,
             "published": published,
             "verified": verified,
             "draft_result": draft_result,
@@ -10313,6 +10437,49 @@ class AiBuilderFacade:
             verification["published"] = False
             return response
         publish_result = self._publish_current_edit_version(profile=profile, app_key=app_key, edit_version_no=edit_version_no)
+        if publish_result.get("status") == "failed" and publish_result.get("error_code") == "APP_EDIT_LOCKED":
+            details = response.get("details")
+            if not isinstance(details, dict):
+                details = {}
+                response["details"] = details
+            suggested = publish_result.get("suggested_next_call")
+            release_args = suggested.get("arguments") if isinstance(suggested, dict) else {}
+            if isinstance(release_args, dict):
+                release_result = self.app_release_edit_lock_if_mine(
+                    profile=profile,
+                    app_key=app_key,
+                    lock_owner_email=str(release_args.get("lock_owner_email") or ""),
+                    lock_owner_name=str(release_args.get("lock_owner_name") or ""),
+                )
+                details["edit_lock_release_result"] = release_result
+                if release_result.get("status") == "success":
+                    retry_result = self._publish_current_edit_version(profile=profile, app_key=app_key, edit_version_no=None)
+                    details["publish_retry_after_edit_lock_release"] = retry_result
+                    publish_result = retry_result
+                    response["retried_after_edit_lock_release"] = True
+                    response["edit_lock_released"] = True
+                elif release_result.get("error_code") == "EDIT_LOCK_OWNER_UNKNOWN" and edit_version_no is not None:
+                    try:
+                        self.apps.app_edit_finished(profile=profile, app_key=app_key, payload={"editVersionNo": edit_version_no})
+                        release_result = {
+                            "status": "success",
+                            "error_code": None,
+                            "recoverable": False,
+                            "message": "released current apply edit context before publish retry",
+                            "details": {"app_key": app_key, "edit_version_no": edit_version_no, "release_strategy": "current_apply_edit_context"},
+                            "verification": {"released": True},
+                            "app_key": app_key,
+                            "verified": True,
+                        }
+                        details["edit_lock_release_result"] = release_result
+                        retry_result = self._publish_current_edit_version(profile=profile, app_key=app_key, edit_version_no=None)
+                        details["publish_retry_after_edit_lock_release"] = retry_result
+                        publish_result = retry_result
+                        response["retried_after_edit_lock_release"] = True
+                        response["edit_lock_released"] = True
+                    except (QingflowApiError, RuntimeError) as error:
+                        api_error = _coerce_api_error(error)
+                        details["current_apply_edit_context_release_error"] = _transport_error_payload(api_error)
         response["publish_result"] = publish_result
         response["published"] = bool(publish_result.get("published"))
         verification["published"] = bool(publish_result.get("published"))
@@ -10337,6 +10504,14 @@ class AiBuilderFacade:
             "schema_source": schema_source,
         }
 
+    def _read_app_name_for_builder_output(self, *, profile: str, app_key: str) -> str | None:
+        try:
+            base = self.apps.app_get_base(profile=profile, app_key=app_key, include_raw=True).get("result") or {}
+        except (QingflowApiError, RuntimeError):
+            return None
+        app_name = str(base.get("formTitle") or base.get("title") or base.get("appName") or "").strip()
+        return app_name or None
+
     def _sync_system_view_apply_config(
         self,
         *,
@@ -12192,6 +12367,8 @@ def _extract_edit_lock_owner(message: str) -> JSONObject:
     patterns = [
         r"应用已被\s*(?P<name>[^（(]+?)\s*[（(](?P<email>[^）)]+)[）)]\s*编辑",
         r"edited by\s*(?P<name>[^<(]+?)\s*<(?P<email>[^>]+)>",
+        r"active editor\s+(?P<email>[A-Za-z0-9._%+\-]+@[A-Za-z0-9.\-]+\.[A-Za-z]{2,})",
+        r"(?P<email>[A-Za-z0-9._%+\-]+@[A-Za-z0-9.\-]+\.[A-Za-z]{2,})",
     ]
     for pattern in patterns:
         match = re.search(pattern, text)
@@ -12337,13 +12514,16 @@ def _bi_field_id_for_field(*, app_key: str, field: dict[str, Any], qingbi_fields
 
 
 def _map_public_chart_type_to_backend(chart_type: PublicChartType) -> str:
-    return {
+    aliases = {
         PublicChartType.target: "indicator",
+        PublicChartType.indicator: "indicator",
         PublicChartType.pie: "pie",
         PublicChartType.bar: "bar",
         PublicChartType.line: "line",
         PublicChartType.table: "detail",
-    }[chart_type]
+        PublicChartType.detail: "detail",
+    }
+    return aliases.get(chart_type, chart_type.value)
 
 
 _CHART_PARTIAL_PATCH_KEY_ALIASES = {
@@ -12579,6 +12759,25 @@ def _build_public_metric_fields(
     return metrics or [_default_public_total_metric()]
 
 
+def _split_axis_metric_fields(metrics: list[dict[str, Any]]) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]:
+    if not metrics:
+        default_metric = _default_public_total_metric()
+        return [deepcopy(default_metric)], [deepcopy(default_metric)]
+    if len(metrics) == 1:
+        return [deepcopy(metrics[0])], [deepcopy(metrics[0])]
+    return [deepcopy(metrics[0])], [deepcopy(metrics[1])]
+
+
+def _two_gauge_metric_fields(metrics: list[dict[str, Any]], *, requested_metric_count: int) -> list[dict[str, Any]]:
+    if not metrics:
+        return []
+    if len(metrics) == 1:
+        if requested_metric_count <= 0:
+            return [deepcopy(metrics[0])]
+        return [deepcopy(metrics[0]), _default_public_total_metric()]
+    return [deepcopy(metrics[0]), deepcopy(metrics[1])]
+
+
 def _build_public_chart_filter_matrix(
     rules: list[Any],
     *,
@@ -12647,23 +12846,28 @@ def _build_public_chart_config_payload(
     for selector in list(config.pop("query_condition_field_ids", []) or []):
         field = _resolve_public_field(selector, field_lookup=field_lookup)
         query_condition_field_ids.append(_bi_field_id_for_field(app_key=app_key, field=field, qingbi_fields_by_id=qingbi_fields_by_id))
+    backend_chart_type = _map_public_chart_type_to_backend(patch.chart_type)
+    if backend_chart_type == "gauge" and not patch.indicator_field_ids and "selectedMetrics" not in config:
+        raise ValueError("gauge charts require at least one indicator_field_ids value; pass one metric and the CLI will pair it with 数据总量")
+    selected_dimensions = _build_public_dimension_fields(
+        patch.dimension_field_ids,
+        app_key=app_key,
+        field_lookup=field_lookup,
+        qingbi_fields_by_id=qingbi_fields_by_id,
+    )
+    selected_metrics = _build_public_metric_fields(
+        patch.indicator_field_ids,
+        app_key=app_key,
+        field_lookup=field_lookup,
+        qingbi_fields_by_id=qingbi_fields_by_id,
+        aggregate=aggregate,
+    )
     payload: dict[str, Any] = {
         "chartName": patch.name,
-        "chartType": _map_public_chart_type_to_backend(patch.chart_type),
+        "chartType": backend_chart_type,
         "dataSource": {"dataSourceId": app_key, "dataSourceType": "qingflow"},
-        "selectedDimensions": _build_public_dimension_fields(
-            patch.dimension_field_ids,
-            app_key=app_key,
-            field_lookup=field_lookup,
-            qingbi_fields_by_id=qingbi_fields_by_id,
-        ),
-        "selectedMetrics": _build_public_metric_fields(
-            patch.indicator_field_ids,
-            app_key=app_key,
-            field_lookup=field_lookup,
-            qingbi_fields_by_id=qingbi_fields_by_id,
-            aggregate=aggregate,
-        ),
+        "selectedDimensions": selected_dimensions,
+        "selectedMetrics": selected_metrics,
         "beforeAggregationFilterMatrix": before_filters,
         "afterAggregationFilterMatrix": after_filters,
         "chartStyleConfigs": deepcopy(config.pop("chartStyleConfigs", [])),
@@ -12679,6 +12883,23 @@ def _build_public_chart_config_payload(
         "queryConditionStatus": bool(config.pop("queryConditionStatus", bool(query_condition_field_ids))),
         "queryConditionExact": bool(config.pop("queryConditionExact", False)),
     }
+    if backend_chart_type == "summary":
+        payload.pop("selectedDimensions", None)
+        payload.setdefault("xDimensions", deepcopy(selected_dimensions))
+        payload.setdefault("yDimensions", [])
+    elif backend_chart_type == "scatter":
+        x_metrics, y_metrics = _split_axis_metric_fields(selected_metrics)
+        payload.pop("selectedMetrics", None)
+        payload.setdefault("xMetrics", x_metrics)
+        payload.setdefault("yMetrics", y_metrics)
+    elif backend_chart_type == "dualaxes":
+        left_metrics, right_metrics = _split_axis_metric_fields(selected_metrics)
+        payload.pop("selectedMetrics", None)
+        payload.setdefault("leftMetrics", left_metrics)
+        payload.setdefault("rightMetrics", right_metrics)
+    elif backend_chart_type == "gauge":
+        payload["selectedDimensions"] = []
+        payload["selectedMetrics"] = _two_gauge_metric_fields(selected_metrics, requested_metric_count=len(patch.indicator_field_ids or []))
     for key in (
         "selectedTime",
         "xDimensions",
@@ -12701,6 +12922,46 @@ def _chart_patch_updates_chart_config(patch: ChartUpsertPatch) -> bool:
     return bool({"dimension_field_ids", "indicator_field_ids", "filters", "config"} & explicit_fields)
 
 
+def _chart_patch_dataset_source_type(patch: ChartUpsertPatch) -> str:
+    config = patch.config if isinstance(patch.config, dict) else {}
+    candidates = [
+        config.get("dataSourceType"),
+        config.get("data_source_type"),
+    ]
+    data_source = config.get("dataSource")
+    if isinstance(data_source, dict):
+        candidates.extend([data_source.get("dataSourceType"), data_source.get("data_source_type"), data_source.get("type")])
+    data_source = config.get("data_source")
+    if isinstance(data_source, dict):
+        candidates.extend([data_source.get("dataSourceType"), data_source.get("data_source_type"), data_source.get("type")])
+    for candidate in candidates:
+        normalized = str(candidate or "").strip().lower()
+        if not normalized:
+            continue
+        if normalized not in {"qingflow", "app"}:
+            return normalized
+    return ""
+
+
+def _chart_item_dataset_source_type(item: dict[str, Any]) -> str:
+    candidates = [
+        item.get("dataSourceType"),
+        item.get("data_source_type"),
+        item.get("sourceType"),
+        item.get("source_type"),
+    ]
+    data_source = item.get("dataSource")
+    if isinstance(data_source, dict):
+        candidates.extend([data_source.get("dataSourceType"), data_source.get("data_source_type"), data_source.get("type")])
+    for candidate in candidates:
+        normalized = str(candidate or "").strip().lower()
+        if not normalized:
+            continue
+        if normalized not in {"qingflow", "app", "bi_qingflow"}:
+            return normalized
+    return ""
+
+
 def _build_public_portal_base_payload(
     *,
     dash_name: str,
@@ -12771,16 +13032,33 @@ def _normalize_backend_chart_type(value: Any) -> str:
         "12": "dualaxes",
         "13": "map",
         "14": "timeline",
+        "15": "area",
+        "16": "stacked_column",
+        "17": "stacked_bar",
+        "18": "rose",
+        "19": "stacked_area",
+        "20": "pct_stack_col",
+        "21": "pct_stack_bar",
+        "22": "pct_stack_area",
+        "23": "waterfall",
+        "24": "gauge",
+        "25": "heatmap",
+        "26": "histogram",
+        "27": "treemap",
     }
-    return by_code.get(raw, raw.lower())
+    aliases = {
+        "percent_stacked_column": "pct_stack_col",
+        "percent_stacked_bar": "pct_stack_bar",
+        "percent_stacked_area": "pct_stack_area",
+    }
+    normalized = by_code.get(raw, raw.lower())
+    return aliases.get(normalized, normalized)
 
 
 def _public_chart_type_from_backend(value: Any) -> str:
     normalized = _normalize_backend_chart_type(value)
     return {
         "indicator": PublicChartType.target.value,
-        "summary": PublicChartType.target.value,
-        "columnar": PublicChartType.bar.value,
         "detail": PublicChartType.table.value,
     }.get(normalized, normalized)
 
@@ -14067,6 +14345,38 @@ def _parse_schema(schema: dict[str, Any]) -> dict[str, Any]:
     return parsed
 
 
+def _schema_field_identity(field: dict[str, Any] | None, *, fallback_name: str | None = None) -> dict[str, Any]:
+    field = field or {}
+    name = str(field.get("name") or fallback_name or "").strip() or None
+    field_id = str(field.get("field_id") or "").strip() or None
+    que_id = _coerce_positive_int(field.get("que_id") or field.get("queId"))
+    return {
+        "name": name,
+        "field_id": field_id,
+        "que_id": que_id,
+    }
+
+
+def _schema_field_diff_details(
+    *,
+    added: list[str],
+    updated: list[str],
+    removed: list[str],
+    before_fields: list[dict[str, Any]],
+    after_fields: list[dict[str, Any]],
+) -> dict[str, list[dict[str, Any]]]:
+    before_by_name = {str(field.get("name") or ""): field for field in before_fields if str(field.get("name") or "").strip()}
+    after_by_name = {str(field.get("name") or ""): field for field in after_fields if str(field.get("name") or "").strip()}
+    return {
+        "added": [_schema_field_identity(after_by_name.get(name), fallback_name=name) for name in added],
+        "updated": [
+            _schema_field_identity(after_by_name.get(name) or before_by_name.get(name), fallback_name=name)
+            for name in updated
+        ],
+        "removed": [_schema_field_identity(before_by_name.get(name), fallback_name=name) for name in removed],
+    }
+
+
 def _resolve_layout_sections_to_names(
     requested_sections: list[dict[str, Any]],
     fields: list[dict[str, Any]],
@@ -19234,7 +19544,7 @@ def _compare_view_button_summaries(
             expected_without_pending = [item for index, item in enumerate(expected) if index not in pending_indexes]
             if _sorted_view_button_compare_signatures(actual) == _sorted_view_button_compare_signatures(expected_without_pending):
                 return {
-                    "verified": True,
+                    "verified": False,
                     "custom_button_readback_pending": True,
                     "pending_custom_buttons": deepcopy(pending_custom_buttons),
                 }
@@ -19245,7 +19555,7 @@ def _compare_view_button_summaries(
         and _sorted_view_button_compare_signatures(actual_other) == _sorted_view_button_compare_signatures(expected_other)
     )
     return {
-        "verified": custom_button_readback_pending,
+        "verified": False,
         "custom_button_readback_pending": custom_button_readback_pending,
         "pending_custom_buttons": deepcopy(expected_custom) if custom_button_readback_pending else [],
     }
@@ -20129,7 +20439,7 @@ def _build_view_associated_resources_payload(
                     "missing_fields": [],
                     "received": raw_item_id,
                     "message": "associated_item_id must be an app-level associated resource id from app_get.associated_resources",
-                    "next_action": "call app_get and use associated_resources[].associated_item_id, not chart_id",
+                    "next_action": "prefer app_associated_resources_apply for associated report/view display; it can resolve associated_item_id, chart_id/chart_key, or view_key",
                 }
             ]
         item_ids.append(item_id)
@@ -20143,7 +20453,7 @@ def _build_view_associated_resources_payload(
                 "invalid_associated_item_ids": missing_ids,
                 "available_associated_item_ids": sorted(available_by_id),
                 "message": "associated_resource references ids that are not in the app-level associated resource pool",
-                "next_action": "call app_get and use associated_resources[].associated_item_id, not chart_id",
+                "next_action": "prefer app_associated_resources_apply for associated report/view display; it can resolve associated_item_id, chart_id/chart_key, or view_key",
             }
         ]
     payload = {
@@ -20561,6 +20871,77 @@ def _associated_resource_upsert_payload_from_existing_item(
     return _compact_dict(payload)
 
 
+def _resolve_associated_resource_selector(
+    selector: Any,
+    *,
+    existing_resources: list[dict[str, Any]],
+    existing_by_id: dict[int, dict[str, Any]],
+    reason_path: str,
+) -> tuple[int | None, dict[str, Any] | None]:
+    item_id = _coerce_positive_int(selector)
+    if item_id is not None:
+        if item_id in existing_by_id:
+            return item_id, None
+    raw = str(selector or "").strip()
+    if not raw:
+        return None, {
+            "error_code": "ASSOCIATED_RESOURCE_NOT_FOUND",
+            "reason_path": reason_path,
+            "received": selector,
+            "available_associated_item_ids": sorted(existing_by_id),
+            "message": "associated resource selector cannot be empty",
+        }
+    matches: list[dict[str, Any]] = []
+    for resource in existing_resources:
+        if not isinstance(resource, dict):
+            continue
+        candidates = [
+            resource.get("chart_id"),
+            resource.get("chart_key"),
+            resource.get("view_key"),
+            resource.get("associated_item_id"),
+        ]
+        if raw in {str(candidate).strip() for candidate in candidates if candidate not in {None, ""}}:
+            matches.append(resource)
+    if len(matches) == 1:
+        resolved_id = _coerce_positive_int(matches[0].get("associated_item_id"))
+        if resolved_id is not None:
+            return resolved_id, None
+    if len(matches) > 1:
+        return None, {
+            "error_code": "AMBIGUOUS_ASSOCIATED_RESOURCE",
+            "reason_path": reason_path,
+            "received": selector,
+            "candidate_associated_item_ids": [
+                item_id
+                for item_id in (_coerce_positive_int(item.get("associated_item_id")) for item in matches)
+                if item_id is not None
+            ],
+            "message": "selector matches multiple associated resources; pass associated_item_id",
+        }
+    return None, {
+        "error_code": "ASSOCIATED_RESOURCE_NOT_FOUND",
+        "reason_path": reason_path,
+        "received": selector,
+        "available_associated_item_ids": sorted(existing_by_id),
+        "available_chart_ids": sorted(
+            {
+                str(resource.get("chart_id") or resource.get("chart_key") or "").strip()
+                for resource in existing_resources
+                if str(resource.get("chart_id") or resource.get("chart_key") or "").strip()
+            }
+        ),
+        "available_view_keys": sorted(
+            {
+                str(resource.get("view_key") or "").strip()
+                for resource in existing_resources
+                if str(resource.get("view_key") or "").strip()
+            }
+        ),
+        "message": "selector must be an associated_item_id, QingBI chart_id/chart_key, or Qingflow view_key from the app-level associated resource pool",
+    }
+
+
 def _associated_resource_not_found_issue(reason_path: str, associated_item_id: int, existing_by_id: dict[int, dict[str, Any]]) -> dict[str, Any]:
     return {
         "error_code": "ASSOCIATED_RESOURCE_NOT_FOUND",
@@ -20568,7 +20949,7 @@ def _associated_resource_not_found_issue(reason_path: str, associated_item_id: i
         "associated_item_id": associated_item_id,
         "available_associated_item_ids": sorted(existing_by_id),
         "message": "associated_item_id is not in the app-level associated resource pool",
-        "next_action": "call app_get and use associated_resources[].associated_item_id; do not pass chart_id/chart_key",
+        "next_action": "call app_get and use associated_resources[].associated_item_id, chart_id/chart_key, or view_key",
     }