@qingflow-tech/qingflow-cli 1.1.51 → 1.1.54

package/src/qingflow_mcp/builder_facade/views_extract.py

@@ -0,0 +1,595 @@
+"""ViewgraphInfo → 公开视图声明的反向编译器(round-trip 提取器,eval 与 `views get --schema-kind complete` 共用)。
+
+设计对称性:本模块的每个映射与 `service.py` 正向编译(`_hydrate_view_backend_payload` 族)一一对应;
+「提不出来」的配置面进入 coverage gaps,由调用方汇总进覆盖度报告(evaluation.md §6)。
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from .service import (
+    ASSOCIATED_RESOURCE_LIMIT_TYPE_ALL,
+    _coerce_any_int,
+    _coerce_positive_int,
+    _is_known_system_view_que_id,
+    _extract_view_button_entries,
+    _public_view_filter_groups_from_match_rules,
+    _public_visibility_from_member_auth,
+    _resolve_system_view_button_logical_id,
+)
+
+# 后端 viewgraphType → 公开 type(ViewUpsertPatch/PublicViewType)
+_VIEW_TYPE_BY_BACKEND = {
+    "tableView": "table",
+    "cardView": "card",
+    "boardView": "board",
+    "ganttView": "gantt",
+    "hierarchyView": "hierarchy",
+    "calendarView": "calendar",
+}
+
+# 后端 dataScope → 公开 data_permission.scope(与 _DATA_PERMISSION_SCOPE_MAP 对称)
+_DATA_SCOPE_TO_PUBLIC = {
+    "ALL": "all",
+    "ONESELF": "oneself",
+    "DEPT": "dept",
+    "SUBORDINATE": "subordinate",
+    "CUSTOM": "custom",
+}
+
+# 后端视图列中可直接引用的系统字段 ID。它们不需要出现在表单业务字段索引中。
+_SYSTEM_COLUMN_NAMES = {
+    0: "apply_num",
+    1: "apply_user",
+    2: "apply_time",
+    3: "update_time",
+    4: "current_node",
+    5: "current_status",
+    6: "current_user",
+    -1: "data_source",
+    -2: "user_dept",
+    -3: "audit_node",
+    -4: "audit_node_user",
+    -5: "audit_status",
+    -6: "audit_time",
+    -7: "timeout_time",
+    -8: "audit_table",
+    -18: "error_info",
+    -19: "delete_time",
+    -20: "deleter",
+    -21: "processing_node",
+    -22: "cc_node",
+    -23: "processing_time",
+    -24: "cc_time",
+    -25: "receive_time",
+    -30: "app_key",
+    -31: "ws_id",
+}
+
+# complete 契约不覆盖、读面存在的配置键(进入 SKIP 账本,evaluation.md §4.3)
+_UNCOVERED_READBACK_KEYS = (
+    "attachVisibleOnlyConfig",
+    "beingRemarkStatus",
+    "querySearchStatus",
+    "beingDefaultPrintTplStatus",
+    "usages",
+)
+
+
+def _gap(reason_path: str, kind: str, message: str, **details: Any) -> dict[str, Any]:
+    gap: dict[str, Any] = {"reason_path": reason_path, "kind": kind, "message": message}
+    if details:
+        gap["details"] = details
+    return gap
+
+
+def _extract_filters(
+    view_info: dict[str, Any],
+    *,
+    fields_by_que_id: dict[int, dict[str, Any]],
+    reason_path: str,
+    gaps: list[dict[str, Any]],
+) -> list[Any] | None:
+    """viewgraphLimit → filters。
+
+    简易模式(limitType=1):规则组是唯一真源(viewgraphLimitFormula 是后端从规则组派生的存储态,
+    提取时忽略);单组 → 扁平 [rule,...](组内 AND,向后兼容),多组 → 嵌套 [[rule,...],...]
+    (组间 OR、组内 AND,与 visible_when/root_filter 的嵌组形态对齐)。
+    公式模式(limitType!=1):用户手写公式串,规则组不含其语义,真不可表达 → gap。
+    """
+    limit_type = view_info.get("viewgraphLimitType")
+    if limit_type not in (None, 1):
+        gaps.append(
+            _gap(
+                f"{reason_path}",
+                "formula_filters",
+                "viewgraphLimitType!=1 (formula mode) is not expressible in v1alpha1; view is not extractable",
+                viewgraphLimitType=limit_type,
+            )
+        )
+        return None
+    groups = view_info.get("viewgraphLimit")
+    if not groups:
+        return None
+    raw_groups = [groups] if isinstance(groups, list) and all(isinstance(rule, dict) for rule in groups) else groups
+    if not isinstance(raw_groups, list) or any(
+        not isinstance(group, list) or not group or any(not isinstance(rule, dict) for rule in group)
+        for group in raw_groups
+    ):
+        gaps.append(_gap(reason_path, "unresolved_filter_rules", "filter groups contain an invalid or empty group"))
+        return None
+    public_groups = _public_view_filter_groups_from_match_rules(groups, fields_by_que_id=fields_by_que_id)
+    if [len(group) for group in public_groups] != [len(group) for group in raw_groups]:
+        gaps.append(_gap(reason_path, "unresolved_filter_rules", "filter rules could not be completely extracted"))
+        return None
+    normalized_groups: list[list[dict[str, Any]]] = []
+    for group_index, raw_rules in enumerate(public_groups):
+        normalized_group: list[dict[str, Any]] = []
+        for rule in raw_rules:
+            operator = str(rule.get("operator") or "")
+            if operator.startswith("judge_type:"):
+                gaps.append(
+                    _gap(
+                        f"{reason_path}[{group_index}]",
+                        "unsupported_operator",
+                        "filter operator not in the v1alpha1 operator set",
+                        operator=operator,
+                    )
+                )
+                continue
+            field_que_id = _coerce_positive_int(rule.get("que_id"))
+            if field_que_id is None or field_que_id not in fields_by_que_id:
+                gaps.append(
+                    _gap(
+                        f"{reason_path}[{group_index}]",
+                        "unresolved_filter_field",
+                        "filter rule que_id does not resolve to a form field",
+                        que_id=rule.get("que_id"),
+                    )
+                )
+                continue
+            entry: dict[str, Any] = {"que_id": field_que_id, "operator": operator}
+            if operator in {"is_empty", "not_empty"}:
+                entry["values"] = []
+            elif operator == "in" and not (rule.get("values") or []) and rule.get("value") is None:
+                # ANY 判型+空值 = "未选任何值"合法形态,judgeType 保真回写
+                entry["values"] = []
+            elif isinstance(rule.get("values"), list) and rule["values"]:
+                entry["values"] = rule["values"]
+            elif rule.get("value") is not None:
+                entry["values"] = [rule["value"]]
+            else:
+                gaps.append(
+                    _gap(
+                        f"{reason_path}[{group_index}]",
+                        "empty_filter_values",
+                        "filter rule has no resolvable values",
+                        rule=rule,
+                    )
+                )
+                continue
+            normalized_group.append(entry)
+        if normalized_group:
+            normalized_groups.append(normalized_group)
+    if not normalized_groups:
+        return None
+    # 单组 → 扁平(兼容既有声明);多组 → 嵌套(OR of AND)
+    return normalized_groups[0] if len(normalized_groups) == 1 else normalized_groups
+
+
+def _extract_sort(
+    view_info: dict[str, Any],
+    *,
+    fields_by_que_id: dict[int, dict[str, Any]],
+    reason_path: str,
+    gaps: list[dict[str, Any]],
+) -> list[dict[str, Any]] | None:
+    """viewgraphSorts + sortType → sort;defaultSort(含 queId=0 占位)不产出。"""
+    if str(view_info.get("sortType") or "").strip() != "customSort":
+        return None
+    sorts: list[dict[str, Any]] = []
+    for index, raw in enumerate(view_info.get("viewgraphSorts") or []):
+        if not isinstance(raw, dict):
+            continue
+        que_id = raw.get("queId")
+        if _coerce_positive_int(que_id) in (None, 0):
+            continue
+        parsed_sort = _coerce_positive_int(que_id)
+        if parsed_sort in (None, 0):
+            continue
+        if parsed_sort not in fields_by_que_id:
+            gaps.append(_gap(f"{reason_path}[{index}]", "unresolved_que_id", "sort queId not in form field schema", que_id=parsed_sort))
+            continue
+        sorts.append({"que_id": parsed_sort, "ascending": bool(raw.get("beingSortAscend", True))})
+    return sorts or None
+
+
+def _extract_buttons(
+    view_info: dict[str, Any],
+    *,
+    fields_by_que_id: dict[int, dict[str, Any]],
+    reason_path: str,
+    gaps: list[dict[str, Any]],
+) -> list[dict[str, Any]]:
+    """从完整按钮读面提取绑定；DTO 列表仅作为旧读面的回退。"""
+    bindings: list[dict[str, Any]] = []
+    entries, entry_source = _extract_view_button_entries(view_info)
+    if entry_source in {"buttonConfigVO", "buttonConfigDTOList"} and len(entries) != len(view_info[entry_source]):
+        gaps.append(_gap(reason_path, "unresolved_button_entry", "button list contains invalid entries"))
+    for index, raw in enumerate(entries):
+        button_type = str(raw.get("buttonType") or "").upper()
+        if not button_type and entry_source == "buttonConfigDTOList":
+            button_type = "CUSTOM" if raw.get("buttonId") is not None else "SYSTEM"
+        if button_type not in {"SYSTEM", "CUSTOM"}:
+            gaps.append(_gap(f"{reason_path}[{index}].button_type", "unresolved_button_type", "button type could not be resolved"))
+            continue
+        button_id = _coerce_positive_int(raw.get("buttonId"))
+        if button_type == "SYSTEM":
+            # 系统按钮会由后端重建；自定义按钮必须使用实体 ID，不能使用配置行 ID。
+            button_id = _resolve_system_view_button_logical_id(raw) or button_id or _coerce_positive_int(raw.get("id"))
+        if button_id is None:
+            gaps.append(_gap(f"{reason_path}[{index}].button_id", "button_without_id", "button binding has no resolvable button ID", button_type=button_type))
+            continue
+        unsupported = [key for key in ("targetFormId", "triggerAddDataConfig", "triggerLinkUrl", "triggerWingsConfig", "httpRequestConfig") if raw.get(key) not in (None, "", [], {})]
+        if button_type == "SYSTEM" and unsupported:
+            gaps.append(_gap(f"{reason_path}[{index}]", "unsupported_button_config", "button action configuration cannot be represented by a binding", keys=unsupported))
+            continue
+        binding: dict[str, Any] = {
+            "button_id": button_id,
+            "config_type": str(raw.get("configType") or "TOP"),
+        }
+        binding["button_type"] = button_type
+        for source_key, target in (
+            ("buttonText", "button_text"),
+            ("buttonIcon", "button_icon"),
+            ("backgroundColor", "background_color"),
+            ("textColor", "text_color"),
+            ("triggerAction", "trigger_action"),
+        ):
+            if raw.get(source_key) is not None:
+                binding[target] = raw.get(source_key)
+        if raw.get("stylePreset"):
+            binding["style_preset"] = raw.get("stylePreset")
+        binding["being_main"] = bool(raw.get("beingMain"))
+        if raw.get("printTpls"):
+            binding["print_tpls"] = raw.get("printTpls")
+        if raw.get("buttonFormula") is not None:
+            binding["button_formula"] = raw.get("buttonFormula")
+        binding["button_formula_type"] = raw.get("buttonFormulaType") or 1
+        if raw.get("buttonLimit"):
+            public_limits = _extract_filters(
+                {"viewgraphLimit": raw["buttonLimit"], "viewgraphLimitType": 1},
+                fields_by_que_id=fields_by_que_id,
+                reason_path=f"{reason_path}[{index}].button_limit",
+                gaps=gaps,
+            )
+            if public_limits and isinstance(public_limits[0], dict):
+                public_limits = [public_limits]
+            binding["button_limit"] = public_limits or []
+        bindings.append(binding)
+    return bindings
+
+
+def _optionally(target: dict[str, Any], key: str, value: Any) -> None:
+    if value is None:
+        return
+    if isinstance(value, str) and not value.strip():
+        return
+    target[key] = value
+
+
+def extract_complete_view_declaration(
+    view_info: dict[str, Any],
+    *,
+    fields_by_que_id: dict[int, dict[str, Any]],
+) -> tuple[dict[str, Any], list[dict[str, Any]]]:
+    """把后端 ViewgraphInfo(GET /view/{key}/viewConfig 的 data)反向编译为 complete 档声明。
+
+    返回 (declaration, coverage_gaps)。声明可再经 `views validate` 离线校验;
+    gaps 覆盖:v1alpha1 契约外的配置面(公式/OR 组/系统列/打印模板等)与解析失败项。
+    """
+    gaps: list[dict[str, Any]] = []
+    name_by_que_id: dict[int, str] = {}
+    for que_id, field in fields_by_que_id.items():
+        name = str(field.get("name") or "").strip() if isinstance(field, dict) else ""
+        if name:
+            name_by_que_id[que_id] = name
+
+    raw_type = str(view_info.get("viewgraphType") or "").strip()
+    view_type = _VIEW_TYPE_BY_BACKEND.get(raw_type)
+    if view_type is None:
+        gaps.append(_gap("type", "unsupported_view_type", "viewgraphType is not a public v1alpha1 type", viewgraphType=raw_type))
+        return {}, gaps
+
+    declaration: dict[str, Any] = {"type": view_type, "name": str(view_info.get("viewgraphName") or "").strip()}
+    view_key = str(view_info.get("viewgraphKey") or "").strip()
+    if view_key:
+        declaration["view_key"] = view_key
+
+    columns: list[int] = []
+    for index, que_id in enumerate(view_info.get("viewgraphQueIds") or []):
+        parsed = _coerce_any_int(que_id)
+        if parsed in _SYSTEM_COLUMN_NAMES:
+            columns.append(parsed)
+            continue
+        if parsed is None or parsed <= 0:
+            gaps.append(
+                _gap(f"columns[{index}]", "system_column", "unknown system column is not supported by the public contract", que_id=que_id)
+            )
+            continue
+        if parsed not in fields_by_que_id:
+            gaps.append(
+                _gap(f"columns[{index}]", "unresolved_que_id", "queId does not exist in the form field schema", que_id=parsed)
+            )
+            continue
+        columns.append(parsed)
+    if columns:
+        declaration["columns"] = columns
+    elif view_type in {"table", "card"}:
+        # table/card 至少要有一列；系统列也属于后端可展示列。
+        gaps.append(
+            _gap("columns", "no_resolvable_columns", "table/card view has no columns resolvable to field names; view is not extractable")
+        )
+        return {}, gaps
+
+    group_que_id = _coerce_positive_int(view_info.get("groupQueId"))
+    if view_type == "board":
+        if group_que_id and group_que_id not in fields_by_que_id:
+            gaps.append(_gap("group_que_id", "unresolved_que_id", "board group queId not in form field schema", que_id=group_que_id))
+            group_que_id = None
+        if group_que_id:
+            declaration["group_que_id"] = group_que_id
+        else:
+            gaps.append(
+                _gap("group_by", "unresolved_board_group", "board view groupQueId does not resolve; view is not extractable")
+            )
+            return {}, gaps
+
+    gantt_raw = view_info.get("viewgraphGanttConfigVO") if isinstance(view_info.get("viewgraphGanttConfigVO"), dict) else {}
+    if view_type == "gantt":
+        start_que_id = _coerce_positive_int(gantt_raw.get("startTimeQueId"))
+        end_que_id = _coerce_positive_int(gantt_raw.get("endTimeQueId"))
+        title_que_id = _coerce_positive_int(gantt_raw.get("titleQueId")) or _coerce_positive_int(view_info.get("titleQue"))
+        # 系统列(queId<=5)或已删字段的 queId 不在 fields_by_que_id——不可引用,丢弃+gap
+        if start_que_id and start_que_id not in fields_by_que_id:
+            gaps.append(_gap("gantt.start_que_id", "unresolved_que_id", "start queId not in form field schema", que_id=start_que_id))
+            start_que_id = None
+        if end_que_id and end_que_id not in fields_by_que_id:
+            gaps.append(_gap("gantt.end_que_id", "unresolved_que_id", "end queId not in form field schema", que_id=end_que_id))
+            end_que_id = None
+        if title_que_id and title_que_id not in fields_by_que_id:
+            gaps.append(_gap("gantt.title_que_id", "unresolved_que_id", "title queId not in form field schema", que_id=title_que_id))
+            title_que_id = None
+        if not (start_que_id and end_que_id):
+            # 契约要求 gantt 必须有 start/end;存量存在配置一半的视图(无起止字段),
+            # 判不可提取入账本,而非产出缺字段的非法声明
+            gaps.append(_gap("gantt", "unresolved_gantt_config", "gantt start/end fields do not resolve; view is not extractable"))
+            return {}, gaps
+        declaration["start_que_id"] = start_que_id
+        declaration["end_que_id"] = end_que_id
+        _optionally(declaration, "title_que_id", title_que_id)
+        gantt: dict[str, Any] = {}
+        _optionally(gantt, "title_que_id", title_que_id)
+        _optionally(gantt, "start_que_id", start_que_id)
+        _optionally(gantt, "end_que_id", end_que_id)
+        _optionally(gantt, "default_time_dimension", gantt_raw.get("defaultTimeDimension"))
+        groups: list[dict[str, Any]] = []
+        for raw_group in gantt_raw.get("ganttGroupVOList") or []:
+            if not isinstance(raw_group, dict):
+                continue
+            group_que = _coerce_positive_int(raw_group.get("groupQueId"))
+            if group_que:
+                entry: dict[str, Any] = {"que_id": group_que}
+                _optionally(entry, "ordinal", raw_group.get("ordinal"))
+                groups.append(entry)
+        if groups:
+            gantt["groups"] = groups
+        dependency_raw = gantt_raw.get("ganttDependencyVO") if isinstance(gantt_raw.get("ganttDependencyVO"), dict) else {}
+        if dependency_raw.get("dependencyQueId") is not None or dependency_raw.get("predecessorTaskQueId") is not None:
+            dependency: dict[str, Any] = {}
+            dep_que = _coerce_positive_int(dependency_raw.get("dependencyQueId"))
+            pred_que = _coerce_positive_int(dependency_raw.get("predecessorTaskQueId"))
+            if dep_que and pred_que:
+                dependency = {"dependency_que_id": dep_que, "predecessor_que_id": pred_que}
+                _optionally(dependency, "start_start_option_id", dependency_raw.get("startStartOptionId"))
+                _optionally(dependency, "start_end_option_id", dependency_raw.get("startEndOptionId"))
+                _optionally(dependency, "end_start_option_id", dependency_raw.get("endStartOptionId"))
+                _optionally(dependency, "end_end_option_id", dependency_raw.get("endEndOptionId"))
+                gantt["dependencies"] = [dependency]
+            else:
+                gaps.append(_gap("gantt.dependencies", "unresolved_gantt_dependency", "gantt dependency queIds do not resolve", raw=dependency_raw))
+        if gantt:
+            declaration["gantt"] = gantt
+
+    hierarchy_raw = view_info.get("viewgraphHierarchyConfigVO") if isinstance(view_info.get("viewgraphHierarchyConfigVO"), dict) else {}
+    if view_type == "hierarchy":
+        title_que = _coerce_positive_int(hierarchy_raw.get("titleQueId"))
+        children_que = _coerce_positive_int(hierarchy_raw.get("childrenQueId"))
+        if not (title_que and children_que):
+            gaps.append(_gap("hierarchy", "unresolved_hierarchy_config", "hierarchy title/children queIds do not resolve; view is not extractable"))
+            return {}, gaps
+        hierarchy: dict[str, Any] = {"title_que_id": title_que, "children_que_id": children_que}
+        root_groups = _public_view_filter_groups_from_match_rules(
+            hierarchy_raw.get("rootNodeFilter"), fields_by_que_id=fields_by_que_id
+        )
+        if root_groups:
+            hierarchy["root_filter"] = root_groups
+        declaration["hierarchy"] = hierarchy
+        _optionally(declaration, "title_que_id", title_que)
+
+    if view_type == "calendar":
+        calendar_raw = view_info.get("viewgraphCalendarConfigVO") if isinstance(view_info.get("viewgraphCalendarConfigVO"), dict) else {}
+        title_que = _coerce_positive_int(calendar_raw.get("titleQueId"))
+        date_que = _coerce_any_int(calendar_raw.get("dateQueId"))
+        color_que = _coerce_positive_int(calendar_raw.get("colorQueId"))
+        if title_que is None or title_que not in fields_by_que_id:
+            gaps.append(_gap("calendar.title_que_id", "unresolved_calendar_config", "calendar title queId does not resolve; view is not extractable", que_id=title_que))
+            return {}, gaps
+        if date_que is None or (date_que not in {2, 3} and date_que not in fields_by_que_id):
+            gaps.append(_gap("calendar.date_que_id", "unresolved_calendar_config", "calendar date queId does not resolve; view is not extractable", que_id=date_que))
+            return {}, gaps
+        calendar: dict[str, Any] = {"title_que_id": title_que, "date_que_id": date_que}
+        if color_que is not None:
+            if color_que not in fields_by_que_id:
+                gaps.append(_gap("calendar.color_que_id", "unresolved_que_id", "calendar color queId does not resolve", que_id=color_que))
+                return {}, gaps
+            calendar["color_que_id"] = color_que
+        declaration["calendar"] = calendar
+        declaration["title_que_id"] = title_que
+
+    if view_type in {"card", "board"}:
+        _optionally(declaration, "title_que_id", _coerce_positive_int(view_info.get("titleQue")))
+
+    if view_type == "card":
+        card: dict[str, Any] = {}
+        for raw_key, gap_key in (("titleQue", "title_que_id"), ("frontCoverQueId", "cover_que_id")):
+            raw_val = _coerce_positive_int(view_info.get(raw_key))
+            if raw_val and raw_val not in fields_by_que_id:
+                gaps.append(_gap(f"card.{gap_key}", "unresolved_que_id", f"card {gap_key} not in form field schema", que_id=raw_val))
+            else:
+                _optionally(card, gap_key, raw_val)
+        _optionally(card, "clipping_mode", view_info.get("clippingMode"))
+        _optionally(card, "image_adaption", view_info.get("beingImageAdaption"))
+        _optionally(card, "show_field_title", view_info.get("beingShowQueTitle"))
+        _optionally(card, "show_title", view_info.get("beingShowTitleQue"))
+        _optionally(card, "show_cover", view_info.get("beingShowCover"))
+        if group_que_id and group_que_id not in fields_by_que_id:
+            gaps.append(_gap("card.group_que_id", "unresolved_que_id", "card group queId not in form field schema", que_id=group_que_id))
+        else:
+            _optionally(card, "group_que_id", group_que_id)
+        _optionally(card, "group_color", view_info.get("beingGroupColor"))
+        if card:
+            declaration["card"] = card
+
+    filter_gap_count = len(gaps)
+    filters = _extract_filters(view_info, fields_by_que_id=fields_by_que_id, reason_path="filters", gaps=gaps)
+    if len(gaps) > filter_gap_count:
+        return {}, gaps
+    if filters is not None:
+        declaration["filters"] = filters
+
+    data_permission_type = str(view_info.get("dataPermissionType") or "").strip().upper()
+    data_scope = _DATA_SCOPE_TO_PUBLIC.get(str(view_info.get("dataScope") or "").strip().upper())
+    if data_permission_type or data_scope:
+        declaration["data_permission"] = {
+            "type": "config" if data_permission_type == "CONFIG" else "custom",
+            "scope": data_scope or "all",
+        }
+
+    sort = _extract_sort(view_info, fields_by_que_id=fields_by_que_id, reason_path="sort", gaps=gaps)
+    if sort is not None:
+        declaration["sort"] = sort
+
+    auth = view_info.get("auth")
+    if auth is not None:
+        visibility = _public_visibility_from_member_auth(auth)
+        # mode="specific" + 空 selectors 是合法形态(auth=2 但未配置成员);
+        # apply 回写 auth=2 + 空成员列表,语义保真,不降级。
+        declaration["visibility"] = visibility
+
+    button_gap_count = len(gaps)
+    buttons = _extract_buttons(view_info, fields_by_que_id=fields_by_que_id, reason_path="buttons", gaps=gaps)
+    if len(gaps) > button_gap_count:
+        return {}, gaps
+    if _extract_view_button_entries(view_info)[1] is not None:
+        declaration["buttons"] = buttons
+
+    if view_info.get("queryConditionStatus") is not None:
+        rows: list[list[str]] = []
+        for raw_row in view_info.get("queryCondition") or []:
+            if not isinstance(raw_row, dict):
+                continue
+            row_names: list[str] = []
+            for index, que_id in enumerate(raw_row.get("queIds") or []):
+                parsed = _coerce_any_int(que_id)
+                if parsed is None:
+                    continue
+                if _is_known_system_view_que_id(parsed) or parsed in fields_by_que_id:
+                    row_names.append(parsed)
+            if row_names:
+                rows.append(row_names)
+        if view_info.get("queryConditionStatus") and not rows:
+            gaps.append(_gap("query_conditions", "unresolved_query_condition", "queryConditionStatus=true but no queIds resolve to field names"))
+        else:
+            declaration["query_conditions"] = {
+                "enabled": bool(view_info.get("queryConditionStatus")),
+                "exact": bool(view_info.get("queryConditionExact")),
+                "hide_before_query": bool(view_info.get("hideBeforeQueryCondition")),
+                "rows": rows,
+            }
+
+    asos_raw = view_info.get("asosChartConfig") if isinstance(view_info.get("asosChartConfig"), dict) else {}
+    asos_visible = view_info.get("asosChartVisible")
+    if asos_visible is not None or asos_raw:
+        associated: dict[str, Any] = {"visible": bool(asos_visible)}
+        if associated["visible"]:
+            limit_type = asos_raw.get("limitType")
+            if limit_type is not None:
+                associated["limit_type"] = "all" if int(limit_type) == ASSOCIATED_RESOURCE_LIMIT_TYPE_ALL else "select"
+            item_ids = [item for item in asos_raw.get("asosChartIdList") or [] if item is not None]
+            if item_ids:
+                associated["associated_item_ids"] = item_ids
+        declaration["associated_resources"] = associated
+
+    display: dict[str, Any] = {}
+    _optionally(display, "row_height", view_info.get("defaultRowHigh"))
+    _optionally(display, "pin_navigate", view_info.get("beingPinNavigate"))
+    _optionally(display, "remark", view_info.get("remark"))
+    if display:
+        declaration["display"] = display
+
+    record: dict[str, Any] = {}
+    for source, target in (
+        ("beingAuditRecordVisible", "audit_visible"),
+        ("beingDataLogVisible", "data_log_visible"),
+        ("beingQrobotRecordVisible", "qrobot_record_visible"),
+        ("beingWorkflowNodeFutureListVisible", "workflow_future_visible"),
+        ("beingCommentStatus", "comment"),
+    ):
+        if view_info.get(source) is not None:
+            record[target] = bool(view_info.get(source))
+    if record:
+        declaration["record"] = record
+
+    share: dict[str, Any] = {}
+    if view_info.get("beingNeedPass") is not None:
+        share["need_pass"] = bool(view_info.get("beingNeedPass"))
+    # 历史数据保全项(legacy_data_preserved):存量密码不符合当前安全策略(49603)——
+    # 视图配置本身合法,后端策略演进导致无法原样回写。提取不回传敏感值,
+    # apply 显式清空触发后端 isNotBlank(空)保留语义,原密码/开关零丢失。
+    # 这类不是失败,单列统计。
+    if view_info.get("beingNeedPass") and str(view_info.get("viewgraphPass") or "").strip():
+        gaps.append(_gap("share.password", "legacy_password_preserved", "legacy password not round-tripped (backend policy); original preserved via isNotBlank semantics"))
+    if view_info.get("beingForceLogin") is not None:
+        share["force_login"] = bool(view_info.get("beingForceLogin"))
+    if view_info.get("beingPrintStatus") is not None:
+        share["print_enabled"] = bool(view_info.get("beingPrintStatus"))
+    if share:
+        declaration["share"] = share
+
+    if view_info.get("printTpls"):
+        gaps.append(_gap("share.print", "print_templates", "printTpls details are deferred to v1alpha2", count=len(view_info.get("printTpls") or [])))
+    for key in _UNCOVERED_READBACK_KEYS:
+        value = view_info.get(key)
+        if value in (None, [], {}, "", False):
+            continue
+        if key == "querySearchStatus" and value is True and view_info.get("queryConditionStatus") is None:
+            continue
+        gaps.append(_gap(key, "uncovered_readback_key", "read-back key present in backend payload but outside the v1alpha1 contract", value_preview=str(value)[:80]))
+
+    return declaration, gaps
+
+
+def summarize_gaps(gaps: list[dict[str, Any]]) -> dict[str, int]:
+    """按 kind 聚合 coverage gaps,供覆盖度报告使用。"""
+    summary: dict[str, int] = {}
+    for gap in gaps:
+        summary[gap.get("kind") or "unknown"] = summary.get(gap.get("kind") or "unknown", 0) + 1
+    return summary
+
+
+__all__ = [
+    "extract_complete_view_declaration",
+    "summarize_gaps",
+]