@qingflow-tech/qingflow-cli 1.1.50-beta.2 → 1.1.50-beta.3

package/src/qingflow_mcp/builder_facade/service.py

@@ -15,6 +15,8 @@ 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
@@ -26,7 +28,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, extract_field_map
+from ..solution.executor import _build_viewgraph_questions, _compact_dict, _flatten_viewgraph_questions, 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
@@ -41,6 +43,8 @@ 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,
@@ -290,6 +294,7 @@ 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
@@ -3072,14 +3077,27 @@ class AiBuilderFacade:
             member_ids=visibility.external_selectors.member_ids,
             member_emails=visibility.external_selectors.member_emails,
         )
-        self._raise_visibility_resolution_issues(
-            [
+        # 冗余引用降级:提取器对同一成员同时产出 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 [
                 *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:
@@ -3220,7 +3238,7 @@ class AiBuilderFacade:
                     }
                 )
             condition_matrix, condition_issues = _build_flow_condition_matrix(
-                current_fields_by_name=field_name_to_field,
+                fields_by_que_id=field_name_to_field,
                 node=normalized_node,
             )
             issues.extend({**issue, "node_id": node.get("id")} for issue in condition_issues)
@@ -8430,11 +8448,7 @@ class AiBuilderFacade:
         try:
             schema, _schema_source = self._read_schema_with_fallback(profile=profile, app_key=app_key)
             parsed_schema = _parse_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 "")
-            }
+            fields_by_que_id = _collect_fields_by_que_id([], schema=schema)
             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)
@@ -8525,7 +8539,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,
-                    current_fields_by_name=current_fields_by_name,
+                    fields_by_que_id=fields_by_que_id,
                     valid_custom_button_ids=valid_custom_button_ids,
                     allow_unverified_custom_button_id=allow_unverified_numeric_button_ids,
                 )
@@ -9455,49 +9469,37 @@ class AiBuilderFacade:
             return fields_result
         current_fields = fields_result.get("fields", [])
         field_names = {str(field.get("name") or "") for field in 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 "")
-        }
+        fields_by_que_id = _collect_fields_by_que_id(current_fields)
         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:
-            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]
+            # 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]
             if missing_columns:
                 blocking_issues.append({"error_code": "UNKNOWN_VIEW_FIELD", "view_name": patch.get("name"), "missing_fields": missing_columns})
-            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()
+            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")
             if patch.get("type") == "gantt":
                 missing_required = []
-                if not start_field:
-                    missing_required.append("start_field")
-                if not end_field:
-                    missing_required.append("end_field")
+                if not start_que_id:
+                    missing_required.append("start_que_id")
+                if not end_que_id:
+                    missing_required.append("end_que_id")
                 if missing_required:
                     blocking_issues.append({"error_code": "INVALID_GANTT_CONFIG", "view_name": patch.get("name"), "missing_fields": missing_required})
-                missing_gantt_fields = [name for name in (start_field, end_field, title_field) if name and name not in field_names]
+                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]
                 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(current_fields_by_name=current_fields_by_name, filters=patch.get("filters") or [])
+            translated_filters, filter_issues = _build_view_filter_groups(fields_by_que_id=fields_by_que_id, filters=patch.get("filters") or [])
             if filter_issues:
                 blocking_issues.extend(
                     {
@@ -9509,7 +9511,7 @@ class AiBuilderFacade:
             if translated_filters:
                 patch["filters"] = [dict(rule) for rule in (patch.get("filters") or [])]
             _, _, query_condition_issues = _build_view_query_conditions_payload(
-                current_fields_by_name=current_fields_by_name,
+                fields_by_que_id=fields_by_que_id,
                 query_conditions=patch.get("query_conditions"),
             )
             if query_condition_issues:
@@ -11796,6 +11798,26 @@ 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,
         *,
@@ -11805,15 +11827,91 @@ 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_views": [public_view_upsert_payload(patch) for patch in upsert_views],
+            "upsert_view": public_view_upsert_payload(upsert_views[0]) if upsert_views else None,
             "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
@@ -11828,6 +11926,8 @@ 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:
@@ -12044,7 +12144,25 @@ class AiBuilderFacade:
                 return finish(create_permission_outcome.block)
             permission_outcomes.append(create_permission_outcome)
         parsed_schema = _parse_schema(schema)
-        field_names = {field["name"] for field in parsed_schema["fields"]}
+
+        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)
         if patch_views:
             expanded_views, patch_issues, patch_results = self._expand_view_partial_patches(
                 profile=profile,
@@ -12064,14 +12182,18 @@ class AiBuilderFacade:
                         suggested_next_call={"tool_name": "view_get", "arguments": {"profile": profile, "view_key": patch_issues[0].get("view_key") or "VIEW_KEY"}},
                     )
                 )
-            upsert_views = [*upsert_views, *expanded_views]
-            normalized_args["upsert_views"] = [public_view_upsert_payload(patch) for patch in upsert_views]
+            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
             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
@@ -12167,8 +12289,8 @@ class AiBuilderFacade:
             associated_resource_inventory_ms += _duration_ms(associated_resource_inventory_started_at)
         removed: list[str] = []
         removed_keys: set[str] = set()
-        view_results: list[dict[str, Any]] = []
-        failed_views: list[dict[str, Any]] = []
+        view_result: dict[str, Any] | None = None
+        failure_result: dict[str, Any] | None = None
         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:
@@ -12186,10 +12308,17 @@ class AiBuilderFacade:
             )
 
         view_mutation_started_at = time.perf_counter()
-        for selector in remove_views:
-            selector_text = str(selector or "").strip()
+        if operation == "remove" and remove_views:
+            selector_text = str(remove_views[0] or "").strip()
             if not selector_text:
-                continue
+                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}},
+                ))
             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:
@@ -12216,44 +12345,40 @@ class AiBuilderFacade:
                     "error_code": "VIEW_NOT_FOUND",
                     "message": "remove_views item did not match an existing view name or view_key",
                 }
-                failed_views.append(failed_view)
-                view_results.append(deepcopy(failed_view))
-                continue
-            if len(matches) == 1:
+                failure_result = failed_view
+                view_result = deepcopy(failed_view)
+            else:
                 key = _extract_view_key(matches[0])
                 removed_name = _extract_view_name(matches[0]) or selector_text
                 try:
