@josephyan/qingflow-cli 0.2.0-beta.74 → 0.2.0-beta.76

package/src/qingflow_mcp/tools/ai_builder_tools.py

@@ -6,6 +6,7 @@ import time
 
 from pydantic import ValidationError
 
+from ..public_surface import public_builder_contract_tool_names
 from ..config import DEFAULT_PROFILE
 from ..errors import QingflowApiError
 from ..json_types import JSONObject
@@ -462,11 +463,7 @@ class AiBuilderTools(ToolBase):
 
     def builder_tool_contract(self, *, tool_name: str) -> JSONObject:
         requested = str(tool_name or "").strip()
-        public_tool_names = sorted(
-            name
-            for name in _BUILDER_TOOL_CONTRACTS.keys()
-            if name not in _PRIVATE_BUILDER_TOOL_CONTRACTS and name not in _BUILDER_TOOL_CONTRACT_ALIASES
-        )
+        public_tool_names = public_builder_contract_tool_names()
         if requested in _PRIVATE_BUILDER_TOOL_CONTRACTS:
             lookup_name = ""
         elif requested in _BUILDER_TOOL_CONTRACTS:
@@ -2207,6 +2204,11 @@ _BUILDER_TOOL_CONTRACTS: dict[str, JSONObject] = {
         "allowed_values": {
             "payload.trigger_action": [member.value for member in PublicButtonTriggerAction],
         },
+        "execution_notes": [
+            "custom button writes now auto-publish the current app draft as a fixed closing step",
+            "background_color and text_color cannot both be white",
+            "for addData buttons, put field mappings in payload.trigger_add_data_config.que_relation",
+        ],
         "minimal_example": {
             "profile": "default",
             "app_key": "APP_KEY",
@@ -2240,6 +2242,11 @@ _BUILDER_TOOL_CONTRACTS: dict[str, JSONObject] = {
         "allowed_values": {
             "payload.trigger_action": [member.value for member in PublicButtonTriggerAction],
         },
+        "execution_notes": [
+            "custom button writes now auto-publish the current app draft as a fixed closing step",
+            "background_color and text_color cannot both be white",
+            "for addData buttons, put field mappings in payload.trigger_add_data_config.que_relation",
+        ],
         "minimal_example": {
             "profile": "default",
             "app_key": "APP_KEY",
@@ -2281,6 +2288,7 @@ _BUILDER_TOOL_CONTRACTS: dict[str, JSONObject] = {
             "field.allow_multiple": "field.relation_mode",
             "field.optional_data_num": "field.relation_mode",
             "field.optionalDataNum": "field.relation_mode",
+            "field.departmentScope": "field.department_scope",
             "field.remoteLookupConfig": "field.remote_lookup_config",
             "field.qLinkerBinding": "field.q_linker_binding",
             "field.codeBlockConfig": "field.code_block_config",
@@ -2338,6 +2346,7 @@ _BUILDER_TOOL_CONTRACTS: dict[str, JSONObject] = {
             "field.allow_multiple": "field.relation_mode",
             "field.optional_data_num": "field.relation_mode",
             "field.optionalDataNum": "field.relation_mode",
+            "field.departmentScope": "field.department_scope",
             "field.remoteLookupConfig": "field.remote_lookup_config",
             "field.qLinkerBinding": "field.q_linker_binding",
             "field.codeBlockConfig": "field.code_block_config",
@@ -2349,6 +2358,7 @@ _BUILDER_TOOL_CONTRACTS: dict[str, JSONObject] = {
         "allowed_values": {
             "field.type": [member.value for member in PublicFieldType],
             "field.relation_mode": [member.value for member in PublicRelationMode],
+            "field.department_scope.mode": ["all", "custom"],
             "field.code_block_binding.outputs.target_field.type": list(INTEGRATION_OUTPUT_TARGET_FIELD_TYPES),
             "field.q_linker_binding.outputs.target_field.type": list(INTEGRATION_OUTPUT_TARGET_FIELD_TYPES),
             "field_type_ids": sorted(FIELD_TYPE_ID_ALIASES.keys()),
@@ -2360,7 +2370,9 @@ _BUILDER_TOOL_CONTRACTS: dict[str, JSONObject] = {
             "multiple relation fields are backend-risky; read verification.relation_field_limit_verified and warnings before declaring the schema stable",
             "backend 49614 is normalized to MULTIPLE_RELATION_FIELDS_UNSUPPORTED with a workaround message",
             "relation_mode=multiple maps to referenceConfig.optionalDataNum=0",
+            "relation fields now require both display_field and visible_fields in MCP/CLI payloads",
             "if relation target metadata lookup is blocked by 40161/40002/40027, explicit display_field.name and visible_fields[].name let builder degrade verification and still continue schema write",
+            "department fields accept department_scope with mode=all or mode=custom; custom scope requires explicit departments[].dept_id and optional include_sub_departs",
             "q_linker_binding lets you declare request config, dynamic inputs, alias parsing, and target-field bindings in one step; builder writes remoteLookupConfig plus the existing backend relation-default and questionRelations structures",
             "code_block_binding lets you declare inputs, code, alias parsing, and target-field bindings in one step; builder writes codeBlockConfig plus the existing backend relation-default and questionRelations structures",
             "builder configures code blocks only; it does not execute or trigger code blocks",
@@ -2397,6 +2409,24 @@ _BUILDER_TOOL_CONTRACTS: dict[str, JSONObject] = {
             "update_fields": [],
             "remove_fields": [],
         },
+        "department_scope_example": {
+            "profile": "default",
+            "app_key": "APP_LEAD",
+            "publish": True,
+            "add_fields": [
+                {
+                    "name": "归属部门",
+                    "type": "department",
+                    "department_scope": {
+                        "mode": "custom",
+                        "departments": [{"dept_id": 334952, "dept_name": "生产"}],
+                        "include_sub_departs": False,
+                    },
+                }
+            ],
+            "update_fields": [],
+            "remove_fields": [],
+        },
         "code_block_example": {
             "profile": "default",
             "app_key": "APP_SCRIPT",

package/src/qingflow_mcp/tools/approval_tools.py

@@ -117,22 +117,6 @@ class ApprovalTools(ToolBase):
         ) -> dict[str, Any]:
             return self.task_transfer(profile=profile, app_key=app_key, record_id=record_id, payload=payload or {}, fields=fields or {})
 
-        @mcp.tool(description=self._high_risk_tool_description(operation="save", target="workflow task fields without advancing the workflow"))
-        def task_save_only(
-            profile: str = DEFAULT_PROFILE,
-            app_key: str = "",
-            record_id: int = 0,
-            workflow_node_id: int = 0,
-            fields: dict[str, Any] | None = None,
-        ) -> dict[str, Any]:
-            return self.task_save_only(
-                profile=profile,
-                app_key=app_key,
-                record_id=record_id,
-                workflow_node_id=workflow_node_id,
-                fields=fields or {},
-            )
-
         @mcp.tool()
         def task_transfer_candidates(
             profile: str = DEFAULT_PROFILE,

package/src/qingflow_mcp/tools/record_tools.py

@@ -138,6 +138,7 @@ class LookupResolutionState:
     operation: str
     app_key: str
     apply_id: int | None
+    workflow_node_id: int | None
     force_refresh_form: bool
     context_complete: bool
     field_index: FieldIndex
@@ -252,15 +253,19 @@ class RecordTools(ToolBase):
 
         @mcp.tool(
             description=(
-                "List current-user candidate members for a member field in the applicant-node visible schema. "
-                "Use record_insert_schema_get or record_update_schema_get with output_profile='verbose' first, then pass the member field_id. "
-                "This tool fails closed when the field uses dynamic or external candidate scopes."
+                "List current-user candidate members for a member field. "
+                "When record_id/workflow_node_id/fields are provided, this tool uses the backend runtime candidate scope that matches writes. "
+                "Without runtime context it only returns a static applicant-node preview scope. "
+                "Use record_insert_schema_get or record_update_schema_get with output_profile='verbose' first, then pass the member field_id."
             )
         )
         def record_member_candidates(
             profile: str = DEFAULT_PROFILE,
             app_key: str = "",
             field_id: int = 0,
+            record_id: int | None = None,
+            workflow_node_id: int | None = None,
+            fields: JSONObject | None = None,
             keyword: str = "",
             page_num: int = 1,
             page_size: int = 20,
@@ -269,6 +274,9 @@ class RecordTools(ToolBase):
                 profile=profile,
                 app_key=app_key,
                 field_id=field_id,
+                record_id=record_id,
+                workflow_node_id=workflow_node_id,
+                fields=fields or {},
                 keyword=keyword,
                 page_num=page_num,
                 page_size=page_size,
@@ -276,16 +284,19 @@ class RecordTools(ToolBase):
 
         @mcp.tool(
             description=(
-                "List current-user candidate departments for a department field in the applicant-node visible schema. "
-                "Use record_insert_schema_get or record_update_schema_get with output_profile='verbose' first, then pass the department field_id. "
-                "This tool supports explicit department scopes and default-all department scopes, but fails closed "
-                "for dynamic or external candidate scopes."
+                "List current-user candidate departments for a department field. "
+                "When record_id/workflow_node_id/fields are provided, this tool uses the backend runtime candidate scope that matches writes. "
+                "Without runtime context it only returns a static applicant-node preview scope. "
+                "Use record_insert_schema_get or record_update_schema_get with output_profile='verbose' first, then pass the department field_id."
             )
         )
         def record_department_candidates(
             profile: str = DEFAULT_PROFILE,
             app_key: str = "",
             field_id: int = 0,
+            record_id: int | None = None,
+            workflow_node_id: int | None = None,
+            fields: JSONObject | None = None,
             keyword: str = "",
             page_num: int = 1,
             page_size: int = 20,
@@ -294,6 +305,9 @@ class RecordTools(ToolBase):
                 profile=profile,
                 app_key=app_key,
                 field_id=field_id,
+                record_id=record_id,
+                workflow_node_id=workflow_node_id,
+                fields=fields or {},
                 keyword=keyword,
                 page_num=page_num,
                 page_size=page_size,
@@ -1007,6 +1021,14 @@ class RecordTools(ToolBase):
             payload["options"] = list(field.options)
         if kind in {"member", "department", "relation"}:
             payload["accepts_natural_input"] = True
+        if kind == "department":
+            payload["candidate_hint"] = {
+                "tool": "record_department_candidates",
+                "field_id": field.que_id,
+                "scope_source": "static_applicant_scope",
+                "preview_only": True,
+                "runtime_context_supported": True,
+            }
         if kind == "attachment":
             payload["requires_upload"] = True
         if kind == "relation" and field.target_app_key:
@@ -1214,6 +1236,9 @@ class RecordTools(ToolBase):
         profile: str,
         app_key: str,
         field_id: int,
+        record_id: int | None = None,
+        workflow_node_id: int | None = None,
+        fields: JSONObject | None = None,
         keyword: str,
         page_num: int,
         page_size: int,
@@ -1243,7 +1268,33 @@ class RecordTools(ToolBase):
                         },
                     )
                 )
-            items = self._resolve_member_candidates(context, field, keyword=keyword)
+            normalized_fields = fields if isinstance(fields, dict) else {}
+            runtime_lookup = self._candidate_lookup_uses_runtime_scope(
+                record_id=record_id,
+                workflow_node_id=workflow_node_id,
+                fields=normalized_fields,
+            )
+            warnings: list[JSONObject] = []
+            scope_source = "static_applicant_scope"
+            if runtime_lookup:
+                state = self._build_candidate_lookup_state(
+                    profile,
+                    context,
+                    app_key=app_key,
+                    record_id=record_id,
+                    workflow_node_id=workflow_node_id,
+                    fields=normalized_fields,
+                )
+                items = self._resolve_member_candidates_backend(context, field, keyword=keyword, state=state)
+                scope_source = "backend_runtime_scope"
+            else:
+                items = self._resolve_member_candidates(context, field, keyword=keyword)
+                warnings.append(
+                    {
+                        "code": "CANDIDATE_SCOPE_PREVIEW_ONLY",
+                        "message": "candidate scope is a static applicant-node preview; pass record_id/workflow_node_id/fields to match runtime write scope",
+                    }
+                )
             total = len(items)
             start = (page_num - 1) * page_size
             end = start + page_size
@@ -1254,7 +1305,7 @@ class RecordTools(ToolBase):
                 "ws_id": session_profile.selected_ws_id,
                 "ok": True,
                 "request_route": self._request_route_payload(context),
-                "warnings": [],
+                "warnings": warnings,
                 "output_profile": "normal",
                 "data": {
                     "items": page_items,
@@ -1269,9 +1320,13 @@ class RecordTools(ToolBase):
                         "app_key": app_key,
                         "field_id": field.que_id,
                         "field_title": field.que_title,
+                        "record_id": record_id,
+                        "workflow_node_id": workflow_node_id,
+                        "fields_present": bool(normalized_fields),
                         "keyword": keyword,
                         "permission_scope": "applicant_node",
                     },
+                    "scope_source": scope_source,
                 },
             }
 
@@ -1283,6 +1338,9 @@ class RecordTools(ToolBase):
         profile: str,
         app_key: str,
         field_id: int,
+        record_id: int | None = None,
+        workflow_node_id: int | None = None,
+        fields: JSONObject | None = None,
         keyword: str,
         page_num: int,
         page_size: int,
@@ -1312,7 +1370,50 @@ class RecordTools(ToolBase):
                         },
                     )
                 )
-            items = self._resolve_department_candidates(context, field, keyword=keyword)
+            normalized_fields = fields if isinstance(fields, dict) else {}
+            runtime_lookup = self._candidate_lookup_uses_runtime_scope(
+                record_id=record_id,
+                workflow_node_id=workflow_node_id,
+                fields=normalized_fields,
+            )
+            warnings: list[JSONObject] = []
+            scope_source = "static_applicant_scope"
+            if runtime_lookup:
+                state = self._build_candidate_lookup_state(
+                    profile,
+                    context,
+                    app_key=app_key,
+                    record_id=record_id,
+                    workflow_node_id=workflow_node_id,
+                    fields=normalized_fields,
+                )
+                items = self._resolve_department_candidates_backend(context, field, keyword=keyword, state=state)
+                scope_source = "backend_runtime_scope"
+            else:
+                items = self._resolve_department_candidates(context, field, keyword=keyword)
+                scope = field.dept_select_scope if isinstance(field.dept_select_scope, dict) else {}
+                if (
+                    not items
+                    and field.dept_select_scope_type == 2
+                    and not _scope_has_dynamic_or_external(scope)
+                    and not list(scope.get("depart") or [])
+                ):
+                    state = self._build_candidate_lookup_state(
+                        profile,
+                        context,
+                        app_key=app_key,
+                        record_id=None,
+                        workflow_node_id=None,
+                        fields={},
+                    )
+                    items = self._resolve_department_candidates_backend(context, field, keyword=keyword, state=state)
+                    scope_source = "backend_runtime_scope"
+                warnings.append(
+                    {
+                        "code": "CANDIDATE_SCOPE_PREVIEW_ONLY",
+                        "message": "candidate scope is a static applicant-node preview; pass record_id/workflow_node_id/fields to match runtime write scope",
+                    }
+                )
             total = len(items)
             start = (page_num - 1) * page_size
             end = start + page_size
@@ -1323,7 +1424,7 @@ class RecordTools(ToolBase):
                 "ws_id": session_profile.selected_ws_id,
                 "ok": True,
                 "request_route": self._request_route_payload(context),
-                "warnings": [],
+                "warnings": warnings,
                 "output_profile": "normal",
                 "data": {
                     "items": page_items,
@@ -1338,9 +1439,13 @@ class RecordTools(ToolBase):
                         "app_key": app_key,
                         "field_id": field.que_id,
                         "field_title": field.que_title,
+                        "record_id": record_id,
+                        "workflow_node_id": workflow_node_id,
+                        "fields_present": bool(normalized_fields),
                         "keyword": keyword,
                         "permission_scope": "applicant_node",
                     },
+                    "scope_source": scope_source,
                 },
             }
 
@@ -3183,6 +3288,65 @@ class RecordTools(ToolBase):
     def _lookup_context_is_incomplete(self, state: LookupResolutionState | None) -> bool:
         return bool(state is not None and not state.context_complete)
 
+    def _candidate_lookup_uses_runtime_scope(
+        self,
+        *,
+        record_id: int | None,
+        workflow_node_id: int | None,
+        fields: JSONObject | None,
+    ) -> bool:
+        return bool(
+            (record_id is not None and record_id > 0)
+            or (workflow_node_id is not None and workflow_node_id > 0)
+            or bool(fields)
+        )
+
+    def _build_candidate_lookup_state(
+        self,
+        profile: str,
+        context,  # type: ignore[no-untyped-def]
+        *,
+        app_key: str,
+        record_id: int | None,
+        workflow_node_id: int | None,
+        fields: JSONObject,
+    ) -> LookupResolutionState:
+        index = self._get_field_index(profile, context, app_key, force_refresh=False)
+        apply_id = record_id if isinstance(record_id, int) and record_id > 0 else None
+        base_answers: list[JSONObject] = []
+        context_complete = True
+        if apply_id is not None:
+            try:
+                base_answers = self._load_record_answers_for_preflight(context, app_key=app_key, apply_id=apply_id)
+            except QingflowApiError:
+                context_complete = False
+        state = LookupResolutionState(
+            operation="update" if apply_id is not None else "insert",
+            app_key=app_key,
+            apply_id=apply_id,
+            workflow_node_id=workflow_node_id if isinstance(workflow_node_id, int) and workflow_node_id > 0 else None,
+            force_refresh_form=False,
+            context_complete=context_complete,
+            field_index=index,
+            base_answers=base_answers,
+            normalized_answers=[],
+            confirmation_requests=[],
+            resolved_fields=[],
+            unresolved_field_ids=set(),
+            unresolved_subtable_cells=set(),
+        )
+        if fields:
+            state.normalized_answers = self._resolve_answers(
+                profile,
+                context,
+                app_key,
+                answers=[],
+                fields=fields,
+                force_refresh_form=False,
+                resolution_state=state,
+            )
+        return state
+
     def _raise_lookup_context_unavailable(
         self,
         *,
@@ -3474,6 +3638,28 @@ class RecordTools(ToolBase):
             return "contains_unique_match"
         return reason
 
+    def _candidate_scope_fix_hint(
+        self,
+        *,
+        kind: str,
+        state: LookupResolutionState | None,
+        explicit_guidance: str,
+    ) -> str:
+        if state is not None and self._candidate_lookup_uses_runtime_scope(
+            record_id=state.apply_id,
+            workflow_node_id=state.workflow_node_id,
+            fields={item.get("queId"): True for item in state.normalized_answers if isinstance(item, dict)},
+        ):
+            return (
+                f"Use record_{kind}_candidates with the same record_id/workflow_node_id/fields context to inspect the "
+                "backend runtime candidate scope and choose one returned item exactly. "
+                f"{explicit_guidance}"
+            )
+        return (
+            f"Use record_{kind}_candidates to inspect the allowed candidate scope and choose one returned item exactly. "
+            f"{explicit_guidance}"
+        )
+
     def _resolve_member_candidates(self, context, field: FormField, *, keyword: str) -> list[JSONObject]:  # type: ignore[no-untyped-def]
         scope_type = field.member_select_scope_type
         scope = field.member_select_scope if isinstance(field.member_select_scope, dict) else {}
@@ -3485,7 +3671,7 @@ class RecordTools(ToolBase):
             filtered = [item for item in candidates if item is not None]
             filtered.sort(key=lambda item: (_normalize_optional_text(item.get("value")) or "", _coerce_count(item.get("id")) or 0))
             return filtered
-        if scope_type != 1:
+        if scope_type != 2:
             raise_tool_error(
                 QingflowApiError(
                     category="not_supported",
@@ -3581,7 +3767,7 @@ class RecordTools(ToolBase):
                 if normalized is not None:
                     self._merge_department_candidate(merged, normalized)
         else:
-            if scope_type != 1:
+            if scope_type != 2:
                 raise_tool_error(
                     QingflowApiError(
                         category="not_supported",
@@ -3599,6 +3785,14 @@ class RecordTools(ToolBase):
                 if dept_id is None:
                     continue
                 dept_name = _normalize_optional_text(item.get("deptName", item.get("value")) if isinstance(item, dict) else None)
+                configured_candidate = _normalize_candidate_department(
+                    {"deptId": dept_id, "deptName": dept_name},
+                    source_kind="department",
+                    source_id=dept_id,
+                    source_value=dept_name,
+                )
+                if configured_candidate is not None:
+                    self._merge_department_candidate(merged, configured_candidate)
                 for dept in self._list_departments_by_scope(context, dept_id=dept_id, include_sub_departments=include_sub):
                     normalized = _normalize_candidate_department(
                         dept,
@@ -4719,14 +4913,15 @@ class RecordTools(ToolBase):
         view_key: str | None,
         view_name: str | None,
         existing_answers_override: list[JSONObject] | None = None,
+        field_index_override: FieldIndex | None = None,
     ) -> JSONObject:
         schema = self._get_form_schema(profile, context, app_key, force_refresh=force_refresh_form)
-        base_index = _build_applicant_top_level_field_index(schema)
+        base_index = field_index_override or _build_applicant_top_level_field_index(schema)
         question_relations = _collect_question_relations(schema)
         runtime_linked_field_ids = _collect_linked_required_field_ids(question_relations)
         runtime_linked_field_ids.update(_collect_option_linked_field_ids(base_index))
         index = base_index
-        if operation == "create":
+        if operation == "create" and field_index_override is None:
             linked_hidden_index = _build_applicant_hidden_linked_top_level_field_index(
                 schema,
                 linked_field_ids=runtime_linked_field_ids,
@@ -4800,6 +4995,7 @@ class RecordTools(ToolBase):
             operation=operation,
             app_key=app_key,
             apply_id=apply_id,
+            workflow_node_id=None,
             force_refresh_form=force_refresh_form,
             context_complete=(operation != "update" or existing_answers_loaded),
             field_index=index,
@@ -4824,6 +5020,7 @@ class RecordTools(ToolBase):
                 fields=scoped_fields,
                 force_refresh_form=force_refresh_form,
                 resolution_state=lookup_resolution,
+                field_index_override=index,
             )
         except RecordInputError as error:
             invalid_fields.append(
@@ -6929,13 +7126,14 @@ class RecordTools(ToolBase):
         fields: JSONObject,
         force_refresh_form: bool,
         resolution_state: LookupResolutionState | None = None,
+        field_index_override: FieldIndex | None = None,
     ) -> list[JSONObject]:
         if not app_key:
             raise_tool_error(QingflowApiError.config_error("app_key is required"))
         if not answers and not fields:
             raise_tool_error(QingflowApiError.config_error("either answers or fields is required"))
         if not answers and fields:
-            index = self._get_field_index(profile, context, app_key, force_refresh=force_refresh_form)
+            index = field_index_override or self._get_field_index(profile, context, app_key, force_refresh=force_refresh_form)
             normalized: list[JSONObject] = []
             for key, value in fields.items():
                 if value is None:
@@ -6948,7 +7146,7 @@ class RecordTools(ToolBase):
             return normalized
         if answers and not _answers_need_resolution(answers) and not fields:
             return answers
-        index = self._get_field_index(profile, context, app_key, force_refresh=force_refresh_form)
+        index = field_index_override or self._get_field_index(profile, context, app_key, force_refresh=force_refresh_form)
         normalized: list[JSONObject] = []
         for item in answers:
             answer = self._normalize_answer_item(profile, context, index, item, resolution_state=resolution_state)
@@ -8473,9 +8671,10 @@ class RecordTools(ToolBase):
             raise RecordInputError(
                 message=f"member value for field '{field.que_title}' could not be resolved in the current candidate scope",
                 error_code="MEMBER_NOT_IN_CANDIDATE_SCOPE",
-                fix_hint=(
-                    "Use record_member_candidates to inspect the allowed candidate scope and choose one returned item exactly. "
-                    "Explicit member id/userId/email values do not bypass candidate scope."
+                fix_hint=self._candidate_scope_fix_hint(
+                    kind="member",
+                    state=resolution_state,
+                    explicit_guidance="Explicit member id/userId/email values do not bypass candidate scope.",
                 ),
                 details={
                     "field": _field_ref_payload(field),
@@ -8740,9 +8939,10 @@ class RecordTools(ToolBase):
             raise RecordInputError(
                 message=f"department value for field '{field.que_title}' could not be resolved in the current candidate scope",
                 error_code="DEPARTMENT_NOT_IN_CANDIDATE_SCOPE",
-                fix_hint=(
-                    "Use record_department_candidates to inspect the allowed candidate scope and choose one returned item exactly. "
-                    "Explicit department ids do not bypass candidate scope."
+                fix_hint=self._candidate_scope_fix_hint(
+                    kind="department",
+                    state=resolution_state,
+                    explicit_guidance="Explicit department ids do not bypass candidate scope.",
                 ),
                 details={
                     "field": _field_ref_payload(field),
@@ -9662,6 +9862,81 @@ def _build_applicant_hidden_linked_top_level_field_index(
     )
 
 
+def _answer_to_form_field(answer: JSONObject) -> FormField | None:
+    que_id = _coerce_count(answer.get("queId", answer.get("que_id")))
+    title = _normalize_optional_text(answer.get("queTitle", answer.get("que_title")))
+    que_type = _coerce_count(answer.get("queType", answer.get("que_type")))
+    if que_id is None or que_id < 0 or not title or que_type in LAYOUT_ONLY_QUE_TYPES:
+        return None
+    raw: JSONObject = {
+        "queId": que_id,
+        "queTitle": title,
+    }
+    if que_type is not None:
+        raw["queType"] = que_type
+    field = FormField(
+        que_id=que_id,
+        que_title=title,
+        que_type=que_type,
+        required=False,
+        readonly=False,
+        system=False,
+        options=[],
+        aliases=[],
+        target_app_key=None,
+        target_app_name_hint=None,
+        member_select_scope_type=None,
+        member_select_scope=None,
+        dept_select_scope_type=None,
+        dept_select_scope=None,
+        raw=raw,
+    )
+    field.aliases = sorted(_field_alias_candidates(field))
+    return field
+
+
+def _build_answer_backed_field_index(
+    answers: list[JSONObject] | JSONValue,
+    *,
+    field_id_filter: set[str] | None = None,
+) -> FieldIndex:
+    by_id: dict[str, FormField] = {}
+    by_title: dict[str, list[FormField]] = {}
+    by_alias: dict[str, list[FormField]] = {}
+    if not isinstance(answers, list):
+        return FieldIndex(
+            by_id=by_id,
+            by_title=by_title,
+            by_alias=by_alias,
+            subtable_leaf_by_id={},
+            subtable_leaf_by_title={},
+            subtable_leaf_by_alias={},
+        )
+    for item in answers:
+        if not isinstance(item, dict):
+            continue
+        field = _answer_to_form_field(item)
+        if field is None:
+            continue
+        field_id = str(field.que_id)
+        if field_id_filter is not None and field_id not in field_id_filter:
+            continue
+        if field_id in by_id:
+            continue
+        by_id[field_id] = field
+        by_title.setdefault(_normalize_field_lookup_key(field.que_title), []).append(field)
+        for alias in field.aliases:
+            by_alias.setdefault(_normalize_field_lookup_key(alias), []).append(field)
+    return FieldIndex(
+        by_id=by_id,
+        by_title=by_title,
+        by_alias=by_alias,
+        subtable_leaf_by_id={},
+        subtable_leaf_by_title={},
+        subtable_leaf_by_alias={},
+    )
+
+
 def _merge_field_indexes(primary: FieldIndex, extra: FieldIndex) -> FieldIndex:
     by_id = dict(primary.by_id)
     by_title = {key: list(value) for key, value in primary.by_title.items()}
@@ -12701,8 +12976,6 @@ def _scope_has_dynamic_or_external(scope: JSONObject) -> bool:
 
 
 def _scope_is_default_all(scope_type: int | None, scope: JSONObject, *, keys: tuple[str, ...]) -> bool:
-    if scope_type == 2:
-        return True
     if scope_type != 1:
         return False
     if _scope_has_dynamic_or_external(scope):