@qingflow-tech/qingflow-cli 1.1.60 → 1.1.61-beta.2

package/src/qingflow_mcp/builder_facade/app_form.py

@@ -18,6 +18,7 @@ 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,
@@ -45,6 +46,7 @@ QUE_TYPE_TO_CANONICAL = {
     11: "single_select",
     12: "multi_select",
     13: "attachment",
+    16: "rich_text",
     18: "subtable",
     19: "data_relation",
     20: "q_linker",
@@ -56,6 +58,7 @@ QUE_TYPE_TO_CANONICAL = {
 CANONICAL_TO_QUE_TYPE = {
     "text": 2,
     "long_text": 3,
+    "rich_text": 16,
     "number": 8,
     "amount": 8,
     "link": 9,
@@ -80,8 +83,10 @@ SUBFIELD_TYPES = {
     "text",
     "long_text",
     "number",
+    "amount",
     "link",
     "date",
+    "datetime",
     "phone",
     "email",
     "single_choice",
@@ -94,6 +99,43 @@ 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",
@@ -662,8 +704,9 @@ class AppFormNormalizer:
                     ]
                     if fields:
                         rows.append({"fields": fields})
-                if not rows:
-                    raise AppFormFailure("UNSUPPORTED_LAYOUT", "existing section is empty", "NORMALIZE")
+                # 空 section 是合法存量形态:后端 updateFormInfo 对空 innerQuestions 仅产出
+                # 零行 draft_section_question(段落本身作为 queType=24 question 照常保存),
+                # 读面 getFormInfoByAppKey 同样返回空 innerQuestions——按声明原样写,空↔空稳定。
                 body.append(
                     {
                         "kind": "section",
@@ -680,14 +723,26 @@ 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 else None,
-                "dataCoverField": _selector(cover_id, field_names.get(cover_id or 0)) if cover_id is not None else 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,
                 "attachments": self._attachments(form.get("formAttach")),
                 "serialNumber": self._serial_number(form.get("serialNumType"), form.get("serialNumConfig")),
                 "body": body,
@@ -919,8 +974,6 @@ 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(
@@ -932,25 +985,37 @@ class AppFormNormalizer:
             relation_config: JSONObject = {
                 "targetAppKey": target_app_key,
                 "relationMode": "multiple" if _positive_int(reference.get("optionalDataNum")) not in {None, 1} else "single",
-                "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},
+                "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,
+                        ),
                     )
-                    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
@@ -1292,7 +1357,12 @@ 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:
-            raise AppFormFailure("UNSUPPORTED_FIELD_CONFIG", "data_relation has no question relation", "NORMALIZE", details={"queId": que_id})
+            # 后端 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 {}
         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 {}
@@ -1393,15 +1463,25 @@ 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": _require_selector(value.get("queId"), value.get("queTitle"), message="data_relation source field cannot be normalized", details={"queId": que_id}),
+            "sourceField": _selector(value.get("queId"), value.get("queTitle")) or None,
             "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.get("value") if item.get("value") is not None else item.get("id"))
+                    str(item["id"])
+                    if item.get("value") in (None, "") and item.get("id") is not None
+                    else str(item.get("value"))
                     for item in details
                     if isinstance(item, dict) and (item.get("value") is not None or item.get("id") is not None)
                 ]
@@ -1652,7 +1732,10 @@ 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"))
-        data_title, data_cover = self._validate_target(target_spec)
+        # target 层面同样放行 dataTitleField=null:后端写链
+        # FormSvcImpl.normalizeDataTitleQueId 会兑底到第一个可用字段,
+        # current 与 declared 均为 null 时 target 保持 null 合法。
+        data_title, data_cover = self._validate_target(target_spec, allow_missing_data_title=True)
         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}
@@ -1673,6 +1756,8 @@ 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)
@@ -1978,10 +2063,13 @@ 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):
-            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")
+            # 宽度取值:任意 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")
             return
         widths = {
             1: [100],
@@ -2000,24 +2088,23 @@ class AppFormCompiler:
     ) -> tuple[JSONObject | None, JSONObject | None]:
         body = spec.get("body") or []
         fields = list(_iter_fields(body))
-        names: set[str] = set()
+        # 方案 A(duplicate-field-name):同父级允许同名——后端以 queId 为字段身份
+        # (40013 实测 1624 组同名),get 提出的合法形态必须能写回;name 解析的
+        # 歧义由各 selector resolver 以 AMBIGUOUS_FIELD_SELECTOR 显式拒绝,
+        # 不在目标校验层做 name 唯一性强校验。
         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:
-            if title_selector is None and allow_missing_data_title and "dataTitleField" not in spec:
+            # dataTitleField=null(键存在值为空)与省略键同权放行:后端写链
+            # FormSvcImpl.normalizeDataTitleQueId 对 null 自动 fallback 到第一个
+            # 可用字段(findDefaultDataTitleQueId),apply 侧缺省完全合法;
+            # get 读面在后端 dataTitleQueId 未设置时原样输出 null,round-trip 必须接受。
+            if title_selector is None and allow_missing_data_title:
                 pass
             elif not isinstance(title_selector, dict):
                 raise AppFormFailure(
@@ -2068,6 +2155,8 @@ 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)
@@ -2124,7 +2213,8 @@ class AppFormCompiler:
                 rows.append([section])
         payload["formQues"] = rows
         self._validate_unique_temp_ids(rows)
-        data_title = _resolve_canonical_selector(target["spec"]["dataTitleField"], target_fields, "dataTitleField") if target_fields else None
+        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_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)
@@ -2331,6 +2421,16 @@ 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"),
@@ -2349,7 +2449,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"} else field_type
+        build_type = "boolean" if field_type == "single_choice" else "text" if field_type in {"link", "data_relation", "rich_text"} else field_type
         built_internal = deepcopy(internal)
         built_internal["type"] = build_type
         if build_type == "subtable":