-                    self.views.view_delete(profile=profile, viewgraph_key=key)
-                    delete_readback = self._verify_view_deleted_by_key(profile=profile, view_key=key)
+                    delete_readback = self._apply_view_remove(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_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 {}
-                            ),
-                        }
-                    )
+                    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 {}
+                        ),
+                    }
                 except (QingflowApiError, RuntimeError) as error:
                     api_error = _coerce_api_error(error)
                     failed_view = {
@@ -12270,8 +12395,8 @@ class AiBuilderFacade:
                         "backend_code": api_error.backend_code,
                         "http_status": None if api_error.http_status == 404 else api_error.http_status,
                     }
-                    failed_views.append(failed_view)
-                    view_results.append(deepcopy(failed_view))
+                    failure_result = failed_view
+                    view_result = deepcopy(failed_view)
         created: list[str] = []
         updated: list[str] = []
         existing_view_list = [
@@ -12281,25 +12406,19 @@ class AiBuilderFacade:
             and _extract_view_name(view) not in removed
             and _extract_view_key(view) not in removed_keys
         ]
-        for ordinal, patch in enumerate(upsert_views, start=1):
-            apply_columns = _resolve_view_visible_field_names(patch)
-            ignored_system_columns = [
-                name
-                for name in [str(value or "").strip() for value in patch.columns]
-                if name in _KNOWN_SYSTEM_VIEW_COLUMNS
-            ]
+        for ordinal, patch in ((1, upsert_views[0]),) if operation == "upsert" and upsert_views else ():
+            apply_columns = _resolve_view_visible_que_ids(patch)
             if patch.type in {PublicViewType.table, PublicViewType.card} and patch.columns and not apply_columns:
                 return _failed(
                     "VALIDATION_ERROR",
                     "view columns must include at least one real app field; system columns cannot be applied directly",
                     normalized_args=normalized_args,
-                    details={
-                        "app_key": app_key,
-                        "view_name": patch.name,
-                        "ignored_system_columns": ignored_system_columns,
-                    },
+                    details={"app_key": app_key, "view_name": patch.name},
                 )
-            missing_columns = [name for name in apply_columns if name not in field_names]
+            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
+            ]
             if missing_columns:
                 return _failed(
                     "UNKNOWN_VIEW_FIELD",
@@ -12309,45 +12428,89 @@ class AiBuilderFacade:
                         "app_key": app_key,
                         "view_name": patch.name,
                         "missing_fields": missing_columns,
-                        "ignored_system_columns": ignored_system_columns,
                     },
                     missing_fields=missing_columns,
                     suggested_next_call={"tool_name": "app_get_fields", "arguments": {"profile": profile, "app_key": app_key}},
                 )
-            if patch.group_by and patch.group_by not in field_names:
+            if patch.group_que_id and patch.group_que_id not in fields_by_que_id:
                 return _failed(
                     "UNKNOWN_VIEW_FIELD",
-                    f"group_by references unknown field '{patch.group_by}'",
+                    f"group_by references unknown field '{patch.group_que_id}'",
                     normalized_args=normalized_args,
                     details={
                         "app_key": app_key,
                         "view_name": patch.name,
-                        "missing_fields": [patch.group_by],
+                        "missing_fields": [patch.group_que_id],
                     },
-                    missing_fields=[patch.group_by],
+                    missing_fields=[patch.group_que_id],
                     suggested_next_call={"tool_name": "app_get_fields", "arguments": {"profile": profile, "app_key": app_key}},
                 )
-            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:
+            for gantt_que_id in (patch.start_que_id, patch.end_que_id, patch.title_que_id):
+                if gantt_que_id and gantt_que_id not in fields_by_que_id:
                     return _failed(
                         "UNKNOWN_VIEW_FIELD",
-                        f"gantt configuration references unknown field '{gantt_field_name}'",
+                        f"gantt configuration references unknown field '{gantt_que_id}'",
                         normalized_args=normalized_args,
                         details={
                             "app_key": app_key,
                             "view_name": patch.name,
-                            "missing_fields": [gantt_field_name],
+                            "missing_fields": [gantt_que_id],
                         },
-                        missing_fields=[gantt_field_name],
+                        missing_fields=[gantt_que_id],
                         suggested_next_call={"tool_name": "app_get_fields", "arguments": {"profile": profile, "app_key": app_key}},
                     )
+            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]
+                if missing_config_fields:
+                    return _failed(
+                        "UNKNOWN_VIEW_FIELD",
+                        f"view {group_name} configuration references unknown fields",
+                        normalized_args=normalized_args,
+                        details={
+                            "app_key": app_key,
+                            "view_name": patch.name,
+                            "missing_fields": missing_config_fields,
+                            "reason_path": f"{group_name}",
+                        },
+                        missing_fields=missing_config_fields,
+                        suggested_next_call={"tool_name": "app_get_fields", "arguments": {"profile": profile, "app_key": app_key}},
+                    )
+            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,
+                    )
+                    if hierarchy_filter_issues:
+                        first_issue = hierarchy_filter_issues[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
+                )
             else:
-                translated_filters, filter_issues = _build_view_filter_groups(current_fields_by_name=current_fields_by_name, filters=patch.filters)
+                translated_filters, filter_issues = _build_view_filter_groups(fields_by_que_id=fields_by_que_id, filters=patch.filters)
             if filter_issues:
                 first_issue = filter_issues[0]
                 return _failed(
@@ -12369,7 +12532,7 @@ class AiBuilderFacade:
                 query_condition_issues = []
             else:
                 query_condition_payload, expected_query_conditions, query_condition_issues = _build_view_query_conditions_payload(
-                    current_fields_by_name=current_fields_by_name,
+                    fields_by_que_id=fields_by_que_id,
                     query_conditions=patch.query_conditions,
                 )
             if query_condition_issues:
@@ -12426,7 +12589,7 @@ class AiBuilderFacade:
                 expected_button_summary = None
             elif patch.buttons is not None:
                 explicit_button_dtos, button_issues = _build_view_button_dtos(
-                    current_fields_by_name=current_fields_by_name,
+                    fields_by_que_id=fields_by_que_id,
                     bindings=patch.buttons,
                     valid_custom_button_ids=valid_custom_button_ids,
                 )
@@ -12484,6 +12647,10 @@ 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)
@@ -12517,16 +12684,17 @@ 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,
-                        current_fields_by_name=current_fields_by_name,
+                        fields_by_que_id=fields_by_que_id,
                         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.views.view_update(profile=profile, viewgraph_key=existing_key, payload=payload)
