@josephyan/qingflow-cli 0.2.0-beta.88 → 0.2.0-beta.90

package/README.md

@@ -3,13 +3,13 @@
 Install:
 
 ```bash
-npm install @josephyan/qingflow-cli@0.2.0-beta.88
+npm install @josephyan/qingflow-cli@0.2.0-beta.90
 ```
 
 Run:
 
 ```bash
-npx -y -p @josephyan/qingflow-cli@0.2.0-beta.88 qingflow
+npx -y -p @josephyan/qingflow-cli@0.2.0-beta.90 qingflow
 ```
 
 Environment:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@josephyan/qingflow-cli",
-  "version": "0.2.0-beta.88",
+  "version": "0.2.0-beta.90",
   "description": "Human-friendly Qingflow command line interface for auth, record operations, import, tasks, and stable builder flows.",
   "license": "MIT",
   "type": "module",

package/src/qingflow_mcp/builder_facade/service.py

@@ -4789,12 +4789,22 @@ class AiBuilderFacade:
             response = _apply_permission_outcomes(response, relation_permission_outcome)
             return finalize(self._append_publish_result(profile=profile, app_key=target.app_key, publish=publish, response=response))
 
-        payload = _build_form_payload_from_fields(
-            title=effective_app_name,
-            current_schema=schema_result,
-            fields=current_fields,
-            layout=layout,
-            question_relations=compiled_question_relations,
+        payload = (
+            _build_form_payload_from_fields(
+                title=effective_app_name,
+                current_schema=schema_result,
+                fields=current_fields,
+                layout=layout,
+                question_relations=compiled_question_relations,
+            )
+            if bool(resolved.get("created"))
+            else _build_form_payload_for_edit_fields(
+                title=effective_app_name,
+                current_schema=schema_result,
+                fields=current_fields,
+                layout=layout,
+                question_relations=compiled_question_relations,
+            )
         )
         payload["editVersionNo"] = self._resolve_form_edit_version(
             profile=profile,
@@ -4897,12 +4907,22 @@ class AiBuilderFacade:
                     },
                     suggested_next_call={"tool_name": "app_get_fields", "arguments": {"profile": profile, "app_key": target.app_key}},
                 )
-            rebound_payload = _build_form_payload_from_fields(
-                title=effective_app_name,
-                current_schema=rebound_schema,
-                fields=rebound_fields,
-                layout=rebound_layout,
-                question_relations=compiled_question_relations,
+            rebound_payload = (
+                _build_form_payload_from_fields(
+                    title=effective_app_name,
+                    current_schema=rebound_schema,
+                    fields=rebound_fields,
+                    layout=rebound_layout,
+                    question_relations=compiled_question_relations,
+                )
+                if bool(resolved.get("created"))
+                else _build_form_payload_for_edit_fields(
+                    title=effective_app_name,
+                    current_schema=rebound_schema,
+                    fields=rebound_fields,
+                    layout=rebound_layout,
+                    question_relations=compiled_question_relations,
+                )
             )
             rebound_payload["editVersionNo"] = self._resolve_form_edit_version(
                 profile=profile,
@@ -9844,8 +9864,8 @@ def _parse_field(question: dict[str, Any], *, field_id_hint: str | None = None)
         "subfields": [],
         "que_id": que_id,
         "que_type": que_type,
-        "default_type": _coerce_positive_int(question.get("queDefaultType")) or 1,
-        "default_value": question.get("queDefaultValue"),
+        "default_type": _coerce_positive_int(question.get("queDefaultType")) if "queDefaultType" in question else None,
+        "default_value": question.get("queDefaultValue") if "queDefaultValue" in question else None,
     }
     if field_type in {FieldType.single_select.value, FieldType.multi_select.value, FieldType.boolean.value}:
         options = question.get("options")
@@ -9893,7 +9913,6 @@ def _parse_field(question: dict[str, Any], *, field_id_hint: str | None = None)
         field["visible_fields"] = visible_fields
         field["field_name_show"] = bool(reference.get("fieldNameShow", True))
         field["_reference_config_template"] = deepcopy(reference)
-        field["_question_template"] = deepcopy(question)
         field["_relation_config_explicit"] = False
     if field_type == FieldType.department:
         department_scope = _normalize_department_scope_from_question(question)
@@ -9961,6 +9980,7 @@ def _parse_field(question: dict[str, Any], *, field_id_hint: str | None = None)
                 continue
             subfields.append(_parse_field(sub_question))
         field["subfields"] = subfields
+    field["_question_template"] = deepcopy(question)
     return field
 
 
@@ -10847,53 +10867,82 @@ def _apply_field_mutation(field: dict[str, Any], mutation: Any) -> None:
         payload.get("type") == FieldType.relation.value
         or any(key in payload for key in ("target_app_key", "display_field", "visible_fields", "relation_mode"))
     )