@@ -2506,18 +2606,24 @@ 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:
-                question.pop("relatedQueId", 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)
             else:
                 question["relatedQueId"] = related_que_id
             que_origin_type = _positive_int(internal.get("data_relation_origin_type"))
             if que_origin_type is None:
-                raise AppFormFailure(
-                    "UNSUPPORTED_FIELD_CONFIG",
-                    "data_relation source type could not be derived",
-                    "COMPILE",
-                    details={"field": field.get("name")},
-                )
-            question["queOriginType"] = que_origin_type
+                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
             aggregation = config.get("aggregation")
             if aggregation is None:
                 question.pop("aggreType", None)
@@ -2532,23 +2638,76 @@ class AppFormCompiler:
 
     def _reference_config(self, profile: str, config: JSONObject, template: JSONObject | None = None) -> JSONObject:
         target_app_key = str(config.get("targetAppKey") or "")
-        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)
+        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
         result = deepcopy(template or {})
         result.update(
             {
                 "referAppKey": target_app_key,
-                "referQueId": display["queId"],
+                "referQueId": resolved_two_way.get("queId") if resolved_two_way else None,
                 "optionalDataNum": 1 if config.get("relationMode", "single") == "single" else 2,
                 "referQuestions": [
-                {"queId": item["queId"], "queTitle": item["queTitle"], "queType": item["queType"], "queAuth": 3, "ordinal": index}
-                for index, item in enumerate(visible)
+                    {"queId": item["queId"], "queTitle": item["queTitle"], "queType": item["queType"], "queAuth": auth, "ordinal": index}
+                    for index, (item, auth) in enumerate(resolved_display)
                 ],
-                "referAuthQues": [{"queId": item["queId"], "queAuth": 1} for item in 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],
                 "beingDefaultFormulaAutoFillEnabled": config.get("beingDefaultFormulaAutoFillEnabled"),
                 "defaultValueFormula": config.get("defaultValueFormula"),
                 "defaultValueMatchRules": deepcopy(config.get("defaultValueMatchRules")),
@@ -2566,8 +2725,7 @@ 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")
-        target_form = self._read_form(profile, target_app_key, being_draft=False)
-        candidates = _backend_question_candidates(target_form)
+        candidates, target_form = self._target_form_candidates(profile, target_app_key)
         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),
@@ -2589,14 +2747,27 @@ 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 "")
+        name = str(selector.get("name") or "").strip()
         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 "") == name)
+            and (not name or str(item.get("name") or "").strip() == 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)
 
@@ -2627,6 +2798,13 @@ 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,
@@ -2641,8 +2819,7 @@ class AppFormCompiler:
             source_fields = available_internal_fields
             source_fields_are_backend = False
             if source.get("kind") == "app":
