@qingflow-tech/qingflow-cli 1.1.50-beta.5 → 1.1.51

package/src/qingflow_mcp/builder_facade/service.py

@@ -15,8 +15,6 @@ from typing import Any, NoReturn, cast
 from urllib.parse import quote_plus, unquote_plus
 from uuid import uuid4
 
-from pydantic import ValidationError
-
 from ..backend_client import BackendRequestContext
 from ..config import get_flow_edit_maintenance_threshold
 from ..errors import QingflowApiError, backend_code_int, backend_code_value_int, is_auth_like_error
@@ -28,7 +26,7 @@ from ..solution.compiler.chart_compiler import qingbi_workspace_visible_auth
 from ..solution.compiler.form_compiler import build_question, default_form_payload, default_member_auth
 from ..solution.compiler.icon_utils import encode_workspace_icon_with_defaults, workspace_icon_config
 from ..solution.compiler.view_compiler import VIEW_TYPE_MAP
-from ..solution.executor import _build_viewgraph_questions, _compact_dict, _flatten_viewgraph_questions, extract_field_map
+from ..solution.executor import _build_viewgraph_questions, _compact_dict, extract_field_map
 from ..solution.spec_models import FieldType, FormLayoutRowSpec, FormLayoutSectionSpec, ViewSpec
 from ..tools.app_tools import AppTools
 from ..tools.custom_button_tools import CustomButtonTools
@@ -43,8 +41,6 @@ from ..tools.workflow_tools import WorkflowTools
 from . import flow_validation
 from . import workflow_spec as workflow_spec_api
 from .button_style_catalog import button_style_catalog_payload
-from ..tools.view_writer import ViewWriter
-from .views_schema import ViewsContractError, compact_none_values, views_schema_registry
 from .models import (
     AppChartsReadResponse,
     AppFieldsReadResponse,
@@ -163,14 +159,9 @@ FIELD_TYPE_TO_QUESTION_TYPE: dict[str, int] = {
     FieldType.relation.value: 25,
 }
 
-# code_block / q_linker 输出目标字段类型。后端写链无类型白名单(FormSvcImpl 原样
-# 落库),运行时 DataSvcImpl.getAnswerValueByString:attachment 按拆分 URL 写入、
-# subtable 整表组装(均有专门分支),rich_text/data_relation 走 Question.canImport
-# 兜底按字符串写入(不报错)——四者为存量合法配置,与 validator 侧白名单同口径。
 INTEGRATION_OUTPUT_TARGET_FIELD_TYPES: tuple[str, ...] = (
     FieldType.text.value,
     FieldType.long_text.value,
-    "rich_text",
     FieldType.number.value,
     FieldType.amount.value,
     FieldType.date.value,
@@ -178,9 +169,6 @@ INTEGRATION_OUTPUT_TARGET_FIELD_TYPES: tuple[str, ...] = (
     FieldType.single_select.value,
     FieldType.multi_select.value,
     FieldType.boolean.value,
-    FieldType.attachment.value,
-    "data_relation",
-    FieldType.subtable.value,
 )
 
 MATCH_TYPE_ACCURACY = 1
@@ -302,7 +290,6 @@ class AiBuilderFacade:
         self.buttons = buttons
         self.packages = packages
         self.views = views
-        self._view_writer = ViewWriter(views.sessions, views.backend)
         self.workflows = workflows
         self.portals = portals
         self.charts = charts
@@ -3085,27 +3072,14 @@ class AiBuilderFacade:
             member_ids=visibility.external_selectors.member_ids,
             member_emails=visibility.external_selectors.member_emails,
         )
-        # 冗余引用降级:提取器对同一成员同时产出 uid/email/name 三通道(uid 必有且直通解析,
-        # 保证成员不丢);email/name 走后端通讯录搜索,受数据/权限边界影响解析可能失败。
-        # 这类失败降级为非阻断——只有 uid/dept_id 直通也覆盖不了的引用才真正阻断。
-        _SOFT_RESOLUTION_KINDS = {"member_email", "member_name", "department_name", "role", "external_member_email"}
-        _NOT_FOUND_RESOLUTION_CODES = {"MEMBER_NOT_FOUND", "AMBIGUOUS_MEMBER", "ROLE_NOT_FOUND", "AMBIGUOUS_ROLE", "DEPARTMENT_NOT_FOUND", "AMBIGUOUS_DEPARTMENT"}
-        blocking_issues = [
-            issue
-            for issue in [
+        self._raise_visibility_resolution_issues(
+            [
                 *member_resolution["issues"],
                 *role_resolution["issues"],
                 *department_resolution["issues"],
                 *external_member_resolution["issues"],
             ]
-            # 冗余 email/name 引用「找不到」降级为非阻断(uid/id 直通已保主体不丢);
-            # 权限拒绝/查询失败类(LOOKUP_FAILED/PERMISSION_DENIED)仍阻断
-            if not (
-                str(issue.get("kind") or "") in _SOFT_RESOLUTION_KINDS
-                and str(issue.get("error_code") or "") in _NOT_FOUND_RESOLUTION_CODES
-            )
-        ]
-        self._raise_visibility_resolution_issues(blocking_issues)
+        )
 
         external_depart_entries: list[dict[str, Any]] = []
         for dept_id in visibility.external_selectors.dept_ids:
@@ -3246,7 +3220,7 @@ class AiBuilderFacade:
                     }
                 )
             condition_matrix, condition_issues = _build_flow_condition_matrix(
-                fields_by_que_id=field_name_to_field,
+                current_fields_by_name=field_name_to_field,
                 node=normalized_node,
             )
             issues.extend({**issue, "node_id": node.get("id")} for issue in condition_issues)
@@ -3933,7 +3907,7 @@ class AiBuilderFacade:
                         "reason_path": f"patch_buttons[{index}].button_id",
                         "button_id": selector_id,
                         "message": "button_id does not exist in the current app draft",
-                        "next_action": "call app_get_buttons with button_text to reuse an existing custom button; create only if absent via app_custom_buttons_apply",
+                        "next_action": "call app_get and use custom_buttons[].button_id",
                     }
                     issues.append(issue)
                     results.append({"index": index, "status": "failed", **issue})
@@ -4237,7 +4211,7 @@ class AiBuilderFacade:
                             "reason_path": f"upsert_buttons[{index}].button_id",
                             "button_id": button_id,
                             "message": "button_id does not exist in the current app draft",
-                            "next_action": "call app_get_buttons with button_text to reuse an existing custom button; create only if absent via app_custom_buttons_apply",
+                            "next_action": "call app_get and use custom_buttons[].button_id",
                         }
                     )
                     continue
@@ -4308,7 +4282,7 @@ class AiBuilderFacade:
                             "reason_path": f"remove_buttons[{index}].button_id",
                             "button_id": selector_id,
                             "message": "button_id does not exist in the current app draft",
-                            "next_action": "call app_get_buttons with button_text to reuse an existing custom button; create only if absent via app_custom_buttons_apply",
+                            "next_action": "call app_get and use custom_buttons[].button_id",
                         }
                     )
                     continue
@@ -7181,14 +7155,10 @@ class AiBuilderFacade:
         fields = cast(list[dict[str, Any]], state["parsed"]["fields"])
         return _chart_field_names_by_id_from_public_fields(app_key=app_key, fields=fields), None
 
-    def app_get_buttons(self, *, profile: str, app_key: str, button_text: str | None = None) -> JSONObject:
+    def app_get_buttons(self, *, profile: str, app_key: str) -> JSONObject:
         self.apps._require_app_key(app_key)
         warnings: list[dict[str, Any]] = []
         verification: dict[str, Any] = {"buttons_loaded": True, "view_configs_loaded": True}
-        normalized_text = str(button_text or "").strip() or None
-        normalized_args: dict[str, Any] = {"app_key": app_key}
-        if normalized_text is not None:
-            normalized_args["button_text"] = normalized_text
         try:
             raw = self.buttons.custom_button_list(profile=profile, app_key=app_key, being_draft=True)
         except (QingflowApiError, RuntimeError) as error:
@@ -7196,18 +7166,11 @@ class AiBuilderFacade:
             return _failed_from_api_error(
                 "BUTTONS_READ_FAILED",
                 api_error,
-                normalized_args=normalized_args,
+                normalized_args={"app_key": app_key},
                 details={"app_key": app_key},
                 suggested_next_call={"tool_name": "app_get", "arguments": {"profile": profile, "app_key": app_key}},
             )
         buttons = raw.get("items") if isinstance(raw.get("items"), list) else []
-        total_count = len(buttons)
-        if normalized_text is not None:
-            buttons = [
-                item
-                for item in buttons
-                if isinstance(item, dict) and str(item.get("buttonText") or item.get("button_text") or "").strip() == normalized_text
-            ]
         view_configs: list[dict[str, Any]] = []
         view_config_read_errors: list[dict[str, Any]] = []
         try:
@@ -7227,7 +7190,7 @@ class AiBuilderFacade:
         if view_config_read_errors:
             verification["view_configs_loaded"] = False
             warnings.append(_warning("BUTTON_VIEW_CONFIGS_PARTIAL", "some view button binding configs could not be read back"))
-        response: JSONObject = {
+        return {
             "status": "success",
             "error_code": None,
             "recoverable": False,
@@ -7242,11 +7205,6 @@ class AiBuilderFacade:
             "verification": verification,
             "details": {"view_config_read_errors": view_config_read_errors} if view_config_read_errors else {},
         }
-        if normalized_text is not None:
-            response["button_text_filter"] = normalized_text
-            response["total_count"] = total_count
-            verification["button_text_exact_match"] = True
-        return response
 
     def app_get_associated_resources(self, *, profile: str, app_key: str) -> JSONObject:
         self.apps._require_app_key(app_key)
@@ -8472,7 +8430,11 @@ class AiBuilderFacade:
         try:
             schema, _schema_source = self._read_schema_with_fallback(profile=profile, app_key=app_key)
             parsed_schema = _parse_schema(schema)
-            fields_by_que_id = _collect_fields_by_que_id([], schema=schema)
+            current_fields_by_name = {
+                str(field.get("name") or ""): field
+                for field in parsed_schema.get("fields") or []
+                if isinstance(field, dict) and str(field.get("name") or "")
+            }
             existing_views, _views_unavailable = self._load_views_result(profile=profile, app_key=app_key, tolerate_404=False)
         except (QingflowApiError, RuntimeError) as error:
             api_error = _coerce_api_error(error)
@@ -8563,7 +8525,7 @@ class AiBuilderFacade:
                 view_binding = _custom_button_view_binding_to_view_button_patch(binding=binding, button_id=button_id)
                 dto, binding_issues = _serialize_view_button_binding(
                     binding=view_binding,
-                    fields_by_que_id=fields_by_que_id,
+                    current_fields_by_name=current_fields_by_name,
                     valid_custom_button_ids=valid_custom_button_ids,
                     allow_unverified_custom_button_id=allow_unverified_numeric_button_ids,
                 )
@@ -9493,37 +9455,49 @@ class AiBuilderFacade:
             return fields_result
         current_fields = fields_result.get("fields", [])
         field_names = {str(field.get("name") or "") for field in current_fields}
-        fields_by_que_id = _collect_fields_by_que_id(current_fields)
+        current_fields_by_name = {
+            str(field.get("name") or ""): field
+            for field in current_fields
+            if isinstance(field, dict) and str(field.get("name") or "")
+        }
         upsert_views = [public_view_upsert_payload(view) for view in request.upsert_views]
         patch_views = [public_view_partial_payload(patch) for patch in request.patch_views]
         if request.preset is not None:
             upsert_views = _build_views_preset(request.preset, list(field_names))
         blocking_issues: list[dict[str, Any]] = []
         for patch in upsert_views:
-            # queId 形态:columns 是 int 数组,系统列 queId<=0 天然排除
-            raw_columns = [que for que in (patch.get("columns") or []) if isinstance(que, int) and que > 0]
-            columns = raw_columns
-            missing_columns = [que for que in columns if que not in fields_by_que_id]
+            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})
-            group_que_id = patch.get("group_que_id")
-            if group_que_id and group_que_id not in fields_by_que_id:
-                blocking_issues.append({"error_code": "UNKNOWN_VIEW_FIELD", "view_name": patch.get("name"), "missing_fields": [group_que_id]})
-            start_que_id = patch.get("start_que_id")
-            end_que_id = patch.get("end_que_id")
-            title_que_id = patch.get("title_que_id")
+            group_by = patch.get("group_by")
+            if group_by and group_by not in field_names:
+                blocking_issues.append({"error_code": "UNKNOWN_VIEW_FIELD", "view_name": patch.get("name"), "missing_fields": [group_by]})
+            start_field = str(patch.get("start_field") or "").strip()
+            end_field = str(patch.get("end_field") or "").strip()
+            title_field = str(patch.get("title_field") or "").strip()
             if patch.get("type") == "gantt":
                 missing_required = []
-                if not start_que_id:
-                    missing_required.append("start_que_id")
-                if not end_que_id:
-                    missing_required.append("end_que_id")
+                if not start_field:
+                    missing_required.append("start_field")
+                if not end_field:
+                    missing_required.append("end_field")
                 if missing_required:
                     blocking_issues.append({"error_code": "INVALID_GANTT_CONFIG", "view_name": patch.get("name"), "missing_fields": missing_required})
-                missing_gantt_fields = [que for que in (start_que_id, end_que_id, title_que_id) if que and que not in fields_by_que_id]
+                missing_gantt_fields = [name for name in (start_field, end_field, title_field) if name and name not in field_names]
                 if missing_gantt_fields:
                     blocking_issues.append({"error_code": "UNKNOWN_VIEW_FIELD", "view_name": patch.get("name"), "missing_fields": missing_gantt_fields})
-            translated_filters, filter_issues = _build_view_filter_groups(fields_by_que_id=fields_by_que_id, filters=patch.get("filters") or [])
+            translated_filters, filter_issues = _build_view_filter_groups(current_fields_by_name=current_fields_by_name, filters=patch.get("filters") or [])
             if filter_issues:
                 blocking_issues.extend(
                     {
@@ -9531,12 +9505,11 @@ class AiBuilderFacade:
                         "view_name": patch.get("name"),
                     }
                     for issue in filter_issues
-                    if issue.get("error_code")
                 )
             if translated_filters:
                 patch["filters"] = [dict(rule) for rule in (patch.get("filters") or [])]
             _, _, query_condition_issues = _build_view_query_conditions_payload(
-                fields_by_que_id=fields_by_que_id,
+                current_fields_by_name=current_fields_by_name,
                 query_conditions=patch.get("query_conditions"),
             )
             if query_condition_issues:
@@ -11823,26 +11796,6 @@ class AiBuilderFacade:
         result["retry_payload"] = self._view_action_buttons_retry_payload(profile=profile, app_key=app_key, intents=retry_intents) if retry_intents else None
         return result
 
-    def _apply_view_create(self, *, profile: str, payload: JSONObject) -> str | None:
-        """创建一个视图并从后端响应中提取 view key。"""
-        create_result = self._view_writer.create_view(profile=profile, payload=payload)
-        raw_created = create_result.get("result")
-        if isinstance(raw_created, dict):
-            raw_view_key = raw_created.get("viewgraphKey") or raw_created.get("viewKey")
-            return str(raw_view_key).strip() if raw_view_key is not None and str(raw_view_key).strip() else None
-        if isinstance(raw_created, str):
-            return raw_created.strip() or None
-        return None
-
-    def _apply_view_update(self, *, profile: str, view_key: str, payload: JSONObject) -> None:
-        """更新一个已有视图。"""
-        self.views.view_update(profile=profile, viewgraph_key=view_key, payload=payload)
-
-    def _apply_view_remove(self, *, profile: str, view_key: str) -> JSONObject:
-        """删除一个视图并执行单 view key 读回验证。"""
-        self.views.view_delete(profile=profile, viewgraph_key=view_key)
-        return self._verify_view_deleted_by_key(profile=profile, view_key=view_key)
-
     def app_views_apply(
         self,
         *,
@@ -11852,91 +11805,15 @@ class AiBuilderFacade:
         patch_views: list[ViewPartialPatch] | None = None,
         remove_views: list[str],
         publish: bool = True,
-        schema_version: str | None = None,
     ) -> JSONObject:
         patch_views = patch_views or []
-        operation_values = (
-            ("upsert", "upsert_views", upsert_views, "VIEW_BATCH_CREATE_UNSUPPORTED"),
-            ("patch", "patch_views", patch_views, "VIEW_BATCH_OPERATION_UNSUPPORTED"),
-            ("remove", "remove_views", remove_views, "VIEW_BATCH_OPERATION_UNSUPPORTED"),
-        )
-        selected_operation_types = [operation for operation, _field_name, values, _error_code in operation_values if values]
-        selected_operations = [field_name for _operation, field_name, values, _error_code in operation_values if values]
         normalized_args = {
             "app_key": app_key,
-            "upsert_view": public_view_upsert_payload(upsert_views[0]) if upsert_views else None,
+            "upsert_views": [public_view_upsert_payload(patch) for patch in upsert_views],
             "patch_views": [public_view_partial_payload(patch) for patch in patch_views],
             "remove_views": list(remove_views),
             "publish": publish,
-            "schema_version": schema_version,
         }
-        if len(selected_operations) > 1:
-            return _failed(
-                "VIEW_SINGLE_OPERATION_UNSUPPORTED",
-                "app_views_apply supports one view operation per call; choose upsert_view, patch_views, or remove_views",
-                normalized_args=normalized_args,
-                details={"app_key": app_key, "operations": selected_operations},
-                suggested_next_call=None,
-            )
-        operation = selected_operation_types[0] if selected_operation_types else None
-        for operation_name, _field_name, values, error_code in operation_values:
-            if len(values) <= 1:
-                continue
-            first_value = values[0]
-            if operation_name == "upsert":
-                suggested_value: Any = public_view_upsert_payload(first_value)
-            elif operation_name == "patch":
-                suggested_value = [public_view_partial_payload(first_value)]
-            else:
-                suggested_value = [str(first_value)]
-            argument_name = "upsert_view" if operation_name == "upsert" else f"{operation_name}_views"
-            suggested_arguments: JSONObject = {
-                "profile": profile,
-                "app_key": app_key,
-                argument_name: suggested_value,
-                "publish": publish,
-            }
-            if schema_version is not None:
-                suggested_arguments["schema_version"] = schema_version
-            return _failed(
-                error_code,
-                (
-                    "app_views_apply supports creating or fully updating one view per call"
-                    if operation_name == "upsert"
-                    else f"app_views_apply supports at most one {operation_name} per call"
-                ),
-                normalized_args=normalized_args,
-                details={
-                    "app_key": app_key,
-                    f"max_{operation_name}_views": 1,
-                    f"received_{operation_name}_views": len(values),
-                },
-                suggested_next_call={
-                    "tool_name": "app_views_apply",
-                    "arguments": suggested_arguments,
-                },
-            )
-        schema_context = None
-        if schema_version is not None:
-            try:
-                schema_context = views_schema_registry().resolve_schema_version(schema_version)
-                for upsert in upsert_views:
-                    schema_context.validate_upsert(
-                        compact_none_values(public_view_upsert_payload(upsert))
-                    )
-            except ViewsContractError as error:
-                return _failed(
-                    error.error_code,
-                    str(error.message),
-                    normalized_args=normalized_args,
-                    details={
-                        "app_key": app_key,
-                        "schema_version": schema_version,
-                        "reason_path": error.path or "",
-                        **(error.details or {}),
-                    },
-                    suggested_next_call={"tool_name": "app_views_schema", "arguments": {"schema_version": schema_version, "schema_kind": "complete"}},
-                )
         apply_started_at = time.perf_counter()
         permission_ms = 0
         view_state_read_ms = 0
