@josephyan/qingflow-cli 0.2.0-beta.63 → 0.2.0-beta.64

package/README.md

@@ -3,13 +3,13 @@
 Install:
 
 ```bash
-npm install @josephyan/qingflow-cli@0.2.0-beta.63
+npm install @josephyan/qingflow-cli@0.2.0-beta.64
 ```
 
 Run:
 
 ```bash
-npx -y -p @josephyan/qingflow-cli@0.2.0-beta.63 qingflow
+npx -y -p @josephyan/qingflow-cli@0.2.0-beta.64 qingflow
 ```
 
 Environment:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@josephyan/qingflow-cli",
-  "version": "0.2.0-beta.63",
+  "version": "0.2.0-beta.64",
   "description": "Human-friendly Qingflow command line interface for auth, record operations, import, tasks, and stable builder flows.",
   "license": "MIT",
   "type": "module",

package/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "qingflow-mcp"
-version = "0.2.0b63"
+version = "0.2.0b64"
 description = "User-authenticated MCP server for Qingflow"
 readme = "README.md"
 license = "MIT"

package/src/qingflow_mcp/builder_facade/service.py

@@ -1406,6 +1406,15 @@ class AiBuilderFacade:
         def finalize(response: JSONObject) -> JSONObject:
             return _apply_permission_outcomes(response, *permission_outcomes)
 
+        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_CREATE_FAILED",
+        )
+        if edit_context_error is not None:
+            return finalize(edit_context_error)
+
         create_result = self.buttons.custom_button_create(
             profile=profile,
             app_key=app_key,
@@ -1419,7 +1428,7 @@ class AiBuilderFacade:
                     "CUSTOM_BUTTON_CREATE_FAILED",
                     "custom button create succeeded but no button_id was returned",
                     normalized_args=normalized_args,
-                    details={"app_key": app_key, "result": deepcopy(raw_result)},
+                    details={"app_key": app_key, "result": deepcopy(raw_result), "edit_version_no": edit_version_no},
                     suggested_next_call={"tool_name": "app_custom_button_list", "arguments": {"profile": profile, "app_key": app_key}},
                 )
             )
@@ -1444,6 +1453,7 @@ class AiBuilderFacade:
                 "details": {
                     "app_key": app_key,
                     "button_id": button_id,
+                    "edit_version_no": edit_version_no,
                     "transport_error": _transport_error_payload(api_error),
                 },
                 "request_id": api_error.request_id,
@@ -1487,6 +1497,7 @@ class AiBuilderFacade:
                 "verified": True,
                 "app_key": app_key,
                 "button_id": button_id,
+                "edit_version_no": edit_version_no,
                 "button": button,
             }
         )
@@ -1514,6 +1525,15 @@ class AiBuilderFacade:
         def finalize(response: JSONObject) -> JSONObject:
             return _apply_permission_outcomes(response, *permission_outcomes)
 
+        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_UPDATE_FAILED",
+        )
+        if edit_context_error is not None:
+            return finalize(edit_context_error)
+
         self.buttons.custom_button_update(
             profile=profile,
             app_key=app_key,
@@ -1541,6 +1561,7 @@ class AiBuilderFacade:
                 "details": {
                     "app_key": app_key,
                     "button_id": button_id,
+                    "edit_version_no": edit_version_no,
                     "transport_error": _transport_error_payload(api_error),
                 },
                 "request_id": api_error.request_id,
@@ -1584,6 +1605,7 @@ class AiBuilderFacade:
                 "verified": True,
                 "app_key": app_key,
                 "button_id": button_id,
+                "edit_version_no": edit_version_no,
                 "button": button,
             }
         )
@@ -2567,7 +2589,17 @@ class AiBuilderFacade:
             upsert_views = _build_views_preset(request.preset, list(field_names))
         blocking_issues: list[dict[str, Any]] = []
         for patch in upsert_views:
-            columns = patch.get("columns") or []
+            raw_columns = [str(name or "").strip() for name in (patch.get("columns") or []) if str(name or "").strip()]
+            columns = _filter_known_system_view_columns(raw_columns)
+            if patch.get("type") in {"table", "card"} and raw_columns and not columns:
+                blocking_issues.append(
+                    {
+                        "error_code": "VALIDATION_ERROR",
+                        "view_name": patch.get("name"),
+                        "message": "view columns must include at least one real app field; system columns cannot be applied directly",
+                        "ignored_system_columns": [name for name in raw_columns if name in _KNOWN_SYSTEM_VIEW_COLUMNS],
+                    }
+                )
             missing_columns = [name for name in columns if name not in field_names]
             if missing_columns:
                 blocking_issues.append({"error_code": "UNKNOWN_VIEW_FIELD", "view_name": patch.get("name"), "missing_fields": missing_columns})
@@ -3644,6 +3676,7 @@ class AiBuilderFacade:
             for patch in upsert_views
         )
         valid_custom_button_ids: set[int] = set()
+        custom_button_details_by_id: dict[int, dict[str, Any]] = {}
         if requires_custom_button_validation:
             try:
                 button_listing = self.buttons.custom_button_list(
@@ -3668,6 +3701,26 @@ class AiBuilderFacade:
                 for item in (button_listing.get("items") or [])
                 if isinstance(item, dict) and (button_id := _coerce_positive_int(item.get("button_id"))) is not None
             }
+            referenced_custom_button_ids = {
+                binding.button_id
+                for patch in upsert_views
+                for binding in (patch.buttons or [])
+                if binding.button_type == PublicViewButtonType.custom and binding.button_id in valid_custom_button_ids
+            }
+            for button_id in sorted(referenced_custom_button_ids):
+                try:
+                    detail = self.buttons.custom_button_get(
+                        profile=profile,
+                        app_key=app_key,
+                        button_id=button_id,
+                        being_draft=True,
+                        include_raw=False,
+                    )
+                except (QingflowApiError, RuntimeError):
+                    continue
+                detail_result = detail.get("result")
+                if isinstance(detail_result, dict):
+                    custom_button_details_by_id[button_id] = _normalize_custom_button_detail(detail_result)
         removed: list[str] = []
         view_results: list[dict[str, Any]] = []
         for name in remove_views:
@@ -3704,7 +3757,24 @@ class AiBuilderFacade:
             and _extract_view_name(view) not in remove_views
         ]
         for ordinal, patch in enumerate(upsert_views, start=1):
-            missing_columns = [name for name in patch.columns if name not in field_names]
+            apply_columns = _resolve_view_visible_field_names(patch)
+            ignored_system_columns = [
+                name
+                for name in [str(value or "").strip() for value in patch.columns]
+                if name in _KNOWN_SYSTEM_VIEW_COLUMNS
+            ]
+            if patch.type in {PublicViewType.table, PublicViewType.card} and patch.columns and not apply_columns:
+                return _failed(
+                    "VALIDATION_ERROR",
+                    "view columns must include at least one real app field; system columns cannot be applied directly",
+                    normalized_args=normalized_args,
+                    details={
+                        "app_key": app_key,
+                        "view_name": patch.name,
+                        "ignored_system_columns": ignored_system_columns,
+                    },
+                )
+            missing_columns = [name for name in apply_columns if name not in field_names]
             if missing_columns:
                 return _failed(
                     "UNKNOWN_VIEW_FIELD",
@@ -3714,6 +3784,7 @@ class AiBuilderFacade:
                         "app_key": app_key,
                         "view_name": patch.name,
                         "missing_fields": missing_columns,
+                        "ignored_system_columns": ignored_system_columns,
                     },
                     missing_fields=missing_columns,
                     suggested_next_call={"tool_name": "app_read_fields", "arguments": {"profile": profile, "app_key": app_key}},
@@ -3784,7 +3855,10 @@ class AiBuilderFacade:
                         allowed_values=first_issue.get("allowed_values") or {"view_types": [member.value for member in PublicViewType], "view.filter.operator": [member.value for member in ViewFilterOperator]},
                         suggested_next_call={"tool_name": "app_custom_button_list", "arguments": {"profile": profile, "app_key": app_key}},
                     )
-                expected_button_summary = _normalize_view_buttons_for_compare(explicit_button_dtos or [])
+                expected_button_summary = _normalize_expected_view_buttons_for_compare(
+                    explicit_button_dtos or [],
+                    custom_button_details_by_id=custom_button_details_by_id,
+                )
             matched_existing_view: dict[str, Any] | None = None
             existing_key: str | None = None
             if patch.view_key:
@@ -3837,12 +3911,14 @@ class AiBuilderFacade:
                     system_view_sync: dict[str, Any] | None = None
                     if system_view_list_type is not None and patch.type.value == "table":
                         operation_phase = "default_view_apply_config_sync"
-                        system_view_sync = self._sync_system_view_apply_config(
+                        system_view_sync = self._sync_system_view_and_restore_buttons(
                             profile=profile,
                             app_key=app_key,
+                            viewgraph_key=existing_key,
+                            payload=payload,
                             list_type=system_view_list_type,
                             schema=schema,
-                            visible_field_names=patch.columns,
+                            visible_field_names=apply_columns,
                         )
                         if not bool(system_view_sync.get("verified")):
                             failure_entry = {
@@ -3864,6 +3940,7 @@ class AiBuilderFacade:
                                     "list_type": system_view_list_type,
                                     "expected_visible_order": system_view_sync.get("expected_visible_order"),
                                     "actual_visible_order": system_view_sync.get("actual_visible_order"),
+                                    "apply_columns": apply_columns,
                                 },
                             }
                             failed_views.append(failure_entry)
@@ -3879,6 +3956,7 @@ class AiBuilderFacade:
                                 "expected_filters": deepcopy(translated_filters),
                                 "expected_buttons": deepcopy(expected_button_summary),
                                 "system_view_sync": system_view_sync,
+                                "apply_columns": deepcopy(apply_columns),
                             }
                         )
                 else:
@@ -3956,6 +4034,49 @@ class AiBuilderFacade:
                                 explicit_button_dtos=fallback_button_dtos,
                             )
                             self.views.view_update(profile=profile, viewgraph_key=target_key, payload=fallback_payload)
+                            system_view_sync: dict[str, Any] | None = None
+                            fallback_system_view_list_type = (
+                                _resolve_system_view_list_type(view_key=target_key, view_name=patch.name)
+                                if patch.type.value == "table" and target_key
+                                else None
+                            )
+                            if fallback_system_view_list_type is not None:
+                                operation_phase = "default_view_apply_config_sync"
+                                system_view_sync = self._sync_system_view_and_restore_buttons(
+                                    profile=profile,
+                                    app_key=app_key,
+                                    viewgraph_key=target_key,
+                                    payload=fallback_payload,
+                                    list_type=fallback_system_view_list_type,
+                                    schema=schema,
+                                    visible_field_names=apply_columns,
+                                )
+                                if not bool(system_view_sync.get("verified")):
+                                    failure_entry = {
+                                        "name": patch.name,
+                                        "view_key": target_key,
+                                        "type": patch.type.value,
+                                        "status": "failed",
+                                        "error_code": "SYSTEM_VIEW_ORDER_SYNC_FAILED",
+                                        "message": "default view column order did not verify through app apply/baseInfo readback",
+                                        "request_id": None,
+                                        "backend_code": None,
+                                        "http_status": None,
+                                        "operation": "sync_default_view",
+                                        "details": {
+                                            "app_key": app_key,
+                                            "view_name": patch.name,
+                                            "view_key": target_key,
+                                            "view_type": patch.type.value,
+                                            "list_type": fallback_system_view_list_type,
+                                            "expected_visible_order": system_view_sync.get("expected_visible_order"),
+                                            "actual_visible_order": system_view_sync.get("actual_visible_order"),
+                                            "apply_columns": apply_columns,
+                                        },
+                                    }
+                                    failed_views.append(failure_entry)
+                                    view_results.append(failure_entry)
+                                    continue
                             if existing_key:
                                 updated.append(patch.name)
                                 view_results.append(
@@ -3967,6 +4088,8 @@ class AiBuilderFacade:
                                         "fallback_applied": True,
                                         "expected_filters": deepcopy(translated_filters),
                                         "expected_buttons": deepcopy(expected_button_summary),
+                                        "system_view_sync": system_view_sync,
+                                        "apply_columns": deepcopy(apply_columns),
                                     }
                                 )
                             else:
@@ -3980,6 +4103,8 @@ class AiBuilderFacade:
                                         "fallback_applied": True,
                                         "expected_filters": deepcopy(translated_filters),
                                         "expected_buttons": deepcopy(expected_button_summary),