-                target_form = self._read_form(profile, str(source.get("appKey") or ""), being_draft=False)
-                source_fields = _backend_question_candidates(target_form)
+                source_fields, _target_form = self._target_form_candidates(profile, str(source.get("appKey") or ""))
                 source_fields_are_backend = True
                 target = _resolve_backend_selector(source.get("field") or {}, source_fields, "source.field")
                 relation.update(
@@ -2758,25 +2935,32 @@ class AppFormCompiler:
         current_fields: list[JSONObject],
         source_fields_are_backend: bool,
     ) -> JSONObject:
-        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",
-        )
+        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 = {}
         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),
-            "queTitle": cls._data_relation_field_name(source),
-            "queType": cls._data_relation_que_type(source),
+            "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,
             "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(
                 {
@@ -2802,7 +2986,7 @@ class AppFormCompiler:
         return payload
 
     @staticmethod
-    def _data_relation_literal_values(source: JSONObject, values: list[Any]) -> tuple[list[str], list[JSONObject]]:
+    def _data_relation_literal_values(source: JSONObject, values: list[Any], *, operator: str = "") -> 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 = {
@@ -2832,6 +3016,13 @@ 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 "
@@ -2844,6 +3035,28 @@ 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
@@ -2866,7 +3079,13 @@ class AppFormCompiler:
 
     @staticmethod
     def _data_relation_field_name(field: JSONObject) -> str:
-        return str(field.get("queTitle") or field.get("name") or "")
+        # 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
 
     @staticmethod
     def _data_relation_que_type(field: JSONObject) -> int:
@@ -2924,7 +3143,11 @@ 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"}:
-            allowed = ordered_ops
+            # 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())
         elif field_type in {"member", "department"}:
             allowed = organization_ops
         else:
@@ -3036,6 +3259,34 @@ 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"
@@ -3202,7 +3453,17 @@ class AppFormReconciler:
                     )
                     publish_needed = not _published_equal(current, published)
                 except (QingflowApiError, RuntimeError, AppFormFailure) as error:
-                    raise AppFormFailure("PUBLISHED_FORM_READ_FAILED", str(error), "PRECHECK_PUBLISHED_READ") from 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
             diagnostics["diff"] = self._diff(current, target)
 
             if not form_changed and not publish_needed:
@@ -3303,7 +3564,9 @@ class AppFormReconciler:
                     details={"remainingDiff": deepcopy(diagnostics["remainingDiff"])},
                 )
 
-            publish_needed = created or wrote_form
+            # precheck 阶段推定的 publish_needed(published 元数据缺口)必须保留:
+            # 发布自愈前任何一次 published 读都会失败,重读不会需得新证据。
+            publish_needed = created or wrote_form or publish_needed
             if not publish_needed:
                 try:
                     published = self._published_resource(
@@ -3315,14 +3578,20 @@ class AppFormReconciler:
                     diagnostics["published"] = _published_equal(draft, published)
                     publish_needed = not diagnostics["published"]
                 except (QingflowApiError, RuntimeError, AppFormFailure) as 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 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
 
             if publish_needed:
                 self._publish_and_verify(
@@ -3704,6 +3973,52 @@ 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,
@@ -4130,19 +4445,46 @@ def _snake_code_block(value: JSONObject) -> JSONObject:
 
 
 def _backend_question_candidates(form: JSONObject) -> list[JSONObject]:
-    result = []
+    """目标表字段的解析候选集(含表格子字段及其「父表·子字段」前缀变体)。
+
+    遍历与后端对齐: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)
+
     for item in form.get("baseQues") or []:
         if isinstance(item, dict):
-            result.append(item)
+            _visit(item)
     for row in form.get("formQues") or []:
         for item in row if isinstance(row, list) else []:
-            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)
+            if isinstance(item, dict):
+                _visit(item)
     return result
 
 
@@ -4158,30 +4500,72 @@ 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 "")
+    name = str(selector.get("name") or "").strip()
     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("queTitle") or "") == name)
+        and (not name or name in {title.strip() for title in _backend_selector_titles(item)})
     ]
     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 "")
+    name = str(selector.get("name") or "").strip()
     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 "") == name)
+        and (not name or str(item.get("name") or "").strip() == 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",
@@ -4192,14 +4576,27 @@ 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 "")
+    name = str(selector.get("name") or "").strip()
     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 "") == name)
+        and (not name or str(item.get("name") or "").strip() == 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]