@@ -11951,8 +11828,6 @@ class AiBuilderFacade:
         permission_outcomes: list[PermissionCheckOutcome] = []
 
         def finalize(response: JSONObject) -> JSONObject:
-            if schema_context is not None:
-                response["schemaVersion"] = schema_context.schema_version
             return _apply_permission_outcomes(response, *permission_outcomes)
 
         def attach_duration(response: JSONObject) -> JSONObject:
@@ -12169,25 +12044,7 @@ class AiBuilderFacade:
                 return finish(create_permission_outcome.block)
             permission_outcomes.append(create_permission_outcome)
         parsed_schema = _parse_schema(schema)
-
-        def _register_subfield_names(field: dict[str, Any], index: dict[str, dict[str, Any]]) -> None:
-            # 表格字段(queType 18)的子字段是视图列/筛选/排序的合法引用面(viewgraph_question 有独立行);
-            # _parse_schema 只把顶层字段入列,这里递归并入引用索引(不改 fields 布局面)
-            for sub in field.get("subfields") or []:
-                if isinstance(sub, dict) and str(sub.get("name") or "").strip():
-                    index.setdefault(str(sub["name"]), sub)
-                    _register_subfield_names(sub, index)
-
-        field_name_to_field: dict[str, dict[str, Any]] = {}
-        for field in parsed_schema["fields"]:
-            if isinstance(field, dict) and str(field.get("name") or "").strip():
-                field_name_to_field[str(field["name"])] = field
-                _register_subfield_names(field, field_name_to_field)
-        field_names = set(field_name_to_field)
-        # views 契约全 queId 化后,列/筛选/排序/配置引用的是 queId(int);
-        # fields_by_que_id 必须以 que_id 为键,与 _build_view_filter_groups 等消费方对齐。
-        # 递归收集(顶层+表格子字段;段落内字段经 _parse_schema 已展平到 fields)。
-        fields_by_que_id = _collect_fields_by_que_id([], schema=schema)
+        field_names = {field["name"] for field in parsed_schema["fields"]}
         if patch_views:
             expanded_views, patch_issues, patch_results = self._expand_view_partial_patches(
                 profile=profile,
@@ -12207,18 +12064,14 @@ class AiBuilderFacade:
                         suggested_next_call={"tool_name": "view_get", "arguments": {"profile": profile, "view_key": patch_issues[0].get("view_key") or "VIEW_KEY"}},
                     )
                 )
-            if len(expanded_views) > 1:
-                return finalize(_failed(
-                    "VIEW_BATCH_OPERATION_UNSUPPORTED",
-                    "app_views_apply supports hydrating one patch view per call",
-                    normalized_args=normalized_args,
-                    details={"app_key": app_key, "received_patch_views": len(expanded_views)},
-                    suggested_next_call=None,
-                ))
-            upsert_views = expanded_views
-            operation = "upsert" if expanded_views else "patch"
-            normalized_args["upsert_view"] = public_view_upsert_payload(expanded_views[0]) if expanded_views else None
+            upsert_views = [*upsert_views, *expanded_views]
+            normalized_args["upsert_views"] = [public_view_upsert_payload(patch) for patch in upsert_views]
             normalized_args["patch_results"] = patch_results
+        current_fields_by_name = {
+            str(field.get("name") or ""): field
+            for field in parsed_schema["fields"]
+            if isinstance(field, dict) and str(field.get("name") or "")
+        }
         requires_custom_button_validation = any(
             any(binding.button_type == PublicViewButtonType.custom for binding in (patch.buttons or []))
             for patch in upsert_views
@@ -12314,8 +12167,8 @@ class AiBuilderFacade:
             associated_resource_inventory_ms += _duration_ms(associated_resource_inventory_started_at)
         removed: list[str] = []
         removed_keys: set[str] = set()
-        view_result: dict[str, Any] | None = None
-        failure_result: dict[str, Any] | None = None
+        view_results: list[dict[str, Any]] = []
+        failed_views: list[dict[str, Any]] = []
         action_button_intents: list[dict[str, Any]] = list(patch_action_button_intents)
 
         def record_action_button_intent(*, patch: ViewUpsertPatch, view_key: str | None, index: int) -> None:
@@ -12333,17 +12186,10 @@ class AiBuilderFacade:
             )
 
         view_mutation_started_at = time.perf_counter()
-        if operation == "remove" and remove_views:
-            selector_text = str(remove_views[0] or "").strip()
+        for selector in remove_views:
+            selector_text = str(selector or "").strip()
             if not selector_text:
-                view_mutation_ms += _duration_ms(view_mutation_started_at)
-                return finish(_failed(
-                    "VIEW_NOT_FOUND",
-                    "remove_views item did not match an existing view name or view_key",
-                    normalized_args=normalized_args,
-                    details={"app_key": app_key},
-                    suggested_next_call={"tool_name": "app_get", "arguments": {"profile": profile, "app_key": app_key}},
-                ))
+                continue
             key_match = existing_by_key.get(selector_text)
             matches = [key_match] if isinstance(key_match, dict) else existing_by_name.get(selector_text, [])
             if len(matches) > 1:
@@ -12370,40 +12216,44 @@ class AiBuilderFacade:
                     "error_code": "VIEW_NOT_FOUND",
                     "message": "remove_views item did not match an existing view name or view_key",
                 }
-                failure_result = failed_view
-                view_result = deepcopy(failed_view)
-            else:
+                failed_views.append(failed_view)
+                view_results.append(deepcopy(failed_view))
+                continue
+            if len(matches) == 1:
                 key = _extract_view_key(matches[0])
                 removed_name = _extract_view_name(matches[0]) or selector_text
                 try:
-                    delete_readback = self._apply_view_remove(profile=profile, view_key=key)
+                    self.views.view_delete(profile=profile, viewgraph_key=key)
+                    delete_readback = self._verify_view_deleted_by_key(profile=profile, view_key=key)
                     removed.append(removed_name)
                     if key:
                         removed_keys.add(key)
                         existing_by_key.pop(key, None)
                     existing_by_name.pop(removed_name, None)
-                    view_result = {
-                        "name": removed_name,
-                        "view_key": key,
-                        "type": None,
-                        "status": delete_readback.get("status") or "readback_pending",
-                        "operation": "delete",
-                        "delete_executed": True,
-                        "readback_status": delete_readback.get("readback_status"),
-                        "safe_to_retry_delete": False,
-                        **(
-                            {
-                                "error_code": delete_readback.get("error_code"),
-                                "message": delete_readback.get("message"),
-                                "request_id": delete_readback.get("request_id"),
-                                "backend_code": delete_readback.get("backend_code"),
-                                "http_status": delete_readback.get("http_status"),
-                                "transport_error": delete_readback.get("transport_error"),
-                            }
-                            if delete_readback.get("readback_status") != "deleted"
-                            else {}
-                        ),
-                    }
+                    view_results.append(
+                        {
+                            "name": removed_name,
+                            "view_key": key,
+                            "type": None,
+                            "status": delete_readback.get("status") or "readback_pending",
+                            "operation": "delete",
+                            "delete_executed": True,
+                            "readback_status": delete_readback.get("readback_status"),
+                            "safe_to_retry_delete": False,
+                            **(
+                                {
+                                    "error_code": delete_readback.get("error_code"),
+                                    "message": delete_readback.get("message"),
+                                    "request_id": delete_readback.get("request_id"),
+                                    "backend_code": delete_readback.get("backend_code"),
+                                    "http_status": delete_readback.get("http_status"),
+                                    "transport_error": delete_readback.get("transport_error"),
+                                }
+                                if delete_readback.get("readback_status") != "deleted"
+                                else {}
+                            ),
+                        }
+                    )
                 except (QingflowApiError, RuntimeError) as error:
                     api_error = _coerce_api_error(error)
                     failed_view = {
@@ -12420,8 +12270,8 @@ class AiBuilderFacade:
                         "backend_code": api_error.backend_code,
                         "http_status": None if api_error.http_status == 404 else api_error.http_status,
                     }
-                    failure_result = failed_view
-                    view_result = deepcopy(failed_view)
+                    failed_views.append(failed_view)
+                    view_results.append(deepcopy(failed_view))
         created: list[str] = []
         updated: list[str] = []
         existing_view_list = [
@@ -12431,129 +12281,95 @@ class AiBuilderFacade:
             and _extract_view_name(view) not in removed
             and _extract_view_key(view) not in removed_keys
         ]
-        stale_warnings: list[dict[str, Any]] = []
-        for ordinal, patch in ((1, upsert_views[0]),) if operation == "upsert" and upsert_views else ():
-            apply_columns = _resolve_view_visible_que_ids(patch)
+        for ordinal, patch in enumerate(upsert_views, start=1):
+            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},
+                    details={
+                        "app_key": app_key,
+                        "view_name": patch.name,
+                        "ignored_system_columns": ignored_system_columns,
+                    },
                 )
-            # 死引用(字段已从表单删除,后端保存视图时原样透传)降级为警告透传,不再整视图拒绝
-            missing_columns = [
-                que for que in apply_columns
-                if not _is_known_system_view_que_id(que) and que not in fields_by_que_id
-            ]
+            missing_columns = [name for name in apply_columns if name not in field_names]
             if missing_columns:
-                stale_warnings.append(
-                    _stale_view_reference_warning(scope="columns", view_name=patch.name, field_ids=missing_columns)
-                )
-            if patch.group_que_id and patch.group_que_id not in fields_by_que_id:
-                stale_warnings.append(
-                    _stale_view_reference_warning(scope="group_que_id", view_name=patch.name, field_ids=[patch.group_que_id])
+                return _failed(
+                    "UNKNOWN_VIEW_FIELD",
+                    "view columns reference unknown fields",
+                    normalized_args=normalized_args,
+                    details={
+                        "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_get_fields", "arguments": {"profile": profile, "app_key": app_key}},
                 )
-            for ref_scope, ref_que_id in (
-                ("gantt.start_que_id", patch.start_que_id),
-                ("gantt.end_que_id", patch.end_que_id),
-                ("title_que_id", patch.title_que_id),
-            ):
-                # 系统字段(提交人/提交时间等)可作标题/时间轴;业务字段死引用仅警告透传
-                if ref_que_id and not _is_known_system_view_que_id(ref_que_id) and ref_que_id not in fields_by_que_id:
-                    stale_warnings.append(
-                        _stale_view_reference_warning(scope=ref_scope, view_name=patch.name, field_ids=[ref_que_id])
-                    )
-            for group_name, config_que_ids in _iter_view_config_group_field_names(patch):
-                missing_config_fields = [
-                    que for que in config_que_ids
-                    if que not in fields_by_que_id and not _is_known_system_view_que_id(que)
-                ]
-                if missing_config_fields:
-                    stale_warnings.append(
-                        _stale_view_reference_warning(scope=group_name, view_name=patch.name, field_ids=missing_config_fields)
-                    )
-            hierarchy_root_filter_groups: list[list[dict[str, Any]]] | None = None
-            if patch.hierarchy is not None and patch.hierarchy.root_filter:
-                hierarchy_root_filter_groups = []
-                for root_filter_group in patch.hierarchy.root_filter:
-                    translated_group, hierarchy_filter_issues = _build_view_filter_groups(
-                        fields_by_que_id=fields_by_que_id,
-                        filters=root_filter_group,
-                    )
-                    for issue in hierarchy_filter_issues:
-                        if issue.get("warning_code") == "STALE_OPTION_REFERENCE":
-                            stale_warnings.append(
-                                _stale_view_reference_warning(
-                                    scope="hierarchy.root_filter",
-                                    view_name=patch.name,
-                                    values=issue.get("details", {}).get("unresolved_values") or [],
-                                    option=True,
-                                )
-                            )
-                    hierarchy_filter_errors = [issue for issue in hierarchy_filter_issues if issue.get("error_code")]
-                    if hierarchy_filter_errors:
-                        first_issue = hierarchy_filter_errors[0]
-                        return _failed(
-                            str(first_issue.get("error_code") or "UNKNOWN_VIEW_FIELD"),
-                            "view hierarchy root_filter references invalid fields or values",
-                            normalized_args=normalized_args,
-                            details={
-                                "app_key": app_key,
-                                "view_name": patch.name,
-                                **first_issue,
-                            },
-                            missing_fields=list(first_issue.get("missing_fields") or []),
-                            suggested_next_call={"tool_name": "app_get_fields", "arguments": {"profile": profile, "app_key": app_key}},
-                        )
-                    hierarchy_root_filter_groups.extend(translated_group)
-            translated_filters: list[list[dict[str, Any]]] | None
-            filter_issues: list[dict[str, Any]]
-            if patch.preserve_filters:
-                translated_filters = None
-                filter_issues = []
-            elif patch.filters and isinstance(patch.filters[0], list):
-                # 嵌套形态 [[rule,...],[rule,...]]:组间 OR、组内 AND(viewgraphLimit 多组),
-                # 复用 button_limit 的多组编译;后端简易模式会从多组规则自动派生公式
-                translated_filters, filter_issues = _build_view_button_limit_groups(
-                    fields_by_que_id=fields_by_que_id, groups=patch.filters
+            if patch.group_by and patch.group_by not in field_names:
+                return _failed(
+                    "UNKNOWN_VIEW_FIELD",
+                    f"group_by references unknown field '{patch.group_by}'",
+                    normalized_args=normalized_args,
+                    details={
+                        "app_key": app_key,
+                        "view_name": patch.name,
+                        "missing_fields": [patch.group_by],
+                    },
+                    missing_fields=[patch.group_by],
+                    suggested_next_call={"tool_name": "app_get_fields", "arguments": {"profile": profile, "app_key": app_key}},
                 )
-            else:
-                translated_filters, filter_issues = _build_view_filter_groups(fields_by_que_id=fields_by_que_id, filters=patch.filters)
-            if filter_issues:
-                for issue in filter_issues:
-                    if issue.get("warning_code") == "STALE_OPTION_REFERENCE":
-                        stale_warnings.append(
-                            _stale_view_reference_warning(
-                                scope="filters",
-                                view_name=patch.name,
-                                values=issue.get("details", {}).get("unresolved_values") or [],
-                                option=True,
-                            )
-                        )
-                filter_errors = [issue for issue in filter_issues if issue.get("error_code")]
-                if filter_errors:
-                    first_issue = filter_errors[0]
+            for gantt_field_name in (patch.start_field, patch.end_field, patch.title_field):
+                if gantt_field_name and gantt_field_name not in field_names:
                     return _failed(
-                        str(first_issue.get("error_code") or "UNKNOWN_VIEW_FIELD"),
-                        "view filters reference invalid fields or values",
+                        "UNKNOWN_VIEW_FIELD",
+                        f"gantt configuration references unknown field '{gantt_field_name}'",
                         normalized_args=normalized_args,
                         details={
                             "app_key": app_key,
                             "view_name": patch.name,
-                            **first_issue,
+                            "missing_fields": [gantt_field_name],
                         },
-                        missing_fields=list(first_issue.get("missing_fields") or []),
-                        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]},
+                        missing_fields=[gantt_field_name],
                         suggested_next_call={"tool_name": "app_get_fields", "arguments": {"profile": profile, "app_key": app_key}},
                     )
+            translated_filters: list[list[dict[str, Any]]] | None
+            filter_issues: list[dict[str, Any]]
+            if patch.preserve_filters:
+                translated_filters = None
+                filter_issues = []
+            else:
+                translated_filters, filter_issues = _build_view_filter_groups(current_fields_by_name=current_fields_by_name, filters=patch.filters)
+            if filter_issues:
+                first_issue = filter_issues[0]
+                return _failed(
+                    str(first_issue.get("error_code") or "UNKNOWN_VIEW_FIELD"),
+                    "view filters reference invalid fields or values",
+                    normalized_args=normalized_args,
+                    details={
+                        "app_key": app_key,
+                        "view_name": patch.name,
+                        **first_issue,
+                    },
+                    missing_fields=list(first_issue.get("missing_fields") or []),
+                    allowed_values=first_issue.get("allowed_values") or {"view_types": [member.value for member in PublicViewType], "view.filter.operator": [member.value for member in ViewFilterOperator]},
+                    suggested_next_call={"tool_name": "app_get_fields", "arguments": {"profile": profile, "app_key": app_key}},
+                )
             if patch.preserve_query_conditions:
                 query_condition_payload = None
                 expected_query_conditions = None
                 query_condition_issues = []
             else:
                 query_condition_payload, expected_query_conditions, query_condition_issues = _build_view_query_conditions_payload(
-                    fields_by_que_id=fields_by_que_id,
+                    current_fields_by_name=current_fields_by_name,
                     query_conditions=patch.query_conditions,
                 )
             if query_condition_issues:
@@ -12610,7 +12426,7 @@ class AiBuilderFacade:
                 expected_button_summary = None
             elif patch.buttons is not None:
                 explicit_button_dtos, button_issues = _build_view_button_dtos(
-                    fields_by_que_id=fields_by_que_id,
+                    current_fields_by_name=current_fields_by_name,
                     bindings=patch.buttons,
                     valid_custom_button_ids=valid_custom_button_ids,
                 )
@@ -12627,10 +12443,7 @@ class AiBuilderFacade:
                         },
                         missing_fields=list(first_issue.get("missing_fields") or []),
                         allowed_values=first_issue.get("allowed_values") or {"view_types": [member.value for member in PublicViewType], "view.filter.operator": [member.value for member in ViewFilterOperator]},
-                        suggested_next_call={
-                            "tool_name": "app_get_buttons",
-                            "arguments": {"profile": profile, "app_key": app_key},
-                        },
+                        suggested_next_call={"tool_name": "app_get", "arguments": {"profile": profile, "app_key": app_key}},
                     )
                 expected_button_summary = _normalize_expected_view_buttons_for_compare(
                     explicit_button_dtos or [],
@@ -12671,10 +12484,6 @@ class AiBuilderFacade:
                     existing_key = _extract_view_key(matched_existing_view)
             created_key: str | None = None
             system_view_list_type = _resolve_system_view_list_type(view_key=existing_key, view_name=patch.name) if existing_key else None
-            if system_view_list_type is not None and os.environ.get("QINGFLOW_VIEWS_APPLY_SKIP_SYSTEM_VIEW_SYNC", "").strip().lower() in {"1", "true", "yes", "on"}:
-                # 环境受限开关:默认视图列序同步依赖 app apply/baseInfo 回读,在快照/脱敏环境上该读面可能不可用;
-                # 视图写主体(view_update)不受影响,仅跳过同步与尾部校验。
-                system_view_list_type = None
             operation_phase = "view_update" if existing_key else "view_create"
             query_condition_payload_for_apply = deepcopy(query_condition_payload)
             expected_query_conditions_for_verify = deepcopy(expected_query_conditions)
@@ -12708,17 +12517,16 @@ class AiBuilderFacade:
                         views=self.views,
                         profile=profile,
                         source_viewgraph_key=existing_key,
-                        hierarchy_filter_groups=hierarchy_root_filter_groups,
                         schema=schema,
                         patch=patch,
                         view_filters=translated_filters,
-                        fields_by_que_id=fields_by_que_id,
+                        current_fields_by_name=current_fields_by_name,
                         auth_override=view_auth_override,
                         explicit_button_dtos=explicit_button_dtos,
                         query_condition_payload=query_condition_payload_for_apply,
                         associated_resources_payload=associated_resources_payload_for_apply,
                     )
