@qingflow-tech/qingflow-cli 1.1.57 → 1.1.59

package/src/qingflow_mcp/builder_facade/app_form.py

@@ -18,7 +18,6 @@ from ..tools.app_tools import AppTools
 from ..tools.package_tools import PackageTools
 from .app_form_schema import AppFormContractError, AppFormSchemaContext, AppFormSchemaRegistry
 from .service import (
-    AmbiguousFieldSelector,
     _coerce_any_int,
     _compile_code_block_binding_fields,
     _compile_q_linker_binding_fields,
@@ -46,7 +45,6 @@ QUE_TYPE_TO_CANONICAL = {
     11: "single_select",
     12: "multi_select",
     13: "attachment",
-    16: "rich_text",
     18: "subtable",
     19: "data_relation",
     20: "q_linker",
@@ -58,7 +56,6 @@ QUE_TYPE_TO_CANONICAL = {
 CANONICAL_TO_QUE_TYPE = {
     "text": 2,
     "long_text": 3,
-    "rich_text": 16,
     "number": 8,
     "amount": 8,
     "link": 9,
@@ -83,10 +80,8 @@ SUBFIELD_TYPES = {
     "text",
     "long_text",
     "number",
-    "amount",
     "link",
     "date",
-    "datetime",
     "phone",
     "email",
     "single_choice",
@@ -99,43 +94,6 @@ SUBFIELD_TYPES = {
     "department",
 }
 CHOICE_TYPES = {"single_choice", "single_select", "multi_select"}
-
-# 数据关联筛选 dynamic_range 操作数的动态范围枚举(id → 名称),与后端
-# Constants.DYNAMIC_TYPE(apaas-common Constants.java:4674)单一来源同步:
-# 提取侧 judgeValueDetails.value 即此名称形态(实测 id=7 value="今年"),写回侧
-# 按名称恢复 id——后端 checkRelationMatchRules(FormSvcImpl:10445)对 judgeType=8
-# 校验 judgeValueDetails 非空且 id 非 null,丢失 id 即 400「筛选条件配置有误」。
-# id=22「自定义」在 data_relation 筛选存量里未见(value 形态非固定),不映射名称。
-DYNAMIC_RANGE_NAME_TO_ID = {
-    "今日": 1,
-    "昨日": 2,
-    "本周 （周日 ~ 周六）": 3,
-    "上周 （周日 ~ 周六）": 4,
-    "本月": 5,
-    "上月": 6,
-    "今年": 7,
-    "去年": 8,
-    "近7天": 9,
-    "近30天": 10,
-    "近90天": 11,
-    "本周 （周一 ~ 周日）": 12,
-    "上周 （周一 ~ 周日）": 13,
-    "明天": 14,
-    "下周（周日 ~ 周六）": 15,
-    "下月": 16,
-    "本季度": 17,
-    "下季度": 18,
-    "上季度": 19,
-    "明年": 20,
-    "下周 （周一 ~ 周日）": 21,
-}
-# 名称宽松匹配(剔内嵌空白)兜底:后端数组存在带/不带空格的变体(如 15 与 3/12 形态不一),
-# 归一后仍唯一命中才采用,避免歧义名称误映射。
-_DYNAMIC_RANGE_NORMALIZED = {}
-for _name, _id in DYNAMIC_RANGE_NAME_TO_ID.items():
-    _key = "".join(_name.split())
-    _DYNAMIC_RANGE_NORMALIZED.setdefault(_key, _id)
-
 INTEGRATION_TARGET_TYPES = {
     "text",
     "long_text",
@@ -704,9 +662,8 @@ class AppFormNormalizer:
                     ]
                     if fields:
                         rows.append({"fields": fields})
-                # 空 section 是合法存量形态:后端 updateFormInfo 对空 innerQuestions 仅产出
-                # 零行 draft_section_question(段落本身作为 queType=24 question 照常保存),
-                # 读面 getFormInfoByAppKey 同样返回空 innerQuestions——按声明原样写,空↔空稳定。
+                if not rows:
+                    raise AppFormFailure("UNSUPPORTED_LAYOUT", "existing section is empty", "NORMALIZE")
                 body.append(
                     {
                         "kind": "section",
@@ -723,26 +680,14 @@ class AppFormNormalizer:
                 ]
                 if fields:
                     body.append({"kind": "row", "fields": fields})
-        # 空表单 + 悬空 dataTitleQueId/dataCoverQueId(模板安装出的空壳应用常见:
-        # 后端 GET 原样吐出指向已不存在字段的 id)读面 canonical 化为 null——
-        # 写回 null 后端 normalizeDataTitleQueId 兜底、空表单落库等价,避免
-        # validate/apply 的 INVALID_DATA_TITLE_FIELD 拒掉自家写面(round-trip 断裂)。
-        has_fields = any(
-            bool(block.get("fields")) for block in body if block.get("kind") == "row"
-        ) or any(
-            bool(row.get("fields"))
-            for block in body
-            if block.get("kind") == "section"
-            for row in block.get("rows") or []
-        )
         resource = {
             "apiVersion": context.api_version,
             "appKey": app_key,
             "spec": {
                 "appName": _compat_label(form.get("formTitle"), "App", app_key),
                 "appDescription": form.get("formDesc") or None,
-                "dataTitleField": _selector(title_id, field_names.get(title_id or 0)) if title_id is not None and has_fields else None,
-                "dataCoverField": _selector(cover_id, field_names.get(cover_id or 0)) if cover_id is not None and has_fields else None,
+                "dataTitleField": _selector(title_id, field_names.get(title_id or 0)) if title_id is not None else None,
+                "dataCoverField": _selector(cover_id, field_names.get(cover_id or 0)) if cover_id is not None else None,
                 "attachments": self._attachments(form.get("formAttach")),
                 "serialNumber": self._serial_number(form.get("serialNumType"), form.get("serialNumConfig")),
                 "body": body,
@@ -974,6 +919,8 @@ class AppFormNormalizer:
             reference = question.get("referenceConfig") if isinstance(question.get("referenceConfig"), dict) else {}
             refer_questions = [item for item in reference.get("referQuestions") or [] if isinstance(item, dict)]
             display_id = _positive_int(reference.get("referQueId"))
+            display = next((item for item in refer_questions if _positive_int(item.get("queId")) == display_id), None)
+            visible = [item for item in refer_questions if _positive_int(item.get("queAuth")) != 2]
             target_app_key = str(reference.get("referAppKey") or "")
             if not target_app_key.strip():
                 raise AppFormFailure(
@@ -985,37 +932,25 @@ class AppFormNormalizer:
             relation_config: JSONObject = {
                 "targetAppKey": target_app_key,
                 "relationMode": "multiple" if _positive_int(reference.get("optionalDataNum")) not in {None, 1} else "single",
-                "displayFields": [
-                    {
-                        "field": _require_selector(
-                            item.get("queId"),
-                            item.get("queTitle"),
-                            message="relation display field cannot be normalized",
-                            details={"queId": que_id, "path": "/config/displayFields"},
-                        ),
-                        "auth": {1: "editable", 2: "hidden", 3: "visible"}.get(
-                            _positive_int(item.get("queAuth")), "visible"
-                        ),
-                    }
-                    for item in sorted(
-                        refer_questions,
-                        key=lambda item: (
-                            item.get("ordinal") is None,
-                            item.get("ordinal") if isinstance(item.get("ordinal"), int) else 0,
-                        ),
+                "displayField": _require_selector(
+                    display_id,
+                    (display or {}).get("queTitle"),
+                    message="relation display field cannot be normalized",
+                    details={"queId": que_id, "path": "/config/displayField"},
+                ),
+                "visibleFields": [
+                    _require_selector(
+                        item.get("queId"),
+                        item.get("queTitle"),
+                        message="relation visible field cannot be normalized",
+                        details={"queId": que_id},
                     )
+                    for item in visible
                 ],
                 "beingDefaultFormulaAutoFillEnabled": reference.get("beingDefaultFormulaAutoFillEnabled"),
                 "defaultValueMatchRules": reference.get("defaultValueMatchRules"),
                 "defaultValues": question.get("queDefaultValues") if isinstance(question.get("queDefaultValues"), dict) else None,
             }
-            if display_id is not None:
-                relation_config["twoWayBoundField"] = _require_selector(
-                    display_id,
-                    next((item.get("queTitle") for item in refer_questions if _positive_int(item.get("queId")) == display_id), None),
-                    message="relation two-way bound field cannot be normalized",
-                    details={"queId": que_id, "path": "/config/twoWayBoundField"},
-                )
             if supports_reference_default_formula:
                 formula = reference.get("defaultValueFormula")
                 relation_config["defaultValueFormula"] = formula if not isinstance(formula, str) or formula.strip() else None
@@ -1357,12 +1292,7 @@ class AppFormNormalizer:
         que_id = _positive_int(question.get("queId"))
         relation = next((item for item in relations if _positive_int(item.get("queId")) == que_id), None)
         if relation is None:
-            # 后端 GET 读面会过滤 displayed 目标缺失的 relation 行(FormSvcImpl#getQuestionRelationsBeans
-            # 对 displayedForm/displayedQuestion 为 null 的行 continue,40013 存量实证:displayed_que_id=0
-            # 共 264 行、displayed_form/que 闭包外 98/116 行)。此时字段本体仍在 formQues 中,
-            # 但关联配置不可回读——保留字段并回读空 config(source 省略);写回侧不重建该字段的
-            # relation 行,与后端读面行为对称。库表级 diff 将此类行归入「历史数据保全」单列。
-            return {}
+            raise AppFormFailure("UNSUPPORTED_FIELD_CONFIG", "data_relation has no question relation", "NORMALIZE", details={"queId": que_id})
         relation_type = _positive_int(relation.get("relationType")) or 1
         displayed = relation.get("displayedQueInfo") if isinstance(relation.get("displayedQueInfo"), dict) else {}
         alias = relation.get("aliasConfig") if isinstance(relation.get("aliasConfig"), dict) else {}
@@ -1463,25 +1393,15 @@ class AppFormNormalizer:
         if isinstance(judge_type, bool) or not isinstance(judge_type, int) or judge_type not in BACKEND_TO_JUDGE_TYPE:
             raise AppFormFailure("UNSUPPORTED_FIELD_CONFIG", "data_relation judgeType cannot be normalized", "NORMALIZE", details={"queId": que_id, "judgeType": judge_type})
         condition: JSONObject = {
-            "sourceField": _selector(value.get("queId"), value.get("queTitle")) or None,
+            "sourceField": _require_selector(value.get("queId"), value.get("queTitle"), message="data_relation source field cannot be normalized", details={"queId": que_id}),
             "operator": BACKEND_TO_JUDGE_TYPE[judge_type],
         }
-        if condition["sourceField"] is None:
-            # 存量读回形态:后端反解析出的条件源字段缺失(queId=0 且无名称,原公式
-            # 如 #queId_0$)。省略 sourceField 保留 operator/operand 语义,写回时以
-            # queId=0 透传(后端 matchRulesToFormula 重新生成 #queId_0$,往返对称)。
-            del condition["sourceField"]
         match_type = _positive_int(value.get("matchType")) or 1
         if match_type == 1:
             details = value.get("judgeValueDetails")
             if isinstance(details, list):
-                # value 为空串且 id 非空 → 悬空选项引用(选项已被删,id 仍指向已删
-                # optId):以 id 形态保留(写回时透传为悬空引用,往返对称;约束 2:
-                # 语义保真优先于「apply 通过」——不产出不可写回的空串声明)。
                 literal_values = [
-                    str(item["id"])
-                    if item.get("value") in (None, "") and item.get("id") is not None
-                    else str(item.get("value"))
+                    str(item.get("value") if item.get("value") is not None else item.get("id"))
                     for item in details
                     if isinstance(item, dict) and (item.get("value") is not None or item.get("id") is not None)
                 ]
@@ -1732,10 +1652,7 @@ class AppFormCompiler:
             selected = [field for field in target_fields if selector_id is not None and _positive_int(field.get("queId")) == selector_id]
             if len(selected) == 1:
                 target_spec[key] = _selector(selected[0].get("queId"), selected[0].get("name"))
-        # target 层面同样放行 dataTitleField=null:后端写链
-        # FormSvcImpl.normalizeDataTitleQueId 会兑底到第一个可用字段,
-        # current 与 declared 均为 null 时 target 保持 null 合法。
-        data_title, data_cover = self._validate_target(target_spec, allow_missing_data_title=True)
+        data_title, data_cover = self._validate_target(target_spec)
         target_spec["dataTitleField"] = _selector(data_title.get("queId"), data_title.get("name")) if data_title is not None else None
         target_spec["dataCoverField"] = _selector(data_cover.get("queId"), data_cover.get("name")) if data_cover is not None else None
         return {"apiVersion": context.api_version, "appKey": app_key, "spec": target_spec}
@@ -1756,8 +1673,6 @@ class AppFormCompiler:
             relation_context["questionRelations"] = relations
             internal_fields, relations = _compile_q_linker_binding_fields(fields=internal_fields, current_schema=relation_context)
             self._validate_unique_relation_targets(relations, internal_fields)
-        except AmbiguousFieldSelector as error:
-            raise AppFormFailure("AMBIGUOUS_FIELD_SELECTOR", str(error), "CONTRACT_PRECHECK", details={"candidateQueIds": error.candidates}) from error
         except (KeyError, ValueError) as error:
             raise AppFormFailure("UNSUPPORTED_FIELD_CONFIG", str(error), "CONTRACT_PRECHECK") from error
         self._assign_subfield_temp_ids(internal_fields)
@@ -2063,13 +1978,10 @@ class AppFormCompiler:
         if any(present) and not all(present):
             raise AppFormFailure("INVALID_ROW_WIDTH", "all fields in a row must provide width together", "CONTRACT_PRECHECK")
         if all(present):
-            # 宽度取值:任意 1-100 整数(后端 html_width 无取值校验,存量存在
-            # 33/34/20/30 等值,33+33+34=100 的三等分历史布局);仅保留
-            # 「全有或全无」约束。行总和不强制 =100:后端写链无总和校验
-            # (QuestionConstant.DEFAULT_QUE_WIDTH=100 仅为新建默认值),存量
-            # 数据存在字段删除后留白的行,get 读出的原布局必须能原样 apply。
-            if any(not (isinstance(field.get("width"), int) and 1 <= field["width"] <= 100) for field in fields):
-                raise AppFormFailure("INVALID_ROW_WIDTH", "field widths must be an integer between 1 and 100", "CONTRACT_PRECHECK")
+            if any(_positive_int(field.get("width")) not in {25, 50, 75, 100} for field in fields):
+                raise AppFormFailure("INVALID_ROW_WIDTH", "field widths must be one of 25, 50, 75, or 100", "CONTRACT_PRECHECK")
+            if sum(int(field["width"]) for field in fields) != 100:
+                raise AppFormFailure("INVALID_ROW_WIDTH", "field widths in a row must total 100", "CONTRACT_PRECHECK")
             return
         widths = {
             1: [100],
@@ -2088,23 +2000,24 @@ class AppFormCompiler:
     ) -> tuple[JSONObject | None, JSONObject | None]:
         body = spec.get("body") or []
         fields = list(_iter_fields(body))
-        # 方案 A(duplicate-field-name):同父级允许同名——后端以 queId 为字段身份
-        # (40013 实测 1624 组同名),get 提出的合法形态必须能写回;name 解析的
-        # 歧义由各 selector resolver 以 AMBIGUOUS_FIELD_SELECTOR 显式拒绝,
-        # 不在目标校验层做 name 唯一性强校验。
+        names: set[str] = set()
         for field in fields:
+            name = str(field.get("name") or "")
+            if name in names:
+                raise AppFormFailure("DUPLICATE_FIELD_NAME", f"duplicate top-level field name: {name}", "CONTRACT_PRECHECK")
+            names.add(name)
             if _field_type(field) == "subtable":
+                sub_names: set[str] = set()
                 for subfield in field.get("subfields") or []:
                     if _field_type(subfield) not in SUBFIELD_TYPES:
                         raise AppFormFailure("INVALID_SPEC", "unsupported subtable field type", "CONTRACT_PRECHECK", details={"allowedTypes": sorted(SUBFIELD_TYPES)})
+                    if subfield.get("name") in sub_names:
+                        raise AppFormFailure("DUPLICATE_FIELD_NAME", f"duplicate subtable field name: {subfield.get('name')}", "CONTRACT_PRECHECK")
+                    sub_names.add(str(subfield.get("name") or ""))
         title_selector = spec.get("dataTitleField")
         data_title: JSONObject | None = None
         if fields:
-            # dataTitleField=null(键存在值为空)与省略键同权放行:后端写链
-            # FormSvcImpl.normalizeDataTitleQueId 对 null 自动 fallback 到第一个
-            # 可用字段(findDefaultDataTitleQueId),apply 侧缺省完全合法;
-            # get 读面在后端 dataTitleQueId 未设置时原样输出 null,round-trip 必须接受。
-            if title_selector is None and allow_missing_data_title:
+            if title_selector is None and allow_missing_data_title and "dataTitleField" not in spec:
                 pass
             elif not isinstance(title_selector, dict):
                 raise AppFormFailure(
@@ -2155,8 +2068,6 @@ class AppFormCompiler:
             relation_context["questionRelations"] = relations
             internal_fields, relations = _compile_q_linker_binding_fields(fields=internal_fields, current_schema=relation_context)
             self._validate_unique_relation_targets(relations, internal_fields)
-        except AmbiguousFieldSelector as error:
-            raise AppFormFailure("AMBIGUOUS_FIELD_SELECTOR", str(error), "COMPILE", details={"candidateQueIds": error.candidates}) from error
         except (KeyError, ValueError) as error:
             raise AppFormFailure("UNSUPPORTED_FIELD_CONFIG", str(error), "COMPILE") from error
         self._assign_subfield_temp_ids(internal_fields)
@@ -2213,8 +2124,7 @@ class AppFormCompiler:
                 rows.append([section])
         payload["formQues"] = rows
         self._validate_unique_temp_ids(rows)
-        target_data_title_selector = target["spec"]["dataTitleField"]
-        data_title = _resolve_canonical_selector(target_data_title_selector, target_fields, "dataTitleField") if target_fields and isinstance(target_data_title_selector, dict) else None
+        data_title = _resolve_canonical_selector(target["spec"]["dataTitleField"], target_fields, "dataTitleField") if target_fields else None
         data_cover_selector = target["spec"].get("dataCoverField")
         data_cover = _resolve_canonical_selector(data_cover_selector, target_fields, "dataCoverField") if isinstance(data_cover_selector, dict) else None
         payload["dataTitleQueId"] = self._field_runtime_id(data_title, internal_fields)
@@ -2421,16 +2331,6 @@ class AppFormCompiler:
                 {
                     "target_app_key": config.get("targetAppKey"),
                     "relation_mode": config.get("relationMode") or "single",
-                    "two_way_bound_field": _snake_selector(config.get("twoWayBoundField")),
-                    "display_fields": [
-                        {
-                            "field": _snake_selector(item.get("field")),
-                            "auth": item.get("auth") or "visible",
-                        }
-                        for item in config.get("displayFields") or []
-                        if isinstance(item, dict)
-                    ],
-                    # Deprecated input names stay available to the compiler compatibility translator.
                     "display_field": _snake_selector(config.get("displayField")),
                     "visible_fields": [_snake_selector(item) for item in config.get("visibleFields") or []],
                     "reference_default_formula_auto_fill": config.get("beingDefaultFormulaAutoFillEnabled"),
@@ -2449,7 +2349,7 @@ class AppFormCompiler:
     def _question(self, profile: str, app_key: str, field: JSONObject, internal: JSONObject, temp_id: int, relations: list[JSONObject]) -> JSONObject:
         field_type = _field_type(field)
         que_type = CANONICAL_TO_QUE_TYPE[field_type]
-        build_type = "boolean" if field_type == "single_choice" else "text" if field_type in {"link", "data_relation", "rich_text"} else field_type
+        build_type = "boolean" if field_type == "single_choice" else "text" if field_type in {"link", "data_relation"} else field_type
         built_internal = deepcopy(internal)
         built_internal["type"] = build_type
         if build_type == "subtable":
@@ -2606,24 +2506,18 @@ class AppFormCompiler:
             config = field.get("config") or {}
             related_que_id = _positive_int(internal.get("data_relation_related_que_id"))
             if related_que_id is None:
-                # 存量读回形态(后端 GET 不回传该字段的 relation):模板里保留着后端
-                # 镜像字段(relatedQueId/queOriginType),透传保持字段级语义不失真。
-                template_related = _positive_int((template or {}).get("relatedQueId"))
-                if template_related is not None:
-                    question["relatedQueId"] = template_related
-                else:
-                    question.pop("relatedQueId", None)
+                question.pop("relatedQueId", None)
             else:
                 question["relatedQueId"] = related_que_id
             que_origin_type = _positive_int(internal.get("data_relation_origin_type"))
             if que_origin_type is None:
-                template_origin = _positive_int((template or {}).get("queOriginType"))
-                if template_origin is not None:
-                    question["queOriginType"] = template_origin
-                else:
-                    question.pop("queOriginType", None)
-            else:
-                question["queOriginType"] = que_origin_type
+                raise AppFormFailure(
+                    "UNSUPPORTED_FIELD_CONFIG",
+                    "data_relation source type could not be derived",
+                    "COMPILE",
+                    details={"field": field.get("name")},
+                )
+            question["queOriginType"] = que_origin_type
             aggregation = config.get("aggregation")
             if aggregation is None:
                 question.pop("aggreType", None)
@@ -2638,76 +2532,23 @@ class AppFormCompiler:
 
     def _reference_config(self, profile: str, config: JSONObject, template: JSONObject | None = None) -> JSONObject:
         target_app_key = str(config.get("targetAppKey") or "")
-        candidates, _target_form = self._target_form_candidates(profile, target_app_key)
-        explicit_display = isinstance(config.get("displayFields"), list)
-        deprecated_keys = [
-            key
-            for key in ("displayField", "display_field", "visibleFields", "visible_fields")
-            if key in config and config.get(key) is not None
-        ]
-        if explicit_display and deprecated_keys:
-            raise AppFormFailure(
-                "INVALID_SPEC",
-                "relation cannot mix displayFields with deprecated displayField/visibleFields", 
-                "CONTRACT_PRECHECK",
-            )
-        if explicit_display:
-            # 显式 displayFields(含空列表)按声明原样写:空列表 = 无展示字段,round-trip 空↔空稳定。
-            # 后端语义(2026-09-23 沿源码定案):FormQuestionSvcImpl.creteOrUpdateReference 对空
-            # referQuestions 走 CollectionUtils.isNotEmpty 跳过插入,读面 getReferenceConfig
-            # 同样容忍空——空列表是合法存量形态(双向绑定 referQueId 非空、未配展示字段)。
-            display_entries = [item for item in config["displayFields"] if isinstance(item, dict)]
-        elif deprecated_keys:
-            # v1alpha1 compatibility: the old displayField was both the main display field and the binding field.
-            legacy_display = config.get("displayField") or config.get("display_field") or {}
-            legacy_visible = config.get("visibleFields") or config.get("visible_fields") or []
-            display_entries = [{"field": legacy_display, "auth": "visible"}]
-            display_entries.extend({"field": item, "auth": "visible"} for item in legacy_visible if isinstance(item, dict))
-        else:
-            raise AppFormFailure(
-                "INVALID_SPEC",
-                "relation config requires displayFields (explicit empty list allowed for fields without display fields)",
-                "CONTRACT_PRECHECK",
-            )
-        resolved_display = []
-        seen_ids = set()
-        for index, entry in enumerate(display_entries):
-            selector = entry.get("field") if isinstance(entry, dict) else {}
-            item = _resolve_backend_selector(selector or {}, candidates, f"displayFields[{index}].field")
-            if item["queId"] in seen_ids:
-                raise AppFormFailure(
-                    "INVALID_SPEC",
-                    f"displayFields[{index}].field resolves to duplicate queId {item['queId']}",
-                    "CONTRACT_PRECHECK",
-                )
-            seen_ids.add(item["queId"])
-            auth = (entry.get("auth") if isinstance(entry, dict) else None) or "visible"
-            auth_code = {"editable": 1, "hidden": 2, "visible": 3}.get(auth)
-            if auth_code is None:
-                raise AppFormFailure("INVALID_SPEC", "displayFields auth must be editable, hidden, or visible", "CONTRACT_PRECHECK")
-            resolved_display.append((item, auth_code))
-        two_way = config.get("twoWayBoundField") or config.get("two_way_bound_field")
-        if two_way is None and (config.get("displayField") or config.get("display_field")):
-            two_way = config.get("displayField") or config.get("display_field")
-        resolved_two_way = _resolve_backend_selector(two_way, candidates, "twoWayBoundField") if two_way else None
-        template_auth = (template or {}).get("referAuthQues") if isinstance((template or {}).get("referAuthQues"), list) else None
+        target_form = self._read_form(profile, target_app_key, being_draft=False)
+        candidates = _backend_question_candidates(target_form)
+        display = _resolve_backend_selector(config.get("displayField") or {}, candidates, "displayField")
+        visible = [_resolve_backend_selector(item, candidates, "visibleFields") for item in config.get("visibleFields") or []]
+        if all(_positive_int(item.get("queId")) != _positive_int(display.get("queId")) for item in visible):
+            visible.insert(0, display)
         result = deepcopy(template or {})
         result.update(
             {
                 "referAppKey": target_app_key,
-                "referQueId": resolved_two_way.get("queId") if resolved_two_way else None,
+                "referQueId": display["queId"],
                 "optionalDataNum": 1 if config.get("relationMode", "single") == "single" else 2,
                 "referQuestions": [
-                    {"queId": item["queId"], "queTitle": item["queTitle"], "queType": item["queType"], "queAuth": auth, "ordinal": index}
-                    for index, (item, auth) in enumerate(resolved_display)
+                {"queId": item["queId"], "queTitle": item["queTitle"], "queType": item["queType"], "queAuth": 3, "ordinal": index}
+                for index, item in enumerate(visible)
                 ],
-                # 选择引用数据时的列表权限轴(draft_reference_que_auth,含 section/parent 结构)
-                # 与展示字段轴(referQuestions)独立;声明未建模该轴,已有配置原样透传
-                # (空列表同样原样保留——被默认值覆盖会改变存量语义,历史数据保全红线),
-                # 仅新建字段(无模板)按展示字段默认 editable,避免删除重建丢权限配置。
-                "referAuthQues": deepcopy(template_auth)
-                if template_auth is not None
-                else [{"queId": item["queId"], "queAuth": 1} for item, _ in resolved_display],
+                "referAuthQues": [{"queId": item["queId"], "queAuth": 1} for item in visible],
                 "beingDefaultFormulaAutoFillEnabled": config.get("beingDefaultFormulaAutoFillEnabled"),
                 "defaultValueFormula": config.get("defaultValueFormula"),
                 "defaultValueMatchRules": deepcopy(config.get("defaultValueMatchRules")),
@@ -2725,7 +2566,8 @@ class AppFormCompiler:
         target_app_key = str(relation.get("targetAppKey") or "")
         if not target_app_key:
             raise AppFormFailure("UNSUPPORTED_FIELD_CONFIG", "select scope relation requires targetAppKey", "COMPILE")
-        candidates, target_form = self._target_form_candidates(profile, target_app_key)
+        target_form = self._read_form(profile, target_app_key, being_draft=False)
+        candidates = _backend_question_candidates(target_form)
         displayed = _resolve_backend_selector(relation.get("displayedField") or {}, candidates, "selectScopeRelation.displayedField")
         payload: JSONObject = {
             "queId": _positive_int(internal.get("que_id")) or int(internal.get("que_temp_id") or 0),
@@ -2747,27 +2589,14 @@ class AppFormCompiler:
     def _resolve_subfield_runtime_id(selector: JSONObject, internal_fields: list[JSONObject], location: str) -> int:
         if not isinstance(selector, dict):
             raise AppFormFailure("INVALID_FIELD_SELECTOR", f"{location} must be an object", "COMPILE")
-        # 同 _resolve_backend_selector:name 两侧 strip(存量字段名带前后空格,queId 兜底唯一性)。
         que_id = _positive_int(selector.get("queId"))
-        name = str(selector.get("name") or "").strip()
+        name = str(selector.get("name") or "")
         matches = [
             item for item in internal_fields
             if (que_id is None or _positive_int(item.get("que_id")) == que_id)
-            and (not name or str(item.get("name") or "").strip() == name)
+            and (not name or str(item.get("name") or "") == name)
         ]
         if len(matches) != 1:
-            if que_id is None and matches:
-                raise AppFormFailure(
-                    "AMBIGUOUS_FIELD_SELECTOR",
-                    f"{location} matches multiple subfields with the same name; use queId to disambiguate",
-                    "COMPILE",
-                    details={
-                        "selector": selector,
-                        "candidateQueIds": sorted(
-                            {_positive_int(item.get("que_id")) or 0 for item in matches}
-                        ),
-                    },
-                )
             raise AppFormFailure("INVALID_FIELD_SELECTOR", f"{location} must resolve to exactly one subfield", "COMPILE", details={"selector": selector, "matches": len(matches)})
         return _positive_int(matches[0].get("que_id")) or int(matches[0].get("que_temp_id") or 0)
 
@@ -2798,13 +2627,6 @@ class AppFormCompiler:
                 continue
             config = field.get("config") or {}
             source = config.get("source") or {}
-            if not source.get("kind"):
-                # 存量读回形态:后端 GET 不回传该字段的关联配置(displayed 目标缺失被
-                # getQuestionRelationsBeans continue 过滤)。normalizer 提取为无 source 的
-                # 空 config;写回侧保持对称——不重建 relation 行(后端删除重建后自然无行)。
-                internal.pop("data_relation_related_que_id", None)
-                internal.pop("data_relation_origin_type", None)
-                continue
             field_id = _positive_int(internal.get("que_id")) or int(internal.get("que_temp_id") or 0) or None
             relation: JSONObject = {
                 "queId": field_id,
@@ -2819,7 +2641,8 @@ class AppFormCompiler:
             source_fields = available_internal_fields
             source_fields_are_backend = False
             if source.get("kind") == "app":
-                source_fields, _target_form = self._target_form_candidates(profile, str(source.get("appKey") or ""))
+                target_form = self._read_form(profile, str(source.get("appKey") or ""), being_draft=False)
+                source_fields = _backend_question_candidates(target_form)
                 source_fields_are_backend = True
                 target = _resolve_backend_selector(source.get("field") or {}, source_fields, "source.field")
                 relation.update(
@@ -2935,32 +2758,25 @@ class AppFormCompiler:
         current_fields: list[JSONObject],
         source_fields_are_backend: bool,
     ) -> JSONObject:
-        source_selector = condition.get("sourceField") or {}
-        if source_selector.get("queId") or str(source_selector.get("name") or "").strip():
-            source = cls._resolve_data_relation_source_field(
-                source_selector,
-                source_fields=source_fields,
-                source_fields_are_backend=source_fields_are_backend,
-                location="sourceField",
-            )
-        else:
-            # 存量读回形态:无源字段(原公式 #queId_0$)。以 queId=0 透传,后端
-            # matchRulesToFormula 重新生成 #queId_0$,与原始库内公式往返对称。
-            source = {}
+        source = cls._resolve_data_relation_source_field(
+            condition.get("sourceField") or {},
+            source_fields=source_fields,
+            source_fields_are_backend=source_fields_are_backend,
+            location="sourceField",
+        )
         operand = condition.get("operand") or {}
         operator = str(condition.get("operator") or "")
         cls._validate_data_relation_operator(source, operator, operand)
         payload: JSONObject = {
-            "queId": cls._data_relation_field_ref(source) or 0,
-            "queTitle": cls._data_relation_field_name(source) or None,
-            "queType": cls._data_relation_que_type(source) if source else None,
+            "queId": cls._data_relation_field_ref(source),
+            "queTitle": cls._data_relation_field_name(source),
+            "queType": cls._data_relation_que_type(source),
             "judgeType": JUDGE_TYPE_TO_BACKEND[operator],
         }
         if operand.get("kind") == "literal":
             judge_values, judge_value_details = cls._data_relation_literal_values(
                 source,
                 deepcopy(operand.get("values") or []),
-                operator=operator,
             )
             payload.update(
                 {
@@ -2986,7 +2802,7 @@ class AppFormCompiler:
         return payload
 
     @staticmethod
-    def _data_relation_literal_values(source: JSONObject, values: list[Any], *, operator: str = "") -> tuple[list[str], list[JSONObject]]:
+    def _data_relation_literal_values(source: JSONObject, values: list[Any]) -> tuple[list[str], list[JSONObject]]:
         field_type = _canonical_backend_field_type(source)
         options = [item for item in source.get("options") or [] if isinstance(item, dict)]
         option_by_name = {
@@ -3016,13 +2832,6 @@ class AppFormCompiler:
             if field_type in CHOICE_TYPES and options:
                 option = option_by_name.get(text) or option_by_id.get(text)
                 if option is None:
-                    # 悬空选项引用(选项已被删,id 仍指向已删 optId):透传为存量
-                    # 同构的悬空引用(judgeValues=[optId], details=[{id,value:""}]),
-                    # 后端接受该形态(生产库存量即如此),往返对称;不是选项校验失败。
-                    if text.isdigit() and _positive_int(text) is not None:
-                        judge_values.append(text)
-                        details.append({"id": int(text), "value": ""})
-                        continue
                     raise AppFormFailure(
                         "UNSUPPORTED_FIELD_CONFIG",
                         f"literal value {text!r} is not an option of data_relation source field "
@@ -3035,28 +2844,6 @@ class AppFormCompiler:
                 judge_values.append(str(option_id) if option_id is not None else option_name)
                 details.append(_without_none({"id": option_id, "value": option_name}))
                 continue
-            if operator == "dynamic_range":
-                # 动态范围(judgeType=8):后端 checkRelationMatchRules 要求
-                # judgeValueDetails 非空且 id 非_null;提取侧 values 取自
-                # judgeValueDetails.value(动态范围名称),写回必须恢复 id——
-                # 名称→id 映射对齐 Constants.DYNAMIC_TYPE;数字字符串直通(id 形态)。
-                range_id = DYNAMIC_RANGE_NAME_TO_ID.get(text)
-                if range_id is None and text.isdigit():
-                    range_id = _positive_int(text)
-                if range_id is None:
-                    # 宽松匹配(剔内嵌空白)兜底:数组存在带/不带空格变体
-                    range_id = _DYNAMIC_RANGE_NORMALIZED.get("".join(text.split()))
-                if range_id is None:
-                    raise AppFormFailure(
-                        "UNSUPPORTED_FIELD_CONFIG",
-                        f"literal value {text!r} is not a known dynamic range of data_relation "
-                        f"source field {AppFormCompiler._data_relation_field_name(source)!r}",
-                        "CONTRACT_PRECHECK",
-                        details={"value": text, "allowedValues": sorted(DYNAMIC_RANGE_NAME_TO_ID)},
-                    )
-                judge_values.append(str(range_id))
-                details.append({"id": range_id, "value": text})
-                continue
             judge_values.append(text)
             details.append({"value": text})
         return judge_values, details
@@ -3079,13 +2866,7 @@ class AppFormCompiler:
 
     @staticmethod
     def _data_relation_field_name(field: JSONObject) -> str:
-        # matchRules 筛选源字段的 queTitle 在存量里对表格子字段带父表名前缀
-        # (「父表·子字段」):写回按同形态组装,与提取(后端拼接的 queTitle)对称。
-        title = str(field.get("queTitle") or field.get("name") or "")
-        sup_title = str(field.get("_sup_que_title") or "")
-        if sup_title and title:
-            return f"{sup_title}·{title}"
-        return title
+        return str(field.get("queTitle") or field.get("name") or "")
 
     @staticmethod
     def _data_relation_que_type(field: JSONObject) -> int:
@@ -3143,11 +2924,7 @@ class AppFormCompiler:
         organization_ops = common | {"belongs_to", "not_belongs_to", "subordinate_to", "not_subordinate_to", "subordinate_included", "subordinate_not_included", "contains_any", "contains_all"}
         field_type = _canonical_backend_field_type(source)
         if field_type in {"number", "amount", "date", "datetime"}:
-            # date/datetime 补 belongs_to/not_belongs_to:后端 judgeType=13(JUDGE_BELONG_TO)
-            # 对时间字段的存量语义是「属于时间范围」(judgeValues 形如
-            # "2025-01-30 14:20:59~2026-01-30 14:20:59"),与组织字段的属于语义
-            # 共用同一 judgeType——存量实证(如 82d9379e 申请时间筛选)。
-            allowed = ordered_ops | ({"belongs_to", "not_belongs_to"} if field_type in {"date", "datetime"} else set())
+            allowed = ordered_ops
         elif field_type in {"member", "department"}:
             allowed = organization_ops
         else:
@@ -3259,34 +3036,6 @@ class AppFormCompiler:
             raise AppFormFailure("FORM_READ_FAILED", "backend returned an invalid form", "READ")
         return value
 
-    def _target_form_candidates(self, profile: str, app_key: str) -> tuple[list[JSONObject], JSONObject]:
-        """跨表引用解析候选集:目标表 草稿∪发布 并集(queId 为 key,草稿覆盖)。
-
-        后端写链对跨表 queId(referQuestions/displayedQueId/matchRules 源字段)无
-        存在性校验、原样落库(FormSvcImpl.updateFormInfo);链上唯一读目标字段的
-        Formula.matchRulesToFormula 取 question∪draft_question 且草稿覆盖,编辑器
-        候选接口(/question/{appKey}/relation)同样支持 beingDraft 草稿态。get 按
-        草稿姿态提取声明,apply 只读发布会漏掉目标表「只加在草稿、从未发布」的字段
-        (round-trip 断裂);只读草稿又会漏掉发布后草稿里删掉的旧字段——并集与
-        后端写链语义一致。草稿读失败(目标表无草稿等)退回仅发布态。
-        """
-        draft_form: JSONObject = {}
-        try:
-            draft_form = self._read_form(profile, app_key, being_draft=True)
-        except AppFormFailure:
-            draft_form = {}
-        published_form = self._read_form(profile, app_key, being_draft=False)
-        merged: list[JSONObject] = []
-        seen: set[int] = set()
-        for item in [*_backend_question_candidates(draft_form), *_backend_question_candidates(published_form)]:
-            que_id = _positive_int(item.get("queId"))
-            if que_id is not None:
-                if que_id in seen:
-                    continue
-                seen.add(que_id)
-            merged.append(item)
-        return merged, (draft_form or published_form)
-
 
 class AppFormReconciler:
     RUNTIME_VERSION = "v1alpha1"
@@ -3453,17 +3202,7 @@ class AppFormReconciler:
                     )
                     publish_needed = not _published_equal(current, published)
                 except (QingflowApiError, RuntimeError, AppFormFailure) as error:
-                    if self._is_published_metadata_gap(error):
-                        # published 侧元数据缺行(段落归属/自定义编号配置):发布动作
-                        # 会从 draft 侧复制自愈,推定需要发布而不是失败。
-                        publish_needed = True
-                        warnings.append({"code": "PUBLISHED_METADATA_GAP", "detail": str(error.message)})
-                    elif self._is_form_not_published(error):
-                        # 应用从未发布(40026):published 域不存在,对比跳过——
-                        # draft 一致即达标,不擅自发布从未发布的应用。
-                        warnings.append({"code": "APP_NOT_PUBLISHED", "detail": "published comparison skipped: application was never published"})
-                    else:
-                        raise AppFormFailure("PUBLISHED_FORM_READ_FAILED", str(error), "PRECHECK_PUBLISHED_READ") from error
+                    raise AppFormFailure("PUBLISHED_FORM_READ_FAILED", str(error), "PRECHECK_PUBLISHED_READ") from error
             diagnostics["diff"] = self._diff(current, target)
 
             if not form_changed and not publish_needed:
@@ -3564,9 +3303,7 @@ class AppFormReconciler:
                     details={"remainingDiff": deepcopy(diagnostics["remainingDiff"])},
                 )
 
-            # precheck 阶段推定的 publish_needed(published 元数据缺口)必须保留:
-            # 发布自愈前任何一次 published 读都会失败,重读不会需得新证据。
-            publish_needed = created or wrote_form or publish_needed
+            publish_needed = created or wrote_form
             if not publish_needed:
                 try:
                     published = self._published_resource(
@@ -3578,20 +3315,14 @@ class AppFormReconciler:
                     diagnostics["published"] = _published_equal(draft, published)
                     publish_needed = not diagnostics["published"]
                 except (QingflowApiError, RuntimeError, AppFormFailure) as error:
-                    if self._is_published_metadata_gap(error):
-                        publish_needed = True
-                        warnings.append({"code": "PUBLISHED_METADATA_GAP", "detail": str(error.message)})
-                    elif self._is_form_not_published(error):
-                        warnings.append({"code": "APP_NOT_PUBLISHED", "detail": "published comparison skipped: application was never published"})
-                    else:
-                        self._finish_edit(profile, app_key, edit_version_no, diagnostics)
-                        raise AppFormFailure(
-                            "PUBLISHED_FORM_READ_FAILED",
-                            str(error),
-                            "AUTHORITATIVE_PUBLISHED_READ",
-                            status="partial_success",
-                            details=diagnostics,
-                        ) from error
+                    self._finish_edit(profile, app_key, edit_version_no, diagnostics)
+                    raise AppFormFailure(
+                        "PUBLISHED_FORM_READ_FAILED",
+                        str(error),
+                        "AUTHORITATIVE_PUBLISHED_READ",
+                        status="partial_success",
+                        details=diagnostics,
+                    ) from error
 
             if publish_needed:
                 self._publish_and_verify(
@@ -3973,52 +3704,6 @@ class AppFormReconciler:
         diagnostics["publishResponseAccepted"] = True
         diagnostics["publishCount"] += 1
 
-    @staticmethod
-    def _is_published_metadata_gap(error: Exception) -> bool:
-        """Published 读面因 published 侧元数据缺行而无法归一化的已知形态。
-
-        后端发布链路(FormSvcImpl.publish)把 draft 侧元数据复制到 published 侧
-        (section_question 先删后建、form_custom_serial_num_set 按 id 三分离)。
-        published 侧对应表缺行时(dataset 闭包漏导/迁移中间态),published GET 呈现:
-        - 段落(queType=24)与段内字段同行、innerQuestions 为空
-          → UNSUPPORTED_FIELD_TYPE queType=24(段落归属信息在 published 侧丢失);
-        - serialNumType=2 但 serialNumConfig 无组件
-          → UNSUPPORTED_FIELD_CONFIG "custom serial number has no components"。
-        属数据缺口而非声明不可表达:推定需要发布,由发布动作自愈元数据
-        (draft 读面不受影响——draft 形态段落恒为独立行)。
-        """
-        if not isinstance(error, AppFormFailure) or error.phase != "NORMALIZE":
-            return False
-        details = error.details if isinstance(error.details, dict) else {}
-        if error.error_code == "UNSUPPORTED_FIELD_TYPE" and _positive_int(details.get("queType")) == 24:
-            return True
-        return error.error_code == "UNSUPPORTED_FIELD_CONFIG" and "custom serial number has no components" in str(error.message)
-
-    @staticmethod
-    def _is_form_not_published(error: Exception) -> bool:
-        """published 读面因应用从未发布而 40026。
-
-        后端语义(FormSvcImpl.getFormInfo):appPublishStatus == PUBLISH_STATUS_CREATED
-        时 published GET 恒抛 FORM_NOT_PUBLISHED(40026)——合法存量形态(应用创建后
-        从未发布),draft 域恒可读、published 域不存在。此时 published 对比应跳过:
-        draft 一致即达标,apply 不擅自发布从未发布的应用(发布是独立产品动作,
-        由使用者显式决定)。"""
-        if isinstance(error, QingflowApiError):
-            return str(error.backend_code) == "40026"
-        if isinstance(error, AppFormFailure):
-            details = error.details if isinstance(error.details, dict) else {}
-            transport = details.get("transportError") if isinstance(details.get("transportError"), dict) else details
-            return str(transport.get("backend_code")) == "40026" or str(transport.get("code")) == "40026"
-        if isinstance(error, RuntimeError):
-            # tools 层经 raise_tool_error 把 QingflowApiError 包成 RuntimeError,
-            # message 是 as_json 字符串(含 backend_code);解析识别,不吞其他错误。
-            try:
-                payload = json.loads(str(error))
-            except ValueError:
-                return False
-            return isinstance(payload, dict) and str(payload.get("backend_code")) == "40026"
-        return False
-
     def _published_matches(
         self,
         profile: str,
@@ -4445,46 +4130,19 @@ def _snake_code_block(value: JSONObject) -> JSONObject:
 
 
 def _backend_question_candidates(form: JSONObject) -> list[JSONObject]:
-    """目标表字段的解析候选集(含表格子字段及其「父表·子字段」前缀变体)。
-
-    遍历与后端对齐:FormSvcImpl.fillMatchRulesList 按 supId 全局解析父表标题、
-    不看容器嵌套层级,FormQuestionSvcImpl 的候选集同样把段落内字段展开——因此
-    表格(queType=18)无论位于 formQues 顶层、baseQues 还是段落(queType=24)
-    内部,其 subQuestions 都是合法候选;段落本身不作为候选。
-    """
-    result: list[JSONObject] = []
-
-    def _visit(item: JSONObject) -> None:
-        que_type = _positive_int(item.get("queType"))
-        if que_type == 24:
-            for inner in item.get("innerQuestions") or []:
-                for nested in inner if isinstance(inner, list) else []:
-                    if isinstance(nested, dict):
-                        _visit(nested)
-            return
-        result.append(item)
-        # 表格(queType=18)子字段同样是合法的目标字段:后端 data_relation
-        # 运行时按 queId 解析目标字段并把表格子字段纳入 targetQuestionMap
-        # (DataRelationCalService 先按 queId 查 question、再把表格的
-        # subQuestions 合入)。displayedQueId 指向表格子字段是存量合法
-        # 配置,提取能读出、编译必须能写回(两闸门同口径)。
-        # matchRules 的筛选源字段(sourceField)在存量里带父表名前缀
-        # (「父表·子字段」,_data_relation_field_name 按同形态写回)。
-        if que_type == 18:
-            table_title = str(item.get("queTitle") or "")
-            for sub in item.get("subQuestions") or []:
-                if isinstance(sub, dict):
-                    prefixed = dict(sub)
-                    prefixed["_sup_que_title"] = table_title
-                    result.append(prefixed)
-
+    result = []
     for item in form.get("baseQues") or []:
         if isinstance(item, dict):
-            _visit(item)
+            result.append(item)
     for row in form.get("formQues") or []:
         for item in row if isinstance(row, list) else []:
-            if isinstance(item, dict):
-                _visit(item)
+            if not isinstance(item, dict):
+                continue
+            if _positive_int(item.get("queType")) == 24:
+                for inner in item.get("innerQuestions") or []:
+                    result.extend(nested for nested in inner if isinstance(inner, list) and isinstance(nested, dict))
+            else:
+                result.append(item)
     return result
 
 
@@ -4500,72 +4158,30 @@ def _canonical_backend_field_type(field: JSONObject) -> str:
     return QUE_TYPE_TO_CANONICAL.get(que_type or -1, "")
 
 
-def _backend_selector_titles(item: JSONObject) -> list[str]:
-    """后端匹配规则里该字段可能出现的 queTitle 形态。
-
-    matchRules 的筛选源字段(表格子字段)在存量里带父表名前缀("父表·子字段",
-    FormSvcImpl 组装 judgeQueDetail/queTitle 时拼接),顶层字段无前缀。
-    """
-    titles = [str(item.get("queTitle") or "")]
-    sup_title = str(item.get("_sup_que_title") or "")
-    if sup_title:
-        titles.append(f"{sup_title}·{titles[0]}")
-    return titles
-
-
 def _resolve_backend_selector(selector: JSONObject, candidates: list[JSONObject], location: str) -> JSONObject:
-    # name 比较两侧 strip:存量字段名带前导/尾随空格(后端无空白校验),声明里的
-    # name 与候选 queTitle 一个空格即失配;queId 已同时给出,空格差异不构成歧义。
     que_id = _positive_int(selector.get("queId"))
-    name = str(selector.get("name") or "").strip()
+    name = str(selector.get("name") or "")
     matches = [
         item
         for item in candidates
         if (que_id is None or _positive_int(item.get("queId")) == que_id)
-        and (not name or name in {title.strip() for title in _backend_selector_titles(item)})
+        and (not name or str(item.get("queTitle") or "") == name)
     ]
     if len(matches) != 1:
-        # 方案 A:后端允许同父级同名(queId 为身份)。name-only 命中多个时显式报
-        # 歧义并给出候选 queId,禁止静默取第一个。
-        if que_id is None and matches:
-            raise AppFormFailure(
-                "AMBIGUOUS_FIELD_SELECTOR",
-                f"{location} matches multiple fields with the same name; use queId to disambiguate",
-                "CONTRACT_PRECHECK",
-                details={
-                    "selector": selector,
-                    "candidateQueIds": sorted(
-                        {_positive_int(item.get("queId")) or 0 for item in matches}
-                    ),
-                },
-            )
         raise AppFormFailure("INVALID_FIELD_SELECTOR", f"{location} must resolve to exactly one field", "CONTRACT_PRECHECK", details={"selector": selector, "matches": len(matches)})
     return matches[0]
 
 
 def _resolve_canonical_selector(selector: JSONObject, candidates: list[JSONObject], location: str) -> JSONObject:
-    # 同 _resolve_backend_selector:name 两侧 strip(存量字段名带前后空格,queId 兜底唯一性)。
     que_id = _positive_int(selector.get("queId"))
-    name = str(selector.get("name") or "").strip()
+    name = str(selector.get("name") or "")
     matches = [
         item
         for item in candidates
         if (que_id is None or _positive_int(item.get("queId")) == que_id)
-        and (not name or str(item.get("name") or "").strip() == name)
+        and (not name or str(item.get("name") or "") == name)
     ]
     if len(matches) != 1:
-        if que_id is None and matches:
-            raise AppFormFailure(
-                "AMBIGUOUS_FIELD_SELECTOR",
-                f"{location} matches multiple fields with the same name; use queId to disambiguate",
-                "CONTRACT_PRECHECK",
-                details={
-                    "selector": selector,
-                    "candidateQueIds": sorted(
-                        {_positive_int(item.get("queId")) or 0 for item in matches}
-                    ),
-                },
-            )
         raise AppFormFailure(
             "INVALID_FIELD_SELECTOR",
             f"{location} must resolve to exactly one top-level field",
@@ -4576,27 +4192,14 @@ def _resolve_canonical_selector(selector: JSONObject, candidates: list[JSONObjec
 
 
 def _resolve_internal_selector(selector: JSONObject, fields: list[JSONObject], location: str) -> JSONObject:
-    # 同 _resolve_backend_selector:name 两侧 strip(存量字段名带前后空格,queId 兜底唯一性)。
     que_id = _positive_int(selector.get("queId") or selector.get("que_id"))
-    name = str(selector.get("name") or "").strip()
+    name = str(selector.get("name") or "")
     matches = [
         item
         for item in fields
         if (que_id is None or _positive_int(item.get("que_id")) == que_id)
-        and (not name or str(item.get("name") or "").strip() == name)
+        and (not name or str(item.get("name") or "") == name)
     ]
     if len(matches) != 1:
-        if que_id is None and matches:
-            raise AppFormFailure(
-                "AMBIGUOUS_FIELD_SELECTOR",
-                f"{location} matches multiple fields with the same name; use queId to disambiguate",
-                "COMPILE",
-                details={
-                    "selector": selector,
-                    "candidateQueIds": sorted(
-                        {_positive_int(item.get("que_id")) or 0 for item in matches}
-                    ),
-                },
-            )
         raise AppFormFailure("INVALID_FIELD_SELECTOR", f"{location} must resolve to exactly one field", "COMPILE", details={"selector": selector, "matches": len(matches)})
     return matches[0]