+                                        "system_view_sync": system_view_sync,
+                                        "apply_columns": deepcopy(apply_columns),
                                     }
                                 )
                             continue
@@ -4079,6 +4204,8 @@ class AiBuilderFacade:
         filter_mismatches: list[dict[str, Any]] = []
         button_readback_pending = False
         button_mismatches: list[dict[str, Any]] = []
+        custom_button_readback_pending = False
+        custom_button_readback_pending_entries: list[dict[str, Any]] = []
         for item in view_results:
             status = str(item.get("status") or "")
             name = str(item.get("name") or "")
@@ -4181,12 +4308,28 @@ class AiBuilderFacade:
                             config_response = self.views.view_get_config(profile=profile, viewgraph_key=verification_key)
                             config_result = (config_response.get("result") or {}) if isinstance(config_response.get("result"), dict) else {}
                             actual_buttons = _normalize_view_buttons_for_compare(config_result)
-                            buttons_verified = actual_buttons == expected_buttons
+                            button_comparison = _compare_view_button_summaries(
+                                expected=expected_buttons,
+                                actual=actual_buttons,
+                            )
+                            buttons_verified = bool(button_comparison.get("verified"))
                             verification_entry["buttons_verified"] = buttons_verified
                             verification_entry["view_key"] = verification_key
                             verification_entry["expected_buttons"] = deepcopy(expected_buttons)
                             verification_entry["actual_buttons"] = actual_buttons