-                    self._apply_view_update(profile=profile, view_key=existing_key, payload=payload)
+                    self.views.view_update(profile=profile, viewgraph_key=existing_key, payload=payload)
                     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"
@@ -12729,9 +12537,7 @@ class AiBuilderFacade:
                             payload=payload,
                             list_type=system_view_list_type,
                             schema=schema,
-                            visible_field_names=[
-                                str((fields_by_que_id.get(que) or {}).get("name") or "") for que in apply_columns if que in fields_by_que_id
-                            ],
+                            visible_field_names=apply_columns,
                         )
                         if not bool(system_view_sync.get("verified")):
                             failure_entry = {
@@ -12756,23 +12562,24 @@ class AiBuilderFacade:
                                     "apply_columns": apply_columns,
                                 },
                             }
-                            failure_result = failure_entry
-                            view_result = failure_entry
+                            failed_views.append(failure_entry)
+                            view_results.append(failure_entry)
                             continue
                     updated.append(patch.name)
-                    view_result = {
-                        "name": patch.name,
-                        "view_key": existing_key,
-                        "type": patch.type.value,
-                        "status": "updated",
-                        "expected_filters": deepcopy(translated_filters),
-                        "expected_buttons": deepcopy(expected_button_summary),
-                        "expected_query_conditions": deepcopy(expected_query_conditions_for_verify),
-                        "expected_associated_resources": deepcopy(expected_associated_resources_for_verify),
-                        "expected_pinned": patch.pinned,
-                        "system_view_sync": system_view_sync,
-                        "apply_columns": deepcopy(apply_columns),
-                    }
+                    view_results.append(
+                        {
+                                "name": patch.name,
+                                "view_key": existing_key,
+                                "type": patch.type.value,
+                                "status": "updated",
+                                "expected_filters": deepcopy(translated_filters),
+                                "expected_buttons": deepcopy(expected_button_summary),
+                                "expected_query_conditions": deepcopy(expected_query_conditions_for_verify),
+                                "expected_associated_resources": deepcopy(expected_associated_resources_for_verify),
+                                "system_view_sync": system_view_sync,
+                                "apply_columns": deepcopy(apply_columns),
+                            }
+                        )
                     record_action_button_intent(patch=patch, view_key=existing_key, index=ordinal - 1)
                 else:
                     template_key = _pick_view_template_key(existing_view_list, desired_type=patch.type.value)
@@ -12784,45 +12591,50 @@ class AiBuilderFacade:
                             views=self.views,
                             profile=profile,
                             source_viewgraph_key=created_key,
-                            hierarchy_filter_groups=hierarchy_root_filter_groups,
                             schema=schema,
                             patch=patch,
                             view_filters=translated_filters,
-                            fields_by_que_id=fields_by_que_id,
+                            current_fields_by_name=current_fields_by_name,
                             auth_override=view_auth_override,
                             explicit_button_dtos=explicit_button_dtos,
                             query_condition_payload=query_condition_payload_for_apply,
                             associated_resources_payload=associated_resources_payload_for_apply,
                         )
-                        self._apply_view_update(profile=profile, view_key=created_key, payload=payload)
+                        self.views.view_update(profile=profile, viewgraph_key=created_key, payload=payload)
                     else:
-                        payload = _build_view_creation_payload(
+                        payload = _build_view_create_payload(
                             app_key=app_key,
                             base_info=base,
                             schema=schema,
                             patch=patch,
                             ordinal=ordinal,
                             view_filters=translated_filters,
-                            fields_by_que_id=fields_by_que_id,
+                            current_fields_by_name=current_fields_by_name,
                             auth_override=view_auth_override,
                             explicit_button_dtos=explicit_button_dtos,
                             query_condition_payload=query_condition_payload_for_apply,
                             associated_resources_payload=associated_resources_payload_for_apply,
-                            hierarchy_filter_groups=hierarchy_root_filter_groups,
                         )
-                        created_key = self._apply_view_create(profile=profile, payload=payload)
+                        create_result = self.views.view_create(profile=profile, payload=payload)
+                        raw_created = create_result.get("result")
+                        if isinstance(raw_created, dict):
+                            raw_view_key = raw_created.get("viewgraphKey") or raw_created.get("viewKey")
+                            created_key = str(raw_view_key).strip() if raw_view_key is not None and str(raw_view_key).strip() else None
+                        elif isinstance(raw_created, str):
+                            created_key = raw_created.strip() or None
                     created.append(patch.name)
-                    view_result = {
-                        "name": patch.name,
-                        "view_key": created_key,
-                        "type": patch.type.value,
-                        "status": "created",
-                        "expected_filters": deepcopy(translated_filters),
-                        "expected_buttons": deepcopy(expected_button_summary),
-                        "expected_query_conditions": deepcopy(expected_query_conditions_for_verify),
-                        "expected_associated_resources": deepcopy(expected_associated_resources_for_verify),
-                        "expected_pinned": patch.pinned,
-                    }
+                    view_results.append(
+                            {
+                                "name": patch.name,
+                                "view_key": created_key,
+                                "type": patch.type.value,
+                                "status": "created",
+                                "expected_filters": deepcopy(translated_filters),
+                                "expected_buttons": deepcopy(expected_button_summary),
+                                "expected_query_conditions": deepcopy(expected_query_conditions_for_verify),
+                                "expected_associated_resources": deepcopy(expected_associated_resources_for_verify),
+                            }
+                        )
                     record_action_button_intent(patch=patch, view_key=created_key, index=ordinal - 1)
             except (QingflowApiError, RuntimeError) as error:
                 api_error = _coerce_api_error(error)
@@ -12849,20 +12661,17 @@ class AiBuilderFacade:
                                 patch=patch,
                                 ordinal=ordinal,
                                 view_filters=translated_filters,
-                                hierarchy_filter_groups=hierarchy_root_filter_groups,
-                                fields_by_que_id=fields_by_que_id,
+                                current_fields_by_name=current_fields_by_name,
                                 auth_override=view_auth_override,
                                 explicit_button_dtos=fallback_button_dtos,
                                 query_condition_payload=query_condition_payload_for_apply,
                                 associated_resources_payload=associated_resources_payload_for_apply,
                             )
-                            self._apply_view_update(profile=profile, view_key=target_key, payload=fallback_payload)
+                            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
-                                and os.environ.get("QINGFLOW_VIEWS_APPLY_SKIP_SYSTEM_VIEW_SYNC", "").strip().lower() not in {"1", "true", "yes", "on"}
+                                if patch.type.value == "table" and target_key
                                 else None
                             )
                             if fallback_system_view_list_type is not None:
@@ -12874,9 +12683,7 @@ class AiBuilderFacade:
                                     payload=fallback_payload,
                                     list_type=fallback_system_view_list_type,
                                     schema=schema,
-                                    visible_field_names=[
-                                        str((fields_by_que_id.get(que) or {}).get("name") or "") for que in apply_columns if que in fields_by_que_id
-                                    ],
+                                    visible_field_names=apply_columns,
                                 )
                                 if not bool(system_view_sync.get("verified")):
                                     failure_entry = {
@@ -12901,42 +12708,44 @@ class AiBuilderFacade:
                                             "apply_columns": apply_columns,
                                         },
                                     }
-                                    failure_result = failure_entry
-                                    view_result = failure_entry
+                                    failed_views.append(failure_entry)
+                                    view_results.append(failure_entry)
                                     continue
                             if existing_key:
                                 updated.append(patch.name)
-                                view_result = {
-                                    "name": patch.name,
-                                    "view_key": existing_key,
-                                    "type": patch.type.value,
-                                    "status": "updated",
-                                    "fallback_applied": True,
-                                    "expected_filters": deepcopy(translated_filters),
-                                    "expected_buttons": deepcopy(expected_button_summary),
-                                    "expected_query_conditions": deepcopy(expected_query_conditions_for_verify),
-                                    "expected_associated_resources": deepcopy(expected_associated_resources_for_verify),
-                                    "expected_pinned": patch.pinned,
-                                    "system_view_sync": system_view_sync,
-                                    "apply_columns": deepcopy(apply_columns),
-                                }
+                                view_results.append(
+                                    {
+                                        "name": patch.name,
+                                        "view_key": existing_key,
+                                        "type": patch.type.value,
+                                        "status": "updated",
+                                        "fallback_applied": True,
+                                        "expected_filters": deepcopy(translated_filters),
+                                        "expected_buttons": deepcopy(expected_button_summary),
+                                        "expected_query_conditions": deepcopy(expected_query_conditions_for_verify),
+                                        "expected_associated_resources": deepcopy(expected_associated_resources_for_verify),
+                                        "system_view_sync": system_view_sync,
+                                        "apply_columns": deepcopy(apply_columns),
+                                    }
+                                )
                                 record_action_button_intent(patch=patch, view_key=existing_key, index=ordinal - 1)
                             else:
                                 created.append(patch.name)
-                                view_result = {
-                                    "name": patch.name,
-                                    "view_key": created_key,
-                                    "type": patch.type.value,
-                                    "status": "created",
-                                    "fallback_applied": True,
-                                    "expected_filters": deepcopy(translated_filters),
-                                    "expected_buttons": deepcopy(expected_button_summary),
-                                    "expected_query_conditions": deepcopy(expected_query_conditions_for_verify),
-                                    "expected_associated_resources": deepcopy(expected_associated_resources_for_verify),
-                                    "expected_pinned": patch.pinned,
-                                    "system_view_sync": system_view_sync,
-                                    "apply_columns": deepcopy(apply_columns),
-                                }
+                                view_results.append(
+                                    {
+                                        "name": patch.name,
+                                        "view_key": created_key,
+                                        "type": patch.type.value,
+                                        "status": "created",
+                                        "fallback_applied": True,
+                                        "expected_filters": deepcopy(translated_filters),
+                                        "expected_buttons": deepcopy(expected_button_summary),
+                                        "expected_query_conditions": deepcopy(expected_query_conditions_for_verify),
+                                        "expected_associated_resources": deepcopy(expected_associated_resources_for_verify),
+                                        "system_view_sync": system_view_sync,
+                                        "apply_columns": deepcopy(apply_columns),
+                                    }
+                                )
                                 record_action_button_intent(patch=patch, view_key=created_key, index=ordinal - 1)
                             continue
                         fallback_payload = _build_minimal_view_payload(
@@ -12945,16 +12754,16 @@ class AiBuilderFacade:
                             patch=patch,
                             ordinal=ordinal,
                             view_filters=translated_filters,
-                            hierarchy_filter_groups=hierarchy_root_filter_groups,
-                            fields_by_que_id=fields_by_que_id,
+                            current_fields_by_name=current_fields_by_name,
                             auth_override=view_auth_override,
                             explicit_button_dtos=explicit_button_dtos,
                             query_condition_payload=query_condition_payload_for_apply,
                             associated_resources_payload=associated_resources_payload_for_apply,
                         )
-                        self._apply_view_create(profile=profile, payload=fallback_payload)
+                        self.views.view_create(profile=profile, payload=fallback_payload)
                         created.append(patch.name)
-                        view_result = {
+                        view_results.append(
+                            {
                                 "name": patch.name,
                                 "view_key": created_key,
                                 "type": patch.type.value,
@@ -12964,6 +12773,7 @@ class AiBuilderFacade:
                                 "expected_query_conditions": deepcopy(expected_query_conditions_for_verify),
                                 "expected_associated_resources": deepcopy(expected_associated_resources_for_verify),
                             }
+                        )
                         record_action_button_intent(patch=patch, view_key=created_key, index=ordinal - 1)
                         continue
                     except (QingflowApiError, RuntimeError) as fallback_error:
@@ -12989,16 +12799,11 @@ class AiBuilderFacade:
                         "view_name": patch.name,
                         "view_type": patch.type.value,
                         "columns": patch.columns,
-                        "group_que_id": patch.group_que_id,
-                        "filters": [
-                            (item.model_dump(mode="json") if hasattr(item, "model_dump") else item)
-                            if not isinstance(item, list)
-                            else [sub.model_dump(mode="json") if hasattr(sub, "model_dump") else sub for sub in item]
-                            for item in patch.filters
-                        ],
-                        "start_que_id": patch.start_que_id,
-                        "end_que_id": patch.end_que_id,
-                        "title_que_id": patch.title_que_id,
+                        "group_by": patch.group_by,
+                        "filters": [item.model_dump(mode="json") for item in patch.filters],
+                        "start_field": patch.start_field,
+                        "end_field": patch.end_field,
+                        "title_field": patch.title_field,
                         "operation": "sync_default_view" if operation_phase == "default_view_apply_config_sync" else ("update" if existing_key or created_key else "create"),
                         "list_type": system_view_list_type,
                         "transport_error": {
@@ -13008,69 +12813,24 @@ class AiBuilderFacade:
                         },
                         **_view_apply_failure_diagnostics(
                             patch=patch,
-                            fields_by_que_id=fields_by_que_id,
+                            current_fields_by_name=current_fields_by_name,
                             backend_code=api_error.backend_code,
                             operation_phase=operation_phase,
                         ),
                     },
                 }
-                failure_result = failure_entry
-                view_result = failure_entry
+                failed_views.append(failure_entry)
+                view_results.append(failure_entry)
                 continue
         view_mutation_ms += _duration_ms(view_mutation_started_at)
-        for item in ((view_result,) if view_result is not None else ()):
-            requested_pinned = item.get("expected_pinned")
-            view_key = str(item.get("view_key") or "").strip()
-            if (
-                str(item.get("status") or "") not in {"created", "updated"}
-                or not isinstance(requested_pinned, bool)
-                or not view_key
-            ):
-                continue
-            try:
-                pin_result = self._set_view_pinned(
-                    profile=profile,
-                    app_key=app_key,
-                    view_key=view_key,
-                    pinned=requested_pinned,
-                )
-                item["pinned_state"] = pin_result
-                if not bool(pin_result.get("verified")):
-                    failure_result = {
-                        "name": item.get("name"),
-                        "view_key": view_key,
-                        "type": item.get("type"),
-                        "status": "failed",
-                        "error_code": "VIEW_PIN_STATE_READBACK_MISMATCH",
-                        "message": "view configuration was saved, but its pinned state did not verify",
-                        "operation": "set_pinned",
-                        "details": pin_result,
-                    }
-            except (QingflowApiError, RuntimeError, ValueError) as error:
-                api_error = _coerce_api_error(error)
-                pin_failure = {
-                    "name": item.get("name"),
-                    "view_key": view_key,
-                    "type": item.get("type"),
-                    "status": "failed",
-                    "error_code": "VIEW_PIN_STATE_APPLY_FAILED",
-                    "message": "view configuration was saved, but updating its pinned state failed",
-                    "request_id": api_error.request_id,
-                    "backend_code": api_error.backend_code,
-                    "http_status": api_error.http_status,
-                    "operation": "set_pinned",
-                    "details": {"requested_pinned": requested_pinned},
-                }
-                item["pinned_state"] = {"requested_pinned": requested_pinned, "verified": False}
-                failure_result = pin_failure
         successful_action_view_keys = {
             str(item.get("view_key") or "").strip()
-            for item in ((view_result,) if view_result is not None else ())
+            for item in view_results
             if str(item.get("status") or "") in {"created", "updated"} and str(item.get("view_key") or "").strip()
         }
         successful_action_view_names = {
             str(item.get("name") or "").strip()
-            for item in ((view_result,) if view_result is not None else ())
+            for item in view_results
             if str(item.get("status") or "") in {"created", "updated"} and str(item.get("name") or "").strip()
         }
         skipped_action_button_intents = [
@@ -13121,12 +12881,12 @@ class AiBuilderFacade:
         action_buttons_failed = bool(action_button_intents) and not (action_buttons_verified and view_action_button_bindings_verified)
         action_buttons_retry_payload = action_buttons_result.get("retry_payload") if isinstance(action_buttons_result.get("retry_payload"), dict) else None
         needs_view_list_readback = bool(created or updated)
-        verified_views: list[dict[str, Any]] | None = []
+        verified_view_result: list[dict[str, Any]] | None = []
         verified_views_unavailable = False
         if needs_view_list_readback:
             try:
                 view_readback_started_at = time.perf_counter()
-                verified_views, verified_views_unavailable = self._load_views_result(profile=profile, app_key=app_key, tolerate_404=True)
+                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)
@@ -13140,23 +12900,23 @@ class AiBuilderFacade:
             view_readback_ms += _duration_ms(view_readback_started_at)
         verified_names = {
             _extract_view_name(item)
-            for item in (verified_views or [])
+            for item in (verified_view_result or [])
             if isinstance(item, dict) and _extract_view_name(item)
         }
         verified_by_key = {
             _extract_view_key(item): item
-            for item in (verified_views or [])
+            for item in (verified_view_result or [])
             if isinstance(item, dict) and _extract_view_key(item)
         }
         verified_view_keys_by_name: dict[str, list[str]] = {}
-        for item in (verified_views or []):
+        for item in (verified_view_result or []):
             if not isinstance(item, dict):
                 continue
             name = _extract_view_name(item)
             key = _extract_view_key(item)
             if name and key:
                 verified_view_keys_by_name.setdefault(name, []).append(key)
-        verification_result: dict[str, Any] | None = None
+        verification_by_view: list[dict[str, Any]] = []
         filter_readback_pending = False
         filter_mismatches: list[dict[str, Any]] = []
         query_condition_readback_pending = False
@@ -13183,7 +12943,7 @@ class AiBuilderFacade:
             return cached
 
         view_verification_started_at = time.perf_counter()
-        for item in ((view_result,) if view_result is not None else ()):
+        for item in view_results:
             status = str(item.get("status") or "")
             name = str(item.get("name") or "")
             item_view_key = str(item.get("view_key") or "").strip()
@@ -13226,7 +12986,7 @@ class AiBuilderFacade:
                                 verification_entry["readback_ambiguous"] = True
                                 verification_entry["matching_view_keys"] = matched_keys
                                 filter_readback_pending = True
-                                verification_result = verification_entry
+                                verification_by_view.append(verification_entry)
                                 continue
                         try:
                             config_result, config_error = read_view_config_for_verification(verification_key)
@@ -13244,11 +13004,11 @@ class AiBuilderFacade:
                             filters_verified = filters_semantically_equivalent and actual_data_scope == expected_data_scope
                             public_expected_filters = _public_view_filter_groups_from_match_rules(
                                 expected_filter_summary,
-                                fields_by_que_id=fields_by_que_id,
+                                current_fields_by_name=current_fields_by_name,
                             )
                             public_actual_filters = _public_view_filter_groups_from_match_rules(
                                 semantic_actual_filters,
-                                fields_by_que_id=fields_by_que_id,
+                                current_fields_by_name=current_fields_by_name,
                             )
                             verification_entry["filters_verified"] = filters_verified
                             verification_entry["view_key"] = verification_key
