@josephyan/qingflow-app-user-mcp 1.1.21 → 1.1.23

package/src/qingflow_mcp/builder_facade/service.py

@@ -108,6 +108,7 @@ from .models import (
 
 BUILDER_PORTAL_LIST_DETAIL_VERIFY_LIMIT = 50
 CHART_APPLY_RECOMMENDED_UPSERT_BATCH_SIZE = 8
+CUSTOM_BUTTON_VIEW_CONFIG_READBACK_RETRY_SECONDS = 0.4
 
 
 QUESTION_TYPE_TO_FIELD_TYPE: dict[int, str] = {
@@ -293,6 +294,12 @@ class AiBuilderFacade:
     def _with_backend_context(self, profile: str, handler):
         return self.apps._run(profile, lambda _session_profile, context: handler(context))
 
+    def _read_app_base_raw_direct(self, *, profile: str, app_key: str) -> JSONObject:
+        return self._with_backend_context(
+            profile,
+            lambda context: self.apps.backend.request("GET", context, f"/app/{app_key}/baseInfo"),
+        )
+
     def flow_get_schema(self, *, profile: str, schema_version: str | None = None) -> JSONObject:
         normalized_args = {"schema_version": schema_version or workflow_spec_api.DEFAULT_SCHEMA_VERSION}
         try:
@@ -406,22 +413,50 @@ class AiBuilderFacade:
             "idempotency_key": idempotency_key,
             "schema_version": schema_version or workflow_spec_api.DEFAULT_SCHEMA_VERSION,
         }
+        apply_started_at = time.perf_counter()
+        permission_ms = 0
+        flow_spec_apply_ms = 0
+        flow_spec_verify_ms = 0
+        publish_ms = 0
         permission_outcomes: list[PermissionCheckOutcome] = []
+        def finalize(response: JSONObject) -> JSONObject:
+            return _apply_permission_outcomes(response, *permission_outcomes)
+
+        def attach_duration(response: JSONObject) -> JSONObject:
+            _merge_duration_breakdown(
+                response,
+                permission_ms=permission_ms,
+                flow_spec_apply_ms=flow_spec_apply_ms,
+                flow_spec_verify_ms=flow_spec_verify_ms,
+                publish_ms=publish_ms,
+                total_ms=_duration_ms(apply_started_at),
+            )
+            return response
+
+        def finish(response: JSONObject) -> JSONObject:
+            return finalize(attach_duration(response))
+
+        def finish_with_publish(response: JSONObject) -> JSONObject:
+            nonlocal publish_ms
+            publish_started_at = time.perf_counter()
+            published_response = self._append_publish_result(profile=profile, app_key=app_key, publish=publish, response=response)
+            publish_ms += _duration_ms(publish_started_at)
+            return finish(published_response)
+
+        permission_started_at = time.perf_counter()
         permission_outcome = self._guard_app_permission(
             profile=profile,
             app_key=app_key,
             required_permission="data_manage",
             normalized_args=normalized_args,
         )
+        permission_ms += _duration_ms(permission_started_at)
         if permission_outcome.block is not None:
-            return permission_outcome.block
+            return finish(permission_outcome.block)
         permission_outcomes.append(permission_outcome)
 
-        def finalize(response: JSONObject) -> JSONObject:
-            return _apply_permission_outcomes(response, *permission_outcomes)
-
         if not isinstance(spec, dict) or not spec:
-            return finalize(
+            return finish(
                 _failed(
                     "FLOW_SPEC_REQUIRED",
                     "spec must be a non-empty WorkflowSpecDTO object",
@@ -436,13 +471,15 @@ class AiBuilderFacade:
             "spec": spec,
         }
         try:
+            flow_spec_apply_started_at = time.perf_counter()
             apply_result = self._with_backend_context(
                 profile,
                 lambda context: workflow_spec_api.post_apply(self.apps.backend, context, apply_body=apply_body),
             )
         except (QingflowApiError, RuntimeError) as error:
+            flow_spec_apply_ms += _duration_ms(flow_spec_apply_started_at)
             api_error = _coerce_api_error(error)
-            return finalize(
+            return finish(
                 _failed_from_api_error(
                     "FLOW_SPEC_APPLY_FAILED",
                     api_error,
@@ -451,15 +488,18 @@ class AiBuilderFacade:
                     suggested_next_call={"tool_name": "app_flow_get", "arguments": {"profile": profile, "app_key": app_key}},
                 )
             )
+        flow_spec_apply_ms += _duration_ms(flow_spec_apply_started_at)
         if not isinstance(apply_result, dict):
             apply_result = {"result": apply_result}
+        flow_spec_verify_started_at = time.perf_counter()
         verification, verify_warnings, verified = workflow_spec_api.verify_apply_response(
             input_spec=spec,
             apply_result=apply_result,
         )
+        flow_spec_verify_ms += _duration_ms(flow_spec_verify_started_at)
         backend_status = str(apply_result.get("status") or "SUCCESS").upper()
         if backend_status not in {"SUCCESS", "OK"}:
-            return finalize(
+            return finish(
                 _failed(
                     "FLOW_SPEC_APPLY_FAILED",
                     str(apply_result.get("message") or "workflow spec apply failed"),
@@ -495,7 +535,7 @@ class AiBuilderFacade:
             "write_succeeded": True,
             "safe_to_retry": False,
         }
-        return finalize(self._append_publish_result(profile=profile, app_key=app_key, publish=publish, response=response))
+        return finish_with_publish(response)
 
     def package_resolve(self, *, profile: str, package_name: str) -> JSONObject:
         requested = str(package_name or "").strip()
@@ -796,7 +836,6 @@ class AiBuilderFacade:
         profile: str,
         package_id: int | None = None,
         package_name: str | None = None,
-        create_if_missing: bool = False,
         icon: str | None = None,
         color: str | None = None,
         visibility: VisibilityPatch | None = None,
@@ -807,7 +846,6 @@ class AiBuilderFacade:
         normalized_args: JSONObject = {
             "package_id": package_id,
             **({"package_name": requested_name} if requested_name else {}),
-            "create_if_missing": bool(create_if_missing),
             **({"icon": icon} if icon else {}),
             **({"color": color} if color else {}),
             **({"visibility": visibility.model_dump(mode="json")} if visibility is not None else {}),
@@ -819,39 +857,119 @@ class AiBuilderFacade:
         create_result: JSONObject | None = None
         update_result: JSONObject | None = None
         permission_outcomes: list[PermissionCheckOutcome] = []
+        duration_started_at = time.perf_counter()
+        duration_breakdown_ms: dict[str, int] = {
+            "package_create_ms": 0,
+            "package_update_ms": 0,
+            "package_items_ms": 0,
+            "package_readback_ms": 0,
+        }
+
+        def finish_duration(response: JSONObject) -> JSONObject:
+            duration = dict(duration_breakdown_ms)
+            duration["total_ms"] = int((time.perf_counter() - duration_started_at) * 1000)
+            existing_duration = response.get("duration_breakdown_ms")
+            if isinstance(existing_duration, dict):
+                duration.update({str(key): value for key, value in existing_duration.items()})
+                duration["total_ms"] = int((time.perf_counter() - duration_started_at) * 1000)
+            response["duration_breakdown_ms"] = duration
+            return response
 
         if effective_package_id is None:
-            if not create_if_missing:
-                return _failed(
-                    "PACKAGE_ID_REQUIRED",
-                    "package_id is required unless create_if_missing=true",
-                    normalized_args=normalized_args,
-                    suggested_next_call=None,
-                )
             if not requested_name:
                 return _failed(
                     "PACKAGE_NAME_REQUIRED",
-                    "package_name is required when create_if_missing=true",
+                    "package_name is required when creating a package without package_id",
                     normalized_args=normalized_args,
                     suggested_next_call=None,
                 )
-            create_result = self.package_create(
-                profile=profile,
-                package_name=requested_name,
-                icon=icon,
-                color=color,
-                visibility=visibility,
-            )
+            create_started_at = time.perf_counter()
+            try:
+                desired_tag_icon = encode_workspace_icon_with_defaults(
+                    icon=icon,
+                    color=color,
+                    title=requested_name,
+                    fallback_icon_name="files-folder",
+                )
+                desired_auth = self._compile_visibility_to_member_auth(profile=profile, visibility=visibility)
+                created_payload = self.packages.package_create(
+                    profile=profile,
+                    payload={"tagName": requested_name, "tagIcon": desired_tag_icon, "auth": desired_auth},
+                )
+            except VisibilityResolutionError as error:
+                duration_breakdown_ms["package_create_ms"] += int((time.perf_counter() - create_started_at) * 1000)
+                return finish_duration(
+                    _failed(
+                        error.error_code,
+                        error.message,
+                        normalized_args=normalized_args,
+                        details=error.details,
+                        suggested_next_call=None,
+                    )
+                )
+            except (QingflowApiError, RuntimeError) as error:
+                duration_breakdown_ms["package_create_ms"] += int((time.perf_counter() - create_started_at) * 1000)
+                api_error = _coerce_api_error(error)
+                return finish_duration(
+                    _failed_from_api_error(
+                        "PACKAGE_CREATE_FAILED",
+                        api_error,
+                        normalized_args=normalized_args,
+                        details={"package_name": requested_name},
+                        suggested_next_call={
+                            "tool_name": "package_apply",
+                            "arguments": {
+                                "profile": profile,
+                                "package_name": requested_name,
+                                **({"icon": icon} if icon else {}),
+                                **({"color": color} if color else {}),
+                            },
+                        },
+                    )
+                )
+            duration_breakdown_ms["package_create_ms"] += int((time.perf_counter() - create_started_at) * 1000)
+            result = created_payload.get("result") if isinstance(created_payload.get("result"), dict) else {}
+            tag_id = _coerce_positive_int(result.get("tagId"))
+            tag_name = str(result.get("tagName") or requested_name).strip() or requested_name
+            tag_icon = str(result.get("tagIcon") or desired_tag_icon or "").strip() or None
+            verified = tag_id is not None
+            create_result = {
+                "status": "success" if verified else "partial_success",
+                "error_code": None if verified else "PACKAGE_CREATE_UNVERIFIED",
+                "recoverable": not verified,
+                "message": "created package" if verified else "created package but could not verify package_id",
+                "normalized_args": normalized_args,
+                "missing_fields": [],
+                "allowed_values": {},
+                "details": {"direct_submit": True},
+                "request_id": created_payload.get("request_id") if isinstance(created_payload, dict) else None,
+                "suggested_next_call": None
+                if verified
+                else {"tool_name": "package_get", "arguments": {"profile": profile, "package_id": tag_id}},
+                "noop": False,
+                "warnings": [],
+                "verification": {"tag_id_verified": verified, "direct_submit": True},
+                "verified": verified,
+                "tag_id": tag_id,
+                "tag_name": tag_name,
+                "tag_icon": tag_icon,
+                "visibility": _public_visibility_from_member_auth(desired_auth),
+                "write_executed": True,
+                "write_succeeded": True,
+                "safe_to_retry": False,
+            }
             if create_result.get("status") not in {"success", "partial_success"}:
-                return _publicize_package_apply_failure(create_result, profile=profile, normalized_args=normalized_args)
+                return finish_duration(_publicize_package_apply_failure(create_result, profile=profile, normalized_args=normalized_args))
             effective_package_id = _coerce_positive_int(create_result.get("tag_id") or create_result.get("package_id"))
             if effective_package_id is None:
-                return _failed(
-                    "PACKAGE_CREATE_UNVERIFIED",
-                    "created package but could not verify package_id",
-                    normalized_args=normalized_args,
-                    details={"create_result": create_result},
-                    suggested_next_call={"tool_name": "package_get", "arguments": {"profile": profile, "package_id": package_id}},
+                return finish_duration(
+                    _failed(
+                        "PACKAGE_CREATE_UNVERIFIED",
+                        "created package but could not verify package_id",
+                        normalized_args=normalized_args,
+                        details={"create_result": create_result},
+                        suggested_next_call={"tool_name": "package_get", "arguments": {"profile": profile, "package_id": package_id}},
+                    )
                 )
             normalized_args["package_id"] = effective_package_id
             created = True
@@ -867,6 +985,7 @@ class AiBuilderFacade:
             if edit_tag_outcome.block is not None:
                 return edit_tag_outcome.block
             permission_outcomes.append(edit_tag_outcome)
+            update_started_at = time.perf_counter()
             update_result = self.package_update(
                 profile=profile,
                 tag_id=effective_package_id,
@@ -875,18 +994,22 @@ class AiBuilderFacade:
                 color=color,
                 visibility=visibility,
             )
+            duration_breakdown_ms["package_update_ms"] += int((time.perf_counter() - update_started_at) * 1000)
             if update_result.get("status") not in {"success", "partial_success"}:
-                return _publicize_package_apply_failure(update_result, profile=profile, normalized_args=normalized_args)
+                return finish_duration(_publicize_package_apply_failure(update_result, profile=profile, normalized_args=normalized_args))
 
         layout_result: JSONObject | None = None
         if items is not None:
             if not isinstance(items, list):
-                return _failed(
-                    "PACKAGE_ITEMS_INVALID",
-                    "items must be a list",
-                    normalized_args=normalized_args,
-                    suggested_next_call=None,
+                return finish_duration(
+                    _failed(
+                        "PACKAGE_ITEMS_INVALID",
+                        "items must be a list",
+                        normalized_args=normalized_args,
+                        suggested_next_call=None,
+                    )
                 )
+            items_started_at = time.perf_counter()
             layout_result = self._apply_package_items(
                 profile=profile,
                 package_id=effective_package_id,
@@ -894,6 +1017,7 @@ class AiBuilderFacade:
                 allow_detach=allow_detach,
                 normalized_args=normalized_args,
             )
+            duration_breakdown_ms["package_items_ms"] += int((time.perf_counter() - items_started_at) * 1000)
             if layout_result.get("status") not in {"success", "partial_success"}:
                 prior_package_write_executed = bool(
                     created
@@ -930,8 +1054,8 @@ class AiBuilderFacade:
                     )
                     partial["package_id"] = effective_package_id
                     partial["layout_failed"] = True
-                    return _apply_permission_outcomes(partial, *permission_outcomes)
-                return _apply_permission_outcomes(layout_result, *permission_outcomes)
+                    return finish_duration(_apply_permission_outcomes(partial, *permission_outcomes))
+                return finish_duration(_apply_permission_outcomes(layout_result, *permission_outcomes))
 
         write_executed = bool(
             created
@@ -948,10 +1072,120 @@ class AiBuilderFacade:
                 and not bool(layout_result.get("noop"))
             )
         )
+        if items is None and (created or (metadata_requested and isinstance(update_result, dict))):
+            metadata_result = create_result if created else update_result
+            metadata_verified = bool(metadata_result.get("verified")) if isinstance(metadata_result, dict) else False
+            metadata_verification = metadata_result.get("verification") if isinstance(metadata_result, dict) and isinstance(metadata_result.get("verification"), dict) else {}
+            response_verification: JSONObject = {
+                "package_exists": True,
+                "package_created": created,
+                "layout_applied": False,
+                "metadata_verified": metadata_verified,
+                **deepcopy(metadata_verification),
+            }
+            response: JSONObject = {
+                "status": "success" if metadata_verified else "partial_success",
+                "error_code": None if metadata_verified else (metadata_result.get("error_code") if isinstance(metadata_result, dict) else "PACKAGE_READBACK_PENDING"),
+                "recoverable": not metadata_verified,
+                "message": "applied package" if metadata_verified else "applied package with unverified readback",
+                "normalized_args": normalized_args,
+                "missing_fields": [],
+                "allowed_values": {},
+                "details": {
+                    "metadata_result": metadata_result,
+                    "final_readback_skipped": True,
+                    "skip_reason": "metadata_result_already_verified" if metadata_verified else "metadata_result_is_partial",
+                },
+                "request_id": metadata_result.get("request_id") if isinstance(metadata_result, dict) else None,
+                "suggested_next_call": None
+                if metadata_verified
+                else {"tool_name": "package_get", "arguments": {"profile": profile, "package_id": effective_package_id}},
+                "noop": False,
+                "warnings": deepcopy(metadata_result.get("warnings") or []) if isinstance(metadata_result, dict) and isinstance(metadata_result.get("warnings"), list) else [],
+                "verification": response_verification,
+                "verified": metadata_verified,
+                "write_executed": write_executed,
+                "write_succeeded": write_executed,
+                "safe_to_retry": not write_executed,
+            }
+            if isinstance(metadata_result, dict):
+                response.update(
+                    {
+                        key: deepcopy(value)
+                        for key, value in metadata_result.items()
+                        if key
+                        not in {
+                            "status",
+                            "error_code",
+                            "recoverable",
+                            "message",
+                            "normalized_args",
+                            "missing_fields",
+                            "allowed_values",
+                            "details",
+                            "request_id",
+                            "suggested_next_call",
+                            "noop",
+                            "warnings",
+                            "verification",
+                            "verified",
+                            "write_executed",
+                            "write_succeeded",
+                            "safe_to_retry",
+                        }
+                    }
+                )
+            return finish_duration(_apply_permission_outcomes(response, *permission_outcomes))
+
+        layout_readback_skippable = (
+            items is not None
+            and not created
+            and not metadata_requested
+            and isinstance(layout_result, dict)
+            and bool(layout_result.get("verified"))
+            and isinstance(layout_result.get("details"), dict)
+            and bool(layout_result["details"].get("current_read_skipped"))
+        )
+        if layout_readback_skippable:
+            response: JSONObject = {
+                "status": "success",
+                "error_code": None,
+                "recoverable": False,
+                "message": "applied package",
+                "normalized_args": normalized_args,
+                "missing_fields": [],
+                "allowed_values": {},
+                "details": {
+                    "layout_result": layout_result,
+                    "final_readback_skipped": True,
+                    "skip_reason": "layout_result_already_verified",
+                },
+                "request_id": layout_result.get("request_id") if isinstance(layout_result.get("request_id"), str) else None,
+                "suggested_next_call": None,
+                "noop": False,
+                "warnings": deepcopy(layout_result.get("warnings") or []) if isinstance(layout_result.get("warnings"), list) else [],
+                "verification": {
+                    "package_exists": True,
+                    "package_created": False,
+                    "layout_applied": True,
+                    "layout_verified": True,
+                    "metadata_verified": True,
+                    "final_readback_skipped": True,
+                },
+                "verified": True,
+                "package_id": effective_package_id,
+                "write_executed": write_executed,
+                "write_succeeded": write_executed,
+                "safe_to_retry": not write_executed,
+            }
+            return finish_duration(_apply_permission_outcomes(response, *permission_outcomes))
+
+        readback_started_at = time.perf_counter()
         verification = self.package_get(profile=profile, package_id=effective_package_id)
+        duration_breakdown_ms["package_readback_ms"] += int((time.perf_counter() - readback_started_at) * 1000)
         if verification.get("status") != "success":
             if write_executed:
-                return _apply_permission_outcomes(
+                return finish_duration(_apply_permission_outcomes(
                     _post_write_readback_pending_result(
                         error_code="PACKAGE_READBACK_PENDING",
                         message="applied package; final package readback is unavailable",
@@ -960,8 +1194,8 @@ class AiBuilderFacade:
                         suggested_next_call={"tool_name": "package_get", "arguments": {"profile": profile, "package_id": effective_package_id}},
                     ),
                     *permission_outcomes,
-                )
-            return _apply_permission_outcomes(verification, *permission_outcomes)
+                ))
+            return finish_duration(_apply_permission_outcomes(verification, *permission_outcomes))
         expected_visibility = None
         if visibility is not None:
             try:
@@ -1052,7 +1286,7 @@ class AiBuilderFacade:
                 }
             },
         }
-        return _apply_permission_outcomes(response, *permission_outcomes)
+        return finish_duration(_apply_permission_outcomes(response, *permission_outcomes))
 
     def package_update(
         self,
@@ -1313,6 +1547,72 @@ class AiBuilderFacade:
         allow_detach: bool,
         normalized_args: JSONObject,
     ) -> JSONObject:
+        duplicate_resources = _find_duplicate_package_resources(items)
+        if duplicate_resources:
+            return _failed(
+                "PACKAGE_LAYOUT_DUPLICATE_ITEM",
+                "items contains duplicate apps or portals",
+                normalized_args=normalized_args,
+                details={"duplicates": [{"type": item[0], "id": item[1]} for item in duplicate_resources]},
+                suggested_next_call=None,
+            )
+
+        desired_groups = _collect_public_package_group_specs(items)
+        if allow_detach and not desired_groups:
+            permission_outcome = self._guard_package_permission(
+                profile=profile,
+                tag_id=package_id,
+                required_permission="edit_app",
+                normalized_args=normalized_args,
+            )
+            if permission_outcome.block is not None:
+                return permission_outcome.block
+            try:
+                backend_items = _backend_package_items_from_public_items(items, {})
+            except ValueError as error:
+                return _failed(
+                    "PACKAGE_LAYOUT_INVALID",
+                    str(error),
+                    normalized_args=normalized_args,
+                    details={"package_id": package_id},
+                    suggested_next_call=None,
+                )
+            try:
+                sort_result = self.packages.package_sort_items(profile=profile, tag_id=package_id, tag_items=backend_items)
+            except (QingflowApiError, RuntimeError) as error:
+                api_error = _coerce_api_error(error)
+                return _failed_from_api_error(
+                    "PACKAGE_LAYOUT_SORT_FAILED",
+                    api_error,
+                    normalized_args=normalized_args,
+                    details={"package_id": package_id, "current_read_skipped": True},
+                    suggested_next_call=None,
+                )
+            return _apply_permission_outcomes(
+                {
+                    "status": "success",
+                    "error_code": None,
+                    "recoverable": False,
+                    "message": "applied package items",
+                    "normalized_args": normalized_args,
+                    "missing_fields": [],
+                    "allowed_values": {},
+                    "details": {
+                        "group_operations": [],
+                        "sort_result": sort_result,
+                        "current_read_skipped": True,
+                    },
+                    "request_id": sort_result.get("request_id") if isinstance(sort_result, dict) else None,
+                    "suggested_next_call": None,
+                    "noop": False,
+                    "warnings": [],
+                    "verification": {"layout_applied": True, "current_read_skipped": True},
+                    "verified": True,
+                    "package_id": package_id,
+                },
+                permission_outcome,
+            )
+
         current_detail_result: JSONObject | None = None
         current_base_result: JSONObject | None = None
         detail_api_error: QingflowApiError | None = None
@@ -1388,16 +1688,6 @@ class AiBuilderFacade:
                 suggested_next_call=None,
             )
 
-        duplicate_resources = _find_duplicate_package_resources(normalized_items)
-        if duplicate_resources:
-            return _failed(
-                "PACKAGE_LAYOUT_DUPLICATE_ITEM",
-                "items contains duplicate apps or portals",
-                normalized_args=normalized_args,
-                details={"duplicates": [{"type": item[0], "id": item[1]} for item in duplicate_resources]},
-                suggested_next_call=None,
-            )
-
         current_groups = {int(spec["group_id"]): str(spec["name"] or "").strip() for spec in current_group_specs}
         desired_groups = _collect_public_package_group_specs(normalized_items)
         desired_group_ids = {
@@ -3158,47 +3448,107 @@ class AiBuilderFacade:
     def app_custom_buttons_apply(self, *, profile: str, request: CustomButtonsApplyRequest) -> JSONObject:
         normalized_args = request.model_dump(mode="json", exclude_none=True, exclude_defaults=True)
         app_key = request.app_key
+        apply_started_at = time.perf_counter()
+        permission_ms = 0
+        button_inventory_ms = 0
+        app_name_read_ms = 0
+        button_patch_hydration_ms = 0
+        add_data_compile_ms = 0
+        edit_context_ms = 0
+        button_write_ms = 0
+        button_readback_ms = 0
+        view_config_ms = 0
+        publish_ms = 0
         permission_outcomes: list[PermissionCheckOutcome] = []
         button_write_intent = bool(request.upsert_buttons or request.patch_buttons or request.remove_buttons)
         if button_write_intent:
+            permission_started_at = time.perf_counter()
             permission_outcome = self._guard_app_permission(
                 profile=profile,
                 app_key=app_key,
                 required_permission="edit_app",
                 normalized_args=normalized_args,
             )
+            permission_ms += _duration_ms(permission_started_at)
             if permission_outcome.block is not None:
+                _merge_duration_breakdown(
+                    permission_outcome.block,
+                    permission_ms=permission_ms,
+                    total_ms=_duration_ms(apply_started_at),
+                )
                 return permission_outcome.block
             permission_outcomes.append(permission_outcome)
         if request.view_configs:
+            permission_started_at = time.perf_counter()
             permission_outcome = self._guard_app_permission(
                 profile=profile,
                 app_key=app_key,
                 required_permission="view_manage",
                 normalized_args=normalized_args,
             )
+            permission_ms += _duration_ms(permission_started_at)
             if permission_outcome.block is not None:
+                _merge_duration_breakdown(
+                    permission_outcome.block,
+                    permission_ms=permission_ms,
+                    total_ms=_duration_ms(apply_started_at),
+                )
                 return permission_outcome.block
             permission_outcomes.append(permission_outcome)
 
         def finalize(response: JSONObject) -> JSONObject:
-            return _apply_permission_outcomes(response, *permission_outcomes)
+            response = _apply_permission_outcomes(response, *permission_outcomes)
+            _merge_duration_breakdown(
+                response,
+                permission_ms=permission_ms,
+                button_inventory_ms=button_inventory_ms,
+                app_name_read_ms=app_name_read_ms,
+                button_patch_hydration_ms=button_patch_hydration_ms,
+                add_data_compile_ms=add_data_compile_ms,
+                edit_context_ms=edit_context_ms,
+                button_write_ms=button_write_ms,
+                button_readback_ms=button_readback_ms,
+                view_config_ms=view_config_ms,
+                publish_ms=publish_ms,
+                total_ms=_duration_ms(apply_started_at),
+            )
+            return response
 
+        same_call_client_keys = {
+            str(patch.client_key or "").strip()
+            for patch in request.upsert_buttons
+            if str(patch.client_key or "").strip()
+        }
+        all_upserts_are_named_creates = bool(request.upsert_buttons) and all(
+            str(patch.client_key or "").strip()
+            and _coerce_positive_int(patch.button_id) is None
+            for patch in request.upsert_buttons
+        )
         view_config_refs = [
             binding.button_ref
             for config in request.view_configs
             for binding in config.buttons
         ]
-        needs_button_inventory = button_write_intent or any(
-            _coerce_positive_int(ref) is None for ref in view_config_refs
+        view_refs_need_inventory = any(
+            _coerce_positive_int(ref) is None and str(ref or "").strip() not in same_call_client_keys
+            for ref in view_config_refs
+        )
+        needs_button_inventory = (
+            bool(request.patch_buttons)
+            or bool(request.remove_buttons)
+            or any(_coerce_positive_int(patch.button_id) is not None for patch in request.upsert_buttons)
+            or (bool(request.upsert_buttons) and not all_upserts_are_named_creates)
+            or view_refs_need_inventory
         )
         try:
+            button_inventory_started_at = time.perf_counter()
             existing_buttons = (
                 self._load_custom_buttons_for_builder(profile=profile, app_key=app_key)
                 if needs_button_inventory
                 else []
             )
         except (QingflowApiError, RuntimeError) as error:
+            button_inventory_ms += _duration_ms(button_inventory_started_at)
             api_error = _coerce_api_error(error)
             return finalize(_failed_from_api_error(
                 "CUSTOM_BUTTON_LIST_FAILED",
@@ -3207,7 +3557,10 @@ 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}},
             ))
+        button_inventory_ms += _duration_ms(button_inventory_started_at)
+        app_name_started_at = time.perf_counter()
         app_name = self._read_app_name_for_builder_output(profile=profile, app_key=app_key)
+        app_name_read_ms += _duration_ms(app_name_started_at)
 
         existing_by_id = {
             button_id: item
@@ -3222,6 +3575,7 @@ class AiBuilderFacade:
 
         upsert_buttons = list(request.upsert_buttons)
         if request.patch_buttons:
+            button_patch_started_at = time.perf_counter()
             expanded_buttons, patch_issues, patch_results = self._expand_custom_button_partial_patches(
                 profile=profile,
                 app_key=app_key,
@@ -3229,6 +3583,7 @@ class AiBuilderFacade:
                 existing_by_text=existing_by_text,
                 patch_buttons=request.patch_buttons,
             )
+            button_patch_hydration_ms += _duration_ms(button_patch_started_at)
             if patch_issues:
                 return finalize(
                     _failed(
@@ -3246,11 +3601,13 @@ class AiBuilderFacade:
             ]
             normalized_args["patch_results"] = patch_results
 
+        add_data_compile_started_at = time.perf_counter()
         compiled_add_data_configs, add_data_issues = self._compile_custom_button_semantic_add_data_configs(
             profile=profile,
             app_key=app_key,
             patches=upsert_buttons,
         )
+        add_data_compile_ms += _duration_ms(add_data_compile_started_at)
         upsert_ops: list[dict[str, Any]] = []
         remove_ops: list[dict[str, Any]] = []
         blocking_issues: list[dict[str, Any]] = []
@@ -3433,12 +3790,14 @@ class AiBuilderFacade:
 
         edit_version_no = None
         if button_write_intent:
+            edit_context_started_at = time.perf_counter()
             edit_version_no, edit_context_error = self._ensure_app_edit_context(
                 profile=profile,
                 app_key=app_key,
                 normalized_args=normalized_args,
                 failure_code="CUSTOM_BUTTON_APPLY_FAILED",
             )
+            edit_context_ms += _duration_ms(edit_context_started_at)
             if edit_context_error is not None:
                 return finalize(edit_context_error)
 
@@ -3450,6 +3809,7 @@ class AiBuilderFacade:
         client_key_map: dict[str, int] = {}
         write_executed = False
 
+        button_write_started_at = time.perf_counter()
         for op in upsert_ops:
             patch = cast(CustomButtonUpsertPatch, op["patch"])
             patch_payload = _serialize_custom_button_payload(patch, add_data_config_override=compiled_add_data_configs.get(int(op["index"])))
@@ -3460,7 +3820,9 @@ class AiBuilderFacade:
                     button_id = _extract_custom_button_id(result.get("result"))
                     if button_id is None:
                         try:
+                            button_readback_started_at = time.perf_counter()
                             readback_buttons = self._load_custom_buttons_for_builder(profile=profile, app_key=app_key)
+                            button_readback_ms += _duration_ms(button_readback_started_at)
                             matches = [
                                 item
                                 for item in readback_buttons
@@ -3470,6 +3832,7 @@ class AiBuilderFacade:
                             if len(matches) == 1:
                                 button_id = _coerce_positive_int(matches[0].get("button_id"))
                         except (QingflowApiError, RuntimeError) as error:
+                            button_readback_ms += _duration_ms(button_readback_started_at)
                             readback_errors.append(
                                 {
                                     "resource": "custom_buttons",
@@ -3525,7 +3888,9 @@ class AiBuilderFacade:
             try:
                 write_executed = True
                 self.buttons.custom_button_delete(profile=profile, app_key=app_key, button_id=button_id)
+                button_readback_started_at = time.perf_counter()
                 delete_readback = self._verify_custom_button_deleted_by_id(profile=profile, app_key=app_key, button_id=button_id)
+                button_readback_ms += _duration_ms(button_readback_started_at)
                 removed.append(
                     {
                         "index": op["index"],
@@ -3565,13 +3930,41 @@ class AiBuilderFacade:
                     }
                 )
 
-        needs_button_list_readback = bool(created or updated or (request.view_configs and needs_button_inventory))
+        button_write_ms += _duration_ms(button_write_started_at)
+        created_ids = [
+            int(item["button_id"])
+            for item in created
+            if _coerce_positive_int(item.get("button_id")) is not None
+        ]
+        updated_ids = [
+            int(item["button_id"])
+            for item in updated
+            if _coerce_positive_int(item.get("button_id")) is not None
+        ]
+        removed_ids = [
+            int(item["button_id"])
+            for item in removed
+            if _coerce_positive_int(item.get("button_id")) is not None
+        ]
+        same_call_view_binding_verifies_buttons = bool(request.view_configs) and not needs_button_inventory
+        final_readback_skipped = (
+            bool(created or updated)
+            and (not request.view_configs or same_call_view_binding_verifies_buttons)
+            and not removed
+            and not failed
+            and not readback_errors
+            and all(_coerce_positive_int(item.get("button_id")) is not None for item in [*created, *updated])
+        )
+        needs_button_list_readback = bool(created or updated or (request.view_configs and needs_button_inventory)) and not final_readback_skipped
         readback_buttons: list[dict[str, Any]] = []
         readback_failed = False
         if needs_button_list_readback:
             try:
+                button_readback_started_at = time.perf_counter()
                 readback_buttons = self._load_custom_buttons_for_builder(profile=profile, app_key=app_key)
+                button_readback_ms += _duration_ms(button_readback_started_at)
             except (QingflowApiError, RuntimeError) as error:
+                button_readback_ms += _duration_ms(button_readback_started_at)
                 readback_errors.append(
                     {
                         "resource": "custom_buttons",
@@ -3585,26 +3978,14 @@ class AiBuilderFacade:
             for item in readback_buttons
             if (button_id := _coerce_positive_int(item.get("button_id"))) is not None
         }
-        created_ids = [
-            int(item["button_id"])
-            for item in created
-            if _coerce_positive_int(item.get("button_id")) is not None
-        ]
-        updated_ids = [
-            int(item["button_id"])
-            for item in updated
-            if _coerce_positive_int(item.get("button_id")) is not None
-        ]
-        removed_ids = [
-            int(item["button_id"])
-            for item in removed
-            if _coerce_positive_int(item.get("button_id")) is not None
-        ]
         removed_verified = all(str(item.get("readback_status") or "") == "deleted" for item in removed)
         remove_readback_pending = any(str(item.get("readback_status") or "") != "deleted" for item in removed)
+        created_verified = final_readback_skipped or (not readback_failed and all(button_id in readback_ids for button_id in created_ids))
+        updated_verified = final_readback_skipped or (not readback_failed and all(button_id in readback_ids for button_id in updated_ids))
         verified = (
-            not readback_failed
-            and all(button_id in readback_ids for button_id in created_ids + updated_ids)
+            (final_readback_skipped or not readback_failed)
+            and created_verified
+            and updated_verified
             and removed_verified
             and not failed
             and all(_coerce_positive_int(item.get("button_id")) is not None for item in created)
@@ -3616,7 +3997,9 @@ class AiBuilderFacade:
         view_config_verified = True
         view_config_write_executed = False
         view_config_write_succeeded = False
+        created_verified_by_view_binding = False
         if request.view_configs:
+            view_config_started_at = time.perf_counter()
             view_config_result = self._apply_custom_button_view_configs(
                 profile=profile,
                 app_key=app_key,
@@ -3628,6 +4011,7 @@ class AiBuilderFacade:
                 updated_ids=updated_ids,
                 removed_ids=removed_ids,
             )
+            view_config_ms += _duration_ms(view_config_started_at)
             view_config_results = list(view_config_result.get("view_configs") or [])
             view_config_failed = list(view_config_result.get("failed") or [])
             view_config_warnings = list(view_config_result.get("warnings") or [])
@@ -3640,6 +4024,38 @@ class AiBuilderFacade:
             if view_config_warnings:
                 if not isinstance(view_config_warnings, list):
                     view_config_warnings = []
+            if not created_verified and created_ids and view_config_verified:
+                bound_custom_button_ids = {
+                    button_id
+                    for view_config in view_config_results
+                    if isinstance(view_config, dict)
+                    for button in (view_config.get("actual_buttons") or [])
+                    if isinstance(button, dict)
+                    and str(button.get("button_type") or "").strip().upper() == "CUSTOM"
+                    and (button_id := _coerce_positive_int(button.get("button_id"))) is not None
+                }
+                expected_custom_button_ids = {
+                    button_id
+                    for view_config in view_config_results
+                    if isinstance(view_config, dict) and bool(view_config.get("verified_by_write_ack"))
+                    for button in (view_config.get("expected_buttons") or [])
+                    if isinstance(button, dict)
+                    and str(button.get("button_type") or "").strip().upper() == "CUSTOM"
+                    and (button_id := _coerce_positive_int(button.get("button_id"))) is not None
+                }
+                created_verified_by_view_binding = all(
+                    button_id in bound_custom_button_ids or button_id in expected_custom_button_ids
+                    for button_id in created_ids
+                )
+                if created_verified_by_view_binding:
+                    created_verified = True
+                    custom_buttons_verified = (
+                        (final_readback_skipped or not readback_failed)
+                        and updated_verified
+                        and removed_verified
+                        and not failed
+                        and all(_coerce_positive_int(item.get("button_id")) is not None for item in created)
+                    )
         verified = custom_buttons_verified and view_config_verified
         write_succeeded = bool(created or updated or removed or view_config_write_succeeded)
         status = "success" if verified else ("partial_success" if write_succeeded else "failed")
@@ -3693,6 +4109,10 @@ class AiBuilderFacade:
                 "edit_version_no": edit_version_no,
                 "button_ids_by_client_key": client_key_map,
                 "readback_failed": readback_failed,
+                "initial_inventory_read_skipped": not needs_button_inventory,
+                "final_readback_skipped": final_readback_skipped,
+                "same_call_view_binding_verifies_buttons": same_call_view_binding_verifies_buttons,
+                "created_verified_by_view_binding": created_verified_by_view_binding,
                 **({"readback_errors": readback_errors} if readback_errors else {}),
                 "compiled_match_rules": {
                     str(index): _summarize_compiled_match_rules(config.get("que_relation") or [])
@@ -3705,9 +4125,10 @@ class AiBuilderFacade:
             "warnings": warnings,
             "verification": {
                 "custom_buttons_verified": custom_buttons_verified,
-                "readback_loaded": not readback_failed,
-                "created_verified": not readback_failed and all(button_id in readback_ids for button_id in created_ids),
-                "updated_verified": not readback_failed and all(button_id in readback_ids for button_id in updated_ids),
+                "readback_loaded": False if final_readback_skipped else not readback_failed,
+                "final_readback_skipped": final_readback_skipped,
+                "created_verified": created_verified,
+                "updated_verified": updated_verified,
                 "removed_verified": removed_verified,
                 "remove_readback_pending": remove_readback_pending,
                 "removed_readback_results": deepcopy(removed),
@@ -3727,14 +4148,17 @@ class AiBuilderFacade:
             "write_succeeded": write_succeeded,
             "safe_to_retry": not write_executed,
         }
+        publish_started_at = time.perf_counter()
+        published_response = self._append_publish_result(
+            profile=profile,
+            app_key=app_key,
+            publish=bool(write_succeeded and button_write_intent),
+            response=response,
+            edit_version_no=edit_version_no,
+        )
+        publish_ms += _duration_ms(publish_started_at)
         return finalize(
-            self._append_publish_result(
-                profile=profile,
-                app_key=app_key,
-                publish=bool(write_succeeded and button_write_intent),
-                response=response,
-                edit_version_no=edit_version_no,
-            )
+            published_response
         )
 
     def app_custom_button_list(self, *, profile: str, app_key: str) -> JSONObject:
@@ -4360,6 +4784,18 @@ class AiBuilderFacade:
     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
+        apply_started_at = time.perf_counter()
+        permission_ms = 0
+        resource_inventory_ms = 0
+        app_name_read_ms = 0
+        resource_patch_hydration_ms = 0
+        match_mapping_compile_ms = 0
+        edit_context_ms = 0
+        resource_write_ms = 0
+        resource_readback_ms = 0
+        view_config_ms = 0
+        publish_ms = 0
+        post_publish_verify_ms = 0
         permission_outcomes: list[PermissionCheckOutcome] = []
         resource_write_intent = bool(
             request.upsert_resources
@@ -4368,32 +4804,97 @@ class AiBuilderFacade:
             or request.reorder_associated_item_ids
         )
         if resource_write_intent:
+            permission_started_at = time.perf_counter()
             permission_outcome = self._guard_app_permission(
                 profile=profile,
                 app_key=app_key,
                 required_permission="edit_app",
                 normalized_args=normalized_args,
             )
+            permission_ms += _duration_ms(permission_started_at)
             if permission_outcome.block is not None:
+                _merge_duration_breakdown(
+                    permission_outcome.block,
+                    permission_ms=permission_ms,
+                    total_ms=_duration_ms(apply_started_at),
+                )
                 return permission_outcome.block
             permission_outcomes.append(permission_outcome)
         if request.view_configs:
+            permission_started_at = time.perf_counter()
             permission_outcome = self._guard_app_permission(
                 profile=profile,
                 app_key=app_key,
                 required_permission="view_manage",
                 normalized_args=normalized_args,
             )
+            permission_ms += _duration_ms(permission_started_at)
             if permission_outcome.block is not None:
+                _merge_duration_breakdown(
+                    permission_outcome.block,
+                    permission_ms=permission_ms,
+                    total_ms=_duration_ms(apply_started_at),
+                )
                 return permission_outcome.block
             permission_outcomes.append(permission_outcome)
 
         def finalize(response: JSONObject) -> JSONObject:
-            return _apply_permission_outcomes(response, *permission_outcomes)
+            response = _apply_permission_outcomes(response, *permission_outcomes)
+            _merge_duration_breakdown(
+                response,
+                permission_ms=permission_ms,
+                resource_inventory_ms=resource_inventory_ms,
+                app_name_read_ms=app_name_read_ms,
+                resource_patch_hydration_ms=resource_patch_hydration_ms,
+                match_mapping_compile_ms=match_mapping_compile_ms,
+                edit_context_ms=edit_context_ms,
+                resource_write_ms=resource_write_ms,
+                resource_readback_ms=resource_readback_ms,
+                view_config_ms=view_config_ms,
+                publish_ms=publish_ms,
+                post_publish_verify_ms=post_publish_verify_ms,
+                total_ms=_duration_ms(apply_started_at),
+            )
+            return response
 
+        same_call_resource_client_keys = {
+            str(patch.client_key or "").strip()
+            for patch in request.upsert_resources
+            if str(patch.client_key or "").strip()
+        }
+        all_resource_upserts_are_named_creates = bool(request.upsert_resources) and all(
+            str(patch.client_key or "").strip()
+            and _coerce_positive_int(patch.associated_item_id) is None
+            for patch in request.upsert_resources
+        )
+        view_config_refs_need_inventory = any(
+            str(ref or "").strip() not in same_call_resource_client_keys
+            for config in request.view_configs
+            for ref in config.associated_item_refs
+            if str(ref or "").strip()
+        )
+        view_config_ids_need_inventory = any(
+            bool(config.associated_item_ids)
+            for config in request.view_configs
+        )
+        needs_resource_inventory = (
+            bool(request.patch_resources)
+            or bool(request.remove_associated_item_ids)
+            or bool(request.reorder_associated_item_ids)
+            or any(_coerce_positive_int(patch.associated_item_id) is not None for patch in request.upsert_resources)
+            or (bool(request.upsert_resources) and not all_resource_upserts_are_named_creates)
+            or view_config_refs_need_inventory
+            or view_config_ids_need_inventory
+        )
         try:
-            existing_resources = self._load_associated_resources_for_builder(profile=profile, app_key=app_key, include_raw=True)
+            resource_inventory_started_at = time.perf_counter()
+            existing_resources = (
+                self._load_associated_resources_for_builder(profile=profile, app_key=app_key, include_raw=True)
+                if needs_resource_inventory
+                else []
+            )
         except (QingflowApiError, RuntimeError) as error:
+            resource_inventory_ms += _duration_ms(resource_inventory_started_at)
             api_error = _coerce_api_error(error)
             return finalize(_failed_from_api_error(
                 "ASSOCIATED_RESOURCES_READ_FAILED",
@@ -4402,7 +4903,10 @@ 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}},
             ))
+        resource_inventory_ms += _duration_ms(resource_inventory_started_at)
+        app_name_started_at = time.perf_counter()
         app_name = self._read_app_name_for_builder_output(profile=profile, app_key=app_key)
+        app_name_read_ms += _duration_ms(app_name_started_at)
 
         existing_by_id = _associated_resource_index(existing_resources)
         blocking_issues: list[dict[str, Any]] = []
@@ -4415,10 +4919,12 @@ class AiBuilderFacade:
 
         upsert_resources = list(request.upsert_resources)
         if request.patch_resources:
+            resource_patch_started_at = time.perf_counter()
             expanded_resources, patch_issues, patch_results = self._expand_associated_resource_partial_patches(
                 existing_by_id=existing_by_id,
                 patch_resources=request.patch_resources,
             )
+            resource_patch_hydration_ms += _duration_ms(resource_patch_started_at)
             if patch_issues:
                 return finalize(
                     _failed(
@@ -4433,11 +4939,13 @@ class AiBuilderFacade:
             normalized_args["upsert_resources"] = [patch.model_dump(mode="json") for patch in upsert_resources]
             normalized_args["patch_results"] = patch_results
 
+        match_mapping_compile_started_at = time.perf_counter()
         compiled_resource_match_rules, resource_match_issues = self._compile_associated_resource_semantic_match_mappings(
             profile=profile,
             app_key=app_key,
             patches=upsert_resources,
         )
+        match_mapping_compile_ms += _duration_ms(match_mapping_compile_started_at)
         normalized_args["compiled_match_rules"] = {
             str(index): _summarize_compiled_match_rules(rules)
             for index, rules in compiled_resource_match_rules.items()
@@ -4651,12 +5159,14 @@ class AiBuilderFacade:
 
         edit_version_no = None
         if resource_write_intent:
+            edit_context_started_at = time.perf_counter()
             edit_version_no, edit_context_error = self._ensure_app_edit_context(
                 profile=profile,
                 app_key=app_key,
                 normalized_args=normalized_args,
                 failure_code="ASSOCIATED_RESOURCES_APPLY_FAILED",
             )
+            edit_context_ms += _duration_ms(edit_context_started_at)
             if edit_context_error is not None:
                 return finalize(edit_context_error)
 
@@ -4671,6 +5181,7 @@ class AiBuilderFacade:
         verification_errors: list[JSONObject] = []
         write_executed = False
 
+        resource_write_started_at = time.perf_counter()
         for op in upsert_ops:
             patch = cast(AssociatedResourceUpsertPatch, op["patch"])
             try:
@@ -4688,26 +5199,30 @@ class AiBuilderFacade:
                         match_rules_override=compiled_resource_match_rules.get(int(op["index"])),
                     )
                     created_id = _extract_associated_resource_id_from_result(create_result)
-                    try:
-                        readback_resources = self._load_associated_resources_for_builder(profile=profile, app_key=app_key)
-                        matches = [
-                            item
-                            for item in readback_resources
-                            if _associated_resource_matches_patch(item, patch)
-                            and _coerce_positive_int(item.get("associated_item_id")) is not None
-                        ]
-                        readback_id = _coerce_positive_int(matches[0].get("associated_item_id")) if len(matches) == 1 else None
-                        if readback_id is not None:
-                            created_id = readback_id
-                    except (QingflowApiError, RuntimeError) as error:
-                        readback_errors.append(
-                            {
-                                "resource": "associated_resources",
-                                "phase": "create_id_lookup",
-                                "index": op["index"],
-                                "transport_error": _transport_error_payload(_coerce_api_error(error)),
-                            }
-                        )
+                    if created_id is None:
+                        try:
+                            resource_readback_started_at = time.perf_counter()
+                            readback_resources = self._load_associated_resources_for_builder(profile=profile, app_key=app_key)
+                            resource_readback_ms += _duration_ms(resource_readback_started_at)
+                            matches = [
+                                item
+                                for item in readback_resources
+                                if _associated_resource_matches_patch(item, patch)
+                                and _coerce_positive_int(item.get("associated_item_id")) is not None
+                            ]
+                            readback_id = _coerce_positive_int(matches[0].get("associated_item_id")) if len(matches) == 1 else None
+                            if readback_id is not None:
+                                created_id = readback_id
+                        except (QingflowApiError, RuntimeError) as error:
+                            resource_readback_ms += _duration_ms(resource_readback_started_at)
+                            readback_errors.append(
+                                {
+                                    "resource": "associated_resources",
+                                    "phase": "create_id_lookup",
+                                    "index": op["index"],
+                                    "transport_error": _transport_error_payload(_coerce_api_error(error)),
+                                }
+                            )
                     created.append(_associated_resource_result_entry("create", op["index"], patch, associated_item_id=created_id))
                     if created_id is not None and patch.client_key:
                         client_key_to_id[str(patch.client_key)] = created_id
@@ -4765,15 +5280,19 @@ class AiBuilderFacade:
             except (QingflowApiError, RuntimeError) as error:
                 api_error = _coerce_api_error(error)
                 failed.append({"operation": "reorder", "associated_item_ids": reorder_ids, "status": "failed", "error_code": "ASSOCIATED_RESOURCE_REORDER_FAILED", "message": api_error.message, "transport_error": _transport_error_payload(api_error)})
+        resource_write_ms += _duration_ms(resource_write_started_at)
 
         resources_after: list[dict[str, Any]] = []
         resources_after_loaded = False
         resources_after_readback_failed = False
         if request.view_configs:
             try:
+                resource_readback_started_at = time.perf_counter()
                 resources_after = self._load_associated_resources_for_builder(profile=profile, app_key=app_key)
+                resource_readback_ms += _duration_ms(resource_readback_started_at)
                 resources_after_loaded = True
             except (QingflowApiError, RuntimeError) as error:
+                resource_readback_ms += _duration_ms(resource_readback_started_at)
                 readback_errors.append({"resource": "associated_resources", "phase": "pre_view_config", "transport_error": _transport_error_payload(_coerce_api_error(error))})
                 resources_after = []
                 resources_after_readback_failed = True
@@ -4819,6 +5338,7 @@ class AiBuilderFacade:
                 failed.append({"operation": "view_config", "index": index, "view_key": view_config.view_key, "view_name": view_name, "status": "failed", "issues": issues})
                 continue
             try:
+                view_config_started_at = time.perf_counter()
                 write_executed = True
                 self._update_view_associated_resources_config(profile=profile, view_key=view_config.view_key, associated_resources_payload=view_payload)
                 try:
@@ -4848,16 +5368,35 @@ class AiBuilderFacade:
                     actual_config = {}
                     verified_config = False
                 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})
+                view_config_ms += _duration_ms(view_config_started_at)
             except (QingflowApiError, RuntimeError) as error:
+                view_config_ms += _duration_ms(view_config_started_at)
                 api_error = _coerce_api_error(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)})
 
+        created_ids = [int(item["associated_item_id"]) for item in created if _coerce_positive_int(item.get("associated_item_id")) is not None]
+        updated_ids = [int(item["associated_item_id"]) for item in updated if _coerce_positive_int(item.get("associated_item_id")) is not None]
+        unchanged_ids = [int(item["associated_item_id"]) for item in unchanged if _coerce_positive_int(item.get("associated_item_id")) is not None]
+        final_readback_skipped = (
+            bool(created or updated)
+            and not request.view_configs
+            and not removed
+            and not reordered
+            and not failed
+            and not readback_errors
+            and all(_coerce_positive_int(item.get("associated_item_id")) is not None for item in [*created, *updated])
+        )
         final_resources: list[dict[str, Any]] = resources_after if resources_after_loaded else []
         readback_failed = resources_after_readback_failed
-        if not resources_after_loaded and not resources_after_readback_failed:
+        if final_readback_skipped:
+            final_resources = []
+        elif not resources_after_loaded and not resources_after_readback_failed:
             try:
+                resource_readback_started_at = time.perf_counter()
                 final_resources = self._load_associated_resources_for_builder(profile=profile, app_key=app_key)
+                resource_readback_ms += _duration_ms(resource_readback_started_at)
             except (QingflowApiError, RuntimeError) as error:
+                resource_readback_ms += _duration_ms(resource_readback_started_at)
                 readback_errors.append({"resource": "associated_resources", "phase": "final_pool", "transport_error": _transport_error_payload(_coerce_api_error(error))})
                 readback_failed = True
         final_by_id = _associated_resource_index(final_resources)
@@ -4867,15 +5406,16 @@ class AiBuilderFacade:
                 resources=final_resources,
                 readback_failed=readback_failed,
             )
-        created_ids = [int(item["associated_item_id"]) for item in created if _coerce_positive_int(item.get("associated_item_id")) is not None]
-        updated_ids = [int(item["associated_item_id"]) for item in updated if _coerce_positive_int(item.get("associated_item_id")) is not None]
-        unchanged_ids = [int(item["associated_item_id"]) for item in unchanged if _coerce_positive_int(item.get("associated_item_id")) is not None]
         removed_ids = [int(item["associated_item_id"]) for item in removed if _coerce_positive_int(item.get("associated_item_id")) is not None]
         removed_verified = all(str(item.get("readback_status") or "") == "deleted" for item in removed)
         remove_readback_pending = any(str(item.get("readback_status") or "") != "deleted" for item in removed)
-        pool_verified = (
+        pool_items_verified = final_readback_skipped or (
             not readback_failed
             and all(item_id in final_by_id for item_id in created_ids + updated_ids + unchanged_ids)
+        )
+        pool_verified = (
+            (final_readback_skipped or not readback_failed)
+            and pool_items_verified
             and removed_verified
             and not failed
             and all(_coerce_positive_int(item.get("associated_item_id")) is not None for item in created)
@@ -4944,6 +5484,8 @@ class AiBuilderFacade:
                 "edit_version_no": edit_version_no,
                 "associated_item_ids_by_client_key": client_key_to_id,
                 "readback_failed": readback_failed,
+                "initial_inventory_read_skipped": not needs_resource_inventory,
+                "final_readback_skipped": final_readback_skipped,
                 **({"readback_errors": readback_errors} if readback_errors else {}),
                 **({"verification_errors": verification_errors} if verification_errors else {}),
                 "compiled_match_rules": {
@@ -4959,7 +5501,8 @@ class AiBuilderFacade:
             "verification": {
                 "associated_resources_verified": pool_verified,
                 "associated_resource_view_configs_verified": view_configs_verified,
-                "readback_loaded": not readback_failed,
+                "readback_loaded": False if final_readback_skipped else not readback_failed,
+                "final_readback_skipped": final_readback_skipped,
                 "removed_verified": removed_verified,
                 "remove_readback_pending": remove_readback_pending,
                 "removed_readback_results": deepcopy(removed),
@@ -4981,6 +5524,7 @@ class AiBuilderFacade:
             "safe_to_retry": not write_executed,
             "associated_resources": final_resources,
         }
+        publish_started_at = time.perf_counter()
         response = self._append_publish_result(
             profile=profile,
             app_key=app_key,
@@ -4988,7 +5532,9 @@ class AiBuilderFacade:
             response=response,
             edit_version_no=edit_version_no,
         )
+        publish_ms += _duration_ms(publish_started_at)
         if response.get("published") and view_config_results:
+            post_publish_started_at = time.perf_counter()
             try:
                 post_publish_resources = self._load_associated_resources_for_builder(profile=profile, app_key=app_key)
             except (QingflowApiError, RuntimeError) as error:
@@ -5097,6 +5643,7 @@ class AiBuilderFacade:
                 response["recoverable"] = False
                 response["message"] = "applied associated resources patch"
                 response["suggested_next_call"] = None
+            post_publish_verify_ms += _duration_ms(post_publish_started_at)
         return finalize(response)
 
     def _resolve_app_matches_in_visible_apps(
@@ -6153,32 +6700,52 @@ class AiBuilderFacade:
         idempotency_key: str | None = None,
         schema_version: str | None = None,
     ) -> JSONObject:
+        patch_started_at = time.perf_counter()
+        flow_patch_read_ms = 0
+        flow_patch_compile_ms = 0
+        flow_patch_apply_ms = 0
+
+        def attach_patch_duration(response: JSONObject) -> JSONObject:
+            _merge_duration_breakdown(
+                response,
+                flow_patch_read_ms=flow_patch_read_ms,
+                flow_patch_compile_ms=flow_patch_compile_ms,
+                flow_patch_apply_ms=flow_patch_apply_ms,
+                total_ms=_duration_ms(patch_started_at),
+            )
+            return response
+
         try:
+            flow_patch_read_started_at = time.perf_counter()
             current = self.flow_get(profile=profile, app_key=app_key)
         except (QingflowApiError, RuntimeError) as error:
+            flow_patch_read_ms += _duration_ms(flow_patch_read_started_at)
             api_error = _coerce_api_error(error)
-            return _failed_from_api_error(
+            return attach_patch_duration(_failed_from_api_error(
                 "FLOW_READ_FAILED",
                 api_error,
                 normalized_args={"app_key": app_key},
                 details={"app_key": app_key},
                 suggested_next_call={"tool_name": "app_flow_get", "arguments": {"profile": profile, "app_key": app_key}},
-            )
+            ))
+        flow_patch_read_ms += _duration_ms(flow_patch_read_started_at)
         if str(current.get("status") or "").strip().lower() != "success":
-            return _failed(
+            return attach_patch_duration(_failed(
                 "FLOW_READ_FAILED",
                 current.get("message") or "failed to read current flow",
                 normalized_args={"app_key": app_key},
                 suggested_next_call={"tool_name": "app_flow_get", "arguments": {"profile": profile, "app_key": app_key}},
-            )
+            ))
+        flow_patch_compile_started_at = time.perf_counter()
         spec = deepcopy(current.get("spec") or {})
         if not isinstance(spec, dict) or not spec:
-            return _failed(
+            flow_patch_compile_ms += _duration_ms(flow_patch_compile_started_at)
+            return attach_patch_duration(_failed(
                 "FLOW_PATCH_FAILED",
                 "current flow has no spec; use full app_flow_apply with spec first",
                 normalized_args={"app_key": app_key, "patch_nodes": patch_nodes},
                 suggested_next_call={"tool_name": "app_flow_apply", "arguments": {"profile": profile, "app_key": app_key}},
-            )
+            ))
         nodes = spec.get("nodes") if isinstance(spec.get("nodes"), list) else []
         node_by_id: dict[str, dict[str, Any]] = {}
         for node in nodes:
@@ -6205,30 +6772,35 @@ class AiBuilderFacade:
             for key in unset_payload:
                 target.pop(str(key), None)
         if invalid_items:
-            return _failed(
+            flow_patch_compile_ms += _duration_ms(flow_patch_compile_started_at)
+            return attach_patch_duration(_failed(
                 "FLOW_PATCH_INVALID",
                 "patch_nodes[] contains invalid items",
                 normalized_args={"app_key": app_key, "invalid_items": invalid_items},
                 suggested_next_call={"tool_name": "app_flow_get", "arguments": {"profile": profile, "app_key": app_key}},
-            )
+            ))
         if not_found:
-            return _failed(
+            flow_patch_compile_ms += _duration_ms(flow_patch_compile_started_at)
+            return attach_patch_duration(_failed(
                 "FLOW_NODE_NOT_FOUND",
                 f"patch_nodes[] referenced node id(s) not found in current flow: {not_found}",
                 normalized_args={"app_key": app_key, "not_found_ids": not_found},
                 suggested_next_call={"tool_name": "app_flow_get", "arguments": {"profile": profile, "app_key": app_key}},
-            )
+            ))
         edge_container = spec.get("edges") if isinstance(spec.get("edges"), dict) else {}
         edges = edge_container.get("edges") if isinstance(edge_container, dict) else None
         transitions = spec.get("transitions") if isinstance(spec.get("transitions"), list) else None
         if not edges and not transitions:
-            return _failed(
+            flow_patch_compile_ms += _duration_ms(flow_patch_compile_started_at)
+            return attach_patch_duration(_failed(
                 "FLOW_PATCH_EMPTY_GRAPH_UNSUPPORTED",
                 "current flow spec has no edges; patch_nodes cannot safely save this backend shape",
                 normalized_args={"app_key": app_key, "patch_nodes": patch_nodes},
                 suggested_next_call={"tool_name": "app_flow_apply", "arguments": {"profile": profile, "app_key": app_key}},
-            )
-        return self.flow_apply(
+            ))
+        flow_patch_compile_ms += _duration_ms(flow_patch_compile_started_at)
+        flow_patch_apply_started_at = time.perf_counter()
+        result = self.flow_apply(
             profile=profile,
             app_key=app_key,
             spec=spec,
@@ -6236,6 +6808,8 @@ class AiBuilderFacade:
             idempotency_key=idempotency_key,
             schema_version=schema_version,
         )
+        flow_patch_apply_ms += _duration_ms(flow_patch_apply_started_at)
+        return attach_patch_duration(result)
 
     def _components_to_sections_payload(self, components: list[dict[str, Any]]) -> list[dict[str, Any]]:
         result: list[dict[str, Any]] = []
@@ -7474,19 +8048,35 @@ class AiBuilderFacade:
                     all_verified = False
                     continue
             try:
-                verify_response = self.views.view_get_config(profile=profile, viewgraph_key=view_key)
-                verify_config = verify_response.get("result") if isinstance(verify_response.get("result"), dict) else {}
                 expected_summary = _normalize_expected_view_buttons_for_compare(
                     effective_merged_dtos,
                     custom_button_details_by_id=button_inventory,
                 )
-                actual_summary = _normalize_view_buttons_for_compare(verify_config)
-                comparison = _compare_view_button_summaries(
-                    expected=expected_summary,
-                    actual=actual_summary,
-                    pending_custom_button_ids=set(created_ids),
+                actual_summary: list[dict[str, Any]] = []
+                comparison: dict[str, Any] = {"verified": False, "custom_button_readback_pending": False}
+                readback_retry_count = 0
+                while True:
+                    verify_response = self.views.view_get_config(profile=profile, viewgraph_key=view_key)
+                    verify_config = verify_response.get("result") if isinstance(verify_response.get("result"), dict) else {}
+                    actual_summary = _normalize_view_buttons_for_compare(verify_config)
+                    comparison = _compare_view_button_summaries(
+                        expected=expected_summary,
+                        actual=actual_summary,
+                        pending_custom_button_ids=set(created_ids),
+                    )
+                    if not comparison.get("custom_button_readback_pending") or readback_retry_count >= 1:
+                        break
+                    readback_retry_count += 1
+                    time.sleep(CUSTOM_BUTTON_VIEW_CONFIG_READBACK_RETRY_SECONDS)
+                pending_custom_button_readback = bool(comparison.get("custom_button_readback_pending"))
+                accepted_with_delayed_custom_button_readback = (
+                    pending_custom_button_readback
+                    and write_succeeded
+                    and unsupported_list_issue is None
                 )
-                verified = bool(comparison.get("verified")) and unsupported_list_issue is None
+                verified = (
+                    bool(comparison.get("verified")) or accepted_with_delayed_custom_button_readback
+                ) and unsupported_list_issue is None
                 if not verified:
                     all_verified = False
                 results.append(
@@ -7501,12 +8091,14 @@ class AiBuilderFacade:
                         "view_buttons_verified": verified,
                         "supported_buttons_verified": bool(comparison.get("verified")) if unsupported_list_issue is not None else None,
                         "unsupported_placements": ["list"] if unsupported_list_issue is not None else [],
-                        "custom_button_readback_pending": bool(comparison.get("custom_button_readback_pending")),
+                        "custom_button_readback_pending": pending_custom_button_readback,
+                        "verified_by_write_ack": accepted_with_delayed_custom_button_readback,
+                        "readback_retry_count": readback_retry_count,
                         "expected_buttons": expected_summary,
                         "actual_buttons": actual_summary,
                     }
                 )
-                if comparison.get("custom_button_readback_pending"):
+                if pending_custom_button_readback and not accepted_with_delayed_custom_button_readback:
                     warnings.append(_warning("VIEW_CUSTOM_BUTTON_READBACK_PENDING", "view config write landed but custom button readback is delayed"))
             except (QingflowApiError, RuntimeError) as error:
                 api_error = _coerce_api_error(error)
@@ -7959,7 +8551,6 @@ class AiBuilderFacade:
             app_key=request.app_key,
             app_name=request.app_name,
             package_tag_id=request.package_tag_id,
-            create_if_missing=request.create_if_missing,
         )
         if target.get("status") == "failed":
             target.setdefault("normalized_args", normalized_args)
@@ -8231,7 +8822,6 @@ class AiBuilderFacade:
                     "arguments": {
                         "profile": profile,
                         "app_key": request.app_key,
-                        "create_if_missing": False,
                         "add_fields": [{"name": "状态", "type": "select", "options": ["草稿", "进行中", "已完成"], "required": True}],
                         "update_fields": [],
                         "remove_fields": [],
@@ -8581,7 +9171,6 @@ class AiBuilderFacade:
         icon: str | None = None,
         color: str | None = None,
         visibility: VisibilityPatch | None = None,
-        create_if_missing: bool = False,
         publish: bool = True,
         add_fields: list[FieldPatch],
         update_fields: list[FieldUpdatePatch],
@@ -8604,7 +9193,6 @@ class AiBuilderFacade:
             "icon": icon,
             "color": color,
             "visibility": visibility.model_dump(mode="json") if visibility is not None else None,
-            "create_if_missing": create_if_missing,
             "publish": publish,
             "add_fields": [patch.model_dump(mode="json") for patch in add_fields],
             "update_fields": [patch.model_dump(mode="json") for patch in update_fields],
@@ -8629,25 +9217,30 @@ class AiBuilderFacade:
         permission_outcomes: list[PermissionCheckOutcome] = []
         requested_inline_layout = bool(requested_inline_layout_sections)
         requested_field_changes = bool(add_fields or update_fields or remove_fields or requested_inline_layout)
-        resolved: JSONObject
-        if app_key:
-            resolved = self.app_resolve(profile=profile, app_key=app_key)
-        elif app_name:
-            resolved = self.app_resolve(profile=profile, app_name=app_name, package_tag_id=package_tag_id)
-        else:
-            return _failed("APP_NAME_REQUIRED", "app_name or app_key is required", normalized_args=normalized_args, suggested_next_call=None)
 
         def finalize(response: JSONObject) -> JSONObject:
             return _apply_permission_outcomes(response, *permission_outcomes)
 
-        if resolved.get("status") == "failed":
-            if not isinstance(resolved.get("normalized_args"), dict) or not resolved.get("normalized_args"):
-                resolved["normalized_args"] = normalized_args
-            if not create_if_missing or app_key or resolved.get("error_code") != "APP_NOT_FOUND":
-                return finalize(resolved)
+        resolved: JSONObject
+        if app_key:
+            resolved = self.app_resolve(profile=profile, app_key=app_key)
+        else:
+            requested_app_name_for_create = str(app_name or "").strip()
             permission_tag_id = _coerce_positive_int(package_tag_id)
+            if not requested_app_name_for_create:
+                return _failed(
+                    "APP_NAME_REQUIRED",
+                    "app_name is required when creating an app without app_key",
+                    normalized_args=normalized_args,
+                    suggested_next_call=None,
+                )
             if permission_tag_id is None:
-                permission_tag_id = 0
+                return _failed(
+                    "PACKAGE_ID_REQUIRED",
+                    "package_id is required when creating an app without app_key",
+                    normalized_args=normalized_args,
+                    suggested_next_call=None,
+                )
             add_permission_outcome = self._guard_package_permission(
                 profile=profile,
                 tag_id=permission_tag_id,
@@ -8659,8 +9252,8 @@ class AiBuilderFacade:
             permission_outcomes.append(add_permission_outcome)
             resolved = self._create_target_app_shell(
                 profile=profile,
-                app_name=app_name,
-                package_tag_id=package_tag_id,
+                app_name=requested_app_name_for_create,
+                package_tag_id=permission_tag_id,
                 icon=icon,
                 color=color,
                 auth=desired_auth,
@@ -8673,6 +9266,11 @@ class AiBuilderFacade:
                 if not isinstance(resolved.get("normalized_args"), dict) or not resolved.get("normalized_args"):
                     resolved["normalized_args"] = normalized_args
                 return finalize(resolved)
+
+        if resolved.get("status") == "failed":
+            if not isinstance(resolved.get("normalized_args"), dict) or not resolved.get("normalized_args"):
+                resolved["normalized_args"] = normalized_args
+            return finalize(resolved)
         resolved_outcome = _permission_outcome_from_result(resolved)
         if resolved_outcome is not None:
             permission_outcomes.append(resolved_outcome)
@@ -9611,71 +10209,113 @@ class AiBuilderFacade:
             "sections": requested_sections,
             "publish": publish,
         }
+        apply_started_at = time.perf_counter()
+        permission_ms = 0
+        schema_read_ms = 0
+        layout_compile_ms = 0
+        edit_version_ms = 0
+        layout_write_ms = 0
+        layout_readback_ms = 0
+        publish_ms = 0
         permission_outcomes: list[PermissionCheckOutcome] = []
+        def finalize(response: JSONObject) -> JSONObject:
+            return _apply_permission_outcomes(response, *permission_outcomes)
+
+        def attach_duration(response: JSONObject) -> JSONObject:
+            _merge_duration_breakdown(
+                response,
+                permission_ms=permission_ms,
+                schema_read_ms=schema_read_ms,
+                layout_compile_ms=layout_compile_ms,
+                edit_version_ms=edit_version_ms,
+                layout_write_ms=layout_write_ms,
+                layout_readback_ms=layout_readback_ms,
+                publish_ms=publish_ms,
+                total_ms=_duration_ms(apply_started_at),
+            )
+            return response
+
+        def finish(response: JSONObject) -> JSONObject:
+            return finalize(attach_duration(response))
+
+        def finish_with_publish(response: JSONObject) -> JSONObject:
+            nonlocal publish_ms
+            publish_started_at = time.perf_counter()
+            published_response = self._append_publish_result(profile=profile, app_key=app_key, publish=publish, response=response)
+            publish_ms += _duration_ms(publish_started_at)
+            return finish(published_response)
+
+        permission_started_at = time.perf_counter()
         permission_outcome = self._guard_app_permission(
             profile=profile,
             app_key=app_key,
             required_permission="edit_app",
             normalized_args=normalized_args,
         )
+        permission_ms += _duration_ms(permission_started_at)
         if permission_outcome.block is not None:
-            return permission_outcome.block
+            return finish(permission_outcome.block)
         permission_outcomes.append(permission_outcome)
 
-        def finalize(response: JSONObject) -> JSONObject:
-            return _apply_permission_outcomes(response, *permission_outcomes)
-
         try:
+            schema_read_started_at = time.perf_counter()
             schema_result, _schema_source = self._read_schema_with_fallback(profile=profile, app_key=app_key)
         except (QingflowApiError, RuntimeError) as error:
+            schema_read_ms += _duration_ms(schema_read_started_at)
             api_error = _coerce_api_error(error)
-            return finalize(_failed_from_api_error(
+            return finish(_failed_from_api_error(
                 "LAYOUT_READ_FAILED",
                 api_error,
                 normalized_args=normalized_args,
                 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}},
             ))
+        schema_read_ms += _duration_ms(schema_read_started_at)
+        layout_compile_started_at = time.perf_counter()
         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)
         normalized_args["sections"] = requested_sections
         if missing_selectors:
-            return _failed(
+            layout_compile_ms += _duration_ms(layout_compile_started_at)
+            return finish(_failed(
                 "UNKNOWN_LAYOUT_FIELD",
                 "layout references unknown field selectors",
                 normalized_args=normalized_args,
                 details={"unknown_selectors": missing_selectors},
                 missing_fields=[str(item) for item in missing_selectors],
                 suggested_next_call={"tool_name": "app_get_fields", "arguments": {"profile": profile, "app_key": app_key}},
-            )
+            ))
         fields_by_name = {field["name"]: field for field in current_fields}
         seen: list[str] = []
         for section in requested_sections:
             for row in section.get("rows", []):
                 for field_name in row:
                     if field_name not in fields_by_name:
-                        return _failed(
+                        layout_compile_ms += _duration_ms(layout_compile_started_at)
+                        return finish(_failed(
                             "UNKNOWN_LAYOUT_FIELD",
                             f"layout references unknown field '{field_name}'",
                             normalized_args=normalized_args,
                             details={"field_name": field_name},
                             suggested_next_call={"tool_name": "app_get_layout", "arguments": {"profile": profile, "app_key": app_key}},
-                        )
+                        ))
                     if field_name in seen:
-                        return _failed(
+                        layout_compile_ms += _duration_ms(layout_compile_started_at)
+                        return finish(_failed(
                             "DUPLICATE_LAYOUT_FIELD",
                             f"layout references field '{field_name}' more than once",
                             normalized_args=normalized_args,
                             details={"field_name": field_name},
                             suggested_next_call={"tool_name": "app_layout_apply", "arguments": {"profile": profile, **normalized_args}},
-                        )
+                        ))
                     seen.append(field_name)
         expected = {field["name"] for field in current_fields}
         if mode == LayoutApplyMode.replace and set(seen) != expected:
             missing = sorted(expected.difference(seen))
-            return _failed(
+            layout_compile_ms += _duration_ms(layout_compile_started_at)
+            return finish(_failed(
                 "INCOMPLETE_LAYOUT",
                 "layout must reference every current field exactly once in replace mode",
                 normalized_args=normalized_args,
@@ -9692,7 +10332,7 @@ class AiBuilderFacade:
                     "tool_name": "app_layout_apply",
                     "arguments": {"profile": profile, "app_key": app_key, "mode": "merge", "sections": requested_sections},
                 },
-            )
+            ))
         merged = _merge_layout(
             current_layout=parsed["layout"],
             requested_sections=requested_sections,
@@ -9704,6 +10344,7 @@ class AiBuilderFacade:
             else merged["layout"]
         )
         if _layouts_equal(parsed["layout"], target_layout):
+            layout_compile_ms += _duration_ms(layout_compile_started_at)
             response = {
                 "status": "success",
                 "error_code": None,
@@ -9732,21 +10373,26 @@ class AiBuilderFacade:
                 "write_succeeded": False,
                 "safe_to_retry": True,
             }
-            return finalize(self._append_publish_result(profile=profile, app_key=app_key, publish=publish, response=response))
+            return finish_with_publish(response)
         payload = _build_form_payload_from_existing_schema(
             current_schema=schema_result,
             layout=target_layout,
         )
+        layout_compile_ms += _duration_ms(layout_compile_started_at)
+        edit_version_started_at = time.perf_counter()
         payload["editVersionNo"] = self._resolve_form_edit_version(
             profile=profile,
             app_key=app_key,
             current_schema=schema_result,
         )
+        edit_version_ms += _duration_ms(edit_version_started_at)
         applied_layout = target_layout
         fallback_applied = None
         try:
+            layout_write_started_at = time.perf_counter()
             self.apps.app_update_form_schema(profile=profile, app_key=app_key, payload=payload)
         except (QingflowApiError, RuntimeError) as error:
+            layout_write_ms += _duration_ms(layout_write_started_at)
             api_error = _coerce_api_error(error)
             if backend_code_int(api_error) == 400 and target_layout.get("sections"):
                 flattened_layout = _flatten_layout_sections(target_layout)
@@ -9760,12 +10406,15 @@ class AiBuilderFacade:
                     current_schema=schema_result,
                 )
                 try:
+                    fallback_write_started_at = time.perf_counter()
                     self.apps.app_update_form_schema(profile=profile, app_key=app_key, payload=fallback_payload)
+                    layout_write_ms += _duration_ms(fallback_write_started_at)
                     applied_layout = flattened_layout
                     fallback_applied = "flatten_sections"
                 except (QingflowApiError, RuntimeError) as fallback_error:
+                    layout_write_ms += _duration_ms(fallback_write_started_at)
                     api_fallback_error = _coerce_api_error(fallback_error)
-                    return finalize(_failed_from_api_error(
+                    return finish(_failed_from_api_error(
                         "LAYOUT_APPLY_FAILED",
                         api_fallback_error,
                         normalized_args=normalized_args,
@@ -9780,7 +10429,7 @@ class AiBuilderFacade:
                         suggested_next_call={"tool_name": "app_layout_apply", "arguments": {"profile": profile, **normalized_args}},
                     ))
             else:
-                return finalize(_failed_from_api_error(
+                return finish(_failed_from_api_error(
                     "LAYOUT_APPLY_FAILED",
                     api_error,
                     normalized_args=normalized_args,
@@ -9792,9 +10441,13 @@ class AiBuilderFacade:
                     },
                     suggested_next_call={"tool_name": "app_layout_apply", "arguments": {"profile": profile, **normalized_args}},
                 ))
+        else:
+            layout_write_ms += _duration_ms(layout_write_started_at)
         try:
+            layout_readback_started_at = time.perf_counter()
             verified_schema, _verified_schema_source = self._read_schema_with_fallback(profile=profile, app_key=app_key)
         except (QingflowApiError, RuntimeError) as error:
+            layout_readback_ms += _duration_ms(layout_readback_started_at)
             api_error = _coerce_api_error(error)
             response = {
                 "status": "partial_success",
@@ -9834,7 +10487,8 @@ class AiBuilderFacade:
                 "write_succeeded": True,
                 "safe_to_retry": False,
             }
-            return finalize(self._append_publish_result(profile=profile, app_key=app_key, publish=publish, response=response))
+            return finish_with_publish(response)
+        layout_readback_ms += _duration_ms(layout_readback_started_at)
         verified_layout = _parse_schema(verified_schema)["layout"]
         layout_verified = _layouts_equal(verified_layout, applied_layout) or _layouts_semantically_equal(verified_layout, applied_layout)
         raw_layout_has_content = _schema_has_layout_content(verified_schema)
@@ -9848,24 +10502,21 @@ class AiBuilderFacade:
             warnings.append(_warning("LAYOUT_SUMMARY_UNVERIFIED", "layout summary is incomplete relative to raw schema readback"))
         if fallback_applied is not None and layout_verified and layout_summary_verified:
             warnings.append(_warning("LAYOUT_FALLBACK_APPLIED", "layout readback normalized sectioned layout into flat layout while preserving field placement"))
+        result_verified = layout_verified
         response = {
-            "status": "success" if layout_verified and layout_summary_verified else "partial_success",
+            "status": "success" if result_verified else "partial_success",
             "error_code": (
                 None
-                if layout_verified and layout_summary_verified
-                else "LAYOUT_SUMMARY_UNVERIFIED"
-                if not layout_summary_verified
+                if result_verified
                 else "LAYOUT_READBACK_MISMATCH"
             ),
-            "recoverable": not (layout_verified and layout_summary_verified),
+            "recoverable": not result_verified,
             "message": (
                 "applied app layout with flattened section fallback"
                 if layout_verified and layout_summary_verified and fallback_applied is not None
                 else
                 "applied app layout"
-                if layout_verified and layout_summary_verified
-                else "applied app layout; raw layout verified but compact summary is incomplete"
-                if layout_verified and not layout_summary_verified
+                if layout_verified
                 else "applied app layout with flattened section fallback"
                 if fallback_applied is not None
                 else "applied app layout; readback did not fully match the requested layout"
@@ -9888,12 +10539,12 @@ class AiBuilderFacade:
                 "auto_added_fields": merged["auto_added_fields"] if mode == LayoutApplyMode.merge else [],
                 "fallback_applied": fallback_applied,
             },
-            "verified": layout_verified,
+            "verified": result_verified,
             "write_executed": True,
             "write_succeeded": True,
             "safe_to_retry": False,
         }
-        return finalize(self._append_publish_result(profile=profile, app_key=app_key, publish=publish, response=response))
+        return finish_with_publish(response)
 
     def app_flow_apply(
         self,
@@ -9912,22 +10563,54 @@ class AiBuilderFacade:
             "transitions": transitions,
             "publish": publish,
         }
+        apply_started_at = time.perf_counter()
+        permission_ms = 0
+        flow_state_read_ms = 0
+        flow_compile_ms = 0
+        flow_write_ms = 0
+        flow_readback_ms = 0
+        publish_ms = 0
         permission_outcomes: list[PermissionCheckOutcome] = []
+        def finalize(response: JSONObject) -> JSONObject:
+            return _apply_permission_outcomes(response, *permission_outcomes)
+
+        def attach_duration(response: JSONObject) -> JSONObject:
+            _merge_duration_breakdown(
+                response,
+                permission_ms=permission_ms,
+                flow_state_read_ms=flow_state_read_ms,
+                flow_compile_ms=flow_compile_ms,
+                flow_write_ms=flow_write_ms,
+                flow_readback_ms=flow_readback_ms,
+                publish_ms=publish_ms,
+                total_ms=_duration_ms(apply_started_at),
+            )
+            return response
+
+        def finish(response: JSONObject) -> JSONObject:
+            return finalize(attach_duration(response))
+
+        def finish_with_publish(response: JSONObject) -> JSONObject:
+            nonlocal publish_ms
+            publish_started_at = time.perf_counter()
+            published_response = self._append_publish_result(profile=profile, app_key=app_key, publish=publish, response=response)
+            publish_ms += _duration_ms(publish_started_at)
+            return finish(published_response)
+
+        permission_started_at = time.perf_counter()
         permission_outcome = self._guard_app_permission(
             profile=profile,
             app_key=app_key,
             required_permission="edit_app",
             normalized_args=normalized_args,
         )
+        permission_ms += _duration_ms(permission_started_at)
         if permission_outcome.block is not None:
-            return permission_outcome.block
+            return finish(permission_outcome.block)
         permission_outcomes.append(permission_outcome)
 
-        def finalize(response: JSONObject) -> JSONObject:
-            return _apply_permission_outcomes(response, *permission_outcomes)
-
         if mode != "replace":
-            return finalize(_failed(
+            return finish(_failed(
                 "UNSUPPORTED_FLOW_MODE",
                 "only mode='replace' is supported",
                 normalized_args=normalized_args,
@@ -9935,17 +10618,21 @@ class AiBuilderFacade:
                 suggested_next_call={"tool_name": "app_flow_apply", "arguments": {"profile": profile, **normalized_args}},
             ))
         try:
+            flow_state_read_started_at = time.perf_counter()
             base = self.apps.app_get_base(profile=profile, app_key=app_key, include_raw=True).get("result") or {}
             schema, _schema_source = self._read_schema_with_fallback(profile=profile, app_key=app_key)
         except (QingflowApiError, RuntimeError) as error:
+            flow_state_read_ms += _duration_ms(flow_state_read_started_at)
             api_error = _coerce_api_error(error)
-            return finalize(_failed_from_api_error(
+            return finish(_failed_from_api_error(
                 "FLOW_READ_FAILED",
                 api_error,
                 normalized_args=normalized_args,
                 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}},
             ))
+        flow_state_read_ms += _duration_ms(flow_state_read_started_at)
+        flow_compile_started_at = time.perf_counter()
         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"]
@@ -9954,7 +10641,8 @@ class AiBuilderFacade:
         unsupported_nodes = self._unsupported_public_flow_nodes(nodes=public_nodes)
         normalized_args["nodes"] = public_nodes
         if unsupported_nodes:
-            return _failed(
+            flow_compile_ms += _duration_ms(flow_compile_started_at)
+            return finish(_failed(
                 "FLOW_NODE_TYPE_UNSUPPORTED",
                 "app_flow_apply currently supports only linear workflows; branch and condition nodes are disabled because the backend workflow route is not front-end stable for these node types.",
                 normalized_args=normalized_args,
@@ -9964,7 +10652,7 @@ class AiBuilderFacade:
                     "disabled_node_types": sorted(DISABLED_PUBLIC_FLOW_NODE_TYPES),
                 },
                 suggested_next_call={"tool_name": "builder_tool_contract", "arguments": {"tool_name": "app_flow_apply"}},
-            )
+            ))
         if resolution_issues:
             first_issue = resolution_issues[0]
             suggested_call = None
@@ -9974,13 +10662,14 @@ class AiBuilderFacade:
                 suggested_call = {"tool_name": "member_search", "arguments": {"profile": profile, "query": first_issue.get("value") or ""}}
             elif first_issue.get("kind") in {"editable_fields", "condition_fields"}:
                 suggested_call = {"tool_name": "app_get_fields", "arguments": {"profile": profile, "app_key": app_key}}
-            return _failed(
+            flow_compile_ms += _duration_ms(flow_compile_started_at)
+            return finish(_failed(
                 first_issue.get("error_code") or "FLOW_ASSIGNEE_UNRESOLVED",
                 "workflow contains unresolved assignees or field permissions",
                 normalized_args=normalized_args,
                 details={"issues": resolution_issues},
                 suggested_next_call=suggested_call,
-            )
+            ))
         assignee_required_nodes = [
             node.get("id")
             for node in normalized_nodes
@@ -9991,19 +10680,21 @@ class AiBuilderFacade:
             )
         ]
         if assignee_required_nodes:
-            return _failed(
+            flow_compile_ms += _duration_ms(flow_compile_started_at)
+            return finish(_failed(
                 "FLOW_ASSIGNEE_REQUIRED",
                 "workflow approval/fill/copy nodes must declare at least one role or member assignee",
                 normalized_args=normalized_args,
                 details={"node_ids": assignee_required_nodes, "policy": "prefer role assignees; explicit members are also supported"},
                 suggested_next_call={"tool_name": "role_search", "arguments": {"profile": profile, "keyword": ""}},
-            )
+            ))
         workflow_spec = _build_public_workflow_spec(nodes=normalized_nodes, transitions=transitions)
         if workflow_spec.get("status") == "failed":
             workflow_spec["normalized_args"] = normalized_args
             workflow_spec.setdefault("request_id", None)
             workflow_spec["suggested_next_call"] = {"tool_name": "app_flow_apply", "arguments": {"profile": profile, **normalized_args}}
-            return workflow_spec
+            flow_compile_ms += _duration_ms(flow_compile_started_at)
+            return finish(workflow_spec)
         desired_node_count = len([node for node in normalized_nodes if node.get("type") != "end"])
         build_id = f"facade-flow-{uuid4().hex[:12]}"
         previous_build_home = os.getenv("QINGFLOW_MCP_BUILD_HOME")
@@ -10028,6 +10719,8 @@ class AiBuilderFacade:
                 "entities": [{"entity_id": entity["entity_id"], "workflow": workflow_spec["workflow"]}],
             }
             assembly.set_stage_spec("app_flow", flow_stage_spec)
+            flow_compile_ms += _duration_ms(flow_compile_started_at)
+            flow_write_started_at = time.perf_counter()
             stage = self.solutions.solution_build_flow(
                 profile=profile,
                 mode="apply",
@@ -10037,6 +10730,7 @@ class AiBuilderFacade:
                 run_label=None,
                 repair_patch={},
             )
+            flow_write_ms += _duration_ms(flow_write_started_at)
         finally:
             if previous_build_home is None:
                 os.environ.pop("QINGFLOW_MCP_BUILD_HOME", None)
@@ -10058,8 +10752,10 @@ class AiBuilderFacade:
                 suggested_next_call["tool_name"] = "app_flow_apply"
                 suggested_next_call["arguments"] = arguments
             failed["suggested_next_call"] = suggested_next_call
-            return finalize(failed)
+            return finish(failed)
+        flow_readback_started_at = time.perf_counter()
         verified_nodes, verified_nodes_unavailable = self._load_workflow_result(profile=profile, app_key=app_key, tolerate_404=True)
+        flow_readback_ms += _duration_ms(flow_readback_started_at)
         workflow_structure_verified = bool(verified_nodes) and _workflow_nodes_semantically_equal(
             current_workflow=verified_nodes,
             requested_nodes=normalized_nodes,
@@ -10121,7 +10817,7 @@ class AiBuilderFacade:
             "write_succeeded": True,
             "safe_to_retry": False,
         }
-        return finalize(self._append_publish_result(profile=profile, app_key=app_key, publish=publish, response=response))
+        return finish_with_publish(response)
 
     def _extract_view_action_button_patch_intents(
         self,
@@ -10547,12 +11243,65 @@ class AiBuilderFacade:
             "remove_views": list(remove_views),
             "publish": publish,
         }
+        apply_started_at = time.perf_counter()
+        permission_ms = 0
+        view_state_read_ms = 0
+        custom_button_inventory_ms = 0
+        associated_resource_inventory_ms = 0
+        view_mutation_ms = 0
+        action_buttons_ms = 0
+        view_readback_ms = 0
+        view_verification_ms = 0
+        publish_ms = 0
+        publish_already_satisfied_by_action_buttons = False
+        permission_outcomes: list[PermissionCheckOutcome] = []
+
+        def finalize(response: JSONObject) -> JSONObject:
+            return _apply_permission_outcomes(response, *permission_outcomes)
+
+        def attach_duration(response: JSONObject) -> JSONObject:
+            _merge_duration_breakdown(
+                response,
+                permission_ms=permission_ms,
+                view_state_read_ms=view_state_read_ms,
+                custom_button_inventory_ms=custom_button_inventory_ms,
+                associated_resource_inventory_ms=associated_resource_inventory_ms,
+                view_mutation_ms=view_mutation_ms,
+                action_buttons_ms=action_buttons_ms,
+                view_readback_ms=view_readback_ms,
+                view_verification_ms=view_verification_ms,
+                publish_ms=publish_ms,
+                total_ms=_duration_ms(apply_started_at),
+            )
+            return response
+
+        def finish(response: JSONObject) -> JSONObject:
+            return finalize(attach_duration(response))
+
+        def finish_with_publish(response: JSONObject) -> JSONObject:
+            nonlocal publish_ms
+            if publish and publish_already_satisfied_by_action_buttons and not bool(response.get("noop")):
+                verification = response.get("verification")
+                if not isinstance(verification, dict):
+                    verification = {}
+                    response["verification"] = verification
+                response["publish_requested"] = True
+                response["publish_skipped"] = True
+                response["publish_skip_reason"] = "already_published_by_action_buttons"
+                response["published"] = True
+                verification["published"] = True
+                return finish(response)
+            publish_started_at = time.perf_counter()
+            published_response = self._append_publish_result(profile=profile, app_key=app_key, publish=publish, response=response)
+            publish_ms += _duration_ms(publish_started_at)
+            return finish(published_response)
+
         has_action_button_intent = any(patch.action_buttons is not None for patch in upsert_views) or any(
             any(key in (patch.set or {}) for key in ("action_buttons", "actionButtons"))
             for patch in patch_views
         )
         if has_action_button_intent and not publish:
-            return _failed(
+            return finish(_failed(
                 "VIEW_ACTION_BUTTONS_REQUIRE_PUBLISH",
                 "app_views_apply action_buttons require publish=true because the underlying custom button writer may publish after successful button writes",
                 normalized_args=normalized_args,
@@ -10562,7 +11311,7 @@ class AiBuilderFacade:
                     "reason": "action_buttons are compiled through app_custom_buttons_apply",
                 },
                 suggested_next_call={"tool_name": "app_views_apply", "arguments": {"profile": profile, **{**normalized_args, "publish": True}}},
-            )
+            ))
         if not upsert_views and not patch_views and not remove_views:
             response = {
                 "status": "success",
@@ -10590,10 +11339,10 @@ class AiBuilderFacade:
                 "write_succeeded": False,
                 "safe_to_retry": True,
             }
-            return self._append_publish_result(profile=profile, app_key=app_key, publish=publish, response=response)
-        permission_outcomes: list[PermissionCheckOutcome] = []
+            return finish_with_publish(response)
         app_permission_summary: JSONObject | None = None
         app_permission_error: QingflowApiError | None = None
+        permission_started_at = time.perf_counter()
         try:
             app_permission_summary = self._read_app_permission_summary(profile=profile, app_key=app_key)
         except (QingflowApiError, RuntimeError) as error:
@@ -10637,26 +11386,27 @@ class AiBuilderFacade:
                 normalized_args=normalized_args,
                 permission_summary=app_permission_summary,
             )
+        permission_ms += _duration_ms(permission_started_at)
         if permission_outcome.block is not None:
-            return permission_outcome.block
+            return finish(permission_outcome.block)
         permission_outcomes.append(permission_outcome)
 
-        def finalize(response: JSONObject) -> JSONObject:
-            return _apply_permission_outcomes(response, *permission_outcomes)
-
         try:
+            view_state_read_started_at = time.perf_counter()
             base = self.apps.app_get_base(profile=profile, app_key=app_key, include_raw=True).get("result") or {}
             schema, _schema_source = self._read_schema_with_fallback(profile=profile, app_key=app_key)
             existing_views, _views_unavailable = self._load_views_result(profile=profile, app_key=app_key, tolerate_404=False)
         except (QingflowApiError, RuntimeError) as error:
+            view_state_read_ms += _duration_ms(view_state_read_started_at)
             api_error = _coerce_api_error(error)
-            return finalize(_failed_from_api_error(
+            return finish(_failed_from_api_error(
                 "VIEWS_READ_FAILED",
                 api_error,
                 normalized_args=normalized_args,
                 details=_with_state_read_blocked_details({"app_key": app_key}, resource="views", error=api_error),
                 suggested_next_call={"tool_name": "app_get", "arguments": {"profile": profile, "app_key": app_key}},
             ))
+        view_state_read_ms += _duration_ms(view_state_read_started_at)
         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]] = {}
@@ -10680,7 +11430,7 @@ class AiBuilderFacade:
             if action_button_patch_results:
                 normalized_args["action_button_patch_results"] = action_button_patch_results
             if action_button_patch_issues:
-                return finalize(
+                return finish(
                     _failed(
                         "VIEW_ACTION_BUTTON_PATCH_FAILED",
                         "one or more patch_views action_buttons entries could not be resolved; no write was executed",
@@ -10705,6 +11455,7 @@ class AiBuilderFacade:
                     transport_error=_transport_error_payload(app_permission_error),
                 )
             else:
+                create_permission_started_at = time.perf_counter()
                 create_permission_outcome = self._guard_app_permission(
                     profile=profile,
                     app_key=app_key,
@@ -10712,13 +11463,14 @@ class AiBuilderFacade:
                     normalized_args=normalized_args,
                     permission_summary=app_permission_summary,
                 )
+                permission_ms += _duration_ms(create_permission_started_at)
             if create_permission_outcome.block is not None:
                 details = create_permission_outcome.block.get("details")
                 if isinstance(details, dict):
                     details["operation"] = "view_create"
                     details["view_names"] = creating_view_names
                     details["also_required_permission"] = "view_manage"
-                return create_permission_outcome.block
+                return finish(create_permission_outcome.block)
             permission_outcomes.append(create_permission_outcome)
         parsed_schema = _parse_schema(schema)
         field_names = {field["name"] for field in parsed_schema["fields"]}
@@ -10757,6 +11509,7 @@ class AiBuilderFacade:
         custom_button_details_by_id: dict[int, dict[str, Any]] = {}
         if requires_custom_button_validation:
             try:
+                custom_button_inventory_started_at = time.perf_counter()
                 button_listing = self.buttons.custom_button_list(
                     profile=profile,
                     app_key=app_key,
@@ -10764,8 +11517,9 @@ class AiBuilderFacade:
                     include_raw=False,
                 )
             except (QingflowApiError, RuntimeError) as error:
+                custom_button_inventory_ms += _duration_ms(custom_button_inventory_started_at)
                 api_error = _coerce_api_error(error)
-                return finalize(
+                return finish(
                     _failed_from_api_error(
                         "CUSTOM_BUTTON_LIST_FAILED",
                         api_error,
@@ -10774,6 +11528,7 @@ class AiBuilderFacade:
                         suggested_next_call={"tool_name": "app_get", "arguments": {"profile": profile, "app_key": app_key}},
                     )
                 )
+            custom_button_inventory_ms += _duration_ms(custom_button_inventory_started_at)
             valid_custom_button_ids = {
                 button_id
                 for item in (button_listing.get("items") or [])
@@ -10787,6 +11542,7 @@ class AiBuilderFacade:
             }
             for button_id in sorted(referenced_custom_button_ids):
                 try:
+                    custom_button_detail_started_at = time.perf_counter()
                     detail = self.buttons.custom_button_get(
                         profile=profile,
                         app_key=app_key,
@@ -10794,7 +11550,9 @@ class AiBuilderFacade:
                         being_draft=True,
                         include_raw=False,
                     )
+                    custom_button_inventory_ms += _duration_ms(custom_button_detail_started_at)
                 except (QingflowApiError, RuntimeError) as error:
+                    custom_button_inventory_ms += _duration_ms(custom_button_detail_started_at)
                     api_error = _coerce_api_error(error)
                     if _is_optional_builder_lookup_error(api_error):
                         continue
@@ -10813,7 +11571,7 @@ class AiBuilderFacade:
                         },
                     )
                     failed.update({"write_executed": False, "write_succeeded": False, "safe_to_retry": True})
-                    return finalize(failed)
+                    return finish(failed)
                 detail_result = detail.get("result")
                 if isinstance(detail_result, dict):
                     custom_button_details_by_id[button_id] = _normalize_custom_button_detail(detail_result)
@@ -10821,10 +11579,12 @@ class AiBuilderFacade:
         associated_resources: list[dict[str, Any]] = []
         if requires_associated_resource_validation:
             try:
+                associated_resource_inventory_started_at = time.perf_counter()
                 associated_resources = self._load_associated_resources_for_builder(profile=profile, app_key=app_key)
             except (QingflowApiError, RuntimeError) as error:
+                associated_resource_inventory_ms += _duration_ms(associated_resource_inventory_started_at)
                 api_error = _coerce_api_error(error)
-                return finalize(
+                return finish(
                     _failed_from_api_error(
                         "ASSOCIATED_RESOURCES_READ_FAILED",
                         api_error,
@@ -10833,6 +11593,7 @@ class AiBuilderFacade:
                         suggested_next_call={"tool_name": "app_get", "arguments": {"profile": profile, "app_key": app_key}},
                     )
                 )
+            associated_resource_inventory_ms += _duration_ms(associated_resource_inventory_started_at)
         removed: list[str] = []
         removed_keys: set[str] = set()
         view_results: list[dict[str, Any]] = []
@@ -10853,6 +11614,7 @@ class AiBuilderFacade:
                 }
             )
 
+        view_mutation_started_at = time.perf_counter()
         for selector in remove_views:
             selector_text = str(selector or "").strip()
             if not selector_text:
@@ -11489,6 +12251,7 @@ class AiBuilderFacade:
                 failed_views.append(failure_entry)
                 view_results.append(failure_entry)
                 continue
+        view_mutation_ms += _duration_ms(view_mutation_started_at)
         successful_action_view_keys = {
             str(item.get("view_key") or "").strip()
             for item in view_results
@@ -11510,11 +12273,13 @@ class AiBuilderFacade:
         runnable_action_button_intents = [
             intent for intent in action_button_intents if id(intent) not in skipped_action_button_intent_ids
         ]
+        action_buttons_started_at = time.perf_counter()
         action_buttons_result = self._apply_view_action_buttons(
             profile=profile,
             app_key=app_key,
             intents=runnable_action_button_intents,
         )
+        action_buttons_ms += _duration_ms(action_buttons_started_at)
         if skipped_action_button_intents:
             action_buttons_result.setdefault("skipped_due_to_view_write_failure", [])
             if isinstance(action_buttons_result["skipped_due_to_view_write_failure"], list):
@@ -11530,6 +12295,11 @@ class AiBuilderFacade:
                 )
         action_button_write_executed = bool(action_buttons_result.get("write_executed"))
         action_button_write_succeeded = bool(action_buttons_result.get("write_succeeded"))
+        publish_already_satisfied_by_action_buttons = bool(
+            publish
+            and action_buttons_result.get("publish_requested") is True
+            and action_buttons_result.get("published") is True
+        )
         action_buttons_verification = action_buttons_result.get("verification") if isinstance(action_buttons_result.get("verification"), dict) else {}
         action_buttons_verified = (
             bool(action_buttons_result.get("verified", True))
@@ -11544,16 +12314,19 @@ class AiBuilderFacade:
         verified_views_unavailable = False
         if needs_view_list_readback:
             try:
+                view_readback_started_at = time.perf_counter()
                 verified_view_result, verified_views_unavailable = self._load_views_result(profile=profile, app_key=app_key, tolerate_404=True)
             except (QingflowApiError, RuntimeError) as error:
+                view_readback_ms += _duration_ms(view_readback_started_at)
                 api_error = _coerce_api_error(error)
-                return finalize(_failed_from_api_error(
+                return finish(_failed_from_api_error(
                     "VIEWS_READ_FAILED",
                     api_error,
                     normalized_args=normalized_args,
                     details=_with_state_read_blocked_details({"app_key": app_key}, resource="views", error=api_error),
                     suggested_next_call={"tool_name": "app_get", "arguments": {"profile": profile, "app_key": app_key}},
                 ))
+            view_readback_ms += _duration_ms(view_readback_started_at)
         verified_names = {
             _extract_view_name(item)
             for item in (verified_view_result or [])
@@ -11583,6 +12356,22 @@ class AiBuilderFacade:
         button_mismatches: list[dict[str, Any]] = []
         custom_button_readback_pending = False
         custom_button_readback_pending_entries: list[dict[str, Any]] = []
+        view_config_readback_cache: dict[str, tuple[dict[str, Any], QingflowApiError | None]] = {}
+
+        def read_view_config_for_verification(view_key: str) -> tuple[dict[str, Any], QingflowApiError | None]:
+            cached = view_config_readback_cache.get(view_key)
+            if cached is not None:
+                return cached
+            try:
+                config_response = self.views.view_get_config(profile=profile, viewgraph_key=view_key)
+                config_result = (config_response.get("result") or {}) if isinstance(config_response.get("result"), dict) else {}
+                cached = (config_result, None)
+            except (QingflowApiError, RuntimeError) as error:
+                cached = ({}, _coerce_api_error(error))
+            view_config_readback_cache[view_key] = cached
+            return cached
+
+        view_verification_started_at = time.perf_counter()
         for item in view_results:
             status = str(item.get("status") or "")
             name = str(item.get("name") or "")
@@ -11629,8 +12418,9 @@ class AiBuilderFacade:
                                 verification_by_view.append(verification_entry)
                                 continue
                         try:
-                            config_response = self.views.view_get_config(profile=profile, viewgraph_key=verification_key)
-                            config_result = (config_response.get("result") or {}) if isinstance(config_response.get("result"), dict) else {}
+                            config_result, config_error = read_view_config_for_verification(verification_key)
+                            if config_error is not None:
+                                raise config_error
                             actual_filters = _normalize_view_filter_groups_for_compare(config_result.get("viewgraphLimit"))
                             expected_filter_summary = _normalize_view_filter_groups_for_compare(expected_filters)
                             expected_data_scope = "CUSTOM" if expected_filter_summary else "ALL"
@@ -11706,8 +12496,9 @@ class AiBuilderFacade:
                                 verification_by_view.append(verification_entry)
                                 continue
                         try:
-                            config_response = self.views.view_get_config(profile=profile, viewgraph_key=verification_key)
-                            config_result = (config_response.get("result") or {}) if isinstance(config_response.get("result"), dict) else {}
+                            config_result, config_error = read_view_config_for_verification(verification_key)
+                            if config_error is not None:
+                                raise config_error
                             actual_query_conditions = _normalize_view_query_conditions_for_compare(config_result)
                             query_conditions_verified = actual_query_conditions == expected_query_conditions
                             verification_entry["query_conditions_verified"] = query_conditions_verified
@@ -11754,8 +12545,9 @@ class AiBuilderFacade:
                                 verification_by_view.append(verification_entry)
                                 continue
                         try:
-                            config_response = self.views.view_get_config(profile=profile, viewgraph_key=verification_key)
-                            config_result = (config_response.get("result") or {}) if isinstance(config_response.get("result"), dict) else {}
+                            config_result, config_error = read_view_config_for_verification(verification_key)
+                            if config_error is not None:
+                                raise config_error
                             actual_associated_resources = _extract_view_associated_resources_config(
                                 config_result,
                                 available_resources=associated_resources,
@@ -11808,8 +12600,9 @@ class AiBuilderFacade:
                                 verification_by_view.append(verification_entry)
                                 continue
                         try:
-                            config_response = self.views.view_get_config(profile=profile, viewgraph_key=verification_key)
-                            config_result = (config_response.get("result") or {}) if isinstance(config_response.get("result"), dict) else {}
+                            config_result, config_error = read_view_config_for_verification(verification_key)
+                            if config_error is not None:
+                                raise config_error
                             actual_buttons = _normalize_view_buttons_for_compare(config_result)
                             button_comparison = _compare_view_button_summaries(
                                 expected=expected_buttons,
@@ -11893,6 +12686,7 @@ class AiBuilderFacade:
                         "error_code": item.get("error_code"),
                     }
                 )
+        view_verification_ms += _duration_ms(view_verification_started_at)
         removed_delete_results = [
             item
             for item in view_results
@@ -11992,7 +12786,7 @@ class AiBuilderFacade:
                 "write_succeeded": bool(created or updated or removed or action_button_write_succeeded),
                 "safe_to_retry": not bool(created or updated or removed or action_button_write_executed),
             }
-            return finalize(self._append_publish_result(profile=profile, app_key=app_key, publish=publish, response=response))
+            return finish_with_publish(response)
         warnings: list[dict[str, Any]] = []
         if filter_readback_pending or filter_mismatches:
             warnings.append(_warning("VIEW_FILTERS_UNVERIFIED", "view definitions were applied, but saved filter behavior is not fully verified"))
@@ -12092,7 +12886,7 @@ class AiBuilderFacade:
             "write_succeeded": bool(created or updated or removed or action_button_write_succeeded),
             "safe_to_retry": not bool(created or updated or removed or action_button_write_executed),
         }
-        return finalize(self._append_publish_result(profile=profile, app_key=app_key, publish=publish, response=response))
+        return finish_with_publish(response)
 
     def app_publish_verify(
         self,
@@ -12101,87 +12895,132 @@ class AiBuilderFacade:
         app_key: str,
         expected_package_tag_id: int | None = None,
     ) -> JSONObject:
+        apply_started_at = time.perf_counter()
+        initial_base_read_ms = 0
+        initial_views_read_ms = 0
+        edit_version_ms = 0
+        publish_ms = 0
+        base_readback_ms = 0
+        views_readback_ms = 0
         normalized_args = {"app_key": app_key, "expected_package_tag_id": expected_package_tag_id}
+
+        def finish(response: JSONObject) -> JSONObject:
+            _merge_duration_breakdown(
+                response,
+                initial_base_read_ms=initial_base_read_ms,
+                initial_views_read_ms=initial_views_read_ms,
+                edit_version_ms=edit_version_ms,
+                publish_ms=publish_ms,
+                base_readback_ms=base_readback_ms,
+                views_readback_ms=views_readback_ms,
+                total_ms=_duration_ms(apply_started_at),
+            )
+            return response
+
+        initial_base_read_started_at = time.perf_counter()
         try:
             base_before = self.apps.app_get_base(profile=profile, app_key=app_key, include_raw=True).get("result") or {}
         except (QingflowApiError, RuntimeError) as error:
+            initial_base_read_ms += _duration_ms(initial_base_read_started_at)
             api_error = _coerce_api_error(error)
-            return _failed_from_api_error(
-                "APP_READ_FAILED",
-                api_error,
-                normalized_args=normalized_args,
-                details={"app_key": app_key},
-                suggested_next_call={"tool_name": "app_get", "arguments": {"profile": profile, "app_key": app_key}},
+            return finish(
+                _failed_from_api_error(
+                    "APP_READ_FAILED",
+                    api_error,
+                    normalized_args=normalized_args,
+                    details={"app_key": app_key},
+                    suggested_next_call={"tool_name": "app_get", "arguments": {"profile": profile, "app_key": app_key}},
+                )
             )
+        initial_base_read_ms += _duration_ms(initial_base_read_started_at)
         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
+        initial_views_read_started_at = time.perf_counter()
         try:
             views_before, views_before_unavailable = self._load_views_result(profile=profile, app_key=app_key, tolerate_404=True)
         except (QingflowApiError, RuntimeError) as error:
+            initial_views_read_ms += _duration_ms(initial_views_read_started_at)
             api_error = _coerce_api_error(error)
-            return _failed_from_api_error(
-                "VIEWS_READ_FAILED",
-                api_error,
-                normalized_args=normalized_args,
-                details={"app_key": app_key},
-                suggested_next_call={"tool_name": "app_get_views", "arguments": {"profile": profile, "app_key": app_key}},
+            return finish(
+                _failed_from_api_error(
+                    "VIEWS_READ_FAILED",
+                    api_error,
+                    normalized_args=normalized_args,
+                    details={"app_key": app_key},
+                    suggested_next_call={"tool_name": "app_get_views", "arguments": {"profile": profile, "app_key": app_key}},
+                )
             )
+        initial_views_read_ms += _duration_ms(initial_views_read_started_at)
         views_before = views_before or []
         if already_published and package_already_attached is not False and isinstance(views_before, list) and not views_before_unavailable:
-            return {
-                "status": "success",
-                "error_code": None,
-                "recoverable": False,
-                "message": "app already published and verified",
-                "normalized_args": normalized_args,
-                "missing_fields": [],
-                "allowed_values": {},
-                "details": {},
-                "request_id": None,
-                "suggested_next_call": None,
-                "noop": True,
-                "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,
-                "views_ok": True,
-                "verified": True,
-                "write_executed": False,
-                "write_succeeded": False,
-                "safe_to_retry": True,
-            }
+            return finish(
+                {
+                    "status": "success",
+                    "error_code": None,
+                    "recoverable": False,
+                    "message": "app already published and verified",
+                    "normalized_args": normalized_args,
+                    "missing_fields": [],
+                    "allowed_values": {},
+                    "details": {},
+                    "request_id": None,
+                    "suggested_next_call": None,
+                    "noop": True,
+                    "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,
+                    "views_ok": True,
+                    "verified": True,
+                    "write_executed": False,
+                    "write_succeeded": False,
+                    "safe_to_retry": True,
+                }
+            )
+        edit_version_started_at = time.perf_counter()
         try:
             version_result = self.apps.app_get_edit_version_no(profile=profile, app_key=app_key).get("result") or {}
         except (QingflowApiError, RuntimeError) as error:
+            edit_version_ms += _duration_ms(edit_version_started_at)
             api_error = _coerce_api_error(error)
-            return _failed_from_api_error(
-                "PUBLISH_PRECHECK_FAILED",
-                api_error,
-                normalized_args=normalized_args,
-                details={"app_key": app_key, "phase": "prepare_publish_edit_version"},
-                suggested_next_call={"tool_name": "app_get", "arguments": {"profile": profile, "app_key": app_key}},
+            return finish(
+                _failed_from_api_error(
+                    "PUBLISH_PRECHECK_FAILED",
+                    api_error,
+                    normalized_args=normalized_args,
+                    details={"app_key": app_key, "phase": "prepare_publish_edit_version"},
+                    suggested_next_call={"tool_name": "app_get", "arguments": {"profile": profile, "app_key": app_key}},
+                )
             )
+        edit_version_ms += _duration_ms(edit_version_started_at)
         edit_version_no = _coerce_positive_int(version_result.get("editVersionNo") or version_result.get("versionNo")) or 1
+        publish_started_at = time.perf_counter()
         try:
             self.apps.app_publish(profile=profile, app_key=app_key, payload={"editVersionNo": edit_version_no})
             self.apps.app_edit_finished(profile=profile, app_key=app_key, payload={"editVersionNo": edit_version_no})
         except (QingflowApiError, RuntimeError) as error:
+            publish_ms += _duration_ms(publish_started_at)
             api_error = _coerce_api_error(error)
-            return _failed_from_api_error(
-                "PUBLISH_FAILED",
-                api_error,
-                normalized_args=normalized_args,
-                details={"app_key": app_key, "edit_version_no": edit_version_no},
-                suggested_next_call={"tool_name": "app_get", "arguments": {"profile": profile, "app_key": app_key}},
+            return finish(
+                _failed_from_api_error(
+                    "PUBLISH_FAILED",
+                    api_error,
+                    normalized_args=normalized_args,
+                    details={"app_key": app_key, "edit_version_no": edit_version_no},
+                    suggested_next_call={"tool_name": "app_get", "arguments": {"profile": profile, "app_key": app_key}},
+                )
             )
+        publish_ms += _duration_ms(publish_started_at)
+        base_readback_started_at = time.perf_counter()
         try:
             base = self.apps.app_get_base(profile=profile, app_key=app_key, include_raw=True).get("result") or {}
         except (QingflowApiError, RuntimeError) as error:
+            base_readback_ms += _duration_ms(base_readback_started_at)
             api_error = _coerce_api_error(error)
             result = _post_write_readback_pending_result(
                 error_code="PUBLISH_READBACK_PENDING",
@@ -12194,13 +13033,16 @@ class AiBuilderFacade:
                 http_status=None if api_error.http_status == 404 else api_error.http_status,
             )
             result.update({"app_key": app_key, "published": None, "verified": False})
-            return result
+            return finish(result)
+        base_readback_ms += _duration_ms(base_readback_started_at)
         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
+        views_readback_started_at = time.perf_counter()
         try:
             views, views_unavailable = self._load_views_result(profile=profile, app_key=app_key, tolerate_404=True)
         except (QingflowApiError, RuntimeError) as error:
+            views_readback_ms += _duration_ms(views_readback_started_at)
             api_error = _coerce_api_error(error)
             result = _post_write_readback_pending_result(
                 error_code="VIEWS_READBACK_PENDING",
@@ -12213,7 +13055,8 @@ class AiBuilderFacade:
                 http_status=None if api_error.http_status == 404 else api_error.http_status,
             )
             result.update({"app_key": app_key, "app_name": app_name_after, "published": bool(base.get("appPublishStatus") in {1, 2}), "verified": False})
-            return result
+            return finish(result)
+        views_readback_ms += _duration_ms(views_readback_started_at)
         views = views or []
         views_ok = isinstance(views, list) and not views_unavailable
         verified = bool(base.get("appPublishStatus") in {1, 2}) and (package_attached is not False) and views_ok
@@ -12222,36 +13065,38 @@ class AiBuilderFacade:
             views_unavailable=views_unavailable,
             verified=verified,
         )
-        return {
-            "status": "success" if verified else "partial_success",
-            "error_code": None if not views_unavailable else "VIEWS_READBACK_PENDING",
-            "recoverable": bool(views_unavailable),
-            "message": "published and verified app" if not views_unavailable else "published app; views readback pending",
-            "normalized_args": normalized_args,
-            "missing_fields": [],
-            "allowed_values": {},
-            "details": {},
-            "request_id": None,
-            "suggested_next_call": None
-            if package_attached is not False
-            else {
-                "tool_name": "package_attach_app",
-                "arguments": {"profile": profile, "tag_id": expected_package_tag_id, "app_key": app_key},
-            },
-            "noop": False,
-            "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,
-            "views_ok": views_ok,
-            "verified": verified,
-            "write_executed": True,
-            "write_succeeded": True,
-            "safe_to_retry": False,
-        }
+        return finish(
+            {
+                "status": "success" if verified else "partial_success",
+                "error_code": None if not views_unavailable else "VIEWS_READBACK_PENDING",
+                "recoverable": bool(views_unavailable),
+                "message": "published and verified app" if not views_unavailable else "published app; views readback pending",
+                "normalized_args": normalized_args,
+                "missing_fields": [],
+                "allowed_values": {},
+                "details": {},
+                "request_id": None,
+                "suggested_next_call": None
+                if package_attached is not False
+                else {
+                    "tool_name": "package_attach_app",
+                    "arguments": {"profile": profile, "tag_id": expected_package_tag_id, "app_key": app_key},
+                },
+                "noop": False,
+                "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,
+                "views_ok": views_ok,
+                "verified": verified,
+                "write_executed": True,
+                "write_succeeded": True,
+                "safe_to_retry": False,
+            }
+        )
 
     def _expand_chart_partial_patches(
         self,
@@ -12535,6 +13380,12 @@ class AiBuilderFacade:
         }
 
     def chart_apply(self, *, profile: str, request: ChartApplyRequest) -> JSONObject:
+        apply_started_at = time.perf_counter()
+        chart_inventory_ms: int | None = None
+        chart_upsert_ms: int | None = None
+        chart_delete_ms: int | None = None
+        chart_reorder_ms: int | None = None
+        chart_readback_ms: int | None = None
         normalized_args = request.model_dump(mode="json")
         permission_outcomes: list[PermissionCheckOutcome] = []
         app_result = self.app_resolve(profile=profile, app_key=request.app_key)
@@ -12556,21 +13407,51 @@ class AiBuilderFacade:
         permission_outcomes.append(permission_outcome)
 
         def finalize(response: JSONObject) -> JSONObject:
+            _merge_duration_breakdown(
+                response,
+                chart_inventory_ms=chart_inventory_ms,
+                chart_upsert_ms=chart_upsert_ms,
+                chart_delete_ms=chart_delete_ms,
+                chart_reorder_ms=chart_reorder_ms,
+                chart_readback_ms=chart_readback_ms,
+                total_ms=_duration_ms(apply_started_at),
+            )
             return _apply_permission_outcomes(response, *permission_outcomes)
 
         fields: list[dict[str, Any]] = []
         qingbi_fields: list[Any] = []
         existing_chart_items: list[Any] = []
         existing_chart_list_source: str | None = None
-        needs_chart_inventory = bool(request.upsert_charts or request.patch_charts or request.reorder_chart_ids)
+        upsert_charts = list(request.upsert_charts)
+        direct_create_upserts = [
+            patch for patch in upsert_charts if not str(patch.chart_id or "").strip()
+        ]
+        explicit_target_upserts = [
+            patch for patch in upsert_charts if str(patch.chart_id or "").strip()
+        ]
+        pure_direct_create = bool(direct_create_upserts) and len(direct_create_upserts) == len(upsert_charts) and not (
+            request.patch_charts or request.remove_chart_ids or request.reorder_chart_ids
+        )
+        chart_inventory_skipped = False
+        chart_final_readback_skipped = False
+        needs_schema_and_qingbi_fields = bool(upsert_charts or request.patch_charts)
+        needs_existing_chart_inventory = bool(explicit_target_upserts or request.patch_charts or request.reorder_chart_ids)
+        needs_chart_inventory = bool(needs_schema_and_qingbi_fields or needs_existing_chart_inventory)
         if needs_chart_inventory:
+            chart_inventory_started_at = time.perf_counter()
             try:
-                schema_state = self._load_base_schema_state(profile=profile, app_key=app_key)
-                parsed = schema_state.get("parsed") if isinstance(schema_state.get("parsed"), dict) else {}
-                fields = parsed.get("fields") if isinstance(parsed.get("fields"), list) else []
-                qingbi_fields = self.charts.qingbi_report_list_fields(profile=profile, app_key=app_key).get("items") or []
-                existing_chart_items, existing_chart_list_source = self._load_chart_list_for_builder(profile=profile, app_key=app_key)
+                if needs_schema_and_qingbi_fields:
+                    schema_state = self._load_base_schema_state(profile=profile, app_key=app_key)
+                    parsed = schema_state.get("parsed") if isinstance(schema_state.get("parsed"), dict) else {}
+                    fields = parsed.get("fields") if isinstance(parsed.get("fields"), list) else []
+                    qingbi_fields = self.charts.qingbi_report_list_fields(profile=profile, app_key=app_key).get("items") or []
+                if needs_existing_chart_inventory:
+                    existing_chart_items, existing_chart_list_source = self._load_chart_list_for_builder(profile=profile, app_key=app_key)
+                elif direct_create_upserts:
+                    chart_inventory_skipped = True
+                    existing_chart_list_source = "skipped_for_direct_create"
             except (QingflowApiError, RuntimeError) as error:
+                chart_inventory_ms = _duration_ms(chart_inventory_started_at)
                 api_error = _coerce_api_error(error)
                 return finalize(_failed_from_api_error(
                     "CHART_APPLY_FAILED",
@@ -12579,6 +13460,7 @@ class AiBuilderFacade:
                     details=_with_state_read_blocked_details({"app_key": app_key}, resource="chart", error=api_error),
                     suggested_next_call={"tool_name": "app_charts_apply", "arguments": {"profile": profile, **normalized_args}},
                 ))
+            chart_inventory_ms = _duration_ms(chart_inventory_started_at)
 
         field_lookup = _build_public_field_lookup(fields)
         qingbi_fields_by_id = {
@@ -12605,7 +13487,6 @@ 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,
@@ -12628,67 +13509,37 @@ class AiBuilderFacade:
             normalized_args["upsert_charts"] = [patch.model_dump(mode="json") for patch in upsert_charts]
             normalized_args["patch_results"] = patch_results
 
-        if len(upsert_charts) > CHART_APPLY_RECOMMENDED_UPSERT_BATCH_SIZE:
-            batching_context = _chart_apply_batching_context(
-                request=request,
-                upsert_charts=upsert_charts,
-                batch_size=CHART_APPLY_RECOMMENDED_UPSERT_BATCH_SIZE,
-            )
-            first_batch = batching_context["suggested_batch_payloads"][0]
-            return finalize({
-                "status": "failed",
-                "error_code": "CHART_UPSERT_BATCH_TOO_LARGE",
-                "recoverable": True,
-                "message": (
-                    f"upsert_charts contains {len(upsert_charts)} items; split into batches of "
-                    f"{CHART_APPLY_RECOMMENDED_UPSERT_BATCH_SIZE} or fewer before writing"
-                ),
-                "normalized_args": normalized_args,
-                "missing_fields": [],
-                "allowed_values": {"chart.chart_type": [member.value for member in PublicChartType], "chart.filter.operator": [member.value for member in ViewFilterOperator]},
-                "details": batching_context,
-                "request_id": None,
-                "suggested_next_call": {"tool_name": "app_charts_apply", "arguments": {"profile": profile, **first_batch}},
-                "backend_code": None,
-                "http_status": None,
-                "noop": False,
-                "warnings": [
-                    _warning(
-                        "CHART_UPSERT_BATCH_SIZE_BLOCKED",
-                        "large chart upsert batches are blocked before write to avoid timeout and unknown write state",
-                        upsert_count=len(upsert_charts),
-                        max_upsert_count=CHART_APPLY_RECOMMENDED_UPSERT_BATCH_SIZE,
-                    )
-                ],
-                "verification": {
-                    "charts_verified": False,
-                    "readback_unavailable": False,
-                    "readback_before_retry": False,
-                    "chart_delete_readback_results": [],
-                    "chart_order_verified": True,
-                    "chart_list_source": existing_chart_list_source,
-                },
-                "app_key": app_key,
-                "app_name": app_name,
-                "chart_results": [],
-                "verified": False,
-                "write_executed": False,
-                "write_succeeded": False,
-                "safe_to_retry": True,
-                "next_action": "split_upsert_charts_and_retry",
-            })
+        large_upsert_warnings = (
+            [
+                _warning(
+                    "CHART_UPSERT_BATCH_SIZE_RECOMMENDED",
+                    "large chart upsert batch accepted; monitor duration_breakdown_ms and readback before retrying",
+                    upsert_count=len(upsert_charts),
+                    recommended_upsert_count=CHART_APPLY_RECOMMENDED_UPSERT_BATCH_SIZE,
+                )
+            ]
+            if len(upsert_charts) > CHART_APPLY_RECOMMENDED_UPSERT_BATCH_SIZE
+            else []
+        )
 
         chart_results: list[dict[str, Any]] = []
         created_ids: list[str] = []
         updated_ids: list[str] = []
         removed_ids: list[str] = []
         failed_items: list[dict[str, Any]] = []
+        skipped_after_timeout_count = 0
+        stopped_after_timeout = False
         delete_readback_issues: list[dict[str, Any]] = []
+        write_attempted = False
+        created_ids_from_create_response: list[str] = []
+        create_id_readback_fallback_used = False
 
-        for patch in upsert_charts:
+        chart_upsert_started_at = time.perf_counter()
+        for patch_index, patch in enumerate(upsert_charts):
             chart_id = ""
             target_type = ""
             config_payload: dict[str, Any] | None = None
+            patch_write_attempted = False
             try:
                 dataset_source = _chart_patch_dataset_source_type(patch)
                 if dataset_source:
@@ -12708,7 +13559,7 @@ class AiBuilderFacade:
                     existing = existing_by_id.get(str(patch.chart_id))
                     if existing is None:
                         raise ValueError(f"chart_id '{patch.chart_id}' was not found under app '{app_key}'")
-                if existing is None:
+                if existing is None and needs_existing_chart_inventory:
                     name_matches = list(existing_by_name.get(patch.name) or [])
                     if len(name_matches) > 1:
                         raise ValueError(
@@ -12737,6 +13588,7 @@ class AiBuilderFacade:
                     )
                 if existing is None:
                     temp_chart_id = str(patch.chart_id or f"mcp_{uuid4().hex[:16]}")
+                    chart_id = temp_chart_id
                     create_payload = {
                         "chartId": temp_chart_id,
                         "chartName": patch.name,
@@ -12750,9 +13602,13 @@ class AiBuilderFacade:
                         "editAuthType": "ws",
                         "editAuthIncludeSubDept": True,
                     }
+                    write_attempted = True
+                    patch_write_attempted = True
                     create_result = self.charts.qingbi_report_create(profile=profile, payload=create_payload).get("result") or {}
                     created_chart_id = _extract_chart_identifier(create_result or {})
+                    created_id_from_response = bool(created_chart_id)
                     if not created_chart_id:
+                        create_id_readback_fallback_used = True
                         try:
                             refreshed_items, _ = self._load_chart_list_for_builder(profile=profile, app_key=app_key)
                             refreshed_matches = _find_charts_by_name(
@@ -12774,6 +13630,8 @@ class AiBuilderFacade:
                         )
                     chart_id = created_chart_id
                     created_ids.append(chart_id)
+                    if created_id_from_response:
+                        created_ids_from_create_response.append(chart_id)
                     created_chart = {
                         "chartId": chart_id,
                         "chartName": patch.name,
@@ -12783,6 +13641,8 @@ class AiBuilderFacade:
                     existing_by_name.setdefault(patch.name, []).append(deepcopy(created_chart))
                 elif existing_name != patch.name or existing_type != target_type or isinstance(chart_visible_auth, dict):
                     base_info = self.charts.qingbi_report_get_base(profile=profile, chart_id=chart_id).get("result") or {}
+                    write_attempted = True
+                    patch_write_attempted = True
                     self.charts.qingbi_report_update_base(
                         profile=profile,
                         chart_id=chart_id,
@@ -12821,11 +13681,15 @@ class AiBuilderFacade:
 
                 config_updated = False
                 if existing is None or config_update_requested:
+                    write_attempted = True
+                    patch_write_attempted = True
                     self.charts.qingbi_report_update_config(profile=profile, chart_id=chart_id, payload=config_payload or {})
                     config_updated = True
                 if existing is not None and chart_id not in updated_ids and config_updated:
                     updated_ids.append(chart_id)
                 if patch.question_config:
+                    write_attempted = True
+                    patch_write_attempted = True
                     self._request_backend(
                         profile=profile,
                         method="POST",
@@ -12833,6 +13697,8 @@ class AiBuilderFacade:
                         json_body=patch.question_config,
                     )
                 if patch.user_config:
+                    write_attempted = True
+                    patch_write_attempted = True
                     self._request_backend(
                         profile=profile,
                         method="POST",
@@ -12872,9 +13738,30 @@ class AiBuilderFacade:
                 }
                 failed_items.append(failure)
                 chart_results.append(failure)
+                if api_error is not None and patch_write_attempted and _is_uncertain_write_transport_error(api_error):
+                    stopped_after_timeout = True
+                    remaining_upserts = upsert_charts[patch_index + 1 :]
+                    skipped_after_timeout_count = len(remaining_upserts)
+                    for remaining_patch in remaining_upserts:
+                        skipped = {
+                            "chart_id": str(remaining_patch.chart_id or ""),
+                            "name": remaining_patch.name,
+                            "chart_type": remaining_patch.chart_type.value,
+                            "status": "skipped",
+                            "error_code": "CHART_APPLY_SKIPPED_AFTER_TIMEOUT",
+                            "message": "skipped because a previous chart write timed out with uncertain backend state; read back charts before retrying remaining items",
+                            "depends_on_failed_chart": patch.name,
+                            "readback_before_retry": True,
+                        }
+                        failed_items.append(skipped)
+                        chart_results.append(skipped)
+                    break
+        chart_upsert_ms = _duration_ms(chart_upsert_started_at)
 
+        chart_delete_started_at = time.perf_counter()
         for chart_id in request.remove_chart_ids:
             try:
+                write_attempted = True
                 self.charts.qingbi_report_delete(profile=profile, chart_id=chart_id)
                 removed_ids.append(chart_id)
                 delete_result = self._verify_chart_deleted_by_id(profile=profile, chart_id=chart_id)
@@ -12896,8 +13783,10 @@ class AiBuilderFacade:
                 }
                 failed_items.append(failure)
                 chart_results.append(failure)
+        chart_delete_ms = _duration_ms(chart_delete_started_at)
 
         reordered = False
+        chart_reorder_started_at = time.perf_counter()
         if request.reorder_chart_ids:
             try:
                 current_order = [
@@ -12907,6 +13796,7 @@ class AiBuilderFacade:
                 ]
                 desired_display_order = list(request.reorder_chart_ids) + [chart_id for chart_id in current_order if chart_id not in request.reorder_chart_ids]
                 backend_reorder_ids = list(reversed(desired_display_order))
+                write_attempted = True
                 self.charts.qingbi_report_reorder(profile=profile, app_key=app_key, chart_ids=backend_reorder_ids)
                 reordered = True
             except (QingflowApiError, RuntimeError) as error:
@@ -12921,17 +13811,34 @@ class AiBuilderFacade:
                 }
                 failed_items.append(failure)
                 chart_results.append(failure)
+        chart_reorder_ms = _duration_ms(chart_reorder_started_at)
 
         noop = not created_ids and not updated_ids and not removed_ids and not reordered and not failed_items
-        write_executed = bool(created_ids or updated_ids or removed_ids or reordered)
-        write_succeeded = write_executed
-        needs_list_readback = bool(created_ids or updated_ids or reordered)
+        confirmed_write = bool(created_ids or updated_ids or removed_ids or reordered)
+        write_executed = bool(confirmed_write or write_attempted)
+        write_succeeded = confirmed_write
+        chart_final_readback_skipped = bool(
+            pure_direct_create
+            and created_ids
+            and not updated_ids
+            and not removed_ids
+            and not reordered
+            and not failed_items
+            and not create_id_readback_fallback_used
+            and len(created_ids_from_create_response) == len(created_ids) == len(direct_create_upserts)
+        )
+        needs_list_readback = bool(created_ids or updated_ids or reordered) and not chart_final_readback_skipped
         delete_readback_unavailable = any(item.get("readback_status") == "unavailable" for item in delete_readback_issues)
         deletes_verified = not delete_readback_issues
         readback_unavailable = False
         readback_error: QingflowApiError | None = None
         readback_list_source: str | None = existing_chart_list_source
-        if needs_list_readback:
+        if chart_final_readback_skipped:
+            verified = True
+            chart_readback_ms = 0
+            readback_list_source = "skipped_for_direct_create"
+        elif needs_list_readback:
+            chart_readback_started_at = time.perf_counter()
             try:
                 readback_items, readback_list_source = self._load_chart_list_for_builder(profile=profile, app_key=app_key)
                 readback_ids = {
@@ -12954,8 +13861,10 @@ class AiBuilderFacade:
                 verified = False
                 readback_unavailable = True
                 readback_list_source = None
+            chart_readback_ms = _duration_ms(chart_readback_started_at)
         else:
             verified = True
+            chart_readback_ms = 0
         verified = verified and deletes_verified
         any_readback_unavailable = readback_unavailable or delete_readback_unavailable
 
@@ -12983,6 +13892,10 @@ class AiBuilderFacade:
                 "allowed_values": {"chart.chart_type": [member.value for member in PublicChartType], "chart.filter.operator": [member.value for member in ViewFilterOperator]},
                 "details": {
                     "per_chart_results": chart_results,
+                    "stopped_after_timeout": stopped_after_timeout,
+                    "skipped_after_timeout_count": skipped_after_timeout_count,
+                    "inventory_readback_skipped": chart_inventory_skipped,
+                    "final_readback_skipped": chart_final_readback_skipped,
                     **retry_context,
                     **({"readback_error": _transport_error_payload(readback_error)} if readback_error is not None else {}),
                 },
@@ -12991,7 +13904,7 @@ class AiBuilderFacade:
                 "backend_code": failed_items[0].get("backend_code") or (readback_error.backend_code if readback_error is not None else None),
                 "http_status": failed_items[0].get("http_status") or (None if readback_error is None or readback_error.http_status == 404 else readback_error.http_status),
                 "noop": noop,
-                "warnings": _chart_apply_warnings(
+                "warnings": large_upsert_warnings + _chart_apply_warnings(
                     failed_items=failed_items,
                     readback_unavailable=readback_unavailable,
                     verified=False if failed_items else verified,
@@ -13004,6 +13917,8 @@ class AiBuilderFacade:
                     "chart_delete_readback_results": [deepcopy(item) for item in chart_results if item.get("operation") == "delete"],
                     "chart_order_verified": False if request.reorder_chart_ids else True,
                     "chart_list_source": readback_list_source or existing_chart_list_source,
+                    "inventory_readback_skipped": chart_inventory_skipped,
+                    "final_readback_skipped": chart_final_readback_skipped,
                 },
                 "app_key": app_key,
                 "app_name": app_name,
@@ -13031,13 +13946,18 @@ class AiBuilderFacade:
             "normalized_args": normalized_args,
             "missing_fields": [],
             "allowed_values": {"chart.chart_type": [member.value for member in PublicChartType], "chart.filter.operator": [member.value for member in ViewFilterOperator]},
-            "details": {"readback_error": _transport_error_payload(readback_error)} if readback_error is not None else {},
+            "details": {
+                "inventory_readback_skipped": chart_inventory_skipped,
+                "final_readback_skipped": chart_final_readback_skipped,
+                **({"readback_skip_reason": "direct_create_response_ids"} if chart_final_readback_skipped else {}),
+                **({"readback_error": _transport_error_payload(readback_error)} if readback_error is not None else {}),
+            },
             "request_id": readback_error.request_id if readback_error is not None else None,
             "suggested_next_call": None if result_verified else pending_suggestion,
             "backend_code": readback_error.backend_code if readback_error is not None else None,
             "http_status": None if readback_error is None or readback_error.http_status == 404 else readback_error.http_status,
             "noop": noop,
-            "warnings": _chart_apply_warnings(
+            "warnings": large_upsert_warnings + _chart_apply_warnings(
                 failed_items=[],
                 readback_unavailable=False if noop else readback_unavailable,
                 verified=result_verified,
@@ -13049,6 +13969,8 @@ class AiBuilderFacade:
                 "chart_delete_readback_results": [deepcopy(item) for item in chart_results if item.get("operation") == "delete"],
                 "chart_order_verified": (readback_list_source == "sorted" and result_verified) if request.reorder_chart_ids else True,
                 "chart_list_source": existing_chart_list_source if noop else readback_list_source,
+                "inventory_readback_skipped": chart_inventory_skipped,
+                "final_readback_skipped": chart_final_readback_skipped,
             },
             "app_key": app_key,
             "app_name": app_name,
@@ -13060,6 +13982,15 @@ class AiBuilderFacade:
         })
 
     def portal_apply(self, *, profile: str, request: PortalApplyRequest) -> JSONObject:
+        apply_started_at = time.perf_counter()
+        portal_initial_read_ms: int | None = None
+        portal_create_ms: int | None = None
+        portal_component_build_ms: int | None = None
+        portal_update_ms: int | None = None
+        portal_base_info_update_ms: int | None = None
+        portal_draft_readback_ms: int | None = None
+        portal_publish_ms: int | None = None
+        portal_live_readback_ms: int | None = None
         normalized_args = request.model_dump(mode="json")
         permission_outcomes: list[PermissionCheckOutcome] = []
         dash_key = str(request.dash_key or "").strip()
@@ -13089,8 +14020,10 @@ class AiBuilderFacade:
                 suggested_next_call=None,
             )
         try:
+            portal_initial_read_started_at = time.perf_counter()
             base_payload = self.portals.portal_get(profile=profile, dash_key=dash_key, being_draft=True).get("result") if dash_key else {}
         except (QingflowApiError, RuntimeError) as error:
+            portal_initial_read_ms = _duration_ms(portal_initial_read_started_at)
             api_error = _coerce_api_error(error)
             return _failed(
                 "PORTAL_APPLY_FAILED",
@@ -13102,6 +14035,7 @@ class AiBuilderFacade:
                 backend_code=api_error.backend_code,
                 http_status=None if api_error.http_status == 404 else api_error.http_status,
             )
+        portal_initial_read_ms = _duration_ms(portal_initial_read_started_at) if dash_key else 0
         if not isinstance(base_payload, dict):
             base_payload = {}
         if not creating:
@@ -13116,6 +14050,18 @@ class AiBuilderFacade:
             permission_outcomes.append(portal_permission_outcome)
 
         def finalize(response: JSONObject) -> JSONObject:
+            _merge_duration_breakdown(
+                response,
+                portal_initial_read_ms=portal_initial_read_ms,
+                portal_create_ms=portal_create_ms,
+                portal_component_build_ms=portal_component_build_ms,
+                portal_update_ms=portal_update_ms,
+                portal_base_info_update_ms=portal_base_info_update_ms,
+                portal_draft_readback_ms=portal_draft_readback_ms,
+                portal_publish_ms=portal_publish_ms,
+                portal_live_readback_ms=portal_live_readback_ms,
+                total_ms=_duration_ms(apply_started_at),
+            )
             return _apply_permission_outcomes(response, *permission_outcomes)
         target_package_tag_id = request.package_tag_id
         if target_package_tag_id is None:
@@ -13175,7 +14121,9 @@ class AiBuilderFacade:
                     config=request.config,
                     base_payload=None,
                 )
+                portal_create_started_at = time.perf_counter()
                 create_result = self.portals.portal_create(profile=profile, payload=create_payload)
+                portal_create_ms = _duration_ms(portal_create_started_at)
                 write_executed = True
                 created = create_result.get("result") if isinstance(create_result.get("result"), dict) else {}
                 dash_key = str(created.get("dashKey") or "")
@@ -13208,36 +14156,61 @@ class AiBuilderFacade:
                 base_payload=base_payload,
             )
             if sections_requested:
+                portal_component_build_started_at = time.perf_counter()
                 component_payload, layout_metadata, inline_chart_results = self._build_portal_components_from_sections(
                     profile=profile,
                     sections=request.sections,
                     layout_preset=request.layout_preset,
                     inline_chart_results=inline_chart_results,
                 )
+                portal_component_build_ms = _duration_ms(portal_component_build_started_at)
                 layout_diagnostics = _portal_layout_diagnostics(request.sections, component_payload, layout_metadata=layout_metadata)
                 update_payload["components"] = component_payload
+                portal_update_started_at = time.perf_counter()
                 self.portals.portal_update(profile=profile, dash_key=dash_key, payload=update_payload)
+                portal_update_ms = _duration_ms(portal_update_started_at)
                 write_executed = True
-            self.portals.portal_update_base_info(
-                profile=profile,
-                dash_key=dash_key,
-                payload={
-                    "dashName": update_payload.get("dashName"),
-                    "dashIcon": update_payload.get("dashIcon"),
-                    "auth": deepcopy(update_payload.get("auth")),
-                    "tags": deepcopy(update_payload.get("tags") or []),
-                },
-            )
-            write_executed = True
+            else:
+                portal_component_build_ms = 0
+                portal_update_ms = 0
+            base_info_update_requested = bool(
+                (not creating and not sections_requested)
+                or request.dash_name is not None
+                or request.icon is not None
+                or request.color is not None
+                or request.visibility is not None
+                or request.auth is not None
+                or request.package_tag_id is not None
+            )
+            if base_info_update_requested:
+                portal_base_info_update_started_at = time.perf_counter()
+                self.portals.portal_update_base_info(
+                    profile=profile,
+                    dash_key=dash_key,
+                    payload={
+                        "dashName": update_payload.get("dashName"),
+                        "dashIcon": update_payload.get("dashIcon"),
+                        "auth": deepcopy(update_payload.get("auth")),
+                        "tags": deepcopy(update_payload.get("tags") or []),
+                    },
+                )
+                portal_base_info_update_ms = _duration_ms(portal_base_info_update_started_at)
+                write_executed = True
+            else:
+                portal_base_info_update_ms = 0
             try:
+                portal_draft_readback_started_at = time.perf_counter()
                 draft_result = self.portals.portal_get(profile=profile, dash_key=dash_key, being_draft=True).get("result") or {}
             except (QingflowApiError, RuntimeError) as read_error:
+                portal_draft_readback_ms = _duration_ms(portal_draft_readback_started_at)
                 api_read_error = _coerce_api_error(read_error)
                 draft_readback_error = {
                     "phase": "portal_draft_readback",
                     "transport_error": _transport_error_payload(api_read_error),
                 }
                 draft_result = {}
+            else:
+                portal_draft_readback_ms = _duration_ms(portal_draft_readback_started_at)
         except (QingflowApiError, RuntimeError, ValueError) as error:
             api_error = _coerce_api_error(error) if not isinstance(error, ValueError) else None
             inline_chart_write_executed = any(bool(item.get("write_executed")) for item in inline_chart_results)
@@ -13313,9 +14286,12 @@ class AiBuilderFacade:
         publish_error: JSONObject | None = None
         if request.publish:
             try:
+                portal_publish_started_at = time.perf_counter()
                 self.portals.portal_publish(profile=profile, dash_key=dash_key)
+                portal_publish_ms = _duration_ms(portal_publish_started_at)
                 published = True
             except (QingflowApiError, RuntimeError) as error:
+                portal_publish_ms = _duration_ms(portal_publish_started_at)
                 api_error = _coerce_api_error(error)
                 publish_failed = True
                 publish_error = {
@@ -13324,13 +14300,20 @@ class AiBuilderFacade:
                 }
             if published:
                 try:
+                    portal_live_readback_started_at = time.perf_counter()
                     live_result = self.portals.portal_get(profile=profile, dash_key=dash_key, being_draft=False).get("result") or {}
                 except (QingflowApiError, RuntimeError) as read_error:
+                    portal_live_readback_ms = _duration_ms(portal_live_readback_started_at)
                     api_read_error = _coerce_api_error(read_error)
                     live_readback_error = {
                         "phase": "portal_live_readback",
                         "transport_error": _transport_error_payload(api_read_error),
                     }
+                else:
+                    portal_live_readback_ms = _duration_ms(portal_live_readback_started_at)
+        else:
+            portal_publish_ms = 0
+            portal_live_readback_ms = 0
 
         draft_components = draft_result.get("components") if isinstance(draft_result, dict) else None
         expected_count = len(request.sections) if sections_requested else None
@@ -13469,55 +14452,79 @@ class AiBuilderFacade:
         })
 
     def portal_delete(self, *, profile: str, dash_key: str) -> JSONObject:
+        apply_started_at = time.perf_counter()
+        portal_delete_ms = 0
+        portal_delete_readback_ms = 0
         normalized_args = {"dash_key": dash_key}
+
+        def finish(response: JSONObject) -> JSONObject:
+            _merge_duration_breakdown(
+                response,
+                portal_delete_ms=portal_delete_ms,
+                portal_delete_readback_ms=portal_delete_readback_ms,
+                total_ms=_duration_ms(apply_started_at),
+            )
+            return response
+
         dash_key = str(dash_key or "").strip()
         if not dash_key:
-            return _failed(
-                "PORTAL_DASH_KEY_REQUIRED",
-                "dash_key is required when deleting a portal",
-                normalized_args=normalized_args,
-                missing_fields=["dash_key"],
-                suggested_next_call={"tool_name": "portal_delete", "arguments": {"profile": profile, "dash_key": "DASH_KEY"}},
+            return finish(
+                _failed(
+                    "PORTAL_DASH_KEY_REQUIRED",
+                    "dash_key is required when deleting a portal",
+                    normalized_args=normalized_args,
+                    missing_fields=["dash_key"],
+                    suggested_next_call={"tool_name": "portal_delete", "arguments": {"profile": profile, "dash_key": "DASH_KEY"}},
+                )
             )
+        portal_delete_started_at = time.perf_counter()
         try:
             self.portals.portal_delete(profile=profile, dash_key=dash_key)
         except (QingflowApiError, RuntimeError) as error:
+            portal_delete_ms += _duration_ms(portal_delete_started_at)
             api_error = _coerce_api_error(error)
-            return _failed_from_api_error(
-                "PORTAL_DELETE_FAILED",
-                api_error,
-                normalized_args=normalized_args,
-                details={"dash_key": dash_key},
-                suggested_next_call={"tool_name": "portal_delete", "arguments": {"profile": profile, **normalized_args}},
+            return finish(
+                _failed_from_api_error(
+                    "PORTAL_DELETE_FAILED",
+                    api_error,
+                    normalized_args=normalized_args,
+                    details={"dash_key": dash_key},
+                    suggested_next_call={"tool_name": "portal_delete", "arguments": {"profile": profile, **normalized_args}},
+                )
             )
+        portal_delete_ms += _duration_ms(portal_delete_started_at)
 
+        portal_delete_readback_started_at = time.perf_counter()
         delete_readback = self._verify_portal_deleted_by_key(profile=profile, dash_key=dash_key)
+        portal_delete_readback_ms += _duration_ms(portal_delete_readback_started_at)
         verified = delete_readback.get("readback_status") == "deleted"
-        return {
-            "status": "success" if verified else "partial_success",
-            "error_code": None if verified else delete_readback.get("error_code") or "PORTAL_DELETE_READBACK_PENDING",
-            "recoverable": not verified,
-            "message": "deleted portal" if verified else "portal delete completed; readback pending",
-            "normalized_args": normalized_args,
-            "missing_fields": [],
-            "allowed_values": {},
-            "details": {} if verified else {"delete_readback": delete_readback},
-            "request_id": delete_readback.get("request_id"),
-            "backend_code": delete_readback.get("backend_code"),
-            "http_status": delete_readback.get("http_status"),
-            "suggested_next_call": None if verified else {"tool_name": "portal_get", "arguments": {"profile": profile, "dash_key": dash_key}},
-            "noop": False,
-            "warnings": [] if verified else [_warning("PORTAL_DELETE_READBACK_PENDING", "portal delete was sent, but deletion readback is not fully verified")],
-            "verification": {"portal_deleted": verified, "delete_readback": delete_readback},
-            "verified": verified,
-            "dash_key": dash_key,
-            "deleted": verified,
-            "delete_executed": True,
-            "readback_status": delete_readback.get("readback_status"),
-            "safe_to_retry_delete": False,
-            "write_executed": True,
-            "safe_to_retry": False,
-        }
+        return finish(
+            {
+                "status": "success" if verified else "partial_success",
+                "error_code": None if verified else delete_readback.get("error_code") or "PORTAL_DELETE_READBACK_PENDING",
+                "recoverable": not verified,
+                "message": "deleted portal" if verified else "portal delete completed; readback pending",
+                "normalized_args": normalized_args,
+                "missing_fields": [],
+                "allowed_values": {},
+                "details": {} if verified else {"delete_readback": delete_readback},
+                "request_id": delete_readback.get("request_id"),
+                "backend_code": delete_readback.get("backend_code"),
+                "http_status": delete_readback.get("http_status"),
+                "suggested_next_call": None if verified else {"tool_name": "portal_get", "arguments": {"profile": profile, "dash_key": dash_key}},
+                "noop": False,
+                "warnings": [] if verified else [_warning("PORTAL_DELETE_READBACK_PENDING", "portal delete was sent, but deletion readback is not fully verified")],
+                "verification": {"portal_deleted": verified, "delete_readback": delete_readback},
+                "verified": verified,
+                "dash_key": dash_key,
+                "deleted": verified,
+                "delete_executed": True,
+                "readback_status": delete_readback.get("readback_status"),
+                "safe_to_retry_delete": False,
+                "write_executed": True,
+                "safe_to_retry": False,
+            }
+        )
 
     def _verify_portal_deleted_by_key(self, *, profile: str, dash_key: str) -> JSONObject:
         try:
@@ -13920,36 +14927,30 @@ class AiBuilderFacade:
         app_key: str,
         app_name: str,
         package_tag_id: int | None,
-        create_if_missing: bool,
     ) -> JSONObject:
         if app_key:
             return self.app_resolve(profile=profile, app_key=app_key)
         if app_name:
-            resolved = self.app_resolve(profile=profile, app_name=app_name, package_tag_id=package_tag_id)
-            if resolved.get("status") == "success":
-                return resolved
-            if not create_if_missing:
-                return resolved
-        elif not create_if_missing:
+            return {
+                "status": "success",
+                "error_code": None,
+                "recoverable": False,
+                "message": "target app would be created",
+                "normalized_args": {},
+                "missing_fields": [],
+                "allowed_values": {},
+                "details": {},
+                "request_id": None,
+                "suggested_next_call": None,
+                "noop": False,
+                "verification": {},
+                "app_key": "",
+                "app_name": app_name,
+                "tag_ids": [package_tag_id] if package_tag_id else [],
+                "would_create": True,
+            }
+        else:
             return _failed("APP_NAME_REQUIRED", "app_name or app_key is required", suggested_next_call=None)
-        return {
-            "status": "success",
-            "error_code": None,
-            "recoverable": False,
-            "message": "target app would be created",
-            "normalized_args": {},
-            "missing_fields": [],
-            "allowed_values": {},
-            "details": {},
-            "request_id": None,
-            "suggested_next_call": None,
-            "noop": False,
-            "verification": {},
-            "app_key": "",
-            "app_name": app_name or "未命名应用",
-            "tag_ids": [package_tag_id] if package_tag_id else [],
-            "would_create": True,
-        }
 
     def _create_target_app_shell(
         self,
@@ -14018,7 +15019,7 @@ class AiBuilderFacade:
         if not new_app_key:
             return _failed("APP_CREATE_FAILED", "failed to create app shell", details={"result": result}, suggested_next_call=None)
         try:
-            base = self.apps.app_get_base(profile=profile, app_key=new_app_key, include_raw=True).get("result") or {}
+            base = self._read_app_base_raw_direct(profile=profile, app_key=new_app_key)
         except (QingflowApiError, RuntimeError) as error:
             api_error = _coerce_api_error(error)
             if api_error.http_status != 404:
@@ -14211,12 +15212,104 @@ class AiBuilderFacade:
         resolved_components: list[dict[str, Any]] = []
         layout_metadata: list[dict[str, Any]] = []
         inline_chart_results = inline_chart_results if inline_chart_results is not None else []
+        inline_chart_resolutions: dict[int, dict[str, Any]] = {}
+        inline_chart_result_by_section: dict[int, dict[str, Any]] = {}
+        inline_chart_failures: list[str] = []
+        inline_chart_batches: dict[str, list[tuple[int, PortalSectionPatch, ChartUpsertPatch]]] = {}
+        for section_index, section in enumerate(sections):
+            if section.source_type != "chart" or section.chart is None:
+                continue
+            inline_chart_payload = section.chart.model_dump(mode="json", exclude={"app_key"})
+            inline_chart_batches.setdefault(section.chart.app_key, []).append(
+                (section_index, section, ChartUpsertPatch.model_validate(inline_chart_payload))
+            )
+        for app_key, batch_entries in inline_chart_batches.items():
+            chart_request = ChartApplyRequest(
+                app_key=app_key,
+                upsert_charts=[patch for _, _, patch in batch_entries],
+                patch_charts=[],
+                remove_chart_ids=[],
+                reorder_chart_ids=[],
+            )
+            chart_apply = self.chart_apply(profile=profile, request=chart_request)
+            chart_items = chart_apply.get("chart_results") if isinstance(chart_apply.get("chart_results"), list) else []
+            matched_chart_item_indexes: set[int] = set()
+            for batch_index, (section_index, section, patch) in enumerate(batch_entries):
+                result_item: dict[str, Any] | None = None
+                if (
+                    batch_index < len(chart_items)
+                    and batch_index not in matched_chart_item_indexes
+                    and isinstance(chart_items[batch_index], dict)
+                    and str(chart_items[batch_index].get("name") or "").strip() == patch.name
+                ):
+                    result_item = chart_items[batch_index]
+                    matched_chart_item_indexes.add(batch_index)
+                if result_item is None:
+                    for item_index, item in enumerate(chart_items):
+                        if item_index in matched_chart_item_indexes or not isinstance(item, dict):
+                            continue
+                        if str(item.get("name") or "").strip() == patch.name:
+                            result_item = item
+                            matched_chart_item_indexes.add(item_index)
+                            break
+                if (
+                    result_item is None
+                    and batch_index < len(chart_items)
+                    and batch_index not in matched_chart_item_indexes
+                    and isinstance(chart_items[batch_index], dict)
+                ):
+                    result_item = chart_items[batch_index]
+                    matched_chart_item_indexes.add(batch_index)
+                successful_chart = (
+                    result_item
+                    if isinstance(result_item, dict)
+                    and str(result_item.get("status") or "") in {"created", "updated"}
+                    and str(result_item.get("chart_id") or "").strip()
+                    else None
+                )
+                inline_chart_result_by_section[section_index] = {
+                    "title": section.title,
+                    "app_key": app_key,
+                    "chart_name": section.chart.name,
+                    "chart_type": section.chart.chart_type.value,
+                    "status": str(successful_chart.get("status") or "") if isinstance(successful_chart, dict) else "failed",
+                    "chart_id": str(successful_chart.get("chart_id") or "") if isinstance(successful_chart, dict) else "",
+                    "chart_apply_status": chart_apply.get("status"),
+                    "write_executed": bool(chart_apply.get("write_executed")),
+                    "batch_size": len(batch_entries),
+                    "batch_index": batch_index,
+                    **(
+                        {"duration_breakdown_ms": deepcopy(chart_apply.get("duration_breakdown_ms"))}
+                        if isinstance(chart_apply.get("duration_breakdown_ms"), dict)
+                        else {}
+                    ),
+                    **({"error_code": chart_apply.get("error_code")} if chart_apply.get("error_code") else {}),
+                    **({"message": chart_apply.get("message")} if chart_apply.get("message") else {}),
+                }
+                if not isinstance(successful_chart, dict):
+                    inline_chart_failures.append(
+                        f"inline chart '{section.chart.name}' could not be created or updated for portal section '{section.title}'"
+                    )
+                    continue
+                inline_chart_resolutions[section_index] = {
+                    "chart_id": str(successful_chart.get("chart_id") or "").strip(),
+                    "chart_name": str(successful_chart.get("name") or section.chart.name).strip(),
+                    "app_key": app_key,
+                    "chart_type": section.chart.chart_type.value,
+                }
+        if inline_chart_result_by_section:
+            inline_chart_results.extend(
+                deepcopy(inline_chart_result_by_section[section_index])
+                for section_index in sorted(inline_chart_result_by_section)
+            )
+        if inline_chart_failures:
+            raise ValueError(inline_chart_failures[0])
         pc_x = 0
         pc_y = 0
         pc_row_height = 0
         mobile_y = 0
         app_title_cache: dict[str, str] = {}
-        for section in sections:
+        for section_index, section in enumerate(sections):
             position_payload: dict[str, Any]
             if section.position is None:
                 position_payload, pc_x, pc_y, pc_row_height, mobile_y = _portal_component_position_public(
@@ -14238,46 +15331,9 @@ class AiBuilderFacade:
             component: dict[str, Any]
             if section.source_type == "chart":
                 if section.chart is not None:
-                    inline_chart_payload = section.chart.model_dump(mode="json", exclude={"app_key"})
-                    chart_request = ChartApplyRequest(
-                        app_key=section.chart.app_key,
-                        upsert_charts=[ChartUpsertPatch.model_validate(inline_chart_payload)],
-                        patch_charts=[],
-                        remove_chart_ids=[],
-                        reorder_chart_ids=[],
-                    )
-                    chart_apply = self.chart_apply(profile=profile, request=chart_request)
-                    chart_items = chart_apply.get("chart_results") if isinstance(chart_apply.get("chart_results"), list) else []
-                    successful_chart = next(
-                        (
-                            item
-                            for item in chart_items
-                            if isinstance(item, dict)
-                            and str(item.get("status") or "") in {"created", "updated"}
-                            and str(item.get("chart_id") or "").strip()
-                        ),
-                        None,
-                    )
-                    inline_chart_results.append({
-                        "title": section.title,
-                        "app_key": section.chart.app_key,
-                        "chart_name": section.chart.name,
-                        "chart_type": section.chart.chart_type.value,
-                        "status": str(successful_chart.get("status") or "") if isinstance(successful_chart, dict) else "failed",
-                        "chart_id": str(successful_chart.get("chart_id") or "") if isinstance(successful_chart, dict) else "",
-                        "chart_apply_status": chart_apply.get("status"),
-                        "write_executed": bool(chart_apply.get("write_executed")),
-                        **({"error_code": chart_apply.get("error_code")} if chart_apply.get("error_code") else {}),
-                        **({"message": chart_apply.get("message")} if chart_apply.get("message") else {}),
-                    })
-                    if not isinstance(successful_chart, dict):
+                    resolved_chart = inline_chart_resolutions.get(section_index)
+                    if not isinstance(resolved_chart, dict):
                         raise ValueError(f"inline chart '{section.chart.name}' could not be created or updated for portal section '{section.title}'")
-                    resolved_chart = {
-                        "chart_id": str(successful_chart.get("chart_id") or "").strip(),
-                        "chart_name": str(successful_chart.get("name") or section.chart.name).strip(),
-                        "app_key": section.chart.app_key,
-                        "chart_type": section.chart.chart_type.value,
-                    }
                 else:
                     resolved_chart = _resolve_chart_reference(
                         charts=self.charts,
@@ -18907,7 +19963,11 @@ def _verify_relation_readback_by_name(
             for item in cast(list[Any], actual.get("visible_fields") or [])
             if isinstance(item, dict) and str(item.get("name") or "").strip()
         ]
-        if expected_visible_names != actual_visible_names:
+        if not _relation_visible_field_names_match(
+            expected_visible_names=expected_visible_names,
+            actual_visible_names=actual_visible_names,
+            display_field_name=expected_display_name,
+        ):
             return False
     return True
 
@@ -18925,6 +19985,36 @@ def _relation_field_names(values: object) -> list[str]:
     return names
 
 
+def _relation_visible_field_names_match(
+    *,
+    expected_visible_names: list[str],
+    actual_visible_names: list[str],
+    display_field_name: str | None = None,
+) -> bool:
+    if expected_visible_names == actual_visible_names:
+        return True
+
+    def dedupe(values: list[str]) -> list[str]:
+        result: list[str] = []
+        for value in values:
+            normalized = str(value or "").strip()
+            if normalized and normalized not in result:
+                result.append(normalized)
+        return result
+
+    expected = dedupe(expected_visible_names)
+    actual = dedupe(actual_visible_names)
+    if expected == actual:
+        return True
+    if set(expected) != set(actual):
+        return False
+    display = str(display_field_name or "").strip()
+    if display and actual and actual[0] == display and display in expected:
+        expected_display_first = [display, *[name for name in expected if name != display]]
+        return actual == expected_display_first
+    return False
+
+
 def _relation_field_public_selector(value: object) -> dict[str, Any] | None:
     if not isinstance(value, dict):
         return None
@@ -18983,13 +20073,18 @@ def _schema_relation_readback_matrix(
         actual_display = _relation_field_public_selector((actual or {}).get("display_field"))
         expected_visible_names = _relation_field_names((expected or degraded or {}).get("visible_fields"))
         actual_visible_names = _relation_field_names((actual or {}).get("visible_fields"))
+        display_name = str((expected_display or {}).get("name") or "").strip() or None
 
         checks = {
             "field_exists": isinstance(actual, dict),
             "target_app_key": expected_target == actual_target,
             "relation_mode": expected_mode == actual_mode,
             "display_field": (expected_display or {}).get("name") == (actual_display or {}).get("name"),
-            "visible_fields": expected_visible_names == actual_visible_names,
+            "visible_fields": _relation_visible_field_names_match(
+                expected_visible_names=expected_visible_names,
+                actual_visible_names=actual_visible_names,
+                display_field_name=display_name,
+            ),
         }
         readback_verified = all(checks.values())
         if not isinstance(actual, dict):
@@ -23802,8 +24897,8 @@ def _build_form_payload_for_edit_fields(
         parsed_section_id = _coerce_positive_int(section.get("section_id"))
         if parsed_section_id is not None:
             wrapper["sectionId"] = parsed_section_id
-        elif template is None and section.get("section_id") is not None:
-            wrapper["sectionId"] = section.get("section_id")
+        elif template is None and _coerce_positive_int(wrapper.get("sectionId")) is None:
+            wrapper.pop("sectionId", None)
         wrapper["innerQuestions"] = inner_rows
         form_rows.append([wrapper])
 
@@ -27678,7 +28773,6 @@ def _normalize_flow_stage_failure(stage: JSONObject, *, profile: str, app_key: s
                 "arguments": {
                     "profile": profile,
                     "app_key": app_key,
-                    "create_if_missing": False,
                     "add_fields": [
                         {
                             "name": "状态",