@josephyan/qingflow-cli 1.0.10 → 1.1.1

package/src/qingflow_mcp/tools/record_tools.py

@@ -2,18 +2,22 @@ from __future__ import annotations
 
 import csv
 import html
+import mimetypes
 import json
 import os
 import re
 import time
+import zipfile
 from copy import deepcopy
 from dataclasses import dataclass
 from datetime import UTC, datetime, timedelta
 from decimal import Decimal, InvalidOperation
+from io import BytesIO
 from pathlib import Path
 from typing import Any, cast
 from urllib.parse import parse_qs, unquote, urlsplit
 from uuid import uuid4
+from xml.etree import ElementTree
 
 from mcp.server.fastmcp import FastMCP
 
@@ -34,15 +38,29 @@ from .directory_tools import _directory_has_more, _directory_items
 
 DEFAULT_QUERY_PAGE_SIZE = 50
 DEFAULT_LIST_PAGE_SIZE = 200
+DEFAULT_RECORD_LIST_RETURN_LIMIT = 10
 BACKEND_RECORD_ACCESS_PAGE_SIZE = 1000
 DEFAULT_RECORD_ACCESS_SHARD_ROWS = 20_000
 RECORD_ACCESS_UNBOUNDED_ROW_THRESHOLD = 50_000
 RECORD_ACCESS_TIME_BUDGET_SECONDS = 55.0
 RECORD_ACCESS_MIN_REMAINING_SECONDS = 8.0
 RECORD_GET_DETAIL_LOG_PAGE_SIZE = 10
+RECORD_LOGS_PAGE_SIZE = 200
+RECORD_LOGS_PREVIEW_LIMIT = 10
+RECORD_LOGS_MAX_ITEMS = 20_000
+RECORD_LOGS_TIME_BUDGET_SECONDS = 55.0
+RECORD_LOGS_MIN_REMAINING_SECONDS = 8.0
 RECORD_GET_MEDIA_MAX_IMAGES = 30
 RECORD_GET_MEDIA_MAX_IMAGE_BYTES = 20 * 1024 * 1024
 RECORD_GET_MEDIA_MAX_TOTAL_BYTES = 100 * 1024 * 1024
+RECORD_GET_FILE_MAX_FILES = 50
+RECORD_GET_FILE_MAX_BYTES = 50 * 1024 * 1024
+RECORD_GET_FILE_MAX_TOTAL_BYTES = 200 * 1024 * 1024
+RECORD_GET_FILE_TIME_BUDGET_SECONDS = 55.0
+RECORD_GET_FILE_MIN_REMAINING_SECONDS = 8.0
+RECORD_GET_FILE_EXTRACT_PREVIEW_CHARS = 20_000
+RECORD_GET_FILE_EXTRACT_XLSX_MAX_ROWS_PER_SHEET = 200
+RECORD_GET_FILE_EXTRACT_PDF_MAX_PAGES = 50
 DEFAULT_ANALYSIS_PAGE_SIZE = 1000
 DEFAULT_SCAN_MAX_PAGES = 10
 DEFAULT_ANALYSIS_SCAN_MAX_PAGES = 100