@@ -13298,7 +13058,7 @@ class AiBuilderFacade:
                                 verification_entry["readback_ambiguous"] = True
                                 verification_entry["matching_view_keys"] = matched_keys
                                 query_condition_readback_pending = True
-                                verification_result = verification_entry
+                                verification_by_view.append(verification_entry)
                                 continue
                         try:
                             config_result, config_error = read_view_config_for_verification(verification_key)
@@ -13347,7 +13107,7 @@ class AiBuilderFacade:
                                 verification_entry["readback_ambiguous"] = True
                                 verification_entry["matching_view_keys"] = matched_keys
                                 associated_resource_readback_pending = True
-                                verification_result = verification_entry
+                                verification_by_view.append(verification_entry)
                                 continue
                         try:
                             config_result, config_error = read_view_config_for_verification(verification_key)
@@ -13402,7 +13162,7 @@ class AiBuilderFacade:
                                 verification_entry["readback_ambiguous"] = True
                                 verification_entry["matching_view_keys"] = matched_keys
                                 button_readback_pending = True
-                                verification_result = verification_entry
+                                verification_by_view.append(verification_entry)
                                 continue
                         try:
                             config_result, config_error = read_view_config_for_verification(verification_key)
@@ -13450,45 +13210,51 @@ class AiBuilderFacade:
                                 "category": api_error.category,
                             }
                             button_readback_pending = True
-                verification_result = verification_entry
+                verification_by_view.append(verification_entry)
             elif status == "removed":
-                verification_result = {
-                    "name": name,
-                    "view_key": item.get("view_key"),
-                    "type": item.get("type"),
-                    "status": "removed",
-                    "present_in_readback": False,
-                    "removed_verified": True,
-                    "delete_executed": bool(item.get("delete_executed")),
-                    "readback_status": item.get("readback_status") or "deleted",
-                    "safe_to_retry_delete": False,
-                }
+                verification_by_view.append(
+                    {
+                        "name": name,
+                        "view_key": item.get("view_key"),
+                        "type": item.get("type"),
+                        "status": "removed",
+                        "present_in_readback": False,
+                        "removed_verified": True,
+                        "delete_executed": bool(item.get("delete_executed")),
+                        "readback_status": item.get("readback_status") or "deleted",
+                        "safe_to_retry_delete": False,
+                    }
+                )
             elif status == "readback_pending" and item.get("operation") == "delete":
                 readback_status = str(item.get("readback_status") or "unavailable")
-                verification_result = {
-                    "name": name,
-                    "view_key": item.get("view_key"),
-                    "type": item.get("type"),
-                    "status": "readback_pending",
-                    "present_in_readback": True if readback_status == "still_exists" else None,
-                    "removed_verified": False,
-                    "delete_executed": bool(item.get("delete_executed")),
-                    "readback_status": readback_status,
-                    "safe_to_retry_delete": False,
-                    "error_code": item.get("error_code"),
-                }
+                verification_by_view.append(
+                    {
+                        "name": name,
+                        "view_key": item.get("view_key"),
+                        "type": item.get("type"),
+                        "status": "readback_pending",
+                        "present_in_readback": True if readback_status == "still_exists" else None,
+                        "removed_verified": False,
+                        "delete_executed": bool(item.get("delete_executed")),
+                        "readback_status": readback_status,
+                        "safe_to_retry_delete": False,
+                        "error_code": item.get("error_code"),
+                    }
+                )
             else:
-                verification_result = {
-                    "name": item.get("name"),
-                    "type": item.get("type"),
-                    "status": "failed",
-                    "present_in_readback": None,
-                    "error_code": item.get("error_code"),
-                }
+                verification_by_view.append(
+                    {
+                        "name": item.get("name"),
+                        "type": item.get("type"),
+                        "status": "failed",
+                        "present_in_readback": None,
+                        "error_code": item.get("error_code"),
+                    }
+                )
         view_verification_ms += _duration_ms(view_verification_started_at)
         removed_delete_results = [
             item
-            for item in ((view_result,) if view_result is not None else ())
+            for item in view_results
             if item.get("operation") == "delete" and bool(item.get("delete_executed"))
         ]
         removed_verified = all(str(item.get("readback_status") or "") == "deleted" for item in removed_delete_results)
@@ -13503,19 +13269,19 @@ class AiBuilderFacade:
         view_associated_resources_verified = verified and not associated_resource_readback_pending and not associated_resource_mismatches
         view_buttons_verified = verified and not button_readback_pending and not button_mismatches and not custom_button_readback_pending
         noop = not created and not updated and not removed and not action_button_write_executed
-        if failure_result is not None:
+        if failed_views:
             successful_changes = bool(created or updated or removed or action_button_write_succeeded)