-                            if not buttons_verified:
+                            if button_comparison.get("custom_button_readback_pending"):
+                                verification_entry["custom_button_readback_pending"] = True
+                                verification_entry["pending_custom_buttons"] = deepcopy(button_comparison.get("pending_custom_buttons") or [])
+                                custom_button_readback_pending = True
+                                custom_button_readback_pending_entries.append(
+                                    {
+                                        "name": name,
+                                        "type": item.get("type"),
+                                        "view_key": verification_key,
+                                        "pending_custom_buttons": deepcopy(button_comparison.get("pending_custom_buttons") or []),
+                                    }
+                                )
+                            elif not buttons_verified:
                                 button_mismatches.append(
                                     {
                                         "name": name,
@@ -4249,6 +4392,11 @@ class AiBuilderFacade:
                     "per_view_results": view_results,
                     "filter_mismatches": filter_mismatches,
                     "button_mismatches": button_mismatches,
+                    **(
+                        {"custom_button_readback_pending": deepcopy(custom_button_readback_pending_entries)}
+                        if custom_button_readback_pending_entries
+                        else {}
+                    ),
                 },
                 "request_id": first_failure.get("request_id"),
                 "suggested_next_call": {"tool_name": "app_read_views_summary", "arguments": {"profile": profile, "app_key": app_key}},
@@ -4256,10 +4404,21 @@ class AiBuilderFacade:
                 "http_status": first_failure.get("http_status"),
                 "noop": noop,
                 "warnings": (
-                    [_warning("VIEW_FILTERS_UNVERIFIED", "view definitions may exist, but saved filter behavior is not fully verified")] if (filter_readback_pending or filter_mismatches) else []
-                )
-                + (
-                    [_warning("VIEW_BUTTONS_UNVERIFIED", "view definitions may exist, but saved button behavior is not fully verified")] if (button_readback_pending or button_mismatches) else []
+                    (
+                        [_warning("VIEW_FILTERS_UNVERIFIED", "view definitions may exist, but saved filter behavior is not fully verified")]
+                        if (filter_readback_pending or filter_mismatches)
+                        else []
+                    )
+                    + (
+                        [_warning("VIEW_BUTTONS_UNVERIFIED", "view definitions may exist, but saved button behavior is not fully verified")]
+                        if (button_readback_pending or button_mismatches)
+                        else []
+                    )
+                    + (
+                        [_warning("VIEW_CUSTOM_BUTTON_READBACK_PENDING", "system buttons verified, but draft custom button bindings are not fully visible through view readback yet")]
+                        if custom_button_readback_pending
+                        else []
+                    )
                 ),
                 "verification": {
                     "views_verified": verified,
@@ -4267,6 +4426,8 @@ class AiBuilderFacade:
                     "view_buttons_verified": view_buttons_verified,
                     "views_read_unavailable": verified_views_unavailable,
                     "by_view": verification_by_view,
+                    "custom_button_readback_pending": custom_button_readback_pending,
+                    "custom_button_readback_pending_entries": deepcopy(custom_button_readback_pending_entries),
                 },
                 "app_key": app_key,
                 "views_diff": {"created": created, "updated": updated, "removed": removed, "failed": failed_views},
@@ -4278,6 +4439,13 @@ class AiBuilderFacade:
             warnings.append(_warning("VIEW_FILTERS_UNVERIFIED", "view definitions were applied, but saved filter behavior is not fully verified"))
         if button_readback_pending or button_mismatches:
             warnings.append(_warning("VIEW_BUTTONS_UNVERIFIED", "view definitions were applied, but saved button behavior is not fully verified"))
+        if custom_button_readback_pending:
+            warnings.append(
+                _warning(
+                    "VIEW_CUSTOM_BUTTON_READBACK_PENDING",
+                    "system buttons verified, but draft custom button bindings are not fully visible through view readback yet",
+                )
+            )
         response = {
             "status": "success" if verified and view_filters_verified and view_buttons_verified else "partial_success",
             "error_code": None if verified and view_filters_verified and view_buttons_verified else ("VIEW_BUTTON_READBACK_MISMATCH" if button_mismatches else "VIEW_FILTER_READBACK_MISMATCH" if filter_mismatches else "VIEWS_READBACK_PENDING"),
@@ -4297,6 +4465,11 @@ class AiBuilderFacade:
             "details": {
                 **({"filter_mismatches": filter_mismatches} if filter_mismatches else {}),
                 **({"button_mismatches": button_mismatches} if button_mismatches else {}),
+                **(
+                    {"custom_button_readback_pending": deepcopy(custom_button_readback_pending_entries)}
+                    if custom_button_readback_pending_entries
+                    else {}
+                ),
             },
             "request_id": None,
             "suggested_next_call": None if verified and view_filters_verified and view_buttons_verified else {"tool_name": "app_read_views_summary", "arguments": {"profile": profile, "app_key": app_key}},
@@ -4309,6 +4482,8 @@ class AiBuilderFacade:
                 "views_read_unavailable": verified_views_unavailable,
                 "filter_readback_pending": filter_readback_pending,
                 "button_readback_pending": button_readback_pending,
+                "custom_button_readback_pending": custom_button_readback_pending,
+                "custom_button_readback_pending_entries": deepcopy(custom_button_readback_pending_entries),
                 "by_view": verification_by_view,
             },
             "app_key": app_key,
@@ -5055,6 +5230,28 @@ class AiBuilderFacade:
             version_result = {}
         return _coerce_positive_int(version_result.get("editVersionNo") or version_result.get("versionNo")) or int(current_schema.get("editVersionNo") or 1)
 
+    def _ensure_app_edit_context(
+        self,
+        *,
+        profile: str,
+        app_key: str,
+        normalized_args: dict[str, Any],
+        failure_code: str,
+    ) -> tuple[int | None, JSONObject | None]:
+        try:
+            version_result = self.apps.app_get_edit_version_no(profile=profile, app_key=app_key).get("result") or {}
+        except (QingflowApiError, RuntimeError) as error:
+            api_error = _coerce_api_error(error)
+            return None, _failed_from_api_error(
+                failure_code,
+                api_error,
+                normalized_args=normalized_args,
+                details={"app_key": app_key, "phase": "prepare_edit_context"},
+                suggested_next_call={"tool_name": "app_read_summary", "arguments": {"profile": profile, "app_key": app_key}},
+            )
+        edit_version_no = _coerce_positive_int(version_result.get("editVersionNo") or version_result.get("versionNo")) or 1
+        return edit_version_no, None
+
     def _append_publish_result(self, *, profile: str, app_key: str, publish: bool, response: JSONObject) -> JSONObject:
         verification = response.get("verification")
         if not isinstance(verification, dict):
@@ -5134,6 +5331,29 @@ class AiBuilderFacade:
             "verified": verified,
         }
 
