@qingflow-tech/qingflow-cli 1.1.61-beta.5 → 1.1.61

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",
@@ -54,29 +52,10 @@ QUE_TYPE_TO_CANONICAL = {
     22: "department",
     25: "relation",
     26: "code_block",
-    # 透传型字段(r10 读面 65 app 缺口):声明层 EmptyConfig,round-trip 经后端
-    # 模板保真(选项/技能配置列随模板透传);语义 = QuestionTypeEnum 14/15/17/23
-    # 与 Constants QUE_TYPE_EMBED_FIELD(27)、AI 系 30-37(AI_CONTENT_GENERATION
-    # /EXTRACTION/CLASSIFICATION、AI_MACHINE_TRANSLATION、AI_IMAGE_RECOGNITION
-    # /GENERATION、AI_DOCUMENT_PARSING、AI_TEXT_SUMMARY)
-    14: "date_duration",
-    15: "image_select",
-    17: "location",
-    23: "ocr",
-    27: "embed_field",
-    30: "ai_content_generation",
-    31: "ai_content_extraction",
-    32: "ai_content_classification",
-    33: "ai_machine_translation",
-    34: "ai_image_recognition",
-    35: "ai_image_generation",
-    36: "ai_document_parsing",
-    37: "ai_text_summary",
 }
 CANONICAL_TO_QUE_TYPE = {
     "text": 2,
     "long_text": 3,
-    "rich_text": 16,
     "number": 8,
     "amount": 8,
     "link": 9,
@@ -96,29 +75,13 @@ CANONICAL_TO_QUE_TYPE = {
     "data_relation": 19,
     "relation": 25,
     "subtable": 18,
-
-    "date_duration": 14,
-    "image_select": 15,
-    "location": 17,
-    "ocr": 23,
-    "embed_field": 27,
-    "ai_content_generation": 30,
-    "ai_content_extraction": 31,
-    "ai_content_classification": 32,
-    "ai_machine_translation": 33,
-    "ai_image_recognition": 34,
-    "ai_image_generation": 35,
-    "ai_document_parsing": 36,
-    "ai_text_summary": 37,
 }
 SUBFIELD_TYPES = {
     "text",
     "long_text",
     "number",
-    "amount",
     "link",
     "date",
-    "datetime",
     "phone",
     "email",
     "single_choice",
@@ -131,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",
@@ -736,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",
@@ -755,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,
@@ -1006,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(
@@ -1017,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
@@ -1259,20 +1162,11 @@ class AppFormNormalizer:
                 name = match.group("name").strip()
                 if name:
                     token = match.group("token").strip()
-                    # 名字两侧 strip 匹配:存量字段名带尾随空格(如 am4oh08v2401
-                    # 「答:Answer 」),模板引用名无空格——严格相等会丢 queId 锚定
                     matching_ids = [
                         que_id
                         for que_id, field_name in field_names.items()
-                        if str(field_name).strip() == name and _encrypt_question_id(que_id) == token
+                        if field_name == name and _encrypt_question_id(que_id) == token
                     ]
-                    if not matching_ids:
-                        # 悬空引用(字段已删/改名,模板仍留旧引用):原文透传——占位符
-                        # 化会丢 token 无法复原(加密不可逆),后端写链对模板原样落库;
-                        # 不注册 input(声明无此输入,写回与 B0 模板逐字一致,
-                        # r10 实测 9gtommb3ng01 等 6 app「inputs[N].field could not
-                        # be resolved」即此形态)
-                        return match.group(0)
                     json_path_inputs.setdefault(
                         name,
                         {
@@ -1285,21 +1179,11 @@ class AppFormNormalizer:
 
             request_values[request_key] = Q_LINKER_VALUE_REFERENCE_RE.sub(replace_reference, raw_value)
         inputs.extend(json_path_inputs.values())
-        # URL 空容忍边界(#208③):后端写链仅 configMode=1(自定义)校验 url/method/
-        # resultType 非空(FormQuestionSvcImpl.createQuestionRemoteLookUp:444 抛
-        # REMOTE_LOOK_UP_SETTING_WRONG);configMode=2 插件模板 / 3 连接中心 /
-        # 4 轻翼智能体的 URL 由模板侧提供,本表 url 空 是合法存量形态——非自定义
-        # 模式放行空 URL 透传(写回走模板透传,round-trip 保真;r12 归因 27 app;
-        # 自定义模式 url 空的 2 app 脓数据仍拒绝,入排除账本)。
-        config_mode = _positive_int(config.get("configMode")) or 1
-        if config_mode == 1:
-            request_url = _required_text(
-                request_values["url"],
-                message="Q-Linker request URL is empty",
-                details={"queId": source_id, "path": "/config/qLinkerBinding/request/url"},
-            )
-        else:
-            request_url = str(request_values["url"] or "")
+        request_url = _required_text(
+            request_values["url"],
+            message="Q-Linker request URL is empty",
+            details={"queId": source_id, "path": "/config/qLinkerBinding/request/url"},
+        )
         request = _without_none(
             {
                 "url": request_url,
@@ -1408,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 {}
@@ -1514,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)
                 ]
@@ -1783,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}
@@ -1807,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)
@@ -1822,9 +1686,7 @@ class AppFormCompiler:
                     if not isinstance(item, dict) or item.get("source") != "json_path":
                         continue
                     selected = _resolve_internal_selector(item.get("field") or {}, internal_fields, f"qLinkerBinding.inputs[{index}].field")
-                    # 两侧 strip:模板引用名提取时已 strip(存量字段名带尾随空格,
-                    # 如 r10 am4oh08v2401「答:Answer 」),严格相等误报 key 不一致
-                    if str(item.get("key") or "").strip() != str(selected.get("name") or "").strip():
+                    if str(item.get("key") or "") != str(selected.get("name") or ""):
                         raise AppFormFailure(
                             "UNSUPPORTED_FIELD_CONFIG",
                             "json_path input key must equal the selected field name for lossless readback",
@@ -2116,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],
@@ -2141,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(
@@ -2208,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)
@@ -2266,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)
@@ -2474,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"),
@@ -2502,18 +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",
-                # 透传型新类型(r10 读面覆盖):build 走 text 兜底,类型/配置经模板保真
-                "date_duration", "image_select", "location", "ocr", "embed_field",
-                "ai_content_generation", "ai_content_extraction", "ai_content_classification",
-                "ai_machine_translation", "ai_image_recognition", "ai_image_generation",
-                "ai_document_parsing", "ai_text_summary",
-            }
-            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":
@@ -2670,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)
@@ -2702,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")),
@@ -2789,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),
@@ -2811,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)
 