+    question_overlay_keys = set(cast(list[str], field.get("_question_overlay_keys") or []))
+    question_rebuild_required = bool(field.get("_question_rebuild_required"))
     if "name" in payload:
         field["name"] = payload["name"]
+        question_overlay_keys.add("name")
     if "type" in payload:
         field["type"] = payload["type"]
+        question_rebuild_required = True
     if "required" in payload:
         field["required"] = payload["required"]
+        question_overlay_keys.add("required")
     if "description" in payload:
         field["description"] = payload["description"]
+        question_overlay_keys.add("description")
     if "options" in payload:
         field["options"] = list(payload["options"])
+        question_rebuild_required = True
     if "target_app_key" in payload:
         field["target_app_key"] = payload["target_app_key"]
+        question_rebuild_required = True
     if "display_field" in payload:
         field["display_field"] = payload["display_field"]
+        question_rebuild_required = True
     if "visible_fields" in payload:
         field["visible_fields"] = list(payload["visible_fields"])
+        question_rebuild_required = True
     if "relation_mode" in payload:
         field["relation_mode"] = payload["relation_mode"]
+        question_rebuild_required = True
     if "department_scope" in payload:
         field["department_scope"] = payload["department_scope"]
+        question_rebuild_required = True
     if "remote_lookup_config" in payload:
         field["remote_lookup_config"] = payload["remote_lookup_config"]
         field["config"] = deepcopy(payload["remote_lookup_config"])
         field["_explicit_remote_lookup_config"] = True
+        question_rebuild_required = True
     if "q_linker_binding" in payload:
         field["q_linker_binding"] = payload["q_linker_binding"]
         if "remote_lookup_config" not in payload:
             field["_explicit_remote_lookup_config"] = False
+        question_rebuild_required = True
     if "code_block_config" in payload:
         field["code_block_config"] = payload["code_block_config"]
         field["config"] = deepcopy(payload["code_block_config"])
+        question_rebuild_required = True
     if "code_block_binding" in payload:
         field["code_block_binding"] = payload["code_block_binding"]
         field["_explicit_code_block_binding"] = True
+        question_rebuild_required = True
     if "auto_trigger" in payload:
         field["auto_trigger"] = payload["auto_trigger"]
+        question_rebuild_required = True
     if "custom_button_text_enabled" in payload:
         field["custom_button_text_enabled"] = payload["custom_button_text_enabled"]
+        question_rebuild_required = True
     if "custom_button_text" in payload:
         field["custom_button_text"] = payload["custom_button_text"]
+        question_rebuild_required = True
     if "subfields" in payload:
         field["subfields"] = [_field_patch_to_internal(item) for item in payload["subfields"]]
+        question_rebuild_required = True
     if relation_config_explicit:
         field["_relation_config_explicit"] = True
+        question_rebuild_required = True
     elif payload.get("type") and payload.get("type") != FieldType.relation.value:
         field.pop("_relation_config_explicit", None)
         field.pop("_reference_config_template", None)