+                    self._apply_view_update(profile=profile, view_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"
@@ -12537,7 +12705,9 @@ class AiBuilderFacade:
                             payload=payload,
                             list_type=system_view_list_type,
                             schema=schema,
-                            visible_field_names=apply_columns,
+                            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
+                            ],
                         )
                         if not bool(system_view_sync.get("verified")):
                             failure_entry = {
@@ -12562,24 +12732,23 @@ class AiBuilderFacade:
                                     "apply_columns": apply_columns,
                                 },
                             }
-                            failed_views.append(failure_entry)
-                            view_results.append(failure_entry)
+                            failure_result = failure_entry
+                            view_result = failure_entry
                             continue
                     updated.append(patch.name)
-                    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),
-                            }
-                        )
+                    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),
+                    }
                     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)
@@ -12591,50 +12760,45 @@ 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,
-                            current_fields_by_name=current_fields_by_name,
+                            fields_by_que_id=fields_by_que_id,
                             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.views.view_update(profile=profile, viewgraph_key=created_key, payload=payload)
+                        self._apply_view_update(profile=profile, view_key=created_key, payload=payload)
                     else:
-                        payload = _build_view_create_payload(
+                        payload = _build_view_creation_payload(
                             app_key=app_key,
                             base_info=base,
                             schema=schema,
                             patch=patch,
                             ordinal=ordinal,
                             view_filters=translated_filters,
-                            current_fields_by_name=current_fields_by_name,
+                            fields_by_que_id=fields_by_que_id,
                             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,
                         )
-                        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_key = self._apply_view_create(profile=profile, payload=payload)
                     created.append(patch.name)
-                    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),
-                            }
-                        )
+                    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,
+                    }
                     record_action_button_intent(patch=patch, view_key=created_key, index=ordinal - 1)
             except (QingflowApiError, RuntimeError) as error:
                 api_error = _coerce_api_error(error)
@@ -12661,17 +12825,20 @@ class AiBuilderFacade:
                                 patch=patch,
                                 ordinal=ordinal,
                                 view_filters=translated_filters,
-                                current_fields_by_name=current_fields_by_name,
+                                hierarchy_filter_groups=hierarchy_root_filter_groups,
+                                fields_by_que_id=fields_by_que_id,
                                 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.views.view_update(profile=profile, viewgraph_key=target_key, payload=fallback_payload)
+                            self._apply_view_update(profile=profile, view_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
+                                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"}
                                 else None
                             )
                             if fallback_system_view_list_type is not None:
@@ -12683,7 +12850,9 @@ class AiBuilderFacade:
                                     payload=fallback_payload,
                                     list_type=fallback_system_view_list_type,
                                     schema=schema,
-                                    visible_field_names=apply_columns,
+                                    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
+                                    ],
                                 )
                                 if not bool(system_view_sync.get("verified")):
                                     failure_entry = {
@@ -12708,44 +12877,42 @@ class AiBuilderFacade:
                                             "apply_columns": apply_columns,
                                         },
                                     }
-                                    failed_views.append(failure_entry)
-                                    view_results.append(failure_entry)
+                                    failure_result = failure_entry
+                                    view_result = failure_entry
                                     continue
                             if existing_key:
                                 updated.append(patch.name)
-                                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),
-                                    }
-                                )
+                                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),
+                                }
                                 record_action_button_intent(patch=patch, view_key=existing_key, index=ordinal - 1)
                             else:
                                 created.append(patch.name)