@@ -256,6 +274,30 @@ GENERIC_FIELD_ALIAS_OVERRIDES: dict[str, list[str]] = {
 FIELD_LOOKUP_STRIP_RE = re.compile(r"[\s_()（）\[\]【】{}<>·/\\:：-]+")
 
 
+def _pick_route_payload(payload: JSONObject) -> JSONObject:
+    return {
+        key: payload[key]
+        for key in (
+            "route_type",
+            "endpoint_kind",
+            "status",
+            "role",
+            "task_id",
+            "workflow_node_id",
+            "view_id",
+            "view_key",
+            "view_name",
+            "error_code",
+            "backend_code",
+            "http_status",
+            "request_id",
+            "message",
+            "reason",
+        )
+        if key in payload and payload[key] not in (None, "", [], {})
+    }
+
+
 class RecordTools(ToolBase):
     """记录工具（中文名：记录读写与分析）。
 
@@ -355,7 +397,7 @@ class RecordTools(ToolBase):
             description=(
                 "Browse Qingflow records with a schema-first list DSL. "
                 "Use record_browse_schema_get first, then pass field_id-only columns, where, and order_by clauses. "
-                "This route is for browse/export/sample inspection only, not analysis."
+                "This route returns up to 10 rows plus total counts for browse, sample inspection, and fuzzy record lookup; it is not for analysis."
             )
         )
         def record_list(
@@ -366,7 +408,6 @@ class RecordTools(ToolBase):
             query_fields: list[JSONObject | int] | None = None,
             where: list[JSONObject] | None = None,
             order_by: list[JSONObject] | None = None,
-            limit: int = 50,
             page: int = 1,
             view_id: str | None = None,
             output_profile: str = "normal",
@@ -379,7 +420,6 @@ class RecordTools(ToolBase):
                 query_fields=query_fields or [],
                 where=where or [],
                 order_by=order_by or [],
-                limit=limit,
                 page=page,
                 view_id=view_id,
                 list_type=None,
@@ -431,6 +471,20 @@ class RecordTools(ToolBase):
                 output_profile=output_profile,
             )
 
+        @mcp.tool(description="Read all visible data logs and workflow logs for one Qingflow record into local JSONL files. This tool hides pagination and returns file paths plus completeness metadata.")
+        def record_logs_get(
+            profile: str = DEFAULT_PROFILE,
+            app_key: str = "",
+            record_id: str = "",
+            view_id: str | None = None,
+        ) -> JSONObject:
+            return self.record_logs_get(
+                profile=profile,
+                app_key=app_key,
+                record_id=record_id,
+                view_id=view_id,
+            )
+
         @mcp.tool()
         def record_browse_schema_get(
             app_key: str = "",
@@ -459,21 +513,22 @@ class RecordTools(ToolBase):
 
         @mcp.tool(
             description=(
-                "Insert one Qingflow record using an applicant-node field map. "
+                "Insert Qingflow records using applicant-node field maps. "
                 "Use record_insert_schema_get first. "
-                "This tool performs internal preflight validation before any write is applied."
+                "Prefer items=[{'fields': {...}}]; a single insert is one item. "
+                "Each item performs internal preflight validation before that item is written."
             )
         )
         def record_insert(
             app_key: str = "",
-            fields: JSONObject | None = None,
+            items: list[JSONObject] | None = None,
             verify_write: bool = True,
             output_profile: str = "normal",
         ) -> JSONObject:
             return self.record_insert_public(
                 profile=DEFAULT_PROFILE,
                 app_key=app_key,
-                fields=fields or {},
+                items=items,
                 verify_write=verify_write,
                 output_profile=output_profile,
             )
@@ -481,8 +536,9 @@ class RecordTools(ToolBase):
         @mcp.tool(
             description=(
                 "Update one Qingflow record using a field map. "
-                "Use record_update_schema_get first. "
-                "This tool automatically probes accessible views in order and uses the first safe match."
+                "For simple field changes, call this tool directly after the target record is clear. "
+                "It first tries the data-manager direct route, then falls back to the frontend custom-view edit route when available. "
+                "Use record_update_schema_get for diagnostics or complex field-scope inspection."
             )
         )
         def record_update(
@@ -983,15 +1039,59 @@ class RecordTools(ToolBase):
                     item["title"]: self._ready_schema_template_value(item)
                     for item in writable_fields
                 },
+                "available_update_routes": self._record_update_schema_available_routes(matched_probes),
+                "recommended_update_route": {
+                    "route_type": "auto",
+                    "order": ["admin_direct", "view_edit", "task_save_only"],
+                    "message": "record_update will try data-manager direct edit first, then a matching custom-view edit route, then a unique current-user todo save-only route when the target fields are editable on that workflow node.",
+                },
             }
             if normalized_output_profile == "verbose":
                 response["view_probe_summary"] = probe_summary
                 response["record_context_probe"] = probe_summary
                 response["ambiguous_fields"] = ambiguous_fields
+                response["route_probe_summary"] = probe_summary
             return response
 
         return self._run_record_tool(profile, runner)
 
+    def _record_update_schema_available_routes(self, matched_probes: list[RecordContextRouteProbe]) -> list[JSONObject]:
+        routes: list[JSONObject] = [
+            {
+                "route_type": "admin_direct",
+                "endpoint_kind": "app_apply_update",
+                "role": 1,
+                "availability": "attempted_on_update",
+                "message": "Requires data-manager edit permission; record_update safely falls back if backend returns permission denied.",
+            }
+        ]
+        for probe in matched_probes:
+            if probe.route.kind != "custom":
+                continue
+            view_key = self._route_view_key(probe.route)
+            if not view_key:
+                continue
+            routes.append(
+                {
+                    "route_type": "view_edit",
+                    "endpoint_kind": "view_apply_update",
+                    "view_id": probe.route.view_id,
+                    "view_key": view_key,
+                    "view_name": probe.route.name,
+                    "availability": "candidate",
+                    "message": "Uses the same custom-view detail edit route as the frontend.",
+                }
+            )
+        routes.append(
+            {
+                "route_type": "task_save_only",
+                "endpoint_kind": "workflow_node_save_only",
+                "availability": "auto_probe_on_update",
+                "message": "record_update probes the current user's todo list and uses save-only only when exactly one matching task exists and the requested fields are editable on that workflow node.",
+            }
+        )
+        return routes
+
     def _record_update_schema_blocked_response(
         self,
         *,
@@ -1053,11 +1153,16 @@ class RecordTools(ToolBase):
             required = bool(required_override) if required_override is not None else bool(field.required or any(item.get("required") for item in row_fields))
         else:
             required = bool(required_override) if required_override is not None else bool(field.required)
+        write_format = _write_format_for_field(field)
         payload: JSONObject = {
             "title": field.que_title,
             "kind": kind,
             "required": required,
+            "format_hint": _ready_schema_format_hint(kind, write_format),
         }
+        example_value = _ready_schema_example_value(kind, field, write_format, row_fields=row_fields)
+        if example_value is not None:
+            payload["example_value"] = example_value
         if include_field_id:
             payload["field_id"] = field.que_id
         if kind in {"single_select", "multi_select"} and field.options:
@@ -1618,8 +1723,8 @@ class RecordTools(ToolBase):
         query_fields: list[JSONObject | int] | None = None,
         where: list[JSONObject],
         order_by: list[JSONObject],
-        limit: int,
-        page: int,
+        limit: int = DEFAULT_RECORD_LIST_RETURN_LIMIT,
+        page: int = 1,
         view_id: str | None = None,
         list_type: int | None = None,
         view_key: str | None = None,
@@ -1664,127 +1769,133 @@ class RecordTools(ToolBase):
                     },
                 )
             )
-        resolved_columns = normalized_columns or self._derive_public_list_columns_for_public(
-            profile=profile,
-            app_key=app_key,
-            resolved_view=view_route,
-        )
-        resolved_query_fields = self._resolve_record_list_query_fields_for_public(
-            profile=profile,
-            app_key=app_key,
-            resolved_view=view_route,
-            selectors=normalized_query_field_selectors,
-        )
+        filters = self._normalize_record_list_where(where)
+        sorts = self._normalize_record_list_order_by(order_by)
 
-        raw = self.record_query(
-            profile=profile,
-            query_mode="list",
-            app_key=app_key,
-            apply_id=None,
-            page_num=page,
-            page_size=DEFAULT_LIST_PAGE_SIZE,
-            requested_pages=1,
-            scan_max_pages=1,
-            auto_expand_pages=False,
-            query_key=normalized_query,
-            search_que_ids=resolved_query_fields,
-            filters=self._normalize_record_list_where(where),
-            sorts=self._normalize_record_list_order_by(order_by),
-            max_rows=limit,
-            max_columns=len(resolved_columns),
-            select_columns=resolved_columns,
-            amount_column=None,
-            time_range={},
-            stat_policy={},
-            strict_full=False,
-            output_profile="verbose" if normalized_output_profile in {"verbose", "normalized"} else DEFAULT_OUTPUT_PROFILE,
-            list_type=view_route.list_type if view_route.list_type is not None else DEFAULT_RECORD_LIST_TYPE,
-            view_key=view_route.view_selection.view_key if view_route.view_selection is not None else None,
-            view_name=view_route.view_selection.view_name if view_route.view_selection is not None else None,
-        )
-        list_data = cast(JSONObject, cast(JSONObject, raw["data"])["list"])
-        pagination = cast(JSONObject, list_data["pagination"])
-        warnings: list[JSONObject] = []
-        warnings.extend(legacy_warnings)
-        warnings.extend(compatibility_warnings)
-        warnings.extend(_view_filter_trust_warnings(view_route))
-        warning = _normalize_optional_text(list_data.get("analysis_warning"))
-        if warning:
-            warnings.append({"code": "BROWSE_ONLY", "message": warning})
-        list_type_used = _coerce_count(pagination.get("list_type_used"))
-        if list_type_used is not None and list_type_used != DEFAULT_RECORD_LIST_TYPE:
-            warnings.append(
-                {
-                    "code": "LIST_TYPE_FALLBACK",
-                    "message": (
-                        f"record_list not accessible via listType={DEFAULT_RECORD_LIST_TYPE}; "
-                        f"fell back to listType={list_type_used} ({get_record_list_type_label(list_type_used)})."
-                    ),
-                }
+        def runner(session_profile, context):
+            browse_scope = self._build_browse_read_scope(
+                profile,
+                context,
+                app_key,
+                view_route,
+                force_refresh=False,
             )
-        rows = list_data.get("rows", [])
-        normalized_public_rows = _normalize_public_record_rows(rows if isinstance(rows, list) else [])
-        lookup_payload = _build_record_list_lookup_payload(
-            query=normalized_query,
-            items=normalized_public_rows,
-            pagination=pagination,
-            limit=limit,
-        )
-        response: JSONObject = {
-            "profile": profile,
-            "ws_id": raw.get("ws_id"),
-            "ok": bool(raw.get("ok", True)),
-            "request_route": raw.get("request_route"),
-            "warnings": warnings,
-            "verification": _view_filter_verification_payload(view_route),
-            "output_profile": normalized_output_profile,
-            "data": {
-                "app_key": app_key,
-                "items": normalized_public_rows,
-                "pagination": {
-                    "page": page,
-                    "limit": limit,
-                    "returned_items": pagination.get("returned_items"),
-                    "result_amount": pagination.get("result_amount"),
-                    "list_type_used": list_type_used,
-                },
-                "selection": {
-                    "columns": [_column_selector_payload(field_id) for field_id in resolved_columns],
-                    "query_fields": [_column_selector_payload(field_id) for field_id in resolved_query_fields],
-                    "view": _accessible_view_payload(view_route),
+            index = cast(FieldIndex, browse_scope["index"])
+            selected_fields = (
+                self._resolve_record_list_columns(normalized_columns, index, view_route=view_route)
+                if normalized_columns
+                else self._derive_record_list_fields_from_index(index)
+            )
+            resolved_columns = [field.que_id for field in selected_fields]
+            resolved_query_fields = self._resolve_record_list_query_fields(
+                normalized_query_field_selectors,
+                index,
+                view_route=view_route,
+            )
+            match_rules = self._resolve_record_list_match_rules(context, filters, index, view_route=view_route)
+            sort_rules = self._resolve_record_list_sort_rules(sorts, index, view_route=view_route)
+            raw = self._record_list_query_view_fields(
+                session_profile=session_profile,
+                context=context,
+                app_key=app_key,
+                view_route=view_route,
+                page_num=page,
+                page_size=DEFAULT_LIST_PAGE_SIZE,
+                query_key=normalized_query,
+                search_que_ids=resolved_query_fields or None,
+                match_rules=match_rules,
+                sort_rules=sort_rules,
+                max_rows=limit,
+                selected_fields=selected_fields,
+                output_profile="verbose" if normalized_output_profile in {"verbose", "normalized"} else DEFAULT_OUTPUT_PROFILE,
+            )
+            list_data = cast(JSONObject, cast(JSONObject, raw["data"])["list"])
+            pagination = cast(JSONObject, list_data["pagination"])
+            warnings: list[JSONObject] = []
+            warnings.extend(legacy_warnings)
+            warnings.extend(compatibility_warnings)
+            warnings.extend(_view_filter_trust_warnings(view_route))
+            warning = _normalize_optional_text(list_data.get("analysis_warning"))
+            if warning:
+                warnings.append({"code": "BROWSE_ONLY", "message": warning})
+            list_type_used = _coerce_count(pagination.get("list_type_used"))
+            if list_type_used is not None and list_type_used != DEFAULT_RECORD_LIST_TYPE:
+                warnings.append(
+                    {
+                        "code": "LIST_TYPE_FALLBACK",
+                        "message": (
+                            f"record_list not accessible via listType={DEFAULT_RECORD_LIST_TYPE}; "
+                            f"fell back to listType={list_type_used} ({get_record_list_type_label(list_type_used)})."
+                        ),
+                    }
+                )
+            rows = list_data.get("rows", [])
+            normalized_public_rows = _normalize_public_record_rows(rows if isinstance(rows, list) else [])
+            lookup_payload = _build_record_list_lookup_payload(
+                query=normalized_query,
+                items=normalized_public_rows,
+                pagination=pagination,
+            )
+            total_count = _coerce_count(pagination.get("result_amount"))
+            returned_count = _coerce_count(pagination.get("returned_items"))
+            if returned_count is None:
+                returned_count = len(normalized_public_rows)
+            truncated = bool(total_count is not None and total_count > returned_count)
+            response: JSONObject = {
+                "profile": profile,
+                "ws_id": raw.get("ws_id"),
+                "ok": bool(raw.get("ok", True)),
+                "request_route": raw.get("request_route"),
+                "warnings": warnings,
+                "verification": _view_filter_verification_payload(view_route),
+                "output_profile": normalized_output_profile,
+                "data": {
+                    "app_key": app_key,
+                    "items": normalized_public_rows,
+                    "pagination": {
+                        "returned_count": returned_count,
+                        "total_count": total_count,
+                        "truncated": truncated,
+                    },
+                    "selection": {
+                        "columns": [_column_selector_payload(field_id) for field_id in resolved_columns],
+                        "query_fields": [_column_selector_payload(field_id) for field_id in resolved_query_fields],
+                        "view": _accessible_view_payload(view_route),
+                    },
                 },
-            },
-        }
-        if lookup_payload is not None:
-            response["lookup"] = lookup_payload
-        if normalized_output_profile == "normalized":
-            normalized_rows = list_data.get("normalized_rows")
-            if isinstance(normalized_rows, list):
-                item_by_apply_id = {
-                    _coerce_count(item.get("apply_id")): item
-                    for item in cast(list[JSONObject], response["data"]["items"])
-                    if isinstance(item, dict) and _coerce_count(item.get("apply_id")) is not None
-                }
-                for entry in normalized_rows:
-                    if not isinstance(entry, dict):
-                        continue
-                    apply_id = _coerce_count(entry.get("apply_id"))
-                    if apply_id is None:
-                        continue
-                    target = item_by_apply_id.get(apply_id)
-                    if target is None:
-                        continue
-                    target["normalized_record"] = cast(JSONObject, entry.get("normalized_record") or {})
-                    target["normalized_ambiguous_fields"] = cast(JSONObject, entry.get("normalized_ambiguous_fields") or {})
-        if normalized_output_profile == "verbose":
-            response["data"]["debug"] = {
-                "completeness": raw.get("completeness"),
-                "evidence": raw.get("evidence"),
-                "resolved_mappings": raw.get("resolved_mappings"),
-                "row_cap_hit": list_data.get("row_cap_hit"),
-                "sample_only": list_data.get("sample_only"),
             }
-        return response
+            if lookup_payload is not None:
+                response["lookup"] = lookup_payload
+            if normalized_output_profile == "normalized":
+                normalized_rows = list_data.get("normalized_rows")
+                if isinstance(normalized_rows, list):
+                    item_by_apply_id = {
+                        _coerce_count(item.get("apply_id")): item
+                        for item in cast(list[JSONObject], response["data"]["items"])
+                        if isinstance(item, dict) and _coerce_count(item.get("apply_id")) is not None
+                    }
+                    for entry in normalized_rows:
+                        if not isinstance(entry, dict):
+                            continue
+                        apply_id = _coerce_count(entry.get("apply_id"))
+                        if apply_id is None:
+                            continue
+                        target = item_by_apply_id.get(apply_id)
+                        if target is None:
+                            continue
+                        target["normalized_record"] = cast(JSONObject, entry.get("normalized_record") or {})
+                        target["normalized_ambiguous_fields"] = cast(JSONObject, entry.get("normalized_ambiguous_fields") or {})
+            if normalized_output_profile == "verbose":
+                response["data"]["debug"] = {
+                    "completeness": raw.get("completeness"),
+                    "evidence": raw.get("evidence"),
+                    "resolved_mappings": raw.get("resolved_mappings"),
+                    "row_cap_hit": list_data.get("row_cap_hit"),
+                    "sample_only": list_data.get("sample_only"),
+                }
+            return response
+
+        return self._run_record_tool(profile, runner)
 
     @tool_cn_name("记录访问")
     def record_access(
@@ -2152,6 +2263,130 @@ class RecordTools(ToolBase):
 
         return self._run_record_tool(profile, runner)
 
+    @tool_cn_name("记录全量日志")
+    def record_logs_get(
+        self,
+        *,
+        profile: str,
+        app_key: str,
+        record_id: Any,
+        view_id: str | None = None,
+    ) -> JSONObject:
+        """读取单条记录可见的全量数据日志和流程日志，写入本地 JSONL。"""
+        record_id_int = normalize_positive_id_int(record_id, field_name="record_id")
+
+        def runner(session_profile, context):
+            resolved_view, compatibility_warnings = self._resolve_accessible_view_route(
+                profile,
+                context,
+                app_key,
+                view_id=view_id,
+                list_type=None,
+                view_key=None,
+                view_name=None,
+                allow_default=True,
+            )
+            warnings: list[JSONObject] = []
+            warnings.extend(compatibility_warnings)
+            warnings.extend(_view_filter_trust_warnings(resolved_view))
+            unavailable_context: list[JSONObject] = []
+
+            schema = self._record_get_detail_schema(profile, context, app_key, resolved_view, force_refresh=False)
+            index = _build_top_level_field_index(schema)
+            audit_info = self._record_get_audit_info(
+                context,
+                app_key=app_key,
+                record_id=record_id_int,
+                resolved_view=resolved_view,
+            )
+            audit_context = _record_detail_audit_context(audit_info, workflow_node_id=None)
+            detail_result, used_list_type, used_role = self._record_get_apply_detail(
+                context,
+                app_key=app_key,
+                record_id=record_id_int,
+                resolved_view=resolved_view,
+                audit_node_id=cast(int | None, audit_context.get("audit_node_id")),
+            )
+            answer_list = _record_detail_answers(detail_result)
+            selected_fields = list(index.by_id.values())
+            fields = [
+                _record_detail_field_payload(field, _find_answer_for_field(cast(list[JSONValue], answer_list), field), focus_id_set=set())
+                for field in selected_fields
+            ]
+            app_name = self._record_get_detail_app_name(
+                profile,
+                context,
+                app_key=app_key,
+                schema=schema,
+                used_list_type=used_list_type,
+            )
+            view_payload = _accessible_view_payload(resolved_view)
+            record_payload = _record_detail_record_payload(
+                app_key=app_key,
+                record_id=record_id_int,
+                detail=detail_result,
+                answer_list=cast(list[JSONValue], answer_list),
+                fields=fields,
+            )
+            log_visibility = self._record_get_log_visibility_context(
+                context,
+                app_key=app_key,
+                record_id=record_id_int,
+                resolved_view=resolved_view,
+                role=used_role,
+                audit_node_id=cast(int | None, audit_context.get("audit_node_id")),
+                unavailable_context=unavailable_context,
+            )
+            run_dir = _record_logs_run_dir()
+            run_dir.mkdir(parents=True, exist_ok=True)
+            deadline = time.monotonic() + RECORD_LOGS_TIME_BUDGET_SECONDS
+            data_logs = self._record_get_full_data_logs_context(
+                context,
+                app_key=app_key,
+                record_id=record_id_int,
+                role=used_role,
+                log_visibility=log_visibility,
+                unavailable_context=unavailable_context,
+                run_dir=run_dir,
+                deadline=deadline,
+            )
+            workflow_logs = self._record_get_full_workflow_logs_context(
+                context,
+                app_key=app_key,
+                record_id=record_id_int,
+                resolved_view=resolved_view,
+                role=used_role,
+                audit_node_id=cast(int | None, audit_context.get("audit_node_id")),
+                log_visibility=log_visibility,
+                unavailable_context=unavailable_context,
+                run_dir=run_dir,
+                deadline=deadline,
+            )
+            status = _record_logs_overall_status(data_logs=data_logs, workflow_logs=workflow_logs)
+            context_integrity = _record_logs_context_integrity(data_logs=data_logs, workflow_logs=workflow_logs)
+            payload: JSONObject = {
+                "ok": True,
+                "status": status,
+                "output_profile": "record_logs",
+                "app": {"app_key": app_key, "app_name": app_name},
+                "view": view_payload,
+                "record": record_payload,
+                "local_dir": str(run_dir),
+                "data_logs": data_logs,
+                "workflow_logs": workflow_logs,
+                "warnings": warnings,
+                "unavailable_context": unavailable_context,
+                "context_integrity": context_integrity,
+            }
+            summary_path = run_dir / "summary.json"
+            summary_payload = deepcopy(payload)
+            summary_payload.pop("request_route", None)
+            summary_path.write_text(json.dumps(summary_payload, ensure_ascii=False, indent=2), encoding="utf-8")
+            payload["summary_path"] = str(summary_path)
+            return payload
+
+        return self._run_record_tool(profile, runner)
+
     def _record_get_detail_context(
         self,
         *,
@@ -2304,12 +2539,23 @@ class RecordTools(ToolBase):
             fields=fields,
             references=references,
         )
+        file_assets = self._record_get_file_assets(
+            context,
+            app_key=app_key,
+            record_id=record_id_int,
+            resolved_view=resolved_view,
+            audit_node_id=cast(int | None, audit_context.get("audit_node_id")),
+            fields=fields,
+            references=references,
+            media_assets=media_assets,
+        )
         context_integrity = _record_detail_context_integrity(
             references=references,
             data_logs=data_logs,
             workflow_logs=workflow_logs,
             associated_resources=associated_resources,
             media_assets=media_assets,
+            file_assets=file_assets,
             unavailable_context=unavailable_context,
         )
         payload: JSONObject = {
@@ -2332,6 +2578,7 @@ class RecordTools(ToolBase):
             "requested_focus_fields": [_column_selector_payload(field_id) for field_id in requested_focus_field_ids],
             "references": references,
             "media_assets": media_assets,
+            "file_assets": file_assets,
             "data_logs": data_logs,
             "workflow_logs": workflow_logs,
             "associated_resources": associated_resources,
@@ -2789,57 +3036,159 @@ class RecordTools(ToolBase):
             unavailable_context.append(_record_detail_unavailable_context("workflow_logs", "流程日志本次获取失败。", exc))
             return _record_detail_log_unavailable_payload("workflow_logs", "fetch_unavailable")
 
-    def _record_get_associated_resources(
+    def _record_get_full_data_logs_context(
         self,
         context,  # type: ignore[no-untyped-def]
         *,
         app_key: str,
-        resolved_view: AccessibleViewRoute,
+        record_id: int,
         role: int,
-        audit_node_id: int | None,
+        log_visibility: JSONObject,
         unavailable_context: list[JSONObject],
-    ) -> list[JSONObject]:
-        """执行内部辅助逻辑。"""
+        run_dir: Path,
+        deadline: float,
+    ) -> JSONObject:
+        """读取全量数据日志并写入 JSONL。"""
+        if log_visibility.get("status") == "unavailable":
+            return _record_logs_unavailable_payload("data_logs", "visibility_unavailable")
+        if log_visibility.get("data_log_visible") is False:
+            return _record_logs_hidden_payload("data_logs")
+
+        def fetch_page(page_num: int) -> JSONValue:
+            return self.backend.request(
+                "POST",
+                context,
+                f"/worksheet/data/log/{app_key}/{record_id}/page",
+                json_body={
+                    "viewChannel": log_visibility.get("channel"),
+                    "role": role,
+                    "pageNum": page_num,
+                    "pageSize": RECORD_LOGS_PAGE_SIZE,
+                },
+            )
+
         try:
-            if resolved_view.kind == "custom" and resolved_view.view_selection is not None:
-                payload = self.backend.request(
-                    "GET",
-                    context,
-                    f"/view/{app_key}/asosChart",
-                    params={
-                        "role": role,
-                        "viewgraphKey": resolved_view.view_selection.view_key,
-                        "beingConfig": False,
-                    },
-                )
-            else:
-                params: JSONObject = {"role": role, "beingDraft": False}
-                if audit_node_id is not None:
-                    params["auditNodeId"] = audit_node_id
-                payload = self.backend.request("GET", context, f"/app/{app_key}/asosChart", params=params)
+            return _record_logs_fetch_all_to_jsonl(
+                fetch_page=fetch_page,
+                normalizer=_record_detail_data_log_item,
+                source="data_logs",
+                file_path=run_dir / "data-logs.jsonl",
+                deadline=deadline,
+            )
         except QingflowApiError as exc:
-            unavailable_context.append(_record_detail_unavailable_context("associated_resources", "关联资源获取失败。", exc))
-            return []
-        return [_record_detail_associated_resource(item) for item in _record_detail_associated_resource_items(payload)]
+            unavailable_context.append(_record_detail_unavailable_context("data_logs", "全量数据日志获取失败。", exc))
+            return _record_logs_unavailable_payload("data_logs", "fetch_unavailable")
 
-    def _record_get_media_assets(
+    def _record_get_full_workflow_logs_context(
         self,
         context,  # type: ignore[no-untyped-def]
         *,
         app_key: str,
         record_id: int,
         resolved_view: AccessibleViewRoute,
+        role: int,
         audit_node_id: int | None,
-        fields: list[JSONObject],
-        references: list[JSONObject],
+        log_visibility: JSONObject,
+        unavailable_context: list[JSONObject],
+        run_dir: Path,
+        deadline: float,
     ) -> JSONObject:
-        """Collect and localize image assets that the frontend detail page can render."""
-        try:
-            def refresh_source_url(candidate: JSONObject) -> str | None:
-                return self._record_get_refreshed_media_source_url(
+        """读取全量流程日志并写入 JSONL。"""
+        if log_visibility.get("status") == "unavailable":
+            return _record_logs_unavailable_payload("workflow_logs", "visibility_unavailable")
+        if log_visibility.get("workflow_log_visible") is False:
+            return _record_logs_hidden_payload("workflow_logs")
+
+        def fetch_page(page_num: int) -> JSONValue:
+            if resolved_view.kind == "custom" and resolved_view.view_selection is not None:
+                return self.backend.request(
+                    "POST",
                     context,
-                    app_key=app_key,
-                    record_id=record_id,
+                    f"/viewGraph/{resolved_view.view_selection.view_key}/workflow/node/record",
+                    json_body={
+                        "key": resolved_view.view_selection.view_key,
+                        "rowRecordId": str(record_id),
+                        "pageNum": page_num,
+                        "pageSize": RECORD_LOGS_PAGE_SIZE,
+                    },
+                )
+            return self.backend.request(
+                "POST",
+                context,
+                "/application/workflow/node/record",
+                json_body={
+                    "key": app_key,
+                    "rowRecordId": str(record_id),
+                    "nodeId": audit_node_id,
+                    "role": role,
+                    "pageNum": page_num,
+                    "pageSize": RECORD_LOGS_PAGE_SIZE,
+                },
+            )
+
+        try:
+            return _record_logs_fetch_all_to_jsonl(
+                fetch_page=fetch_page,
+                normalizer=_record_detail_workflow_log_item,
+                source="workflow_logs",
+                file_path=run_dir / "workflow-logs.jsonl",
+                deadline=deadline,
+            )
+        except QingflowApiError as exc:
+            unavailable_context.append(_record_detail_unavailable_context("workflow_logs", "全量流程日志获取失败。", exc))
+            return _record_logs_unavailable_payload("workflow_logs", "fetch_unavailable")
+
+    def _record_get_associated_resources(
+        self,
+        context,  # type: ignore[no-untyped-def]
+        *,
+        app_key: str,
+        resolved_view: AccessibleViewRoute,
+        role: int,
+        audit_node_id: int | None,
+        unavailable_context: list[JSONObject],
+    ) -> list[JSONObject]:
+        """执行内部辅助逻辑。"""
+        try:
+            if resolved_view.kind == "custom" and resolved_view.view_selection is not None:
+                payload = self.backend.request(
+                    "GET",
+                    context,
+                    f"/view/{app_key}/asosChart",
+                    params={
+                        "role": role,
+                        "viewgraphKey": resolved_view.view_selection.view_key,
+                        "beingConfig": False,
+                    },
+                )
+            else:
+                params: JSONObject = {"role": role, "beingDraft": False}
+                if audit_node_id is not None:
+                    params["auditNodeId"] = audit_node_id
+                payload = self.backend.request("GET", context, f"/app/{app_key}/asosChart", params=params)
+        except QingflowApiError as exc:
+            unavailable_context.append(_record_detail_unavailable_context("associated_resources", "关联资源获取失败。", exc))
+            return []
+        return [_record_detail_associated_resource(item) for item in _record_detail_associated_resource_items(payload)]
+
+    def _record_get_media_assets(
+        self,
+        context,  # type: ignore[no-untyped-def]
+        *,
+        app_key: str,
+        record_id: int,
+        resolved_view: AccessibleViewRoute,
+        audit_node_id: int | None,
+        fields: list[JSONObject],
+        references: list[JSONObject],
+    ) -> JSONObject:
+        """Collect and localize image assets that the frontend detail page can render."""
+        try:
+            def refresh_source_url(candidate: JSONObject) -> str | None:
+                return self._record_get_refreshed_media_source_url(
+                    context,
+                    app_key=app_key,
+                    record_id=record_id,
                     resolved_view=resolved_view,
                     audit_node_id=audit_node_id,
                     candidate=candidate,
@@ -2867,6 +3216,53 @@ class RecordTools(ToolBase):
                 ],
             }
 
+    def _record_get_file_assets(
+        self,
+        context,  # type: ignore[no-untyped-def]
+        *,
+        app_key: str,
+        record_id: int,
+        resolved_view: AccessibleViewRoute,
+        audit_node_id: int | None,
+        fields: list[JSONObject],
+        references: list[JSONObject],
+        media_assets: JSONObject,
+    ) -> JSONObject:
+        """Collect and localize file assets from the frontend detail context."""
+        try:
+            def refresh_source_url(candidate: JSONObject) -> str | None:
+                return self._record_get_refreshed_media_source_url(
+                    context,
+                    app_key=app_key,
+                    record_id=record_id,
+                    resolved_view=resolved_view,
+                    audit_node_id=audit_node_id,
+                    candidate=candidate,
+                )
+
+            return _record_detail_file_assets_payload(
+                backend=self.backend,
+                context=context,
+                app_key=app_key,
+                record_id=record_id,
+                fields=fields,
+                references=references,
+                media_assets=media_assets,
+                refresh_source_url=refresh_source_url,
+            )
+        except Exception as exc:  # defensive: file assets should never break the core record detail.
+            return {
+                "status": "unavailable",
+                "local_dir": None,
+                "items": [],
+                "warnings": [
+                    {
+                        "code": "FILE_ASSETS_UNAVAILABLE",
+                        "message": f"record_get could not collect file assets: {exc}",
+                    }
+                ],
+            }
+
     def _record_get_refreshed_media_source_url(
         self,
         context,  # type: ignore[no-untyped-def]
@@ -2919,6 +3315,7 @@ class RecordTools(ToolBase):
         profile: str = DEFAULT_PROFILE,
         app_key: str,
         fields: JSONObject | None = None,
+        items: list[JSONObject] | None = None,
         verify_write: bool = True,
         output_profile: str = "normal",
     ) -> JSONObject:
@@ -2926,88 +3323,497 @@ class RecordTools(ToolBase):
         normalized_output_profile = self._normalize_public_output_profile(output_profile)
         if not app_key:
             raise_tool_error(QingflowApiError.config_error("app_key is required"))
+        if items is not None:
+            normalized_items = self._normalize_public_record_insert_batch_items(fields=fields, items=items)
+            return self._record_insert_public_batch(
+                profile=profile,
+                app_key=app_key,
+                items=normalized_items,
+                verify_write=verify_write,
+                output_profile=normalized_output_profile,
+            )
         if fields is not None and not isinstance(fields, dict):
             raise_tool_error(QingflowApiError.config_error("fields must be an object map keyed by field title"))
-        submit_type_value = self._normalize_record_write_submit_type("submit")
-        raw_preflight = self._preflight_record_write(
+        return self._record_insert_public_single(
             profile=profile,
-            operation="create",
             app_key=app_key,
-            apply_id=None,
-            answers=[],
             fields=cast(JSONObject, fields or {}),
-            force_refresh_form=False,
-            view_id=None,
-            list_type=None,
-            view_key=None,
-            view_name=None,
-        )
-        preflight_used_force_refresh = self._record_preflight_used_force_refresh(raw_preflight)
-        preflight_data = cast(JSONObject, raw_preflight.get("data", {}))
-        normalized_payload: JSONObject = self._record_write_normalized_payload(
-            operation="insert",
-            record_id=None,
-            record_ids=[],
-            normalized_answers=cast(list[JSONObject], preflight_data.get("normalized_answers", [])),
-            submit_type=submit_type_value,
-            selection=cast(JSONObject | None, preflight_data.get("selection") if isinstance(preflight_data.get("selection"), dict) else None),
+            verify_write=verify_write,
+            output_profile=normalized_output_profile,
+            capture_exceptions=False,
         )
-        if preflight_data.get("blockers"):
-            return self._record_write_blocked_response(
-                raw_preflight,
-                operation="insert",
-                normalized_payload=normalized_payload,
-                output_profile=normalized_output_profile,
-                human_review=False,
-                target_resource={"type": "record", "app_key": app_key, "record_id": None, "record_ids": []},
-            )
+
+    def _record_insert_public_single(
+        self,
+        *,
+        profile: str,
+        app_key: str,
+        fields: JSONObject,
+        verify_write: bool,
+        output_profile: str,
+        capture_exceptions: bool,
+    ) -> JSONObject:
+        """执行内部辅助逻辑。"""
+        submit_type_value = self._normalize_record_write_submit_type("submit")
+        write_attempted = False
         try:
-            raw_apply = self.record_create(
+            raw_preflight = self._preflight_record_write(
                 profile=profile,
+                operation="create",
                 app_key=app_key,
-                answers=cast(list[JSONObject], preflight_data.get("normalized_answers", [])),
-                fields={},
+                apply_id=None,
+                answers=[],
+                fields=fields,
+                force_refresh_form=False,
+                view_id=None,
+                list_type=None,
+                view_key=None,
+                view_name=None,
+            )
+            preflight_used_force_refresh = self._record_preflight_used_force_refresh(raw_preflight)
+            preflight_data = cast(JSONObject, raw_preflight.get("data", {}))
+            normalized_payload: JSONObject = self._record_write_normalized_payload(
+                operation="insert",
+                record_id=None,
+                record_ids=[],
+                normalized_answers=cast(list[JSONObject], preflight_data.get("normalized_answers", [])),
                 submit_type=submit_type_value,
-                verify_write=verify_write,
-                force_refresh_form=preflight_used_force_refresh,
+                selection=cast(JSONObject | None, preflight_data.get("selection") if isinstance(preflight_data.get("selection"), dict) else None),
             )
-        except QingflowApiError as exc:
-            self._raise_record_write_permission_error(
+            if preflight_data.get("blockers"):
+                return self._record_write_blocked_response(
+                    raw_preflight,
+                    operation="insert",
+                    normalized_payload=normalized_payload,
+                    output_profile=output_profile,
+                    human_review=False,
+                    target_resource={"type": "record", "app_key": app_key, "record_id": None, "record_ids": []},
+                )
+            try:
+                write_attempted = True
+                raw_apply = self.record_create(
+                    profile=profile,
+                    app_key=app_key,
+                    answers=cast(list[JSONObject], preflight_data.get("normalized_answers", [])),
+                    fields={},
+                    submit_type=submit_type_value,
+                    verify_write=verify_write,
+                    force_refresh_form=preflight_used_force_refresh,
+                )
+            except QingflowApiError as exc:
+                self._raise_record_write_permission_error(
+                    exc,
+                    operation="insert",
+                    app_key=app_key,
+                    record_id=None,
+                    selection=cast(JSONObject | None, preflight_data.get("selection") if isinstance(preflight_data.get("selection"), dict) else None),
+                )
+                raise
+            return self._record_write_apply_response(
+                raw_apply,
+                operation="insert",
+                normalized_payload=normalized_payload,
+                output_profile=output_profile,
+                human_review=False,
+                preflight=raw_preflight,
+            )
+        except (QingflowApiError, RuntimeError) as exc:
+            if not capture_exceptions:
+                raise
+            return self._record_write_exception_response(
                 exc,
                 operation="insert",
+                profile=profile,
                 app_key=app_key,
                 record_id=None,
-                selection=cast(JSONObject | None, preflight_data.get("selection") if isinstance(preflight_data.get("selection"), dict) else None),
+                output_profile=output_profile,
+                human_review=False,
+                write_executed=write_attempted,
             )
-            raise
-        return self._record_write_apply_response(
-            raw_apply,
-            operation="insert",
-            normalized_payload=normalized_payload,
-            output_profile=normalized_output_profile,
-            human_review=False,
-            preflight=raw_preflight,
-        )
 
-    @tool_cn_name("更新记录")
-    def record_update_public(
+    def _normalize_public_record_insert_batch_items(
         self,
         *,
-        profile: str = DEFAULT_PROFILE,
+        fields: JSONObject | None,
+        items: list[JSONObject] | None,
+    ) -> list[JSONObject]:
+        """执行内部辅助逻辑。"""
+        if fields is not None:
+            raise_tool_error(QingflowApiError.config_error("record_insert batch mode does not accept fields"))
+        if not isinstance(items, list) or not items:
+            raise_tool_error(QingflowApiError.config_error("items must be a non-empty list"))
+        normalized_items: list[JSONObject] = []
+        for index, item in enumerate(items):
+            if not isinstance(item, dict):
+                raise_tool_error(QingflowApiError.config_error(f"items[{index}] must be an object"))
+            item_fields = item.get("fields")
+            if not isinstance(item_fields, dict):
+                raise_tool_error(QingflowApiError.config_error(f"items[{index}].fields must be an object map keyed by field title"))
+            normalized_items.append({"fields": cast(JSONObject, item_fields)})
+        return normalized_items
+
+    def _record_insert_public_batch(
+        self,
+        *,
+        profile: str,
         app_key: str,
-        record_id: Any | None,
-        fields: JSONObject | None = None,
-        items: list[JSONObject] | None = None,
-        dry_run: bool = False,
-        verify_write: bool = True,
-        output_profile: str = "normal",
+        items: list[JSONObject],
+        verify_write: bool,
+        output_profile: str,
     ) -> JSONObject:
-        """执行记录相关逻辑。"""
-        normalized_output_profile = self._normalize_public_output_profile(output_profile)
-        if not app_key:
-            raise_tool_error(QingflowApiError.config_error("app_key is required"))
-        if items is not None:
-            if dry_run not in {True, False}:
+        """执行内部辅助逻辑。"""
+        responses: list[JSONObject] = []
+        for item in items:
+            responses.append(
+                self._record_insert_public_single(
+                    profile=profile,
+                    app_key=app_key,
+                    fields=cast(JSONObject, item["fields"]),
+                    verify_write=verify_write,
+                    output_profile=output_profile,
+                    capture_exceptions=True,
+                )
+            )
+        return self._record_insert_batch_response(
+            profile=profile,
+            app_key=app_key,
+            responses=responses,
+            output_profile=output_profile,
+        )
+
+    def _record_insert_batch_response(
+        self,
+        *,
+        profile: str,
+        app_key: str,
+        responses: list[JSONObject],
+        output_profile: str,
+    ) -> JSONObject:
+        """执行内部辅助逻辑。"""
+        items = [
+            self._record_insert_batch_item_from_response(index=index, response=response, output_profile=output_profile)
+            for index, response in enumerate(responses)
+        ]
+        summary = self._record_insert_batch_summary(items)
+        status, ok, message = self._record_insert_batch_envelope_status(summary=summary)
+        first_response = responses[0] if responses else {}
+        created_record_ids = [
+            cast(str, item["record_id"])
+            for item in items
+            if isinstance(item.get("record_id"), str) and item.get("record_id")
+        ]
+        write_executed = any(bool(item.get("write_executed")) for item in items)
+        verification_status = self._record_insert_batch_verification_status(items)
+        return {
+            "profile": first_response.get("profile", profile),
+            "ws_id": first_response.get("ws_id"),
+            "ok": ok,
+            "status": status,
+            "mode": "batch",
+            "total": summary["total"],
+            "succeeded": summary["succeeded"],
+            "failed": summary["failed"],
+            "created_record_ids": created_record_ids,
+            "write_executed": write_executed,
+            "verification_status": verification_status,
+            "safe_to_retry": not write_executed,
+            "request_route": first_response.get("request_route"),
+            "warnings": [],
+            "output_profile": output_profile,
+            "items": items,
+            "data": {
+                "app_key": app_key,
+                "mode": "batch",
+                "summary": summary,
+                "created_record_ids": created_record_ids,
+                "items": items,
+            },
+            "message": message,
+        }
+
+    def _record_insert_batch_summary(self, items: list[JSONObject]) -> JSONObject:
+        """执行内部辅助逻辑。"""
+        created = [item for item in items if isinstance(item.get("record_id"), str) and item.get("record_id")]
+        failed = [item for item in items if item.get("status") not in {"success", "verification_failed"}]
+        return {
+            "total": len(items),
+            "succeeded": len(created),
+            "failed": len(failed),
+            "created_count": len(created),
+            "blocked_count": sum(1 for item in items if item.get("status") == "blocked"),
+            "confirmation_count": sum(1 for item in items if item.get("status") == "needs_confirmation"),
+            "verification_failed_count": sum(1 for item in items if item.get("status") == "verification_failed"),
+        }
+
+    def _record_insert_batch_envelope_status(self, *, summary: JSONObject) -> tuple[str, bool, str]:
+        """执行内部辅助逻辑。"""
+        succeeded = int(summary["succeeded"])
+        failed = int(summary["failed"])
+        if succeeded and failed:
+            return "partial_success", False, "batch insert completed with partial failures"
+        if succeeded and int(summary["verification_failed_count"]):
+            return "verification_failed", True, "batch insert completed but verification failed for some created records"
+        if succeeded:
+            return "success", True, "batch insert completed"
+        if int(summary["confirmation_count"]):
+            return "needs_confirmation", False, "batch insert requires confirmation before retrying failed rows"
+        if int(summary["blocked_count"]):
+            return "blocked", False, "batch insert preflight blocked all rows"
+        return "failed", False, "batch insert failed"
+
+    def _record_insert_batch_verification_status(self, items: list[JSONObject]) -> str:
+        """执行内部辅助逻辑。"""
+        statuses = {str(item.get("verification_status") or "not_requested") for item in items}
+        if "failed" in statuses:
+            return "failed"
+        if "verified" in statuses:
+            return "verified"
+        return "not_requested"
+
+    def _record_insert_batch_item_from_response(
+        self,
+        *,
+        index: int,
+        response: JSONObject,
+        output_profile: str,
+    ) -> JSONObject:
+        """执行内部辅助逻辑。"""
+        data = cast(JSONObject, response.get("data", {})) if isinstance(response.get("data"), dict) else {}
+        resource = _public_record_resource(data.get("resource"))
+        record_id = _public_record_id_text(response.get("record_id"))
+        apply_id = _public_record_id_text(response.get("apply_id"))
+        if record_id is None and isinstance(resource, dict):
+            record_id = _public_record_id_text(resource.get("record_id"))
+        if apply_id is None and isinstance(resource, dict):
+            apply_id = _public_record_id_text(resource.get("apply_id"))
+        item: JSONObject = {
+            "index": index,
+            "row_number": index + 1,
+            "status": response.get("status"),
+            "write_executed": bool(response.get("write_executed")),
+            "verification_status": response.get("verification_status", "not_requested"),
+            "safe_to_retry": bool(response.get("safe_to_retry", True)),
+        }
+        if record_id is not None:
+            item["record_id"] = record_id
+        if apply_id is not None:
+            item["apply_id"] = apply_id
+        if resource:
+            item["resource"] = resource
+        verification = data.get("verification")
+        if isinstance(verification, dict):
+            compact_verification = {
+                key: verification[key]
+                for key in ("verified", "verification_mode", "field_level_verified")
+                if key in verification
+            }
+            if compact_verification:
+                item["verification"] = compact_verification
+        field_errors = cast(list[JSONObject], data.get("field_errors", [])) if isinstance(data.get("field_errors"), list) else []
+        confirmation_requests = cast(list[JSONObject], data.get("confirmation_requests", [])) if isinstance(data.get("confirmation_requests"), list) else []
+        failed_fields = self._record_write_failed_fields(field_errors=field_errors, confirmation_requests=confirmation_requests)
+        if failed_fields:
+            item["failed_fields"] = failed_fields
+        if confirmation_requests:
+            item["confirmation_requests"] = [
+                self._record_write_semantic_confirmation_request(request)
+                for request in confirmation_requests
+                if isinstance(request, dict)
+            ]
+        blockers = data.get("blockers")
+        if isinstance(blockers, list) and blockers:
+            item["blockers"] = blockers
+        warnings = response.get("warnings")
+        if isinstance(warnings, list) and warnings:
+            item["warnings"] = warnings
+        error = data.get("error")
+        if isinstance(error, dict):
+            item["error"] = error
+        if output_profile == "verbose" and isinstance(data.get("debug"), dict):
+            item["debug"] = data.get("debug")
+        return item
+
+    def _record_write_failed_fields(
+        self,
+        *,
+        field_errors: list[JSONObject],
+        confirmation_requests: list[JSONObject],
+    ) -> list[JSONObject]:
+        """执行内部辅助逻辑。"""
+        failed_fields = [
+            self._record_write_semantic_field_error(error)
+            for error in field_errors
+            if isinstance(error, dict)
+        ]
+        failed_fields.extend(
+            self._record_write_failed_field_from_confirmation(request)
+            for request in confirmation_requests
+            if isinstance(request, dict)
+        )
+        return failed_fields
+
+    def _record_write_semantic_field_error(self, error: JSONObject) -> JSONObject:
+        """执行内部辅助逻辑。"""
+        field = error.get("field")
+        field_payload = cast(JSONObject, field) if isinstance(field, dict) else {}
+        error_code = _normalize_optional_text(error.get("error_code")) or "INVALID_FIELD_VALUE"
+        title = (
+            _normalize_optional_text(field_payload.get("que_title"))
+            or _normalize_optional_text(field_payload.get("title"))
+            or _normalize_optional_text(error.get("location"))
+            or "unknown field"
+        )
+        field_id = (
+            field_payload.get("que_id")
+            if field_payload.get("que_id") is not None
+            else field_payload.get("field_id")
+        )
+        expected_format = error.get("expected_format") if isinstance(error.get("expected_format"), dict) else None
+        if expected_format is None:
+            expected_format = self._record_write_expected_format_from_field_payload(field_payload)
+        payload: JSONObject = {
+            "title": title,
+            "field_id": field_id,
+            "error_code": error_code,
+            "message": self._record_write_semantic_error_message(error_code, error.get("message")),
+            "next_action": self._record_write_next_action_for_error(error_code),
+        }
+        if expected_format is not None:
+            payload["expected_format"] = expected_format
+            payload["example_value"] = self._record_write_example_value_for_format(expected_format, field_payload)
+        if error.get("received_value") is not None:
+            payload["received_value"] = error.get("received_value")
+        if error.get("fix_hint") is not None:
+            payload["fix_hint"] = error.get("fix_hint")
+        if error.get("details") is not None:
+            payload["details"] = error.get("details")
+        return payload
+
+    def _record_write_semantic_confirmation_request(self, request: JSONObject) -> JSONObject:
+        """执行内部辅助逻辑。"""
+        field_ref = request.get("field_ref")
+        field_payload = cast(JSONObject, field_ref) if isinstance(field_ref, dict) else {}
+        payload: JSONObject = {
+            "field": request.get("field"),
+            "title": _normalize_optional_text(request.get("field")) or _normalize_optional_text(field_payload.get("que_title")),
+            "field_id": field_payload.get("que_id"),
+            "kind": request.get("kind"),
+            "input": request.get("input"),
+            "candidates": request.get("candidates", []),
+            "next_action": "让用户确认候选，或用显式 id/object 只重试本行。",
+        }
+        if request.get("parent_field") is not None:
+            payload["parent_field"] = request.get("parent_field")
+        if request.get("row_ordinal") is not None:
+            payload["row_ordinal"] = request.get("row_ordinal")
+        return payload
+
+    def _record_write_failed_field_from_confirmation(self, request: JSONObject) -> JSONObject:
+        """执行内部辅助逻辑。"""
+        semantic = self._record_write_semantic_confirmation_request(request)
+        return {
+            "title": semantic.get("title") or semantic.get("field"),
+            "field_id": semantic.get("field_id"),
+            "error_code": "LOOKUP_NEEDS_CONFIRMATION",
+            "message": "候选不唯一，需要用户确认。",
+            "kind": semantic.get("kind"),
+            "input": semantic.get("input"),
+            "candidates": semantic.get("candidates", []),
+            "next_action": semantic.get("next_action"),
+        }
+
+    def _record_write_expected_format_from_field_payload(self, field_payload: JSONObject) -> JSONObject | None:
+        """执行内部辅助逻辑。"""
+        que_type = _coerce_count(field_payload.get("que_type"))
+        if que_type is None:
+            return None
+        synthetic_field = FormField(
+            que_id=_coerce_count(field_payload.get("que_id")) or 0,
+            que_title=_normalize_optional_text(field_payload.get("que_title")) or _normalize_optional_text(field_payload.get("title")) or "",
+            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={},
+        )
+        return _write_format_for_field(synthetic_field)
+
+    def _record_write_example_value_for_format(self, expected_format: JSONObject, field_payload: JSONObject) -> JSONValue:
+        """执行内部辅助逻辑。"""
+        examples = expected_format.get("examples")
+        if isinstance(examples, list) and examples:
+            return cast(JSONValue, examples[0])
+        kind = _normalize_optional_text(expected_format.get("kind"))
+        if kind == "member_list":
+            return "张三"
+        if kind == "department_list":
+            return "直销部"
+        if kind == "relation_record":
+            return {"apply_id": "5001"}
+        if kind == "attachment_list":
+            return {"value": "<file_upload_local 返回的 value/url>", "name": "example.pdf"}
+        if kind == "subtable_rows":
+            return {"rows": [{"子字段": "值"}]}
+        if kind == "date_string":
+            return "2026-03-13 10:00:00"
+        if kind == "boolean_label":
+            return "是"
+        if kind in {"single_select", "multi_select"}:
+            options = expected_format.get("options")
+            if isinstance(options, list) and options:
+                return cast(JSONValue, options[0])
+        que_type = _coerce_count(field_payload.get("que_type"))
+        if que_type in NUMBER_QUE_TYPES:
+            return 100
+        return "文本"
+
+    def _record_write_semantic_error_message(self, error_code: str, fallback: JSONValue) -> str:
+        """执行内部辅助逻辑。"""
+        if error_code == "MISSING_REQUIRED_FIELD":
+            return "缺少必填字段。"
+        if error_code == "FIELD_NOT_FOUND":
+            return "字段不存在或字段标题不匹配。"
+        if error_code == "AMBIGUOUS_FIELD":
+            return "字段标题存在歧义。"
+        if error_code in {"INVALID_FIELD_VALUE", "INVALID_MEMBER_VALUE", "INVALID_DEPARTMENT_VALUE", "INVALID_RELATION_VALUE"}:
+            return _normalize_optional_text(fallback) or "字段值格式不正确。"
+        return _normalize_optional_text(fallback) or "字段写入失败。"
+
+    def _record_write_next_action_for_error(self, error_code: str) -> str:
+        """执行内部辅助逻辑。"""
+        if error_code == "MISSING_REQUIRED_FIELD":
+            return "补充该字段后只重试本行。"
+        if error_code in {"FIELD_NOT_FOUND", "AMBIGUOUS_FIELD"}:
+            return "重新调用 schema 工具确认字段标题或 field_id 后，只重试本行。"
+        return "修正该字段值后只重试本行。"
+
+    @tool_cn_name("更新记录")
+    def record_update_public(
+        self,
+        *,
+        profile: str = DEFAULT_PROFILE,
+        app_key: str,
+        record_id: Any | None,
+        fields: JSONObject | None = None,
+        items: list[JSONObject] | None = None,
+        dry_run: bool = False,
+        verify_write: bool = True,
+        output_profile: str = "normal",
+    ) -> JSONObject:
+        """执行记录相关逻辑。"""
+        normalized_output_profile = self._normalize_public_output_profile(output_profile)
+        if not app_key:
+            raise_tool_error(QingflowApiError.config_error("app_key is required"))
+        if items is not None:
+            if dry_run not in {True, False}:
                 raise_tool_error(QingflowApiError.config_error("dry_run must be boolean"))
             normalized_items = self._normalize_public_record_update_batch_items(
                 record_id=record_id,
@@ -3022,87 +3828,736 @@ class RecordTools(ToolBase):
                 verify_write=verify_write,
                 output_profile=normalized_output_profile,
             )
-        if dry_run:
-            raise_tool_error(QingflowApiError.config_error("dry_run currently requires items"))
-        if record_id is None:
-            raise_tool_error(QingflowApiError.config_error("record_id is required"))
-        record_id_int = normalize_positive_id_int(record_id, field_name="record_id")
-        if fields is not None and not isinstance(fields, dict):
-            raise_tool_error(QingflowApiError.config_error("fields must be an object map keyed by field title"))
-        return self._record_update_public_single(
-            profile=profile,
-            app_key=app_key,
-            record_id=record_id_int,
-            fields=cast(JSONObject, fields or {}),
-            verify_write=verify_write,
-            output_profile=normalized_output_profile,
-        )
+        if dry_run:
+            raise_tool_error(QingflowApiError.config_error("dry_run currently requires items"))
+        if record_id is None:
+            raise_tool_error(QingflowApiError.config_error("record_id is required"))
+        record_id_int = normalize_positive_id_int(record_id, field_name="record_id")
+        if fields is not None and not isinstance(fields, dict):
+            raise_tool_error(QingflowApiError.config_error("fields must be an object map keyed by field title"))
+        return self._record_update_public_single(
+            profile=profile,
+            app_key=app_key,
+            record_id=record_id_int,
+            fields=cast(JSONObject, fields or {}),
+            verify_write=verify_write,
+            output_profile=normalized_output_profile,
+        )
+
+    def _record_update_public_single(
+        self,
+        *,
+        profile: str,
+        app_key: str,
+        record_id: int,
+        fields: JSONObject,
+        verify_write: bool,
+        output_profile: str,
+    ) -> JSONObject:
+        """执行内部辅助逻辑。"""
+        raw_preflight = self._preflight_record_update_with_auto_view(
+            profile=profile,
+            app_key=app_key,
+            record_id=record_id,
+            fields=fields,
+            force_refresh_form=False,
+        )
+        preflight_used_force_refresh = self._record_preflight_used_force_refresh(raw_preflight)
+        preflight_data = cast(JSONObject, raw_preflight.get("data", {}))
+        normalized_payload = self._record_write_normalized_payload(
+            operation="update",
+            record_id=record_id,
+            record_ids=[],
+            normalized_answers=cast(list[JSONObject], preflight_data.get("normalized_answers", [])),
+            submit_type=1,
+            selection=cast(JSONObject | None, preflight_data.get("selection") if isinstance(preflight_data.get("selection"), dict) else None),
+        )
+        if preflight_data.get("blockers"):
+            return self._record_write_blocked_response(
+                raw_preflight,
+                operation="update",
+                normalized_payload=normalized_payload,
+                output_profile=output_profile,
+                human_review=True,
+                target_resource={"type": "record", "app_key": app_key, "record_id": record_id, "record_ids": []},
+            )
+        route_apply, tried_routes, route_blocker = self._record_update_apply_with_auto_route(
+            profile=profile,
+            app_key=app_key,
+            record_id=record_id,
+            normalized_answers=cast(list[JSONObject], preflight_data.get("normalized_answers", [])),
+            preflight_data=preflight_data,
+            verify_write=verify_write,
+            force_refresh_form=preflight_used_force_refresh,
+        )
+        if route_blocker is not None:
+            return self._record_update_route_blocked_response(
+                raw_preflight=raw_preflight,
+                operation="update",
+                normalized_payload=normalized_payload,
+                output_profile=output_profile,
+                human_review=True,
+                app_key=app_key,
+                record_id=record_id,
+                tried_routes=tried_routes,
+                route_blocker=route_blocker,
+            )
+        raw_apply = cast(JSONObject, route_apply)
+        return self._record_write_apply_response(
+            raw_apply,
+            operation="update",
+            normalized_payload=normalized_payload,
+            output_profile=output_profile,
+            human_review=True,
+            preflight=raw_preflight,
+        )
+
+    def _record_update_apply_with_auto_route(
+        self,
+        *,
+        profile: str,
+        app_key: str,
+        record_id: int,
+        normalized_answers: list[JSONObject],
+        preflight_data: JSONObject,
+        verify_write: bool,
+        force_refresh_form: bool,
+    ) -> tuple[JSONObject | None, list[JSONObject], JSONObject | None]:
+        """Try record update routes in the same order a frontend user would expect."""
+        tried_routes: list[JSONObject] = []
+        admin_attempt = self._record_update_route_attempt(
+            route_type="admin_direct",
+            endpoint_kind="app_apply_update",
+            role=1,
+            reason="try data-manager direct edit first",
+        )
+        try:
+            raw_apply = self.record_update(
+                profile=profile,
+                app_key=app_key,
+                apply_id=record_id,
+                answers=normalized_answers,
+                fields={},
+                role=1,
+                verify_write=verify_write,
+                force_refresh_form=force_refresh_form,
+            )
+            admin_attempt["status"] = "success"
+            raw_apply["update_route"] = self._record_update_route_public(admin_attempt)
+            raw_apply["tried_routes"] = [admin_attempt]
+            return raw_apply, [admin_attempt], None
+        except (QingflowApiError, RuntimeError) as exc:
+            api_error = self._record_update_extract_api_error(exc)
+            if api_error is None or not self._record_update_route_permission_denied(api_error):
+                raise
+            admin_attempt.update(self._record_update_route_error_payload(
+                api_error,
+                status="denied",
+                error_code="ADMIN_UPDATE_PERMISSION_DENIED",
+            ))
+            tried_routes.append(admin_attempt)
+
+        view_route = self._record_update_selected_custom_view_route(preflight_data)
+        if view_route is None:
+            tried_routes.append(
+                self._record_update_route_attempt(
+                    route_type="view_edit",
+                    endpoint_kind="view_apply_update",
+                    status="skipped",
+                    error_code="VIEW_UPDATE_ROUTE_NOT_AVAILABLE",
+                    reason="preflight did not select a single custom view route for this payload",
+                )
+            )
+        else:
+            view_attempt = self._record_update_route_attempt(
+                route_type="view_edit",
+                endpoint_kind="view_apply_update",
+                view_id=cast(str, view_route.get("view_id")),
+                view_key=cast(str, view_route.get("view_key")),
+                view_name=_normalize_optional_text(view_route.get("name")),
+                reason="fallback to frontend custom-view detail edit route",
+            )
+            try:
+                raw_apply = self._record_update_via_custom_view(
+                    profile=profile,
+                    app_key=app_key,
+                    apply_id=record_id,
+                    view_key=cast(str, view_route["view_key"]),
+                    answers=normalized_answers,
+                    verify_write=verify_write,
+                    force_refresh_form=force_refresh_form,
+                )
+                view_attempt["status"] = "success"
+                tried_routes.append(view_attempt)
+                raw_apply["update_route"] = self._record_update_route_public(view_attempt)
+                raw_apply["tried_routes"] = tried_routes
+                return raw_apply, tried_routes, None
+            except (QingflowApiError, RuntimeError) as exc:
+                api_error = self._record_update_extract_api_error(exc)
+                if api_error is None or not self._record_update_route_permission_denied(api_error):
+                    raise
+                view_attempt.update(self._record_update_route_error_payload(
+                    api_error,
+                    status="denied",
+                    error_code="VIEW_UPDATE_PERMISSION_DENIED",
+                ))
+                tried_routes.append(view_attempt)
+
+        task_route = self._record_update_task_save_only_candidate(
+            profile=profile,
+            app_key=app_key,
+            record_id=record_id,
+            normalized_answers=normalized_answers,
+        )
+        task_attempt = cast(JSONObject, task_route.get("attempt") if isinstance(task_route.get("attempt"), dict) else {})
+        if not task_route.get("available"):
+            tried_routes.append(task_attempt or self._record_update_route_attempt(
+                route_type="task_save_only",
+                endpoint_kind="workflow_node_save_only",
+                status="skipped",
+                error_code="TASK_UPDATE_ROUTE_NOT_AVAILABLE",
+                reason="no unique current-user todo task can edit the requested fields",
+            ))
+        else:
+            task_attempt = self._record_update_route_attempt(
+                route_type="task_save_only",
+                endpoint_kind="workflow_node_save_only",
+                role=3,
+                task_id=_normalize_optional_text(task_route.get("task_id")),
+                workflow_node_id=_coerce_count(task_route.get("workflow_node_id")),
+                reason="fallback to current-user workflow todo save-only route",
+            )
+            try:
+                raw_apply = self._record_update_via_task_save_only(
+                    profile=profile,
+                    app_key=app_key,
+                    apply_id=record_id,
+                    workflow_node_id=cast(int, task_route["workflow_node_id"]),
+                    answers=normalized_answers,
+                    verify_write=verify_write,
+                    force_refresh_form=force_refresh_form,
+                )
+                task_attempt["status"] = "success"
+                tried_routes.append(task_attempt)
+                raw_apply["update_route"] = self._record_update_route_public(task_attempt)
+                raw_apply["tried_routes"] = tried_routes
+                return raw_apply, tried_routes, None
+            except (QingflowApiError, RuntimeError) as exc:
+                api_error = self._record_update_extract_api_error(exc)
+                if api_error is None or not self._record_update_route_permission_denied(api_error):
+                    raise
+                task_attempt.update(self._record_update_route_error_payload(
+                    api_error,
+                    status="denied",
+                    error_code="TASK_UPDATE_PERMISSION_DENIED",
+                ))
+                tried_routes.append(task_attempt)
+        return None, tried_routes, {
+            "error_code": "NO_AVAILABLE_UPDATE_ROUTE",
+            "message": "No available record update route could execute this payload for the current user.",
+            "recommended_next_actions": [
+                "If this user should edit the record as a data manager, grant data edit permission and retry record_update.",
+                "If the record is editable from a specific table view in the UI, make sure the target fields are visible and editable in that view.",
+                "If this is workflow work, use task_list -> task_get -> task_action_execute(action='save_only') with the current task context.",
+            ],
+        }
+
+    def _record_update_selected_custom_view_route(self, preflight_data: JSONObject) -> JSONObject | None:
+        selection = preflight_data.get("selection")
+        if not isinstance(selection, dict):
+            return None
+        view = selection.get("view")
+        if not isinstance(view, dict):
+            return None
+        view_id = _normalize_optional_text(view.get("view_id"))
+        if not view_id or not view_id.startswith("custom:"):
+            return None
+        view_key = _normalize_optional_text(view.get("view_key")) or view_id.split(":", 1)[1].strip()
+        if not view_key:
+            return None
+        return {
+            "view_id": view_id,
+            "view_key": view_key,
+            "name": view.get("name"),
+        }
+
+    def _record_update_route_attempt(
+        self,
+        *,
+        route_type: str,
+        endpoint_kind: str,
+        status: str = "attempted",
+        role: int | None = None,
+        task_id: str | None = None,
+        workflow_node_id: int | None = None,
+        view_id: str | None = None,
+        view_key: str | None = None,
+        view_name: str | None = None,
+        error_code: str | None = None,
+        reason: str | None = None,
+    ) -> JSONObject:
+        payload: JSONObject = {
+            "route_type": route_type,
+            "endpoint_kind": endpoint_kind,
+            "status": status,
+        }
+        if role is not None:
+            payload["role"] = role
+        if task_id:
+            payload["task_id"] = task_id
+        if workflow_node_id is not None:
+            payload["workflow_node_id"] = workflow_node_id
+        if view_id:
+            payload["view_id"] = view_id
+        if view_key:
+            payload["view_key"] = view_key
+        if view_name:
+            payload["view_name"] = view_name
+        if error_code:
+            payload["error_code"] = error_code
+        if reason:
+            payload["reason"] = reason
+        return payload
+
+    def _record_update_route_public(self, attempt: JSONObject) -> JSONObject:
+        return _pick_route_payload(attempt)
+
+    def _record_update_route_error_payload(
+        self,
+        exc: QingflowApiError,
+        *,
+        status: str,
+        error_code: str,
+    ) -> JSONObject:
+        payload: JSONObject = {
+            "status": status,
+            "error_code": error_code,
+            "message": exc.message,
+        }
+        if exc.backend_code is not None:
+            payload["backend_code"] = exc.backend_code
+        if exc.http_status is not None:
+            payload["http_status"] = exc.http_status
+        if exc.request_id is not None:
+            payload["request_id"] = exc.request_id
+        return payload
+
+    def _record_update_extract_api_error(self, exc: QingflowApiError | RuntimeError) -> QingflowApiError | None:
+        if isinstance(exc, QingflowApiError):
+            return exc
+        try:
+            payload = json.loads(str(exc))
+        except json.JSONDecodeError:
+            return None
+        if not isinstance(payload, dict):
+            return None
+        return QingflowApiError(
+            category=str(payload.get("category") or "backend"),
+            message=str(payload.get("message") or exc),
+            backend_code=payload.get("backend_code"),
+            request_id=_normalize_optional_text(payload.get("request_id")),
+            http_status=_coerce_count(payload.get("http_status")),
+            details=cast(JSONObject | None, payload.get("details") if isinstance(payload.get("details"), dict) else None),
+        )
+
+    def _record_update_route_permission_denied(self, exc: QingflowApiError) -> bool:
+        if exc.backend_code in {40002, 40027, 40038, 404}:
+            return True
+        if exc.http_status == 404:
+            return True
+        return False
+
+    def _record_update_route_blocked_response(
+        self,
+        *,
+        raw_preflight: JSONObject,
+        operation: str,
+        normalized_payload: JSONObject,
+        output_profile: str,
+        human_review: bool,
+        app_key: str,
+        record_id: int,
+        tried_routes: list[JSONObject],
+        route_blocker: JSONObject,
+    ) -> JSONObject:
+        plan_data = cast(JSONObject, raw_preflight.get("data", {}))
+        validation = cast(JSONObject, plan_data.get("validation", {}))
+        warnings_payload = validation.get("warnings", [])
+        warnings = [{"code": "PREFLIGHT_WARNING", "message": str(item)} for item in warnings_payload] if isinstance(warnings_payload, list) else []
+        warnings.append(
+            {
+                "code": cast(str, route_blocker.get("error_code") or "NO_AVAILABLE_UPDATE_ROUTE"),
+                "message": cast(str, route_blocker.get("message") or "No update route could execute the write."),
+            }
+        )
+        recommended = list(route_blocker.get("recommended_next_actions") or [])
+        response: JSONObject = {
+            "profile": raw_preflight.get("profile"),
+            "ws_id": raw_preflight.get("ws_id"),
+            "ok": False,
+            "status": "blocked",
+            "write_executed": False,
+            "verification_status": "not_requested",
+            "safe_to_retry": True,
+            "request_route": raw_preflight.get("request_route"),
+            "warnings": warnings,
+            "output_profile": output_profile,
+            "update_route": None,
+            "tried_routes": tried_routes,
+            "error_code": route_blocker.get("error_code"),
+            "data": {
+                "action": {"operation": operation, "executed": False},
+                "resource": {"type": "record", "app_key": app_key, "record_id": stringify_backend_id(record_id), "record_ids": []},
+                "verification": None,
+                "normalized_payload": normalized_payload,
+                "blockers": [route_blocker.get("error_code") or "NO_AVAILABLE_UPDATE_ROUTE"],
+                "field_errors": [],
+                "confirmation_requests": [],
+                "resolved_fields": cast(list[JSONObject], plan_data.get("lookup_resolved_fields", [])),
+                "recommended_next_actions": recommended,
+                "human_review": self._record_write_human_review_payload(operation, enabled=human_review),
+                "error": route_blocker,
+                "update_route": None,
+                "tried_routes": tried_routes,
+            },
+        }
+        if output_profile == "verbose":
+            response["data"]["debug"] = {"preflight": plan_data}
+        return response
+
+    def _record_update_task_save_only_candidate(
+        self,
+        *,
+        profile: str,
+        app_key: str,
+        record_id: int,
+        normalized_answers: list[JSONObject],
+    ) -> JSONObject:
+        requested_question_ids = self._record_update_answer_question_ids(normalized_answers)
+
+        def unavailable(*, status: str = "skipped", error_code: str, reason: str, extra: JSONObject | None = None) -> JSONObject:
+            attempt = self._record_update_route_attempt(
+                route_type="task_save_only",
+                endpoint_kind="workflow_node_save_only",
+                status=status,
+                error_code=error_code,
+                reason=reason,
+            )
+            if extra:
+                attempt.update(extra)
+            return {"available": False, "attempt": attempt}
+
+        def runner(session_profile, context):
+            matches: list[JSONObject] = []
+            pages_scanned = 0
+            for page_num in range(1, VERIFY_TASK_FALLBACK_MAX_PAGES + 1):
+                try:
+                    task_page = self.backend.request(
+                        "POST",
+                        context,
+                        "/task/dynamic/page",
+                        json_body={
+                            "type": 1,
+                            "processStatus": 1,
+                            "appKey": app_key,
+                            "pageNum": page_num,
+                            "pageSize": VERIFY_TASK_FALLBACK_PAGE_SIZE,
+                        },
+                    )
+                except QingflowApiError as exc:
+                    return unavailable(
+                        error_code="TASK_UPDATE_ROUTE_NOT_AVAILABLE",
+                        reason="current-user todo task list is unavailable",
+                        extra=self._record_update_route_error_payload(
+                            exc,
+                            status="skipped",
+                            error_code="TASK_UPDATE_ROUTE_NOT_AVAILABLE",
+                        ),
+                    )
+                pages_scanned += 1
+                rows = task_page.get("list") if isinstance(task_page, dict) else None
+                items = [item for item in rows if isinstance(item, dict)] if isinstance(rows, list) else []
+                for item in items:
+                    candidate_record_id = _coerce_count(item.get("rowRecordId") or item.get("recordId") or item.get("applyId"))
+                    if candidate_record_id == record_id:
+                        matches.append(dict(item))
+                if not _page_has_more(cast(JSONObject, task_page if isinstance(task_page, dict) else {}), page_num, VERIFY_TASK_FALLBACK_PAGE_SIZE, len(items)):
+                    break
+
+            if not matches:
+                return unavailable(
+                    error_code="TASK_UPDATE_ROUTE_NOT_AVAILABLE",
+                    reason="no current-user todo task was found for this record",
+                    extra={"pages_scanned": pages_scanned},
+                )
+            if len(matches) > 1:
+                return unavailable(
+                    error_code="TASK_UPDATE_ROUTE_AMBIGUOUS",
+                    reason="multiple current-user todo tasks match this record; refusing to guess workflow context",
+                    extra={"matched_tasks": [self._record_update_compact_task_match(item) for item in matches[:5]]},
+                )
+
+            task = matches[0]
+            workflow_node_id = _coerce_count(task.get("nodeId") or task.get("auditNodeId"))
+            if workflow_node_id is None:
+                return unavailable(
+                    error_code="TASK_UPDATE_ROUTE_NOT_AVAILABLE",
+                    reason="matched todo task does not expose a workflow node id",
+                    extra={"matched_task": self._record_update_compact_task_match(task)},
+                )
+            try:
+                editable_payload = self.backend.request(
+                    "GET",
+                    context,
+                    f"/app/{app_key}/auditNode/{workflow_node_id}/editableQueIds",
+                )
+            except QingflowApiError as exc:
+                return unavailable(
+                    error_code="TASK_EDITABLE_FIELDS_UNAVAILABLE",
+                    reason="workflow node editable field list is unavailable; record_update will not guess task editability",
+                    extra=self._record_update_route_error_payload(
+                        exc,
+                        status="skipped",
+                        error_code="TASK_EDITABLE_FIELDS_UNAVAILABLE",
+                    ),
+                )
+            editable_question_ids = self._record_update_extract_question_ids(editable_payload)
+            if not editable_question_ids:
+                return unavailable(
+                    error_code="TASK_UPDATE_ROUTE_NOT_AVAILABLE",
+                    reason="workflow node editable field list is empty",
+                    extra={
+                        "task_id": stringify_backend_id(task.get("id") or task.get("taskId")),
+                        "workflow_node_id": workflow_node_id,
+                    },
+                )
+            effective_editable_question_ids = self._record_update_effective_task_editable_ids(
+                editable_question_ids,
+                normalized_answers=normalized_answers,
+            )
+            non_editable = sorted(
+                question_id for question_id in requested_question_ids
+                if question_id not in effective_editable_question_ids
+            )
+            if non_editable:
+                return unavailable(
+                    status="denied",
+                    error_code="TASK_UPDATE_FIELD_NOT_EDITABLE",
+                    reason="one or more requested fields are not editable on the current workflow node",
+                    extra={
+                        "task_id": stringify_backend_id(task.get("id") or task.get("taskId")),
+                        "workflow_node_id": workflow_node_id,
+                        "non_editable_question_ids": non_editable,
+                    },
+                )
+            return {
+                "available": True,
+                "task_id": stringify_backend_id(task.get("id") or task.get("taskId")),
+                "workflow_node_id": workflow_node_id,
+                "matched_task": self._record_update_compact_task_match(task),
+                "editable_question_ids": sorted(editable_question_ids),
+                "effective_editable_question_ids": sorted(effective_editable_question_ids),
+            }
+
+        return self._run_record_tool(profile, runner)
+
+    def _record_update_compact_task_match(self, item: JSONObject) -> JSONObject:
+        return {
+            key: value
+            for key, value in {
+                "task_id": stringify_backend_id(item.get("id") or item.get("taskId")),
+                "record_id": stringify_backend_id(item.get("rowRecordId") or item.get("recordId") or item.get("applyId")),
+                "workflow_node_id": item.get("nodeId") or item.get("auditNodeId"),
+                "workflow_node_name": item.get("nodeName") or item.get("auditNodeName"),
+            }.items()
+            if value not in (None, "", [], {})
+        }
+
+    def _record_update_answer_question_ids(self, answers: list[JSONObject]) -> set[int]:
+        question_ids: set[int] = set()
+        for answer in answers:
+            if not isinstance(answer, dict):
+                continue
+            que_id = _coerce_count(answer.get("queId"))
+            if que_id is not None and que_id > 0:
+                question_ids.add(que_id)
+            table_values = answer.get("tableValues")
+            if not isinstance(table_values, list):
+                continue
+            for row in table_values:
+                if not isinstance(row, list):
+                    continue
+                for cell in row:
+                    if not isinstance(cell, dict):
+                        continue
+                    cell_que_id = _coerce_count(cell.get("queId"))
+                    if cell_que_id is not None and cell_que_id > 0:
+                        question_ids.add(cell_que_id)
+        return question_ids
+
+    def _record_update_extract_question_ids(self, payload: JSONValue) -> set[int]:
+        candidates: list[Any] = []
+        if isinstance(payload, list):
+            candidates = payload
+        elif isinstance(payload, dict):
+            for key in ("editableQueIds", "editableQuestionIds", "queIds", "questionIds", "ids", "list", "result"):
+                value = payload.get(key)
+                if isinstance(value, list):
+                    candidates = value
+                    break
+        question_ids: set[int] = set()
+        for item in candidates:
+            value: Any = item
+            if isinstance(item, dict):
+                value = item.get("queId", item.get("questionId", item.get("id")))
+            que_id = _coerce_count(value)
+            if que_id is not None and que_id > 0:
+                question_ids.add(que_id)
+        return question_ids
+
+    def _record_update_effective_task_editable_ids(
+        self,
+        editable_question_ids: set[int],
+        *,
+        normalized_answers: list[JSONObject],
+    ) -> set[int]:
+        effective_editable_ids = set(editable_question_ids)
+        for answer in normalized_answers:
+            if not isinstance(answer, dict):
+                continue
+            parent_que_id = _coerce_count(answer.get("queId"))
+            if parent_que_id is None or parent_que_id <= 0:
+                continue
+            table_values = answer.get("tableValues")
+            if not isinstance(table_values, list) or not table_values:
+                continue
+            row_subfield_ids: set[int] = set()
+            for row in table_values:
+                if not isinstance(row, list):
+                    continue
+                for cell in row:
+                    if not isinstance(cell, dict):
+                        continue
+                    cell_que_id = _coerce_count(cell.get("queId"))
+                    if cell_que_id is not None and cell_que_id > 0:
+                        row_subfield_ids.add(cell_que_id)
+            if row_subfield_ids & editable_question_ids:
+                effective_editable_ids.add(parent_que_id)
+        return effective_editable_ids
+
+    def _record_update_via_custom_view(
+        self,
+        *,
+        profile: str,
+        app_key: str,
+        apply_id: int,
+        view_key: str,
+        answers: list[JSONObject],
+        verify_write: bool,
+        force_refresh_form: bool,
+    ) -> JSONObject:
+        normalized_apply_id = self._validate_app_and_record(app_key, apply_id)
+        normalized_view_key = view_key.strip()
+        if not normalized_view_key:
+            raise_tool_error(QingflowApiError.config_error("view_key is required for custom view update"))
+
+        def runner(session_profile, context):
+            index = self._get_field_index(profile, context, app_key, force_refresh=force_refresh_form) if verify_write else None
+            normalized_answers = [dict(item) for item in answers if isinstance(item, dict)]
+            self._validate_record_write(app_key, normalized_answers, apply_id=normalized_apply_id)
+            result = self.backend.request(
+                "POST",
+                context,
+                f"/view/{normalized_view_key}/apply/{normalized_apply_id}",
+                json_body={"answers": normalized_answers},
+            )
+            verification = self._verify_record_write_result(
+                context,
+                app_key=app_key,
+                apply_id=normalized_apply_id,
+                normalized_answers=normalized_answers,
+                index=cast(FieldIndex, index),
+                verify_view_key=normalized_view_key,
+            ) if verify_write and index is not None else None
+            verified = True if verification is None else bool(verification.get("verified"))
+            return self._attach_human_review_notice(
+                {
+                    "profile": profile,
+                    "ws_id": session_profile.selected_ws_id,
+                    "request_route": self._request_route_payload(context),
+                    "app_key": app_key,
+                    "apply_id": normalized_apply_id,
+                    "record_id": normalized_apply_id,
+                    "result": result,
+                    "normalized_answers": normalized_answers,
+                    "status": "completed" if verified else "verification_failed",
+                    "ok": True,
+                    "verify_write": verify_write,
+                    "write_verified": verified if verify_write else None,
+                    "verification": verification,
+                    "resource": _record_resource_payload(normalized_apply_id),
+                },
+                operation="update",
+                target="record data",
+            )
 
-    def _record_update_public_single(
+        return self._run_record_tool(profile, runner)
+
+    def _record_update_via_task_save_only(
         self,
         *,
         profile: str,
         app_key: str,
-        record_id: int,
-        fields: JSONObject,
+        apply_id: int,
+        workflow_node_id: int,
+        answers: list[JSONObject],
         verify_write: bool,
-        output_profile: str,
+        force_refresh_form: bool,
     ) -> JSONObject:
-        """执行内部辅助逻辑。"""
-        raw_preflight = self._preflight_record_update_with_auto_view(
-            profile=profile,
-            app_key=app_key,
-            record_id=record_id,
-            fields=fields,
-            force_refresh_form=False,
-        )
-        preflight_used_force_refresh = self._record_preflight_used_force_refresh(raw_preflight)
-        preflight_data = cast(JSONObject, raw_preflight.get("data", {}))
-        normalized_payload = self._record_write_normalized_payload(
-            operation="update",
-            record_id=record_id,
-            record_ids=[],
-            normalized_answers=cast(list[JSONObject], preflight_data.get("normalized_answers", [])),
-            submit_type=1,
-            selection=cast(JSONObject | None, preflight_data.get("selection") if isinstance(preflight_data.get("selection"), dict) else None),
-        )
-        if preflight_data.get("blockers"):
-            return self._record_write_blocked_response(
-                raw_preflight,
-                operation="update",
-                normalized_payload=normalized_payload,
-                output_profile=output_profile,
-                human_review=True,
-                target_resource={"type": "record", "app_key": app_key, "record_id": record_id, "record_ids": []},
+        normalized_apply_id = self._validate_app_and_record(app_key, apply_id)
+        if workflow_node_id <= 0:
+            raise_tool_error(QingflowApiError.config_error("workflow_node_id must be positive for task save-only update"))
+
+        def runner(session_profile, context):
+            index = self._get_field_index(profile, context, app_key, force_refresh=force_refresh_form) if verify_write else None
+            normalized_answers = [dict(item) for item in answers if isinstance(item, dict)]
+            self._validate_record_write(app_key, normalized_answers, apply_id=normalized_apply_id)
+            result = self.backend.request(
+                "POST",
+                context,
+                f"/app/{app_key}/apply/{normalized_apply_id}",
+                json_body={"role": 3, "auditNodeId": workflow_node_id, "answers": normalized_answers},
             )
-        try:
-            raw_apply = self.record_update(
-                profile=profile,
+            verification = self._verify_record_write_result(
+                context,
                 app_key=app_key,
-                apply_id=record_id,
-                answers=cast(list[JSONObject], preflight_data.get("normalized_answers", [])),
-                fields={},
-                role=1,
-                verify_write=verify_write,
-                force_refresh_form=preflight_used_force_refresh,
-            )
-        except QingflowApiError as exc:
-            self._raise_record_write_permission_error(
-                exc,
+                apply_id=normalized_apply_id,
+                normalized_answers=normalized_answers,
+                index=cast(FieldIndex, index),
+            ) if verify_write and index is not None else None
+            verified = True if verification is None else bool(verification.get("verified"))
+            return self._attach_human_review_notice(
+                {
+                    "profile": profile,
+                    "ws_id": session_profile.selected_ws_id,
+                    "request_route": self._request_route_payload(context),
+                    "app_key": app_key,
+                    "apply_id": normalized_apply_id,
+                    "record_id": normalized_apply_id,
+                    "result": result,
+                    "normalized_answers": normalized_answers,
+                    "status": "completed" if verified else "verification_failed",
+                    "ok": True,
+                    "verify_write": verify_write,
+                    "write_verified": verified if verify_write else None,
+                    "verification": verification,
+                    "resource": _record_resource_payload(normalized_apply_id),
+                },
                 operation="update",
-                app_key=app_key,
-                record_id=record_id,
-                selection=cast(JSONObject | None, preflight_data.get("selection") if isinstance(preflight_data.get("selection"), dict) else None),
+                target="record data",
             )
-            raise
-        return self._record_write_apply_response(
-            raw_apply,
-            operation="update",
-            normalized_payload=normalized_payload,
-            output_profile=output_profile,
-            human_review=True,
-            preflight=raw_preflight,
-        )
+
+        return self._run_record_tool(profile, runner)
 
     def _record_update_public_batch(
         self,
@@ -3265,13 +4720,44 @@ class RecordTools(ToolBase):
         """执行内部辅助逻辑。"""
         summary = self._record_update_batch_summary(responses)
         batch_items = [self._record_update_batch_item_from_response(response, output_profile=output_profile) for response in responses]
+        public_items = [self._record_update_public_batch_item(item, index=index) for index, item in enumerate(batch_items)]
         status, ok, message = self._record_update_batch_envelope_status(summary=summary, dry_run=dry_run)
         first_response = responses[0] if responses else {}
+        applied_count = int(summary.get("applied_count") or 0)
+        ready_count = int(summary.get("ready_count") or 0)
+        verified_count = int(summary.get("verified_count") or 0)
+        field_level_verified_count = int(summary.get("field_level_verified_count") or 0)
+        confirmation_count = int(summary.get("confirmation_count") or 0)
+        blocked_count = int(summary.get("blocked_count") or 0)
+        failed_count = int(summary.get("failed_count") or 0)
+        write_executed = applied_count > 0
+        verification_status = "not_requested"
+        if write_executed:
+            verification_status = "verified" if verified_count == applied_count else "failed"
+        updated_record_ids = [
+            str(item.get("record_id"))
+            for item in public_items
+            if item.get("record_id") not in (None, "") and str(item.get("status") or "").lower() == "success"
+        ]
         return {
             "profile": first_response.get("profile", profile),
             "ws_id": first_response.get("ws_id"),
             "ok": ok,
             "status": status,
+            "mode": "batch",
+            "dry_run": dry_run,
+            "app_key": app_key,
+            "total": int(summary.get("total") or 0),
+            "succeeded": ready_count if dry_run else applied_count,
+            "failed": blocked_count + failed_count,
+            "needs_confirmation": confirmation_count,
+            "updated_record_ids": updated_record_ids,
+            "write_executed": write_executed,
+            "safe_to_retry": not write_executed,
+            "verification_status": verification_status,
+            "field_level_verified_count": field_level_verified_count,
+            "summary": summary,
+            "items": public_items,
             "request_route": first_response.get("request_route"),
             "warnings": [],
             "output_profile": output_profile,
@@ -3285,6 +4771,31 @@ class RecordTools(ToolBase):
             "message": message,
         }
 
+    def _record_update_public_batch_item(self, item: JSONObject, *, index: int) -> JSONObject:
+        """执行内部辅助逻辑。"""
+        public = dict(item)
+        public.setdefault("index", index)
+        public.setdefault("row_number", index + 1)
+        resource = public.get("resource")
+        if isinstance(resource, dict):
+            record_id = resource.get("record_id")
+            apply_id = resource.get("apply_id")
+            if record_id not in (None, ""):
+                public["record_id"] = str(record_id)
+            if apply_id not in (None, ""):
+                public["apply_id"] = str(apply_id)
+        status = str(public.get("status") or "").lower()
+        verification = public.get("verification")
+        if isinstance(verification, dict):
+            if bool(verification.get("verified")):
+                public.setdefault("verification_status", "verified")
+            elif status == "success":
+                public.setdefault("verification_status", "failed")
+        public.setdefault("write_executed", status == "success")
+        public.setdefault("safe_to_retry", not bool(public.get("write_executed")))
+        public.setdefault("verification_status", "not_requested")
+        return public
+
     def _record_update_batch_summary(self, responses: list[JSONObject]) -> JSONObject:
         """执行内部辅助逻辑。"""
         summary: JSONObject = {
@@ -3345,6 +4856,12 @@ class RecordTools(ToolBase):
             "confirmation_requests": cast(list[JSONObject], data.get("confirmation_requests", [])),
             "resolved_fields": cast(list[JSONObject], data.get("resolved_fields", [])),
         }
+        update_route = response.get("update_route")
+        if isinstance(update_route, dict):
+            item["update_route"] = update_route
+        tried_routes = response.get("tried_routes")
+        if isinstance(tried_routes, list):
+            item["tried_routes"] = tried_routes
         blockers = data.get("blockers")
         if isinstance(blockers, list) and blockers:
             item["blockers"] = blockers
@@ -4210,6 +5727,11 @@ class RecordTools(ToolBase):
             delete_ids = [normalize_positive_id_int(record_id, field_name="record_id")]
         if not delete_ids:
             raise_tool_error(QingflowApiError.config_error("record_id or record_ids is required"))
+        seen_delete_ids: set[int] = set()
+        for item in delete_ids:
+            if item in seen_delete_ids:
+                raise_tool_error(QingflowApiError.config_error(f"duplicate record id in delete payload: {stringify_backend_id(item)}"))
+            seen_delete_ids.add(item)
         normalized_payload = {
             "operation": "delete",
             "record_id": stringify_backend_id(record_id) if record_id is not None else None,
@@ -4217,16 +5739,134 @@ class RecordTools(ToolBase):
             "answers": [],
             "submit_type": 1,
         }
-        raw_apply = self._record_delete_many(profile=profile, app_key=app_key, record_ids=delete_ids)
-        return self._record_write_apply_response(
-            raw_apply,
-            operation="delete",
+        return self._record_delete_public_batch(
+            profile=profile,
+            app_key=app_key,
+            delete_ids=delete_ids,
             normalized_payload=normalized_payload,
             output_profile=normalized_output_profile,
-            human_review=True,
-            preflight=None,
         )
 
+    def _record_delete_public_batch(
+        self,
+        *,
+        profile: str,
+        app_key: str,
+        delete_ids: list[int],
+        normalized_payload: JSONObject,
+        output_profile: str,
+    ) -> JSONObject:
+        items: list[JSONObject] = []
+        request_route: JSONObject | None = None
+        ws_id: object = None
+        for index, delete_id in enumerate(delete_ids):
+            record_id_text = stringify_backend_id(delete_id)
+            try:
+                raw_apply = self._record_delete_many(profile=profile, app_key=app_key, record_ids=[delete_id])
+                request_route = cast(JSONObject, raw_apply.get("request_route")) if isinstance(raw_apply.get("request_route"), dict) else request_route
+                ws_id = raw_apply.get("ws_id", ws_id)
+                single_payload = {
+                    "operation": "delete",
+                    "record_id": record_id_text,
+                    "record_ids": [record_id_text],
+                    "answers": [],
+                    "submit_type": 1,
+                }
+                single_response = self._record_write_apply_response(
+                    raw_apply,
+                    operation="delete",
+                    normalized_payload=single_payload,
+                    output_profile=output_profile,
+                    human_review=True,
+                    preflight=None,
+                )
+                item_status = str(single_response.get("status") or "success")
+                item: JSONObject = {
+                    "index": index,
+                    "row_number": index + 1,
+                    "record_id": record_id_text,
+                    "status": item_status,
+                    "write_executed": bool(single_response.get("write_executed")),
+                    "verification_status": single_response.get("verification_status", "not_requested"),
+                    "safe_to_retry": bool(single_response.get("safe_to_retry", False)),
+                }
+                if item_status != "success":
+                    item["error"] = (single_response.get("data") or {}).get("error") if isinstance(single_response.get("data"), dict) else None
+                items.append(item)
+            except (QingflowApiError, RuntimeError) as exc:
+                error_response = self._record_write_exception_response(
+                    exc,
+                    operation="delete",
+                    profile=profile,
+                    app_key=app_key,
+                    record_id=record_id_text,
+                    output_profile=output_profile,
+                    human_review=True,
+                    write_executed=False,
+                )
+                request_route = cast(JSONObject, error_response.get("request_route")) if isinstance(error_response.get("request_route"), dict) else request_route
+                item = {
+                    "index": index,
+                    "row_number": index + 1,
+                    "record_id": record_id_text,
+                    "status": "failed",
+                    "write_executed": False,
+                    "verification_status": "not_requested",
+                    "safe_to_retry": True,
+                    "error": (error_response.get("data") or {}).get("error") if isinstance(error_response.get("data"), dict) else {"message": str(exc)},
+                }
+                items.append(item)
+        deleted_ids = [
+            str(item["record_id"])
+            for item in items
+            if str(item.get("status") or "") == "success"
+        ]
+        failed_ids = [
+            str(item["record_id"])
+            for item in items
+            if str(item.get("status") or "") != "success"
+        ]
+        total = len(items)
+        succeeded = len(deleted_ids)
+        failed = len(failed_ids)
+        if succeeded and failed:
+            status = "partial_success"
+            ok = False
+        elif succeeded:
+            status = "success"
+            ok = True
+        else:
+            status = "failed"
+            ok = False
+        write_executed = any(bool(item.get("write_executed")) for item in items)
+        return {
+            "profile": profile,
+            "ws_id": ws_id,
+            "ok": ok,
+            "status": status,
+            "mode": "batch",
+            "total": total,
+            "succeeded": succeeded,
+            "failed": failed,
+            "deleted_ids": deleted_ids,
+            "failed_ids": failed_ids,
+            "write_executed": write_executed,
+            "verification_status": "not_requested",
+            "safe_to_retry": False if write_executed else True,
+            "request_route": request_route,
+            "warnings": [],
+            "output_profile": output_profile,
+            "items": items,
+            "data": {
+                "action": {"operation": "delete", "executed": write_executed},
+                "resource": {"type": "record", "app_key": app_key, "record_id": None, "record_ids": [stringify_backend_id(item) for item in delete_ids]},
+                "normalized_payload": normalized_payload,
+                "deleted_ids": deleted_ids,
+                "failed_ids": failed_ids,
+                "items": items,
+            },
+        }
+
     @tool_cn_name("写入记录")
     def record_write(
         self,
@@ -6785,6 +8425,7 @@ class RecordTools(ToolBase):
                 field_index_override=index,
             )
         except RecordInputError as error:
+            normalized_answers = list(lookup_resolution.normalized_answers)
             invalid_fields.append(
                 {
                     "location": _stringify_json(error.details.get("location") if error.details else None),
@@ -7281,7 +8922,7 @@ class RecordTools(ToolBase):
                 "result": result,
                 "normalized_answers": normalized_answers,
                 "status": "completed" if verified else "verification_failed",
-                "ok": verified,
+                "ok": True,
                 "apply_id": apply_id,
                 "record_id": apply_id,
                 "verify_write": verify_write,
@@ -7485,7 +9126,7 @@ class RecordTools(ToolBase):
                     "result": result,
                     "normalized_answers": normalized_answers,
                     "status": "completed" if verified else "verification_failed",
-                    "ok": verified,
+                    "ok": True,
                     "verify_write": verify_write,
                     "write_verified": verified if verify_write else None,
                     "verification": verification,
@@ -7879,22 +9520,188 @@ class RecordTools(ToolBase):
                         },
                     },
                 },
-                "output_profile": output_profile,
-                "next_page_token": None,
+                "output_profile": output_profile,
+                "next_page_token": None,
+            }
+            if output_profile == "verbose":
+                cast(JSONObject, cast(JSONObject, response["data"])["list"])["normalized_rows"] = normalized_rows
+                response["completeness"] = completeness
+                evidence["backend_reported_total"] = reported_total
+                response["evidence"] = evidence
+                response["resolved_mappings"] = {
+                    "select_columns": [_field_mapping_entry("row", field, requested=field.que_title) for field in selected_fields],
+                    "filters": [_field_mapping_entry("filter", entry["field"], requested=entry["requested"]) for entry in self._resolve_filter_field_entries(filters, index)],
+                    "time_range": _field_mapping_entry("time", time_field, requested=time_field.que_title) if time_field is not None else None,
+                }
+            return response
+
+        return self._run_record_tool(profile, runner)
+
+    def _record_list_query_view_fields(
+        self,
+        *,
+        session_profile,
+        context,
+        app_key: str,
+        view_route: AccessibleViewRoute,
+        page_num: int,
+        page_size: int,
+        query_key: str | None,
+        search_que_ids: list[int] | None,
+        match_rules: list[JSONObject],
+        sort_rules: list[JSONObject],
+        max_rows: int,
+        selected_fields: list[FormField],
+        output_profile: str,
+    ) -> JSONObject:
+        """Run public record_list with fields already resolved from the selected view schema."""
+        view_selection = view_route.view_selection
+        current_page = max(page_num, 1)
+        used_list_type: int | None = None
+        if view_selection is not None:
+            fallback_list_types = [view_route.list_type if view_route.list_type is not None else DEFAULT_RECORD_LIST_TYPE]
+        elif view_route.list_type is not None and view_route.list_type != DEFAULT_RECORD_LIST_TYPE:
+            fallback_list_types = [view_route.list_type]
+        else:
+            fallback_list_types = [DEFAULT_RECORD_LIST_TYPE, 14, 1, 2, 12]
+        last_error: QingflowApiError | None = None
+        page: JSONObject | None = None
+        for candidate_list_type in fallback_list_types:
+            try:
+                page = self._search_page(
+                    context,
+                    app_key=app_key,
+                    view_selection=view_selection,
+                    page_num=current_page,
+                    page_size=page_size,
+                    query_key=query_key,
+                    match_rules=match_rules,
+                    sorts=sort_rules,
+                    search_que_ids=search_que_ids,
+                    list_type=candidate_list_type,
+                )
+                used_list_type = None if view_selection is not None else candidate_list_type
+                break
+            except QingflowApiError as exc:
+                last_error = exc
+                if self._should_retry_list_type_fallback(exc) and candidate_list_type != fallback_list_types[-1]:
+                    continue
+                raise
+        if page is None:
+            if last_error is not None:
+                raise last_error
+            raise_tool_error(QingflowApiError.config_error("record_list failed: no accessible listType"))
+
+        page_rows = page.get("list")
+        items = page_rows if isinstance(page_rows, list) else []
+        reported_total = _coerce_count(page.get("total"))
+        if reported_total is None:
+            reported_total = _coerce_count(page.get("count"))
+        result_amount = _effective_total(page, page_size)
+        has_more = _page_has_more(page, current_page, page_size, len(items))
+        rows: list[JSONObject] = []
+        normalized_rows: list[JSONObject] = []
+        page_apply_order: list[int] = []
+        page_answer_map: dict[int, list[JSONValue]] = {}
+        for item in items:
+            if not isinstance(item, dict):
+                continue
+            answers = item.get("answers")
+            answer_list = answers if isinstance(answers, list) else []
+            apply_id = _coerce_count(item.get("applyId")) or _coerce_count(item.get("id"))
+            row = _build_flat_row(answer_list, selected_fields, apply_id=apply_id)
+            rows.append(row)
+            if apply_id is not None:
+                page_apply_order.append(apply_id)
+                page_answer_map[apply_id] = cast(list[JSONValue], answer_list)
+            if len(rows) >= max_rows:
+                break
+        if output_profile == "verbose" and page_apply_order:
+            for apply_id in page_apply_order:
+                normalized_record, normalized_ambiguous_fields = _build_normalized_row_from_answers(
+                    page_answer_map.get(apply_id, []),
+                    selected_fields,
+                )
+                normalized_rows.append(
+                    {
+                        "apply_id": apply_id,
+                        "normalized_record": normalized_record,
+                        "normalized_ambiguous_fields": normalized_ambiguous_fields,
+                    }
+                )
+        effective_result_amount = result_amount if result_amount is not None else len(rows)
+        completeness = _build_completeness(
+            result_amount=effective_result_amount,
+            returned_items=len(rows),
+            fetched_pages=1,
+            requested_pages=1,
+            has_more=has_more,
+            next_page_token=None,
+            is_complete=not has_more and len(rows) < max_rows,
+            omitted_items=max(0, effective_result_amount - len(rows)),
+            extra={},
+        )
+        evidence = {
+            "query_id": _query_id(),
+            "app_key": app_key,
+            "filters": _echo_filters(match_rules),
+            "selected_columns": [field.que_title for field in selected_fields],
+            "time_range": None,
+            "source_pages": [current_page],
+            "view": _view_selection_payload(view_selection),
+            "backend_reported_total": reported_total,
+        }
+        response: JSONObject = {
+            "profile": session_profile.profile,
+            "ws_id": session_profile.selected_ws_id,
+            "ok": True,
+            "request_route": self._request_route_payload(context),
+            "data": {
+                "mode": "list",
+                "source_tool": "record_list",
+                "view": _view_selection_payload(view_selection),
+                "list": {
+                    "rows": rows,
+                    "row_cap_hit": _list_row_cap_hit(returned_items=len(rows), row_cap=max_rows),
+                    "sample_only": _list_sample_only(
+                        returned_items=len(rows),
+                        row_cap=max_rows,
+                        result_amount=effective_result_amount,
+                    ),
+                    "safe_for_final_conclusion": False,
+                    "analysis_warning": _list_sample_warning(
+                        returned_items=len(rows),
+                        row_cap=max_rows,
+                        result_amount=effective_result_amount,
+                    ),
+                    "pagination": {
+                        "page_num": current_page,
+                        "page_size": page_size,
+                        "requested_pages": 1,
+                        "result_amount": effective_result_amount,
+                        "returned_items": len(rows),
+                        "list_type_used": used_list_type,
+                    },
+                    "applied_limits": {
+                        "row_cap": max_rows,
+                        "column_cap": len(selected_fields),
+                        "selected_columns": [field.que_title for field in selected_fields],
+                    },
+                },
+            },
+            "output_profile": output_profile,
+            "next_page_token": None,
+        }
+        if output_profile == "verbose":
+            cast(JSONObject, cast(JSONObject, response["data"])["list"])["normalized_rows"] = normalized_rows
+            response["completeness"] = completeness
+            response["evidence"] = evidence
+            response["resolved_mappings"] = {
+                "select_columns": [_field_mapping_entry("row", field, requested=field.que_title) for field in selected_fields],
+                "filters": [],
+                "time_range": None,
             }
-            if output_profile == "verbose":
-                cast(JSONObject, cast(JSONObject, response["data"])["list"])["normalized_rows"] = normalized_rows
-                response["completeness"] = completeness
-                evidence["backend_reported_total"] = reported_total
-                response["evidence"] = evidence
-                response["resolved_mappings"] = {
-                    "select_columns": [_field_mapping_entry("row", field, requested=field.que_title) for field in selected_fields],
-                    "filters": [_field_mapping_entry("filter", entry["field"], requested=entry["requested"]) for entry in self._resolve_filter_field_entries(filters, index)],
-                    "time_range": _field_mapping_entry("time", time_field, requested=time_field.que_title) if time_field is not None else None,
-                }
-            return response
-
-        return self._run_record_tool(profile, runner)
+        return response
 
     def _get_form_schema(self, profile: str, context, app_key: str, *, force_refresh: bool) -> JSONObject:  # type: ignore[no-untyped-def]
         """执行内部辅助逻辑。"""
@@ -8392,63 +10199,7 @@ class RecordTools(ToolBase):
                 force_refresh=False,
             )
             index = cast(FieldIndex, browse_scope["index"])
-            visible_question_ids = cast(set[int], browse_scope["visible_question_ids"])
-            resolved: list[int] = []
-            seen: set[int] = set()
-            for selector in selectors:
-                try:
-                    field = self._resolve_field_selector(selector, index, location="record_list.query_fields")
-                except RecordInputError as exc:
-                    if exc.error_code == "FIELD_NOT_FOUND":
-                        raise RecordInputError(
-                            message=(
-                                f"record_list query field_id '{selector}' is not in the selected view schema "
-                                f"({resolved_view.view_id})."
-                            ),
-                            error_code="QUERY_FIELD_NOT_IN_VIEW_SCHEMA",
-                            fix_hint="Call record_browse_schema_get for this exact view_id and pass only field_id values from its fields[].",
-                            details={
-                                "location": "record_list.query_fields",
-                                "requested": selector,
-                                "view_id": resolved_view.view_id,
-                                "view_name": resolved_view.name,
-                            },
-                        ) from exc
-                    raise
-                if field.que_id not in visible_question_ids:
-                    raise RecordInputError(
-                        message=(
-                            f"record_list query field_id '{field.que_id}' is not readable in the selected view "
-                            f"({resolved_view.view_id})."
-                        ),
-                        error_code="QUERY_FIELD_NOT_IN_VIEW_SCHEMA",
-                        fix_hint="Call record_browse_schema_get for this exact view_id and pass only field_id values from its fields[].",
-                        details={
-                            "location": "record_list.query_fields",
-                            "requested": selector,
-                            "field_id": field.que_id,
-                            "view_id": resolved_view.view_id,
-                            "view_name": resolved_view.name,
-                        },
-                    )
-                if field.que_id in seen:
-                    continue
-                resolved.append(field.que_id)
-                seen.add(field.que_id)
-            if len(resolved) > BACKEND_LIST_SEARCH_FIELD_LIMIT:
-                raise RecordInputError(
-                    message=(
-                        f"record_list query_fields supports at most {BACKEND_LIST_SEARCH_FIELD_LIMIT} fields."
-                    ),
-                    error_code="QUERY_FIELDS_TOO_MANY",
-                    fix_hint="Narrow query_fields to the most likely title/name/customer/number fields, or omit query_fields to use the backend default search scope.",
-                    details={
-                        "location": "record_list.query_fields",
-                        "max_fields": BACKEND_LIST_SEARCH_FIELD_LIMIT,
-                        "received": len(resolved),
-                    },
-                )
-            return resolved
+            return self._resolve_record_list_query_fields(selectors, index, view_route=resolved_view)
 
         return cast(list[int], self._run_record_tool(profile, runner))
 
@@ -8460,7 +10211,7 @@ class RecordTools(ToolBase):
         resolved_view: AccessibleViewRoute,
     ) -> list[int]:
         """执行内部辅助逻辑。"""
-        browse_scope = self._build_browse_write_scope(
+        browse_scope = self._build_browse_read_scope(
             profile,
             context,
             app_key,
@@ -8468,33 +10219,7 @@ class RecordTools(ToolBase):
             force_refresh=False,
         )
         index = cast(FieldIndex, browse_scope["index"])
-        visible_question_ids = cast(set[int], browse_scope["visible_question_ids"])
-        ordered_visible_fields = [
-            field
-            for field in self._schema_fields_for_mode(
-                profile,
-                context,
-                app_key,
-                index,
-                schema_mode="browse",
-                resolved_view=resolved_view,
-            )
-            if field.que_id in visible_question_ids and field.que_type not in LAYOUT_ONLY_QUE_TYPES
-        ]
-        field_ids = [field.que_id for field in ordered_visible_fields[:MAX_LIST_COLUMN_LIMIT]]
-        if not field_ids:
-            field_ids = [
-                field.que_id
-                for field in index.by_id.values()
-                if field.que_type not in LAYOUT_ONLY_QUE_TYPES
-            ][:MAX_LIST_COLUMN_LIMIT]
-        if not field_ids:
-            raise_tool_error(
-                QingflowApiError.config_error(
-                    "record_list could not determine readable columns for the selected view"
-                )
-            )
-        return field_ids
+        return [field.que_id for field in self._derive_record_list_fields_from_index(index)]
 
     def _get_view_question_ids(self, profile: str, context, view_key: str) -> set[int]:  # type: ignore[no-untyped-def]
         """执行内部辅助逻辑。"""
@@ -9940,6 +11665,9 @@ class RecordTools(ToolBase):
             "ws_id": raw_preflight.get("ws_id"),
             "ok": False,
             "status": status,
+            "write_executed": False,
+            "verification_status": "not_requested",
+            "safe_to_retry": True,
             "request_route": raw_preflight.get("request_route"),
             "warnings": warnings,
             "output_profile": output_profile,
@@ -9983,6 +11711,9 @@ class RecordTools(ToolBase):
             "ws_id": raw_preflight.get("ws_id"),
             "ok": True,
             "status": "ready",
+            "write_executed": False,
+            "verification_status": "not_requested",
+            "safe_to_retry": True,
             "request_route": raw_preflight.get("request_route"),
             "warnings": warnings,
             "output_profile": output_profile,
@@ -10025,17 +11756,49 @@ class RecordTools(ToolBase):
         resolved_fields = cast(list[JSONObject], preflight_data.get("lookup_resolved_fields", []))
         if isinstance(verification_warnings, list):
             warnings.extend(cast(list[JSONObject], [item for item in verification_warnings if isinstance(item, dict)]))
+        resource = _public_record_resource(raw_apply.get("resource"))
+        record_id = _public_record_id_text(resource.get("record_id")) if isinstance(resource, dict) else None
+        apply_id = _public_record_id_text(resource.get("apply_id")) if isinstance(resource, dict) else None
+        if record_id is None:
+            record_id = _public_record_id_text(raw_apply.get("record_id"))
+        if apply_id is None:
+            apply_id = _public_record_id_text(raw_apply.get("apply_id"))
+        if apply_id is None:
+            apply_id = record_id
+        if record_id is None:
+            record_id = apply_id
+        write_executed = True
+        verification_requested = (
+            raw_apply.get("verify_write") is True
+            or raw_apply.get("write_verified") is not None
+            or isinstance(raw_apply.get("verification"), dict)
+        )
+        if verification_requested:
+            verification_status = "verified" if bool(verification.get("verified")) else "failed"
+        else:
+            verification_status = "not_requested"
+        raw_status = _normalize_optional_text(raw_apply.get("status"))
+        response_status = "verification_failed" if verification_status == "failed" else "success"
+        if not bool(raw_apply.get("ok", True)) and verification_status != "failed":
+            response_status = raw_status or "failed"
+        update_route = raw_apply.get("update_route") if isinstance(raw_apply.get("update_route"), dict) else None
+        tried_routes = raw_apply.get("tried_routes") if isinstance(raw_apply.get("tried_routes"), list) else []
         response: JSONObject = {
             "profile": raw_apply.get("profile"),
             "ws_id": raw_apply.get("ws_id"),
-            "ok": bool(raw_apply.get("ok", True)),
-            "status": "success" if bool(raw_apply.get("ok", True)) else _normalize_optional_text(raw_apply.get("status")) or "failed",
+            "ok": True if verification_status == "failed" and write_executed else bool(raw_apply.get("ok", True)),
+            "status": response_status,
+            "write_executed": write_executed,
+            "verification_status": verification_status,
+            "safe_to_retry": False,
             "request_route": raw_apply.get("request_route"),
             "warnings": warnings,
             "output_profile": output_profile,
+            "update_route": update_route,
+            "tried_routes": tried_routes,
             "data": {
                 "action": {"operation": operation, "executed": True},
-                "resource": _public_record_resource(raw_apply.get("resource")),
+                "resource": resource,
                 "verification": raw_apply.get("verification"),
                 "normalized_payload": normalized_payload,
                 "blockers": [],
@@ -10043,8 +11806,14 @@ class RecordTools(ToolBase):
                 "confirmation_requests": [],
                 "resolved_fields": resolved_fields,
                 "human_review": self._record_write_human_review_payload(operation, enabled=human_review),
+                "update_route": update_route,
+                "tried_routes": tried_routes,
             },
         }
+        if record_id is not None:
+            response["record_id"] = record_id
+        if apply_id is not None:
+            response["apply_id"] = apply_id
         if output_profile == "verbose":
             debug: JSONObject = {
                 "legacy_result": raw_apply.get("result"),
@@ -10063,9 +11832,10 @@ class RecordTools(ToolBase):
         operation: str,
         profile: str,
         app_key: str,
-        record_id: int,
+        record_id: Any | None,
         output_profile: str,
         human_review: bool,
+        write_executed: bool = True,
     ) -> JSONObject:
         """执行内部辅助逻辑。"""
         error_payload: JSONObject = {
@@ -10106,11 +11876,14 @@ class RecordTools(ToolBase):
             "ws_id": None,
             "ok": False,
             "status": "failed",
+            "write_executed": write_executed,
+            "verification_status": "failed" if write_executed else "not_requested",
+            "safe_to_retry": not write_executed,
             "request_route": request_route,
             "warnings": [],
             "output_profile": output_profile,
             "data": {
-                "action": {"operation": operation, "executed": True},
+                "action": {"operation": operation, "executed": write_executed},
                 "resource": {"type": "record", "app_key": app_key, "record_id": record_id, "record_ids": []},
                 "verification": None,
                 "normalized_payload": None,
@@ -10446,6 +12219,153 @@ class RecordTools(ToolBase):
             seen.add(field.que_id)
         return fields
 
+    def _derive_record_list_fields_from_index(self, index: FieldIndex) -> list[FormField]:
+        fields = [
+            field
+            for field in index.by_id.values()
+            if field.que_type not in LAYOUT_ONLY_QUE_TYPES
+        ][:MAX_LIST_COLUMN_LIMIT]
+        if not fields:
+            raise_tool_error(
+                QingflowApiError.config_error(
+                    "record_list could not determine readable columns for the selected view"
+                )
+            )
+        return fields
+
+    def _resolve_record_list_columns(
+        self,
+        selectors: list[int],
+        index: FieldIndex,
+        *,
+        view_route: AccessibleViewRoute,
+    ) -> list[FormField]:
+        if not selectors:
+            raise_tool_error(QingflowApiError.config_error("columns is required"))
+        fields: list[FormField] = []
+        seen: set[int] = set()
+        for selector in selectors:
+            try:
+                field = self._resolve_field_selector(selector, index, location="record_list.columns")
+            except RecordInputError as exc:
+                if exc.error_code == "FIELD_NOT_FOUND":
+                    raise self._record_list_field_not_in_view_error(
+                        exc,
+                        location="record_list.columns",
+                        error_code="FIELD_NOT_IN_VIEW_SCHEMA",
+                        view_route=view_route,
+                    ) from exc
+                raise
+            if field.que_id in seen:
+                continue
+            fields.append(field)
+            seen.add(field.que_id)
+        return fields
+
+    def _resolve_record_list_query_fields(
+        self,
+        selectors: list[int],
+        index: FieldIndex,
+        *,
+        view_route: AccessibleViewRoute,
+    ) -> list[int]:
+        resolved: list[int] = []
+        seen: set[int] = set()
+        for selector in selectors:
+            try:
+                field = self._resolve_field_selector(selector, index, location="record_list.query_fields")
+            except RecordInputError as exc:
+                if exc.error_code == "FIELD_NOT_FOUND":
+                    raise self._record_list_field_not_in_view_error(
+                        exc,
+                        location="record_list.query_fields",
+                        error_code="QUERY_FIELD_NOT_IN_VIEW_SCHEMA",
+                        view_route=view_route,
+                    ) from exc
+                raise
+            if field.que_id in seen:
+                continue
+            resolved.append(field.que_id)
+            seen.add(field.que_id)
+        if len(resolved) > BACKEND_LIST_SEARCH_FIELD_LIMIT:
+            raise RecordInputError(
+                message=(
+                    f"record_list query_fields supports at most {BACKEND_LIST_SEARCH_FIELD_LIMIT} fields."
+                ),
+                error_code="QUERY_FIELDS_TOO_MANY",
+                fix_hint="Narrow query_fields to the most likely title/name/customer/number fields, or omit query_fields to use the backend default search scope.",
+                details={
+                    "location": "record_list.query_fields",
+                    "max_fields": BACKEND_LIST_SEARCH_FIELD_LIMIT,
+                    "received": len(resolved),
+                },
+            )
+        return resolved
+
+    def _resolve_record_list_match_rules(
+        self,
+        context,  # type: ignore[no-untyped-def]
+        filters: list[JSONObject],
+        index: FieldIndex,
+        *,
+        view_route: AccessibleViewRoute,
+    ) -> list[JSONObject]:
+        try:
+            return self._resolve_match_rules(context, filters, index)
+        except RecordInputError as exc:
+            if exc.error_code == "FIELD_NOT_FOUND":
+                raise self._record_list_field_not_in_view_error(
+                    exc,
+                    location="record_list.where",
+                    error_code="FILTER_FIELD_NOT_IN_VIEW_SCHEMA",
+                    view_route=view_route,
+                ) from exc
+            raise
+
+    def _resolve_record_list_sort_rules(
+        self,
+        sorts: list[JSONObject],
+        index: FieldIndex,
+        *,
+        view_route: AccessibleViewRoute,
+    ) -> list[JSONObject]:
+        try:
+            return self._resolve_sorts(sorts, index)
+        except RecordInputError as exc:
+            if exc.error_code == "FIELD_NOT_FOUND":
+                raise self._record_list_field_not_in_view_error(
+                    exc,
+                    location="record_list.order_by",
+                    error_code="SORT_FIELD_NOT_IN_VIEW_SCHEMA",
+                    view_route=view_route,
+                ) from exc
+            raise
+
+    def _record_list_field_not_in_view_error(
+        self,
+        exc: RecordInputError,
+        *,
+        location: str,
+        error_code: str,
+        view_route: AccessibleViewRoute,
+    ) -> RecordInputError:
+        details = exc.details if isinstance(exc.details, dict) else {}
+        requested = details.get("requested")
+        return RecordInputError(
+            message=(
+                f"{location} field_id '{requested}' is not in the selected view schema "
+                f"({view_route.view_id})."
+            ),
+            error_code=error_code,
+            fix_hint="Call record_browse_schema_get for this exact view_id and pass only field_id values from its fields[].",
+            details={
+                "location": location,
+                "requested": requested,
+                "view_id": view_route.view_id,
+                "view_name": view_route.name,
+            },
+        )
+
     def _resolve_summary_preview_fields(
         self,
         selectors: list[str | int],
@@ -11459,6 +13379,7 @@ class RecordTools(ToolBase):
         normalized_answers: list[JSONObject],
         index: FieldIndex,
         verify_list_type: int = DEFAULT_RECORD_LIST_TYPE,
+        verify_view_key: str | None = None,
     ) -> JSONObject:
         """执行内部辅助逻辑。"""
         if apply_id is None:
@@ -11470,13 +13391,36 @@ class RecordTools(ToolBase):
                 "count_mismatches": [],
             }
         try:
-            record = self.backend.request(
-                "GET",
-                context,
-                f"/app/{app_key}/apply/{apply_id}",
-                params={"role": 1, "listType": verify_list_type},
-            )
+            if verify_view_key:
+                record = self.backend.request(
+                    "GET",
+                    context,
+                    f"/view/{verify_view_key}/apply/{apply_id}",
+                )
+            else:
+                record = self.backend.request(
+                    "GET",
+                    context,
+                    f"/app/{app_key}/apply/{apply_id}",
+                    params={"role": 1, "listType": verify_list_type},
+                )
         except QingflowApiError as exc:
+            if verify_view_key:
+                return {
+                    "verified": False,
+                    "verification_mode": "custom_view_record_detail",
+                    "field_level_verified": False,
+                    "error": "custom_view_readback_failed",
+                    "missing_fields": [],
+                    "empty_fields": [],
+                    "count_mismatches": [],
+                    "warnings": [{
+                        "code": "WRITE_VERIFY_CUSTOM_VIEW_READBACK_FAILED",
+                        "message": "Write was sent through a custom view route, but the same view could not be re-read for field-level verification.",
+                        "backend_code": exc.backend_code,
+                        "http_status": exc.http_status,
+                    }],
+                }
             if exc.backend_code != 40002:
                 raise
             return self._verify_record_write_result_via_initiated_tasks(
@@ -11540,7 +13484,7 @@ class RecordTools(ToolBase):
                 )
         return {
             "verified": not missing_fields and not empty_fields and not count_mismatches,
-            "verification_mode": "initiated_record_view",
+            "verification_mode": "custom_view_record_detail" if verify_view_key else "initiated_record_view",
             "field_level_verified": True,
             "missing_fields": missing_fields,
             "empty_fields": empty_fields,
@@ -12452,6 +14396,13 @@ def _record_access_run_dir() -> Path:
     return base_dir / run_id
 
 
+def _record_logs_run_dir() -> Path:
+    custom_home = os.getenv("QINGFLOW_MCP_RECORD_LOGS_HOME")
+    base_dir = Path(custom_home).expanduser() if custom_home else get_mcp_home() / "record-logs"
+    run_id = f"{datetime.now(UTC).strftime('%Y%m%dT%H%M%SZ')}-{uuid4().hex[:8]}"
+    return base_dir / run_id
+
+
 def _record_access_field_payload(field: FormField) -> JSONObject:
     return {
         "field_id": field.que_id,
@@ -13192,34 +15143,187 @@ def _record_detail_visibility_value(payload: JSONObject, *, keys: tuple[str, ...
     return default
 
 
-def _record_detail_log_hidden_payload() -> JSONObject:
+def _record_detail_log_hidden_payload() -> JSONObject:
+    return {
+        "status": "hidden",
+        "visible": False,
+        "page": 1,
+        "page_size": RECORD_GET_DETAIL_LOG_PAGE_SIZE,
+        "items_loaded": 0,
+        "has_more": False,
+        "complete": False,
+        "items": [],
+    }
+
+
+def _record_detail_log_unavailable_payload(source: str, reason: str) -> JSONObject:
+    return {
+        "status": "unavailable",
+        "visible": None,
+        "source": source,
+        "reason": reason,
+        "page": 1,
+        "page_size": RECORD_GET_DETAIL_LOG_PAGE_SIZE,
+        "items_loaded": 0,
+        "has_more": None,
+        "complete": False,
+        "items": [],
+    }
+
+
+def _record_logs_hidden_payload(source: str) -> JSONObject:
+    return {
+        "status": "hidden",
+        "visible": False,
+        "source": source,
+        "complete": False,
+        "items_count": 0,
+        "pages_fetched": 0,
+        "reported_total": None,
+        "local_path": None,
+        "preview_items": [],
+        "warnings": [],
+    }
+
+
+def _record_logs_unavailable_payload(source: str, reason: str) -> JSONObject:
+    return {
+        "status": "unavailable",
+        "visible": None,
+        "source": source,
+        "reason": reason,
+        "complete": False,
+        "items_count": 0,
+        "pages_fetched": 0,
+        "reported_total": None,
+        "local_path": None,
+        "preview_items": [],
+        "warnings": [],
+    }
+
+
+def _record_logs_fetch_all_to_jsonl(
+    *,
+    fetch_page,
+    normalizer,
+    source: str,
+    file_path: Path,
+    deadline: float,
+) -> JSONObject:  # type: ignore[no-untyped-def]
+    file_path.parent.mkdir(parents=True, exist_ok=True)
+    page_num = 1
+    pages_fetched = 0
+    items_count = 0
+    reported_total: int | None = None
+    preview_items: list[JSONObject] = []
+    warnings: list[JSONObject] = []
+    stopped_reason: str | None = None
+    complete = True
+
+    with file_path.open("w", encoding="utf-8") as handle:
+        while True:
+            if _record_logs_time_budget_exceeded(deadline=deadline):
+                complete = False
+                stopped_reason = "time_budget_exceeded"
+                warnings.append(_record_logs_time_budget_warning(source=source, pages_fetched=pages_fetched, items_count=items_count))
+                break
+            payload = fetch_page(page_num)
+            pages_fetched += 1
+            items = _record_detail_page_items(payload)
+            if reported_total is None:
+                reported_total = _record_detail_page_total(payload)
+            if not items:
+                break
+            for item in items:
+                normalized = normalizer(item)
+                handle.write(json.dumps(normalized, ensure_ascii=False) + "\n")
+                items_count += 1
+                if len(preview_items) < RECORD_LOGS_PREVIEW_LIMIT:
+                    preview_items.append(normalized)
+                if items_count >= RECORD_LOGS_MAX_ITEMS:
+                    complete = False
+                    stopped_reason = "item_limit_exceeded"
+                    warnings.append(_record_logs_item_limit_warning(source=source, item_limit=RECORD_LOGS_MAX_ITEMS))
+                    break
+            if stopped_reason:
+                break
+            if reported_total is not None and items_count >= reported_total:
+                break
+            if reported_total is None and len(items) < RECORD_LOGS_PAGE_SIZE:
+                break
+            page_num += 1
+
+    return {
+        "status": "ok" if complete else "partial",
+        "visible": True,
+        "source": source,
+        "complete": complete,
+        "items_count": items_count,
+        "pages_fetched": pages_fetched,
+        "page_size": RECORD_LOGS_PAGE_SIZE,
+        "reported_total": reported_total,
+        "local_path": str(file_path),
+        "preview_items": preview_items,
+        "warnings": warnings,
+        "stopped_reason": stopped_reason,
+    }
+
+
+def _record_logs_time_budget_exceeded(*, deadline: float) -> bool:
+    return time.monotonic() + RECORD_LOGS_MIN_REMAINING_SECONDS >= deadline
+
+
+def _record_logs_time_budget_warning(*, source: str, pages_fetched: int, items_count: int) -> JSONObject:
     return {
-        "status": "hidden",
-        "visible": False,
-        "page": 1,
-        "page_size": RECORD_GET_DETAIL_LOG_PAGE_SIZE,
-        "items_loaded": 0,
-        "has_more": False,
-        "complete": False,
-        "items": [],
+        "code": "RECORD_LOGS_TIME_BUDGET_EXCEEDED",
+        "source": source,
+        "message": "record_logs_get stopped early to return partial JSONL files before the caller timeout.",
+        "pages_fetched": pages_fetched,
+        "items_count": items_count,
     }
 
 
-def _record_detail_log_unavailable_payload(source: str, reason: str) -> JSONObject:
+def _record_logs_item_limit_warning(*, source: str, item_limit: int) -> JSONObject:
     return {
-        "status": "unavailable",
-        "visible": None,
+        "code": "RECORD_LOGS_ITEM_LIMIT_EXCEEDED",
         "source": source,
-        "reason": reason,
-        "page": 1,
-        "page_size": RECORD_GET_DETAIL_LOG_PAGE_SIZE,
-        "items_loaded": 0,
-        "has_more": None,
-        "complete": False,
-        "items": [],
+        "message": f"record_logs_get stopped after the internal {item_limit} item limit.",
+        "item_limit": item_limit,
     }
 
 
+def _record_logs_overall_status(*, data_logs: JSONObject, workflow_logs: JSONObject) -> str:
+    statuses = {str(data_logs.get("status") or ""), str(workflow_logs.get("status") or "")}
+    if statuses == {"unavailable"}:
+        return "unavailable"
+    if "partial" in statuses or "unavailable" in statuses:
+        return "partial"
+    return "success"
+
+
+def _record_logs_context_integrity(*, data_logs: JSONObject, workflow_logs: JSONObject) -> JSONObject:
+    data_integrity = _record_logs_section_integrity(data_logs)
+    workflow_integrity = _record_logs_section_integrity(workflow_logs)
+    return {
+        "data_logs": data_integrity,
+        "workflow_logs": workflow_integrity,
+        "safe_for_full_log_conclusion": data_integrity == "full" and workflow_integrity == "full",
+    }
+
+
+def _record_logs_section_integrity(section: JSONObject) -> str:
+    status = str(section.get("status") or "")
+    if status == "ok" and section.get("complete") is True:
+        return "full"
+    if status == "hidden":
+        return "hidden"
+    if status == "partial":
+        return "partial"
+    if status == "unavailable":
+        return "unavailable"
+    return "unknown"
+
+
 def _record_detail_log_page_payload(payload: JSONValue, *, normalizer, source: str) -> JSONObject:  # type: ignore[no-untyped-def]
     items = _record_detail_page_items(payload)
     total = _record_detail_page_total(payload)
@@ -13351,11 +15455,15 @@ def _record_detail_associated_resource(raw: JSONObject) -> JSONObject:
     view_key = _normalize_optional_text(raw.get("viewKey", raw.get("viewgraphKey")))
     chart_key = _normalize_optional_text(raw.get("chartKey", raw.get("chartId")))
     is_view = bool(view_key) or graph_type.endswith("view") or graph_type == "view"
+    if is_view and not view_key and chart_key:
+        view_key = chart_key
+        chart_key = None
     resource_type = "view" if is_view else "report"
     view_type = _normalize_optional_text(raw.get("viewType", raw.get("viewgraphType", raw.get("graphType"))))
     data_access = _record_detail_resource_data_access(resource_type=resource_type, view_type=view_type)
     return {
         "type": resource_type,
+        "resource_type": resource_type,
         "name": _normalize_optional_text(raw.get("viewName", raw.get("chartName", raw.get("name", raw.get("title"))))),
         "app_key": _normalize_optional_text(raw.get("appKey", raw.get("targetAppKey"))),
         "app_name": _normalize_optional_text(raw.get("formTitle", raw.get("appName", raw.get("targetAppName")))),
@@ -13363,10 +15471,15 @@ def _record_detail_associated_resource(raw: JSONObject) -> JSONObject:
         "chart_key": chart_key,
         "view_type": view_type,
         "graph_type": raw.get("graphType"),
+        "report_source": _record_detail_report_source(raw.get("sourceType")) if resource_type == "report" else None,
         "data_access": data_access,
     }
 
 
+def _record_detail_report_source(source_type: Any) -> str:
+    return "dataset" if str(source_type or "").strip().upper() == "BI_DATASET" else "app"
+
+
 def _record_detail_resource_data_access(*, resource_type: str, view_type: str | None) -> JSONObject:
     if resource_type == "report":
         return {
@@ -13412,6 +15525,19 @@ _RECORD_MEDIA_IMG_SRC_RE = re.compile(r"""<img\b[^>]*\bsrc\s*=\s*["']?([^"'\s>]+
 _RECORD_MEDIA_MD_IMAGE_RE = re.compile(r"""!\[[^\]]*]\(([^)\s]+)(?:\s+["'][^"']*["'])?\)""")
 _RECORD_MEDIA_URL_RE = re.compile(r"""https?://[^\s<>"')\]]+""", re.IGNORECASE)
 _RECORD_MEDIA_IMAGE_EXTENSIONS = {".png", ".jpg", ".jpeg", ".gif", ".webp", ".bmp", ".svg"}
+_RECORD_FILE_EXTENSIONS = _RECORD_MEDIA_IMAGE_EXTENSIONS | {
+    ".csv",
+    ".doc",
+    ".docx",
+    ".json",
+    ".md",
+    ".pdf",
+    ".text",
+    ".txt",
+    ".xls",
+    ".xlsm",
+    ".xlsx",
+}
 _RECORD_MEDIA_IMAGE_URL_KEYS = {
     "image",
     "imageurl",
@@ -13431,6 +15557,15 @@ _RECORD_MEDIA_IMAGE_URL_KEYS = {
     "url",
     "value",
 }
+_RECORD_FILE_URL_KEYS = _RECORD_MEDIA_IMAGE_URL_KEYS | {
+    "downloadurl",
+    "download_url",
+    "file",
+    "href",
+    "link",
+    "path",
+}
+_RECORD_FILE_NAME_KEYS = {"name", "otherinfo", "filename", "file_name", "title"}
 
 
 def _record_detail_media_assets_payload(
@@ -13550,7 +15685,278 @@ def _record_detail_media_assets_payload(
                             source_url=refreshed_url,
                             warnings=warnings,
                             environment_prefix_cache=environment_prefix_cache,
-                            requested_strategy=download_strategy if download_strategy == "decrypted_file_url_then_storage_cookie_redirect" else refreshed_strategy,
+                            requested_strategy=download_strategy if download_strategy == "decrypted_file_url_then_storage_cookie_redirect" else refreshed_strategy,
+                        )
+                        source_url = refreshed_url
+                        base_item["source_url"] = refreshed_url
+                        download_succeeded = True
+                    except QingflowApiError as refreshed_exc:
+                        exc = refreshed_exc
+                        blocked = exc.http_status in {401, 403}
+                    else:
+                        warnings.append(
+                            {
+                                "code": "MEDIA_ASSET_STORAGE_URL_REFRESHED",
+                                "asset_id": asset_id,
+                                "message": "record_get refreshed the record detail once before downloading this media asset.",
+                            }
+                        )
+            if not download_succeeded:
+                warning_code = "STORAGE_COOKIE_AUTH_FAILED" if blocked and download_strategy != "referer_acl" else "MEDIA_ASSET_DOWNLOAD_FAILED"
+                items.append(
+                    {
+                        **base_item,
+                        "storage_auth_type": _record_detail_storage_auth_type(source_url),
+                        "storage_cookie_prefix": environment_prefix_cache.get("value"),
+                        "redirected": False,
+                        "local_path": None,
+                        "mime_type": None,
+                        "size_bytes": None,
+                        "access_status": "blocked_private_url" if blocked else "download_failed",
+                        "download_strategy": download_strategy,
+                        "readable_by_agent": False,
+                    }
+                )
+                warnings.append(
+                    {
+                        "code": warning_code,
+                        "asset_id": asset_id,
+                        "message": f"record_get could not download image asset {asset_id}: {exc.message}",
+                        "http_status": exc.http_status,
+                    }
+                )
+                continue
+
+        if not isinstance(content, bytes):
+            content = bytes(content or b"")
+        mime_type = _record_detail_image_mime_from_bytes(content)
+        if not mime_type:
+            items.append(
+                {
+                    **base_item,
+                    **download_meta,
+                    "local_path": None,
+                    "mime_type": _record_detail_mime_from_url(source_url),
+                    "size_bytes": len(content),
+                    "access_status": "skipped_non_image",
+                    "readable_by_agent": False,
+                }
+            )
+            continue
+        if len(content) > RECORD_GET_MEDIA_MAX_IMAGE_BYTES or total_bytes + len(content) > RECORD_GET_MEDIA_MAX_TOTAL_BYTES:
+            items.append(
+                {
+                    **base_item,
+                    **download_meta,
+                    "local_path": None,
+                    "mime_type": mime_type,
+                    "size_bytes": len(content),
+                    "access_status": "too_large",
+                    "readable_by_agent": False,
+                }
+            )
+            warnings.append(
+                {
+                    "code": "MEDIA_ASSET_SIZE_LIMIT_EXCEEDED",
+                    "asset_id": asset_id,
+                    "message": "record_get skipped an image asset because it exceeded the internal media size budget.",
+                }
+            )
+            continue
+
+        ensure_local_dir()
+        extension = _record_detail_image_extension(mime_type, source_url)
+        local_path = local_dir / f"{asset_id}{extension}"
+        local_path.write_bytes(content)
+        total_bytes += len(content)
+        image_count += 1
+        items.append(
+            {
+                **base_item,
+                **download_meta,
+                "local_path": str(local_path),
+                "mime_type": mime_type,
+                "size_bytes": len(content),
+                "access_status": "downloaded",
+                "readable_by_agent": True,
+            }
+        )
+
+    if not items:
+        status = "none"
+    elif any(item.get("access_status") != "downloaded" for item in items):
+        status = "partial"
+    else:
+        status = "ok"
+    return {"status": status, "local_dir": str(local_dir) if items else None, "items": items, "warnings": warnings}
+
+
+def _record_detail_file_assets_payload(
+    *,
+    backend: Any,
+    context: BackendRequestContext,
+    app_key: str,
+    record_id: int,
+    fields: list[JSONObject],
+    references: list[JSONObject],
+    media_assets: JSONObject,
+    refresh_source_url: Any | None = None,
+) -> JSONObject:
+    candidates: list[JSONObject] = []
+    source_record_id = _public_record_id_text(record_id)
+    for field in fields:
+        if isinstance(field, dict):
+            candidates.extend(
+                _record_detail_file_candidates_from_field(
+                    field,
+                    source_app_key=app_key,
+                    source_record_id=source_record_id,
+                    forced_source=None,
+                )
+            )
+    for reference in references:
+        if not isinstance(reference, dict):
+            continue
+        target_fields = reference.get("target_fields") if isinstance(reference.get("target_fields"), list) else []
+        target_app_key = _normalize_optional_text(reference.get("target_app_key")) or app_key
+        target_record_id = _normalize_optional_text(reference.get("target_record_id"))
+        for field in target_fields:
+            if isinstance(field, dict):
+                candidates.extend(
+                    _record_detail_file_candidates_from_field(
+                        field,
+                        source_app_key=target_app_key,
+                        source_record_id=target_record_id,
+                        forced_source="reference_target",
+                    )
+                )
+    if not candidates:
+        return {"status": "none", "local_dir": None, "items": [], "warnings": []}
+
+    local_dir = _record_detail_file_assets_dir(uuid4().hex)
+    local_dir_created = False
+    items: list[JSONObject] = []
+    warnings: list[JSONObject] = []
+    file_by_url: dict[str, str] = {}
+    media_by_url = _record_detail_media_assets_by_url(media_assets)
+    media_by_asset_id = _record_detail_media_assets_by_asset_id(media_assets)
+    total_bytes = 0
+    downloaded_count = 0
+    deadline = time.monotonic() + RECORD_GET_FILE_TIME_BUDGET_SECONDS
+    stopped_for_time_budget = False
+    environment_prefix_cache: dict[str, str] = {}
+
+    def ensure_local_dir() -> None:
+        nonlocal local_dir_created
+        if not local_dir_created:
+            local_dir.mkdir(parents=True, exist_ok=True)
+            local_dir_created = True
+
+    for candidate in candidates:
+        if items and time.monotonic() + RECORD_GET_FILE_MIN_REMAINING_SECONDS >= deadline:
+            stopped_for_time_budget = True
+            warnings.append(
+                {
+                    "code": "FILE_ASSET_TIME_BUDGET_EXCEEDED",
+                    "message": "record_get stopped downloading additional file assets to stay within the internal time budget.",
+                    "time_budget_seconds": RECORD_GET_FILE_TIME_BUDGET_SECONDS,
+                }
+            )
+            break
+        source_url = _normalize_optional_text(candidate.get("source_url"))
+        owner = candidate.get("_owner")
+        if not source_url or not isinstance(owner, dict):
+            continue
+        existing_asset_id = file_by_url.get(source_url)
+        if existing_asset_id:
+            _record_detail_attach_file_asset_id(owner, existing_asset_id)
+            continue
+        file_asset_id = f"file_{len(items) + 1:04d}"
+        file_by_url[source_url] = file_asset_id
+        _record_detail_attach_file_asset_id(owner, file_asset_id)
+        base_item = _record_detail_file_asset_base_item(candidate, file_asset_id=file_asset_id)
+
+        media_item = media_by_url.get(source_url)
+        if media_item is None:
+            media_item = _record_detail_media_item_from_owner_asset_ids(owner, media_by_asset_id, candidate)
+        if isinstance(media_item, dict) and media_item.get("asset_id") not in (None, ""):
+            base_item["media_asset_id"] = media_item.get("asset_id")
+        if downloaded_count >= RECORD_GET_FILE_MAX_FILES:
+            items.append(
+                {
+                    **base_item,
+                    "local_path": None,
+                    "mime_type": None,
+                    "size_bytes": None,
+                    "access_status": "too_large",
+                    "download_strategy": "skipped_limit",
+                    "readable_by_agent": False,
+                    "extraction": {"status": "skipped_too_large", "text_path": None, "preview": None},
+                }
+            )
+            warnings.append(
+                {
+                    "code": "FILE_ASSET_LIMIT_EXCEEDED",
+                    "message": f"record_get stopped downloading files after {RECORD_GET_FILE_MAX_FILES} assets.",
+                }
+            )
+            continue
+
+        reused_media_path = _normalize_optional_text(media_item.get("local_path")) if isinstance(media_item, dict) else None
+        if reused_media_path and media_item.get("access_status") == "downloaded":
+            file_name = _record_detail_file_name_from_candidate(candidate, source_url=source_url, fallback_id=file_asset_id)
+            mime_type = _normalize_optional_text(media_item.get("mime_type")) or _record_detail_mime_from_url(source_url)
+            items.append(
+                {
+                    **base_item,
+                    "download_strategy": media_item.get("download_strategy"),
+                    "storage_auth_type": media_item.get("storage_auth_type"),
+                    "storage_cookie_prefix": media_item.get("storage_cookie_prefix"),
+                    "redirected": media_item.get("redirected"),
+                    "file_name": file_name,
+                    "local_path": reused_media_path,
+                    "mime_type": mime_type,
+                    "size_bytes": media_item.get("size_bytes"),
+                    "access_status": "downloaded",
+                    "readable_by_agent": True,
+                    "extraction": {"status": "unsupported", "text_path": None, "preview": None},
+                }
+            )
+            downloaded_count += 1
+            continue
+
+        download_strategy = _record_detail_media_download_strategy(source_url)
+        download_succeeded = False
+        content: bytes = b""
+        download_meta: JSONObject = {}
+        try:
+            content, download_meta = _record_detail_download_media_content(
+                backend=backend,
+                context=context,
+                source_url=source_url,
+                warnings=warnings,
+                environment_prefix_cache=environment_prefix_cache,
+                requested_strategy=download_strategy,
+            )
+            download_succeeded = True
+        except QingflowApiError as exc:
+            blocked = exc.http_status in {401, 403}
+            if blocked and download_strategy != "referer_acl" and callable(refresh_source_url):
+                refreshed_url = _normalize_optional_text(refresh_source_url(candidate))
+                if refreshed_url and refreshed_url != source_url:
+                    refreshed_strategy = _record_detail_media_download_strategy(refreshed_url)
+                    try:
+                        content, download_meta = _record_detail_download_media_content(
+                            backend=backend,
+                            context=context,
+                            source_url=refreshed_url,
+                            warnings=warnings,
+                            environment_prefix_cache=environment_prefix_cache,
+                            requested_strategy=(
+                                download_strategy
+                                if download_strategy == "decrypted_file_url_then_storage_cookie_redirect"
+                                else refreshed_strategy
+                            ),
                         )
                         source_url = refreshed_url
                         base_item["source_url"] = refreshed_url
@@ -13561,13 +15967,13 @@ def _record_detail_media_assets_payload(
                     else:
                         warnings.append(
                             {
-                                "code": "MEDIA_ASSET_STORAGE_URL_REFRESHED",
-                                "asset_id": asset_id,
-                                "message": "record_get refreshed the record detail once before downloading this media asset.",
+                                "code": "FILE_ASSET_STORAGE_URL_REFRESHED",
+                                "file_asset_id": file_asset_id,
+                                "message": "record_get refreshed the record detail once before downloading this file asset.",
                             }
                         )
             if not download_succeeded:
-                warning_code = "STORAGE_COOKIE_AUTH_FAILED" if blocked and download_strategy != "referer_acl" else "MEDIA_ASSET_DOWNLOAD_FAILED"
+                warning_code = "STORAGE_COOKIE_AUTH_FAILED" if blocked and download_strategy != "referer_acl" else "FILE_ASSET_DOWNLOAD_FAILED"
                 items.append(
                     {
                         **base_item,
@@ -13575,18 +15981,19 @@ def _record_detail_media_assets_payload(
                         "storage_cookie_prefix": environment_prefix_cache.get("value"),
                         "redirected": False,
                         "local_path": None,
-                        "mime_type": None,
+                        "mime_type": _record_detail_mime_from_url(source_url),
                         "size_bytes": None,
                         "access_status": "blocked_private_url" if blocked else "download_failed",
                         "download_strategy": download_strategy,
                         "readable_by_agent": False,
+                        "extraction": {"status": "failed", "text_path": None, "preview": None},
                     }
                 )
                 warnings.append(
                     {
                         "code": warning_code,
-                        "asset_id": asset_id,
-                        "message": f"record_get could not download image asset {asset_id}: {exc.message}",
+                        "file_asset_id": file_asset_id,
+                        "message": f"record_get could not download file asset {file_asset_id}: {exc.message}",
                         "http_status": exc.http_status,
                     }
                 )
@@ -13594,62 +16001,70 @@ def _record_detail_media_assets_payload(
 
         if not isinstance(content, bytes):
             content = bytes(content or b"")
-        mime_type = _record_detail_image_mime_from_bytes(content)
-        if not mime_type:
-            items.append(
-                {
-                    **base_item,
-                    **download_meta,
-                    "local_path": None,
-                    "mime_type": _record_detail_mime_from_url(source_url),
-                    "size_bytes": len(content),
-                    "access_status": "skipped_non_image",
-                    "readable_by_agent": False,
-                }
-            )
-            continue
-        if len(content) > RECORD_GET_MEDIA_MAX_IMAGE_BYTES or total_bytes + len(content) > RECORD_GET_MEDIA_MAX_TOTAL_BYTES:
+        file_name = _record_detail_file_name_from_candidate(candidate, source_url=source_url, fallback_id=file_asset_id)
+        mime_type = _record_detail_file_mime_from_content_or_name(content, source_url=source_url, file_name=file_name)
+        size_bytes = len(content)
+        if size_bytes > RECORD_GET_FILE_MAX_BYTES or total_bytes + size_bytes > RECORD_GET_FILE_MAX_TOTAL_BYTES:
             items.append(
                 {
                     **base_item,
                     **download_meta,
+                    "file_name": file_name,
                     "local_path": None,
                     "mime_type": mime_type,
-                    "size_bytes": len(content),
+                    "size_bytes": size_bytes,
                     "access_status": "too_large",
                     "readable_by_agent": False,
+                    "extraction": {"status": "skipped_too_large", "text_path": None, "preview": None},
                 }
             )
             warnings.append(
                 {
-                    "code": "MEDIA_ASSET_SIZE_LIMIT_EXCEEDED",
-                    "asset_id": asset_id,
-                    "message": "record_get skipped an image asset because it exceeded the internal media size budget.",
+                    "code": "FILE_ASSET_SIZE_LIMIT_EXCEEDED",
+                    "file_asset_id": file_asset_id,
+                    "message": "record_get skipped a file asset because it exceeded the internal file size budget.",
                 }
             )
             continue
 
         ensure_local_dir()
-        extension = _record_detail_image_extension(mime_type, source_url)
-        local_path = local_dir / f"{asset_id}{extension}"
+        extension = _record_detail_file_extension(mime_type, source_url=source_url, file_name=file_name)
+        local_path = local_dir / f"{file_asset_id}{extension}"
         local_path.write_bytes(content)
-        total_bytes += len(content)
-        image_count += 1
+        extraction = _record_detail_extract_file_asset_text(
+            content,
+            mime_type=mime_type,
+            file_name=file_name,
+            local_dir=local_dir,
+            file_asset_id=file_asset_id,
+        )
+        if extraction.get("status") == "failed":
+            warnings.append(
+                {
+                    "code": "FILE_ASSET_EXTRACTION_FAILED",
+                    "file_asset_id": file_asset_id,
+                    "message": f"record_get downloaded file asset {file_asset_id}, but text extraction failed.",
+                }
+            )
+        total_bytes += size_bytes
+        downloaded_count += 1
         items.append(
             {
                 **base_item,
                 **download_meta,
+                "file_name": file_name,
                 "local_path": str(local_path),
                 "mime_type": mime_type,
-                "size_bytes": len(content),
+                "size_bytes": size_bytes,
                 "access_status": "downloaded",
-                "readable_by_agent": True,
+                "readable_by_agent": extraction.get("status") == "ok" or _record_detail_image_mime_from_bytes(content) is not None,
+                "extraction": extraction,
             }
         )
 
     if not items:
         status = "none"
-    elif any(item.get("access_status") != "downloaded" for item in items):
+    elif stopped_for_time_budget or any(item.get("access_status") != "downloaded" or cast(JSONObject, item.get("extraction", {})).get("status") == "failed" for item in items):
         status = "partial"
     else:
         status = "ok"
@@ -13736,6 +16151,104 @@ def _record_detail_media_candidates_from_field(
     return candidates
 
 
+def _record_detail_file_candidates_from_field(
+    field: JSONObject,
+    *,
+    source_app_key: str | None,
+    source_record_id: str | None,
+    forced_source: str | None,
+) -> list[JSONObject]:
+    field_id = _coerce_count(field.get("field_id"))
+    field_title = _normalize_optional_text(field.get("title"))
+    field_type = _normalize_optional_text(field.get("type"))
+    candidates: list[JSONObject] = []
+    seen_urls: set[str] = set()
+
+    def add_candidate(url: str | None, *, source: str, path: str, name: str | None = None, file_hint: bool = False) -> None:
+        normalized_url = _record_detail_normalize_media_url(url)
+        if not normalized_url or normalized_url in seen_urls:
+            return
+        if not _record_detail_supported_file_url(normalized_url):
+            return
+        if not file_hint and not _record_detail_url_or_name_looks_like_file(normalized_url, name):
+            return
+        seen_urls.add(normalized_url)
+        candidates.append(
+            {
+                "_owner": field,
+                "kind": "file",
+                "source": forced_source or source,
+                "source_path": path,
+                "field_id": field_id,
+                "field_title": field_title,
+                "source_app_key": source_app_key,
+                "source_record_id": source_record_id,
+                "source_url": normalized_url,
+                "file_name": name,
+            }
+        )
+
+    def candidate_name_from_mapping(value: dict[Any, Any]) -> str | None:
+        for key, item in value.items():
+            if _record_detail_media_key(key) in _RECORD_FILE_NAME_KEYS:
+                text = _normalize_optional_text(item) if not isinstance(item, (dict, list)) else None
+                if text:
+                    return text
+        return None
+
+    def scan_text(value: str, *, path: str, source: str, file_hint: bool = False) -> None:
+        for match in _RECORD_MEDIA_IMG_SRC_RE.finditer(value):
+            add_candidate(match.group(1), source="rich_text", path=path, file_hint=True)
+        for match in _RECORD_MEDIA_MD_IMAGE_RE.finditer(value):
+            add_candidate(match.group(1), source="rich_text", path=path, file_hint=True)
+        for match in _RECORD_MEDIA_URL_RE.finditer(value):
+            add_candidate(match.group(0), source=source, path=path, file_hint=file_hint)
+
+    def scan_value(value: JSONValue, *, path: str, source: str, file_hint: bool = False) -> None:
+        if isinstance(value, str):
+            scan_text(value, path=path, source=source, file_hint=file_hint)
+            return
+        if isinstance(value, list):
+            for index, item in enumerate(value):
+                scan_value(cast(JSONValue, item), path=f"{path}[{index}]", source=source, file_hint=file_hint)
+            return
+        if not isinstance(value, dict):
+            return
+
+        attachment = _extract_attachment_item(cast(JSONValue, value))
+        if attachment:
+            add_candidate(
+                _normalize_optional_text(attachment.get("value")),
+                source="attachment" if source == "attachment" else source,
+                path=path,
+                name=_normalize_optional_text(attachment.get("name")),
+                file_hint=True,
+            )
+        candidate_name = candidate_name_from_mapping(value)
+        for key, item in value.items():
+            normalized_key = _record_detail_media_key(key)
+            item_text = _normalize_optional_text(item) if not isinstance(item, (dict, list)) else None
+            key_source = source
+            key_file_hint = file_hint
+            if normalized_key in _RECORD_FILE_URL_KEYS:
+                key_source = "attachment" if source == "attachment" else ("image_field" if source != "subtable" else "subtable")
+                key_file_hint = source == "attachment" or normalized_key not in {"value", "url"}
+                if item_text:
+                    add_candidate(item_text, source=key_source, path=f"{path}.{key}", name=candidate_name, file_hint=key_file_hint)
+            scan_value(cast(JSONValue, item), path=f"{path}.{key}", source=key_source, file_hint=key_file_hint)
+
+    value = cast(JSONValue, field.get("value"))
+    display_value = cast(JSONValue, field.get("display_value"))
+    if field_type == "attachment":
+        scan_value(value, path="value", source="attachment", file_hint=True)
+    elif field_type == "subtable":
+        scan_value(value, path="value", source="subtable", file_hint=True)
+    else:
+        scan_value(value, path="value", source="image_field", file_hint=False)
+    scan_value(display_value, path="display_value", source="rich_text", file_hint=False)
+    return candidates
+
+
 def _record_detail_attach_asset_id(field: JSONObject, asset_id: str) -> None:
     asset_ids = field.get("asset_ids")
     if not isinstance(asset_ids, list):
@@ -13745,6 +16258,15 @@ def _record_detail_attach_asset_id(field: JSONObject, asset_id: str) -> None:
         asset_ids.append(asset_id)
 
 
+def _record_detail_attach_file_asset_id(field: JSONObject, file_asset_id: str) -> None:
+    asset_ids = field.get("file_asset_ids")
+    if not isinstance(asset_ids, list):
+        asset_ids = []
+        field["file_asset_ids"] = asset_ids
+    if file_asset_id not in asset_ids:
+        asset_ids.append(file_asset_id)
+
+
 def _record_detail_media_asset_base_item(candidate: JSONObject, *, asset_id: str) -> JSONObject:
     payload: JSONObject = {
         "asset_id": asset_id,
@@ -13760,12 +16282,77 @@ def _record_detail_media_asset_base_item(candidate: JSONObject, *, asset_id: str
     return payload
 
 
+def _record_detail_file_asset_base_item(candidate: JSONObject, *, file_asset_id: str) -> JSONObject:
+    payload: JSONObject = {
+        "file_asset_id": file_asset_id,
+        "kind": candidate.get("kind") or "file",
+        "source": candidate.get("source") or "attachment",
+        "field_id": candidate.get("field_id"),
+        "field_title": candidate.get("field_title"),
+        "source_url": candidate.get("source_url"),
+    }
+    for key in ("source_path", "source_app_key", "source_record_id", "file_name"):
+        if candidate.get(key) not in (None, ""):
+            payload[key] = candidate.get(key)
+    return payload
+
+
+def _record_detail_media_assets_by_url(media_assets: JSONObject) -> dict[str, JSONObject]:
+    items = media_assets.get("items") if isinstance(media_assets.get("items"), list) else []
+    result: dict[str, JSONObject] = {}
+    for item in items:
+        if not isinstance(item, dict):
+            continue
+        source_url = _normalize_optional_text(item.get("source_url"))
+        if source_url and source_url not in result:
+            result[source_url] = cast(JSONObject, item)
+    return result
+
+
+def _record_detail_media_assets_by_asset_id(media_assets: JSONObject) -> dict[str, JSONObject]:
+    items = media_assets.get("items") if isinstance(media_assets.get("items"), list) else []
+    result: dict[str, JSONObject] = {}
+    for item in items:
+        if not isinstance(item, dict):
+            continue
+        asset_id = _normalize_optional_text(item.get("asset_id"))
+        if asset_id and asset_id not in result:
+            result[asset_id] = cast(JSONObject, item)
+    return result
+
+
+def _record_detail_media_item_from_owner_asset_ids(
+    owner: JSONObject,
+    media_by_asset_id: dict[str, JSONObject],
+    candidate: JSONObject,
+) -> JSONObject | None:
+    asset_ids = owner.get("asset_ids") if isinstance(owner.get("asset_ids"), list) else []
+    if len(asset_ids) != 1:
+        return None
+    media_item = media_by_asset_id.get(str(asset_ids[0]))
+    if not isinstance(media_item, dict):
+        return None
+    candidate_name = _normalize_optional_text(candidate.get("file_name"))
+    media_name = _normalize_optional_text(media_item.get("file_name"))
+    if candidate_name and media_name and candidate_name != media_name:
+        return None
+    if candidate.get("field_id") not in (None, media_item.get("field_id")):
+        return None
+    return media_item
+
+
 def _record_detail_media_assets_dir(run_id: str) -> Path:
     custom_home = os.environ.get("QINGFLOW_MCP_RECORD_ASSETS_HOME")
     base_dir = Path(custom_home).expanduser() if custom_home else get_mcp_home() / "record-assets"
     return base_dir / run_id
 
 
+def _record_detail_file_assets_dir(run_id: str) -> Path:
+    custom_home = os.environ.get("QINGFLOW_MCP_RECORD_FILES_HOME")
+    base_dir = Path(custom_home).expanduser() if custom_home else get_mcp_home() / "record-files"
+    return base_dir / run_id
+
+
 def _record_detail_media_download_headers(context: BackendRequestContext) -> dict[str, str]:
     origin = _record_detail_context_origin(context)
     return {"User-Agent": DEFAULT_USER_AGENT, "Referer": f"{origin}/", "Origin": origin}
@@ -13970,6 +16557,11 @@ def _record_detail_supported_media_url(url: str) -> bool:
     return parsed.scheme.lower() in {"http", "https"} or _record_detail_is_download_file_url(url)
 
 
+def _record_detail_supported_file_url(url: str) -> bool:
+    parsed = urlsplit(url)
+    return parsed.scheme.lower() in {"http", "https"} or _record_detail_is_download_file_url(url)
+
+
 def _record_detail_media_key(key: Any) -> str:
     return str(key or "").strip().replace("-", "_").lower()
 
@@ -13982,6 +16574,18 @@ def _record_detail_url_or_name_looks_like_image(url: str, name: str | None = Non
     return False
 
 
+def _record_detail_url_or_name_looks_like_file(url: str, name: str | None = None) -> bool:
+    if _record_detail_is_download_file_url(url) or _record_detail_is_qingflow_storage_url(url):
+        return True
+    for value in (url, name or ""):
+        if not value:
+            continue
+        path = unquote(urlsplit(value).path).lower() or value.lower()
+        if any(path.endswith(extension) for extension in _RECORD_FILE_EXTENSIONS):
+            return True
+    return False
+
+
 def _record_detail_mime_from_url(url: str) -> str | None:
     path = unquote(urlsplit(url).path).lower()
     if path.endswith(".png"):
@@ -13996,9 +16600,210 @@ def _record_detail_mime_from_url(url: str) -> str | None:
         return "image/bmp"
     if path.endswith(".svg"):
         return "image/svg+xml"
+    if path.endswith(".pdf"):
+        return "application/pdf"
+    if path.endswith(".docx"):
+        return "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+    if path.endswith(".xlsx"):
+        return "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+    if path.endswith(".xlsm"):
+        return "application/vnd.ms-excel.sheet.macroEnabled.12"
+    if path.endswith(".csv"):
+        return "text/csv"
+    if path.endswith(".txt") or path.endswith(".text"):
+        return "text/plain"
+    if path.endswith(".md"):
+        return "text/markdown"
+    if path.endswith(".json"):
+        return "application/json"
+    return None
+
+
+def _record_detail_file_name_from_candidate(candidate: JSONObject, *, source_url: str, fallback_id: str) -> str:
+    raw_name = _normalize_optional_text(candidate.get("file_name"))
+    if raw_name:
+        return raw_name
+    path_name = Path(unquote(urlsplit(source_url).path)).name
+    if path_name:
+        return path_name
+    return fallback_id
+
+
+def _record_detail_file_mime_from_content_or_name(content: bytes, *, source_url: str, file_name: str) -> str | None:
+    image_mime = _record_detail_image_mime_from_bytes(content)
+    if image_mime:
+        return image_mime
+    if content.startswith(b"%PDF"):
+        return "application/pdf"
+    guessed = mimetypes.guess_type(file_name or source_url)[0] or _record_detail_mime_from_url(source_url)
+    if guessed:
+        return guessed
+    lowered = (file_name or source_url).lower()
+    if lowered.endswith(".docx"):
+        return "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+    if lowered.endswith(".xlsx"):
+        return "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+    if lowered.endswith(".xlsm"):
+        return "application/vnd.ms-excel.sheet.macroEnabled.12"
+    if lowered.endswith(".csv"):
+        return "text/csv"
+    if lowered.endswith(".json"):
+        return "application/json"
+    if _record_detail_bytes_look_like_text(content):
+        return "text/plain"
     return None
 
 
+def _record_detail_file_extension(mime_type: str | None, *, source_url: str, file_name: str) -> str:
+    for value in (file_name, unquote(urlsplit(source_url).path)):
+        suffix = Path(value).suffix.lower()
+        if suffix and re.fullmatch(r"\.[a-z0-9]{1,10}", suffix):
+            return suffix
+    if mime_type:
+        extension = mimetypes.guess_extension(mime_type)
+        if extension:
+            return ".jpg" if extension == ".jpe" else extension
+    return ".bin"
+
+
+def _record_detail_bytes_look_like_text(content: bytes) -> bool:
+    if not content:
+        return True
+    sample = content[:4096]
+    if b"\x00" in sample:
+        return False
+    try:
+        sample.decode("utf-8")
+        return True
+    except UnicodeDecodeError:
+        try:
+            sample.decode("gb18030")
+            return True
+        except UnicodeDecodeError:
+            return False
+
+
+def _record_detail_extract_file_asset_text(
+    content: bytes,
+    *,
+    mime_type: str | None,
+    file_name: str,
+    local_dir: Path,
+    file_asset_id: str,
+) -> JSONObject:
+    normalized_name = file_name.lower()
+    try:
+        text: str | None
+        if normalized_name.endswith(".docx") or mime_type == "application/vnd.openxmlformats-officedocument.wordprocessingml.document":
+            text = _record_detail_extract_docx_text(content)
+        elif normalized_name.endswith((".xlsx", ".xlsm")) or mime_type in {
+            "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+            "application/vnd.ms-excel.sheet.macroEnabled.12",
+        }:
+            text = _record_detail_extract_xlsx_text(content)
+        elif normalized_name.endswith(".pdf") or mime_type == "application/pdf":
+            text = _record_detail_extract_pdf_text(content)
+        elif normalized_name.endswith(".json") or mime_type == "application/json":
+            text = _record_detail_decode_json_text(content)
+        elif normalized_name.endswith((".csv", ".txt", ".text", ".md")) or (mime_type or "").startswith("text/"):
+            text = _record_detail_decode_text(content)
+        else:
+            text = None
+    except Exception as exc:
+        return {"status": "failed", "text_path": None, "preview": None, "error": str(exc)}
+    if text is None:
+        return {"status": "unsupported", "text_path": None, "preview": None}
+    text_path = local_dir / f"{file_asset_id}.txt"
+    text_path.write_text(text, encoding="utf-8")
+    preview = text[:RECORD_GET_FILE_EXTRACT_PREVIEW_CHARS]
+    return {
+        "status": "ok",
+        "text_path": str(text_path),
+        "preview": preview,
+        "preview_truncated": len(text) > RECORD_GET_FILE_EXTRACT_PREVIEW_CHARS,
+    }
+
+
+def _record_detail_decode_text(content: bytes) -> str:
+    for encoding in ("utf-8-sig", "utf-8", "gb18030"):
+        try:
+            return content.decode(encoding)
+        except UnicodeDecodeError:
+            continue
+    return content.decode("utf-8", errors="replace")
+
+
+def _record_detail_decode_json_text(content: bytes) -> str:
+    text = _record_detail_decode_text(content)
+    try:
+        return json.dumps(json.loads(text), ensure_ascii=False, indent=2)
+    except ValueError:
+        return text
+
+
+def _record_detail_extract_docx_text(content: bytes) -> str:
+    with zipfile.ZipFile(BytesIO(content)) as archive:
+        document_xml = archive.read("word/document.xml")
+    root = ElementTree.fromstring(document_xml)
+    ns = "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}"
+    body = root.find(f"{ns}body")
+    if body is None:
+        return ""
+
+    def node_text(node: ElementTree.Element) -> str:
+        return "".join(text_node.text or "" for text_node in node.iter(f"{ns}t")).strip()
+
+    lines: list[str] = []
+    for child in list(body):
+        if child.tag == f"{ns}p":
+            line = node_text(child)
+            if line:
+                lines.append(line)
+        elif child.tag == f"{ns}tbl":
+            for row in child.iter(f"{ns}tr"):
+                cells = [node_text(cell) for cell in row.iter(f"{ns}tc")]
+                cells = [cell for cell in cells if cell]
+                if cells:
+                    lines.append(" | ".join(cells))
+    return "\n".join(lines)
+
+
+def _record_detail_extract_xlsx_text(content: bytes) -> str:
+    from openpyxl import load_workbook
+
+    workbook = load_workbook(BytesIO(content), read_only=True, data_only=True)
+    try:
+        parts: list[str] = []
+        for sheet in workbook.worksheets:
+            parts.append(f"# {sheet.title}")
+            row_count = 0
+            for row in sheet.iter_rows(values_only=True):
+                row_count += 1
+                if row_count > RECORD_GET_FILE_EXTRACT_XLSX_MAX_ROWS_PER_SHEET:
+                    parts.append(f"... skipped rows after {RECORD_GET_FILE_EXTRACT_XLSX_MAX_ROWS_PER_SHEET}")
+                    break
+                cells = ["" if cell is None else str(cell) for cell in row]
+                if any(cell for cell in cells):
+                    parts.append("\t".join(cells).rstrip())
+        return "\n".join(parts)
+    finally:
+        workbook.close()
+
+
+def _record_detail_extract_pdf_text(content: bytes) -> str:
+    from pypdf import PdfReader
+
+    reader = PdfReader(BytesIO(content))
+    lines: list[str] = []
+    for index, page in enumerate(reader.pages[:RECORD_GET_FILE_EXTRACT_PDF_MAX_PAGES], start=1):
+        page_text = page.extract_text() or ""
+        if page_text.strip():
+            lines.append(f"# Page {index}\n{page_text.strip()}")
+    if len(reader.pages) > RECORD_GET_FILE_EXTRACT_PDF_MAX_PAGES:
+        lines.append(f"... skipped pages after {RECORD_GET_FILE_EXTRACT_PDF_MAX_PAGES}")
+    return "\n\n".join(lines)
+
+
 def _record_detail_image_mime_from_bytes(content: bytes) -> str | None:
     if content.startswith(b"\x89PNG\r\n\x1a\n"):
         return "image/png"
@@ -14038,6 +16843,7 @@ def _record_detail_context_integrity(
     workflow_logs: JSONObject,
     associated_resources: list[JSONObject],
     media_assets: JSONObject,
+    file_assets: JSONObject,
     unavailable_context: list[JSONObject],
 ) -> JSONObject:
     reference_unavailable = any(item.get("target_detail_completeness") != "full" for item in references)
@@ -14049,6 +16855,7 @@ def _record_detail_context_integrity(
         "workflow_logs": workflow_logs.get("status") or "unknown",
         "associated_resources": "full" if associated_resources or not any(item.get("section") == "associated_resources" for item in unavailable_context) else "unavailable",
         "media_assets": media_assets.get("status") or "unknown",
+        "file_assets": file_assets.get("status") or "unknown",
         "unavailable_count": len(unavailable_context),
         "safe_for_record_fact_conclusion": True,
         "safe_for_full_log_conclusion": False,
@@ -14063,6 +16870,7 @@ def _record_detail_semantic_context(payload: JSONObject) -> str:
     fields = payload.get("fields") if isinstance(payload.get("fields"), list) else []
     references = payload.get("references") if isinstance(payload.get("references"), list) else []
     media_assets = payload.get("media_assets") if isinstance(payload.get("media_assets"), dict) else {}
+    file_assets = payload.get("file_assets") if isinstance(payload.get("file_assets"), dict) else {}
     data_logs = payload.get("data_logs") if isinstance(payload.get("data_logs"), dict) else {}
     workflow_logs = payload.get("workflow_logs") if isinstance(payload.get("workflow_logs"), dict) else {}
     associated_resources = payload.get("associated_resources") if isinstance(payload.get("associated_resources"), list) else []
@@ -14110,6 +16918,20 @@ def _record_detail_semantic_context(payload: JSONObject) -> str:
                 f"（fieldId={_semantic_escape(item.get('field_id'))}），"
                 f"本地路径：{_semantic_escape(item.get('local_path')) or '无'}，{_semantic_escape(readable_text)}。"
             )
+    file_items = file_assets.get("items") if isinstance(file_assets.get("items"), list) else []
+    if file_items:
+        lines.extend(["", "文件附件："])
+        for item in file_items:
+            if not isinstance(item, dict):
+                continue
+            extraction = item.get("extraction") if isinstance(item.get("extraction"), dict) else {}
+            readable_text = "可由智能体读取" if item.get("readable_by_agent") else f"不可直接读取（{item.get('access_status') or 'unknown'}）"
+            lines.append(
+                f"- 文件 {_semantic_escape(item.get('file_asset_id'))}「{_semantic_escape(item.get('file_name'))}」"
+                f"来自字段「{_semantic_escape(item.get('field_title'))}」（fieldId={_semantic_escape(item.get('field_id'))}），"
+                f"本地路径：{_semantic_escape(item.get('local_path')) or '无'}，"
+                f"提取文本：{_semantic_escape(extraction.get('text_path')) or '无'}，{_semantic_escape(readable_text)}。"
+            )
     lines.extend(["", "最近数据日志："])
     _append_semantic_log_lines(lines, data_logs)
     lines.extend(["", "最近流程日志："])
@@ -14227,7 +17049,6 @@ def _build_record_list_lookup_payload(
     query: str | None,
     items: list[JSONObject],
     pagination: JSONObject,
-    limit: int,
 ) -> JSONObject | None:
     if not query:
         return None
@@ -14236,17 +17057,7 @@ def _build_record_list_lookup_payload(
     if returned_items is None:
         returned_items = len(items)
     truncated = bool(reported_total is not None and reported_total > returned_items)
-    scored: list[tuple[int, int, JSONObject]] = []
-    for index, item in enumerate(items):
-        candidate = _record_list_candidate_payload(item, query=query)
-        score = _coerce_count(candidate.get("score")) or 0
-        if score <= 0:
-            candidate["score"] = 40
-            candidate["match_reason"] = "backend_match_without_selected_field_evidence"
-        scored.append((int(candidate["score"]), index, candidate))
-    scored.sort(key=lambda entry: (-entry[0], entry[1]))
-    candidates = [entry[2] for entry in scored[: min(limit, LOOKUP_CONFIRMATION_CANDIDATE_LIMIT)]]
-    confidence = _record_list_lookup_confidence(candidates, truncated=truncated)
+    confidence = _record_list_lookup_confidence(returned_items=returned_items, reported_total=reported_total, truncated=truncated)
     next_action = {
         "single_high": "record_get",
         "multiple": "ask_user",
@@ -14256,140 +17067,25 @@ def _build_record_list_lookup_payload(
     return {
         "mode": "candidate_locator",
         "query": query,
-        "reported_total": reported_total,
-        "returned_candidates": len(candidates),
+        "total_count": reported_total,
+        "returned_count": returned_items,
+        "truncated": truncated,
         "confidence": confidence,
         "next_action": next_action,
-        "candidates": candidates,
     }
 
 
-def _record_list_lookup_confidence(candidates: list[JSONObject], *, truncated: bool) -> str:
-    if not candidates:
+def _record_list_lookup_confidence(*, returned_items: int, reported_total: int | None, truncated: bool) -> str:
+    if returned_items <= 0:
         return "none"
     if truncated:
         return "truncated"
-    if len(candidates) == 1:
-        return "single_high"
-    top = _coerce_count(candidates[0].get("score")) or 0
-    second = _coerce_count(candidates[1].get("score")) or 0
-    if top >= 90 and (top - second) >= 10:
+    effective_total = reported_total if reported_total is not None else returned_items
+    if effective_total == 1:
         return "single_high"
     return "multiple"
 
 
-def _record_list_candidate_payload(item: JSONObject, *, query: str) -> JSONObject:
-    query_norm = _normalize_lookup_query_text(query)
-    matched_fields: list[JSONObject] = []
-    best_score = 0
-    for key, value in item.items():
-        if key in {"normalized_record", "normalized_ambiguous_fields"}:
-            continue
-        value_text = _record_list_value_text(value)
-        if not value_text:
-            continue
-        score, match_type = _record_list_field_match_score(key, value_text, query_norm)
-        if score <= 0:
-            continue
-        best_score = max(best_score, score)
-        matched_fields.append(
-            {
-                "title": key,
-                "value": _truncate_text(value_text, 120),
-                "match_type": match_type,
-                "score": score,
-            }
-        )
-    if matched_fields:
-        best_score = min(100, best_score + min(10, (len(matched_fields) - 1) * 3))
-    record_id = _normalize_optional_text(item.get("record_id")) or _normalize_optional_text(item.get("apply_id"))
-    display_fields = _record_list_display_fields(item)
-    return {
-        "record_id": record_id,
-        "title": _record_list_candidate_title(item) or record_id,
-        "score": best_score,
-        "matched_fields": sorted(matched_fields, key=lambda entry: int(entry.get("score") or 0), reverse=True)[:6],
-        "display_fields": display_fields,
-    }
-
-
-def _record_list_field_match_score(field_title: str, value_text: str, query_norm: str) -> tuple[int, str]:
-    if not query_norm:
-        return 0, "none"
-    value_norm = _normalize_lookup_query_text(value_text)
-    if not value_norm:
-        return 0, "none"
-    title_norm = _normalize_lookup_query_text(field_title)
-    title_like = _record_list_title_like(field_title)
-    id_like = field_title in {"record_id", "apply_id"} or "编号" in field_title or "id" == title_norm
-    if value_norm == query_norm:
-        if id_like:
-            return 100, "exact_identifier"
-        if title_like:
-            return 96, "exact_title"
-        return 86, "exact"
-    if query_norm in value_norm:
-        if id_like:
-            return 92, "contains_identifier"
-        if title_like:
-            return 88, "contains_title"
-        return 68, "contains"
-    if title_like and value_norm in query_norm and len(value_norm) >= 2:
-        return 72, "reverse_contains_title"
-    return 0, "none"
-
-
-def _record_list_candidate_title(item: JSONObject) -> str | None:
-    for key, value in item.items():
-        if key in {"record_id", "apply_id"}:
-            continue
-        if _record_list_title_like(key):
-            text = _record_list_value_text(value)
-            if text:
-                return _truncate_text(text, 80)
-    for key, value in item.items():
-        if key in {"record_id", "apply_id", "normalized_record", "normalized_ambiguous_fields"}:
-            continue
-        text = _record_list_value_text(value)
-        if text:
-            return _truncate_text(text, 80)
-    return None
-
-
-def _record_list_display_fields(item: JSONObject) -> list[JSONObject]:
-    display: list[JSONObject] = []
-    for key, value in item.items():
-        if key in {"record_id", "apply_id", "normalized_record", "normalized_ambiguous_fields"}:
-            continue
-        text = _record_list_value_text(value)
-        if not text:
-            continue
-        display.append({"title": key, "value": _truncate_text(text, 120)})
-        if len(display) >= 6:
-            break
-    return display
-
-
-def _record_list_title_like(field_title: str) -> bool:
-    lowered = field_title.lower()
-    return any(
-        token in field_title or token in lowered
-        for token in ("标题", "名称", "名字", "客户", "公司", "项目", "商机", "线索", "主题", "编号", "name", "title", "customer", "company")
-    )
-
-
-def _record_list_value_text(value: JSONValue) -> str:
-    if value is None:
-        return ""
-    if isinstance(value, str):
-        return value.strip()
-    return _stringify_json(value).strip()
-
-
-def _normalize_lookup_query_text(value: str) -> str:
-    return re.sub(r"\s+", "", value).lower()
-
-
 def _truncate_text(value: str, limit: int) -> str:
     if len(value) <= limit:
         return value
@@ -17423,9 +20119,122 @@ def _write_format_for_field(field: FormField) -> JSONObject:
         return _write_support_payload(support_level="full", kind="boolean_label", examples=["是", "否"])
     if field.que_type in DATE_QUE_TYPES:
         return _write_support_payload(support_level="full", kind="date_string", examples=["2026-03-13 10:00:00"])
+    if field.que_type == 8:
+        allow_decimal = bool((field.raw or {}).get("canDecimal"))
+        payload = _write_support_payload(
+            support_level="full",
+            kind="amount_number",
+            examples=[100.5 if allow_decimal else 100],
+        )
+        payload["allow_decimal"] = allow_decimal
+        return payload
     return _write_support_payload(support_level="full", kind="scalar_text")
 
 
+def _ready_schema_format_hint(kind: str, write_format: JSONObject) -> str:
+    if kind == "member":
+        return "可直接填成员姓名；唯一匹配会自动解析，重名时会返回候选确认。也可传成员 id/value 对象。"
+    if kind == "department":
+        return "可直接填部门名称；唯一匹配会自动解析，重名时会返回候选确认。也可传部门 id/value 对象。"
+    if kind == "relation":
+        return "可传目标记录 apply_id/record_id 对象，也可填目标记录的可搜索文本；多候选时会返回确认。"
+    if kind == "attachment":
+        return "先调用 file_upload_local 上传文件，再写入上传返回的附件对象或 value/name。"
+    if kind == "subtable":
+        return "传 {'rows': [{...}]} 或直接传行对象数组；每行 key 使用子字段标题。"
+    if kind == "address":
+        return "传省/市/区/详细地址对象、地址明细字符串，或后端地址 parts 数组。"
+    if kind == "single_select":
+        return "传 options 中的一个选项文本。"
+    if kind == "multi_select":
+        return "传 options 中的多个选项文本数组。"
+    if kind == "boolean":
+        return "传 '是' 或 '否'。"
+    if kind == "date":
+        return "推荐传 'YYYY-MM-DD HH:MM:SS'；只有日期时可传 'YYYY-MM-DD'。"
+    if kind == "number":
+        write_kind = _normalize_optional_text(write_format.get("kind"))
+        if write_kind == "amount_number":
+            if bool(write_format.get("allow_decimal")):
+                return "传数字或数字字符串，支持小数。"
+            return "传整数或整数字符串；该字段后端不接受小数。"
+        return "传数字或数字字符串。"
+    if kind == "unsupported":
+        reason = _normalize_optional_text(write_format.get("reason"))
+        return reason or "该字段不支持直接写入。"
+    return "传文本值。"
+
+
+def _ready_schema_example_value(
+    kind: str,
+    field: FormField,
+    write_format: JSONObject,
+    *,
+    row_fields: list[JSONObject],
+) -> JSONValue:
+    if kind == "member":
+        return "张三"
+    if kind == "department":
+        return "直销部"
+    if kind == "relation":
+        return {"apply_id": "5001"}
+    if kind == "attachment":
+        return {"value": "<file_upload_local 返回的 value/url>", "name": "example.pdf"}
+    if kind == "subtable":
+        row: JSONObject = {}
+        for item in row_fields:
+            if not isinstance(item, dict):
+                continue
+            title = _normalize_optional_text(item.get("title"))
+            if not title:
+                continue
+            row[title] = item.get("example_value", _ready_schema_template_scalar(item.get("kind")))
+        if not row:
+            row = {"子字段": "值"}
+        return {"rows": [row]}
+    if kind == "address":
+        examples = write_format.get("examples")
+        if isinstance(examples, list) and examples:
+            return deepcopy(cast(JSONValue, examples[0]))
+        return {"province": "上海市", "city": "上海市", "district": "闵行区", "detail": "浦江路99号"}
+    if kind == "single_select":
+        return field.options[0] if field.options else "选项A"
+    if kind == "multi_select":
+        return [field.options[0]] if field.options else ["选项A"]
+    if kind == "boolean":
+        return "是"
+    if kind == "date":
+        return "2026-03-13 10:00:00"
+    if kind == "number":
+        return 100
+    if kind == "unsupported":
+        return None
+    return "示例文本"
+
+
+def _ready_schema_template_scalar(kind: Any) -> JSONValue:
+    normalized = _normalize_optional_text(kind)
+    if normalized == "number":
+        return 100
+    if normalized == "date":
+        return "2026-03-13 10:00:00"
+    if normalized == "boolean":
+        return "是"
+    if normalized == "member":
+        return "张三"
+    if normalized == "department":
+        return "直销部"
+    if normalized == "relation":
+        return {"apply_id": "5001"}
+    if normalized == "multi_select":
+        return ["选项A"]
+    if normalized == "attachment":
+        return {"value": "<file_upload_local 返回的 value/url>", "name": "example.pdf"}
+    if normalized == "address":
+        return {"province": "上海市", "city": "上海市", "district": "闵行区", "detail": "浦江路99号"}
+    return "值"
+
+
 def _summarize_write_support(resolved_fields: list[JSONObject]) -> JSONObject:
     summary: JSONObject = {
         "full": [],