+    def _sync_system_view_and_restore_buttons(
+        self,
+        *,
+        profile: str,
+        app_key: str,
+        viewgraph_key: str,
+        payload: dict[str, Any],
+        list_type: int,
+        schema: dict[str, Any],
+        visible_field_names: list[str],
+    ) -> dict[str, Any]:
+        sync_result = self._sync_system_view_apply_config(
+            profile=profile,
+            app_key=app_key,
+            list_type=list_type,
+            schema=schema,
+            visible_field_names=visible_field_names,
+        )
+        if bool(sync_result.get("verified")) and "buttonConfigDTOList" in payload:
+            self.views.view_update(profile=profile, viewgraph_key=viewgraph_key, payload=payload)
+            sync_result = {**sync_result, "button_config_restored": True}
+        return sync_result
+
     def _load_views_result(self, *, profile: str, app_key: str, tolerate_404: bool) -> tuple[Any, bool]:
         try:
             views = self.views.view_list_flat(profile=profile, app_key=app_key)
@@ -5512,6 +5732,8 @@ def _serialize_custom_button_payload(payload: CustomButtonPatch) -> dict[str, An
     trigger_add_data_config = data.get("trigger_add_data_config")
     if isinstance(trigger_add_data_config, dict):
         serialized["triggerAddDataConfig"] = _serialize_custom_button_add_data_config(trigger_add_data_config)
+    else:
+        serialized["triggerAddDataConfig"] = _serialize_custom_button_add_data_config({})
     external_qrobot_config = data.get("external_qrobot_config")
     if isinstance(external_qrobot_config, dict):
         serialized["customButtonExternalQRobotRelationVO"] = _serialize_custom_button_external_qrobot_config(external_qrobot_config)
@@ -8072,6 +8294,36 @@ def _merge_view_summary_with_config(base: dict[str, Any], *, config: dict[str, A
         for entry in display_entries
         if str(entry.get("name") or "").strip()
     ]
+    apply_entries = [
+        entry
+        for entry in display_entries
+        if _coerce_nonnegative_int(entry.get("field_id")) is not None
+        and str(entry.get("name") or "").strip()
+        and str(entry.get("name") or "").strip() not in _KNOWN_SYSTEM_VIEW_COLUMNS
+    ]
+    apply_column_ids = [
+        field_id
+        for field_id in (_coerce_nonnegative_int(entry.get("field_id")) for entry in apply_entries)
+        if field_id is not None
+    ]
+    apply_columns = [
+        str(entry.get("name") or "").strip()
+        for entry in apply_entries
+        if str(entry.get("name") or "").strip()
+    ]
+    if not apply_columns and configured_column_ids:
+        apply_columns = [
+            str((question_entries_by_id.get(field_id) or {}).get("name") or "").strip()
+            for field_id in configured_column_ids
+            if str((question_entries_by_id.get(field_id) or {}).get("name") or "").strip()
+            and str((question_entries_by_id.get(field_id) or {}).get("name") or "").strip() not in _KNOWN_SYSTEM_VIEW_COLUMNS
+        ]
+        apply_column_ids = [
+            field_id
+            for field_id in configured_column_ids
+            if str((question_entries_by_id.get(field_id) or {}).get("name") or "").strip()
+            and str((question_entries_by_id.get(field_id) or {}).get("name") or "").strip() not in _KNOWN_SYSTEM_VIEW_COLUMNS
+        ]
     if not display_columns and configured_columns:
         display_columns = configured_columns
         display_column_ids = list(configured_column_ids)
@@ -8087,6 +8339,10 @@ def _merge_view_summary_with_config(base: dict[str, Any], *, config: dict[str, A
         summary["configured_columns"] = configured_columns
         summary["configured_column_ids"] = configured_column_ids
         config_enriched = True
+    if apply_columns:
+        summary["apply_columns"] = apply_columns
+        summary["apply_column_ids"] = apply_column_ids
+        config_enriched = True
     if question_entries:
         summary["column_details"] = display_entries or _sort_view_question_entries(question_entries)
         config_enriched = True
@@ -8370,7 +8626,7 @@ def _normalize_view_buttons_for_compare(value: Any) -> list[dict[str, Any]]:
             {
                 "button_type": normalized.get("button_type"),
                 "config_type": normalized.get("config_type"),
-                "button_id": normalized.get("button_id"),
+                "button_id": normalized.get("button_id") if normalized.get("button_type") == "CUSTOM" else None,
                 "button_text": normalized.get("button_text"),
                 "button_icon": normalized.get("button_icon"),
                 "background_color": normalized.get("background_color"),
@@ -8387,12 +8643,127 @@ def _normalize_view_buttons_for_compare(value: Any) -> list[dict[str, Any]]:
     return normalized_entries
 
 
+_SYSTEM_VIEW_BUTTON_ID_BY_ACTION: dict[tuple[str, str], int] = {
+    ("TOP", "set"): 1,
+    ("TOP", "switchView"): 2,
+    ("TOP", "setRowHeight"): 3,
+    ("TOP", "search"): 6,
+    ("DETAIL", "share"): 7,
+    ("DETAIL", "edit"): 8,
+}
+
+_SYSTEM_VIEW_BUTTON_ID_BY_TEXT: dict[tuple[str, str], int] = {
+    ("TOP", "字段管理"): 1,
+    ("TOP", "视图类型"): 2,
+    ("TOP", "行高"): 3,
+    ("TOP", "搜索"): 6,
+    ("DETAIL", "分享"): 7,
+    ("DETAIL", "修改"): 8,
+    ("DETAIL", "修改记录"): 8,
+}
+
+
+def _resolve_system_view_button_logical_id(entry: dict[str, Any]) -> int | None:
+    config_type = _normalize_view_button_config_type(entry.get("configType") or entry.get("config_type")) or ""
+    trigger_action = str(entry.get("triggerAction") or entry.get("trigger_action") or "").strip()
+    if config_type and trigger_action:
+        mapped = _SYSTEM_VIEW_BUTTON_ID_BY_ACTION.get((config_type, trigger_action))
+        if mapped is not None:
+            return mapped
+    button_text = str(entry.get("buttonText") or entry.get("button_text") or "").strip()
+    default_button_text = str(entry.get("defaultButtonText") or entry.get("default_button_text") or "").strip()
+    for candidate in (button_text, default_button_text):
+        if config_type and candidate:
+            mapped = _SYSTEM_VIEW_BUTTON_ID_BY_TEXT.get((config_type, candidate))
+            if mapped is not None:
+                return mapped
+    button_id = _coerce_positive_int(entry.get("buttonId") or entry.get("button_id") or entry.get("id"))
+    if button_id is not None and button_id < 1000:
+        return button_id
+    return None
+
+
+def _normalize_expected_view_buttons_for_compare(
+    value: Any,
+    *,
+    custom_button_details_by_id: dict[int, dict[str, Any]] | None = None,
+) -> list[dict[str, Any]]:
+    normalized_entries = _normalize_view_buttons_for_compare(value)
+    if not custom_button_details_by_id:
+        return normalized_entries
+    enriched_entries: list[dict[str, Any]] = []
+    for item in normalized_entries:
+        enriched = deepcopy(item)
+        if enriched.get("button_type") == "CUSTOM":
+            button_id = _coerce_positive_int(enriched.get("button_id"))
+            detail = custom_button_details_by_id.get(button_id or -1)
+            if isinstance(detail, dict):
+                for key in (
+                    "button_text",
+                    "button_icon",
+                    "background_color",
+                    "text_color",
+                    "trigger_action",
+                    "trigger_link_url",
+                ):
+                    value = detail.get(key)
+                    if value not in {None, ""}:
+                        enriched[key] = deepcopy(value)
+        enriched_entries.append(enriched)
+    return enriched_entries
+
+
+def _partition_view_button_summaries(
+    items: list[dict[str, Any]],
+) -> tuple[list[dict[str, Any]], list[dict[str, Any]], list[dict[str, Any]]]:
+    system_buttons: list[dict[str, Any]] = []
+    custom_buttons: list[dict[str, Any]] = []
+    other_buttons: list[dict[str, Any]] = []
+    for item in items:
+        button_type = str(item.get("button_type") or "").strip().upper()
+        if button_type == "SYSTEM":
+            system_buttons.append(item)
+        elif button_type == "CUSTOM":
+            custom_buttons.append(item)
+        else:
+            other_buttons.append(item)
+    return system_buttons, custom_buttons, other_buttons
+
+
+def _compare_view_button_summaries(
+    *,
+    expected: list[dict[str, Any]],
+    actual: list[dict[str, Any]],
+) -> dict[str, Any]:
+    if actual == expected:
+        return {
+            "verified": True,
+            "custom_button_readback_pending": False,
+            "pending_custom_buttons": [],
+        }
+    expected_system, expected_custom, expected_other = _partition_view_button_summaries(expected)
+    actual_system, actual_custom, actual_other = _partition_view_button_summaries(actual)
+    custom_button_readback_pending = (
+        bool(expected_custom)
+        and not actual_custom
+        and actual_system == expected_system
+        and actual_other == expected_other
+    )
+    return {
+        "verified": custom_button_readback_pending,
+        "custom_button_readback_pending": custom_button_readback_pending,
+        "pending_custom_buttons": deepcopy(expected_custom) if custom_button_readback_pending else [],
+    }
+
+
 def _serialize_existing_view_button_entry(entry: dict[str, Any]) -> dict[str, Any]:
     dto: dict[str, Any] = {}
+    button_type = _normalize_view_button_type(entry.get("buttonType") or entry.get("button_type"))
     button_id = _coerce_positive_int(entry.get("buttonId") or entry.get("button_id") or entry.get("id"))
+    if button_type == "SYSTEM":
+        button_id = _resolve_system_view_button_logical_id(entry)
     if button_id is not None:
         dto["buttonId"] = button_id
-    button_type = _normalize_view_button_type(entry.get("buttonType") or entry.get("button_type"))
     if button_type is not None:
         dto["buttonType"] = button_type
     config_type = _normalize_view_button_config_type(entry.get("configType") or entry.get("config_type"))
@@ -8405,6 +8776,7 @@ def _serialize_existing_view_button_entry(entry: dict[str, Any]) -> dict[str, An
     dto["printTpls"] = _serialize_print_tpl_ids(entry.get("printTpls"))
     for source_key, target_key in (
         ("buttonText", "buttonText"),
+        ("defaultButtonText", "defaultButtonText"),
         ("buttonIcon", "buttonIcon"),
         ("backgroundColor", "backgroundColor"),
         ("textColor", "textColor"),
@@ -8423,10 +8795,9 @@ def _serialize_existing_view_button_entry(entry: dict[str, Any]) -> dict[str, An
 def _extract_existing_view_button_dtos(config: dict[str, Any]) -> list[dict[str, Any]]:
     if not isinstance(config, dict):
         return []
-    button_config_dtos = config.get("buttonConfigDTOList")
-    if isinstance(button_config_dtos, list):
-        return [deepcopy(item) for item in button_config_dtos if isinstance(item, dict)]
-    entries, _ = _extract_view_button_entries(config)
+    entries, source = _extract_view_button_entries(config)
+    if source == "buttonConfigDTOList":
+        return [deepcopy(item) for item in entries if isinstance(item, dict)]
     return [_serialize_existing_view_button_entry(entry) for entry in entries if isinstance(entry, dict)]
 
 
@@ -9171,6 +9542,22 @@ def _build_view_update_payload(
     )
 
 
+_KNOWN_SYSTEM_VIEW_COLUMNS = {
+    "编号",
+    "当前流程状态",
+    "申请人",
+    "申请时间",
+    "更新时间",
+    "流程标题",
+    "当前处理人",
+    "当前处理节点",
+}
+
+
+def _filter_known_system_view_columns(columns: list[str]) -> list[str]:
+    return [name for name in columns if str(name or "").strip() and str(name).strip() not in _KNOWN_SYSTEM_VIEW_COLUMNS]
+
+
 def _build_minimal_view_payload(
     *,
     app_key: str,
@@ -9299,7 +9686,7 @@ def _resolve_view_visible_field_names(patch: ViewUpsertPatch) -> list[str]:
     ordered: list[str] = []
     for value in [*patch.columns, patch.title_field, patch.start_field, patch.end_field, patch.group_by]:
         name = str(value or "").strip()
-        if name and name not in ordered:
+        if name and name not in _KNOWN_SYSTEM_VIEW_COLUMNS and name not in ordered:
             ordered.append(name)
     return ordered