-                                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),
-                                    }
-                                )
+                                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),
+                                }
                                 record_action_button_intent(patch=patch, view_key=created_key, index=ordinal - 1)
                             continue
                         fallback_payload = _build_minimal_view_payload(
@@ -12754,16 +12921,16 @@ class AiBuilderFacade:
                             patch=patch,
                             ordinal=ordinal,
                             view_filters=translated_filters,
-                            current_fields_by_name=current_fields_by_name,
+                            hierarchy_filter_groups=hierarchy_root_filter_groups,
+                            fields_by_que_id=fields_by_que_id,
                             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.views.view_create(profile=profile, payload=fallback_payload)
+                        self._apply_view_create(profile=profile, payload=fallback_payload)
                         created.append(patch.name)
-                        view_results.append(
-                            {
+                        view_result = {
                                 "name": patch.name,
                                 "view_key": created_key,
                                 "type": patch.type.value,
@@ -12773,7 +12940,6 @@ 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:
@@ -12799,11 +12965,16 @@ class AiBuilderFacade:
                         "view_name": patch.name,
                         "view_type": patch.type.value,
                         "columns": patch.columns,
-                        "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,
+                        "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,
                         "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": {
@@ -12813,24 +12984,69 @@ class AiBuilderFacade:
                         },
                         **_view_apply_failure_diagnostics(
                             patch=patch,
-                            current_fields_by_name=current_fields_by_name,
+                            fields_by_que_id=fields_by_que_id,
                             backend_code=api_error.backend_code,
                             operation_phase=operation_phase,
                         ),
                     },
                 }
-                failed_views.append(failure_entry)
-                view_results.append(failure_entry)
+                failure_result = failure_entry
+                view_result = 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_results
+            for item in ((view_result,) if view_result is not None else ())
             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_results
+            for item in ((view_result,) if view_result is not None else ())
             if str(item.get("status") or "") in {"created", "updated"} and str(item.get("name") or "").strip()
         }
         skipped_action_button_intents = [
@@ -12881,12 +13097,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_view_result: list[dict[str, Any]] | None = []
+        verified_views: list[dict[str, Any]] | None = []
         verified_views_unavailable = False
         if needs_view_list_readback:
             try:
                 view_readback_started_at = time.perf_counter()
-                verified_view_result, verified_views_unavailable = self._load_views_result(profile=profile, app_key=app_key, tolerate_404=True)
+                verified_views, 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)
@@ -12900,23 +13116,23 @@ class AiBuilderFacade:
             view_readback_ms += _duration_ms(view_readback_started_at)
         verified_names = {
             _extract_view_name(item)
-            for item in (verified_view_result or [])
+            for item in (verified_views or [])
             if isinstance(item, dict) and _extract_view_name(item)
         }
         verified_by_key = {
             _extract_view_key(item): item
-            for item in (verified_view_result or [])
+            for item in (verified_views or [])
             if isinstance(item, dict) and _extract_view_key(item)
         }
         verified_view_keys_by_name: dict[str, list[str]] = {}
-        for item in (verified_view_result or []):
+        for item in (verified_views 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_by_view: list[dict[str, Any]] = []
+        verification_result: dict[str, Any] | None = None
         filter_readback_pending = False
         filter_mismatches: list[dict[str, Any]] = []
         query_condition_readback_pending = False
@@ -12943,7 +13159,7 @@ class AiBuilderFacade:
             return cached
 
         view_verification_started_at = time.perf_counter()
-        for item in view_results:
+        for item in ((view_result,) if view_result is not None else ()):
             status = str(item.get("status") or "")
             name = str(item.get("name") or "")
             item_view_key = str(item.get("view_key") or "").strip()
@@ -12986,7 +13202,7 @@ class AiBuilderFacade:
                                 verification_entry["readback_ambiguous"] = True
                                 verification_entry["matching_view_keys"] = matched_keys
                                 filter_readback_pending = True
-                                verification_by_view.append(verification_entry)
+                                verification_result = verification_entry
                                 continue
                         try:
                             config_result, config_error = read_view_config_for_verification(verification_key)
@@ -13004,11 +13220,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,
-                                current_fields_by_name=current_fields_by_name,
+                                fields_by_que_id=fields_by_que_id,
                             )
                             public_actual_filters = _public_view_filter_groups_from_match_rules(
                                 semantic_actual_filters,
-                                current_fields_by_name=current_fields_by_name,
+                                fields_by_que_id=fields_by_que_id,
                             )
                             verification_entry["filters_verified"] = filters_verified
                             verification_entry["view_key"] = verification_key
@@ -13058,7 +13274,7 @@ class AiBuilderFacade:
                                 verification_entry["readback_ambiguous"] = True
                                 verification_entry["matching_view_keys"] = matched_keys
                                 query_condition_readback_pending = True
-                                verification_by_view.append(verification_entry)
+                                verification_result = verification_entry
                                 continue
                         try:
                             config_result, config_error = read_view_config_for_verification(verification_key)
@@ -13107,7 +13323,7 @@ class AiBuilderFacade:
                                 verification_entry["readback_ambiguous"] = True
                                 verification_entry["matching_view_keys"] = matched_keys
                                 associated_resource_readback_pending = True
-                                verification_by_view.append(verification_entry)
+                                verification_result = verification_entry
                                 continue
                         try:
                             config_result, config_error = read_view_config_for_verification(verification_key)
@@ -13162,7 +13378,7 @@ class AiBuilderFacade:
                                 verification_entry["readback_ambiguous"] = True
                                 verification_entry["matching_view_keys"] = matched_keys
                                 button_readback_pending = True
-                                verification_by_view.append(verification_entry)
+                                verification_result = verification_entry
                                 continue
                         try:
                             config_result, config_error = read_view_config_for_verification(verification_key)
@@ -13210,51 +13426,45 @@ class AiBuilderFacade:
                                 "category": api_error.category,
                             }
                             button_readback_pending = True
-                verification_by_view.append(verification_entry)
+                verification_result = verification_entry
             elif status == "removed":
-                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,
-                    }
-                )
+                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,
+                }
             elif status == "readback_pending" and item.get("operation") == "delete":
                 readback_status = str(item.get("readback_status") or "unavailable")
-                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"),
-                    }
-                )
+                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"),
+                }
             else:
-                verification_by_view.append(
-                    {
-                        "name": item.get("name"),
-                        "type": item.get("type"),
-                        "status": "failed",
-                        "present_in_readback": None,
-                        "error_code": item.get("error_code"),
-                    }
-                )
+                verification_result = {
+                    "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_results
+            for item in ((view_result,) if view_result is not None else ())
             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)
@@ -13269,19 +13479,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 failed_views:
+        if failure_result is not None:
             successful_changes = bool(created or updated or removed or action_button_write_succeeded)
-            first_failure = failed_views[0]
+            first_failure = failure_result
             response = {
                 "status": "partial_success" if successful_changes else "failed",
                 "error_code": "VIEW_APPLY_PARTIAL" if successful_changes else "VIEW_APPLY_FAILED",
                 "recoverable": True,
-                "message": "applied some view patches; at least one view failed" if successful_changes else "one or more view patches failed",
+                "message": "view operation completed with a verification failure" if successful_changes else "view operation 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": {
-                    "per_view_results": view_results,
+                    "view_result": deepcopy(view_result) if view_result is not None else None,
                     "filter_mismatches": filter_mismatches,
                     "query_condition_mismatches": query_condition_mismatches,
                     "associated_resource_mismatches": associated_resource_mismatches,
@@ -13339,13 +13549,14 @@ class AiBuilderFacade:
                     "action_buttons_verified": action_buttons_verified,
                     "view_button_bindings_verified": view_action_button_bindings_verified,
                     "views_read_unavailable": verified_views_unavailable,
-                    "by_view": verification_by_view,
+                    "view": deepcopy(verification_result) if verification_result is not None else None,
                     "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,
-                "views_diff": {"created": created, "updated": updated, "removed": removed, "failed": failed_views},
+                "view_result": deepcopy(view_result) if view_result is not None else None,
+                "views_diff": {"created": created, "updated": updated, "removed": removed, "failed": [failure_result]},
                 "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),
@@ -13414,6 +13625,7 @@ class AiBuilderFacade:
                 **({"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)}
@@ -13441,10 +13653,11 @@ class AiBuilderFacade:
                 "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,
+                "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),
@@ -13453,6 +13666,305 @@ class AiBuilderFacade:
         }
         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,
+                    }
+                )
+                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)",
+            "normalized_args": normalized_args,
+            "missing_fields": [],
+            "allowed_values": {"view_types": [member.value for member in PublicViewType]},
+            "details": {
+                "extraction_gap_summary": gap_summary,
+                "extraction_gaps": all_gaps[:50],
+                "config_read_errors": read_errors[:50],
+                "config_read_error_count": len(read_errors),
+            },
+            "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,
+            "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,
+        }
+
     def app_publish_verify(
         self,
         *,
@@ -15429,6 +15941,76 @@ 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,
         *,
@@ -19226,40 +19808,44 @@ def _chart_apply_batching_context(
 def _view_apply_failure_diagnostics(
     *,
     patch: ViewUpsertPatch,
-    current_fields_by_name: dict[str, dict[str, Any]],
+    fields_by_que_id: dict[int, dict[str, Any]],
     backend_code: Any,
     operation_phase: str,
 ) -> dict[str, Any]:
-    references: list[tuple[str, str]] = []
+    references: list[tuple[int, str]] = []
 
-    def add_reference(name: Any, source: str) -> None:
-        text = str(name or "").strip()
-        if text:
-            references.append((text, source))
+    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))
 
     for column in patch.columns:
         add_reference(column, "columns")