-            first_failure = failure_result
+            first_failure = failed_views[0]
             response = {
                 "status": "partial_success" if successful_changes else "failed",
                 "error_code": "VIEW_APPLY_PARTIAL" if successful_changes else "VIEW_APPLY_FAILED",
                 "recoverable": True,
-                "message": "view operation completed with a verification failure" if successful_changes else "view operation failed",
+                "message": "applied some view patches; at least one view failed" if successful_changes else "one or more view patches failed",
                 "normalized_args": normalized_args,
                 "missing_fields": [],
                 "allowed_values": {"view_types": [member.value for member in PublicViewType], "view.filter.operator": [member.value for member in ViewFilterOperator]},
                 "details": {
-                    "view_result": deepcopy(view_result) if view_result is not None else None,
+                    "per_view_results": view_results,
                     "filter_mismatches": filter_mismatches,
                     "query_condition_mismatches": query_condition_mismatches,
                     "associated_resource_mismatches": associated_resource_mismatches,
@@ -13533,8 +13299,7 @@ class AiBuilderFacade:
                 "http_status": first_failure.get("http_status"),
                 "noop": noop,
                 "warnings": (
-                    list(stale_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 []
@@ -13574,14 +13339,13 @@ class AiBuilderFacade:
                     "action_buttons_verified": action_buttons_verified,
                     "view_button_bindings_verified": view_action_button_bindings_verified,
                     "views_read_unavailable": verified_views_unavailable,
-                    "view": deepcopy(verification_result) if verification_result is not None else None,
+                    "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,
                 "app_name": app_name,
-                "view_result": deepcopy(view_result) if view_result is not None else None,
-                "views_diff": {"created": created, "updated": updated, "removed": removed, "failed": [failure_result]},
+                "views_diff": {"created": created, "updated": updated, "removed": removed, "failed": failed_views},
                 "verified": verified and view_filters_verified and view_query_conditions_verified and view_associated_resources_verified and view_buttons_verified and action_buttons_verified and view_action_button_bindings_verified,
                 "write_executed": bool(created or updated or removed or action_button_write_executed),
                 "write_succeeded": bool(created or updated or removed or action_button_write_succeeded),
@@ -13589,7 +13353,6 @@ class AiBuilderFacade:
             }
             return finish_with_publish(response)
         warnings: list[dict[str, Any]] = []
-        warnings.extend(stale_warnings)
         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"))
         if query_condition_readback_pending or query_condition_mismatches:
@@ -13608,388 +13371,87 @@ class AiBuilderFacade:
                 )
             )
         if delete_readback_pending:
-            warnings.append(
-                _warning(
-                    "VIEW_DELETE_READBACK_PENDING",
-                    "view delete was sent, but deletion readback is not fully verified; do not blindly repeat delete",
-                )
-            )
-        all_verified = (
-            verified
-            and view_filters_verified
-            and view_query_conditions_verified
-            and view_associated_resources_verified
-            and view_buttons_verified
-            and action_buttons_verified
-            and view_action_button_bindings_verified
-        )
-        action_buttons_error_code = str(action_buttons_result.get("error_code") or "VIEW_ACTION_BUTTONS_APPLY_FAILED") if action_buttons_failed else None
-        response = {
-            "status": "success" if all_verified else "partial_success",
-            "error_code": None if all_verified else (action_buttons_error_code if action_buttons_failed else "VIEW_BUTTON_READBACK_MISMATCH" if button_mismatches else "VIEW_ASSOCIATED_RESOURCE_READBACK_MISMATCH" if associated_resource_mismatches else "VIEW_QUERY_CONDITION_READBACK_MISMATCH" if query_condition_mismatches else "VIEW_FILTER_READBACK_MISMATCH" if filter_mismatches else "VIEWS_READBACK_PENDING"),
-            "recoverable": not all_verified,
-            "message": (
-                "applied view patch"
-                if all_verified
-                else "applied view patch; inline action buttons did not fully verify"
-                if action_buttons_failed
-                else "applied view patch; buttons did not fully verify"
-                if button_mismatches
-                else "applied view patch; associated resources did not fully verify"
-                if associated_resource_mismatches
-                else "applied view patch; query conditions did not fully verify"
-                if query_condition_mismatches
-                else "applied view patch; filters did not fully verify"
-                if filter_mismatches
-                else "applied view patch; views readback pending"
-            ),
-            "normalized_args": normalized_args,
-            "missing_fields": [],
-            "allowed_values": {"view_types": [member.value for member in PublicViewType], "view.filter.operator": [member.value for member in ViewFilterOperator], "view.associated_resources.limit_type": ["all", "select"]},
-            "details": {
-                **({"filter_mismatches": filter_mismatches} if filter_mismatches else {}),
-                **({"query_condition_mismatches": query_condition_mismatches} if query_condition_mismatches else {}),
-                **({"associated_resource_mismatches": associated_resource_mismatches} if associated_resource_mismatches else {}),
-                **({"button_mismatches": button_mismatches} if button_mismatches else {}),
-                "view_result": deepcopy(view_result) if view_result is not None else None,
-                **({"action_buttons_result": action_buttons_result} if action_button_intents 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 all_verified else (action_buttons_retry_payload if action_buttons_failed and action_buttons_retry_payload else {"tool_name": "app_get", "arguments": {"profile": profile, "app_key": app_key}}),
-            "noop": noop,
-            "warnings": warnings,
-            "verification": {
-                "views_verified": verified,
-                "view_filters_verified": view_filters_verified,
-                "view_query_conditions_verified": view_query_conditions_verified,
-                "view_associated_resources_verified": view_associated_resources_verified,
-                "view_buttons_verified": view_buttons_verified,
-                "action_buttons_verified": action_buttons_verified,
-                "view_button_bindings_verified": view_action_button_bindings_verified,
-                "views_read_unavailable": verified_views_unavailable,
-                "filter_readback_pending": filter_readback_pending,
-                "query_condition_readback_pending": query_condition_readback_pending,
-                "associated_resource_readback_pending": associated_resource_readback_pending,
-                "button_readback_pending": button_readback_pending,
-                "delete_readback_pending": delete_readback_pending,
-                "custom_button_readback_pending": custom_button_readback_pending,
-                "custom_button_readback_pending_entries": deepcopy(custom_button_readback_pending_entries),
-                "view": deepcopy(verification_result) if verification_result is not None else None,
-            },
-            "app_key": app_key,
-            "app_name": app_name,
-            "view_result": deepcopy(view_result) if view_result is not None else None,
-            "views_diff": {"created": created, "updated": updated, "removed": removed, "failed": []},
-            "verified": all_verified,
-            "write_executed": bool(created or updated or removed or action_button_write_executed),
-            "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 finish_with_publish(response)
-
-    def app_views_schema(
-        self,
-        *,
-        schema_version: str | None = None,
-        schema_kind: str | None = None,
-    ) -> JSONObject:
-        """读取版本化视图声明 schema；detail kind 用于获取专项配置定义。"""
-        normalized_args = {"schema_version": schema_version, "schema_kind": schema_kind}
-        try:
-            payload = views_schema_registry().schema(schema_version=schema_version, schema_kind=schema_kind)
-        except ViewsContractError as error:
-            return _failed(
-                error.error_code,
-                str(error.message),
-                normalized_args=normalized_args,
-                details={"reason_path": error.path or "", **(error.details or {})},
-                suggested_next_call={"tool_name": "app_views_schema", "arguments": {"schema_kind": "summary"}},
-            )
-        return {
-            "status": "success",
-            "error_code": None,
-            "recoverable": False,
-            "message": "read views declaration schema",
-            "normalized_args": normalized_args,
-            "missing_fields": [],
-            "allowed_values": {"schema_kind": payload["supportedSchemaKinds"]},
-            "details": {},
-            "request_id": None,
-            "suggested_next_call": None,
-            "warnings": [],
-            "verification": {"schema_loaded": True},
-            **payload,
-        }
-
-    def app_views_get(
-        self,
-        *,
-        profile: str,
-        app_key: str,
-        schema_version: str | None = None,
-        schema_kind: str = "summary",
-    ) -> JSONObject:
-        """读取应用的 canonical 视图声明数组(summary 级投影或 complete 反向编译)。"""
-        normalized_args = {"app_key": app_key, "schema_version": schema_version, "schema_kind": schema_kind}
-        try:
-            context = views_schema_registry().resolve_schema_version(schema_version)
-        except ViewsContractError as error:
-            return _failed(
-                error.error_code,
-                str(error.message),
-                normalized_args=normalized_args,
-                details={"reason_path": error.path or "", **(error.details or {})},
-                suggested_next_call={"tool_name": "app_views_schema", "arguments": {"schema_kind": "summary"}},
-            )
-        try:
-            views, _views_unavailable = self._load_views_result(profile=profile, app_key=app_key, tolerate_404=False)
-        except (QingflowApiError, RuntimeError) as error:
-            api_error = _coerce_api_error(error)
-            return _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}},
-            )
-        schema, _schema_source = self._read_schema_with_fallback(profile=profile, app_key=app_key)
-        parsed_schema = _parse_schema(schema)
-        # 读面 summary 面向 agent 展示字段名:从原始 schema 递归收集(同名不丢);
-        # 系统列(queId<=5)用公开名映射,未知系统列以 queId 展示兜底
-        name_by_que_id: dict[int, str] = {
-            **{system_id: name for system_id, name in _SYSTEM_VIEW_QUE_NAMES.items()},
-            **_collect_field_id_to_name(schema),
-        }
-        normalized_kind = str(schema_kind or "summary").strip().lower()
-        if normalized_kind == "complete":
-            return self._app_views_get_complete(
-                profile=profile,
-                app_key=app_key,
-                views=views,
-                parsed_schema=parsed_schema,
-                normalized_args=normalized_args,
-                schema_version=schema_version,
-            )
-        projected: list[dict[str, Any]] = []
-        scope_map = {"ALL": "all", "ONESELF": "oneself", "DEPT": "dept", "SUBORDINATE": "subordinate", "CUSTOM": "custom"}
-        for view in views if isinstance(views, list) else []:
-            if not isinstance(view, dict):
-                continue
-            entry: dict[str, Any] = {
-                "view_key": _extract_view_key(view),
-                "name": _extract_view_name(view),
-                "type": _normalize_view_type_name(view.get("viewgraphType") or view.get("type")),
-            }
-            columns = [name_by_que_id.get(que_id, str(que_id)) for que_id in view.get("viewgraphQueIds") or [] if isinstance(que_id, int)]
-            if columns:
-                entry["columns"] = columns
-            group_que_id = _coerce_positive_int(view.get("groupQueId"))
-            if group_que_id is not None and group_que_id in name_by_que_id:
-                entry["group_by"] = name_by_que_id[group_que_id]
-            gantt_config = view.get("viewgraphGanttConfigVO")
-            if isinstance(gantt_config, dict):
-                for source, target in (
-                    ("startTimeQueId", "start_field"),
-                    ("endTimeQueId", "end_field"),
-                    ("titleQueId", "title_field"),
-                ):
-                    gantt_que_id = _coerce_positive_int(gantt_config.get(source))
-                    if gantt_que_id is not None and gantt_que_id in name_by_que_id:
-                        entry[target] = name_by_que_id[gantt_que_id]
-            title_que_id = _coerce_positive_int(view.get("titleQue"))
-            if title_que_id is not None and title_que_id in name_by_que_id:
-                entry.setdefault("title_field", name_by_que_id[title_que_id])
-            data_permission_type = view.get("dataPermissionType")
-            if data_permission_type:
-                entry["data_permission"] = {
-                    "type": "config" if str(data_permission_type).upper() == "CONFIG" else "custom",
-                    "scope": scope_map.get(str(view.get("dataScope") or "").upper(), "all"),
-                }
-            projected.append(entry)
-        return {
-            "status": "success",
-            "error_code": None,
-            "recoverable": False,
-            "message": "read canonical views declarations",
-            "normalized_args": normalized_args,
-            "missing_fields": [],
-            "allowed_values": {"view_types": [member.value for member in PublicViewType]},
-            "details": {},
-            "request_id": None,
-            "suggested_next_call": None,
-            "warnings": [],
-            "verification": {"views_read": len(projected)},
-            "schemaVersion": context.schema_version,
-            "apiVersion": context.api_version,
-            "latestVersion": views_schema_registry().latest_version,
-            "app_key": app_key,
-            "views": projected,
-        }
-
-    def _app_views_get_complete(
-        self,
-        *,
-        profile: str,
-        app_key: str,
-        views: Any,
-        parsed_schema: dict[str, Any],
-        normalized_args: JSONObject,
-        schema_version: str | None,
-    ) -> JSONObject:
-        """complete 档 canonical:逐视图 GET /view/{key}/viewConfig → 反向编译。"""
-        from .views_extract import extract_complete_view_declaration, summarize_gaps
-
-        fields_by_que_id = _collect_fields_by_que_id(parsed_schema["fields"])
-        projected: list[dict[str, Any]] = []
-        read_errors: list[dict[str, Any]] = []
-        all_gaps: list[dict[str, Any]] = []
-        for view in views if isinstance(views, list) else []:
-            if not isinstance(view, dict):
-                continue
-            view_key = _extract_view_key(view)
-            view_name = _extract_view_name(view)
-            if not view_key:
-                continue
-            if _resolve_system_view_list_type(view_key=view_key, view_name=view_name) is not None and not _normalize_view_type_name(view.get("viewgraphType") or view.get("type")):
-                # 系统视图（列表/申请页等，viewgraphKey 为固定数字 id）：不在公开声明语义内，直接跳过。
-                continue
-            try:
-                config = self.views.view_get_config(profile=profile, viewgraph_key=view_key).get("result") or {}
-            except (QingflowApiError, RuntimeError) as error:
-                api_error = _coerce_api_error(error)
-                read_errors.append(
-                    {
-                        "view_key": view_key,
-                        "name": view_name,
-                        "error_code": "VIEW_CONFIG_READ_FAILED",
-                        "http_status": api_error.http_status,
-                        "message": str(api_error.message or error),
-                    }
-                )
-                continue
-            if not isinstance(config, dict) or not config:
-                read_errors.append({"view_key": view_key, "name": view_name, "error_code": "VIEW_CONFIG_EMPTY", "message": "viewConfig read returned no data"})
-                continue
-            declaration, gaps = extract_complete_view_declaration(config, fields_by_que_id=fields_by_que_id)
-            if not declaration:
-                read_errors.append(
-                    {
-                        "view_key": view_key,
-                        "name": view_name,
-                        "error_code": "VIEW_NOT_EXTRACTABLE",
-                        "message": "view configuration cannot be represented completely by the public contract; see gaps",
-                        "gaps": gaps,
-                    }
+            warnings.append(
+                _warning(
+                    "VIEW_DELETE_READBACK_PENDING",
+                    "view delete was sent, but deletion readback is not fully verified; do not blindly repeat delete",
                 )
-                continue
-            if gaps:
-                all_gaps.append({"view_key": view_key, "gaps": gaps})
-            projected.append(declaration)
-        gap_summary: dict[str, int] = {}
-        for item in all_gaps:
-            for kind, count in summarize_gaps(item["gaps"]).items():
-                gap_summary[kind] = gap_summary.get(kind, 0) + count
-        context = views_schema_registry().resolve_schema_version(schema_version)
-        return {
-            "status": "success",
-            "error_code": None,
-            "recoverable": False,
-            "message": "read canonical views declarations (complete)",
+            )
+        all_verified = (
+            verified
+            and view_filters_verified
+            and view_query_conditions_verified
+            and view_associated_resources_verified
+            and view_buttons_verified
+            and action_buttons_verified
+            and view_action_button_bindings_verified
+        )
+        action_buttons_error_code = str(action_buttons_result.get("error_code") or "VIEW_ACTION_BUTTONS_APPLY_FAILED") if action_buttons_failed else None
+        response = {
+            "status": "success" if all_verified else "partial_success",
+            "error_code": None if all_verified else (action_buttons_error_code if action_buttons_failed else "VIEW_BUTTON_READBACK_MISMATCH" if button_mismatches else "VIEW_ASSOCIATED_RESOURCE_READBACK_MISMATCH" if associated_resource_mismatches else "VIEW_QUERY_CONDITION_READBACK_MISMATCH" if query_condition_mismatches else "VIEW_FILTER_READBACK_MISMATCH" if filter_mismatches else "VIEWS_READBACK_PENDING"),
+            "recoverable": not all_verified,
+            "message": (
+                "applied view patch"
+                if all_verified
+                else "applied view patch; inline action buttons did not fully verify"
+                if action_buttons_failed
+                else "applied view patch; buttons did not fully verify"
+                if button_mismatches
+                else "applied view patch; associated resources did not fully verify"
+                if associated_resource_mismatches
+                else "applied view patch; query conditions did not fully verify"
+                if query_condition_mismatches
+                else "applied view patch; filters did not fully verify"
+                if filter_mismatches
+                else "applied view patch; views readback pending"
+            ),
             "normalized_args": normalized_args,
             "missing_fields": [],
-            "allowed_values": {"view_types": [member.value for member in PublicViewType]},
+            "allowed_values": {"view_types": [member.value for member in PublicViewType], "view.filter.operator": [member.value for member in ViewFilterOperator], "view.associated_resources.limit_type": ["all", "select"]},
             "details": {
-                "extraction_gap_summary": gap_summary,
-                "extraction_gaps": all_gaps[:50],
-                "config_read_errors": read_errors[:50],
-                "config_read_error_count": len(read_errors),
+                **({"filter_mismatches": filter_mismatches} if filter_mismatches else {}),
+                **({"query_condition_mismatches": query_condition_mismatches} if query_condition_mismatches else {}),
+                **({"associated_resource_mismatches": associated_resource_mismatches} if associated_resource_mismatches else {}),
+                **({"button_mismatches": button_mismatches} if button_mismatches else {}),
+                **({"action_buttons_result": action_buttons_result} if action_button_intents 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,
-            "warnings": [],
-            "verification": {"views_read": len(projected), "views_with_gaps": len(all_gaps), "read_errors": len(read_errors)},
-            "schemaVersion": context.schema_version,
-            "apiVersion": context.api_version,
-            "latestVersion": views_schema_registry().latest_version,
+            "suggested_next_call": None if all_verified else (action_buttons_retry_payload if action_buttons_failed and action_buttons_retry_payload else {"tool_name": "app_get", "arguments": {"profile": profile, "app_key": app_key}}),
+            "noop": noop,
+            "warnings": warnings,
+            "verification": {
+                "views_verified": verified,
+                "view_filters_verified": view_filters_verified,
+                "view_query_conditions_verified": view_query_conditions_verified,
+                "view_associated_resources_verified": view_associated_resources_verified,
+                "view_buttons_verified": view_buttons_verified,
+                "action_buttons_verified": action_buttons_verified,
+                "view_button_bindings_verified": view_action_button_bindings_verified,
+                "views_read_unavailable": verified_views_unavailable,
+                "filter_readback_pending": filter_readback_pending,
+                "query_condition_readback_pending": query_condition_readback_pending,
+                "associated_resource_readback_pending": associated_resource_readback_pending,
+                "button_readback_pending": button_readback_pending,
+                "delete_readback_pending": delete_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,
-            "views": projected,
-        }
-
-    def app_views_validate(
-        self,
-        *,
-        declaration: JSONObject,
-        schema_version: str | None = None,
-    ) -> JSONObject:
-        """纯离线校验一条视图声明；不访问后端。"""
-        normalized_args = {"schema_version": schema_version}
-        resolved_version = str(schema_version or (declaration.get("schema_version") if isinstance(declaration, dict) else None) or "").strip() or None
-        try:
-            context = views_schema_registry().resolve_schema_version(resolved_version)
-        except ViewsContractError as error:
-            return _failed(
-                error.error_code,
-                str(error.message),
-                normalized_args=normalized_args,
-                details={"reason_path": error.path or "", **(error.details or {})},
-                suggested_next_call={"tool_name": "app_views_schema", "arguments": {"schema_kind": "complete"}},
-            )
-        issues: list[dict[str, Any]] = []
-        batch_keys = ("views", "upsert_views", "upsertViews", "apps")
-        if not isinstance(declaration, dict):
-            issues.append({"path": "/", "code": "INVALID_SPEC", "message": "views declaration must be a JSON object"})
-        elif any(key in declaration for key in batch_keys):
-            issues.append(
-                {
-                    "path": "/",
-                    "code": "VIEW_BATCH_CREATE_UNSUPPORTED",
-                    "message": "views schema validates one view declaration; batch envelopes are unsupported",
-                }
-            )
-        else:
-            declaration_item = {
-                key: value
-                for key, value in declaration.items()
-                if key not in {"schema_version", "schemaVersion", "apiVersion"}
-            }
-            try:
-                parsed = ViewUpsertPatch.model_validate(declaration_item)
-                context.validate_declaration(compact_none_values(public_view_upsert_payload(parsed)))
-            except ValidationError as exc:
-                first_error = exc.errors()[0]
-                issues.append(
-                    {
-                        "path": f"/{'/'.join(str(part) for part in first_error.get('loc', ()))}".rstrip("/"),
-                        "code": "INVALID_SPEC",
-                        "message": str(first_error.get("msg") or exc),
-                    }
-                )
-            except ViewsContractError as error:
-                issues.append({"path": error.path or "/", "code": error.error_code, "message": str(error.message)})
-        ok = not issues
-        return {
-            "status": "success" if ok else "failed",
-            "error_code": None if ok else issues[0]["code"],
-            "recoverable": True,
-            "message": "views declaration is valid" if ok else "views declaration failed validation",
-            "normalized_args": normalized_args,
-            "missing_fields": [],
-            "allowed_values": {},
-            "details": {"issues": issues},
-            "request_id": None,
-            "suggested_next_call": None,
-            "warnings": [],
-            "verification": {"validated_entries": 1 if ok else 0},
-            "ok": ok,
-            "schemaVersion": context.schema_version,
-            "apiVersion": context.api_version,
-            "issues": issues,
+            "app_name": app_name,
+            "views_diff": {"created": created, "updated": updated, "removed": removed, "failed": []},
+            "verified": all_verified,
+            "write_executed": bool(created or updated or removed or action_button_write_executed),
+            "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 finish_with_publish(response)
 
     def app_publish_verify(
         self,
@@ -15967,76 +15429,6 @@ class AiBuilderFacade:
         result = legacy_normalized or normalized_views
         return (result, False, None) if include_error else (result, False)
 
-    def _set_view_pinned(
-        self,
-        *,
-        profile: str,
-        app_key: str,
-        view_key: str,
-        pinned: bool,
-    ) -> dict[str, Any]:
-        """Move one view between the application-level fixed and ordinary lists."""
-        target_key = str(view_key or "").strip()
-        if not target_key:
-            raise ValueError("view_key is required to update the pinned state")
-        response = self.views.view_list(profile=profile, app_key=app_key)
-        raw_groups = response.get("result") if isinstance(response, dict) else None
-        if not isinstance(raw_groups, list):
-            raise ValueError("view list does not expose ordinal groups")
-
-        group_keys: dict[str, list[str]] = {
-            "FIXED_VIEW_LIST": [],
-            "VIEW_LIST": [],
-        }
-        for group in raw_groups:
-            if not isinstance(group, dict):
-                continue
-            ordinal_type = str(group.get("ordinalType") or "").strip()
-            if ordinal_type not in group_keys:
-                continue
-            view_list = group.get("viewList")
-            if not isinstance(view_list, list):
-                continue
-            group_keys[ordinal_type] = [
-                key
-                for item in view_list
-                if isinstance(item, dict)
-                and (key := _extract_view_key(item))
-                and key != target_key
-            ]
-
-        target_group = "FIXED_VIEW_LIST" if pinned else "VIEW_LIST"
-        group_keys[target_group].append(target_key)
-        self.views.view_reorder(
-            profile=profile,
-            app_key=app_key,
-            payload=[
-                {"ordinalType": "FIXED_VIEW_LIST", "viewKeyList": group_keys["FIXED_VIEW_LIST"]},
-                {"ordinalType": "VIEW_LIST", "viewKeyList": group_keys["VIEW_LIST"]},
-            ],
-        )
-
-        readback = self.views.view_list(profile=profile, app_key=app_key)
-        readback_groups = readback.get("result") if isinstance(readback, dict) else None
-        actual_group: str | None = None
-        if isinstance(readback_groups, list):
-            for group in readback_groups:
-                if not isinstance(group, dict):
-                    continue
-                ordinal_type = str(group.get("ordinalType") or "").strip()
-                for item in group.get("viewList") or []:
-                    if isinstance(item, dict) and _extract_view_key(item) == target_key:
-                        actual_group = ordinal_type
-                        break
-                if actual_group is not None:
-                    break
-        return {
-            "requested_pinned": pinned,
-            "actual_pinned": actual_group == "FIXED_VIEW_LIST" if actual_group is not None else None,
-            "verified": actual_group == target_group,
-            "actual_ordinal_type": actual_group,
-        }
-
     def _load_workflow_result(
         self,
         *,
@@ -17464,7 +16856,7 @@ def _resolve_custom_button_view_button_ref(
             "reason_path": reason_path,
             "button_ref": button_ref,
             "message": "button_ref id does not exist in the current app draft or was removed in this apply",
-            "next_action": "call app_get_buttons with button_text to find an existing button_id, or use a client_key from upsert_buttons",
+            "next_action": "call app_get and use custom_buttons[].button_id, or use a client_key from upsert_buttons",
         }
     ref_text = str(button_ref or "").strip()
     if ref_text in client_key_map:
@@ -19834,44 +19226,40 @@ def _chart_apply_batching_context(
 def _view_apply_failure_diagnostics(
     *,
     patch: ViewUpsertPatch,
-    fields_by_que_id: dict[int, dict[str, Any]],
+    current_fields_by_name: dict[str, dict[str, Any]],
     backend_code: Any,
     operation_phase: str,
 ) -> dict[str, Any]:
-    references: list[tuple[int, str]] = []
+    references: list[tuple[str, str]] = []
 
-    def add_reference(value: Any, source: str) -> None:
-        que_id = _coerce_positive_int(value)
-        if que_id is not None:
-            references.append((que_id, source))
+    def add_reference(name: Any, source: str) -> None:
+        text = str(name or "").strip()
+        if text:
+            references.append((text, source))
 
     for column in patch.columns:
         add_reference(column, "columns")
-    add_reference(patch.group_que_id, "group_que_id")
-    add_reference(patch.start_que_id, "start_que_id")
-    add_reference(patch.end_que_id, "end_que_id")
-    add_reference(patch.title_que_id, "title_que_id")
-    for item in patch.filters:
-        if isinstance(item, list):
-            for rule in item:
-                add_reference(getattr(rule, "que_id", None), "filters")
-        else:
-            add_reference(getattr(item, "que_id", None), "filters")
+    add_reference(patch.group_by, "group_by")
+    add_reference(patch.start_field, "start_field")
+    add_reference(patch.end_field, "end_field")
+    add_reference(patch.title_field, "title_field")
+    for rule in patch.filters:
+        add_reference(rule.field_name, "filters")
 
-    seen: set[tuple[int, str]] = set()
+    seen: set[str] = set()
     field_entries: list[dict[str, Any]] = []
-    for que_id, source in references:
-        key = (que_id, source)
+    for field_name, source in references:
+        key = f"{field_name}\0{source}"
         if key in seen:
             continue
         seen.add(key)
-        field = fields_by_que_id.get(que_id) or {}
+        field = current_fields_by_name.get(field_name) or {}
         field_entries.append(
             {
-                "field_name": str(field.get("name") or que_id),
+                "field_name": field_name,
                 "source": source,
                 "field_id": field.get("field_id"),
-                "que_id": field.get("que_id") or que_id,
+                "que_id": field.get("que_id"),
                 "field_type": field.get("type"),
                 "que_type": field.get("que_type"),
                 "exists_in_schema": bool(field),
@@ -19889,7 +19277,7 @@ def _view_apply_failure_diagnostics(
                 "recommended_minimal_retry": {
                     "name": patch.name,
                     "type": patch.type.value,
-                    "columns": [field_entries[0]["que_id"]] if field_entries else [],
+                    "columns": [field_entries[0]["field_name"]] if field_entries else [],
                     **({"filters": [rule.model_dump(mode="json", exclude_none=True) for rule in patch.filters]} if patch.filters else {}),
                 },
             }
@@ -20968,8 +20356,6 @@ def _normalize_portal_view_type(view: dict[str, Any]) -> str:
         "ganttView": "ganttView",
         "hierarchy": "hierarchyView",
         "hierarchyView": "hierarchyView",
-        "calendar": "calendarView",
-        "calendarView": "calendarView",
     }
     return mapping.get(raw, "tableView")
 
@@ -21800,10 +21186,8 @@ def _infer_field_type(question: dict[str, Any]) -> str:
 
 
 def _parse_field(question: dict[str, Any], *, field_id_hint: str | None = None) -> dict[str, Any]:
+    name = str(question.get("queTitle") or "").strip()
     que_id = _coerce_positive_int(question.get("queId"))
-    # 无标题字段用「字段{que_id}」兜底命名,与提取器(eval_replay/views get)对称,
-    # 否则视图列引用无标题字段时 UNKNOWN_VIEW_FIELD
-    name = str(question.get("queTitle") or "").strip() or (f"字段{que_id}" if que_id else "")
     que_type = _coerce_positive_int(question.get("queType"))
     field_type = _infer_field_type(question)
     field_id = field_id_hint or f"field_{que_id or _slugify(name, default='x')}"
@@ -21973,17 +21357,6 @@ def _parse_schema(schema: dict[str, Any]) -> dict[str, Any]:
                 for question in inner_row or []:
                     if not isinstance(question, dict):
                         continue
-                    if _coerce_positive_int(question.get("queType")) == 24:
-                        # 嵌套段落:不注册段落本身,递归解析其 innerQuestions
-                        for nested_row in question.get("innerQuestions", []) or []:
-                            for nested_question in (nested_row if isinstance(nested_row, list) else [nested_row]):
-                                if not isinstance(nested_question, dict):
-                                    continue
-                                nested_field = _parse_field(nested_question)
-                                if str(nested_field["name"] or "").strip():
-                                    fields_by_name.setdefault(nested_field["name"], nested_field)
-                                    labels.append(nested_field["name"])
-                        continue
                     field = _parse_field(question)
                     fields_by_name.setdefault(field["name"], field)
                     labels.append(field["name"])
@@ -22009,16 +21382,8 @@ def _parse_schema(schema: dict[str, Any]) -> dict[str, Any]:
         for question in row:
             if not isinstance(question, dict):
                 continue
-            if _coerce_positive_int(question.get("queType")) == 24:
-                # 同行混入段落容器:不注册段落本身(它的子字段在自己 row),跳过避免同名占位挡住真实字段
-                continue
             field = _parse_field(question)
-            existing = fields_by_name.get(field["name"])
-            # 同名冲突:保留信息更丰富的那个(表格字段带 subfields,被同名普通字段覆盖会丢子字段引用面);
-            # 但 queId 索引必须收录全部同名字段(_collect_fields_by_que_id 按 queId 消费,同名不同 id 各自有效)
-            if existing is None or (not existing.get("subfields") and field.get("subfields")):
-                fields_by_name[field["name"]] = field
-
+            fields_by_name.setdefault(field["name"], field)
             labels.append(field["name"])
         if labels:
             root_rows.append(labels)
@@ -23243,23 +22608,6 @@ def _apply_field_mutation(field: dict[str, Any], mutation: Any) -> None:
         field.pop("_question_rebuild_required", None)
 
 
-class AmbiguousFieldSelector(ValueError):
-    """name-only selector 命中多个同名字段。
-
-    方案 A(duplicate-field-name):后端以 queId 为字段身份、允许同父级同名;
-    name 命中多个字段时禁止静默取第一个,必须显式失败并给出候选 queId。
-    compiler 包装层(app_form)把它转写为 AMBIGUOUS_FIELD_SELECTOR 错误码。
-    """
-
-    def __init__(self, location: str, candidates: list[int]) -> None:
-        self.location = location
-        self.candidates = candidates
-        super().__init__(
-            f"{location} matches multiple fields with the same name; "
-            f"use queId to disambiguate (candidate queIds: {sorted(candidates)})"
-        )
-
-
 def _resolve_field_selector_with_uniqueness(
     *,
     fields: list[dict[str, Any]],
@@ -23275,12 +22623,7 @@ def _resolve_field_selector_with_uniqueness(
         name = str(selector.name or "").strip()
         matched = [field for field in fields if str(field.get("name") or "").strip() == name]
         if len(matched) > 1:
-            candidate_ids = [
-                ref
-                for candidate in matched
-                if (ref := _coerce_any_int(candidate.get("que_id"))) is not None
-            ]
-            raise AmbiguousFieldSelector(location, candidate_ids)
+            raise ValueError(f"{location} matched multiple fields with the same name; use field_id or que_id")
     else:
         matched = []
     if len(matched) != 1:
@@ -26723,11 +26066,7 @@ def _merge_view_summary_with_config(
         return summary
     if isinstance(config.get("auth"), dict):
         summary["visibility_summary"] = _visibility_summary(_public_visibility_from_member_auth(config.get("auth")))
-    legacy_columns = [
-        _SYSTEM_VIEW_QUE_NAMES.get(value if isinstance(value, int) else None, str(value))
-        for value in (summary.get("columns") or [])
-        if str(value or "").strip()
-    ]
+    legacy_columns = [str(value) for value in (summary.get("columns") or []) if str(value or "").strip()]
     question_entries = _extract_view_question_entries(config.get("viewgraphQuestions"))
     canonical_question_entries = _extract_view_question_entries(question_list)
     question_entries_by_id = {
@@ -26873,7 +26212,7 @@ def _merge_view_summary_with_config(
         )
         summary["filters"] = _public_view_filter_groups_from_match_rules(
             config.get("viewgraphLimit"),
-            fields_by_que_id=field_lookup,
+            current_fields_by_name=field_lookup,
         )
         config_enriched = True
     if any(key in config for key in ("asosChartVisible", "asosChartConfig", "asosChartIdList", "limitType")):
@@ -27116,16 +26455,12 @@ def _normalize_print_tpls(value: Any) -> list[dict[str, Any]]:
     items: list[dict[str, Any]] = []
     for item in value:
         if isinstance(item, dict):
-            tpl_id = item.get("printKey")
-            if tpl_id is None:
-                tpl_id = item.get("printTplId")
+            tpl_id = item.get("printTplId")
             if tpl_id is None:
                 tpl_id = item.get("templateId")
             if tpl_id is None:
                 tpl_id = item.get("id")
-            tpl_name = item.get("printName")
-            if tpl_name is None:
-                tpl_name = item.get("printTplName")
+            tpl_name = item.get("printTplName")
             if tpl_name is None:
                 tpl_name = item.get("templateName")
             if tpl_name is None:
@@ -27569,7 +26904,7 @@ def _build_grouped_view_button_config(button_config_dtos: list[dict[str, Any]])
 
 def _build_view_button_dtos(
     *,
-    fields_by_que_id: dict[str, dict[str, Any]],
+    current_fields_by_name: dict[str, dict[str, Any]],
     bindings: list[ViewButtonBindingPatch],
     valid_custom_button_ids: set[int],
 ) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]:
@@ -27578,7 +26913,7 @@ def _build_view_button_dtos(
     for binding in bindings:
         dto, binding_issues = _serialize_view_button_binding(
             binding=binding,
-            fields_by_que_id=fields_by_que_id,
+            current_fields_by_name=current_fields_by_name,
             valid_custom_button_ids=valid_custom_button_ids,
         )
         if binding_issues:
@@ -27591,7 +26926,7 @@ def _build_view_button_dtos(
 def _serialize_view_button_binding(
     *,
     binding: ViewButtonBindingPatch,
-    fields_by_que_id: dict[str, dict[str, Any]],
+    current_fields_by_name: dict[str, dict[str, Any]],
     valid_custom_button_ids: set[int],
     allow_unverified_custom_button_id: bool = False,
 ) -> tuple[dict[str, Any], list[dict[str, Any]]]:
@@ -27606,11 +26941,10 @@ def _serialize_view_button_binding(
                 "reason_path": "buttons[].button_id",
                 "missing_fields": [],
                 "details": {"button_id": binding.button_id},
-                "next_action": "call app_get_buttons with the intended button_text to reuse an existing custom button; create only if absent via app_custom_buttons_apply",
             }
         ]
     translated_limits, limit_issues = _build_view_button_limit_groups(
-        fields_by_que_id=fields_by_que_id,
+        current_fields_by_name=current_fields_by_name,
         groups=binding.button_limit,
     )
     if limit_issues:
@@ -27636,7 +26970,7 @@ def _serialize_view_button_binding(
 
 def _build_view_button_limit_groups(
     *,
-    fields_by_que_id: dict[str, dict[str, Any]],
+    current_fields_by_name: dict[str, dict[str, Any]],
     groups: list[list[ViewFilterRulePatch]],
 ) -> tuple[list[list[dict[str, Any]]], list[dict[str, Any]]]:
     translated_groups: list[list[dict[str, Any]]] = []
@@ -27650,14 +26984,14 @@ def _build_view_button_limit_groups(
                 raw_rule = raw_rule.model_dump(mode="json")
             if not isinstance(raw_rule, dict):
                 continue
-            rule_que_id = _coerce_positive_int(raw_rule.get("que_id"))
-            field = fields_by_que_id.get(rule_que_id) if rule_que_id is not None else None
+            field_name = str(raw_rule.get("field_name") or "").strip()
+            field = current_fields_by_name.get(field_name)
             if field is None:
                 issues.append(
                     {
                         "error_code": "UNKNOWN_VIEW_FIELD",
-                        "missing_fields": [str(raw_rule.get("que_id") or "")],
-                        "reason_path": "buttons[].button_limit[].que_id",
+                        "missing_fields": [field_name] if field_name else [],
+                        "reason_path": "buttons[].button_limit[].field_name",
                     }
                 )
                 continue
@@ -27667,11 +27001,6 @@ def _build_view_button_limit_groups(
                 issue["reason_path"] = "buttons[].button_limit[].values"
                 issues.append(issue)
                 continue
-            stale_warning = translated_rule.pop("_stale_warning", None)
-            if stale_warning is not None:
-                stale_warning = deepcopy(stale_warning)
-                stale_warning["reason_path"] = "buttons[].button_limit[].values"
-                issues.append(stale_warning)
             translated_rules.append(translated_rule)
         if translated_rules:
             translated_groups.append(translated_rules)
@@ -27833,7 +27162,7 @@ def _custom_button_view_configs_from_view_summaries(views: list[dict[str, Any]])
             placement = _public_view_button_placement(entry.get("config_type")) or entry.get("placement")
             raw_button_limit = deepcopy(entry.get("button_limit") or [])
             public_button_limit = (
-                _public_view_filter_groups_from_match_rules(raw_button_limit, fields_by_que_id=field_lookup)
+                _public_view_filter_groups_from_match_rules(raw_button_limit, current_fields_by_name=field_lookup)
                 if raw_button_limit
                 else []
             )
@@ -28031,11 +27360,6 @@ def _field_id_for_name(fields: list[dict[str, Any]], name: str) -> str:
     for field in fields:
         if field["name"] == name:
             return field["field_id"]
-    # 表格子字段是视图列/筛选的合法引用面:顶层未命中时递归 subfields
-    for field in fields:
-        for sub in field.get("subfields") or []:
-            if isinstance(sub, dict) and sub.get("name") == name:
-                return str(sub.get("field_id") or f"field_{sub.get('que_id') or ''}")
     raise KeyError(name)
 
 
@@ -28135,7 +27459,7 @@ def _build_public_workflow_spec(*, nodes: list[dict[str, Any]], transitions: lis
 
 def _build_flow_condition_matrix(
     *,
-    fields_by_que_id: dict[str, dict[str, Any]],
+    current_fields_by_name: dict[str, dict[str, Any]],
     node: dict[str, Any],
 ) -> tuple[list[list[dict[str, Any]]], list[dict[str, Any]]]:
     if str(node.get("type") or "") != "condition":
@@ -28153,7 +27477,7 @@ def _build_flow_condition_matrix(
             if not isinstance(raw_rule, dict):
                 continue
             field_name = str(raw_rule.get("field_name") or "").strip()
-            field = fields_by_que_id.get(field_name)
+            field = current_fields_by_name.get(field_name)
             if field is None:
                 issues.append(
                     {
@@ -28200,9 +27524,7 @@ def _translate_flow_condition_rule(*, field: dict[str, Any], rule: dict[str, Any
         base["judgeType"] = JUDGE_LESS_OR_EQUAL
         base["judgeValues"] = [_stringify_condition_value(values[0])]
     elif operator == "is_empty":
-        # 选项/成员/部门类字段的空值,后端历史形态是 EQUAL_ANY(9)+空值(该类字段用
-        # ANY 语义选值,"没选任何值"也是 9 判型);文本/数字类才是 EQUAL(0)+空值
-        base["judgeType"] = JUDGE_EQUAL_ANY if field_type in INCLUDE_ANY_FLOW_FIELD_TYPES or field_type in {FieldType.single_select.value} else JUDGE_EQUAL
+        base["judgeType"] = JUDGE_EQUAL
         base["judgeValues"] = []
     elif operator == "not_empty":
         base["judgeType"] = JUDGE_UNEQUAL
@@ -28231,7 +27553,7 @@ def _empty_view_query_conditions_payload() -> dict[str, Any]:
 
 def _build_view_query_conditions_payload(
     *,
-    fields_by_que_id: dict[str, dict[str, Any]],
+    current_fields_by_name: dict[str, dict[str, Any]],
     query_conditions: Any,
 ) -> tuple[dict[str, Any] | None, dict[str, Any] | None, list[dict[str, Any]]]:
     if query_conditions is None:
@@ -28271,7 +27593,7 @@ def _build_view_query_conditions_payload(
         compiled_row: list[int] = []
         for column_index, selector in enumerate(row):
             field, issue = _resolve_query_condition_field(
-                fields_by_que_id=fields_by_que_id,
+                current_fields_by_name=current_fields_by_name,
                 selector=selector,
                 reason_path=f"query_conditions.rows[{row_index}][{column_index}]",
             )
@@ -28289,16 +27611,14 @@ def _build_view_query_conditions_payload(
         "queryConditionStatus": enabled,
         "queryConditionExact": exact,
         "hideBeforeQueryCondition": hide_before_query,
-        # 后端 ViewgraphInfo.queryCondition 是 List<ViewgraphQueryConditionConfig>({title?,queIds}),
-        # 不能发裸 [[queId]](fastjson expect {, actual [ → 发现 #7)
-        "queryCondition": [{"queIds": row} for row in rows] if enabled else [],
+        "queryCondition": rows if enabled else [],
     }
     return payload, _normalize_view_query_conditions_for_compare(payload), []
 
 
 def _resolve_query_condition_field(
     *,
-    fields_by_que_id: dict[str, dict[str, Any]],
+    current_fields_by_name: dict[str, dict[str, Any]],
     selector: Any,
     reason_path: str,
 ) -> tuple[dict[str, Any], dict[str, Any] | None]:
@@ -28310,8 +27630,8 @@ def _resolve_query_condition_field(
             "missing_fields": [],
             "message": "query condition field selector cannot be empty",
         }
-    fields = [field for field in fields_by_que_id.values() if isinstance(field, dict)]
-    field = fields_by_que_id.get(raw)
+    fields = [field for field in current_fields_by_name.values() if isinstance(field, dict)]
+    field = current_fields_by_name.get(raw)
     if field is None:
         for candidate in fields:
             if raw == str(candidate.get("field_id") or "").strip():
@@ -28322,7 +27642,7 @@ def _resolve_query_condition_field(
                 field = candidate
                 break
     if field is None:
-        subfield_parent = _find_subtable_subfield_parent(fields_by_que_id=fields_by_que_id, selector=raw)
+        subfield_parent = _find_subtable_subfield_parent(current_fields_by_name=current_fields_by_name, selector=raw)
         if subfield_parent is not None:
             return {}, {
                 "error_code": "INVALID_QUERY_CONDITION_FIELD",
@@ -28370,10 +27690,10 @@ def _resolve_query_condition_field(
 
 def _find_subtable_subfield_parent(
     *,
-    fields_by_que_id: dict[str, dict[str, Any]],
+    current_fields_by_name: dict[str, dict[str, Any]],
     selector: str,
 ) -> dict[str, Any] | None:
-    for field in fields_by_que_id.values():
+    for field in current_fields_by_name.values():
         if not isinstance(field, dict) or str(field.get("type") or "") != FieldType.subtable.value:
             continue
         for subfield in field.get("subfields") or []:
@@ -28434,9 +27754,6 @@ def _normalize_view_query_conditions_for_compare(config: Any) -> dict[str, Any]:
     rows: list[list[int]] = []
     if isinstance(raw_rows, list):
         for raw_row in raw_rows:
-            if isinstance(raw_row, dict):
-                # ViewgraphQueryConditionConfig 形态({title?,queIds})
-                raw_row = raw_row.get("queIds") or []
             if not isinstance(raw_row, list):
                 continue
             compiled_row = [
@@ -28499,18 +27816,11 @@ def _build_view_associated_resources_payload(
         ]
     available_by_id = _associated_resource_index(available_resources)
     if limit_type == "all":
-        # limitType=ALL 时后端保留原 idList 不清(语义忽略但存储保留);
-        # 透传声明的 id 列表,避免 apply 清空→回读 idList 不匹配→READBACK_MISMATCH
-        all_ids = [
-            item_id
-            for item_id in (_coerce_positive_int(raw) for raw in raw_item_ids)
-            if item_id is not None
-        ]
         payload = {
             "asosChartVisible": True,
             "asosChartConfig": {
                 "limitType": ASSOCIATED_RESOURCE_LIMIT_TYPE_ALL,
-                "asosChartIdList": all_ids,
+                "asosChartIdList": [],
             },
         }
         expected = _extract_view_associated_resources_config(payload, available_resources=available_resources)
@@ -28531,19 +27841,26 @@ def _build_view_associated_resources_payload(
             ]
         item_ids.append(item_id)
     missing_ids = [item_id for item_id in item_ids if item_id not in available_by_id]
-    # 兼容存量脏引用:关联资源 id 指向闭包外/已下架的图表或视图时,剔除后继续写而非整视图失败;
-    # 剔除明细记入 expected 供回读校验与响应展示
-    resolvable_ids = [item_id for item_id in item_ids if item_id in available_by_id]
+    if missing_ids:
+        return None, None, [
+            {
+                "error_code": "ASSOCIATED_RESOURCE_NOT_FOUND",
+                "reason_path": "associated_resources.associated_item_ids",
+                "missing_fields": [],
+                "invalid_associated_item_ids": missing_ids,
+                "available_associated_item_ids": sorted(available_by_id),
+                "message": "associated_resource references ids that are not in the app-level associated resource pool",
+                "next_action": "prefer app_associated_resources_apply for associated report/view display; it can resolve associated_item_id, chart_id/chart_key, or view_key",
+            }
+        ]
     payload = {
         "asosChartVisible": True,
         "asosChartConfig": {
             "limitType": ASSOCIATED_RESOURCE_LIMIT_TYPE_SELECT,
-            "asosChartIdList": resolvable_ids,
+            "asosChartIdList": item_ids,
         },
     }
     expected = _extract_view_associated_resources_config(payload, available_resources=available_resources)
-    if isinstance(expected, dict) and missing_ids:
-        expected["dropped_unresolvable_associated_item_ids"] = missing_ids
     return payload, expected, []
 
 
@@ -29280,10 +28597,6 @@ _VIEW_PARTIAL_PATCH_KEY_ALIASES = {
     "view_key": "view_key",
     "viewKey": "view_key",
     "viewgraphKey": "view_key",
-    "pinned": "pinned",
-    "fixed": "pinned",
-    "is_pinned": "pinned",
-    "isPinned": "pinned",
     "type": "type",
     "view_type": "type",
     "viewType": "type",
@@ -29291,25 +28604,17 @@ _VIEW_PARTIAL_PATCH_KEY_ALIASES = {
     "column_names": "columns",
     "columnNames": "columns",
     "fields": "columns",
-    "group_que_id": "group_que_id",
-    "groupQueId": "group_que_id",
-    "group_by": "group_que_id",
-    "groupBy": "group_que_id",
+    "group_by": "group_by",
+    "groupBy": "group_by",
     "filters": "filters",
     "filter_rules": "filters",
     "filterRules": "filters",
-    "start_que_id": "start_que_id",
-    "startQueId": "start_que_id",
-    "start_field": "start_que_id",
-    "startField": "start_que_id",
-    "end_que_id": "end_que_id",
-    "endQueId": "end_que_id",
-    "end_field": "end_que_id",
-    "endField": "end_que_id",
-    "title_que_id": "title_que_id",
-    "titleQueId": "title_que_id",
-    "title_field": "title_que_id",
-    "titleField": "title_que_id",
+    "start_field": "start_field",
+    "startField": "start_field",
+    "end_field": "end_field",
+    "endField": "end_field",
+    "title_field": "title_field",
+    "titleField": "title_field",
     "buttons": "buttons",
     "visibility": "visibility",
     "query_conditions": "query_conditions",
@@ -29396,14 +28701,13 @@ def _normalize_view_partial_unset(raw_unset: Any, *, reason_path: str) -> tuple[
 
 _VIEW_PARTIAL_SET_KEYS = {
     "name",
-    "pinned",
     "type",
     "columns",
-    "group_que_id",
+    "group_by",
     "filters",
-    "start_que_id",
-    "end_que_id",
-    "title_que_id",
+    "start_field",
+    "end_field",
+    "title_field",
     "buttons",
     "visibility",
     "query_conditions",
@@ -29429,108 +28733,6 @@ def _field_name_by_id(field_names_by_id: dict[int, str], field_id: Any) -> str |
     return name or None
 
 
-def _collect_fields_by_que_id(fields: list[dict[str, Any]], *, schema: dict[str, Any] | None = None) -> dict[int, dict[str, Any]]:
-    """构建 queId→field 索引。
-
-    传 schema 时直接从原始 formQues/baseQues 递归收集(同名冲突不丢字段——名字索引
-    只保留第一个,但同名不同 queId 的字段对 queId 引用各自有效);
-    不传 schema 时从解析后的 fields 列表递归 subfields 构建。
-    """
-    index: dict[int, dict[str, Any]] = {}
-
-    type_by_question_type = {v: k for k, v in QUESTION_TYPE_TO_FIELD_TYPE.items()}
-
-    def collect_raw(question: dict[str, Any]) -> None:
-        que_id = _coerce_positive_int(question.get("queId"))
-        if que_id is not None and que_id not in index:
-            que_type = _coerce_positive_int(question.get("queType"))
-            # 用 _parse_field 解析(含 options/option_details,与 _parse_schema 对齐);
-            # 直收原始 dict 的 queTitle/queType 不够——选项字段需 options 才能解析值→id
-            parsed = _parse_field(question)
-            index[que_id] = parsed
-        for key in ("subQuestions", "innerQuestions"):
-            for child in question.get(key) or []:
-                if isinstance(child, list):
-                    for inner in child:
-                        if isinstance(inner, dict):
-                            collect_raw(inner)
-                elif isinstance(child, dict):
-                    collect_raw(child)
-
-    if schema is not None:
-        for base_question in schema.get("baseQues", []) or []:
-            if isinstance(base_question, dict):
-                collect_raw(base_question)
-        for line in schema.get("formQues", []) or []:
-            for question in (line if isinstance(line, list) else [line]):
-                if isinstance(question, dict):
-                    collect_raw(question)
-        return index
-
-    def collect(field: dict[str, Any]) -> None:
-        que_id = _coerce_positive_int(field.get("que_id"))
-        if que_id is not None and que_id not in index:
-            index[que_id] = field
-        for sub in field.get("subfields") or []:
-            if isinstance(sub, dict):
-                collect(sub)
-
-    for field in fields:
-        if isinstance(field, dict):
-            collect(field)
-    return index
-
-
-def _collect_field_id_to_name(schema: dict[str, Any]) -> dict[int, str]:
-    """从 form schema 收集 queId→queTitle(含子字段/段落内字段;同名时各 id 独立映射)。"""
-    id_to_name: dict[int, str] = {}
-
-    def collect(question: dict[str, Any]) -> None:
-        que_id = _coerce_positive_int(question.get("queId"))
-        if que_id is not None and que_id not in id_to_name:
-            title = str(question.get("queTitle") or "").strip()
-            if title:
-                id_to_name[que_id] = title
-        for key in ("subQuestions", "innerQuestions"):
-            for child in question.get(key) or []:
-                if isinstance(child, list):
-                    for inner in child:
-                        if isinstance(inner, dict):
-                            collect(inner)
-                elif isinstance(child, dict):
-                    collect(child)
-
-    for base_question in schema.get("baseQues", []) or []:
-        if isinstance(base_question, dict):
-            collect(base_question)
-    for line in schema.get("formQues", []) or []:
-        for question in (line if isinstance(line, list) else [line]):
-            if isinstance(question, dict):
-                collect(question)
-    return id_to_name
-
-
-def _resolve_field_ref_preserving(
-    config: dict[str, Any],
-    config_key: str,
-    name: str | None,
-    field_map: dict[str, int],
-    id_to_name: dict[int, str],
-) -> int | None:
-    """同名字段歧义消解(字段引用类:card title/cover、board group 等)。
-
-    契约按字段名引用,同 form 内同名字段时按名解析会取到错误的一个。
-    UPDATE 场景读面原 queId 可用:若原 queId 的字段名与声明名一致,保留原 queId(保真);
-    只有声明名与原值名字不同(用户真改了字段)才按名重新解析。
-    """
-    if not name:
-        return None
-    original = _coerce_positive_int(config.get(config_key))
-    if original is not None and id_to_name.get(original) == name:
-        return original
-    return field_map.get(name)
-
-
 def _view_upsert_payload_from_existing_view(
     *,
     config: dict[str, Any],
@@ -29540,28 +28742,25 @@ def _view_upsert_payload_from_existing_view(
 ) -> dict[str, Any]:
     view_type = _normalize_view_type_name(config.get("viewgraphType") or summary.get("type"))
     configured_columns = [
-        que_id
-        for item in (config.get("viewgraphQueIds") or [])
-        if (que_id := _coerce_positive_int(item)) is not None
-        and (field_names_by_id.get(que_id) or "") not in _KNOWN_SYSTEM_VIEW_COLUMNS
+        name
+        for name in (_field_name_by_id(field_names_by_id, item) for item in (config.get("viewgraphQueIds") or []))
+        if name and name not in _KNOWN_SYSTEM_VIEW_COLUMNS
     ]
     columns = [
-        que_id
-        for item in (summary.get("apply_column_ids") or summary.get("columns") or [])
-        if (que_id := _coerce_positive_int(item)) is not None
-        and (field_names_by_id.get(que_id) or "") not in _KNOWN_SYSTEM_VIEW_COLUMNS
+        str(name or "").strip()
+        for name in (summary.get("apply_columns") or summary.get("columns") or [])
+        if str(name or "").strip() and str(name or "").strip() not in _KNOWN_SYSTEM_VIEW_COLUMNS
     ]
     if configured_columns and (not columns or len(configured_columns) >= len(columns)):
         columns = configured_columns
     display_config = summary.get("display_config") if isinstance(summary.get("display_config"), dict) else {}
-    group_que_id = _coerce_positive_int(config.get("groupQueId") or summary.get("group_que_id") or display_config.get("group_que_id"))
-    title_que_id = _coerce_positive_int(config.get("titleQue") or display_config.get("title_que_id"))
+    group_by = str(summary.get("group_by") or display_config.get("group_by") or "").strip() or _field_name_by_id(field_names_by_id, config.get("groupQueId"))
+    title_field = str(display_config.get("title_field") or "").strip() or _field_name_by_id(field_names_by_id, config.get("titleQue"))
     gantt_config = config.get("viewgraphGanttConfigVO") if isinstance(config.get("viewgraphGanttConfigVO"), dict) else {}
-    start_que_id = _coerce_positive_int(gantt_config.get("startTimeQueId"))
-    end_que_id = _coerce_positive_int(gantt_config.get("endTimeQueId"))
-    gantt_title_que_id = _coerce_positive_int(gantt_config.get("titleQueId"))
+    start_field = _field_name_by_id(field_names_by_id, gantt_config.get("startTimeQueId")) if isinstance(gantt_config, dict) else None
+    end_field = _field_name_by_id(field_names_by_id, gantt_config.get("endTimeQueId")) if isinstance(gantt_config, dict) else None
+    gantt_title = _field_name_by_id(field_names_by_id, gantt_config.get("titleQueId")) if isinstance(gantt_config, dict) else None
     query_conditions = _extract_view_query_conditions_config(config)
-    query_conditions["rows"] = query_conditions.get("row_field_ids") or []
     query_conditions.pop("row_field_ids", None)
     associated_resources = _extract_view_associated_resources_config(config)
     payload: dict[str, Any] = {
@@ -29569,6 +28768,7 @@ def _view_upsert_payload_from_existing_view(
         "view_key": view_key,
         "type": view_type or "table",
         "columns": columns,
+        "group_by": group_by,
         "filters": [],
         "query_conditions": query_conditions,
         "associated_resources": {
@@ -29577,17 +28777,15 @@ def _view_upsert_payload_from_existing_view(
             "associated_item_ids": list(associated_resources.get("configured_associated_item_ids") or []),
         },
     }
-    if group_que_id is not None:
-        payload["group_que_id"] = group_que_id
-    if title_que_id is not None:
-        payload["title_que_id"] = title_que_id
+    if title_field:
+        payload["title_field"] = title_field
     if view_type == "gantt":
-        if start_que_id is not None:
-            payload["start_que_id"] = start_que_id
-        if end_que_id is not None:
-            payload["end_que_id"] = end_que_id
-        if gantt_title_que_id is not None:
-            payload["title_que_id"] = gantt_title_que_id
+        if start_field:
+            payload["start_field"] = start_field
+        if end_field:
+            payload["end_field"] = end_field
+        if gantt_title:
+            payload["title_field"] = gantt_title
     return payload
 
 
@@ -29598,7 +28796,7 @@ def _first_present(mapping: dict[str, Any], *keys: str) -> Any:
     return None
 
 
-def _build_view_creation_payload(
+def _build_view_create_payload(
     *,
     app_key: str,
     base_info: dict[str, Any],
@@ -29606,24 +28804,23 @@ def _build_view_creation_payload(
     patch: ViewUpsertPatch,
     ordinal: int,
     view_filters: list[list[dict[str, Any]]] | None,
-    fields_by_que_id: dict[str, dict[str, Any]],
+    current_fields_by_name: dict[str, dict[str, Any]],
     auth_override: dict[str, Any] | None = None,
     explicit_button_dtos: list[dict[str, Any]] | None = None,
     query_condition_payload: dict[str, Any] | None = None,
     associated_resources_payload: dict[str, Any] | None = None,
-    hierarchy_filter_groups: list[list[dict[str, Any]]] | None = None,
 ) -> JSONObject:
     entity = _entity_spec_from_app(base_info=base_info, schema=schema, views=None)
     parsed_schema = _parse_schema(schema)
-    visible_que_ids = _resolve_view_visible_que_ids(patch)
-    field_ids = [f"field_{que}" for que in visible_que_ids]
+    visible_field_names = _resolve_view_visible_field_names(patch)
+    field_ids = [_field_id_for_name(parsed_schema["fields"], name) for name in visible_field_names]
     gantt_config = _build_public_gantt_payload(parsed_schema["fields"], extract_field_map(schema), patch)
     view_spec = ViewSpec(
         view_id=_slugify(patch.name, default=f"view_{uuid4().hex[:6]}"),
         name=patch.name,
         type=patch.type.value,
         field_ids=field_ids,
-        group_by_field_id=f"field_{patch.group_que_id}" if patch.group_que_id else None,
+        group_by_field_id=_field_id_for_name(_parse_schema(schema)["fields"], patch.group_by) if patch.group_by else None,
         config=gantt_config,
     )
     from ..solution.spec_models import EntitySpec
@@ -29632,6 +28829,7 @@ def _build_view_creation_payload(
     compiled = compile_views(EntitySpec.model_validate({**entity, "views": [view_spec.model_dump(mode="json")]}))[0]
     field_map = extract_field_map(schema)
     payload = deepcopy(compiled["create_payload"])
+    visible_que_ids = [field_map[field_name] for field_name in visible_field_names if field_name in field_map]
     payload["appKey"] = app_key
     payload["ordinal"] = ordinal
     payload["viewgraphQueIds"] = visible_que_ids
@@ -29643,21 +28841,17 @@ def _build_view_creation_payload(
         payload["beingShowTitleQue"] = True
         payload["titleQue"] = gantt_config.get("titleQueId") or (visible_que_ids[0] if visible_que_ids else None)
     if patch.type.value == "board":
-        payload["groupQueId"] = patch.group_que_id
+        payload["groupQueId"] = field_map.get(patch.group_by or "")
     return _hydrate_view_backend_payload(
         payload=payload,
         view_type=patch.type.value,
         visible_que_id_values=visible_que_ids,
-        group_que_id=patch.group_que_id,
+        group_que_id=field_map.get(patch.group_by or "") if patch.group_by else None,
         view_filters=view_filters,
         gantt_payload=gantt_config,
         button_config_dtos=explicit_button_dtos,
         query_condition_payload=query_condition_payload,
         associated_resources_payload=associated_resources_payload,
-        patch=patch,
-        field_map=field_map,
-        fields_by_que_id=fields_by_que_id,
-        hierarchy_filter_groups=hierarchy_filter_groups,
     )
 
 
@@ -29795,10 +28989,6 @@ def _normalize_view_type_name(value: Any) -> str:
         return "gantt"
     if "board" in normalized:
         return "board"
-    if "hierarchy" in normalized:
-        return "hierarchy"
-    if "calendar" in normalized:
-        return "calendar"
     if "card" in normalized:
         return "card"
     return "table"
@@ -29812,20 +29002,20 @@ def _build_view_update_payload(
     schema: dict[str, Any],
     patch: ViewUpsertPatch,
     view_filters: list[list[dict[str, Any]]] | None,
-    fields_by_que_id: dict[str, dict[str, Any]],
+    current_fields_by_name: dict[str, dict[str, Any]],
     auth_override: dict[str, Any] | None = None,
     explicit_button_dtos: list[dict[str, Any]] | None = None,
     query_condition_payload: dict[str, Any] | None = None,
     associated_resources_payload: dict[str, Any] | None = None,
-    hierarchy_filter_groups: list[list[dict[str, Any]]] | None = None,
 ) -> JSONObject:
     config_response = views.view_get_config(profile=profile, viewgraph_key=source_viewgraph_key)
     config = config_response.get("result") if isinstance(config_response.get("result"), dict) else {}
     payload = deepcopy(config)
     parsed_schema = _parse_schema(schema)
     field_map = extract_field_map(schema)
-    visible_que_ids = _resolve_view_visible_que_ids(patch)
-    visible_que_id_values = list(visible_que_ids)
+    visible_field_names = _resolve_view_visible_field_names(patch)
+    visible_que_ids = [_field_id_for_name(parsed_schema["fields"], name) for name in visible_field_names]
+    visible_que_id_values = [field_map[name] for name in visible_field_names if name in field_map]
     gantt_payload = _build_public_gantt_payload(parsed_schema["fields"], field_map, patch)
 
     for key in (
@@ -29847,25 +29037,8 @@ def _build_view_update_payload(
     payload["auth"] = deepcopy(auth_override if isinstance(auth_override, dict) else payload.get("auth") or default_member_auth())
     if "viewName" in payload:
         payload["viewName"] = patch.name
-    # 保留系统列在业务列之间的位置；业务列顺序和增删仍由声明决定。
-    existing_que_ids = dict.fromkeys(
-        que_id
-        for que_id in (_coerce_any_int(raw) for raw in (config.get("viewgraphQueIds") or []))
-        if que_id is not None
-    )
-    business_que_ids = iter(que_id for que_id in visible_que_id_values if que_id > 5)
-    merged_que_ids: list[int] = []
-    for que_id in existing_que_ids:
-        if que_id <= 5:
-            merged_que_ids.append(que_id)
-        elif que_id in visible_que_id_values:
-            merged_que_ids.append(next(business_que_ids))
-    merged_que_ids.extend(business_que_ids)
-    merged_que_ids.extend(que_id for que_id in visible_que_id_values if que_id <= 5 and que_id not in merged_que_ids)
-    payload["viewgraphQueIds"] = merged_que_ids
-    payload["viewgraphQuestions"] = _build_viewgraph_questions(
-        schema, merged_que_ids, existing_by_que_id=_flatten_viewgraph_questions(config.get("viewgraphQuestions"))
-    )
+    payload["viewgraphQueIds"] = visible_que_id_values
+    payload["viewgraphQuestions"] = _build_viewgraph_questions(schema, visible_que_id_values)
     payload.setdefault("sortType", "defaultSort")
     payload.setdefault("viewgraphSorts", [{"queId": 0, "beingSortAscend": True, "queType": 8}])
     payload.setdefault("beingPinNavigate", True)
@@ -29895,79 +29068,25 @@ def _build_view_update_payload(
         payload["viewgraphType"] = "boardView"
         payload["beingShowTitleQue"] = True
         payload["titleQue"] = visible_que_id_values[0] if visible_que_id_values else None
-        payload["groupQueId"] = patch.group_que_id
+        payload["groupQueId"] = field_map.get(patch.group_by or "")
     elif normalized_type == "gantt":
         payload["viewgraphType"] = "ganttView"
         payload["beingShowTitleQue"] = True
         payload["titleQue"] = gantt_payload.get("titleQueId") or (visible_que_id_values[0] if visible_que_id_values else None)
         payload.pop("groupQueId", None)
-    elif normalized_type == "hierarchy":
-        payload["viewgraphType"] = "hierarchyView"
-        payload["beingShowTitleQue"] = True
-        payload.pop("groupQueId", None)
-    elif normalized_type == "calendar":
-        payload["viewgraphType"] = "calendarView"
-        payload["beingShowTitleQue"] = True
-        payload.pop("groupQueId", None)
     return _hydrate_view_backend_payload(
         payload=payload,
         view_type=normalized_type,
         visible_que_id_values=visible_que_id_values,
-        group_que_id=patch.group_que_id,
+        group_que_id=field_map.get(patch.group_by or "") if patch.group_by else None,
         view_filters=view_filters,
         gantt_payload=gantt_payload,
         button_config_dtos=button_config_dtos,
         query_condition_payload=query_condition_payload,
         associated_resources_payload=associated_resources_payload,
-        patch=patch,
-        field_map=field_map,
-        fields_by_que_id=fields_by_que_id,
-        hierarchy_filter_groups=hierarchy_filter_groups,
-        schema=schema,
     )
 
 
-# 系统列 queId→公开名(后端语义;读面展示与 viewgraphQueIds 透传时的名称解析)
-_SYSTEM_VIEW_QUE_NAMES = {
-    0: "编号",
-    1: "提交人",
-    2: "提交时间",
-    3: "更新时间",
-    4: "流程标题",
-    5: "当前流程状态",
-    -17: "数据ID",
-    -19: "删除时间",
-    -20: "删除人",
-    -21: "处理节点",
-    -22: "抄送节点",
-    -23: "处理时间",
-    -24: "抄送时间",
-    -25: "接收时间",
-}
-
-_SYSTEM_VIEW_QUE_IDS = frozenset(
-    {
-        *_SYSTEM_VIEW_QUE_NAMES,
-        -1,
-        -2,
-        -3,
-        -4,
-        -5,
-        -6,
-        -7,
-        -8,
-        -18,
-        -30,
-        -31,
-    }
-)
-
-
-def _is_known_system_view_que_id(value: Any) -> bool:
-    que_id = _coerce_any_int(value)
-    return que_id in _SYSTEM_VIEW_QUE_IDS if que_id is not None else False
-
-
 _KNOWN_SYSTEM_VIEW_COLUMNS = {
     "编号",
     "当前流程状态",
@@ -29991,16 +29110,16 @@ def _build_minimal_view_payload(
     patch: ViewUpsertPatch,
     ordinal: int,
     view_filters: list[list[dict[str, Any]]] | None,
-    fields_by_que_id: dict[str, dict[str, Any]],
+    current_fields_by_name: dict[str, dict[str, Any]],
     auth_override: dict[str, Any] | None = None,
     explicit_button_dtos: list[dict[str, Any]] | None = None,
     query_condition_payload: dict[str, Any] | None = None,
     associated_resources_payload: dict[str, Any] | None = None,
-    hierarchy_filter_groups: list[list[dict[str, Any]]] | None = None,
 ) -> JSONObject:
     field_map = extract_field_map(schema)
     parsed_schema = _parse_schema(schema)
-    visible_que_id_values = _resolve_view_visible_que_ids(patch)
+    visible_field_names = _resolve_view_visible_field_names(patch)
+    visible_que_id_values = [field_map[name] for name in visible_field_names if name in field_map]
     gantt_payload = _build_public_gantt_payload(parsed_schema["fields"], field_map, patch)
     payload: JSONObject = {
         "appKey": app_key,
@@ -30010,8 +29129,6 @@ def _build_minimal_view_payload(
             "card": "cardView",
             "board": "boardView",
             "gantt": "ganttView",
-            "hierarchy": "hierarchyView",
-            "calendar": "calendarView",
         }[patch.type.value],
         "ordinal": ordinal,
         "viewgraphQueIds": visible_que_id_values,
@@ -30022,21 +29139,17 @@ def _build_minimal_view_payload(
         payload["beingShowTitleQue"] = True
         payload["titleQue"] = gantt_payload.get("titleQueId") or (visible_que_id_values[0] if visible_que_id_values else None)
     if patch.type.value == "board":
-        payload["groupQueId"] = patch.group_que_id
+        payload["groupQueId"] = field_map.get(patch.group_by or "")
     return _hydrate_view_backend_payload(
         payload=payload,
         view_type=patch.type.value,
         visible_que_id_values=visible_que_id_values,
-        group_que_id=patch.group_que_id,
+        group_que_id=field_map.get(patch.group_by or "") if patch.group_by else None,
         view_filters=view_filters,
         gantt_payload=gantt_payload,
         button_config_dtos=explicit_button_dtos,
         query_condition_payload=query_condition_payload,
         associated_resources_payload=associated_resources_payload,
-        patch=patch,
-        field_map=field_map,
-        fields_by_que_id=fields_by_que_id,
-        hierarchy_filter_groups=hierarchy_filter_groups,
     )
 
 
@@ -30051,11 +29164,6 @@ def _hydrate_view_backend_payload(
     button_config_dtos: list[dict[str, Any]] | None = None,
     query_condition_payload: dict[str, Any] | None = None,
     associated_resources_payload: dict[str, Any] | None = None,
-    patch: ViewUpsertPatch | None = None,
-    field_map: dict[str, int] | None = None,
-    fields_by_que_id: dict[str, dict[str, Any]] | None = None,
-    hierarchy_filter_groups: list[list[dict[str, Any]]] | None = None,
-    schema: dict[str, Any] | None = None,
 ) -> JSONObject:
     data = deepcopy(payload)
     data.setdefault("beingPinNavigate", True)
@@ -30125,239 +29233,26 @@ def _hydrate_view_backend_payload(
         data["titleQue"] = (gantt_payload or {}).get("titleQueId") or (visible_que_id_values[0] if visible_que_id_values else None)
         data["groupQueId"] = None
         data["viewgraphGanttConfigVO"] = deepcopy(gantt_payload) if gantt_payload else None
-    elif view_type == "hierarchy":
-        data["viewgraphType"] = "hierarchyView"
-        data["beingShowTitleQue"] = True
-        data["groupQueId"] = None
-        data["viewgraphGanttConfigVO"] = None
-    elif view_type == "calendar":
-        data["viewgraphType"] = "calendarView"
-        data["beingShowTitleQue"] = True
-        data["groupQueId"] = None
-        data["viewgraphGanttConfigVO"] = None
     if view_filters is not None:
         data["viewgraphLimit"] = deepcopy(view_filters)
         data["viewgraphLimitType"] = 1
         data["viewgraphLimitFormula"] = ""
         data["dataPermissionType"] = "CUSTOM"
         data["dataScope"] = "CUSTOM" if view_filters else "ALL"
-    if patch is not None:
-        _apply_view_config_groups(
-            data,
-            patch=patch,
-            view_type=view_type,
-            visible_que_id_values=visible_que_id_values,
-            field_map=field_map or {},
-            fields_by_que_id=fields_by_que_id or {},
-            hierarchy_filter_groups=hierarchy_filter_groups,
-            config=payload if isinstance(payload, dict) else None,
-            id_to_name=_collect_field_id_to_name(schema) if isinstance(schema, dict) else None,
-        )
     _apply_view_query_conditions_payload(data, query_condition_payload)
     _apply_view_associated_resources_payload(data, associated_resources_payload)
     return data
 
 
-_DATA_PERMISSION_SCOPE_MAP = {
-    "all": "ALL",
-    "oneself": "ONESELF",
-    "dept": "DEPT",
-    "subordinate": "SUBORDINATE",
-    "custom": "CUSTOM",
-}
-
-
-def _apply_view_config_groups(
-    data: JSONObject,
-    *,
-    patch: ViewUpsertPatch,
-    view_type: str,
-    visible_que_id_values: list[int],
-    field_map: dict[str, int],
-    fields_by_que_id: dict[str, dict[str, Any]],
-    hierarchy_filter_groups: list[list[dict[str, Any]]] | None,
-    config: dict[str, Any] | None = None,
-    id_to_name: dict[int, str] | None = None,
-) -> None:
-    """编译 complete 档新字段组:data_permission/sort/card/hierarchy/display/record/share。"""
-    if patch.data_permission is not None:
-        data["dataPermissionType"] = "CONFIG" if patch.data_permission.type == "config" else "CUSTOM"
-        data["dataScope"] = _DATA_PERMISSION_SCOPE_MAP.get(patch.data_permission.scope, "ALL")
-    if patch.sort is not None:
-        if patch.sort:
-            sorts: list[dict[str, Any]] = []
-            for rule in patch.sort:
-                field = fields_by_que_id.get(rule.que_id) or {}
-                que_type = _coerce_positive_int(field.get("que_type")) or FIELD_TYPE_TO_QUESTION_TYPE.get(
-                    str(field.get("type") or FieldType.text.value), 2
-                )
-                sorts.append(
-                    {
-                        "queId": rule.que_id,
-                        "beingSortAscend": bool(rule.ascending),
-                        "queType": que_type,
-                    }
-                )
-            data["sortType"] = "customSort"
-            data["viewgraphSorts"] = sorts
-        else:
-            data["sortType"] = "defaultSort"
-            data["viewgraphSorts"] = [{"queId": 0, "beingSortAscend": True, "queType": 8}]
-    card = patch.card
-    config = config or {}
-    id_to_name = id_to_name or {}
-    if card is not None:
-        if card.title_que_id is not None:
-            data["titleQue"] = card.title_que_id
-        if card.cover_que_id is not None:
-            data["frontCoverQueId"] = card.cover_que_id
-        if card.clipping_mode is not None:
-            data["clippingMode"] = card.clipping_mode
-        if card.image_adaption is not None:
-            data["beingImageAdaption"] = card.image_adaption
-        if card.show_field_title is not None:
-            data["beingShowQueTitle"] = card.show_field_title
-        if card.show_title is not None:
-            data["beingShowTitleQue"] = card.show_title
-        if card.show_cover is not None:
-            data["beingShowCover"] = card.show_cover
-        if card.group_que_id is not None:
-            data["groupQueId"] = card.group_que_id
-        if card.group_color is not None:
-            data["beingGroupColor"] = card.group_color
-    if patch.hierarchy is not None and view_type == "hierarchy":
-        data["viewgraphHierarchyConfigVO"] = {
-            "titleQueId": patch.hierarchy.title_que_id,
-            "childrenQueId": patch.hierarchy.children_que_id,
-            "rootNodeFilter": deepcopy(hierarchy_filter_groups) if hierarchy_filter_groups is not None else [],
-        }
-        data["titleQue"] = patch.hierarchy.title_que_id
-    if patch.calendar is not None and view_type == "calendar":
-        data["viewgraphCalendarConfigVO"] = {
-            "titleQueId": patch.calendar.title_que_id,
-            "dateQueId": patch.calendar.date_que_id,
-            "colorQueId": patch.calendar.color_que_id,
-        }
-        data["titleQue"] = patch.calendar.title_que_id
-    display = patch.display
-    if display is not None:
-        if display.row_height is not None:
-            data["defaultRowHigh"] = display.row_height
-        if display.pin_navigate is not None:
-            data["beingPinNavigate"] = display.pin_navigate
-        if display.remark is not None:
-            data["remark"] = display.remark
-    record = patch.record
-    if record is not None:
-        if record.audit_visible is not None:
-            data["beingAuditRecordVisible"] = record.audit_visible
-        if record.data_log_visible is not None:
-            data["beingDataLogVisible"] = record.data_log_visible
-        if record.qrobot_record_visible is not None:
-            data["beingQrobotRecordVisible"] = record.qrobot_record_visible
-        if record.workflow_future_visible is not None:
-            data["beingWorkflowNodeFutureListVisible"] = record.workflow_future_visible
-        if record.comment is not None:
-            data["beingCommentStatus"] = record.comment
-    share = patch.share
-    if share is not None:
-        if share.need_pass is not None:
-            data["beingNeedPass"] = share.need_pass
-            data["needPass"] = share.need_pass
-            if share.password is None:
-                # 声明未带密码(提取语义:不回传敏感值)——显式清空 payload 里读面带来的旧密码;
-                # 后端 isNotBlank(空)跳过校验且不更新密码列,原密码保留(Java AbstractViewgraphStrategicService:424)
-                data["viewgraphPass"] = ""
-                data.pop("pass", None)
-        if share.password is not None:
-            data["viewgraphPass"] = share.password
-        if share.force_login is not None:
-            data["beingForceLogin"] = share.force_login
-        if share.print_enabled is not None:
-            data["beingPrintStatus"] = share.print_enabled
-
-
-def _stale_view_reference_warning(
-    *,
-    scope: str,
-    view_name: str,
-    field_ids: list[Any] | None = None,
-    values: list[Any] | None = None,
-    option: bool = False,
-) -> dict[str, Any]:
-    """存量死引用(已删字段/已删选项)透传警告:后端保存视图不校验引用存在性并原样透传,
-    CLI 同口径透传写回,仅以警告留痕,不再整视图拒绝(apply(get(S))≡S 重放兼容)。"""
-    warning = _warning(
-        "STALE_OPTION_REFERENCE" if option else "STALE_FIELD_REFERENCE",
-        (
-            f"view {scope} references option values not present in the current form; original values passed through (backend tolerates stale references)"
-            if option
-            else f"view {scope} references fields not present in the current form; ids passed through (backend tolerates stale references)"
-        ),
-        scope=scope,
-        view_name=view_name,
-    )
-    if field_ids:
-        warning["field_ids"] = list(field_ids)
-    if values:
-        warning["values"] = list(values)
-    return warning
-
-
-def _iter_view_config_group_field_names(patch: ViewUpsertPatch) -> list[tuple[str, list[int]]]:
-    """枚举 complete 档新字段组引用的 queId(用于 UNKNOWN_VIEW_FIELD 校验)。"""
-    groups: list[tuple[str, list[int]]] = []
-    if patch.sort:
-        groups.append(("sort", [rule.que_id for rule in patch.sort]))
-    if patch.card is not None:
-        groups.append(
-            (
-                "card",
-                [
-                    que
-                    for que in (patch.card.title_que_id, patch.card.cover_que_id, patch.card.group_que_id)
-                    if que
-                ],
-            )
-        )
-    if patch.gantt is not None:
-        gantt_ids = [
-            que
-            for que in (patch.gantt.title_que_id, patch.gantt.start_que_id, patch.gantt.end_que_id)
-            if que
-        ]
-        gantt_ids.extend(group.que_id for group in patch.gantt.groups or [])
-        for dep in patch.gantt.dependencies or []:
-            gantt_ids.extend([dep.dependency_que_id, dep.predecessor_que_id])
-        if gantt_ids:
-            groups.append(("gantt", gantt_ids))
-    if patch.hierarchy is not None:
-        groups.append(("hierarchy", [patch.hierarchy.title_que_id, patch.hierarchy.children_que_id]))
-    if patch.calendar is not None:
-        calendar_ids = [patch.calendar.title_que_id, patch.calendar.date_que_id]
-        if patch.calendar.color_que_id is not None:
-            calendar_ids.append(patch.calendar.color_que_id)
-        groups.append(("calendar", calendar_ids))
-    return groups
-
-
-
-def _resolve_view_visible_que_ids(patch: ViewUpsertPatch) -> list[int]:
-    """收集视图引用的业务字段和已知系统字段 queId。"""
-    ordered: list[int] = []
-    extra_ids: list[int | None] = []
-    if patch.hierarchy is not None:
-        extra_ids.extend([patch.hierarchy.title_que_id, patch.hierarchy.children_que_id])
-    if patch.calendar is not None:
-        extra_ids.extend([patch.calendar.title_que_id, patch.calendar.date_que_id, patch.calendar.color_que_id])
-    for value in [*patch.columns, patch.title_que_id, patch.start_que_id, patch.end_que_id, patch.group_que_id, *extra_ids]:
-        que_id = _coerce_any_int(value)
-        if que_id is not None and (que_id > 0 or _is_known_system_view_que_id(que_id)) and que_id not in ordered:
-            ordered.append(que_id)
+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 _KNOWN_SYSTEM_VIEW_COLUMNS and name not in ordered:
+            ordered.append(name)
     return ordered
 
 
-
 def _build_public_gantt_payload(
     fields: list[dict[str, Any]],
     field_map: dict[str, int],
@@ -30365,35 +29260,22 @@ def _build_public_gantt_payload(
 ) -> dict[str, Any]:
     if patch.type.value != "gantt":
         return {}
-    gantt_config = patch.gantt
-    title_que_id = (
-        getattr(gantt_config, "title_que_id", None)
-        or patch.title_que_id
-        or (patch.columns[0] if patch.columns else None)
-    )
-    start_que_id = getattr(gantt_config, "start_que_id", None) or patch.start_que_id
-    end_que_id = getattr(gantt_config, "end_que_id", None) or patch.end_que_id
-    dependency = gantt_config.dependencies[0] if gantt_config is not None and gantt_config.dependencies else None
-    auto_calibration = bool(getattr(gantt_config, "auto_calibration", False) or False)
+    title_field_name = str((patch.title_field or (patch.columns[0] if patch.columns else "")) or "").strip()
+    start_field_name = str(patch.start_field or "").strip()
+    end_field_name = str(patch.end_field or "").strip()
     return {
-        "titleQueId": title_que_id,
-        "startTimeQueId": start_que_id,
-        "endTimeQueId": end_que_id,
-        "defaultTimeDimension": getattr(gantt_config, "default_time_dimension", None) or "week",
-        "ganttGroupVOList": [
-            {
-                "groupQueId": group.que_id,
-                "ordinal": group.ordinal if group.ordinal is not None else index,
-            }
-            for index, group in enumerate((gantt_config.groups if gantt_config is not None else []), start=1)
-        ],
+        "titleQueId": field_map.get(title_field_name),
+        "startTimeQueId": field_map.get(start_field_name),
+        "endTimeQueId": field_map.get(end_field_name),
+        "defaultTimeDimension": "week",
+        "ganttGroupVOList": [],
         "ganttDependencyVO": {
-            "dependencyQueId": dependency.dependency_que_id if dependency else None,
-            "predecessorTaskQueId": dependency.predecessor_que_id if dependency else None,
-            "startStartOptionId": dependency.start_start_option_id if dependency else None,
-            "startEndOptionId": dependency.start_end_option_id if dependency else None,
-            "endEndOptionId": dependency.end_end_option_id if dependency else None,
-            "endStartOptionId": dependency.end_start_option_id if dependency else None,
+            "dependencyQueId": None,
+            "predecessorTaskQueId": None,
+            "startEndOptionId": None,
+            "startStartOptionId": None,
+            "endEndOptionId": None,
+            "endStartOptionId": None,
         },
         "ganttAutoCalibrationVO": {
             "autoCalibrationRuleVO": {
@@ -30404,15 +29286,15 @@ def _build_public_gantt_payload(
                 "endStartFinish": True,
                 "endEndFinish": False,
             },
-            "beingAutoCalibration": auto_calibration,
-            "userAutoCalibration": auto_calibration,
+            "beingAutoCalibration": False,
+            "userAutoCalibration": False,
         },
     }
 
 
 def _build_view_filter_groups(
     *,
-    fields_by_que_id: dict[str, dict[str, Any]],
+    current_fields_by_name: dict[str, dict[str, Any]],
     filters: list[Any],
 ) -> tuple[list[list[dict[str, Any]]], list[dict[str, Any]]]:
     translated_rules: list[dict[str, Any]] = []
@@ -30422,14 +29304,14 @@ def _build_view_filter_groups(
             raw_rule = raw_rule.model_dump(mode="json")
         if not isinstance(raw_rule, dict):
             continue
-        rule_que_id = _coerce_positive_int(raw_rule.get("que_id"))
-        field = fields_by_que_id.get(rule_que_id) if rule_que_id is not None else None
+        field_name = str(raw_rule.get("field_name") or "").strip()
+        field = current_fields_by_name.get(field_name)
         if field is None:
             issues.append(
                 {
                     "error_code": "UNKNOWN_VIEW_FIELD",
-                    "missing_fields": [str(raw_rule.get("que_id") or "")],
-                    "reason_path": "filters[].que_id",
+                    "missing_fields": [field_name] if field_name else [],
+                    "reason_path": "filters[].field_name",
                 }
             )
             continue
@@ -30437,9 +29319,6 @@ def _build_view_filter_groups(
         if issue:
             issues.append(issue)
             continue
-        stale_warning = translated_rule.pop("_stale_warning", None)
-        if stale_warning is not None:
-            issues.append(stale_warning)
         translated_rules.append(translated_rule)
     return ([translated_rules] if translated_rules else []), issues
 
@@ -30450,9 +29329,9 @@ def _translate_view_filter_rule(*, field: dict[str, Any], rule: dict[str, Any])
     field_type = str(field.get("type") or FieldType.text.value)
     que_id = _coerce_positive_int(field.get("que_id")) or 0
     que_type = _coerce_positive_int(field.get("que_type")) or FIELD_TYPE_TO_QUESTION_TYPE.get(field_type, 2)
-    judge_values, judge_value_details, value_issue = _resolve_view_filter_values(field=field, values=values)
-    if value_issue and value_issue.get("error_code"):
-        return {}, value_issue
+    judge_values, judge_value_details, issue = _resolve_view_filter_values(field=field, values=values)
+    if issue:
+        return {}, issue
     payload: dict[str, Any] = {
         "queId": que_id,
         "queTitle": str(field.get("name") or ""),
@@ -30484,9 +29363,6 @@ def _translate_view_filter_rule(*, field: dict[str, Any], rule: dict[str, Any])
     elif operator == "not_empty":
         payload["judgeType"] = JUDGE_UNEQUAL
         payload["judgeValues"] = []
-    if value_issue is not None:
-        # 死选项透传:规则照常写入,warning 随 payload 携带由上层收集(_build_view_filter_groups 弹出)
-        payload["_stale_warning"] = value_issue
     return payload, None
 
 
@@ -30517,23 +29393,21 @@ def _resolve_view_filter_values(
             unresolved_values.append(_stringify_condition_value(value))
             continue
         resolved_details.append({"id": resolved.get("id"), "value": str(resolved.get("value") or resolved.get("id"))})
-    if unresolved_values and not resolved_details:
-        # 全部值都解析不出(选项已删):原值透传(后端对存量死选项引用原样保存),
-        # 以 STALE_OPTION_REFERENCE 警告留痕,不再整视图失败
+    if unresolved_values:
         return (
-            [_stringify_condition_value(value) for value in values],
-            _build_view_filter_value_details(values),
+            [],
+            [],
             {
-                "warning_code": "STALE_OPTION_REFERENCE",
+                "error_code": "UNKNOWN_VIEW_FILTER_VALUE",
                 "reason_path": "filters[].values",
                 "missing_fields": [],
+                "allowed_values": {"filter_values": sorted(option_by_value.keys())},
                 "details": {
                     "field_name": str(field.get("name") or ""),
                     "unresolved_values": unresolved_values,
                 },
             },
         )
-    # 部分值解析不出:剔除已删选项值继续写(兼容存量脏数据,不再整视图失败)
     return (
         [str(detail["id"]) for detail in resolved_details if detail.get("id") is not None],
         [_coerce_view_filter_value_detail(detail) for detail in resolved_details],
@@ -30577,10 +29451,6 @@ def _build_view_filter_value_details(values: list[Any]) -> list[dict[str, Any]]:
             details.append(_coerce_view_filter_value_detail({"id": item_id, "value": item_value if item_value is not None else str(item_id)}))
         elif isinstance(value, int):
             details.append(_coerce_view_filter_value_detail({"id": value, "value": str(value)}))
-        elif isinstance(value, str):
-            # text/number 字段:AnswerValue.id 是 Integer(选项 id),字符串值无 id;
-            # 后端 formula getId()==null → 走 getValue() 分支构建 ""value"" 形式
-            details.append(_coerce_view_filter_value_detail({"id": None, "value": value}))
     return details
 
 
@@ -30747,11 +29617,11 @@ def _view_filter_groups_semantic_readback(expected: Any, actual: Any) -> tuple[b
 def _public_view_filter_groups_from_match_rules(
     groups: Any,
     *,
-    fields_by_que_id: dict[str, dict[str, Any]],
+    current_fields_by_name: dict[str, dict[str, Any]],
 ) -> list[list[dict[str, Any]]]:
     fields_by_que_id = {
         _coerce_positive_int(field.get("que_id")): field
-        for field in fields_by_que_id.values()
+        for field in current_fields_by_name.values()
         if isinstance(field, dict) and _coerce_positive_int(field.get("que_id")) is not None
     }
     public_groups: list[list[dict[str, Any]]] = []
@@ -30762,7 +29632,7 @@ def _public_view_filter_groups_from_match_rules(
             field = fields_by_que_id.get(que_id) or {}
             values = _public_view_filter_rule_values(rule, field=field)
             public_rule: dict[str, Any] = {
-                "que_id": que_id,
+                "field_name": str(field.get("name") or rule.get("queTitle") or que_id),
                 "operator": _public_view_filter_operator_from_judge_type(rule.get("judgeType"), values=values),
             }
             if public_rule["operator"] == "in":
@@ -30787,8 +29657,6 @@ def _public_view_filter_operator_from_judge_type(judge_type: Any, *, values: lis
     if normalized in {JUDGE_INCLUDE, JUDGE_FUZZY_MATCH}:
         return "contains"
     if normalized in {JUDGE_EQUAL_ANY, JUDGE_INCLUDE_ANY}:
-        # ANY 判型+空值 = "该字段未选任何值"的合法存量形态(judgeType 保真回写,
-        # 转 is_empty 会丢判型——后端 9 与 0 是不同判定域,实测回读不同)
         return "in"
     if normalized == JUDGE_GREATER_OR_EQUAL:
         return "gte"