+    if question_overlay_keys:
+        field["_question_overlay_keys"] = sorted(question_overlay_keys)
+    else:
+        field.pop("_question_overlay_keys", None)
+    if question_rebuild_required:
+        field["_question_rebuild_required"] = True
+    else:
+        field.pop("_question_rebuild_required", None)
 
 
 def _resolve_field_selector_with_uniqueness(
@@ -12691,6 +12740,42 @@ def _verify_package_attachment(packages: PackageTools, *, profile: str, tag_id:
     return last_result
 
 
+def _field_question_overlay_keys(field: dict[str, Any]) -> set[str]:
+    raw_value = field.get("_question_overlay_keys")
+    if isinstance(raw_value, set):
+        return {str(item) for item in raw_value if isinstance(item, str) and item}
+    if isinstance(raw_value, list):
+        return {str(item) for item in raw_value if isinstance(item, str) and item}
+    return set()
+
+
+def _field_needs_question_rebuild(field: dict[str, Any]) -> bool:
+    return not isinstance(field.get("_question_template"), dict) or bool(field.get("_question_rebuild_required"))
+
+
+def _materialize_preserved_question(field: dict[str, Any]) -> dict[str, Any] | None:
+    template = deepcopy(field.get("_question_template"))
+    if not isinstance(template, dict):
+        return None
+    overlay_keys = _field_question_overlay_keys(field)
+    if "name" in overlay_keys:
+        template["queTitle"] = str(field.get("name") or "")
+    if "required" in overlay_keys:
+        template["required"] = bool(field.get("required", False))
+    if "description" in overlay_keys:
+        description = field.get("description")
+        template["queHint"] = "" if description is None else str(description)
+    return template
+
+
+def _materialize_edit_question(field: dict[str, Any], *, temp_id: int) -> tuple[dict[str, Any], bool]:
+    if not _field_needs_question_rebuild(field):
+        preserved = _materialize_preserved_question(field)
+        if preserved is not None:
+            return preserved, True
+    return _field_to_question(field, temp_id=temp_id), False
+
+
 def _field_to_question(field: dict[str, Any], *, temp_id: int) -> dict[str, Any]:
     built_question, _next_temp_id = build_question(
         {
@@ -12746,7 +12831,6 @@ def _field_to_question(field: dict[str, Any], *, temp_id: int) -> dict[str, Any]
         )
         if preserved_reference is not None:
             preserved_reference["referAppKey"] = field.get("target_app_key")
-            preserved_reference["_targetEntityId"] = field.get("target_app_key")
             question["referenceConfig"] = preserved_reference
         else:
             reference = deepcopy(question.get("referenceConfig")) if isinstance(question.get("referenceConfig"), dict) else {}
@@ -12914,6 +12998,96 @@ def _build_form_payload_from_fields(
     return payload
 
 
+def _build_form_payload_for_edit_fields(
+    *,
+    title: str,
+    current_schema: dict[str, Any],
+    fields: list[dict[str, Any]],
+    layout: dict[str, Any],
+    question_relations: list[dict[str, Any]] | None = None,
+) -> dict[str, Any]:
+    _, section_templates = _extract_question_templates(current_schema)
+    fields_by_name = {
+        str(field.get("name") or ""): field
+        for field in fields
+        if isinstance(field, dict) and str(field.get("name") or "").strip()
+    }
+    form_rows: list[list[dict[str, Any]]] = []
+    temp_id = -10000
+
+    for row in layout.get("root_rows", []) or []:
+        questions: list[dict[str, Any]] = []
+        row_preserved = True
+        for name in row:
+            field = fields_by_name.get(str(name))
+            if field is None:
+                continue
+            question, preserved = _materialize_edit_question(field, temp_id=temp_id)
+            questions.append(question)
+            row_preserved = row_preserved and preserved
+            temp_id -= 100
+        if not questions:
+            continue
+        if not row_preserved:
+            _apply_row_widths(questions)
+        form_rows.append(questions)
+
+    for section in layout.get("sections", []) or []:
+        inner_rows: list[list[dict[str, Any]]] = []
+        for row in section.get("rows", []) or []:
+            questions: list[dict[str, Any]] = []
+            row_preserved = True
+            for name in row:
+                field = fields_by_name.get(str(name))
+                if field is None:
+                    continue
+                question, preserved = _materialize_edit_question(field, temp_id=temp_id)
+                questions.append(question)
+                row_preserved = row_preserved and preserved
+                temp_id -= 100
+            if not questions:
+                continue
+            if not row_preserved:
+                _apply_row_widths(questions)
+            inner_rows.append(questions)
+        if not inner_rows:
+            continue
+        template = _select_section_template(section_templates, section)
+        wrapper = deepcopy(template) if isinstance(template, dict) else {
+            "queId": 0,
+            "queTempId": -(20000 + sum(ord(ch) for ch in str(section.get("section_id") or section.get("title") or "section"))),
+            "queType": 24,
+            "queWidth": 100,
+            "scanType": 1,
+            "status": 1,
+            "required": False,
+            "queHint": "",
+            "linkedQuestions": {},
+            "logicalShow": True,
+            "queDefaultValue": None,
+            "queDefaultType": 1,
+            "subQueWidth": 2,
+            "beingHide": False,
+            "beingDesensitized": False,
+        }
+        if section.get("title") is not None:
+            wrapper["queTitle"] = section.get("title") or wrapper.get("queTitle") or "未命名分组"
+        parsed_section_id = _coerce_positive_int(section.get("section_id"))
+        if parsed_section_id is not None:
+            wrapper["sectionId"] = parsed_section_id
+        elif template is None and section.get("section_id") is not None:
+            wrapper["sectionId"] = section.get("section_id")
+        wrapper["innerQuestions"] = inner_rows
+        form_rows.append([wrapper])
+
+    payload = deepcopy(current_schema)
+    payload["formTitle"] = title
+    payload["formQues"] = form_rows
+    payload["questionRelations"] = deepcopy(question_relations if question_relations is not None else (current_schema.get("questionRelations") or []))
+    payload["editVersionNo"] = int(current_schema.get("editVersionNo") or 1)
+    return payload
+
+
 def _apply_row_widths(row: list[dict[str, Any]]) -> None:
     if not row:
         return

package/src/qingflow_mcp/tools/record_tools.py

@@ -180,6 +180,16 @@ class AccessibleViewRoute:
     view_type: str | None = None
 
 
+@dataclass(slots=True)
+class RecordContextRouteProbe:
+    route: AccessibleViewRoute
+    answer_list: list[JSONObject] | None
+    used_list_type: int | None
+    readable: bool
+    transport_error: bool
+    error_payload: JSONObject | None
+
+
 @dataclass(slots=True)
 class WorkflowNodeRef:
     workflow_node_id: int
@@ -782,55 +792,29 @@ class RecordTools(ToolBase):
                 index=app_index,
                 question_relations=question_relations,
             )
-            try:
-                current_answers = self._load_record_answers_for_preflight(context, app_key=app_key, apply_id=record_id)
-            except QingflowApiError:
-                return self._record_update_schema_blocked_response(
-                    profile=profile,
-                    ws_id=session_profile.selected_ws_id,
-                    request_route=request_route,
-                    app_key=app_key,
-                    record_id=record_id,
-                    blockers=["CURRENT_RECORD_CONTEXT_UNAVAILABLE"],
-                    warnings=[
-                        "update schema could not load the current record; context-sensitive lookup requirements cannot be derived safely."
-                    ],
-                    recommended_next_actions=[
-                        "Retry after the record becomes readable in the current workspace/profile context.",
-                        "If the issue persists, verify that the current profile still has read access to this record.",
-                    ],
-                    output_profile=normalized_output_profile,
-                    view_probe_summary=[],
-                    ambiguous_fields=[],
-                )
-
             candidate_routes = self._candidate_update_views(profile, context, app_key)
+            probes = self._probe_candidate_record_contexts(
+                context,
+                app_key=app_key,
+                apply_id=record_id,
+                candidate_routes=candidate_routes,
+            )
             probe_summary: list[JSONObject] = []
-            matched_any = False
+            matched_probes: list[RecordContextRouteProbe] = []
             ordered_field_ids: list[int] = []
             field_payloads_by_id: dict[int, JSONObject] = {}
             title_to_field_ids: dict[str, list[int]] = {}
             ws_id = session_profile.selected_ws_id
 
-            for candidate in candidate_routes:
-                matched_record = self._record_matches_accessible_view(
-                    context,
-                    current_answers,
-                    resolved_view=candidate,
-                )
-                candidate_summary: JSONObject = {
-                    "view_id": candidate.view_id,
-                    "name": candidate.name,
-                    "kind": candidate.kind,
-                    "matched_record": matched_record,
-                    "context_complete": True,
-                    "writable_field_titles": [],
-                }
-                if not matched_record:
+            for probe in probes:
+                candidate = probe.route
+                candidate_summary = self._record_context_probe_summary_payload(probe)
+                candidate_summary["writable_field_titles"] = []
+                if not probe.readable:
                     probe_summary.append(candidate_summary)
                     continue
 
-                matched_any = True
+                matched_probes.append(probe)
                 browse_scope = self._build_browse_write_scope(
                     profile,
                     context,
@@ -874,19 +858,39 @@ class RecordTools(ToolBase):
                 candidate_summary["writable_field_titles"] = candidate_titles
                 probe_summary.append(candidate_summary)
 
-            if not matched_any:
+            if not matched_probes:
+                blockers = (
+                    ["CURRENT_RECORD_CONTEXT_UNAVAILABLE"]
+                    if probes and all(probe.transport_error for probe in probes)
+                    else ["NO_MATCHING_ACCESSIBLE_VIEW_FOR_RECORD"]
+                )
+                warnings = (
+                    [
+                        "update schema could not load the current record from any candidate route; context-sensitive lookup requirements cannot be derived safely."
+                    ]
+                    if blockers == ["CURRENT_RECORD_CONTEXT_UNAVAILABLE"]
+                    else []
+                )
+                recommended_next_actions = (
+                    [
+                        "Retry after the record becomes readable in the current workspace/profile context.",
+                        "If the issue persists, verify that the current profile still has read access to this record.",
+                    ]
+                    if blockers == ["CURRENT_RECORD_CONTEXT_UNAVAILABLE"]
+                    else [
+                        "Check whether this record is still visible in any accessible view for the current profile.",
+                        "Use record_get or record_list to confirm the record still exists in the current workspace.",
+                    ]
+                )
                 return self._record_update_schema_blocked_response(
                     profile=profile,
                     ws_id=ws_id,
                     request_route=request_route,
                     app_key=app_key,
                     record_id=record_id,
-                    blockers=["NO_MATCHING_ACCESSIBLE_VIEW_FOR_RECORD"],
-                    warnings=[],
-                    recommended_next_actions=[
-                        "Check whether this record is still visible in any accessible view for the current profile.",
-                        "Use record_get or record_list to confirm the record still exists in the current workspace.",
-                    ],
+                    blockers=blockers,
+                    warnings=warnings,
+                    recommended_next_actions=recommended_next_actions,
                     output_profile=normalized_output_profile,
                     view_probe_summary=probe_summary,
                     ambiguous_fields=[],
@@ -894,7 +898,10 @@ class RecordTools(ToolBase):
 
             ambiguous_field_ids: set[int] = set()
             ambiguous_fields: list[JSONObject] = []
-            warnings: list[JSONObject] = []
+            warnings: list[JSONObject] = [
+                {"code": "RECORD_CONTEXT_ROUTE_FALLBACK", "message": message}
+                for message in self._record_context_probe_fallback_warnings(probes)
+            ]
             for title, field_ids in title_to_field_ids.items():
                 unique_ids = list(dict.fromkeys(field_ids))
                 if len(unique_ids) <= 1:
@@ -953,6 +960,7 @@ class RecordTools(ToolBase):
             }
             if normalized_output_profile == "verbose":
                 response["view_probe_summary"] = probe_summary
+                response["record_context_probe"] = probe_summary
                 response["ambiguous_fields"] = ambiguous_fields
             return response
 
@@ -2286,9 +2294,15 @@ class RecordTools(ToolBase):
         def runner(session_profile, context):
             request_route = self._request_route_payload(context)
             def build_once(*, effective_force_refresh: bool) -> JSONObject:
-                try:
-                    current_answers = self._load_record_answers_for_preflight(context, app_key=app_key, apply_id=record_id)
-                except QingflowApiError:
+                candidate_routes = self._candidate_update_views(profile, context, app_key)
+                probes = self._probe_candidate_record_contexts(
+                    context,
+                    app_key=app_key,
+                    apply_id=record_id,
+                    candidate_routes=candidate_routes,
+                )
+                matched_probes = [probe for probe in probes if probe.readable]
+                if not matched_probes and probes and all(probe.transport_error for probe in probes):
                     return {
                         "profile": profile,
                         "ws_id": session_profile.selected_ws_id,
@@ -2299,46 +2313,40 @@ class RecordTools(ToolBase):
                             record_id=record_id,
                             blockers=["CURRENT_RECORD_CONTEXT_UNAVAILABLE"],
                             warnings=[
-                                "update preflight could not load the current record; automatic view selection was blocked to avoid resolving lookup fields against a partial patch."
+                                "update preflight could not load the current record from any candidate route; automatic view selection was blocked to avoid resolving lookup fields against a partial patch."
                             ],
                             recommended_next_actions=[
                                 "Retry after the record becomes readable in the current workspace/profile context.",
                                 "Call record_update_schema_get to inspect the overall writable field set for this record after context access is restored.",
                             ],
-                            view_probe_summary=[],
+                            view_probe_summary=[
+                                self._record_context_probe_summary_payload(probe)
+                                for probe in probes
+                            ],
                         ),
                     }
 
-                candidate_routes = self._candidate_update_views(profile, context, app_key)
                 probe_summary: list[JSONObject] = []
-                matched_any = False
                 matched_routes: list[AccessibleViewRoute] = []
+                matched_answers_for_union: list[JSONObject] | None = None
                 first_blocked_plan: JSONObject | None = None
                 first_confirmation_plan: JSONObject | None = None
-
-                for candidate in candidate_routes:
-                    matched_record = self._record_matches_accessible_view(
-                        context,
-                        current_answers,
-                        resolved_view=candidate,
-                    )
-                    if not matched_record:
-                        probe_summary.append(
-                            {
-                                "view_id": candidate.view_id,
-                                "name": candidate.name,
-                                "kind": candidate.kind,
-                                "matched_record": False,
-                                "writable_field_titles": [],
-                                "missing_field_titles": [],
-                                "context_complete": True,
-                                "selected": False,
-                            }
-                        )
+                fallback_warning_messages = self._record_context_probe_fallback_warnings(probes)
+
+                for probe in probes:
+                    candidate = probe.route
+                    candidate_summary = self._record_context_probe_summary_payload(probe)
+                    candidate_summary["writable_field_titles"] = []
+                    candidate_summary["missing_field_titles"] = []
+                    candidate_summary["selected"] = False
+                    if not probe.readable:
+                        probe_summary.append(candidate_summary)
                         continue
 
-                    matched_any = True
+                    current_answers = probe.answer_list or []
                     matched_routes.append(candidate)
+                    if matched_answers_for_union is None:
+                        matched_answers_for_union = current_answers
                     browse_scope = self._build_browse_write_scope(
                         profile,
                         context,
@@ -2394,16 +2402,8 @@ class RecordTools(ToolBase):
                             title = _normalize_optional_text(field_payload.get("que_title"))
                             if title and title not in missing_field_titles:
                                 missing_field_titles.append(title)
-                    candidate_summary: JSONObject = {
-                        "view_id": candidate.view_id,
-                        "name": candidate.name,
-                        "kind": candidate.kind,
-                        "matched_record": True,
-                        "writable_field_titles": candidate_titles,
-                        "missing_field_titles": missing_field_titles,
-                        "context_complete": True,
-                        "selected": False,
-                    }
+                    candidate_summary["writable_field_titles"] = candidate_titles
+                    candidate_summary["missing_field_titles"] = missing_field_titles
                     if plan_data.get("blockers"):
                         confirmation_requests = plan_data.get("confirmation_requests")
                         if (
@@ -2422,8 +2422,26 @@ class RecordTools(ToolBase):
                             view_payload["auto_selected"] = True
                             view_payload["selection_source"] = "first_satisfying_accessible_view"
                             candidate_summary["selected"] = True
+                            validation = plan_data.get("validation")
+                            if isinstance(validation, dict):
+                                warnings = validation.get("warnings")
+                                if not isinstance(warnings, list):
+                                    warnings = []
+                                    validation["warnings"] = warnings
+                                for message in fallback_warning_messages:
+                                    if message not in warnings:
+                                        warnings.append(message)
                             first_confirmation_plan = plan_data
                         elif first_blocked_plan is None:
+                            validation = plan_data.get("validation")
+                            if isinstance(validation, dict):
+                                warnings = validation.get("warnings")
+                                if not isinstance(warnings, list):
+                                    warnings = []
+                                    validation["warnings"] = warnings
+                                for message in fallback_warning_messages:
+                                    if message not in warnings:
+                                        warnings.append(message)
                             first_blocked_plan = plan_data
                         probe_summary.append(candidate_summary)
                         continue
@@ -2439,8 +2457,18 @@ class RecordTools(ToolBase):
                     view_payload["auto_selected"] = True
                     view_payload["selection_source"] = "first_satisfying_accessible_view"
                     candidate_summary["selected"] = True
+                    validation = plan_data.get("validation")
+                    if isinstance(validation, dict):
+                        warnings = validation.get("warnings")
+                        if not isinstance(warnings, list):
+                            warnings = []
+                            validation["warnings"] = warnings
+                        for message in fallback_warning_messages:
+                            if message not in warnings:
+                                warnings.append(message)
                     probe_summary.append(candidate_summary)
                     plan_data["view_probe_summary"] = probe_summary
+                    plan_data["record_context_probe"] = probe_summary
                     return {
                         "profile": profile,
                         "ws_id": session_profile.selected_ws_id,
@@ -2449,7 +2477,7 @@ class RecordTools(ToolBase):
                         "data": plan_data,
                     }
 
-                if not matched_any:
+                if not matched_probes:
                     blocked_data = self._build_auto_view_blocked_preflight_data(
                         app_key=app_key,
                         record_id=record_id,
@@ -2471,6 +2499,7 @@ class RecordTools(ToolBase):
 
                 if first_confirmation_plan is not None:
                     first_confirmation_plan["view_probe_summary"] = probe_summary
+                    first_confirmation_plan["record_context_probe"] = probe_summary
                     return {
                         "profile": profile,
                         "ws_id": session_profile.selected_ws_id,
@@ -2485,12 +2514,22 @@ class RecordTools(ToolBase):
                     app_key=app_key,
                     record_id=record_id,
                     fields=fields,
-                    current_answers=current_answers,
+                    current_answers=matched_answers_for_union or [],
                     matched_routes=matched_routes,
                     force_refresh_form=effective_force_refresh,
                 )
                 if union_plan is not None:
+                    validation = union_plan.get("validation")
+                    if isinstance(validation, dict):
+                        warnings = validation.get("warnings")
+                        if not isinstance(warnings, list):
+                            warnings = []
+                            validation["warnings"] = warnings
+                        for message in fallback_warning_messages:
+                            if message not in warnings:
+                                warnings.append(message)
                     union_plan["view_probe_summary"] = probe_summary
+                    union_plan["record_context_probe"] = probe_summary
                     return {
                         "profile": profile,
                         "ws_id": session_profile.selected_ws_id,
@@ -2785,6 +2824,161 @@ class RecordTools(ToolBase):
             )
         return candidates
 
+    def _route_view_key(self, resolved_view: AccessibleViewRoute) -> str | None:
+        if resolved_view.view_selection is not None:
+            view_key = _normalize_optional_text(resolved_view.view_selection.view_key)
+            if view_key:
+                return view_key
+        if resolved_view.kind == "custom" and resolved_view.view_id.startswith("custom:"):
+            view_key = resolved_view.view_id.split(":", 1)[1].strip()
+            return view_key or None
+        return None
+
+    def _record_context_route_error_payload(self, error: QingflowApiError) -> JSONObject:
+        payload: JSONObject = {"message": error.message}
+        if error.category:
+            payload["category"] = error.category
+        if error.backend_code is not None:
+            payload["backend_code"] = error.backend_code
+        if error.http_status is not None:
+            payload["http_status"] = error.http_status
+        return payload
+
+    def _is_record_context_route_miss(self, error: QingflowApiError) -> bool:
+        if error.backend_code in {40002, 40027, 40038, 404}:
+            return True
+        if error.http_status == 404:
+            return True
+        return False
+
+    def _load_record_answers_for_accessible_route(
+        self,
+        context,  # type: ignore[no-untyped-def]
+        *,
+        app_key: str,
+        apply_id: int,
+        resolved_view: AccessibleViewRoute,
+    ) -> tuple[list[JSONObject], int | None]:
+        if resolved_view.kind == "custom":
+            view_key = self._route_view_key(resolved_view)
+            if not view_key:
+                raise_tool_error(
+                    QingflowApiError.config_error(
+                        f"cannot resolve custom view route for '{resolved_view.view_id}'"
+                    )
+                )
+            record = self.backend.request(
+                "GET",
+                context,
+                f"/view/{view_key}/apply/{apply_id}",
+            )
+            used_list_type = None
+        else:
+            used_list_type = resolved_view.list_type if resolved_view.list_type is not None else DEFAULT_RECORD_LIST_TYPE
+            record = self.backend.request(
+                "GET",
+                context,
+                f"/app/{app_key}/apply/{apply_id}",
+                params={"role": 1, "listType": used_list_type},
+            )
+        answers = record.get("answers") if isinstance(record, dict) else None
+        normalized_answers = [item for item in answers if isinstance(item, dict)] if isinstance(answers, list) else []
+        return normalized_answers, used_list_type
+
+    def _probe_record_context_route(
+        self,
+        context,  # type: ignore[no-untyped-def]
+        *,
+        app_key: str,
+        apply_id: int,
+        resolved_view: AccessibleViewRoute,
+    ) -> RecordContextRouteProbe:
+        try:
+            answer_list, used_list_type = self._load_record_answers_for_accessible_route(
+                context,
+                app_key=app_key,
+                apply_id=apply_id,
+                resolved_view=resolved_view,
+            )
+            return RecordContextRouteProbe(
+                route=resolved_view,
+                answer_list=answer_list,
+                used_list_type=used_list_type,
+                readable=True,
+                transport_error=False,
+                error_payload=None,
+            )
+        except QingflowApiError as exc:
+            return RecordContextRouteProbe(
+                route=resolved_view,
+                answer_list=None,
+                used_list_type=resolved_view.list_type if resolved_view.kind == "system" else None,
+                readable=False,
+                transport_error=not self._is_record_context_route_miss(exc),
+                error_payload=self._record_context_route_error_payload(exc),
+            )
+
+    def _probe_candidate_record_contexts(
+        self,
+        context,  # type: ignore[no-untyped-def]
+        *,
+        app_key: str,
+        apply_id: int,
+        candidate_routes: list[AccessibleViewRoute],
+    ) -> list[RecordContextRouteProbe]:
+        return [
+            self._probe_record_context_route(
+                context,
+                app_key=app_key,
+                apply_id=apply_id,
+                resolved_view=candidate,
+            )
+            for candidate in candidate_routes
+        ]
+
+    def _record_context_probe_summary_payload(self, probe: RecordContextRouteProbe) -> JSONObject:
+        payload: JSONObject = {
+            "view_id": probe.route.view_id,
+            "name": probe.route.name,
+            "kind": probe.route.kind,
+            "matched_record": probe.readable,
+            "readable": probe.readable,
+            "context_complete": probe.readable,
+            "used_list_type": probe.used_list_type,
+        }
+        if probe.error_payload is not None:
+            payload["error"] = probe.error_payload
+            payload["transport_error"] = probe.transport_error
+        return payload
+
+    def _record_context_probe_fallback_warnings(
+        self,
+        probes: list[RecordContextRouteProbe],
+    ) -> list[str]:
+        matched_probes = [probe for probe in probes if probe.readable]
+        if not matched_probes:
+            return []
+        if any(
+            probe.route.kind == "system" and probe.used_list_type == DEFAULT_RECORD_LIST_TYPE
+            for probe in matched_probes
+        ):
+            return []
+        first_probe = matched_probes[0]
+        if first_probe.route.kind == "custom":
+            return [
+                "current record context was not accessible via listType="
+                f"{DEFAULT_RECORD_LIST_TYPE}; preflight resolved it via custom view "
+                f"'{first_probe.route.name}'."
+            ]
+        used_list_type = first_probe.used_list_type
+        if used_list_type is None:
+            return []
+        return [
+            "current record context was not accessible via listType="
+            f"{DEFAULT_RECORD_LIST_TYPE}; preflight resolved it via listType={used_list_type} "
+            f"({get_record_list_type_label(used_list_type)})."
+        ]
+
     def _record_matches_accessible_view(
         self,
         context,  # type: ignore[no-untyped-def]
@@ -5276,7 +5470,19 @@ class RecordTools(ToolBase):
                 existing_answers_loaded = True
             else:
                 try:
-                    existing_answers_for_update = self._load_record_answers_for_preflight(context, app_key=app_key, apply_id=apply_id)
+                    if resolved_view is not None:
+                        existing_answers_for_update, _used_list_type = self._load_record_answers_for_accessible_route(
+                            context,
+                            app_key=app_key,
+                            apply_id=apply_id,
+                            resolved_view=resolved_view,
+                        )
+                    else:
+                        existing_answers_for_update = self._load_record_answers_for_preflight(
+                            context,
+                            app_key=app_key,
+                            apply_id=apply_id,
+                        )
                     existing_answers_loaded = True
                 except QingflowApiError:
                     validation_warnings.append(