-    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")
+    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")
 
-    seen: set[str] = set()
+    seen: set[tuple[int, str]] = set()
     field_entries: list[dict[str, Any]] = []
-    for field_name, source in references:
-        key = f"{field_name}\0{source}"
+    for que_id, source in references:
+        key = (que_id, source)
         if key in seen:
             continue
         seen.add(key)
-        field = current_fields_by_name.get(field_name) or {}
+        field = fields_by_que_id.get(que_id) or {}
         field_entries.append(
             {
-                "field_name": field_name,
+                "field_name": str(field.get("name") or que_id),
                 "source": source,
                 "field_id": field.get("field_id"),
-                "que_id": field.get("que_id"),
+                "que_id": field.get("que_id") or que_id,
                 "field_type": field.get("type"),
                 "que_type": field.get("que_type"),
                 "exists_in_schema": bool(field),
@@ -19277,7 +19863,7 @@ def _view_apply_failure_diagnostics(
                 "recommended_minimal_retry": {
                     "name": patch.name,
                     "type": patch.type.value,
-                    "columns": [field_entries[0]["field_name"]] if field_entries else [],
+                    "columns": [field_entries[0]["que_id"]] if field_entries else [],
                     **({"filters": [rule.model_dump(mode="json", exclude_none=True) for rule in patch.filters]} if patch.filters else {}),
                 },
             }
@@ -21186,8 +21772,10 @@ 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')}"
@@ -21357,6 +21945,17 @@ 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"])
@@ -21382,8 +21981,16 @@ 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)
-            fields_by_name.setdefault(field["name"], field)
+            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
+
             labels.append(field["name"])
         if labels:
             root_rows.append(labels)
@@ -26066,7 +26673,11 @@ 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 = [str(value) for value in (summary.get("columns") or []) if str(value or "").strip()]
+    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()
+    ]
     question_entries = _extract_view_question_entries(config.get("viewgraphQuestions"))
     canonical_question_entries = _extract_view_question_entries(question_list)
     question_entries_by_id = {
@@ -26167,7 +26778,7 @@ def _merge_view_summary_with_config(
             and str(entry.get("name") or "").strip()
             and str(entry.get("name") or "").strip() not in _KNOWN_SYSTEM_VIEW_COLUMNS
         ]
-        summary["columns"] = canonical_display_columns
+        summary["columns"] = canonical_display_column_ids
         summary["display_columns"] = canonical_display_columns
         summary["display_column_ids"] = canonical_display_column_ids
         summary["column_details"] = canonical_display_entries
@@ -26212,7 +26823,7 @@ def _merge_view_summary_with_config(
         )
         summary["filters"] = _public_view_filter_groups_from_match_rules(
             config.get("viewgraphLimit"),
-            current_fields_by_name=field_lookup,
+            fields_by_que_id=field_lookup,
         )
         config_enriched = True
     if any(key in config for key in ("asosChartVisible", "asosChartConfig", "asosChartIdList", "limitType")):
@@ -26455,12 +27066,16 @@ 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("printTplId")
+            tpl_id = item.get("printKey")
+            if tpl_id is None:
+                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("printTplName")
+            tpl_name = item.get("printName")
+            if tpl_name is None:
+                tpl_name = item.get("printTplName")
             if tpl_name is None:
                 tpl_name = item.get("templateName")
             if tpl_name is None:
@@ -26904,7 +27519,7 @@ def _build_grouped_view_button_config(button_config_dtos: list[dict[str, Any]])
 
 def _build_view_button_dtos(
     *,
-    current_fields_by_name: dict[str, dict[str, Any]],
+    fields_by_que_id: dict[str, dict[str, Any]],
     bindings: list[ViewButtonBindingPatch],
     valid_custom_button_ids: set[int],
 ) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]:
@@ -26913,7 +27528,7 @@ def _build_view_button_dtos(
     for binding in bindings:
         dto, binding_issues = _serialize_view_button_binding(
             binding=binding,
-            current_fields_by_name=current_fields_by_name,
+            fields_by_que_id=fields_by_que_id,
             valid_custom_button_ids=valid_custom_button_ids,
         )
         if binding_issues:
@@ -26926,7 +27541,7 @@ def _build_view_button_dtos(
 def _serialize_view_button_binding(
     *,
     binding: ViewButtonBindingPatch,
-    current_fields_by_name: dict[str, dict[str, Any]],
+    fields_by_que_id: 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]]]:
@@ -26944,7 +27559,7 @@ def _serialize_view_button_binding(
             }
         ]
     translated_limits, limit_issues = _build_view_button_limit_groups(
-        current_fields_by_name=current_fields_by_name,
+        fields_by_que_id=fields_by_que_id,
         groups=binding.button_limit,
     )
     if limit_issues:
@@ -26970,7 +27585,7 @@ def _serialize_view_button_binding(
 
 def _build_view_button_limit_groups(
     *,
-    current_fields_by_name: dict[str, dict[str, Any]],
+    fields_by_que_id: 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]]] = []
@@ -26984,14 +27599,14 @@ def _build_view_button_limit_groups(
                 raw_rule = raw_rule.model_dump(mode="json")
             if not isinstance(raw_rule, dict):
                 continue
-            field_name = str(raw_rule.get("field_name") or "").strip()
-            field = current_fields_by_name.get(field_name)
+            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
             if field is None:
                 issues.append(
                     {
                         "error_code": "UNKNOWN_VIEW_FIELD",
-                        "missing_fields": [field_name] if field_name else [],
-                        "reason_path": "buttons[].button_limit[].field_name",
+                        "missing_fields": [str(raw_rule.get("que_id") or "")],
+                        "reason_path": "buttons[].button_limit[].que_id",
                     }
                 )
                 continue
@@ -27162,7 +27777,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, current_fields_by_name=field_lookup)
+                _public_view_filter_groups_from_match_rules(raw_button_limit, fields_by_que_id=field_lookup)
                 if raw_button_limit
                 else []
             )
@@ -27360,6 +27975,11 @@ 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)
 
 
@@ -27459,7 +28079,7 @@ def _build_public_workflow_spec(*, nodes: list[dict[str, Any]], transitions: lis
 
 def _build_flow_condition_matrix(
     *,
-    current_fields_by_name: dict[str, dict[str, Any]],
+    fields_by_que_id: 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":
@@ -27477,7 +28097,7 @@ def _build_flow_condition_matrix(
             if not isinstance(raw_rule, dict):
                 continue
             field_name = str(raw_rule.get("field_name") or "").strip()
-            field = current_fields_by_name.get(field_name)
+            field = fields_by_que_id.get(field_name)
             if field is None:
                 issues.append(
                     {
@@ -27524,7 +28144,9 @@ 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":
-        base["judgeType"] = JUDGE_EQUAL
+        # 选项/成员/部门类字段的空值,后端历史形态是 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["judgeValues"] = []
     elif operator == "not_empty":
         base["judgeType"] = JUDGE_UNEQUAL
@@ -27553,7 +28175,7 @@ def _empty_view_query_conditions_payload() -> dict[str, Any]:
 
 def _build_view_query_conditions_payload(
     *,
-    current_fields_by_name: dict[str, dict[str, Any]],
+    fields_by_que_id: 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:
@@ -27593,7 +28215,7 @@ def _build_view_query_conditions_payload(
         compiled_row: list[int] = []
         for column_index, selector in enumerate(row):
             field, issue = _resolve_query_condition_field(
-                current_fields_by_name=current_fields_by_name,
+                fields_by_que_id=fields_by_que_id,
                 selector=selector,
                 reason_path=f"query_conditions.rows[{row_index}][{column_index}]",
             )
@@ -27611,14 +28233,16 @@ def _build_view_query_conditions_payload(
         "queryConditionStatus": enabled,
         "queryConditionExact": exact,
         "hideBeforeQueryCondition": hide_before_query,
-        "queryCondition": rows if enabled else [],
+        # 后端 ViewgraphInfo.queryCondition 是 List<ViewgraphQueryConditionConfig>({title?,queIds}),
+        # 不能发裸 [[queId]](fastjson expect {, actual [ → 发现 #7)
+        "queryCondition": [{"queIds": row} for row in rows] if enabled else [],
     }
     return payload, _normalize_view_query_conditions_for_compare(payload), []
 
 
 def _resolve_query_condition_field(
     *,
-    current_fields_by_name: dict[str, dict[str, Any]],
+    fields_by_que_id: dict[str, dict[str, Any]],
     selector: Any,
     reason_path: str,
 ) -> tuple[dict[str, Any], dict[str, Any] | None]:
@@ -27630,8 +28254,8 @@ def _resolve_query_condition_field(
             "missing_fields": [],
             "message": "query condition field selector cannot be empty",
         }
-    fields = [field for field in current_fields_by_name.values() if isinstance(field, dict)]
-    field = current_fields_by_name.get(raw)
+    fields = [field for field in fields_by_que_id.values() if isinstance(field, dict)]
+    field = fields_by_que_id.get(raw)
     if field is None:
         for candidate in fields:
             if raw == str(candidate.get("field_id") or "").strip():
@@ -27642,7 +28266,7 @@ def _resolve_query_condition_field(
                 field = candidate
                 break
     if field is None:
-        subfield_parent = _find_subtable_subfield_parent(current_fields_by_name=current_fields_by_name, selector=raw)
+        subfield_parent = _find_subtable_subfield_parent(fields_by_que_id=fields_by_que_id, selector=raw)
         if subfield_parent is not None:
             return {}, {
                 "error_code": "INVALID_QUERY_CONDITION_FIELD",
@@ -27690,10 +28314,10 @@ def _resolve_query_condition_field(
 
 def _find_subtable_subfield_parent(
     *,
-    current_fields_by_name: dict[str, dict[str, Any]],
+    fields_by_que_id: dict[str, dict[str, Any]],
     selector: str,
 ) -> dict[str, Any] | None:
-    for field in current_fields_by_name.values():
+    for field in fields_by_que_id.values():
         if not isinstance(field, dict) or str(field.get("type") or "") != FieldType.subtable.value:
             continue
         for subfield in field.get("subfields") or []:
@@ -27754,6 +28378,9 @@ 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 = [
@@ -27816,11 +28443,18 @@ 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": [],
+                "asosChartIdList": all_ids,
             },
         }
         expected = _extract_view_associated_resources_config(payload, available_resources=available_resources)
@@ -27841,26 +28475,19 @@ 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]
-    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",
-            }
-        ]
+    # 兼容存量脏引用:关联资源 id 指向闭包外/已下架的图表或视图时,剔除后继续写而非整视图失败;
+    # 剔除明细记入 expected 供回读校验与响应展示
+    resolvable_ids = [item_id for item_id in item_ids if item_id in available_by_id]
     payload = {
         "asosChartVisible": True,
         "asosChartConfig": {
             "limitType": ASSOCIATED_RESOURCE_LIMIT_TYPE_SELECT,
-            "asosChartIdList": item_ids,
+            "asosChartIdList": resolvable_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, []
 
 
@@ -28597,6 +29224,10 @@ _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",
@@ -28604,17 +29235,25 @@ _VIEW_PARTIAL_PATCH_KEY_ALIASES = {
     "column_names": "columns",
     "columnNames": "columns",
     "fields": "columns",
-    "group_by": "group_by",
-    "groupBy": "group_by",
+    "group_que_id": "group_que_id",
+    "groupQueId": "group_que_id",
+    "group_by": "group_que_id",
+    "groupBy": "group_que_id",
     "filters": "filters",
     "filter_rules": "filters",
     "filterRules": "filters",
-    "start_field": "start_field",
-    "startField": "start_field",
-    "end_field": "end_field",
-    "endField": "end_field",
-    "title_field": "title_field",
-    "titleField": "title_field",
+    "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",
     "buttons": "buttons",
     "visibility": "visibility",
     "query_conditions": "query_conditions",
@@ -28701,13 +29340,14 @@ def _normalize_view_partial_unset(raw_unset: Any, *, reason_path: str) -> tuple[
 
 _VIEW_PARTIAL_SET_KEYS = {
     "name",
+    "pinned",
     "type",
     "columns",
-    "group_by",
+    "group_que_id",
     "filters",
-    "start_field",
-    "end_field",
-    "title_field",
+    "start_que_id",
+    "end_que_id",
+    "title_que_id",
     "buttons",
     "visibility",
     "query_conditions",
@@ -28733,6 +29373,108 @@ 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],
@@ -28742,25 +29484,28 @@ 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 = [
-        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
+        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
     ]
     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
+        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
     ]
     if configured_columns and (not columns or len(configured_columns) >= len(columns)):
         columns = configured_columns
     display_config = summary.get("display_config") if isinstance(summary.get("display_config"), dict) else {}
-    group_by = str(summary.get("group_by") or display_config.get("group_by") or "").strip() or _field_name_by_id(field_names_by_id, config.get("groupQueId"))
-    title_field = str(display_config.get("title_field") or "").strip() or _field_name_by_id(field_names_by_id, config.get("titleQue"))
+    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"))
     gantt_config = config.get("viewgraphGanttConfigVO") if isinstance(config.get("viewgraphGanttConfigVO"), dict) else {}
-    start_field = _field_name_by_id(field_names_by_id, gantt_config.get("startTimeQueId")) if isinstance(gantt_config, dict) else None
-    end_field = _field_name_by_id(field_names_by_id, gantt_config.get("endTimeQueId")) if isinstance(gantt_config, dict) else None
-    gantt_title = _field_name_by_id(field_names_by_id, gantt_config.get("titleQueId")) if isinstance(gantt_config, dict) else None
+    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"))
     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] = {
@@ -28768,7 +29513,6 @@ 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": {
@@ -28777,15 +29521,17 @@ def _view_upsert_payload_from_existing_view(
             "associated_item_ids": list(associated_resources.get("configured_associated_item_ids") or []),
         },
     }
-    if title_field:
-        payload["title_field"] = title_field
+    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 view_type == "gantt":
-        if start_field:
-            payload["start_field"] = start_field
-        if end_field:
-            payload["end_field"] = end_field
-        if gantt_title:
-            payload["title_field"] = gantt_title
+        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
     return payload
 
 
@@ -28796,7 +29542,7 @@ def _first_present(mapping: dict[str, Any], *keys: str) -> Any:
     return None
 
 
-def _build_view_create_payload(
+def _build_view_creation_payload(
     *,
     app_key: str,
     base_info: dict[str, Any],
@@ -28804,23 +29550,24 @@ def _build_view_create_payload(
     patch: ViewUpsertPatch,
     ordinal: int,
     view_filters: list[list[dict[str, Any]]] | None,
-    current_fields_by_name: dict[str, dict[str, Any]],
+    fields_by_que_id: 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_field_names = _resolve_view_visible_field_names(patch)
-    field_ids = [_field_id_for_name(parsed_schema["fields"], name) for name in visible_field_names]
+    visible_que_ids = _resolve_view_visible_que_ids(patch)
+    field_ids = [f"field_{que}" for que in visible_que_ids]
     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=_field_id_for_name(_parse_schema(schema)["fields"], patch.group_by) if patch.group_by else None,
+        group_by_field_id=f"field_{patch.group_que_id}" if patch.group_que_id else None,
         config=gantt_config,
     )
     from ..solution.spec_models import EntitySpec
@@ -28829,7 +29576,6 @@ def _build_view_create_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
@@ -28841,17 +29587,21 @@ def _build_view_create_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"] = field_map.get(patch.group_by or "")
+        payload["groupQueId"] = patch.group_que_id
     return _hydrate_view_backend_payload(
         payload=payload,
         view_type=patch.type.value,
         visible_que_id_values=visible_que_ids,
-        group_que_id=field_map.get(patch.group_by or "") if patch.group_by else None,
+        group_que_id=patch.group_que_id,
         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,
     )
 
 
@@ -28989,6 +29739,8 @@ def _normalize_view_type_name(value: Any) -> str:
         return "gantt"
     if "board" in normalized:
         return "board"
+    if "hierarchy" in normalized:
+        return "hierarchy"
     if "card" in normalized:
         return "card"
     return "table"
@@ -29002,20 +29754,20 @@ def _build_view_update_payload(
     schema: dict[str, Any],
     patch: ViewUpsertPatch,
     view_filters: list[list[dict[str, Any]]] | None,
-    current_fields_by_name: dict[str, dict[str, Any]],
+    fields_by_que_id: 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_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]
+    visible_que_ids = _resolve_view_visible_que_ids(patch)
+    visible_que_id_values = list(visible_que_ids)
     gantt_payload = _build_public_gantt_payload(parsed_schema["fields"], field_map, patch)
 
     for key in (
@@ -29037,8 +29789,25 @@ 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
-    payload["viewgraphQueIds"] = visible_que_id_values
-    payload["viewgraphQuestions"] = _build_viewgraph_questions(schema, visible_que_id_values)
+    # 保留系统列在业务列之间的位置；业务列顺序和增删仍由声明决定。
+    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.setdefault("sortType", "defaultSort")
     payload.setdefault("viewgraphSorts", [{"queId": 0, "beingSortAscend": True, "queType": 8}])
     payload.setdefault("beingPinNavigate", True)
@@ -29068,25 +29837,75 @@ 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"] = field_map.get(patch.group_by or "")
+        payload["groupQueId"] = patch.group_que_id
     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)
     return _hydrate_view_backend_payload(
         payload=payload,
         view_type=normalized_type,
         visible_que_id_values=visible_que_id_values,
-        group_que_id=field_map.get(patch.group_by or "") if patch.group_by else None,
+        group_que_id=patch.group_que_id,
         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 = {
     "编号",
     "当前流程状态",
@@ -29110,16 +29929,16 @@ def _build_minimal_view_payload(
     patch: ViewUpsertPatch,
     ordinal: int,
     view_filters: list[list[dict[str, Any]]] | None,
-    current_fields_by_name: dict[str, dict[str, Any]],
+    fields_by_que_id: 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_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]
+    visible_que_id_values = _resolve_view_visible_que_ids(patch)
     gantt_payload = _build_public_gantt_payload(parsed_schema["fields"], field_map, patch)
     payload: JSONObject = {
         "appKey": app_key,
@@ -29129,6 +29948,7 @@ def _build_minimal_view_payload(
             "card": "cardView",
             "board": "boardView",
             "gantt": "ganttView",
+            "hierarchy": "hierarchyView",
         }[patch.type.value],
         "ordinal": ordinal,
         "viewgraphQueIds": visible_que_id_values,
@@ -29139,17 +29959,21 @@ 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"] = field_map.get(patch.group_by or "")
+        payload["groupQueId"] = patch.group_que_id
     return _hydrate_view_backend_payload(
         payload=payload,
         view_type=patch.type.value,
         visible_que_id_values=visible_que_id_values,
-        group_que_id=field_map.get(patch.group_by or "") if patch.group_by else None,
+        group_que_id=patch.group_que_id,
         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,
     )
 
 
@@ -29164,6 +29988,11 @@ 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)
@@ -29233,26 +30062,193 @@ 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
     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
 
 
-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)
+_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
+    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 _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]))
+    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])
+    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)
     return ordered
 
 
+
 def _build_public_gantt_payload(
     fields: list[dict[str, Any]],
     field_map: dict[str, int],
@@ -29260,22 +30256,35 @@ def _build_public_gantt_payload(
 ) -> dict[str, Any]:
     if patch.type.value != "gantt":
         return {}
-    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()
+    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)
     return {
-        "titleQueId": field_map.get(title_field_name),
-        "startTimeQueId": field_map.get(start_field_name),
-        "endTimeQueId": field_map.get(end_field_name),
-        "defaultTimeDimension": "week",
-        "ganttGroupVOList": [],
+        "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)
+        ],
         "ganttDependencyVO": {
-            "dependencyQueId": None,
-            "predecessorTaskQueId": None,
-            "startEndOptionId": None,
-            "startStartOptionId": None,
-            "endEndOptionId": None,
-            "endStartOptionId": None,
+            "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,
         },
         "ganttAutoCalibrationVO": {
             "autoCalibrationRuleVO": {
@@ -29286,15 +30295,15 @@ def _build_public_gantt_payload(
                 "endStartFinish": True,
                 "endEndFinish": False,
             },
-            "beingAutoCalibration": False,
-            "userAutoCalibration": False,
+            "beingAutoCalibration": auto_calibration,
+            "userAutoCalibration": auto_calibration,
         },
     }
 
 
 def _build_view_filter_groups(
     *,
-    current_fields_by_name: dict[str, dict[str, Any]],
+    fields_by_que_id: dict[str, dict[str, Any]],
     filters: list[Any],
 ) -> tuple[list[list[dict[str, Any]]], list[dict[str, Any]]]:
     translated_rules: list[dict[str, Any]] = []
@@ -29304,14 +30313,14 @@ def _build_view_filter_groups(
             raw_rule = raw_rule.model_dump(mode="json")
         if not isinstance(raw_rule, dict):
             continue
-        field_name = str(raw_rule.get("field_name") or "").strip()
-        field = current_fields_by_name.get(field_name)
+        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
         if field is None:
             issues.append(
                 {
                     "error_code": "UNKNOWN_VIEW_FIELD",
-                    "missing_fields": [field_name] if field_name else [],
-                    "reason_path": "filters[].field_name",
+                    "missing_fields": [str(raw_rule.get("que_id") or "")],
+                    "reason_path": "filters[].que_id",
                 }
             )
             continue
@@ -29393,7 +30402,8 @@ 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:
+    if unresolved_values and not resolved_details:
+        # 全部值都解析不出(选项已删):返回错误让上层判定(该规则已死语义)
         return (
             [],
             [],
@@ -29408,6 +30418,7 @@ def _resolve_view_filter_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],
@@ -29451,6 +30462,10 @@ 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
 
 
@@ -29617,11 +30632,11 @@ def _view_filter_groups_semantic_readback(expected: Any, actual: Any) -> tuple[b
 def _public_view_filter_groups_from_match_rules(
     groups: Any,
     *,
-    current_fields_by_name: dict[str, dict[str, Any]],
+    fields_by_que_id: 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 current_fields_by_name.values()
+        for field in fields_by_que_id.values()
         if isinstance(field, dict) and _coerce_positive_int(field.get("que_id")) is not None
     }
     public_groups: list[list[dict[str, Any]]] = []
@@ -29632,7 +30647,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] = {
-                "field_name": str(field.get("name") or rule.get("queTitle") or que_id),
+                "que_id": que_id,
                 "operator": _public_view_filter_operator_from_judge_type(rule.get("judgeType"), values=values),
             }
             if public_rule["operator"] == "in":
@@ -29657,6 +30672,8 @@ 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"