@@ -2862,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,
@@ -2883,23 +2641,10 @@ 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
-                # 展示字段同样按后端语义透传:写链对 displayedQueId 无存在性校验
-                # 原样落库(fillMatchRulesList 读链按全局 question∪draft_question
-                # 解析)。解析不到时 queType=None → 写侧 origin_type 回退 current
-                # 模板值(见 data_relation relatedQueId/queOriginType 组装)。
-                try:
-                    target = _resolve_backend_selector(source.get("field") or {}, source_fields, "source.field")
-                except AppFormFailure as error:
-                    if error.error_code != "INVALID_FIELD_SELECTOR" or _positive_int((source.get("field") or {}).get("queId")) is None:
-                        raise
-                    target = {
-                        "queId": _positive_int(source["field"].get("queId")),
-                        "queTitle": str(source["field"].get("name") or "").strip() or None,
-                        "queType": None,
-                        "_app_form_unresolved": True,
-                    }
+                target = _resolve_backend_selector(source.get("field") or {}, source_fields, "source.field")
                 relation.update(
                     {
                         "displayedQueId": target["queId"],
@@ -3013,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(
                 {
@@ -3064,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 = {
@@ -3094,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 "
@@ -3113,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
@@ -3148,23 +2857,7 @@ class AppFormCompiler:
         location: str,
     ) -> JSONObject:
         if source_fields_are_backend:
-            try:
-                return _resolve_backend_selector(selector, source_fields, location)
-            except AppFormFailure as error:
-                # 目标表单候选集(草稿∪发布 formQues)解析不到、但 selector 带正
-                # queId:按后端语义透传——读链 fillMatchRulesList 按 queId 查
-                # question∪draft_question 全局表,查不到容忍置空(new Question());
-                # 写链 updateFormInfo 对 matchRules/sortConfig 源 queId 无存在性
-                # 校验、原样落库。存量里该形态 = 引用指向目标表单 GET 响应之外
-                # 的字段(跨表/已删,如 r8 实测 00e0e0d8 筛选源),严格拒绝即
-                # round-trip 断裂。queType 置 None 与后端「查不到置空」同构。
-                if error.error_code == "INVALID_FIELD_SELECTOR" and _positive_int(selector.get("queId")) is not None:
-                    return {
-                        "queId": _positive_int(selector.get("queId")),
-                        "queTitle": str(selector.get("name") or "").strip() or None,
-                        "_app_form_unresolved": True,
-                    }
-                raise
+            return _resolve_backend_selector(selector, source_fields, location)
         return _resolve_internal_selector(selector, source_fields, location)
 
     @staticmethod
@@ -3173,20 +2866,10 @@ 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 | None:
-        if field.get("_app_form_unresolved"):
-            # 透传形态(目标表单候选集解析不到):后端 fillMatchRulesList 对查
-            # 不到的 queId 置空 queType 继续出参,写链不校验——同构置 None。
-            return None
+    def _data_relation_que_type(field: JSONObject) -> int:
         backend_type = _positive_int(field.get("queType"))
         if backend_type is not None:
             return backend_type
@@ -3240,25 +2923,10 @@ class AppFormCompiler:
         ordered_ops = common | {"greater_than", "greater_or_equal", "less_than", "less_or_equal", "dynamic_range", "decimal_range"}
         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 source.get("_app_form_unresolved"):
-            # 透传形态:源字段类型不可知(后端读链查不到置空),后端写链对
-            # operator×源类型组合无校验——跳过类型白名单,仅保留 operand 形状
-            # 校验(下方),与「读面保留、写面透传」的存量形态处理同口径。
-            allowed = common | text_ops | ordered_ops | organization_ops
-        elif 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())
+        if field_type in {"number", "amount", "date", "datetime"}:
+            allowed = ordered_ops
         elif field_type in {"member", "department"}:
             allowed = organization_ops
-        elif field_type in {"text", "multi_select"}:
-            # text/multi_select 补 belongs_to/not_belongs_to:judgeType=13 同为多态
-            # 语义(选项「属于」集合),后端写链对 operator×源类型无校验——存量
-            # 实证 r8:bjqj2bge2g02(multi_select 资产类型 belongs_to 当前字段)、
-            # e4f644fe(text 客户等级 belongs_to literal ["BC"])。
-            allowed = text_ops | {"belongs_to", "not_belongs_to"}
         else:
             allowed = text_ops
         if operator not in allowed:
@@ -3272,10 +2940,7 @@ class AppFormCompiler:
         if operator in EMPTY_OPERATORS:
             if operand.get("kind") != "literal" or values not in ([], None):
                 raise AppFormFailure("UNSUPPORTED_FIELD_CONFIG", "empty-value operators require an empty literal operand", "CONTRACT_PRECHECK")
-        elif operand.get("kind") == "literal" and not values and operator not in {"subordinate_to", "not_subordinate_to"}:
-            # subordinate 两算子放行空 literal:存量「设置后清空」形态(r13 实证
-            # 41ce0ad8)——后端写链仅校验 dynamic_range(checkRelationMatchRules),
-            # formula 对空 judgeValueDetails 渲染 [],读回解析对称,往返保真
+        elif operand.get("kind") == "literal" and not values:
             raise AppFormFailure("UNSUPPORTED_FIELD_CONFIG", "literal data_relation operands must contain at least one value", "CONTRACT_PRECHECK")
 
     @staticmethod
@@ -3371,42 +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)]:
-            raw_id = item.get("queId")
-            if isinstance(raw_id, int) and not isinstance(raw_id, bool):
-                # queId 是字段身份,身份语义覆盖 0 与负数:0 是系统「编号」虚拟行
-                # (que_type=8,GET 草稿/发布两态各带一行)、负数是系统行(-1 数据来源
-                # 等,补导后物理在表)。只按正整数去重会让 queId=0 的「编号」在
-                # 并集里出现两次,by_name 引用恒定命中 2 个候选 → AMBIGUOUS_
-                # FIELD_SELECTOR(r13 103 app data_relation/relation 深层配置写回
-                # 全量失败根因)。同 queId 即同字段,草稿优先(与正整数身份同
-                # 语义);同名不同 queId 的真实用户字段仍双候选保留,by_name 歧义
-                # 照常显式拒绝(存量脏形态不消歧,禁止静默取第一个)。
-                if raw_id in seen:
-                    continue
-                seen.add(raw_id)
-            merged.append(item)
-        return merged, (draft_form or published_form)
-
 
 class AppFormReconciler:
     RUNTIME_VERSION = "v1alpha1"
@@ -3573,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:
@@ -3684,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(
@@ -3698,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(
@@ -4093,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,
@@ -4565,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
 
 
@@ -4620,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",
@@ -4696,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]